/// <summary>
/// This Function Will return all the net worth euros values
/// </summary>
/// <returns></returns>
public List <L_TradingExperience> GetTradingExpValues()
{
try
{
var tradingExpKey = CacheKey.CDS_TRADINGEXPS;
var tradingExpList = new List <L_TradingExperience>();
if (StaticCache.Exist(tradingExpKey))
{
tradingExpList = (List <L_TradingExperience>)StaticCache.Get(tradingExpKey);
}
else
{
using (var unitOfWork = new EFUnitOfWork())
{
var lTradingExpRepo =
new L_TradingExperienceRepository(new EFRepository <L_TradingExperience>(), unitOfWork);
//Returning list of trading exp look up values
tradingExpList = lTradingExpRepo.All().ToList();
StaticCache.Max(tradingExpKey, tradingExpList);
}
}
return(tradingExpList);
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// This Function Will return all the AccountCODE
/// </summary>
/// <returns></returns>
public List <L_AccountCode> GetAccountCodes()
{
try
{
var accountCodeKey = CacheKey.CDS_ACCOUNTCODE;
var accountCodeList = new List <L_AccountCode>();
if (StaticCache.Exist(accountCodeKey))
{
accountCodeList = (List <L_AccountCode>)StaticCache.Get(accountCodeKey);
}
else
{
using (var unitOfWork = new EFUnitOfWork())
{
var lAccountRepo =
new L_AccountCodeRepository(new EFRepository <L_AccountCode>(), unitOfWork);
//Returning List Of Demo Lead
accountCodeList = lAccountRepo.All().ToList();
//Store it into the cache
StaticCache.Max(accountCodeKey, accountCodeList);
}
}
return(accountCodeList);
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// This Function Will return all the net worth euros values
/// </summary>
/// <returns></returns>
public List <L_NetWorthEuros> GetNetWorthEurosValues()
{
try
{
var netWorthKey = CacheKey.CDS_NETWORTHEUROS;
var netWorthList = new List <L_NetWorthEuros>();
if (StaticCache.Exist(netWorthKey))
{
netWorthList = (List <L_NetWorthEuros>)StaticCache.Get(netWorthKey);
}
else
{
using (var unitOfWork = new EFUnitOfWork())
{
var lNetWorthEurosRepo =
new L_NetWorthEurosRepository(new EFRepository <L_NetWorthEuros>(), unitOfWork);
//Returning list of net worth euros look up values
netWorthList = lNetWorthEurosRepo.All().ToList();
StaticCache.Max(netWorthKey, netWorthList);
}
}
return(netWorthList);
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// This Function will Return All Trustee Type
/// </summary>
/// <returns></returns>
public List <L_CompanyTypeValue> GetCompanyType()
{
try
{
var companyTypeKey = CacheKey.CDS_COMPANYTYPE;
var companyTypeList = new List <L_CompanyTypeValue>();
if (StaticCache.Exist(companyTypeKey))
{
companyTypeList = (List <L_CompanyTypeValue>)StaticCache.Get(companyTypeKey);
}
else
{
using (var unitOfWork = new EFUnitOfWork())
{
var lCompanyTypeRepo =
new L_CompanyTypeValueRepository(new EFRepository <L_CompanyTypeValue>(), unitOfWork);
//Returning List Of Demo Lead
companyTypeList = lCompanyTypeRepo.All().ToList();
//Store it into the cache
StaticCache.Max(companyTypeKey, companyTypeList);
}
}
return(companyTypeList);
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// This Function Will return all the TicketSize
/// </summary>
/// <returns></returns>
public List <L_TicketSize> GetTickets()
{
try
{
var ticketSizeKey = CacheKey.CDS_TICKETSIZES;
var ticketSizeList = new List <L_TicketSize>();
if (StaticCache.Exist(ticketSizeKey))
{
ticketSizeList = (List <L_TicketSize>)StaticCache.Get(ticketSizeKey);
}
else
{
using (var unitOfWork = new EFUnitOfWork())
{
var lTicketSizeRepo =
new L_TicketSizeRepository(new EFRepository <L_TicketSize>(), unitOfWork);
//Returning List Of Demo Lead
ticketSizeList = lTicketSizeRepo.All().ToList();
StaticCache.Max(ticketSizeKey, ticketSizeList);
}
}
return(ticketSizeList);
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// This Function Will return all the liquid assets values
/// </summary>
/// <returns></returns>
public List <L_LiquidAssetsValue> GetLiquidAssetsValues()
{
try
{
var liquidAssetKey = CacheKey.CDS_LIQUIDASSETS;
var liquidAssetList = new List <L_LiquidAssetsValue>();
if (StaticCache.Exist(liquidAssetKey))
{
liquidAssetList = (List <L_LiquidAssetsValue>)StaticCache.Get(liquidAssetKey);
}
else
{
using (var unitOfWork = new EFUnitOfWork())
{
var lLiquidAssetsRepo =
new L_LiquidAssetsValueRepository(new EFRepository <L_LiquidAssetsValue>(), unitOfWork);
//Returning list of liquid assets values
liquidAssetList = lLiquidAssetsRepo.All().ToList();
StaticCache.Max(liquidAssetKey, liquidAssetList);
}
}
return(liquidAssetList);
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// This Function Will return all initialInvestment
/// </summary>
/// <returns></returns>
public List <L_InitialInvestment> GetInitialInvestment()
{
try
{
var initialInvestmentKey = CacheKey.CDS_INITIALINVESTMENTS;
var initialInvestmentList = new List <L_InitialInvestment>();
if (StaticCache.Exist(initialInvestmentKey))
{
initialInvestmentList = (List <L_InitialInvestment>)StaticCache.Get(initialInvestmentKey);
}
else
{
using (var unitOfWork = new EFUnitOfWork())
{
var initialInvestmentRepo =
new L_InitialInvestmentRepository(new EFRepository <L_InitialInvestment>(), unitOfWork);
initialInvestmentList = initialInvestmentRepo.All().ToList();
StaticCache.Max(initialInvestmentKey, initialInvestmentList);
}
}
return(initialInvestmentList);
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// This Function Will return all the estimated annual income values
/// </summary>
/// <returns></returns>
public List <L_AnnualIncomeValue> GetEstimatedAnnualIncomeValues()
{
try
{
var annualIncomeKey = CacheKey.CDS_ANNUALINCOME;
var annualIncomeList = new List <L_AnnualIncomeValue>();
if (StaticCache.Exist(annualIncomeKey))
{
annualIncomeList = (List <L_AnnualIncomeValue>)StaticCache.Get(annualIncomeKey);
}
else
{
using (var unitOfWork = new EFUnitOfWork())
{
var lAnnualIncomeRepo =
new L_AnnualIncomeValueRepository(new EFRepository <L_AnnualIncomeValue>(), unitOfWork);
//Returning list of annual income values
annualIncomeList = lAnnualIncomeRepo.All().ToList();
//Store it into the cache
StaticCache.Max(annualIncomeKey, annualIncomeList);
}
}
return(annualIncomeList);
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// This Function Will return all the ID Info types
/// </summary>
/// <returns></returns>
public List <L_IDInformationType> GetIdInfoType()
{
try
{
var idInformationKey = CacheKey.CDS_ID_INFORMATION;
var idInformationList = new List <L_IDInformationType>();
if (StaticCache.Exist(idInformationKey))
{
idInformationList = (List <L_IDInformationType>)StaticCache.Get(idInformationKey);
}
else
{
using (var unitOfWork = new EFUnitOfWork())
{
var lIdInfoTypeRepo =
new L_IDInformationTypeRepository(new EFRepository <L_IDInformationType>(), unitOfWork);
//Returning list of ID info type values
idInformationList = lIdInfoTypeRepo.All().ToList();
StaticCache.Max(idInformationKey, idInformationList);
}
}
return(idInformationList);
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// This Function Will return all the receiving banks
/// </summary>
/// <returns></returns>
public List <L_RecievingBank> GetReceivingBankInfo()
{
try
{
var idInformationKey = CacheKey.CDS_RECEVING_BANK_INFORMATION;
var receivingBankList = new List <L_RecievingBank>();
if (StaticCache.Exist(idInformationKey))
{
receivingBankList = (List <L_RecievingBank>)StaticCache.Get(idInformationKey);
}
else
{
using (var unitOfWork = new EFUnitOfWork())
{
var lReceivingBankRepo =
new L_RecievingBankRepository(new EFRepository <L_RecievingBank>(), unitOfWork);
//Returning list of receiving bank values
receivingBankList = lReceivingBankRepo.All().ToList();
//Store it into the cache
StaticCache.Max(idInformationKey, receivingBankList);
}
}
return(receivingBankList);
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// This Function will Return All Trustee Type
/// </summary>
/// <returns></returns>
public List <L_TrusteeTypeValue> GetTrusteeType()
{
try
{
var trusteeTypeKey = CacheKey.CDS_TRUSTEETYPEVALUES;
var trusteeTypeList = new List <L_TrusteeTypeValue>();
if (StaticCache.Exist(trusteeTypeKey))
{
trusteeTypeList = (List <L_TrusteeTypeValue>)StaticCache.Get(trusteeTypeKey);
}
else
{
using (var unitOfWork = new EFUnitOfWork())
{
var lTrusteeTypeRepo =
new L_TrusteeTypeValueRepository(new EFRepository <L_TrusteeTypeValue>(), unitOfWork);
//Returning List Of Demo Lead
trusteeTypeList = lTrusteeTypeRepo.All().ToList();
StaticCache.Max(trusteeTypeKey, trusteeTypeList);
}
}
return(trusteeTypeList);
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
