/// <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;
}
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));
}
