Exemplo n.º 1
0
        public JobReceiveQAPenalty Create(JobReceiveQAPenalty pt, string UserName)
        {
            pt.CreatedBy    = UserName;
            pt.CreatedDate  = DateTime.Now;
            pt.ModifiedBy   = UserName;
            pt.ModifiedDate = DateTime.Now;

            pt.ObjectState = ObjectState.Added;
            db.JobReceiveQAPenalty.Add(pt);

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

                JobReceiveQALine Line = db.JobReceiveQALine.Find(pt.JobReceiveQALineId);
                Line.PenaltyAmt  = TotalPenalty;
                Line.ObjectState = ObjectState.Modified;
                db.JobReceiveQALine.Add(Line);
            }

            return(pt);
        }
Exemplo n.º 2
0
        public JobReceiveQALine Create(JobReceiveQAAttributeViewModel pt, string UserName)
        {
            JobReceiveQAHeader header = new JobReceiveQAHeader();

            header = Mapper.Map <JobReceiveQAAttributeViewModel, JobReceiveQAHeader>(pt);
            _JobReceiveQAHeaderService.Create(header, UserName);

            JobReceiveQALine Line = Mapper.Map <JobReceiveQAAttributeViewModel, JobReceiveQALine>(pt);

            Line.Sr          = new JobReceiveQALineService(db, _unitOfWork).GetMaxSr(Line.JobReceiveQAHeaderId);
            Line.FailQty     = Line.QAQty - Line.Qty;
            Line.FailDealQty = Line.FailQty * Line.UnitConversionMultiplier;
            new JobReceiveLineStatusService(_unitOfWork).UpdateJobReceiveQtyOnQA(Mapper.Map <JobReceiveQALineViewModel>(Line), pt.DocDate, ref db);
            new JobReceiveQALineService(db, _unitOfWork).Create(Line, UserName);

            JobReceiveQALineExtended LineExtended = new JobReceiveQALineExtended();

            LineExtended.JobReceiveQALineId = Line.JobReceiveQALineId;
            LineExtended.Length             = pt.Length;
            LineExtended.Width       = pt.Width;
            LineExtended.Height      = pt.Height;
            LineExtended.ObjectState = ObjectState.Added;
            db.JobReceiveQALineExtended.Add(LineExtended);


            List <QAGroupLineLineViewModel> tem = pt.QAGroupLine;

            if (tem != null)
            {
                foreach (var item in tem)
                {
                    JobReceiveQAAttribute pa = new JobReceiveQAAttribute();
                    pa.JobReceiveQALineId = Line.JobReceiveQALineId;
                    pa.QAGroupLineId      = item.QAGroupLineId;
                    pa.Value        = item.Value;
                    pa.Remark       = item.Remarks;
                    pa.CreatedBy    = UserName;
                    pa.ModifiedBy   = UserName;
                    pa.CreatedDate  = DateTime.Now;
                    pa.ModifiedDate = DateTime.Now;
                    pa.ObjectState  = ObjectState.Added;
                    db.JobReceiveQAAttribute.Add(pa);
                }
            }

            return(Line);
        }
        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));
        }
Exemplo n.º 4
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));
                }
            }
        }