public BoardMessageResponse SetBoardMessage(BoardMessage boardMessage)
{
if (boardMessage == null)
{
throw new ArgumentNullException(nameof(boardMessage));
}
var response = this.ValidateBoardMessage(boardMessage);
response.StorageOperation = new StorageOperation()
{
Id = Enums.StorageOperationEnum.Create,
Name = Constants.Constants.StorageOperations.Create
};
if (!response.OperationSuccess)
{
response.BoardMessage = boardMessage;
throw new HttpResponseException(response);
}
var messages = this.GetBoardMessages();
boardMessage.Id = this.idProvider.GetNextId(messages);
boardMessage.Created = DateTime.UtcNow;
boardMessage.Modified = null;
boardMessage.IsMine = null;
messages.Add(boardMessage);
this.cacheService.Store(Constants.Constants.CacheKeys.AllBoardMessages, messages);
response.BoardMessage = boardMessage;
response.Status = $"Successfully stored board message with id: {boardMessage.Id}";
return(response);
}
private BoardMessageResponse ValidateBoardMessage(BoardMessage boardMessage)
{
var response = new BoardMessageResponse();
if (boardMessage == null)
{
response.OperationSuccess = false;
response.Status = "Boardmessage is null.";
return(response);
}
if (string.IsNullOrWhiteSpace(boardMessage.Message))
{
response.OperationSuccess = false;
response.Status = "Boardmessage.Message cannot be empty";
return(response);
}
if (!this.clientService.ClientExists(boardMessage.ClientId))
{
response.OperationSuccess = false;
response.Status = "BoardMessage.ClientId is not a valid clientId, the client does not exist.";
return(response);
}
response.OperationSuccess = true;
response.Status = "BoardMessage is valid.";
return(response);
}
public void UpdateValidBoardMessageReturnsValidBoardMessageResponse()
{
var existingBoardMessageWithUpdatedMessage = new BoardMessage()
{
Id = MockData.BoardMessageMocks.ExistingValidBoardMessage.Id,
Message = "This message is modified and should be updated.",
ClientId = MockData.BoardMessageMocks.ExistingValidBoardMessage.ClientId,
Created = MockData.BoardMessageMocks.ExistingValidBoardMessage.Created
};
var expected = new BoardMessageResponse()
{
BoardMessage = existingBoardMessageWithUpdatedMessage,
OperationSuccess = true,
StorageOperation = new Entities.StorageOperation()
{
Id = Enums.StorageOperationEnum.Update,
Name = Constants.Constants.StorageOperations.Update
}
};
var response = boardMessageService.UpdateBoardMessage(existingBoardMessageWithUpdatedMessage);
// setting not tested properties
expected.Status = response.Status;
expected.BoardMessage.Modified = response.BoardMessage.Modified;
// convert to json strings for comparison
var jsonExpected = JsonConvert.SerializeObject(expected);
var jsonResponse = JsonConvert.SerializeObject(response);
Assert.AreEqual(jsonExpected, jsonResponse);
}
private void ProcessBoardMessage(BoardMessage message)
{
ExchangeBoard.GetOrCreateBoard(message.Code, code =>
{
var exchange = message.ToExchange(EntityFactory.CreateExchange(message.ExchangeCode));
return message.ToBoard(EntityFactory.CreateBoard(code, exchange));
});
}
public void UpdateBoardDefinition(BoardMessage message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
_timeZoneInfo = message.TimeZoneInfo;
}
public ActionResult <Board> CreateBoard([FromBody] BoardMessage boardMessage)
{
Board board = _boardService.Create(boardMessage.title, boardMessage.description, boardMessage.currentProjectId);
if (board == null)
{
return(BadRequest(boardMessage));
}
return(Ok(board));
}
public static MessageDto Create(BoardMessage boardMessage)
{
return(new MessageDto
{
Id = boardMessage.Id,
ClientId = boardMessage.ClientId,
Message = boardMessage.Message,
CreatedAt = boardMessage.CreatedAt,
ModifiedAt = boardMessage.ModifiedAt
});
}
public void UpdateBoardMessageWithOtherClientsIdThrowsHttpResponseException()
{
var existingBoardMessageWithOtherClientId = new BoardMessage()
{
Id = MockData.BoardMessageMocks.ExistingValidBoardMessage.Id,
ClientId = MockData.BoardMessageMocks.ExistingValidBoardMessage.ClientId + 1,
Created = MockData.BoardMessageMocks.ExistingValidBoardMessage.Created,
Message = MockData.BoardMessageMocks.ExistingValidBoardMessage.Message
};
boardMessageService.UpdateBoardMessage(existingBoardMessageWithOtherClientId);
Assert.Fail();
}
/// <inheritdoc />
public override void Init()
{
base.Init();
_lastTradePrice = null;
_prevTradePrice = null;
_bestAskPrice = null;
_bestBidPrice = null;
_newTrades = false;
_currGenerations = MaxGenerations;
_boardDefinition = null;
}
public BoardMessageResponse UpdateBoardMessage(BoardMessage boardMessage)
{
if (boardMessage == null)
{
throw new ArgumentNullException(nameof(boardMessage));
}
var response = this.ValidateBoardMessage(boardMessage);
response.StorageOperation = new StorageOperation()
{
Id = Enums.StorageOperationEnum.Update,
Name = Constants.Constants.StorageOperations.Update
};
if (!response.OperationSuccess)
{
response.BoardMessage = boardMessage;
throw new HttpResponseException(response);
}
if (!boardMessage.Id.IsValidId())
{
response.BoardMessage = boardMessage;
throw new HttpResponseException(response, $"{boardMessage.Id} is not a valid {nameof(boardMessage.Id)}");
}
var messageList = this.GetBoardMessages();
var messageToUpdate = messageList.FirstOrDefault(message => message.Id == boardMessage.Id);
if (messageToUpdate == null)
{
throw new HttpResponseException(response, $"Cannot update board message with id: {boardMessage.Id} => message does not exist.");
}
if (messageToUpdate.ClientId != boardMessage.ClientId)
{
throw new HttpResponseException(response, $"Cannot update board message with id: {messageToUpdate.Id} => message is not created by client with id: {boardMessage.ClientId}.");
}
messageList = messageList.Where(message => message.Id != messageToUpdate.Id).ToList();
messageToUpdate.Modified = DateTime.UtcNow;
messageToUpdate.Message = boardMessage.Message;
messageList.Add(messageToUpdate);
this.cacheService.Store <List <BoardMessage> >(Constants.Constants.CacheKeys.AllBoardMessages, messageList);
response.BoardMessage = messageToUpdate;
response.Status = $"Successfully updated board message with id: {messageToUpdate.Id}";
return(response);
}
public async Task Should_return_non_empty_array_when_message_exists()
{
// Arrange
var messages = new List <BoardMessage>
{
BoardMessage.Create("The message", Guid.NewGuid().ToString())
};
_mockedReadOnlyContext.Setup(x => x.Messages).Returns(messages.AsQueryable().BuildMock().Object);
var query = new ListMessagesQuery();
var handler = new ListMessagesQueryHandler(_mockedReadOnlyContext.Object);
// Act
var messagesDto = await handler.Handle(query, default);
// Assert
Assert.NotEmpty(messagesDto);
_mockedReadOnlyContext.Verify(x => x.Messages, Times.Once);
}
// TODO: Use FluentValidation for CreateMessageCommand to get rid of the validation of the params in the handler
public async Task <Result <MessageDto> > Handle(CreateMessageCommand request, CancellationToken cancellationToken)
{
if (string.IsNullOrWhiteSpace(request.Message))
{
return(Result.Fail <BadRequest, MessageDto>("Message is required."));
}
if (string.IsNullOrWhiteSpace(request.ClientId))
{
return(Result.Fail <BadRequest, MessageDto>("ClientId is required."));
}
var message = BoardMessage.Create(request.Message, request.ClientId);
_messageRepository.Add(message);
await _messageRepository.UnitOfWork.SaveChangesAsync(cancellationToken);
var messageDto = MessageDto.Create(message);
return(Result.Ok <Created, MessageDto>(messageDto));
}
protected Message ProcessIncomingEnvelope(Envelope env)
{
this.IncomingEnvelopes.Enqueue(env);
Identifier messageNumber = new Identifier(SubSystem.ProcessID, SubSystem.GetNextSeqNumber());
if (env.Message.GetType() == typeof(BoardMessage))
{
Logger.Info("Received a board message in RespondBoard convo");
BoardMessage boardMessage = (BoardMessage)env.Message;
GMAppState appState = SubSystem.appState as GMAppState;
lock (boardAccessLock)
{
if (appState.P1grid == null) //Board message maybe should include player id. That way we dont have to check the endpoints.
{
appState.P1grid = boardMessage.getGrid();
appState.p1PID = boardMessage.MessageNumber.Pid;
appState.P1EndPoint = env.From;
Logger.Info("set player 1's grid in GM");
}
else
{
appState.P2grid = boardMessage.getGrid();
appState.p2PID = boardMessage.MessageNumber.Pid;
appState.P2EndPoint = env.From;
Logger.Info("set player 2's grid in GM");
}
}
return(new AckMessage(boardMessage.getGameId(), 0, messageNumber, this.ConversationId));
}
else
{
Logger.Error("Did not receive a board message in RespondBoard convo");
return(new ErrorMessage(2, messageNumber, ConversationId));
}
}
public async Task Should_return_expected_number_of_items()
{
// Arrange
var messages = new List <BoardMessage>
{
BoardMessage.Create("First message", Guid.NewGuid().ToString()),
BoardMessage.Create("Second message", Guid.NewGuid().ToString()),
BoardMessage.Create("Third message", Guid.NewGuid().ToString())
};
_mockedReadOnlyContext.Setup(x => x.Messages).Returns(messages.AsQueryable().BuildMock().Object);
var query = new ListMessagesQuery();
var handler = new ListMessagesQueryHandler(_mockedReadOnlyContext.Object);
// Act
var messagesDto = await handler.Handle(query, default);
// Assert
Assert.NotEmpty(messagesDto);
Assert.Equal(messages.Count, messagesDto.Count());
_mockedReadOnlyContext.Verify(x => x.Messages, Times.Once);
}
private void ProcessBoardMessage(BoardMessage boardMsg)
{
SendOutMessage(boardMsg);
}
/// <inheritdoc />
protected override Message OnProcess(Message message)
{
if (_boardDefinition == null)
{
if (message.Type == MessageTypes.Board)
{
_boardDefinition = (BoardMessage)message.Clone();
}
return(null);
}
DateTimeOffset time;
switch (message.Type)
{
case MessageTypes.Level1Change:
{
var l1Msg = (Level1ChangeMessage)message;
var value = l1Msg.TryGetDecimal(Level1Fields.LastTradePrice);
if (value != null)
{
_lastTradePrice = value.Value;
}
value = l1Msg.TryGetDecimal(Level1Fields.BestBidPrice);
if (value != null)
{
_bestBidPrice = value.Value;
}
value = l1Msg.TryGetDecimal(Level1Fields.BestAskPrice);
if (value != null)
{
_bestAskPrice = value.Value;
}
time = l1Msg.ServerTime;
break;
}
case MessageTypes.Execution:
{
var execMsg = (ExecutionMessage)message;
switch (execMsg.ExecutionType)
{
case ExecutionTypes.Tick:
{
var tradePrice = execMsg.TradePrice;
if (null == _prevTradePrice)
{
_prevTradePrice = tradePrice;
_bestAskPrice = tradePrice;
_bestBidPrice = tradePrice;
}
switch (execMsg.OriginSide)
{
case null:
{
if (tradePrice > _prevTradePrice)
{
_bestAskPrice = tradePrice;
//BestBid = PrevTrade;
_prevTradePrice = tradePrice;
}
else if (tradePrice < _prevTradePrice)
{
_bestBidPrice = tradePrice;
//BestAsk = PrevTrade;
_prevTradePrice = tradePrice;
}
break;
}
case Sides.Buy:
_bestAskPrice = tradePrice;
break;
default:
_bestBidPrice = tradePrice;
break;
}
_lastTradePrice = tradePrice;
_newTrades = true;
break;
}
default:
return(null);
}
time = execMsg.ServerTime;
break;
}
case MessageTypes.Time:
{
var timeMsg = (TimeMessage)message;
time = timeMsg.ServerTime;
break;
}
default:
return(null);
}
if (_currGenerations == 0 || _bestBidPrice == null || _bestAskPrice == null)
{
return(null);
}
var isTradeTime = _boardDefinition.IsTradeTime(time);
var canProcess = GenerateDepthOnEachTrade && _newTrades
? isTradeTime
: (IsTimeToGenerate(time) && isTradeTime);
if (!canProcess)
{
return(null);
}
_currGenerations = MaxGenerations;
var depth = new QuoteChangeMessage
{
SecurityId = SecurityId,
ServerTime = time,
LocalTime = time,
};
if (_bestBidPrice == null || _bestAskPrice == null)
{
if (_lastTradePrice == null)
{
throw new InvalidOperationException(LocalizedStrings.Str1142);
}
_bestBidPrice = _bestAskPrice = _lastTradePrice;
}
if (_currGenerations == 0)
{
throw new InvalidOperationException(LocalizedStrings.Str1143);
}
var bidPrice = _bestBidPrice;
var askPrice = _bestAskPrice;
var minSpred = MinSpreadStepCount * SecurityDefinition.PriceStep;
var maxStread = MaxSpreadStepCount * SecurityDefinition.PriceStep;
if ((askPrice - bidPrice) < minSpred)
{
if (_bestBidPrice == _lastTradePrice) // up trend
{
askPrice = bidPrice + minSpred;
}
else
{
bidPrice = askPrice - minSpred;
}
}
else if ((askPrice - bidPrice) > maxStread)
{
if (_bestBidPrice == _lastTradePrice) // down trend
{
askPrice = bidPrice + maxStread;
}
else
{
bidPrice = askPrice - maxStread;
}
}
var bids = new List <QuoteChange>();
//{
// new QuoteChange(Sides.Buy, bidPrice.Value, Volumes.Next())
//};
var count = MaxBidsDepth /* - bids.Count*/;
for (var i = 0; i < count; i++)
{
var quote = CreateQuote(bidPrice.Value, Sides.Buy);
if (quote.Price <= 0)
{
break;
}
bids.Add(quote);
bidPrice = quote.Price;
}
var asks = new List <QuoteChange>();
//{
// new QuoteChange(Sides.Sell, askPrice.Value, Volumes.Next())
//};
count = MaxAsksDepth /* - asks.Count*/;
for (var i = 0; i < count; i++)
{
var quote = CreateQuote(askPrice.Value, Sides.Sell);
if (quote.Price <= 0)
{
break;
}
asks.Add(quote);
askPrice = quote.Price;
}
depth.Bids = bids.ToArray();
depth.Asks = asks.ToArray();
_newTrades = false;
_currGenerations--;
return(depth);
}
public IActionResult Put(BoardMessage boardMessage)
{
var response = this.boardMessageService.UpdateBoardMessage(boardMessage);
return(this.Ok(response));
}
public async Task SendMessage(BoardMessage boardMessage)
{
await Clients.All.SendAsync("Send", boardMessage);
}
public void TestEncodeDecode()
{
short gameId = 1;
List <List <short> > grid = new List <List <short> >();
Identifier messageNum = new Identifier(1, 2);
Identifier convoId = new Identifier(12, 22);
for (int i = 0; i < 8; i++)
{
List <short> row = new List <short>();
for (int j = 0; j < 8; j++)
{
if (j % 2 == 0)
{
row.Add(1);
}
else
{
row.Add(0);
}
}
grid.Add(row);
}
var outGoing = new BoardMessage(gameId, grid, messageNum, convoId);
byte[] bytes1 = outGoing.encode();
var MT = Message.decodeMessageType(bytes1);
Assert.AreEqual((short)8, MT);
var board = (BoardMessage)Message.decoder(bytes1);
Assert.AreEqual(gameId, board.getGameId());
Assert.IsInstanceOfType(board.getGrid(), typeof(List <List <short> >));
// test columns
Assert.AreEqual(grid[0][0], board.getGrid()[0][0]);
Assert.AreEqual(grid[1][0], board.getGrid()[1][0]);
Assert.AreEqual(grid[2][0], board.getGrid()[2][0]);
Assert.AreEqual(grid[3][0], board.getGrid()[3][0]);
Assert.AreEqual(grid[4][0], board.getGrid()[4][0]);
Assert.AreEqual(grid[5][0], board.getGrid()[5][0]);
Assert.AreEqual(grid[6][0], board.getGrid()[6][0]);
Assert.AreEqual(grid[7][0], board.getGrid()[7][0]);
Assert.AreEqual(grid[0][1], board.getGrid()[0][1]);
Assert.AreEqual(grid[1][1], board.getGrid()[1][1]);
Assert.AreEqual(grid[2][1], board.getGrid()[2][1]);
Assert.AreEqual(grid[3][1], board.getGrid()[3][1]);
Assert.AreEqual(grid[4][1], board.getGrid()[4][1]);
Assert.AreEqual(grid[5][1], board.getGrid()[5][1]);
Assert.AreEqual(grid[6][1], board.getGrid()[6][1]);
Assert.AreEqual(grid[7][1], board.getGrid()[7][1]);
Assert.AreEqual(grid[0][2], board.getGrid()[0][2]);
Assert.AreEqual(grid[1][2], board.getGrid()[1][2]);
Assert.AreEqual(grid[2][2], board.getGrid()[2][2]);
Assert.AreEqual(grid[3][2], board.getGrid()[3][2]);
Assert.AreEqual(grid[4][2], board.getGrid()[4][2]);
Assert.AreEqual(grid[5][2], board.getGrid()[5][2]);
Assert.AreEqual(grid[6][2], board.getGrid()[6][2]);
Assert.AreEqual(grid[7][2], board.getGrid()[7][2]);
Assert.AreEqual(grid[0][7], board.getGrid()[0][7]);
Assert.AreEqual(grid[1][7], board.getGrid()[1][7]);
Assert.AreEqual(grid[2][7], board.getGrid()[2][7]);
Assert.AreEqual(grid[3][7], board.getGrid()[3][7]);
Assert.AreEqual(grid[4][7], board.getGrid()[4][7]);
Assert.AreEqual(grid[5][7], board.getGrid()[5][7]);
Assert.AreEqual(grid[6][7], board.getGrid()[6][7]);
Assert.AreEqual(grid[7][7], board.getGrid()[7][7]);
// test rows;
Assert.AreEqual(grid[3][3], board.getGrid()[3][3]);
Assert.AreEqual(grid[3][4], board.getGrid()[3][4]);
Assert.AreEqual(grid[3][5], board.getGrid()[3][5]);
Assert.AreEqual(grid[3][6], board.getGrid()[3][6]);
Assert.AreEqual(grid[4][3], board.getGrid()[4][3]);
Assert.AreEqual(grid[4][4], board.getGrid()[4][4]);
Assert.AreEqual(grid[4][5], board.getGrid()[4][5]);
Assert.AreEqual(grid[4][6], board.getGrid()[4][6]);
Assert.AreEqual(grid[5][3], board.getGrid()[5][3]);
Assert.AreEqual(grid[5][4], board.getGrid()[5][4]);
Assert.AreEqual(grid[5][5], board.getGrid()[5][5]);
Assert.AreEqual(grid[5][6], board.getGrid()[5][6]);
Assert.AreEqual(grid[6][3], board.getGrid()[6][3]);
Assert.AreEqual(grid[6][4], board.getGrid()[6][4]);
Assert.AreEqual(grid[6][5], board.getGrid()[6][5]);
Assert.AreEqual(grid[6][6], board.getGrid()[6][6]);
Assert.AreEqual(grid[7][3], board.getGrid()[7][3]);
Assert.AreEqual(grid[7][4], board.getGrid()[7][4]);
Assert.AreEqual(grid[7][5], board.getGrid()[7][5]);
Assert.AreEqual(grid[7][6], board.getGrid()[7][6]);
var testIdentifier1 = board.getMessageNumber();
Assert.IsInstanceOfType(testIdentifier1, typeof(Identifier));
Assert.AreEqual(messageNum.getPid(), testIdentifier1.getPid());
Assert.AreEqual(messageNum.getSeq(), testIdentifier1.getSeq());
var testIdentifier2 = board.getConversationId();
Assert.IsInstanceOfType(testIdentifier2, typeof(Identifier));
Assert.AreEqual(convoId.getPid(), testIdentifier2.getPid());
Assert.AreEqual(convoId.getSeq(), testIdentifier2.getSeq());
byte[] badBytes = new byte[2];
badBytes[0] = 1;
badBytes[1] = 1;
badBytes = bytes1.Concat(badBytes).ToArray();
try
{
Message.decoder(badBytes);
Assert.Fail();
}
catch (Exception e)
{
Logger.Debug($"Test passed: {e}");
}
}
public void Remove(BoardMessage message)
{
_context.Entry(message).State = EntityState.Deleted;
}
public void Update(BoardMessage message)
{
_context.Entry(message).State = EntityState.Modified;
}
public BoardMessage Add(BoardMessage message)
{
return(_context.Add(message).Entity);
}
