public static AccountSummaryMain FillAccountSummaryMain(out Dictionary <string, decimal> topViewTotal)
{
AccountSummaryMain accountSummaryMain = new AccountSummaryMain();
accountSummaryMain.ArSummary = GetAccSummaryByParentAccId("171").Take(5).ToList();
//accountSummaryMain.ApSummary = GetAccSummaryByParentAccId("281", true).Take(5).ToList();
accountSummaryMain.AgentSummary = GetAccSummaryByParentAccId("178").Take(5).ToList();
accountSummaryMain.CashInBankSummary = GetBankListRpt("193").ToList();
accountSummaryMain.ApCarrierSummary = GetAccSummaryByParentAccId("2811", true).Take(5).ToList();
accountSummaryMain.ApContractorSummary = GetAccSummaryByParentAccId("2812", true).Take(5).ToList();
accountSummaryMain.TreasurySummary = GetAccSummaryByParentAccId("194").Take(5).ToList();
//Get Total Collected
AccountingEntities db = new AccountingEntities();
accountSummaryMain.TotalCollectedByCurrency = db.CashInReceipts.Include("Currency")
.Where(x => x.IsDeleted == false)
.GroupBy(x => x.Currency.CurrencySign)
.Select(x => new { CurrSign = x.Key, Amount = x.Sum(y => y.ReceiptAmount) })
.ToDictionary(x => x.CurrSign, x => x.Amount);
accountSummaryMain.TotalPaidByCurrency = db.CashOutReceipts.Include("Currency")
.Where(x => x.IsDeleted == false)
.GroupBy(x => x.Currency.CurrencySign)
.Select(x => new { CurrSign = x.Key, Amount = x.Sum(y => y.ReceiptAmount) })
.ToDictionary(x => x.CurrSign, x => x.Amount);
//Fill Balance Top View Report
accountSummaryMain.TopViewBalance = GetTopViewBalanceRpt();
topViewTotal = GetTopBalanceTotals(accountSummaryMain.TopViewBalance);
return(accountSummaryMain);
}
public static CashInVm GetCashReceiptInfo(int cashReceiptId = 0)
{
CashInVm cashVm = new CashInVm();
AccountingEntities db = new AccountingEntities();
var cashReceiptObj = db.ArCashDepositViews.Where(x => x.ReceiptId == cashReceiptId).FirstOrDefault();
Mapper.CreateMap <ArCashDepositView, CashInVm>()
.ForMember(x => x.CashInReceiptChecks, y => y.Ignore())
.ForMember(x => x.CashInReceiptInvs, y => y.Ignore())
.ForMember(x => x.PaymentTermName, y => y.MapFrom(u => u.PaymentTermEn));
Mapper.Map(cashReceiptObj, cashVm);
cashVm.CustomerName = string.IsNullOrEmpty(cashReceiptObj.ShipperNameEn) ? cashReceiptObj.ConsigneeNameEn : cashReceiptObj.ShipperNameEn;
//for bank
if (cashVm.PaymentTermId == (byte)PaymentTermEnum.BankCashDeposit)
{
int bankAccId = cashVm.BankAccId.Value;
var bankInfo = db.BankAccounts.Include("Bank").Where(x => x.BankAccId == bankAccId).FirstOrDefault();
cashVm.BankDetailsVm = new BankDetailsVm()
{
AccountName = bankInfo.AccountName,
AccountNumber = bankInfo.AccountNumber,
BankNameEn = bankInfo.Bank.BankNameEn,
BankAddressEn = bankInfo.Bank.BankAddressEn
};
}
return(cashVm);
}
public static List <CCCashDepositVm> GetCCCashDepositList(int operationId)
{
AccountingEntities db = new AccountingEntities();
List <CCCashDepositVm> cashDepositVmList = new List <CCCashDepositVm>();
var cashDepositDbList = db.CashOutCCCashDeposits.Include("CashOutReceipt")
.Where(x => x.OperationId == operationId)
.Select(x => new
{
x.OperationId,
x.ReceiptId,
x.CashOutReceipt.ReceiptAmount,
x.CashOutReceipt.Currency.CurrencySign,
x.CashOutReceipt.CreateDate,
x.CashOutReceipt.ReceiptCode
}).ToList();
CCCashDepositVm cashDepositVm;
foreach (var item in cashDepositDbList)
{
cashDepositVm = new CCCashDepositVm()
{
CreateDate = item.CreateDate,
CurrencySign = item.CurrencySign,
OperationId = item.OperationId,
ReceiptId = item.ReceiptId,
ReceiptAmount = item.ReceiptAmount,
ReceiptCode = item.ReceiptCode
};
cashDepositVmList.Add(cashDepositVm);
}
return(cashDepositVmList);
}
internal static BankDetailsVm GetBankDetByCurrency(int bankId, int currencyId)
{
BankDetailsVm bankDetails = new BankDetailsVm();
AccountingEntities db = new AccountingEntities();
Bank bankDbObj = db.Banks.Include("BankAccounts")
.Where(x => x.BankId == bankId).FirstOrDefault();
Mapper.CreateMap <Bank, BankDetailsVm>()
.ForMember(x => x.BankAccounts, y => y.Ignore())
.IgnoreAllNonExisting();
Mapper.Map(bankDbObj, bankDetails);
var bankAccountObj = bankDbObj.BankAccounts.Where(x => x.CurrencyId == currencyId).FirstOrDefault();
if (bankAccountObj != null)
{
bankDetails.AccountName = bankAccountObj.AccountName;
bankDetails.AccountNumber = bankAccountObj.AccountNumber;
bankDetails.BankAccId = bankAccountObj.BankAccId;
}
else
{
bankDetails.AccountName = "false";
}
return(bankDetails);
}
public static List <CashInInvoiceVm> GetCashInvList(int invId)
{
List <CashInInvoiceVm> cashInVmList = new List <CashInInvoiceVm>();
AccountingEntities db = new AccountingEntities();
var cashDbList = db.CashOutReceiptInvs
.Include("CashOutReceipt")
.Include("CashOutReceipt.PaymentTerm")
.Include("CashOutReceipt.Currency")
.Where(x => x.InvoiceId == invId).ToList();
Mapper.CreateMap <CashOutReceiptInv, CashInInvoiceVm>()
.IgnoreAllNonExisting();
Mapper.CreateMap <CashOutReceipt, CashInVm>()
.ForMember(x => x.CashInReceiptChecks, y => y.Ignore())
.IgnoreAllNonExisting();
Mapper.Map(cashDbList, cashInVmList);
foreach (var item in cashInVmList)
{
var cashDbObj = cashDbList
.Where(x => x.ReceiptId == item.ReceiptId && x.InvoiceId == item.InvoiceId).FirstOrDefault();
Mapper.Map(cashDbObj.CashOutReceipt, item.CashInReceipt);
item.CurrencySign = cashDbObj.CashOutReceipt.Currency.CurrencySign;
item.CashInReceipt.PaymentTermName = cashDbObj.CashOutReceipt.PaymentTerm.PaymentTermEn;
item.CashInReceipt.CashType = "cashout";
}
return(cashInVmList);
}
public static List <CashInInvoiceVm> GetCashAgNoteList(int agNoteId)
{
List <CashInInvoiceVm> cashInVmList = new List <CashInInvoiceVm>();
AccountingEntities db = new AccountingEntities();
var cashDbList = db.CashOutReceiptAgNotes
.Include("CashOutReceipt")
.Include("CashOutReceipt.PaymentTerm")
.Include("CashOutReceipt.Currency")
.Where(x => x.AgentNoteId == agNoteId).ToList();
Mapper.CreateMap <CashOutReceiptAgNote, CashInInvoiceVm>().IgnoreAllNonExisting();
Mapper.Map(cashDbList, cashInVmList);
Mapper.CreateMap <CashOutReceipt, CashInVm>();
foreach (var item in cashInVmList)
{
int receiptId = item.ReceiptId;
Mapper.Map(cashDbList.Where(x => x.ReceiptId == receiptId).FirstOrDefault().CashOutReceipt, item.CashInReceipt);
var cashDbObj = cashDbList
.Where(x => x.ReceiptId == item.ReceiptId && x.AgentNoteId == item.AgentNoteId).FirstOrDefault();
item.CurrencySign = cashDbObj.CashOutReceipt.Currency.CurrencySign;
item.CashInReceipt.PaymentTermName = cashDbObj.CashOutReceipt.PaymentTerm.PaymentTermEn;
}
return(cashInVmList);
}
/// <summary>
/// Delete accounting transaction the transaction table
/// </summary>
/// <param name="transID"></param>
/// <returns></returns>
public static bool DeleteTransaction(int transID)
{
bool isDeleted = false;
AccountingEntities db = new AccountingEntities();
AccTransaction transDb = new AccTransaction();
List <AccTransactionDetail> transDetailDb = new List <AccTransactionDetail>();
transDb = db.AccTransactions.Where(x => x.TransId == transID).FirstOrDefault();
if (transDb != null)
{
transDetailDb = db.AccTransactionDetails.Where(x => x.TransId == transID).ToList();
try
{
db.AccTransactions.Remove(transDb);
foreach (var item in transDetailDb)
{
db.AccTransactionDetails.Remove(item);
}
db.SaveChanges();
isDeleted = true;
}
catch
{
isDeleted = false;
}
}
return(isDeleted);
}
/// <summary>
/// Get Cash Receipt info for Agent Note ..Not like invoices ..
/// Will allow only to collect from one agent note only .. not for all notes for that agent
/// </summary>
/// <param name="agNoteId"></param>
/// <param name="cashVm"></param>
private static void FillCashVmForAgNote(int agNoteId, ref CashInVm cashVm)
{
AccountingEntities db = new AccountingEntities();
List <CashInInvoiceVm> cashAgNoteList = new List <CashInInvoiceVm>();
List <AgentNoteView> agNoteList = new List <AgentNoteView>();
agNoteList = db.AgentNoteViews
.Where(x => x.AgentNoteId == agNoteId && (x.InvStatusId != 4 && x.InvStatusId != 1)).ToList();
Mapper.CreateMap <AgentNoteView, CashInInvoiceVm>().IgnoreAllNonExisting();
Mapper.Map(agNoteList, cashAgNoteList);
cashVm.CashInReceiptInvs = cashAgNoteList;
List <int> invIds = agNoteList.Select(x => x.AgentNoteId).ToList();
var cashInvDb = db.CashOutReceiptAgNotes
.Where(x => invIds.Contains(x.AgentNoteId))
.GroupBy(x => x.AgentNoteId)
.ToList();
foreach (var item in cashVm.CashInReceiptInvs)
{
item.CollectedAmount = cashInvDb.Where(x => x.Key == item.AgentNoteId)
.Select(x => x.Sum(y => y.PaidAmount)).FirstOrDefault();
item.AmountDue = item.TotalAmount - item.CollectedAmount;
}
cashVm.CashType = "cashout";
}
public static List <AgentNoteVm> GetAgentNoteList(int operId)
{
AccountingEntities db = new AccountingEntities();
List <AgentNoteVm> agentNoteList = new List <AgentNoteVm>();
var agNoteDb = db.AgentNotes.Where(x => x.OperationId == operId).ToList();
Mapper.CreateMap <AgentNote, AgentNoteVm>()
.ForMember(x => x.AgentNoteDetails, y => y.Ignore())
.IgnoreAllNonExisting();
Mapper.Map(agNoteDb, agentNoteList);
//Get agent Name
List <int> agentIds = agentNoteList.Select(x => x.AgentId).ToList();
EasyFreightEntities db1 = new EasyFreightEntities();
var agentInfo = db1.Agents.Where(x => agentIds.Contains(x.AgentId))
.Select(x => new { x.AgentId, x.AgentNameEn }).ToList();
// update to show status 24/01/2017
var invStatusLib = db.InvStatusLibs.Select(a => a).ToList();
foreach (var item in agentNoteList)
{
item.AgentName = agentInfo.Where(x => x.AgentId == item.AgentId).FirstOrDefault().AgentNameEn;
// update to show status 24/01/2017
item.InvStatusName = invStatusLib.Where(x => x.InvStatusId == item.InvStatusId)
.FirstOrDefault().InvStatusNameEn;
if (item.AgentNoteType == 1) //Debit .. will collect
{
item.InvStatusName = item.InvStatusName.Replace("Paid", "Collected");
}
}
return(agentNoteList);
}
internal static List <BankVm> GetAllBankAndAccountList()
{
List <BankVm> bankList = new List <BankVm>();
AccountingEntities db = new AccountingEntities();
var carrDbList = db.Banks.ToList();
Mapper.CreateMap <Bank, BankVm>()
.ForMember(x => x.BankAccounts, y => y.Ignore())
.IgnoreAllNonExisting();
Mapper.Map(carrDbList, bankList);
//Accounts
List <BankAccountVm> bankAccountVm = new List <BankAccountVm>();
List <BankAccount> bankAccountDb = db.BankAccounts.Include("Currency").ToList();
Mapper.CreateMap <BankAccount, BankAccountVm>()
.IgnoreAllNonExisting();
Mapper.Map(bankAccountDb, bankAccountVm);
foreach (var item in bankAccountVm)
{
item.CurrencySign = bankAccountDb.Where(x => x.BankAccId == item.BankAccId).FirstOrDefault().Currency.CurrencySign;
}
foreach (var item in bankList)
{
item.BankAccounts = bankAccountVm.Where(x => x.BankId == item.BankId).ToList();
}
return(bankList);
}
public static string AddEditArDepBalance(int?shipperId, int?consigneeId,
int currId, decimal amountToAdd, AccountingEntities db)
{
string isSaved = "true";
//AccountingEntities db = new AccountingEntities();
var arDepBalance = GetBalanceObj(shipperId, consigneeId, currId, db);
//New balance case
if (arDepBalance.BalanceAmount == 0)
{
arDepBalance.BalanceAmount = amountToAdd;
arDepBalance.ConsigneeId = consigneeId;
arDepBalance.ShipperId = shipperId;
arDepBalance.CurrencyId = currId;
db.ArCashDepositBalances.Add(arDepBalance);
}
else
{
db.ArCashDepositBalances.Attach(arDepBalance);
arDepBalance.BalanceAmount = arDepBalance.BalanceAmount + amountToAdd;
}
db.SaveChanges();
return(isSaved);
}
public static List <ExpenseLib> GetExpenseLibList()
{
AccountingEntities db = new AccountingEntities();
List <ExpenseLib> expensesList = db.ExpenseLibs.ToList();
return(expensesList);
}
/// <summary>
/// Get current deposit balance for client and currency
/// </summary>
/// <param name="shipperId"></param>
/// <param name="consigneeId"></param>
/// <param name="currId"></param>
/// <returns>decimal balance amount</returns>
public static decimal GetDepositBalance(int?shipperId, int?consigneeId, int currId)
{
AccountingEntities db = new AccountingEntities();
var arDepBalance = GetBalanceObj(shipperId, consigneeId, currId, db);
return(arDepBalance?.BalanceAmount ?? 0);
}
internal static List <InvoiceLightVm> GetInvListForHb(int hbId)
{
AccountingEntities db2 = new AccountingEntities();
var invList = db2.Invoices.Where(x => x.HouseBillId == hbId)
.Select(x => new InvoiceLightVm
{
InvoiceCode = x.InvoiceCode,
InvoiceId = x.InvoiceId,
InvoiceDate = x.InvoiceDate,
InvoiceType = x.InvoiceType,
HouseBillId = x.HouseBillId
})
.ToList();
//Get Cost list
var operCostObj = AccountingHelper.GetOperationCost(0, hbId);
var operCostList = operCostObj.OperationCostAccVms;
foreach (var item in invList)
{
var operCostTotalList = operCostObj.OperationCostTotalAccVms;
GetHbInvTotal(item.InvoiceType, ref operCostList, ref operCostTotalList);
item.OperationCostTotalAccVms = operCostTotalList;
}
return(invList);
}
internal static Dictionary <byte, string> GetPaymentTerm(string langCode = "en", bool includeDepositOption = false)
{
AccountingEntities db = new AccountingEntities();
Dictionary <byte, string> paymentTermList = new Dictionary <byte, string>();
var operationCostListDb = db.PaymentTerms.ToList();
if (!includeDepositOption)
{
operationCostListDb = operationCostListDb.Where(x => x.PaymentTermId != 5).ToList();
}
if (langCode == "en")
{
paymentTermList = operationCostListDb
.OrderBy(x => x.PaymentTermId)
.ToDictionary(x => x.PaymentTermId, x => x.PaymentTermEn);
}
else
{
paymentTermList = operationCostListDb
.OrderBy(x => x.PaymentTermId)
.ToDictionary(x => x.PaymentTermId, x => x.PaymentTermAr);
}
return(paymentTermList);
}
private static void AddExpenseReceiptToTrans(CashInVm cashInVmObj)
{
string creditAccId = AccountingChartHelper.GetAccountIdByPkAndTbName(cashInVmObj.CurrencyId, "Currency", "CurrencyId");
if (string.IsNullOrEmpty(creditAccId))
{
string parentAccountId = ((int)AccountingChartEnum.Cash).ToString();
//Add new accountId to the chart
creditAccId = AccountingChartHelper
.AddAccountToChart(cashInVmObj.CurrencySign, cashInVmObj.CurrencySign, parentAccountId);
AccountingChartHelper.AddAccountIdToObj(creditAccId, "Currency", cashInVmObj.CurrencyId, "CurrencyId");
}
AccTransactionVm accTrans = new AccTransactionVm()
{
CreateDate = DateTime.Now,
CreateBy = EasyFreight.DAL.AdminHelper.GetCurrentUserId(),
TransactionName = "Cash Out Receipt Number " + cashInVmObj.ReceiptCode,
TransactionNameAr = "ايصال صرف نقدية رقم " + cashInVmObj.ReceiptCode
};
AccountingEntities db = new AccountingEntities();
var expensesLibList = db.ExpenseLibs.Select(x => new { x.ExpenseId, x.AccountId }).ToList();
AccTransactionDetailVm accTransDetDebit;
//Loop through expenses for debit accounts
foreach (var item in cashInVmObj.CashOutReceiptExpenses)
{
string debitAccId = expensesLibList.Where(x => x.ExpenseId == item.ExpenseId).FirstOrDefault().AccountId;
accTransDetDebit = new AccTransactionDetailVm()
{
AccountId = debitAccId,
DebitAmount = item.PaidAmount.Value,
CurrencyId = cashInVmObj.CurrencyId,
CreditAmount = 0
};
accTrans.AccTransactionDetails.Add(accTransDetDebit);
}
// Add Cash as credit
AccTransactionDetailVm accTransDetCredit = new AccTransactionDetailVm()
{
AccountId = creditAccId,
CreditAmount = cashInVmObj.ReceiptAmount.Value,
CurrencyId = cashInVmObj.CurrencyId,
DebitAmount = 0
};
accTrans.AccTransactionDetails.Add(accTransDetCredit);
int transId = AccountingHelper.AddTransaction(accTrans);
//Update TransId in invoice table
AccountingChartHelper.AddTransIdToObj(transId, "CashOutReceipt", cashInVmObj.ReceiptId, "ReceiptId");
}
public int populateModel()
{
using (var accountingEntities = new AccountingEntities()) {
accountingEntities.account_document
}
return(0);
}
public void Setup()
{
using (var dbContext = new AccountingEntities())
{
dbContext.Budgets.RemoveRange(dbContext.Budgets);
dbContext.SaveChanges();
}
}
internal static void ChangeAgNoteStatus(int agNoteId, InvStatusEnum invStatusEnum)
{
byte invStatusId = (byte)invStatusEnum;
AccountingEntities db = new AccountingEntities();
var invDb = db.AgentNotes.Where(x => x.AgentNoteId == agNoteId).FirstOrDefault();
invDb.InvStatusId = invStatusId;
db.SaveChanges();
}
public static string AddEditBank(BankVm bankVm)
{
int bankId = bankVm.BankId;
string isSaved = "true";
AccountingEntities db = new AccountingEntities();
Bank bankDb;
List <BankAccount> dbContactList = new List <BankAccount>();
if (bankId == 0) //Add new case
{
bankDb = new Bank();
}
else
{
bankDb = db.Banks.Include("BankAccounts").Where(x => x.BankId == bankId).FirstOrDefault();
//delete any removed contact on the screen
dbContactList = bankDb.BankAccounts.ToList();
//Get contact Ids sent from the screen
List <int> contactVmIds = bankVm.BankAccounts.Select(x => x.BankAccId).ToList();
var contactDel = dbContactList.Where(x => !contactVmIds.Contains(x.BankAccId)).ToList();
foreach (var item in contactDel)
{
db.BankAccounts.Remove(item);
}
}
Mapper.CreateMap <BankVm, Bank>().IgnoreAllNonExisting();
Mapper.CreateMap <BankAccountVm, BankAccount>().IgnoreAllNonExisting();
Mapper.Map(bankVm, bankDb);
if (bankId == 0)
{
db.Banks.Add(bankDb);
}
try
{
db.SaveChanges();
}
catch (DbEntityValidationException e)
{
isSaved = "false " + e.Message;
}
catch (Exception e)
{
isSaved = "false " + e.Message;
}
return(isSaved);
}
/// <summary>
/// Get Account Summary Grouped By Currency .. Used to fill summary table at page top
/// </summary>
/// <param name="parentAccId"></param>
/// <param name="isCreditAccount"></param>
/// <param name="fromDate"></param>
/// <param name="toDate"></param>
/// <returns>AccountSummary object</returns>
public static AccountSummary GetAccountSummaryGrouped(string parentAccId, bool isCreditAccount = false,
DateTime?fromDate = null, DateTime?toDate = null, int bId = 0)
{
AccountSummary accountSummary = new AccountSummary();
var accSummaryList = GetAccSummaryByParentAccId(parentAccId, isCreditAccount, fromDate, toDate);
AccountingEntities db = new AccountingEntities();
accountSummary.AccountNameEn = db.AccountingCharts.Where(x => x.AccountId == parentAccId).FirstOrDefault().AccountNameEn;
//Cash in Bank .. get for specific bank ID
if (parentAccId == "193" && bId != 0)
{
var accIdsForBank = db.BankAccounts.Where(x => x.BankId == bId).Select(x => x.AccountId).ToList();
accSummaryList = accSummaryList.Where(x => accIdsForBank.Contains(x.AccountId)).ToList();
}
if (accSummaryList.Count > 0)
{
var grouped = accSummaryList.GroupBy(x => x.CurrencySign)
.Select(x => new
{
Currency = x.Key,
DebitSum = x.Sum(y => y.DebitAmout),
CreditSum = x.Sum(y => y.CreditAmount)
}).ToList();
List <AccountSummaryTotal> sumByCurrency = new List <AccountSummaryTotal>();
AccountSummaryTotal accountSummaryTotal;
decimal diffAmount;
foreach (var item in grouped)
{
accountSummaryTotal = new AccountSummaryTotal();
accountSummaryTotal.CurrencySign = item.Currency;
diffAmount = item.DebitSum - item.CreditSum;
if (diffAmount > 0)
{
accountSummaryTotal.DebitAmout = diffAmount;
}
else
{
accountSummaryTotal.CreditAmount = diffAmount * -1;
}
sumByCurrency.Add(accountSummaryTotal);
}
accountSummary.TotalByCurrency = sumByCurrency;
}
return(accountSummary);
}
internal static string Delete(int invId, string deleteReason)
{
string isSaved = "false";
if (invId == 0)
{
return(isSaved);
}
AccountingEntities db = new AccountingEntities();
InvoiceAP invDb = new InvoiceAP();
invDb = db.InvoiceAPs
.Where(x => x.InvoiceId == invId).FirstOrDefault();
int?transID = null;
if (invDb.TransId != null)
{
transID = invDb.TransId.Value;
}
if (invDb.InvStatusId == 1 || invDb.InvStatusId == 2)
{
invDb.IsDeleted = true;
invDb.DeleteReason = deleteReason;
invDb.DeletedBy = EasyFreight.DAL.AdminHelper.GetCurrentUserId();
invDb.TransId = null;
// invoice total
var invTotal = db.InvoiceTotalAPs.Where(x => x.InvoiceId == invId).FirstOrDefault();
try
{
db.SaveChanges();
db.InvoiceTotalAPs.Remove(invTotal);
if (transID.HasValue)
{
AccountingHelper.DeleteTransaction(transID.Value);
}
isSaved = "true";
}
catch
{
isSaved = "false";
}
}
return(isSaved);
}
internal static JObject GetCashReceiptsJson()
{
AccountingEntities db = new AccountingEntities();
var receiptList = db.ArCashDepositViews.OrderByDescending(x => x.CreateDate).ToList();
JTokenWriter pJTokenWriter = new JTokenWriter();
JObject ordersJson = new JObject();
pJTokenWriter.WriteStartObject();
pJTokenWriter.WritePropertyName("data");
pJTokenWriter.WriteStartArray();
foreach (var item in receiptList)
{
pJTokenWriter.WriteStartObject();
pJTokenWriter.WritePropertyName("ReceiptId");
pJTokenWriter.WriteValue(item.ReceiptId);
pJTokenWriter.WritePropertyName("ReceiptCode");
pJTokenWriter.WriteValue(item.ReceiptCode);
pJTokenWriter.WritePropertyName("ReceiptDate");
pJTokenWriter.WriteValue(item.ReceiptDate.ToString("dd/MM/yyyy"));
pJTokenWriter.WritePropertyName("ReceiptAmount");
pJTokenWriter.WriteValue(item.ReceiptAmount.ToString() + " " + item.CurrencySign);
pJTokenWriter.WritePropertyName("Notes");
pJTokenWriter.WriteValue(item.Notes ?? "");
pJTokenWriter.WritePropertyName("Client");
pJTokenWriter.WriteValue(string.IsNullOrEmpty(item.ShipperNameEn) ? item.ConsigneeNameEn : item.ShipperNameEn);
pJTokenWriter.WritePropertyName("CreateDate");
pJTokenWriter.WriteValue(item.CreateDate.ToString("dd/MM/yyyy"));
pJTokenWriter.WritePropertyName("UserName");
pJTokenWriter.WriteValue(item.UserName);
pJTokenWriter.WritePropertyName("PaymentTermEn");
pJTokenWriter.WriteValue(item.PaymentTermEn);
pJTokenWriter.WriteEndObject();
}
pJTokenWriter.WriteEndArray();
pJTokenWriter.WriteEndObject();
ordersJson = (JObject)pJTokenWriter.Token;
return(ordersJson);
}
internal static List <BankVm> GetBankList()
{
List <BankVm> bankList = new List <BankVm>();
AccountingEntities db = new AccountingEntities();
var carrDbList = db.Banks.ToList();
Mapper.CreateMap <Bank, BankVm>()
.ForMember(x => x.BankAccounts, y => y.Ignore())
.IgnoreAllNonExisting();
Mapper.Map(carrDbList, bankList);
return(bankList);
}
public static string AddEditExpense(int expenseId, string expenseNameEn, string expenseNameAr)
{
string isSaved = "";
AccountingEntities db = new AccountingEntities();
ExpenseLib expenseLibDb;
if (expenseId != 0)
{
expenseLibDb = db.ExpenseLibs.Where(x => x.ExpenseId == expenseId).FirstOrDefault();
}
else
{
expenseLibDb = new ExpenseLib();
}
expenseLibDb.ExpenseNameEn = expenseNameEn;
expenseLibDb.ExpenseNameAr = expenseNameAr;
if (expenseId == 0)
{
db.ExpenseLibs.Add(expenseLibDb);
}
using (TransactionScope transaction = new TransactionScope())
{
try
{
db.SaveChanges();
if (expenseId == 0)
{
expenseId = expenseLibDb.ExpenseId;
string parentAccountId = ((int)AccountingChartEnum.GeneralAndAdministrativeExpenses).ToString();
string accountId = AccountingChartHelper.AddAccountToChart(expenseNameEn, expenseNameAr, parentAccountId);
AccountingChartHelper.AddAccountIdToObj(accountId, "ExpenseLib", expenseId, "ExpenseId");
isSaved = expenseId.ToString();
}
transaction.Complete();
}
catch (DbEntityValidationException e)
{
isSaved = "false " + e.Message;
}
catch (Exception e)
{
isSaved = "false " + e.Message;
}
}
return(isSaved);
}
internal static Dictionary <int, string> GetBankAccList()
{
AccountingEntities db = new AccountingEntities();
Dictionary <int, string> banksList = new Dictionary <int, string>();
var bankAccListDb = db.BankAccounts.ToList();
banksList = bankAccListDb
.OrderBy(x => x.BankId)
.ToDictionary(x => x.BankAccId, x => x.AccountName + " (" + x.AccountNumber + ")");
return(banksList);
}
public static string AddCashToChart(int currencyId)
{
string parentAccountId = "", accountId;
AccountingEntities db = new AccountingEntities();
var currObj = db.CurrencyAccs.Where(x => x.CurrencyId == currencyId).FirstOrDefault();
parentAccountId = ((int)AccountingChartEnum.Cash).ToString();
//Add new accountId to the chart
accountId = AccountingChartHelper
.AddAccountToChart(currObj.CurrencySign, currObj.CurrencySign, parentAccountId);
AccountingChartHelper.AddAccountIdToObj(accountId, "Currency", currObj.CurrencyId, "CurrencyId");
return(accountId);
}
internal static BankAccountVm GetBankAccountInfo(int bankAccId)
{
BankAccountVm bankAccountVm = new BankAccountVm();
AccountingEntities db = new AccountingEntities();
BankAccount bankAccountDb = db.BankAccounts.Include("Currency").Where(x => x.BankAccId == bankAccId).FirstOrDefault();
Mapper.CreateMap <BankAccount, BankAccountVm>()
.IgnoreAllNonExisting();
Mapper.Map(bankAccountDb, bankAccountVm);
bankAccountVm.CurrencySign = bankAccountDb.Currency.CurrencySign;
return(bankAccountVm);
}
public static string AddArCashDeposit(CashInVm cashInVm)
{
string isSaved = "true";
AccountingEntities db = new AccountingEntities();
ArCashDeposit arCashDeposit = new ArCashDeposit();
Mapper.CreateMap <CashInVm, ArCashDeposit>()
.IgnoreAllNonExisting();
Mapper.Map(cashInVm, arCashDeposit);
using (TransactionScope transaction = new TransactionScope())
{
try
{
arCashDeposit.ReceiptCode = AdminHelper.GeneratePrefixCode(PrefixForEnum.CashIn, true);
db.ArCashDeposits.Add(arCashDeposit);
db.SaveChanges();
cashInVm.ReceiptId = arCashDeposit.ReceiptId;
cashInVm.ReceiptCode = arCashDeposit.ReceiptCode;
string creditAccountId = ((int)AccountingChartEnum.DepositRevenues).ToString();
//Add invoice to accounting transactions table
CashHelper.AddReceiptToTransTable(creditAccountId, cashInVm, "ArCashDeposit");
//Add or update deposit balance for this client
CashDepositBalanceHelper.AddEditArDepBalance(cashInVm.ShipperId, cashInVm.ConsigneeId,
cashInVm.CurrencyId, cashInVm.ReceiptAmount.Value, db);
transaction.Complete();
}
catch (DbEntityValidationException e)
{
isSaved = "false " + e.Message;
}
catch (Exception e)
{
isSaved = "false " + e.Message;
}
}
return(isSaved);
}
public static string AddAccountToChart(string accountNameEn, string accountNameAr, string parentAccountId)
{
AccountingEntities db = new AccountingEntities();
// string accountRecCode = ((int) AccountingChartEnum.AccountsRecievable).ToString();
// int addOne = db.AccountingCharts.Where(x => x.ParentAccountId == parentAccountId).Count() + 1;
var addOne = db.AccountingCharts.Where(x => x.ParentAccountId == parentAccountId).ToList();
string newAccountId = "";
if (addOne.Count() > 0)
{
var accNumberAddOne = long.Parse(addOne.Max(x => long.Parse(x.AccountId)).ToString()
.Replace(parentAccountId, "")) + 1;
newAccountId = parentAccountId + accNumberAddOne;
}
else
{
newAccountId = parentAccountId + "1";
}
AccountingChart accChart = new AccountingChart()
{
AccountId = newAccountId,
AccountNameAr = accountNameAr,
AccountNameEn = accountNameEn,
CreateDate = DateTime.Now,
ParentAccountId = parentAccountId
};
db.AccountingCharts.Add(accChart);
try
{
db.SaveChanges();
}
catch (DbEntityValidationException e)
{
newAccountId = "false " + e.Message;
throw;
}
catch (Exception e)
{
newAccountId = "false " + e.InnerException;
throw;
}
return(newAccountId);
}
