public override void CancelOrder(Order order)
        {
            LTBrokerProvider ltProvider = (from provider in _providers
                                           from account in _accounts
                                           where order.Account == account.AccountNumber &&
                                           account.ProviderName == provider.ProviderName
                                           select provider).FirstOrDefault();

            if (ltProvider != null)
            {
                ltProvider.CancelOrder(order);
            }
        }
        public override bool AllowOrderTypeForRoute(string route, OrderType orderType)
        {
            LTBrokerProvider ltProvider = (from provider in _providers
                                           where provider.ProviderName == route
                                           select provider).FirstOrDefault();

            if (ltProvider != null)
            {
                return(ltProvider.AllowOrderType(orderType));
            }
            else
            {
                return(true);
            }
        }
        public override void RequestOrderStatusUpdatesForOrders(IList <Order> orders)
        {
            foreach (Order order in orders)
            {
                LTBrokerProvider ltProvider = (from provider in _providers
                                               from account in _accounts
                                               where order.Account == account.AccountNumber &&
                                               account.ProviderName == provider.ProviderName
                                               select provider).FirstOrDefault();

                if (ltProvider != null)
                {
                    ltProvider.OrderStatusUpdate(order);
                }
            }
        }
        public override List <string> TifsAllowed(string acctNumber, string route, string orderType)
        {
            LTBrokerProvider ltProvider = (from account in _accounts
                                           from provider in _providers
                                           where account.AccountNumber == acctNumber &&
                                           account.ProviderName == provider.ProviderName
                                           select provider).FirstOrDefault();

            if (ltProvider != null)
            {
                return(ltProvider.TifsAllowed());
            }
            else
            {
                return(new List <string>());
            }
        }
        public override List <string> AccountTradeTypesAllowed(string acctNumber, string action)
        {
            LTBrokerProvider ltProvider = (from account in _accounts
                                           from provider in _providers
                                           where account.AccountNumber == acctNumber &&
                                           account.ProviderName == provider.ProviderName
                                           select provider).FirstOrDefault();

            if (ltProvider != null)
            {
                return(ltProvider.AccountTradeTypes(acctNumber));
            }
            else
            {
                return new List <string>()
                       {
                           "Default"
                       }
            };
        }
        public override void Initialize(IBrokerHost brokerHost, AuthenticationProvider authProvider)
        {
            base.Initialize(brokerHost, authProvider);
            authProvider.AllowAutoTrading = true;

            AssemblyLoader assemblyLoader = new AssemblyLoader();

            assemblyLoader.BaseClass = "LTBrokerProvider";

            assemblyLoader.Path = Path.GetDirectoryName(Application.ExecutablePath);

            foreach (Type type in assemblyLoader.Types)
            {
                try
                {
                    LTBrokerProvider assemblyDescription = (LTBrokerProvider)assemblyLoader.CreateInstance(type);

                    assemblyDescription.Initialize();

                    if (assemblyDescription.Enable)
                    {
                        assemblyDescription.AccountUpdate += AccountUpdate;
                        assemblyDescription.OrderUpdate   += OrderStatusUpdate;

                        _providers.Add(assemblyDescription);
                        _routes.Add(assemblyDescription.ProviderName);
                    }
                }
                catch (Exception ex)
                {
                    _logger.Error(ex);

                    if (ex.InnerException != null)
                    {
                        _logger.Error(ex.InnerException);
                    }
                }
            }
        }
        public override void RequestOrderStatusUpdates(Account acct)
        {
            if (acct == null)
            {
                foreach (LTBrokerProvider provider in _providers)
                {
                    List <LTAccount> accounts = _accounts.FindAll(x => x.ProviderName == provider.ProviderName);

                    foreach (Account account in accounts)
                    {
                        provider.Orders.AddRange(base.BrokerHost.GetOrders(account));
                    }

                    foreach (Order order in provider.Orders)
                    {
                        provider.OrderStatusUpdate(order);
                    }
                }
            }
            else
            {
                LTBrokerProvider ltProvider = (from account in _accounts
                                               from provider in _providers
                                               where account.AccountNumber == acct.AccountNumber &&
                                               account.ProviderName == provider.ProviderName
                                               select provider).FirstOrDefault();

                if (ltProvider != null)
                {
                    List <Order> orders = base.BrokerHost.GetOrders(acct);

                    foreach (Order order in orders)
                    {
                        ltProvider.OrderStatusUpdate(order);
                    }
                }
            }
        }