Example #1
0
        public double SellDigicoin(Client client, int digicoinNumber)
        {
            ValidateInputParams(client, digicoinNumber);

            return new DigicoinOperationHandler(brokerRepository, orderRepository).
                GetOverallCostForDigicoinOperation(client, digicoinNumber, OperationType.Sell);
        }
Example #2
0
 public DigicoinTest()
 {
     service = new DigicoinService();
     clientA = new Client("A");
     clientB = new Client("B");
     clientC = new Client("C");
 }
Example #3
0
        private static void InitClients()
        {
            clientA = new Client();
            clientA.Id = 1;
            clientA.Name = "Client A";

            clientB = new Client();
            clientB.Id = 2;
            clientB.Name = "Client B";

            clientC = new Client();
            clientC.Id = 3;
            clientC.Name = "Client C";
        }
Example #4
0
        public Order MakeOrder(Client client, ITradeable product, OrderType type, int count)
        {
            Order order = new Order();
            order.Client = client;
            order.Product = product;
            order.Type = type;
            order.Count = count;

            Order tempOrder = (Order)order.Clone();
            Order [] brokerOrders = new Order[brokers.Count];
            bool [] rtnCdes = new bool[brokers.Count];
            int modCount = order.Count;
            int idx = 0;
            int maxCount = 0;
            decimal minBrokerValue = 0;
            int brokerValueIdx = -1;

            while (modCount > 0)
            {
                tempOrder.Count = modCount;

                maxCount = 0;
                idx = 0;
                foreach (Broker broker in brokers)
                {
                    rtnCdes[idx] = broker.PrepareOrder(tempOrder, out brokerOrders[idx]);
                    if (rtnCdes[idx])
                    {
                        if (brokerOrders[idx].Count > maxCount)
                            maxCount = brokerOrders[idx].Count;
                    }

                    idx++;
                }

                if (maxCount == 0)
                    return order;

                minBrokerValue = decimal.MaxValue;
                brokerValueIdx = -1;
                for(idx = 0; idx < brokers.Count; ++idx)
                {
                    if (rtnCdes[idx])
                    {
                        if (brokerOrders[idx].Count == maxCount)
                        {
                            if (brokerOrders[idx].BrokerValue < minBrokerValue)
                            {
                                minBrokerValue = brokerOrders[idx].BrokerValue;
                                brokerValueIdx = idx;
                            }
                        }
                    }
                }

                if (brokerValueIdx == -1)
                    return order;

                brokers[brokerValueIdx].AddOrder(brokerOrders[brokerValueIdx]);
                order.TotalValue += brokerOrders[brokerValueIdx].BrokerValue;
                modCount -= brokerOrders[brokerValueIdx].Count;
            }

            client.AddOrder(order);
            return order;
        }
Example #5
0
 public static string ClientNetPositions(Client client, decimal value)
 {
     return client.Name + " net positions value: " + Convert.ToString(value);
 }
Example #6
0
 public static decimal GetClientNetPositions(Client client)
 {
     return client.CalculateNet();
 }
Example #7
0
 private void ValidateInputParams(Client client, int digicoinNumber)
 {
     if (client == null) throw new ArgumentNullException("client");
     if (digicoinNumber % 10 != 0) throw new ArgumentException("digicoinNumber can only be multiples of 10");
 }
Example #8
0
        public double ClientReport(Client client)
        {
            if (client == null) throw new ArgumentNullException("client");

            return new ClientReport(this.orderRepository).GetClientNetPositon(client.ClientId);
        }