public static List <AccountHead> GetAccountHeadList(bool showPrimary = true, bool showDeleted = false)
{
List <AccountHead> AccountHeadList = new List <AccountHead>();
DataTable GetAccountHeadTable = AccountHeadDataAccess.GetInstance.GetAccountHeadList(showPrimary, showDeleted);
foreach (DataRow dr in GetAccountHeadTable.Rows)
{
AccountHead TheAccountHead = DataRowToObject(dr);
AccountHeadList.Add(TheAccountHead);
}
return(AccountHeadList);
}
public static AccountHead DataRowToObject(DataRow dr)
{
AccountHead TheAccountHead = new AccountHead();
TheAccountHead.AccountHeadID = int.Parse(dr["AccountHeadID"].ToString());
TheAccountHead.AccountHeadDescription = dr["AccountHeadDescription"].ToString();
TheAccountHead.AccountHeadType = dr["AccountHeadType"].ToString();
TheAccountHead.ParentAccountHeadID = int.Parse(MicroGlobals.ReturnZeroIfNull(dr["ParentAccountHeadID"].ToString()));
TheAccountHead.ParentAccountHeadDescription = dr["ParentAccountHeadDescription"].ToString();
TheAccountHead.IsPrimary = bool.Parse(dr["IsPrimary"].ToString());
TheAccountHead.DisplayOrder = int.Parse(dr["DisplayOrder"].ToString());
return(TheAccountHead);
}
public ActionResult Edit(AccountHead objAccountHead)
{
bool status = false;
if (ModelState.IsValid)
{
AccountHeadBLL objAccountHeadBll = new AccountHeadBLL();
objAccountHeadBll.UpdateAccountHead(objAccountHead);
status = true;
}
return(new JsonResult {
Data = new { status = status }
});
}
protected void ddl_AccountHeads_SelectedIndexChanged(object sender, EventArgs e)
{
ClearListItems(ddl_AnalysisFlag);
if (!IsDefaultItemText(ddl_AccountHeads))
{
AccountHead ThisAccountHead = AccountHeadManagement.GetInstance.GetAccountHeadByID(int.Parse(ddl_AccountHeads.SelectedItem.Value));
BindDropdown_AnalysisFlag(ThisAccountHead.AccountHeadType);
}
if (chk_TreatAsSubAccount.Checked)
{
ClearListItems(ddl_ParentAccountName);
}
}
public IActionResult Post([FromBody] AccountHead value)
{
try
{
using (var db = My.ConnectionFactory())
{
int result = db.Execute($@"IF EXISTS({My.Table_AccountHead.SelectSingle}) {My.Table_AccountHead.Update} ELSE {My.Table_AccountHead.Insert}", value);
}
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public ActionResult DeleteHead(int id)
{
Session["err"] = "Error, Can't Delete, Please check Dependency Data";
Session["msg"] = "";
try
{
AccountHead accounthead = db.AccountHeads.Find(id);
db.AccountHeads.Remove(accounthead);
db.SaveChanges();
Session["err"] = "";
Session["msg"] = "Deleted Successfully";
}
catch { }
return(RedirectToAction("Index"));
}
public int DeleteAccountHead(AccountHead theAccountHead)
{
int ReturnValue = 0;
using (SqlCommand DeleteCommand = new SqlCommand())
{
DeleteCommand.CommandType = CommandType.StoredProcedure;
DeleteCommand.Parameters.Add(GetParameter("@ReturnValue", SqlDbType.Int, ReturnValue)).Direction = ParameterDirection.Output;
DeleteCommand.Parameters.Add(GetParameter("@AccountHeadID", SqlDbType.Int, theAccountHead.AccountHeadID));
DeleteCommand.Parameters.Add(GetParameter("@ModifiedBy", SqlDbType.Int, 1));//TO DO Remove HC:KP :Micro.Commons.Connection.LoggedOnUser.UserID
DeleteCommand.CommandText = "pFIN_AccountHeads_Delete";
ExecuteStoredProcedure(DeleteCommand);
ReturnValue = int.Parse(DeleteCommand.Parameters[0].Value.ToString());
return(ReturnValue);
}
}
public static AccountHead GetAccountHeadByID(int accountHeadID)
{
AccountHead TheAccountHead;
DataRow TheAccountHeadRow = AccountHeadDataAccess.GetInstance.GetAccountHeadByID(accountHeadID);
if (TheAccountHeadRow != null)
{
TheAccountHead = DataRowToObject(TheAccountHeadRow);
}
else
{
TheAccountHead = new AccountHead();
}
return(TheAccountHead);
}
private int InsertRecord()
{
int ProcReturnValue = 0;
AccountHead TheAccountHead = new AccountHead();
TheAccountHead.AccountHeadDescription = ToProper(txt_AccountHeadName.Text);
TheAccountHead.AccountHeadType = ddl_AccountHeadType.SelectedItem.Text;
if (chk_TreatAsSubHead.Checked)
{
TheAccountHead.ParentAccountHeadID = int.Parse(ddl_ParentAccountHeadName.SelectedItem.Value);
}
ProcReturnValue = AccountHeadManagement.GetInstance.InsertAccountHead(TheAccountHead);
return(ProcReturnValue);
}
public ActionResult EditHead([Bind(Include = "AccountHeadID,Name,AccountGroupID")] AccountHead accounthead, string existing)
{
Session["err"] = "Error, Please Check Input Fields";
Session["msg"] = "";
if (ModelState.IsValid)
{
if (accounthead.Name != existing)
{
AccountHead exist = db.AccountHeads.Include(a => a.CurrentAccountGroup).Include(a => a.CurrentAccountGroup.CurrentAccountCategory).Where(s => s.Name == accounthead.Name && s.Name != existing).FirstOrDefault();
if (exist != null)
{
Session["err"] = "Head already exists";
ViewBag.AccountCategoryID = accounthead.CurrentAccountGroup.CurrentAccountCategory.Name;
ViewBag.AccountGroupID = new SelectList(db.AccountGroups.Include(a => a.CurrentAccountCategory).Where(a => a.CurrentAccountCategory.AccountCategoryID == exist.CurrentAccountGroup.AccountCategoryID), "AccountGroupID", "Name", accounthead.AccountGroupID);
ViewBag.Existing = accounthead.Name;
ViewBag.Existing = existing;
ViewBag.Message = Session["msg"];
ViewBag.Error = Session["err"];
Session["err"] = "";
Session["msg"] = "";
return(View(accounthead));
}
}
db.Entry(accounthead).State = EntityState.Modified;
db.SaveChanges();
ModelState.Clear();
Session["err"] = "";
Session["msg"] = "Modified Successfully";
return(RedirectToAction("Index"));
}
ViewBag.Existing = existing;
ViewBag.Message = Session["msg"];
ViewBag.Error = Session["err"];
Session["err"] = "";
Session["msg"] = "";
AccountHead accountheadexist = db.AccountHeads.Include(a => a.CurrentAccountGroup).Include(a => a.CurrentAccountGroup.CurrentAccountCategory).Where(a => a.AccountHeadID == accounthead.AccountHeadID).FirstOrDefault();
ViewBag.AccountCategoryID = accounthead.CurrentAccountGroup.CurrentAccountCategory.Name;
ViewBag.AccountGroupID = new SelectList(db.AccountGroups.Include(a => a.CurrentAccountCategory).Where(a => a.CurrentAccountCategory.AccountCategoryID == accountheadexist.CurrentAccountGroup.AccountCategoryID), "AccountGroupID", "Name", accounthead.AccountGroupID);
ViewBag.Existing = accounthead.Name;
return(View(accounthead));
}
public static void AddAccountHeads(BusinessDbContext context, string shopId)
{
var heads = GetAccountHeads();
foreach (string head in heads)
{
if (context.AccountHeads.Any(x => x.Name.ToUpper().Contains(head) && x.ShopId == shopId))
{
continue;
}
AccountHead accountHead = GetDefaults <AccountHead>(shopId);
accountHead.Id = Guid.NewGuid().ToString();
accountHead.Name = head;
context.AccountHeads.Add(accountHead);
context.SaveChanges();
}
}
private AccountHead GetPurchaseAccountHead(Purchase purchase)
{
var db = this.Repository.Db as BusinessDbContext;
AccountHead accountHead = db.AccountHeads.FirstOrDefault(x => x.Name == "Purchase" && x.ShopId == purchase.ShopId);
if (accountHead == null)
{
accountHead = new AccountHead()
{
ShopId = purchase.ShopId, Name = "Purchase"
};
this.AddCommonValues(purchase, accountHead);
db.AccountHeads.Add(accountHead);
db.SaveChanges();
}
return(accountHead);
}
protected void btn_Delete_CheckedItem_Click(object sender, EventArgs e)
{
foreach (GridViewRow EachRow in gview_AccountHead.Rows)
{
CheckBox EachCheckBox = (CheckBox)EachRow.FindControl("chk_AccountHeadID");
if (EachCheckBox.Checked)
{
int RecordID = int.Parse(((Label)EachRow.FindControl("lbl_AccountHeadID")).Text);
AccountHead TheAccountHead = new AccountHead();
TheAccountHead.AccountHeadID = RecordID;
int ProcReturnValue = AccountHeadManagement.GetInstance.DeleteAccountHead(TheAccountHead);
}
BindGridView();
}
}
// Update Accound Head
public string UpdateAccountHead(AccountHead objAccountHead)
{
int noRowCount = 0;
objDataAccess = DataAccess.NewDataAccess();
objDbCommand = objDataAccess.GetCommand(true, IsolationLevel.Serializable);
objDbCommand.AddInParameter("AccountHeadId", objAccountHead.AccountHeadId);
objDbCommand.AddInParameter("AccountCode", objAccountHead.AccountCode);
objDbCommand.AddInParameter("AccountName", objAccountHead.AccountName);
objDbCommand.AddInParameter("AccountType", objAccountHead.AccountType);
objDbCommand.AddInParameter("Description", objAccountHead.Description);
objDbCommand.AddInParameter("IsActive", objAccountHead.IsActive);
objDbCommand.AddInParameter("UpdatedBy", SessionUtility.STSessionContainer.UserID);
try
{
noRowCount = objDataAccess.ExecuteNonQuery(objDbCommand, "[dbo].uspUpdateAccountHead", CommandType.StoredProcedure);
if (noRowCount > 0)
{
objDbCommand.Transaction.Commit();
return("Save Successfully");
}
else
{
objDbCommand.Transaction.Rollback();
return("Save Failed");
}
}
catch (Exception ex)
{
objDbCommand.Transaction.Rollback();
throw new Exception("Database Error Occured", ex);
}
finally
{
objDataAccess.Dispose(objDbCommand);
}
}
private void AddTransaction(Purchase purchase)
{
var db = Repository.Db as BusinessDbContext;
AccountHead accountHead = db.AccountHeads.FirstOrDefault(x => x.Name == "Purchase" && x.ShopId == purchase.ShopId);
if (accountHead == null)
{
accountHead = new AccountHead()
{
ShopId = purchase.ShopId,
Name = "Purchase"
};
AddCommonValues(purchase, accountHead);
db.AccountHeads.Add(accountHead);
db.SaveChanges();
}
Transaction transaction = new Transaction()
{
ShopId = purchase.ShopId,
AccountHeadId = accountHead.Id,
AccountHeadName = accountHead.Name,
TransactionFlowType = TransactionFlowType.Expense,
Amount = purchase.PaidAmount,
OrderNumber = purchase.OrderNumber,
OrderId = purchase.Id,
ParentId = purchase.SupplierId,
Remarks = "initial payment",
TransactionFor = TransactionFor.Purchase,
TransactionWith = TransactionWith.Supplier,
TransactionMedium = TransactionMedium.Cash,
TransactionMediumName = "Cash",
PaymentGatewayService = PaymentGatewayService.Cash,
PaymentGatewayServiceName = "Cash",
TransactionDate = DateTime.Now
};
AddCommonValues(purchase, transaction);
db.Transactions.Add(transaction);
db.SaveChanges();
}
public int InsertAccountHead(AccountHead theAccountHead)
{
int ReturnValue = 0;
using (SqlCommand InsertCommand = new SqlCommand())
{
InsertCommand.CommandType = CommandType.StoredProcedure;
InsertCommand.Parameters.Add(GetParameter("@ReturnValue", SqlDbType.Int, ReturnValue)).Direction = ParameterDirection.Output;
InsertCommand.Parameters.Add(GetParameter("@AccountHeadDescription", SqlDbType.VarChar, theAccountHead.AccountHeadDescription));
InsertCommand.Parameters.Add(GetParameter("@AccountHeadType", SqlDbType.VarChar, theAccountHead.AccountHeadType));
if (theAccountHead.ParentAccountHeadID != null)
{
InsertCommand.Parameters.Add(GetParameter("@ParentAccountHeadID", SqlDbType.Int, theAccountHead.ParentAccountHeadID));
}
InsertCommand.Parameters.Add(GetParameter("@AddedBy", SqlDbType.Int, Micro.Commons.Connection.LoggedOnUser.UserID));
InsertCommand.CommandText = "pICAS_FIN_AccountHeads_Insert";
ExecuteStoredProcedure(InsertCommand);
ReturnValue = int.Parse(InsertCommand.Parameters[0].Value.ToString());
return(ReturnValue);
}
}
internal void DeleteTheAcccountInformation(AccountHead accountHeadObj)
{
try
{
connection.Open();
string selectQuery = @"DELETE FROM [tbl_acc_head] WHERE [acch_id] ='" + accountHeadObj.Id + "' ";
SqlCommand command = new SqlCommand(selectQuery, connection);
command.ExecuteNonQuery();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
if (connection.State == ConnectionState.Open)
{
connection.Close();
}
}
}
// GET: /CashVoucherPrint/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
CashVoucher cashvoucher = db.CashVouchers.Find(id);
if (cashvoucher == null)
{
return(HttpNotFound());
}
VoucherType vouchertypemaster = db.VoucherTypes.Find(cashvoucher.VoucherTypeID);
ViewBag.VoucherTypeID = vouchertypemaster.Name;
Employee employee = db.Employees.Find(cashvoucher.EmployeeID);
ViewBag.EmployeeID = employee.Name;
AccountHead accounthead = db.AccountHeads.Find(cashvoucher.AccountHeadID);
ViewBag.AccountHeadID = accounthead.Name;
return(View(cashvoucher));
}
//get account head detail by Id for edit and delete
public AccountHead GetAccountHeadById(int id)
{
objDataAccess = DataAccess.NewDataAccess();
objDbCommand = objDataAccess.GetCommand(true, IsolationLevel.ReadCommitted);
DbDataReader objDbDataReader = null;
List <AccountHead> objAccountHeadList = new List <AccountHead>();
AccountHead objAccountHead = new AccountHead();
try
{
objDbCommand.AddInParameter("AccountHeadId", id);
objDbDataReader = objDataAccess.ExecuteReader(objDbCommand, "[dbo].uspGetAccountHeadById", CommandType.StoredProcedure);
if (objDbDataReader.HasRows)
{
while (objDbDataReader.Read())
{
objAccountHead = new AccountHead();
this.BuildModelForAccountHead(objDbDataReader, objAccountHead);
objAccountHeadList.Add(objAccountHead);
}
}
}
catch (Exception ex)
{
throw new Exception("Error : " + ex.Message);
}
finally
{
if (objDbDataReader != null)
{
objDbDataReader.Close();
}
objDataAccess.Dispose(objDbCommand);
}
return(objAccountHead);
}
public ActionResult CreateHead([Bind(Include = "AccountHeadID,Name,AccountGroupID")] AccountHead accounthead, int AccountCategoryID)
{
Session["err"] = "Error, Please Check Input Fields";
Session["msg"] = "";
if (ModelState.IsValid)
{
AccountHead exist = db.AccountHeads.Where(c => c.Name == accounthead.Name).FirstOrDefault();
if (exist != null)
{
Session["err"] = "Head already exists";
ViewBag.Message = Session["msg"];
ViewBag.Error = Session["err"];
Session["err"] = "";
Session["msg"] = "";
ViewBag.AccountCategoryID = new SelectList(db.AccountCategorys, "AccountCategoryID", "Name", AccountCategoryID);
ViewBag.AccountGroupID = new SelectList(db.AccountGroups.Where(c => c.AccountGroupID == AccountCategoryID), "AccountGroupID", "Name");
return(View(accounthead));
}
db.AccountHeads.Add(accounthead);
db.SaveChanges();
ModelState.Clear();
Session["err"] = "";
Session["msg"] = "Created Successfully";
return(RedirectToAction("Index"));
}
ViewBag.Message = Session["msg"];
ViewBag.Error = Session["err"];
Session["err"] = "";
Session["msg"] = "";
ViewBag.AccountCategoryID = new SelectList(db.AccountCategorys, "AccountCategoryID", "Name", AccountCategoryID);
ViewBag.AccountGroupID = new SelectList(db.AccountGroups.Where(c => c.AccountGroupID == AccountCategoryID), "AccountGroupID", "Name");
return(View(accounthead));
}
public int UpdatetAccountHead(AccountHead theAccountHead)
{
return(AccountHeadIntegration.UpdateAccountHead(theAccountHead));
}
private void BuildModelForAccountHead(DbDataReader objDataReader, AccountHead objAccountHead)
{
DataTable objDataTable = objDataReader.GetSchemaTable();
foreach (DataRow dr in objDataTable.Rows)
{
String column = dr.ItemArray[0].ToString();
switch (column)
{
case "AccountHeadId":
if (!Convert.IsDBNull(objDataReader["AccountHeadId"]))
{
objAccountHead.AccountHeadId = Convert.ToInt32(objDataReader["AccountHeadId"]);
}
break;
case "AccountCode":
if (!Convert.IsDBNull(objDataReader["AccountCode"]))
{
objAccountHead.AccountCode = objDataReader["AccountCode"].ToString();
}
break;
case "AccountName":
if (!Convert.IsDBNull(objDataReader["AccountName"]))
{
objAccountHead.AccountName = objDataReader["AccountName"].ToString();
}
break;
case "Description":
if (!Convert.IsDBNull(objDataReader["Description"]))
{
objAccountHead.Description = objDataReader["Description"].ToString();
}
break;
case "AccountType":
if (!Convert.IsDBNull(objDataReader["AccountType"]))
{
objAccountHead.AccountType = objDataReader["AccountType"].ToString();
}
break;
case "IsActive":
if (!Convert.IsDBNull(objDataReader["IsActive"]))
{
objAccountHead.IsActive = Convert.ToBoolean(objDataReader["IsActive"].ToString());
}
break;
case "UserStatus":
if (!Convert.IsDBNull(objDataReader["UserStatus"]))
{
objAccountHead.UserStatus = objDataReader["UserStatus"].ToString();
}
break;
case "CreatedBy":
if (!Convert.IsDBNull(objDataReader["CreatedBy"]))
{
objAccountHead.CreatedBy = Convert.ToInt16(objDataReader["CreatedBy"]);
}
break;
case "CreatedDate":
if (!Convert.IsDBNull(objDataReader["CreatedDate"]))
{
objAccountHead.CreatedDate = Convert.ToDateTime(objDataReader["CreatedDate"].ToString());
}
break;
case "UpdatedBy":
if (!Convert.IsDBNull(objDataReader["UpdatedBy"]))
{
objAccountHead.UpdatedBy = Convert.ToInt16(objDataReader["UpdatedBy"].ToString());
}
break;
case "UpdatedDate":
if (!Convert.IsDBNull(objDataReader["UpdatedDate"]))
{
objAccountHead.UpdatedDate = Convert.ToDateTime(objDataReader["UpdatedDate"].ToString());
}
break;
case "SortedBy":
if (!Convert.IsDBNull(objDataReader["SortedBy"]))
{
objAccountHead.SortedBy = Convert.ToByte(objDataReader["SortedBy"].ToString());
}
break;
case "Remarks":
if (!Convert.IsDBNull(objDataReader["Remarks"]))
{
objAccountHead.Remarks = objDataReader["Remarks"].ToString();
}
break;
default:
break;
}
}
}
public static int DeleteAccountHead(AccountHead theAccountHead)
{
return(AccountHeadDataAccess.GetInstance.DeleteAccountHead(theAccountHead));
}
public static int InsertAccountHead(AccountHead theAccountHead)
{
return(AccountHeadDataAccess.GetInstance.InsertAccountHead(theAccountHead));
}
public int Update(AccountHead entity)
{
return(_accountHeadRepo.Update(entity));
}
public int Insert(AccountHead entity)
{
return(_accountHeadRepo.Insert(entity));
}
public ActionResult HeadName(int id)
{
AccountHead x = db.AccountHeads.Find(id);
return(PartialView(x));
}
public int InsertAccountHead(AccountHead theAccountHead)
{
return(AccountHeadIntegration.InsertAccountHead(theAccountHead));
}
private void UpdateAccountReport(Purchase purchase)
{
AccountHead accountHead = this.GetPurchaseAccountHead(purchase);
//this.accountReportService.QuickUpdate(purchase.ShopId, accountHead.Id, purchase.Created);
}
public int DeleteAccountHead(AccountHead theAccountHead)
{
return(AccountHeadIntegration.DeleteAccountHead(theAccountHead));
}
