Gateways

Author: artemiusgreat

Core/Core/Conventions/Gateway.cs

@@ -29,7 +29,7 @@ public interface ITradeObserver : IGrainObserver
     /// Price message
     /// </summary>
     /// <param name="instrument"></param>
-    Task StreamTrade(Instrument instrument);
+    Task StreamInstrument(Instrument instrument);
   }
 
   public interface IGateway
@@ -52,7 +52,7 @@ public interface IGateway
     /// <summary>
     /// Trade message
     /// </summary>
-    Func<Instrument, Task> OnTrade { get; set; }
+    Func<Instrument, Task> OnInstrument { get; set; }
 
     /// <summary>
     /// Connect
@@ -171,7 +171,7 @@ public abstract class Gateway : IGateway, ITradeObserver
     /// <summary>
     /// Trade message
     /// </summary>
-    public virtual Func<Instrument, Task> OnTrade { get; set; } = o => Task.CompletedTask;
+    public virtual Func<Instrument, Task> OnInstrument { get; set; } = o => Task.CompletedTask;
 
     /// <summary>
     /// Order message
@@ -189,7 +189,7 @@ public abstract class Gateway : IGateway, ITradeObserver
     /// Price message
     /// </summary>
     /// <param name="instrument"></param>
-    public virtual Task StreamTrade(Instrument instrument) => OnTrade(instrument);
+    public virtual Task StreamInstrument(Instrument instrument) => OnInstrument(instrument);
 
     /// <summary>
     /// Connect

Core/Core/Enums/OrderTypeEnum.cs

@@ -7,5 +7,6 @@ public enum OrderTypeEnum : byte
     Limit,
     Market,
     StopLimit,
+    LimitMaker,
   }
 }

Core/Core/Grains/OrderGrain.cs

@@ -1,11 +1,9 @@
 using Core.Enums;
-using Core.Extensions;
 using Core.Models;
 using Core.Validators;
 using Orleans;
-using System;
 using System.Collections.Generic;
-using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace Core.Grains
@@ -19,139 +17,81 @@ public interface IOrdersGrain : IGrainWithStringKey
     Task<OrdersResponse> Orders(Criteria criteria);
 
     /// <summary>
-    /// Store order
+    /// Store orders
     /// </summary>
-    /// <param name="order"></param>
-    Task<OrderResponse> Store(Order order);
+    /// <param name="orders"></param>
+    Task<StatusResponse> Store(Dictionary<string, Order> orders);
 
     /// <summary>
-    /// Send order
+    /// Store order
     /// </summary>
     /// <param name="order"></param>
-    Task<OrderResponse> Send(Order order);
-
-    /// <summary>
-    /// Update order data
-    /// </summary>
-    /// <param name="instrument"></param>
-    Task<StatusResponse> Tap(Instrument instrument);
+    Task<OrderResponse> Store(Order order);
 
     /// <summary>
     /// Remove order from the list
     /// </summary>
     /// <param name="order"></param>
     Task<DescriptorResponse> Clear(Order order);
-
-    /// <summary>
-    /// Clear orders
-    /// </summary>
-    Task<StatusResponse> Clear();
   }
 
-  public class OrdersGrain : Grain<Orders>, IOrdersGrain
+  public class OrdersGrain : Grain<Dictionary<string, Order>>, IOrdersGrain
   {
     /// <summary>
     /// Order validator
     /// </summary>
     protected OrderValidator orderValidator = new();
 
     /// <summary>
-    /// Get orders
+    /// Activation
     /// </summary>
-    /// <param name="criteria"></param>
-    public virtual async Task<OrdersResponse> Orders(Criteria criteria)
+    /// <param name="cancellation"></param>
+    public override async Task OnActivateAsync(CancellationToken cancellation)
     {
-      var items = await Task.WhenAll(State
-        .Grains
-        .Values
-        .Select(o => o.Order()));
-
-      return new()
-      {
-        Data = items
-      };
+      State = [];
+      await base.OnActivateAsync(cancellation);
     }
 
     /// <summary>
-    /// Store order
+    /// Get orders
     /// </summary>
-    /// <param name="order"></param>
-    public virtual async Task<OrderResponse> Store(Order order)
+    /// <param name="criteria"></param>
+    public virtual async Task<OrdersResponse> Orders(Criteria criteria) => new()
     {
-      var descriptor = this.GetDescriptor(order.Id);
-      var grain = GrainFactory.GetGrain<IOrderGrain>(descriptor);
-
-      await grain.Store(order with
-      {
-        Operation = order.Operation with
-        {
-          Status = OrderStatusEnum.Order
-        }
-      });
-
-      State.Grains[order.Id] = grain;
-
-      return new()
-      {
-        Data = order
-      };
-    }
+      Data = [.. State.Values]
+    };
 
     /// <summary>
-    /// Send order
+    /// Store positions
     /// </summary>
-    /// <param name="order"></param>
-    public virtual async Task<OrderResponse> Send(Order order)
+    /// <param name="orders"></param>
+    public virtual Task<StatusResponse> Store(Dictionary<string, Order> orders)
     {
-      var response = new OrderResponse
-      {
-        Errors = [.. Errors(order).Select(error => error.Message).Distinct()]
-      };
+      State = orders;
 
-      if (response.Errors.Count is 0)
+      return Task.FromResult(new StatusResponse()
       {
-        var orders = order
-          .Orders
-          .Where(o => o.Instruction is null)
-          .ToList();
-
-        if (order.Amount is not null || order.Orders.Count is 0)
-        {
-          orders.Add(order);
-        }
-
-        foreach (var o in orders)
-        {
-          await Store(o with { Orders = [.. o.Orders.Where(v => v.Instruction is InstructionEnum.Brace)] });
-        }
-      }
-
-      return response;
+        Data = StatusEnum.Active
+      });
     }
 
     /// <summary>
-    /// Update order data
+    /// Store order
     /// </summary>
-    /// <param name="instrument"></param>
-    public virtual async Task<StatusResponse> Tap(Instrument instrument)
+    /// <param name="order"></param>
+    public virtual async Task<OrderResponse> Store(Order order)
     {
-      var descriptor = this.GetDescriptor();
-      var positionsGrain = GrainFactory.GetGrain<IPositionsGrain>(descriptor);
-
-      foreach (var grain in State.Grains)
+      State[order.Id] = order with
       {
-        var response = await grain.Value.Tap(instrument);
-
-        if (response.Data is not null)
+        Operation = order.Operation with
         {
-          State.Grains.Remove(grain.Key);
-          await positionsGrain.Send(response.Data);
+          Status = OrderStatusEnum.Order
         }
-      }
+      };
 
       return new()
       {
-        Data = StatusEnum.Active
+        Data = order
       };
     }
 
@@ -161,47 +101,12 @@ public virtual async Task<StatusResponse> Tap(Instrument instrument)
     /// <param name="order"></param>
     public virtual Task<DescriptorResponse> Clear(Order order)
     {
-      State.Grains.Remove(order.Id);
+      State.Remove(order.Id);
 
       return Task.FromResult(new DescriptorResponse
       {
         Data = order.Id
       });
     }
-
-    /// <summary>
-    /// Clear orders
-    /// </summary>
-    public virtual Task<StatusResponse> Clear()
-    {
-      State.Grains.Clear();
-
-      return Task.FromResult(new StatusResponse
-      {
-        Data = StatusEnum.Inactive
-      });
-    }
-
-    /// <summary>
-    /// Preprocess order
-    /// </summary>
-    /// <param name="order"></param>
-    protected virtual List<Error> Errors(Order order)
-    {
-      var response = new List<Error>();
-      var orders = order.Orders.Append(order);
-
-      foreach (var subOrder in orders)
-      {
-        var errors = orderValidator
-          .Validate(subOrder)
-          .Errors
-          .Select(error => new Error { Message = error.ErrorMessage });
-
-        response.AddRange(errors);
-      }
-
-      return response;
-    }
   }
 }