/// <summary> /// Initialises a new instance of the <see cref="GetPositionReportDataCommand"/> class. /// </summary> /// <param name="logger">The logger.</param> /// <param name="userIdentity">The user identity.</param> /// <param name="dateTimeService">The date-time service.</param> /// <param name="fundRepository">The fund repository.</param> /// <param name="valuationRepository">The valuation repository</param> /// <param name="orderManagementService">The order management service</param> /// <param name="forwardContractRepository">The forward Contract Repository</param> /// <param name="mfgiRepository">The MFGI Repository.</param> /// <param name="structureRepository">The fund structure repository</param> public GetPositionReportDataCommand( ILogger logger, IUserIdentity userIdentity, IDateTimeService dateTimeService, IFundRepository fundRepository, IValuationRepository valuationRepository, IOrderManagementService orderManagementService, IForwardContractRepository forwardContractRepository, IMfgiRepository mfgiRepository, IStructureRepository structureRepository) { Guard.IsNotNull(logger, "logger"); Guard.IsNotNull(userIdentity, "uderIdentity"); Guard.IsNotNull(dateTimeService, "dateTimeService"); Guard.IsNotNull(fundRepository, "fundRepository"); Guard.IsNotNull(valuationRepository, "valuationRepository"); Guard.IsNotNull(orderManagementService, "orderManagementService"); Guard.IsNotNull(forwardContractRepository, "forwardContractRepository"); Guard.IsNotNull(mfgiRepository, "mfgiRepository"); Guard.IsNotNull(structureRepository, "structureRepository"); this.logger = logger; this.userIdentity = userIdentity; this.dateTimeService = dateTimeService; this.fundRepository = fundRepository; this.valuationRepository = valuationRepository; this.orderManagementService = orderManagementService; this.forwardContractRepository = forwardContractRepository; this.mfgiRepository = mfgiRepository; this.structureRepository = structureRepository; }
/// <summary> /// /// </summary> /// <param name="walletRepository"></param> /// <param name="currencyRepository"></param> /// <param name="userRepository"></param> /// <param name="fundRepository"></param> public WalletController(IWalletRepository walletRepository, ICurrencyRepository currencyRepository, IUserRepository userRepository, IFundRepository fundRepository) { _walletRepository = walletRepository; _currencyRepository = currencyRepository; _userRepository = userRepository; _fundRepository = fundRepository; }
public bool CanFundAcceptParticipationAddition(int fundId, decimal amount) { IFundRepository fundRepository = _DataRepositoryFactory.GetDataRepository <IFundRepository>(); Fund fund = fundRepository.Get(fundId); if (fund == null) { FundFault fault = new FundFault(string.Format("Fund {0} does not exist in the system.", fundId)); throw new FaultException <FundFault>(fault, fault.Message); } if (amount <= 0) { FundFault fault = new FundFault(string.Format("Allocation amount ${0} is invalid.", amount)); throw new FaultException <FundFault>(fault, fault.Message); } else { decimal fundMaximumAUM = fund.Strategies.Sum(e => e.MaximumAUM); decimal fundCurrentAUM = fund.Strategies.Sum(e => e.CurrentAUM); if (amount > (fundMaximumAUM - fundCurrentAUM)) { FundFault fault = new FundFault(string.Format("Allocation amount ${0} exceeds Fund {1} available capacity.", amount, fundId)); throw new FaultException <FundFault>(fault, fault.Message); } } return(true); }
public MainForm(IFundRepository fundRepository) { InitializeComponent(); Initialize(); Presenter = new FundPresenter(this, fundRepository); gvFunds.DataSourceChanged += GvFunds_DataSourceChanged; }
public FundController(IFundRepository repository, IHostingEnvironment environment) { this._repository = repository; _hostingEnvironment = environment; _contentDirectoryPath = Path.Combine(_hostingEnvironment.ContentRootPath, "App_Data"); }
public FundPresenter(IMainView view, IFundRepository fundRepository) { m_View = view; FundRepository = fundRepository; funds = FundRepository.FindAll(); m_View.LoadFunds(FundRepository.FindAll()); FundSummary(); m_View.DataSourceChange += M_View_DataSourceChange; }
/// <summary> /// /// </summary> /// <param name="context"></param> /// <param name="currencyRepository"></param> /// <param name="fundRepository"></param> /// <param name="transactionRepository"></param> /// <param name="httpContextAccessor"></param> /// <param name="userRepository"></param> public WalletRepository(DataContext context, ICurrencyRepository currencyRepository, IFundRepository fundRepository, ITransactionRepository transactionRepository, IHttpContextAccessor httpContextAccessor, IUserRepository userRepository) { _context = context; _currencyRepository = currencyRepository; _fundRepository = fundRepository; _transactionRepository = transactionRepository; _httpContextAccessor = httpContextAccessor; _userRepository = userRepository; }
public CapitalCallController(IFundRepository fundRepository, ICapitalCallRepository capitalCallRepository, IInvestorRepository investorRepository, DeepBlue.Controllers.Admin.IAdminRepository adminRepository) { FundRepository=fundRepository; CapitalCallRepository=capitalCallRepository; InvestorRepository=investorRepository; AdminRepository=adminRepository; }
public List <QueryResult> GetFundResult() { string repoName = ConfigurationManager.AppSettings["FundRepoType"]; Type repoType = Type.GetType(repoName); IFundRepository Funds = Activator.CreateInstance(repoType) as IFundRepository; Console.WriteLine(Funds.GetType()); List <QueryResult> result = Funds.GetRepository(); return(result); }
public FundService(IUnitOfWork unitOfWork, IFundRepository fundRepository) : base(unitOfWork, fundRepository) { try { _unitOfWork = unitOfWork; _fundRepository = fundRepository; } catch (Exception ex) { throw ex; } }
public Participation PushAllocationIntoParticipation(Allocation allocation) { IParticipationRepository participationRepository = _DataRepositoryFactory.GetDataRepository <IParticipationRepository>(); IFundRepository fundRepository = _DataRepositoryFactory.GetDataRepository <IFundRepository>(); Participation participation = participationRepository.GetParticipationsByAccount(allocation.Reservation.AccountID) .Where(p => p.FundID == allocation.FundID) .FirstOrDefault(); try { if (participation == null) { if (CanFundAcceptNewParticipation(allocation.FundID, allocation.Amount)) { participation = new Participation() { AccountID = allocation.Reservation.AccountID, InitialBalance = allocation.Amount, Fund = fundRepository.Get(allocation.FundID) }; participationRepository.Add(participation); } } else { if (CanFundAcceptParticipationAddition(participation.Fund.FundID, allocation.Amount)) { participation.CurrentBalance += allocation.Amount; } participationRepository.Update(participation); } allocation.Pushed = true; } catch (Exception e) { } return(participation); }
public bool CanFundAcceptNewParticipation(int fundId, decimal amount) { bool fundHasSufficientCapacity = CanFundAcceptParticipationAddition(fundId, amount); if (fundHasSufficientCapacity) { IFundRepository fundRepository = _DataRepositoryFactory.GetDataRepository <IFundRepository>(); Fund fund = fundRepository.Get(fundId); if (!fund.OpenToNew || DateTime.UtcNow > fund.CloseDate) { FundFault fault = new FundFault(string.Format("Fund {0} is closed to new participations.", fundId)); throw new FaultException <FundFault>(fault, fault.Message); } return(true); } else { return(fundHasSufficientCapacity); } }
public FundsController(InvestingContext context, IFundRepository fundRepository, IMediator mediator) { _context = context ?? throw new ArgumentNullException(nameof(context)); _fundRepository = fundRepository ?? throw new ArgumentNullException(nameof(fundRepository)); _mediator = mediator ?? throw new ArgumentNullException(nameof(mediator)); }
public BalanceInitializeIntegrationEventHandler(IFundRepository fundRepository) { _fundRepository = fundRepository ?? throw new ArgumentNullException(nameof(fundRepository)); }
/// <summary> /// /// </summary> /// <param name="fundRepository"></param> /// <param name="walletRepository"></param> /// <param name="userRepository"></param> public AdminController(IFundRepository fundRepository, IWalletRepository walletRepository, IUserRepository userRepository) { _fundRepository = fundRepository; _walletRepository = walletRepository; _userRepository = userRepository; }
public FundService(IFundRepository fundRepository) { this.fundRepository = fundRepository; }
public FundController(IFundRepository repository) { this.repository = repository; }
public AllocateInvestmentFundCommandHandler(IInvestmentRepository investmentRepository, IFundRepository fundRepository) { _investmentRepository = investmentRepository ?? throw new ArgumentNullException(nameof(investmentRepository)); _fundRepository = fundRepository ?? throw new ArgumentNullException(nameof(fundRepository)); }
public FundManagerController(IFundManagerRepository fundManagerRepository, IFundRepository fundRepostory) { _fundManagerRepository = fundManagerRepository; _fundRepostory = fundRepostory; }
public FundController(IFundRepository fundRepository, IFundPerformanceCalculator fundPerformanceCalculator) { this.fundRepository = fundRepository; this.fundPerformanceCalculator = fundPerformanceCalculator; }
public InvestemntBalanceChangedDomainEventHandler(IInvestmentRepository investmentRepository, IFundRepository fundRepository) { _investmentRepository = investmentRepository ?? throw new ArgumentNullException(nameof(investmentRepository)); _fundRepository = fundRepository ?? throw new ArgumentNullException(nameof(fundRepository)); }
/// <summary> /// The class constructor. /// </summary> /// <param name="uow"></param> /// <param name="repository"></param> public FundBusiness(IUnitOfWork uow, IFundRepository repository) { this.Uow = uow ?? throw new ArgumentNullException(nameof(uow)); this.Repository = repository ?? throw new ArgumentNullException(nameof(repository)); }