public ActionResult  Grid_Read([DataSourceRequest] DataSourceRequest request, string id)
        {
            API.Elements.OrderItemController OC = new API.Elements.OrderItemController();
            string[] ids          = id.Split('_');
            var      actionResult = OC.GetScriptOrderItem(Convert.ToInt32(ids[1]));

            ViewBag.OID = id;

            ScriptItemSelector scriptorderitem = (actionResult as OkNegotiatedContentResult <ScriptItemSelector>).Content;

            if (scriptorderitem.LayoutType == "F")
            {
                scriptorderitem.DisplayColumns += string.Format(",{0},{1},{2},{3},{4}", "quantity", "filterKey", "ItemMaxQuantity", "Code", "Total");
            }
            else
            {
                scriptorderitem.DisplayColumns += string.Format(",{0},{1},{2},{3}", "quantity", "filterKey", "ItemMaxQuantity", "Code");
            }

            string[]  columns   = scriptorderitem.DisplayColumns.Split(',');
            DataTable dataTable = BuildDisplayColumnsTable(columns, scriptorderitem, HttpContext.Session);

            if (dataTable.Rows.Count > 0)
            {
                dataTable = dataTable.Select(string.Empty, "Code asc").CopyToDataTable();
            }

            return(Json(dataTable.ToDataSourceResult(request)));
        }
        // PUT api/OrderItem/5
        public IHttpActionResult PutScriptOrderItem(int id, ScriptItemSelector scriptorderitem)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != scriptorderitem.ScriptItemSelectorID)
            {
                return(BadRequest());
            }

            db.Entry(scriptorderitem).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ScriptOrderItemExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(StatusCode(HttpStatusCode.NoContent));
        }
        public IHttpActionResult GetScriptOrderItem(int id)
        {
            ScriptItemSelector scriptorderitem = db.ScriptItemSelectors.Find(id);

            if (scriptorderitem == null)
            {
                return(NotFound());
            }

            return(Ok(scriptorderitem));
        }
        public IHttpActionResult PostScriptOrderItem(ScriptItemSelector scriptorderitem)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            db.ScriptItemSelectors.Add(scriptorderitem);
            db.SaveChanges();

            return(CreatedAtRoute("DefaultApi", new { id = scriptorderitem.ScriptItemSelectorID }, scriptorderitem));
        }
        public IHttpActionResult DeleteScriptOrderItem(int id)
        {
            ScriptItemSelector scriptorderitem = db.ScriptItemSelectors.Find(id);

            if (scriptorderitem == null)
            {
                return(NotFound());
            }

            db.ScriptItemSelectors.Remove(scriptorderitem);
            db.SaveChanges();

            return(Ok(scriptorderitem));
        }
        public List <ScriptItem> GetScriptItems(ScriptItemSelector scriptorderitem)
        {
            string[] Items = System.Text.RegularExpressions.Regex.Split(scriptorderitem.ItemList, ",");

            List <ScriptItem> scriptItems = new List <ScriptItem>();

            API.ItemController itemC = new API.ItemController();

            foreach (string item in Items)
            {
                string[] itemparts = item.Split(new char[] { '\\' });
                switch (itemparts.Length)
                {
                case 1:      //Category Selected
                    scriptItems.AddRange(itemC.GetActiveScriptItems(itemparts[0]));
                    break;

                case 2:
                    scriptItems.AddRange(itemC.GetActiveScriptItems(itemparts[0], itemparts[1]));
                    break;

                case 3:        //Item Selected
                    string[] itempieces = System.Text.RegularExpressions.Regex.Split(itemparts[2], "::");

                    if (itemC.GetActiveScriptItem(itemparts[0], itemparts[1], itempieces[0]) != null)
                    {
                        scriptItems.Add(itemC.GetActiveScriptItem(itemparts[0], itemparts[1], itempieces[0]));
                    }

                    break;

                default:
                    break;
                }
            }

            return(scriptItems);
        }
        public string Render(int?id, bool criticalelement, ControllerContext ContCont)
        {
            API.Elements.OrderItemController OC = new API.Elements.OrderItemController();
            var actionResult = OC.GetScriptOrderItem((int)id);

            if (actionResult != null && actionResult != actionResult as System.Web.Http.Results.NotFoundResult)
            {
                ScriptItemSelector scriptorderitem = (actionResult as OkNegotiatedContentResult <ScriptItemSelector>).Content;

                //scriptorderitem.DisplayColumns += string.Format(",{0},{1},{2},{3}", "quantity", "filterKey", "ItemMaxQuantity", "Code");

                if (criticalelement)
                {
                    ViewBag.OID      = "C_" + scriptorderitem.ScriptItemSelectorID.ToString();
                    ViewBag.Critical = "Y";
                }
                else
                {
                    ViewBag.OID      = "N_" + scriptorderitem.ScriptItemSelectorID.ToString();
                    ViewBag.Critical = "N";
                }

                if (scriptorderitem.LayoutType == "F")
                {
                    scriptorderitem.DisplayColumns += string.Format(",{0},{1},{2},{3},{4}", "quantity", "filterKey", "ItemMaxQuantity", "Code", "Total");
                }
                else
                {
                    scriptorderitem.DisplayColumns += string.Format(",{0},{1},{2},{3}", "quantity", "filterKey", "ItemMaxQuantity", "Code");
                }

                string[]  columns   = scriptorderitem.DisplayColumns.Split(',');
                DataTable dataTable = BuildDisplayColumnsTable(columns, scriptorderitem, ContCont.HttpContext.Session);

                if (dataTable.Rows.Count > 0)
                {
                    dataTable = dataTable.Select(string.Empty, "Code asc").CopyToDataTable();
                }

                //ContCont.HttpContext.Session["DataTable"] = dataTable;

                var Model = new QueryModel();
                Model.Data = dataTable;

                //Column description: Name and Type
                var dyn = new Dictionary <string, System.Type>();
                foreach (System.Data.DataColumn column in Model.Data.Columns)
                {
                    var t = System.Type.GetType(column.DataType.FullName);
                    dyn.Add(column.ColumnName, t);
                }

                Model.Bind = dyn;

                List <ScriptItem> scriptItems = GetScriptItems(scriptorderitem);
                bool   firsttime = true;
                string ilist     = "";

                foreach (ScriptItem scriptItem in scriptItems)
                {
                    if (firsttime)
                    {
                        ilist = scriptItem.ItemCode;
                    }
                    else
                    {
                        ilist = ilist + "~~" + scriptItem.ItemCode;
                    }
                    firsttime = false;
                }

                ViewBag.itemCollection = ilist;
                if (!string.IsNullOrEmpty(scriptorderitem.SetKeys))
                {
                    ViewBag.SetKeys = "Y";
                    criticalelement = true;
                }
                else
                {
                    ViewBag.SetKeys = false;
                }

                if (criticalelement)
                {
                    ViewBag.OID      = "C_" + scriptorderitem.ScriptItemSelectorID.ToString();
                    ViewBag.Critical = "Y";
                }
                else
                {
                    ViewBag.OID      = "N_" + scriptorderitem.ScriptItemSelectorID.ToString();
                    ViewBag.Critical = "N";
                }
                ViewBag.Title = scriptorderitem.SelectorTitle;
                if (scriptItems.Count == 1)
                {
                    return(RenderHelper.RenderViewToString(ContCont, "~/Views/OrderItem/_MultiItemGrid.cshtml", Model, ViewData));
                }
                else if (scriptItems.Count > 1)
                {
                    switch (scriptorderitem.LayoutType)
                    {
                    case "S":
                        return(RenderHelper.RenderViewToString(ContCont, "~/Views/OrderItem/_SelectItem.cshtml", Model, ViewData));

                    case "M":
                        return(RenderHelper.RenderViewToString(ContCont, "~/Views/OrderItem/_SelectMultiItem.cshtml", Model, ViewData));

                    case "F":
                        return(RenderHelper.RenderViewToString(ContCont, "~/Views/OrderItem/_MultiItemGrid.cshtml", Model, ViewData));
                    }
                }
            }

            return("");
        }
        private DataTable BuildDisplayColumnsTable(string[] columns, ScriptItemSelector scriptorderitem, HttpSessionStateBase theSession)
        {
            string            filterkeylist = "";
            DataTable         dataTable     = new DataTable();
            List <ScriptItem> ScriptItems   = GetScriptItems(scriptorderitem);

            List <ItemOrdered> Items = SessionControl.SessionManager.GetItemsOrdered(theSession);

            foreach (ScriptItem sItem in ScriptItems)
            {
                //DisplayOrderItem DOI = new DisplayOrderItem();
                //DOI.OrderItem = sItem;

                DataRow dataRow = dataTable.NewRow();

                foreach (string col in columns)
                {
                    if (!dataTable.Columns.Contains(col))
                    {
                        if (col == "ItemPrice" || col == "ItemShippingPrice" || col == "ItemHandlingPrice")
                        {
                            dataTable.Columns.Add(col, typeof(Double));
                        }
                        else
                        {
                            dataTable.Columns.Add(col);
                        }
                    }

                    if (sItem.GetType().GetProperty(col) != null)
                    {
                        dataRow[col] = sItem.GetType().GetProperty(col).GetValue(sItem, null);
                    }
                    else
                    {
                        foreach (var item in sItem.ScriptItemKeys)
                        {
                            if (col == item.ItemKey)
                            {
                                dataRow[col] = item.ItemValue;
                            }
                        }
                    }
                }

                dataRow["Code"]            = sItem.ItemCode;
                dataRow["ItemMaxQuantity"] = sItem.ItemMaxQuantity;

                if (!string.IsNullOrEmpty(scriptorderitem.FilterKeys))
                {
                    List <string> oicKeys = scriptorderitem.FilterKeys.Split(',').ToList();
                    filterkeylist = "";

                    foreach (var item in oicKeys)
                    {
                        foreach (var itemKey in sItem.ScriptItemKeys)
                        {
                            if (item == itemKey.ItemKey)
                            {
                                if (filterkeylist != "")
                                {
                                    filterkeylist += ",";
                                }
                                filterkeylist += string.Format("{0}:{1}", itemKey.ItemKey, itemKey.ItemValue);
                            }
                        }
                    }

                    dataRow["filterKey"] = filterkeylist;
                }
                else
                {
                    dataRow["filterKey"] = "";
                }

                try
                {
                    string checkcode = sItem.ItemCode;
                    dataRow["quantity"] = "0";

                    foreach (ItemOrdered item in Items)
                    {
                        if (sItem.ItemCode == item.ItemCode)
                        {
                            dataRow["quantity"] = item.ItemQuantity.ToString();
                        }
                    }
                }
                catch
                { }

                if (scriptorderitem.LayoutType == "F")
                {
                    if (sItem.ItemMaxQuantity > 1)
                    {
                        dataRow["Total"] = string.Format("<input type=\"number\" min=\"0\" max=\"{0}\" value=\"{1}\" name=\"SPitemquant_{2}_{3}\" style=\"width: 35px\" />", sItem.ItemMaxQuantity.ToString(), dataRow["quantity"].ToString(), ViewBag.OID, dataRow["Code"].ToString());
                    }
                    else if (sItem.ItemMaxQuantity == 0)
                    {
                        dataRow["Total"] = string.Format("<input type=\"number\" min=\"0\" value=\"{0}\" name=\"SPitemquant_{1}_{2}\" style=\"width: 75px\" />", dataRow["quantity"].ToString(), ViewBag.OID, dataRow["Code"].ToString());
                    }
                    else
                    {
                        dataRow["Total"] = string.Format("<input type=\"checkbox\" name=\"SPitemcheck_{0}_{1}\" {2} />", ViewBag.OID, dataRow["Code"].ToString(), System.Convert.ToBoolean(Convert.ToInt32(dataRow["quantity"])) ? "checked" : string.Empty);
                    }
                }

                if (filterkeylist != "")
                {
                    if (KeyPassedFilter(filterkeylist, SessionControl.SessionManager.ReturnItemKeys(theSession)))
                    {
                        dataTable.Rows.Add(dataRow);
                    }
                }
                else
                {
                    dataTable.Rows.Add(dataRow);
                }
            }

            return(dataTable);
        }