public FundPositionHistorical(IFundPortfolioHistorical parent, InstrumentSize size, Price price, Decimal rate)
{
this.Parent = parent;
this.Size = size;
this.Price = price;
this.rate = rate;
}
/// <summary>
/// Constructor for creating a test FeeClient object
/// </summary>
/// <param name="account"></param>
/// <param name="instrument"></param>
/// <param name="side"></param>
/// <param name="actiontype"></param>
/// <param name="transactionDate"></param>
/// <param name="issizebased"></param>
/// <param name="orderValue"></param>
/// <param name="amount"></param>
/// <param name="price"></param>
/// <param name="ordercurrency"></param>
/// <param name="isValueInclComm"></param>
public CommClient(IAccountTypeInternal account,IInstrument instrument, Side side, OrderActionTypes actiontype,
DateTime transactionDate, bool issizebased, InstrumentSize orderValue, Money amount, Price price,
ICurrency ordercurrency, bool isValueInclComm)
{
if (account == null)
throw new ApplicationException("It is not possible to calculate the commission when the account is unknown.");
if (instrument == null)
throw new ApplicationException("It is not possible to calculate the commission when the instrument value is unknown.");
this.account = account;
this.instrument = instrument;
this.Side = side;
this.ActionType = actiontype;
this.TransactionDate = transactionDate;
this.IsSizeBased = issizebased;
this.OriginalOrderType = issizebased ? BaseOrderTypes.SizeBased : BaseOrderTypes.AmountBased;
this.Value = orderValue;
this.amount = amount;
this.Price = price;
this.OrderCurrency = ordercurrency;
this.IsValueInclComm = isValueInclComm;
type = CommClientType.Test;
}
public CrumbleTransaction(IOrder order, ICrumbleAccount acctA, IAccount acctB,
InstrumentSize valueSize, Price price, decimal exRate, DateTime transactionDate,
DateTime transactionDateTime, Decimal ServiceChargePercentage, Side txSide, ITradingJournalEntry tradingJournalEntry,
IGLLookupRecords lookups, ListOfTransactionComponents[] components)
: base(order, acctA, acctB, valueSize, price, exRate, transactionDate, transactionDateTime, ServiceChargePercentage,
txSide, tradingJournalEntry, lookups, components)
{
}
public InstrumentConversion(IAccountTypeInternal acctA, IAccount acctB,
InstrumentSize valueSize, InstrumentSize convertedInstrumentSize,
decimal exRate, IInstrumentHistory instrumentTransformation,
ITradingJournalEntry tradingJournalEntry)
: this(acctA, acctB, valueSize, convertedInstrumentSize, null,
exRate, instrumentTransformation, tradingJournalEntry, null)
{
}
/// <summary>
/// This method tries to find a commission rule based on the parameters entered
/// </summary>
/// <param name="saccount">Account number</param>
/// <param name="sinstrument">Instrument</param>
/// <param name="sordervalue">Order value</param>
/// <param name="samount">Amount</param>
/// <param name="sprice">Price</param>
public static string CalculateAccruedInterest(int instrumentId,
DateTime settlementDate, BaseOrderTypes orderType,
decimal amountQuantity, decimal sizeQuantity, decimal priceQuantity,
int exchangeId)
{
string result = "";
try
{
using (IDalSession session = NHSessionFactory.CreateSession())
{
InstrumentSize size = null;
IBond instrument = (IBond)InstrumentMapper.GetInstrument(session, instrumentId);
IExchange exchange = null;
if (instrument == null)
throw new ApplicationException("select a valid bond");
if (exchangeId != 0 && exchangeId != int.MinValue)
exchange = ExchangeMapper.GetExchange(session, exchangeId);
ICurrency defcurrency = instrument.CurrencyNominal;
Price price = null;
if (priceQuantity != 0M)
price = new Price(priceQuantity, defcurrency, instrument);
else if (instrument.CurrentPrice != null)
price = instrument.CurrentPrice.Price;
if (!(price != null && price.IsNotZero))
throw new ApplicationException("There is no price");
if (orderType == BaseOrderTypes.AmountBased)
{
Money amount = new Money(amountQuantity, defcurrency);
size = instrument.CalculateSizeBackwards(amount, price, settlementDate);
}
else
size = new InstrumentSize(sizeQuantity, instrument);
AccruedInterestDetails accInt = instrument.AccruedInterest(size, settlementDate, exchange);
Money calcAmount = size.CalculateAmount(price);
if (accInt.IsRelevant)
result = accInt.DisplayString + string.Format("<br>Size: {0}<br>Amount: {1}<br>Settlement Date: {2}",
size.Quantity, calcAmount.Quantity, settlementDate.ToString("dd-MM-yyyy"));
else
result = "Accrued interest is not relevant";
}
}
catch (Exception ex)
{
result = "Error during accrued interest test: " + ex.Message;
}
return result;
}
protected SecurityOrder(IAccountTypeInternal account, InstrumentSize value, ITradeableInstrument tradedInstrument, bool doNotChargeCommission)
: base(account, value)
{
if (tradedInstrument == null)
{
throw new ApplicationException("TradedInstrument is mandatory on an order.");
}
this.tradedInstrument = tradedInstrument;
this.DoNotChargeCommission = doNotChargeCommission;
if (DoNotChargeCommission)
this.OrderInfo = "No commission charged";
}
public TransactionNTM(IAccountTypeInternal acctA, IAccount acctB,
InstrumentSize valueSize,
Price price, decimal exRate, DateTime transactionDate, DateTime transactionDateTime,
Decimal ServiceChargePercentage, Side txSide,
ITradingJournalEntry tradingJournalEntry,
IGLLookupRecords lookups, ListOfTransactionComponents[] components, string description)
: base(acctA, acctB, valueSize, price, exRate, transactionDate,
transactionDateTime, ServiceChargePercentage, txSide,
tradingJournalEntry, lookups, components)
{
this.Description = description;
}
public CommClient(ITransactionOrder transaction, InstrumentSize newValue)
{
if (transaction == null)
throw new ApplicationException("It is not possible to calculate the commission when the transaction is null.");
if (newValue == null)
throw new ApplicationException("It is not possible to calculate the commission when the transaction value is null.");
this.transaction = transaction;
this.orderValue = newValue;
this.amount = newValue.GetMoney();
type = CommClientType.Transaction;
}
public BondCouponPaymentDailyCalculation(
IBondCouponPayment parent, DateTime calcDate, DateTime settlementDate,
InstrumentSize positionSize, Money calculatedAccruedInterestUpToDate,
IList<IBondCouponPaymentDailyCalculation> oldCalculations)
{
this.Parent = parent;
this.Position = this.Parent.Position;
this.CalcDate = calcDate;
this.SettlementDate = settlementDate;
this.PositionSize = positionSize;
this.CalculatedAccruedInterestUpToDate = calculatedAccruedInterestUpToDate;
this.OldCalculations = oldCalculations;
CalculateDailyInterest();
}
public BonusDistribution(IAccountTypeInternal acctA, IAccount acctB,
InstrumentSize valueSize,
Price price, decimal exRate, DateTime transactionDate, DateTime transactionDateTime,
Decimal ServiceChargePercentage, Side txSide,
ICorporateActionBonusDistribution bonusDistributionDetails, ITradingJournalEntry tradingJournalEntry,
IGLLookupRecords lookups, ListOfTransactionComponents[] components)
: base(acctA, acctB, valueSize,
price, exRate, transactionDate, transactionDateTime,
ServiceChargePercentage, txSide,
tradingJournalEntry,
lookups, components)
{
this.CorporateActionType = CorporateActionTypes.BonusDistribution;
this.CorporateActionDetails = bonusDistributionDetails;
}
/// <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);
}
internal StgSizeOrder(IStgAmtOrder childOrder, InstrumentSize value, Price price, IOrderRouteMapper routeMapper)
: base(childOrder.Account, value, false)
{
// Used for TypeConversion
// Some check
if (childOrder.ParentOrder != null)
throw new ApplicationException("This order has a parent order and can no longer be converted.");
this.IsTypeConverted = true;
setInitialValues(routeMapper);
this.price = price;
this.ChildOrders.Add(childOrder);
childOrder.Approve();
//this.CommissionDetails = childOrder.CommissionDetails;
this.exRate = childOrder.ExRate;
Validate();
}
public static void UpdateExtPosition(DateTime date, decimal Size, int custodianID, int original_Key)
{
IDalSession session = NHSessionFactory.CreateSession();
ITradeableInstrument instrument = (ITradeableInstrument)InstrumentMapper.GetInstrument(session, original_Key);
ExtCustodian custodian = ExtCustodianMapper.GetExtCustodian(session, custodianID);
ExtPosition position = ExtCustodianMapper.GetExtCustodianPosition(session, custodian, instrument, date);
InstrumentSize size = new InstrumentSize(Size, instrument);
if (position == null)
position = new ExtPosition(custodian, size, date);
else
position.Size = size;
ExtCustodianMapper.InsertOrUpdate(session, position);
session.Close();
}
public InstrumentConversion(IAccountTypeInternal acctA, IAccount acctB,
InstrumentSize valueSize, InstrumentSize convertedInstrumentSize, Money additionalCash,
decimal exRate, IInstrumentHistory instrumentTransformation,
ITradingJournalEntry tradingJournalEntry, IGLLookupRecords lookups)
: base(acctA, acctB, valueSize, valueSize.GetPrice(0M), exRate,
instrumentTransformation.ChangeDate, instrumentTransformation.ChangeDate, 0M,
(valueSize.Sign ? Side.XI : Side.XO), tradingJournalEntry, lookups, null)
{
if (instrumentTransformation == null)
throw new ApplicationException("Corporate action information is missing");
if (!(valueSize != null && valueSize.IsNotZero && convertedInstrumentSize != null && convertedInstrumentSize.IsNotZero))
throw new ApplicationException("Not all instrument information for this corporate action is available, both instruments have to be supplied");
if (valueSize.Underlying.Equals(convertedInstrumentSize.Underlying))
throw new ApplicationException("Both instruments can not be the same in a corporate action");
if (valueSize.Sign.Equals(convertedInstrumentSize.Sign))
throw new ApplicationException("Both instruments can not have the same side in a corporate action");
IInstrumentsHistoryConversion conversion = (IInstrumentsHistoryConversion)instrumentTransformation;
if (!(conversion.Instrument.Equals(valueSize.Underlying) && conversion.NewInstrument.Equals(convertedInstrumentSize.Underlying)))
throw new ApplicationException("Corporate action does not equal the instrument history data");
decimal diff = (convertedInstrumentSize.Abs().Quantity / valueSize.Abs().Quantity) - conversion.ConversionRate;
if (diff != 0)
throw new ApplicationException("Sizes do not correspond with conversion rate of the Corporate action");
if (additionalCash != null && additionalCash.IsNotZero)
{
ListOfTransactionComponents[] components = new ListOfTransactionComponents[1];
components[0] = new ListOfTransactionComponents() { ComponentType = BookingComponentTypes.Conversion, ComponentValue = additionalCash };
createComponents(lookups, components);
}
this.CorporateActionType = CorporateActionTypes.Conversion;
ConvertedInstrumentSize = convertedInstrumentSize;
CorporateActionType = instrumentTransformation.CorporateActionType;
InstrumentTransformation = instrumentTransformation;
}
internal AggregatedCashValuation(ValuationCollection cashValuations, bool aggregateToBase)
{
bool hasInitialized = false;
if (aggregateToBase)
{
foreach (IValuation valuation in cashValuations)
{
if (valuation.Instrument.IsCash)
{
if (this.account == null)
{
this.account = valuation.Account;
this.date = valuation.Date;
this.key = valuation.Key;
this.marketRate = 1M;
this.avgOpenExRate = 1M;
baseCurrency = ((ICurrency)valuation.Instrument).BaseCurrency;
price = new Price(1M, baseCurrency, baseCurrency);
this.bookPrice = price;
this.costPrice = price;
this.marketPrice = price;
this.displayInstrumentsCategory = valuation.DisplayInstrumentsCategory;
this.AssetClass = valuation.ValuationMutation.AssetClass;
this.ValuationMutation = valuation.ValuationMutation;
}
this.size += valuation.BaseMarketValue;
this.bookValue += valuation.BookValue;
this.bookChange += valuation.BookChange;
this.deposit += valuation.Deposit;
this.withDrawal += valuation.WithDrawal;
if (!valuation.ValuationMutation.IsSecurityValuationMutation)
{
this.depositToDate += ((IMonetaryValuationMutation)valuation.ValuationMutation).DepositToDate;
this.withDrawalToDate += ((IMonetaryValuationMutation)valuation.ValuationMutation).WithDrawalToDate;
}
hasInitialized = true;
}
}
}
if (!hasInitialized)
throw new ApplicationException("Class AggregatedCashValuation could not be initialized");
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="account">User account</param>
/// <param name="value">Instrument size</param>
/// <param name="isClosure">Is this order closing a position.</param>
/// <param name="feeFactory">The set of rules to use for calculating transaction costs.</param>
/// <param name="doNotChargeCommission">parameter that decides whether commission should be charged</param>
/// <param name="actionType">The action type that created this order.</param>
public OrderSizeBased(IAccountTypeInternal account, InstrumentSize value, bool isClosure, IFeeFactory feeFactory, bool doNotChargeCommission, OrderActionTypes actionType)
: base(account, value, (ITradeableInstrument)value.Underlying, doNotChargeCommission)
{
this.ActionType = actionType;
this.isClosure = isClosure;
setCommission(feeFactory);
// Accrued Interest for Client Orders
if (account.IsAccountTypeCustomer && TradedInstrument.SecCategory.Key == SecCategories.Bond)
{
IBond bond = (IBond)TradedInstrument;
if (bond.DoesPayInterest)
{
IExchange exchange = bond.DefaultExchange ?? bond.HomeExchange;
AccruedInterestDetails calc = bond.AccruedInterest(value, bond.GetSettlementDate(DateTime.Today, exchange), exchange);
if (calc.IsRelevant)
this.AccruedInterest = calc.AccruedInterest.Abs() * (decimal)this.Side * -1M;
}
}
}
public CorporateActionStockDividend(IAccountTypeInternal acctA, IAccount acctB,
InstrumentSize valueSize, Price price, decimal exRate, DateTime transactionDate,
IDividendHistory dividendDetails, InstrumentSize previousSize,
ITradingJournalEntry tradingJournalEntry)
: base(acctA, acctB, valueSize,
price, exRate, transactionDate, transactionDate,
0M, valueSize.Sign ? Side.XI : Side.XO,
tradingJournalEntry, null, null)
{
if (dividendDetails == null)
throw new ApplicationException("Dividend details are mandatory when creating a stock dividend corporate action");
if (previousSize == null)
throw new ApplicationException("The units in possession are mandatory when creating a stock dividend corporate action");
else if (previousSize.IsZero)
throw new ApplicationException("The units can not be zero when creating a stock dividend corporate action");
this.CorporateActionType = CorporateActionTypes.StockDividend;
this.CorporateActionDetails = dividendDetails;
this.PreviousSize = previousSize;
}
public static void CheckMaximalRoundOffError(bool isSizeBased, InstrumentSize size, Money amount, Price price, Money accruedInterest, Side side)
{
if (!isSizeBased)
{
InstrumentSize calcAmt = size.CalculateAmount(price) * (decimal)side * -1M;
//if (accruedInterest != null && accruedInterest.IsNotZero)
//{
// accruedInterest = accruedInterest.Abs() * (decimal)side * -1M;
// calcAmt += accruedInterest;
//}
InstrumentSize diff = (calcAmt.Abs() - amount.Abs());
if (diff.IsNotZero && !diff.IsWithinTolerance(0.02m))
{
decimal percLeft = diff.Abs().Quantity / amount.Abs().Quantity;
if (percLeft >= 0.05m)
throw new ApplicationException(string.Format(
"Price times Size ({0}) differs by {1}% from the provided Amount ({2}). Order cannot be filled.",
calcAmt.DisplayString, Math.Round(percLeft * 100m, 1), amount.DisplayString));
}
}
}
public static decimal CalculateAccruedInterestAmount(int orderId, decimal size, DateTime settlementDate)
{
using (IDalSession session = NHSessionFactory.CreateSession())
{
decimal accruedInterest = 0;
IStgOrder order = (IStgOrder)OrderMapper.GetOrder(session, orderId);
if (order != null && order.RequestedInstrument.SecCategory.Key == SecCategories.Bond)
{
IBond bond = (IBond)order.RequestedInstrument;
if (bond.DoesPayInterest)
{
if (order.IsSizeBased)
{
InstrumentSize volume = new InstrumentSize(size, bond);
AccruedInterestDetails calc = bond.AccruedInterest(volume, settlementDate, null);
if (calc.IsRelevant)
accruedInterest = calc.AccruedInterest.Quantity;
}
}
}
return accruedInterest;
}
}
public IOrderExecution Fill(InstrumentSize size, Price price, Money amount, decimal exRate,
IAccount counterParty, DateTime transactionDate, DateTime transactionDateTime, IExchange exchange,
bool isCompleteFill, Money serviceCharge, decimal serviceChargePercentage, Money accruedInterest,
ITradingJournalEntry tradingJournalEntry, IGLLookupRecords lookups)
{
IOrderExecution returnValue = null;
if (size == null || price == null || amount == null)
throw new Exception("Size, Price and Amount are mandatory when filling the order.");
if (IsFillable != OrderFillability.True)
throw new ApplicationException("This Order is not fillable.");
setSignServiceCharge(ref serviceCharge, ref serviceChargePercentage);
if (accruedInterest != null && accruedInterest.IsNotZero)
accruedInterest = accruedInterest.Abs() * (decimal)this.Side * -1M;
CheckMaximalRoundOffError(IsSizeBased, size, amount, price, accruedInterest, this.Side);
if (isCompleteFill)
{
// Check whether the order has not been filled before
if (Transactions.Count > 0)
throw new ApplicationException("The order has already been filled and so it can not be a complete fill.");
if (this.OpenValue.IsZero)
throw new ApplicationException("The open value of this order is zero.");
InstrumentSize diff = getTradeDifferenceOpenValue(size, amount, serviceCharge, accruedInterest);
if (diff.IsNotZero)
{
const decimal maxAllowed = 0.05m;
// TickSize && NominalValue
decimal tickSize = 0M;
if (this.OrderType == OrderTypes.SizeBased)
{
IInstrumentExchange ie = getInstrumentExchange(exchange);
if (ie != null)
tickSize = ie.TickSize;
}
if (this.RequestedInstrument.SecCategory.Key == SecCategories.Bond)
tickSize = ((IBond)this.RequestedInstrument).NominalValue.Quantity;
if (!(tickSize > 0M && Math.Abs(diff.Quantity / tickSize) < 1M))
{
decimal fillRatio = diff.Abs().Quantity / this.OpenValue.Abs().Quantity;
if (fillRatio > maxAllowed)
throw new ApplicationException(
string.Format("The size of this transaction is different from the order size by more than {0:0.##}%.", maxAllowed * 100));
}
}
amount.XRate = exRate;
}
else
{
orderInitialCheck(ref amount, size, exRate, serviceCharge, accruedInterest);
}
this.IsCompleteFilled = isCompleteFill;
orderCheckSide(this.Side, ref amount, ref size);
checkServiceChargePercentage(serviceCharge, serviceChargePercentage, amount);
ListOfTransactionComponents[] components = packageComponents(amount, serviceCharge, accruedInterest);
returnValue = new OrderExecution(this, counterParty, size, price, exRate, transactionDate, transactionDateTime, serviceChargePercentage, tradingJournalEntry, lookups, components);
fillOrder(returnValue, size, price, amount, serviceCharge, accruedInterest);
return returnValue;
}
private InstrumentSize getTradeDifferenceOpenValue(InstrumentSize size, Money amount, Money serviceCharge, Money accruedInterest)
{
InstrumentSize diff;
if (IsSizeBased)
diff = (this.OpenValue.Abs() - size.Abs());
else
diff = (this.OpenValue.Abs() - amount.Abs() + serviceCharge + accruedInterest);
return diff;
}
protected bool orderCheckSide(Side side, ref Money amount, ref InstrumentSize size)
{
if (side == Side.Buy)
{
size = size.Abs();
amount = amount.Abs() * -1;
}
else
{
size = size.Abs() * -1;
amount = amount.Abs();
}
return true;
}
protected void orderInitialCheck(ref Money amount, InstrumentSize size, decimal exRate, Money serviceCharge, Money accruedInterest)
{
InstrumentSize diff = getTradeDifferenceOpenValue(size, amount, serviceCharge, accruedInterest);
if (!diff.Sign)
{
if (diff < diff.Clone(-0.02m))
throw new ApplicationException("This size of the trade is larger than the order size.");
}
if (IsMonetary) // can not be partfilled
{
if (FilledValue != null)
throw new ApplicationException("Monetary orders can only be filled once.");
if (!diff.IsWithinTolerance(0.02m))
throw new ApplicationException("Monetary orders can only be filled completely.");
}
else if (!(IsSizeBased)) // applies only to amount based orders
{
// If first fill -> check if size should not be equal to Order size
if (FilledValue == null)
{
if (diff.IsWithinTolerance(0.02m) && this.Amount != null)
{
amount = this.Amount;
// reduce it with servicecharge
amount = MoneyMath.AdjustAmountForServiceCharge(amount, serviceCharge, Side, MathOperator.Subtract);
// reduce it with accruedInterest
amount = MoneyMath.AdjustAmountForServiceCharge(amount, accruedInterest, Side, MathOperator.Subtract);
}
}
}
amount.XRate = exRate;
//bool approved = (route != null) ? route.ApproveTransactions : false;
if (IsFillable != OrderFillability.True)
{
throw new ApplicationException("This Order is not fillable.");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T:B4F.TotalGiro.Instruments.PredictedSize">PredictedSize</see> class.
/// </summary>
/// <param name="size">The predicted size</param>
/// <param name="rateDate">The date of the used rate to predict the size</param>
public PredictedSize(InstrumentSize size, DateTime rateDate)
{
this.size = size;
this.rateDate = rateDate;
}
/// <summary>
/// Fills an order by setting the agreed size and price, exchange rate, counter party and transaction date.
/// </summary>
/// <param name="trade">The order to be filled</param>
/// <param name="size">Size of the instrument</param>
/// <param name="price">Agreed price of the instrument</param>
/// <param name="amount">Amount of the order (=size * price)</param>
/// <returns>True if it succeeded</returns>
protected bool fillOrder(ITransactionOrder trade, InstrumentSize size, Price price, Money amount, Money serviceCharge, Money accruedInterest)
{
decimal ratio = 1m;
Transactions.AddTransactionOrder(trade);
FilledValue += fillOrderValue(size, amount, serviceCharge, accruedInterest);
if (this.IsSecurity)
{
((ISecurityOrder)this).ServiceCharge += serviceCharge;
if (this.IsAmountBased)
((ISecurityOrder)this).AccruedInterest += accruedInterest;
}
// If OrderExecution -> set FillRatio
if (trade.TransactionType == TransactionTypes.Execution)
{
if (IsCompleteFilled)
// if order is already partly filled -> subtract rest
ratio = 1M - Transactions.TotalFillRatio();
else
{
InstrumentSize diff = PlacedValue.Abs() - fillOrderValue(size, amount, serviceCharge, accruedInterest).Abs();
if (diff.IsZero || diff.IsWithinTolerance(0.02M))
ratio = 1M;
else
{
ratio = fillOrderValue(size, amount, serviceCharge, accruedInterest).Abs().Quantity / PlacedValue.Abs().Quantity;
// If this trade filled the order (OpenSize = 0) -> take the remainder ratio
if (OpenValue.IsZero)
{
decimal var = ratio - (1M - getFillatioTransactions());
if (Math.Abs(var) < 0.0001M)
ratio = 1M - getFillatioTransactions();
}
}
}
}
trade.FillRatio = ratio;
OrderStateMachine.SetNewStatus(this, OrderStateEvents.Fill);
//// If MoneyOrder on order -> set ExRate
//if (IsMonetary)
//{
// // Use the size as the amount -> because it is a conversion
// processMoneyFill(price, trade);
//}
return true;
}
/// <summary>
/// The value added with the ServiceCharge
/// The following calculation has been used:
/// side servCh value fillOrderValue
/// ---- --- ----- -----------
/// buy -5 -100 -105
/// sell -5 100 105
/// </summary>
internal override InstrumentSize fillOrderValue(InstrumentSize size, Money value, Money serviceCharge, Money accruedInterest)
{
Money orderValue = MoneyMath.AdjustAmountForServiceCharge(value * -1, serviceCharge, Side, MathOperator.Add);
orderValue += (accruedInterest * -1);
return (InstrumentSize)orderValue;
}
protected virtual TransactionFillDetails getTransactionFillDetailsAmountBasedOrderByGoalSeek(
Money grossAmount, Side side, bool isCommissionRelevant, bool isValueInclComm,
DateTime settlementDate, Price price, IExchange exchange,
ICommRule rule, ICommClient client, decimal servChargePerc, int precision)
{
decimal realAmount;
decimal guess = grossAmount.Abs().CalculateSize(price).Quantity;
FinancialMath.MaxCycles = 200;
// Check -> use Commission
bool useComm = true;
bool useAddComm = false;
if (!isCommissionRelevant || rule == null)
useComm = false;
if (useComm)
useAddComm = (rule.AdditionalCalculation != null);
realAmount = FinancialMath.GoalSeek(x =>
new InstrumentSize(x, this).CalculateAmount(price).Quantity +
(useComm ? rule.CommCalculation.Calculate(client.GetNewInstance(new InstrumentSize(x, this), price, (useAddComm ? rule.AdditionalCalculation.Calculate(client.GetNewInstance(new InstrumentSize(x, this), price)) : null))).Quantity : 0M) +
(useAddComm ? rule.AdditionalCalculation.Calculate(client.GetNewInstance(new InstrumentSize(x, this), price)).Quantity : 0M) +
(new InstrumentSize(x, this).CalculateAmount(price).Abs().Quantity * servChargePerc),
grossAmount.Abs().Quantity, guess, precision);
InstrumentSize size = new InstrumentSize(realAmount, this);
Money amount = size.CalculateAmount(price);
InstrumentSize cleanSize = amount.CalculateSize(price);
Money servCh = (amount.Abs() * servChargePerc);
Money comm = amount.ZeroedAmount();
Money addComm = amount.ZeroedAmount();
if (useComm)
{
if (rule.AdditionalCalculation != null)
addComm = rule.AdditionalCalculation.Calculate(client.GetNewInstance(cleanSize, price));
comm = rule.CommCalculation.Calculate(client.GetNewInstance(cleanSize, price, addComm));
// if sell -> comm is already in the amount
if (side == Side.Sell && (comm + addComm) != null && (comm + addComm).IsNotZero)
{
amount += (comm + addComm);
cleanSize = amount.CalculateSize(price);
if (!isValueInclComm)
{
if (rule.AdditionalCalculation != null)
addComm = rule.AdditionalCalculation.Calculate(client.GetNewInstance(cleanSize, price));
comm = rule.CommCalculation.Calculate(client.GetNewInstance(cleanSize, price, addComm));
}
}
}
return new TransactionFillDetails(cleanSize, amount, null, servCh, servChargePerc, comm + addComm, grossAmount.Abs(), side);
}
// Orphan instruments
public PortfolioComponentView(InstrumentSize size)
: this(size.Underlying, 0m, null)
{
}
public static bool InitialiseConversion(int instrumentConversionId)
{
using (IDalSession session = NHSessionFactory.CreateSession())
{
bool success = false;
int successCount = 0;
IInstrumentsHistoryConversion conversion = InstrumentHistoryMapper.GetInstrumentConversion(session, instrumentConversionId);
if (!conversion.IsInitialised)
{
if (conversion.ChangeDate > DateTime.Today)
throw new ApplicationException("The change date is in the future.");
int journalId = int.Parse((string)(System.Configuration.ConfigurationManager.AppSettings.Get(@"DefaultTransactiesEUR")));
IJournal journal = JournalMapper.GetJournal(session, journalId);
IList<IHistoricalPosition> accountsWithPositionByDate = B4F.TotalGiro.MIS.StoredPositions.StoredPositionTransactionMapper.GetAccountsWithPositionByDate(session, conversion.ChangeDate, conversion.Instrument.Key);
if (accountsWithPositionByDate != null && accountsWithPositionByDate.Count > 0)
{
DateTime transactionDate = conversion.ChangeDate;
decimal exRate = ((ITradeableInstrument)conversion.Instrument).CurrencyNominal.ExchangeRate.Rate;
foreach (IHistoricalPosition hp in accountsWithPositionByDate)
{
if (!conversion.Conversions.Any(x => x.AccountA.Key == hp.Account.Key))
{
IDalSession session2 = NHSessionFactory.CreateSession();
IAccountTypeCustomer account = (IAccountTypeCustomer)AccountMapper.GetAccount(session2, hp.Account.Key);
InstrumentSize size = hp.ValueSize * -1M;
InstrumentSize newSize = new InstrumentSize(hp.ValueSize.Quantity * conversion.ConversionRate, conversion.NewInstrument);
if (size.IsNotZero)
{
ITradingJournalEntry tradingJournalEntry = getNewBooking(session2, journal, transactionDate);
IInstrumentConversion instConv = new InstrumentConversion(
account, account.DefaultAccountforTransfer,
size, newSize, exRate, conversion, tradingJournalEntry);
if (session2.Insert(instConv))
successCount++;
}
else
successCount++;
}
else
successCount++;
}
}
if (accountsWithPositionByDate.Count == successCount)
{
conversion.IsInitialised = true;
session.InsertOrUpdate(conversion);
success = true;
}
}
return success;
}
}
/// <summary>
/// Used by method <b>Calculate</b> on derived classes to perform the common part of the commission calculation.
/// </summary>
/// <param name="size">The size for which to calculate commission.</param>
/// <param name="client">The order for which to calculate commission.</param>
/// <returns>The value of the commission.</returns>
protected Money calculateNormal(InstrumentSize size, ICommClient client)
{
Money result = new Money(0m, CommCurrency);
InstrumentSize comSize = size.Abs();
foreach (CommCalcLineSizeBased line in CommLines)
{
if (line.Envelops(comSize))
{
result = line.Calculate(comSize);
SetCommissionInfoOnOrder(client, string.Format("Flat -> Size ({0}) {1} -> use {2}.", comSize.DisplayString, line.DisplayRange, line.LineDistinctives));
break;
}
}
return addFixMinMax(result, client);
}