Beispiel #1
0
        public ActionResult Submitted(int Id, string IndexType, string UserRemark, string IsContinue)
        {
            bool BeforeSave = true;

            try
            {
                BeforeSave = JobConsumptionDocEvents.beforeHeaderSubmitEvent(this, new StockEventArgs(Id), ref db);
            }
            catch (Exception ex)
            {
                string message = _exception.HandleException(ex);
                TempData["CSEXC"] += message;
                EventException     = true;
            }

            if (!BeforeSave)
            {
                TempData["CSEXC"] += "Falied validation before submit.";
            }

            StockHeader pd = new StockHeaderService(_unitOfWork).Find(Id);

            if (ModelState.IsValid && BeforeSave && !EventException)
            {
                if (User.Identity.Name == pd.ModifiedBy || UserRoles.Contains("Admin"))
                {
                    int ActivityType;


                    pd.Status    = (int)StatusConstants.Submitted;
                    ActivityType = (int)ActivityTypeContants.Submitted;

                    pd.ReviewBy    = null;
                    pd.ObjectState = Model.ObjectState.Modified;
                    db.StockHeader.Add(pd);

                    try
                    {
                        JobConsumptionDocEvents.onHeaderSubmitEvent(this, new StockEventArgs(Id), ref db);
                    }
                    catch (Exception ex)
                    {
                        string message = _exception.HandleException(ex);
                        TempData["CSEXC"] += message;
                        EventException     = true;
                    }

                    try
                    {
                        if (EventException)
                        {
                            throw new Exception();
                        }

                        db.SaveChanges();
                    }

                    catch (Exception ex)
                    {
                        string message = _exception.HandleException(ex);
                        TempData["CSEXC"] += message;
                        return(RedirectToAction("Index", new { id = pd.DocTypeId, IndexType = IndexType }));
                    }

                    try
                    {
                        JobConsumptionDocEvents.afterHeaderSubmitEvent(this, new StockEventArgs(Id), ref db);
                    }
                    catch (Exception ex)
                    {
                        string message = _exception.HandleException(ex);
                        TempData["CSEXC"] += message;
                    }

                    LogActivity.LogActivityDetail(LogVm.Map(new ActiivtyLogViewModel
                    {
                        DocTypeId    = pd.DocTypeId,
                        DocId        = pd.StockHeaderId,
                        ActivityType = ActivityType,
                        UserRemark   = UserRemark,
                        DocNo        = pd.DocNo,
                        DocDate      = pd.DocDate,
                        DocStatus    = pd.Status,
                    }));

                    return(RedirectToAction("Index", new { id = pd.DocTypeId, IndexType = IndexType }).Success("Record Submitted Successfully"));
                }
                else
                {
                    return(RedirectToAction("Index", new { id = pd.DocTypeId, IndexType = IndexType }).Warning("Record can be submitted by user " + pd.ModifiedBy + " only."));
                }
            }

            return(View());
        }
Beispiel #2
0
        public ActionResult Reviewed(int Id, string IndexType, string UserRemark, string IsContinue)
        {
            bool BeforeSave = true;

            try
            {
                BeforeSave = JobConsumptionDocEvents.beforeHeaderReviewEvent(this, new StockEventArgs(Id), ref db);
            }
            catch (Exception ex)
            {
                string message = _exception.HandleException(ex);
                TempData["CSEXC"] += message;
            }

            if (!BeforeSave)
            {
                TempData["CSEXC"] += "Falied validation before Review.";
            }

            StockHeader pd = new StockHeaderService(_unitOfWork).Find(Id);

            if (ModelState.IsValid && BeforeSave)
            {
                pd.ReviewCount = (pd.ReviewCount ?? 0) + 1;
                pd.ReviewBy   += User.Identity.Name + ", ";


                pd.ObjectState = Model.ObjectState.Modified;
                db.StockHeader.Add(pd);
                //_unitOfWork.Save();

                try
                {
                    JobConsumptionDocEvents.onHeaderReviewEvent(this, new StockEventArgs(Id), ref db);
                }
                catch (Exception ex)
                {
                    string message = _exception.HandleException(ex);
                    TempData["CSEXC"] += message;
                }


                db.SaveChanges();

                try
                {
                    JobConsumptionDocEvents.afterHeaderReviewEvent(this, new StockEventArgs(Id), ref db);
                }
                catch (Exception ex)
                {
                    string message = _exception.HandleException(ex);
                    TempData["CSEXC"] += message;
                }

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

                //SendEmail_POApproved(Id);
                return(RedirectToAction("Index", new { id = pd.DocTypeId, IndexType = IndexType }).Success("Reviewed Successfully."));
            }

            return(RedirectToAction("Index", new { id = pd.DocTypeId, IndexType = IndexType }).Warning("Error in Reviewing."));
        }
Beispiel #3
0
        public ActionResult Delete(ReasonViewModel vm)
        {
            bool BeforeSave = true;

            try
            {
                BeforeSave = JobConsumptionDocEvents.beforeHeaderDeleteEvent(this, new StockEventArgs(vm.id), ref db);
            }
            catch (Exception ex)
            {
                string message = _exception.HandleException(ex);
                TempData["CSEXC"] += message;
                EventException     = true;
            }

            if (!BeforeSave)
            {
                TempData["CSEXC"] += "Failed validation before delete";
            }

            if (ModelState.IsValid && BeforeSave && !EventException)
            {
                List <LogTypeViewModel> LogList = new List <LogTypeViewModel>();

                //first find the Purchase Order Object based on the ID. (sience this object need to marked to be deleted IE. ObjectState.Deleted)
                StockHeader StockHeader = (from p in db.StockHeader
                                           where p.StockHeaderId == vm.id
                                           select p).FirstOrDefault();

                LogList.Add(new LogTypeViewModel
                {
                    ExObj = Mapper.Map <StockHeader>(StockHeader),
                });

                //Then find all the Purchase Order Header Line associated with the above ProductType.
                var StockLine = (from p in db.StockLine
                                 where p.StockHeaderId == vm.id
                                 select p).ToList();

                try
                {
                    JobConsumptionDocEvents.onHeaderDeleteEvent(this, new StockEventArgs(vm.id), ref db);
                }
                catch (Exception ex)
                {
                    string message = _exception.HandleException(ex);
                    TempData["CSEXC"] += message;
                    EventException     = true;
                }


                List <int> StockProcessIdList = new List <int>();

                //Mark ObjectState.Delete to all the Purchase Order Lines.
                foreach (var item in StockLine)
                {
                    LogList.Add(new LogTypeViewModel
                    {
                        ExObj = Mapper.Map <StockLine>(item),
                    });


                    if (item.StockProcessId != null)
                    {
                        StockProcessIdList.Add((int)item.StockProcessId);
                    }

                    item.ObjectState = Model.ObjectState.Deleted;
                    db.StockLine.Remove(item);
                    //new StockLineService(_unitOfWork).Delete(item);
                }

                foreach (var item in StockProcessIdList)
                {
                    new StockProcessService(_unitOfWork).DeleteStockProcessDB(item, ref db, true);
                }

                //if (StockHeader != null)
                //{
                //    new StockHeaderService(_unitOfWork).Delete(StockHeader.StockHeaderId);
                //}


                // Now delete the Purhcase Order Header
                //new StockHeaderService(_unitOfWork).Delete(StockHeader);

                StockHeader.ObjectState = Model.ObjectState.Deleted;
                db.StockHeader.Remove(StockHeader);

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

                //Commit the DB
                try
                {
                    if (EventException)
                    {
                        throw new Exception();
                    }
                    db.SaveChanges();
                }

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

                try
                {
                    JobConsumptionDocEvents.afterHeaderDeleteEvent(this, new StockEventArgs(vm.id), ref db);
                }
                catch (Exception ex)
                {
                    string message = _exception.HandleException(ex);
                    TempData["CSEXC"] += message;
                }

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

                return(Json(new { success = true }));
            }
            return(PartialView("_Reason", vm));
        }
Beispiel #4
0
        public ActionResult Post(StockHeaderViewModel svm)
        {
            StockHeader s = Mapper.Map <StockHeaderViewModel, StockHeader>(svm);

            #region BeforeSave
            bool BeforeSave = true;
            try
            {
                if (svm.StockHeaderId <= 0)
                {
                    BeforeSave = JobConsumptionDocEvents.beforeHeaderSaveEvent(this, new StockEventArgs(svm.StockHeaderId, EventModeConstants.Add), ref db);
                }
                else
                {
                    BeforeSave = JobConsumptionDocEvents.beforeHeaderSaveEvent(this, new StockEventArgs(svm.StockHeaderId, EventModeConstants.Edit), ref db);
                }
            }
            catch (Exception ex)
            {
                string message = _exception.HandleException(ex);
                TempData["CSEXC"] += message;
                EventException     = true;
            }
            if (!BeforeSave)
            {
                TempData["CSEXC"] += "Failed validation before save";
            }

            #endregion

            #region DocTypeTimeLineValidation

            try
            {
                if (svm.StockHeaderId <= 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 (svm.StockHeaderSettings != null)
            {
                if (svm.StockHeaderSettings.isMandatoryMachine == true && (svm.MachineId <= 0 || svm.MachineId == null))
                {
                    ModelState.AddModelError("MachineId", "The Machine field is required");
                }
            }



            if (ModelState.IsValid && BeforeSave && !EventException && (TimePlanValidation || Continue))
            {
                #region CreateRecord
                if (svm.StockHeaderId <= 0)
                {
                    s.CreatedDate  = DateTime.Now;
                    s.ModifiedDate = DateTime.Now;
                    s.CreatedBy    = User.Identity.Name;
                    s.ModifiedBy   = User.Identity.Name;
                    s.Status       = (int)StatusConstants.Drafted;
                    s.ObjectState  = Model.ObjectState.Added;
                    db.StockHeader.Add(s);
                    //_StockHeaderService.Create(s);

                    try
                    {
                        JobConsumptionDocEvents.onHeaderSaveEvent(this, new StockEventArgs(s.StockHeaderId, EventModeConstants.Add), ref db);
                    }
                    catch (Exception ex)
                    {
                        string message = _exception.HandleException(ex);
                        TempData["CSEXC"] += message;
                        EventException     = true;
                    }

                    try
                    {
                        if (EventException)
                        {
                            throw new Exception();
                        }

                        db.SaveChanges();
                        //_unitOfWork.Save();
                    }

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

                    try
                    {
                        JobConsumptionDocEvents.afterHeaderSaveEvent(this, new StockEventArgs(s.StockHeaderId, EventModeConstants.Add), ref db);
                    }
                    catch (Exception ex)
                    {
                        string message = _exception.HandleException(ex);
                        TempData["CSEXC"] += message;
                    }


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

                    return(RedirectToAction("Modify", "JobConsumptionHeader", new { Id = s.StockHeaderId }).Success("Data saved successfully"));
                }
                #endregion

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

                    StockHeader temp = _StockHeaderService.Find(s.StockHeaderId);

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


                    int status = temp.Status;

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


                    temp.DocDate      = s.DocDate;
                    temp.DocNo        = s.DocNo;
                    temp.CostCenterId = s.CostCenterId;
                    temp.MachineId    = s.MachineId;
                    temp.PersonId     = s.PersonId;
                    temp.ProcessId    = s.ProcessId;
                    temp.GodownId     = s.GodownId;
                    temp.Remark       = s.Remark;

                    temp.ModifiedDate = DateTime.Now;
                    temp.ModifiedBy   = User.Identity.Name;
                    temp.ObjectState  = Model.ObjectState.Modified;
                    db.StockHeader.Add(temp);
                    //_StockHeaderService.Update(temp);

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

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

                    try
                    {
                        JobConsumptionDocEvents.onHeaderSaveEvent(this, new StockEventArgs(temp.StockHeaderId, EventModeConstants.Edit), ref db);
                    }
                    catch (Exception ex)
                    {
                        string message = _exception.HandleException(ex);
                        TempData["CSEXC"] += message;
                        EventException     = true;
                    }

                    try
                    {
                        if (EventException)
                        {
                            throw new Exception();
                        }
                        db.SaveChanges();
                        //_unitOfWork.Save();
                    }

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

                    try
                    {
                        JobConsumptionDocEvents.afterHeaderSaveEvent(this, new StockEventArgs(s.StockHeaderId, EventModeConstants.Edit), ref db);
                    }
                    catch (Exception ex)
                    {
                        string message = _exception.HandleException(ex);
                        TempData["CSEXC"] += message;
                    }


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


                    return(RedirectToAction("Index", new { id = svm.DocTypeId }).Success("Data saved successfully"));
                }
                #endregion
            }
            PrepareViewBag(svm.DocTypeId);
            ViewBag.Mode = "Add";
            return(View("Create", svm));
        }
        public ActionResult _ResultsPost(StockMasterDetailModel vm)
        {
            StockHeader         temp     = new StockHeaderService(_unitOfWork).Find(vm.StockLineViewModel.FirstOrDefault().StockHeaderId);
            StockHeaderSettings Settings = new StockHeaderSettingsService(_unitOfWork).GetStockHeaderSettingsForDocument(temp.DocTypeId, temp.DivisionId, temp.SiteId);

            bool BeforeSave = true;

            try
            {
                BeforeSave = JobConsumptionDocEvents.beforeLineSaveBulkEvent(this, new StockEventArgs(vm.StockLineViewModel.FirstOrDefault().StockHeaderId), ref db);
            }
            catch (Exception ex)
            {
                string message = _exception.HandleException(ex);
                TempData["CSEXC"] += message;
                EventException     = true;
            }

            if (!BeforeSave)
            {
                ModelState.AddModelError("", "Validation failed before save");
            }

            int Cnt = 0;

            if (ModelState.IsValid && BeforeSave && !EventException)
            {
                foreach (var item in vm.StockLineViewModel)
                {
                    if (item.Qty != 0 && (Settings.isMandatoryLineCostCenter == true ? item.CostCenterId.HasValue : 1 == 1))
                    {
                        StockLine line = new StockLine();
                        line.StockHeaderId = item.StockHeaderId;
                        line.Qty           = item.Qty;
                        line.ProductId     = item.ProductId;
                        line.LotNo         = item.LotNo;
                        line.Dimension1Id  = item.Dimension1Id;
                        line.Dimension2Id  = item.Dimension2Id;
                        line.Dimension3Id  = item.Dimension3Id;
                        line.Dimension4Id  = item.Dimension4Id;
                        line.CostCenterId  = item.CostCenterId;
                        line.FromProcessId = item.FromProcessId;
                        line.Specification = item.Specification;
                        line.CreatedDate   = DateTime.Now;
                        line.ModifiedDate  = DateTime.Now;
                        line.CreatedBy     = User.Identity.Name;
                        line.ModifiedBy    = User.Identity.Name;
                        line.DocNature     = (item.Qty < 0 ? StockNatureConstants.Receive : StockNatureConstants.Issue);


                        StockProcessViewModel StockProcessViewModel = new StockProcessViewModel();

                        if (temp.StockHeaderId != null && temp.StockHeaderId != 0)//If Transaction Header Table Has Stock Header Id Then It will Save Here.
                        {
                            StockProcessViewModel.StockHeaderId = (int)temp.StockHeaderId;
                        }
                        else if (Cnt > 0)//If function will only post in stock process then after first iteration of loop the stock header id will go -1
                        {
                            StockProcessViewModel.StockHeaderId = -1;
                        }
                        else//If function will only post in stock process then this statement will execute.For Example Job consumption.
                        {
                            StockProcessViewModel.StockHeaderId = 0;
                        }
                        StockProcessViewModel.StockProcessId      = -Cnt;
                        StockProcessViewModel.DocHeaderId         = temp.StockHeaderId;
                        StockProcessViewModel.DocLineId           = line.StockLineId;
                        StockProcessViewModel.DocTypeId           = temp.DocTypeId;
                        StockProcessViewModel.StockHeaderDocDate  = temp.DocDate;
                        StockProcessViewModel.StockProcessDocDate = temp.DocDate;
                        StockProcessViewModel.DocNo              = temp.DocNo;
                        StockProcessViewModel.DivisionId         = temp.DivisionId;
                        StockProcessViewModel.SiteId             = temp.SiteId;
                        StockProcessViewModel.CurrencyId         = null;
                        StockProcessViewModel.PersonId           = temp.PersonId;
                        StockProcessViewModel.ProductId          = item.ProductId;
                        StockProcessViewModel.HeaderFromGodownId = null;
                        StockProcessViewModel.HeaderGodownId     = temp.GodownId;
                        StockProcessViewModel.HeaderProcessId    = temp.ProcessId;
                        StockProcessViewModel.GodownId           = temp.GodownId;
                        StockProcessViewModel.Remark             = temp.Remark;
                        StockProcessViewModel.Status             = temp.Status;
                        StockProcessViewModel.ProcessId          = temp.ProcessId;
                        StockProcessViewModel.LotNo              = null;
                        StockProcessViewModel.CostCenterId       = item.CostCenterId;
                        //StockProcessViewModel.Qty_Iss = item.Qty;
                        //StockProcessViewModel.Qty_Rec = 0;

                        if (item.Qty > 0)
                        {
                            StockProcessViewModel.Qty_Rec = item.Qty;
                            StockProcessViewModel.Qty_Iss = 0;
                        }
                        else if (item.Qty < 0)
                        {
                            StockProcessViewModel.Qty_Rec = 0;
                            StockProcessViewModel.Qty_Iss = Math.Abs(item.Qty);
                        }

                        StockProcessViewModel.Rate          = item.Rate;
                        StockProcessViewModel.ExpiryDate    = null;
                        StockProcessViewModel.Specification = item.Specification;
                        StockProcessViewModel.Dimension1Id  = item.Dimension1Id;
                        StockProcessViewModel.Dimension2Id  = item.Dimension2Id;
                        StockProcessViewModel.Dimension3Id  = item.Dimension3Id;
                        StockProcessViewModel.Dimension4Id  = item.Dimension4Id;
                        StockProcessViewModel.CreatedBy     = User.Identity.Name;
                        StockProcessViewModel.CreatedDate   = DateTime.Now;
                        StockProcessViewModel.ModifiedBy    = User.Identity.Name;
                        StockProcessViewModel.ModifiedDate  = DateTime.Now;

                        string StockProcessPostingError = "";
                        StockProcessPostingError = new StockProcessService(_unitOfWork).StockProcessPostDB(ref StockProcessViewModel, ref db);

                        if (StockProcessPostingError != "")
                        {
                            string message = StockProcessPostingError;
                            ModelState.AddModelError("", message);
                            return(PartialView("_Results", vm));
                        }

                        line.StockProcessId = StockProcessViewModel.StockProcessId;

                        line.ObjectState = Model.ObjectState.Added;
                        db.StockLine.Add(line);
                        //_StockLineService.Create(line);
                        Cnt = Cnt + 1;
                    }
                }


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

                    temp.ObjectState = Model.ObjectState.Modified;
                    db.StockHeader.Add(temp);
                }

                try
                {
                    JobConsumptionDocEvents.onLineSaveBulkEvent(this, new StockEventArgs(vm.StockLineViewModel.FirstOrDefault().StockHeaderId), ref db);
                }
                catch (Exception ex)
                {
                    string message = _exception.HandleException(ex);
                    TempData["CSEXCL"] += message;
                    EventException      = true;
                }

                try
                {
                    if (EventException)
                    {
                        throw new Exception();
                    }

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

                try
                {
                    JobConsumptionDocEvents.afterLineSaveBulkEvent(this, new StockEventArgs(vm.StockLineViewModel.FirstOrDefault().StockHeaderId), ref db);
                }
                catch (Exception ex)
                {
                    string message = _exception.HandleException(ex);
                    TempData["CSEXC"] += message;
                }

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

                return(Json(new { success = true }));
            }
            return(PartialView("_Results", vm));
        }
        public ActionResult DeletePost(StockLineViewModel vm)
        {
            bool BeforeSave = true;

            try
            {
                BeforeSave = JobConsumptionDocEvents.beforeLineDeleteEvent(this, new StockEventArgs(vm.StockHeaderId, vm.StockLineId), ref db);
            }
            catch (Exception ex)
            {
                string message = _exception.HandleException(ex);
                TempData["CSEXC"] += message;
                EventException     = true;
            }

            if (!BeforeSave)
            {
                TempData["CSEXC"] += "Validation failed before delete.";
            }

            if (BeforeSave && !EventException)
            {
                int?StockProcessId = 0;
                List <LogTypeViewModel> LogList = new List <LogTypeViewModel>();


                StockLine StockLine = (from p in db.StockLine
                                       where p.StockLineId == vm.StockLineId
                                       select p).FirstOrDefault();

                LogList.Add(new LogTypeViewModel
                {
                    ExObj = Mapper.Map <StockLine>(StockLine),
                });


                StockProcessId = StockLine.StockProcessId;

                //_StockLineService.Delete(StockLine);
                StockLine.ObjectState = Model.ObjectState.Deleted;
                db.StockLine.Remove(StockLine);


                if (StockProcessId != null)
                {
                    new StockProcessService(_unitOfWork).DeleteStockProcessDB((int)StockProcessId, ref db, true);
                }


                StockHeader header = new StockHeaderService(_unitOfWork).Find(StockLine.StockHeaderId);
                if (header.Status != (int)StatusConstants.Drafted)
                {
                    header.Status       = (int)StatusConstants.Modified;
                    header.ModifiedDate = DateTime.Now;
                    header.ModifiedBy   = User.Identity.Name;
                    header.ObjectState  = Model.ObjectState.Modified;
                    db.StockHeader.Add(header);
                    //new StockHeaderService(_unitOfWork).Update(header);
                }


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

                try
                {
                    JobConsumptionDocEvents.onLineDeleteEvent(this, new StockEventArgs(StockLine.StockHeaderId, StockLine.StockLineId), ref db);
                }
                catch (Exception ex)
                {
                    string message = _exception.HandleException(ex);
                    TempData["CSEXCL"] += message;
                    EventException      = true;
                }


                try
                {
                    if (EventException)
                    {
                        throw new Exception();
                    }

                    db.SaveChanges();
                }

                catch (Exception ex)
                {
                    string message = _exception.HandleException(ex);
                    TempData["CSEXCL"] += message;
                    ViewBag.LineMode    = "Delete";
                    return(View("_Create", vm));
                }

                try
                {
                    JobConsumptionDocEvents.afterLineDeleteEvent(this, new StockEventArgs(StockLine.StockHeaderId, StockLine.StockLineId), ref db);
                }
                catch (Exception ex)
                {
                    string message = _exception.HandleException(ex);
                    TempData["CSEXC"] += message;
                }

                LogActivity.LogActivityDetail(LogVm.Map(new ActiivtyLogViewModel
                {
                    DocTypeId       = header.DocTypeId,
                    DocId           = header.StockHeaderId,
                    DocLineId       = StockLine.StockLineId,
                    ActivityType    = (int)ActivityTypeContants.Deleted,
                    DocNo           = header.DocNo,
                    xEModifications = Modifications,
                    DocDate         = header.DocDate,
                    DocStatus       = header.Status,
                }));
            }

            return(Json(new { success = true }));
        }
        public ActionResult _CreatePost(StockLineViewModel svm)
        {
            StockHeader temp = new StockHeaderService(_unitOfWork).Find(svm.StockHeaderId);

            StockLine s = Mapper.Map <StockLineViewModel, StockLine>(svm);

            if (svm.StockHeaderSettings != null)
            {
                if (svm.StockHeaderSettings.isMandatoryProcessLine == true && (svm.FromProcessId <= 0 || svm.FromProcessId == null))
                {
                    ModelState.AddModelError("FromProcessId", "The Process field is required");
                }
                if (svm.StockHeaderSettings.isVisibleLineCostCenter == true && svm.StockHeaderSettings.isMandatoryLineCostCenter == true && (!svm.CostCenterId.HasValue))
                {
                    ModelState.AddModelError("CostCenterId", "The CostCenter field is required");
                }
            }

            bool BeforeSave = true;

            try
            {
                if (svm.StockLineId <= 0)
                {
                    BeforeSave = JobConsumptionDocEvents.beforeLineSaveEvent(this, new StockEventArgs(svm.StockHeaderId, EventModeConstants.Add), ref db);
                }
                else
                {
                    BeforeSave = JobConsumptionDocEvents.beforeLineSaveEvent(this, new StockEventArgs(svm.StockHeaderId, EventModeConstants.Edit), ref db);
                }
            }
            catch (Exception ex)
            {
                string message = _exception.HandleException(ex);
                TempData["CSEXCL"] += message;
                EventException      = true;
            }

            if (!BeforeSave)
            {
                ModelState.AddModelError("", "Validation failed before save.");
            }

            if (svm.StockLineId <= 0)
            {
                ViewBag.LineMode = "Create";
            }
            else
            {
                ViewBag.LineMode = "Edit";
            }

            if (ModelState.IsValid && BeforeSave && !EventException)
            {
                if (svm.StockLineId <= 0)
                {
                    StockProcessViewModel StockProcessViewModel = new StockProcessViewModel();
                    StockHeader           StockHeader           = new StockHeaderService(_unitOfWork).Find(temp.StockHeaderId);

                    //Posting in StockProcess
                    if (StockHeader.StockHeaderId != null)
                    {
                        StockProcessViewModel.StockHeaderId = StockHeader.StockHeaderId;
                    }
                    else
                    {
                        StockProcessViewModel.StockHeaderId = 0;
                    }

                    StockProcessViewModel.StockHeaderId       = temp.StockHeaderId;
                    StockProcessViewModel.DocHeaderId         = temp.StockHeaderId;
                    StockProcessViewModel.DocLineId           = s.StockLineId;
                    StockProcessViewModel.DocTypeId           = temp.DocTypeId;
                    StockProcessViewModel.StockHeaderDocDate  = temp.DocDate;
                    StockProcessViewModel.StockProcessDocDate = temp.DocDate;
                    StockProcessViewModel.DocNo              = temp.DocNo;
                    StockProcessViewModel.DivisionId         = temp.DivisionId;
                    StockProcessViewModel.SiteId             = temp.SiteId;
                    StockProcessViewModel.CurrencyId         = null;
                    StockProcessViewModel.HeaderProcessId    = null;
                    StockProcessViewModel.PersonId           = temp.PersonId;
                    StockProcessViewModel.ProductId          = s.ProductId;
                    StockProcessViewModel.HeaderFromGodownId = temp.FromGodownId;
                    StockProcessViewModel.HeaderGodownId     = temp.GodownId;
                    StockProcessViewModel.GodownId           = temp.GodownId ?? 0;
                    StockProcessViewModel.ProcessId          = s.FromProcessId;
                    StockProcessViewModel.LotNo              = s.LotNo;
                    StockProcessViewModel.CostCenterId       = temp.CostCenterId;


                    if (s.Qty > 0)
                    {
                        StockProcessViewModel.Qty_Rec = s.Qty;
                        StockProcessViewModel.Qty_Iss = 0;
                    }
                    else if (s.Qty < 0)
                    {
                        StockProcessViewModel.Qty_Rec = 0;
                        StockProcessViewModel.Qty_Iss = Math.Abs(s.Qty);
                    }

                    StockProcessViewModel.Rate          = s.Rate;
                    StockProcessViewModel.ExpiryDate    = null;
                    StockProcessViewModel.Specification = s.Specification;
                    StockProcessViewModel.Dimension1Id  = s.Dimension1Id;
                    StockProcessViewModel.Dimension2Id  = s.Dimension2Id;
                    StockProcessViewModel.Dimension3Id  = s.Dimension3Id;
                    StockProcessViewModel.Dimension4Id  = s.Dimension4Id;
                    StockProcessViewModel.Remark        = s.Remark;
                    StockProcessViewModel.Status        = temp.Status;
                    StockProcessViewModel.CreatedBy     = temp.CreatedBy;
                    StockProcessViewModel.CreatedDate   = DateTime.Now;
                    StockProcessViewModel.ModifiedBy    = temp.ModifiedBy;
                    StockProcessViewModel.ModifiedDate  = DateTime.Now;

                    string StockProcessPostingError = "";
                    StockProcessPostingError = new StockProcessService(_unitOfWork).StockProcessPostDB(ref StockProcessViewModel, ref db);

                    if (StockProcessPostingError != "")
                    {
                        ModelState.AddModelError("", StockProcessPostingError);
                        return(PartialView("_Create", svm));
                    }

                    s.StockProcessId = StockProcessViewModel.StockProcessId;


                    s.CreatedDate  = DateTime.Now;
                    s.ModifiedDate = DateTime.Now;
                    s.CreatedBy    = User.Identity.Name;
                    s.ModifiedBy   = User.Identity.Name;
                    s.ObjectState  = Model.ObjectState.Added;
                    db.StockLine.Add(s);
                    //_StockLineService.Create(s);

                    //StockHeader header = new StockHeaderService(_unitOfWork).Find(s.StockHeaderId);
                    if (temp.Status != (int)StatusConstants.Drafted)
                    {
                        temp.Status       = (int)StatusConstants.Modified;
                        temp.ModifiedDate = DateTime.Now;
                        temp.ModifiedBy   = User.Identity.Name;
                        temp.ObjectState  = Model.ObjectState.Modified;

                        db.StockHeader.Add(temp);
                        //new StockHeaderService(_unitOfWork).Update(temp);
                    }

                    try
                    {
                        JobConsumptionDocEvents.onLineSaveEvent(this, new StockEventArgs(s.StockHeaderId, s.StockLineId, EventModeConstants.Add), ref db);
                    }
                    catch (Exception ex)
                    {
                        string message = _exception.HandleException(ex);
                        TempData["CSEXCL"] += message;
                        EventException      = true;
                    }

                    try
                    {
                        if (EventException)
                        {
                            throw new Exception();
                        }

                        db.SaveChanges();
                    }

                    catch (Exception ex)
                    {
                        string message = _exception.HandleException(ex);
                        TempData["CSEXCL"] += message;
                        PrepareViewBag(svm);
                        return(PartialView("_Create", svm));
                    }

                    try
                    {
                        JobConsumptionDocEvents.afterLineSaveEvent(this, new StockEventArgs(s.StockHeaderId, s.StockLineId, EventModeConstants.Add), ref db);
                    }
                    catch (Exception ex)
                    {
                        string message = _exception.HandleException(ex);
                        TempData["CSEXCL"] += message;
                    }

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


                    return(RedirectToAction("_Create", new { id = svm.StockHeaderId }));
                }


                else
                {
                    StockLine templine = _StockLineService.Find(s.StockLineId);
                    List <LogTypeViewModel> LogList = new List <LogTypeViewModel>();


                    StockLine ExRec = new StockLine();
                    ExRec = Mapper.Map <StockLine>(templine);

                    templine.Qty = s.Qty;

                    if (templine.StockProcessId != null)
                    {
                        StockProcessViewModel StockProcessViewModel = new StockProcessViewModel();

                        //Posting in StockProcess
                        if (temp.StockHeaderId != null)
                        {
                            StockProcessViewModel.StockHeaderId = temp.StockHeaderId;
                        }
                        else
                        {
                            StockProcessViewModel.StockHeaderId = 0;
                        }

                        StockProcessViewModel.StockProcessId      = templine.StockProcessId ?? 0;
                        StockProcessViewModel.DocHeaderId         = templine.StockHeaderId;
                        StockProcessViewModel.DocLineId           = templine.StockLineId;
                        StockProcessViewModel.DocTypeId           = temp.DocTypeId;
                        StockProcessViewModel.StockHeaderDocDate  = temp.DocDate;
                        StockProcessViewModel.StockProcessDocDate = temp.DocDate;
                        StockProcessViewModel.DocNo              = temp.DocNo;
                        StockProcessViewModel.DivisionId         = temp.DivisionId;
                        StockProcessViewModel.SiteId             = temp.SiteId;
                        StockProcessViewModel.CurrencyId         = null;
                        StockProcessViewModel.HeaderProcessId    = temp.ProcessId;
                        StockProcessViewModel.PersonId           = temp.PersonId;
                        StockProcessViewModel.ProductId          = s.ProductId;
                        StockProcessViewModel.HeaderFromGodownId = null;
                        StockProcessViewModel.HeaderGodownId     = temp.GodownId;
                        StockProcessViewModel.GodownId           = temp.GodownId;
                        StockProcessViewModel.ProcessId          = temp.ProcessId;
                        StockProcessViewModel.LotNo              = templine.LotNo;
                        StockProcessViewModel.CostCenterId       = templine.CostCenterId;

                        if (s.Qty > 0)
                        {
                            StockProcessViewModel.Qty_Rec = s.Qty;
                            StockProcessViewModel.Qty_Iss = 0;
                        }
                        else if (s.Qty < 0)
                        {
                            StockProcessViewModel.Qty_Rec = 0;
                            StockProcessViewModel.Qty_Iss = Math.Abs(s.Qty);
                        }

                        StockProcessViewModel.Rate          = templine.Rate;
                        StockProcessViewModel.ExpiryDate    = null;
                        StockProcessViewModel.Specification = templine.Specification;
                        StockProcessViewModel.Dimension1Id  = templine.Dimension1Id;
                        StockProcessViewModel.Dimension2Id  = templine.Dimension2Id;
                        StockProcessViewModel.Dimension3Id  = templine.Dimension3Id;
                        StockProcessViewModel.Dimension4Id  = templine.Dimension4Id;
                        StockProcessViewModel.Remark        = s.Remark;
                        StockProcessViewModel.Status        = temp.Status;
                        StockProcessViewModel.CreatedBy     = templine.CreatedBy;
                        StockProcessViewModel.CreatedDate   = templine.CreatedDate;
                        StockProcessViewModel.ModifiedBy    = User.Identity.Name;
                        StockProcessViewModel.ModifiedDate  = DateTime.Now;

                        string StockProcessPostingError = "";
                        StockProcessPostingError = new StockProcessService(_unitOfWork).StockProcessPostDB(ref StockProcessViewModel, ref db);

                        if (StockProcessPostingError != "")
                        {
                            ModelState.AddModelError("", StockProcessPostingError);
                            return(PartialView("_Create", svm));
                        }
                    }


                    templine.Remark = s.Remark;


                    templine.ModifiedDate = DateTime.Now;
                    templine.ModifiedBy   = User.Identity.Name;
                    templine.ObjectState  = Model.ObjectState.Modified;
                    db.StockLine.Add(templine);
                    //_StockLineService.Update(templine);

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

                        temp.ModifiedBy   = User.Identity.Name;
                        temp.ModifiedDate = DateTime.Now;

                        temp.ObjectState = Model.ObjectState.Modified;
                        db.StockHeader.Add(temp);
                        //new StockHeaderService(_unitOfWork).Update(temp);
                    }


                    LogList.Add(new LogTypeViewModel
                    {
                        ExObj = ExRec,
                        Obj   = templine,
                    });

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

                    try
                    {
                        JobConsumptionDocEvents.onLineSaveEvent(this, new StockEventArgs(s.StockHeaderId, templine.StockLineId, EventModeConstants.Edit), ref db);
                    }
                    catch (Exception ex)
                    {
                        string message = _exception.HandleException(ex);
                        TempData["CSEXC"] += message;
                        EventException     = true;
                    }

                    try
                    {
                        if (EventException)
                        {
                            throw new Exception();
                        }
                        db.SaveChanges();
                    }

                    catch (Exception ex)
                    {
                        string message = _exception.HandleException(ex);
                        TempData["CSEXCL"] += message;
                        PrepareViewBag(svm);
                        return(PartialView("_Create", svm));
                    }

                    try
                    {
                        JobConsumptionDocEvents.afterLineSaveEvent(this, new StockEventArgs(s.StockHeaderId, templine.StockLineId, EventModeConstants.Edit), ref db);
                    }
                    catch (Exception ex)
                    {
                        string message = _exception.HandleException(ex);
                        TempData["CSEXC"] += message;
                    }

                    //Saving the Activity Log

                    LogActivity.LogActivityDetail(LogVm.Map(new ActiivtyLogViewModel
                    {
                        DocTypeId       = temp.DocTypeId,
                        DocId           = templine.StockHeaderId,
                        DocLineId       = templine.StockLineId,
                        ActivityType    = (int)ActivityTypeContants.Modified,
                        DocNo           = temp.DocNo,
                        xEModifications = Modifications,
                        DocDate         = temp.DocDate,
                        DocStatus       = temp.Status,
                    }));
                    //End of Saving the Activity Log

                    return(Json(new { success = true }));
                }
            }
            PrepareViewBag(svm);
            return(PartialView("_Create", svm));
        }