public ActionResult DeletePost(LedgerAccountOpeningViewModel vm)
{
LedgerHeader Header = new LedgerHeaderService(_unitOfWork).Find(vm.LedgerHeaderId);
LedgerLine Line = new LedgerLineService(_unitOfWork).FindByLedgerHeader(vm.LedgerHeaderId).FirstOrDefault();
Ledger Ledger = new LedgerService(_unitOfWork).FindForLedgerHeader(vm.LedgerHeaderId).FirstOrDefault();
Ledger LedgerToDelete = db.Ledger.Find(Ledger.LedgerId);
LedgerLine LedgerLineToDelete = db.LedgerLine.Find(Line.LedgerLineId);
LedgerHeader LedgerHeaderToDelete = db.LedgerHeader.Find(Header.LedgerHeaderId);
LedgerToDelete.ObjectState = Model.ObjectState.Deleted;
db.Ledger.Remove(LedgerToDelete);
LedgerLineToDelete.ObjectState = Model.ObjectState.Deleted;
db.LedgerLine.Remove(LedgerLineToDelete);
LedgerHeaderToDelete.ObjectState = Model.ObjectState.Deleted;
db.LedgerHeader.Remove(LedgerHeaderToDelete);
try
{
db.SaveChanges();
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
PrepareViewBag();
ModelState.AddModelError("", message);
return(PartialView("EditSize", vm));
}
return(Json(new { success = true }));
}
public static LedgerHeader Decode(XdrDataInputStream stream)
{
var decodedLedgerHeader = new LedgerHeader();
decodedLedgerHeader.LedgerVersion = Uint32.Decode(stream);
decodedLedgerHeader.PreviousLedgerHash = Hash.Decode(stream);
decodedLedgerHeader.ScpValue = StellarValue.Decode(stream);
decodedLedgerHeader.TxSetResultHash = Hash.Decode(stream);
decodedLedgerHeader.BucketListHash = Hash.Decode(stream);
decodedLedgerHeader.LedgerSeq = Uint32.Decode(stream);
decodedLedgerHeader.TotalCoins = Int64.Decode(stream);
decodedLedgerHeader.FeePool = Int64.Decode(stream);
decodedLedgerHeader.InflationSeq = Uint32.Decode(stream);
decodedLedgerHeader.IdPool = Uint64.Decode(stream);
decodedLedgerHeader.BaseFee = Uint32.Decode(stream);
decodedLedgerHeader.BaseReserve = Uint32.Decode(stream);
decodedLedgerHeader.MaxTxSetSize = Uint32.Decode(stream);
var skipListsize = 4;
decodedLedgerHeader.SkipList = new Hash[skipListsize];
for (var i = 0; i < skipListsize; i++)
{
decodedLedgerHeader.SkipList[i] = Hash.Decode(stream);
}
decodedLedgerHeader.Ext = LedgerHeaderExt.Decode(stream);
return(decodedLedgerHeader);
}
public ActionResult Submit(int id, string IndexType, string TransactionType)
{
#region DocTypeTimeLineValidation
LedgerHeader s = _CollectionService.Find(id);
try
{
TimePlanValidation = _documentValidation.ValidateDocument(Mapper.Map <DocumentUniqueId>(s), DocumentTimePlanTypeConstants.Submit, User.Identity.Name, out ExceptionMsg, out Continue);
TempData["CSEXC"] += ExceptionMsg;
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
TempData["CSEXC"] += message;
TimePlanValidation = false;
}
if (!TimePlanValidation && !Continue)
{
return(RedirectToAction("Index", new { id = s.DocTypeId, IndexType = IndexType }));
}
#endregion
return(RedirectToAction("Detail", new { id = id, IndexType = IndexType, transactionType = string.IsNullOrEmpty(TransactionType) ? "submit" : TransactionType }));
}
public ActionResult Submitted(int Id, string IndexType, string UserRemark, string IsContinue, string GenGatePass)
{
LedgerHeader pd = _CollectionService.Find(Id);
CollectionViewModel s = _CollectionService.GetCollection(Id);
if (ModelState.IsValid)
{
if (User.Identity.Name == pd.ModifiedBy || UserRoles.Contains("Admin"))
{
try
{
_CollectionService.Submit(Id, User.Identity.Name, GenGatePass, UserRemark);
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
TempData["CSEXC"] += message;
return(RedirectToAction("Index", new { id = pd.DocTypeId, PersonId = s.PersonId }));
}
}
else
{
return(RedirectToAction("Index", new { id = pd.DocTypeId, PersonId = s.PersonId, IndexType = IndexType }).Warning("Record can be submitted by user " + pd.ModifiedBy + " only."));
}
}
return(RedirectToAction("Index", new { id = pd.DocTypeId, PersonId = s.PersonId, IndexType = IndexType }));
}
public static LedgerHeaderHistoryEntry Decode(XdrDataInputStream stream)
{
var decodedLedgerHeaderHistoryEntry = new LedgerHeaderHistoryEntry();
decodedLedgerHeaderHistoryEntry.Hash = Hash.Decode(stream);
decodedLedgerHeaderHistoryEntry.Header = LedgerHeader.Decode(stream);
decodedLedgerHeaderHistoryEntry.Ext = LedgerHeaderHistoryEntryExt.Decode(stream);
return(decodedLedgerHeaderHistoryEntry);
}
public static LedgerHeaderHistoryEntry Decode(IByteReader stream)
{
LedgerHeaderHistoryEntry decodedLedgerHeaderHistoryEntry = new LedgerHeaderHistoryEntry();
decodedLedgerHeaderHistoryEntry.Hash = Hash.Decode(stream);
decodedLedgerHeaderHistoryEntry.Header = LedgerHeader.Decode(stream);
decodedLedgerHeaderHistoryEntry.Ext = LedgerHeaderHistoryEntryExt.Decode(stream);
return(decodedLedgerHeaderHistoryEntry);
}
public ActionResult Modify(int id, string IndexType)
{
LedgerHeader header = _CollectionService.Find(id);
if (header.Status == (int)StatusConstants.Drafted || header.Status == (int)StatusConstants.Import)
{
return(Edit(id, IndexType));
}
else
{
return(HttpNotFound());
}
}
public ActionResult ModifyAfter_Approve(int id, string IndexType)
{
LedgerHeader header = _CollectionService.Find(id);
if (header.Status == (int)StatusConstants.Approved)
{
return(Edit(id, IndexType));
}
else
{
return(HttpNotFound());
}
}
public ActionResult DeleteAfter_Approve(int id)
{
LedgerHeader header = _CollectionService.Find(id);
if (header.Status == (int)StatusConstants.Approved)
{
return(Remove(id));
}
else
{
return(HttpNotFound());
}
}
public ActionResult Reviewed(int Id, string IndexType, string UserRemark, string IsContinue)
{
LedgerHeader pd = _CollectionService.Find(Id);
if (ModelState.IsValid)
{
_CollectionService.Review(Id, User.Identity.Name, UserRemark);
string ReturnUrl = System.Configuration.ConfigurationManager.AppSettings["CurrentDomain"] + "/" + "Collection" + "/" + "Index" + "/" + pd.DocTypeId + "?IndexType=" + IndexType;
return(Redirect(ReturnUrl));
}
return(RedirectToAction("Index", new { id = pd.DocTypeId, IndexType = IndexType }).Warning("Error in Reviewing."));
}
public virtual void ParseOneLedger()
{
_parentLedger = _ledger;
_ledger = LedgerHeader.FromReader(_reader);
if (NextFrame() == FrameType.AccountStateTree)
{
ParseAccountState();
}
ParseTransactions();
CheckTransactionHash();
ParseAndApplyAccountStateDiff();
CheckStateHash();
CheckHashChain();
}
public void TestExample()
{
var utf8 = System.Text.Encoding.UTF8.GetBytes("005B67A60163457208228EB931635D1A225FF646885BFA8A33A2A3424BFE3290E493C6C6CEB9A51D84D5457BD96702F77340ED9C5294B88A13A0F42BE487D7921F18A2916E6BCA9AC3F9D3F1EEBDADA11F85DA6AB50E29754BEBF4276C327BA05E48004AE574C8F04B4493FD261A7568261A75690A00");
var data = new byte[Base16.GetDecodedFromUtf8Length(utf8.Length)];
Assert.Equal(System.Buffers.OperationStatus.Done, Base16.DecodeFromUtf8(utf8, data, out var _, out var _));
var reader = new St.StReader(data);
var header = new LedgerHeader(reader);
Assert.Equal(5990310u, header.Sequence);
Assert.Equal(99999972797353657ul, header.TotalCoins);
Assert.Equal(new Hash256("31635D1A225FF646885BFA8A33A2A3424BFE3290E493C6C6CEB9A51D84D5457B"), header.ParentHash);
Assert.Equal(new Hash256("D96702F77340ED9C5294B88A13A0F42BE487D7921F18A2916E6BCA9AC3F9D3F1"), header.TransactionHash);
Assert.Equal(new Hash256("EEBDADA11F85DA6AB50E29754BEBF4276C327BA05E48004AE574C8F04B4493FD"), header.AccountHash);
Assert.Equal(Epoch.ToDateTimeOffset(639268200), header.ParentCloseTime);
Assert.Equal(Epoch.ToDateTimeOffset(639268201), header.CloseTime);
Assert.Equal(10, header.CloseTimeResolution);
Assert.Equal(0, header.CloseFlags);
}
public static void Encode(IByteWriter stream, LedgerHeader encodedLedgerHeader) {
Uint32.Encode(stream, encodedLedgerHeader.LedgerVersion);
Hash.Encode(stream, encodedLedgerHeader.PreviousLedgerHash);
StellarValue.Encode(stream, encodedLedgerHeader.ScpValue);
Hash.Encode(stream, encodedLedgerHeader.TxSetResultHash);
Hash.Encode(stream, encodedLedgerHeader.BucketListHash);
Uint32.Encode(stream, encodedLedgerHeader.LedgerSeq);
Int64.Encode(stream, encodedLedgerHeader.TotalCoins);
Int64.Encode(stream, encodedLedgerHeader.FeePool);
Uint32.Encode(stream, encodedLedgerHeader.InflationSeq);
Uint64.Encode(stream, encodedLedgerHeader.IdPool);
Uint32.Encode(stream, encodedLedgerHeader.BaseFee);
Uint32.Encode(stream, encodedLedgerHeader.BaseReserve);
Uint32.Encode(stream, encodedLedgerHeader.MaxTxSetSize);
int skipListsize = encodedLedgerHeader.SkipList.Length;
for (int i = 0; i < skipListsize; i++) {
Hash.Encode(stream, encodedLedgerHeader.SkipList[i]);
}
LedgerHeaderExt.Encode(stream, encodedLedgerHeader.Ext);
}
private ActionResult Remove(int id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
LedgerHeader LedgerHeader = _CollectionService.Find(id);
if (LedgerHeader == null)
{
return(HttpNotFound());
}
#region DocTypeTimeLineValidation
try
{
TimePlanValidation = _documentValidation.ValidateDocument(Mapper.Map <DocumentUniqueId>(LedgerHeader), DocumentTimePlanTypeConstants.Delete, User.Identity.Name, out ExceptionMsg, out Continue);
TempData["CSEXC"] += ExceptionMsg;
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
TempData["CSEXC"] += message;
TimePlanValidation = false;
}
if (!TimePlanValidation && !Continue)
{
return(PartialView("AjaxError"));
}
#endregion
ReasonViewModel rvm = new ReasonViewModel()
{
id = id,
};
return(PartialView("_Reason", rvm));
}
public static LedgerHeader Decode(IByteReader stream) {
LedgerHeader decodedLedgerHeader = new LedgerHeader();
decodedLedgerHeader.LedgerVersion = Uint32.Decode(stream);
decodedLedgerHeader.PreviousLedgerHash = Hash.Decode(stream);
decodedLedgerHeader.ScpValue = StellarValue.Decode(stream);
decodedLedgerHeader.TxSetResultHash = Hash.Decode(stream);
decodedLedgerHeader.BucketListHash = Hash.Decode(stream);
decodedLedgerHeader.LedgerSeq = Uint32.Decode(stream);
decodedLedgerHeader.TotalCoins = Int64.Decode(stream);
decodedLedgerHeader.FeePool = Int64.Decode(stream);
decodedLedgerHeader.InflationSeq = Uint32.Decode(stream);
decodedLedgerHeader.IdPool = Uint64.Decode(stream);
decodedLedgerHeader.BaseFee = Uint32.Decode(stream);
decodedLedgerHeader.BaseReserve = Uint32.Decode(stream);
decodedLedgerHeader.MaxTxSetSize = Uint32.Decode(stream);
int skipListsize = 4;
decodedLedgerHeader.SkipList = new Hash[skipListsize];
for (int i = 0; i < skipListsize; i++) {
decodedLedgerHeader.SkipList[i] = Hash.Decode(stream);
}
decodedLedgerHeader.Ext = LedgerHeaderExt.Decode(stream);
return decodedLedgerHeader;
}
public static void Encode(XdrDataOutputStream stream, LedgerHeader encodedLedgerHeader)
{
Uint32.Encode(stream, encodedLedgerHeader.LedgerVersion);
Hash.Encode(stream, encodedLedgerHeader.PreviousLedgerHash);
StellarValue.Encode(stream, encodedLedgerHeader.ScpValue);
Hash.Encode(stream, encodedLedgerHeader.TxSetResultHash);
Hash.Encode(stream, encodedLedgerHeader.BucketListHash);
Uint32.Encode(stream, encodedLedgerHeader.LedgerSeq);
Int64.Encode(stream, encodedLedgerHeader.TotalCoins);
Int64.Encode(stream, encodedLedgerHeader.FeePool);
Uint32.Encode(stream, encodedLedgerHeader.InflationSeq);
Uint64.Encode(stream, encodedLedgerHeader.IdPool);
Uint32.Encode(stream, encodedLedgerHeader.BaseFee);
Uint32.Encode(stream, encodedLedgerHeader.BaseReserve);
Uint32.Encode(stream, encodedLedgerHeader.MaxTxSetSize);
var skipListsize = encodedLedgerHeader.SkipList.Length;
for (var i = 0; i < skipListsize; i++)
{
Hash.Encode(stream, encodedLedgerHeader.SkipList[i]);
}
LedgerHeaderExt.Encode(stream, encodedLedgerHeader.Ext);
}
public ActionResult PostCostCenters(List <int> CostCenterId, DateTime CloseDate)
{
List <LogTypeViewModel> LogList = new List <LogTypeViewModel>();
int[] CostCenterIds = CostCenterId.Select(m => m).ToArray();
if (ModelState.IsValid)
{
var CostCenters = (from p in db.CostCenter
join t in db.CostCenterStatus on p.CostCenterId equals t.CostCenterId into CostCenterStatusTable
from CostCenterStatusTab in CostCenterStatusTable.DefaultIfEmpty()
join jos in db.JobOrderSettings on new { A = p.ReferenceDocTypeId ?? 0, B = p.SiteId ?? 0, C = p.DivisionId ?? 0 } equals new { A = jos.DocTypeId, B = jos.SiteId, C = jos.DivisionId } into josTable
from josTab in josTable.DefaultIfEmpty()
where CostCenterIds.Contains(p.CostCenterId)
select new
{
p.CostCenterId,
p.LedgerAccountId,
p.DivisionId,
p.SiteId,
p.ReferenceDocId,
p.ReferenceDocTypeId,
AmountDr = CostCenterStatusTab.AmountDr ?? 0,
AmountCr = CostCenterStatusTab.AmountCr ?? 0,
p.DocTypeId,
p.StartDate,
p.Status,
p.CloseDate,
p.ModifiedBy,
p.ModifiedDate,
josTab.RetensionCostCenter,
}).ToList();
int?ProcessId = null;
var Process = db.Process.Where(m => m.ProcessName == ProcessConstants.Weaving).FirstOrDefault();
if (Process != null)
{
ProcessId = Process.ProcessId;
}
int itemcount = 0;
int ROitemcount = 0;
string DocNo = "";
string TempDocNo = "";
foreach (var item in CostCenters)
{
itemcount = itemcount + 1;
int PurjaAmountTransferDocTypeId = 717;
int LedgerAccountId = (int)item.LedgerAccountId;
LedgerHeader Header = new LedgerHeader();
Header.CreatedBy = User.Identity.Name;
Header.CreatedDate = DateTime.Now;
Header.DivisionId = (int)item.DivisionId;
Header.SiteId = (int)item.SiteId;
Header.DivisionId = (int)item.DivisionId;
Header.DocDate = CloseDate;
Header.PaymentFor = CloseDate;
Header.ProcessId = ProcessId;
//Header.DocDate = (DateTime)item.CloseDate;
//Header.PaymentFor = item.CloseDate;
Header.DocTypeId = PurjaAmountTransferDocTypeId;
Header.CostCenterId = item.CostCenterId;
// Header.DocHeaderId = StokHeader.StockHeaderId;
DocNo = new DocumentTypeService(_unitOfWork).FGetNewDocNo("DocNo", ConfigurationManager.AppSettings["DataBaseSchema"] + ".LedgerHeaders", Header.DocTypeId, Header.DocDate, Header.DivisionId, Header.SiteId);
TempDocNo = DocNo.Substring(0, 2) + "-" + (Convert.ToInt32(DocNo.Substring(DocNo.IndexOf("-") + 1)) + itemcount - 1).ToString().PadLeft(4, '0').ToString();
DocNo = TempDocNo;
Header.LedgerHeaderId = -itemcount;
Header.DocNo = DocNo;
Header.LedgerAccountId = LedgerAccountId;
Header.ModifiedBy = User.Identity.Name;
Header.ModifiedDate = DateTime.Now;
//Header.Remark = StokHeader.Remark;
Header.Status = (int)StatusConstants.Locked;
Header.ObjectState = Model.ObjectState.Added;
db.LedgerHeader.Add(Header);
decimal Amount = Math.Round((decimal)item.AmountDr - (decimal)item.AmountCr, 0, MidpointRounding.AwayFromZero);
decimal RoundOffAmount = Amount - ((decimal)item.AmountDr - (decimal)item.AmountCr);
if (Amount != 0)
{
//Postingcontra LedgerRecord;;
LedgerLine Ledgerline = new LedgerLine();
Ledgerline.LedgerHeaderId = Header.LedgerHeaderId;
Ledgerline.LedgerAccountId = LedgerAccountId;
Ledgerline.Amount = Amount;
Ledgerline.CostCenterId = item.RetensionCostCenter;
Ledgerline.CreatedDate = DateTime.Now;
Ledgerline.ModifiedDate = DateTime.Now;
Ledgerline.CreatedBy = User.Identity.Name;
//Ledgerline.Remark = svm.Remark;
Ledgerline.ModifiedBy = User.Identity.Name;
Ledgerline.ObjectState = Model.ObjectState.Added;
db.LedgerLine.Add(Ledgerline);
//Postingcontra LedgerRecord;;
Ledger Ledger = new Ledger();
Ledger.AmtDr = Amount < 0 ? Math.Abs(Amount) : 0;
Ledger.AmtCr = Amount < 0 ? 0 : Math.Abs(Amount);
Ledger.LedgerHeaderId = Header.LedgerHeaderId;
Ledger.LedgerAccountId = LedgerAccountId;
Ledger.CostCenterId = item.CostCenterId;
Ledger.ContraLedgerAccountId = LedgerAccountId;
Ledger.ObjectState = Model.ObjectState.Added;
db.Ledger.Add(Ledger);
//new LedgerService(_unitOfWork).Create(Ledger);
//Postingcontra LedgerRecord;;
Ledger ContraLedger = new Ledger();
ContraLedger.AmtCr = Amount;
ContraLedger.AmtDr = Amount < 0 ? 0 : Math.Abs(Amount);
ContraLedger.AmtCr = Amount < 0 ? Math.Abs(Amount) : 0;
ContraLedger.LedgerHeaderId = Header.LedgerHeaderId;
ContraLedger.LedgerAccountId = LedgerAccountId;
ContraLedger.CostCenterId = item.RetensionCostCenter;
ContraLedger.ContraLedgerAccountId = LedgerAccountId;
ContraLedger.ObjectState = Model.ObjectState.Added;
//new LedgerService(_unitOfWork).Create(ContraLedger);
db.Ledger.Add(ContraLedger);
}
if (RoundOffAmount != 0)
{
ROitemcount = ROitemcount + 1;
LedgerHeader ROLHeader = new LedgerHeader();
int RODocType = 0;
int RoundOffAccountId = 6660;
if (RoundOffAmount > 0)
{
RODocType = 785;//dr
}
else
{
RODocType = 786;//cr
}
ROLHeader.CreatedBy = User.Identity.Name;
ROLHeader.CreatedDate = DateTime.Now;
ROLHeader.DivisionId = (int)item.DivisionId;
ROLHeader.SiteId = (int)item.SiteId;
ROLHeader.DivisionId = (int)item.DivisionId;
ROLHeader.DocDate = CloseDate;
ROLHeader.PaymentFor = CloseDate;
ROLHeader.ProcessId = ProcessId;
ROLHeader.DocTypeId = RODocType;
ROLHeader.CostCenterId = item.CostCenterId;
DocNo = new DocumentTypeService(_unitOfWork).FGetNewDocNo("DocNo", ConfigurationManager.AppSettings["DataBaseSchema"] + ".LedgerHeaders", ROLHeader.DocTypeId, ROLHeader.DocDate, ROLHeader.DivisionId, ROLHeader.SiteId);;
TempDocNo = DocNo.Substring(0, 2) + "-" + (Convert.ToInt32(DocNo.Substring(DocNo.IndexOf("-") + 1)) + ROitemcount - 1).ToString().PadLeft(4, '0').ToString();
DocNo = TempDocNo;
ROLHeader.LedgerHeaderId = +ROitemcount;
ROLHeader.DocNo = DocNo;
ROLHeader.LedgerAccountId = RoundOffAccountId;
ROLHeader.ModifiedBy = User.Identity.Name;
ROLHeader.ModifiedDate = DateTime.Now;
ROLHeader.Remark = "On Cost Center Closing";
ROLHeader.Status = (int)StatusConstants.Locked;
ROLHeader.ObjectState = Model.ObjectState.Added;
db.LedgerHeader.Add(ROLHeader);
//Postingcontra LedgerRecord;;
LedgerLine Ledgerline1 = new LedgerLine();
Ledgerline1.LedgerHeaderId = ROLHeader.LedgerHeaderId;
Ledgerline1.LedgerAccountId = LedgerAccountId;
Ledgerline1.Amount = Math.Abs(RoundOffAmount);
Ledgerline1.CostCenterId = item.CostCenterId;
Ledgerline1.CreatedDate = DateTime.Now;
Ledgerline1.ModifiedDate = DateTime.Now;
Ledgerline1.CreatedBy = User.Identity.Name;
//Ledgerline.Remark = svm.Remark;
Ledgerline1.ModifiedBy = User.Identity.Name;
Ledgerline1.ObjectState = Model.ObjectState.Added;
db.LedgerLine.Add(Ledgerline1);
#region CSEUpdate
var CSE = db.CostCenterStatusExtended.Find(item.CostCenterId);
if (RODocType == 785)
{
CSE.DebitAmount = (CSE.DebitAmount ?? 0) + Math.Abs(RoundOffAmount);
}
else if (RODocType == 786)
{
CSE.CreditAmount = (CSE.CreditAmount ?? 0) + Math.Abs(RoundOffAmount);
}
CSE.ObjectState = Model.ObjectState.Modified;
db.CostCenterStatusExtended.Add(CSE);
#endregion
//Postingcontra LedgerRecord;;
Ledger Ledger1 = new Ledger();
Ledger1.AmtDr = RoundOffAmount > 0 ? Math.Abs(RoundOffAmount) : 0;
Ledger1.AmtCr = RoundOffAmount < 0 ? Math.Abs(RoundOffAmount) : 0;
Ledger1.LedgerHeaderId = ROLHeader.LedgerHeaderId;
Ledger1.LedgerAccountId = LedgerAccountId;
Ledger1.CostCenterId = item.CostCenterId;
Ledger1.ContraLedgerAccountId = RoundOffAccountId;
Ledger1.ObjectState = Model.ObjectState.Added;
db.Ledger.Add(Ledger1);
//new LedgerService(_unitOfWork).Create(Ledger);
//Postingcontra LedgerRecord;;
Ledger ContraLedger1 = new Ledger();
ContraLedger1.AmtDr = RoundOffAmount < 0 ? Math.Abs(RoundOffAmount) : 0;
ContraLedger1.AmtCr = RoundOffAmount > 0 ? Math.Abs(RoundOffAmount) : 0;
ContraLedger1.LedgerHeaderId = ROLHeader.LedgerHeaderId;
ContraLedger1.LedgerAccountId = RoundOffAccountId;
ContraLedger1.ContraLedgerAccountId = LedgerAccountId;
ContraLedger1.ObjectState = Model.ObjectState.Added;
//new LedgerService(_unitOfWork).Create(ContraLedger);
db.Ledger.Add(ContraLedger1);
}
}
// Start For Old RetentionTrf
foreach (var item in CostCenters)
{
IQueryable <JobOrderHeaderViewModel> p = _JobOrderHeaderService.GetJobOrderHeaderListByCostCenter(item.CostCenterId);
foreach (var V1 in p)
{
JobOrderHeader joborder = db.JobOrderHeader.Find(V1.JobOrderHeaderId);
joborder.Status = (int)StatusConstants.Closed;
joborder.ModifiedBy = User.Identity.Name;
joborder.ModifiedDate = DateTime.Now;
joborder.ObjectState = Model.ObjectState.Modified;
db.JobOrderHeader.Add(joborder);
#region CSEUpdate
var JOHS = db.JobOrderHeaderStatus.Find(V1.JobOrderHeaderId);
JOHS.Status = (int)StatusConstants.Closed;
JOHS.ObjectState = Model.ObjectState.Modified;
db.JobOrderHeaderStatus.Add(JOHS);
#endregion
}
CostCenter costcenter = db.CostCenter.Find(item.CostCenterId);
costcenter.Status = (int)StatusConstants.Closed;
costcenter.CloseDate = CloseDate;
costcenter.IsActive = false;
costcenter.ModifiedBy = User.Identity.Name;
costcenter.ModifiedDate = DateTime.Now;
costcenter.ObjectState = Model.ObjectState.Modified;
db.CostCenter.Add(costcenter);
LogList.Add(new LogTypeViewModel {
ExObj = costcenter, Obj = costcenter
});
XElement Modifications = new ModificationsCheckService().CheckChanges(LogList);
ActivityLog Log = new ActivityLog()
{
ActivityType = (int)ActivityTypeContants.Closed,
CreatedBy = User.Identity.Name,
CreatedDate = DateTime.Now,
DocId = item.CostCenterId,
DocTypeId = item.DocTypeId,
Modifications = Modifications.ToString(),
Narration = "",
};
Log.ObjectState = Model.ObjectState.Added;
db.ActivityLog.Add(Log);
}
// End For Old RetentionTrf
try
{
db.SaveChanges();
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
ModelState.AddModelError("", message);
return(Json(new { Success = false }));
}
return(Json(new { Success = true }));
}
//PrepareViewBag(svm.DocTypeId);
//ViewBag.Mode = "Add";
//return View("Create", svm);
return(View("CloseCostCenters"));
}
public void LedgerPostingDB(ref LedgerHeaderViewModel LedgerHeaderViewModel, IEnumerable <CalculationHeaderCharge> HeaderTable, IEnumerable <CalculationLineCharge> LineTable, ref ApplicationDbContext Context)
{
int PersonAccountId = 6612;
int LedgerHeaderId = 0;
if (LedgerHeaderViewModel.LedgerHeaderId == 0)
{
LedgerHeader LedgerHeader = new LedgerHeader();
LedgerHeader.DocHeaderId = LedgerHeaderViewModel.DocHeaderId;
LedgerHeader.DocTypeId = LedgerHeaderViewModel.DocTypeId;
LedgerHeader.DocDate = LedgerHeaderViewModel.DocDate;
LedgerHeader.DocNo = LedgerHeaderViewModel.DocNo;
LedgerHeader.DivisionId = LedgerHeaderViewModel.DivisionId;
LedgerHeader.SiteId = LedgerHeaderViewModel.SiteId;
LedgerHeader.PartyDocNo = LedgerHeaderViewModel.PartyDocNo;
LedgerHeader.PartyDocDate = LedgerHeaderViewModel.PartyDocDate;
LedgerHeader.Narration = LedgerHeaderViewModel.Narration;
LedgerHeader.Remark = LedgerHeaderViewModel.Remark;
LedgerHeader.CreatedBy = LedgerHeaderViewModel.CreatedBy;
LedgerHeader.ProcessId = LedgerHeaderViewModel.ProcessId;
LedgerHeader.CreatedDate = DateTime.Now.Date;
LedgerHeader.ModifiedBy = LedgerHeaderViewModel.ModifiedBy;
LedgerHeader.ModifiedDate = DateTime.Now.Date;
LedgerHeader.ObjectState = Model.ObjectState.Added;
Context.LedgerHeader.Add(LedgerHeader);
//new LedgerHeaderService(_unitOfWork).Create(LedgerHeader);
}
else
{
int LedHeadId = LedgerHeaderViewModel.LedgerHeaderId;
LedgerHeader LedgerHeader = (from p in Context.LedgerHeader
where p.LedgerHeaderId == LedHeadId
select p).FirstOrDefault();
LedgerHeader.DocHeaderId = LedgerHeaderViewModel.DocHeaderId;
LedgerHeader.DocTypeId = LedgerHeaderViewModel.DocTypeId;
LedgerHeader.DocDate = LedgerHeaderViewModel.DocDate;
LedgerHeader.DocNo = LedgerHeaderViewModel.DocNo;
LedgerHeader.DivisionId = LedgerHeaderViewModel.DivisionId;
LedgerHeader.ProcessId = LedgerHeaderViewModel.ProcessId;
LedgerHeader.SiteId = LedgerHeaderViewModel.SiteId;
LedgerHeader.PartyDocNo = LedgerHeaderViewModel.PartyDocNo;
LedgerHeader.PartyDocDate = LedgerHeaderViewModel.PartyDocDate;
LedgerHeader.Narration = LedgerHeaderViewModel.Narration;
LedgerHeader.Remark = LedgerHeaderViewModel.Remark;
LedgerHeader.ModifiedBy = LedgerHeaderViewModel.ModifiedBy;
LedgerHeader.ModifiedDate = DateTime.Now.Date;
LedgerHeader.ObjectState = Model.ObjectState.Modified;
Context.LedgerHeader.Add(LedgerHeader);
//new LedgerHeaderService(_unitOfWork).Update(LedgerHeader);
IEnumerable <Ledger> LedgerList = (from p in Context.Ledger
where p.LedgerHeaderId == LedHeadId
select p).ToList();
foreach (Ledger item in LedgerList)
{
item.ObjectState = Model.ObjectState.Deleted;
Context.Ledger.Remove(item);
//new LedgerService(_unitOfWork).Delete(item);
}
LedgerHeaderId = LedgerHeader.LedgerHeaderId;
}
IEnumerable <LedgerPostingViewModel> LedgerHeaderAmtDr = (from H in HeaderTable
join A in Context.LedgerAccount on H.PersonID equals A.PersonId into LedgerAccountTable
from LedgerAccountTab in LedgerAccountTable.DefaultIfEmpty()
where H.LedgerAccountDrId != null && H.Amount != 0 && H.Amount != null
select new LedgerPostingViewModel
{
LedgerAccountId = (int)(H.LedgerAccountDrId == PersonAccountId ? LedgerAccountTab.LedgerAccountId : H.LedgerAccountDrId),
ContraLedgerAccountId = (H.LedgerAccountCrId == PersonAccountId ? LedgerAccountTab.LedgerAccountId : H.LedgerAccountCrId),
CostCenterId = H.CostCenterId,
AmtDr = Math.Abs((H.Amount > 0 ? H.Amount : 0) ?? 0),
AmtCr = Math.Abs((H.Amount < 0 ? H.Amount : 0) ?? 0)
}).ToList();
IEnumerable <LedgerPostingViewModel> LedgerHeaderAmtCr = (from H in HeaderTable
join A in Context.LedgerAccount on H.PersonID equals A.PersonId into LedgerAccountTable
from LedgerAccountTab in LedgerAccountTable.DefaultIfEmpty()
where H.LedgerAccountCrId != null && H.Amount != 0 && H.Amount != null
select new LedgerPostingViewModel
{
LedgerAccountId = (int)(H.LedgerAccountCrId == PersonAccountId ? LedgerAccountTab.LedgerAccountId : H.LedgerAccountCrId),
ContraLedgerAccountId = (H.LedgerAccountDrId == PersonAccountId ? LedgerAccountTab.LedgerAccountId : H.LedgerAccountDrId),
CostCenterId = H.CostCenterId,
AmtCr = Math.Abs((H.Amount > 0 ? H.Amount : 0) ?? 0),
AmtDr = Math.Abs((H.Amount < 0 ? H.Amount : 0) ?? 0)
}).ToList();
IEnumerable <LedgerPostingViewModel> LedgerLineAmtDr = (from L in LineTable
join A in Context.LedgerAccount on L.PersonID equals A.PersonId into LedgerAccountTable
from LedgerAccountTab in LedgerAccountTable.DefaultIfEmpty()
where L.LedgerAccountDrId != null && L.Amount != 0 && L.Amount != null
select new LedgerPostingViewModel
{
LedgerAccountId = (int)(L.LedgerAccountDrId == PersonAccountId ? LedgerAccountTab.LedgerAccountId : L.LedgerAccountDrId),
ContraLedgerAccountId = (L.LedgerAccountCrId == PersonAccountId ? LedgerAccountTab.LedgerAccountId : L.LedgerAccountCrId),
CostCenterId = L.CostCenterId,
AmtDr = Math.Abs((L.Amount > 0 ? L.Amount : 0) ?? 0),
AmtCr = Math.Abs((L.Amount < 0 ? L.Amount : 0) ?? 0)
}).ToList();
IEnumerable <LedgerPostingViewModel> LedgerLineAmtCr = (from L in LineTable
join A in Context.LedgerAccount on L.PersonID equals A.PersonId into LedgerAccountTable
from LedgerAccountTab in LedgerAccountTable.DefaultIfEmpty()
where L.LedgerAccountCrId != null && L.Amount != 0 && L.Amount != null
select new LedgerPostingViewModel
{
LedgerAccountId = (int)(L.LedgerAccountCrId == PersonAccountId ? LedgerAccountTab.LedgerAccountId : L.LedgerAccountCrId),
ContraLedgerAccountId = (L.LedgerAccountDrId == PersonAccountId ? LedgerAccountTab.LedgerAccountId : L.LedgerAccountDrId),
CostCenterId = L.CostCenterId,
AmtCr = Math.Abs((L.Amount > 0 ? L.Amount : 0) ?? 0),
AmtDr = Math.Abs((L.Amount < 0 ? L.Amount : 0) ?? 0)
}).ToList();
IEnumerable <LedgerPostingViewModel> LedgerCombind = LedgerHeaderAmtDr.Union(LedgerHeaderAmtCr).Union(LedgerLineAmtDr).Union(LedgerLineAmtCr).ToList();
//IEnumerable<LedgerPostingViewModel> LedgerPost = (from L in LedgerCombind
// group new { L } by new { L.LedgerAccountId, L.ContraLedgerAccountId, L.CostCenterId } into Result
// select new LedgerPostingViewModel
// {
// LedgerAccountId = Result.Key.LedgerAccountId,
// ContraLedgerAccountId = Result.Key.ContraLedgerAccountId,
// CostCenterId = Result.Key.CostCenterId,
// AmtDr = Result.Sum(i => i.L.AmtDr),
// AmtCr = Result.Sum(i => i.L.AmtCr)
// }).ToList();
IEnumerable <LedgerPostingViewModel> LedgerPost1 = from L in LedgerCombind
join Ca in db.LedgerAccount on L.ContraLedgerAccountId equals Ca.LedgerAccountId into ContraLedgerAccountTable
from ContraLedgerAccountTab in ContraLedgerAccountTable.DefaultIfEmpty()
join Cag in db.LedgerAccountGroup on ContraLedgerAccountTab.LedgerAccountGroupId equals Cag.LedgerAccountGroupId into ContraLedgerAccountGroupTable
from ContraLedgerAccountGroupTab in ContraLedgerAccountGroupTable.DefaultIfEmpty()
group new { L, ContraLedgerAccountGroupTab } by new { L.LedgerAccountId, L.ContraLedgerAccountId, L.CostCenterId } into Result
select new LedgerPostingViewModel
{
LedgerAccountId = Result.Key.LedgerAccountId,
ContraLedgerAccountId = Result.Key.ContraLedgerAccountId,
ContraLedgerAccountWeightage = Result.Max(i => i.ContraLedgerAccountGroupTab.Weightage ?? 0),
CostCenterId = Result.Key.CostCenterId,
AmtDr = Result.Sum(i => i.L.AmtDr),
AmtCr = Result.Sum(i => i.L.AmtCr)
};
IEnumerable <LedgerPostingViewModel> LedgerPost2 = from L in LedgerPost1
group new { L } by new { L.LedgerAccountId, L.CostCenterId } into Result
select new LedgerPostingViewModel
{
LedgerAccountId = Result.Key.LedgerAccountId,
ContraLedgerAccountWeightage = Result.Max(i => i.L.ContraLedgerAccountWeightage ?? 0),
CostCenterId = Result.Key.CostCenterId,
AmtDr = Result.Sum(i => i.L.AmtDr) - Result.Sum(i => i.L.AmtCr) > 0 ? Result.Sum(i => i.L.AmtDr) - Result.Sum(i => i.L.AmtCr) : 0,
AmtCr = Result.Sum(i => i.L.AmtCr) - Result.Sum(i => i.L.AmtDr) > 0 ? Result.Sum(i => i.L.AmtCr) - Result.Sum(i => i.L.AmtDr) : 0,
};
IEnumerable <LedgerPostingViewModel> LedgerPost = from L2 in LedgerPost2
join L1 in LedgerPost1 on new { A1 = L2.LedgerAccountId, A2 = L2.CostCenterId, A3 = L2.ContraLedgerAccountWeightage } equals new { A1 = L1.LedgerAccountId, A2 = L1.CostCenterId, A3 = L1.ContraLedgerAccountWeightage } into LedgerPost1Table
from LedgerPost1Tab in LedgerPost1Table.DefaultIfEmpty()
group new { LedgerPost1Tab, L2 } by new { L2.LedgerAccountId, L2.CostCenterId } into Result
select new LedgerPostingViewModel
{
LedgerAccountId = Result.Key.LedgerAccountId,
ContraLedgerAccountId = Result.Max(i => i.LedgerPost1Tab.ContraLedgerAccountId),
CostCenterId = Result.Key.CostCenterId,
AmtDr = Result.Max(i => i.L2.AmtDr),
AmtCr = Result.Max(i => i.L2.AmtCr)
};
var temp = (from L in LedgerPost
group L by 1 into Result
select new
{
AmtDr = Result.Sum(i => i.AmtDr),
AmtCr = Result.Sum(i => i.AmtCr)
}).FirstOrDefault();
if (temp != null)
{
if (temp.AmtDr != temp.AmtCr)
{
throw new Exception("Debit amount and credit amount is not equal.Check account posting.");
}
}
foreach (LedgerPostingViewModel item in LedgerPost)
{
Ledger Ledger = new Ledger();
if (LedgerHeaderId != 0)
{
Ledger.LedgerHeaderId = LedgerHeaderId;
}
Ledger.LedgerAccountId = item.LedgerAccountId;
Ledger.ContraLedgerAccountId = item.ContraLedgerAccountId;
var TempCostCenter = (from C in Context.CostCenter
where C.CostCenterId == item.CostCenterId && C.LedgerAccountId == item.LedgerAccountId
select new { CostCenterId = C.CostCenterId }).FirstOrDefault();
if (TempCostCenter != null)
{
Ledger.CostCenterId = item.CostCenterId;
}
Ledger.AmtDr = item.AmtDr * (LedgerHeaderViewModel.ExchangeRate ?? 1);
Ledger.AmtCr = item.AmtCr * (LedgerHeaderViewModel.ExchangeRate ?? 1);
Ledger.Narration = "";
//new LedgerService(_unitOfWork).Create(Ledger);
Ledger.ObjectState = Model.ObjectState.Added;
Context.Ledger.Add(Ledger);
}
}
public ActionResult ConfirmedJobInvoices(List <PaymentCancelWizardViewModel> ConfirmedList, int DocTypeId, string UserRemark)
{
if (ConfirmedList.Count() > 0 && ConfirmedList.GroupBy(m => m.LedgerHeaderId).Count() > 1)
{
return(Json(new { Success = false, Data = " Multiple Headers are selected. " }, JsonRequestBehavior.AllowGet));
}
else
{
int LedgerHeaderId = ConfirmedList.GroupBy(m => m.LedgerHeaderId).FirstOrDefault().Key;
var OrderIds = ConfirmedList.Select(m => m.LedgerLineId).ToArray();
var RecordDetails = (from p in db.LedgerLine
where OrderIds.Contains(p.LedgerLineId)
select p).ToList();
var Ledgers = (from p in db.Ledger
where OrderIds.Contains(p.LedgerLineId ?? 0)
select p).ToList();
DocumentType Type = db.DocumentType.Find(DocTypeId);
string Nature = Type.Nature;
var LedgerHead = db.LedgerHeader.Find(LedgerHeaderId);
LedgerHeader Header = new LedgerHeader();
Header.AdjustmentType = LedgerHead.AdjustmentType;
Header.CostCenterId = LedgerHead.CostCenterId;
Header.CreatedBy = User.Identity.Name;
Header.CreatedDate = DateTime.Now;
Header.CreditDays = LedgerHead.CreditDays;
Header.DivisionId = LedgerHead.DivisionId;
Header.SiteId = LedgerHead.SiteId;
Header.DocDate = DateTime.Now;
Header.DocTypeId = DocTypeId;
Header.DocHeaderId = LedgerHead.DocHeaderId;
Header.DocNo = new DocumentTypeService(_unitOfWork).FGetNewDocNo("DocNo", ConfigurationManager.AppSettings["DataBaseSchema"] + ".LedgerHeaders", Header.DocTypeId, Header.DocDate, Header.DivisionId, Header.SiteId);
Header.LedgerAccountId = LedgerHead.LedgerAccountId;
Header.LockReason = LedgerHead.LockReason;
Header.ModifiedBy = User.Identity.Name;
Header.ModifiedDate = DateTime.Now;
Header.Narration = LedgerHead.Narration;
Header.PaymentFor = LedgerHead.PaymentFor;
Header.ProcessId = LedgerHead.ProcessId;
Header.Remark = UserRemark;
Header.ObjectState = Model.ObjectState.Added;
db.LedgerHeader.Add(Header);
int pk = 1;
int pk1 = 1;
foreach (var item in RecordDetails)
{
LedgerLine Line = new LedgerLine();
Line.Amount = item.Amount;
Line.BaseRate = item.BaseRate;
Line.BaseValue = item.BaseValue;
Line.ChqDate = item.ChqDate;
Line.ChqNo = item.ChqNo;
Line.CostCenterId = item.CostCenterId;
Line.CreatedBy = User.Identity.Name;
Line.CreatedDate = DateTime.Now;
Line.LedgerAccountId = item.LedgerAccountId;
Line.LedgerHeaderId = Header.LedgerHeaderId;
Line.ModifiedBy = User.Identity.Name;
Line.ModifiedDate = DateTime.Now;
Line.ReferenceDocId = item.LedgerHeaderId;
Line.ReferenceDocLineId = item.LedgerLineId;
Line.ReferenceDocTypeId = LedgerHead.DocTypeId;
Line.ReferenceId = Ledgers.Where(m => m.LedgerLineId == item.LedgerLineId && m.LedgerAccountId == item.LedgerAccountId).FirstOrDefault().LedgerId;
Line.Remark = UserRemark;
Line.LedgerLineId = pk;
Line.ObjectState = Model.ObjectState.Added;
db.LedgerLine.Add(Line);
#region LedgerSave
Ledger Ledger = new Ledger();
if (Nature == NatureConstants.Credit)
{
Ledger.AmtDr = Line.Amount;
}
else if (Nature == NatureConstants.Debit)
{
Ledger.AmtCr = Line.Amount;
}
Ledger.ChqNo = Line.ChqNo;
Ledger.ContraLedgerAccountId = Header.LedgerAccountId;
Ledger.CostCenterId = Line.CostCenterId;
Ledger.DueDate = Line.ChqDate;
Ledger.LedgerAccountId = Line.LedgerAccountId;
Ledger.LedgerHeaderId = Line.LedgerHeaderId;
Ledger.LedgerLineId = Line.LedgerLineId;
Ledger.Narration = Header.Narration + Line.Remark;
Ledger.ObjectState = Model.ObjectState.Added;
Ledger.LedgerId = pk;
db.Ledger.Add(Ledger);
if (Line.ReferenceId != null)
{
LedgerAdj LedgerAdj = new LedgerAdj();
if (Nature == NatureConstants.Credit)
{
LedgerAdj.DrLedgerId = Ledger.LedgerId;
//LedgerAdj.CrLedgerId = (int)Line.ReferenceId;
LedgerAdj.LedgerId = (int)Line.ReferenceId;
}
else
{
//LedgerAdj.DrLedgerId = (int)Line.ReferenceId;
LedgerAdj.LedgerId = (int)Line.ReferenceId;
LedgerAdj.CrLedgerId = Ledger.LedgerId;
}
LedgerAdj.LedgerAdjId = pk1;
LedgerAdj.Amount = Line.Amount;
LedgerAdj.SiteId = Header.SiteId;
LedgerAdj.CreatedDate = DateTime.Now;
LedgerAdj.ModifiedDate = DateTime.Now;
LedgerAdj.CreatedBy = User.Identity.Name;
LedgerAdj.ModifiedBy = User.Identity.Name;
LedgerAdj.ObjectState = Model.ObjectState.Added;
db.LedgerAdj.Add(LedgerAdj);
}
#endregion
#region ContraLedgerSave
Ledger ContraLedger = new Ledger();
if (Nature == NatureConstants.Credit)
{
ContraLedger.AmtCr = Line.Amount;
}
else if (Nature == NatureConstants.Debit)
{
ContraLedger.AmtDr = Line.Amount;
}
ContraLedger.LedgerHeaderId = Header.LedgerHeaderId;
ContraLedger.CostCenterId = Header.CostCenterId;
ContraLedger.LedgerLineId = Line.LedgerLineId;
ContraLedger.LedgerAccountId = Header.LedgerAccountId.Value;
ContraLedger.ContraLedgerAccountId = Line.LedgerAccountId;
ContraLedger.ObjectState = Model.ObjectState.Added;
db.Ledger.Add(ContraLedger);
#endregion
pk++;
pk1++;
}
try
{
LedgerDocEvents.onWizardSaveEvent(this, new LedgerEventArgs(Header.LedgerHeaderId, EventModeConstants.Add), ref db);
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
TempData["CSEXC"] += message;
EventException = true;
}
try
{
if (EventException)
{
throw new Exception((string)TempData["CSEXC"]);
}
db.SaveChanges();
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
return(Json(new { Success = false, Data = message }, JsonRequestBehavior.AllowGet));
}
return(Json(new { Success = "URL", Data = "/LedgerHeader/Submit/" + Header.LedgerHeaderId }, JsonRequestBehavior.AllowGet));
}
}
public string LedgerPost(IEnumerable <LedgerViewModel> LedgerViewModel)
{
string ErrorText = "";
var ledgertemp = (from L in LedgerViewModel
group new { L } by new { L.DocHeaderId } into Result
select new
{
DocHeadewrId = Result.Key.DocHeaderId,
TotalDrAmt = Result.Sum(i => i.L.AmtDr),
TotalCrAmt = Result.Sum(i => i.L.AmtCr)
}).FirstOrDefault();
if (ledgertemp.TotalCrAmt != ledgertemp.TotalDrAmt)
{
ErrorText = "Debit and credit side amounts are not equal.";
return(ErrorText);
}
//Get Data from Ledger VIew Model and post in ledger header model for insertion or updation
LedgerHeader LedgerHeader = (from L in LedgerViewModel
select new LedgerHeader
{
DocHeaderId = L.DocHeaderId,
DocTypeId = L.DocTypeId,
DocDate = L.DocDate,
DocNo = L.DocNo,
DivisionId = L.DivisionId,
SiteId = L.SiteId,
LedgerAccountId = L.HeaderLedgerAccountId,
CreditDays = L.CreditDays,
Narration = L.HeaderNarration,
Remark = L.Remark,
Status = L.Status,
CreatedBy = L.CreatedBy,
CreatedDate = L.CreatedDate,
ModifiedBy = L.ModifiedBy,
ModifiedDate = L.ModifiedDate
}).FirstOrDefault();
//For Checking that this Doc Header Id already exist in Ledger Header
var temp = new LedgerHeaderService(_unitOfWork).FindByDocHeader(LedgerHeader.DocHeaderId, LedgerHeader.DocTypeId, LedgerHeader.SiteId, LedgerHeader.DivisionId);
//if record is found in Ledger Header Table then it will edit it if data is not found in ledger header table than it will add a new record.
if (temp == null)
{
new LedgerHeaderService(_unitOfWork).Create(LedgerHeader);
LedgerHeader H = new LedgerHeader();
H.DocHeaderId = LedgerHeader.DocHeaderId;
H.DocTypeId = LedgerHeader.DocTypeId;
H.DocDate = LedgerHeader.DocDate;
H.DocNo = LedgerHeader.DocNo;
H.DivisionId = LedgerHeader.DivisionId;
H.SiteId = LedgerHeader.SiteId;
H.LedgerAccountId = LedgerHeader.LedgerAccountId;
H.CreditDays = LedgerHeader.CreditDays;
H.Narration = LedgerHeader.Narration;
H.Remark = LedgerHeader.Remark;
H.Status = LedgerHeader.Status;
H.CreatedBy = LedgerHeader.CreatedBy;
H.CreatedDate = LedgerHeader.CreatedDate;
H.ModifiedBy = LedgerHeader.ModifiedBy;
H.ModifiedDate = LedgerHeader.ModifiedDate;
}
else
{
DeleteLedgerForLedgerHeader(LedgerHeader.LedgerHeaderId);
temp.DocHeaderId = LedgerHeader.DocHeaderId;
temp.DocTypeId = LedgerHeader.DocTypeId;
temp.DocDate = LedgerHeader.DocDate;
temp.DocNo = LedgerHeader.DocNo;
temp.DivisionId = LedgerHeader.DivisionId;
temp.SiteId = LedgerHeader.SiteId;
temp.LedgerAccountId = LedgerHeader.LedgerAccountId;
temp.CreditDays = LedgerHeader.CreditDays;
temp.Narration = LedgerHeader.Narration;
temp.Remark = LedgerHeader.Remark;
temp.Status = LedgerHeader.Status;
temp.CreatedBy = LedgerHeader.CreatedBy;
temp.CreatedDate = LedgerHeader.CreatedDate;
temp.ModifiedBy = LedgerHeader.ModifiedBy;
temp.ModifiedDate = LedgerHeader.ModifiedDate;
new LedgerHeaderService(_unitOfWork).Update(temp);
}
IEnumerable <Ledger> LedgerList = (from L in LedgerViewModel
group new { L } by new { L.LedgerAccountId, L.ContraLedgerAccountId, L.CostCenterId } into Result
select new Ledger
{
LedgerAccountId = Result.Key.LedgerAccountId,
ContraLedgerAccountId = Result.Key.ContraLedgerAccountId,
CostCenterId = Result.Key.CostCenterId,
AmtDr = Result.Sum(i => i.L.AmtDr),
AmtCr = Result.Sum(i => i.L.AmtCr),
Narration = Result.Max(i => i.L.Narration)
}).ToList();
foreach (Ledger item in LedgerList)
{
if (temp != null)
{
item.LedgerHeaderId = temp.LedgerHeaderId;
}
Create(item);
}
return(ErrorText);
}
public string LedgerPost(LedgerViewModel LedgerViewModel_New, LedgerViewModel LedgerViewModel_Old)
{
string ErrorText = "";
LedgerHeader LedgerHeader;
if (LedgerViewModel_New != null)
{
LedgerHeader = new LedgerHeaderService(_unitOfWork).FindByDocHeader(LedgerViewModel_New.DocHeaderId, LedgerViewModel_New.DocTypeId, LedgerViewModel_New.SiteId, LedgerViewModel_New.DivisionId);
if (LedgerHeader == null)
{
LedgerHeader H = new LedgerHeader();
H.DocHeaderId = LedgerHeader.DocHeaderId;
H.DocTypeId = LedgerHeader.DocTypeId;
H.DocDate = LedgerHeader.DocDate;
H.DocNo = LedgerHeader.DocNo;
H.DivisionId = LedgerHeader.DivisionId;
H.SiteId = LedgerHeader.SiteId;
H.LedgerAccountId = LedgerHeader.LedgerAccountId;
H.CreditDays = LedgerHeader.CreditDays;
H.Narration = LedgerHeader.Narration;
H.Remark = LedgerHeader.Remark;
H.Status = LedgerHeader.Status;
H.CreatedBy = LedgerHeader.CreatedBy;
H.CreatedDate = LedgerHeader.CreatedDate;
H.ModifiedBy = LedgerHeader.ModifiedBy;
H.ModifiedDate = LedgerHeader.ModifiedDate;
new LedgerHeaderService(_unitOfWork).Create(H);
}
else
{
LedgerHeader.DocHeaderId = LedgerViewModel_New.DocHeaderId;
LedgerHeader.DocTypeId = LedgerViewModel_New.DocTypeId;
LedgerHeader.DocDate = LedgerViewModel_New.DocDate;
LedgerHeader.DocNo = LedgerViewModel_New.DocNo;
LedgerHeader.DivisionId = LedgerViewModel_New.DivisionId;
LedgerHeader.SiteId = LedgerViewModel_New.SiteId;
LedgerHeader.Remark = LedgerViewModel_New.Remark;
LedgerHeader.Status = LedgerViewModel_New.Status;
LedgerHeader.CreatedBy = LedgerViewModel_New.CreatedBy;
LedgerHeader.CreatedDate = LedgerViewModel_New.CreatedDate;
LedgerHeader.ModifiedBy = LedgerViewModel_New.ModifiedBy;
LedgerHeader.ModifiedDate = LedgerViewModel_New.ModifiedDate;
new LedgerHeaderService(_unitOfWork).Update(LedgerHeader);
}
}
else
{
LedgerHeader = new LedgerHeaderService(_unitOfWork).FindByDocHeader(LedgerViewModel_Old.DocHeaderId, LedgerViewModel_Old.DocTypeId, LedgerViewModel_Old.SiteId, LedgerViewModel_Old.DivisionId);
}
if (LedgerViewModel_Old != null)
{
Ledger Ledger_Old = Find(LedgerHeader.LedgerHeaderId, LedgerViewModel_Old.LedgerAccountId, LedgerViewModel_Old.ContraLedgerAccountId, LedgerViewModel_Old.CostCenterId);
Ledger_Old.AmtCr = Ledger_Old.AmtCr - LedgerViewModel_Old.AmtCr;
Ledger_Old.AmtDr = Ledger_Old.AmtDr - LedgerViewModel_Old.AmtDr;
if (Ledger_Old.AmtCr == 0 && Ledger_Old.AmtDr == 0)
{
Delete(Ledger_Old);
}
else
{
Update(Ledger_Old);
}
}
if (LedgerViewModel_New != null)
{
Ledger Ledger_New;
if (LedgerHeader != null)
{
Ledger_New = Find(LedgerHeader.LedgerHeaderId, LedgerViewModel_New.LedgerAccountId, LedgerViewModel_New.ContraLedgerAccountId, LedgerViewModel_New.CostCenterId);
}
else
{
Ledger_New = null;
}
if (Ledger_New == null)
{
Ledger L = new Ledger();
L.LedgerAccountId = LedgerViewModel_New.LedgerAccountId;
L.ContraLedgerAccountId = LedgerViewModel_New.ContraLedgerAccountId;
L.CostCenterId = LedgerViewModel_New.CostCenterId;
L.AmtDr = LedgerViewModel_New.AmtDr;
L.AmtCr = LedgerViewModel_New.AmtCr;
L.Narration = LedgerViewModel_New.Narration;
L.ContraText = LedgerViewModel_New.ContraText;
if (LedgerHeader != null)
{
L.LedgerHeaderId = LedgerHeader.LedgerHeaderId;
}
Create(L);
}
else
{
Ledger_New.AmtDr = Ledger_New.AmtDr + LedgerViewModel_New.AmtDr;
Ledger_New.AmtCr = Ledger_New.AmtCr + LedgerViewModel_New.AmtCr;
Update(Ledger_New);
}
}
return(ErrorText);
}
public void Delete(LedgerHeader s)
{
_ledgerHeaderRepository.Delete(s);
}
public void Update(LedgerHeader s)
{
s.ObjectState = ObjectState.Modified;
_ledgerHeaderRepository.Update(s);
}
public LedgerHeader Create(LedgerHeader s)
{
s.ObjectState = ObjectState.Added;
_ledgerHeaderRepository.Insert(s);
return(s);
}
public static void Encode(IByteWriter stream, LedgerHeaderHistoryEntry encodedLedgerHeaderHistoryEntry)
{
Hash.Encode(stream, encodedLedgerHeaderHistoryEntry.Hash);
LedgerHeader.Encode(stream, encodedLedgerHeaderHistoryEntry.Header);
LedgerHeaderHistoryEntryExt.Encode(stream, encodedLedgerHeaderHistoryEntry.Ext);
}
public ActionResult _CreatePost(LedgerAccountOpeningViewModel svm)
{
if (ModelState.IsValid)
{
if (svm.LedgerHeaderId <= 0)
{
var temp = (from H in db.LedgerHeader
where H.DocTypeId == svm.DocTypeId && H.DocNo == svm.DocNo && H.SiteId == svm.SiteId && H.DivisionId == svm.DivisionId
select H).FirstOrDefault();
if (temp != null)
{
if (svm.LedgerSetting.IsAutoDocNo == true)
{
svm.DocNo = new DocumentTypeService(_unitOfWork).FGetNewDocNo("DocNo", ConfigurationManager.AppSettings["DataBaseSchema"] + ".LedgerHeaders", svm.DocTypeId, svm.DocDate, svm.DivisionId, svm.SiteId);
}
}
}
if (svm.LedgerHeaderId == 0)
{
LedgerHeader Header = new LedgerHeader();
Header.DocHeaderId = svm.LedgerAccountId;
Header.DocNo = svm.DocNo;
Header.DocTypeId = svm.DocTypeId;
Header.DocDate = svm.DocDate;
Header.SiteId = svm.SiteId;
Header.DivisionId = svm.DivisionId;
Header.PaymentFor = null;
Header.AdjustmentType = null;
Header.ProcessId = null;
Header.GodownId = null;
Header.LedgerAccountId = null;
Header.DrCr = null;
Header.PartyDocNo = svm.PartyDocNo;
Header.PartyDocDate = svm.PartyDocDate;
Header.Narration = svm.Narration;
Header.CreatedDate = DateTime.Now;
Header.CreatedBy = User.Identity.Name;
Header.ModifiedDate = DateTime.Now;
Header.ModifiedBy = User.Identity.Name;
Header.ObjectState = Model.ObjectState.Added;
db.LedgerHeader.Add(Header);
LedgerLine Line = new LedgerLine();
Line.LedgerHeaderId = Header.LedgerHeaderId;
Line.LedgerAccountId = svm.LedgerAccountId;
Line.Amount = svm.Amount;
Line.ChqNo = null;
Line.ChqDate = null;
Line.CostCenterId = null;
Line.BaseRate = 0;
Line.BaseValue = 0;
Line.ReferenceId = null;
Line.ProductUidId = null;
Line.ReferenceDocTypeId = null;
Line.ReferenceDocId = null;
Line.CreatedDate = DateTime.Now;
Line.ModifiedDate = DateTime.Now;
Line.CreatedBy = User.Identity.Name;
Line.Remark = svm.Narration;
Line.ModifiedBy = User.Identity.Name;
Line.ObjectState = Model.ObjectState.Added;
db.LedgerLine.Add(Line);
Ledger Ledger = new Ledger();
if (svm.DrCr == NatureConstants.Debit)
{
Ledger.AmtDr = svm.Amount;
}
else if (svm.DrCr == NatureConstants.Credit)
{
Ledger.AmtCr = svm.Amount;
}
Ledger.ChqNo = Line.ChqNo;
Ledger.ContraLedgerAccountId = null;
Ledger.CostCenterId = Line.CostCenterId;
Ledger.DueDate = null;
Ledger.LedgerAccountId = Line.LedgerAccountId;
Ledger.LedgerHeaderId = Line.LedgerHeaderId;
Ledger.LedgerLineId = Line.LedgerLineId;
Ledger.ProductUidId = Line.ProductUidId;
Ledger.Narration = Header.Narration;
Ledger.ObjectState = Model.ObjectState.Added;
Ledger.LedgerId = 1;
db.Ledger.Add(Ledger);
try
{
db.SaveChanges();
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
PrepareViewBag();
ModelState.AddModelError("", message);
return(PartialView("_Create", svm));
}
return(RedirectToAction("_Create", new { id = svm.LedgerAccountId }));
}
else
{
LedgerHeader Header = new LedgerHeaderService(_unitOfWork).Find(svm.LedgerHeaderId);
LedgerLine Line = new LedgerLineService(_unitOfWork).FindByLedgerHeader(svm.LedgerHeaderId).FirstOrDefault();
Ledger Ledger = new LedgerService(_unitOfWork).FindForLedgerHeader(svm.LedgerHeaderId).FirstOrDefault();
Header.SiteId = svm.SiteId;
Header.DivisionId = svm.DivisionId;
Header.DocNo = svm.DocNo;
Header.DocTypeId = svm.DocTypeId;
Header.DocDate = svm.DocDate;
Header.PartyDocNo = svm.PartyDocNo;
Header.PartyDocDate = svm.PartyDocDate;
Header.Narration = svm.Narration;
Header.ModifiedDate = DateTime.Now;
Header.ModifiedBy = User.Identity.Name;
Header.ObjectState = Model.ObjectState.Modified;
db.LedgerHeader.Add(Header);
Line.Amount = svm.Amount;
Line.ModifiedDate = DateTime.Now;
Line.ModifiedBy = User.Identity.Name;
Line.ObjectState = Model.ObjectState.Modified;
db.LedgerLine.Add(Line);
if (svm.DrCr == NatureConstants.Debit)
{
Ledger.AmtDr = svm.Amount;
Ledger.AmtCr = 0;
}
else if (svm.DrCr == NatureConstants.Credit)
{
Ledger.AmtCr = svm.Amount;
Ledger.AmtDr = 0;
}
Ledger.ChqNo = Line.ChqNo;
Ledger.CostCenterId = Line.CostCenterId;
Ledger.LedgerAccountId = Line.LedgerAccountId;
Ledger.LedgerHeaderId = Line.LedgerHeaderId;
Ledger.LedgerLineId = Line.LedgerLineId;
Ledger.ProductUidId = Line.ProductUidId;
Ledger.Narration = Header.Narration;
Ledger.ObjectState = Model.ObjectState.Modified;
db.Ledger.Add(Ledger);
try
{
db.SaveChanges();
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
PrepareViewBag();
ModelState.AddModelError("", message);
return(PartialView("_Create", svm));
}
return(Json(new { success = true }));
}
}
PrepareViewBag();
return(PartialView("_Create", svm));
}
public static void Encode(XdrDataOutputStream stream, LedgerHeaderHistoryEntry encodedLedgerHeaderHistoryEntry)
{
Hash.Encode(stream, encodedLedgerHeaderHistoryEntry.Hash);
LedgerHeader.Encode(stream, encodedLedgerHeaderHistoryEntry.Header);
LedgerHeaderHistoryEntryExt.Encode(stream, encodedLedgerHeaderHistoryEntry.Ext);
}
public void Update(LedgerHeader s)
{
s.ObjectState = ObjectState.Modified;
_unitOfWork.Repository <LedgerHeader>().Update(s);
}
public ActionResult PostSummary(JobInvoiceSummaryDetailViewModel vm)
{
//TempData["CSEXC"] = "Customize Test Exception";
String ErrorMsg = "";
foreach (var item in vm.JobInvoiceSummaryViewModel)
{
if (item.AdvanceAdjusted > item.InvoiceAmount + item.TanaAmount)
{
string ProductUidName = "";
if (item.ProductUidId != null)
{
ProductUidName = new ProductUidService(_unitOfWork).Find((int)item.ProductUidId).ProductUidName;
}
ErrorMsg = "Total adjusted advance for barcode " + ProductUidName + " is exceeding invoice amount.";
}
}
var AdvanceData = (from H in vm.JobInvoiceSummaryViewModel
group new { H } by new { H.CostCenterId } into Result
select new
{
CostCenterId = Result.Key.CostCenterId,
TotalAdvanceAmount = Result.Max(m => m.H.AdvanceAmount),
TotalAdvanceAdjusted = Result.Sum(m => m.H.AdvanceAdjusted)
}).ToList();
foreach (var item in AdvanceData)
{
if (item.TotalAdvanceAdjusted > item.TotalAdvanceAmount)
{
string CostCenterName = new CostCenterService(_unitOfWork).Find(item.CostCenterId).CostCenterName;
ErrorMsg = "Total adjusted advance for purja " + CostCenterName + " is exceeding total advance amount.";
}
}
var TdsData = (from H in vm.JobInvoiceSummaryViewModel
group new { H } by new { H.PersonId } into Result
select new
{
PersonId = Result.Key.PersonId,
TotalTdsAmount = Result.Max(m => m.H.TdsAmount),
TotalTdsAdjusted = Result.Sum(m => m.H.TdsAdjusted)
}).ToList();
foreach (var item in TdsData)
{
if (item.TotalTdsAdjusted > item.TotalTdsAmount)
{
string PersonName = new PersonService(_unitOfWork).Find(item.PersonId).Name;
ErrorMsg = "Total adjusted tds for person " + PersonName + " is exceeding total tds amount.";
}
}
if (ErrorMsg != "")
{
TempData["CSEXC"] = ErrorMsg;
return(View("Summary", vm));
}
List <LogTypeViewModel> LogList = new List <LogTypeViewModel>();
bool Modified = false;
int Id = vm.JobInvoiceHeaderId;
var Header = _JobInvoiceHeaderService.Find(Id);
int LedgerHeaderId = 0;
int LedgerLineId = 0;
int LedgerId = 0;
int LedgerAdjId = 0;
int TanaPaymentDueCnt = 0;
int TdsCollectionCnt = 0;
int SavedTanaLedgerHeaderId = 0;
int SavedTdsCollectionLedgerHeaderId = 0;
int TanaPaymentDueAcId = new LedgerAccountService(_unitOfWork).Find(TanaPaymentDueAccount).LedgerAccountId;
DeleteLedgerTransaction(Header.JobInvoiceHeaderId);
DataTable AdvanceAdjustedDataTable = new DataTable();
AdvanceAdjustedDataTable.Columns.Add("Id");
AdvanceAdjustedDataTable.Columns.Add("Qty");
foreach (var item in vm.JobInvoiceSummaryViewModel)
{
if (item.TanaAmount > 0)
{
#region "Tana Payment Due"
if (TanaPaymentDueCnt == 0)
{
LedgerHeader TanaLedgerHeader = new LedgerHeader();
TanaLedgerHeader.LedgerHeaderId = LedgerHeaderId;
TanaLedgerHeader.DocTypeId = new DocumentTypeService(_unitOfWork).Find(TanaPaymentDueDocType).DocumentTypeId;
TanaLedgerHeader.DocDate = DateTime.Now.Date;
TanaLedgerHeader.DivisionId = Header.DivisionId;
TanaLedgerHeader.SiteId = Header.SiteId;
TanaLedgerHeader.DocNo = new DocumentTypeService(_unitOfWork).FGetNewDocNo("DocNo", ConfigurationManager.AppSettings["DataBaseSchema"] + ".LedgerHeaders", TanaLedgerHeader.DocTypeId, TanaLedgerHeader.DocDate, TanaLedgerHeader.DivisionId, TanaLedgerHeader.SiteId);
TanaLedgerHeader.LedgerAccountId = TanaPaymentDueAcId;
TanaLedgerHeader.Narration = "Tana Payment Due";
TanaLedgerHeader.Status = (int)StatusConstants.Submitted;
TanaLedgerHeader.ProcessId = new ProcessService(_unitOfWork).Find(ProcessConstants.Weaving).ProcessId;
TanaLedgerHeader.CostCenterId = null;
TanaLedgerHeader.AdjustmentType = "Due";
TanaLedgerHeader.PaymentFor = DateTime.Now.Date;
TanaLedgerHeader.ReferenceDocId = Header.JobInvoiceHeaderId;
TanaLedgerHeader.ReferenceDocTypeId = Header.DocTypeId;
TanaLedgerHeader.CreatedDate = DateTime.Now;
TanaLedgerHeader.ModifiedDate = DateTime.Now;
TanaLedgerHeader.CreatedBy = User.Identity.Name;
TanaLedgerHeader.ModifiedBy = User.Identity.Name;
TanaLedgerHeader.ObjectState = Model.ObjectState.Added;
new LedgerHeaderService(_unitOfWork).Create(TanaLedgerHeader);
LedgerHeaderId = LedgerHeaderId - 1;
TanaPaymentDueCnt = TanaPaymentDueCnt + 1;
SavedTanaLedgerHeaderId = TanaLedgerHeader.LedgerHeaderId;
}
LedgerLine TanaLedgerLine = new LedgerLine();
TanaLedgerLine.LedgerLineId = LedgerLineId;
TanaLedgerLine.LedgerHeaderId = SavedTanaLedgerHeaderId;
TanaLedgerLine.LedgerAccountId = new LedgerAccountService(_unitOfWork).GetLedgerAccountByPersondId(item.PersonId).LedgerAccountId;
TanaLedgerLine.CostCenterId = item.CostCenterId;
TanaLedgerLine.ProductUidId = item.ProductUidId;
TanaLedgerLine.Amount = item.TanaAmount;
TanaLedgerLine.ReferenceDocLineId = item.JobInvoiceLineId;
TanaLedgerLine.ReferenceDocTypeId = Header.DocTypeId;
TanaLedgerLine.CreatedDate = DateTime.Now;
TanaLedgerLine.ModifiedDate = DateTime.Now;
TanaLedgerLine.CreatedBy = User.Identity.Name;
TanaLedgerLine.ModifiedBy = User.Identity.Name;
TanaLedgerLine.ObjectState = Model.ObjectState.Added;
new LedgerLineService(_unitOfWork).Create(TanaLedgerLine);
LedgerLineId = LedgerLineId - 1;
Ledger TanaLedgerDr = new Ledger();
TanaLedgerDr.LedgerId = LedgerId;
TanaLedgerDr.LedgerHeaderId = SavedTanaLedgerHeaderId;
TanaLedgerDr.LedgerAccountId = TanaPaymentDueAcId;
TanaLedgerDr.ContraLedgerAccountId = TanaLedgerLine.LedgerAccountId;
TanaLedgerDr.CostCenterId = null;
TanaLedgerDr.ProductUidId = item.ProductUidId;
TanaLedgerDr.AmtDr = TanaLedgerLine.Amount;
TanaLedgerDr.AmtCr = 0;
TanaLedgerDr.Narration = "Tana Payment Due";
TanaLedgerDr.LedgerLineId = TanaLedgerLine.LedgerLineId;
TanaLedgerDr.ObjectState = Model.ObjectState.Added;
new LedgerService(_unitOfWork).Create(TanaLedgerDr);
LedgerId = LedgerId - 1;
Ledger TanaLedgerCr = new Ledger();
TanaLedgerDr.LedgerId = LedgerId;
TanaLedgerCr.LedgerHeaderId = SavedTanaLedgerHeaderId;
TanaLedgerCr.LedgerAccountId = TanaLedgerLine.LedgerAccountId;
TanaLedgerCr.ContraLedgerAccountId = TanaPaymentDueAcId;
TanaLedgerCr.CostCenterId = item.CostCenterId;
TanaLedgerDr.ProductUidId = item.ProductUidId;
TanaLedgerCr.AmtDr = 0;
TanaLedgerCr.AmtCr = TanaLedgerLine.Amount;
TanaLedgerCr.Narration = null;
TanaLedgerCr.LedgerLineId = TanaLedgerLine.LedgerLineId;
TanaLedgerCr.ObjectState = Model.ObjectState.Added;
new LedgerService(_unitOfWork).Create(TanaLedgerCr);
LedgerId = LedgerId - 1;
#endregion
}
if (item.TdsAdjusted > 0)
{
#region "Tds Collection"
var TdsRate = (from H in db.BusinessEntity
join Tr in db.TdsRate on new { X1 = H.TdsCategoryId ?? 0, X2 = H.TdsGroupId ?? 0 } equals new { X1 = Tr.TdsCategoryId, X2 = Tr.TdsGroupId } into TdsRateTable
from TdsRateTab in TdsRateTable.DefaultIfEmpty()
where H.PersonID == item.PersonId
select TdsRateTab).FirstOrDefault();
if (TdsCollectionCnt == 0)
{
LedgerHeader TdsLedgerHeader = new LedgerHeader();
TdsLedgerHeader.LedgerHeaderId = LedgerHeaderId;
TdsLedgerHeader.DocTypeId = new DocumentTypeService(_unitOfWork).Find(TdsCollectionDocType).DocumentTypeId;
TdsLedgerHeader.DocDate = DateTime.Now.Date;
TdsLedgerHeader.DivisionId = Header.DivisionId;
TdsLedgerHeader.SiteId = Header.SiteId;
TdsLedgerHeader.DocNo = new DocumentTypeService(_unitOfWork).FGetNewDocNo("DocNo", ConfigurationManager.AppSettings["DataBaseSchema"] + ".LedgerHeaders", TdsLedgerHeader.DocTypeId, TdsLedgerHeader.DocDate, TdsLedgerHeader.DivisionId, TdsLedgerHeader.SiteId);
TdsLedgerHeader.LedgerAccountId = TdsRate.LedgerAccountId;
TdsLedgerHeader.Narration = "Tds Adjustment";
TdsLedgerHeader.Status = (int)StatusConstants.Submitted;
TdsLedgerHeader.ProcessId = new ProcessService(_unitOfWork).Find(ProcessConstants.Weaving).ProcessId;
TdsLedgerHeader.CostCenterId = null;
TdsLedgerHeader.AdjustmentType = "Due";
TdsLedgerHeader.PaymentFor = DateTime.Now.Date;
TdsLedgerHeader.ReferenceDocId = Header.JobInvoiceHeaderId;
TdsLedgerHeader.ReferenceDocTypeId = Header.DocTypeId;
TdsLedgerHeader.CreatedDate = DateTime.Now;
TdsLedgerHeader.ModifiedDate = DateTime.Now;
TdsLedgerHeader.CreatedBy = User.Identity.Name;
TdsLedgerHeader.ModifiedBy = User.Identity.Name;
TdsLedgerHeader.ObjectState = Model.ObjectState.Added;
new LedgerHeaderService(_unitOfWork).Create(TdsLedgerHeader);
LedgerHeaderId = LedgerHeaderId - 1;
TdsCollectionCnt = TdsCollectionCnt + 1;
SavedTdsCollectionLedgerHeaderId = TdsLedgerHeader.LedgerHeaderId;
}
LedgerLine TdsLedgerLine = new LedgerLine();
TdsLedgerLine.LedgerLineId = LedgerLineId;
TdsLedgerLine.LedgerHeaderId = SavedTdsCollectionLedgerHeaderId;
TdsLedgerLine.LedgerAccountId = new LedgerAccountService(_unitOfWork).GetLedgerAccountByPersondId(item.PersonId).LedgerAccountId;
if (item.CostCenterId != 0)
{
TdsLedgerLine.CostCenterId = item.CostCenterId;
}
TdsLedgerLine.ProductUidId = item.ProductUidId;
TdsLedgerLine.BaseValue = item.TdsAdjusted * 100 / TdsRate.Percentage;
TdsLedgerLine.Amount = item.TdsAdjusted;
TdsLedgerLine.CreatedDate = DateTime.Now;
TdsLedgerLine.ModifiedDate = DateTime.Now;
TdsLedgerLine.CreatedBy = User.Identity.Name;
TdsLedgerLine.ModifiedBy = User.Identity.Name;
TdsLedgerLine.ObjectState = Model.ObjectState.Added;
new LedgerLineService(_unitOfWork).Create(TdsLedgerLine);
LedgerLineId = LedgerLineId - 1;
Ledger TdsLedgerDr = new Ledger();
TdsLedgerDr.LedgerId = LedgerId;
TdsLedgerDr.LedgerHeaderId = SavedTdsCollectionLedgerHeaderId;
TdsLedgerDr.LedgerAccountId = TdsLedgerLine.LedgerAccountId;
TdsLedgerDr.ContraLedgerAccountId = TdsRate.LedgerAccountId;
if (item.CostCenterId != 0)
{
TdsLedgerDr.CostCenterId = item.CostCenterId;
}
TdsLedgerDr.ProductUidId = item.ProductUidId;
TdsLedgerDr.AmtDr = TdsLedgerLine.Amount;
TdsLedgerDr.AmtCr = 0;
TdsLedgerDr.Narration = "Tds Adjusted.";
TdsLedgerDr.LedgerLineId = TdsLedgerLine.LedgerLineId;
TdsLedgerDr.ObjectState = Model.ObjectState.Added;
new LedgerService(_unitOfWork).Create(TdsLedgerDr);
LedgerId = LedgerId - 1;
Ledger TdsLedgerCr = new Ledger();
TdsLedgerCr.LedgerId = LedgerId;
TdsLedgerCr.LedgerHeaderId = SavedTdsCollectionLedgerHeaderId;
TdsLedgerCr.LedgerAccountId = (int)TdsRate.LedgerAccountId;
TdsLedgerCr.ContraLedgerAccountId = TdsLedgerLine.LedgerAccountId;
TdsLedgerCr.CostCenterId = null;
TdsLedgerCr.ProductUidId = item.ProductUidId;
TdsLedgerCr.AmtDr = 0;
TdsLedgerCr.AmtCr = TdsLedgerLine.Amount;
TdsLedgerCr.Narration = null;
TdsLedgerCr.LedgerLineId = TdsLedgerLine.LedgerLineId;
TdsLedgerCr.ObjectState = Model.ObjectState.Added;
new LedgerService(_unitOfWork).Create(TdsLedgerCr);
LedgerId = LedgerId - 1;
var TempLedger = (from L in db.Ledger
where L.ReferenceDocLineId == item.JobInvoiceLineId && L.ReferenceDocTypeId == Header.DocTypeId
select new
{
LedgerCrId = L.LedgerId
}).FirstOrDefault();
LedgerAdj LedgerAdj = new LedgerAdj();
LedgerAdj.LedgerAdjId = LedgerAdjId;
LedgerAdj.DrLedgerId = TdsLedgerDr.LedgerId;
LedgerAdj.CrLedgerId = TempLedger == null ? 0 : TempLedger.LedgerCrId;
LedgerAdj.SiteId = Header.SiteId;
LedgerAdj.Adj_Type = "Tds Adjustment";
LedgerAdj.Amount = TdsLedgerDr.AmtDr;
LedgerAdj.CreatedBy = Header.CreatedBy;
LedgerAdj.CreatedDate = DateTime.Now;
LedgerAdj.ModifiedBy = Header.ModifiedBy;
LedgerAdj.ModifiedDate = DateTime.Now;
LedgerAdj.ObjectState = Model.ObjectState.Added;
new LedgerAdjService(_unitOfWork).Create(LedgerAdj);
LedgerAdjId = LedgerAdjId - 1;
#endregion
}
if (item.AdvanceAdjusted > 0)
{
var AdvanceAdjustedDataRow = AdvanceAdjustedDataTable.NewRow();
AdvanceAdjustedDataRow["Id"] = item.JobInvoiceLineId;
AdvanceAdjustedDataRow["Qty"] = item.AdvanceAdjusted;
AdvanceAdjustedDataTable.Rows.Add(AdvanceAdjustedDataRow);
}
}
if (AdvanceAdjustedDataTable.Rows.Count > 0)
{
string ConnectionString = (string)System.Web.HttpContext.Current.Session["DefaultConnectionString"];
DataSet ds = new DataSet();
using (SqlConnection sqlConnection = new SqlConnection(ConnectionString))
{
sqlConnection.Open();
using (SqlCommand cmd = new SqlCommand("" + ConfigurationManager.AppSettings["DataBaseSchema"] + ".spGetLedgerAdj"))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Connection = sqlConnection;
cmd.Parameters.AddWithValue("@T", AdvanceAdjustedDataTable);
cmd.CommandTimeout = 1000;
using (SqlDataAdapter adp = new SqlDataAdapter(cmd))
{
adp.Fill(ds);
}
}
}
for (int j = 0; j <= ds.Tables[0].Rows.Count - 1; j++)
{
LedgerAdj LedgerAdj = new LedgerAdj();
LedgerAdj.LedgerAdjId = LedgerAdjId;
LedgerAdj.DrLedgerId = (int)ds.Tables[0].Rows[j]["LedgerDrId"];
LedgerAdj.CrLedgerId = (int)ds.Tables[0].Rows[j]["LedgerCrId"];
LedgerAdj.SiteId = Header.SiteId;
LedgerAdj.Adj_Type = "Advance Adjustment";
LedgerAdj.Amount = (decimal)ds.Tables[0].Rows[j]["BalanceDr"];
LedgerAdj.CreatedBy = Header.CreatedBy;
LedgerAdj.CreatedDate = DateTime.Now;
LedgerAdj.ModifiedBy = Header.ModifiedBy;
LedgerAdj.ModifiedDate = DateTime.Now;
LedgerAdj.ObjectState = Model.ObjectState.Added;
new LedgerAdjService(_unitOfWork).Create(LedgerAdj);
LedgerAdjId = LedgerAdjId - 1;
}
}
try
{
_unitOfWork.Save();
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
ModelState.AddModelError("", message);
PrepareViewBag(vm.JobInvoiceHeaderId);
return(Json(new { Success = false }));
}
LogActivity.LogActivityDetail(LogVm.Map(new ActiivtyLogViewModel
{
DocTypeId = Header.DocTypeId,
DocId = Header.JobInvoiceHeaderId,
ActivityType = (int)ActivityTypeContants.Modified,
DocNo = Header.DocNo,
//xEModifications = Modifications,
DocDate = Header.DocDate,
DocStatus = Header.Status,
}));
string RetUrl = "";
if (Header.Status == (int)StatusConstants.Drafted || Header.Status == (int)StatusConstants.Import)
{
RetUrl = System.Configuration.ConfigurationManager.AppSettings["JobsDomain"] + "/JobInvoiceHeader/Modify/" + Header.JobInvoiceHeaderId;
}
else if (Header.Status == (int)StatusConstants.Submitted || Header.Status == (int)StatusConstants.ModificationSubmitted || Header.Status == (int)StatusConstants.Modified)
{
RetUrl = System.Configuration.ConfigurationManager.AppSettings["JobsDomain"] + "/JobInvoiceHeader/ModifyAfter_Submit/" + Header.JobInvoiceHeaderId;
}
else if (Header.Status == (int)StatusConstants.Approved || Header.Status == (int)StatusConstants.Closed)
{
RetUrl = System.Configuration.ConfigurationManager.AppSettings["JobsDomain"] + "/JobInvoiceHeader/ModifyAfter_Approve/" + Header.JobInvoiceHeaderId;
}
else
{
RetUrl = System.Configuration.ConfigurationManager.AppSettings["JobsDomain"] + "/JobInvoiceHeader/Index/" + Header.DocTypeId;
}
return(Json(new { Success = true, Url = RetUrl }));
}
public LedgerHeader Create(LedgerHeader s)
{
s.ObjectState = ObjectState.Added;
_unitOfWork.Repository <LedgerHeader>().Insert(s);
return(s);
}
public int LedgerPost(SaleOrderHeader pd)
{
int LedgerHeaderId = 0;
if (pd.LedgerHeaderId == 0 || pd.LedgerHeaderId == null)
{
LedgerHeader LedgerHeader = new LedgerHeader();
LedgerHeader.DocTypeId = pd.DocTypeId;
LedgerHeader.DocDate = pd.DocDate;
LedgerHeader.DocNo = pd.DocNo;
LedgerHeader.DivisionId = pd.DivisionId;
LedgerHeader.SiteId = pd.SiteId;
LedgerHeader.Remark = pd.Remark;
LedgerHeader.CreatedBy = pd.CreatedBy;
LedgerHeader.CreatedDate = DateTime.Now.Date;
LedgerHeader.ModifiedBy = pd.ModifiedBy;
LedgerHeader.ModifiedDate = DateTime.Now.Date;
new LedgerHeaderService(_unitOfWork).Create(LedgerHeader);
}
else
{
LedgerHeader LedgerHeader = new LedgerHeaderService(_unitOfWork).Find((int)pd.LedgerHeaderId);
LedgerHeader.DocTypeId = pd.DocTypeId;
LedgerHeader.DocDate = pd.DocDate;
LedgerHeader.DocNo = pd.DocNo;
LedgerHeader.DivisionId = pd.DivisionId;
LedgerHeader.SiteId = pd.SiteId;
LedgerHeader.Remark = pd.Remark;
LedgerHeader.ModifiedBy = pd.ModifiedBy;
LedgerHeader.ModifiedDate = DateTime.Now.Date;
new LedgerHeaderService(_unitOfWork).Update(LedgerHeader);
IEnumerable <Ledger> LedgerList = new LedgerService(_unitOfWork).FindForLedgerHeader(LedgerHeader.LedgerHeaderId);
foreach (Ledger item in LedgerList)
{
new LedgerService(_unitOfWork).Delete(item);
}
LedgerHeaderId = LedgerHeader.LedgerHeaderId;
}
int SalesAc = new LedgerAccountService(_unitOfWork).Find(LedgerAccountConstants.Sale).LedgerAccountId;
if (pd.Advance > 0)
{
Ledger LedgerDr = new Ledger();
if (LedgerHeaderId != 0)
{
LedgerDr.LedgerHeaderId = LedgerHeaderId;
}
LedgerDr.LedgerAccountId = SalesAc;
LedgerDr.ContraLedgerAccountId = pd.BillToBuyerId;
LedgerDr.AmtDr = pd.Advance ?? 0;
LedgerDr.AmtCr = 0;
LedgerDr.Narration = "";
new LedgerService(_unitOfWork).Create(LedgerDr);
Ledger LedgerCr = new Ledger();
if (LedgerHeaderId != 0)
{
LedgerCr.LedgerHeaderId = LedgerHeaderId;
}
LedgerCr.LedgerAccountId = pd.BillToBuyerId;
LedgerCr.ContraLedgerAccountId = SalesAc;
LedgerCr.AmtDr = 0;
LedgerCr.AmtCr = pd.Advance ?? 0;
LedgerCr.Narration = "";
new LedgerService(_unitOfWork).Create(LedgerCr);
}
return(LedgerHeaderId);
}
public void Delete(LedgerHeader s)
{
_unitOfWork.Repository <LedgerHeader>().Delete(s);
}
