public async Task <Models.Result <bool?> > UpdateContactStatus(ContactUpdateStatus contactUpdateStatus)
{
var result = new Models.Result <bool?>();
try
{
//Get contactEntity using GetSingleAsync to avoid tracking
var contactEntity = await _contactRepository.GetSingleAsync(x => x.Id == contactUpdateStatus.Id);
if (contactEntity == null)
{
result.Data = false; //result.Data = false => controller will return 404
return(result);
}
//Check/Update contactEntity properties as per contactUpdateStatus provided
if (!contactUpdateStatus.MapUpdatesToEntity(ref contactEntity))
{
result.ErrorMessage = ERROR_UPDATE_CONTACT_NO_CHANGES_DETECTED;
return(result);
}
result.Data = await _contactRepository.UpdateAsync(contactEntity);
}
catch (Exception e)
{
result.ErrorMessage = LogError(e, "UpdateContactStatus", new object[] { contactUpdateStatus });
}
return(result);
}
private void ServerMessageReceived(NetworkClient senderClient, int messageType, ByteString messageContent)
{
Debug.Log("Server message Type={0} Size={1}.", messageType, messageContent.Length);
switch (messageType) {
/* Handshake request. */
case MessageType.ClientHandshakeRequest: {
HandshakeRequest request = HandshakeRequest.Parser.ParseFrom(messageContent);
senderClient.UpdatePublicKey(request.Key);
PublicKey serverPublic = this.ServerKey;
if (serverPublic == null) {
Debug.Error("Server public key is invalid.");
return;
}
HandshakeResponse response = new HandshakeResponse();
response.Key = serverPublic;
senderClient.SendMessage(MessageType.ClientHandshakeResponse, response);
}
break;
/* Authorization request. */
case MessageType.AuthorizationRequest: {
AuthorizationRequest request = AuthorizationRequest.Parser.ParseFrom(messageContent);
senderClient.Profile.UpdateProfile(request);
AuthorizationResponse response = new AuthorizationResponse();
response.ServerName = this.m_serverConfig.ServerName;
senderClient.SendMessage(MessageType.AuthorizationResponse, response);
Task.Run(() => {
ContactUpdate contactUpdate = new ContactUpdate();
contactUpdate.Add.Add(senderClient.ContactClient);
foreach (NetworkClient connectedClient in this.m_connectedClients) {
if (connectedClient.ClientId == senderClient.ClientId) continue;
Debug.Log("Sending contact update to ClientId={0}.", connectedClient.ClientId);
connectedClient.SendMessage(MessageType.ContactUpdate, contactUpdate);
}
});
}
break;
/* Contact list update. */
case MessageType.ContactUpdateRequest: {
ContactUpdateRequest request = ContactUpdateRequest.Parser.ParseFrom(messageContent);
ContactUpdate contactUpdate = new ContactUpdate();
List<long> clientList = request.Clients.ToList();
foreach (NetworkClient connectedClient in this.m_connectedClients) {
// if (connectedClient.ClientId == senderClient.ClientId) continue;
if (!connectedClient.Profile.Valid) continue;
if (clientList.Contains(connectedClient.ClientId)) {
Debug.Log("Client {0} has got ClientId={1}.", senderClient.ClientId, connectedClient.ClientId);
clientList.Remove(connectedClient.ClientId);
}
else {
Debug.Log("Client {0} requires ClientId={1}.", senderClient.ClientId, connectedClient.ClientId);
contactUpdate.Add.Add(connectedClient.ContactClient);
}
}
Debug.Log("Trash clients count={0}.", clientList.Count);
if (clientList.Count > 0) {
contactUpdate.Remove.Add(clientList);
}
senderClient.SendMessage(MessageType.ContactUpdate, contactUpdate);
}
break;
case MessageType.ContactUpdateChangeRequest: {
ContactUpdateChangeRequest clientRequestedChange = ContactUpdateChangeRequest.Parser.ParseFrom(messageContent);
var senderProfile = senderClient.Profile;
if (senderProfile.Name != clientRequestedChange.Name || senderProfile.Surname != clientRequestedChange.Surname) {
Debug.Log("Updating client data. This is not implemented on the client side. ;)");
}
else if(senderProfile.Status != clientRequestedChange.Online) {
senderProfile.Status = clientRequestedChange.Online;
ContactUpdateStatus statusUpdate = new ContactUpdateStatus();
statusUpdate.Online = clientRequestedChange.Online;
statusUpdate.ClientId = senderClient.ClientId;
foreach (NetworkClient connectedClient in this.m_connectedClients) {
// if (connectedClient.ClientId == senderClient.ClientId) continue;
Debug.Log("Sending status update to ClientId={0}.", connectedClient.ClientId);
connectedClient.SendMessage(MessageType.ContactUpdateStatus, statusUpdate);
}
}
}
break;
/* Client Public Key request. */
case MessageType.MessageClientPublicRequest: {
MessageRequestClientPublic requestMessage = MessageRequestClientPublic.Parser.ParseFrom(messageContent);
PublicKey responseKey = null;
foreach (NetworkClient connectedClient in this.m_connectedClients) {
if (connectedClient.ClientId == requestMessage.ClientId) {
responseKey = connectedClient.ClientPublic;
}
}
if (responseKey != null) {
MessageResponseClientPublic responseMessage = new MessageResponseClientPublic();
responseMessage.ClientId = requestMessage.ClientId;
responseMessage.Key = responseKey;
senderClient.SendMessage(MessageType.MessageClientPublicResponse, responseMessage);
}
else
Debug.Warn("ClientId={0} has invalid public key.");
}
break;
}
}
public async Task <IActionResult> UpdateContactStatus([FromRoute] Guid contactId, [FromBody] ContactUpdateStatus contactUpdateStatus)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
contactUpdateStatus.Id = contactId;
contactUpdateStatus.UpdatedUserId = _claimsUser.UserId;
var updateStatusResult = await _contactService.UpdateContactStatus(contactUpdateStatus);
if (updateStatusResult.IsBadRequest)
{
return(BadRequest(updateStatusResult.ErrorMessage));
}
else if (updateStatusResult.Data.Value)
{
return(Ok());
}
else //if (!updateStatusResult.Data.Value)
{
return(NotFound());
}
}
