public AlgorithmMessage UpdateAlgorithmMessage(AlgorithmMessage message)
{
return(ExecuteFaultHandledOperation(() =>
{
IAlgorithmInstanceRepository algorithmInstanceRepository = _DataRepositoryFactory.GetDataRepository <IAlgorithmInstanceRepository>();
AlgorithmInstance instance = algorithmInstanceRepository.Get(message.AlgorithmInstanceID);
if (instance == null)
{
NotFoundFault fault = new NotFoundFault(string.Format("No algorithm instance found for instanceId '{0}'.", message.AlgorithmInstanceID));
throw new FaultException <NotFoundFault>(fault, fault.Message);
}
IAlgorithmMessageRepository messageRepository = _DataRepositoryFactory.GetDataRepository <IAlgorithmMessageRepository>();
AlgorithmMessage updatedEntity = null;
if (message.AlgorithmMessageID == 0)
{
updatedEntity = messageRepository.Add(message);
}
else
{
updatedEntity = messageRepository.Update(message);
}
return updatedEntity;
}));
}
public Reservation UpdateReservation(Reservation reservation)
{
return(ExecuteFaultHandledOperation(() =>
{
IAccountRepository accountRepository = _DataRepositoryFactory.GetDataRepository <IAccountRepository>();
IReservationRepository reservationRepository = _DataRepositoryFactory.GetDataRepository <IReservationRepository>();
Account account = accountRepository.GetByLogin(reservation.Account.LoginEmail);
if (account == null)
{
NotFoundFault fault = new NotFoundFault(string.Format("No account found for login '{0}'.", reservation.Account.LoginEmail));
throw new FaultException <NotFoundFault>(fault, fault.Message);
}
ValidateAuthorization(account);
Reservation updatedEntity = null;
if (reservation.ReservationID == 0)
{
updatedEntity = reservationRepository.Add(reservation);
}
else
{
updatedEntity = reservationRepository.Update(reservation);
}
return updatedEntity;
}));
}
public void RedeemParticipation(string loginEmail, int participationId, decimal amount)
{
ExecuteFaultHandledOperation(() =>
{
IAccountRepository accountRepository = _DataRepositoryFactory.GetDataRepository <IAccountRepository>();
IParticipationRepository ParticipationRepository = _DataRepositoryFactory.GetDataRepository <IParticipationRepository>();
IParticipationEngine ParticipationEngine = _BusinessEngineFactory.GetBusinessEngine <IParticipationEngine>();
Account account = accountRepository.GetByLogin(loginEmail);
if (account == null)
{
NotFoundFault fault = new NotFoundFault(string.Format("No account found for login '{0}'.", loginEmail));
throw new FaultException <NotFoundFault>(fault, fault.Message);
}
ValidateAuthorization(account);
Participation participation = ParticipationRepository.Get(participationId);
if (participation == null)
{
NotFoundFault fault = new NotFoundFault(string.Format("No participation record found for id '{0}'.", participationId));
throw new FaultException <NotFoundFault>(fault, fault.Message);
}
ParticipationEngine.RedeemFundsFromParticipation(participationId, amount);
});
}
protected Account GetAccountEntity(string loginName)
{
IAccountRepository accountRepository = _DataRepositoryFactory.GetDataRepository <IAccountRepository>();
Account acctEntity = accountRepository.GetByLogin(loginName);
if (acctEntity == null)
{
NotFoundFault fault = new NotFoundFault(string.Format("Cannot find account for login name {0} to use as thread principal.", loginName));
throw new FaultException <NotFoundFault>(fault, fault.Message);
}
return(acctEntity);
}
public Strategy GetStrategy(int strategyId)
{
return(ExecuteFaultHandledOperation(() =>
{
Strategy strategy = GetStrategies().Where(s => s.StrategyID == strategyId).FirstOrDefault();
if (strategy == null)
{
NotFoundFault fault = new NotFoundFault(string.Format("No strategy found for id '{0}'.", strategyId));
throw new FaultException <NotFoundFault>(fault, fault.Message);
}
return strategy;
}));
}
public Broker GetBroker(int brokerId)
{
return(ExecuteFaultHandledOperation(() =>
{
Broker broker = GetBrokers().Where(b => b.BrokerID == brokerId).FirstOrDefault();
if (broker == null)
{
NotFoundFault fault = new NotFoundFault(string.Format("No broker found with BrokeID '{0}'.", brokerId));
throw new FaultException <NotFoundFault>(fault, fault.Message);
}
return broker;
}));
}
public Broker GetBrokerByName(string name)
{
return(ExecuteFaultHandledOperation(() =>
{
Broker broker = GetBrokers().Where(b => b.Name == name).FirstOrDefault();
if (broker == null)
{
NotFoundFault fault = new NotFoundFault(string.Format("No broker found with name '{0}'.", name));
throw new FaultException <NotFoundFault>(fault, fault.Message);
}
return broker;
}));
}
public MetaSetting GetSetting(string type, string code, bool enabledOnly = true)
{
return(ExecuteFaultHandledOperation(() =>
{
IMetaSettingRepository settingRepository = _DataRepositoryFactory.GetDataRepository <IMetaSettingRepository>();
MetaSetting setting = settingRepository.GetSetting(type, code, enabledOnly);
if (setting == null)
{
NotFoundFault fault = new NotFoundFault(string.Format("No setting found for type-code: [{0}]-[{1}].", type, code));
throw new FaultException <NotFoundFault>(fault, fault.Message);
}
return setting;
}));
}
public MetaResource GetResource(string set, string type, string key, string cultureCode = "en-US", bool enabled = true)
{
return(ExecuteFaultHandledOperation(() =>
{
IMetaResourceRepository resourceRepository = _DataRepositoryFactory.GetDataRepository <IMetaResourceRepository>();
MetaResource resource = resourceRepository.GetResource(set, type, key, cultureCode, enabled);
if (resource == null)
{
NotFoundFault fault = new NotFoundFault(string.Format("No resource found for set-type-code-culture-enabled: [{0}]-[{1}]-[{2}]-[{3}]-[{4}].", set, type, key, cultureCode, enabled));
throw new FaultException <NotFoundFault>(fault, fault.Message);
}
return resource;
}));
}
public MetaLookup GetLookup(string type, string code, bool enabled = true)
{
return(ExecuteFaultHandledOperation(() =>
{
IMetaLookupRepository lookupRepository = _DataRepositoryFactory.GetDataRepository <IMetaLookupRepository>();
MetaLookup lookup = lookupRepository.GetLookup(type, code, enabled);
if (lookup == null)
{
NotFoundFault fault = new NotFoundFault(string.Format("No lookup found for type-code: [{0}]-[{1}].", type, code));
throw new FaultException <NotFoundFault>(fault, fault.Message);
}
return lookup;
}));
}
public StrategyTransaction GetStrategyTransaction(int transactionId)
{
return(ExecuteFaultHandledOperation(() =>
{
IStrategyTransactionRepository transactionRepository = _DataRepositoryFactory.GetDataRepository <IStrategyTransactionRepository>();
StrategyTransaction transaction = transactionRepository.Get(transactionId);
if (transaction == null)
{
NotFoundFault fault = new NotFoundFault(string.Format("No transaction found with id '{0}'.", transactionId));
throw new FaultException <NotFoundFault>(fault, fault.Message);
}
return transaction;
}));
}
public Reservation GetReservation(int reservationId)
{
return(ExecuteFaultHandledOperation(() =>
{
IReservationRepository reservationRepository = _DataRepositoryFactory.GetDataRepository <IReservationRepository>();
Reservation reservation = reservationRepository.Get(reservationId);
if (reservation == null)
{
NotFoundFault fault = new NotFoundFault(string.Format("No reservation found for id '{0}'.", reservationId));
throw new FaultException <NotFoundFault>(fault, fault.Message);
}
ValidateAuthorization(reservation);
return reservation;
}));
}
public Participation GetParticipation(int participationId)
{
return(ExecuteFaultHandledOperation(() =>
{
IParticipationRepository ParticipationRepository = _DataRepositoryFactory.GetDataRepository <IParticipationRepository>();
Participation participation = ParticipationRepository.Get(participationId);
if (participation == null)
{
NotFoundFault fault = new NotFoundFault(string.Format("No participation record found for id '{0}'.", participationId));
throw new FaultException <NotFoundFault>(fault, fault.Message);
}
ValidateAuthorization(participation);
return participation;
}));
}
public Participation[] GetParticipationsByAccount(string loginEmail)
{
return(ExecuteFaultHandledOperation(() =>
{
IAccountRepository accountRepository = _DataRepositoryFactory.GetDataRepository <IAccountRepository>();
IParticipationRepository ParticipationRepository = _DataRepositoryFactory.GetDataRepository <IParticipationRepository>();
Account account = accountRepository.GetByLogin(loginEmail);
if (account == null)
{
NotFoundFault fault = new NotFoundFault(string.Format("No account found for login '{0}'.", loginEmail));
throw new FaultException <NotFoundFault>(fault, fault.Message);
}
ValidateAuthorization(account);
IEnumerable <Participation> participations = ParticipationRepository.GetParticipationsByAccount(account.AccountID);
return participations.ToArray();
}));
}
public void ExecuteParticipationsFromReservation(int reservationId)
{
ExecuteFaultHandledOperation(() =>
{
IAccountRepository accountRepository = _DataRepositoryFactory.GetDataRepository <IAccountRepository>();
IReservationRepository reservationRepository = _DataRepositoryFactory.GetDataRepository <IReservationRepository>();
IParticipationEngine ParticipationEngine = _BusinessEngineFactory.GetBusinessEngine <IParticipationEngine>();
Reservation reservation = reservationRepository.Get(reservationId);
if (reservation == null)
{
NotFoundFault fault = new NotFoundFault(string.Format("Reservation {0} was not found.", reservationId));
throw new FaultException <NotFoundFault>(fault, fault.Message);
}
Account account = accountRepository.Get(reservation.AccountID);
if (account == null)
{
NotFoundFault fault = new NotFoundFault(string.Format("No account found for account ID '{0}'.", reservation.AccountID));
throw new FaultException <NotFoundFault>(fault, fault.Message);
}
// create the new participations
foreach (Allocation allocation in reservation.Allocations)
{
try
{
Participation participation = ParticipationEngine.PushAllocationIntoParticipation(allocation);
}
catch (FaultException ex)
{
throw ex;
}
}
// close and save the reservation
reservation.Open = false;
reservationRepository.Update(reservation);
});
}
