public ActionResult DeleteConfirmed(ReasonViewModel vm)
        {
            if (ModelState.IsValid)
            {
                List <LogTypeViewModel> LogList = new List <LogTypeViewModel>();

                db.Configuration.AutoDetectChangesEnabled = false;
                var temp = _MaterialPlanCancelHeaderService.Find(vm.id);

                int status = temp.Status;

                LogList.Add(new LogTypeViewModel
                {
                    ExObj = temp,
                });

                var MaterialPlanCancelline = new MaterialPlanCancelLineService(_unitOfWork).GetMaterialPlanCancelForDelete(vm.id).ToList();

                List <ProdOrderCancelLine>      ProdOrderCancelLines      = new List <ProdOrderCancelLine>();
                List <PurchaseIndentCancelLine> PurchaseIndentCancelLines = new List <PurchaseIndentCancelLine>();


                foreach (var item in MaterialPlanCancelline)
                {
                    //Deleting MaterialPlanCancelforSaleOrder
                    var MaterialPlanCancelForSaleOrder = new MaterialPlanCancelForSaleOrderService(_unitOfWork).GetMaterialPlanCancelForSaleOrderForMaterialPlanCancelline(item.MaterialPlanCancelLineId).ToList();
                    foreach (var item2 in MaterialPlanCancelForSaleOrder)
                    {
                        LogList.Add(new LogTypeViewModel
                        {
                            ExObj = item2,
                        });

                        item2.ObjectState = Model.ObjectState.Deleted;
                        //new MaterialPlanCancelForSaleOrderService(_unitOfWork).Delete(item2);
                        db.MaterialPlanCancelForSaleOrder.Attach(item2);
                        db.MaterialPlanCancelForSaleOrder.Remove(item2);
                    }

                    //Deleting MaterialPlanCancelForProdOrderLine
                    var MaterialPlanCancelForProdOrderLine = new MaterialPlanCancelForProdOrderLineService(_unitOfWork).GetMaterialPlanCancelForProdORderForMaterialPlanCancel(item.MaterialPlanCancelLineId).ToList();
                    foreach (var item2 in MaterialPlanCancelForProdOrderLine)
                    {
                        LogList.Add(new LogTypeViewModel
                        {
                            ExObj = item2,
                        });

                        item2.ObjectState = Model.ObjectState.Deleted;
                        //new MaterialPlanCancelForProdOrderLineService(_unitOfWork).Delete(item2.MaterialPlanCancelForProdOrderLineId);
                        db.MaterialPlanCancelForProdOrderLine.Attach(item2);
                        db.MaterialPlanCancelForProdOrderLine.Remove(item2);
                    }

                    //new MaterialPlanCancelLineService(_unitOfWork).Delete(item.MaterialPlanCancelLineId);

                    //MaterialPlanCancelLine Si = (MaterialPlanCancelLine) item;



                    ProdOrderCancelLines = new ProdOrderCancelLineService(_unitOfWork).GetProdOrderCancelLineForMaterialPlanCancel(item.MaterialPlanCancelLineId).ToList();

                    foreach (var item2 in ProdOrderCancelLines)
                    {
                        LogList.Add(new LogTypeViewModel
                        {
                            ExObj = item2,
                        });

                        item2.ObjectState = Model.ObjectState.Deleted;
                        db.ProdOrderCancelLine.Attach(item2);
                        db.ProdOrderCancelLine.Remove(item2);
                    }

                    PurchaseIndentCancelLines = new PurchaseIndentCancelLineService(_unitOfWork).GetPurchaseIndentCancelLineForMaterialPlanCancel(item.MaterialPlanCancelLineId).ToList();

                    foreach (var item2 in PurchaseIndentCancelLines)
                    {
                        LogList.Add(new LogTypeViewModel
                        {
                            ExObj = item2,
                        });

                        item2.ObjectState = Model.ObjectState.Deleted;
                        db.PurchaseIndentCancelLine.Attach(item2);
                        db.PurchaseIndentCancelLine.Remove(item2);
                    }



                    MaterialPlanCancelLine MPL = new MaterialPlanCancelLineService(_unitOfWork).Find(item.MaterialPlanCancelLineId);

                    LogList.Add(new LogTypeViewModel
                    {
                        ExObj = MPL,
                    });

                    MPL.ObjectState = Model.ObjectState.Deleted;

                    db.MaterialPlanCancelLine.Attach(MPL);
                    db.MaterialPlanCancelLine.Remove(MPL);
                }

                //Deleting MaterialPlanCancelForProdORder
                var MaterialPlanCancelForProdOrder = new MaterialPlanCancelForProdOrderService(_unitOfWork).GetMaterialPlanCancelForProdORderForMaterialPlanCancel(vm.id).ToList();
                foreach (var item2 in MaterialPlanCancelForProdOrder)
                {
                    LogList.Add(new LogTypeViewModel
                    {
                        ExObj = item2,
                    });

                    item2.ObjectState = Model.ObjectState.Deleted;
                    //new MaterialPlanCancelForProdOrderService(_unitOfWork).Delete(item2);
                    db.MaterialPlanCancelForProdOrder.Attach(item2);
                    db.MaterialPlanCancelForProdOrder.Remove(item2);
                }



                ProdOrderCancelHeader ProdOrderCancelHeaders = new ProdOrderCancelHeaderService(_unitOfWork).GetProdOrderCancelForMaterialPlan(vm.id);


                LogList.Add(new LogTypeViewModel
                {
                    ExObj = ProdOrderCancelHeaders,
                });

                ProdOrderCancelHeaders.ObjectState = Model.ObjectState.Deleted;
                // new ProdOrderHeaderService(_unitOfWork).Delete(item2.ProdOrderHeaderId);
                db.ProdOrderCancelHeader.Attach(ProdOrderCancelHeaders);
                db.ProdOrderCancelHeader.Remove(ProdOrderCancelHeaders);



                temp.ObjectState = Model.ObjectState.Deleted;
                // _MaterialPlanCancelHeaderService.Delete(temp);
                db.MaterialPlanCancelHeader.Attach(temp);
                db.MaterialPlanCancelHeader.Remove(temp);

                XElement Modifications = new ModificationsCheckService().CheckChanges(LogList);

                try
                {
                    // _unitOfWork.Save();
                    db.SaveChanges();
                    db.Configuration.AutoDetectChangesEnabled = true;
                }

                catch (Exception ex)
                {
                    string message = _exception.HandleException(ex);
                    TempData["CSEXC"] += message;
                    return(PartialView("_Reason", vm));
                }

                LogActivity.LogActivityDetail(LogVm.Map(new ActiivtyLogViewModel
                {
                    DocTypeId       = temp.DocTypeId,
                    DocId           = temp.MaterialPlanCancelHeaderId,
                    ActivityType    = (int)ActivityTypeContants.Deleted,
                    UserRemark      = vm.Reason,
                    DocNo           = temp.DocNo,
                    xEModifications = Modifications,
                    DocDate         = temp.DocDate,
                    DocStatus       = temp.Status,
                }));

                return(Json(new { success = true }));
            }
            return(PartialView("_Reason", vm));
        }
        public ActionResult GeneratePrints(string Ids, int DocTypeId)
        {
            if (!string.IsNullOrEmpty(Ids))
            {
                int SiteId     = (int)System.Web.HttpContext.Current.Session["SiteId"];
                int DivisionId = (int)System.Web.HttpContext.Current.Session["DivisionId"];

                var Settings = new MaterialPlanCancelLineService(_unitOfWork).GetMaterialPlanSettingsForDocument(DocTypeId, DivisionId, SiteId);

                if (new RolePermissionService(_unitOfWork).IsActionAllowed(UserRoles, DocTypeId, null, this.ControllerContext.RouteData.Values["controller"].ToString(), "GeneratePrints") == false)
                {
                    return(View("~/Views/Shared/PermissionDenied.cshtml").Warning("You don't have permission to do this task."));
                }

                try
                {
                    List <byte[]> PdfStream = new List <byte[]>();
                    foreach (var item in Ids.Split(',').Select(Int32.Parse))
                    {
                        DirectReportPrint drp = new DirectReportPrint();

                        var pd = db.MaterialPlanCancelHeader.Find(item);

                        LogActivity.LogActivityDetail(LogVm.Map(new ActiivtyLogViewModel
                        {
                            DocTypeId    = pd.DocTypeId,
                            DocId        = pd.MaterialPlanCancelHeaderId,
                            ActivityType = (int)ActivityTypeContants.Print,
                            DocNo        = pd.DocNo,
                            DocDate      = pd.DocDate,
                            DocStatus    = pd.Status,
                        }));

                        byte[] Pdf;

                        if (pd.Status == (int)StatusConstants.Drafted || pd.Status == (int)StatusConstants.Import || pd.Status == (int)StatusConstants.Modified)
                        {
                            //LogAct(item.ToString());
                            Pdf = drp.DirectDocumentPrint(Settings.SqlProcDocumentPrint, User.Identity.Name, item);

                            PdfStream.Add(Pdf);
                        }
                        else if (pd.Status == (int)StatusConstants.Submitted || pd.Status == (int)StatusConstants.ModificationSubmitted)
                        {
                            Pdf = drp.DirectDocumentPrint(Settings.SqlProcDocumentPrint, User.Identity.Name, item);

                            PdfStream.Add(Pdf);
                        }
                        else
                        {
                            Pdf = drp.DirectDocumentPrint(Settings.SqlProcDocumentPrint, User.Identity.Name, item);
                            PdfStream.Add(Pdf);
                        }
                    }

                    PdfMerger pm = new PdfMerger();

                    byte[] Merge = pm.MergeFiles(PdfStream);

                    if (Merge != null)
                    {
                        return(File(Merge, "application/pdf"));
                    }
                }
                catch (Exception ex)
                {
                    string message = _exception.HandleException(ex);
                    return(Json(new { success = "Error", data = message }, JsonRequestBehavior.AllowGet));
                }

                return(Json(new { success = "Success" }, JsonRequestBehavior.AllowGet));
            }
            return(Json(new { success = "Error", data = "No Records Selected." }, JsonRequestBehavior.AllowGet));
        }
        public JsonResult Index(int id)
        {
            var p = new MaterialPlanCancelLineService(_unitOfWork).GetMaterialPlanCancelLineList(id).ToList();

            return(Json(p, JsonRequestBehavior.AllowGet));
        }