/// <summary>
/// Get Project/Division AccessList By UserId
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <List <ProjectAccessListUnitDto> > GetProjectAccessList(GetUserSecuritySettingsInputUnit input)
{
List <DivisionCacheItem> divisionCacheItems = new List <DivisionCacheItem>();
AutoSearchInput cacheInput = new AutoSearchInput()
{
OrganizationUnitId = input.OrganizationUnitId
};
var divisionCache = await _divisionCache.GetDivisionCacheItemAsync(
CacheKeyStores.CalculateCacheKey(CacheKeyStores.DivisionKey, Convert.ToInt32(_customAppSession.TenantId)));
var user = await _userManager.GetUserByIdAsync(input.UserId);
var organizationUnits = await _organizationExtendedUnitManager.GetExtendedOrganizationUnitsAsync(user, input.EntityClassificationId);
var organizationUnitIds = organizationUnits.Select(ou => ou.Id);
var strOrgIds = string.Join(",", organizationUnitIds.ToArray());
if (!string.IsNullOrEmpty(strOrgIds))
{
if (ReferenceEquals(input.Filters, null))
{
input.Filters = new List <Filters>();
}
var orgfilter = new Filters()
{
Property = "OrganizationUnitId",
Comparator = 6,//In Operator
SearchTerm = strOrgIds,
DataType = DataTypes.Text
};
input.Filters.Add(orgfilter);
}
if (!ReferenceEquals(input.Filters, null))
{
Func <DivisionCacheItem, bool> multiRangeExp = null;
var multiRangeFilters = input.Filters.Where(u => u.IsMultiRange == true).ToList();
if (multiRangeFilters.Count != 0)
{
multiRangeExp = ExpressionBuilder.GetExpression <DivisionCacheItem>(Helper.GetMultiRangeFilters(multiRangeFilters), SearchPattern.Or).Compile();
input.Filters.RemoveAll(u => u.IsMultiRange == true);
}
var filterCondition = ExpressionBuilder.GetExpression <DivisionCacheItem>(input.Filters).Compile();
divisionCacheItems = divisionCache.ToList()
.WhereIf(multiRangeFilters.Count != 0, multiRangeExp)
.Where(filterCondition).ToList();
}
return(divisionCacheItems.Select(item =>
{
var dto = new ProjectAccessListUnitDto();
dto.JobNumber = item.JobNumber;
dto.Caption = item.Caption;
dto.OrganizationUnitId = item.OrganizationUnitId;
dto.JobId = item.JobId;
return dto;
}).ToList());
}
/// <summary>
/// Get Bank Accounts List which is not in BankAccountsAccessList
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <List <BankAccountAccessListUnitDto> > GetBankAccountList(GetUserSecuritySettingsInputUnit input)
{
List <BankAccountCacheItem> bankAccountCacheItems;
AutoSearchInput cacheInput = new AutoSearchInput()
{
OrganizationUnitId = input.OrganizationUnitId
};
var values = Enum.GetValues(typeof(TypeOfBankAccount)).Cast <TypeOfBankAccount>().Select(x => x)
.ToDictionary(u => u.ToDescription(), u => (int)u).Where(u => u.Value >= 1 && u.Value <= 10)
.Select(u => u.Key).ToArray();
var strTypeOfbankAccount = string.Join(",", values);
var user = await _userManager.GetUserByIdAsync(input.UserId);
var organizationUnits = await _organizationExtendedUnitManager.GetExtendedOrganizationUnitsAsync(user, input.EntityClassificationId);
var bankAccountCache = await _bankAccountCache.GetBankAccountCacheItemAsync(
CacheKeyStores.CalculateCacheKey(CacheKeyStores.BankAccountKey, Convert.ToInt32(_customAppSession.TenantId)));
if (!ReferenceEquals(input.Filters, null))
{
Func <BankAccountCacheItem, bool> multiRangeExp = null;
Func <BankAccountCacheItem, bool> filterCondition = null;
var multiRangeFilters = input.Filters.Where(u => u.IsMultiRange == true).ToList();
if (multiRangeFilters.Count != 0)
{
multiRangeExp = ExpressionBuilder.GetExpression <BankAccountCacheItem>(Helper.GetMultiRangeFilters(multiRangeFilters), SearchPattern.Or).Compile();
input.Filters.RemoveAll(u => u.IsMultiRange == true);
}
var otherFilters = input.Filters.Where(u => u.IsMultiRange == false).ToList();
if (otherFilters.Count != 0)
{
filterCondition = ExpressionBuilder.GetExpression <BankAccountCacheItem>(otherFilters).Compile();
}
bankAccountCacheItems = bankAccountCache.ToList().Where(u => strTypeOfbankAccount.Contains(u.TypeOfBankAccountId.ToString()))
.WhereIf(multiRangeFilters.Count != 0, multiRangeExp)
.WhereIf(otherFilters.Count != 0, filterCondition)
.Where(p => !organizationUnits.Any(p2 => p2.Id == p.OrganizationUnitId)).ToList();
}
else
{
bankAccountCacheItems = bankAccountCache.ToList()
.Where(p => !organizationUnits.Any(p2 => p2.Id == p.OrganizationUnitId)).ToList();
}
return(bankAccountCacheItems.Select(item =>
{
var dto = new BankAccountAccessListUnitDto();
dto.BankAccountNumber = item.BankAccountNumber;
dto.BankName = item.Description;
dto.AccountName = item.BankAccountName;
dto.OrganizationUnitId = item.OrganizationUnitId;
dto.BankAccountId = item.BankAccountId;
return dto;
}).ToList());
}
/// <summary>
/// Get CardHolder Information
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <List <AutoFillDto> > GetCardInfoList(AutoSearchInput input)
{
var cardLength = 0;
var cardHolderList = await _bankAccountUnitRepository.GetAll()
.WhereIf(!string.IsNullOrEmpty(input.Query),
p => p.Description.Contains(input.Query) || p.Description.Contains(input.Query))
.Where(p => p.IsClosed == false)
.ToListAsync();
var cardHolders = cardHolderList.
Select(item =>
{
cardLength = item.CCFullAccountNO.Length;
var dto = new AutoFillDto
{
Name = item.BankAccountName,
Value = item.Id.ToString(),
Column1 = item.TypeOfBankAccountId.ToDisplayName(),
Column2 = !string.IsNullOrEmpty(item.BankAccountNumber) ? item.BankAccountNumber.Substring(cardLength - 5, cardLength) : ""
};
return(dto);
}).ToList();
return(cardHolders);
}
/// <summary>
/// Get SubAccounts List based on OrganizationUnitId
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <List <SubAccountCacheItem> > GetSubAccountList(AutoSearchInput input)
{
var cacheItem = await _subAccountCache.GetSubAccountCacheItemAsync(
CacheKeyStores.CalculateCacheKey(CacheKeyStores.SubAccountKey, Convert.ToInt32(_customAppSession.TenantId)));
var subaccountRestrictioncacheItem = await _subAccountRestrictionCache.GetSubAccountRestrictionCacheItemAsync(
CacheKeyStores.CalculateCacheKey(CacheKeyStores.SubAccountRestrictionKey, Convert.ToInt32(_customAppSession.TenantId)));
if (input.AccountId == 0 || subaccountRestrictioncacheItem.Count == 0)
{
return
(cacheItem.ToList()
.WhereIf(!string.IsNullOrEmpty(input.Query),
p => p.Caption.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper()) ||
p.Description.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper()) ||
p.SubAccountNumber.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper()) ||
p.SearchNo.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper())).ToList());
}
else
{
var res = from subaccount in cacheItem.ToList()
join subAccountRestriction in subaccountRestrictioncacheItem.Where(p => p.AccountId == input.AccountId)
on subaccount.SubAccountId equals subAccountRestriction.SubAccountId
select subaccount;
return(res.ToList().WhereIf(!string.IsNullOrEmpty(input.Query),
p => p.Caption.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper()) ||
p.Description.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper()) ||
p.SubAccountNumber.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper()) ||
p.SearchNo.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper())).ToList());
}
}
/// <summary>
/// Get BankAccountList
/// </summary>
/// <returns></returns>
public async Task <List <BankAccountCacheItem> > GetBankAccountList(AutoSearchInput input)
{
var bankCacheItemList = await _bankAccountCache.GetBankAccountCacheItemAsync(CacheKeyStores.CalculateCacheKey(CacheKeyStores.BankAccountKey, Convert.ToInt32(_customAppSession.TenantId)));
return(bankCacheItemList.WhereIf(!string.IsNullOrEmpty(input.Query), p => p.Description.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper()) ||
p.BankAccountName.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper()) ||
p.BankAccountNumber.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper())).ToList());
}
/// <summary>
/// Get PositivePayList
/// </summary>
/// <returns></returns>
public async Task <List <NameValueDto> > GetPositivePayList(AutoSearchInput input)
{
return(await(from uploadtype in _typeOfUploadFileUnitRepository.GetAll().Where(p => p.TypeofUploadId == TyeofUpload.PositivePayFile)
.WhereIf(!string.IsNullOrEmpty(input.Query), p => p.Description.Contains(input.Query) || p.Notes.Contains(input.Query))
select new NameValueDto {
Name = uploadtype.Description, Value = uploadtype.Id.ToString()
}).ToListAsync());
}
/// <summary>
/// Get CheckStockList
/// </summary>
/// <returns></returns>
public async Task <List <NameValueDto> > GetCheckStockList(AutoSearchInput input)
{
return(await(from checkstock in _typeOfCheckStockUnitRepository.GetAll()
.WhereIf(!string.IsNullOrEmpty(input.Query), p => p.Description.Contains(input.Query) || p.Notes.Contains(input.Query))
select new NameValueDto {
Name = checkstock.Description, Value = checkstock.Id.ToString()
}).ToListAsync());
}
/// <summary>
/// Get Accounts List By CoaId for autofills
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <List <AccountCacheItem> > GetAccountListByCoaId(AutoSearchInput input)
{
var accountList = await _accountcache.GetAccountCacheItemAsync(
CacheKeyStores.CalculateCacheKey(CacheKeyStores.AccountKey, Convert.ToInt32(_customAppSession.TenantId)));
return(accountList.ToList().WhereIf(!string.IsNullOrEmpty(input.Query),
p => p.Caption.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper()) || p.AccountNumber.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper()) ||
p.Description.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper())).Where(p => p.ChartOfAccountId == input.Id).ToList());
}
/// <summary>
/// Get Customers
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <List <CustomerCacheItem> > GetCustomersList(AutoSearchInput input)
{
var customerList = await _customercache.GetCustomersCacheItemAsync(
CacheKeyStores.CalculateCacheKey(CacheKeyStores.CustomerKey, Convert.ToInt32(_customAppSession.TenantId)));
return(customerList.ToList().WhereIf(!string.IsNullOrEmpty(input.Query),
p => p.LastName.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper()) || p.FirstName.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper()) ||
p.CustomerNumber.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper())).ToList());
}
/// <summary>
/// Get DivisionsList
/// </summary>
/// <returns></returns>
public async Task <List <DivisionCacheItem> > GetDivisionList(AutoSearchInput input)
{
var cacheItem = await _divisioncache.GetDivisionCacheItemAsync(
CacheKeyStores.CalculateCacheKey(CacheKeyStores.DivisionKey, Convert.ToInt32(_customAppSession.TenantId)));
return(cacheItem.ToList().Where(p => p.IsDivision == true)
.WhereIf(!string.IsNullOrEmpty(input.Query), p => p.JobNumber.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper()) ||
p.Caption.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper())).ToList());
}
/// <summary>
/// Get TaxCreditList
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <List <AutoFillDto> > GetTaxCreditList(AutoSearchInput input)
{
var taxCreditList = await _taxCreditUnitRepository.GetAll()
.WhereIf(!string.IsNullOrEmpty(input.Query), p => p.Description.Contains(input.Query) || p.Number.Contains(input.Query))
.Select(u => new AutoFillDto {
Name = u.Description, Value = u.Id.ToString(), Column1 = u.Number
}).OrderBy(p => p.Name).ToListAsync();
return(taxCreditList);
}
/// <summary>
/// Get VendorPaymentTermsList
/// </summary>
/// <returns></returns>
public async Task <List <NameValueDto> > GetVendorPaymentTermsList(AutoSearchInput input)
{
var paymentTermsList = await _vendorPaymentTermUnitRepository.GetAll().WhereIf(!ReferenceEquals(input.OrganizationUnitId, null), p => p.OrganizationUnitId == input.OrganizationUnitId)
.WhereIf(!string.IsNullOrEmpty(input.Query), p => p.Description.Contains(input.Query))
.Select(u => new NameValueDto {
Name = u.Description, Value = u.Id.ToString()
}).ToListAsync();
return(paymentTermsList);
}
/// <summary>
/// get Credit Card File Upload Types
/// </summary>
/// <returns></returns>
public async Task <List <NameValueDto> > FileUploadCRDRList(AutoSearchInput input)
{
var uploadFilesList = await _typeOfUploadFileUnitRepository.GetAll().Where(u => u.Id >= 10 && u.Id <= 25)
.WhereIf(!string.IsNullOrEmpty(input.Query), p => p.Description.Contains(input.Query))
.Select(u => new NameValueDto {
Name = u.Description, Value = u.Id.ToString()
}).ToListAsync();
return(uploadFilesList);
}
/// <summary>
/// Get SalesRep as list
/// </summary>
/// <returns></returns>
public async Task <List <NameValueDto> > GetSalesRepList(AutoSearchInput input)
{
var salesRepList = await _salesRepRepository.GetAll()
.WhereIf(!string.IsNullOrEmpty(input.Query), p => p.LastName.Contains(input.Query))
.Select(u => new NameValueDto {
Name = u.LastName, Value = u.Id.ToString()
}).OrderBy(p => p.Name).ToListAsync();
return(salesRepList);
}
/// <summary>
/// Get Customer Payment Terms
/// </summary>
/// <returns></returns>
public async Task <List <NameValueDto> > GetCustomerPaymentTermsList(AutoSearchInput input)
{
var customerPaymentTermList = await _customerPaymentTermRepository.GetAll()
.WhereIf(!string.IsNullOrEmpty(input.Query), p => p.Description.Contains(input.Query))
.Select(u => new NameValueDto {
Name = u.Description, Value = u.Id.ToString()
}).OrderBy(p => p.Name).ToListAsync();
return(customerPaymentTermList);
}
public async Task <List <NameValueDto> > GetProjectCoaList(AutoSearchInput input)
{
var divisions = await _coaUnitRepository.GetAll().Where(p => p.IsCorporate == false)
.WhereIf(!string.IsNullOrEmpty(input.Query), p => p.Caption.Contains(input.Query))
.Select(u => new NameValueDto {
Name = u.Caption, Value = u.Id.ToString()
}).ToListAsync();
return(divisions);
}
/// <summary>
/// Get GetArBillingTypeList
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <List <NameValueDto> > GetBillingTypeList(AutoSearchInput input)
{
var billingTypeList = await _aRBillingTypeUnitRepository.GetAll()
.WhereIf(!string.IsNullOrEmpty(input.Query), p => p.Description.Contains(input.Query))
.Select(u => new NameValueDto {
Name = u.Description, Value = u.Id.ToString()
}).ToListAsync();
return(billingTypeList);
}
/// <summary>
/// Get Payroll Vendors
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <List <VendorCacheItem> > GetPayRollVendorList(AutoSearchInput input)
{
var vendorCacheItemList = await _vendorCache.GetVendorsCacheItemAsync(CacheKeyStores.CalculateCacheKey(CacheKeyStores.VendorKey,
Convert.ToInt32(_customAppSession.TenantId)));
return(vendorCacheItemList.ToList().Where(p => p.TypeofVendorId == TypeofVendor.PayrollCompany)
.WhereIf(!string.IsNullOrEmpty(input.Query), p => p.LastName.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper()) ||
p.FirstName.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper()) ||
p.VendorAccountInfo.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper()) ||
p.VendorNumber.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper())).ToList());
}
/// <summary>
/// Get Accounts/Lines List which is not in AccountAccessList
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <List <AccountAccessListUnitDto> > GetAccountList(GetUserSecuritySettingsInputUnit input)
{
List <AccountCacheItem> accountCacheItems = new List <AccountCacheItem>();
AutoSearchInput cacheInput = new AutoSearchInput()
{
OrganizationUnitId = input.OrganizationUnitId
};
var user = await _userManager.GetUserByIdAsync(input.UserId);
var organizationUnits = await _organizationExtendedUnitManager.GetExtendedOrganizationUnitsAsync(user, input.EntityClassificationId);
var accountCache = await _accountCache.GetAccountCacheItemAsync(
CacheKeyStores.CalculateCacheKey(CacheKeyStores.AccountKey, Convert.ToInt32(_customAppSession.TenantId)));
if (!ReferenceEquals(input.Filters, null))
{
Func <AccountCacheItem, bool> multiRangeExp = null;
Func <AccountCacheItem, bool> filterCondition = null;
var multiRangeFilters = input.Filters.Where(u => u.IsMultiRange == true).ToList();
if (multiRangeFilters.Count != 0)
{
multiRangeExp = ExpressionBuilder.GetExpression <AccountCacheItem>(Helper.GetMultiRangeFilters(multiRangeFilters), SearchPattern.Or).Compile();
input.Filters.RemoveAll(u => u.IsMultiRange == true);
}
var otherFilters = input.Filters.Where(u => u.IsMultiRange == false).ToList();
if (otherFilters.Count != 0)
{
filterCondition = ExpressionBuilder.GetExpression <AccountCacheItem>(otherFilters).Compile();
}
accountCacheItems = accountCache.ToList()
.Where(u => u.ChartOfAccountId == input.ChartOfAccountId)
.WhereIf(multiRangeFilters.Count != 0, multiRangeExp)
.WhereIf(otherFilters.Count != 0, filterCondition)
.Where(p => !organizationUnits.Any(p2 => p2.Id == p.OrganizationUnitId)).ToList();
}
else
{
accountCacheItems = accountCache.ToList().Where(u => u.ChartOfAccountId == input.ChartOfAccountId)
.Where(p => !organizationUnits.Any(p2 => p2.Id == p.OrganizationUnitId)).ToList();
}
return(accountCacheItems.Select(item =>
{
var dto = new AccountAccessListUnitDto();
dto.AccountId = item.AccountId;
dto.AccountNumber = item.AccountNumber;
dto.Caption = item.Caption;
dto.OrganizationUnitId = item.OrganizationUnitId;
return dto;
}).ToList());
}
/// <summary>
/// Get All Locations List
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <List <NameValueDto> > GetLocationList(AutoSearchInput input)
{
var locationSets = await _subAccountUnitRepository.GetAll().OrderBy(p => p.Description)
.Where(p => p.TypeofSubAccountId == TypeofSubAccount.Locations || p.TypeofSubAccountId == TypeofSubAccount.Sets)
.WhereIf(!ReferenceEquals(input.OrganizationUnitId, null), p => p.OrganizationUnitId == input.OrganizationUnitId)
.WhereIf(!string.IsNullOrEmpty(input.Query), p => p.Description.Contains(input.Query))
.Select(u => new NameValueDto {
Name = u.Description, Value = u.Id.ToString()
}).ToListAsync();
return(locationSets);
}
/// <summary>
/// Get TypeOfAccountClassification List
/// </summary>
/// <returns></returns>
public async Task <List <NameValueDto> > GetTypeOfAccountClassificationList(AutoSearchInput input)
{
var accountClassificationList = await _typeOfAccountClassificationUnitRepository.GetAll()
.WhereIf(!string.IsNullOrEmpty(input.Query), p => p.Description.Contains(input.Query))
.Select(u => new NameValueDto {
Name = u.Description, Value = u.Id.ToString()
})
.OrderBy(u => u.Name)
.ToListAsync();
return(accountClassificationList);
}
/// <summary>
/// Get AccountType as Bank of all Corporate AccountList
/// </summary>
/// <returns></returns>
public async Task <List <AccountCacheItem> > GetCorporateAccountList(AutoSearchInput input)
{
var query = from account in _accountUnitRepository.GetAll()
join coa in _coaUnitRepository.GetAll() on account.ChartOfAccountId equals coa.Id
where coa.IsCorporate && account.TypeOfAccountId == 17 //Checking the typeofAccount is Bank
select account;
return(await query.WhereIf(!string.IsNullOrEmpty(input.Query), p => p.Caption.Contains(input.Query) || p.Description.Contains(input.Query) ||
p.AccountNumber.Contains(input.Query))
.Select(u => new AccountCacheItem
{
Caption = u.Caption,
AccountId = u.Id,
Description = u.Description,
AccountNumber = u.AccountNumber,
ChartOfAccountId = u.ChartOfAccountId
}).ToListAsync());
}
public async Task <List <NameValueDto> > GetEmployeeList(AutoSearchInput input)
{
var cacheItem = await _empCache.GetEmployeeCacheItemAsync(
CacheKeyStores.CalculateCacheKey(CacheKeyStores.EmployeeKey, Convert.ToInt32(_customAppSession.TenantId)));
var res = cacheItem.ToList()
.WhereIf(input.Property == "isDirector", p => p.IsDirector)
.WhereIf(input.Property == "isProducer", p => p.IsProducer)
.WhereIf(input.Property == "isDirPhoto", p => p.IsArtDirector)
.WhereIf(input.Property == "isArtDirector", p => p.IsArtDirector)
.WhereIf(input.Property == "isSetDesigner", p => p.IsSetDesigner)
.WhereIf(!string.IsNullOrEmpty(input.Query), p => p.LastName.ToUpper().Contains(input.Query.ToUpper()) || p.FirstName.ToUpper().Contains(input.Query.ToUpper()))
.Select(u => new NameValueDto {
Name = u.FirstName + " " + u.LastName, Value = u.EmployeeId.ToString()
}).ToList();
return(res);
}
/// <summary>
/// Get Jobs or Divisions List by using OrganizationUnitId
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <List <DivisionCacheItem> > GetJobListByStatus(AutoSearchInput input)
{
Func <DivisionCacheItem, bool> expDivisionCache = null;
var cacheItem = await _divisionCache.GetDivisionCacheItemAsync(
CacheKeyStores.CalculateCacheKey(CacheKeyStores.DivisionKey, Convert.ToInt32(_customAppSession.TenantId)));
//apply User have restrictions
if (_customAppSession.HasProjectRestriction || _customAppSession.HasDivisionRestriction)
{
var strEntityClassification = string.Join(",", new string[] { EntityClassification.Division.ToDescription(), EntityClassification.Project.ToDescription() });
expDivisionCache = ExpressionBuilder.GetExpression <DivisionCacheItem>(await GetEntityAccessFilter(strEntityClassification)).Compile();
}
return(cacheItem.ToList().WhereIf(!ReferenceEquals(expDivisionCache, null), expDivisionCache)
.Where(p => p.IsDivision == false && p.TypeOfJobStatusId != ProjectStatus.Closed && p.TypeOfJobStatusId != ProjectStatus.WrLockedap)
.WhereIf(!string.IsNullOrEmpty(input.Query), p => p.JobNumber.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper()) ||
p.Caption.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper())).ToList());
}
/// <summary>
/// Get LinkAccount List By CoaId
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <List <NameValueDto> > GetLinkAccountListByCoaId(AutoSearchInput input)
{
var linkCoaId = _coaRepository.GetAll().Where(u => u.Id == input.Id).Select(u => u.LinkChartOfAccountID).FirstOrDefault();
var linkAccountList = _accountUnitRepository.GetAll().Where(u => u.ChartOfAccountId == linkCoaId);
if (!string.IsNullOrEmpty(input.Query))
{
linkAccountList = linkAccountList.Where(u => u.Caption.Contains(input.Query));
}
var result = await linkAccountList.Select(u => new NameValueDto {
Name = u.Caption, Value = u.Id.ToString()
})
.OrderBy(p => p.Name).ToListAsync();
return(result);
}
/// <summary>
/// Get PettyCashAccountList
/// </summary>
/// <returns></returns>
public async Task <List <AutoFillDto> > GetPettyCashAccountList(AutoSearchInput input)
{
var query = from pcaccount in _pettyCashAccountUnitRepository.GetAll()
join account in _accountUnitRepository.GetAll() on pcaccount.AccountId equals account.Id
select new { pcaccount, Caption = account.Caption, Description = account.Description };
var pcAccountList = await query.WhereIf(!ReferenceEquals(input.OrganizationUnitId, null),
p => p.pcaccount.OrganizationUnitId == input.OrganizationUnitId)
.WhereIf(!string.IsNullOrEmpty(input.Query),
p => p.Caption.Contains(input.Query) || p.Caption.Contains(input.Query))
.Select(u => new AutoFillDto
{
Name = u.Caption,
Value = u.pcaccount.Id.ToString(),
Column1 = u.Description,
Column2 = u.Caption
}).ToListAsync();
return(pcAccountList);
}
/// <summary>
/// Get new mapping accounts by Convert to new coa id
/// </summary>
/// <param name="input"></param>
/// <returns>Account units</returns>
public async Task <List <AccountUnitDto> > GetAccountsForMapping(AutoSearchInput input)
{
var linkCoaId = _coaRepository.GetAll().Where(u => u.Id == input.Id).Select(u => u.LinkChartOfAccountID).FirstOrDefault();
var linkAccountList = _accountUnitRepository.GetAll().Where(u => u.ChartOfAccountId == linkCoaId);
if (!string.IsNullOrEmpty(input.Query))
{
linkAccountList =
linkAccountList.Where(u => u.AccountNumber.Contains(input.Query) || u.Caption.Contains(input.Query));
}
var result = await linkAccountList.Select(
u => new AccountUnitDto {
Caption = u.Caption, Description = u.Description, AccountNumber = u.AccountNumber, AccountId = u.Id, ChartOfAccountId = u.ChartOfAccountId
}
).OrderBy(p => p.Caption).ToListAsync();
return(result);
}
/// <summary>
/// Get accounts based on Job and chartofAccountId
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <List <AccountCacheItem> > GetAccountsList(AutoSearchInput input)
{
Func <AccountCacheItem, bool> expAccountCache = null;
var chartOfAccountId = (from job in _jobUnitRepository.GetAll().Where(p => p.Id == input.JobId)
select job.ChartOfAccountId).FirstOrDefault();
var accountList = await _accountCache.GetAccountCacheItemAsync(
CacheKeyStores.CalculateCacheKey(CacheKeyStores.AccountKey, Convert.ToInt32(_customAppSession.TenantId)));
//apply User have restrictions
if (_customAppSession.HasGLRestrictions || _customAppSession.HasLineRestrictions)
{
var strEntityClassification = string.Join(",", new string[] { EntityClassification.Account.ToDescription(), EntityClassification.Line.ToDescription() });
expAccountCache = ExpressionBuilder.GetExpression <AccountCacheItem>(await GetEntityAccessFilter(strEntityClassification)).Compile();
}
return(accountList.ToList().WhereIf(!string.IsNullOrEmpty(input.Query),
p => p.Caption.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper()) || p.AccountNumber.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper()) ||
p.Description.EmptyIfNull().ToUpper().Contains(input.Query.ToUpper())).Where(p => p.ChartOfAccountId == chartOfAccountId)
.WhereIf(!ReferenceEquals(expAccountCache, null), expAccountCache).ToList());
}
/// <summary>
/// Get Bank Accounts Access List By UserId
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <List <BankAccountAccessListUnitDto> > GetBankAccountAccessList(GetUserSecuritySettingsInputUnit input)
{
List <BankAccountCacheItem> bankAccountCacheItems = new List <BankAccountCacheItem>();
AutoSearchInput cacheInput = new AutoSearchInput()
{
OrganizationUnitId = input.OrganizationUnitId
};
var bankAccountCache = await _bankAccountCache.GetBankAccountCacheItemAsync(
CacheKeyStores.CalculateCacheKey(CacheKeyStores.BankAccountKey, Convert.ToInt32(_customAppSession.TenantId)));
var user = await _userManager.GetUserByIdAsync(input.UserId);
var organizationUnits = await _organizationExtendedUnitManager.GetExtendedOrganizationUnitsAsync(user, input.EntityClassificationId);
var organizationUnitIds = organizationUnits.Select(ou => ou.Id);
var strOrgIds = string.Join(",", organizationUnitIds.ToArray());
var values = Enum.GetValues(typeof(TypeOfBankAccount)).Cast <TypeOfBankAccount>().Select(x => x)
.ToDictionary(u => u.ToDescription(), u => (int)u).Where(u => u.Value >= 1 && u.Value <= 10)
.Select(u => u.Key).ToArray();
var strTypeOfbankAC = string.Join(",", values);
if (!string.IsNullOrEmpty(strOrgIds))
{
if (ReferenceEquals(input.Filters, null))
{
input.Filters = new List <Filters>();
}
var orgfilter = new Filters()
{
Property = "OrganizationUnitId",
Comparator = 6,//In Operator
SearchTerm = strOrgIds,
DataType = DataTypes.Text
};
input.Filters.Add(orgfilter);
}
if (!ReferenceEquals(input.Filters, null))
{
Func <BankAccountCacheItem, bool> multiRangeExp = null;
var multiRangeFilters = input.Filters.Where(u => u.IsMultiRange == true).ToList();
if (multiRangeFilters.Count != 0)
{
multiRangeExp = ExpressionBuilder.GetExpression <BankAccountCacheItem>(Helper.GetMultiRangeFilters(multiRangeFilters), SearchPattern.Or).Compile();
input.Filters.RemoveAll(u => u.IsMultiRange == true);
}
var filterCondition = ExpressionBuilder.GetExpression <BankAccountCacheItem>(input.Filters).Compile();
bankAccountCacheItems = bankAccountCache.ToList()
.Where(u => strTypeOfbankAC.Contains(u.TypeOfBankAccountId.ToString()))
.WhereIf(multiRangeFilters.Count != 0, multiRangeExp)
.Where(filterCondition).ToList();
}
return(bankAccountCacheItems.Select(item =>
{
var dto = new BankAccountAccessListUnitDto
{
BankAccountNumber = item.BankAccountNumber,
BankName = item.Description,
AccountName = item.BankAccountName,
OrganizationUnitId = item.OrganizationUnitId,
BankAccountId = item.BankAccountId
};
return dto;
}).ToList());
}
/// <summary>
///
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <ListResultOutput <VendorAliasUnitDto> > GetVendorAliasUnits(AutoSearchInput input)
{
var query = _vendorAliasUnitRepository.GetAll()
.Where(au => au.VendorId == input.VendorId);
var items = await query.ToListAsync();
return(new ListResultOutput <VendorAliasUnitDto>(
items.Select(item =>
{
var dto = item.MapTo <VendorAliasUnitDto>();
dto.VendorAliasId = item.Id;
return dto;
}).ToList()));
}
