Пример #1
0
        //Reduce Order Quantity
        public void ReduceOrderQuantity(int idActiveOrder, char buySell, int quantity, OrderContract spotContract, string userName, string member)
        {
            ReduceOrderStructure red = new ReduceOrderStructure();

            red.Contract      = spotContract;
            red.IdActiveOrder = idActiveOrder;
            red.MemberCode    = DataConverter.ConvertToDelphiString(member, 6);
            red.BuySell       = buySell;
            red.Quantity      = quantity;

            connection.Send(MessageType.MESSAGE_104_ORDER_REDUCE, userName, red);
        }
        public static T ParseXml <T>(T structure, XElement actionQuery, QueryAction queryAction)
        {
            Type type       = typeof(T);
            T    obj        = default(T);
            var  properties = type.GetProperties();


            switch (queryAction)
            {
            case QueryAction.SubmitActiveOrder:
            {
                SubmitOrderStructure template = new SubmitOrderStructure();
                SubmitOrderStructure results  = null;
                var result = actionQuery.Elements("SubmitOrder")
                             .Elements()
                             .ToList();
                results = GetObject <SubmitOrderStructure>(template, result);
                obj     = (T)Convert.ChangeType(results, type);
                break;
            }

            case QueryAction.SubmitBulkOrder:
            {
                SubmitOrderStructure template = new SubmitOrderStructure();
                SubmitOrderStructure results  = null;
                var result = actionQuery.Elements()
                             .ToList();

                results = GetObject <SubmitOrderStructure>(template, result);
                obj     = (T)Convert.ChangeType(results, type);

                break;
            }

            case QueryAction.CancelAllOrders:
            {
                CancelAllOrdersStructure template = new CancelAllOrdersStructure();
                CancelAllOrdersStructure results  = null;
                var result = actionQuery.Elements("CancelAllOrders")
                             .Elements()
                             .ToList();
                results = GetObject <CancelAllOrdersStructure>(template, result);
                obj     = (T)Convert.ChangeType(results, type);
                break;
            }

            case QueryAction.SuspendActiveOrder:
            {
                CancelOrSuspendOrderStructure template = new CancelOrSuspendOrderStructure();
                CancelOrSuspendOrderStructure results  = null;
                var result = actionQuery.Elements("SuspendActiveOrder")
                             .Elements()
                             .ToList();
                results = GetObject <CancelOrSuspendOrderStructure>(template, result);
                obj     = (T)Convert.ChangeType(results, type);
                break;
            }

            case QueryAction.DeleteActiveOrder:
            {
                DeleteOrderStructure template = new DeleteOrderStructure();
                DeleteOrderStructure results  = null;
                var result = actionQuery.Elements("DeleteActiveOrder")
                             .Elements()
                             .ToList();
                results = GetObject <DeleteOrderStructure>(template, result);
                obj     = (T)Convert.ChangeType(results, type);
                break;
            }

            case QueryAction.EditSuspendedOrder:
            {
                EditSuspendedOrderStructure template = new EditSuspendedOrderStructure();
                EditSuspendedOrderStructure results  = null;
                var result = actionQuery.Elements("EditSuspendedOrder")
                             .Elements()
                             .ToList();
                results = GetObject <EditSuspendedOrderStructure>(template, result);
                obj     = (T)Convert.ChangeType(results, type);
                break;
            }

            case QueryAction.ReduceOrderQuantity:
            {
                ReduceOrderStructure template = new ReduceOrderStructure();
                ReduceOrderStructure results  = null;
                var result = actionQuery.Elements("ReduceOrderQuantity")
                             .Elements()
                             .ToList();
                results = GetObject <ReduceOrderStructure>(template, result);
                obj     = (T)Convert.ChangeType(results, type);
                break;
            }

            case QueryAction.InstrumentSubscription:
            {
                List <InstrumentCodeStructure> instrumentCodeStructureList = new List <InstrumentCodeStructure>();

                InstrumentSubscriptionStructure template = new InstrumentSubscriptionStructure();
                InstrumentSubscriptionStructure instrumentSubscriptionStructure = null;

                var action = actionQuery.Elements("InstrumentSubscription")
                             .Elements()
                             .ToList();

                var _instrumentcode = actionQuery.Elements("InstrumentSubscription").Elements("Instruments")
                                      .Elements()
                                      .ToList();

                foreach (var element in _instrumentcode)
                {
                    InstrumentCodeStructure instrumentCodeStructure = new InstrumentCodeStructure();
                    instrumentCodeStructure.InstrumentCode = element.Value;
                    instrumentCodeStructureList.Add(instrumentCodeStructure);
                }

                instrumentSubscriptionStructure = GetObject <InstrumentSubscriptionStructure>(template, action);
                instrumentSubscriptionStructure.InstrumentCodes = instrumentCodeStructureList;
                obj = (T)Convert.ChangeType(instrumentSubscriptionStructure, type);
                break;
            }

            case QueryAction.IndicesSubscription:
            {
                IndicesSubscriptionStructure template = new IndicesSubscriptionStructure();
                IndicesSubscriptionStructure results  = null;
                var result = actionQuery.Elements("IndicesSubscription")
                             .Elements()
                             .ToList();
                results = GetObject <IndicesSubscriptionStructure>(template, result);
                obj     = (T)Convert.ChangeType(results, type);
                break;
            }

            case QueryAction.DeleteSuspendedOrder:
            {
                break;
            }

            case QueryAction.ResubmitSuspendedOrder:
            {
                ResubmitOrderStructure template = new ResubmitOrderStructure();
                ResubmitOrderStructure results  = null;
                var result = actionQuery.Elements("ResubmitSuspendedOrder")
                             .Elements()
                             .ToList();
                results = GetObject <ResubmitOrderStructure>(template, result);
                obj     = (T)Convert.ChangeType(results, type);
                break;
            }

            case QueryAction.EditActiveOrder:
            {
                EditActiveOrderStructure template = new EditActiveOrderStructure();
                EditActiveOrderStructure results  = null;
                var result = actionQuery.Elements("EditActiveOrder")
                             .Elements()
                             .ToList();
                results = GetObject <EditActiveOrderStructure>(template, result);
                obj     = (T)Convert.ChangeType(results, type);
                break;
            }

            case QueryAction.DataDownload:
            {
                DataDownloadStructure template = new DataDownloadStructure();
                DataDownloadStructure results  = null;
                var result = actionQuery.Elements("DataDownload")
                             .Elements()
                             .ToList();
                results = GetObject <DataDownloadStructure>(template, result);
                obj     = (T)Convert.ChangeType(results, type);
                break;
            }

            default:
            {
                break;
            }
            }

            return(obj);
        }