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

public partial class controls_admin_canvas : System.Web.UI.UserControl
{
    private const string controlPath = "~/controls/";
    private const string compositePath = "~/controls/composite/";

    #region methods

    /// <summary>
    /// Method to Bind Canvas Data
    /// </summary>
    private void BindCanvasData()
    {
        int parentId = 0;
        try
        {
            if (utils.verifySession("parentId"))
                parentId = int.Parse(Session["parentId"].ToString());

            ArrayList canvasList = xData.GetTypedByCriteriaSpecific("recId", typeof(oCanvas), "parentId,isActive", "" + parentId + ",1", "sequence");
            rptCanvasPages.DataSource = canvasList;
            rptCanvasPages.DataBind();
        }
        catch (Exception ex)
        {
            exception.HandleException("canvas:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Bind Content Pages
    /// </summary>
    private void BindContentPages()
    {
        try
        {
            ArrayList contentPages = xData.GetTypedByCriteriaSpecific("recId", typeof(oContent), "isActive", "1", "sequence");
            ddContentPages.DataSource = contentPages;
            ddContentPages.DataTextField = "title";
            ddContentPages.DataValueField = "recId";

            ddContentPages.DataBind();

            ddContentPages.Items.Insert(0, new ListItem("Select Content", "0"));

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

    /// <summary>
    /// Bind Surface Apps
    /// </summary>
    private void BindSurfaceApps()
    {
        try
        {
            ArrayList surfaceApps = xData.GetTypedByCriteriaSpecific("recId", typeof(oSurface), "isActive", "1", "surface");
            ddSurfaceApps.DataSource = surfaceApps;
            ddSurfaceApps.DataTextField = "surface";
            ddSurfaceApps.DataValueField = "recId";

            ddSurfaceApps.DataBind();

            ddSurfaceApps.Items.Insert(0, new ListItem("Select Surface", "0"));

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

    /// <summary>
    /// Bind Promotions
    /// </summary>
    private void BindPromotions()
    {
        try
        {
            ArrayList promotions = xData.GetTypedByCriteriaSpecific("recId", typeof(oPromotion), "isActive", "1", "title");
            ddPromotions.DataSource = promotions;
            ddPromotions.DataTextField = "title";
            ddPromotions.DataValueField = "recId";

            ddPromotions.DataBind();

            ddPromotions.Items.Insert(0, new ListItem("Select Promotion", "0"));

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

    /// <summary>
    /// Bind Surface Apps
    /// </summary>
    private void BindReports()
    {
        try
        {
            ArrayList reports = xData.GetTypedByCriteriaSpecific("recId", typeof(oReport), "isActive", "1", "display");
            ddReports.DataSource = reports;
            ddReports.DataTextField = "display";
            ddReports.DataValueField = "recId";

            ddReports.DataBind();

            ddReports.Items.Insert(0, new ListItem("Select Report", "0"));

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

    /// <summary>
    /// Bind Parent Pages
    /// </summary>
    private void BindParentCanvasPages()
    {
        try
        {
            /* CVH 2016-04-05 Multi level menu not workingcorrectly. When adding canvas to 3rd level or lower, only load current parent Id in Parent list. */

            ddParent.ClearSelection();

            int parentId = 0;
            if (utils.verifySession("parentId"))
                parentId = int.Parse(Session["parentId"].ToString());

            ArrayList parentPages = new ArrayList();

            if (parentId == 0)
                parentPages = xData.GetTypedByCriteriaSpecific("recId", typeof(oCanvas), "isActive,parentId", "1,0", "sequence");
            else
                parentPages = xData.GetTypedByCriteriaSpecific("recId", typeof(oCanvas), "recId", parentId.ToString());

            ddParent.DataSource = parentPages;
            ddParent.DataTextField = "display";
            ddParent.DataValueField = "recId";

            ddParent.DataBind();

            if (parentId == 0)
                ddParent.Items.Insert(0, new ListItem("Main Parent Page", "0"));
        }
        catch (Exception ex)
        {
            exception.HandleException("canvas:", MethodBase.GetCurrentMethod().Name, ex, 0);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Bind Canvas Types
    /// </summary>
    private void BindCanvasTypes()
    {
        try
        {
            ArrayList modules = xData.GetTypedByCriteriaSpecific("recId", typeof(oModule), "isCanvas", "1", "sequence");
            ddCanvasType.DataSource = modules;
            ddCanvasType.DataTextField = "module";
            ddCanvasType.DataValueField = "recId";

            ddCanvasType.DataBind();
            ddCanvasType.Items.Insert(0, new ListItem("Choose a module", "0"));
        }
        catch (Exception ex)
        {
            exception.HandleException("canvas:", MethodBase.GetCurrentMethod().Name, ex, 0);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Bind User Types
    /// </summary>
    private void BindUserTypes()
    {
        try
        {
            ArrayList userTypes = xData.GetTypedByCriteriaSpecific("recId", typeof(oUserType), "isActive", "1", "sequence");
            oUserType publicUser = new oUserType();
            publicUser.recId = 0;
            publicUser.userType = "Public User";

            userTypes.Insert(0, publicUser);

            lstUserTypes.DataSource = userTypes;
            lstUserTypes.DataTextField = "userType";
            lstUserTypes.DataValueField = "recId";
            lstUserTypes.DataBind();
        }
        catch (Exception ex)
        {
            exception.HandleException("canvas:", MethodBase.GetCurrentMethod().Name, ex, 0);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Method to Bind the slide Order Drop down
    /// </summary>
    private void BindSequence()
    {
        try
        {
            for (int i = 0; i < 20; i++)
            {
                //append sequence item                
                ddSequence.Items.Add(new ListItem(i.ToString(), i.ToString()));
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("canvas:", MethodBase.GetCurrentMethod().Name, ex, 0);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Populate Form Values
    /// </summary>
    /// <param name="_canvas"></param>
    private void PopulatePageFormValues(ref oCanvas _canvas)
    {
        try
        {
            txtAnalyticsCode.Value = _canvas.seoAnalyticsCode;
            txtDescription.Value = _canvas.description;
            txtExternal.Value = _canvas.externalPath;
            txtName.Value = _canvas.display;
            txtSeoDescription.Value = _canvas.seoDescription;
            txtSeoKeywords.Value = _canvas.seoKeywords;
            txtSeoTitle.Value = _canvas.seoTitle;

            txtSummary.Value = _canvas.summary;
            chkSummary.Checked = _canvas.isSummary;

            chkIsExternal.Checked = _canvas.isExternal;
            chkVisible.Checked = _canvas.isVisible;
            chkVisibleFooter.Checked = _canvas.isVisibleFooter;
            chkIsComposite.Checked = _canvas.isComposite;
            chkIsDefaultToForm.Checked = _canvas.isDefaultToForm;
            chkIsRightAligned.Checked = _canvas.isRightAligned;
            chkIsAccessible.Checked = _canvas.isAccessible;
            chklPanelShown.Checked = _canvas.isPanelShown;
            chkSecure.Checked = _canvas.isSecureLandingPage;
            chkHideNav.Checked = _canvas.hideNavigation;

            if (ddParent.Items.FindByValue(_canvas.parentId.ToString()) != null)
                ddParent.SelectedValue = _canvas.parentId.ToString();

            if (_canvas.sequence > 0)
                ddSequence.SelectedValue = _canvas.sequence.ToString();

            //get Canvas Meta
            foreach (oCanvasMetaData met in xData.GetTypedByCriteriaSpecific("recId", typeof(oCanvasMetaData), "canvasId,isActive", _canvas.recId + ",1", "sequence"))
            {
                if (ddCanvasType.Items.FindByValue(met.moduleId.ToString()) != null)
                    ddCanvasType.SelectedValue = met.moduleId.ToString();

                //handle selection of canvas type modules

                //CVH 2017-01-20 Add module Report
                pNums.Module mod = (pNums.Module)Enum.ToObject(typeof(pNums.Module), int.Parse(ddCanvasType.SelectedValue));
                switch (mod)
                {
                    case pNums.Module.Content:
                        if (ddContentPages.Items.FindByValue(met.entityId.ToString()) != null)
                            ddContentPages.SelectedValue = met.entityId.ToString();
                        break;
                    case pNums.Module.Surface:
                        if (ddSurfaceApps.Items.FindByValue(met.entityId.ToString()) != null)
                            ddSurfaceApps.SelectedValue = met.entityId.ToString();
                        break;
                    case pNums.Module.Report:
                        if (ddReports.Items.FindByValue(met.entityId.ToString()) != null)
                            ddReports.SelectedValue = met.entityId.ToString();
                        break;
                    case pNums.Module.Promotions:
                        if (ddPromotions.Items.FindByValue(met.entityId.ToString()) != null)
                            ddPromotions.SelectedValue = met.entityId.ToString();
                        break;
                }
            }


            lstUserTypes.ClearSelection();
            if (_canvas.userTypes != String.Empty)
            {
                string[] types = _canvas.userTypes.Split(char.Parse(","));
                foreach (string type in types)
                {
                    foreach (ListItem item in lstUserTypes.Items)
                    {
                        if (item.Value == type)
                        {
                            item.Selected = true;
                            break;
                        }
                    }
                }
            }

            ToggleCanvasType();

        }
        catch (Exception ex)
        {
            exception.HandleException("canvas:", MethodBase.GetCurrentMethod().Name, ex, 0);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Save Form Values
    /// </summary>
    /// <param name="_canvas"></param>
    private void SavePageFormValues(ref oCanvas _canvas)
    {
        try
        {
            _canvas.seoAnalyticsCode = txtAnalyticsCode.Value;
            _canvas.description = txtDescription.Value;
            _canvas.externalPath = txtExternal.Value;
            _canvas.display = txtName.Value;
            _canvas.name = utils.stripCharacters(txtName.Value).Replace(" ", "~");
            _canvas.seoDescription = txtSeoDescription.Value;
            _canvas.seoKeywords = txtSeoKeywords.Value;
            _canvas.seoTitle = txtSeoTitle.Value;
            _canvas.isExternal = chkIsExternal.Checked;
            _canvas.isDefaultToForm = chkIsDefaultToForm.Checked;
            _canvas.isRightAligned = chkIsRightAligned.Checked;
            _canvas.isVisible = chkVisible.Checked;
            _canvas.isVisibleFooter = chkVisibleFooter.Checked;
            _canvas.isComposite = chkIsComposite.Checked;
            _canvas.isAccessible = chkIsAccessible.Checked;
            _canvas.isPanelShown = chklPanelShown.Checked;
            _canvas.isSecureLandingPage = chkSecure.Checked;
            _canvas.hideNavigation = chkHideNav.Checked;
            _canvas.parentId = int.Parse(ddParent.SelectedValue);
            _canvas.sequence = int.Parse(ddSequence.SelectedValue);
            _canvas.summary = txtSummary.Value;
            _canvas.isSummary = chkSummary.Checked;
            _canvas.userTypes = String.Empty;
            //save user types
            foreach (ListItem item in lstUserTypes.Items)
            {
                if (item.Selected)
                {
                    if (_canvas.userTypes == String.Empty)
                    { _canvas.userTypes = item.Value.ToString(); }
                    else
                    { _canvas.userTypes += "," + item.Value; }
                }
            }

            if (_canvas.userTypes != String.Empty)
            { _canvas.isRestricted = true; }
            else
            { _canvas.isRestricted = false; }

        }
        catch (Exception ex)
        {
            exception.HandleException("canvas:", MethodBase.GetCurrentMethod().Name, ex, 0);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Method to Toggle Panels
    /// </summary>
    /// <param name="panelName"></param>
    private void TogglePanels(string panelName)
    {
        switch (panelName)
        {
            case "pnlCanvasPage":
                pnlCanvasPage.Visible = true;
                pnlCanvasList.Visible = false;
                break;
            case "pnlCanvasList":
                pnlCanvasPage.Visible = false;
                pnlCanvasList.Visible = true;
                break;
        }

        //clear result
        pnlResult.Visible = false;
    }


    /// <summary>
    /// Method to Toggle Panels
    /// </summary>
    /// <param name="panelName"></param>
    private void ToggleCanvasType()
    {
        pNums.Module mod = (pNums.Module)Enum.ToObject(typeof(pNums.Module), int.Parse(ddCanvasType.SelectedValue));
        switch (mod)
        {
            case pNums.Module.Content:
                pnlSelectContentPage.Visible = true;
                pnlSelectSurface.Visible = false;
                pnlSelectReport.Visible = false;
                //pnlSelectPromotion.Visible = false;
                break;
            case pNums.Module.Surface:
                pnlSelectSurface.Visible = true;
                pnlSelectContentPage.Visible = false;
                pnlSelectReport.Visible = false;
                //pnlSelectPromotion.Visible = false;
                break;
            case pNums.Module.Report:
                pnlSelectSurface.Visible = false;
                pnlSelectReport.Visible = true;
                pnlSelectContentPage.Visible = false;
                break;
            case pNums.Module.Promotions:
                pnlSelectSurface.Visible = false;
                pnlSelectContentPage.Visible = false;
                pnlSelectReport.Visible = false;
                //pnlSelectPromotion.Visible = true;
                break;
            default:
                pnlSelectContentPage.Visible = false;
                pnlSelectSurface.Visible = false;
                pnlSelectReport.Visible = false;
                //pnlSelectPromotion.Visible = false;
                break;
        }
    }

    #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)
            {
                Session["parentId"] = 0;
                BindCanvasData();
                BindParentCanvasPages();
                BindContentPages();
                BindSurfaceApps();
                BindPromotions();
                BindReports();
                BindCanvasTypes();
                BindUserTypes();
                BindSequence();
            }

        }
        catch (Exception ex)
        {
            exception.HandleException("canvas:", 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 rptCanvasPages_ItemDataBound(object sender, RepeaterItemEventArgs e)
    {
        try
        {
            LinkButton lnkParent = (LinkButton)e.Item.FindControl("lnkParent");
            LinkButton lnkChildren = (LinkButton)e.Item.FindControl("lnkChildren");
            if (lnkChildren != null && lnkParent != null)
            {
                if (Session["parentId"].ToString() == "0")
                {
                    lnkParent.Visible = false;
                }
                int parentId = int.Parse(lnkChildren.CommandArgument);
                ArrayList subItems = xData.GetTypedByCriteriaSpecific("recId", typeof(oCanvas), "parentId", parentId.ToString());
                lnkChildren.Text = "<span class=\"badge\">" + subItems.Count + "</span>";
            }

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


    /// <summary>
    /// New Canvas Click
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnNewCanvas_Click(object sender, EventArgs e)
    {
        try
        {
            //show Content Specific
            TogglePanels("pnlCanvasPage");
            Session["canvasId"] = 0;
            utils.disposeSession("canvas");
            oCanvas canvas = new oCanvas();
            /* CVH 2016-04-18 Default isAccessible to true */
            canvas.isAccessible = true;
            BindParentCanvasPages();
            PopulatePageFormValues(ref canvas);
            chkVisible.Checked = true;
            /* CVH 2016-04-05 Check if parent is in list before trying to select it. Also rebind the drop down */
            //if (utils.verifySession("parentId"))
            if (utils.verifySession("parentId") && ddParent.Items.FindByValue(Session["parentId"].ToString()) != null)
            {
                ddParent.SelectedValue = Session["parentId"].ToString();
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("canvas:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }


    /// <summary>
    /// Edit the canvas page
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lnkEdit_Click(object sender, EventArgs e)
    {
        oCanvas _canvas = new oCanvas();
        ArrayList canvasList = new ArrayList();
        try
        {
            if (sender.GetType() == typeof(LinkButton))
            {
                //
                int recId = int.Parse(((LinkButton)sender).CommandArgument);
                if (recId > 0)
                {
                    Session["canvasId"] = recId;
                    //get page
                    canvasList = xData.GetTypedByCriteriaSpecific("recId", typeof(oCanvas), "recId", recId.ToString());
                    //enumerate list
                    foreach (oCanvas cnv in canvasList)
                    {
                        //assign object
                        _canvas = cnv;
                        /* CVH 2016-04-13 Rebind parent canvas drop down, page level may have changed */
                        BindParentCanvasPages();
                        //populate page form
                        PopulatePageFormValues(ref _canvas);
                        Session["canvas"] = _canvas;
                        break;
                    }

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

    /// <summary>
    /// Remove the Canvas page
    /// </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);
                //Delete page
                if (xData.DeleteTyped("recId", recId.ToString(), typeof(oCanvas)))
                {
                    //remove any metaData
                    xData.DeleteTyped("canvasId", recId.ToString(), typeof(oCanvasMetaData));

                    if (Session["parentId"].ToString() != "0")
                    {
                        ArrayList children = xData.GetTypedByCriteriaSpecific("recId", typeof(oCanvas), "parentId", Session["parentId"].ToString());
                        if (children.Count == 0)
                            Session["parentId"] = 0;
                    }

                    //rebind pages grid
                    BindCanvasData();
                    BindParentCanvasPages();
                    pnlResult.Visible = true;
                    //display successful result
                    lblResult.Text = "the selected canvas was deleted successfully.";
                }
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("canvas:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Cancel
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnCancel_Click(object sender, EventArgs e)
    {
        try
        {
            Session["canvasId"] = 0;
            utils.disposeSession("canvas");




            BindCanvasData();
            //show canvas list
            TogglePanels("pnlCanvasList");
        }
        catch (Exception ex)
        {
            exception.HandleException("canvas:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Save Click
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnSave_Click(object sender, EventArgs e)
    {
        oCanvas canvas = new oCanvas();
        try
        {
            if (utils.verifySession("canvas"))//update mode
            {
                canvas = (oCanvas)Session["canvas"];
                canvas.dateUpdated = DateTime.Now;
                //save form values
                SavePageFormValues(ref canvas);
                if (xData.UpdateTyped("recId", canvas.recId.ToString(), typeof(oCanvas), canvas))
                {
                    Session["canvasId"] = canvas.recId;
                    Session["canvas"] = canvas;
                    //remove any metaData
                    xData.DeleteTyped("canvasId", canvas.recId.ToString(), typeof(oCanvasMetaData));
                    BindCanvasData();
                    pnlResult.Visible = true;
                    lblResult.Text = "your changes were updated successfully.";
                }
            }
            else
            {
                if (!xData.VerifyExists("recId", typeof(oCanvas), "display", txtName.Value))
                {

                    canvas.isActive = true;
                    canvas.dateCreated = DateTime.Now;
                    canvas.dateUpdated = DateTime.Now;
                    //save form values
                    SavePageFormValues(ref canvas);
                    canvas.recId = xData.SaveTyped("recId", typeof(oCanvas), canvas);
                    if (canvas.recId > 0)
                    {
                        Session["canvasId"] = canvas.recId;
                        Session["canvas"] = canvas;

                        BindCanvasData();

                        pnlResult.Visible = true;
                        lblResult.Text = "your canvas was created successfully.";
                    }
                }
                else
                {
                    pnlResult.Visible = true;
                    lblResult.Text = "A Page Canvas with this name already exists on the system";
                }
            }
            if (canvas.recId > 0)
            {
                oCanvasMetaData meta = new oCanvasMetaData();
                meta.canvasId = canvas.recId;
                meta.isActive = true;
                if (ddCanvasType.SelectedValue != String.Empty)
                    meta.moduleId = int.Parse(ddCanvasType.SelectedValue);

                pNums.Module mod = (pNums.Module)Enum.ToObject(typeof(pNums.Module), int.Parse(ddCanvasType.SelectedValue));
                switch (mod)
                {
                    case pNums.Module.Content:
                        if (ddContentPages.SelectedValue != String.Empty)
                            meta.entityId = int.Parse(ddContentPages.SelectedValue);
                        break;
                    case pNums.Module.Surface:
                        if (ddSurfaceApps.SelectedValue != String.Empty)
                            meta.entityId = int.Parse(ddSurfaceApps.SelectedValue);
                        break;
                    case pNums.Module.Report:
                        if (ddReports.SelectedValue != String.Empty)
                            meta.entityId = int.Parse(ddReports.SelectedValue);
                        break;
                    case pNums.Module.Promotions:
                        if (ddPromotions.SelectedValue != String.Empty)
                            meta.entityId = int.Parse(ddPromotions.SelectedValue);
                        break;
                }

                meta.sequence = 1;
                meta.recId = xData.SaveTyped("recId", typeof(oCanvasMetaData), meta);

                //composite stuff
                if (canvas.isComposite)
                {
                    CreateComposite(canvas);
                }
                else
                {
                    if (canvas.parentId > 0)
                    {
                        foreach (oCanvas parentCanvas in xData.GetTypedByCriteriaSpecific("recId", typeof(oCanvas), "recId", canvas.parentId.ToString()))
                        {
                            if (parentCanvas.isComposite)
                            {
                                CreateComposite(parentCanvas);
                            }
                        }
                    }
                }
            }

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

    private static void CreateComposite(oCanvas canvas)
    {
        oComposite composite = new oComposite();
        foreach (oComposite comp in xData.GetTypedByCriteriaSpecific("recId", typeof(oComposite), "canvasId", canvas.recId.ToString()))
        {
            composite = comp;
        }
        composite.canvasId = canvas.recId;
        composite.name = canvas.name;
        composite.composite = canvas.display;
        if (composite.recId > 0)
            xData.UpdateTyped("recId", composite.recId.ToString(), typeof(oComposite), composite);
        else
        {
            composite.dateCreated = DateTime.Now;
            xData.SaveTyped("recId", typeof(oComposite), composite);
        }
        compositeHandler.BuildCompositeTemplate(composite, compositePath + "composite.ascx", compositePath, true);
    }

    /// <summary>
    /// View Children Pages
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lnkChildren_Click(object sender, EventArgs e)
    {
        try
        {
            if (sender.GetType() == typeof(LinkButton))
            {
                //
                int parentId = int.Parse(((LinkButton)sender).CommandArgument);
                Session["parentId"] = parentId;
                BindCanvasData();

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

    /// <summary>
    /// View Parent Pages
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lnkParent_Click(object sender, EventArgs e)
    {
        try
        {
            if (sender.GetType() == typeof(LinkButton))
            {
                //
                int parentId = int.Parse(((LinkButton)sender).CommandArgument);

                if (parentId > 0)
                {
                    foreach (oCanvas parentCat in xData.GetTypedByCriteriaSpecific("recId", typeof(oCanvas), "recID", parentId.ToString()))
                    {
                        Session["parentId"] = parentCat.parentId;
                        break;
                    }
                }
                BindCanvasData();
            }
        }
        catch (Exception ex)
        {
            exception.HandleException("canvas:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    /// <summary>
    /// Canavas Type Selection Changed
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void ddCanvasType_SelectedIndexChanged(object sender, EventArgs e)
    {
        try
        {
            ToggleCanvasType();
        }
        catch (Exception ex)
        {
            exception.HandleException("canvas:", MethodBase.GetCurrentMethod().Name, ex, Session["user"]);
            Response.Redirect("/error", false);
        }
    }

    #endregion

}