public ChatInfoModel(ZaolisServiceClient.ZaolisServiceClient client, UserDTO current, ChatDTO chat)
{
this.client = client;
Chat = chat;
CurrentUser = current;
ContactMsgGetter = client.GetUsersByChat(Chat).Where(u => u.Id != current.Id).FirstOrDefault();
Messages = new ObservableCollection <MessageModel>();
Task.Run(() =>
{
Application.Current.Dispatcher.Invoke(() =>
{
foreach (var item in client.GetMessagesByChat(chat))
{
Messages.Add(new MessageModel(item, CurrentUser)
{
Message = item
});
}
if (Messages.Count() > 1)
{
var firstMsg = Messages.First();
Messages.Remove(firstMsg);
Messages.Insert(Messages.IndexOf(Messages.Last()) + 1, firstMsg);
}
});
});
}
public void ShowChat(ChatDTO chatDto)
{
string messageToSend;
if (!chatDictionary.ContainsKey(chatDto.chatMessage))
{
messageToSend = "Error, message doesn't exist: " + chatDto.chatMessage;
}
else
{
messageToSend = chatDictionary[chatDto.chatMessage];
}
Text chatText;
if (chatDto.characterImage == null)
{
chatSys.SetNormalChat(true);
chatText = chatSys.normalChat;
}
else
{
chatSys.SetNormalChat(false);
foreach (CharacterImage chImg in charImage)
{
if (chImg.CharacterName == chatDto.characterImage)
{
chatSys.characterImage.sprite = chImg.ProfilePicture;
}
}
chatText = chatSys.charaterChat;
}
StartCoroutine(TypeText(chatText, messageToSend, 0.01f, chatDto));
}
public bool ValidateChatModel(ChatDTO chat, out string error)
{
var participants = chat.Participants.Select(p => p.Id).ToList();
var ownerId = chat.Owner?.Id ?? chat.OwnerId;
if (ownerId != null && !participants.Any(p => p == ownerId))
{
error = "The owner must also be a participant";
return(false);
}
var existingUsers = _db.Users.ReadMultiple(participants)
.Where(u => u.Active)
.Select(u => u.Id)
.ToList();
var diff = participants.Except(existingUsers).ToList();
if (diff.Count() == 1)
{
error = $"Invalid users provided: {string.Join(", ", diff)}";
return(false);
}
error = null;
return(true);
}
public UserDTO AddContact(string contactEmail, UserDTO user)
{
UserDTO addingContact;
if ((addingContact = userService.GetAll().FirstOrDefault((u) => u.Email == contactEmail)) == null)
{
throw new FaultException("Inccorect email");
}
int temporaryId = new Random().Next(1, 100000);
chatService.UpdeteOrCreate(new ChatDTO()
{
IsPrivateChat = true, Name = $"{temporaryId}"
});
chatService.SaveChanges();
ChatDTO createdChat = chatService.GetAll().FirstOrDefault((c) => c.Name == $"{temporaryId}");
createdChat.Name = "Private chat";
chatService.UpdeteOrCreate(createdChat); chatService.SaveChanges();
chatUserService.UpdeteOrCreate(new ChatUserDTO()
{
IsCreator = true, IsAdmin = true, UserId = addingContact.UserId, ChatId = createdChat.ChatId
});
chatUserService.UpdeteOrCreate(new ChatUserDTO()
{
IsCreator = true, IsAdmin = true, UserId = user.UserId, ChatId = createdChat.ChatId
});
chatUserService.SaveChanges();
NotifyUserAboutCreatedChat(addingContact.UserId, createdChat);
NotifyUserAboutCreatedChat(user.UserId, createdChat);
return(addingContact);
}
public IHttpActionResult GetChatById(int userId, string chat)
{
Logger.log.Debug("at ChatController.GetChatById");
ChatDTO chatDTO = null;
if (!this.CheckUserIdAcces(userId))
{
Logger.log.Error("at ChatController.GetChatById - User request denied");
return(new Forbidden("User cannot have acces to other chat!"));
}
int chatId = this.CreateChatIdFromProxy(chat);
using (var client = SoapProvider.GetChatServiceClient())
{
if (!this.IfUserHasAccesToChat(client, chatId, userId))
{
Logger.log.Error("at ChatController.GetChatById - User request denied");
return(new Forbidden("User cannot have acces to other chat!"));
}
chatDTO = client.GetChatById(chatId);
}
if (chatDTO == null)
{
Logger.log.Error("at ChatController.GetChatById - Error at database");
return(InternalServerError());
}
return(Ok(chatDTO));
}
public IHttpActionResult AddChat(int userId, ChatDTO chat)
{
Logger.log.Debug("at ChatController.AddChat");
int createdChatId;
if (!this.CheckUserIdAcces(userId))
{
Logger.log.Error("at ChatController.AddChat - User request denied");
return(new Forbidden("User cannot add chat to other people!"));
}
using (var client = SoapProvider.GetChatServiceClient())
{
createdChatId = client.AddChat(chat);
if (createdChatId == -1)
{
Logger.log.Error("at ChatController.AddChat - Error at database");
return(InternalServerError());
}
if (!client.AddUser(createdChatId, userId))
{
Logger.log.Error("at ChatController.AddChat - Error at database");
return(InternalServerError());
}
}
return(Ok(createdChatId));
}
public IEnumerable <MessageDTO> GetMessages(ChatDTO chatDTO)
{
IEnumerable <Message> messages;
List <MessageDTO> messageDTOs = new List <MessageDTO>();
IMainMap mainMap = new Map();
using (ChatRepository repository = new ChatRepository())
{
messages = repository.GetMessages(mainMap.ChatDTOToChat(chatDTO));
}
using (UserRepository repository = new UserRepository())
{
foreach (Message message in messages)
{
MessageDTO messageDTO = new MessageDTO();
messageDTO = mainMap.MessageToMessageDTO(message);
User user = repository.GetItem(messageDTO.UserId);
messageDTO.Author = user.UserLogin;
messageDTO.Img = user.UserImg;
messageDTOs.Add(messageDTO);
}
}
return(messageDTOs);
}
IEnumerator TypeText(Text textComp, string message, float letterPause, ChatDTO chatDto)
{
canSwith = false;
canContinue = false;
GameManagerBase.instance.PauseGame(true);
textComp.text = "";
message = message.Replace("<br>", "\n");
foreach (char letter in message.ToCharArray())
{
textComp.text += letter;
yield return(0);
yield return(new WaitForSeconds(letterPause));
}
while (!canSwith)
{
yield return(new WaitForSeconds(0.5f));
textComp.text = message + " —";
yield return(new WaitForSeconds(0.5f));
textComp.text = message;
}
chatSys.CloseAll();
canContinue = true;
GameManagerBase.instance.PauseGame(false);
if (chatDto.chatEvent != null)
{
chatDto.chatEvent();
}
}
/// <summary>
/// Add chat to db
/// </summary>
/// <param name="newChat"></param>
/// <returns>Created chat id</returns>
public int AddChat(ChatDTO newChat)
{
Logger.log.Debug("at WCFService.ChatService.AddChat");
var chat = _chatConverter.ToBusinessEntity(newChat);
return(ChatProvider.AddChat(chat));
}
public JsonResult New(ChatDTO item)
{
Chat chat = new Chat();
chat.Message = item.Message;
chat.UserId = Convert.ToString(Session["Email"]);
return(Json(new { success = true, data = _context.Create(chat) }));
}
public void CallBackChatAdded(ChatDTO chat)
{
App.Current.Dispatcher.BeginInvoke((Action) delegate()
{
Thread.Sleep(20);
UserChats.Add(InitializeChat(chat));
});
}
public void WCFTestAddChat()
{
ChatDTO chat = new ChatDTO();
int before = ChatProvider.GetAllChats().Count;
_chatClient.AddChat(chat);
var after = ChatProvider.GetAllChats().Count;
Assert.That(after == before + 1);
}
public ChatDTO GetFullChat(int chatId)
{
Chat chat = Database.Chats.GetWithInclude(chatId,
c => c.Admin,
c => c.Messages,
c => c.Participants);
ChatDTO chatDTO = Mapper.Map <Chat, ChatDTO>(chat);
return(chatDTO);
}
public void SendMessage(ChatDTO chatDTO)
{
_context.Messages.Add(new Message()
{
Text = chatDTO.Text,
UserIdFrom = chatDTO.UserIdFrom,
UserIdTo = chatDTO.UserIdTo,
CreatedOn = DateTime.Now
});
_context.SaveChanges();
}
public Chat ChatDTOToChat(ChatDTO chatDTO)
{
Chat chat = new Chat
{
ChatId = chatDTO.Id,
ChatImg = chatDTO.Img,
ChatName = chatDTO.Name,
ChatStatus = chatDTO.Status
};
return(chat);
}
public ChatDTO ChatToChatDTO(Chat chat)
{
ChatDTO chatDTO = new ChatDTO
{
Id = chat.ChatId,
Img = chat.ChatImg,
Name = chat.ChatName,
Status = chat.ChatStatus,
};
return(chatDTO);
}
private void NotifyUserAboutCreatedChat(int userId, ChatDTO chat)
{
UserDTO findindUser;
if ((findindUser = OnlineUsers.Keys.FirstOrDefault((u) => u.UserId == userId)) != null)
{
Task.Run(() =>
{
OnlineUsers[findindUser].GetCallbackChannel <IServiceMessangerCallback>().CallBackChatAdded(chat);
});
}
}
public ChatDTO ChatModelToChatDTO(ChatModel chatModel)
{
ChatDTO chatDTO = new ChatDTO
{
Id = chatModel.Id,
Img = chatModel.Img,
Name = chatModel.Name,
Status = chatModel.Status,
};
return(chatDTO);
}
public ChatModel ChatDTOToChatModel(ChatDTO chatDTO)
{
ChatModel chatModel = new ChatModel
{
Id = chatDTO.Id,
Img = chatDTO.Img,
Name = chatDTO.Name,
Status = chatDTO.Status
};
return(chatModel);
}
public void WCFTestUpdateChat()
{
ChatDTO chat = _chatClient.GetChatById(1);
string before = chat.Title;
chat.Title = chat.Title + "A";
_chatClient.UpdateChat(chat);
ChatDTO chatAfter = _chatClient.GetChatById(1);
string after = chatAfter.Title;
Assert.That(before != after);
}
public IActionResult Post(ChatDTO chat)
{
if (!_chatService.ValidateChatModel(chat, out string error))
{
this.ModelState.AddModelError(nameof(chat), error);
return(BadRequest(ModelState));
}
var created = _chatService.CreateChat(chat);
return(Ok(created));
}
public bool SendMessage(ChatDTO chatDTO, string token, string message)
{
if (String.IsNullOrWhiteSpace(message))
{
return(false);
}
IMainMap mainMap = new Map();
using (ChatRepository repository = new ChatRepository())
{
repository.AddMessage(mainMap.ChatDTOToChat(chatDTO), message, token);
repository.Save();
return(true);
}
}
ChatModel InitializeChat(ChatDTO chat)
{
ChatModel chatModel = new ChatModel();
chatModel.Chat = chat;
chatModel.DraftMessage = new MessageDTO();
foreach (var chatUser in NetworkManager.Client.GetChatUsers(chat))
{
ChatUserModel chatUserModel = new ChatUserModel()
{
ChatUser = chatUser
};
chatUserModel.User = new UserModel()
{
User = NetworkManager.Client.GetUser(chatUser.UserId)
};
//if(chatUserModel.User.User.Photo != null)
//{
// Stream photoStream ;
// int photoId = (int)chatUserModel.User.User.Photo;
// string downloadingFileName = Client.DownloadFile(ref photoId, out photoStream);
// string downloadingFilePath = Path.Combine(fileDirectoryPath, downloadingFileName);
// //if (!File.Exists(downloadingFilePath))
// //{
// // using(FileStream savingFileStream = new FileStream(downloadingFilePath,FileMode.Create))
// // {
// // photoStream.Seek(0, SeekOrigin.Begin);
// // photoStream.CopyTo(savingFileStream);
// // }
// //}
// chatUserModel.User.UserPhoto = new System.Drawing.Bitmap(downloadingFilePath);
//}
chatModel.Members.Add(chatUserModel);
}
if (chatModel.Chat.IsPrivateChat)
{
chatModel.Chat.Name = chatModel.Members.FirstOrDefault((chatUserModel) => chatUserModel.User.User.UserId != NetworkManager.CurrentUser.UserId).User.User.Name;
}
foreach (var msg in NetworkManager.Client.GetMessages(chat))
{
chatModel.Messages.Add(new MessageModel()
{
Message = msg, Sender = chatModel.Members.FirstOrDefault((chatMembers) => chatMembers.User.User.UserId == msg.SenderId).User
});
}
return(chatModel);
}
public Task <bool> EditChat(ChatDTO chatDto)
{
return(Task.Run(() => {
try
{
var chat = Mapper.Map <ChatDTO, Chat>(chatDto);
Database.Chats.Update(chat);
Database.Save();
}
catch (Exception)
{
return false;
}
return true;
}));
}
public bool DoesUserNameExists(ChatDTO obj)
{
// Find username inside database based on obj.UserName
var foundUserName = (from credentials in db.Credentials
where credentials.UserName == obj.UserName
select credentials.UserName).FirstOrDefault();
// Checking if it found a user
if (foundUserName == null)
{
// returns false if passed username does not exists in database
return(false);
}
else
{
// returns true if passed username does exists in database
return(true);
}
}
public async Task <ActionResult> AddChat(ChatDTO chatDTO, HttpPostedFileBase upload, string[] users)
{
IsFilenameValide(upload);
if (ModelState.IsValid)
{
chatDTO.AdminId = User.Identity.GetUserId();
chatDTO.PhotoUrl = SaveChatIcon(upload);
chatDTO.CreatedAt = DateTime.Now;
int chatId = await serviceUOW.ChatService.CreateChat(chatDTO);
AddUsersToChat(chatId, users);
return(RedirectToAction("Index", "Manage"));
}
return(View(chatDTO));
}
public Task <int> CreateChat(ChatDTO chatDto)
{
return(Task.Run(() => {
int chatId;
try
{
User admin = Database.Users.GetById(chatDto.AdminId);
Chat chat = Mapper.Map <ChatDTO, Chat>(chatDto);
chat.Admin = admin;
chatId = Database.Chats.Create(chat);
Database.Save();
}
catch (Exception)
{
return -1;
}
return chatId;
}));
}
public ChatDTO CreateChat(ChatDTO chat)
{
try
{
_db.StartTransaction();
var chatEntity = _mapper.Map <Chat>(chat);
foreach (var u in chatEntity.Participants)
{
u.AddedDate = DateTime.Now;
}
var chatId = _db.Chats.Create(chatEntity);
_db.Commit();
var created = GetChat(chatId);
return(created);
}
catch
{
_db.Rollback();
throw;
}
}
public IActionResult Put(int id, [FromBody] ChatDTO dto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var chat = _chatRepo.Get(id);
if (chat == null)
{
return(NotFound());
}
_mapper.Map(dto, chat); // (from, to)
if (_chatRepo.SaveAll())
{
return(Ok());
}
return(BadRequest($"Updating chat {id} failed on save"));
}
public async Task <ActionResult> UpdateChat(ChatDTO chatDTO, HttpPostedFileBase upload, string[] users)
{
IsFilenameValide(upload);
if (ModelState.IsValid)
{
chatDTO.PhotoUrl = SaveChatIcon(upload);
await serviceUOW.ChatService.EditChat(chatDTO);
await serviceUOW.ChatService.ChangeChatUsersList(chatDTO.Id, users);
return(RedirectToAction("Index", "Manage"));
}
ChatToUpdateViewModel vm = new ChatToUpdateViewModel
{
Chat = chatDTO,
Participants = await LoadUsersToList(users ?? new string[0])
};
return(View(vm));
}
/// <summary>
/// 本地输入公共聊天消息提交
/// </summary>
public void OnPublicChattingSubmit(UIInput input)
{
string text = input.value;
if (text != null && text != "" && text.Trim() != "")
{
LogsSystem.Instance.Print("[用户]" + text);
AddChatList("我", text);
if (cardClient != null)
{
SocketModel model = new SocketModel();
model.protocol = SocketProtocol.CHAT;
ChatDTO data = new ChatDTO(text, Global.Instance.playerName, Global.Instance.UUID);
model.message = JsonCoding<ChatDTO>.encode(data);
cardClient.SendMsg(JsonCoding<SocketModel>.encode(model));
}
}
input.value = "";
}
