public static void WriteMessageAsync(this NetworkStream stream, MessageData msg)
{
if (stream == null)
throw new ArgumentException(nameof(stream));
byte[] bytes = msg.ToByteArray();
stream.WriteAsync(bytes, 0, bytes.Length);
}
public void ChangeUserNameRequest(string newName)
{
if (!Connected)
return;
var msg = new MessageData
{
Id = UserId,
Message = newName,
Command = Command.ChangeName,
MessageTime = DateTime.Now,
};
Stream.WriteMessageAsync(msg);
}
public void FileTransferRequest(FileInfo fi)
{
if (!Connected)
return;
filePathTransferFile = fi.FullName;
var msg = new MessageData
{
Id = UserId,
Message = fi.Name + Separator + fi.Length,
Command = Command.FileTransferRequest,
MessageTime = DateTime.Now,
};
Stream.WriteMessageAsync(msg);
}
public void TestMessageDataToByteConvertion2()
{
MessageData expectedMessage = new MessageData
{
Id = Guid.Empty,
Command = Command.Login,
Message = null,
MessageTime = DateTime.MinValue,
};
byte[] bytes = expectedMessage.ToByteArray();
var convertedMessage = (MessageData)bytes.ByteArrayToObject();
Assert.That(expectedMessage.Message, Is.EqualTo(convertedMessage.Message));
Assert.That(expectedMessage.Id, Is.EqualTo(convertedMessage.Id));
Assert.That(expectedMessage.Status, Is.EqualTo(convertedMessage.Status));
Assert.That(expectedMessage.Command, Is.EqualTo(convertedMessage.Command));
}
private void AcceptTcpClient()
{
WriteLine("Waiting for a connection...");
TcpClient client = _listener.AcceptTcpClient();
var user = new User(client);
_clients.TryAdd(user.Id, user);
WriteLine($"New client {user.Name} connected...");
var response = new MessageData
{
Id = user.Id,
Command = Command.Login,
MessageTime = DateTime.Now
};
WriteMessage(response);
TryRemoveDisconnectedClients();
BroadcastUserListUpdate();
Task t = MessageLoop(client);
}
private void SendUserList(Guid id, string list)
{
var response = new MessageData
{
Id = id,
Message = list,
Command = Command.List,
MessageTime = DateTime.Now,
};
WriteMessage(response);
}
private void ChangeName(MessageData msg)
{
var responce = new MessageData
{
Id = msg.Id,
Command = Command.ChangeName,
MessageTime = DateTime.Now,
};
var oldName = _clients[msg.Id].Name;
var newName = msg.Message;
bool allowChange = !string.IsNullOrEmpty(msg.Message) && _clients.All(client => client.Value.Name != msg.Message);
if (!allowChange)
{
string error = $"Couldn't change name to \"{newName}\" because user with that name already exists.";
responce.Error = !allowChange;
responce.Message = error;
WriteLine($"{oldName}: {error}");
WriteMessage(responce);
return;
}
_clients[msg.Id].Name = newName;
responce.Message = oldName + _separator + newName;
WriteLine($"User \"{oldName}\" changed name to \"{newName}\".");
BroadcastMessage(responce);
}
public void BroadcastMessageFromClient(MessageData msg)
{
foreach (var client in _clients.Where(client => client.Key != msg.Id))
WriteMessage(new MessageData
{
Id = msg.Id,
Command = msg.Command,
Message = msg.Message,
MessageTime = DateTime.Now,
},
client.Value.Client);
}
public void BroadcastMessage(MessageData msg)
{
foreach (var client in _clients)
WriteMessage(new MessageData
{
Id = msg.Id,
Command = msg.Command,
Message = msg.Message,
MessageTime = DateTime.Now,
},
client.Value.Client);
}
private void ProcessMessage(MessageData msg)
{
switch (msg.Command)
{
case Command.Login:
OnUserLogin(msg);
break;
case Command.ChangeName:
ProcessChangeName(msg);
break;
case Command.Message:
MessageReceived?.Invoke(msg);
break;
case Command.List:
OnUserListReceived(msg.Message);
break;
case Command.FileTransferRequest:
OnFileTransferRequestReceived(msg);
break;
case Command.FileTransferResponse:
OnFileTransferResponse(msg);
break;
default:
break;
}
}
public void WriteMessage(MessageData msg , TcpClient tcpClient = null)
{
var client = tcpClient ?? _clients[msg.Id].Client;
client.GetStream().WriteMessageAsync(msg);
}
private void OnFileTransferRequestReceived(MessageData msg)
{
string[] fi = msg.Message.Split(Separator);
var fileName = fi[0];
var fileSize = fi[1];
DownloadFileRequest?.Invoke(fileName, fileSize);
}
private void OnMessageDataReceived(MessageData message)
{
if (message.Error)
AddSystemMessage(message.Message);
else
UserMessages.Add(ConvertMessageDataToViewModel(message));
}
void ProcessMessage(MessageData msg)
{
TryRemoveDisconnectedClients();
switch (msg.Command)
{
case Command.ChangeName:
ChangeName(msg);
break;
case Command.Message:
WriteLine($"{_clients[msg.Id].Name}: {msg.Message}");
BroadcastMessageFromClient(msg);
break;
case Command.List:
SendUserList(msg.Id, ReturnUserList);
break;
case Command.FileTransferRequest:
ProcessFileRequest(msg);
break;
case Command.FileTransferResponse:
ProcessFileTransferResponce(msg);
break;
case Command.Logout:
default:
RemoveClient(msg);
break;
}
}
public async Task FileTransferResponce(bool acceptFile, string fileName, IProgress<double> iProgress = null)
{
var ip = _client.Client.LocalEndPoint as IPEndPoint;
if (ip == null)
return;
int port = 50001;
if (_fileTcpListener == null)
{
_fileTcpListener = new TcpListener(IPAddress.Any, 50001);
_fileTcpListener.Start();
}
string filePath = string.Empty;
var response = new MessageData
{
Id = UserId,
Command = Command.FileTransferResponse,
Error = !acceptFile,
Message = acceptFile ? ip.Address.ToString() + Separator + port : string.Empty,
};
Stream.WriteMessageAsync(response);
if (!acceptFile)
return;
using(var client = _fileTcpListener.AcceptTcpClient())
using (var fStream = new FileStream(fileName, FileMode.Create))
{
await client.GetStream().ReadFileFromNetStreamAsync(fStream, iProgress);
}
}
private async Task OnFileTransferResponse(MessageData msg)
{
if(msg.Error || string.IsNullOrEmpty(msg.Message))
return;
string[] info = msg.Message.Split(Separator);
IProgress<double> iProgress = null; // TODO
using (var file = new FileStream(filePathTransferFile, FileMode.Open))
{
var sendstream = new TcpClient(info[0], int.Parse(info[1]));
await sendstream.GetStream().WriteFileToNetStreamAsync(file, iProgress);
sendstream.Close();
}
}
private void OnUserLogin(MessageData msg)
{
UserId = msg.Id;
OnLogin?.Invoke();
}
private void ProcessChangeName(MessageData msg)
{
if (msg.Error)
{
MessageReceived?.Invoke(msg);
return;
}
var entry = msg.Message.Split(Separator);
var oldName = entry[0];
var newName = entry[1];
var id = UserNameDictionary.FirstOrDefault(user => user.Value == oldName).Key;
if (id != null)
UserNameDictionary[id] = newName;
UserNameChanged?.Invoke(oldName, newName);
}
private void ProcessFileRequest(MessageData msg)
{
var responce = new MessageData
{
Id = msg.Id,
Command = Command.FileTransferRequest,
Message = msg.Message,
};
BroadcastMessageFromClient(msg);
}
private void ProcessFileTransferResponce(MessageData msg)
{
BroadcastMessageFromClient(msg);
}
private void SendMessage()
{
var msg = new MessageData
{
Id = _clientModel.UserId,
Message = MessageTextToSend.TrimEnd(),
Command = Command.Message,
MessageTime = DateTime.Now,
};
var msgItem = ConvertMessageDataToViewModel(msg);
UserMessages.Add(msgItem);
MessageTextToSend = string.Empty;
_clientModel.WriteMessageAsync(msg);
}
private void RemoveClient(MessageData msg)
{
User user;
_clients.TryRemove(msg.Id, out user);
user.Client.Close();
}
private UserMessageViewModel ConvertMessageDataToViewModel(MessageData msgData)
{
string userName;
if (!UserNameDict.TryGetValue(msgData.Id.ToString(), out userName))
userName = "******";
return new UserMessageViewModel()
{
Message = msgData.Message,
Status = msgData.Status.ToString(),
MessageTime = msgData.MessageTime.ToShortTimeString(),
UserName = userName,
};
}
public void WriteMessageAsync(MessageData message)
{
Stream.WriteMessageAsync(message);
}
