public void Populate(string targetReference)
        {
            MainDataContext db = new MainDataContext();

            if (_DataTableID != 0)
            {
                _DataTable = db._DataTables.Single(f => f.ID == _DataTableID);


                if (!Page.IsPostBack)
                {
                    var questions = _DataTable.CRM_FormFields.Where(f => f.IsActive && !f.IsArchived).OrderBy(f => f.OrderNo);
                    rptQuestions.DataSource = questions;
                    rptQuestions.DataBind();
                }
            }
            else
            {
                this.Visible = false;
            }


            foreach (RepeaterItem item in rptQuestions.Items)
            {
                int           fieldID   = Int32.Parse(((HiddenField)item.FindControl("hdnID")).Value);
                CRM_FormField formField = db.CRM_FormFields.SingleOrDefault(a => a.ID == fieldID);

                CRM.Controls.Admin.CustomFields.Form.CustomField formQuestionControl = (CRM.Controls.Admin.CustomFields.Form.CustomField)item.FindControl("ucFormQuestion");

                IEnumerable <CRM_FormFieldResponse> answers = db.CRM_FormFieldResponses.Where(r => r.CRM_FormFieldID == formField.ID && r.TargetReference == targetReference);

                formQuestionControl.Populate(answers);
            }
        }
        public void ProcessRequest(HttpContext context)
        {
            MainDataContext db = new MainDataContext();

            foreach (CRM_FormFieldAnswer formFieldAnswer in db.CRM_FormFieldAnswers)
            {
                string[] individualAnswerSet = formFieldAnswer.Answer.Split(new string[] { "<br/>" }, StringSplitOptions.RemoveEmptyEntries);

                foreach (string individualAnswer in individualAnswerSet)
                {
                    CRM_FormField     field = formFieldAnswer.CRM_FormField;
                    CRM_FormFieldItem item  = field.CRM_FormFieldItems.FirstOrDefault(f => f.Label == individualAnswer);


                    CRM_FormFieldResponse formFieldResponse = new CRM_FormFieldResponse();
                    formFieldResponse.TargetReference = formFieldAnswer.TargetReference;
                    formFieldResponse.CRM_FormFieldID = field.ID;

                    if (field.Type == (byte)CRM_FormField.Types.SingleLineTextBox || field.Type == (byte)CRM_FormField.Types.MultiLineTextBox || field.Type == (byte)CRM_FormField.Types.SingleCheckBox)
                    {
                        formFieldResponse.Answer = individualAnswer;
                        formFieldResponse.CRM_FormFieldItemID = null;
                        db.CRM_FormFieldResponses.InsertOnSubmit(formFieldResponse);
                        db.SubmitChanges();

                        if (individualAnswerSet.Count() > 1)
                        {
                            HttpContext.Current.Response.Write("multiple answers for single item" + individualAnswerSet.Count() + " on " + formFieldAnswer.ID);
                        }
                    }
                    else
                    {
                        if (item == null)
                        {
                            // this answer doesn't exist as an option, possibly because of the issue we are resolving here (changing parent item doesn't update responses since just a mash of strings).

                            item                 = new CRM_FormFieldItem();
                            item.IsArchived      = true;
                            item.IsActive        = false;
                            item.Label           = individualAnswer;
                            item.OrderNo         = CRM.Code.Utils.Ordering.Ordering.GetNextOrderID(db.CRM_FormFieldItems);
                            item.CRM_FormFieldID = field.ID;
                            db.CRM_FormFieldItems.InsertOnSubmit(item);
                            db.SubmitChanges();
                        }


                        formFieldResponse.Answer = "";
                        formFieldResponse.CRM_FormFieldItemID = item.ID;
                        db.CRM_FormFieldResponses.InsertOnSubmit(formFieldResponse);
                        db.SubmitChanges();
                    }
                }
            }
        }
        public new void Page_PreInit(object sender, EventArgs e)
        {
            base.Page_PreInit(sender, e);

            Entity = db.CRM_FormFields.SingleOrDefault(a => a.ID.ToString() == Request.QueryString["id"]);

            if (Entity == null)
            {
                NoticeManager.SetMessage("Field not found", "/admin/customfields/list.aspx");
            }
        }
        protected void Page_Load(object sender, EventArgs e)
        {
            RunSecurity(CRM.Code.Models.Admin.AllowedSections.NotSet);
            FormField             = db.CRM_FormFields.SingleOrDefault(f => f.ID.ToString() == Request.QueryString["id"]);
            navCustomField.Entity = FormField;
            // buttons //

            btnSubmit.EventHandler        = btnSubmit_Click;
            btnSubmitChanges.EventHandler = btnSubmitChanges_Click;
            btnDelete.EventHandler        = btnDelete_Click;

            // Security //

            btnSubmitChanges.Visible = PermissionManager.CanUpdate;
            btnDelete.Visible        = PermissionManager.CanDelete;
            if (!PermissionManager.CanAdd && FormField == null)
            {
                Response.Redirect("list.aspx");
            }

            // confirmations //

            confirmationDelete.StandardDeleteHidden("item", btnRealDelete_Click);


            // process //

            if (!IsPostBack)
            {
                ddlTable.DataSource = CRM_FormField.DataTableBaseSet(db);
                ddlTable.DataBind();

                ddlType.DataSource = Enumeration.GetAll <CRM_FormField.Types>();
                ddlType.DataBind();

                if (FormField != null)
                {
                    PopulateFields();
                    lnkBack.HRef = "list.aspx?id=" + ddlTable.SelectedValue;
                }
                else
                {
                    ddlTable.SelectedValue = Request.QueryString["sid"];
                }
            }
        }
        protected void SaveRecord(bool newRecord)
        {
            // new record / exiting record //
            if (newRecord)
            {
                FormField         = new CRM_FormField();
                FormField.OrderNo = Ordering.GetNextOrderID(db.CRM_FormFields);
                db.CRM_FormFields.InsertOnSubmit(FormField);
            }

            // common //
            FormField.IsRequired   = chkIsRequired.Checked;
            FormField.Name         = txtName.Text;
            FormField.Type         = byte.Parse(ddlType.SelectedValue);
            FormField.IsActive     = chkIsActive.Checked;
            FormField._DataTableID = Convert.ToInt32(ddlTable.SelectedValue);
            db.SubmitChanges();
        }
        public bool IsValid()
        {
            MainDataContext db      = new MainDataContext();
            bool            isValid = true;

            foreach (RepeaterItem item in rptQuestions.Items)
            {
                int           fieldID   = Int32.Parse(((HiddenField)item.FindControl("hdnID")).Value);
                CRM_FormField formField = db.CRM_FormFields.SingleOrDefault(a => a.ID == fieldID);

                CRM.Controls.Admin.CustomFields.Form.CustomField formQuestionControl = (CRM.Controls.Admin.CustomFields.Form.CustomField)item.FindControl("ucFormQuestion");
                formQuestionControl.CRM_FormField = formField;

                string selectedValue = formQuestionControl.SelectedValue();

                if ((selectedValue == "" || selectedValue == "-1") && formField.IsRequired)
                {
                    ValidationError.AddValidationError(formField.Name + " is required");
                    isValid = false;
                }
            }

            return(isValid);
        }
        protected void lnkSubmit_Click(object sender, EventArgs e)
        {
            if (Page.IsValid)
            {
                MainDataContext db      = new MainDataContext();
                bool            isValid = true;


                foreach (RepeaterItem item in rptQuestions.Items)
                {
                    int           fieldID   = Int32.Parse(((HiddenField)item.FindControl("hdnID")).Value);
                    CRM_FormField formField = db.CRM_FormFields.SingleOrDefault(a => a.ID == fieldID);

                    CRM.Controls.Admin.CustomFields.Form.CustomField formQuestionControl = (CRM.Controls.Admin.CustomFields.Form.CustomField)item.FindControl("ucFormQuestion");
                    formQuestionControl.CRM_FormField = formField;
                    string selectedValue = formQuestionControl.SelectedValue();


                    if ((selectedValue == "" || selectedValue == "-1") && formField.IsRequired)
                    {
                        isValid = false;
                        ValidationError.AddValidationError(formField.Name + " is required");
                    }
                    else
                    {
                        IEnumerable <CRM_FormFieldResponse> answers = db.CRM_FormFieldResponses.Where(r => r.TargetReference == TargetReference && r.CRM_FormFieldID == formField.ID);

                        db.CRM_FormFieldResponses.DeleteAllOnSubmit(answers);
                        db.SubmitChanges();

                        if (formField.Type == (byte)CRM_FormField.Types.DropDownList || formField.Type == (byte)CRM_FormField.Types.MultipleRadioButtons)
                        {
                            CRM_FormFieldResponse response = new CRM_FormFieldResponse()
                            {
                                Answer = "",
                                CRM_FormFieldItemID = db.CRM_FormFieldItems.Single(s => s.ID.ToString() == selectedValue).ID,
                                CRM_FormFieldID     = formField.ID,
                                TargetReference     = TargetReference
                            };

                            db.CRM_FormFieldResponses.InsertOnSubmit(response);
                            db.SubmitChanges();
                        }
                        else if (formField.Type == (byte)CRM_FormField.Types.MultiLineTextBox || formField.Type == (byte)CRM_FormField.Types.SingleLineTextBox || formField.Type == (byte)CRM_FormField.Types.SingleCheckBox)
                        {
                            CRM_FormFieldResponse response = new CRM_FormFieldResponse()
                            {
                                Answer = selectedValue,
                                CRM_FormFieldItemID = null,
                                CRM_FormFieldID     = formField.ID,
                                TargetReference     = TargetReference
                            };

                            db.CRM_FormFieldResponses.InsertOnSubmit(response);
                            db.SubmitChanges();
                        }
                        else if (formField.Type == (byte)CRM_FormField.Types.MultipleCheckBoxes)
                        {
                            string[] IDs = selectedValue.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

                            foreach (string id in IDs)
                            {
                                CRM_FormFieldResponse response = new CRM_FormFieldResponse();

                                response.Answer = "";
                                response.CRM_FormFieldItemID = db.CRM_FormFieldItems.Single(s => s.ID.ToString() == id).ID;
                                response.CRM_FormFieldID     = formField.ID;
                                response.TargetReference     = TargetReference;

                                db.CRM_FormFieldResponses.InsertOnSubmit(response);
                                db.SubmitChanges();
                            }
                        }
                    }
                }


                if (isValid)
                {
                    db.SubmitChanges();
                }
            }
        }