コード例 #1
0
        public ActionResult Post(JobReceiveQAAttributeViewModel vm)
        {
            if (ModelState.IsValid)
            {
                #region CreateRecord
                if (vm.JobReceiveQALineId <= 0)
                {
                    JobReceiveQALine Line = new JobReceiveQALine();
                    Line = _JobReceiveQAAttributeService.Create(vm, User.Identity.Name);



                    try
                    {
                        db.SaveChanges();
                    }

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

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


                    return(RedirectToAction("Edit", new { id = Line.JobReceiveQALineId }).Success("Data saved successfully"));
                }
                #endregion

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

                    JobReceiveQAHeader temp = new JobReceiveQAHeaderService(db).Find(vm.JobReceiveQAHeaderId);

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


                    int status = temp.Status;

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


                    _JobReceiveQAAttributeService.Update(vm, User.Identity.Name);

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

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

                    try
                    {
                        JobReceiveQADocEvents.onHeaderSaveEvent(this, new JobEventArgs(temp.JobReceiveQAHeaderId, 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["CSEXC"] += message;
                        PrepareViewBag(temp.DocTypeId);
                        ViewBag.Mode = "Edit";
                        return(View("Create", vm));
                    }

                    try
                    {
                        JobReceiveQADocEvents.afterHeaderSaveEvent(this, new JobEventArgs(temp.JobReceiveQAHeaderId, 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.JobReceiveQAHeaderId,
                        ActivityType    = (int)ActivityTypeContants.Modified,
                        DocNo           = temp.DocNo,
                        DocDate         = temp.DocDate,
                        xEModifications = Modifications,
                        DocStatus       = temp.Status,
                    }));

                    return(RedirectToAction("Index", new { id = temp.DocTypeId }).Success("Data saved successfully"));
                }
                #endregion
            }
            PrepareViewBag(vm.DocTypeId);
            ViewBag.Mode = "Add";
            return(View("Create", vm));
        }
コード例 #2
0
        public ActionResult _CreatePost(JobReceiveQAPenaltyViewModel svm)
        {
            JobReceiveQALine    L    = new JobReceiveQALineService(db, _unitOfWork).Find(svm.JobReceiveQALineId);
            JobReceiveQAPenalty s    = Mapper.Map <JobReceiveQAPenaltyViewModel, JobReceiveQAPenalty>(svm);
            JobReceiveQAHeader  temp = new JobReceiveQAHeaderService(db).Find(L.JobReceiveQAHeaderId);

            #region BeforeSave
            bool BeforeSave = true;
            try
            {
                if (svm.JobReceiveQAPenaltyId <= 0)
                {
                    BeforeSave = JobReceiveQADocEvents.beforeLineSaveEvent(this, new JobEventArgs(svm.JobReceiveQAPenaltyId, EventModeConstants.Add), ref db);
                }
                else
                {
                    BeforeSave = JobReceiveQADocEvents.beforeLineSaveEvent(this, new JobEventArgs(svm.JobReceiveQAPenaltyId, 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.");
            }
            #endregion


            var settings = new JobReceiveQASettingsService(db).GetJobReceiveQASettingsForDocument(temp.DocTypeId, temp.DivisionId, temp.SiteId);

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



            //if (svm.JobReceiveLineId <= 0)
            //    ModelState.AddModelError("JobReceiveLineId", "The JobReceiveLine field is required");

            if (ModelState.IsValid && BeforeSave && !EventException)
            {
                if (svm.JobReceiveQAPenaltyId <= 0)
                {
                    _JobReceiveQAPenaltyService.Create(s, User.Identity.Name);



                    try
                    {
                        db.SaveChanges();
                    }

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



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

                    return(RedirectToAction("_Create", new { id = svm.JobReceiveQALineId }));
                }
                else
                {
                    List <LogTypeViewModel> LogList = new List <LogTypeViewModel>();


                    StringBuilder       logstring = new StringBuilder();
                    JobReceiveQAPenalty temp1     = _JobReceiveQAPenaltyService.Find(svm.JobReceiveQAPenaltyId);


                    JobReceiveQAPenalty ExRec = new JobReceiveQAPenalty();
                    ExRec = Mapper.Map <JobReceiveQAPenalty>(temp1);

                    temp1.ReasonId = svm.ReasonId;
                    temp1.Amount   = svm.Amount;
                    temp1.Remark   = svm.Remark;

                    _JobReceiveQAPenaltyService.Update(temp1, User.Identity.Name);


                    //List<JobReceiveQAPenalty> PenaltyLines = (from Pl in db.JobReceiveQAPenalty where Pl.JobReceiveQALineId == L.JobReceiveQALineId select Pl).ToList();



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

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

                    List <JobReceiveQAPenalty> PenaltyLinesList = (from Pl in db.JobReceiveQAPenalty where Pl.JobReceiveQALineId == L.JobReceiveQALineId && Pl.JobReceiveQAPenaltyId != svm.JobReceiveQAPenaltyId select Pl).ToList();
                    Decimal TotalPenalty = 0;
                    if (PenaltyLinesList.Count() != 0)
                    {
                        TotalPenalty = PenaltyLinesList.Sum(i => i.Amount) + svm.Amount;
                    }
                    else
                    {
                        TotalPenalty = svm.Amount;
                    }

                    L.PenaltyAmt = TotalPenalty;
                    new JobReceiveQALineService(db, _unitOfWork).Update(L, User.Identity.Name);

                    new JobReceiveQAHeaderService(db).Update(temp, User.Identity.Name);

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

                    try
                    {
                        JobReceiveQADocEvents.onLineSaveEvent(this, new JobEventArgs(temp.JobReceiveQAHeaderId, temp1.JobReceiveQAPenaltyId, 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();
                        return(PartialView("_Create", svm));
                    }

                    try
                    {
                        JobReceiveQADocEvents.afterLineSaveEvent(this, new JobEventArgs(temp.JobReceiveQAHeaderId, temp1.JobReceiveQAPenaltyId, 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.JobReceiveQAHeaderId,
                        DocLineId       = temp1.JobReceiveQAPenaltyId,
                        ActivityType    = (int)ActivityTypeContants.Modified,
                        DocNo           = temp.DocNo,
                        xEModifications = Modifications,
                        DocDate         = temp.DocDate,
                        DocStatus       = temp.Status,
                    }));


                    return(Json(new { success = true }));
                }
            }
            PrepareViewBag();
            return(PartialView("_Create", svm));
        }
コード例 #3
0
        public ActionResult ConfirmedJobReceives(List <JobReceiveQAWizardViewModel> ConfirmedList, int DocTypeId, string UserRemark, int QAById)
        {
            //System.Web.HttpContext.Current.Session["BalanceQtyAmendmentWizardOrders"] = ConfirmedList;
            //return Json(new { Success = "URL", Data = "/JobReceiveQAWizard/Create/" + DocTypeId }, JsonRequestBehavior.AllowGet);

            if (ConfirmedList.Count() > 0 && ConfirmedList.GroupBy(m => m.JobWorkerId).Count() > 1)
            {
                return(Json(new { Success = false, Data = " Multiple Headers are selected. " }, JsonRequestBehavior.AllowGet));
            }
            else if (ConfirmedList.Count() == 0)
            {
                return(Json(new { Success = false, Data = " No Records are selected. " }, JsonRequestBehavior.AllowGet));
            }
            else
            {
                int DivisionId = (int)System.Web.HttpContext.Current.Session["DivisionId"];
                int SiteId     = (int)System.Web.HttpContext.Current.Session["SiteId"];

                bool BeforeSave = true;
                int  Serial     = 1;
                List <JobReceiveQALineViewModel> LineStatus = new List <JobReceiveQALineViewModel>();

                try
                {
                    BeforeSave = JobReceiveQADocEvents.beforeWizardSaveEvent(this, new JobEventArgs(0), ref db);
                }
                catch (Exception ex)
                {
                    string message = _exception.HandleException(ex);
                    return(Json(new { Success = false, Data = message }, JsonRequestBehavior.AllowGet));
                }


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


                int Cnt = 0;
                int Sr  = 0;


                JobReceiveQASettings Settings = new JobReceiveQASettingsService(db).GetJobReceiveQASettingsForDocument(DocTypeId, DivisionId, SiteId);

                int?MaxLineId = 0;

                if (ModelState.IsValid && BeforeSave && !EventException)
                {
                    JobReceiveQAHeader pt = new JobReceiveQAHeader();

                    //Getting Settings
                    pt.SiteId       = SiteId;
                    pt.JobWorkerId  = ConfirmedList.FirstOrDefault().JobWorkerId;
                    pt.DivisionId   = DivisionId;
                    pt.QAById       = QAById;
                    pt.ProcessId    = Settings.ProcessId;
                    pt.Remark       = UserRemark;
                    pt.DocTypeId    = DocTypeId;
                    pt.DocDate      = DateTime.Now;
                    pt.DocNo        = new DocumentTypeService(_unitOfWork).FGetNewDocNo("DocNo", ConfigurationManager.AppSettings["DataBaseSchema"] + ".JobReceiveQAHeaders", pt.DocTypeId, pt.DocDate, pt.DivisionId, pt.SiteId);
                    pt.ModifiedBy   = User.Identity.Name;
                    pt.ModifiedDate = DateTime.Now;
                    pt.CreatedBy    = User.Identity.Name;
                    pt.CreatedDate  = DateTime.Now;

                    pt.Status      = (int)StatusConstants.Drafted;
                    pt.ObjectState = Model.ObjectState.Added;

                    db.JobReceiveQAHeader.Add(pt);

                    var SelectedJobReceives = ConfirmedList;

                    var JobReceiveLineIds = SelectedJobReceives.Select(m => m.JobReceiveLineId).ToArray();

                    var JobReceiveBalanceRecords = (from p in db.ViewJobReceiveBalanceForQA
                                                    where JobReceiveLineIds.Contains(p.JobReceiveLineId)
                                                    select p).AsNoTracking().ToList();

                    var JobReceiveRecords = (from p in db.JobReceiveLine.Include(m => m.JobOrderLine)
                                             where JobReceiveLineIds.Contains(p.JobReceiveLineId)
                                             select p).AsNoTracking().ToList();

                    foreach (var item in SelectedJobReceives)
                    {
                        JobReceiveLine Recline    = JobReceiveRecords.Where(m => m.JobReceiveLineId == item.JobReceiveLineId).FirstOrDefault();
                        var            balRecline = JobReceiveBalanceRecords.Where(m => m.JobReceiveLineId == item.JobReceiveLineId).FirstOrDefault();

                        if (item.InspectionQty <= JobReceiveBalanceRecords.Where(m => m.JobReceiveLineId == item.JobReceiveLineId).FirstOrDefault().BalanceQty)
                        {
                            JobReceiveQALine line = new JobReceiveQALine();

                            line.JobReceiveQAHeaderId = pt.JobReceiveQAHeaderId;
                            line.JobReceiveLineId     = item.JobReceiveLineId;
                            line.QAQty = balRecline.BalanceQty;
                            line.UnitConversionMultiplier = Recline.JobOrderLine.UnitConversionMultiplier;
                            line.Qty                = item.Qty;
                            line.DealQty            = line.Qty * line.UnitConversionMultiplier;
                            line.FailQty            = line.QAQty - line.Qty;
                            line.FailDealQty        = line.FailQty * line.UnitConversionMultiplier;
                            line.InspectedQty       = item.InspectionQty;
                            line.PenaltyAmt         = item.PenaltyAmount;
                            line.Remark             = item.Remark;
                            line.ProductUidId       = Recline.ProductUidId;
                            line.Sr                 = Serial++;
                            line.JobReceiveQALineId = Cnt;
                            line.CreatedDate        = DateTime.Now;
                            line.ModifiedDate       = DateTime.Now;
                            line.CreatedBy          = User.Identity.Name;
                            line.ModifiedBy         = User.Identity.Name;
                            LineStatus.Add(Mapper.Map <JobReceiveQALineViewModel>(line));

                            line.ObjectState = Model.ObjectState.Added;
                            db.JobReceiveQALine.Add(line);
                            Cnt = Cnt + 1;
                        }
                    }

                    new JobReceiveLineStatusService(_unitOfWork).UpdateJobReceiveQtyQAMultiple(LineStatus, pt.DocDate, ref db);

                    try
                    {
                        JobReceiveQADocEvents.onWizardSaveEvent(this, new JobEventArgs(pt.JobReceiveQAHeaderId, 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);
                        return(Json(new { Success = false, Data = message }, JsonRequestBehavior.AllowGet));
                    }

                    try
                    {
                        JobReceiveQADocEvents.afterWizardSaveEvent(this, new JobEventArgs(pt.JobReceiveQAHeaderId, EventModeConstants.Add), ref db);
                    }
                    catch (Exception ex)
                    {
                        string message = _exception.HandleException(ex);
                        TempData["CSEXC"] += message;
                    }

                    LogActivity.LogActivityDetail(new ActiivtyLogViewModel
                    {
                        DocTypeId    = pt.DocTypeId,
                        DocId        = pt.JobReceiveQAHeaderId,
                        ActivityType = (int)ActivityTypeContants.Added,
                        User         = User.Identity.Name,
                        DocNo        = pt.DocNo,
                        DocDate      = pt.DocDate
                    });

                    return(Json(new { Success = "URL", Data = "/JobReceiveQAHeader/Submit/" + pt.JobReceiveQAHeaderId }, JsonRequestBehavior.AllowGet));
                }

                else
                {
                    return(Json(new { Success = false, Data = "ModelState is Invalid" }, JsonRequestBehavior.AllowGet));
                }
            }
        }
コード例 #4
0
        public ActionResult DeletePost(JobReceiveQAPenaltyViewModel vm)
        {
            JobReceiveQALine L = new JobReceiveQALineService(db, _unitOfWork).Find(vm.JobReceiveQALineId);

            #region BeforeSave
            bool BeforeSave = true;
            try
            {
                BeforeSave = JobReceiveQADocEvents.beforeLineDeleteEvent(this, new JobEventArgs(L.JobReceiveQAHeaderId, vm.JobReceiveQAPenaltyId), ref db);
            }
            catch (Exception ex)
            {
                string message = _exception.HandleException(ex);
                TempData["CSEXC"] += message;
                EventException     = true;
            }

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

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


                JobReceiveQAPenalty JobReceiveQAPenalty = (from p in db.JobReceiveQAPenalty
                                                           where p.JobReceiveQAPenaltyId == vm.JobReceiveQAPenaltyId
                                                           select p).FirstOrDefault();

                JobReceiveQAHeader header = new JobReceiveQAHeaderService(db).Find(L.JobReceiveQAHeaderId);

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


                _JobReceiveQAPenaltyService.Delete(JobReceiveQAPenalty);



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

                    new JobReceiveQAHeaderService(db).Update(header, User.Identity.Name);
                }

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

                try
                {
                    JobReceiveQADocEvents.onLineDeleteEvent(this, new JobEventArgs(L.JobReceiveQAHeaderId, JobReceiveQAPenalty.JobReceiveQAPenaltyId), 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();
                    ViewBag.LineMode = "Delete";
                    return(PartialView("_Create", vm));
                }

                try
                {
                    JobReceiveQADocEvents.afterLineDeleteEvent(this, new JobEventArgs(L.JobReceiveQAHeaderId, JobReceiveQAPenalty.JobReceiveQAPenaltyId), ref db);
                }
                catch (Exception ex)
                {
                    string message = _exception.HandleException(ex);
                    TempData["CSEXC"] += message;
                }

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

            return(Json(new { success = true }));
        }