/// <summary>
/// Calculates the price of one currency in another base currency.
/// </summary>
/// <param name="baseCurrency">The base currency for the requested price.</param>
/// <param name="CurrencyId">The identifier of the currency.</param>
/// <returns>The price of the currency in the base currency</returns>
public static decimal Currency(DataModel.CurrencyRow baseCurrency, DataModel.CurrencyRow currencyRow)
{
// Look up the price in the security's native currency.
DataModel.PriceRow securityPriceRow =
DataModel.Price.FindBySecurityIdCurrencyId(currencyRow.CurrencyId, baseCurrency.CurrencyId);
if (securityPriceRow == null)
{
return(0.0M);
}
// Use the User Preferences to determine which price (Last, Closing) we should use.
decimal securityPrice = 0.0M;
if (Preferences.Pricing == Pricing.Last)
{
securityPrice = securityPriceRow.LastPrice;
}
if (Preferences.Pricing == Pricing.Close)
{
securityPrice = securityPriceRow.ClosePrice;
}
// The price, in the requested currency, is the native price multiplied by the cross currency price.
return(securityPrice);
}
/// <summary>
/// Calculates the market market value of the account and, optinally, all the sub-account.
/// </summary>
/// <param name="baseCurrency">The identifier of the base currency.</param>
/// <param name="accountRow">The identifier of the account.</param>
/// <returns>The market value of the account and, optinally, all the sub account in the base currency.</returns>
public static decimal Calculate(DataModel.CurrencyRow baseCurrency, DataModel.AccountRow accountRow,
MarketValueFlags marketValueFlags)
{
// This is the accumulator for market value.
decimal marketValue = 0.0M;
// Add up all the taxLot.
if ((marketValueFlags & MarketValueFlags.IncludeTaxLot) != 0)
{
foreach (DataModel.TaxLotRow taxLotRow in accountRow.GetTaxLotRows())
{
marketValue += Calculate(baseCurrency, taxLotRow);
}
}
// Add up all the proposedOrder.
if ((marketValueFlags & MarketValueFlags.IncludeProposedOrder) != 0)
{
foreach (DataModel.ProposedOrderRow proposedOrderRow in accountRow.GetProposedOrderRows())
{
marketValue += Calculate(baseCurrency, proposedOrderRow);
}
}
// Add up all the order.
if ((marketValueFlags & MarketValueFlags.IncludeOrder) != 0)
{
foreach (DataModel.OrderRow SetPrice in accountRow.GetOrderRows())
{
marketValue += Calculate(baseCurrency, SetPrice);
}
}
// Add up all the allocation.
if ((marketValueFlags & MarketValueFlags.IncludeAllocation) != 0)
{
foreach (DataModel.AllocationRow allocationRow in accountRow.GetAllocationRows())
{
marketValue += Calculate(baseCurrency, allocationRow);
}
}
// Add in the market value of the sub-account.
if ((marketValueFlags & MarketValueFlags.IncludeChildAccounts) != 0)
{
foreach (DataModel.ObjectTreeRow objectTreeRow in
accountRow.ObjectRow.GetObjectTreeRowsByFKObjectObjectTreeParentId())
{
foreach (DataModel.AccountRow childAccount in
objectTreeRow.ObjectRowByFKObjectObjectTreeChildId.GetAccountRows())
{
marketValue += Calculate(baseCurrency, childAccount, marketValueFlags);
}
}
}
// This is the market value of the given account in the base currency.
return(marketValue);
}
/// <summary>
/// Calculates the market value of the given Order in the base currency.
/// </summary>
/// <param name="baseCurrency">The base currency for the market value calculation.</param>
/// <param name="proposedOrderRow">The subject of the calculation.</param>
/// <returns>The market value of the Order in the base currency.</returns>
private static decimal Calculate(DataModel.CurrencyRow baseCurrency, DataModel.OrderRow SetPrice)
{
return(SetPrice.Quantity *
SetPrice.SecurityRowByFKSecurityOrderSecurityId.QuantityFactor *
Price.Security(baseCurrency, SetPrice.SecurityRowByFKSecurityOrderSecurityId) *
SetPrice.SecurityRowByFKSecurityOrderSecurityId.PriceFactor *
SetPrice.TransactionTypeRow.QuantitySign);
}
/// <summary>
/// Calculates the market value of the given Allocation in the base currency.
/// </summary>
/// <param name="baseCurrency">The base currency for the market value calculation.</param>
/// <param name="proposedOrderRow">The subject of the calculation.</param>
/// <returns>The market value of the Allocation in the base currency.</returns>
private static decimal Calculate(DataModel.CurrencyRow baseCurrency,
DataModel.AllocationRow allocationRow)
{
return(allocationRow.Quantity *
allocationRow.SecurityRowByFKSecurityAllocationSecurityId.QuantityFactor *
Price.Security(baseCurrency, allocationRow.SecurityRowByFKSecurityAllocationSecurityId) *
allocationRow.SecurityRowByFKSecurityAllocationSecurityId.PriceFactor *
allocationRow.TransactionTypeRow.QuantitySign);
}
/// <summary>
/// Calculates the market value of the given Proposed Order in the base currency.
/// </summary>
/// <param name="baseCurrency">The base currency for the market value calculation.</param>
/// <param name="proposedOrderRow">The subject of the calculation.</param>
/// <returns>The market value of the Proposed Order in the base currency.</returns>
private static decimal Calculate(DataModel.CurrencyRow baseCurrency,
DataModel.ProposedOrderRow proposedOrderRow)
{
return(proposedOrderRow.Quantity *
proposedOrderRow.SecurityRowByFKSecurityProposedOrderSecurityId.QuantityFactor *
Price.Security(baseCurrency, proposedOrderRow.SecurityRowByFKSecurityProposedOrderSecurityId) *
proposedOrderRow.SecurityRowByFKSecurityProposedOrderSecurityId.PriceFactor *
proposedOrderRow.TransactionTypeRow.QuantitySign);
}
/// <summary>
/// Calculates the price of a security.
/// </summary>
/// <param name="baseCurrency">The demonimation of the price.</param>
/// <param name="securityRow">The security to be priced.</param>
/// <returns>The price of the security in the requested denomination.</returns>
public static decimal Security(DataModel.CurrencyRow baseCurrency, DataModel.SecurityRow securityRow)
{
// Calculate the price of a Currency.
foreach (DataModel.CurrencyRow currencyRow in securityRow.GetCurrencyRows())
{
return(Price.Currency(baseCurrency, currencyRow));
}
// Calculate the price of a Debt.
foreach (DataModel.DebtRow debtRow in securityRow.GetDebtRowsByFKSecurityDebtDebtId())
{
return(Price.Debt(baseCurrency, debtRow));
}
// Calculate the price of an Equity.
foreach (DataModel.EquityRow equityRow in securityRow.GetEquityRowsByFKSecurityEquityEquityId())
{
return(Price.Equity(baseCurrency, equityRow));
}
// If the security isn't one of the major securityType, then it can't be priced.
return(0.0M);
}
/// <summary>
/// Calculates the market value of a sector in an account.
/// </summary>
/// <param name="baseCurrency">The base currency for the market value calculation.</param>
/// <param name="accountRow">The identifier of the account.</param>
/// <param name="SecurityId">The identifier of the security.</param>
/// <param name="marketValueFlags">These flags direct what elements are included and whether to include
/// children.</param>
/// <returns>The market value of the position.</returns>
public static decimal Calculate(DataModel.CurrencyRow baseCurrency, DataModel.AccountRow accountRow,
DataModel.SectorRow sectorRow, MarketValueFlags marketValueFlags)
{
// This is the accumulator for market value.
decimal marketValue = 0.0M;
// Aggregate the market value of sub-sector.
foreach (DataModel.ObjectTreeRow objectTreeRow in
sectorRow.ObjectRow.GetObjectTreeRowsByFKObjectObjectTreeParentId())
{
foreach (DataModel.SectorRow childSector in
objectTreeRow.ObjectRowByFKObjectObjectTreeChildId.GetSectorRows())
{
marketValue += Calculate(baseCurrency, accountRow, childSector, marketValueFlags);
}
}
// Aggregate the market value of all security belonging to this sector.
foreach (DataModel.ObjectTreeRow objectTreeRow in
sectorRow.ObjectRow.GetObjectTreeRowsByFKObjectObjectTreeParentId())
{
foreach (DataModel.SecurityRow childSecurity in
objectTreeRow.ObjectRowByFKObjectObjectTreeChildId.GetSecurityRows())
{
// Aggregate the Long Position in this security in this account.
marketValue += Calculate(baseCurrency, accountRow, childSecurity, PositionType.Long,
marketValueFlags);
// Aggregate the Short Position in this security in this account.
marketValue += Calculate(baseCurrency, accountRow, childSecurity, PositionType.Short,
marketValueFlags);
}
}
// This is the market value of the given account/sector combination.
return(marketValue);
}
/// <summary>
/// Calculates the price of a debt issue.
/// </summary>
/// <param name="baseCurrency">The base currency for the requested price.</param>
/// <param name="debtId">The identifier of a debt.</param>
/// <returns>The price of the debt in the base currency</returns>
public static decimal Debt(DataModel.CurrencyRow baseCurrency, DataModel.DebtRow debtRow)
{
// Look up the price in the security's native currency.
DataModel.PriceRow securityPriceRow = DataModel.Price.FindBySecurityIdCurrencyId(
debtRow.DebtId, debtRow.SettlementId);
if (securityPriceRow == null)
{
return(0.0M);
}
// Look up the cross currency value. This is needed to return the value in the requested base currency.
DataModel.PriceRow crossPriceRow = DataModel.Price.FindBySecurityIdCurrencyId(
debtRow.SettlementId, baseCurrency.CurrencyId);
if (crossPriceRow == null)
{
return(0.0M);
}
// Use the User Preferences to determine which price (Last, Closing) we should use.
decimal securityPrice = 0.0M;
decimal crossPrice = 0.0M;
if (Preferences.Pricing == Pricing.Last)
{
securityPrice = securityPriceRow.LastPrice;
crossPrice = crossPriceRow.LastPrice;
}
if (Preferences.Pricing == Pricing.Close)
{
securityPrice = securityPriceRow.ClosePrice;
crossPrice = crossPriceRow.ClosePrice;
}
// The price, in the requested currency, is the native price multiplied by the cross currency price and any factors.
return(securityPrice * crossPrice);
}
/// <summary>
/// Calculates the market value of a position.
/// </summary>
/// <param name="baseCurrency">The base currency for the market value calculation.</param>
/// <param name="accountRow">The identifier of the account.</param>
/// <param name="SecurityId">The identifier of the security.</param>
/// <param name="PositionTypeCode">The PositionTypeCode (long or short).</param>
/// <param name="marketValueFlags">These flags direct what elements are included and whether to include
/// children.</param>
/// <returns></returns>
public static decimal Calculate(DataModel.CurrencyRow baseCurrency, DataModel.AccountRow accountRow,
DataModel.SecurityRow securityRow, int PositionTypeCode, MarketValueFlags marketValueFlags)
{
// This is the accumulator for market value.
decimal marketValue = 0.0M;
// Aggregate Tax Lots
if ((marketValueFlags & MarketValueFlags.IncludeTaxLot) != 0)
{
foreach (DataModel.TaxLotRow taxLotRow in accountRow.GetTaxLotRows())
{
if (taxLotRow.SecurityId == securityRow.SecurityId &&
taxLotRow.PositionTypeCode == PositionTypeCode)
{
marketValue += Calculate(baseCurrency, taxLotRow);
}
}
}
// Aggregate Proposed Order
if ((marketValueFlags & MarketValueFlags.IncludeProposedOrder) != 0)
{
foreach (DataModel.ProposedOrderRow proposedOrderRow in accountRow.GetProposedOrderRows())
{
if (proposedOrderRow.SecurityId == securityRow.SecurityId &&
proposedOrderRow.PositionTypeCode == PositionTypeCode)
{
marketValue += Calculate(baseCurrency, proposedOrderRow);
}
}
}
// Aggregate Order
if ((marketValueFlags & MarketValueFlags.IncludeOrder) != 0)
{
foreach (DataModel.OrderRow SetPrice in accountRow.GetOrderRows())
{
if (SetPrice.SecurityId == securityRow.SecurityId &&
SetPrice.PositionTypeCode == PositionTypeCode)
{
marketValue += Calculate(baseCurrency, SetPrice);
}
}
}
// Aggregate Allocation
if ((marketValueFlags & MarketValueFlags.IncludeAllocation) != 0)
{
foreach (DataModel.AllocationRow allocationRow in accountRow.GetAllocationRows())
{
if (allocationRow.SecurityId == securityRow.SecurityId &&
allocationRow.PositionTypeCode == PositionTypeCode)
{
marketValue += Calculate(baseCurrency, allocationRow);
}
}
}
// If sub-account are to be included, recurse into the account structures.
if ((marketValueFlags & MarketValueFlags.IncludeChildAccounts) != 0)
{
foreach (DataModel.ObjectTreeRow objectTreeRow in
accountRow.ObjectRow.GetObjectTreeRowsByFKObjectObjectTreeParentId())
{
foreach (DataModel.AccountRow childAccount in
objectTreeRow.ObjectRowByFKObjectObjectTreeChildId.GetAccountRows())
{
marketValue += Calculate(baseCurrency, childAccount, securityRow,
PositionTypeCode, marketValueFlags);
}
}
}
// This is the market value of the given account/security/position combination.
return(marketValue);
}
/// <summary>
/// Calculates the market value of the given Tax Lot in the base currency.
/// </summary>
/// <param name="baseCurrency">The base currency for the market value calculation.</param>
/// <param name="proposedOrderRow">The subject of the calculation.</param>
/// <returns>The market value of the Tax Lot in the base currency.</returns>
private static decimal Calculate(DataModel.CurrencyRow baseCurrency, DataModel.TaxLotRow taxLotRow)
{
return(taxLotRow.Quantity * taxLotRow.SecurityRow.QuantityFactor *
Price.Security(baseCurrency, taxLotRow.SecurityRow) * taxLotRow.SecurityRow.PriceFactor);
}
