private static AlpacaTradingClientConfiguration withFactoryCreatedHttpClient(
     this AlpacaTradingClientConfiguration configuration,
     HttpClient httpClient)
 {
     configuration.HttpClient = httpClient;
     return(configuration);
 }
 public static IServiceCollection AddAlpacaTradingClient(
     this IServiceCollection services,
     AlpacaTradingClientConfiguration configuration) =>
 services
 .AddHttpClient <IAlpacaTradingClient>()
 .AddTypedClient <IAlpacaTradingClient>(
     httpClient => new AlpacaTradingClient(
         configuration.withFactoryCreatedHttpClient(httpClient)))
 .AddPolicyHandler(configuration
                   .EnsureNotNull(nameof(configuration))
                   .ThrottleParameters.GetAsyncPolicy())
 .Services;
Esempio n. 3
0
        public static async Task SellOnOnePercentGainAsync()
        {
            //setup rest client
            //var restClient = new RestClient(Switches.AlpacaAPIKey(), Switches.AlpacaSecretAPIKey(), Switches.AlpacaEndPoint());

            try
            {
                AlpacaTradingClientConfiguration config = new AlpacaTradingClientConfiguration();
                config.ApiEndpoint = new Uri(Switches.AlpacaEndPoint());
                //config.KeyId = Switches.AlpacaAPIKey();
                config.SecurityId = new SecretKey(Switches.AlpacaAPIKey(), Switches.AlpacaSecretAPIKey());
                var restClient = new AlpacaTradingClient(config);

                //var positions1 = await restClient.ListAssetsAsync(AssetStatus.Active);
                //var positions2 = await restClient.ListPositionsAsync();

                /*
                 * foreach (var position in positions)
                 * {
                 *  Console.Write(position);
                 * }
                 */
            }
            catch (Exception ex)
            {
                throw ex;
            }

            /*
             * if (File.Exists(Switches.stockDirectory + "Portfolio.csv"))
             * {
             *  var allLines = File.ReadAllLines(Switches.stockDirectory + "Portfolio.csv");
             *  for (int i = 1; i < allLines.Count(); i++)
             *  {
             *      string[] temp = allLines[i].Split(',');
             *      var p2 = await restClient.GetAssetAsync((temp[0]));
             *
             *      var position = await restClient.GetPositionAsync(temp[0]);
             *      //double required = temp[]
             *      int numberOfShares = position.Quantity;
             *      int daysAlloted = DateTime.Today.Day - Convert.ToDateTime(temp[1]).Day;
             *      double required = Convert.ToDouble(temp[3]);
             *
             *      //set minimal required selling point
             *      required *= 1.01;
             *
             *      try
             *      {
             *          if ((double)position.AssetCurrentPrice > required)
             *          {
             *              var order = await restClient.PostOrderAsync(temp[0], numberOfShares, OrderSide.Sell, OrderType.Market, TimeInForce.Day);
             *          }
             *      }
             *      catch (Exception ex)
             *      {
             *          Console.WriteLine("could not sell because " + ex.ToString());
             *      }
             *  }
             * }
             */
        }
 public static IAlpacaTradingClient GetClient(
     this AlpacaTradingClientConfiguration configuration) =>
 new AlpacaTradingClient(configuration);
Esempio n. 5
0
        static async Task Main(string[] args)
        {
            bool created = false;

            using (var m = new Mutex(true, "AlpacaTrade", out created))
            {
                if (!created)
                {
                    return;
                }

                try
                {
                    settings = JsonConvert.DeserializeObject <Settings>(File.ReadAllText(@"settings.json"));
                }
                catch (Exception)
                {
                    settings = new Settings();
                    File.WriteAllText(@"settings.json", JsonConvert.SerializeObject(settings, Formatting.Indented));

                    Console.WriteLine("Defaults have been saved to 'settings.json'");
                    Console.ReadKey();
                    return;
                }

                var c = new AlpacaTradingClientConfiguration();
                c.KeyId       = settings.Paper ? settings.AlpacaPaperKey : settings.AlpacaKey;
                c.SecurityId  = new SecretKey(settings.Paper ? settings.AlpacaPaperSecret : settings.AlpacaSecret);
                c.ApiEndpoint = new Uri(settings.Paper ? "https://paper-api.alpaca.markets" : "https://api.alpaca.markets");
                c.ApiVersion  = ApiVersion.V2;

                trading = new AlpacaTradingClient(c);

                while (true)
                {
                    await WaitMarketOpen();

                    foreach (var symbol in settings.Symbols)
                    {
                        var account = await trading.GetAccountAsync();

                        if (!account.IsTradingBlocked)
                        {
                            var orders   = GetOrders(symbol);
                            var position = GetPosition(symbol);
                            var candles  = await GetPolygonBars(symbol, "minute", DateTime.Now.AddDays(-7), DateTime.Now.AddDays(1));

                            await orders;
                            await position;

                            if (candles != null)
                            {
                                await Update(symbol, account, position.Result, orders.Result, candles);
                            }
                        }
                    }

                    await Task.Delay(10000);
                }
            }
        }