private void SendMessage()
{
Message message = new Message(MainWindowViewModel.ClientUser, MessageText);
MessageRequest messageRequest = new MessageRequest(message);
DataTransferHelper.SendRequestToServer(MainWindowViewModel.Client, messageRequest);
}
private void SendResponseToAllClients(Response response)
{
foreach (Socket client in _clients.Values)
{
DataTransferHelper.SendResponseToClient(client, response);
}
}
public IEnumerable <Cart> Carts()
{
return(_repository.GetCarts().ToList().Select(c => new Cart
{
CartId = c.CartId,
ProductIds = DataTransferHelper.IdsToString(c.ProductIds)
}));
}
private async void OnImageDragStarting(UIElement sender, DragStartingEventArgs args)
{
var response = (ImageResponse)((Image)sender).DataContext;
var content = await response.GetResponseContentAsync();
var file = await DataTransferHelper.CreateTemporaryFileAsync(content.stream, content.contentType);
args.Data.SetStorageItems(new[] { file });
}
public IEnumerable <Product> ProductsByIds(string idsString)
{
var ids = DataTransferHelper.IdsFromString(idsString);
return(_repository.GetProducts()?
.ToList()
.Where(p => ids.Contains(p.ProductId))
.Select(productDto => FromDto(productDto)));
}
public async Task <Cart> Cart(string id)
{
var queryResult = await _repository.GetCartAsync(id, default);
return(new Cart
{
CartId = queryResult.CartId,
ProductIds = DataTransferHelper.IdsToString(queryResult.ProductIds)
});
}
private void SignUp()
{
MainWindowViewModel.SettingsManager.Settings.ServerIPAddress = IPAddress;
MainWindowViewModel.SettingsManager.ApplySettings();
MainWindowViewModel.Connect();
if (!MainWindowViewModel.IsConnected)
{
return;
}
RegistrationRequest registrationRequest = new RegistrationRequest(UserName, Password);
DataTransferHelper.SendRequestToServer(MainWindowViewModel.Client, registrationRequest);
}
public static void Disconnect()
{
if (!IsConnected)
{
return;
}
Request disconnectRequest = new SignOutRequest();
DataTransferHelper.SendRequestToServer(Client, disconnectRequest);
Client?.Close();
IsConnected = false;
}
public async Task <Customer> Customer(string id)
{
var queryResult = await _repository.GetCustomerAsync(id, default);
return(queryResult != null ? new Customer
{
Id = queryResult.CustomerId,
CartId = queryResult.CartId,
Name = queryResult.Name,
Email = queryResult.Email,
Addresses = DataTransferHelper.IdsToString(queryResult.Addresses),
DiscountCard = queryResult.DiscountCard,
WishlistId = queryResult.WishlistId,
Orders = DataTransferHelper.IdsToString(queryResult.Orders)
} : default);
public async Task <Payment> CheckoutCart(
[Service] PaymentsResolver resolver,
string cartId,
string addressId,
string prescriptionId,
string productIds,
string customerId,
string paymentInfoId,
string amount)
{
var orderItems = !string.IsNullOrWhiteSpace(productIds)
? DataTransferHelper.IdsFromString(productIds)
: default;
return(await resolver.CheckoutOrder(orderItems?.Select(o => new OrderItem
{
Price = "",
Quantity = "1",
ProductId = o
}), prescriptionId, cartId, customerId, addressId, paymentInfoId, amount));
}
public async void CopyToClipboard()
{
var content = await GetResponseContentAsync();
await DataTransferHelper.CopyToClipboardAsync(content.stream, content.contentType);
}
private static void ServerListenerLoop()
{
try
{
while (true)
{
Response server_response = DataTransferHelper.GetResponseFromServer(Client);
switch (server_response.ResponseType)
{
case "user_signin":
{
UserSignInResponse userSignInResponse = server_response as UserSignInResponse;
InvokeHelper.ApplicationInvoke(() => _chatViewModel.Users.Add(userSignInResponse.User));
break;
}
case "user_signout":
{
UserSignOutResponse userSignOutResponse = server_response as UserSignOutResponse;
for (int i = 0; i < _chatViewModel.Users.Count; i++)
{
if (_chatViewModel.Users[i].ID == userSignOutResponse.User.ID)
{
InvokeHelper.ApplicationInvoke(() => _chatViewModel.Users.RemoveAt(i));
}
}
break;
}
case "auth":
{
if (server_response.Ok)
{
ClientUser = (server_response as AuthResponse).User;
InvokeHelper.ApplicationInvoke
(
() =>
{
ChatView chatView = new ChatView();
_chatViewModel = chatView.DataContext as ChatViewModel;
SetView(chatView);
}
);
}
else
{
if (server_response.Error == "user_name_not_exists")
{
throw new InvalidUserNameException();
}
else if (server_response.Error == "invalid_password")
{
throw new InvalidPasswordException();
}
else if (server_response.Error == "user_is_connected")
{
throw new Exception("User is connected");
}
}
break;
}
case "registration":
{
if (server_response.Ok)
{
InvokeHelper.ApplicationInvoke(() => ShowSnackBarMessage("User successfully registered"));
Disconnect();
}
else
{
if (server_response.Error == "user_name_exists")
{
throw new InvalidUserNameException("This user name already exists");
}
}
break;
}
case "message":
{
InvokeHelper.ApplicationInvoke(() => _chatViewModel.Messages.Add((server_response as MessageResponse).Message));
break;
}
case "ban":
{
throw new UserBannedException();
}
default:
break;
}
}
}
catch (UserBannedException e)
{
InvokeHelper.ApplicationInvoke(() => ShowSnackBarMessage(e.Message));
}
catch (InvalidUserNameException e)
{
InvokeHelper.ApplicationInvoke(() => ShowSnackBarMessage(e.Message));
}
catch (InvalidPasswordException e)
{
InvokeHelper.ApplicationInvoke(() => ShowSnackBarMessage(e.Message));
}
catch (SocketException)
{
InvokeHelper.ApplicationInvoke(() => ShowSnackBarMessage("Connection with server was destroyed."));
}
catch (Exception)
{}
finally
{
IsConnected = false;
Client?.Close();
Client = null;
_chatViewModel = null;
ClientUser = null;
InvokeHelper.ApplicationInvoke(() => SetView(new StartView()));
}
}
public async void OpenFileWith()
{
var content = await GetResponseContentAsync();
await DataTransferHelper.OpenWithAsync(content.stream, content.contentType);
}
private void SignOut()
{
SignOutRequest signOutRequest = new SignOutRequest();
DataTransferHelper.SendRequestToServer(MainWindowViewModel.Client, signOutRequest);
}
public void ClearDatabase()
{
DataTransferHelper.ClearDatabase();
}
public bool TransferData()
{
return(DataTransferHelper.TransferData());
}
public IQueryable <OrderDto> GetOrders(string ids)
{
var idsList = DataTransferHelper.IdsFromString(ids);
return(_ordersCollection.AsQueryable().Where(o => idsList.Contains(o.OrderId)));
}
private void SendResponseToUserByUserID(String user_id, Response response)
{
DataTransferHelper.SendResponseToClient(GetClientByUserID(user_id), response);
}
public async void ShareFile()
{
var content = await GetResponseContentAsync();
DataTransferHelper.Share(content.stream, content.contentType);
}
private void ClientLoop(object o)
{
Socket temp_client = ((IDSocket)o).Handle_Socket;
User client_user = new User(((IDSocket)o).Handle_ID, null, null);
try
{
while (true)
{
Request client_request = DataTransferHelper.GetRequestFromClient(temp_client);
switch (client_request.RequestType)
{
case "registration":
{
RegistrationRequest registrationRequest = client_request as RegistrationRequest;
if (!IsUserNameExists(registrationRequest.UserName))
{
AddUser(new User(GetNewUserID(), registrationRequest.UserName, registrationRequest.Password));
RegistrationResponse registrationResponse = new RegistrationResponse();
DataTransferHelper.SendResponseToClient(temp_client, registrationResponse);
}
else
{
RegistrationResponse registrationResponse = new RegistrationResponse()
{
Ok = false,
Error = "user_name_exists"
};
DataTransferHelper.SendResponseToClient(temp_client, registrationResponse);
}
break;
}
case "auth":
{
AuthRequest authRequest = client_request as AuthRequest;
if (IsUserNameExists(authRequest.UserName))
{
User temp_user = GetUserByName(authRequest.UserName);
if (authRequest.Password == temp_user.Password)
{
if (IsBannedUser(temp_user.ID))
{
BanResponse banResponse = new BanResponse();
DataTransferHelper.SendResponseToClient(temp_client, banResponse);
}
else
{
if (IsConnectedUser(temp_user.ID))
{
AuthResponse authResponse = new AuthResponse(temp_user);
authResponse.Error = "user_is_connected";
authResponse.Ok = false;
DataTransferHelper.SendResponseToClient(temp_client, authResponse);
}
else
{
AuthResponse authResponse = new AuthResponse(temp_user);
DataTransferHelper.SendResponseToClient(temp_client, authResponse);
temp_user.IsConnected = true;
RaisePropertyChangedEvent("UserDataBase");
RaisePropertyChangedEvent("ConnectedUsers");
_clients.Add(temp_user.ID, temp_client);
_clients.Remove(client_user.ID);
client_user.ID = temp_user.ID;
client_user.Name = temp_user.Name;
client_user.Password = temp_user.Password;
for (int i = 0; i < ConnectedUsers.Count(); i++)
{
if (ConnectedUsers.ElementAt(i).ID == client_user.ID)
{
continue;
}
UserSignInResponse userSignInResponse = new UserSignInResponse(ConnectedUsers.ElementAt(i));
DataTransferHelper.SendResponseToClient(temp_client, userSignInResponse);
}
for (int i = 0; i < _clients.Count(); i++)
{
if (_clients.ElementAt(i).Key == client_user.ID)
{
continue;
}
UserSignInResponse userSignInResponse = new UserSignInResponse(client_user);
DataTransferHelper.SendResponseToClient(_clients.ElementAt(i).Value, userSignInResponse);
}
}
}
}
else
{
AuthResponse authResponse = new AuthResponse(null)
{
Ok = false,
Error = "invalid_password"
};
DataTransferHelper.SendResponseToClient(temp_client, authResponse);
}
}
else
{
AuthResponse authResponse = new AuthResponse(null)
{
Ok = false,
Error = "user_name_not_exists"
};
DataTransferHelper.SendResponseToClient(temp_client, authResponse);
}
break;
}
case "signout":
{
GetUserByID(client_user.ID).IsConnected = false;
throw new Exception();
}
case "message":
{
MessageResponse messageResponse = new MessageResponse((client_request as MessageRequest).Message);
SendResponseToAllClients(messageResponse);
break;
}
default:
break;
}
}
}
catch (Exception e)
{
}
finally
{
temp_client?.Close();
_clients.Remove(client_user.ID);
if (client_user != null)
{
User temp_user = GetUserByID(client_user.ID);
if (temp_user != null)
{
temp_user.IsConnected = false;
}
UserSignOutResponse userSignOutResponse = new UserSignOutResponse(client_user);
SendResponseToAllClients(userSignOutResponse);
}
RaisePropertyChangedEvent("UserDataBase");
RaisePropertyChangedEvent("ConnectedUsers");
}
}
