using framework_business;
using framework_library;
using Microsoft.VisualBasic;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Web;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;

public partial class controls_module_report : System.Web.UI.UserControl, IControlBase
{
    #region properties

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

    public bool ReportLoaded
    {
        get
        {
            if (ViewState["ReportLoaded"] == null)
                return false;
            else return (bool)ViewState["ReportLoaded"];
        }
        set
        {
            ViewState["ReportLoaded"] = value;
        }
    }

    #endregion

    #region methods 

    private string BuildReportLegend(oReport report)
    {
        string legend = "";
        try
        {
            oSetup _setup = handler.ReturnSetup();
            StringBuilder legendBuilder = new StringBuilder();

            if (_setup.code == "STUD-1" && report.name.Contains("Document"))
            {
                legendBuilder.AppendLine("<div class=\"col-md-2 col-md-offset-2\"><div class=\"grid-legend\">LEGEND:</div></div>");
                legendBuilder.AppendLine("<div class=\"col-md-2\"><i class=\"fa fa-check-circle-o palette-edit pull-left\" aria-hidden=\"true\" ></i><div class=\"pull-left grid-legend\">Yes</div></div>");
                legendBuilder.AppendLine("<div class=\"col-md-2\"><i class=\"fa fa-check-circle-o palette-add pull-left\" aria-hidden=\"true\" ></i><div class=\"pull-left grid-legend\">N/A</div></div>");
                legendBuilder.AppendLine("<div class=\"col-md-2\"><i class=\"fa fa-times-circle-o palette-back pull-left\" aria-hidden=\"true\" ></i><div class=\"pull-left grid-legend\">Flag</div></div>");
                legendBuilder.AppendLine("<div class=\"col-md-2\"><i class=\"fa fa-times-circle-o palette-remove pull-left\" aria-hidden=\"true\" ></i><div class=\"pull-left grid-legend\">No</div></div>");
            }

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

        return legend;
    }

    #region Backup 2017-03-07
    //private string CalculateCustomReportFieldValue(List<oSurfaceField> surfaceFields, oReportField rptField, DataTable dtSurfaceData, DataRow rowSurface, int mainSurfaceId)
    //{
    //    string value = "";
    //    try
    //    {
    //        oSetup _setup = handler.ReturnSetup();

    //        if (_setup.code == "STUD-1")
    //        {
    //            //only processing non-custom type fields in the loop, need to handle custom status field after all other fields have been processed
    //            if (rptField.reportFieldTypeId == pNums.ReportFieldType.Surface.GetHashCode())
    //            {
    //                //main surface
    //                if (mainSurfaceId == rptField.surfaceId)
    //                {
    //                    //find related surface field
    //                    //Speed test: Looping through surfaceFields is quicker than sql lookup to get 1 surface field in foreach
    //                    //Speed test: Looping through surfaceFields is quicker than sql lookup to get 1 surface field not in a foreach
    //                    //Speed test: Linq on List<oSurfaceField> is quicker than looping through surfaceFields

    //                    //foreach (oSurfaceField surfField in surfaceFields)
    //                    //{
    //                    //    if (surfField.recId == rptField.surfaceFieldId)
    //                    //    {
    //                    //        if (rowSurface[surfField.surfaceFieldName] != null)
    //                    //            value = rowSurface[surfField.surfaceFieldName].ToString();

    //                    //        break;
    //                    //    }
    //                    //}
    //                    foreach (oSurfaceField surfField in surfaceFields.Where(f => f.recId == rptField.surfaceFieldId).ToList())
    //                    {
    //                        if (rowSurface[surfField.surfaceFieldName] != null)
    //                            value = rowSurface[surfField.surfaceFieldName].ToString();

    //                        break;
    //                    }
    //                }
    //                else    //child surface
    //                {
    //                    string maxStatus = "N/A";
    //                    //get child data
    //                    DataTable dtChildData = null;
    //                    if (ViewState["ChildData"] != null)
    //                    {
    //                        dtChildData = (DataTable)ViewState["ChildData"];
    //                    }
    //                    //if no datatable yet, or if there is a datatable, but not the same child surface, get the current child surface
    //                    if (dtChildData == null || (dtChildData.Rows.Count > 0 && dtChildData.Rows[0]["surfaceId"].ToString() != rptField.surfaceId.ToString()))
    //                    {
    //                        int itemId = 0;
    //                        if (rowSurface["itemId"] != null)
    //                            int.TryParse(rowSurface["itemId"].ToString(), out itemId);
    //                        List<oDynamicParam> list = new List<oDynamicParam>();
    //                        oDynamicParam par1 = new oDynamicParam();
    //                        par1.paramDisplayName = "SurfaceID";
    //                        par1.paramObject = rptField.surfaceId;
    //                        list.Add(par1);
    //                        oDynamicParam par2 = new oDynamicParam();
    //                        par2.paramDisplayName = "ParentSurfaceItemId";
    //                        par2.paramObject = itemId;
    //                        list.Add(par2);
    //                        oDynamicParam par3 = new oDynamicParam();
    //                        par3.paramDisplayName = "RowLimit";
    //                        par3.paramObject = 0;
    //                        list.Add(par3);
    //                        oDynamicParam par4 = new oDynamicParam();
    //                        par4.paramDisplayName = "GridOnly";
    //                        par4.paramObject = 0;
    //                        list.Add(par4);
    //                        dtChildData = xData.GetTypedTableByProc("recId", typeof(oSurfaceFieldData), "sp_GetChildSurfaceData", list);

    //                        ViewState["ChildData"] = dtChildData;
    //                    }

    //                    //find related surface field
    //                    foreach (oSurfaceField childField in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceField), "surfaceId,recId", rptField.surfaceId + "," + rptField.surfaceFieldId))
    //                    {
    //                        //find surface data column in child data
    //                        foreach (DataColumn colChild in dtChildData.Columns)
    //                        {
    //                            if (colChild.ColumnName == childField.surfaceFieldName)
    //                            {
    //                                //loop through child rows
    //                                foreach (DataRow rowChild in dtChildData.Rows)
    //                                {
    //                                    string childValue = rowChild[colChild.ColumnName].ToString();
    //                                    if (childValue == "No")
    //                                    {
    //                                        //if 1 or more is No, status is No
    //                                        maxStatus = "No";
    //                                        break;
    //                                    }
    //                                    //if Flag (but not saved as Flag, reason is saved
    //                                    else if (childValue != "No" && childValue != "Yes" && childValue != "N/A" && maxStatus != "No")
    //                                        maxStatus = "Flag";
    //                                    else if (childValue == "Yes" && maxStatus != "No" && maxStatus != "Flag")
    //                                        maxStatus = "Yes";
    //                                    //remains "N/A" if conditions not met
    //                                }

    //                                break;
    //                            }
    //                        }

    //                        break;

    //                    }

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

    //    return value;
    //}
    #endregion

    private string CalculateLookup(oSurfaceField lookupField, decimal sourceValue)
    {
        //assuming the source field and Bottom and Top fields numberic types, using decimals
        string value = "";
        try
        {
            int lookupSurfaceId = 0;
            int.TryParse(lookupField.actionValue, out lookupSurfaceId);
            if (lookupSurfaceId <= 0)
                return value;

            DataTable dtLookup = xData.GetSurfaceDataAll(lookupSurfaceId, true);
            //rename columns for easer processing
            foreach (DataColumn col in dtLookup.Columns)
            {
                if (col.ColumnName.EndsWith("_Bottom"))
                    col.ColumnName = "Bottom";
                else if (col.ColumnName.EndsWith("_Top"))
                    col.ColumnName = "Top";
                else if (col.ColumnName.EndsWith("_Lookup"))
                    col.ColumnName = "Lookup";
            }
            if (dtLookup.Columns["Bottom"] == null || dtLookup.Columns["Top"] == null || dtLookup.Columns["Lookup"] == null)
                return value;
            dtLookup.DefaultView.Sort = "Bottom";
            int counter = 0;
            foreach (DataRow row in dtLookup.Rows)
            {
                //bottom can be invalid when counter is 0, top can be invalid when counter is number of rows
                decimal bottom = 0m;
                if (!decimal.TryParse(row["Bottom"].ToString(), out bottom) && counter != 0)
                    continue;
                decimal top = 0m;
                if (!decimal.TryParse(row["Top"].ToString(), out top) && counter != (dtLookup.Rows.Count - 1))
                    continue;
                if (counter == 0)
                {
                    if (sourceValue <= top)
                    {
                        value = row["Lookup"].ToString();
                        break;
                    }
                }
                else if (counter == dtLookup.Rows.Count - 1)
                {
                    if (sourceValue >= bottom)
                    {
                        value = row["Lookup"].ToString();
                        break;
                    }
                }
                else
                {
                    if (sourceValue >= bottom && sourceValue <= top)
                    {
                        value = row["Lookup"].ToString();
                        break;
                    }
                }

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

    private string CalculateLabelValue(oSurfaceField field, int itemId, DataRow rowSurface, oSurfaceAction lookupAction, oSurfaceAction divideAction, oSurfaceAction aggrSumAction,
        List<oSurfaceField> surfaceFields)
    {
        string labelValue = String.Empty;
        try
        {
            string sourceFieldValue = string.Empty;
            if (field.relationalSurface != field.surfaceId.ToString() && rowSurface["ParentSurfaceItemId"] != null && rowSurface["ParentSurfaceItemId"].ToString() != "" && rowSurface["ParentSurfaceItemId"].ToString() != "0")
                itemId = Int32.Parse(rowSurface["ParentSurfaceItemId"].ToString());

            foreach (oSurfaceField sourceField in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceField), "surfaceId,recId", field.relationalSurface.ToString() + "," + field.relationalFields.ToString()))
            {
                //cater for a label referencing a label, only in instances where need details from the parent parent
                if (sourceField.surfaceFieldTypeId == (int)pNums.FieldType.Label)
                {
                    foreach (oSurfaceField sourceField2 in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceField), "surfaceId,recId", sourceField.relationalSurface.ToString() + "," + sourceField.relationalFields.ToString()))
                    {
                        //get parent item id
                        foreach (oSurfaceField parentField in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceField), "surfaceId,surfaceFieldName", sourceField.surfaceId + ",ParentSurfaceItemId"))
                        {
                            foreach (oSurfaceFieldData parentSurfaceItemId in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceFieldData), "surfaceId,surfaceFieldID,surfaceItemId", parentField.surfaceId + "," + parentField.recId + "," + itemId))
                            {
                                if (parentSurfaceItemId.surfaceFieldValueNum > 0)
                                    itemId = parentSurfaceItemId.surfaceFieldValueNum;
                            }
                        }

                        //get data
                        foreach (oSurfaceFieldData sourceData2 in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceFieldData), "surfaceId,surfaceFieldID,surfaceItemId", sourceField.relationalSurface.ToString() + "," + sourceField.relationalFields.ToString() + "," + itemId))
                        {
                            pNums.FieldType sourceType = (pNums.FieldType)Enum.ToObject(typeof(pNums.FieldType), sourceField2.surfaceFieldTypeId);
                            switch (sourceType)
                            {
                                case pNums.FieldType.Text:
                                case pNums.FieldType.Caption:
                                case pNums.FieldType.Address:
                                case pNums.FieldType.MultiPicklist:
                                    sourceFieldValue = sourceData2.surfaceFieldValueChar;
                                    break;
                                case pNums.FieldType.Number:
                                    sourceFieldValue = sourceData2.surfaceFieldValueNum.ToString();
                                    break;
                                case pNums.FieldType.Decimal:
                                    sourceFieldValue = sourceData2.surfaceFieldValueDecimal.ToString();
                                    break;
                                case pNums.FieldType.Date:
                                    sourceFieldValue = sourceData2.surfaceFieldValueDate.ToShortDateString();
                                    break;
                                case pNums.FieldType.Picklist:
                                case pNums.FieldType.RadioButtonList:
                                    sourceFieldValue = "";
                                    foreach (oSurfaceLookup look in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceLookup), "recId", sourceData2.surfaceFieldLookupID.ToString()))
                                    {
                                        sourceFieldValue = look.display;
                                        break;
                                    }
                                    break;
                                case pNums.FieldType.Checkbox:
                                    sourceFieldValue = sourceData2.surfaceFieldValueBool == true ? "Yes" : "No";
                                    break;
                                case pNums.FieldType.FormulaField:
                                    sourceFieldValue = "";
                                    if (sourceField2.actionType == (int)pNums.ActionType.Calculation && sourceField2.action == lookupAction.recId)
                                    {
                                        decimal lookupSrcValue = 0m;
                                        bool conversionSuccess = false;
                                        //get source field
                                        foreach (oSurfaceField lookupSrcField in surfaceFields.Where(f => f.recId == sourceField2.actionSource).ToList())
                                        {
                                            //catering for field types char, number, decimal
                                            if (lookupSrcField.surfaceFieldTypeId == (int)pNums.FieldType.Number)
                                                conversionSuccess = decimal.TryParse(rowSurface["surfaceFieldValueNum"].ToString(), out lookupSrcValue);
                                            else if (lookupSrcField.surfaceFieldTypeId == (int)pNums.FieldType.Decimal)
                                                conversionSuccess = decimal.TryParse(rowSurface["surfaceFieldValueDecimal"].ToString(), out lookupSrcValue);
                                            else
                                                conversionSuccess = decimal.TryParse(rowSurface["surfaceFieldValueChar"].ToString(), out lookupSrcValue);

                                            break;
                                        }

                                        if (conversionSuccess)
                                        {
                                            sourceFieldValue = CalculateLookup(sourceField, lookupSrcValue);
                                        }
                                    }
                                    //CVH 2017-02-07 New action Divide is saved in Char
                                    else if (sourceField2.actionType == (int)pNums.ActionType.Calculation && sourceField2.action != divideAction.recId)
                                    {
                                        sourceFieldValue = utils.returnFormattedDecimal(Convert.ToString(sourceData2.surfaceFieldValueDecimal));
                                        foreach (oSurfaceAction act in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceAction), "recId", sourceField2.action.ToString()))
                                        {
                                            if (act.action == "Age")
                                            {
                                                //need to calculate age, it isn't always saved in the age field
                                                //get age source (date of birth) data
                                                DateTime? dob = null;
                                                foreach (oSurfaceFieldData dobData in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceFieldData), "surfaceId,surfaceItemId,surfaceFieldID", sourceField2.surfaceId + "," + sourceData2.surfaceItemId + "," + sourceField2.actionSource))
                                                {
                                                    dob = dobData.surfaceFieldValueDate;
                                                    break;
                                                }
                                                if (dob != null)
                                                {
                                                    oAge age = utils.FormatAge(Convert.ToDateTime(dob), DateTime.Now);
                                                    sourceFieldValue = age.years.ToString();
                                                }
                                            }
                                            break;
                                        }
                                    }
                                    //CVH 2017-02-24 New action type Aggregation Sum
                                    else if (sourceField.actionType == (int)pNums.ActionType.Aggregation && sourceField.action == aggrSumAction.recId)
                                    {
                                        int actionSurfaceId = 0;
                                        if (int.TryParse(sourceField.actionValue, out actionSurfaceId))
                                        {
                                            decimal decFormula = xData.GetSurfaceAggregationSum(actionSurfaceId, sourceField.actionSource, itemId);
                                            sourceFieldValue = utils.returnFormattedDecimal(decFormula.ToString());
                                        }
                                    }
                                    else
                                    {
                                        sourceFieldValue = sourceData2.surfaceFieldValueChar;
                                    }
                                    break;
                                case pNums.FieldType.CheckboxList:

                                    sourceFieldValue = "";

                                    //split string to get lookup IDs
                                    foreach (string temp in sourceData2.surfaceFieldValueChar.Split(new string[] { "~|~" }, StringSplitOptions.None))
                                    {
                                        string lookupId = "";
                                        if (temp.IndexOf("~R~") >= 0)
                                        {
                                            lookupId = temp.Substring(0, temp.IndexOf("~R~"));
                                        }
                                        else
                                        {
                                            lookupId = temp;
                                        }

                                        //get lookup
                                        foreach (oSurfaceLookup look in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceLookup), "recId", lookupId))
                                        {
                                            if (sourceFieldValue == String.Empty)
                                                sourceFieldValue = look.display;
                                            else
                                                sourceFieldValue += ", " + look.display;
                                            break;
                                        }
                                    }

                                    break;
                                case pNums.FieldType.Image:
                                    //not catering for images in report
                                    break;
                                case pNums.FieldType.Attachment:
                                    //not catering for attachments in report
                                    break;
                                case pNums.FieldType.Note:
                                    //not catering for notes in report
                                    break;
                            }
                        }
                    }
                }
                else
                {
                    foreach (oSurfaceFieldData sourceData in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceFieldData), "surfaceId,surfaceFieldID,surfaceItemId", field.relationalSurface.ToString() + "," + field.relationalFields.ToString() + "," + itemId))
                    {
                        pNums.FieldType sourceType = (pNums.FieldType)Enum.ToObject(typeof(pNums.FieldType), sourceField.surfaceFieldTypeId);
                        switch (sourceType)
                        {
                            case pNums.FieldType.Text:
                            case pNums.FieldType.Caption:
                            case pNums.FieldType.Address:
                            case pNums.FieldType.MultiPicklist:
                                sourceFieldValue = sourceData.surfaceFieldValueChar;
                                break;
                            case pNums.FieldType.Number:
                                sourceFieldValue = sourceData.surfaceFieldValueNum.ToString();
                                break;
                            case pNums.FieldType.Decimal:
                                sourceFieldValue = sourceData.surfaceFieldValueDecimal.ToString();
                                break;
                            case pNums.FieldType.Date:
                                sourceFieldValue = sourceData.surfaceFieldValueDate.ToShortDateString();
                                break;
                            case pNums.FieldType.Picklist:
                            case pNums.FieldType.RadioButtonList:
                                sourceFieldValue = "";
                                foreach (oSurfaceLookup look in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceLookup), "recId", sourceData.surfaceFieldLookupID.ToString()))
                                {
                                    sourceFieldValue = look.display;
                                    break;
                                }
                                break;
                            case pNums.FieldType.Checkbox:
                                sourceFieldValue = sourceData.surfaceFieldValueBool == true ? "Yes" : "No";
                                break;
                            case pNums.FieldType.FormulaField:
                                sourceFieldValue = "";
                                if (sourceField.actionType == (int)pNums.ActionType.Calculation && sourceField.action == lookupAction.recId)
                                {
                                    decimal lookupSrcValue = 0m;
                                    bool conversionSuccess = false;
                                    //get source field
                                    foreach (oSurfaceField lookupSrcField in surfaceFields.Where(f => f.recId == sourceField.actionSource).ToList())
                                    {
                                        //catering for field types char, number, decimal
                                        if (lookupSrcField.surfaceFieldTypeId == (int)pNums.FieldType.Number)
                                            conversionSuccess = decimal.TryParse(rowSurface["surfaceFieldValueNum"].ToString(), out lookupSrcValue);
                                        else if (lookupSrcField.surfaceFieldTypeId == (int)pNums.FieldType.Decimal)
                                            conversionSuccess = decimal.TryParse(rowSurface["surfaceFieldValueDecimal"].ToString(), out lookupSrcValue);
                                        else
                                            conversionSuccess = decimal.TryParse(rowSurface["surfaceFieldValueChar"].ToString(), out lookupSrcValue);

                                        break;
                                    }

                                    if (conversionSuccess)
                                    {
                                        sourceFieldValue = CalculateLookup(field, lookupSrcValue);
                                    }
                                }
                                //CVH 2017-02-07 New action Divide is saved in Char
                                else if (sourceField.actionType == (int)pNums.ActionType.Calculation && sourceField.action != divideAction.recId)
                                {
                                    sourceFieldValue = utils.returnFormattedDecimal(Convert.ToString(sourceData.surfaceFieldValueDecimal));
                                    foreach (oSurfaceAction act in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceAction), "recId", sourceField.action.ToString()))
                                    {
                                        if (act.action == "Age")
                                        {
                                            //need to calculate age, it isn't always saved in the age field
                                            //get age source (date of birth) data
                                            DateTime? dob = null;
                                            foreach (oSurfaceFieldData dobData in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceFieldData), "surfaceId,surfaceItemId,surfaceFieldID", sourceField.surfaceId + "," + sourceData.surfaceItemId + "," + sourceField.actionSource))
                                            {
                                                dob = dobData.surfaceFieldValueDate;
                                                break;
                                            }
                                            if (dob != null)
                                            {
                                                oAge age = utils.FormatAge(Convert.ToDateTime(dob), DateTime.Now);
                                                sourceFieldValue = age.years.ToString();
                                            }
                                        }
                                        break;
                                    }
                                }
                                //CVH 2017-02-24 New action type Aggregation Sum
                                else if (field.actionType == (int)pNums.ActionType.Aggregation && field.action == aggrSumAction.recId)
                                {
                                    int actionSurfaceId = 0;
                                    if (int.TryParse(field.actionValue, out actionSurfaceId))
                                    {
                                        decimal decFormula = xData.GetSurfaceAggregationSum(actionSurfaceId, field.actionSource, itemId);
                                        sourceFieldValue = utils.returnFormattedDecimal(decFormula.ToString());
                                    }
                                }
                                else
                                {
                                    sourceFieldValue = sourceData.surfaceFieldValueChar;
                                }
                                break;
                            case pNums.FieldType.CheckboxList:

                                sourceFieldValue = "";

                                //split string to get lookup IDs
                                foreach (string temp in sourceData.surfaceFieldValueChar.Split(new string[] { "~|~" }, StringSplitOptions.None))
                                {
                                    string lookupId = "";
                                    if (temp.IndexOf("~R~") >= 0)
                                    {
                                        lookupId = temp.Substring(0, temp.IndexOf("~R~"));
                                    }
                                    else
                                    {
                                        lookupId = temp;
                                    }

                                    //get lookup
                                    foreach (oSurfaceLookup look in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceLookup), "recId", lookupId))
                                    {
                                        if (sourceFieldValue == String.Empty)
                                            sourceFieldValue = look.display;
                                        else
                                            sourceFieldValue += ", " + look.display;
                                        break;
                                    }
                                }

                                break;
                            case pNums.FieldType.Image:
                                //not catering for images in report
                                break;
                            case pNums.FieldType.Attachment:
                                //not catering for attachments in report
                                break;
                            case pNums.FieldType.Note:
                                //not catering for notes in report
                                break;
                        }
                    }
                }
            }

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

        return labelValue;
    }


    /// <summary>
    /// Return a surface
    /// </summary>
    /// <param name="recId"></param>
    /// <returns></returns>
    private oSurface GetSurface(int recId)
    {
        oSurface result = new oSurface();
        try
        {
            foreach (oSurface srf in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurface), "recId", recId.ToString()))
            {
                result = srf;
                break;
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
        return result;
    }

    /// <summary>
    /// Return a surface field
    /// </summary>
    /// <param name="recId"></param>
    /// <returns></returns>
    private oSurfaceField GetSurfaceField(int recId)
    {
        oSurfaceField result = new oSurfaceField();
        try
        {
            foreach (oSurfaceField fld in xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceField), "recId", recId.ToString()))
            {
                result = fld;
                break;
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
        return result;
    }

    /// <summary>
    /// Build Filters 
    /// </summary>
    /// <param name="report"></param>
    private void BuildFilters(oReport report)
    {
        try
        {
            ArrayList filterFields = new ArrayList();
            int filterCount = 0;
            filterFields = xData.GetTypedByCriteriaSpecific("recId", typeof(oReportField), "reportId,isFilter", report.recId + ",1", "sequence");
            if (filterFields.Count > 0)
                divFilters.Visible = true;

            foreach (oReportField rptFld in filterFields)
            {
                filterCount++;

                HtmlGenericControl grpFilter = (HtmlGenericControl)divFilters.FindControl("grpFilter" + filterCount);
                if (grpFilter != null)
                {
                    grpFilter.Visible = true;
                    Label lblFilter = (Label)divFilters.FindControl("lblFilter" + filterCount);
                    ListBox lstFilter = (ListBox)divFilters.FindControl("lstFilter" + filterCount);
                    if (lblFilter != null && lstFilter != null)
                    {
                        lblFilter.Text = rptFld.reportFieldDisplay;

                        DataTable filterData = new DataTable();

                        oSurface fieldSurf = GetSurface(rptFld.surfaceId);
                        oSurfaceField field = GetSurfaceField(rptFld.surfaceFieldId);

                        string query = "Select DISTINCT(" + field.surfaceFieldName + ") FROM qt_" + fieldSurf.name + " ";

                        filterData = xData.GetCustomTypedTable(query);
                       
                        lstFilter.DataSource = filterData;
                        lstFilter.DataValueField = field.surfaceFieldName; //"itemId";
                        lstFilter.DataTextField = field.surfaceFieldName;
                        lstFilter.DataBind();

                    }
                }
            }

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

    /// <summary>
    /// Bind the Report Grid
    /// </summary>
    /// <param name="report"></param>
    private void BindReportGrid(oReport report)
    {
        try
        {
            oSetup _setup = handler.ReturnSetup();

            DataTable dtReportData = new DataTable();
            DataTable dtReportFooter = new DataTable();
            ArrayList reportFields = null;

            //SBF Document checklist report - call stored procedure
            if (_setup.code == "STUD-1" && report.name.Contains("Document"))
            {
                dtReportData = xData.GetTypedTableByProc("recId", typeof(oSurfaceFieldData), "sp_STUD1_GetReportDataDocumentChecklist", new List<oDynamicParam>());

                bool status = true;
                foreach (DataRow row in dtReportData.Rows)
                {
                    foreach (DataColumn col in dtReportData.Columns)
                    {
                        if (col.ColumnName == "Status" || col.ColumnName.EndsWith("Name") || col.ColumnName.EndsWith("Surname"))
                            continue;

                        if (row[col] != null && row[col].ToString() != "Yes" && row[col].ToString() != "N/A")
                        {
                            status = false;
                            break;
                        }
                    }

                    if (row["Status"] != null)
                        row["Status"] = status ? "Yes" : "No";
                }
            }
            else
            {
                //fetch report fields by grouping then sequence
                reportFields = xData.GetTypedByCriteriaSpecific("recId", typeof(oReportField), "reportId", report.recId.ToString(), "isGrouped DESC, sequence");
                if (reportFields == null || reportFields.Count <= 0)
                    return;

                //setup primary surface
                StringBuilder qBuilder = new StringBuilder();
                //select builder
                StringBuilder sBuilder = new StringBuilder();
                //table builder
                StringBuilder tBuilder = new StringBuilder();
                //join builder
                StringBuilder jBuilder = new StringBuilder();
                //where builder
                StringBuilder wBuilder = new StringBuilder();
                //group builder
                StringBuilder gBuilder = new StringBuilder();


                int primarySurfaceId = 0;
                int fieldCount = 1;
                bool includeGroup = false;
                string primaryTable = String.Empty;
                oSurface primarySurface = new oSurface();
                List<string> groupFields = new List<string>();
                List<KeyValuePair<int, int>> joins = new List<KeyValuePair<int, int>>();
                //build report table columns and report query
                foreach (oReportField field in reportFields)
                {
                    if (primarySurfaceId == 0)
                    {
                        if (field.parentSurfaceId > 0)
                            primarySurface = GetSurface(field.parentSurfaceId);
                        else
                            primarySurface = GetSurface(field.surfaceId);
                    }


                    oSurface surface = GetSurface(field.surfaceId);
                    oSurfaceField surfacefield = GetSurfaceField(field.surfaceFieldId);

                    if (field.isGrouped)//add to group list
                        includeGroup = true;

                    string preFx = String.Empty;
                    string sufFx = String.Empty;

                    if (field.aggregationType > 0)
                    {
                        includeGroup = true;
                        pNums.AggregateType typ = (pNums.AggregateType)Enum.ToObject(typeof(pNums.AggregateType), field.aggregationType);
                        switch (typ)
                        {
                            case pNums.AggregateType.average:

                                if (surfacefield.surfaceFieldTypeId == (int)pNums.FieldType.Number)//then sum
                                {
                                    preFx = "AVG(CAST(ISNULL(NULLIF(";
                                    sufFx = ",''),0)as int)) AS [" + field.reportFieldName + "]";
                                }
                                else if (surfacefield.surfaceFieldTypeId == (int)pNums.FieldType.Decimal)//then sum
                                {
                                    preFx = "AVG(CAST(ISNULL(NULLIF(";
                                    sufFx = ",''),0)as decimal)) AS [" + field.reportFieldName + "]";
                                }
                                else
                                {
                                    sufFx = " AS [" + field.reportFieldName + "]";
                                    if (groupFields.Count > 0 && !field.isGrouped)
                                    { groupFields.Add(surfacefield.surfaceFieldName); }
                                }
                                break;
                            case pNums.AggregateType.sum:
                                if (surfacefield.surfaceFieldTypeId == (int)pNums.FieldType.Number)//then sum
                                {
                                    preFx = "SUM(CAST(ISNULL(NULLIF(";
                                    sufFx = ",''),0)as int)) AS [" + field.reportFieldName + "]";
                                }
                                else if (surfacefield.surfaceFieldTypeId == (int)pNums.FieldType.Decimal)//then sum
                                {
                                    preFx = "SUM(CAST(ISNULL(NULLIF(";
                                    sufFx = ",''),0)as decimal)) AS [" + field.reportFieldName + "]";
                                }
                                else
                                {
                                    sufFx = " AS [" + field.reportFieldName + "]";
                                    if (groupFields.Count > 0 && !field.isGrouped)
                                    { groupFields.Add(surfacefield.surfaceFieldName); }
                                }

                                break;
                            case pNums.AggregateType.count:
                                if (surfacefield.surfaceFieldTypeId == (int)pNums.FieldType.Number)//then sum
                                {
                                    preFx = "Count(CAST(ISNULL(NULLIF(";
                                    sufFx = ",''),0)as int)) AS [" + field.reportFieldName + "]";
                                }
                                else if (surfacefield.surfaceFieldTypeId == (int)pNums.FieldType.Decimal)//then sum
                                {
                                    preFx = "Count(CAST(ISNULL(NULLIF(";
                                    sufFx = ",''),0)as decimal)) AS [" + field.reportFieldName + "]";
                                }
                                else
                                {
                                    sufFx = " AS [" + field.reportFieldName + "]";
                                    if (groupFields.Count > 0 && !field.isGrouped)
                                    { groupFields.Add(surfacefield.surfaceFieldName); }
                                }

                                break;
                        }

                    }
                    else//not an aggregate field
                    {
                        groupFields.Add(surfacefield.surfaceFieldName);
                        sufFx = " AS [" + field.reportFieldName + "]";
                    }

                    if (primarySurfaceId == 0)
                    {
                        if (field.parentSurfaceId > 0)
                            primarySurfaceId = field.parentSurfaceId;
                        else
                            primarySurfaceId = field.surfaceId;


                        if (field.surfaceId != primarySurfaceId)//we need to create a join
                        {
                            fieldCount++;

                            //append join line
                            jBuilder.AppendLine("INNER JOIN qt_" + surface.name + " [" + fieldCount + "] ON [" + fieldCount + "].ParentSurfaceItemId = [1].itemId ");
                            //append to joins list
                            joins.Add(new KeyValuePair<int, int>(field.surfaceId, fieldCount));
                        }

                        //create select line
                        sBuilder.AppendLine("SELECT " + preFx + "[" + fieldCount + "]." + surfacefield.surfaceFieldName + sufFx + " ");
                        //create from table
                        tBuilder.AppendLine("FROM qt_" + primarySurface.name + " [1]");
                    }
                    else
                    {
                        if (field.surfaceId != primarySurfaceId)//we need to create a join
                        {
                            bool joinFound = false;
                            foreach (KeyValuePair<int, int> pr in joins)
                            {
                                if (pr.Key == field.surfaceId)//this join already exists
                                {
                                    joinFound = true;
                                    //append select item
                                    sBuilder.AppendLine(", " + preFx + "[" + pr.Value + "]." + surfacefield.surfaceFieldName + sufFx + " ");
                                    break;
                                }
                            }
                            if (!joinFound)
                            {
                                fieldCount++;
                                //append select item
                                sBuilder.AppendLine(", " + preFx + "[" + fieldCount + "]." + surfacefield.surfaceFieldName + sufFx + " ");
                                //append join line
                                jBuilder.AppendLine("INNER JOIN qt_" + surface.name + " [" + fieldCount + "] ON [" + fieldCount + "].ParentSurfaceItemId = [1].itemId ");
                                //append to joins list
                                joins.Add(new KeyValuePair<int, int>(field.surfaceId, fieldCount));
                            }
                        }
                        else
                        {
                            //append select item of primary field
                            sBuilder.AppendLine(", " + preFx + "[1]." + surfacefield.surfaceFieldName + sufFx + " ");
                        }
                    }
                    //add footer column
                    dtReportFooter.Columns.Add(field.reportFieldName);


                    if (field.isFilter)
                    {
                        //build where clause from filters
                        if (divFilters.Visible == true)
                        {
                            bool filterfound = false;
                            for (int i = 1; i < 7; i++)
                            {
                                if (filterfound)
                                    break;
                                HtmlGenericControl grpFilter = (HtmlGenericControl)divFilters.FindControl("grpFilter" + i);
                                if (grpFilter != null && grpFilter.Visible)
                                {
                                    grpFilter.Visible = true;
                                    Label lblFilter = (Label)divFilters.FindControl("lblFilter" + i);
                                    ListBox lstFilter = (ListBox)divFilters.FindControl("lstFilter" + i);

                                    if (lblFilter != null && lstFilter != null)
                                    {
                                        if (lstFilter.DataValueField == surfacefield.surfaceFieldName)//filter found
                                        {
                                            filterfound = true;
                                            var items = lstFilter.Items.GetSelectedItems();
                                            if (items.Count() > 0)
                                            {
                                                if (wBuilder.ToString() == String.Empty)
                                                {
                                                    wBuilder.AppendLine("WHERE [" + fieldCount + "]." + surfacefield.surfaceFieldName + " IN ('" + String.Join("','", items.Select(x => x.Value).ToArray()) + "') ");
                                                }
                                                else
                                                {
                                                    wBuilder.AppendLine("AND [" + fieldCount + "]." + surfacefield.surfaceFieldName + " IN ('" + String.Join("','", items.Select(x => x.Value).ToArray()) + "') ");
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }

                }


                //check if we need to group
                if (groupFields.Count > 0)
                {
                    gBuilder.AppendLine("GROUP By " + String.Join(",", groupFields.ToArray()) + " ");
                }

                //concatonate query
                //inject select
                qBuilder.AppendLine(sBuilder.ToString());
                //inject table
                qBuilder.AppendLine(tBuilder.ToString());
                //inject join
                qBuilder.AppendLine(jBuilder.ToString());
                //inject where
                qBuilder.AppendLine(wBuilder.ToString());
                if (includeGroup)
                {
                    //inject grouping
                    qBuilder.AppendLine(gBuilder.ToString());
                }


                //get custom generated report DataTable
                dtReportData = xData.GetCustomTypedTable(qBuilder.ToString());


            }

            if (dtReportData.Rows.Count > 0)
            {
                //bind footer
                if (report.enableAggregation)
                {
                    DataRow rowFooter = dtReportFooter.NewRow();
                    if (reportFields != null && reportFields.Count > 0)
                    {
                        decimal convertedDec = 0m;

                        for (int i = 0; i < reportFields.Count; i++)
                        {

                            oReportField rptField = (oReportField)reportFields[i];
                            oSurfaceField surfaceField = GetSurfaceField(rptField.surfaceFieldId);
                            if (rptField.aggregationType == pNums.AggregateType.average.GetHashCode())
                            {
                                if (surfaceField.surfaceFieldTypeId == (int)pNums.FieldType.Number)
                                {
                                    rowFooter[i] = (from row in dtReportData.AsEnumerable()
                                                    select row.Field<int>(rptField.reportFieldName)).Average().ToString();
                                }
                                else if (surfaceField.surfaceFieldTypeId == (int)pNums.FieldType.Decimal)
                                {
                                    rowFooter[i] = utils.returnFormattedDecimal((from row in dtReportData.AsEnumerable()
                                                                                 select row.Field<decimal>(rptField.reportFieldName)).Average().ToString());
                                }
                                else
                                {
                                    rowFooter[i] = utils.returnFormattedDecimal((from row in dtReportData.AsEnumerable()
                                                                                 select decimal.TryParse(row.Field<string>(rptField.reportFieldName).ToString(), out convertedDec) ? convertedDec : 0m
                                                ).Average().ToString());
                                }
                            }
                            else if (rptField.aggregationType == pNums.AggregateType.sum.GetHashCode())
                            {

                                if (surfaceField.surfaceFieldTypeId == (int)pNums.FieldType.Number)
                                {
                                    rowFooter[i] = (from row in dtReportData.AsEnumerable()
                                                    select row.Field<int>(rptField.reportFieldName)).Sum().ToString();
                                }
                                else if (surfaceField.surfaceFieldTypeId == (int)pNums.FieldType.Decimal)
                                {
                                    rowFooter[i] = utils.returnFormattedDecimal((from row in dtReportData.AsEnumerable()
                                                                                 select row.Field<decimal>(rptField.reportFieldName)).Sum().ToString());
                                }
                                else
                                {
                                    rowFooter[i] = utils.returnFormattedDecimal((from row in dtReportData.AsEnumerable()
                                                                                 select decimal.TryParse(row.Field<string>(rptField.reportFieldName).ToString(), out convertedDec) ? convertedDec : 0m
                                                ).Sum().ToString());
                                }
                            }
                            else if (rptField.aggregationType == pNums.AggregateType.count.GetHashCode())
                            {
                                if (surfaceField.surfaceFieldTypeId == (int)pNums.FieldType.Number)
                                {
                                    rowFooter[i] = (from row in dtReportData.AsEnumerable()
                                                    select row.Field<int>(rptField.reportFieldName)).Count().ToString();
                                }
                                else if (surfaceField.surfaceFieldTypeId == (int)pNums.FieldType.Decimal)
                                {
                                    rowFooter[i] = utils.returnFormattedDecimal((from row in dtReportData.AsEnumerable()
                                                                                 select row.Field<int>(rptField.reportFieldName)).Count().ToString());
                                }
                                else
                                {
                                    rowFooter[i] = utils.returnFormattedDecimal((from row in dtReportData.AsEnumerable()
                                                                                 select decimal.TryParse(row.Field<string>(rptField.reportFieldName).ToString(), out convertedDec) ? convertedDec : 0m
                                                 ).Count().ToString());
                                }
                            }
                        }
                    }

                    rowFooter[0] = "Totals:  " + rowFooter[0].ToString();

                    dtReportFooter.Rows.Add(rowFooter);
                    ViewState["FooterData"] = dtReportFooter;
                }
            }


            //bind grid
            gvReport.DataSource = dtReportData;
            gvReport.DataBind();
            //GR 2017-02-16 Added check for null
            //elevnth hour panic before demo
            if (gvReport.HeaderRow != null)
                gvReport.HeaderRow.TableSection = TableRowSection.TableHeader;
            if (gvReport.FooterRow != null)
                gvReport.FooterRow.TableSection = TableRowSection.TableFooter;
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }


    private void BindReportGridOld(oReport report)
    {
        try
        {
            oSetup _setup = handler.ReturnSetup();

            DataTable dtReportData = new DataTable();
            DataTable dtReportFooter = new DataTable();
            ArrayList reportFields = null;

            //SBF Document checklist report - call stored procedure
            if (_setup.code == "STUD-1" && report.name.Contains("Document"))
            {
                dtReportData = xData.GetTypedTableByProc("recId", typeof(oSurfaceFieldData), "sp_STUD1_GetReportDataDocumentChecklist", new List<oDynamicParam>());

                bool status = true;
                foreach (DataRow row in dtReportData.Rows)
                {
                    foreach (DataColumn col in dtReportData.Columns)
                    {
                        if (col.ColumnName == "Status" || col.ColumnName.EndsWith("Name") || col.ColumnName.EndsWith("Surname"))
                            continue;

                        if (row[col] != null && row[col].ToString() != "Yes" && row[col].ToString() != "N/A")
                        {
                            status = false;
                            break;
                        }
                    }

                    if (row["Status"] != null)
                        row["Status"] = status ? "Yes" : "No";
                }
            }
            else
            {
                reportFields = xData.GetTypedByCriteriaSpecific("recId", typeof(oReportField), "reportId", report.recId.ToString(), "surfaceId");
                if (reportFields == null || reportFields.Count <= 0)
                    return;

                //for now only catering for single surface reports
                int surfaceId = 0;
                //build report table
                foreach (oReportField field in reportFields)
                {
                    if (surfaceId == 0)
                    {
                        //only get surfaceId from first 5 columns, otherwise might get child surface Id
                        if (_setup.code == "STUD-1")
                        {
                            if (field.sequence <= 5)
                                surfaceId = field.surfaceId;
                            //else don't set
                        }
                        else
                        {
                            surfaceId = field.surfaceId;
                        }

                    }

                    dtReportData.Columns.Add(field.reportFieldName);
                    dtReportFooter.Columns.Add(field.reportFieldName);
                }

                //get actions, used for calculating label
                oSurfaceAction divideAction = new oSurfaceAction();
                oSurfaceAction lookupAction = new oSurfaceAction();
                oSurfaceAction aggrSumAction = new oSurfaceAction();
                foreach (oSurfaceAction act in xData.GetTypedCollection("recId", typeof(oSurfaceAction)))
                {
                    if (act.actionType == (int)pNums.ActionType.Calculation)
                    {
                        if (act.action == "Divide")
                            divideAction = act;
                        else if (act.action == "Lookup")
                            lookupAction = act;
                    }
                    else if (act.actionType == (int)pNums.ActionType.Aggregation)
                    {
                        if (act.action == "Sum")
                            aggrSumAction = act;
                    }
                }

                //get surface fields
                ArrayList surfaceFieldsAL = xData.GetTypedByCriteriaSpecific("recId", typeof(oSurfaceField), "surfaceId", surfaceId.ToString());
                List<oSurfaceField> surfaceFields = surfaceFieldsAL.Cast<oSurfaceField>().ToList();

                //get surface data
                DataTable dtSurfaceData = xData.GetSurfaceDataAll(surfaceId, true);
                //loop through surface rows
                foreach (DataRow rowSurface in dtSurfaceData.Rows)
                {
                    //clear viewstate so child data is refreshed
                    if (ViewState["ChildData"] != null)
                        ViewState.Remove("ChildData");

                    DataRow newRow = dtReportData.NewRow();

                    //loop through report fields
                    foreach (oReportField rptField in reportFields)
                    {
                        if (rptField.reportFieldTypeId == pNums.ReportFieldType.Surface.GetHashCode())
                        {
                            //find related surface field
                            foreach (oSurfaceField surfField in surfaceFields)
                            {
                                if (surfField.recId == rptField.surfaceFieldId)
                                {
                                    //find surface data column
                                    foreach (DataColumn colSurface in dtSurfaceData.Columns)
                                    {
                                        if (colSurface.ColumnName == surfField.surfaceFieldName)
                                        {
                                            //if label field but not user or date label, need to calculate it based on source field
                                            if (rowSurface[colSurface.ColumnName].ToString() == "" && surfField.surfaceFieldTypeId == (int)pNums.FieldType.Label && surfField.relationalSurface != "user" && surfField.relationalSurface != "date")
                                            {
                                                int itemId = int.Parse(rowSurface["itemID"].ToString());
                                                newRow[rptField.reportFieldName] = CalculateLabelValue(surfField, itemId, rowSurface, lookupAction, divideAction, aggrSumAction, surfaceFields);
                                            }
                                            else
                                            {
                                                newRow[rptField.reportFieldName] = rowSurface[colSurface.ColumnName].ToString();
                                            }
                                        }
                                    }

                                    break;
                                }
                            }
                        }
                    }

                    dtReportData.Rows.Add(newRow);
                }

            }

            //bind footer
            if (report.enableAggregation)
            {
                DataRow rowFooter = dtReportFooter.NewRow();
                if (reportFields != null && reportFields.Count > 0)
                {
                    decimal convertedDec = 0m;
                    for (int i = 0; i < reportFields.Count; i++)
                    {

                        oReportField rptField = (oReportField)reportFields[i];
                        if (rptField.aggregationType == pNums.AggregateType.average.GetHashCode())
                        {
                            rowFooter[i] = (from row in dtReportData.AsEnumerable()
                                            select decimal.TryParse(row.Field<string>(rptField.reportFieldName), out convertedDec) ? convertedDec : 0m
                                            ).Average().ToString("0.##");
                        }
                        else if (rptField.aggregationType == pNums.AggregateType.sum.GetHashCode())
                        {
                            rowFooter[i] = (from row in dtReportData.AsEnumerable()
                                            select decimal.TryParse(row.Field<string>(rptField.reportFieldName), out convertedDec) ? convertedDec : 0m
                                            ).Sum().ToString("0.##");
                        }
                    }
                }

                rowFooter[0] = "Totals:  " + rowFooter[0].ToString();

                dtReportFooter.Rows.Add(rowFooter);
                ViewState["FooterData"] = dtReportFooter;
            }

            //bind grid
            gvReport.DataSource = dtReportData;
            gvReport.DataBind();
            //GR 2017-02-16 Added check for null
            //elevnth hour panic before demo
            if (gvReport.HeaderRow != null)
                gvReport.HeaderRow.TableSection = TableRowSection.TableHeader;
            if (gvReport.FooterRow != null)
                gvReport.FooterRow.TableSection = TableRowSection.TableFooter;
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }
    #endregion

    #region events

    /// <summary>
    /// Event fires from control base
    /// </summary>
    public void ReloadControl()
    {
        try
        {
            if (this.Report == null)
            {
                lblReportHeading.Text = "Report could not be loaded.";
                pnlResult.Visible = true;
                return;
            }

            lblReportHeading.Text = this.Report.name;            
            if (!this.ReportLoaded)
            {
                BuildFilters(this.Report);
                BindReportGrid(this.Report);
                this.ReportLoaded = true;
            }
                
            divLegend.InnerHtml = BuildReportLegend(this.Report);
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, 0);
            Response.Redirect("/error", false);
        }
    }

    public void SaveControlData() { }

    /// <summary>
    /// Page Load
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void Page_Load(object sender, EventArgs e)
    {
        try
        {
            if (!IsPostBack)
            {
                if (this.Report == null)
                {
                    lblReportHeading.Text = "Report could not be loaded.";
                    pnlResult.Visible = true;
                    return;
                }

                lblReportHeading.Text = this.Report.name;
                if (this.Report.createdBy > 0)
                {
                    BuildFilters(this.Report);
                    BindReportGrid(this.Report);                    
                }
                else//cater for older reports
                    BindReportGridOld(this.Report);


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

    protected void gvReport_RowDataBound(object sender, GridViewRowEventArgs e)
    {
        try
        {

            if (e.Row.RowType == DataControlRowType.Header)
            {
                for (int i = 0; i < e.Row.Cells.Count; i++)
                {
                    TableCell cell = e.Row.Cells[i];

                    if (((System.Web.UI.WebControls.AutoGeneratedField)((System.Web.UI.WebControls.DataControlFieldCell)cell).ContainingField).DataType == typeof(String))
                    {
                        cell.Style.Add("text-align", "left");
                        cell.Style.Add("vertical-align", "middle");
                    }
                    else if (((System.Web.UI.WebControls.AutoGeneratedField)((System.Web.UI.WebControls.DataControlFieldCell)cell).ContainingField).DataType == typeof(int))
                    {
                        cell.Style.Add("text-align", "right");
                        cell.Style.Add("vertical-align", "middle");
                    }
                    else if (((System.Web.UI.WebControls.AutoGeneratedField)((System.Web.UI.WebControls.DataControlFieldCell)cell).ContainingField).DataType == typeof(decimal))
                    {
                        cell.Style.Add("text-align", "right");
                        cell.Style.Add("vertical-align", "middle");


                    }
                }
            }

            if (e.Row.RowType == DataControlRowType.DataRow)
            {
                oSetup _setup = handler.ReturnSetup();
                if (_setup.code == "STUD-1" && this.Report.name.Contains("Document"))
                {
                    for (int i = 0; i < e.Row.Cells.Count; i++)
                    {
                        TableCell cell = e.Row.Cells[i];

                        cell.Style.Add("text-align", "center");
                        cell.Style.Add("vertical-align", "middle");

                        //skip 2nd and 3rd columns
                        if (i > 0 && i < 3)
                            continue;
                        //opacity: 0
                        if (cell.Text == "Yes")
                            cell.Text = "<span style='display:none'>" + cell.Text + "</span>" + "<i class=\"fa fa-check-circle-o palette-edit\" aria-hidden=\"true\" ></i>";
                        else if (cell.Text == "N/A")
                            cell.Text = "<span style='display:none'>" + cell.Text + "</span>" + "<i class=\"fa fa-check-circle-o palette-add\" aria-hidden=\"true\" ></i>";
                        else if (cell.Text == "No")
                            cell.Text = "<span style='display:none'>" + cell.Text + "</span>" + "<i class=\"fa fa-times-circle-o palette-remove\" aria-hidden=\"true\" ></i>";
                        else
                            cell.Text = "<span style='display:none'>" + cell.Text + "</span>" + "<i class=\"fa fa-times-circle-o palette-back\" aria-hidden=\"true\" ></i>";
                    }
                }
                else
                {
                    for (int i = 0; i < e.Row.Cells.Count; i++)
                    {
                        TableCell cell = e.Row.Cells[i];

                        if (((System.Web.UI.WebControls.AutoGeneratedField)((System.Web.UI.WebControls.DataControlFieldCell)cell).ContainingField).DataType == typeof(String))
                        {
                            if (Information.IsNumeric(e.Row.Cells[i].Text))
                            {
                                cell.Style.Add("text-align", "right");
                                cell.Style.Add("vertical-align", "middle");
                            }
                            else
                            {
                                cell.Style.Add("text-align", "left");
                                cell.Style.Add("vertical-align", "middle");
                            }

                        }
                        else if (((System.Web.UI.WebControls.AutoGeneratedField)((System.Web.UI.WebControls.DataControlFieldCell)cell).ContainingField).DataType == typeof(int))
                        {
                            cell.Style.Add("text-align", "right");
                            cell.Style.Add("vertical-align", "middle");
                        }
                        else if (((System.Web.UI.WebControls.AutoGeneratedField)((System.Web.UI.WebControls.DataControlFieldCell)cell).ContainingField).DataType == typeof(decimal))
                        {
                            cell.Style.Add("text-align", "right");
                            cell.Style.Add("vertical-align", "middle");

                            e.Row.Cells[i].Text = utils.returnFormattedDecimal(e.Row.Cells[i].Text);
                        }

                    }

                }
            }

            if (e.Row.RowType == DataControlRowType.Footer)
            {
                if (ViewState["FooterData"] != null)
                {
                    DataTable footerData = (DataTable)ViewState["FooterData"];
                    if (footerData != null && footerData.Rows.Count > 0)
                    {
                        for (int i = 0; i < footerData.Columns.Count; i++)
                        {
                            TableCell cell = e.Row.Cells[i];

                            if (((System.Web.UI.WebControls.AutoGeneratedField)((System.Web.UI.WebControls.DataControlFieldCell)cell).ContainingField).DataType == typeof(String))
                            {
                                cell.Style.Add("text-align", "left");
                                cell.Style.Add("vertical-align", "middle");
                            }
                            else if (((System.Web.UI.WebControls.AutoGeneratedField)((System.Web.UI.WebControls.DataControlFieldCell)cell).ContainingField).DataType == typeof(int))
                            {
                                cell.Style.Add("text-align", "right");
                                cell.Style.Add("vertical-align", "middle");
                            }
                            else if (((System.Web.UI.WebControls.AutoGeneratedField)((System.Web.UI.WebControls.DataControlFieldCell)cell).ContainingField).DataType == typeof(decimal))
                            {
                                cell.Style.Add("text-align", "right");
                                cell.Style.Add("vertical-align", "middle");

                            }
                            cell.Style.Add("font-weight", "bold");
                            e.Row.Cells[i].Text = footerData.Rows[0][i].ToString();
                        }
                    }
                }
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("report:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    #endregion

    /// <summary>
    /// Selected index changed event
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lstFilter_SelectedIndexChanged(object sender, EventArgs e)
    {
        BindReportGrid(this.Report);
    }
}