/// <summary>
/// This method updates funding source accepted currencies
/// </summary>
/// <param name="pkFundingSourceID">pkFundingSourceID</param>
/// <param name="acceptedCurr">acceptedCurr</param>
/// <returns></returns>
public bool UpdateFundingSourceAcceptedCurrency(int pkFundingSourceID, string acceptedCurr)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
//Get array of currencies
var allCurr = acceptedCurr.Split(',');
int parseResult;
var sourceAcceptedCurrRepo =
new FundingSourceAcceptedCurrencyRepository(new EFRepository <FundingSourceAcceptedCurrency>(), unitOfWork);
ObjectSet <FundingSourceAcceptedCurrency> acceptedCurrObjSet =
((CurrentDeskClientsEntities)sourceAcceptedCurrRepo.Repository.UnitOfWork.Context).FundingSourceAcceptedCurrencies;
//Get old records and set IsDelete true
var oldRecords = acceptedCurrObjSet.Where(curr => curr.FK_FundingSourceID == pkFundingSourceID).ToList();
foreach (var record in oldRecords)
{
record.IsDeleted = true;
}
//Insert to repo for each currency
foreach (var curr in allCurr)
{
if (Int32.TryParse(curr, out parseResult))
{
FundingSourceAcceptedCurrency fundAcceptedCurr = new FundingSourceAcceptedCurrency();
fundAcceptedCurr.FK_FundingSourceID = pkFundingSourceID;
fundAcceptedCurr.FK_LCurrencyValueID = Convert.ToInt32(curr);
fundAcceptedCurr.IsDeleted = false;
sourceAcceptedCurrRepo.Add(fundAcceptedCurr);
}
}
//Save
sourceAcceptedCurrRepo.Save();
return(true);
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
return(false);
}
}
/// <summary>
/// This method updates funding source
/// </summary>
/// <param name="updateSource">updateSource</param>
/// <returns></returns>
public bool UpdateFundingSource(FundingSource updateSource)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var fundSourceRepo =
new FundingSourceRepository(new EFRepository <FundingSource>(), unitOfWork);
ObjectSet <FundingSource> fundSourceObjSet =
((CurrentDeskClientsEntities)fundSourceRepo.Repository.UnitOfWork.Context).FundingSources;
var source = fundSourceObjSet.Where(src => src.PK_FundingSourceID == updateSource.PK_FundingSourceID).FirstOrDefault();
if (source != null)
{
source.SourceName = updateSource.SourceName;
source.SourceType = updateSource.SourceType;
source.BankName = updateSource.BankName;
source.AccountNumber = updateSource.AccountNumber;
source.BicOrSwiftCode = updateSource.BicOrSwiftCode;
source.FK_ReceivingBankInfoID = updateSource.FK_ReceivingBankInfoID;
source.ReceivingBankInfo = updateSource.ReceivingBankInfo;
source.BankAddress = updateSource.BankAddress;
source.BankCity = updateSource.BankCity;
source.FK_BankCountryID = updateSource.FK_BankCountryID;
source.BankPostalCode = updateSource.BankPostalCode;
source.InterBankName = updateSource.InterBankName;
source.FK_InterBankCountryID = updateSource.FK_InterBankCountryID;
source.InterBicOrSwiftCode = updateSource.InterBicOrSwiftCode;
source.IncomingWireFeeAmount = updateSource.IncomingWireFeeAmount;
source.OutgoingWireFeeAmount = updateSource.OutgoingWireFeeAmount;
source.FK_IncomingWireFeeCurrency = updateSource.FK_IncomingWireFeeCurrency;
source.FK_OutgoingWireFeeCurrency = updateSource.FK_OutgoingWireFeeCurrency;
fundSourceRepo.Save();
return(true);
}
return(false);
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
return(false);
}
}
/// <summary>
/// This method gets all account number creation rules rows
/// </summary>
/// <returns></returns>
public List <AccountCreationRule> GetRule()
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var accountCreationRuleRepo =
new AccountCreationRuleRepository(new EFRepository <AccountCreationRule>(), unitOfWork);
return(accountCreationRuleRepo.All().ToList());
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// This function will insert new Error
/// </summary>
/// <returns></returns>
public void AddNewError(ErrorLog newError)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var errorLogRepo =
new ErrorLogRepository(new EFRepository <ErrorLog>(), unitOfWork);
errorLogRepo.Add(newError);
errorLogRepo.Save();
}
}
catch (Exception ex)
{
//Send mail
}
}
/// <summary>
/// This method gets cfd trade volume for a particular day
/// </summary>
/// <param name="introducingBrokerID">introducingBrokerID</param>
/// <param name="fromDate">fromDate</param>
/// <param name="toDate">toDate</param>
/// <returns></returns>
public double GetCFDTradesVolumeByDay(int introducingBrokerID, long fromDate, long toDate)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var ibRepo =
new IntroducingBrokerRepository(new EFRepository <IntroducingBroker>(), unitOfWork);
return(((CurrentDeskClientsEntities)ibRepo.Repository.UnitOfWork.Context).GetCFDTradesVolumeByDay(introducingBrokerID, fromDate, toDate).FirstOrDefault() ?? 0);
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
// Add your own data access methods here. If you wish to
// expose your public method to a WCF service, marked them with
// the attribute [NCPublish], and another T4 template will generate your service contract
public void UpdateMargin(Margin newMargin)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var marginRepo =
new MarginRepository(new EFRepository <Margin>(), unitOfWork);
ObjectSet <Margin> marginObj =
((CurrentDeskClientsEntities)marginRepo.Repository.UnitOfWork.Context).Margins;
//Check existing margin
var dbMargin = marginObj.Where(m => m.Login == newMargin.Login).FirstOrDefault();
if (dbMargin == null)
{
marginRepo.Add(newMargin);
}
else
{
dbMargin.Login = newMargin.Login;
dbMargin.Group = newMargin.Group;
dbMargin.Leverage = newMargin.Leverage;
dbMargin.Updated = newMargin.Updated;
dbMargin.Balance = newMargin.Balance;
dbMargin.Equity = newMargin.Equity;
dbMargin.Volume = newMargin.Volume;
dbMargin.Margin1 = newMargin.Margin1;
dbMargin.MarginFree = newMargin.MarginFree;
dbMargin.MarginLevel = newMargin.MarginLevel;
dbMargin.MarginType = newMargin.MarginType;
dbMargin.LevelType = newMargin.LevelType;
}
marginRepo.Save();
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
}
}
// Add your own data access methods here. If you wish to
// expose your public method to a WCF service, marked them with
// the attribute [NCPublish], and another T4 template will generate your service contract
/// <summary>
/// This function will insert new partner spread details in PartnerCommission table
/// </summary>
/// <returns></returns>
public void AddNewPartnerSpread(PartnerCommission partComm)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var partCommRepo =
new PartnerCommissionRepository(new EFRepository <PartnerCommission>(), unitOfWork);
partCommRepo.Add(partComm);
partCommRepo.Save();
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// This Function Will get all the open trades related to the list of asset manager.
/// </summary>
/// <param name="loginIDList">AssetManager Platform LoginIDList</param>
/// <param name="lastProcessedID">Last Processed ID</param>
/// <returns>List of Open Trades</returns>
public List <Trade> GetAssetManagerOpenTrades(List <int> loginIDList, int lastProcessedID)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var tradeRepo =
new TradeRepository(new EFRepository <Trade>(), unitOfWork);
return(((CurrentDeskClientsEntities)tradeRepo.Repository.UnitOfWork.Context).Trades.
Where(x => loginIDList.Contains((int)x.Login) && x.PK_TradeID > lastProcessedID).OrderBy(x => x.PK_TradeID).ToList());
}
}
catch (Exception exceptionMessage)
{
CommonErrorLogger.CommonErrorLog(exceptionMessage, System.Reflection.MethodBase.GetCurrentMethod().Name);
return(null);
}
}
// Add your own data access methods here. If you wish to
// expose your public method to a WCF service, marked them with
// the attribute [NCPublish], and another T4 template will generate your service contract
/// <summary>
/// This method gets all trades from Trades table
/// </summary>
/// <returns></returns>
public List <Trade> GetAllTrades()
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var tradeRepo =
new TradeRepository(new EFRepository <Trade>(), unitOfWork);
//Returning List Of Trades
return(tradeRepo.All().ToList());
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// Add a new trade
/// </summary>
/// <param name="trade"></param>
public void AddTrade(Trade trade)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var tradeRepo =
new TradeRepository(new EFRepository <Trade>(), unitOfWork);
tradeRepo.Add(trade);
tradeRepo.Save();
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
}
}
// Add your own data access methods here. If you wish to
// expose your public method to a WCF service, marked them with
// the attribute [NCPublish], and another T4 template will generate your service contract
/// <summary>
/// This method adds or updates new transaction settings
/// </summary>
/// <param name="setting">setting</param>
/// <returns></returns>
public bool AddOrUpdateTransactionSetting(TransactionSetting setting)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var transactionSettingRepo =
new TransactionSettingRepository(new EFRepository <TransactionSetting>(), unitOfWork);
ObjectSet <TransactionSetting> transactionSettingObjSet =
((CurrentDeskClientsEntities)transactionSettingRepo.Repository.UnitOfWork.Context).TransactionSettings;
//Get present setting from db
var dbSetting = transactionSettingObjSet.Where(sett => sett.FK_AdminTransactionTypeID == setting.FK_AdminTransactionTypeID && sett.FK_OrganizationID == setting.FK_OrganizationID).FirstOrDefault();
//If settings present in db
if (dbSetting != null)
{
dbSetting.FK_CurrencyID = setting.FK_CurrencyID;
dbSetting.MinimumDepositAmount = setting.MinimumDepositAmount;
dbSetting.TransferFee = setting.TransferFee;
dbSetting.InternalTransferApprovalOptions = setting.InternalTransferApprovalOptions;
dbSetting.InternalTransferLimitedAmount = setting.InternalTransferLimitedAmount;
dbSetting.MarginRestriction = setting.MarginRestriction;
dbSetting.ConversionMarkupType = setting.ConversionMarkupType;
dbSetting.ConversionMarkupValue = setting.ConversionMarkupValue;
}
else
{
transactionSettingRepo.Add(setting);
}
//Save and return true
transactionSettingRepo.Save();
return(true);
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
return(false);
}
}
/// <summary>
/// This Function will get last closed trade ProcessedID
/// </summary>
/// <returns></returns>
public int GetLastClosedTradeProcessedID()
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var boMAMTradeRepo =
new BOMAMTradeRepository(new EFRepository <BOMAMTrade>(), unitOfWork);
return(((CurrentDeskClientsEntities)boMAMTradeRepo.Repository.UnitOfWork.Context).
BOMAMTrades.Where(trade => trade.IsopenTrades == false).Max(trade => trade.LastIDProcessed));
}
}
catch (Exception exceptionMessage)
{
CommonErrorLogger.CommonErrorLog(exceptionMessage, System.Reflection.MethodBase.GetCurrentMethod().Name);
return(0);
}
}
// Add your own data access methods here. If you wish to
// expose your public method to a WCF service, marked them with
// the attribute [NCPublish], and another T4 template will generate your service contract
/// <summary>
/// This function will insert new user into Users table
/// </summary>
/// <returns></returns>
public void AddNewUser(User newUser)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var userRepo =
new UserRepository(new EFRepository <User>(), unitOfWork);
userRepo.Add(newUser);
userRepo.Save();
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// This Function Will return all the selected Currency
/// </summary>
/// <returns></returns>
public List <L_Languages> GetLanguages()
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var languageRepo =
new L_LanguagesRepository(new EFRepository <L_Languages>(), unitOfWork);
//Return all the languages
return(languageRepo.All().ToList());
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// This function will insert individual account details for new client
/// </summary>
/// <param name="newClient">newClient</param>
public void AddIndividualAccDetailsForNewClient(IndividualAccountInformation newClient)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var individualDetailsRepo =
new IndividualAccountInformationRepository(new EFRepository <IndividualAccountInformation>(), unitOfWork);
individualDetailsRepo.Add(newClient);
individualDetailsRepo.Save();
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
public void InsertPrice(List <Price> lstPrice)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var priceRepo =
new PriceRepository(new EFRepository <Price>(), unitOfWork);
ObjectSet <Price> priceObj =
((CurrentDeskClientsEntities)priceRepo.Repository.UnitOfWork.Context).Prices;
var lstSymbole = lstPrice.Select(s => s.Symbole).ToList();
//Get the existing price from DB and update with New DB
var lstDBPrice = priceObj.Where(p => lstSymbole.Contains(p.Symbole)).ToList();
foreach (var uPrice in lstDBPrice)
{
var newPrice = lstPrice.Where(s => s.Symbole == uPrice.Symbole.Trim()).FirstOrDefault();
if (newPrice != null)
{
uPrice.Ask = newPrice.Ask;
uPrice.Bid = newPrice.Bid;
}
}
//Add new price
var lstDBPriceSymbole = lstDBPrice.Select(p => p.Symbole.Trim()).ToList();
var newPricesToAdd = lstPrice.Where(lp => !lstDBPriceSymbole.Contains(lp.Symbole)).Distinct().ToList();
foreach (var price in newPricesToAdd)
{
priceRepo.Add(price);
}
priceRepo.Save();
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
}
}
/// <summary>
/// This Function Will return all the demo Leads
/// </summary>
/// <returns></returns>
public List <DemoLead> GetDemoLeads()
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var demoLeadRepo =
new DemoLeadRepository(new EFRepository <DemoLead>(), unitOfWork);
//Returning List Of Demo Lead
return(demoLeadRepo.All().ToList());
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// This method returns all Commission increment entries from db
/// </summary>
/// <returns></returns>
public List <L_CommissionIncrementValue> GetCommissionIncrementValues()
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var lCommissionIncrementValueRepo =
new L_CommissionIncrementValueRepository(new EFRepository <L_CommissionIncrementValue>(), unitOfWork);
//Returning List Of Demo Lead
return(lCommissionIncrementValueRepo.All().ToList());
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// This function will insert introducing broker details
/// </summary>
/// <param name="newIB">newIB</param>
public void AddIntroducingBrokerDetails(IntroducingBroker newIB)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var IBDetailsRepo =
new IntroducingBrokerRepository(new EFRepository <IntroducingBroker>(), unitOfWork);
IBDetailsRepo.Add(newIB);
IBDetailsRepo.Save();
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// Get Connection string
/// </summary>
/// <returns></returns>
public string GetConnectionString()
{
string strConnection = string.Empty;
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var context = (CurrentDeskClientsEntities)unitOfWork.Context;
strConnection = ((EntityConnection)context.Connection).StoreConnection.ConnectionString;
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
}
return(strConnection);
}
/// <summary>
/// This method returns list of clients transactions of particular type
/// </summary>
/// <param name="clientIds">clientIds</param>
/// <param name="transactionType">transactionType</param>
/// <param name="organizationID">organizationID</param>
/// <returns></returns>
public List <AdminTransaction> GetAllClientsTransactionOfParticulaType(string clientIds, int transactionType, int organizationID)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var adminTransactionRepo =
new AdminTransactionRepository(new EFRepository <AdminTransaction>(), unitOfWork);
ObjectSet <AdminTransaction> transactionObjSet =
((CurrentDeskClientsEntities)adminTransactionRepo.Repository.UnitOfWork.Context)
.AdminTransactions;
var allTransactions = transactionObjSet.Where(tran => tran.IsDeleted == false && tran.FK_OrganizationID == organizationID).ToList();
//All pending transactions
var allPendingTransactions =
allTransactions.Where(
transaction => clientIds.Contains(transaction.FK_UserID.ToString()) &&
transaction.FK_AdminTransactionTypeID == transactionType &&
transaction.IsApproved == false)
.OrderByDescending(tran => tran.TransactionDate)
.ToList();
//Latest 5 approved transactions
var latestApprovedTransactions =
allTransactions.Where(
tran => clientIds.Contains(tran.FK_UserID.ToString()) &&
tran.FK_AdminTransactionTypeID == transactionType &&
tran.IsApproved == true).OrderByDescending(odr => odr.ApprovedDate).Take(5).ToList();
allPendingTransactions.AddRange(latestApprovedTransactions);
return(allPendingTransactions.OrderByDescending(odr => odr.TransactionDate).ToList());
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
// Add your own data access methods here. If you wish to
// expose your public method to a WCF service, marked them with
// the attribute [NCPublish], and another T4 template will generate your service contract
/// <summary>
/// This method adds new fund account request in AdminTransaction table
/// </summary>
/// <param name="newRequest">newRequest</param>
/// <returns></returns>
public bool AddNewAdminTransactionRequest(AdminTransaction newRequest)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var adminTransactionRepo =
new AdminTransactionRepository(new EFRepository <AdminTransaction>(), unitOfWork);
adminTransactionRepo.Add(newRequest);
adminTransactionRepo.Save();
return(true);
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
return(false);
}
}
/// <summary>
/// This Function will calculate all the pnl
/// and return it Slave Account
/// </summary>
/// <param name="clientAccountID">clientAccountID</param>
/// <returns>sum of pnl</returns>
public double GetProfitSummation(int clientAccountID)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var boMAMTradeRepo =
new BOMAMTradeRepository(new EFRepository <BOMAMTrade>(), unitOfWork);
return
(((CurrentDeskClientsEntities)boMAMTradeRepo.Repository.UnitOfWork.Context).BOMAMTrades.
Where(act => act.FK_ClientAccountID == clientAccountID && act.IsopenTrades == true).Sum(act => act.Pnl + act.Commission + act.Swap) ?? 0);
}
}
catch (Exception exceptionMessage)
{
CommonErrorLogger.CommonErrorLog(exceptionMessage, System.Reflection.MethodBase.GetCurrentMethod().Name);
return(0);
}
}
// Add your own data access methods here. If you wish to
// expose your public method to a WCF service, marked them with
// the attribute [NCPublish], and another T4 template will generate your service contract
/// <summary>
/// This method adds new managed account program for Asset Manager
/// </summary>
/// <param name="program"></param>
/// <returns></returns>
public bool AddNewManagedAccount(ManagedAccountProgram program)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var accProgramRepo =
new ManagedAccountProgramRepository(new EFRepository <ManagedAccountProgram>(), unitOfWork);
accProgramRepo.Add(program);
accProgramRepo.Save();
return(true);
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
return(false);
}
}
/// <summary>
/// This method returns bank account details based on pkBankID
/// </summary>
/// <param name="pkBankInfoID">pkBankInfoID</param>
/// <returns></returns>
public BankAccountInformation GetBankAccountDetails(int pkBankInfoID)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var bankRepo = new BankAccountInformationRepository(new EFRepository <BankAccountInformation>(), unitOfWork);
ObjectSet <BankAccountInformation> bankAccountInformationObjSet =
((CurrentDeskClientsEntities)bankRepo.Repository.UnitOfWork.Context).BankAccountInformations;
return(bankAccountInformationObjSet.Where(bnk => bnk.PK_BankAccountInformationID == pkBankInfoID).FirstOrDefault());
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
// Add your own data access methods here. If you wish to
// expose your public method to a WCF service, marked them with
// the attribute [NCPublish], and another T4 template will generate your service contract
/// <summary>
/// This method adds new agent information
/// </summary>
/// <param name="newAgent">newAgent</param>
/// <param name="introducingBrokerUserID">introducingBrokerUserID</param>
/// <returns></returns>
public bool AddNewAgent(Agent newAgent, int introducingBrokerUserID)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var agentRepo =
new AgentRepository(new EFRepository <Agent>(), unitOfWork);
ObjectSet <Agent> agentObjSet =
((CurrentDeskClientsEntities)agentRepo.Repository.UnitOfWork.Context).Agents;
//Get number of agents under this IB
var highestAgent = agentObjSet.Where(agnt => agnt.FK_IntroducingBrokerUserID == introducingBrokerUserID).OrderByDescending(agnt => agnt.AgentIntroducingBrokerCode).FirstOrDefault();
//If IB has agents
if (highestAgent != null)
{
newAgent.AgentIntroducingBrokerCode = highestAgent.AgentIntroducingBrokerCode + 1;
}
//If no agents under this IB
else
{
newAgent.AgentIntroducingBrokerCode = 1;
}
newAgent.FK_IntroducingBrokerUserID = introducingBrokerUserID;
newAgent.IsActive = true;
agentRepo.Add(newAgent);
agentRepo.Save();
return(true);
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
return(false);
}
}
// Add your own data access methods here. If you wish to
// expose your public method to a WCF service, marked them with
// the attribute [NCPublish], and another T4 template will generate your service contract
/// <summary>
/// This method returns user document details
/// </summary>
/// <param name="userID">userID</param>
/// <param name="docID">docID</param>
/// <returns></returns>
public UserDocument GetUserDocumentDetails(int userID, int docID)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var userDocRepo =
new UserDocumentRepository(new EFRepository <UserDocument>(), unitOfWork);
ObjectSet <UserDocument> userDocObjSet =
((CurrentDeskClientsEntities)userDocRepo.Repository.UnitOfWork.Context).UserDocuments;
return(userDocObjSet.Include("Document").Where(doc => doc.FK_UserID == userID && doc.FK_DocumentID == docID && doc.IsDeleted == false).FirstOrDefault());
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// This method returns list of all incoming fund transfer request
/// </summary>
/// <returns></returns>
public List <AdminTransaction> GetAllIncomingFundRequests(int organizationID)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var adminTransactionRepo =
new AdminTransactionRepository(new EFRepository <AdminTransaction>(), unitOfWork);
ObjectSet <AdminTransaction> transactionObjSet =
((CurrentDeskClientsEntities)adminTransactionRepo.Repository.UnitOfWork.Context).AdminTransactions;
return(transactionObjSet.Include("FundingSource").Where(transaction => transaction.FK_AdminTransactionTypeID == (int)AdminTransactionType.IncomingFunds && transaction.FK_OrganizationID == organizationID && transaction.IsApproved == false && transaction.IsDeleted == false).ToList());
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// This method returns sum of pending transfer request amount for an account
/// </summary>
/// <param name="accountNumber">accountNumber</param>
/// <param name="organizationID">organizationID</param>
/// <returns></returns>
public decimal GetPendingTransferAmount(string accountNumber, int organizationID)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var adminTransactionRepo =
new AdminTransactionRepository(new EFRepository <AdminTransaction>(), unitOfWork);
ObjectSet <AdminTransaction> transactionObjSet =
((CurrentDeskClientsEntities)adminTransactionRepo.Repository.UnitOfWork.Context).AdminTransactions;
return((decimal)transactionObjSet.Where(tran => tran.AccountNumber == accountNumber && tran.FK_OrganizationID == organizationID && (tran.FK_AdminTransactionTypeID == (int)AdminTransactionType.InternalTransfers || tran.FK_AdminTransactionTypeID == (int)AdminTransactionType.ConversionsRequests) && tran.IsApproved == false && tran.IsDeleted == false).ToList().Sum(tran => tran.TransactionAmount));
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}
/// <summary>
/// This method returns all agents under a particular IB
/// </summary>
/// <param name="introducingBrokerUserID">introducingBrokerUserID</param>
/// <returns></returns>
public List <Agent> GetAllAgentsOfIB(int introducingBrokerUserID)
{
try
{
using (var unitOfWork = new EFUnitOfWork())
{
var agentRepo =
new AgentRepository(new EFRepository <Agent>(), unitOfWork);
ObjectSet <Agent> agentObjSet =
((CurrentDeskClientsEntities)agentRepo.Repository.UnitOfWork.Context).Agents;
return(agentObjSet.Where(agnt => agnt.FK_IntroducingBrokerUserID == introducingBrokerUserID).ToList());
}
}
catch (Exception ex)
{
CommonErrorLogger.CommonErrorLog(ex, System.Reflection.MethodBase.GetCurrentMethod().Name);
throw;
}
}