コード例 #1
0
        public ActionResult DeleteAfter_Submit(int id)
        {
            ProdOrderHeader header = _ProdOrderHeaderService.Find(id);

            if (header.Status == (int)StatusConstants.Submitted || header.Status == (int)StatusConstants.Modified)
            {
                return(Remove(id));
            }
            else
            {
                return(HttpNotFound());
            }
        }
コード例 #2
0
        public ActionResult Delete(int id)
        {
            ProdOrderHeader header = _ProdOrderHeaderService.Find(id);

            if (header.Status == (int)StatusConstants.Drafted || header.Status == (int)StatusConstants.Import)
            {
                return(Remove(id));
            }
            else
            {
                return(HttpNotFound());
            }
        }
コード例 #3
0
        public ActionResult ModifyAfter_Submit(int id, string IndexType)
        {
            ProdOrderHeader header = _ProdOrderHeaderService.Find(id);

            if (header.Status == (int)StatusConstants.Submitted || header.Status == (int)StatusConstants.Modified || header.Status == (int)StatusConstants.ModificationSubmitted)
            {
                return(Edit(id, IndexType));
            }
            else
            {
                return(HttpNotFound());
            }
        }
コード例 #4
0
        public ActionResult Submit(int id, string IndexType, string TransactionType)
        {
            ProdOrderHeader s = context.ProdOrderHeader.Find(id);

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

            #region DocTypeTimeLineValidation


            try
            {
                TimePlanValidation = Submitvalidation(id, out ExceptionMsg);
                TempData["CSEXC"] += ExceptionMsg;
            }
            catch (Exception ex)
            {
                string message = _exception.HandleException(ex);
                TempData["CSEXC"] += message;
                TimePlanValidation = false;
            }
            try
            {
                TimePlanValidation = DocumentValidation.ValidateDocument(Mapper.Map <DocumentUniqueId>(s), DocumentTimePlanTypeConstants.Submit, User.Identity.Name, out ExceptionMsg, out Continue);
                TempData["CSEXC"] += ExceptionMsg;
            }
            catch (Exception ex)
            {
                string message = _exception.HandleException(ex);
                TempData["CSEXC"] += message;
                TimePlanValidation = false;
            }

            if (!TimePlanValidation && !Continue)
            {
                return(RedirectToAction("Index", new { id = s.DocTypeId, IndexType = IndexType }));
            }
            #endregion
            return(RedirectToAction("Detail", new { id = id, IndexType = IndexType, transactionType = string.IsNullOrEmpty(TransactionType) ? "submit" : TransactionType }));
        }
コード例 #5
0
 public void Update(ProdOrderHeader pt)
 {
     pt.ObjectState = ObjectState.Modified;
     _unitOfWork.Repository <ProdOrderHeader>().Update(pt);
 }
コード例 #6
0
 public void Delete(ProdOrderHeader pt)
 {
     _unitOfWork.Repository <ProdOrderHeader>().Delete(pt);
 }
コード例 #7
0
 public ProdOrderHeader Create(ProdOrderHeader pt)
 {
     pt.ObjectState = ObjectState.Added;
     _unitOfWork.Repository <ProdOrderHeader>().Insert(pt);
     return(pt);
 }
コード例 #8
0
 public ProdOrderHeader Add(ProdOrderHeader pt)
 {
     _unitOfWork.Repository <ProdOrderHeader>().Insert(pt);
     return(pt);
 }
コード例 #9
0
        public ActionResult Post(MaterialPlanHeaderViewModel vm)
        {
            MaterialPlanHeader pt = AutoMapper.Mapper.Map <MaterialPlanHeaderViewModel, MaterialPlanHeader>(vm);

            //#region DocTypeTimeLineValidation

            //try
            //{

            //    if (vm.MaterialPlanHeaderId <= 0)
            //        TimePlanValidation = DocumentValidation.ValidateDocument(Mapper.Map<DocumentUniqueId>(vm), DocumentTimePlanTypeConstants.Create, User.Identity.Name, out ExceptionMsg, out Continue);
            //    else
            //        TimePlanValidation = DocumentValidation.ValidateDocument(Mapper.Map<DocumentUniqueId>(vm), DocumentTimePlanTypeConstants.Modify, User.Identity.Name, out ExceptionMsg, out Continue);

            //}
            //catch (Exception ex)
            //{
            //    string message = _exception.HandleException(ex);
            //    TempData["CSEXC"] += message;
            //    TimePlanValidation = false;
            //}

            //if (!TimePlanValidation)
            //    TempData["CSEXC"] += ExceptionMsg;

            //#endregion

            if (ModelState.IsValid && (TimePlanValidation || Continue))
            {
                #region CreateRecord
                if (vm.MaterialPlanHeaderId <= 0)
                {
                    using (var context = new ApplicationDbContext())
                    {
                        pt.CreatedDate  = DateTime.Now;
                        pt.ModifiedDate = DateTime.Now;
                        pt.CreatedBy    = User.Identity.Name;
                        pt.ModifiedBy   = User.Identity.Name;
                        pt.ObjectState  = Model.ObjectState.Added;
                        context.MaterialPlanHeader.Add(pt);

                        int Serial = 0;

                        MaterialPlanLineListViewModel svm = new MaterialPlanLineListViewModel();
                        svm.MaterialPlanLineViewModel = (List <MaterialPlanForSaleOrderViewModel>)System.Web.HttpContext.Current.Session["SODyeingPlan"];

                        var Summary = (IEnumerable <MaterialPlanLineViewModel>)System.Web.HttpContext.Current.Session["SODyeingPlanSummary"];

                        MaterialPlanSettings Settings = new MaterialPlanSettingsService(_unitOfWork).GetMaterialPlanSettingsForDocument(pt.DocTypeId, pt.DivisionId, pt.SiteId);


                        bool isPr = false;
                        bool isPP = false;
                        int  j    = 0;
                        foreach (var item in Summary)
                        {
                            {
                                MaterialPlanLine planLine = new MaterialPlanLine();
                                planLine.RequiredQty          = item.RequiredQty;
                                planLine.ExcessStockQty       = item.ExcessStockQty;
                                planLine.MaterialPlanHeaderId = item.MaterialPlanHeaderId;
                                planLine.ProductId            = item.ProductId;
                                planLine.Dimension1Id         = item.Dimension1Id;
                                planLine.Dimension2Id         = item.Dimension2Id;
                                planLine.ProdPlanQty          = item.ProdPlanQty;
                                planLine.CreatedBy            = User.Identity.Name;
                                planLine.CreatedDate          = DateTime.Now;
                                planLine.Sr                 = Serial++;
                                planLine.Specification      = item.Specification;
                                planLine.ModifiedBy         = User.Identity.Name;
                                planLine.MaterialPlanLineId = j;
                                planLine.ModifiedDate       = DateTime.Now;
                                planLine.ProcessId          = item.ProcessId;
                                planLine.Remark             = item.Remark;
                                planLine.PurchPlanQty       = item.PurchPlanQty;
                                planLine.StockPlanQty       = item.StockPlanQty;
                                planLine.GeneratedFor       = MaterialPlanConstants.SaleOrder;
                                planLine.ObjectState        = Model.ObjectState.Added;
                                context.MaterialPlanLine.Add(planLine);
                                if (!isPr)
                                {
                                    if (item.ProdPlanQty > 0)
                                    {
                                        isPr = true;
                                    }
                                }
                                if (!isPP)
                                {
                                    if (item.PurchPlanQty > 0)
                                    {
                                        isPP = true;
                                    }
                                }
                            }
                            j++;
                        }

                        if (isPr)
                        {
                            ProdOrderHeader ExistingProdOrder = new ProdOrderHeaderService(_unitOfWork).GetProdOrderForMaterialPlan(pt.MaterialPlanHeaderId);
                            int             ProdORderSerial   = 1;
                            if (ExistingProdOrder == null)
                            {
                                ProdOrderHeader prodOrderHeader = new ProdOrderHeader();

                                prodOrderHeader.CreatedBy            = User.Identity.Name;
                                prodOrderHeader.CreatedDate          = DateTime.Now;
                                prodOrderHeader.DivisionId           = pt.DivisionId;
                                prodOrderHeader.DocDate              = pt.DocDate;
                                prodOrderHeader.DocNo                = pt.DocNo;
                                prodOrderHeader.DocTypeId            = Settings.DocTypeProductionOrderId.Value;
                                prodOrderHeader.DueDate              = pt.DueDate;
                                prodOrderHeader.MaterialPlanHeaderId = pt.MaterialPlanHeaderId;
                                prodOrderHeader.ModifiedBy           = User.Identity.Name;
                                prodOrderHeader.ModifiedDate         = DateTime.Now;
                                prodOrderHeader.Remark               = pt.Remark;
                                prodOrderHeader.BuyerId              = pt.BuyerId;
                                prodOrderHeader.SiteId               = pt.SiteId;
                                //prodOrderHeader.Status = header.Status;
                                prodOrderHeader.Status      = (int)StatusConstants.System;
                                prodOrderHeader.ObjectState = Model.ObjectState.Added;
                                context.ProdOrderHeader.Add(prodOrderHeader);

                                //ForCreating ProdOrderStatus
                                ProdOrderHeaderStatus pts = new ProdOrderHeaderStatus();
                                pts.ProdOrderHeaderId = prodOrderHeader.ProdOrderHeaderId;
                                pts.ObjectState       = Model.ObjectState.Added;
                                context.ProdOrderHeaderStatus.Add(pts);

                                int ProdOrderLineKey = 0;
                                foreach (var item in context.MaterialPlanLine.Local.Where(m => m.ProdPlanQty > 0))
                                {
                                    ProdOrderLine prodOrderLine = new ProdOrderLine();
                                    prodOrderLine.CreatedBy          = User.Identity.Name;
                                    prodOrderLine.CreatedDate        = DateTime.Now;
                                    prodOrderLine.MaterialPlanLineId = item.MaterialPlanLineId;
                                    prodOrderLine.ModifiedBy         = User.Identity.Name;
                                    prodOrderLine.ModifiedDate       = DateTime.Now;
                                    prodOrderLine.ProdOrderHeaderId  = prodOrderHeader.ProdOrderHeaderId;
                                    prodOrderLine.Specification      = item.Specification;
                                    prodOrderLine.ProductId          = item.ProductId;
                                    prodOrderLine.Dimension1Id       = item.Dimension1Id;
                                    prodOrderLine.Dimension2Id       = item.Dimension2Id;
                                    prodOrderLine.Sr              = ProdORderSerial++;
                                    prodOrderLine.Qty             = item.ProdPlanQty;
                                    prodOrderLine.Remark          = item.Remark;
                                    prodOrderLine.ProdOrderLineId = ProdOrderLineKey++;
                                    prodOrderLine.ObjectState     = Model.ObjectState.Added;
                                    context.ProdOrderLine.Add(prodOrderLine);

                                    //ForAdding ProdrderLinestatus
                                    ProdOrderLineStatus ptl = new ProdOrderLineStatus();
                                    ptl.ProdOrderLineId = prodOrderLine.ProdOrderLineId;
                                    ptl.ObjectState     = Model.ObjectState.Added;
                                    context.ProdOrderLineStatus.Add(ptl);
                                }
                            }
                            else
                            {
                                ProdORderSerial = new ProdOrderLineService(_unitOfWork).GetMaxSr(ExistingProdOrder.ProdOrderHeaderId);


                                int ProdOrderLineKey = 0;
                                foreach (var item in context.MaterialPlanLine.Local.Where(m => m.ProdPlanQty > 0))
                                {
                                    ProdOrderLine prodOrderLine = new ProdOrderLine();
                                    prodOrderLine.CreatedBy          = User.Identity.Name;
                                    prodOrderLine.CreatedDate        = DateTime.Now;
                                    prodOrderLine.MaterialPlanLineId = item.MaterialPlanLineId;
                                    prodOrderLine.ModifiedBy         = User.Identity.Name;
                                    prodOrderLine.ModifiedDate       = DateTime.Now;
                                    prodOrderLine.ProdOrderHeaderId  = ExistingProdOrder.ProdOrderHeaderId;
                                    prodOrderLine.ProductId          = item.ProductId;
                                    prodOrderLine.Dimension1Id       = item.Dimension1Id;
                                    prodOrderLine.Dimension2Id       = item.Dimension2Id;
                                    prodOrderLine.Specification      = item.Specification;
                                    prodOrderLine.Qty             = item.ProdPlanQty;
                                    prodOrderLine.Sr              = ProdORderSerial++;
                                    prodOrderLine.Remark          = item.Remark;
                                    prodOrderLine.ProdOrderLineId = ProdOrderLineKey++;
                                    prodOrderLine.ObjectState     = Model.ObjectState.Added;
                                    context.ProdOrderLine.Add(prodOrderLine);

                                    //ForAdding ProdrderLinestatus
                                    ProdOrderLineStatus ptl = new ProdOrderLineStatus();
                                    ptl.ProdOrderLineId = prodOrderLine.ProdOrderLineId;
                                    ptl.ObjectState     = Model.ObjectState.Added;
                                    context.ProdOrderLineStatus.Add(ptl);
                                }
                            }
                        }
                        if (isPP)
                        {
                            PurchaseIndentHeader ExistingIndent = new PurchaseIndentHeaderService(_unitOfWork).GetPurchaseIndentForMaterialPlan(pt.MaterialPlanHeaderId);
                            int PurchaseIndentSr = 1;
                            if (ExistingIndent == null)
                            {
                                PurchaseIndentHeader indentHeader = new PurchaseIndentHeader();
                                indentHeader.CreatedBy            = User.Identity.Name;
                                indentHeader.CreatedDate          = DateTime.Now;
                                indentHeader.DivisionId           = pt.DivisionId;
                                indentHeader.DocDate              = pt.DocDate;
                                indentHeader.DocNo                = pt.DocNo;
                                indentHeader.DocTypeId            = Settings.DocTypePurchaseIndentId.Value;
                                indentHeader.ModifiedBy           = User.Identity.Name;
                                indentHeader.MaterialPlanHeaderId = pt.MaterialPlanHeaderId;
                                indentHeader.ModifiedDate         = DateTime.Now;
                                indentHeader.Remark               = pt.Remark;
                                indentHeader.SiteId               = pt.SiteId;
                                //indentHeader.Status = header.Status;
                                indentHeader.Status       = (int)StatusConstants.System;
                                indentHeader.DepartmentId = (int)DepartmentConstants.Production;
                                indentHeader.ObjectState  = Model.ObjectState.Added;
                                context.PurchaseIndentHeader.Add(indentHeader);
                                foreach (var item in context.MaterialPlanLine.Local.Where(m => m.PurchPlanQty > 0))
                                {
                                    PurchaseIndentLine indentLine = new PurchaseIndentLine();
                                    indentLine.CreatedBy              = User.Identity.Name;
                                    indentLine.CreatedDate            = DateTime.Now;
                                    indentLine.MaterialPlanLineId     = item.MaterialPlanLineId;
                                    indentLine.ModifiedBy             = User.Identity.Name;
                                    indentLine.ModifiedDate           = DateTime.Now;
                                    indentLine.ProductId              = item.ProductId;
                                    indentLine.Dimension1Id           = item.Dimension1Id;
                                    indentLine.Dimension2Id           = item.Dimension2Id;
                                    indentLine.Specification          = item.Specification;
                                    indentLine.PurchaseIndentHeaderId = indentHeader.PurchaseIndentHeaderId;
                                    indentLine.Qty         = item.PurchPlanQty;
                                    indentLine.Sr          = PurchaseIndentSr++;
                                    indentLine.Remark      = item.Remark;
                                    indentLine.ObjectState = Model.ObjectState.Added;
                                    context.PurchaseIndentLine.Add(indentLine);
                                }
                            }
                            else
                            {
                                PurchaseIndentSr = new PurchaseIndentLineService(_unitOfWork).GetMaxSr(ExistingIndent.PurchaseIndentHeaderId);
                                foreach (var item in context.MaterialPlanLine.Local.Where(m => m.PurchPlanQty > 0))
                                {
                                    PurchaseIndentLine indentLine = new PurchaseIndentLine();
                                    indentLine.CreatedBy          = User.Identity.Name;
                                    indentLine.CreatedDate        = DateTime.Now;
                                    indentLine.MaterialPlanLineId = item.MaterialPlanLineId;
                                    indentLine.ModifiedBy         = User.Identity.Name;
                                    indentLine.Specification      = item.Specification;
                                    indentLine.ModifiedDate       = DateTime.Now;
                                    indentLine.ProductId          = item.ProductId;
                                    indentLine.Dimension1Id       = item.Dimension1Id;
                                    indentLine.Dimension2Id       = item.Dimension2Id;
                                    indentLine.Sr = PurchaseIndentSr++;
                                    indentLine.PurchaseIndentHeaderId = ExistingIndent.PurchaseIndentHeaderId;
                                    indentLine.Qty         = item.PurchPlanQty;
                                    indentLine.Remark      = item.Remark;
                                    indentLine.ObjectState = Model.ObjectState.Added;
                                    context.PurchaseIndentLine.Add(indentLine);
                                }
                            }
                        }


                        int i = 0;
                        int MaterialPlanForSaleOrderSr = new MaterialPlanForSaleOrderService(_unitOfWork).GetMaxSr(svm.MaterialPlanLineViewModel.FirstOrDefault().MaterialPlanHeaderId);
                        foreach (var item in svm.MaterialPlanLineViewModel)
                        {
                            if (item.Qty > 0)
                            {
                                MaterialPlanForSaleOrder order = new MaterialPlanForSaleOrder();
                                order.MaterialPlanHeaderId = item.MaterialPlanHeaderId;
                                order.Qty                        = item.Qty;
                                order.SaleOrderLineId            = item.SaleOrderLineId;
                                order.MaterialPlanForSaleOrderId = i;
                                order.Sr           = MaterialPlanForSaleOrderSr++;
                                order.CreatedBy    = User.Identity.Name;
                                order.CreatedDate  = DateTime.Now;
                                order.ModifiedBy   = User.Identity.Name;
                                order.ModifiedDate = DateTime.Now;

                                //if (item.Dimension1Id != null)
                                //{
                                //    var MaterialPlan = context.MaterialPlanLine.Local.Where(m => m.ProductId == item.ProductId && m.Dimension1Id == item.Dimension1Id).FirstOrDefault();
                                //    if (order != null)
                                //    {
                                //        order.MaterialPlanLineId = MaterialPlan.MaterialPlanLineId;
                                //    }
                                //}
                                //else
                                //{
                                //    var MaterialPlan = context.MaterialPlanLine.Local.Where(m => m.ProductId == item.ProductId).FirstOrDefault();
                                //    if (order != null)
                                //    {
                                //        order.MaterialPlanLineId = MaterialPlan.MaterialPlanLineId;
                                //    }
                                //}

                                order.ObjectState = Model.ObjectState.Added;
                                context.MaterialPlanForSaleOrder.Add(order);

                                i++;
                            }
                        }

                        try
                        {
                            context.SaveChanges();
                        }

                        catch (Exception ex)
                        {
                            string message = _exception.HandleException(ex);
                            TempData["CSEXC"] += message;
                            ViewBag.Mode       = "Add";
                            ViewBag.Name       = new DocumentTypeService(_unitOfWork).Find(vm.DocTypeId).DocumentTypeName;
                            ViewBag.id         = vm.DocTypeId;
                            return(View("Create", vm));
                        }

                        //LogActivity.LogActivityDetail(LogVm.Map(new ActiivtyLogViewModel
                        //{
                        //    DocTypeId = pt.DocTypeId,
                        //    DocId = pt.MaterialPlanHeaderId,
                        //    ActivityType = (int)ActivityTypeContants.Added,
                        //    DocNo = pt.DocNo,
                        //    DocDate = pt.DocDate,
                        //    DocStatus = pt.Status,
                        //}));

                        return(RedirectToAction("Index", "MaterialPlanHeader", new { id = pt.DocTypeId }));
                    }
                }
                #endregion
            }
            ViewBag.Name = new DocumentTypeService(_unitOfWork).Find(vm.DocTypeId).DocumentTypeName;
            ViewBag.id   = vm.DocTypeId;
            ViewBag.Mode = "Add";
            return(View("Create", vm));
        }
コード例 #10
0
        public ActionResult _ResultsPost(ProdOrderMasterDetailModel vm)
        {
            int Serial = _ProdOrderLineService.GetMaxSr(vm.ProdOrderLineViewModel.FirstOrDefault().ProdOrderHeaderId);
            int Pk     = 0;

            if (ModelState.IsValid)
            {
                foreach (var item in vm.ProdOrderLineViewModel)
                {
                    if (item.Qty > 0)
                    {
                        ProdOrderLine line = new ProdOrderLine();

                        line.ProdOrderHeaderId  = item.ProdOrderHeaderId;
                        line.MaterialPlanLineId = item.MaterialPlanLineId;
                        line.ProductId          = item.ProductId;
                        line.Dimension1Id       = item.Dimension1Id;
                        line.Dimension2Id       = item.Dimension2Id;
                        line.Specification      = item.Specification;
                        line.Remark             = item.Remark;
                        line.Qty             = item.Qty;
                        line.Sr              = Serial++;
                        line.ProdOrderLineId = Pk;
                        line.CreatedDate     = DateTime.Now;
                        line.ModifiedDate    = DateTime.Now;
                        line.CreatedBy       = User.Identity.Name;
                        line.ModifiedBy      = User.Identity.Name;

                        line.ObjectState = Model.ObjectState.Added;
                        _ProdOrderLineService.Create(line);

                        new ProdOrderLineStatusService(_unitOfWork).CreateLineStatus(line.ProdOrderLineId);

                        Pk++;
                    }
                }

                ProdOrderHeader Header = db.ProdOrderHeader.Find(vm.ProdOrderLineViewModel.FirstOrDefault().ProdOrderHeaderId);

                if (Header.Status != (int)StatusConstants.Drafted && Header.Status != (int)StatusConstants.Import)
                {
                    Header.Status       = (int)StatusConstants.Modified;
                    Header.ModifiedBy   = User.Identity.Name;
                    Header.ModifiedDate = DateTime.Now;
                    Header.ObjectState  = Model.ObjectState.Modified;

                    new ProdOrderHeaderService(_unitOfWork).Update(Header);
                }

                try
                {
                    _unitOfWork.Save();
                }
                catch (Exception ex)
                {
                    string message = _exception.HandleException(ex);
                    TempData["CSEXCL"] += message;
                    return(PartialView("_Results", vm));
                }

                LogActivity.LogActivityDetail(LogVm.Map(new ActiivtyLogViewModel
                {
                    DocTypeId    = Header.DocTypeId,
                    DocId        = Header.ProdOrderHeaderId,
                    ActivityType = (int)ActivityTypeContants.MultipleCreate,
                    DocNo        = Header.DocNo,
                    DocDate      = Header.DocDate,
                    DocStatus    = Header.Status,
                }));

                return(Json(new { success = true }));
            }
            return(PartialView("_Results", vm));
        }
コード例 #11
0
        public ActionResult HeaderPost(ProdOrderHeaderViewModel svm)
        {
            if (svm.DocDate > svm.DueDate)
            {
                ModelState.AddModelError("DueDate", "DueDate cannot be greater than DocDate");
            }

            #region DocTypeTimeLineValidation

            try
            {
                if (svm.ProdOrderHeaderId <= 0)
                {
                    TimePlanValidation = DocumentValidation.ValidateDocument(Mapper.Map <DocumentUniqueId>(svm), DocumentTimePlanTypeConstants.Create, User.Identity.Name, out ExceptionMsg, out Continue);
                }
                else
                {
                    TimePlanValidation = DocumentValidation.ValidateDocument(Mapper.Map <DocumentUniqueId>(svm), DocumentTimePlanTypeConstants.Modify, User.Identity.Name, out ExceptionMsg, out Continue);
                }
            }
            catch (Exception ex)
            {
                string message = _exception.HandleException(ex);
                TempData["CSEXC"] += message;
                TimePlanValidation = false;
            }

            if (!TimePlanValidation)
            {
                TempData["CSEXC"] += ExceptionMsg;
            }

            #endregion

            if (ModelState.IsValid && (TimePlanValidation || Continue))
            {
                #region CreateRecord
                if (svm.ProdOrderHeaderId == 0)
                {
                    ProdOrderHeader s = Mapper.Map <ProdOrderHeaderViewModel, ProdOrderHeader>(svm);

                    s.CreatedDate  = DateTime.Now;
                    s.ModifiedDate = DateTime.Now;
                    s.CreatedBy    = User.Identity.Name;
                    s.ModifiedBy   = User.Identity.Name;
                    s.Status       = (int)StatusConstants.Drafted;
                    _ProdOrderHeaderService.Create(s);

                    new ProdOrderHeaderStatusService(_unitOfWork).CreateHeaderStatus(s.ProdOrderHeaderId);

                    try
                    {
                        _unitOfWork.Save();
                    }

                    catch (Exception ex)
                    {
                        string message = _exception.HandleException(ex);
                        TempData["CSEXC"] += message;
                        PrepareViewBag(svm.DocTypeId);
                        return(View("Create", svm));
                    }


                    LogActivity.LogActivityDetail(LogVm.Map(new ActiivtyLogViewModel
                    {
                        DocTypeId    = s.DocTypeId,
                        DocId        = s.ProdOrderHeaderId,
                        ActivityType = (int)ActivityTypeContants.Added,
                        DocNo        = s.DocNo,
                        DocDate      = s.DocDate,
                        DocStatus    = s.Status,
                    }));

                    return(RedirectToAction("Modify", new { id = s.ProdOrderHeaderId }).Success("Data saved Successfully"));
                }
                #endregion

                #region EditRecord
                else
                {
                    List <LogTypeViewModel> LogList = new List <LogTypeViewModel>();

                    //string tempredirect = (Request["Redirect"].ToString());
                    ProdOrderHeader s         = Mapper.Map <ProdOrderHeaderViewModel, ProdOrderHeader>(svm);
                    StringBuilder   logstring = new StringBuilder();
                    ProdOrderHeader temp      = _ProdOrderHeaderService.Find(s.ProdOrderHeaderId);

                    ProdOrderHeader ExRec = new ProdOrderHeader();
                    ExRec = Mapper.Map <ProdOrderHeader>(temp);

                    int status = temp.Status;

                    if (temp.Status != (int)StatusConstants.Drafted && temp.Status != (int)StatusConstants.Import)
                    {
                        temp.Status = (int)StatusConstants.Modified;
                    }

                    temp.DocTypeId    = s.DocTypeId;
                    temp.DocDate      = s.DocDate;
                    temp.DocNo        = s.DocNo;
                    temp.Remark       = s.Remark;
                    temp.DueDate      = s.DueDate;
                    temp.ModifiedDate = DateTime.Now;
                    temp.ModifiedBy   = User.Identity.Name;
                    _ProdOrderHeaderService.Update(temp);

                    LogList.Add(new LogTypeViewModel
                    {
                        ExObj = ExRec,
                        Obj   = temp,
                    });
                    XElement Modifications = new ModificationsCheckService().CheckChanges(LogList);
                    try
                    {
                        _unitOfWork.Save();
                    }

                    catch (Exception ex)
                    {
                        string message = _exception.HandleException(ex);
                        TempData["CSEXC"] += message;
                        PrepareViewBag(svm.DocTypeId);
                        ViewBag.Mode = "Edit";
                        return(View("Create", svm));
                    }

                    LogActivity.LogActivityDetail(LogVm.Map(new ActiivtyLogViewModel
                    {
                        DocTypeId       = s.DocTypeId,
                        DocId           = s.ProdOrderHeaderId,
                        ActivityType    = (int)ActivityTypeContants.Modified,
                        DocNo           = s.DocNo,
                        xEModifications = Modifications,
                        DocDate         = s.DocDate,
                        DocStatus       = s.Status,
                    }));

                    return(RedirectToAction("Index", new { id = temp.DocTypeId, IndexType = "" }).Success("Data saved successfully"));
                }

                #endregion
            }
            PrepareViewBag(svm.DocTypeId);
            ViewBag.Mode = "Add";
            return(View("Create", svm));
        }