public ActionResult _Create(int Id, int sid) //Id ==>Sale Order Header Id
        {
            SaleDeliveryOrderCancelHeader        H   = new SaleDeliveryOrderCancelHeaderService(_unitOfWork).Find(Id);
            SaleDeliveryOrderCancelLineViewModel svm = new SaleDeliveryOrderCancelLineViewModel();

            //Getting Settings
            var settings = new SaleDeliveryOrderSettingsService(_unitOfWork).GetSaleDeliveryOrderSettingsForDocument(H.DocTypeId, H.DivisionId, H.SiteId);

            svm.SaleDeliveryOrderSettings = Mapper.Map <SaleDeliveryOrderSettings, SaleDeliveryOrderSettingsViewModel>(settings);

            svm.SaleDeliveryOrderCancelHeaderId = Id;
            svm.BuyerId      = sid;
            ViewBag.LineMode = "Create";
            return(PartialView("_Create", svm));
        }
        public ActionResult _Detail(int id)
        {
            SaleDeliveryOrderCancelLineViewModel temp = _SaleDeliveryOrderCancelLineService.GetSaleDeliveryOrderCancelLine(id);

            if (temp == null)
            {
                return(HttpNotFound());
            }

            SaleDeliveryOrderCancelHeader H = new SaleDeliveryOrderCancelHeaderService(_unitOfWork).Find(temp.SaleDeliveryOrderCancelHeaderId);

            //Getting Settings
            var settings = new SaleDeliveryOrderSettingsService(_unitOfWork).GetSaleDeliveryOrderSettingsForDocument(H.DocTypeId, H.DivisionId, H.SiteId);

            temp.SaleDeliveryOrderSettings = Mapper.Map <SaleDeliveryOrderSettings, SaleDeliveryOrderSettingsViewModel>(settings);

            return(PartialView("_Create", temp));
        }
        private ActionResult _Delete(int id)
        {
            var line = _SaleDeliveryOrderCancelLineService.GetSaleDeliveryOrderCancelLine(id);

            if (line == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            #region DocTypeTimeLineValidation
            try
            {
                TimePlanValidation = DocumentValidation.ValidateDocumentLine(new DocumentUniqueId {
                    LockReason = line.LockReason
                }, User.Identity.Name, out ExceptionMsg, out Continue);
            }
            catch (Exception ex)
            {
                string message = _exception.HandleException(ex);
                TempData["CSEXCL"] += message;
                TimePlanValidation  = false;
            }

            if (!TimePlanValidation)
            {
                TempData["CSEXCL"] += ExceptionMsg;
            }
            #endregion

            if ((TimePlanValidation || Continue))
            {
                ViewBag.LineMode = "Delete";
            }

            SaleDeliveryOrderCancelHeader H = new SaleDeliveryOrderCancelHeaderService(_unitOfWork).Find(line.SaleDeliveryOrderCancelHeaderId);

            //Getting Settings
            var settings = new SaleDeliveryOrderSettingsService(_unitOfWork).GetSaleDeliveryOrderSettingsForDocument(H.DocTypeId, H.DivisionId, H.SiteId);

            line.SaleDeliveryOrderSettings = Mapper.Map <SaleDeliveryOrderSettings, SaleDeliveryOrderSettingsViewModel>(settings);
            return(PartialView("_Create", line));
        }
        public ActionResult _ResultsPost(SaleDeliveryOrderCancelMasterDetailModel vm)
        {
            int Serial = _SaleDeliveryOrderCancelLineService.GetMaxSr(vm.SaleDeliveryOrderCancelViewModels.FirstOrDefault().SaleDeliveryOrderCancelHeaderId);
            Dictionary <int, decimal> LineStatus = new Dictionary <int, decimal>();
            var Header = new SaleDeliveryOrderCancelHeaderService(_unitOfWork).Find(vm.SaleDeliveryOrderCancelViewModels.FirstOrDefault().SaleDeliveryOrderCancelHeaderId);

            bool BeforeSave = true;

            //try
            //{
            //    BeforeSave = SaleDeliveryOrderCancelDocEvents.beforeLineSaveBulkEvent(this, new SaleDeliveryEventArgs(vm.SaleDeliveryOrderCancelViewModels.FirstOrDefault().SaleDeliveryOrderCancelHeaderId), ref db);
            //}
            //catch (Exception ex)
            //{
            //    string message = _exception.HandleException(ex);
            //    TempData["CSEXCL"] += message;
            //    EventException = true;
            //}

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


            if (ModelState.IsValid && BeforeSave && !EventException)
            {
                foreach (var item in vm.SaleDeliveryOrderCancelViewModels)
                {
                    decimal balqty = (from p in db.ViewSaleDeliveryOrderBalance
                                      where p.SaleDeliveryOrderLineId == item.SaleDeliveryOrderLineId
                                      select p.BalanceQty).FirstOrDefault();

                    if (item.Qty > 0 && item.Qty <= balqty)
                    {
                        SaleDeliveryOrderCancelLine line = new SaleDeliveryOrderCancelLine();

                        line.SaleDeliveryOrderCancelHeaderId = item.SaleDeliveryOrderCancelHeaderId;
                        line.SaleDeliveryOrderLineId         = item.SaleDeliveryOrderLineId;
                        line.Qty          = item.Qty;
                        line.Sr           = Serial++;
                        line.CreatedDate  = DateTime.Now;
                        line.ModifiedDate = DateTime.Now;
                        line.CreatedBy    = User.Identity.Name;
                        line.ModifiedBy   = User.Identity.Name;
                        line.Remark       = item.Remark;

                        LineStatus.Add(line.SaleDeliveryOrderLineId, line.Qty);

                        line.ObjectState = Model.ObjectState.Added;
                        db.SaleDeliveryOrderCancelLine.Add(line);

                        //_SaleDeliveryOrderCancelLineService.Create(line);
                    }
                }

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

                    Header.ObjectState = Model.ObjectState.Modified;

                    db.SaleDeliveryOrderCancelHeader.Add(Header);
                }

                //new SaleDeliveryOrderLineStatusService(_unitOfWork).UpdateSaleDeliveryQtyCancelMultiple(LineStatus, Header.DocDate, ref db);

                //try
                //{
                //    SaleDeliveryOrderCancelDocEvents.onLineSaveBulkEvent(this, new SaleDeliveryEventArgs(vm.SaleDeliveryOrderCancelViewModels.FirstOrDefault().SaleDeliveryOrderCancelHeaderId), ref db);
                //}
                //catch (Exception ex)
                //{
                //    string message = _exception.HandleException(ex);
                //    TempData["CSEXCL"] += message;
                //    EventException = true;
                //}

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

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

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

                //try
                //{
                //    SaleDeliveryOrderCancelDocEvents.afterLineSaveBulkEvent(this, new SaleDeliveryEventArgs(vm.SaleDeliveryOrderCancelViewModels.FirstOrDefault().SaleDeliveryOrderCancelHeaderId), ref db);
                //}
                //catch (Exception ex)
                //{
                //    string message = _exception.HandleException(ex);
                //    TempData["CSEXC"] += message;
                //}

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

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

            //try
            //{
            //    BeforeSave = SaleDeliveryOrderCancelDocEvents.beforeLineDeleteEvent(this, new SaleDeliveryEventArgs(vm.SaleDeliveryOrderCancelHeaderId, vm.SaleDeliveryOrderCancelLineId), 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)
            {
                List <LogTypeViewModel> LogList = new List <LogTypeViewModel>();

                SaleDeliveryOrderCancelLine SaleDeliveryOrderCancelLine = db.SaleDeliveryOrderCancelLine.Find(vm.SaleDeliveryOrderCancelLineId);

                //try
                //{
                //    SaleDeliveryOrderCancelDocEvents.onLineDeleteEvent(this, new SaleDeliveryEventArgs(SaleDeliveryOrderCancelLine.SaleDeliveryOrderCancelHeaderId, SaleDeliveryOrderCancelLine.SaleDeliveryOrderCancelLineId), ref db);
                //}
                //catch (Exception ex)
                //{
                //    string message = _exception.HandleException(ex);
                //    TempData["CSEXCL"] += message;
                //    EventException = true;
                //}

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

                SaleDeliveryOrderCancelHeader header = new SaleDeliveryOrderCancelHeaderService(_unitOfWork).Find(SaleDeliveryOrderCancelLine.SaleDeliveryOrderCancelHeaderId);
                //new SaleDeliveryOrderLineStatusService(_unitOfWork).UpdateSaleDeliveryQtyOnCancel(SaleDeliveryOrderCancelLine.SaleDeliveryOrderLineId, SaleDeliveryOrderCancelLine.SaleDeliveryOrderCancelLineId, header.DocDate, 0, ref db, true);

                //_SaleDeliveryOrderCancelLineService.Delete(vm.SaleDeliveryOrderCancelLineId);

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


                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.SaleDeliveryOrderCancelHeader.Add(header);
                    //new SaleDeliveryOrderCancelHeaderService(_unitOfWork).Update(header);
                }
                XElement Modifications = new ModificationsCheckService().CheckChanges(LogList);
                try
                {
                    if (EventException)
                    {
                        throw new Exception();
                    }

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

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

                //try
                //{
                //    SaleDeliveryOrderCancelDocEvents.afterLineDeleteEvent(this, new SaleDeliveryEventArgs(SaleDeliveryOrderCancelLine.SaleDeliveryOrderCancelHeaderId, SaleDeliveryOrderCancelLine.SaleDeliveryOrderCancelLineId), ref db);
                //}
                //catch (Exception ex)
                //{
                //    string message = _exception.HandleException(ex);
                //    TempData["CSEXC"] += message;
                //}

                LogActivity.LogActivityDetail(LogVm.Map(new ActiivtyLogViewModel
                {
                    DocTypeId       = header.DocTypeId,
                    DocId           = header.SaleDeliveryOrderCancelHeaderId,
                    DocLineId       = SaleDeliveryOrderCancelLine.SaleDeliveryOrderCancelLineId,
                    ActivityType    = (int)ActivityTypeContants.Deleted,
                    DocNo           = header.DocNo,
                    xEModifications = Modifications,
                    DocDate         = header.DocDate,
                    DocStatus       = header.Status,
                }));
            }
            return(Json(new { success = true }));
        }
        public ActionResult _CreatePost(SaleDeliveryOrderCancelLineViewModel svm)
        {
            if (svm.SaleDeliveryOrderLineId <= 0)
            {
                ViewBag.LineMode = "Create";
            }
            else
            {
                ViewBag.LineMode = "Edit";
            }

            bool BeforeSave = true;

            //try
            //{

            //    if (svm.SaleDeliveryOrderCancelLineId <= 0)
            //        BeforeSave = SaleDeliveryOrderCancelDocEvents.beforeLineSaveEvent(this, new SaleDeliveryEventArgs(svm.SaleDeliveryOrderCancelHeaderId, EventModeConstants.Add), ref db);
            //    else
            //        BeforeSave = SaleDeliveryOrderCancelDocEvents.beforeLineSaveEvent(this, new SaleDeliveryEventArgs(svm.SaleDeliveryOrderCancelHeaderId, 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.SaleDeliveryOrderCancelLineId <= 0)
            {
                SaleDeliveryOrderCancelLine s = new SaleDeliveryOrderCancelLine();
                decimal balqty = (from p in db.ViewSaleDeliveryOrderBalance
                                  where p.SaleDeliveryOrderLineId == svm.SaleDeliveryOrderLineId
                                  select p.BalanceQty).FirstOrDefault();
                if (balqty < svm.Qty)
                {
                    ModelState.AddModelError("Qty", "Qty Exceeding Balance Qty");
                }
                if (svm.Qty == 0)
                {
                    ModelState.AddModelError("Qty", "Please Check Qty");
                }
                if (ModelState.IsValid && BeforeSave && !EventException)
                {
                    s.Remark = svm.Remark;
                    s.SaleDeliveryOrderCancelHeaderId = svm.SaleDeliveryOrderCancelHeaderId;
                    s.SaleDeliveryOrderLineId         = svm.SaleDeliveryOrderLineId;
                    s.Qty          = svm.Qty;
                    s.Sr           = _SaleDeliveryOrderCancelLineService.GetMaxSr(s.SaleDeliveryOrderCancelHeaderId);
                    s.CreatedDate  = DateTime.Now;
                    s.ModifiedDate = DateTime.Now;
                    s.CreatedBy    = User.Identity.Name;
                    s.ModifiedBy   = User.Identity.Name;
                    s.ObjectState  = Model.ObjectState.Added;
                    db.SaleDeliveryOrderCancelLine.Add(s);
                    //_SaleDeliveryOrderCancelLineService.Create(s);

                    SaleDeliveryOrderCancelHeader temp2 = new SaleDeliveryOrderCancelHeaderService(_unitOfWork).Find(s.SaleDeliveryOrderCancelHeaderId);


                    //new SaleDeliveryOrderLineStatusService(_unitOfWork).UpdateSaleDeliveryQtyOnCancel(s.SaleDeliveryOrderLineId, s.SaleDeliveryOrderCancelLineId, temp2.DocDate, s.Qty, ref db, true);


                    if (temp2.Status != (int)StatusConstants.Drafted)
                    {
                        temp2.Status       = (int)StatusConstants.Modified;
                        temp2.ModifiedBy   = User.Identity.Name;
                        temp2.ModifiedDate = DateTime.Now;
                        temp2.ObjectState  = Model.ObjectState.Modified;
                        db.SaleDeliveryOrderCancelHeader.Add(temp2);
                    }

                    //new SaleDeliveryOrderCancelHeaderService(_unitOfWork).Update(temp2);

                    //try
                    //{
                    //    SaleDeliveryOrderCancelDocEvents.onLineSaveEvent(this, new SaleDeliveryEventArgs(s.SaleDeliveryOrderCancelHeaderId, s.SaleDeliveryOrderCancelLineId, 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();
                        //_unitOfWork.Save();
                    }

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

                    //try
                    //{
                    //    SaleDeliveryOrderCancelDocEvents.afterLineSaveEvent(this, new SaleDeliveryEventArgs(s.SaleDeliveryOrderCancelHeaderId, s.SaleDeliveryOrderCancelLineId, EventModeConstants.Add), ref db);
                    //}
                    //catch (Exception ex)
                    //{
                    //    string message = _exception.HandleException(ex);
                    //    TempData["CSEXCL"] += message;
                    //}

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

                    return(RedirectToAction("_Create", new { id = s.SaleDeliveryOrderCancelHeaderId, sid = svm.BuyerId }));
                }
                return(PartialView("_Create", svm));
            }
            else
            {
                List <LogTypeViewModel> LogList = new List <LogTypeViewModel>();


                SaleDeliveryOrderCancelHeader temp = new SaleDeliveryOrderCancelHeaderService(_unitOfWork).Find(svm.SaleDeliveryOrderCancelHeaderId);
                int           status    = temp.Status;
                StringBuilder logstring = new StringBuilder();

                SaleDeliveryOrderCancelLine s = db.SaleDeliveryOrderCancelLine.Find(svm.SaleDeliveryOrderCancelLineId);


                SaleDeliveryOrderCancelLine ExRec = new SaleDeliveryOrderCancelLine();
                ExRec = Mapper.Map <SaleDeliveryOrderCancelLine>(s);


                decimal balqty = (from p in db.ViewSaleDeliveryOrderBalance
                                  where p.SaleDeliveryOrderLineId == svm.SaleDeliveryOrderLineId
                                  select p.BalanceQty).FirstOrDefault();
                if (balqty + s.Qty < svm.Qty)
                {
                    ModelState.AddModelError("Qty", "Qty Exceeding Balance Qty");
                }


                if (ModelState.IsValid && BeforeSave && !EventException)
                {
                    if (svm.Qty > 0)
                    {
                        s.Remark       = svm.Remark;
                        s.Qty          = svm.Qty;
                        s.ModifiedBy   = User.Identity.Name;
                        s.ModifiedDate = DateTime.Now;

                        //new SaleDeliveryOrderLineStatusService(_unitOfWork).UpdateSaleDeliveryQtyOnCancel(s.SaleDeliveryOrderLineId, s.SaleDeliveryOrderCancelLineId, temp.DocDate, s.Qty, ref db, true);
                    }

                    //_SaleDeliveryOrderCancelLineService.Update(s);
                    s.ObjectState = Model.ObjectState.Modified;
                    db.SaleDeliveryOrderCancelLine.Add(s);

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

                    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.SaleDeliveryOrderCancelHeader.Add(temp);
                        //new SaleDeliveryOrderCancelHeaderService(_unitOfWork).Update(temp);
                    }

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

                    //try
                    //{
                    //    SaleDeliveryOrderCancelDocEvents.onLineSaveEvent(this, new SaleDeliveryEventArgs(s.SaleDeliveryOrderCancelHeaderId, s.SaleDeliveryOrderCancelLineId, EventModeConstants.Edit), ref db);
                    //}
                    //catch (Exception ex)
                    //{
                    //    string message = _exception.HandleException(ex);
                    //    TempData["CSEXCL"] += message;
                    //    EventException = true;
                    //}


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

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

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

                    //try
                    //{
                    //    SaleDeliveryOrderCancelDocEvents.afterLineSaveEvent(this, new SaleDeliveryEventArgs(s.SaleDeliveryOrderCancelHeaderId, s.SaleDeliveryOrderCancelLineId, 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           = s.SaleDeliveryOrderCancelHeaderId,
                        DocLineId       = s.SaleDeliveryOrderCancelLineId,
                        ActivityType    = (int)ActivityTypeContants.Modified,
                        DocNo           = temp.DocNo,
                        xEModifications = Modifications,
                        DocDate         = temp.DocDate,
                        DocStatus       = temp.Status,
                    }));

                    //End Of Saving Activity Log

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