public override bool Approve(IInternalEmployeeLogin employee, bool raiseStornoLimitExceptions)
{
bool success = approve(employee, raiseStornoLimitExceptions);
if (success && !IsStorno)
setOrderStatus(OrderStateEvents.CheckFill);
return success;
}
public ModelHistory(IAccountTypeCustomer account, ILifecycle lifecycle, IPortfolioModel model,
bool isExecOnlyCustomer, AccountEmployerRelationship employerRelationship,
IInternalEmployeeLogin employee, DateTime changeDate)
{
Account = account;
Lifecycle = lifecycle;
ModelPortfolio = model;
IsExecOnlyCustomer = isExecOnlyCustomer;
EmployerRelationship = employerRelationship;
Employee = employee;
ChangeDate = changeDate.Date;
}
public RemisierHistory(IRemisierEmployee remisierEmployee,
decimal kickBack, decimal introductionFee, decimal introductionFeeReduction,
decimal subsequentDepositFee, decimal subsequentDepositFeeReduction,
IInternalEmployeeLogin employee, DateTime changeDate)
{
RemisierEmployee = remisierEmployee;
KickBack = kickBack;
IntroductionFee = introductionFee;
SubsequentDepositFee = subsequentDepositFee;
IntroductionFeeReduction = introductionFeeReduction;
SubsequentDepositFeeReduction = subsequentDepositFeeReduction;
Employee = employee;
ChangeDate = changeDate.Date;
}
public abstract IGeneralOperationsBooking Storno(IInternalEmployeeLogin employee, string reason, IMemorialBooking journalEntry);
public override IGeneralOperationsBooking Storno(IInternalEmployeeLogin employee, string reason, IMemorialBooking journalEntry)
{
CashDividend newStorno = new CashDividend();
newStorno.DividendDetails = this.DividendDetails;
newStorno.UnitsInPossession = this.UnitsInPossession;
return this.storno(employee, reason, journalEntry, newStorno);
}
public override bool Approve(IInternalEmployeeLogin employee, bool raiseStornoLimitExceptions)
{
return approve(employee, raiseStornoLimitExceptions);
}
public override bool Approve(IInternalEmployeeLogin employee)
{
return Approve(employee, false);
}
public override IGeneralOperationsBooking Storno(IInternalEmployeeLogin employee, string reason, IMemorialBooking journalEntry)
{
if (Status != BondCouponPaymentStati.Settled)
throw new ApplicationException("It is not possible to storno a bond interest payements that has not a status of paid.");
if (Position.BondCouponPayments.Where(x =>
x.CouponHistory.StartAccrualDate > this.CouponHistory.EndAccrualDate &&
((x.Status == BondCouponPaymentStati.Settled &&
!(x.StornoBooking != null || x.IsStorno)) ||
x.Status == BondCouponPaymentStati.Active)).Count() > 0)
throw new ApplicationException(string.Format("Bond interest payements exists after {0} that should be stornoed first.", CouponHistory.EndAccrualDate.ToShortDateString()));
BondCouponPayment newStorno = new BondCouponPayment();
newStorno.Position = this.Position;
newStorno.CouponHistory = this.CouponHistory;
newStorno.Status = this.Status;
newStorno.IsNotarizable = this.IsNotarizable;
DateTime newLastDate = CouponHistory.StartAccrualDate.AddDays(-1);
if (newLastDate < Position.OpenDate) newLastDate = Position.OpenDate;
Position.LastBondCouponCalcDate = newLastDate;
return this.storno(employee, reason, journalEntry, newStorno);
}
/// <summary>
/// The method to alter the Model portfolio
/// </summary>
/// <param name="lifecycle">The current lifecycle</param>
/// <param name="newModelPortfolio">The new model portfolio</param>
/// <param name="isExecOnlyCustomer">Is this an execution only customer</param>
/// <param name="employerRelationship">The relationship that the account has to the company</param>
/// <param name="employee">The employee who performs the change</param>
/// <param name="changeDate">The date of the change</param>
/// <returns></returns>
public bool SetModelPortfolio(ILifecycle lifecycle, IPortfolioModel newModelPortfolio,
bool isExecOnlyCustomer, AccountEmployerRelationship employerRelationship,
IInternalEmployeeLogin employee, DateTime changeDate)
{
ModelPortfolioChanges.Add(new ModelHistory.ModelHistory(this, lifecycle, newModelPortfolio, isExecOnlyCustomer, employerRelationship, employee, changeDate));
IsExecOnlyCustomer = isExecOnlyCustomer;
if (this.AccountType == AccountTypes.Customer)
((ICustomerAccount)this).EmployerRelationship = employerRelationship;
ModelPortfolio = newModelPortfolio;
if (CurrentManagementFeePeriod == null && Util.IsNotNullDate(FirstManagementStartDate) && Util.IsNullDate(FinalManagementEndDate))
createManagementFeePeriod(changeDate);
return true;
}
public static bool StornoBondTransaction(IDalSession session, ITransaction storno, IInternalEmployeeLogin employee)
{
bool success = false;
if (storno.Approved)
{
IList<IBondCouponPayment> bondPaymentsToStorno = storno.GetBondPaymentsToStorno();
if (bondPaymentsToStorno != null && bondPaymentsToStorno.Count > 0)
{
IGLLookupRecords lookups = null;
int journalID = int.Parse((string)(System.Configuration.ConfigurationManager.AppSettings.Get("DefaultAccruedInterestJournal")));
IJournal journal = JournalMapper.GetJournal(session, journalID);
foreach (IBondCouponPayment payment in bondPaymentsToStorno.OrderByDescending(x => x.CouponHistory.StartAccrualDate))
{
if (payment.Status == BondCouponPaymentStati.Active || payment.Status == BondCouponPaymentStati.ToBeSettled)
{
if (lookups == null)
lookups = GlLookupRecordMapper.GetGLLookupRecords(session, BookingComponentParentTypes.AccruedInterest);
payment.Cancel();
success = true;
}
else if (payment.Status == BondCouponPaymentStati.Settled)
{
string nextJournalEntryNumber = JournalEntryMapper.GetNextJournalEntryNumber(session, journal);
IMemorialBooking memorialBooking = new MemorialBooking(journal, nextJournalEntryNumber);
memorialBooking.TransactionDate = payment.CouponHistory.EndAccrualDate;
payment.Storno(employee, storno.StornoReason, memorialBooking);
success = true;
}
}
}
}
return success;
}
public override IGeneralOperationsBooking Storno(IInternalEmployeeLogin employee, string reason, IMemorialBooking journalEntry)
{
CashTransfer newStorno = new CashTransfer();
return this.storno(employee, reason, journalEntry, newStorno);
}
public override IGeneralOperationsBooking Storno(IInternalEmployeeLogin employee, string reason, IMemorialBooking journalEntry)
{
ManagementFee newStorno = new ManagementFee();
newStorno.StartDate = this.StartDate;
newStorno.EndDate = this.EndDate;
newStorno.Units = this.Units;
IManagementFee stornoBooking = (IManagementFee)this.storno(employee, reason, journalEntry, newStorno);
stornoBooking.BookLines();
return stornoBooking;
}
public bool Edit(IPortfolioModel model, bool isExecOnlyCustomer, AccountEmployerRelationship employerRelationship,
IInternalEmployeeLogin employee, DateTime changeDate)
{
// It is not possible to edit the model, IsExecOnlyCustomer || EmployerRelationship for the latest item
if (EndDate == DateTime.MinValue)
{
if (this.ModelPortfolio != model ||
this.IsExecOnlyCustomer != isExecOnlyCustomer ||
this.EmployerRelationship != employerRelationship)
throw new ApplicationException("It is not possible to update data on the latest history item. Otherwise the data would no longer be in sync");
if (changeDate != this.ChangeDate && Account != null && Account.ModelPortfolioChanges != null && Account.ModelPortfolioChanges.Count > 0)
{
int check = (from a in Account.ModelPortfolioChanges
where a.Key != this.Key && a.ChangeDate > changeDate
select a).Count();
if (check > 0)
throw new ApplicationException("It is not possible to change the date of the latest history item to a date prior a previous history items.");
}
}
this.ModelPortfolio = model;
this.IsExecOnlyCustomer = isExecOnlyCustomer;
this.EmployerRelationship = employerRelationship;
this.ChangeDate = changeDate;
this.Employee = employee;
return true;
}
protected IGeneralOperationsBooking storno(IInternalEmployeeLogin employee, string reason, IMemorialBooking journalEntry, IGeneralOperationsBooking stornoBooking)
{
if (employee == null)
throw new ApplicationException(
"Creating a Storno is not possible if employee not specified.");
if (employee != null)
employee.VerifyStornoLimit(this.Components.TotalBaseAmount.Abs(), true);
stornoBooking.Account = Account;
stornoBooking.GeneralOpsJournalEntry = journalEntry;
stornoBooking.Description = Description;
stornoBooking.TaxPercentage = TaxPercentage;
stornoBooking.IsStorno = true;
stornoBooking.StornoReason = reason;
stornoBooking.OriginalBooking = this;
stornoBooking.CreationDate = DateTime.Now;
foreach (IGeneralOperationsComponent comp in this.Components)
{
IGeneralOperationsComponent newComp = comp.CloneAndStorno(stornoBooking);
newComp.MainLine = newComp.JournalLines.Where(x => x.GiroAccount != null).FirstOrDefault();
stornoBooking.Components.Add(newComp);
newComp.ParentBooking = stornoBooking;
}
this.StornoBooking = stornoBooking;
return StornoBooking;
}
/// <summary>
/// The method to alter the Model portfolio
/// </summary>
/// <param name="newModelPortfolio">The new model portfolio</param>
/// <param name="isExecOnlyCustomer">Is this an execution only customer</param>
/// <param name="employerRelationship">The relationship that the account has to the company</param>
/// <param name="employee">The employee who performs the change</param>
/// <returns>true when successfull</returns>
public bool SetModelPortfolio(IPortfolioModel newModelPortfolio, IInternalEmployeeLogin employee, DateTime changeDate)
{
AccountEmployerRelationship employerRelationship = AccountEmployerRelationship.None;
if (this.AccountType == AccountTypes.Customer)
employerRelationship = ((ICustomerAccount)this).EmployerRelationship;
if (Util.IsNullDate(changeDate))
changeDate = DateTime.Now;
return SetModelPortfolio(Lifecycle, newModelPortfolio, this.IsExecOnlyCustomer, employerRelationship, employee, changeDate);
}
public override ITransaction Storno(IAccountTypeInternal stornoAccount, IInternalEmployeeLogin employee, string reason, ITradingJournalEntry tradingJournalEntry)
{
ITransactionNTM newStorno = new TransactionNTM();
this.storno(stornoAccount, employee, reason, tradingJournalEntry, newStorno);
return newStorno;
}
public override bool Approve(IInternalEmployeeLogin employee, bool raiseStornoLimitExceptions)
{
createPositionTxs(AccountA, AccountB, ConvertedInstrumentSize, PositionsTxValueTypes.Conversion);
return approve(employee, raiseStornoLimitExceptions);
}
