public ActionResult _Create(int Id, int?sid)  //Id ==>Sale Order Header Id
        {
            PurchaseOrderAmendmentHeader            header = new PurchaseOrderAmendmentHeaderService(db).Find(Id);
            PurchaseOrderRateAmendmentLineViewModel svm    = new PurchaseOrderRateAmendmentLineViewModel();

            //Getting Settings
            var settings = new PurchaseOrderSettingService(_unitOfWork).GetPurchaseOrderSettingForDocument(header.DocTypeId, header.DivisionId, header.SiteId);

            svm.PurchaseOrderSettings = Mapper.Map <PurchaseOrderSetting, PurchaseOrderSettingsViewModel>(settings);
            svm.DocTypeId             = header.DocTypeId;
            svm.DivisionId            = header.DivisionId;
            svm.SiteId       = header.SiteId;
            ViewBag.LineMode = "Create";
            svm.PurchaseOrderAmendmentHeaderId = Id;
            return(PartialView("_Create", svm));
        }
        private ActionResult _Delete(int id)
        {
            PurchaseOrderRateAmendmentLineViewModel temp = _PurchaseOrderRateAmendmentLineService.GetPurchaseOrderRateAmendmentLine(id);

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

            #region DocTypeTimeLineValidation
            try
            {
                TimePlanValidation = DocumentValidation.ValidateDocumentLine(new DocumentUniqueId {
                    LockReason = temp.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";
            }

            PurchaseOrderAmendmentHeader header = new PurchaseOrderAmendmentHeaderService(db).Find(temp.PurchaseOrderAmendmentHeaderId);

            //Getting Settings
            var settings = new PurchaseOrderSettingService(_unitOfWork).GetPurchaseOrderSettingForDocument(header.DocTypeId, header.DivisionId, header.SiteId);

            temp.PurchaseOrderSettings = Mapper.Map <PurchaseOrderSetting, PurchaseOrderSettingsViewModel>(settings);

            return(PartialView("_Create", temp));
        }
        //[ValidateAntiForgeryToken]
        public ActionResult DeletePost(PurchaseOrderRateAmendmentLineViewModel vm)
        {
            bool BeforeSave = true;

            try
            {
                BeforeSave = PurchaseOrderAmendmentDocEvents.beforeLineDeleteEvent(this, new PurchaseEventArgs(vm.PurchaseOrderAmendmentHeaderId, vm.PurchaseOrderRateAmendmentLineId), 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)
            {
                PurchaseOrderRateAmendmentLine PurchaseOrderLine = db.PurchaseOrderRateAmendmentLine.Find(vm.PurchaseOrderRateAmendmentLineId);
                PurchaseOrderAmendmentHeader   header            = new PurchaseOrderAmendmentHeaderService(db).Find(PurchaseOrderLine.PurchaseOrderAmendmentHeaderId);

                new PurchaseOrderLineStatusService(_unitOfWork).UpdatePurchaseRateOnAmendment(PurchaseOrderLine.PurchaseOrderLineId, PurchaseOrderLine.PurchaseOrderRateAmendmentLineId, header.DocDate, 0, ref db);

                var chargeslist = (from p in db.PurchaseOrderRateAmendmentLineCharge
                                   where p.LineTableId == PurchaseOrderLine.PurchaseOrderRateAmendmentLineId
                                   select p).ToList();

                if (chargeslist != null)
                {
                    foreach (var item in chargeslist)
                    {
                        item.ObjectState = Model.ObjectState.Deleted;
                        db.PurchaseOrderRateAmendmentLineCharge.Remove(item);
                    }
                }

                PurchaseOrderLine.ObjectState = Model.ObjectState.Deleted;

                db.PurchaseOrderRateAmendmentLine.Remove(PurchaseOrderLine);

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

                if (vm.footercharges != null)
                {
                    foreach (var item in vm.footercharges)
                    {
                        var footer = db.PurchaseOrderAmendmentHeaderCharges.Find(item.Id);
                        footer.Rate        = item.Rate;
                        footer.Amount      = item.Amount;
                        footer.ObjectState = Model.ObjectState.Modified;
                        db.PurchaseOrderAmendmentHeaderCharges.Add(footer);
                    }
                }

                try
                {
                    PurchaseOrderAmendmentDocEvents.onLineDeleteEvent(this, new PurchaseEventArgs(PurchaseOrderLine.PurchaseOrderAmendmentHeaderId, PurchaseOrderLine.PurchaseOrderRateAmendmentLineId), 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", vm));
                }

                try
                {
                    PurchaseOrderAmendmentDocEvents.afterLineDeleteEvent(this, new PurchaseEventArgs(PurchaseOrderLine.PurchaseOrderAmendmentHeaderId, PurchaseOrderLine.PurchaseOrderRateAmendmentLineId), ref db);
                }
                catch (Exception ex)
                {
                    string message = _exception.HandleException(ex);
                    TempData["CSEXC"] += message;
                }
            }
            return(Json(new { success = true }));
        }
        //[ValidateAntiForgeryToken]
        public ActionResult _CreatePost(PurchaseOrderRateAmendmentLineViewModel svm)
        {
            bool BeforeSave = true;

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

            #region BeforeSave
            try
            {
                if (svm.PurchaseOrderRateAmendmentLineId <= 0)
                {
                    BeforeSave = PurchaseOrderAmendmentDocEvents.beforeLineSaveEvent(this, new PurchaseEventArgs(svm.PurchaseOrderAmendmentHeaderId, EventModeConstants.Add), ref db);
                }
                else
                {
                    BeforeSave = PurchaseOrderAmendmentDocEvents.beforeLineSaveEvent(this, new PurchaseEventArgs(svm.PurchaseOrderAmendmentHeaderId, 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

            if (svm.PurchaseOrderRateAmendmentLineId <= 0)
            {
                PurchaseOrderRateAmendmentLine s = new PurchaseOrderRateAmendmentLine();

                if (ModelState.IsValid && BeforeSave && !EventException)
                {
                    if (svm.Rate != 0)
                    {
                        s.Remark = svm.Remark;
                        s.PurchaseOrderAmendmentHeaderId = svm.PurchaseOrderAmendmentHeaderId;
                        s.PurchaseOrderLineId            = svm.PurchaseOrderLineId;
                        s.Qty               = svm.Qty;
                        s.AmendedRate       = svm.AmendedRate;
                        s.Amount            = svm.Amount;
                        s.PurchaseOrderRate = svm.PurchaseOrderRate;
                        s.Rate              = svm.Rate;
                        s.Remark            = svm.Remark;
                        s.Sr           = _PurchaseOrderRateAmendmentLineService.GetMaxSr(s.PurchaseOrderAmendmentHeaderId);
                        s.CreatedDate  = DateTime.Now;
                        s.ModifiedDate = DateTime.Now;
                        s.CreatedBy    = User.Identity.Name;
                        s.ModifiedBy   = User.Identity.Name;
                        //_PurchaseOrderRateAmendmentLineService.Create(s);
                        s.ObjectState = Model.ObjectState.Added;
                        db.PurchaseOrderRateAmendmentLine.Add(s);

                        PurchaseOrderAmendmentHeader temp2 = new PurchaseOrderAmendmentHeaderService(db).Find(s.PurchaseOrderAmendmentHeaderId);
                        if (temp2.Status != (int)StatusConstants.Drafted)
                        {
                            temp2.Status       = (int)StatusConstants.Modified;
                            temp2.ModifiedBy   = User.Identity.Name;
                            temp2.ModifiedDate = DateTime.Now;
                        }

                        //new PurchaseOrderAmendmentHeaderService(_unitOfWork).Update(temp2);
                        temp2.ObjectState = Model.ObjectState.Modified;
                        db.PurchaseOrderAmendmentHeader.Add(temp2);

                        new PurchaseOrderLineStatusService(_unitOfWork).UpdatePurchaseRateOnAmendment(svm.PurchaseOrderLineId, s.PurchaseOrderRateAmendmentLineId, temp2.DocDate, s.Rate, ref db);


                        if (svm.linecharges != null)
                        {
                            foreach (var item in svm.linecharges)
                            {
                                item.LineTableId   = s.PurchaseOrderRateAmendmentLineId;
                                item.PersonID      = temp2.SupplierId;
                                item.HeaderTableId = s.PurchaseOrderAmendmentHeaderId;
                                item.ObjectState   = Model.ObjectState.Added;
                                db.PurchaseOrderRateAmendmentLineCharge.Add(item);
                            }
                        }

                        if (svm.footercharges != null)
                        {
                            foreach (var item in svm.footercharges)
                            {
                                if (item.Id > 0)
                                {
                                    var footercharge = new PurchaseOrderAmendmentHeaderChargeService(_unitOfWork).Find(item.Id);
                                    footercharge.Rate        = item.Rate;
                                    footercharge.Amount      = item.Amount;
                                    footercharge.ObjectState = Model.ObjectState.Modified;
                                    db.PurchaseOrderAmendmentHeaderCharges.Add(footercharge);
                                }

                                else
                                {
                                    item.HeaderTableId = s.PurchaseOrderAmendmentHeaderId;
                                    item.PersonID      = temp2.SupplierId;
                                    item.ObjectState   = Model.ObjectState.Added;
                                    db.PurchaseOrderAmendmentHeaderCharges.Add(item);
                                }
                            }
                        }


                        try
                        {
                            PurchaseOrderAmendmentDocEvents.onLineSaveEvent(this, new PurchaseEventArgs(s.PurchaseOrderAmendmentHeaderId, s.PurchaseOrderRateAmendmentLineId, 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
                        {
                            PurchaseOrderAmendmentDocEvents.afterLineSaveEvent(this, new PurchaseEventArgs(s.PurchaseOrderAmendmentHeaderId, s.PurchaseOrderRateAmendmentLineId, 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.PurchaseOrderAmendmentHeaderId,
                            DocLineId    = s.PurchaseOrderRateAmendmentLineId,
                            ActivityType = (int)ActivityTypeContants.Added,
                            DocNo        = temp2.DocNo,
                            DocDate      = temp2.DocDate,
                            DocStatus    = temp2.Status,
                        }));
                    }

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

                PurchaseOrderAmendmentHeader temp = new PurchaseOrderAmendmentHeaderService(db).Find(svm.PurchaseOrderAmendmentHeaderId);
                int           status    = temp.Status;
                StringBuilder logstring = new StringBuilder();

                PurchaseOrderRateAmendmentLine s = _PurchaseOrderRateAmendmentLineService.Find(svm.PurchaseOrderRateAmendmentLineId);


                PurchaseOrderRateAmendmentLine ExRecLine = new PurchaseOrderRateAmendmentLine();
                ExRecLine = Mapper.Map <PurchaseOrderRateAmendmentLine>(s);


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

                    s.ObjectState = Model.ObjectState.Modified;
                    db.PurchaseOrderRateAmendmentLine.Add(s);
                    //_PurchaseOrderRateAmendmentLineService.Update(s);

                    new PurchaseOrderLineStatusService(_unitOfWork).UpdatePurchaseRateOnAmendment(s.PurchaseOrderLineId, s.PurchaseOrderRateAmendmentLineId, temp.DocDate, s.Rate, ref db);

                    if (temp.Status != (int)StatusConstants.Drafted)
                    {
                        temp.Status       = (int)StatusConstants.Modified;
                        temp.ModifiedDate = DateTime.Now;
                        temp.ModifiedBy   = User.Identity.Name;
                    }
                    //new PurchaseOrderAmendmentHeaderService(_unitOfWork).Update(temp);

                    temp.ObjectState = Model.ObjectState.Modified;
                    db.PurchaseOrderAmendmentHeader.Add(temp);


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


                    if (svm.linecharges != null)
                    {
                        foreach (var item in svm.linecharges)
                        {
                            var productcharge = db.PurchaseOrderRateAmendmentLineCharge.Find(item.Id);

                            productcharge.Rate        = item.Rate;
                            productcharge.Amount      = item.Amount;
                            productcharge.DealQty     = item.DealQty;
                            productcharge.ObjectState = Model.ObjectState.Modified;
                            db.PurchaseOrderRateAmendmentLineCharge.Add(productcharge);
                        }
                    }


                    if (svm.footercharges != null)
                    {
                        foreach (var item in svm.footercharges)
                        {
                            var footercharge = db.PurchaseOrderAmendmentHeaderCharges.Find(item.Id);

                            footercharge.Rate        = item.Rate;
                            footercharge.Amount      = item.Amount;
                            footercharge.ObjectState = Model.ObjectState.Modified;
                            db.PurchaseOrderAmendmentHeaderCharges.Add(footercharge);
                        }
                    }


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

                    try
                    {
                        PurchaseOrderAmendmentDocEvents.onLineSaveEvent(this, new PurchaseEventArgs(s.PurchaseOrderAmendmentHeaderId, s.PurchaseOrderRateAmendmentLineId, 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
                    {
                        PurchaseOrderAmendmentDocEvents.afterLineSaveEvent(this, new PurchaseEventArgs(s.PurchaseOrderAmendmentHeaderId, s.PurchaseOrderRateAmendmentLineId, 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           = s.PurchaseOrderAmendmentHeaderId,
                        DocLineId       = s.PurchaseOrderRateAmendmentLineId,
                        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));
            }
        }