Added Accounts and Positions endpoints

.github/workflows/ci-build.yml

@@ -21,10 +21,10 @@ jobs:
     name: CI Build
     steps:
     - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
 
     - name: Setup .NET
-      uses: actions/setup-dotnet@v1
+      uses: actions/setup-dotnet@v3
       with:
         dotnet-version: 6.0.x
 
@@ -35,8 +35,8 @@ jobs:
       run: dotnet build Primary.sln --configuration Release --no-restore
 
     - name: Test
-      run: dotnet test Primary.sln --configuration Release --no-build --verbosity normal --collect:"XPlat Code Coverage" --results-directory ./coverage
-
+      run: dotnet test Primary.sln --configuration Release -- no-build --verbosity normal --collect:"XPlat Code Coverage" --results-directory ./coverage
+      
     - name: Copy Coverage To Predictable Location
       run: cp coverage/**/coverage.cobertura.xml coverage.cobertura.xml
 

.gitignore

@@ -21,3 +21,5 @@ bld/
 /Primary.Tests/bin
 /Primary.Tests/obj
 *.user
+
+coverage/

Primary.Tests/AccountsTests.cs

@@ -1,4 +1,5 @@
 using NUnit.Framework;
+using Primary.Data.Orders;
 using System.Linq;
 using System.Threading.Tasks;
 
@@ -25,5 +26,56 @@ public async Task AccountStatementCanBeRetrieved()
             Assert.That(detailedAccountReport.CurrencyBalance, Is.Not.Null.And.Not.Empty);
             Assert.That(detailedAccountReport.AvailableToOperate.Cash.DetailedCash, Is.Not.Empty);
         }
+
+        [Test]
+        public async Task AccountsCanBeRetrieved()
+        {
+            var accounts = await Api.GetAccounts();
+            Assert.That(accounts, Is.Not.Empty);
+
+            var account = accounts.First();
+            Assert.That(account.BrokerId, Is.Not.EqualTo(default));
+            Assert.That(account.Id, Is.Not.EqualTo(default));
+            Assert.That(account.Name, Is.EqualTo(Api.DemoAccount));
+            Assert.That(account.Status, Is.True);
+        }
+
+        [Test]
+        [Timeout(20000)]
+        public async Task PositionsCanBeRetrieved()
+        {
+            var marketData = await GetSomeMarketData();
+            var symbol = marketData.InstrumentId.Symbol;
+
+            // Take the opposite side.
+            var order = new Order()
+            {
+                InstrumentId = marketData.InstrumentId,
+                Type = Type.Market,
+                Side = marketData.Data.Offers?.Length > 0 ? Side.Buy : Side.Sell,
+                Quantity = AllInstrumentsBySymbol[symbol].MinimumTradeVolume,
+            };
+
+            var orderId = await Api.SubmitOrder(Api.DemoAccount, order);
+            await WaitForOrderToComplete(orderId);
+
+            var positions = await Api.GetAccountPositions(Api.DemoAccount);
+            Assert.That(positions, Is.Not.Null);
+
+            var position = positions.FirstOrDefault(p => p.Symbol == symbol);
+            Assert.That(position, Is.Not.EqualTo(default));
+            Assert.That(position.Symbol, Is.EqualTo(symbol));
+
+            if (order.Side == Side.Buy)
+            {
+                Assert.That(position.BuySize, Is.GreaterThanOrEqualTo(order.Quantity));
+                Assert.That(position.OriginalBuyPrice, Is.Not.EqualTo(0));
+            }
+            else
+            {
+                Assert.That(position.SellSize, Is.GreaterThanOrEqualTo(order.Quantity));
+                Assert.That(position.OriginalSellPrice, Is.Not.EqualTo(0));
+            }
+        }
     }
-}
+}

Primary.Tests/ApiTests.cs

@@ -24,6 +24,8 @@ public async Task AllAvailableInstrumentsCanBeRetrieved()
                 Assert.That(instrument.PriceConversionFactor, Is.Not.EqualTo(default));
                 Assert.That(instrument.CfiCode, Is.Not.Null.And.Not.Empty);
                 Assert.That(instrument.Type, Is.Not.EqualTo(InstrumentType.Unknown));
+                Assert.That(instrument.MinimumTradeVolume, Is.GreaterThanOrEqualTo(0));
+                Assert.That(instrument.MaximumTradeVolume, Is.GreaterThanOrEqualTo(0));
             }
 
             Assert.That(instruments.Where(i => i.MaturityDate != default), Is.Not.Empty);

Primary.Tests/TestWithApi.cs

@@ -1,11 +1,71 @@
-using System;
+using Primary.Data;
+using Primary.Data.Orders;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace Primary.Tests
 {
     internal class TestWithApi
     {
-        protected Api Api { get { return _lazyApi.Value; } }
+        protected Api Api => _lazyApi.Value;
 
-        private static readonly Lazy<Api> _lazyApi = new Lazy<Api>(() => Build.AnApi().Result);
+        private static readonly Lazy<Api> _lazyApi = new(() => Build.AnApi().Result);
+
+        protected async Task<MarketData> GetSomeMarketData()
+        {
+            if (AllInstrumentsBySymbol == null)
+            {
+                AllInstrumentsBySymbol = (await Api.GetAllInstruments()).ToDictionary(i => i.Symbol, i => i);
+            }
+
+            using var socket = Api.CreateMarketDataSocket(AllInstrumentsBySymbol.Values, new[] { Entry.Offers, Entry.Bids }, 1, 1);
+
+            MarketData retrievedData = null;
+            var dataSemaphore = new SemaphoreSlim(0, 1);
+            socket.OnData = ((_, marketData) =>
+            {
+                var instrument = AllInstrumentsBySymbol[marketData.InstrumentId.Symbol];
+
+                if (instrument.Type == InstrumentType.Equity &&
+                    (
+                        (marketData.Data.Offers != null &&
+                         marketData.Data.Offers[0].Size > instrument.MinimumTradeVolume * 2)
+                        ||
+                        (marketData.Data.Bids != null &&
+                         marketData.Data.Bids[0].Size > instrument.MinimumTradeVolume * 2)
+                    )
+                )
+                {
+                    retrievedData = marketData;
+                    dataSemaphore.Release();
+                }
+            });
+
+            await socket.Start();
+            await dataSemaphore.WaitAsync();
+
+            return retrievedData;
+        }
+
+        protected async Task<OrderStatus> WaitForOrderToComplete(OrderId orderId)
+        {
+            var orderStatus = await Api.GetOrderStatus(orderId);
+            while (orderStatus.Status != Status.Rejected && orderStatus.Status != Status.Filled)
+            {
+                Thread.Sleep(200);
+                orderStatus = await Api.GetOrderStatus(orderId);
+            }
+
+            if (orderStatus.Status == Status.Rejected)
+            {
+                throw new InvalidOperationException($"{orderStatus.StatusText} / {orderStatus.InstrumentId.Symbol} / {orderStatus.Side}");
+            }
+            return orderStatus;
+        }
+
+        protected Dictionary<string, Instrument> AllInstrumentsBySymbol;
     }
 }

Primary.sln

@@ -6,6 +6,7 @@ MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{3559615F-B6AA-46C5-882E-0DC3A0BB950B}"
 	ProjectSection(SolutionItems) = preProject
 		.gitignore = .gitignore
+		global,json.txt = global,json.txt
 		README.md = README.md
 	EndProjectSection
 EndProject

Primary/Api.cs

@@ -130,13 +130,13 @@
         private class GetTradesResponse
         {
             [JsonProperty("status")]
             public string Status;
 
             [JsonProperty("message")]
             public string Message;
 
             [JsonProperty("description")]
             public string Description;
 
             [JsonProperty("trades")]
             public List<Trade> Trades { get; set; }
@@ -351,7 +351,7 @@
         private struct StatusResponse
         {
             [JsonProperty("status")]
             public string Status;
 
             [JsonProperty("message")]
             public string Message;
@@ -385,13 +385,13 @@
         private struct OrderIdResponse
         {
             [JsonProperty("status")]
             public string Status;
 
             [JsonProperty("message")]
             public string Message;
 
             [JsonProperty("description")]
             public string Description;
 
             public struct Id
             {
@@ -403,19 +403,19 @@
             }
 
             [JsonProperty("order")]
             public Id Order;
         }
 
         private struct GetOrderResponse
         {
             [JsonProperty("status")]
             public string Status;
 
             [JsonProperty("message")]
             public string Message;
 
             [JsonProperty("description")]
             public string Description;
 
             [JsonProperty("order")]
             public OrderStatus Order { get; set; }
@@ -425,6 +425,35 @@
 
         #region Accounts
 
+        public async Task<IEnumerable<Account>> GetAccounts()
+        {
+            var builder = new UriBuilder(BaseUri + "rest/accounts");
+
+            var jsonResponse = await HttpClient.GetStringAsync(builder.Uri);
+
+            var response = JsonConvert.DeserializeObject<AccountsResponse>(jsonResponse);
+            if (response.Status == Status.Error)
+            {
+                throw new Exception($"{response.Message} ({response.Description})");
+            }
+            return response.Accounts;
+        }
+
+        public class AccountsResponse
+        {
+            [JsonProperty("status")]
+            public string Status;
+
+            [JsonProperty("message")]
+            public string Message { get; set; }
+
+            [JsonProperty("description")]
+            public string Description { get; set; }
+
+            [JsonProperty("accounts")]
+            public List<Account> Accounts { get; set; }
+        }
+
         public async Task<AccountStatement> GetAccountStatement(string accountId)
         {
             var uri = new Uri(BaseUri, "/rest/risk/accountReport/" + accountId);
@@ -457,6 +486,38 @@
 
         #endregion
 
+        #region Positions
+
+        public async Task<IEnumerable<Position>> GetAccountPositions(string accountName)
+        {
+            var builder = new UriBuilder(BaseUri + $"rest/risk/position/getPositions/{accountName}");
+            var jsonResponse = await HttpClient.GetStringAsync(builder.Uri);
+
+            var response = JsonConvert.DeserializeObject<PositionsResponse>(jsonResponse);
+            if (response.Status == Status.Error)
+            {
+                throw new Exception($"{response.Message} ({response.Description})");
+            }
+            return response.Positions;
+        }
+
+        public class PositionsResponse
+        {
+            [JsonProperty("status")]
+            public string Status;
+
+            [JsonProperty("message")]
+            public string Message;
+
+            [JsonProperty("description")]
+            public string Description;
+
+            [JsonProperty("positions")]
+            public List<Position> Positions { get; set; }
+        }
+
+        #endregion
+
         #region Constants
 
         private static class Status

Primary/Data/Account.cs

@@ -0,0 +1,23 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Primary.Data;
+
+public class Account
+{
+    [JsonProperty("id")]
+    public int Id { get; set; }
+
+    [JsonProperty("name")]
+    public string Name { get; set; }
+
+    [JsonProperty("brokerId")]
+    public int BrokerId { get; set; }
+
+    [JsonProperty("status")]
+    public bool Status { get; set; }
+}

Primary/Data/Instrument.cs

@@ -21,10 +21,10 @@ public class InstrumentId
         #region JSON serialization
 
         [JsonProperty("instrumentId.marketId")]
-        protected string NestedMarket { get { return Market; } set { Market = value; } }
+        protected string NestedMarket { get => Market; set => Market = value; }
 
         [JsonProperty("instrumentId.symbol")]
-        protected string NestedSymbol { get { return Symbol; } set { Symbol = value; } }
+        protected string NestedSymbol { get => Symbol; set => Symbol = value; }
 
         /// <summary>This is used for serialization purposes and should not be called.</summary>
         public bool ShouldSerializeNestedMarket() { return false; }
@@ -61,31 +61,33 @@ public class Instrument : InstrumentId
         public string CfiCode { get; set; }
 
         /// <summary>Instrument type from CFI code.</summary>
-        public InstrumentType Type
+        public InstrumentType Type => CfiCode switch
         {
-            get
-            {
-                return CfiCode switch
-                {
-                    "ESXXXX" => InstrumentType.Equity,
-                    "DBXXXX" => InstrumentType.Bond,
-                    "OCASPS" => InstrumentType.EquityCallOption,
-                    "OPASPS" => InstrumentType.EquityPutOption,
-                    "FXXXSX" => InstrumentType.Future,
-                    "OPAFXS" => InstrumentType.FuturePutOption,
-                    "OCAFXS" => InstrumentType.FutureCallOption,
-                    "EMXXXX" => InstrumentType.Cedear,
-                    "DBXXFR" => InstrumentType.Obligation,
-                    "MRIXXX" => InstrumentType.Index,
-                    "FXXXXX" => InstrumentType.Future,
-                    "RPXXXX" => InstrumentType.Caucion,
-                    "MXXXXX" => InstrumentType.Miscellaneous,
-                    "LRSTXH" => InstrumentType.Miscellaneous,
-                    "DYXTXR" => InstrumentType.TreasureNotes,
-                    _ => InstrumentType.Unknown
-                };
-            }
-        }
+            "ESXXXX" => InstrumentType.Equity,
+            "DBXXXX" => InstrumentType.Bond,
+            "OCASPS" => InstrumentType.EquityCallOption,
+            "OPASPS" => InstrumentType.EquityPutOption,
+            "FXXXSX" => InstrumentType.Future,
+            "OPAFXS" => InstrumentType.FuturePutOption,
+            "OCAFXS" => InstrumentType.FutureCallOption,
+            "EMXXXX" => InstrumentType.Cedear,
+            "DBXXFR" => InstrumentType.Obligation,
+            "MRIXXX" => InstrumentType.Index,
+            "FXXXXX" => InstrumentType.Future,
+            "RPXXXX" => InstrumentType.Caucion,
+            "MXXXXX" => InstrumentType.Miscellaneous,
+            "LRSTXH" => InstrumentType.Miscellaneous,
+            "DYXTXR" => InstrumentType.TreasureNotes,
+            _ => InstrumentType.Unknown
+        };
+
+        /// <summary>Minimum volume that can be traded for this instrument.</summary>
+        [JsonProperty("minTradeVol")]
+        public uint MinimumTradeVolume { get; set; }
+
+        /// <summary>Maximum volume that can be traded for this instrument.</summary>
+        [JsonProperty("maxTradeVol")]
+        public uint MaximumTradeVolume { get; set; }
     }
 
     public enum InstrumentType