Exemple #1
0
 /// <summary>
 /// Create unknown security type, cannot be used anywhere
 /// </summary>
 /// <param name="ticker"></param>
 public UnknownSecurity(string ticker)
     : base(TickerSymbol.NIL(ticker), null, SecurityDetails.NIL(), SecurityType.NIL, null)
 {
 }
Exemple #2
0
        /// <summary>
        /// Creates a security object based on requested security point
        /// </summary>
        /// <param name="tickername"></param>
        /// <returns></returns>
        public Security Create(string tickername)
        {
            //Set default details
            var details = SecurityDetails.NIL();

            //Get config
            var configured = Config.SecurityConfig.FirstOrDefault(x => x.Ticker == tickername);

            if (configured == null)
            {
                return(new UnknownSecurity(tickername));
            }

            //Get security type
            if (!Enum.TryParse(configured.Type, out SecurityType securitytype))
            {
                securitytype = SecurityType.NIL;
            }

            //Get Exchnage
            ExchangeModel exchangeModel = _exchangeModels.FirstOrDefault(x => x.Name == configured.Exchange);

            if (exchangeModel == null)
            {
                _log.Error(
                    $"Exchange with name {configured.Exchange} is not loaded, cannot load security {tickername}. This security is marked as unknown.");
                return(new UnknownSecurity(tickername));
            }

            //Convert
            CurrencyType basecurrency = (CurrencyType)Enum.Parse(typeof(CurrencyType), configured.Currency);

            //Get commodity
            string commodity = configured.Commodity;

            //Create security
            SecurityBase toreturn;

            switch (securitytype)
            {
            case SecurityType.NIL:
                return(new UnknownSecurity(tickername));

            case SecurityType.Equity:
                toreturn = new EquitySecurity(new TickerSymbol(tickername, commodity, basecurrency), exchangeModel, details, _currency);
                break;

            case SecurityType.Crypto:
                toreturn = GetCryptoCurrency(tickername, commodity, exchangeModel, details);
                break;

            default:
                return(new UnknownSecurity(tickername));
            }

            //Check if security is known by broker model
            try
            {
                if (!_brokerModel.IsSecuritySupported(toreturn))
                {
                    _log.Warn($"Security with ticker {tickername} is not supported by broker, it is marked as unknown");
                    return(new UnknownSecurity(tickername));
                }
            }
            catch (Exception exc)
            {
                _log.Error(exc, $"Error while invoking broker model IsSecuritySupported for security with ticker name {tickername}");
                return(new UnknownSecurity(tickername));
            }

            //Set details
            toreturn.Details = _brokerModel.GetSecurityDetails(toreturn);

            //Return what we have
            return(toreturn);
        }