public List <BusinessObject.Unit> GetActiveFilteredOrderedUnits()
{
try
{
using (var db = new ExpenseManagerDBEntities())
{
var myObjList = db.Units.Where(m => m.DepartmentId != 8).ToList();
var myBusinessObjList = new List <BusinessObject.Unit>();
if (!myObjList.Any())
{
return(myBusinessObjList);
}
//Re-Map each Entity Object to Business Object
foreach (var item in myObjList)
{
var myBusinessObj = DepartmentMapper.Map <Unit, BusinessObject.Unit>(item);
if (myBusinessObj == null)
{
continue;
}
myBusinessObjList.Add(myBusinessObj);
}
return(myBusinessObjList.OrderBy(m => m.Name).ToList());
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(new List <BusinessObject.Unit>());
}
}
public xPlug.BusinessObject.AssetType GetAssetType(int assetTypeId)
{
try
{
using (var db = new ExpenseManagerDBEntities())
{
var myObj = db.AssetTypes.SingleOrDefault(s => s.AssetTypeId == assetTypeId);
if (myObj == null)
{
return(new xPlug.BusinessObject.AssetType());
}
//Re-Map Entity Object to Business Object
var myBusinessObj = AssetTypeMapper.Map <AssetType, xPlug.BusinessObject.AssetType>(myObj);
if (myBusinessObj == null)
{
return(new xPlug.BusinessObject.AssetType());
}
{ return(myBusinessObj); }
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(new xPlug.BusinessObject.AssetType());
}
}
public int AddAssetType(xPlug.BusinessObject.AssetType assetType)
{
try
{
//Re-Map Object to Entity Object
var myEntityObj = AssetTypeMapper.Map <xPlug.BusinessObject.AssetType, AssetType>(assetType);
if (myEntityObj == null)
{
return(-2);
}
using (var db = new ExpenseManagerDBEntities())
{
if (db.AssetTypes.Any())
{
if (db.AssetTypes.Count(m => m.Name == myEntityObj.Name) > 0)
{
return(-3);
}
}
db.AddToAssetTypes(myEntityObj);
db.SaveChanges();
assetType.AssetTypeId = myEntityObj.AssetTypeId;
return(assetType.AssetTypeId);
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public bool DeleteTransactionAndItems(long expenseTransactionId)
{
try
{
using (var db = new ExpenseManagerDBEntities())
{
var myObj = db.TransactionItems.Where(s => s.TransactionItemId == expenseTransactionId).ToList();
if (!myObj.Any())
{
return(false);
}
foreach (var transactionItem in myObj)
{
db.TransactionItems.DeleteObject(transactionItem);
db.SaveChanges();
}
var transaction = db.ExpenseTransactions.Single(m => m.ExpenseTransactionId == expenseTransactionId);
db.ExpenseTransactions.DeleteObject(transaction);
db.SaveChanges();
return(true);
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(false);
}
}
public List <BusinessObject.TransactionItem> GetApprovedTransactionItemsByExpenseTransaction(long expenseTransactionId)
{
try
{
using (var db = new ExpenseManagerDBEntities())
{
var myObjList = db.TransactionItems.Where(m => m.ExpenseTransactionId == expenseTransactionId && m.ApprovedQuantity > 0 && m.ApprovedUnitPrice > 0 && m.ApprovedTotalPrice > 0).ToList();
var myBusinessObjList = new List <BusinessObject.TransactionItem>();
if (!myObjList.Any())
{
return(myBusinessObjList);
}
//Re-Map each Entity Object to Business Object
foreach (var item in myObjList)
{
var myBusinessObj = TransactionItemMapper.Map <TransactionItem, BusinessObject.TransactionItem>(item);
if (myBusinessObj == null)
{
continue;
}
myBusinessObj.TotalPrice = myBusinessObj.RequestedQuantity * myBusinessObj.RequestedUnitPrice;
myBusinessObjList.Add(myBusinessObj);
}
return(myBusinessObjList.OrderBy(m => m.ExpenseItem.Title).ToList());
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(new List <BusinessObject.TransactionItem>());
}
}
public int UpdateBeneficiaryTypeCheckDuplicate(BusinessObject.BeneficiaryType beneficiaryType)
{
try
{
//Re-Map Object to Entity Object
var myEntityObj = BeneficiaryTypeMapper.Map <BusinessObject.BeneficiaryType, BeneficiaryType>(beneficiaryType);
if (myEntityObj == null)
{
return(-2);
}
using (var db = new ExpenseManagerDBEntities())
{
if (db.BeneficiaryTypes.Any())
{
if (db.BeneficiaryTypes.Count(m => m.Name.ToLower().Replace(" ", string.Empty) == beneficiaryType.Name.ToLower().Replace(" ", string.Empty) && m.BeneficiaryTypeId != beneficiaryType.BeneficiaryTypeId) > 0)
{
return(-3);
}
}
db.BeneficiaryTypes.Attach(myEntityObj);
db.ObjectStateManager.ChangeObjectState(myEntityObj, EntityState.Modified);
db.SaveChanges();
return(1);
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public BusinessObject.ExpenseTransaction DeleteTransactionItemUpdateTotalAmount(int transactionItemId)
{
try
{
using (var db = new ExpenseManagerDBEntities())
{
var myObj = db.TransactionItems.Single(s => s.TransactionItemId == transactionItemId);
if (myObj == null)
{
return(new BusinessObject.ExpenseTransaction());
}
db.TransactionItems.DeleteObject(myObj);
db.SaveChanges();
var transactionAmount = db.TransactionItems.Where(m => m.ExpenseTransactionId == myObj.ExpenseTransactionId).Sum(m => m.RequestedQuantity * m.RequestedUnitPrice);
var transaction = db.ExpenseTransactions.Single(m => m.ExpenseTransactionId == myObj.ExpenseTransactionId);
transaction.TotalTransactionAmount = transactionAmount;
if (transaction.Status == 2)
{
transaction.Status = 0;
}
db.ObjectStateManager.ChangeObjectState(transaction, EntityState.Modified);
db.SaveChanges();
var myBusinessObj = ExpenseTransactionMapper.Map <ExpenseTransaction, BusinessObject.ExpenseTransaction>(transaction);
return(myBusinessObj);
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(new BusinessObject.ExpenseTransaction());
}
}
public int UpdateAccountsHead(BusinessObject.AccountsHead accountsHead)
{
try
{
//Re-Map Object to Entity Object
var myEntityObj = AccountsHeadMapper.Map <BusinessObject.AccountsHead, AccountsHead>(accountsHead);
if (myEntityObj == null)
{
return(-2);
}
using (var db = new ExpenseManagerDBEntities())
{
var objTitle = myEntityObj.Title.ToLower().Replace(" ", string.Empty.Trim());
if (db.AccountsHeads.Count(m => m.Title.ToLower().Replace(" ", string.Empty.Trim()) == objTitle && m.AccountsHeadId != myEntityObj.AccountsHeadId) > 0)
{
return(-3);
}
db.AccountsHeads.Attach(myEntityObj);
db.ObjectStateManager.ChangeObjectState(myEntityObj, EntityState.Modified);
db.SaveChanges();
return(accountsHead.AccountsHeadId);
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public xPlug.BusinessObject.Department GetDepartment(int departmentId)
{
try
{
using (var db = new ExpenseManagerDBEntities())
{
var myObj = db.Departments.SingleOrDefault(s => s.DepartmentId == departmentId);
if (myObj == null)
{
return(new xPlug.BusinessObject.Department());
}
//Re-Map Entity Object to Business Object
var myBusinessObj = DepartmentMapper.Map <Department, xPlug.BusinessObject.Department>(myObj);
if (myBusinessObj == null)
{
return(new xPlug.BusinessObject.Department());
}
{ return(myBusinessObj); }
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(new xPlug.BusinessObject.Department());
}
}
public BusinessObject.AccountsHead GetAccountsHead(int accountsHeadId)
{
try
{
using (var db = new ExpenseManagerDBEntities())
{
var myObj = db.AccountsHeads.SingleOrDefault(s => s.AccountsHeadId == accountsHeadId);
if (myObj == null)
{
return(new xPlug.BusinessObject.AccountsHead());
}
//Re-Map Entity Object to Business Object
var myBusinessObj = AccountsHeadMapper.Map <AccountsHead, xPlug.BusinessObject.AccountsHead>(myObj);
if (myBusinessObj == null)
{
return(new xPlug.BusinessObject.AccountsHead());
}
{ return(myBusinessObj); }
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(new xPlug.BusinessObject.AccountsHead());
}
}
public int AddAccountsHead(xPlug.BusinessObject.AccountsHead accountsHead)
{
try
{
//Re-Map Object to Entity Object
var myEntityObj = AccountsHeadMapper.Map <xPlug.BusinessObject.AccountsHead, AccountsHead>(accountsHead);
if (myEntityObj == null)
{
return(-2);
}
using (var db = new ExpenseManagerDBEntities())
{
if (db.AccountsHeads.Any())
{
var objTitle = myEntityObj.Title.ToLower().Replace(" ", string.Empty.Trim());
if (db.AccountsHeads.Count(m => m.Title.ToLower().Replace(" ", string.Empty.Trim()) == objTitle) > 0)
{
return(-3);
}
}
db.AddToAccountsHeads(myEntityObj);
db.SaveChanges();
accountsHead.AccountsHeadId = myEntityObj.AccountsHeadId;
return(accountsHead.AccountsHeadId);
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public List <BusinessObject.Beneficiary> GetBeneficiariesWithApprovedUnpaidTransactions()
{
try
{
using (var db = new ExpenseManagerDBEntities())
{
var myObjList =
db.Beneficiaries.Where(m => m.Status == 1).SelectMany(
x => x.ExpenseTransactions.Where(m => m.BeneficiaryId == x.BeneficiaryId && m.Status == 1),
(x, y) => new { x, y }).SelectMany(
@t =>
@t.y.ExpenseTransactionPaymentHistories.Where(
m => m.ExpenseTransactionId != @t.y.ExpenseTransactionId), (@t, z) => @t.x);
var myBusinessObjList = new List <BusinessObject.Beneficiary>();
if (!myObjList.Any())
{
return(myBusinessObjList);
}
//Re-Map each Entity Object to Business Object
myBusinessObjList.AddRange(myObjList.Select(item => BeneficiaryMapper.Map <Beneficiary, BusinessObject.Beneficiary>(item)).Where(myBusinessObj => myBusinessObj != null));
return(myBusinessObjList.OrderBy(m => m.FullName).ToList());
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(new List <BusinessObject.Beneficiary>());
}
}
public BusinessObject.AccountsHead GetLastInsertedAccountsHeadsByExpenseCategoryId(int expenseCategoryId)
{
try
{
using (var db = new ExpenseManagerDBEntities())
{
var myObjList = db.AccountsHeads.ToList().FindAll(m => m.ExpenseCategoryId == expenseCategoryId);
var myBusinessObjList = new List <BusinessObject.AccountsHead>();
if (!myObjList.Any())
{
return(new BusinessObject.AccountsHead());
}
//Re-Map each Entity Object to Business Object
foreach (var item in myObjList)
{
var myBusinessObj = AccountsHeadMapper.Map <AccountsHead, BusinessObject.AccountsHead>(item);
if (myBusinessObj == null)
{
continue;
}
myBusinessObjList.Add(myBusinessObj);
}
var obj = myBusinessObjList.OrderByDescending(m => long.Parse(m.Code)).ElementAt(0);
return(obj);
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(new BusinessObject.AccountsHead());
}
}
public xPlug.BusinessObject.PaymentVoucherNumber GetPaymentVoucherNumber(int paymentVoucherNumberId)
{
try
{
using (var db = new ExpenseManagerDBEntities())
{
var myObj = db.PaymentVoucherNumbers.SingleOrDefault(s => s.PaymentVoucherNumberId == paymentVoucherNumberId);
if (myObj == null)
{
return(new xPlug.BusinessObject.PaymentVoucherNumber());
}
//Re-Map Entity Object to Business Object
var myBusinessObj = PaymentVoucherNumberMapper.Map <PaymentVoucherNumber, xPlug.BusinessObject.PaymentVoucherNumber>(myObj);
if (myBusinessObj == null)
{
return(new xPlug.BusinessObject.PaymentVoucherNumber());
}
{ return(myBusinessObj); }
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(new xPlug.BusinessObject.PaymentVoucherNumber());
}
}
public bool DeleteExpenseItemCheckReference(int expenseItemId)
{
try
{
using (var db = new ExpenseManagerDBEntities())
{
if (db.TransactionItems.Any(m => m.ExpensenseItemId == expenseItemId))
{
return(false);
}
var myObj = db.ExpenseItems.Single(s => s.ExpenseItemId == expenseItemId);
if (myObj == null)
{
return(false);
}
;
db.ExpenseItems.DeleteObject(myObj);
db.SaveChanges();
return(true);
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(false);
}
}
public List <xPlug.BusinessObject.TransactionItem> GetTransactionItemsByExpenseTypeId(Int32 expenseTypeId)
{
try
{
using (var db = new ExpenseManagerDBEntities())
{
var myObjList = db.TransactionItems.ToList().FindAll(m => m.ExpenseTypeId == expenseTypeId);
var myBusinessObjList = new List <xPlug.BusinessObject.TransactionItem>();
if (myObjList == null)
{
return(myBusinessObjList);
}
//Re-Map each Entity Object to Business Object
foreach (var item in myObjList)
{
var myBusinessObj = TransactionItemMapper.Map <TransactionItem, xPlug.BusinessObject.TransactionItem>(item);
if (myBusinessObj == null)
{
continue;
}
myBusinessObjList.Add(myBusinessObj);
}
return(myBusinessObjList);
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(new List <xPlug.BusinessObject.TransactionItem>());
}
}
public BusinessObject.StaffUser GetStaffUserByMembershipId(int membershipIdId)
{
try
{
using (var db = new ExpenseManagerDBEntities())
{
var myObj = db.StaffUsers.Where(s => s.PortalUserId == membershipIdId).ToList();
if (!myObj.Any())
{
return(new BusinessObject.StaffUser());
}
//Re-Map Entity Object to Business Object
var myBusinessObj = StaffUserMapper.Map <StaffUser, BusinessObject.StaffUser>(myObj.ElementAt(0));
if (myBusinessObj == null)
{
return(new BusinessObject.StaffUser());
}
{ return(myBusinessObj); }
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(new BusinessObject.StaffUser());
}
}
public xPlug.BusinessObject.TransactionItem GetTransactionItem(int transactionItemId)
{
try
{
using (var db = new ExpenseManagerDBEntities())
{
var myObj = db.TransactionItems.SingleOrDefault(s => s.TransactionItemId == transactionItemId);
if (myObj == null)
{
return(new xPlug.BusinessObject.TransactionItem());
}
//Re-Map Entity Object to Business Object
var myBusinessObj = TransactionItemMapper.Map <TransactionItem, xPlug.BusinessObject.TransactionItem>(myObj);
if (myBusinessObj == null)
{
return(new xPlug.BusinessObject.TransactionItem());
}
{ return(myBusinessObj); }
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(new xPlug.BusinessObject.TransactionItem());
}
}
public List <BusinessObject.BeneficiaryType> GetActiveBeneficiaryTypes()
{
try
{
using (var db = new ExpenseManagerDBEntities())
{
var myObjList = db.BeneficiaryTypes.Where(m => m.Status == 1).ToList();
var myBusinessObjList = new List <BusinessObject.BeneficiaryType>();
if (!myObjList.Any())
{
return(myBusinessObjList);
}
//Re-Map each Entity Object to Business Object
foreach (var item in myObjList)
{
var myBusinessObj = BeneficiaryTypeMapper.Map <BeneficiaryType, BusinessObject.BeneficiaryType>(item);
if (myBusinessObj == null)
{
continue;
}
myBusinessObjList.Add(myBusinessObj);
}
return(myBusinessObjList.OrderBy(m => m.Name).ToList());
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(new List <BusinessObject.BeneficiaryType>());
}
}
public xPlug.BusinessObject.ExpenseCategory GetExpenseCategory(int expenseCategoryId)
{
try
{
using (var db = new ExpenseManagerDBEntities())
{
var myObj = db.ExpenseCategories.SingleOrDefault(s => s.ExpenseCategoryId == expenseCategoryId);
if (myObj == null)
{
return(new xPlug.BusinessObject.ExpenseCategory());
}
//Re-Map Entity Object to Business Object
var myBusinessObj = ExpenseCategoryMapper.Map <ExpenseCategory, xPlug.BusinessObject.ExpenseCategory>(myObj);
if (myBusinessObj == null)
{
return(new xPlug.BusinessObject.ExpenseCategory());
}
{ return(myBusinessObj); }
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(new xPlug.BusinessObject.ExpenseCategory());
}
}
public bool DeleteTransactionAndItem(int transactionItemId)
{
try
{
using (var db = new ExpenseManagerDBEntities())
{
var myObj = db.TransactionItems.Single(s => s.TransactionItemId == transactionItemId);
if (myObj == null)
{
return(false);
}
db.TransactionItems.DeleteObject(myObj);
db.SaveChanges();
var transaction = db.ExpenseTransactions.Single(m => m.ExpenseTransactionId == myObj.ExpenseTransactionId);
db.ExpenseTransactions.DeleteObject(transaction);
db.SaveChanges();
return(true);
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(false);
}
}
public List <xPlug.BusinessObject.ExpenseCategory> GetExpenseCategories()
{
try
{
using (var db = new ExpenseManagerDBEntities())
{
var myObjList = db.ExpenseCategories.ToList();
var myBusinessObjList = new List <xPlug.BusinessObject.ExpenseCategory>();
if (myObjList == null)
{
return(myBusinessObjList);
}
//Re-Map each Entity Object to Business Object
foreach (var item in myObjList)
{
var myBusinessObj = ExpenseCategoryMapper.Map <ExpenseCategory, xPlug.BusinessObject.ExpenseCategory>(item);
if (myBusinessObj == null)
{
continue;
}
myBusinessObjList.Add(myBusinessObj);
}
return(myBusinessObjList);
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(new List <xPlug.BusinessObject.ExpenseCategory>());
}
}
public BusinessObject.ExpenseTransaction UpdateTransactionItemAndApprovedTotalAmount(BusinessObject.TransactionItem transactionItem)
{
try
{
//Re-Map Object to Entity Object
var myEntityObj = TransactionItemMapper.Map <BusinessObject.TransactionItem, TransactionItem>(transactionItem);
if (myEntityObj == null)
{
return(new BusinessObject.ExpenseTransaction());
}
using (var db = new ExpenseManagerDBEntities())
{
db.TransactionItems.Attach(myEntityObj);
db.ObjectStateManager.ChangeObjectState(myEntityObj, EntityState.Modified);
db.SaveChanges();
var transactionAmount = db.TransactionItems.Where(m => m.ExpenseTransactionId == myEntityObj.ExpenseTransactionId).Sum(m => m.RequestedQuantity * m.RequestedUnitPrice);
var transaction = db.ExpenseTransactions.Single(m => m.ExpenseTransactionId == myEntityObj.ExpenseTransactionId);
transaction.TotalTransactionAmount = transactionAmount;
db.ExpenseTransactions.Attach(transaction);
db.ObjectStateManager.ChangeObjectState(myEntityObj, EntityState.Modified);
db.SaveChanges();
var myBusinessObj = ExpenseTransactionMapper.Map <ExpenseTransaction, BusinessObject.ExpenseTransaction>(transaction);
return(myBusinessObj);
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(new BusinessObject.ExpenseTransaction());
}
}
public int AddExpenseItemCheckDuplicate(BusinessObject.ExpenseItem expenseItem)
{
try
{
//Re-Map Object to Entity Object
var myEntityObj = ExpenseItemMapper.Map <xPlug.BusinessObject.ExpenseItem, ExpenseItem>(expenseItem);
if (myEntityObj == null)
{
return(-2);
}
using (var db = new ExpenseManagerDBEntities())
{
if (db.ExpenseItems.Count(m => m.Title.ToLower().Replace(" ", string.Empty) == expenseItem.Title.ToLower().Replace(" ", string.Empty)) > 0)
{
return(-3);
}
db.AddToExpenseItems(myEntityObj);
db.SaveChanges();
expenseItem.ExpenseItemId = myEntityObj.ExpenseItemId;
return(expenseItem.ExpenseItemId);
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public bool UpdatePendingTransactionAndItem(BusinessObject.ExpenseTransaction transaction, BusinessObject.TransactionItem updatedTransactionItem)
{
try
{
//Re-Map Object to Entity Object
using (var db = new ExpenseManagerDBEntities())
{
var myEntityObj = TransactionItemMapper.Map <BusinessObject.TransactionItem, TransactionItem>(updatedTransactionItem);
if (myEntityObj == null)
{
return(false);
}
db.TransactionItems.Attach(myEntityObj);
db.ObjectStateManager.ChangeObjectState(myEntityObj, EntityState.Modified);
db.SaveChanges();
var totalPrice = db.TransactionItems.Where(x => x.ExpenseTransactionId == transaction.ExpenseTransactionId).ToList().Sum(m => m.RequestedQuantity * m.RequestedUnitPrice);
transaction.TotalTransactionAmount = totalPrice;
var transactionEntityToUpdate = ExpenseTransactionMapper.Map <BusinessObject.ExpenseTransaction, ExpenseTransaction>(transaction);
db.ExpenseTransactions.Attach(transactionEntityToUpdate);
db.ObjectStateManager.ChangeObjectState(transactionEntityToUpdate, EntityState.Modified);
db.SaveChanges();
}
return(true);
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(false);
}
}
public List <BusinessObject.ExpenseItem> GetOrderedExpenseItemsByAccountsHeadId(Int32 accountsHeadId)
{
try
{
using (var db = new ExpenseManagerDBEntities())
{
var myObjList = db.ExpenseItems.Where(m => m.AccountsHeadId == accountsHeadId).ToList();
var myBusinessObjList = new List <BusinessObject.ExpenseItem>();
if (!myObjList.Any())
{
return(myBusinessObjList);
}
//Re-Map each Entity Object to Business Object
foreach (var item in myObjList)
{
var myBusinessObj = ExpenseItemMapper.Map <ExpenseItem, BusinessObject.ExpenseItem>(item);
if (myBusinessObj == null)
{
continue;
}
myBusinessObjList.Add(myBusinessObj);
}
return(myBusinessObjList.OrderBy(m => m.AccountsHead.Title).ThenBy(m => m.Title).ToList());
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(new List <BusinessObject.ExpenseItem>());
}
}
public List <xPlug.BusinessObject.AssetType> GetAssetTypesByAssetCategoryId(Int32 assetCategoryId)
{
try
{
using (var db = new ExpenseManagerDBEntities())
{
var myObjList = db.AssetTypes.ToList().FindAll(m => m.AssetCategoryId == assetCategoryId);
var myBusinessObjList = new List <xPlug.BusinessObject.AssetType>();
if (myObjList == null)
{
return(myBusinessObjList);
}
//Re-Map each Entity Object to Business Object
foreach (var item in myObjList)
{
var myBusinessObj = AssetTypeMapper.Map <AssetType, xPlug.BusinessObject.AssetType>(item);
if (myBusinessObj == null)
{
continue;
}
myBusinessObjList.Add(myBusinessObj);
}
return(myBusinessObjList);
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(new List <xPlug.BusinessObject.AssetType>());
}
}
public int UpdateExpenseItemCheckDuplicate(BusinessObject.ExpenseItem expenseItem)
{
try
{
//Re-Map Object to Entity Object
var myEntityObj = ExpenseItemMapper.Map <BusinessObject.ExpenseItem, ExpenseItem>(expenseItem);
if (myEntityObj == null)
{
return(-2);
}
using (var db = new ExpenseManagerDBEntities())
{
if (db.ExpenseItems.Count(m => m.Title.ToLower().Replace(" ", string.Empty) == expenseItem.Title.ToLower().Replace(" ", string.Empty) && m.ExpenseItemId != expenseItem.ExpenseItemId) > 0)
{
return(-3);
}
db.ExpenseItems.Attach(myEntityObj);
db.ObjectStateManager.ChangeObjectState(myEntityObj, EntityState.Modified);
db.SaveChanges();
return(1);
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public int UpdateAssetType(xPlug.BusinessObject.AssetType assetType)
{
try
{
//Re-Map Object to Entity Object
var myEntityObj = AssetTypeMapper.Map <xPlug.BusinessObject.AssetType, AssetType>(assetType);
if (myEntityObj == null)
{
return(12);
}
using (var db = new ExpenseManagerDBEntities())
{
if (db.AssetTypes.Any())
{
if (db.AssetTypes.Count(m => m.Name == myEntityObj.Name && m.AssetTypeId != myEntityObj.AssetTypeId) > 0)
{
return(-3);
}
}
db.AssetTypes.Attach(myEntityObj);
db.ObjectStateManager.ChangeObjectState(myEntityObj, EntityState.Modified);
db.SaveChanges();
return(1);
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
public int AddUnitCheckDuplicate(BusinessObject.Unit unit)
{
try
{
//Re-Map Object to Entity Object
var myEntityObj = UnitMapper.Map <BusinessObject.Unit, Unit>(unit);
if (myEntityObj == null)
{
return(0);
}
using (var db = new ExpenseManagerDBEntities())
{
if (db.Units.Count(m => m.Name.ToLower().Replace(" ", string.Empty) == myEntityObj.Name.ToLower().Replace(" ", string.Empty)) > 0)
{
return(-3);
}
db.AddToUnits(myEntityObj);
db.SaveChanges();
unit.UnitId = myEntityObj.UnitId;
return(unit.UnitId);
}
}
catch (Exception ex)
{
ErrorManager.LogApplicationError(ex.StackTrace, ex.Source, ex.Message);
return(0);
}
}
