Example #1
0
        protected virtual MarginAndQuantityResult CreateMarginAndQuantityResult(bool isBuy, decimal margin, decimal quantity)
        {
            var result = new MarginAndQuantityResult();

            result.AddMarginAndQuantity(isBuy, margin, quantity);
            return(result);
        }
Example #2
0
        protected override MarginAndQuantityResult CreateMarginAndQuantityResult(bool isBuy, decimal margin, decimal quantity)
        {
            var result = new MarginAndQuantityResult();

            result.AddMarginAndQuantity(isBuy, this.IsPartialPhysicalOrder(), margin, quantity);
            return(result);
        }
        internal static MarginAndQuantityResult CalculateFilledMarginAndQuantity(this Order order, bool isBuy, Dictionary <Guid, decimal> remainFilledLotPerOrderDict)
        {
            var result = new MarginAndQuantityResult();

            if (!order.ShouldCalculateFilledMarginAndQuantity(isBuy))
            {
                return(result);
            }
            decimal margin, quantity;
            var     physicalOrder = order as PhysicalOrder;
            bool    isPartialPaymentPhysicalOrder = physicalOrder != null && physicalOrder.IsPartialPaymentPhysicalOrder;

            order.CalculateMarginAndQuantity(isPartialPaymentPhysicalOrder, remainFilledLotPerOrderDict, out margin, out quantity);
            result.AddMarginAndQuantity(order.IsBuy, isPartialPaymentPhysicalOrder, margin, quantity);
            return(result);
        }
        internal static MarginAndQuantityResult CalculateUnfilledMarginAndQuantity(this Order order, decimal contractSize, decimal?effectiveLot)
        {
            var     result = new MarginAndQuantityResult();
            decimal lot    = effectiveLot ?? order.Lot;

            if (order.Phase != OrderPhase.Placed || order.Phase != OrderPhase.Placing || !order.IsOpen)
            {
                return(result);
            }
            var     physicalOrder = order as PhysicalOrder;
            bool    isPartialPaymentPhysicalOrder = physicalOrder != null && physicalOrder.IsPartialPaymentPhysicalOrder;
            decimal quantity = isPartialPaymentPhysicalOrder ? lot : lot * contractSize;

            result.AddMarginAndQuantity(order.IsBuy, isPartialPaymentPhysicalOrder, order.PreCheckMargin, quantity);
            return(result);
        }
        internal MarginAndQuantityResult CalculateUnfilledMarginAndQuantity(decimal?effectiveLot = null)
        {
            var     result = new MarginAndQuantityResult();
            Account account = _tran.Owner;
            Price   buy, sell;

            this.CalculatePrice(out buy, out sell);
            foreach (Order eachOrder in _tran.Orders)
            {
                if (!this.ShouldCalculatePreCheckNecessary(eachOrder))
                {
                    continue;
                }
                var price = eachOrder.IsBuy ? sell : buy;
                result += eachOrder.CalculateUnfilledMarginAndQuantityForOrder(price, effectiveLot);
            }
            return(result);
        }
        internal static MarginAndQuantityResult CalculateUnfilledMarginAndQuantity(this Transaction tran, decimal?effectiveLot = null)
        {
            var     result = new MarginAndQuantityResult();
            Account account = tran.Owner;
            Price   buy, sell;

            tran.CalculatePrice(out buy, out sell);
            foreach (Order eachOrder in tran.Orders)
            {
                if (!tran.ShouldCalculatePreCheckNecessary(eachOrder))
                {
                    continue;
                }
                var price = eachOrder.IsBuy ? sell : buy;
                eachOrder.CalculatePreCheckNecessary(tran.SettingInstrument.MarginFormula, tran.CurrencyRate, tran.ContractSize, price, effectiveLot);
                result += eachOrder.CalculateUnfilledMarginAndQuantity(tran.ContractSize, effectiveLot);
            }
            return(result);
        }