using framework_business;
using framework_library;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Reflection;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class controls_admin_report : System.Web.UI.UserControl
{
    #region properties

    private const string controlPath = "~/controls/";

    public string SurfaceFieldTypeIds
    {
        get
        {
            return pNums.FieldType.Text.GetHashCode().ToString() + "|" +
                pNums.FieldType.Number.GetHashCode().ToString() + "|" +
                pNums.FieldType.Decimal.GetHashCode().ToString() + "|" +
                pNums.FieldType.Picklist.GetHashCode().ToString() + "|" +
                pNums.FieldType.Date.GetHashCode().ToString() + "|" +
                pNums.FieldType.Checkbox.GetHashCode().ToString() + "|" +
                pNums.FieldType.RadioButtonList.GetHashCode().ToString() + "|" +
                pNums.FieldType.FormulaField.GetHashCode().ToString() + "|" +
                pNums.FieldType.Content.GetHashCode().ToString() + "|" +
                pNums.FieldType.Caption.GetHashCode().ToString() + "|" +
                pNums.FieldType.Address.GetHashCode().ToString() + "|" +
                pNums.FieldType.CheckboxList.GetHashCode().ToString() + "|" +
                pNums.FieldType.MultiPicklist.GetHashCode().ToString() + "|" +
                pNums.FieldType.Label.GetHashCode().ToString();

        }
    }

    public oReport Report
    {
        get
        {
            if (ViewState["Report"] == null)
                return null;
            else return (oReport)ViewState["Report"];
        }
        set
        {
            ViewState["Report"] = value;
        }
    }
    #endregion

    #region report methods

    /// <summary>
    /// Bind Report List Grid
    /// </summary>
    private void BindReportList()
    {
        try
        {
            DataTable reportData = xData.GetTypedByCriteriaSpecificTable("recId", typeof(oReport), "", "", "display");
            rptReportList.DataSource = reportData;
            rptReportList.DataBind();
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Populate Page form values
    /// </summary>
    /// <param name="_Report"></param>
    private void PopulatePageFormValues(oReport _Report)
    {
        try
        {
            txtReportName.Value = _Report.name;
            if (_Report.recId > 0)
                txtReportName.Disabled = true;
            else
                txtReportName.Disabled = false;
            txtReportDisplay.Value = _Report.display;
            chkActive.Checked = _Report.isActive;
            chkPublic.Checked = _Report.isPublic;
            if (_Report.enableAggregation)
                chkAllowAggregates.Checked = true;
            else
                chkAllowAggregates.Checked = false;

        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    private void SavePageFormValues(ref oReport _Report)
    {
        try
        {
            _Report.display = txtReportDisplay.Value;
            _Report.isActive = chkActive.Checked;
            _Report.isPublic = chkPublic.Checked;
            _Report.name = txtReportName.Value;
            if (chkAllowAggregates.Checked)
                _Report.enableAggregation = true;
            else
                _Report.enableAggregation = false;
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    private void TogglePanels(string panelName)
    {
        switch (panelName)
        {
            case "pnlReportForm":
                pnlReportForm.Visible = true;
                pnlReportList.Visible = false;
                break;
            case "pnlReportList":
                pnlReportForm.Visible = false;
                pnlReportList.Visible = true;
                break;
        }
        //clear result
        pnlResult.Visible = false;
    }

    /// <summary>
    /// Load the report container
    /// </summary>
    /// <param name="report"></param>
    private void LoadReportContainer(oReport report)
    {
        try
        {
            //load control                                           
            plcReportContainer.Controls.Clear();
            dynamic uc = (IControlBase)LoadControl(controlPath + "module/report.ascx");
            uc.Report = report;
            uc.ReloadControl();
            plcReportContainer.Controls.Add(uc);
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }
    #endregion

    #region field methods

    /// <summary>
    /// Bind Report Field List
    /// </summary>
    /// <param name="reportId"></param>
    private void BindReportFieldList(int reportId)
    {
        try
        {
            ArrayList fieldList = xData.GetTypedByCriteriaSpecific("recId", typeof(oReportField), "reportId", reportId.ToString(), "sequence");
            rptReportFields.DataSource = fieldList;
            rptReportFields.DataBind();

            if (fieldList.Count > 0)
            {
                ddSurface.Enabled = false;
                //lstSecondarySources.Enabled = false;

                foreach (oReportField fld in fieldList)
                {
                    if (ddSurface.Items.FindByValue(fld.parentSurfaceId.ToString()) != null)
                        ddSurface.SelectedValue = fld.parentSurfaceId.ToString();
                    BindSurfaceSecondayList();
                    break;
                }
                foreach (oReportField fld in fieldList)
                {
                    if (fld.surfaceId > 0 && fld.surfaceId != fld.parentSurfaceId)
                    {
                        foreach (ListItem item in lstSecondarySources.Items)
                        {
                            if (item.Value == fld.surfaceFieldId.ToString())
                            {
                                item.Selected = true;
                                break;
                            }
                        }
                    }
                }
            }
            else
            {
                ddSurface.Enabled = true;
                ddSurface.ClearSelection();
                lstSecondarySources.Enabled = true;
                lstSecondarySources.ClearSelection();

            }
            upReport.Update();
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    //private void BindReportFieldTypes()
    //{
    //    try
    //    {
    //        ArrayList list = xData.GetTypedByCriteriaSpecific("recId", typeof(oReportFieldType), "isActive", "1");
    //        ddFieldTypes.DataSource = list;
    //        ddFieldTypes.DataTextField = "reportFieldType";
    //        ddFieldTypes.DataValueField = "recId";
    //        ddFieldTypes.DataBind();

    //        ddFieldTypes.Items.Insert(0, new ListItem("select...", "0"));
    //    }
    //    catch (Exception ex)
    //    {
    //        exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
    //        Response.Redirect("/error", false);
    //    }
    //}

    private void PopulateFieldFormValues(oReportField _Field)
    {
        try
        {
            txtFieldName.Value = _Field.reportFieldName;
            //if (_Field.recId > 0)
            //    txtFieldName.Disabled = true;
            //else
            //    txtFieldName.Disabled = false;
            txtFieldDisplay.Text = _Field.reportFieldDisplay;

            //report type
            //ddFieldTypes.ClearSelection();
            //if (ddFieldTypes.Items.FindByValue(_Field.reportFieldTypeId.ToString()) != null)
            //{
            //    ddFieldTypes.Items.FindByValue(_Field.reportFieldTypeId.ToString()).Selected = true;

            //    if (_Field.reportFieldTypeId == pNums.ReportFieldType.Surface.GetHashCode())
            //        divFieldTypeSurface.Visible = true;
            //    else
            //        divFieldTypeSurface.Visible = false;
            //}

            //primary source
            //if (_Field.parentSurfaceId > 0)
            //{
            //    ddSurface.ClearSelection();
            //    if (ddSurface.Items.FindByValue(_Field.parentSurfaceId.ToString()) != null)
            //        ddSurface.SelectedValue = _Field.parentSurfaceId.ToString();

            //    BindSurfaceSecondayList();
            //}

            ////secondary source
            //if (_Field.surfaceId > 0 && _Field.surfaceId != _Field.parentSurfaceId)
            //{
            //    foreach (ListItem item in lstSecondarySources.Items)
            //    {
            //        if (item.Value == _Field.surfaceFieldId.ToString())
            //        {
            //            item.Selected = true;
            //            break;
            //        }
            //    }
            //}

            //surface field
            ddSurfaceField.ClearSelection();
            if (_Field.parentSurfaceId > 0)
            {
                BindSurfaceFieldList();
            }
            if (ddSurfaceField.Items.FindByValue(_Field.surfaceFieldId.ToString()) != null)
                ddSurfaceField.Items.FindByValue(_Field.surfaceFieldId.ToString()).Selected = true;

            //aggregation
            ddFieldAggregation.ClearSelection();
            if (ddFieldAggregation.Items.FindByValue(_Field.aggregationType.ToString()) != null)
                ddFieldAggregation.Items.FindByValue(_Field.aggregationType.ToString()).Selected = true;
            else
                ddFieldAggregation.SelectedIndex = 0;

            txtSequence.Value = _Field.sequence.ToString();
            chkFieldActive.Checked = _Field.isActive;
            chkFieldFilter.Checked = _Field.isFilter;
            chkFieldGrouped.Checked = _Field.isGrouped;
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    private void SaveFieldFormValues(ref oReportField _Field)
    {
        try
        {
            _Field.isActive = chkFieldActive.Checked;
            _Field.isFilter = chkFieldFilter.Checked;
            _Field.isGrouped = chkFieldGrouped.Checked;
            _Field.reportFieldDisplay = txtFieldDisplay.Text;
            _Field.reportFieldName = txtFieldName.Value;

            //field type
            _Field.reportFieldTypeId = 1;

            //int fieldTypeId = 0;
            //if (ddFieldTypes.SelectedItem != null)
            //    int.TryParse(ddFieldTypes.SelectedItem.Value, out fieldTypeId);
            //_Field.reportFieldTypeId = fieldTypeId < 0 ? 0 : fieldTypeId;

            //sequence
            int sequence = 0;
            int.TryParse(txtSequence.Value, out sequence);
            _Field.sequence = sequence < 0 ? 0 : sequence;

            //parentsurfaceId & surfaceFieldId
            int parentsurfaceId = 0;
            int surfaceFieldId = 0;
            if (_Field.reportFieldTypeId == pNums.ReportFieldType.Surface.GetHashCode())
            {
                if (ddSurface.SelectedItem != null)
                    int.TryParse(ddSurface.SelectedItem.Value, out parentsurfaceId);
                if (ddSurfaceField.SelectedItem != null)
                    int.TryParse(ddSurfaceField.SelectedItem.Value, out surfaceFieldId);
            }
            _Field.parentSurfaceId = parentsurfaceId < 0 ? 0 : parentsurfaceId;
            _Field.surfaceFieldId = surfaceFieldId < 0 ? 0 : surfaceFieldId;

            //surface Id
            foreach (oSurfaceField fld in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceField), "recId", surfaceFieldId.ToString()))
            {
                _Field.surfaceId = fld.surfaceId;
                break;
            }

            //aggregation
            _Field.aggregationType = 0;
            if (ddFieldAggregation.SelectedItem != null)
                _Field.aggregationType = int.Parse(ddFieldAggregation.SelectedItem.Value);
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    private void ToggleFieldPanels(string panelName)
    {
        switch (panelName)
        {
            case "pnlReportFieldForm":
                pnlReportFieldForm.Visible = true;
                pnlReportFieldList.Visible = false;
                break;
            case "pnlReportFieldList":
                pnlReportFieldForm.Visible = false;
                pnlReportFieldList.Visible = true;
                break;
        }
        //clear result
        pnlResultReportField.Visible = false;
    }

    /// <summary>
    /// Bind Primary Source Lsit
    /// </summary>
    private void BindSurfaceList()
    {
        try
        {
            DataTable surfaceData = xData.GetTypedByCriteriaSpecificTable("recId", typeof(oSurface), "isActive", "1", "surface");
            ddSurface.DataSource = surfaceData;
            ddSurface.DataTextField = "surface";
            ddSurface.DataValueField = "recId";
            ddSurface.DataBind();

            ddSurface.Items.Insert(0, new ListItem("select...", "0"));
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Bind Secondary List
    /// </summary>
    private void BindSurfaceSecondayList()
    {
        try
        {
            DataTable SecondaryData = new DataTable();
            int parentSurfaceId = 0;
            int.TryParse(ddSurface.SelectedValue, out parentSurfaceId);

            if (parentSurfaceId > 0)
            {
                //build query to get all child surface ids of this parent
                string childFieldQuery = "Select recId FROM pal_Surface WHERE [name] in (Select relationalSurface FROM pal_SurfaceField Where surfaceId = " + parentSurfaceId + " AND surfaceFieldTypeId = 11 and relationalSurface <> '')";
                DataTable childData = xData.GetCustomTypedTable(childFieldQuery, false);
                List<int> surfaceIdList = childData.Rows.OfType<DataRow>().Select(dr => dr.Field<int>("recId")).ToList();
                string childSurfaceIds = String.Join("|", surfaceIdList.ToArray());
                if (childSurfaceIds != String.Empty)
                {
                    SecondaryData = xData.GetTypedByCriteriaSpecificTable("recId", typeof(oSurface), "recId,isActive", "~()" + childSurfaceIds + ",1", "surface");
                    lstSecondarySources.DataTextField = "surface";
                    lstSecondarySources.DataValueField = "recId";
                }

            }

            lstSecondarySources.DataSource = SecondaryData;
            lstSecondarySources.DataBind();

        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// BindsurfaceField List based on primary and secondary sources
    /// </summary>
    private void BindSurfaceFieldList()
    {
        try
        {
            if (ddSurface.SelectedValue != "0")
            {
                DataTable fieldData = new DataTable();
                string childSurfaceIds = String.Empty;
                int parentSurfaceId = 0;
                int.TryParse(ddSurface.SelectedValue, out parentSurfaceId);

                //get selected child surfaceids
                var childItems = lstSecondarySources.Items.GetSelectedItems();
                childSurfaceIds = String.Join("|", childItems.Select(x => x.Value).ToArray());

                if (childSurfaceIds != String.Empty)
                {
                    fieldData = xData.GetTypedByCriteriaSpecificTable("recId", typeof(oSurfaceField), "surfaceId,surfaceFieldTypeId,surfaceFieldName", "~()" + parentSurfaceId + "|" + childSurfaceIds + ",~()" + this.SurfaceFieldTypeIds + ",~<>ParentSurfaceItemId", "surfaceFieldName");
                }
                else
                {
                    fieldData = xData.GetTypedByCriteriaSpecificTable("recId", typeof(oSurfaceField), "surfaceId,surfaceFieldTypeId,surfaceFieldName", parentSurfaceId + ",~()" + this.SurfaceFieldTypeIds + ",~<>ParentSurfaceItemId", "surfaceFieldName");
                }

                ddSurfaceField.DataSource = fieldData;
                ddSurfaceField.DataTextField = "surfaceFieldName";
                ddSurfaceField.DataValueField = "recId";
                ddSurfaceField.DataBind();

                ddSurfaceField.Items.Insert(0, new ListItem("select...", "0"));
            }
            else
            {
                ddSurfaceField.Items.Clear();
            }


        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    private void BindFieldAggregation()
    {
        try
        {
            ArrayList list = xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceGridAggregateType), "isActive", "1");
            ddFieldAggregation.DataSource = list;
            ddFieldAggregation.DataTextField = "aggregateType";
            ddFieldAggregation.DataValueField = "recId";
            ddFieldAggregation.DataBind();

            ddFieldAggregation.Items.Insert(0, new ListItem("select...", "0"));
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    #endregion 

    #region events

    /// <summary>
    /// Page Load Event
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void Page_Load(object sender, EventArgs e)
    {
        try
        {
            if (!Page.IsPostBack)
            {
                BindReportList();
                //BindReportFieldTypes();
                BindSurfaceList();
                BindFieldAggregation();
            }
            else
            {
                if (pnlReportContainer.Visible && this.Report != null)
                {
                    LoadReportContainer(this.Report);
                }
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Edit Report
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lnkEdit_Click(object sender, EventArgs e)
    {
        try
        {
            oReport _Report = new oReport();

            if (sender.GetType() == typeof(LinkButton))
            {
                int recId = int.Parse(((LinkButton)sender).CommandArgument);
                if (recId > 0)
                {
                    //get report
                    foreach (oReport report in xData.GetTypedByCriteriaSpecific("recId", typeof(oReport), "recId", recId.ToString()))
                    {
                        _Report = report;
                        break;
                    }

                    //populate
                    PopulatePageFormValues(_Report);
                    Session["Report"] = _Report;

                    //show Report Form
                    TogglePanels(pnlReportForm.ID);
                    BindReportFieldList(_Report.recId);
                    ToggleFieldPanels(pnlReportFieldList.ID);
                }
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Remove Report
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lnkRemove_Click(object sender, EventArgs e)
    {
        try
        {
            if (sender.GetType() == typeof(LinkButton))
            {
                int recId = int.Parse(((LinkButton)sender).CommandArgument);
                foreach (oReport rpt in xData.GetTypedByCriteriaSpecific("recId", typeof(oReport), "recId", recId.ToString()))
                {
                    //remove fields
                    if (xData.DeleteTyped("reportId", recId.ToString(), typeof(oReportField)))
                    {
                        //Delete report
                        if (xData.DeleteTyped("recId", recId.ToString(), typeof(oReport)))
                        {
                            //rebind grid
                            BindReportList();
                            pnlResult.Visible = true;
                            //display successful result
                            lblResult.Text = "the selected Report was deleted successfully.";
                        }
                    }
                }
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Cancel Report Edit
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnCancel_Click(object sender, EventArgs e)
    {
        try
        {
            utils.disposeSession("Report");
            BindReportList();
            TogglePanels("pnlReportList");
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Save Report
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnSave_Click(object sender, EventArgs e)
    {
        try
        {
            oReport Report = new oReport();

            if (utils.verifySession("Report"))//update mode
            {
                Report = (oReport)Session["Report"];

                //save form values
                SavePageFormValues(ref Report);

                Report.dateUpdated = DateTime.Now;
                Report.updatedBy = handler.ReturnUser().recId;
                if (xData.UpdateTyped("recId", Report.recId.ToString(), typeof(oReport), Report))
                {
                    Session["Report"] = Report;

                    BindReportList();
                    pnlResult.Visible = true;
                    lblResult.Text = "your changes were updated successfully.";
                }
            }
            else
            {
                if (!xData.VerifyExists("recId", typeof(oReport), "name", utils.stripCharacters(txtReportName.Value).Replace(" ", "")))
                {
                    //save form values
                    SavePageFormValues(ref Report);
                    Report.dateSaved = DateTime.Now;
                    Report.createdBy = handler.ReturnUser().recId;

                    Report.recId = xData.SaveTyped("recId", typeof(oReport), Report);
                    if (Report.recId > 0)
                    {
                        Session["Report"] = Report;
                        txtReportName.Disabled = true;
                        BindReportList();
                        pnlResult.Visible = true;
                        lblResult.Text = "your report was created successfully.";
                    }
                }
                else
                {
                    pnlResult.Visible = true;
                    lblResult.Text = "A report with this name already exists on the system";
                }
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    protected void btnNewReport_Click(object sender, EventArgs e)
    {
        try
        {
            utils.disposeSession("Report");
            oReport report = new oReport();
            PopulatePageFormValues(report);
            TogglePanels("pnlReportForm");

            utils.disposeSession("ReportField");
            BindReportFieldList(0);
            ToggleFieldPanels(pnlReportFieldList.ID);
            upReportFields.Update();
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    protected void btnNewField_Click(object sender, EventArgs e)
    {
        try
        {
            oReport Report = new oReport();

            if (utils.verifySession("Report"))
            {
                ToggleFieldPanels(pnlReportFieldForm.ID);
                utils.disposeSession("ReportField");
                oReportField reportField = new oReportField();
                PopulateFieldFormValues(reportField);

            }
            else
            {
                if (!xData.VerifyExists("recId", typeof(oSurface), "name", utils.stripCharacters(txtReportName.Value).Replace(" ", "")))
                {
                    //save form values
                    SavePageFormValues(ref Report);
                    Report.recId = xData.SaveTyped("recId", typeof(oReport), Report);
                    if (Report.recId > 0)
                    {
                        Session["Report"] = Report;

                        BindReportList();

                        ToggleFieldPanels(pnlReportFieldForm.ID);
                        utils.disposeSession("ReportField");
                        oReportField reportField = new oReportField();
                        PopulateFieldFormValues(reportField);
                    }
                }
                else
                {
                    pnlResult.Visible = true;
                    lblResult.Text = "A report with this name already exists on the system";
                }
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    protected void btnSaveReportField_Click(object sender, EventArgs e)
    {
        try
        {
            oReport Report = new oReport();
            oReportField ReportField = new oReportField();

            if (utils.verifySession("Report"))
            {
                Report = (oReport)Session["Report"];

                if (utils.verifySession("ReportField"))//update mode
                {
                    ReportField = (oReportField)Session["ReportField"];


                    //save form values
                    SaveFieldFormValues(ref ReportField);

                    if (xData.UpdateTyped("recId", ReportField.recId.ToString(), typeof(oReportField), ReportField))
                    {
                        Session["ReportField"] = ReportField;

                        pnlResultReportField.Visible = true;
                        lblResultReportField.Text = "your changes were updated successfully.";
                    }
                }
                else
                {
                    //save form values
                    SaveFieldFormValues(ref ReportField);
                    if (!xData.VerifyExists("recId", typeof(oReportField), "reportId,reportFieldName", ReportField.recId + "," + ReportField.reportFieldName))
                    {
                        ReportField.reportId = Report.recId;
                        ReportField.recId = xData.SaveTyped("recId", typeof(oReportField), ReportField);

                        if (ReportField.recId > 0)
                        {
                            Session["ReportField"] = ReportField;
                            //txtFieldName.Disabled = true;

                            pnlResultReportField.Visible = true;
                            lblResultReportField.Text = "your report field was created successfully.";
                        }
                    }
                    else
                    {
                        pnlResultReportField.Visible = true;
                        lblResultReportField.Text = "A report field with this name already exists on this report.";
                    }
                }

                BindReportFieldList(Report.recId);
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    protected void btnCancelReportField_Click(object sender, EventArgs e)
    {
        try
        {
            oReport report = new oReport();
            if (utils.verifySession("Report"))
                report = (oReport)Session["Report"];

            utils.disposeSession("ReportField");
            BindReportFieldList(report.recId);
            ToggleFieldPanels("pnlReportFieldList");
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    protected void lnkEditField_Click(object sender, EventArgs e)
    {
        try
        {
            if (sender.GetType() == typeof(LinkButton))
            {
                int recId = int.Parse(((LinkButton)sender).CommandArgument);
                if (recId > 0)
                {
                    oReportField ReportField = new oReportField();
                    foreach (oReportField field in xData.GetTypedByCriteriaSpecific("recId", typeof(oReportField), "recId", recId.ToString()))
                    {
                        ReportField = field;
                        break;
                    }

                    //populate
                    PopulateFieldFormValues(ReportField);
                    Session["ReportField"] = ReportField;

                    //panels
                    ToggleFieldPanels(pnlReportFieldForm.ID);
                }
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    protected void lnkRemoveField_Click(object sender, EventArgs e)
    {
        try
        {
            if (sender.GetType() == typeof(LinkButton))
            {
                int recId = int.Parse(((LinkButton)sender).CommandArgument);
                if (xData.DeleteTyped("recId", recId.ToString(), typeof(oReportField)))
                {
                    oReport report = new oReport();
                    if (utils.verifySession("Report"))
                        report = (oReport)Session["Report"];

                    //rebind grid
                    BindReportFieldList(report.recId);
                    pnlResultReportField.Visible = true;
                    //display successful result
                    lblResultReportField.Text = "the selected field was deleted successfully.";
                }
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    //protected void ddFieldTypes_SelectedIndexChanged(object sender, EventArgs e)
    //{
    //    try
    //    {
    //        if (sender is DropDownList)
    //        {
    //            DropDownList ddl = (DropDownList)sender;
    //            if (ddl.SelectedItem != null)
    //            {
    //                if (ddl.SelectedItem.Value == pNums.ReportFieldType.Surface.GetHashCode().ToString())
    //                    divFieldTypeSurface.Visible = true;
    //                else
    //                    divFieldTypeSurface.Visible = false;
    //            }
    //        }
    //    }
    //    catch (Exception ex)
    //    {
    //        exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
    //        Response.Redirect("/error", false);
    //    }
    //}

    protected void ddSurface_SelectedIndexChanged(object sender, EventArgs e)
    {
        try
        {
            //bind secondary List
            BindSurfaceSecondayList();
            BindSurfaceFieldList();

        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Secondary Sources Selected Index Changed Event
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lstSecondarySources_SelectedIndexChanged(object sender, EventArgs e)
    {
        try
        {
            BindSurfaceFieldList();
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Item Data bound event
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void rptReportFields_ItemDataBound(object sender, RepeaterItemEventArgs e)
    {
        try
        {
            if (e.Item.ItemIndex != -1)
            {
                Label lblFieldType = ((Label)e.Item.FindControl("lblFieldType"));

                pNums.ReportFieldType typ = (pNums.ReportFieldType)Enum.ToObject(typeof(pNums.ReportFieldType), int.Parse(lblFieldType.Text));

                switch (typ)
                {
                    default:
                        lblFieldType.Text = typ.ToString();
                        break;
                }

            }
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Back to report builder
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnBackToBuilder_Click(object sender, EventArgs e)
    {
        try
        {
            this.Report = null;
            pnlReportBuilder.Visible = true;
            pnlReportContainer.Visible = false;
            plcReportContainer.Controls.Clear();
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Run Report
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lnkRunReport_Click(object sender, EventArgs e)
    {
        try
        {
            oReport _Report = new oReport();

            if (sender.GetType() == typeof(LinkButton))
            {
                int recId = int.Parse(((LinkButton)sender).CommandArgument);
                if (recId > 0)
                {
                    //get report
                    foreach (oReport report in xData.GetTypedByCriteriaSpecific("recId", typeof(oReport), "recId", recId.ToString()))
                    {
                        _Report = report;
                        break;
                    }
                    this.Report = _Report;
                    LoadReportContainer(_Report);
                    pnlReportContainer.Visible = true;
                    pnlReportBuilder.Visible = false;
                    upReport.Update();
                }
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }


    /// <summary>
    /// Preview Report
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnPreview_Click(object sender, EventArgs e)
    {
        try
        {
            oReport Report = new oReport();

            if (utils.verifySession("Report"))//update mode
            {
                Report = (oReport)Session["Report"];
                this.Report = Report;
                LoadReportContainer(Report);
                pnlReportContainer.Visible = true;
                pnlReportBuilder.Visible = false;
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    #endregion


}