public IActionResult SendMessage(ContactsMessage cm)
{
Message newMessage = cm.Message;
newMessage.Send();
return(RedirectToAction("Index"));
}
public IActionResult SendMessage()
{
ContactsMessage cm = new ContactsMessage();
cm.Contacts = _db.Contacts.ToList();
return(View(cm));
}
public static SignalServiceSyncMessage forContacts(ContactsMessage contacts)
{
return(new SignalServiceSyncMessage(May.NoValue,
new May <ContactsMessage>(contacts),
May.NoValue,
May.NoValue,
May.NoValue,
May.NoValue));
}
private void registerToServerWithMessage(NetworkStream nwStream)
{
_messageSender.SendNewMessage(Name, new UserData("Server"), MyData, MyData);
TextMessage serverAnswer = (TextMessage)_messageReceiver.ReceiveAMessage();
Console.WriteLine(serverAnswer.Message);
ContactsMessage contactsMessage = (ContactsMessage)_messageReceiver.ReceiveAMessage();
clientData.contactsManager.UpdateContactsDB(contactsMessage.ContactList);
}
public static SignalServiceSyncMessage ForContacts(ContactsMessage contacts)
{
return(new SignalServiceSyncMessage(null,
contacts,
null,
null,
null,
null,
null,
null));
}
private void welcomeNewUser(User newUser)
{
TextMessage welcomeMessage = new TextMessage($"Welcome, {newUser.Name}", ServerDTO.AdminData, (UserData)newUser.Data);
ServerDTO.Serializer.Serialize(newUser.nwStream, welcomeMessage);
ContactsMessage newContactsDBMessage = new ContactsMessage(ServerDTO.ContactsDB, ServerDTO.AdminData, ServerDTO.AdminData);
_messageSender.SendToAllClients(newContactsDBMessage);
TextMessage userJoinedChatMessage = new TextMessage($"{newUser.Name} joined the chat!", ServerDTO.AdminData, ServerDTO.AdminData);
_messageSender.SendToAllClients(userJoinedChatMessage);
}
public void ContactsMessageWithSeveralContactsTest()
{
var contactsMessage =
new ContactsMessage(
new List <Contact>
{
new Contact("John", new IPEndPoint(IPAddress.Parse("127.0.0.1"), 80)),
new Contact("Harry", new IPEndPoint(IPAddress.Parse("192.168.0.1"), 88)),
new Contact("Marry", new IPEndPoint(IPAddress.Parse("192.168.0.2"), 88))
});
this.AssertMessage(contactsMessage);
}
public void ContactsMessageWithTooManyContactsTest()
{
var contact = new Contact("John", new IPEndPoint(IPAddress.Parse("127.0.0.1"), 80));
var contacts = new List <Contact>();
for (var i = 0; i < 9999; i++)
{
contacts.Add(contact);
}
var contactsMessage = new ContactsMessage(contacts);
this.AssertMessage(contactsMessage);
}
private void removeUserFromMembersDB(TcpClient client)
{
User removedUser = _serverDTO.MembersDB.RemoveUser(client);
UserData removedUserData = (UserData)removedUser.Data;
removeUserFromContactsDB(removedUserData);
if (removedUser != null)
{
TextMessage userLeftChatMessage = new TextMessage($"{removedUser.Name} has left the chat!", _serverDTO.AdminData, _serverDTO.AdminData);
_messageSender.SendToAllClients(userLeftChatMessage);
ContactsMessage contactsUpdateMessage = new ContactsMessage(_serverDTO.ContactsDB, _serverDTO.AdminData, _serverDTO.AdminData);
_messageSender.SendToAllClients(contactsUpdateMessage); // ToDo: move to a function with indicative name
}
}
private SignalServiceSyncMessage(SentTranscriptMessage sent,
ContactsMessage contacts,
SignalServiceAttachment groups,
BlockedListMessage blockedList,
RequestMessage request,
List <ReadMessage> reads,
VerifiedMessage verified,
ConfigurationMessage configuration)
{
Sent = sent;
Contacts = contacts;
Groups = groups;
BlockedList = blockedList;
Request = request;
Reads = reads;
Verified = verified;
Configuration = configuration;
}
private async Task HandleMessage(SignalServiceEnvelope envelope)
{
var cipher = new SignalServiceCipher(new SignalServiceAddress(SignalLibHandle.Instance.Store.Username), new Store());
var content = cipher.Decrypt(envelope);
long timestamp = Util.CurrentTimeMillis();
if (content.Message != null)
{
SignalServiceDataMessage message = content.Message;
if (message.EndSession)
{
await HandleSessionResetMessage(envelope, content, message, false, timestamp);
}
else if (message.IsGroupUpdate())
{
if (message.Group.Type == SignalServiceGroup.GroupType.UPDATE)
{
await HandleGroupUpdateMessage(envelope, content, message, false, timestamp);
}
else if (message.Group.Type == SignalServiceGroup.GroupType.QUIT)
{
await HandleGroupLeaveMessage(envelope, content, message, false, timestamp);
}
else if (message.Group.Type == SignalServiceGroup.GroupType.REQUEST_INFO)
{
Logger.LogWarning("Received REQUEST_INFO request");
}
}
else if (message.ExpirationUpdate)
{
await HandleExpirationUpdateMessage(envelope, content, message, false, timestamp);
}
else
{
await HandleSignalMessage(envelope, content, message, false, timestamp);
}
}
else if (content.SynchronizeMessage != null)
{
if (content.SynchronizeMessage.Sent != null)
{
var syncMessage = content.SynchronizeMessage.Sent;
var dataMessage = syncMessage.Message;
if (dataMessage.EndSession)
{
await HandleSessionResetMessage(envelope, content, dataMessage, true, timestamp);
}
else if (dataMessage.IsGroupUpdate())
{
if (dataMessage.Group.Type == SignalServiceGroup.GroupType.UPDATE)
{
await HandleGroupUpdateMessage(envelope, content, dataMessage, true, timestamp);
}
else if (dataMessage.Group.Type == SignalServiceGroup.GroupType.QUIT)
{
await HandleGroupLeaveMessage(envelope, content, dataMessage, true, timestamp);
}
else if (dataMessage.Group.Type == SignalServiceGroup.GroupType.REQUEST_INFO)
{
Logger.LogWarning("Received synced REQUEST_INFO request");
}
}
else if (dataMessage.ExpirationUpdate)
{
await HandleExpirationUpdateMessage(envelope, content, dataMessage, true, timestamp);
}
else
{
await HandleSignalMessage(envelope, content, dataMessage, true, timestamp);
}
}
else if (content.SynchronizeMessage.Reads != null)
{
var readMessages = content.SynchronizeMessage.Reads;
foreach (var readMessage in readMessages)
{
try
{
await HandleSyncedReadMessage(readMessage);
}
catch (Exception e)
{
Logger.LogError("HandleReadMessage failed: {0}\n{1}", e.Message, e.StackTrace);
}
}
}
else if (content.SynchronizeMessage.BlockedList != null)
{
List <string> blockedNumbers = content.SynchronizeMessage.BlockedList.Numbers;
await HandleBlockedNumbers(blockedNumbers);
}
else if (content.SynchronizeMessage.Groups != null)
{
Logger.LogInformation("HandleMessage() handling groups sync message from device {0}", envelope.GetSourceDevice());
int read;
var avatarBuffer = new byte[4096];
var groups = content.SynchronizeMessage.Groups;
using (var tmpFile = LibUtils.CreateTmpFile("groups_sync"))
{
var plaintextStream = await MessageReceiver.RetrieveAttachment(Token, groups.AsPointer(), tmpFile, 10000, null);
var deviceGroupsStream = new DeviceGroupsInputStream(plaintextStream);
var groupsList = new List <(SignalGroup, IList <string>)>();
DeviceGroup g;
while ((g = deviceGroupsStream.Read()) != null)
{
if (g.Avatar != null)
{
SignalServiceAttachmentStream ssas = g.Avatar.AsStream();
while ((read = ssas.InputStream.Read(avatarBuffer, 0, avatarBuffer.Length)) > 0)
{
}
}
var group = new SignalGroup()
{
ThreadDisplayName = g.Name,
ThreadId = Base64.EncodeBytes(g.Id),
GroupMemberships = new List <GroupMembership>(),
CanReceive = true,
ExpiresInSeconds = g.ExpirationTimer != null ? g.ExpirationTimer.Value : 0
};
groupsList.Add((group, g.Members));
}
List <SignalConversation> dbGroups = await SignalDBContext.InsertOrUpdateGroups(groupsList);
await SignalLibHandle.Instance.DispatchAddOrUpdateConversations(dbGroups);
}
}
else if (content.SynchronizeMessage.Contacts != null && content.SynchronizeMessage.Contacts.Complete) //TODO incomplete updates
{
Logger.LogInformation("HandleMessage() handling contacts sync message from device {0}", envelope.GetSourceDevice());
int read;
var avatarBuffer = new byte[4096];
ContactsMessage contacts = content.SynchronizeMessage.Contacts;
using (var tmpFile = LibUtils.CreateTmpFile("contacts_sync"))
{
var plaintextStream = await MessageReceiver.RetrieveAttachment(Token, contacts.Contacts.AsPointer(), tmpFile, 10000, null);
var deviceContactsStream = new DeviceContactsInputStream(plaintextStream);
List <SignalContact> contactsList = new List <SignalContact>();
DeviceContact c;
while ((c = deviceContactsStream.Read()) != null)
{
if (c.Avatar != null)
{
SignalServiceAttachmentStream ssas = c.Avatar.AsStream();
while ((read = ssas.InputStream.Read(avatarBuffer, 0, avatarBuffer.Length)) > 0)
{
}
}
SignalContact contact = new SignalContact()
{
ThreadDisplayName = c.Name,
ThreadId = c.Number,
Color = c.Color,
CanReceive = true,
ExpiresInSeconds = c.ExpirationTimer != null ? c.ExpirationTimer.Value : 0
};
contactsList.Add(contact);
}
var dbContacts = SignalDBContext.InsertOrUpdateContacts(contactsList);
await SignalLibHandle.Instance.DispatchAddOrUpdateConversations(dbContacts);
}
}
}
else if (content.ReadMessage != null)
{
SignalServiceReceiptMessage receiptMessage = content.ReadMessage;
Logger.LogTrace("HandleMessage() received ReceiptMessage (type={0}, when={1})", receiptMessage.ReceiptType, receiptMessage.When);
}
else
{
//TODO callmessages
Logger.LogWarning("HandleMessage() received unrecognized message");
}
}
/// <summary>
/// Обработчик сообщения со списком контактов
/// </summary>
/// <param name="message">
/// The message.
/// </param>
private void OnContactsMessage(ContactsMessage message)
{
contacts = message.Contacts;
clientView.DisplayContacts(contacts);
}
private void processContactsMessage(ContactsMessage contactsMessage)
{
_clientData.contactsManager.UpdateContactsDB(contactsMessage.ContactList);
}
public void ContactsMessageWithNullContactsTest()
{
var contactsMessage = new ContactsMessage(null);
this.AssertMessage(contactsMessage);
}
public void ContactsMessageWithEmptyContactsTest()
{
var contactsMessage = new ContactsMessage(new List <Contact>());
this.AssertMessage(contactsMessage);
}
