public List <UserDTO> GetAllUsers()
{
using (var context = new TalkBackDBContext())
{
var users = context.Users.ToList(); //TODO: can select be before to list without cast
return(users.Select(u => ConvertToDTO(u)).ToList());
}
}
public UserDTO GetUserBy(string UserName, string Password)
{
using (var context = new TalkBackDBContext())
{
User user = context.Users.Where(u => u.UserName == UserName && u.Password == Password).FirstOrDefault();
return(ConvertToDTO(user));
}
}
public void AddUser(ISignedUp user)
{
using (var context = new TalkBackDBContext())
{
User userDB = ConvertToModel(user);
context.Users.Add(userDB);
context.SaveChanges();
}
}
private void HandleChatResponseMsg(ChatRequestResponse resp, TalkBackDBContext dbContext)
{
// first check that the addressee is in the dictionary:
WebSocket peer;
if (!WebSocketMiddleware._sockets.TryGetValue(resp.To, out peer))
{
// not found -- ignore
return;
}
string strMsg = resp.ToXml().ToString();
WebSocketMiddleware.SendStringAsync(peer, strMsg);
return;
}
private void HandleLoginMsg(Login login, TalkBackDBContext dbContext)
{
UsersRepository repo = new UsersRepository(dbContext);
// check if User Exists:
if (repo.IsUserExist(login.Name))
{
// check password:
if (!repo.IsPasswordCorrect(login.Name, login.Password))
{
LoginResponse response = new LoginResponse {
Success = false, ErrorMessage = "Wrong password, please try again"
};
WebSocketMiddleware.SendStringAsync(_webSocket, response.ToXml().ToString());
return;
}
}
else
{
// new user: add it to repo
repo.AddNewUser(new UserModel {
Name = login.Name, Password = login.Password
});
}
// login successfully:
// 1. record UserName for this handler
UserName = login.Name;
// 2. add to the websocket dictionary
WebSocketMiddleware._sockets.TryAdd(UserName, _webSocket);
// 3. inform all online users about the new/updated contact,
// create a Set<string> of online users:
ISet <string> online = new HashSet <string>();
Contact me = new Contact {
Name = UserName, IsOnline = true
};
string contactUpdate = me.ToXml().ToString();
online = Broadcast(contactUpdate);
// 4. send the client the list of contacts:
IList <AbstractXmlSerializable> contacts = repo.GetContactsList(UserName, online);
string contactsList = ModelXmlMapper.GetAsXmlString(contacts);
WebSocketMiddleware.SendStringAsync(_webSocket, contactsList);
}
private void HandleChatMessageMsg(MessageModel msg, TalkBackDBContext dbContext)
{
// first check that the addressee is in the dictionary:
WebSocket peer;
if (!WebSocketMiddleware._sockets.TryGetValue(msg.To, out peer))
{
// not found -> send a ChatRequestResponse with failure:
ChatRequestResponse resp = new ChatRequestResponse {
Success = false, ErrorMessage = "Chat peer is not online"
};
WebSocketMiddleware.SendStringAsync(_webSocket, resp.ToXml().ToString());
return;
}
// save message in the log:
Message dbMessage = new Message
{
Content = msg.Content,
ReceiverName = msg.To,
SenderName = msg.From,
Time = DateTime.Now
};
try
{
dbContext.Message.Add(dbMessage);
dbContext.SaveChanges();
}
catch (Exception ex)
{
//do nothing
}
// send the message to both sender and receiver:
string strMsg = msg.ToXml().ToString();
WebSocketMiddleware.SendStringAsync(_webSocket, strMsg);
WebSocketMiddleware.SendStringAsync(peer, strMsg);
return;
}
private void HandleChatRequestMsg(ChatRequest req, TalkBackDBContext dbContext)
{
// first check that the addressee is in the dictionary:
WebSocket peer;
if (!WebSocketMiddleware._sockets.TryGetValue(req.To, out peer))
{
// not found -> send a ChatRequestResponse with failure:
ChatRequestResponse resp = new ChatRequestResponse {
Success = false, ErrorMessage = "Chat peer is not online"
};
WebSocketMiddleware.SendStringAsync(_webSocket, resp.ToXml().ToString());
return;
}
string strMsg = req.ToXml().ToString();
WebSocketMiddleware.SendStringAsync(peer, strMsg);
return;
}
public async Task Invoke(HttpContext context)
{
if (!context.WebSockets.IsWebSocketRequest)
{
await _next.Invoke(context);
return;
}
CancellationToken ct = context.RequestAborted;
IServiceProvider sp = context.RequestServices;
TalkBackDBContext dbContext = sp.GetService <TalkBackDBContext>();
WebSocket currentSocket = await context.WebSockets.AcceptWebSocketAsync();
//var socketId = Guid.NewGuid().ToString();
//_sockets.TryAdd(socketId, currentSocket);
MessageHandler handler = new MessageHandler(currentSocket);
while (true)
{
if (ct.IsCancellationRequested)
{
break;
}
var response = await ReceiveStringAsync(currentSocket, ct);
if (string.IsNullOrEmpty(response))
{
if (currentSocket.State != WebSocketState.Open)
{
break;
}
continue;
}
//handling the message from the client
handler.HandleMessage(response, dbContext);
//foreach (var socket in _sockets)
//{
// if (socket.Value.State != WebSocketState.Open)
// {
// continue;
// }
// await SendStringAsync(socket.Value, response, ct);
//}
}
handler.HandleUserDisconnect();
await currentSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", ct);
currentSocket.Dispose();
dbContext.Dispose();
}
public UsersRepository(TalkBackDBContext context)
{
_context = context;
}
public void HandleMessage(string incommingMessage, TalkBackDBContext dbContext)
{
MappedType t = MappedType.UNDEFINED;
XDocument serialized = XDocument.Parse(incommingMessage);
XElement typeElement = serialized.Root.Element("Type");
if (typeElement == null)
{
// ignore
return;
}
string type = typeElement.Value;
if (ModelXmlMapper.map.TryGetValue(type, out t))
{
switch (t)
{
case MappedType.MESSAGE:
MessageModel msg = new MessageModel();
if (msg.FromXml(serialized.Root))
{
HandleChatMessageMsg(msg, dbContext);
}
break;
case MappedType.USER:
UserModel user = new UserModel();
user.FromXml(serialized.Root);
break;
case MappedType.CONTACT:
Contact contact = new Contact();
contact.FromXml(serialized.Root);
break;
case MappedType.CHAT_REQUEST:
ChatRequest req = new ChatRequest();
if (req.FromXml(serialized.Root))
{
HandleChatRequestMsg(req, dbContext);
}
break;
case MappedType.CHAT_REQUEST_RESPONSE:
ChatRequestResponse resp = new ChatRequestResponse();
if (resp.FromXml(serialized.Root))
{
HandleChatResponseMsg(resp, dbContext);
}
break;
case MappedType.LOGIN:
Login login = new Login();
if (login.FromXml(serialized.Root))
{
HandleLoginMsg(login, dbContext);
}
break;
case MappedType.LOGIN_RESPONSE:
LoginResponse loginResp = new LoginResponse();
loginResp.FromXml(serialized.Root);
break;
case MappedType.UNDEFINED:
throw new Exception("Don't know how to parse this type");
}
}
}
