public void UpdateGroupChat(GroupChat chat, Action <GroupChat> chatConsumer)
{
var request = new RestRequest($"/chats/{chat.Id}", Method.PUT);
request.AddJsonBody(chat);
_sender.Send(request, chatConsumer);
}
public GroupChat CreateGroupChat(string owner, string name, List <string> members)
{
var chat = new GroupChat()
{
Name = name,
Owner = _userRepo.GetOne(owner),
ChatMembers = new List <ChatMember>()
};
_chatRepo.Add(chat);
foreach (var member in members)
{
chat.ChatMembers.Add(new ChatMember()
{
Chat = chat,
User = _userRepo.GetOne(member)
});
}
;
_chatRepo.Save(chat);
return(chat);
}
public void StartGroupChat(GroupChat chat, Action <GroupChat> chatConsumer)
{
var request = new RestRequest("/chats", Method.POST);
request.AddJsonBody(chat);
_sender.Send(request, chatConsumer);
}
////отправка сообщений в группу
//public string GroupMessage(string name,Message mes)
//{
// var person = db.Users.FirstOrDefault(x => x.Email == name);
// var date = DateTime.Now;
// if(person.Ban==true&&date>person.BanDateTime.AddMinutes(5))
// {
// person.Ban = false;
// db.Entry(person).State = EntityState.Modified;
// db.SaveChanges();
// }
// if(person.Ban==false)
// {
// var chat = db.Chats.FirstOrDefault(x => x.Name == mes.ToName);
// Message mess = new Message { Text = mes.Text, FromId = person.Id, FromName = person.Email, ChatId = chat.Id, DateTime = DateTime.Now };
// db.Messages.Add(mess);
// db.SaveChanges();
// return "ок";
// }
// else
// {
// return "Вас заблокировали на 5 минут";
// }
//}
//создание беседы из нескольких человек
public string Array(string name, GroupChat groupChat)
{
var clients = groupChat.MassivIdUser.ToList(); // id клиентов для создания беседы, без текущего пользователя
var users = db.Users.ToList(); // все пользователи из бд
var person = db.Users.FirstOrDefault(x => x.Email == name);
var people = new List <Person>(); //клиенты для беседы
foreach (var i in clients)
{
foreach (var j in users)
{
if (i == j.Id)
{
people.Add(j);
}
}
}
Chat chat = new Chat {
Name = groupChat.Name
};
chat.PeopleChat.Add(person);
foreach (var x in people)
{
chat.PeopleChat.Add(x);
}
db.Chats.Add(chat);
db.SaveChanges();
return("беседа создана!");
}
public IActionResult GroupChangeStatus(string id, int groupId)
{
Group group = repository.Groups.FirstOrDefault(g => g.GroupId == groupId);
string newStatus = "Private";
if (group.Status == "Private")
{
newStatus = "Public";
//add notification if not exists
if (repository.Notifications.Any(n => n.For == "Group" && n.ForId == groupId &&
n.Subject == "AddUserToGroup") == false)
{
repository.NewNotification(id, "AddUserToGroup", "Group", group.GroupId);
}
}
group.Status = newStatus;
repository.SaveGroup(group);
if (group.GroupChatId != 0)
{
GroupChat chat = repository.GroupChats.FirstOrDefault(c => c.ChatId == group.GroupChatId);
chat.Status = newStatus;
repository.EditGroupChat(chat);
}
return(RedirectToAction("GroupDetails", new { id, groupId }));
}
public void AddMembers(GroupChat chat, IList <Account> newMembers, Action <GroupChat> chatConsumer)
{
var request = new RestRequest($"/chats/{chat.Id}/members", Method.POST);
request.AddJsonBody(newMembers);
_sender.Send(request, chatConsumer);
}
public async Task <IActionResult> CreateGroupChat([FromBody] GroupChatMember otherMember)
{
var user = await TokenHelper.GetUser(User, _userManager);
if (user == null)
{
return(RequestHandler.Unauthorized());
}
if (user.Id.ToString() == otherMember.Id)
{
return(RequestHandler.BadRequest("You can't start a chat with yourself"));
}
var groupChat = await _groupChatService.GetExistingGroupChatAsync(user.Id.ToString(), otherMember.Id);
if (groupChat != null)
{
return(RequestHandler.BadRequest($"You are already in a group chat with {otherMember.Name}"));
}
groupChat = new GroupChat();
groupChat.Members.Add(new GroupChatMember
{
Id = user.Id.ToString(),
Name = user.UserName,
Email = user.Email,
});
groupChat.Members.Add(otherMember);
await _groupChatService.SaveGroupChatAsync(groupChat);
foreach (var member in groupChat.Members)
{
var clients = SignalRMemberService.GetConnectionsByUser(member.Id);
if (clients == null)
{
continue;
}
foreach (var connectionId in clients)
{
await _signalRHub.Groups.AddToGroupAsync(connectionId, groupChat.Id);
if (member.Id == user.Id.ToString())
{
await _signalRHub.Clients.Client(connectionId).GroupChatUpdated(groupChat);
}
else
{
await _signalRHub.Clients.Client(connectionId).GroupChatCreated(groupChat, user.UserName);
}
}
}
return(Ok(groupChat));
}
public IActionResult AddUsers(NewGroupStep2ViewModel model)
{
//group
Group group = repository.Groups
.FirstOrDefault(g => g.GroupId == model.GroupId);
//Created by
AppUser user = userManager.Users.FirstOrDefault(u => u.Id == group.CreatedBy.Id);
if (model.UsersIdString != null)
{
//list of users id
string userIdList = model.UsersIdString.Trim();
while (userIdList.Trim().Length > 0)
{
int index = userIdList.IndexOf(";");
if (index != -1)
{
string newUserId = userIdList.Substring(0, index);
repository.AddUserToGroup(newUserId, group.GroupId);
//notification
if (group.Status == "Public")
{
repository.NewNotification(group.CreatedBy.Id, "AddUserToGroup", "Group", group.GroupId, newUserId);
}
//group chat exists
if (group.GroupChatId != 0)
{
repository.AddUserToGroupChat(group.GroupChatId, newUserId);
GroupChat groupChat = repository.GroupChats
.FirstOrDefault(g => g.ChatId == group.GroupChatId);
AppUser addedUser = userManager.Users.FirstOrDefault(u => u.Id == newUserId);
string userName = (user.FirstName == null && user.LastName == null) ?
user.UserName : user.FirstName + user.LastName;
string content = $"{userName} added {addedUser}";
GroupChatMessage newMsg = new GroupChatMessage
{
GroupChatId = group.GroupChatId,
UserId = user.Id,
MessageContent = content,
MessageType = "SystemMsg"
};
repository.NewGroupChatMessage(newMsg, groupChat);
}
userIdList = userIdList.Replace(newUserId + ";", "");
}
}
}
return(RedirectToAction("GroupDetails", new
{
id = group.CreatedBy.Id,
groupId = group.GroupId
}));
}
public static PacketWriter Create(GroupChat groupChat)
{
PacketWriter pWriter = PacketWriter.Of(SendOp.GroupChat);
pWriter.Write(GroupChatPacketMode.Create);
pWriter.WriteInt(groupChat.Id);
return(pWriter);
}
public ActionResult GetGroupChat()
{
string tid = Session["TID"].ToString();
GroupChat chat = new GroupChat();
List <NGroup> DetList = chat.GetGroupChat(tid);
return(View(DetList));
}
public List <string> GetAllGroupHistory(GroupChat groupChat)
{
if (_messagesHistory.ContainsKey(groupChat))
{
return(_messagesHistory[groupChat]);
}
return(new List <string>());
}
private GroupChat SendGroup(string groupName)
{
GroupChat groupChat = _data.AllGroupsChat.GetGroupsChat().Where(g => g.Name == groupName).First();
_requests.SendModelMessage(_client, groupChat);
return(groupChat);
}
public IActionResult PutGroupChat(JObject obj)
{
GroupChat groupChat = obj["groupchat"].ToObject <GroupChat>();
User user = obj["user"].ToObject <User>();
GroupChatDataProvider.AddGroupChat(groupChat, user);
return(Ok());
}
public IActionResult RemoveGroupChatUser(JObject obj)
{
GroupChat groupChat = obj["groupchat"].ToObject <GroupChat>();
User user = obj["user"].ToObject <User>();
GroupChatDataProvider.RemoveGroupChatUserID(groupChat, user);
return(Ok());
}
public async Task <GroupChat> createGroupChat(GroupChat groupChat)
{
await _context.GroupChats.AddAsync(groupChat);
await _context.SaveChangesAsync();
return(groupChat);
}
private void AddGroup(GroupChat newGroupChat, GroupChat oldGroupChat, Guid clientGuid)
{
_data.AllGroupsChat.RemoveGroupChat(oldGroupChat);
_data.AllGroupsChat.AddGroupChat(newGroupChat);
List <Guid> removeClients = GetRemoveClients(newGroupChat, oldGroupChat);
SaveAlert(removeClients, oldGroupChat, clientGuid);
}
public static Packet Leave(GroupChat groupChat)
{
PacketWriter pWriter = PacketWriter.Of(SendOp.GROUP_CHAT);
pWriter.WriteEnum(GroupChatPacketMode.Leave);
pWriter.WriteInt(groupChat.Id);
return(pWriter);
}
public override void Connect()
{
base.Connect();
// If it's the first access for the user, we send the added meta message
if (FirstAccess)
{
SendMetaMessage(MetaState.Added);
}
// Now send a meta message, that the user is online
SendMetaMessage(MetaState.Online);
// Declare the queue for the user
var queue = GroupChat.SharedSecret.GroupChatName + "." + GroupChat.ChatMember;
Model.QueueDeclare(queue, true, false, false, null);
var consumer = new EventingBasicConsumer(Model);
consumer.Received += (obj, ea) =>
{
var message = BinaryFormatter <ChatMessage> .FromBinary(ea.Body);
// Proof that receiver is not the sender
if (message.Sender == GroupChat.ChatMember)
{
return;
}
// Decrypt the message
if (message.IsEncrypted)
{
message = GroupChat.Decrypt(message);
}
// if Message can't decrypted (due to wrong shared key etc)
if (message == null)
{
return;
}
// Check, if the plain text is a json meta object
var parsedJsonObject = JObject.Parse(message.PlainText);
if (parsedJsonObject.IsValid(MetaMessageSchema))
{
var metaMessage = JsonConvert.DeserializeObject <MetaMessage>(message.PlainText);
OnMetaMessageReceived?.Invoke(GroupChat.ChatMember, message.Sender, metaMessage);
}
else if (parsedJsonObject.IsValid(ContentMessageSchema))
{
var contentMessage = JsonConvert.DeserializeObject <TMessageObject>(message.PlainText);
OnMessageReceived?.Invoke(GroupChat.ChatMember, message.Sender, contentMessage);
}
};
Model.QueueBind(queue, "amq.fanout", GroupChat.SharedSecret.GroupChatName, null);
Model.BasicConsume(queue, true, string.Empty, false, true, null, consumer);
}
public void SendMessage(TMessageObject message, string chatMember = null)
{
var json = JsonConvert.SerializeObject(message);
var chatMessage = GroupChat.Encrypt(json);
var queue = GroupChat.SharedSecret.GroupChatName + (chatMember != null ? $".{chatMember}" : "");
Model.BasicPublish("amq.fanout", queue, true, new BasicProperties(), BinaryFormatter <ChatMessage> .ToBinary(chatMessage));
}
public async Task <ChatMessage> GetMessageByIdAsync(GroupChat chat, string msgId)
{
return(await _context
.Entry(chat)
.Collection(x => x.Messages)
.Query()
.Include(x => x.SentBy)
.SingleOrDefaultAsync(x => x.Id.Equals(msgId, StringComparison.Ordinal)));
}
public static PacketWriter LoginNotice(GroupChat groupChat, Player player)
{
PacketWriter pWriter = PacketWriter.Of(SendOp.GroupChat);
pWriter.Write(GroupChatPacketMode.LoginNotice);
pWriter.WriteInt(groupChat.Id);
pWriter.WriteUnicodeString(player.Name);
return(pWriter);
}
public static void ChatSystemUpdate()
{
Console.WriteLine("----------------ChatSystemUpdate----------------");
new Thread(() => PrivateChat.GetPage().Update()).Start();
new Thread(() => Chat.GetPage().Update()).Start();
new Thread(() => GroupChat.GetPage().Update()).Start();
new Thread(() => GroupSetting.GetPage().Update()).Start();
new Thread(() => Group.getPage().Update()).Start();
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
GroupChat groupChat = await _db.groupChats.FindAsync(id);
_db.groupChats.Remove(groupChat);
await _db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public void AddGroupChat([FromBody] GroupChat groupChat, int groupId)
{
var group = groupRepository.GetById(groupId);
GroupController gc = new GroupController();
groupChatRepository.Add(groupChat);
groupChatRepository.SaveChanges(groupChat);
}
public void RemoveSelectedMessages()
{
List <Message> removeMessages = LocalMessages.Where(m => m.Selecting).ToList();
removeMessages.ForEach(m => _db.Entry(m).State = EntityState.Deleted);
_db.SaveChanges();
GroupChat.RemoveMessages(groupChat.Messages, removeMessages);
groupChat.UpdateChat(removeMessages);
}
public static Packet LogoutNotice(GroupChat groupChat, Player player)
{
PacketWriter pWriter = PacketWriter.Of(SendOp.GROUP_CHAT);
pWriter.WriteEnum(GroupChatPacketMode.LogoutNotice);
pWriter.WriteInt(groupChat.Id);
pWriter.WriteUnicodeString(player.Name);
return(pWriter);
}
private void AddGroup(GroupChat groupChat, Guid clientGuid)
{
groupChat.Managers.Add(clientGuid);
groupChat.Participants.Add(clientGuid);
_data.AllGroupsChat.AddGroupChat(groupChat);
_logger.LogInformation($"add new group {groupChat.Name}");
SaveAlert(groupChat, clientGuid);
}
// All API calls for GroupChat
// All API calls for GroupChat
// All API calls for GroupChat
public async Task <bool> CreateGroupChat(int groupId, GroupChat chat)
{
var client = new HttpClient();
var json = JsonConvert.SerializeObject(chat);
HttpContent content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await client.PostAsync(ConnectionString + "api/GroupChat/AddGroupChat/" + groupId.ToString() + "/", content);
return(response.IsSuccessStatusCode);
}
private void SaveAlerts(List <TcpClient> allClientsNotConnected, GroupChat group)
{
Alert alert = new Alert(AlertOptions.NEW_MESSAGE, $"you have message in group {group.Name}");
MessageRequest messageRequestAlert = new MessageRequest(MessageKey.ALERT, alert);
foreach (var client in allClientsNotConnected)
{
_data.ClientsAlerts.AddNewAlert(client, messageRequestAlert);
}
}
public GroupChatForm(GroupChat chat, User[] users, ListBox AllUsers)
{
InitializeComponent();
this.chat = chat;
chat.OnClose += OnClose;
chat.OnGetMessage += GetMessage;
chat.OnUserUpdateState += UpdateUser;
InitializeUsers(users);
this.AllUsers = AllUsers;
}
/// <summary>
/// Static method that takes in an xml String and converts it to an AbstractMessage.
///
/// Will throw an XmlException if the xml String was in an unrecognized format.
/// </summary>
/// <param name="xml">A String with xml representing an AbstractMessage</param>
/// <returns>The AbstractMessage parsed from the XML String</returns>
public override AbstractMessage Parse(String xml)
{
XmlTextReader reader = new XmlTextReader(new StringReader(xml));
AbstractMessage returnee = null;
Int32 chatId = 0;
String element = "";
String textMessage = "";
String username = "";
String password = "";
String sender = "";
Boolean accepted = false;
Boolean isAlreadyLoggedOn = true;
Boolean alreadyExisted = false;
Boolean authenticationDisabled = false;
GroupChat chat = null;
ExtendedHashSet<String> hashSet = null;
try
{
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.CDATA:
switch (element)
{
case "Message":
textMessage = reader.Value;
break;
case "Username":
username = reader.Value;
break;
case "Password":
password = reader.Value;
break;
case "User":
hashSet.Add(reader.Value);
break;
case "Participant":
hashSet.Add(reader.Value);
break;
case "Sender":
sender = reader.Value;
break;
case "Name":
hashSet.Add(reader.Value);
break;
default:
break;
}
break;
case XmlNodeType.Element:
element = reader.Name; // define last known element
switch (element)
{
case "UserList":
hashSet = new ExtendedHashSet<String>();
break;
case "Participants":
hashSet = new ExtendedHashSet<String>();
break;
case "ToBeAdded":
hashSet = new ExtendedHashSet<String>();
break;
case "ToBeRemoved":
hashSet = new ExtendedHashSet<String>();
break;
}
break;
case XmlNodeType.EndElement:
switch (reader.Name)
{
case "TextMessage":
returnee = new TextMessage(textMessage);
break;
case "LoginMessage":
returnee = new LoginMessage(username, password);
break;
case "LoginResponseMessage":
returnee = new LoginResponseMessage(accepted, isAlreadyLoggedOn, username);
break;
case "AddToUserListMessage":
returnee = new AddToUserListMessage(hashSet);
break;
case "RemoveFromUserListMessage":
returnee = new RemoveFromUserListMessage(hashSet);
break;
case "GroupChatMessage":
returnee = new GroupChatMessage(chat, textMessage, sender);
break;
case "AddMemberToGroupChatMessage":
returnee = new AddMemberToGroupChatMessage(chatId, hashSet);
break;
case "RemoveMemberFromGroupChatMessage":
returnee = new RemoveMemberFromGroupChatMessage(chatId, hashSet);
break;
case "StartGroupChatRequestMessage":
returnee = new StartGroupChatRequestMessage(hashSet);
break;
case "StartGroupChatResponseMessage":
returnee = new StartGroupChatResponseMessage(chatId, alreadyExisted);
break;
case "GroupChatInfoRequestMessage":
returnee = new GroupChatInfoRequestMessage(chatId);
break;
case "GroupChatInfoResponseMessage":
returnee = new GroupChatInfoResponseMessage(chat);
break;
case "SignupRequestMessage":
returnee = new SignupRequestMessage(username, password);
break;
case "SignupResponseMessage":
returnee = new SignupResponseMessage(accepted, alreadyExisted, authenticationDisabled);
break;
case "GroupChat":
chat = new GroupChat(hashSet, chatId);
break;
default:
break;
}
break;
case XmlNodeType.Text:
switch (element)
{
case "Accepted":
accepted = Boolean.Parse(reader.Value);
break;
case "IsAlreadyLoggedOn":
isAlreadyLoggedOn = Boolean.Parse(reader.Value);
break;
case "ChatID":
chatId = int.Parse(reader.Value);
break;
case "AlreadyExisted":
alreadyExisted = Boolean.Parse(reader.Value);
break;
case "AuthenticationDisabled":
authenticationDisabled = Boolean.Parse(reader.Value);
break;
default:
break;
}
break;
default:
break;
}
}
}
catch
{
throw new XmlException("Unrecognized XML Format...");
}
reader.Close();
if (returnee != null)
{
return returnee;
}
else
{
throw new XmlException("Unrecognized XML Format...");
}
}
