public async Task <IProduct> CreateProduct(string name, double price, ProductType productType)
{
string msg = WebSerializer.SerializeWebMessage(WebMessageType.AddProduct, new ProductDTO {
Name = name,
Price = price,
ProductType = productType
});
await WebSocketConnection.SendAsync(msg);
string responseMsg;
try
{
responseMsg = ReadMessage();
}
catch (Exception e)
{
Debug.WriteLine($"Failed to add product! {e}");
return(null);
}
WebMessageDTO <object> response = WebSerializer.DeserializeWebMessage(responseMsg);
if (!(response.Data is ProductDTO productData))
{
throw new ApplicationException("Provided product data object is invalid!");
}
return(productData.ToIProduct());
}
public async Task <IOrder> CreateOrder(string clientUsername, DateTime orderDate, Dictionary <uint, uint> productIdQuantityMap, DateTime?deliveryDate)
{
string msg = WebSerializer.SerializeWebMessage(WebMessageType.AddOrder, new OrderDTO {
ClientUsername = clientUsername,
OrderDate = orderDate,
ProductIdQuantityMap = productIdQuantityMap,
DeliveryDate = deliveryDate
});
await WebSocketConnection.SendAsync(msg);
string responseMsg;
try
{
responseMsg = ReadMessage();
}
catch (Exception e)
{
Debug.WriteLine($"Failed to add order! {e}");
return(null);
}
WebMessageDTO <object> response = WebSerializer.DeserializeWebMessage(responseMsg);
if (!(response.Data is OrderDTO orderData))
{
throw new ApplicationException("Provided order data object is invalid!");
}
return(orderData.ToIOrder());
}
public async Task <IClient> CreateClient(string username, string firstName, string lastName, string street, uint streetNumber,
string phoneNumber)
{
string msg = WebSerializer.SerializeWebMessage(WebMessageType.AddClient, new ClientDTO {
Username = username,
FirstName = firstName,
LastName = lastName,
Street = street,
StreetNumber = streetNumber,
PhoneNumber = phoneNumber
});
await WebSocketConnection.SendAsync(msg);
string responseMsg;
try
{
responseMsg = ReadMessage();
}
catch (Exception e)
{
Debug.WriteLine($"Failed to add client! {e}");
return(null);
}
WebMessageDTO <object> response = WebSerializer.DeserializeWebMessage(responseMsg);
if (!(response.Data is ClientDTO clientData))
{
throw new ApplicationException("Provided client data object is invalid!");
}
return(clientData.ToIClient());
}
public async Task <bool> RemoveProduct(IProduct product)
{
string msg = WebSerializer.SerializeWebMessage(WebMessageType.RemoveProduct, new ProductDTO(product));
await WebSocketConnection.SendAsync(msg);
string response = ReadMessage();
if (WebSerializer.TryParseRequest(response, out WebSimpleMessageType req) && req == WebSimpleMessageType.Success)
{
return(true);
}
Debug.WriteLine($"Failed to remove product! {response}");
return(false);
}
public async Task <bool> Update(IOrder order)
{
string msg = WebSerializer.SerializeWebMessage(WebMessageType.UpdateOrder, new OrderDTO(order));
await WebSocketConnection.SendAsync(msg);
string response = ReadMessage();
if (WebSerializer.TryParseRequest(response, out WebSimpleMessageType req) && req == WebSimpleMessageType.Success)
{
return(true);
}
Debug.WriteLine($"Failed to update order! {response}");
return(false);
}
public async Task <IProduct> GetProduct(uint id)
{
string msg = WebSerializer.SerializeWebMessage(WebMessageType.GetProduct, id);
await WebSocketConnection.SendAsync(msg);
WebMessageDTO <object> response = WebSerializer.DeserializeWebMessage(ReadMessage());
if (!(response.Data is ProductDTO productData))
{
throw new ApplicationException("Provided product data object is invalid!");
}
return(productData.ToIProduct());
}
public async Task <IOrder> GetOrder(uint id)
{
string msg = WebSerializer.SerializeWebMessage(WebMessageType.GetOrder, id);
await WebSocketConnection.SendAsync(msg);
WebMessageDTO <object> response = WebSerializer.DeserializeWebMessage(ReadMessage());
if (!(response.Data is OrderDTO orderData))
{
throw new ApplicationException("Provided order data object is invalid!");
}
return(orderData.ToIOrder());
}
public async Task <IClient> GetClient(string username)
{
string msg = WebSerializer.SerializeWebMessage(WebMessageType.GetClient, username);
await WebSocketConnection.SendAsync(msg);
WebMessageDTO <object> response = WebSerializer.DeserializeWebMessage(ReadMessage());
if (!(response.Data is ClientDTO clientData))
{
throw new ApplicationException("Provided client data object is invalid!");
}
return(clientData.ToIClient());
}
private async Task ProcessClientMessage(WebSocketConnection connection, string message)
{
Console.WriteLine($"{connection}> {message}");
if (WebSerializer.TryParseRequest(message, out WebSimpleMessageType msgType))
{
switch (msgType)
{
case WebSimpleMessageType.GetAllClients:
{
string response =
WebSerializer.SerializeWebMessage(WebMessageType.ProvideAllClients,
new HashSet <ClientDTO>(
(await DataRepository.GetAllClients())
.Select(c => new ClientDTO(c))));
await connection.SendAsync(response);
break;
}
case WebSimpleMessageType.GetAllProducts:
{
string response =
WebSerializer.SerializeWebMessage(WebMessageType.ProvideAllProducts,
new HashSet <ProductDTO>(
(await DataRepository.GetAllProducts())
.Select(p => new ProductDTO(p))));
await connection.SendAsync(response);
break;
}
case WebSimpleMessageType.GetAllOrders:
{
string response =
WebSerializer.SerializeWebMessage(WebMessageType.ProvideAllOrders,
new HashSet <OrderDTO>(
(await DataRepository.GetAllOrders())
.Select(o => new OrderDTO(o))));
await connection.SendAsync(response);
break;
}
}
}
else
{
try
{
WebMessageDTO <object> msgDto = WebSerializer.DeserializeWebMessage(message);
switch (msgDto.MessageType)
{
case WebMessageType.AddClient:
{
if (msgDto.Data is ClientDTO clt)
{
IClient client = await DataRepository.CreateClient(
clt.Username, clt.FirstName, clt.LastName,
clt.Street, clt.StreetNumber, clt.PhoneNumber);
if (client == null)
{
await connection.SendAsync(WebSimpleMessageType.Failure.ToString());
}
else
{
ClientDTO newDto = new ClientDTO(client);
await connection.SendAsync(
WebSerializer.SerializeWebMessage(WebMessageType.ProvideClient, newDto));
await ServerWebSocketConnection.SendAsync(
WebSerializer.SerializeWebMessage(WebMessageType.AddClient, newDto));
}
}
else
{
await connection.SendAsync(WebSimpleMessageType.Failure.ToString());
}
break;
}
case WebMessageType.UpdateClient:
{
bool result = false;
if (msgDto.Data is ClientDTO clt)
{
try
{
result = await DataRepository.Update(clt.ToIClient());
}
catch (Exception e)
{
await connection.SendAsync(
WebSerializer.SerializeWebMessage(WebMessageType.Error, e.ToString()));
}
}
await connection.SendAsync(result
?WebSimpleMessageType.Success.ToString()
: WebSimpleMessageType.Failure.ToString());
if (result)
{
await ServerWebSocketConnection.SendAsync(
WebSerializer.SerializeWebMessage(WebMessageType.UpdateClient, msgDto.Data));
}
break;
}
case WebMessageType.RemoveClient:
{
bool result = false;
if (msgDto.Data is ClientDTO clt)
{
try
{
result = await DataRepository.RemoveClient(clt.ToIClient());
}
catch (Exception e)
{
await connection.SendAsync(
WebSerializer.SerializeWebMessage(WebMessageType.Error, e.ToString()));
}
}
await connection.SendAsync(result
?WebSimpleMessageType.Success.ToString()
: WebSimpleMessageType.Failure.ToString());
if (result)
{
await ServerWebSocketConnection.SendAsync(
WebSerializer.SerializeWebMessage(WebMessageType.RemoveClient, msgDto.Data));
}
break;
}
case WebMessageType.AddProduct:
{
if (msgDto.Data is ProductDTO prd)
{
IProduct product = await DataRepository.CreateProduct(
prd.Name, prd.Price, prd.ProductType);
if (product == null)
{
await connection.SendAsync(WebSimpleMessageType.Failure.ToString());
}
else
{
ProductDTO newDto = new ProductDTO(product);
await connection.SendAsync(
WebSerializer.SerializeWebMessage(WebMessageType.ProvideProduct, newDto));
await ServerWebSocketConnection.SendAsync(
WebSerializer.SerializeWebMessage(WebMessageType.AddProduct, newDto));
}
}
else
{
await connection.SendAsync(WebSimpleMessageType.Failure.ToString());
}
break;
}
case WebMessageType.UpdateProduct:
{
bool result = false;
if (msgDto.Data is ProductDTO prd)
{
try
{
result = await DataRepository.Update(prd.ToIProduct());
}
catch (Exception e)
{
await connection.SendAsync(
WebSerializer.SerializeWebMessage(WebMessageType.Error, e.ToString()));
}
}
await connection.SendAsync(result
?WebSimpleMessageType.Success.ToString()
: WebSimpleMessageType.Failure.ToString());
if (result)
{
await ServerWebSocketConnection.SendAsync(
WebSerializer.SerializeWebMessage(WebMessageType.UpdateProduct, msgDto.Data));
}
break;
}
case WebMessageType.RemoveProduct:
{
bool result = false;
if (msgDto.Data is ProductDTO prd)
{
try
{
result = await DataRepository.RemoveProduct(prd.ToIProduct());
}
catch (Exception e)
{
await connection.SendAsync(
WebSerializer.SerializeWebMessage(WebMessageType.Error, e.ToString()));
}
}
await connection.SendAsync(result
?WebSimpleMessageType.Success.ToString()
: WebSimpleMessageType.Failure.ToString());
if (result)
{
await ServerWebSocketConnection.SendAsync(
WebSerializer.SerializeWebMessage(WebMessageType.RemoveProduct, msgDto.Data));
}
break;
}
case WebMessageType.AddOrder:
{
if (msgDto.Data is OrderDTO ord)
{
IOrder order = await DataRepository.CreateOrder(
ord.ClientUsername, ord.OrderDate,
ord.ProductIdQuantityMap, ord.DeliveryDate);
if (order == null)
{
await connection.SendAsync(WebSimpleMessageType.Failure.ToString());
}
else
{
OrderDTO newDto = new OrderDTO(order);
await connection.SendAsync(
WebSerializer.SerializeWebMessage(WebMessageType.ProvideOrder, newDto));
await ServerWebSocketConnection.SendAsync(
WebSerializer.SerializeWebMessage(WebMessageType.AddOrder, newDto));
}
}
else
{
await connection.SendAsync(WebSimpleMessageType.Failure.ToString());
}
break;
}
case WebMessageType.UpdateOrder:
{
bool result = false;
if (msgDto.Data is OrderDTO ord)
{
try
{
result = await DataRepository.Update(ord.ToIOrder());
}
catch (Exception e)
{
await connection.SendAsync(
WebSerializer.SerializeWebMessage(WebMessageType.Error, e.ToString()));
}
}
await connection.SendAsync(result
?WebSimpleMessageType.Success.ToString()
: WebSimpleMessageType.Failure.ToString());
if (result)
{
await ServerWebSocketConnection.SendAsync(
WebSerializer.SerializeWebMessage(WebMessageType.UpdateOrder, msgDto.Data));
}
break;
}
case WebMessageType.RemoveOrder:
{
bool result = false;
if (msgDto.Data is OrderDTO ord)
{
try
{
result = await DataRepository.RemoveOrder(ord.ToIOrder());
}
catch (Exception e)
{
await connection.SendAsync(
WebSerializer.SerializeWebMessage(WebMessageType.Error, e.ToString()));
}
}
await connection.SendAsync(result
?WebSimpleMessageType.Success.ToString()
: WebSimpleMessageType.Failure.ToString());
if (result)
{
await ServerWebSocketConnection.SendAsync(
WebSerializer.SerializeWebMessage(WebMessageType.RemoveOrder, msgDto.Data));
}
break;
}
case WebMessageType.GetClient:
{
if (!(msgDto.Data is string username))
{
await connection.SendAsync(WebSimpleMessageType.Failure.ToString());
break;
}
IClient client = await DataRepository.GetClient(username);
if (client == null)
{
await connection.SendAsync(WebSimpleMessageType.Failure.ToString());
break;
}
string response = WebSerializer.SerializeWebMessage(WebMessageType.ProvideClient,
new ClientDTO(client));
await connection.SendAsync(response);
break;
}
case WebMessageType.GetProduct:
{
if (!(msgDto.Data is uint id))
{
await connection.SendAsync(WebSimpleMessageType.Failure.ToString());
break;
}
IProduct product = await DataRepository.GetProduct(id);
if (product == null)
{
await connection.SendAsync(WebSimpleMessageType.Failure.ToString());
break;
}
string response = WebSerializer.SerializeWebMessage(WebMessageType.ProvideProduct,
new ProductDTO(product));
await connection.SendAsync(response);
break;
}
case WebMessageType.GetOrder:
{
if (!(msgDto.Data is uint id))
{
await connection.SendAsync(WebSimpleMessageType.Failure.ToString());
break;
}
IOrder order = await DataRepository.GetOrder(id);
if (order == null)
{
await connection.SendAsync(WebSimpleMessageType.Failure.ToString());
break;
}
string response = WebSerializer.SerializeWebMessage(WebMessageType.ProvideOrder,
new OrderDTO(order));
await connection.SendAsync(response);
break;
}
}
}
catch (Exception e)
{
Console.WriteLine($"Failed to parse message '{message}' from a client! {e}");
}
}
}
public void OnNext(OrderSent value)
{
string msg = WebSerializer.SerializeWebMessage(WebMessageType.OrderSent, new OrderDTO(value.Order));
Task.Run(() => ServerWebSocketConnection.SendAsync(msg));
}