public ActionResult addUnitRate(FormCollection collection)
{
int check = (int)Session["add_unitRate"];
string good = collection["good"];
if (check == 0)
{
return(RedirectToAction("Index", "Home"));
}
string name = collection["account"];
TransactionAccount transAccount = service.findJvTransaction(name);
service.findAndSetUnitRates(transAccount.id, good);
UnitRate uRate = new UnitRate();
uRate.account_id = transAccount.id;
uRate.good = collection["good"];
uRate.rate = float.Parse(collection["rate"]);
uRate.is_active = "Y";
uRate.updated_at = DateTime.UtcNow;
uRate.created_at = uRate.updated_at;
service.addUnitRate(uRate);
service.save();
return(RedirectToAction("unitRate"));
}
public TransactionAccount GetTransactionAccount(long WalletID, short isSettled, long batchNo, decimal drAmount, decimal crAmount, long trnNo, string remarks, byte status)
{
try
{
var walletLedger2 = new TransactionAccount();
walletLedger2.CreatedBy = WalletID;
walletLedger2.CreatedDate = UTC_To_IST();
walletLedger2.DrAmt = drAmount;
walletLedger2.CrAmt = crAmount;
walletLedger2.RefNo = trnNo;
walletLedger2.Remarks = remarks;
walletLedger2.Status = status;
walletLedger2.TrnDate = UTC_To_IST();
walletLedger2.UpdatedBy = WalletID;
walletLedger2.WalletID = WalletID;
walletLedger2.IsSettled = isSettled;
walletLedger2.BatchNo = batchNo;
return(walletLedger2);
}
catch (Exception ex)
{
//_log.LogError(ex, "Date: " + UTC_To_IST() + ",\nMethodName:" + System.Reflection.MethodBase.GetCurrentMethod().Name + "\nClassname=" + this.GetType().Name, LogLevel.Error);
HelperForLog.WriteErrorLog(System.Reflection.MethodBase.GetCurrentMethod().Name, this.GetType().Name, ex);
throw ex;
}
}
public ActionResult salesReportPostItemWise(int id, string dateStart, string dateEnd, string item)
{
TransactionAccount tr = service.findTransactionAccount(id);
string search = tr.name;
if (Session["name"] != "Admin")
{
if (PermissionForAccounts.permisionCheckForSales(PermissionForAccounts.permisionSales, search) == false)
{
return(RedirectToAction("index", "Home"));
}
}
int check = (int)Session["sale_reports"];
if (check == 0)
{
return(RedirectToAction("Index", "Home"));
}
ViewBag.item = item;
ViewBag.search = search;
List <TransactionAccount> accounts = service.findTransactionAccounts(search);
var balance = service.findAccountBalance(search);
ViewBag.openingBalance = balance;
List <TransactionAccount> allaccounts = service.allTransactionaccounts();
ViewBag.start = Convert.ToDateTime(dateStart);
ViewBag.end = Convert.ToDateTime(dateEnd);
ViewBag.MyList = allaccounts;
return(View(accounts));
}
public ActionResult Index(int id)
{
User user = new User();
UserCrudServices service = new UserCrudServices();
user = service.find(id);
List <PinAccounts> listOfPinAccounts = new List <PinAccounts>();
List <Pin_Accounts> list = db.Pin_Accounts.Where(x => x.User_id == id && x.User_type == "User" & x.is_active == 1).ToList();
foreach (var account in list)
{
PinAccounts pin = new PinAccounts();
pin.Name = account.Account_name;
pin.id = account.Account_id;
TransactionAccount transAccount = db.TransactionAccounts.Find(account.Account_id);
pin.Balance = (int)transAccount.balance;
pin.Updated_Time = transAccount.updated_at_.ToShortDateString();
listOfPinAccounts.Add(pin);
}
int count = listOfPinAccounts.Count;
ViewBag.pinAccounts = listOfPinAccounts;
return(View(user));
}
public ActionResult Edit(int id, FormCollection collection)
{
int account_id = Convert.ToInt32(collection["party_name"]);
TransactionAccount account = transactionService.findTransactionAccount(account_id);
Temporary_Orders s_order = db.Temporary_Orders.Find(id);
DateTime date = s_order.uptdated_at;
bool flag =DateTime.TryParse(collection["date"], out date);
s_order.bags = collection["bags"];
s_order.broker_name = collection["broker_name"];
s_order.brokers_commision = collection["commisions"];
s_order.company_sign = "N/A";
if (flag != false)
{
s_order.uptdated_at = date;
}
s_order.is_active = "Y";
s_order.vendor_sign = "N/A";
s_order.item = collection["item"];
s_order.party_name = account.name;
s_order.terms = collection["terms"];
s_order.weight = Convert.ToInt32(collection["weight"]);
s_order.rate = float.Parse(collection["rate"]);
s_order.type = Convert.ToInt32(collection["type"]);
s_order.checked_by = Session["username"].ToString();
s_order.Account_Id = account.id;
db.SaveChanges();
return RedirectToAction("listOfTempOrders");
}
public ActionResult DeleteTransactionAccount(int id)
{
TransactionAccount tr = service.findTransactionAccount(id);
tr.is_active = "N";
service.save();
return(RedirectToAction("index"));
}
/// <summary>
/// Method for making transaction account
/// </summary>
/// <returns></returns>
private ITransactionAccount createTransactionAccount()
{
string curency = txtCurrency.Text.ToString();
decimal limit = Convert.ToDecimal(txtLimit.Text);
ITransactionAccount TranAccount = new TransactionAccount(curency, limit);
return(TranAccount);
}
public IActionResult PostUnpostedVouchers([FromBody] IEnumerable <UnpostedVoucherViewModel> models)
{
IList <Voucher> Vs = new List <Voucher>();
IList <UnpostedVoucher> UVs = new List <UnpostedVoucher>();
IList <TransactionAccount> UpdateUALs = new List <TransactionAccount>();
IList <VoucherDetail> updateVoucherDetails = new List <VoucherDetail>();
IEnumerable <TransactionAccount> UALs = UAL_Repo.GetAll();
foreach (UnpostedVoucherViewModel model in models)
{
PostedVoucher PV = new PostedVoucher()
{
CompanyId = model.CompanyId,
VoucherId = model.VoucherId,
VoucherCode = model.VoucherCode,
Date = model.Date,
Description = model.Description,
TotalCreditAmount = model.TotalCreditAmount,
TotalDebitAmount = model.TotalDebitAmount,
FinancialYearId = model.FinancialYearId,
VoucherTypeId = model.VoucherTypeId,
CreatedAt = DateTime.Now
};
PostedVou_repo.Add(PV);
Voucher V = Vou_repo.GetFirst(a => a.VoucherId == model.VoucherId);
V.PostedVoucherId = PV.PostedVoucherId;
V.IsFinal = true;
foreach (VoucherDetail VD in model.VoucherDetails)
{
TransactionAccount UL = UALs.FirstOrDefault(a => a.AccountId == VD.AccountId);
VD.AccountBalanceAmountBeforePosting = UL.CurrentBalance;
UL.TotalTransactionsAgainstThisAccount += 1;
UL.TotalDebit += VD.DebitAmount;
UL.TotalCredit += VD.CreditAmount;
UL.CurrentBalance = UL.CurrentBalance - VD.DebitAmount + VD.CreditAmount;
VD.AccountBalanceAmountAfterPosting = UL.CurrentBalance;
UpdateUALs.Add(UL);
updateVoucherDetails.Add(VD);
}
;
V.VoucherDetails = updateVoucherDetails;
Vs.Add(V);
UVs.Add(UnpostedVou_repo.Find(model.UnpostedVoucherId));
}
Vou_repo.UpdateRange(Vs);
UAL_Repo.UpdateRange(UpdateUALs);
UnpostedVou_repo.DeleteRange(UVs);
return(Ok("Posted"));
}
public async Task <ActionResult> Edit([Bind(Include = "Id,Name,Notes")] TransactionAccount transactionAccount)
{
if (ModelState.IsValid)
{
//db.Entry(transactionAccount).State = EntityState.Modified;
//await db.SaveChangesAsync();
this.db.TransactionAccountController.Update(transactionAccount);
return(RedirectToAction("Index"));
}
return(View(transactionAccount));
}
public TransactionAccount findJvTransaction(string name)
{
try{
TransactionAccount tr = db.TransactionAccounts.Where(x => x.name == name & x.is_active == "Y").First();
return(tr);
}
catch (Exception)
{
return(null);
}
}
public async Task <ActionResult> Create([Bind(Include = "Id,Name,Notes")] TransactionAccount transactionAccount)
{
if (ModelState.IsValid)
{
//db.TransactionAccounts.Add(transactionAccount);
//await db.SaveChangesAsync();
db.TransactionAccountController.Add(transactionAccount);
return(RedirectToAction("Index"));
}
return(View(transactionAccount));
}
public ActionResult Create(int id)
{
try
{
Temporary_Orders temp = tempServices.findTempOrderById(id);
int account_id = temp.Account_Id;
TransactionAccount account = transactionService.findTransactionAccount(account_id);
Sale_Order s_order = new Sale_Order();
s_order.bags = temp.bags;
s_order.broker_name = temp.broker_name;
s_order.brokers_commision = temp.brokers_commision;
s_order.company_sign = temp.company_sign;
s_order.created_at_ = temp.created_at_;
s_order.is_active = temp.is_active;
s_order.vendor_sign = temp.vendor_sign;
s_order.item = temp.item;
s_order.party_name = account.name;
s_order.so_number = temp.order_number;
s_order.terms = temp.terms;
s_order.uptdated_at = temp.created_at_;
s_order.weight = temp.weight;
s_order.rate = temp.rate;
s_order.prepared_by = temp.prepared_by;
s_order.approved_by = Session["username"].ToString();
s_order.checked_by = temp.checked_by;
s_order.Account_Id = account.id;
service.addSO(s_order);
service.save();
Temporary_Orders TO = db.Temporary_Orders.Find(id);
TO.is_active = "N";
db.SaveChanges();
return RedirectToAction("listOfTempOrders");
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
Trace.TraceInformation("Class: {0}, Property: {1}, Error: {2}",
validationErrors.Entry.Entity.GetType().FullName,
validationError.PropertyName,
validationError.ErrorMessage);
}
}
return RedirectToAction("listOfTempOrders");
}
}
public int findOpeningBalancebeforeDate(DateTime date, string search)
{
TransactionAccount account = db.TransactionAccounts.Where(x => x.name == search & x.is_active == "Y").First();
List <Transaction> transactions = account.Transactions.Where(x => x.created_at < date && x.is_active == "Y").ToList();
int balance = Convert.ToInt32(account.parent);
foreach (var tr in transactions)
{
balance = balance + tr.cr;
balance = balance - tr.dr;
}
return(balance);
}
// GET: TransactionAccounts/Delete/5
public async Task <ActionResult> Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TransactionAccount transactionAccount = this.db.TransactionAccountController.Get(id); //await db.TransactionAccounts.FindAsync(id);
if (transactionAccount == null)
{
return(HttpNotFound());
}
return(View(transactionAccount));
}
public int findOpeningWeightBeforeDate(string enddate, string searching)
{
int counsss = 0;
DateTime date = Convert.ToDateTime(enddate);
TransactionAccount account = db.TransactionAccounts.Where(x => x.name == searching & x.is_active == "Y").First();
List <Transaction> transactions = account.Transactions.Where(x => x.created_at < date & x.is_active == "Y").ToList();
int weight = Convert.ToInt32(account.opening_weight);
int balance = weight;
int totalBalance = 0;
foreach (var t in transactions)
{
if (t.net_weight != null)
{
if (t.extra == "Sale" && account.main_id != 12 || t.net_weight == null)
{
continue;
}
if (t.is_active != "Y")
{
continue;
}
if (account.id == 118 && t.voucher_type == "PRV")
{
continue;
}
if (t.voucher_type == "SV" || t.voucher_type == "UPSV")
{
balance = (int)(balance - t.net_weight);
}
else if (t.voucher_type == "PRV" && t.Id % 2 == 1)
{
balance = (int)(balance - t.net_weight);
}
else if (t.voucher_type == "WEV" && t.Id % 2 == 1)
{
balance = (int)(balance - t.net_weight);
}
else
{
balance = (int)(balance + t.net_weight);
}
totalBalance = totalBalance + balance;
}
}
return(balance);
}
public IActionResult UpdateAccount([FromBody] Account model)
{
Account updateAccount = Account_Repo.Find(model.AccountId);
if (updateAccount.IsGeneralOrDetail == false)
{
updateAccount.OpeningBalance = model.OpeningBalance;
TransactionAccount UAL = UAL_Repo.GetFirst(a => a.AccountId == model.AccountId);
UAL.Description = model.Description;
UAL.OpeningBalance = model.OpeningBalance;
UAL_Repo.Update(UAL);
}
updateAccount.Description = model.Description;
Account_Repo.Update(updateAccount);
return(new OkObjectResult(new { AccountId = model.AccountId }));
}
public async Task <IActionResult> Edit([Bind("BankID,BankDescription,BankName,CompanyID,CreatedBy,TransactionAccountID")] Bank bank)
{
string CompId = User.Claims.Where(r => r.Type == "CompanyID").FirstOrDefault().Value;
int CompID = Convert.ToInt32(CompId);
string TransAccNumber = bank.CreatedBy;
bank.CompanyID = CompID;
bank.CreatedBy = User.Identity.Name;
int mainAccID = _context.MainAccount.Where(r => r.CompanyID == CompID).Where(r => r.MainAccountNumber == "01").FirstOrDefault().MainAccountID;
int subAccID = _context.SubAccount.Where(r => r.SubAccountNumber == "0002").Where(r => r.MainAccountID == mainAccID).FirstOrDefault().SubAccountID;
TransactionAccount TraAcc = new TransactionAccount();
TraAcc.TransactionAccountID = bank.TransactionAccountID;
TraAcc.AccountName = bank.BankName;
TraAcc.CompanyID = CompID;
TraAcc.CreatedBy = User.Identity.Name;
TraAcc.CreationDate = DateTime.Now;
TraAcc.OpeningBalance = 0;
TraAcc.SubAccountID = subAccID;
TraAcc.TransactionAccountNumber = TransAccNumber;
if (ModelState.IsValid)
{
try
{
_context.Update(bank);
_context.Update(TraAcc);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BankExists(bank.BankID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Index"));
}
return(PartialView(bank));
}
public ActionResult EditTransactionAccount(int id, FormCollection collection)
{
try{
TransactionAccount trans = service.findTransactionAccount(id);
trans.type_ = collection["Type"];
int openingamount = Convert.ToInt32(collection["amount"]);
if (collection["OB"] == "Cr.")
{
trans.cr_ = Convert.ToInt32(collection["amount"]);
trans.dr_ = 0;
trans.balance = trans.cr_ * (-1);
openingamount = openingamount * (-1);
}
else
{
trans.dr_ = Convert.ToInt32(collection["amount"]);
trans.cr_ = 0;
trans.balance = trans.dr_;
}
trans.name = collection["name"];
trans.opening_weight = collection["weight"];
trans.updated_at_ = Convert.ToDateTime(collection["date"]);
// for Opening Balance store
trans.parent = openingamount.ToString();
service.save();
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
Trace.TraceInformation("Class: {0}, Property: {1}, Error: {2}",
validationErrors.Entry.Entity.GetType().FullName,
validationError.PropertyName,
validationError.ErrorMessage);
}
}
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> EditTransactionAccount(TransactionAccount transactionAccount)
{
string CompId = User.Claims.Where(r => r.Type == "CompanyID").FirstOrDefault().Value;
int CompID = Convert.ToInt32(CompId);
//if (_context.TransactionAccount.Where(r => r.CompanyID == CompID).Where(r => r.SubAccountID == transactionAccount.SubAccountID).Where(r => r.TransactionAccountNumber == transactionAccount.TransactionAccountNumber).Any() == true)
//{
// ViewData["SameCodeError"] = "Transaction Account Code is already assigned to account.";
// return View("TransactionAccounts", await _context.TransactionAccount.Where(r => r.CompanyID == CompID).Include(r => r.SubAccount).Include(r => r.SubAccount.MainAccount).OrderBy(r => r.SubAccount.MainAccountID).ToListAsync());
//}
transactionAccount.CompanyID = CompID;
transactionAccount.CreationDate = DateTime.Now;
transactionAccount.CreatedBy = User.Identity.Name;
if (ModelState.IsValid)
{
try
{
_context.Update(transactionAccount);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MainAccountExists(transactionAccount.TransactionAccountID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("TransactionAccounts"));
}
var mainAccList = new List <SubAccount>();
mainAccList = _context.SubAccount.Where(r => r.CompanyID == CompID).ToList();
mainAccList.RemoveAll(r => r.SubAccountNumber == "0000");
ViewData["SubAccount"] = new SelectList(mainAccList, "SubAccountID", "AccountName");
return(View(transactionAccount));
}
public async Task <IActionResult> CreateTransactionAccount(TransactionAccount transactionAccount)
{
string CompId = User.Claims.Where(r => r.Type == "CompanyID").FirstOrDefault().Value;
int CompID = Convert.ToInt32(CompId);
int SubAcc = transactionAccount.SubAccountID;
if (_context.TransactionAccount.Where(r => r.CompanyID == CompID).Where(r => r.SubAccountID == transactionAccount.SubAccountID).Where(r => r.TransactionAccountNumber == transactionAccount.TransactionAccountNumber).Any() == true)
{
ViewData["SameCodeError"] = "Transaction Account Code is already assigned to account.";
return(View("TransactionAccounts", await _context.TransactionAccount.Where(r => r.CompanyID == CompID).Include(r => r.SubAccount).Include(r => r.SubAccount.MainAccount).OrderBy(r => r.SubAccount.MainAccountID).ToListAsync()));
}
transactionAccount.CompanyID = CompID;
transactionAccount.CreationDate = DateTime.Now;
transactionAccount.CreatedBy = User.Identity.Name;
if (ModelState.IsValid)
{
_context.Add(transactionAccount);
await _context.SaveChangesAsync();
return(RedirectToAction("TransactionAccounts"));
}
var mainAccList = new List <SubAccount>();
mainAccList = _context.SubAccount.Where(r => r.CompanyID == CompID).ToList();
mainAccList.RemoveAll(r => r.SubAccountNumber == "0000");
int mainAccID = _context.MainAccount.Where(r => r.CompanyID == CompID).Where(r => r.MainAccountNumber == "01").FirstOrDefault().MainAccountID;
int subAccID = _context.SubAccount.Where(r => r.SubAccountNumber == "0002").Where(r => r.MainAccountID == mainAccID).FirstOrDefault().SubAccountID;
mainAccList.RemoveAll(r => r.SubAccountID == subAccID);
ViewData["SubAccount"] = new SelectList(mainAccList, "SubAccountID", "AccountName");
return(View(transactionAccount));
}
public ActionResult Delete(int ID, string SEARCH, string START, string END)
{
int id = ID;
Transaction tr = new Transaction();
Transaction trTo = new Transaction();
if (id % 2 == 0)
{
tr = service.findTransaction(id - 1);
trTo = service.findTransaction(id);
}
else
{
tr = service.findTransaction(id);
trTo = service.findTransaction(id + 1);
}
TransactionAccount transFrom = service.findJvTransaction(tr.to_account);
TransactionAccount transTo = service.findJvTransaction(tr.to_account);
transFrom.balance = transFrom.balance + tr.dr;
transTo.balance = transTo.balance - tr.cr;
if (tr.net_weight != null)
{
transFrom.WEIGHT = (Convert.ToInt32(transFrom.WEIGHT) + tr.net_weight).ToString();
transTo.WEIGHT = (Convert.ToInt32(transTo.WEIGHT) - tr.net_weight).ToString();
}
tr.is_active = "N";
trTo.is_active = "N";
service.save();
return(RedirectToAction("StockReportPost", new { search = SEARCH, dateStart = START, dateEnd = END }));
}
public void addtransactionAccount(TransactionAccount tr)
{
db.TransactionAccounts.Add(tr);
}
internal TransactionDetails(XElement element)
{
element.ProcessChild(AccountElement, e => Account = new TransactionAccount(e));
}
public bool balanceUpdation(int id1, int id2)
{
try{
TransactionAccount account1 = db.TransactionAccounts.Find(id1);
TransactionAccount account2 = db.TransactionAccounts.Find(id2);
int balance1 = Convert.ToInt32(account1.parent);
int balance2 = Convert.ToInt32(account2.parent);
int weight1 = Convert.ToInt32(account1.opening_weight);
int weight2 = Convert.ToInt32(account2.opening_weight);
int Debit1 = 0;
int Credit1 = 0;
int Debit2 = 0;
int Credit2 = 0;
foreach (var tr in account1.Transactions.Where(x => x.is_active == "Y"))
{
if (tr.extra == "Sale" && account1.main_id != 12)
{
continue;
}
Credit1 = Credit1 + tr.cr;
Debit1 = Debit1 + tr.dr;
if (account1.type_ == "Goods Account")
{
if (tr.net_weight != null)
{
if (account1.id == 118 && tr.voucher_type == "PRV")
{
continue;
}
if (tr.voucher_type == "SV" || tr.voucher_type == "UPSV")
{
weight1 = (int)(weight1 - tr.net_weight);
}
else if (tr.voucher_type == "PRV" && tr.Id % 2 != 0)
{
weight1 = (int)(weight1 - tr.net_weight);
}
else if (tr.voucher_type == "WEV" && tr.Id % 2 != 0)
{
weight1 = (int)(weight1 - tr.net_weight);
}
else if (tr.voucher_type == "WEV" && tr.Id % 2 == 0)
{
weight1 = (int)(weight1 + tr.net_weight);
}
else if (tr.voucher_type == "PV" || tr.voucher_type == "UPPV" || tr.voucher_type == "PRV")
{
weight1 = (int)(weight1 + tr.net_weight);
}
}
}
}
foreach (var tr in account2.Transactions.Where(x => x.is_active == "Y"))
{
if (tr.extra == "Sale" && account2.main_id != 12)
{
continue;
}
Credit2 = Credit2 + tr.cr;
Debit2 = Debit2 + tr.dr;
if (account2.type_ == "Goods Account")
{
if (tr.net_weight != null)
{
if (account2.id == 118 && tr.voucher_type == "PRV")
{
continue;
}
if (tr.voucher_type == "SV" || tr.voucher_type == "UPSV")
{
weight2 = (int)(weight2 - tr.net_weight);
}
else if (tr.voucher_type == "PRV" && tr.Id % 2 != 0)
{
weight2 = (int)(weight2 - tr.net_weight);
}
else if (tr.voucher_type == "WEV" && tr.Id % 2 != 0)
{
weight2 = (int)(weight2 - tr.net_weight);
}
else if (tr.voucher_type == "WEV" && tr.Id % 2 == 0)
{
weight2 = (int)(weight2 + tr.net_weight);
}
else if (tr.voucher_type == "PV" || tr.voucher_type == "UPPV" || tr.voucher_type == "PRV")
{
weight2 = (int)(weight2 + tr.net_weight);
}
}
}
}
account1.balance = (balance1 + Credit1) - Debit1;
account2.balance = (balance2 + Credit2) - Debit2;
account1.WEIGHT = weight1.ToString();
account2.WEIGHT = weight2.ToString();
db.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
public async Task <IActionResult> Create([Bind("PartiesID,AdditionalInfo1,AdditionalInfo2,Area,BusinessRelation,City,CompanyID,ContactPerson,CountryID,CreatedBy,Email,ExtraBool,TransactionAccountID,ExtraString,Fax,Observations,OtherDetails,PartyName,PartyShortName,Phone1,Phone2,Remarks,Road,State")] Parties parties)
{
string CompId = User.Claims.Where(r => r.Type == "CompanyID").FirstOrDefault().Value;
int CompID = Convert.ToInt32(CompId);
parties.CompanyID = CompID;
parties.CreatedBy = User.Identity.Name;
if (ModelState.IsValid)
{
// Chart of Account TRANSACTION ACCOUNT ENTRY
TransactionAccount TraAcc = new TransactionAccount();
TraAcc.AccountName = parties.PartyName;
TraAcc.CompanyID = CompID;
TraAcc.CreatedBy = User.Identity.Name;
TraAcc.CreationDate = DateTime.Now;
TraAcc.OpeningBalance = 0;
int subAccID = _context.SubAccount.Where(r => r.CompanyID == CompID).Where(r => r.SubAccountNumber == "0000").FirstOrDefault().SubAccountID;
if (_context.TransactionAccount.Where(r => r.CompanyID == CompID).Where(r => r.SubAccountID == subAccID).Any() == false)
{
TraAcc.TransactionAccountNumber = "0001";
}
else
{
int CountTransAcc = _context.TransactionAccount.Where(r => r.CompanyID == CompID).Where(r => r.SubAccountID == subAccID).Count();
int ADD_CountTransAcc = CountTransAcc + 1;
if (ADD_CountTransAcc < 10)
{
TraAcc.TransactionAccountNumber = "000" + ADD_CountTransAcc;
}
else if (ADD_CountTransAcc < 100)
{
TraAcc.TransactionAccountNumber = "00" + ADD_CountTransAcc;
}
else if (ADD_CountTransAcc < 1000)
{
TraAcc.TransactionAccountNumber = "0" + ADD_CountTransAcc;
}
else
{
TraAcc.TransactionAccountNumber = ADD_CountTransAcc.ToString();
}
}
TraAcc.SubAccountID = subAccID;
_context.Add(TraAcc);
await _context.SaveChangesAsync();
int New_TransID = TraAcc.TransactionAccountID;
// Here TransactionAccountID is Party Transaction AccountID
parties.TransactionAccountID = New_TransID;
_context.Add(parties);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewData["CountryID"] = new SelectList(_context.Country.Where(r => r.CompanyID == CompID), "CountryID", "Name", parties.CountryID);
return(View(parties));
}
public async Task <IActionResult> RegisterCompanyAdmin(RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email, CompanyID = model.CompanyID, AccountActive = false
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
string CurrentRole = "CompanyAdmin";
await this._userManager.AddToRoleAsync(user, CurrentRole);
string CurrentRole1 = "BiznsBook";
await this._userManager.AddToRoleAsync(user, CurrentRole1);
await _userManager.AddClaimAsync(user, new Claim("CompanyID", user.CompanyID.ToString()));
// Insert statements on New user creation *** STATEMENT OF ACCOUNTS ***
DateTime CurrentDate = DateTime.Now;
string CurrentUser = User.Identity.Name;
MainAccount mainParties = new MainAccount();
mainParties.AccountName = "Parties";
mainParties.MainAccountNumber = "00";
mainParties.CreationDate = CurrentDate;
mainParties.CreatedBy = CurrentUser;
mainParties.CompanyID = model.CompanyID;
_context.Add(mainParties);
MainAccount mainAssets = new MainAccount();
mainAssets.AccountName = "Assets";
mainAssets.MainAccountNumber = "01";
mainAssets.CreationDate = CurrentDate;
mainAssets.CreatedBy = CurrentUser;
mainAssets.CompanyID = model.CompanyID;
_context.Add(mainAssets);
MainAccount mainLiabilities = new MainAccount();
mainLiabilities.AccountName = "Liabilities";
mainLiabilities.MainAccountNumber = "02";
mainLiabilities.CreationDate = CurrentDate;
mainLiabilities.CreatedBy = CurrentUser;
mainLiabilities.CompanyID = model.CompanyID;
_context.Add(mainLiabilities);
MainAccount mainIncome = new MainAccount();
mainIncome.AccountName = "Income";
mainIncome.MainAccountNumber = "03";
mainIncome.CreationDate = CurrentDate;
mainIncome.CreatedBy = CurrentUser;
mainIncome.CompanyID = model.CompanyID;
_context.Add(mainIncome);
MainAccount mainExpenses = new MainAccount();
mainExpenses.AccountName = "Expenses";
mainExpenses.MainAccountNumber = "04";
mainExpenses.CreationDate = CurrentDate;
mainExpenses.CreatedBy = CurrentUser;
mainExpenses.CompanyID = model.CompanyID;
_context.Add(mainExpenses);
await _context.SaveChangesAsync();
int mainPartiesID = mainParties.MainAccountID;
int mainAssetsID = mainAssets.MainAccountID;
int mainLiabilitiesID = mainLiabilities.MainAccountID;
int mainIncomeID = mainIncome.MainAccountID;
int mainExpensesID = mainExpenses.MainAccountID;
SubAccount subParties = new SubAccount();
subParties.AccountName = "Parties";
subParties.SubAccountNumber = "0000";
subParties.CreationDate = CurrentDate;
subParties.CreatedBy = CurrentUser;
subParties.CompanyID = model.CompanyID;
subParties.MainAccountID = mainPartiesID;
_context.Add(subParties);
SubAccount subPurchase = new SubAccount();
subPurchase.AccountName = "Purchase";
subPurchase.SubAccountNumber = "0001";
subPurchase.CreationDate = CurrentDate;
subPurchase.CreatedBy = CurrentUser;
subPurchase.CompanyID = model.CompanyID;
subPurchase.MainAccountID = mainExpensesID;
_context.Add(subPurchase);
SubAccount subSaleReturn = new SubAccount();
subSaleReturn.AccountName = "Sale Return";
subSaleReturn.SubAccountNumber = "0002";
subSaleReturn.CreationDate = CurrentDate;
subSaleReturn.CreatedBy = CurrentUser;
subSaleReturn.CompanyID = model.CompanyID;
subSaleReturn.MainAccountID = mainExpensesID;
_context.Add(subSaleReturn);
SubAccount subCash = new SubAccount();
subCash.AccountName = "Cash";
subCash.SubAccountNumber = "0001";
subCash.CreationDate = CurrentDate;
subCash.CreatedBy = CurrentUser;
subCash.CompanyID = model.CompanyID;
subCash.MainAccountID = mainAssetsID;
_context.Add(subCash);
SubAccount subBank = new SubAccount();
subBank.AccountName = "Bank";
subBank.SubAccountNumber = "0002";
subBank.CreationDate = CurrentDate;
subBank.CreatedBy = CurrentUser;
subBank.CompanyID = model.CompanyID;
subBank.MainAccountID = mainAssetsID;
_context.Add(subBank);
SubAccount subSale = new SubAccount();
subSale.AccountName = "Sale";
subSale.SubAccountNumber = "0001";
subSale.CreationDate = CurrentDate;
subSale.CreatedBy = CurrentUser;
subSale.CompanyID = model.CompanyID;
subSale.MainAccountID = mainIncomeID;
_context.Add(subSale);
SubAccount subPurchaseReturn = new SubAccount();
subPurchaseReturn.AccountName = "Purchase Return";
subPurchaseReturn.SubAccountNumber = "0002";
subPurchaseReturn.CreationDate = CurrentDate;
subPurchaseReturn.CreatedBy = CurrentUser;
subPurchaseReturn.CompanyID = model.CompanyID;
subPurchaseReturn.MainAccountID = mainIncomeID;
_context.Add(subPurchaseReturn);
await _context.SaveChangesAsync();
int subPurchaseID = subPurchase.SubAccountID;
int subSaleReturnID = subSaleReturn.SubAccountID;
int subCashID = subCash.SubAccountID;
int subSaleID = subSale.SubAccountID;
int subPurchaseReturnID = subPurchaseReturn.SubAccountID;
TransactionAccount transPurchaseCash = new TransactionAccount();
transPurchaseCash.AccountName = "Cash Purchase";
transPurchaseCash.TransactionAccountNumber = "0001";
transPurchaseCash.OpeningBalance = 0;
transPurchaseCash.CreationDate = CurrentDate;
transPurchaseCash.CreatedBy = CurrentUser;
transPurchaseCash.CompanyID = model.CompanyID;
transPurchaseCash.SubAccountID = subPurchaseID;
_context.Add(transPurchaseCash);
TransactionAccount transPurchaseCredit = new TransactionAccount();
transPurchaseCredit.AccountName = "Credit Purchase";
transPurchaseCredit.TransactionAccountNumber = "0002";
transPurchaseCredit.OpeningBalance = 0;
transPurchaseCredit.CreationDate = CurrentDate;
transPurchaseCredit.CreatedBy = CurrentUser;
transPurchaseCredit.CompanyID = model.CompanyID;
transPurchaseCredit.SubAccountID = subPurchaseID;
_context.Add(transPurchaseCredit);
TransactionAccount transSaleReturn = new TransactionAccount();
transSaleReturn.AccountName = "Sale Return";
transSaleReturn.TransactionAccountNumber = "0001";
transSaleReturn.OpeningBalance = 0;
transSaleReturn.CreationDate = CurrentDate;
transSaleReturn.CreatedBy = CurrentUser;
transSaleReturn.CompanyID = model.CompanyID;
transSaleReturn.SubAccountID = subSaleReturnID;
_context.Add(transSaleReturn);
TransactionAccount transCashInHand = new TransactionAccount();
transCashInHand.AccountName = "Cash In Hand";
transCashInHand.TransactionAccountNumber = "0001";
transCashInHand.OpeningBalance = 0;
transCashInHand.CreationDate = CurrentDate;
transCashInHand.CreatedBy = CurrentUser;
transCashInHand.CompanyID = model.CompanyID;
transCashInHand.SubAccountID = subCashID;
_context.Add(transCashInHand);
TransactionAccount transCashSale = new TransactionAccount();
transCashSale.AccountName = "Cash Sale";
transCashSale.TransactionAccountNumber = "0001";
transCashSale.OpeningBalance = 0;
transCashSale.CreationDate = CurrentDate;
transCashSale.CreatedBy = CurrentUser;
transCashSale.CompanyID = model.CompanyID;
transCashSale.SubAccountID = subSaleID;
_context.Add(transCashSale);
TransactionAccount transCreditSale = new TransactionAccount();
transCreditSale.AccountName = "Credit Sale";
transCreditSale.TransactionAccountNumber = "0002";
transCreditSale.OpeningBalance = 0;
transCreditSale.CreationDate = CurrentDate;
transCreditSale.CreatedBy = CurrentUser;
transCreditSale.CompanyID = model.CompanyID;
transCreditSale.SubAccountID = subSaleID;
_context.Add(transCreditSale);
TransactionAccount transPurchaseReturn = new TransactionAccount();
transPurchaseReturn.AccountName = "Purchase Return";
transPurchaseReturn.TransactionAccountNumber = "0001";
transPurchaseReturn.OpeningBalance = 0;
transPurchaseReturn.CreationDate = CurrentDate;
transPurchaseReturn.CreatedBy = CurrentUser;
transPurchaseReturn.CompanyID = model.CompanyID;
transPurchaseReturn.SubAccountID = subPurchaseReturnID;
_context.Add(transPurchaseReturn);
await _context.SaveChangesAsync();
// Insert statements on New user creation *** STATEMENT OF ACCOUNTS ***
// Send an email with this link
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
await _emailSender.SendEmailAsync(model.Email, "Confirm your account",
$"<h2>BiznsBook.com</h2>Please confirm your account by clicking this link: <a href='{callbackUrl}'>link</a>");
_logger.LogInformation(3, "User created a new account with password.");
return(RedirectToLocal(returnUrl));
//return RedirectToAction("SiteValidations", "Home");
}
AddErrors(result);
}
return(View(model));
}
public TransactionAccount findSaleAccount(int id)
{
TransactionAccount account = db.TransactionAccounts.Find(id);
return(account);
}
public ActionResult Edit(int id, FormCollection collection)
{
int allReports = Convert.ToInt32(Session["sale_reports_edit"]);
if (allReports == 0)
{
return(RedirectToAction("Index", "Home"));
}
Database1Entities1 db = new Database1Entities1();
string fromAccount = collection["from"];
string toAccount = collection["to"];
Transaction transEdit = new Transaction();
Transaction transNext = new Transaction();
TransactionAccount fromAccountTrans = new TransactionAccount();
TransactionAccount toAccountTrans = new TransactionAccount();
if (id % 2 == 0)
{
transEdit = db.Transactions.Find(id - 1);
transNext = db.Transactions.Find(id);
}
else
{
transEdit = db.Transactions.Find(id);
transNext = db.Transactions.Find(id + 1);
}
Good trans_from = service.findGoodByName(fromAccount);
if (transEdit.voucher_type == "PV" || transEdit.voucher_type == "UPPV")
{
fromAccountTrans = db.TransactionAccounts.Where(x => x.name == toAccount & x.is_active == "Y").First();
toAccountTrans = trans_from.TransactionAccount;
}
else
{
fromAccountTrans = trans_from.TransactionAccount;
toAccountTrans = db.TransactionAccounts.Where(x => x.name == toAccount & x.is_active == "Y").First();
}
int amount = 0;
double rate = 0;
//if(transEdit.voucher_type =="PV" || transEdit.voucher_type =="UPPV")
//{
// rate = service.findRate(fromAccountTrans.id, trans_from.good_Name);
//}
//else
//{
// rate = service.findRate(toAccountTrans.id, trans_from.good_Name);
//}
//if(transEdit.voucher_type=="UPPV" || transEdit.voucher_type =="UPSV")
//{
transEdit.unit_price = collection["unitPrice"];
transNext.unit_price = collection["unitPrice"];
rate = float.Parse(transEdit.unit_price);
//}
transEdit.truck = collection["truck"];
transEdit.builty_no_ = Convert.ToInt32(collection["builty"]);
transEdit.weight_empty = Convert.ToInt32(collection["empty"]);
transEdit.weight_load = Convert.ToInt32(collection["load"]);
transEdit.net_weight = Convert.ToInt32(collection["net"]);
transEdit.quantity = transEdit.net_weight.ToString();
transEdit.good_ = trans_from.good_Name;
transEdit.deduction = collection["deduction"];
transEdit.grn = collection["grn"];
transNext.truck = collection["truck"];
transNext.builty_no_ = Convert.ToInt32(collection["builty"]);
transNext.weight_empty = Convert.ToInt32(collection["empty"]);
transNext.weight_load = Convert.ToInt32(collection["load"]);
transNext.net_weight = Convert.ToInt32(collection["net"]);
transNext.quantity = transEdit.net_weight.ToString();
transNext.good_ = trans_from.good_Name;
transNext.deduction = collection["deduction"];
transNext.grn = collection["grn"];
if (rate != 0)
{
amount = Convert.ToInt32(rate * transEdit.net_weight);
}
else
{
amount = transEdit.dr;
}
if (collection["clientWeight"] != null)
{
int client_weight = Convert.ToInt32(collection["clientWeight"]);
transEdit.client_s_weight = client_weight;
transNext.client_s_weight = client_weight;
if (client_weight != 0)
{
amount = Convert.ToInt32(rate * client_weight);
}
}
transEdit.bags = collection["bags"];
transEdit.created_at = Convert.ToDateTime(collection["date"]);
transNext.created_at = transEdit.created_at;
transEdit.dr = amount;
transNext.cr = amount;
// For linking transaction //
transEdit.trans_acc_id = fromAccountTrans.id;
transNext.trans_acc_id = toAccountTrans.id;
//////////////////////////////////////
transEdit.from_account = fromAccountTrans.name;
transEdit.to_account = toAccountTrans.name;
transNext.to_account = toAccountTrans.name;
transNext.from_account = fromAccountTrans.name;
transNext.client_s_weight = transEdit.client_s_weight;
transEdit.description = collection["description"];
transNext.description = collection["description"];
db.SaveChanges();
service.balanceUpdation(fromAccountTrans.id, toAccountTrans.id);
if (transEdit.voucher_type == "SV" || transEdit.voucher_type == "UPSV")
{
return(RedirectToAction("salesReport"));
}
else
{
return(RedirectToAction("purchaseReport"));
}
}
public TransactionAccountDto(TransactionAccount account) : base(account)
{
this.account = account;
this.transactions = new List <ITransaction>(this.account.Transactions.Select(x => new TransactionDto(x)));
}
public IActionResult DeleteAllCompanyData([Bind("CompanyID")] SiteManageVM siteManageVM)
{
int CompanyID = siteManageVM.CompanyID;
if (ModelState.IsValid)
{
_context.CashFlow.RemoveRange(_context.CashFlow.Where(x => x.CompanyID == CompanyID));
var purchaseReturn = _context.PurchaseReturn
.Where(q => q.CompanyID == CompanyID)
.Include(q => q.PurchaseReturnTransaction);
_context.PurchaseReturn.RemoveRange(purchaseReturn);
var salReturn = _context.SaleReturn
.Where(q => q.CompanyID == CompanyID)
.Include(q => q.SaleReturnTransaction);
_context.SaleReturn.RemoveRange(salReturn);
var salBill = _context.SaleBill
.Where(q => q.CompanyID == CompanyID)
.Include(q => q.SaleTransaction)
.Include(q => q.SaleBillItem);
_context.SaleBill.RemoveRange(salBill);
var purBill = _context.PurchaseBill
.Where(q => q.CompanyID == CompanyID)
.Include(q => q.Transaction)
.Include(q => q.PurchaseBillItem);
_context.PurchaseBill.RemoveRange(purBill);
var voucher = _context.Voucher
.Where(q => q.CompanyID == CompanyID)
.Include(q => q.VoucherItems);
_context.Voucher.RemoveRange(voucher);
var grn = _context.GRN
.Where(q => q.CompanyID == CompanyID)
.Include(q => q.GRNItem);
_context.GRN.RemoveRange(grn);
_context.CashInBank.RemoveRange(_context.CashInBank.Where(x => x.CompanyID == CompanyID));
_context.CashPayment.RemoveRange(_context.CashPayment.Where(x => x.CompanyID == CompanyID));
_context.CashReceipt.RemoveRange(_context.CashReceipt.Where(x => x.CompanyID == CompanyID));
_context.ChequePayment.RemoveRange(_context.ChequePayment.Where(x => x.CompanyID == CompanyID));
_context.ChequeReceipt.RemoveRange(_context.ChequeReceipt.Where(x => x.CompanyID == CompanyID));
_context.Item.RemoveRange(_context.Item.Where(x => x.CompanyID == CompanyID));
_context.Parties.RemoveRange(_context.Parties.Where(x => x.CompanyID == CompanyID));
_context.CompanyProfile.RemoveRange(_context.CompanyProfile.Where(x => x.CompanyID == CompanyID));
_context.Country.RemoveRange(_context.Country.Where(x => x.CompanyID == CompanyID));
_context.Currency.RemoveRange(_context.Currency.Where(x => x.CompanyID == CompanyID));
_context.Bank.RemoveRange(_context.Bank.Where(x => x.CompanyID == CompanyID));
_context.ProductGroup.RemoveRange(_context.ProductGroup.Where(x => x.CompanyID == CompanyID));
_context.TransactionAccount.RemoveRange(_context.TransactionAccount.Where(x => x.CompanyID == CompanyID));
_context.SubAccount.RemoveRange(_context.SubAccount.Where(x => x.CompanyID == CompanyID));
_context.MainAccount.RemoveRange(_context.MainAccount.Where(x => x.CompanyID == CompanyID));
_context.SaveChanges();
// Insert statements on New user creation *** STATEMENT OF ACCOUNTS ***
DateTime CurrentDate = DateTime.Now;
string CurrentUser = User.Identity.Name;
MainAccount mainParties = new MainAccount();
mainParties.AccountName = "Parties";
mainParties.MainAccountNumber = "00";
mainParties.CreationDate = CurrentDate;
mainParties.CreatedBy = CurrentUser;
mainParties.CompanyID = CompanyID;
_context.Add(mainParties);
MainAccount mainAssets = new MainAccount();
mainAssets.AccountName = "Assets";
mainAssets.MainAccountNumber = "01";
mainAssets.CreationDate = CurrentDate;
mainAssets.CreatedBy = CurrentUser;
mainAssets.CompanyID = CompanyID;
_context.Add(mainAssets);
MainAccount mainLiabilities = new MainAccount();
mainLiabilities.AccountName = "Liabilities";
mainLiabilities.MainAccountNumber = "02";
mainLiabilities.CreationDate = CurrentDate;
mainLiabilities.CreatedBy = CurrentUser;
mainLiabilities.CompanyID = CompanyID;
_context.Add(mainLiabilities);
MainAccount mainIncome = new MainAccount();
mainIncome.AccountName = "Income";
mainIncome.MainAccountNumber = "03";
mainIncome.CreationDate = CurrentDate;
mainIncome.CreatedBy = CurrentUser;
mainIncome.CompanyID = CompanyID;
_context.Add(mainIncome);
MainAccount mainExpenses = new MainAccount();
mainExpenses.AccountName = "Expenses";
mainExpenses.MainAccountNumber = "04";
mainExpenses.CreationDate = CurrentDate;
mainExpenses.CreatedBy = CurrentUser;
mainExpenses.CompanyID = CompanyID;
_context.Add(mainExpenses);
_context.SaveChanges();
int mainPartiesID = mainParties.MainAccountID;
int mainAssetsID = mainAssets.MainAccountID;
int mainLiabilitiesID = mainLiabilities.MainAccountID;
int mainIncomeID = mainIncome.MainAccountID;
int mainExpensesID = mainExpenses.MainAccountID;
SubAccount subParties = new SubAccount();
subParties.AccountName = "Parties";
subParties.SubAccountNumber = "0000";
subParties.CreationDate = CurrentDate;
subParties.CreatedBy = CurrentUser;
subParties.CompanyID = CompanyID;
subParties.MainAccountID = mainPartiesID;
_context.Add(subParties);
SubAccount subPurchase = new SubAccount();
subPurchase.AccountName = "Purchase";
subPurchase.SubAccountNumber = "0001";
subPurchase.CreationDate = CurrentDate;
subPurchase.CreatedBy = CurrentUser;
subPurchase.CompanyID = CompanyID;
subPurchase.MainAccountID = mainExpensesID;
_context.Add(subPurchase);
SubAccount subSaleReturn = new SubAccount();
subSaleReturn.AccountName = "Sale Return";
subSaleReturn.SubAccountNumber = "0002";
subSaleReturn.CreationDate = CurrentDate;
subSaleReturn.CreatedBy = CurrentUser;
subSaleReturn.CompanyID = CompanyID;
subSaleReturn.MainAccountID = mainExpensesID;
_context.Add(subSaleReturn);
SubAccount subCash = new SubAccount();
subCash.AccountName = "Cash";
subCash.SubAccountNumber = "0001";
subCash.CreationDate = CurrentDate;
subCash.CreatedBy = CurrentUser;
subCash.CompanyID = CompanyID;
subCash.MainAccountID = mainAssetsID;
_context.Add(subCash);
SubAccount subBank = new SubAccount();
subBank.AccountName = "Bank";
subBank.SubAccountNumber = "0002";
subBank.CreationDate = CurrentDate;
subBank.CreatedBy = CurrentUser;
subBank.CompanyID = CompanyID;
subBank.MainAccountID = mainAssetsID;
_context.Add(subBank);
SubAccount subSale = new SubAccount();
subSale.AccountName = "Sale";
subSale.SubAccountNumber = "0001";
subSale.CreationDate = CurrentDate;
subSale.CreatedBy = CurrentUser;
subSale.CompanyID = CompanyID;
subSale.MainAccountID = mainIncomeID;
_context.Add(subSale);
SubAccount subPurchaseReturn = new SubAccount();
subPurchaseReturn.AccountName = "Purchase Return";
subPurchaseReturn.SubAccountNumber = "0002";
subPurchaseReturn.CreationDate = CurrentDate;
subPurchaseReturn.CreatedBy = CurrentUser;
subPurchaseReturn.CompanyID = CompanyID;
subPurchaseReturn.MainAccountID = mainIncomeID;
_context.Add(subPurchaseReturn);
_context.SaveChanges();
int subPurchaseID = subPurchase.SubAccountID;
int subSaleReturnID = subSaleReturn.SubAccountID;
int subCashID = subCash.SubAccountID;
int subSaleID = subSale.SubAccountID;
int subPurchaseReturnID = subPurchaseReturn.SubAccountID;
TransactionAccount transPurchaseCash = new TransactionAccount();
transPurchaseCash.AccountName = "Cash Purchase";
transPurchaseCash.TransactionAccountNumber = "0001";
transPurchaseCash.OpeningBalance = 0;
transPurchaseCash.CreationDate = CurrentDate;
transPurchaseCash.CreatedBy = CurrentUser;
transPurchaseCash.CompanyID = CompanyID;
transPurchaseCash.SubAccountID = subPurchaseID;
_context.Add(transPurchaseCash);
TransactionAccount transPurchaseCredit = new TransactionAccount();
transPurchaseCredit.AccountName = "Credit Purchase";
transPurchaseCredit.TransactionAccountNumber = "0002";
transPurchaseCredit.OpeningBalance = 0;
transPurchaseCredit.CreationDate = CurrentDate;
transPurchaseCredit.CreatedBy = CurrentUser;
transPurchaseCredit.CompanyID = CompanyID;
transPurchaseCredit.SubAccountID = subPurchaseID;
_context.Add(transPurchaseCredit);
TransactionAccount transSaleReturn = new TransactionAccount();
transSaleReturn.AccountName = "Sale Return";
transSaleReturn.TransactionAccountNumber = "0001";
transSaleReturn.OpeningBalance = 0;
transSaleReturn.CreationDate = CurrentDate;
transSaleReturn.CreatedBy = CurrentUser;
transSaleReturn.CompanyID = CompanyID;
transSaleReturn.SubAccountID = subSaleReturnID;
_context.Add(transSaleReturn);
TransactionAccount transCashInHand = new TransactionAccount();
transCashInHand.AccountName = "Cash In Hand";
transCashInHand.TransactionAccountNumber = "0001";
transCashInHand.OpeningBalance = 0;
transCashInHand.CreationDate = CurrentDate;
transCashInHand.CreatedBy = CurrentUser;
transCashInHand.CompanyID = CompanyID;
transCashInHand.SubAccountID = subCashID;
_context.Add(transCashInHand);
TransactionAccount transCashSale = new TransactionAccount();
transCashSale.AccountName = "Cash Sale";
transCashSale.TransactionAccountNumber = "0001";
transCashSale.OpeningBalance = 0;
transCashSale.CreationDate = CurrentDate;
transCashSale.CreatedBy = CurrentUser;
transCashSale.CompanyID = CompanyID;
transCashSale.SubAccountID = subSaleID;
_context.Add(transCashSale);
TransactionAccount transCreditSale = new TransactionAccount();
transCreditSale.AccountName = "Credit Sale";
transCreditSale.TransactionAccountNumber = "0002";
transCreditSale.OpeningBalance = 0;
transCreditSale.CreationDate = CurrentDate;
transCreditSale.CreatedBy = CurrentUser;
transCreditSale.CompanyID = CompanyID;
transCreditSale.SubAccountID = subSaleID;
_context.Add(transCreditSale);
TransactionAccount transPurchaseReturn = new TransactionAccount();
transPurchaseReturn.AccountName = "Purchase Return";
transPurchaseReturn.TransactionAccountNumber = "0001";
transPurchaseReturn.OpeningBalance = 0;
transPurchaseReturn.CreationDate = CurrentDate;
transPurchaseReturn.CreatedBy = CurrentUser;
transPurchaseReturn.CompanyID = CompanyID;
transPurchaseReturn.SubAccountID = subPurchaseReturnID;
_context.Add(transPurchaseReturn);
_context.SaveChanges();
// Insert statements on New user creation *** STATEMENT OF ACCOUNTS ***
return(RedirectToAction("Index", "Home", new { area = "SiteAdmin" }));
}
return(View());
}
public ActionResult AddSaleVoucher(int id)
{
if (service.checkID() == false)
{
return(Content("IDS Conflict Error Occured While Procsesing Request"));
}
TemporaryReport temp = service.findTemporaryReport(id);
int nextID = id + 1;
TemporaryReport tempTo = service.findTemporaryReport(nextID);
string from = temp.from_account;
string to = temp.to_account;
int fromID = (int)temp.tax;
double rate = 0;
int idForRate = 0;
float unitPrice = 0;
if (temp.voucher_type == "UPSV" || temp.voucher_type == "UPPV")
{
try
{
float checkingUnit = float.Parse(temp.unit_price);
}
catch (Exception)
{
if (temp.builty_no_ != null)
{
return(RedirectToAction("unitPriceSV", "SaleVoucher"));
}
else
{
return(RedirectToAction("unitPricePV", "SaleVoucher"));
}
}
}
try
{
int checking = (int)temp.builty_no_;
}
catch (Exception)
{
if (temp.voucher_type == "SV")
{
return(RedirectToAction("Index", "SaleVoucher"));
}
else
{
return(RedirectToAction("unitPriceSV", "SaleVoucher"));
}
}
int builty = Convert.ToInt32(temp.builty_no_);
try
{
String session = Session["name"].ToString();
TransactionAccount transFrom = new TransactionAccount();
TransactionAccount trans_to = new TransactionAccount();
Good good = service.findGood(fromID);
if (temp.voucher_type == "UPPV" || temp.voucher_type == "PV")
{
transFrom = service.findJvTransaction(from);
trans_to = good.TransactionAccount;
idForRate = transFrom.id;
}
else if (temp.voucher_type == "SV" || temp.voucher_type == "UPSV")
{
transFrom = good.TransactionAccount;
trans_to = service.findJvTransaction(to);
idForRate = trans_to.id;
}
Transaction tr = new Transaction();
Transaction transTo = new Transaction();
if (temp.voucher_type == "UPSV" || temp.voucher_type == "UPPV")
{
unitPrice = float.Parse(temp.unit_price);
rate = unitPrice;
}
else
{
try
{
rate = service.findRate(idForRate, good.good_Name);
}
catch (Exception)
{
return(Content("<script language='javascript' type='text/javascript'>alert('Invalid Rate !');</script>"));
}
}
int amount = 0;
tr.truck = temp.truck;
tr.builty_no_ = temp.builty_no_;
tr.weight_empty = temp.weight_empty;
tr.weight_load = temp.weight_load;
tr.net_weight = temp.net_weight;
tr.quantity = tr.net_weight.ToString();
tr.good_ = good.good_Name;
amount = Convert.ToInt32(rate * tr.net_weight);
tr.bags = temp.bags;
tr.created_at = temp.created_at;
tr.updated_at = tr.created_at;
tr.is_active = "Y";
tr.code = transFrom.id;
tr.description = temp.description;
tr.cr = 0;
tr.dr = amount;
tr.balance = (transFrom.balance - amount);
tr.from_account = from;
tr.to_account = to;
//transFrom.dr_ = amount;
if (temp.voucher_type == "SV" || temp.voucher_type == "UPSV")
{
if (temp.voucher_type == "SV")
{
tr.status = "Sale voucher added";
tr.voucher_type = "SV";
// tr.voucher_code = "SV111";
}
else
{
tr.status = "Unit Price Sale Voucher Added";
tr.voucher_type = "UPSV";
// tr.voucher_code = "UPSV111";
}
}
else
{
if (temp.voucher_type == "PV")
{
tr.status = "Purchase Voucher added";
// tr.voucher_code = "PV111";
tr.voucher_type = "PV";
tr.grn = temp.grn;
tr.deduction = temp.deduction;
}
else
{
tr.status = "Unit Price Purchase Voucher added";
// tr.voucher_code = "UPPV111";
tr.voucher_type = "UPPV";
tr.grn = temp.grn;
tr.deduction = temp.deduction;
}
}
tr.trans_acc_id = transFrom.id;
if (session != "Admin")
{
string username = Session["username"].ToString();
User user = service.findUser(username);
ViewBag.userName = user.name;
tr.supervisor = user.name;
}
else
{
ViewBag.userName = Session["username"].ToString();
tr.supervisor = Session["username"].ToString();
}
tr.user_id = temp.user_id;
tr.admin_id = temp.admin_id;
tr.voucher_code = temp.voucher_code;
tr.unit_price = temp.unit_price;
service.addTransaction(tr);
transFrom.balance = tr.balance;
tr.unique_key = transFrom.id;
temp.is_active = "N";
transTo.truck = tempTo.truck;
transTo.builty_no_ = tempTo.builty_no_;
transTo.weight_empty = tempTo.weight_empty;
transTo.weight_load = tempTo.weight_load;
transTo.net_weight = tempTo.net_weight;
transTo.bags = tempTo.bags;
transTo.created_at = tempTo.created_at;
transTo.updated_at = tr.created_at;
transTo.is_active = "Y";
transTo.quantity = tr.quantity;
transTo.good_ = good.good_Name;
transTo.code = trans_to.id;
transTo.description = tempTo.description;
transTo.dr = 0;
transTo.cr = amount;
transTo.balance = (trans_to.balance + amount);
transTo.from_account = from;
transTo.to_account = to;
if (temp.voucher_type == "SV" || temp.voucher_type == "UPSV")
{
if (temp.voucher_type == "SV")
{
transTo.status = "Sale voucher added";
transTo.voucher_type = "SV";
transTo.voucher_code = "SV111";
}
else
{
transTo.status = "Unit Price Sale Voucher Added";
transTo.voucher_type = "UPSV";
transTo.voucher_code = "UPSV111";
}
}
else
{
if (temp.voucher_type == "PV")
{
transTo.status = "Purchase Voucher added";
transTo.voucher_code = "PV111";
transTo.voucher_type = "PV";
transTo.grn = tempTo.grn;
transTo.deduction = tempTo.deduction;
}
else
{
transTo.status = "Unit Price Purchase Voucher added";
transTo.voucher_code = "UPPV111";
transTo.voucher_type = "UPPV";
transTo.grn = tempTo.grn;
transTo.deduction = tempTo.deduction;
}
}
transTo.trans_acc_id = trans_to.id;
//trans_to.cr_ = amount;
if (session != "Admin")
{
string username = Session["username"].ToString();
User user = service.findUser(username);
ViewBag.userName = user.name;
transTo.supervisor = user.name;
}
else
{
ViewBag.userName = Session["username"].ToString();
transTo.supervisor = Session["username"].ToString();
}
transTo.user_id = temp.user_id;
transTo.admin_id = temp.admin_id;
// End //
transTo.voucher_code = temp.voucher_code;
transTo.unit_price = tr.unit_price;
service.addTransaction(transTo);
trans_to.balance = transTo.balance;
transTo.unique_key = tr.unique_key;
tempTo.is_active = "N";
trans_to.updated_at_ = tr.updated_at;
transFrom.updated_at_ = tr.updated_at;
// for Weight maintenece //
//if (tr.voucher_type == "PV" || tr.voucher_type != "UPPV")
// if (transFrom.WEIGHT != null)
// {
// int weight = Convert.ToInt32(transFrom.WEIGHT);
// weight = (int)(weight - temp.net_weight);
// transFrom.WEIGHT = weight.ToString();
// }
// if (trans_to.WEIGHT != null)
// {
// int weight = Convert.ToInt32(trans_to.WEIGHT);
// weight = (int)(weight + temp.net_weight);
// trans_to.WEIGHT = weight.ToString();
// }
//////////////////////////
tr.Last_Edit = "None";
transTo.Last_Edit = "None";
service.save();
#region Sale and Purchase order
if (temp.order_number != 0 && temp.order_number != -1 && temp.order_number != null)
{
Database1Entities1 db = new Database1Entities1();
if (temp.order_code == "SO")
{
Sale_Order so = db.Sale_Order.Find(temp.order_number);
so.weight = (int)(so.weight - temp.net_weight);
if (so.weight <= 0)
{
so.is_active = "N";
}
}
else if (temp.order_code == "PO")
{
Purchase_Order po = db.Purchase_Order.Find(temp.order_number);
po.weight = (int)(po.weight - temp.net_weight);
if (po.weight <= 0)
{
po.is_active = "N";
}
}
db.SaveChanges();
}
#endregion
service.balanceUpdation(transFrom.id, trans_to.id);
//////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
if (tr.voucher_type == "SV" || tr.voucher_type == "UPSV")
{
Transaction transaction = new Transaction();
Transaction transactionTo = new Transaction();
TransactionAccount newTr = new TransactionAccount();
try{
newTr = service.findSaleAccount(transFrom.sale_account_id);
}
catch (Exception)
{
return(Content("<script language='javascript' type='text/javascript'>alert('Link sale Account not Found !');</script>"));
}
transaction.truck = tr.truck;
transaction.builty_no_ = tr.builty_no_;
transaction.weight_empty = tr.weight_empty;
transaction.weight_load = tr.weight_load;
transaction.net_weight = tr.net_weight;
transaction.quantity = tr.quantity;
tr.good_ = good.good_Name;
amount = Convert.ToInt32(rate * tr.net_weight);
transaction.bags = tr.bags;
transaction.created_at = tr.created_at;
transaction.updated_at = tr.created_at;
transaction.is_active = "Y";
transaction.code = transFrom.id;
transaction.description = tr.description;
transaction.cr = 0;
transaction.dr = amount;
transaction.balance = (transFrom.balance - amount);
transaction.from_account = transFrom.name;
transaction.to_account = trans_to.name;
//transFrom.dr_ = amount;
transaction.status = "Sale voucher added";
transaction.voucher_type = "SV";
transaction.voucher_code = tr.voucher_code;
transaction.trans_acc_id = transFrom.id;
if (session != "Admin")
{
string username = Session["username"].ToString();
User user = service.findUser(username);
ViewBag.userName = user.name;
transaction.supervisor = user.name;
}
else
{
ViewBag.userName = Session["username"].ToString();
transaction.supervisor = Session["username"].ToString();
}
transaction.user_id = temp.user_id;
transaction.admin_id = temp.admin_id;
transaction.from_account = transFrom.name;
transaction.to_account = newTr.name;
transaction.voucher_code = tr.voucher_code;
transaction.unique_key = good.Id;
transaction.Last_Edit = tr.Last_Edit;
service.addTransaction(transaction);
transactionTo.truck = tr.truck;
transactionTo.builty_no_ = tr.builty_no_;
transactionTo.weight_empty = tr.weight_empty;
transactionTo.weight_load = tr.weight_load;
transactionTo.net_weight = tr.net_weight;
transactionTo.bags = tr.bags;
transactionTo.created_at = tr.created_at;
transactionTo.updated_at = tr.created_at;
transactionTo.is_active = "Y";
transactionTo.quantity = tr.quantity;
transactionTo.good_ = tr.good_;
transactionTo.code = newTr.id;
transactionTo.description = tr.description;
transactionTo.dr = 0;
transactionTo.cr = amount;
transactionTo.balance = (trans_to.balance + amount);
transactionTo.from_account = transFrom.name;
transaction.to_account = newTr.name;
transactionTo.status = "Sale voucher added";
transactionTo.voucher_type = "SV";
transactionTo.trans_acc_id = newTr.id;
//newTr.cr_ = amount;
if (session != "Admin")
{
string username = Session["username"].ToString();
User user = service.findUser(username);
ViewBag.userName = user.name;
transactionTo.supervisor = user.name;
}
else
{
ViewBag.userName = Session["username"].ToString();
transactionTo.supervisor = Session["username"].ToString();
}
transactionTo.user_id = temp.user_id;
transactionTo.admin_id = temp.admin_id;
transactionTo.from_account = transFrom.name;
transactionTo.to_account = newTr.name;
transactionTo.Last_Edit = tr.Last_Edit;
service.addTransaction(transactionTo);
newTr.balance = newTr.balance + amount;
newTr.updated_at_ = tr.updated_at;
//newTr.dr_ = newTr.dr_ + amount;
int weight = Convert.ToInt32(newTr.WEIGHT);
int newWieght = (int)(weight + tr.net_weight);
newTr.WEIGHT = newWieght.ToString();
transactionTo.voucher_code = tr.voucher_code;
transaction.extra = "Sale"; // for dicriminate sale accounts //
transactionTo.extra = "Sale";
service.save();
service.balanceUpdation(transFrom.id, newTr.id);
}
////////////////////////////////////////////////////////////////////////////
return(RedirectToAction("Supervision", "USER_CRUD"));
}
catch
{
if (temp.voucher_type == "SV" || temp.voucher_type == "UPSV")
{
if (unitPrice == 0)
{
return(RedirectToAction("Supervision", "USER_CRUD"));
//return RedirectToAction("Index");
}
else
{
return(RedirectToAction("Supervision", "USER_CRUD"));
//return RedirectToAction("unitPriceSV");
}
}
else
{
if (unitPrice == 0)
{
return(RedirectToAction("purchaseVoucher"));
}
else
{
return(RedirectToAction("unitPricePV"));
}
}
}
}
