/// <summary> /// Initializes a new instance of the <see cref="T:B4F.TotalGiro.Accounts.Instructions.ClientDepartureInstruction">ClientDepartureInstruction</see> class. /// </summary> /// <param name="account">The account the withdrawal will belong to</param> /// <param name="executionDate">The date the instruction should execute</param> /// <param name="doNotChargeCommission">The instruction is without any charges</param> /// <param name="counterAccount">counter Account</param> /// <param name="transferDescription">transfer Description</param> public ClientDepartureInstruction(IAccountTypeCustomer account, DateTime executionDate, bool doNotChargeCommission, ICounterAccount counterAccount, string transferDescription) : base(account, executionDate, OrderActionTypes.Departure, doNotChargeCommission, null) { this.CounterAccount = counterAccount; this.TransferDescription = transferDescription; this.status = ClientDepartureInstructionStati.New; }
/// <summary> /// Initializes a new instance of the <see cref="T:B4F.TotalGiro.Accounts.Instructions.InstructionTypeRebalance">InstructionTypeRebalance</see> class. /// </summary> /// <param name="account">The account the withdrawal will belong to</param> /// <param name="executionDate">The date the instruction should execute</param> /// <param name="orderActionType">The type of instruction that is placed on the orders</param> /// <param name="doNotChargeCommission">The instruction is without any charges</param> /// <param name="cashTransfers">The transfers involved</param> internal InstructionTypeRebalance(IAccountTypeCustomer account, DateTime executionDate, OrderActionTypes orderActionType, bool doNotChargeCommission, IList<IJournalEntryLine> cashTransfers) : base(account, executionDate, doNotChargeCommission) { this.OrderActionType = orderActionType; this.status = RebalanceInstructionStati.New; CashTransfers.AddTransfers(cashTransfers); }
public GeneralOperationsBookingTaxeable(IAccountTypeCustomer account, IMemorialBooking journalEntry, string description, decimal taxPercentage) : base(account, journalEntry, description) { if (taxPercentage < 0 || taxPercentage > 1) throw new ApplicationException("The Tax Percentage can only be between 0 and 1"); this.TaxPercentage = taxPercentage; }
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; }
/// <summary> /// Initializes a new instance of the <see cref="T:B4F.TotalGiro.Accounts.Instructions.CashWithdrawalInstruction">CashWithdrawalInstruction</see> class. /// </summary> /// <param name="account">The account the withdrawal will belong to</param> /// <param name="executionDate">The day from which the instruction should be taken into account</param> /// <param name="withdrawalDate">The day that the money should be withdrawn</param> /// <param name="amount">The relevant amount</param> /// <param name="counterAccount">The account the money should go to</param> /// <param name="rule">The rule that is responsible for this periodic instruction</param> /// <param name="doNotChargeCommission">The instruction is without any charges</param> internal CashWithdrawalInstruction(IAccountTypeCustomer account, DateTime executionDate, DateTime withdrawalDate, Money amount, ICounterAccount counterAccount, IWithdrawalRule rule, string transferDescription, bool doNotChargeCommission) : base(account, executionDate, doNotChargeCommission) { this.Account = account; this.WithdrawalDate = withdrawalDate; this.Amount = amount; this.CounterAccount = counterAccount; this.Rule = rule; this.TransferDescription = transferDescription; this.status = CashWithdrawalInstructionStati.New; if (rule != null) this.IsPeriodic = true; }
/// <summary> /// Constructor /// </summary> /// <param name="dividendDetails">The details of the cash dividend (date, price)</param> /// <param name="units">The total number of units over which dividend is paid</param> public CashDividend(IAccountTypeCustomer account, IMemorialBooking journalEntry, string description, decimal taxPercentage, IDividendHistory dividendDetails, InstrumentSize units, IGLLookupRecords lookups) : base(account, journalEntry, description, taxPercentage) { if (dividendDetails == null) throw new ApplicationException("Dividend details are mandatory."); if (units == null || units.IsZero) throw new ApplicationException("The number of units is mandatory."); this.DividendDetails = dividendDetails; this.UnitsInPossession = units; //this.CashGeneratingInstrument = dividendDetails.Instrument; createComponents(lookups); }
public ManagementFee(IAccountTypeCustomer account, DateTime startDate, DateTime endDate, IList<IManagementPeriodUnit> units, IMemorialBooking journalEntry, decimal taxPercentage, IGLLookupRecords lookups) : base(account, journalEntry, journalEntry.Description, taxPercentage) { this.StartDate = startDate; this.EndDate = endDate; if (units == null) throw new ApplicationException("The units can not be null"); foreach (IManagementPeriodUnit unit in units) { if (unit.ManagementFee != null) throw new ApplicationException(string.Format("The unit {0} is already used for a management fee transaction.", unit.Key.ToString())); if (!(unit.Success && unit.FeesCalculated == FeesCalculatedStates.Yes)) throw new ApplicationException(string.Format("The unit {0} is not correct for the management fee transaction.", unit.Key.ToString())); } this.Units = units; this.GeneralOpsJournalEntry = journalEntry; createComponents(lookups); }
private void setAccountValidityDate(IDalSession session, IAccountTypeCustomer account, DateTime maxValuationDate) { account.ValuationMutationValidityDate = maxValuationDate; session.Update(account); }
private bool runValuationMutationsForAccount(IDalSession session, IAccountTypeCustomer account, DateTime maxDate, out string message) { bool success = false; message = ""; try { IList<IFundPositionTx> posTxs; IList<IJournalEntryLine> lines; List<IValuationMutation> mutationsToSave = null; IValuationCashMutation[] cashMutationsToSave = null; if (getFundPositionTxData(session, account, maxDate, out posTxs)) { // Calculate the valuations runValuationMutationJobForAccount(session, posTxs, account, maxDate, ref mutationsToSave); } if (getJournalEntryLineData(session, account, maxDate, out lines)) { // Calculate the valuations runValuationMutationJobForAccount(session, lines, account, maxDate, ref mutationsToSave); // Calculate the cash valuations runCashValuationMutationJobForAccount(session, lines, account, maxDate, out cashMutationsToSave); } // save data saveMutations(session, ref mutationsToSave, ref cashMutationsToSave); // Get the ValuationMutationValidityDate of the mutations DateTime validityDate = DateTime.MinValue; foreach (ICommonPosition pos in account.Portfolio.AllPositions) { if (pos.LastMutation != null && pos.LastMutation.Size.IsZero) { if (validityDate < pos.LastMutation.Date) validityDate = pos.LastMutation.Date; } else { // Not all positions are closed -> take maxDate validityDate = maxDate; break; } } //// save the Validity Date setAccountValidityDate(session, account, validityDate); success = true; } catch (Exception ex) { message = Util.GetMessageFromException(ex); string logMessage = string.Format("Error in runValuationMutationsForAccount -> account: {0}; {1}", account.Key, message); log.Error(logMessage); } return success; }
private void runValuationMutationJobForAccount(IDalSession session, IList<IJournalEntryLine> lines, IAccountTypeCustomer account, DateTime maxDate, ref List<IValuationMutation> mutationsToSave) { ////raiseProgressEvent(string.Format("Create valuations for {0}", account.DisplayNumberWithName)); IDictionary<string, IValuationMutation> mutations = new Dictionary<string, IValuationMutation>(); IMonetaryValuationMutation mutation; IList<IJournalEntryLine> notRelevantLines = new List<IJournalEntryLine>(); if (lines != null && lines.Count > 0) { foreach (IJournalEntryLine line in lines) { if (line.BookDate <= maxDate && (Util.IsNullDate(account.ValuationsEndDate) || line.BookDate <= account.ValuationsEndDate)) { if (line.IsRelevant && line.ParentSubPosition.SettledFlag == CashPositionSettleStatus.Settled) { if (line.ParentSubPosition.ParentPosition.LastMutation == null) mutation = new MonetaryValuationMutation(line); else { // check that Date of LastMutation is not after the TxDate if (line.ParentSubPosition.ParentPosition.LastMutation.Date > line.BookDate) throw new ApplicationException(string.Format("The date of the LastMutation can not be greater than the TxDate for Account: {0}, Instrument: {1}, Date: {2}", account.Key, line.Currency.Key, line.BookDate)); // Is the TxDate the same if (line.ParentSubPosition.ParentPosition.LastMutation.Date.Equals(line.BookDate)) mutation = (IMonetaryValuationMutation)line.ParentSubPosition.ParentPosition.LastMutation; // else Create New Valuation from Previous Valuation else mutation = new MonetaryValuationMutation(line.BookDate, (IMonetaryValuationMutation)line.ParentSubPosition.ParentPosition.LastMutation); } mutation.AddLine(line); account.Portfolio.PortfolioCashGL.GetPosition(line.Currency).LastMutation = mutation; if (!mutations.Keys.Contains(mutation.GetUniqueCode)) mutations.Add(mutation.GetUniqueCode, mutation); } else notRelevantLines.Add(line); } } if (mutations != null && mutations.Count > 0) { if (mutationsToSave == null) mutationsToSave = new List<IValuationMutation>(mutations.Count); mutationsToSave.AddRange(mutations.Values); if (notRelevantLines.Count > 0) addNotRelevantLinesToMutations(ref mutationsToSave, notRelevantLines); // Validate mutations foreach (IValuationMutation mut in mutationsToSave) mut.Validate(); } else if (notRelevantLines.Count > 0) { IValuationMutation mut = lines[0].ParentSubPosition.ParentPosition.LastMutation; if (mut != null) { mutationsToSave = new List<IValuationMutation>(1); mutationsToSave.Add(mut); addNotRelevantLinesToMutations(ref mutationsToSave, notRelevantLines); } } } }
public void ResetValuations(IDalSession session, IAccountTypeCustomer account) { // Run TG_ResetValuations //raiseProgressEvent(string.Format("Run TG_ResetValuations for {0}", (account != null ? account.DisplayNumberWithName: "all accounts"))); SqlCommand command = new SqlCommand("TG_ResetValuations", (SqlConnection)session.Connection); SqlParameter param1 = new SqlParameter("endDate", MaxValuationDate); command.Parameters.Add(param1); SqlParameter param2 = new SqlParameter("AccountID", (account != null ? account.Key : 0)); command.Parameters.Add(param2); command.CommandType = CommandType.StoredProcedure; command.CommandTimeout = 0; int i = command.ExecuteNonQuery(); }
private void runValuationMutationJobForAccount(IDalSession session, IList<IFundPositionTx> posTxs, IAccountTypeCustomer account, DateTime maxDate, ref List<IValuationMutation> mutationsToSave) { ////raiseProgressEvent(string.Format("Create valuations for {0}", account.DisplayNumberWithName)); IDictionary<string, IValuationMutation> mutations = new Dictionary<string, IValuationMutation>(); ISecurityValuationMutation mutation; IList<IFundPositionTx> notRelevantPositionTxs = new List<IFundPositionTx>(); if (posTxs != null && posTxs.Count > 0) { foreach (IFundPositionTx posTx in posTxs) { if (posTx.TransactionDate <= maxDate && (Util.IsNullDate(account.ValuationsEndDate) || posTx.TransactionDate <= account.ValuationsEndDate)) { if (posTx.IsRelevant) { if (posTx.ParentPosition.LastMutation == null) { IList<IFundPosition> convertedPositions = null; if (posTx.IsConversion) { // Check whether the Instrument has changed convertedPositions = getPositionsConvertedInstrument(posTx.Instrument, account.Portfolio.PortfolioInstrument); } if (convertedPositions != null && convertedPositions.Count > 0) mutation = new SecurityValuationMutation(convertedPositions, posTx, posTx.TransactionDate); // Create Complete New Valuation else mutation = new SecurityValuationMutation(posTx); } else { // check that Date of LastMutation is not after the TxDate if (posTx.ParentPosition.LastMutation.Date > posTx.TransactionDate) throw new ApplicationException(string.Format("The date of the LastMutation can not be greater than the TxDate for Account: {0}, Instrument: {1}, Date: {2}", posTx.Account.Key, posTx.Instrument.Key, posTx.TransactionDate)); // Is the TxDate the same if (posTx.ParentPosition.LastMutation.Date.Equals(posTx.TransactionDate)) mutation = (ISecurityValuationMutation)posTx.ParentPosition.LastMutation; // else Create New Valuation from Previous Valuation else mutation = new SecurityValuationMutation(posTx.TransactionDate, (ISecurityValuationMutation)posTx.ParentPosition.LastMutation); } mutation.AddTx(posTx); account.Portfolio.PortfolioInstrument.GetPosition(posTx.Instrument).LastMutation = mutation; if (!mutations.Keys.Contains(mutation.GetUniqueCode)) mutations.Add(mutation.GetUniqueCode, mutation); } else notRelevantPositionTxs.Add(posTx); } } if (mutations != null && mutations.Count > 0) { mutationsToSave = mutations.Values.ToList(); if (notRelevantPositionTxs.Count > 0) addNotRelevantPosTxToMutations(ref mutationsToSave, notRelevantPositionTxs); // Validate mutations foreach (IValuationMutation mut in mutationsToSave) mut.Validate(); } } }
private void runCashValuationMutationJobForAccount(IDalSession session, IList<IJournalEntryLine> lines, IAccountTypeCustomer account, DateTime maxDate, out IValuationCashMutation[] cashMutationsToSave) { //raiseProgressEvent(string.Format("Create Cash valuations for {0}", account.DisplayNumberWithName)); cashMutationsToSave = null; IDictionary<string, IValuationCashMutation> mutations = new Dictionary<string, IValuationCashMutation>(); IValuationCashMutation mutation; IList<IJournalEntryLine> notRelevantLines = new List<IJournalEntryLine>(); if (lines != null && lines.Count > 0) { foreach (IJournalEntryLine line in lines.Where(u => u.GLAccount.ValuationCashType != ValuationCashTypes.None)) { if (line.BookDate <= maxDate && (Util.IsNullDate(account.ValuationsEndDate) || line.BookDate <= account.ValuationsEndDate)) { if (line.IsRelevant) { ValuationCashMutationKey key = new ValuationCashMutationKey((IAccountTypeCustomer)line.GiroAccount, line.BookingRelatedInstrument, line.GLAccount.ValuationCashType); // search key in account // It's possible because of storno's or earlier tx that there is no LastCashMutation // In this case create new CashMutation if (account.LastValuationCashMutations.Count > 0 && account.LastValuationCashMutations.ContainsKey(key) && account.LastValuationCashMutations[key].LastCashMutation != null) { ILastValuationCashMutationHolder holder = account.LastValuationCashMutations[key]; // If pos Date is earlier than last recorded date -> skip it if (holder.LastCashMutation.Date <= line.BookDate) { // Is the TxDate the same if (holder.LastCashMutation.Date.Equals(line.BookDate)) { // check whether line not already stored if (!holder.LastCashMutation.ContainsLine(line)) mutation = holder.LastCashMutation; else mutation = null; } else { mutation = new ValuationCashMutation(line.BookDate, holder.LastCashMutation); } } else mutation = null; } else { // Create Complete New Cash Valuation mutation = new ValuationCashMutation(line); } if (mutation != null) { mutation.AddLine(line); if (account.LastValuationCashMutations.ContainsKey(key)) account.LastValuationCashMutations[key].LastCashMutation = mutation; else account.LastValuationCashMutations.Add(key, mutation); if (!mutations.Keys.Contains(mutation.GetUniqueCode)) mutations.Add(mutation.GetUniqueCode, mutation); } } else notRelevantLines.Add(line); } } if (mutations != null && mutations.Count > 0) { cashMutationsToSave = new IValuationCashMutation[mutations.Count]; mutations.Values.CopyTo(cashMutationsToSave, 0); if (notRelevantLines.Count > 0) addNotRelevantLinesToCashMutations(ref cashMutationsToSave, notRelevantLines); // Validate mutations foreach (IValuationCashMutation mut in cashMutationsToSave) mut.Validate(); } } }
public static string GetAllMessages(IAccountTypeCustomer account, bool HTMLLayout, out NotificationTypes notificationType) { if (account == null) throw new ApplicationException("The account can not be null"); IList<Notification> notifications = account.Notifications; if (account.PrimaryAccountHolder != null && account.PrimaryAccountHolder.Contact != null && account.PrimaryAccountHolder.Contact.Notifications.Count > 0) { foreach (Notification notification in account.PrimaryAccountHolder.Contact.Notifications) { if (notification.IsActive && !notifications.Contains(notification)) notifications.Add(notification); } } return GetAllMessages(notifications, HTMLLayout, out notificationType); }
private bool getFundPositionTxData(IDalSession session, IAccountTypeCustomer account, DateTime maxDate, out IList<IFundPositionTx> posTxs) { Hashtable parameters = new Hashtable(); parameters.Add("accountID",account.Key); parameters.Add("maxDate",maxDate); posTxs = session.GetTypedListByNamedQuery<IFundPositionTx>( "B4F.TotalGiro.Valuations.GetFundPositionTxData", parameters); return (posTxs != null && posTxs.Count > 0); }
public bool RunDailyValuationsForAccount(IDalSession session, IAccountTypeCustomer account, DateTime lastValuationDate, out string message) { bool success = false; message = ""; try { SqlCommand command = new SqlCommand("TG_CreateValuationsForAccount", (SqlConnection)session.Connection); SqlParameter param1 = new SqlParameter("AccountID", account.Key); command.Parameters.Add(param1); SqlParameter param2 = new SqlParameter("lastValuationDate", (Util.IsNullDate(lastValuationDate) ? null : lastValuationDate.ToString("yyyy-MM-dd"))); command.Parameters.Add(param2); SqlParameter param3 = new SqlParameter("success", success); param3.SqlDbType = SqlDbType.Bit; param3.Direction = ParameterDirection.Output; command.Parameters.Add(param3); SqlParameter param4 = new SqlParameter("errMessage", message); param4.SqlDbType = SqlDbType.VarChar; param4.Size = 2000; param4.Direction = ParameterDirection.Output; command.Parameters.Add(param4); command.CommandType = CommandType.StoredProcedure; command.CommandTimeout = 0; command.ExecuteNonQuery(); if (!((System.Data.SqlTypes.SqlString)param4.SqlValue).IsNull) message = param4.SqlValue.ToString(); success = ((System.Data.SqlTypes.SqlBoolean)param3.SqlValue).IsTrue; } catch (Exception ex) { message = Util.GetMessageFromException(ex); string logMessage = string.Format("Error in RunDailyValuationsForAccount -> account: {0}; {1}", account.Key, message); log.Error(logMessage); } return success; }
private static List<ICurrency> getCurrencies(IAccountTypeCustomer account, IInstrument instrument) { List<ICurrency> currencies = new List<ICurrency>(); ICurrency baseCurrency = null, instrumentCurrency = null; if (account != null) { baseCurrency = account.AccountOwner.StichtingDetails.BaseCurrency; currencies.Add(baseCurrency); } if (instrument != null) { instrumentCurrency = ((ITradeableInstrument)instrument).CurrencyNominal; if (!instrumentCurrency.IsActive && instrumentCurrency.ParentInstrument != null) instrumentCurrency = instrumentCurrency.ParentInstrument.ToCurrency; if (baseCurrency == null || baseCurrency.Key != instrumentCurrency.Key) currencies.Add(instrumentCurrency); } return currencies; }
public static AccountDetailsView GetAccountDetails(IAccountTypeCustomer account, ICurrency baseCurrency) { return account != null ? new AccountDetailsView(account) : new AccountDetailsView(baseCurrency); }
internal LastValuationCashMutationHolder(IAccountTypeCustomer account, ITradeableInstrument instrument, ValuationCashTypes valuationCashType, IValuationCashMutation lastCashMutation) { this.CashMutKey = new ValuationCashMutationKey(account, instrument, valuationCashType); this.LastCashMutation = lastCashMutation; }
public static DataSet GetPositions(IDalSession session, IAccountTypeCustomer account) { if (account != null) { List<PositionRowView> positionRowViews = FundPositionMapper.GetPositions(session, account, PositionsView.NotZero) .Select(p => new PositionRowView(p)) .ToList(); decimal totalValue = account.TotalPositionAmount(PositionAmountReturnValue.All).Quantity; if (totalValue != 0m) foreach (PositionRowView rowView in positionRowViews.Where(pv => pv.Value != null)) rowView.Percentage = Math.Round(100m * rowView.Value.Quantity / totalValue, 2); return positionRowViews.ToDataSet(); } else return (new List<PositionRowView>()).ToDataSet(); }
public void RunValuationMutationsForAccount(IDalSession session, IAccountTypeCustomer account, bool runSP) { DateTime maxDate = MaxValuationDate; string message; // Run TG_ResetValuations for account if (runSP) ResetValuations(session, account); bool success = runValuationMutationsForAccount(session, account, maxDate, out message); if (!success) throw new ApplicationException(message); }
/// <summary> /// Initializes a new instance of the <see cref="T:B4F.TotalGiro.Accounts.Instructions.BuyModelInstruction">BuyModelInstruction</see> class. /// </summary> /// <param name="account">The account the withdrawal will belong to</param> /// <param name="executionDate">The date the instruction should execute</param> /// <param name="orderActionType">The type of instruction that is placed on the orders</param> /// <param name="doNotChargeCommission">The instruction is without any charges</param> /// <param name="cashTransfers">The transfers involved</param> public BuyModelInstruction(IAccountTypeCustomer account, DateTime executionDate, OrderActionTypes orderActionType, bool doNotChargeCommission, IList<IJournalEntryLine> cashTransfers) : base(account, executionDate, orderActionType, doNotChargeCommission, cashTransfers) { //DepositCashPositionDifference = depositCashPositionDifference; }
private bool getJournalEntryLineData(IDalSession session, IAccountTypeCustomer account, DateTime maxDate, out IList<IJournalEntryLine> lines) { Hashtable parameters = new Hashtable(); parameters.Add("accountID", account.Key); parameters.Add("maxDate", maxDate); parameters.Add("settledFlag", CashPositionSettleStatus.Settled); parameters.Add("unSettledFlag", CashPositionSettleStatus.UnSettled); parameters.Add("statusBooked", JournalEntryLineStati.Booked); lines = session.GetTypedListByNamedQuery<IJournalEntryLine>( "B4F.TotalGiro.Valuations.GetJournalEntryLineData", parameters); return (lines != null && lines.Count > 0); }
public AccountDetailsView(IAccountTypeCustomer account) { AccountNumberWithName = account.DisplayNumberWithName; AccountName = account.ShortName; ManagementStartDate = account.ManagementStartDate; // Set the flag for Crumble account IsCrumbleAccount = account.AccountType == AccountTypes.Crumble; ICustomerAccount customerAccount = null; if (account.AccountType == AccountTypes.Customer) { customerAccount = (ICustomerAccount)account; if (customerAccount.AccountHolders.PrimaryAccountHolder != null) { PrimaryAccountHolderName = customerAccount.Formatter.AddressFirstLine; SecondaryAccountHolderName = customerAccount.Formatter.AddressSecondLine; StreetAddressLine = customerAccount.Formatter.Address.Get(a => a.StreetAddressLine); CityAddressLine = customerAccount.Formatter.Address.Get(a => a.CityAddressLine); CountryAddressLine = customerAccount.Formatter.Address.Get(a => a.CountryAddressLine); } if (customerAccount.RemisierEmployee != null) { RemisierEmployee = customerAccount.RemisierEmployee.LoginPerson.FullName; Remisier = customerAccount.RemisierEmployee.Remisier.Name; } if (customerAccount.VerpandSoort != null) VerpandSoort = Util.Capitalize(Util.SplitCamelCase(customerAccount.VerpandSoort.Description).ToLower()); if (customerAccount.PandHouder != null) Pandhouder = customerAccount.PandHouder.Name; } ModelName = account.ModelPortfolio != null ? account.ModelPortfolio.ModelName : ""; AccountNumber = account.Number; Status = account.Status; StatusIsOpen = account.Status == AccountStati.Active; IsTradeable = account.TradeableStatus == Tradeability.Tradeable; Money totalAll = account.TotalPositionAmount(PositionAmountReturnValue.All); Money totalCash = account.TotalCashAmount; Money totalPositions = totalAll - totalCash; TotalAll = totalAll.DisplayString; TotalCash = totalCash.DisplayString; TotalCashQuantity = totalCash.Quantity; TotalPositions = totalPositions.DisplayString; LastRebalanceDate = account.LastRebalanceDate; CurrentRebalanceDate = account.CurrentRebalanceDate; if (account.IsDeparting) { IsDeparting = true; FutureWithdrawalAmount = totalAll.Quantity; DisplayFutureWithdrawalAmount = TotalAll + " (Portfolio Liquidation)"; } else if (account.ActiveWithdrawalInstructions != null) { Money withdrawalAmount = account.ActiveWithdrawalInstructions.TotalAmount; if (withdrawalAmount != null && withdrawalAmount.IsNotZero) { FutureWithdrawalAmount = withdrawalAmount.Quantity; DisplayFutureWithdrawalAmount = withdrawalAmount.DisplayString; } } IsUnderRebalance = account.IsUnderRebalance; if (customerAccount != null && !(IsDeparting || IsUnderRebalance)) ActiveOrderCount = customerAccount.OpenOrdersForAccount.Count; // Notifications Notification = account.Notifications.DisplayMessages; NotificationType = account.Notifications.DisplayNotificationType; }