// Token: 0x06000B79 RID: 2937 RVA: 0x00049A0C File Offset: 0x00047C0C
private int DrawMyMessage(InboxMessage msg, int x, int y, int width)
{
int num = Mathf.RoundToInt(BlueStonez.speechbubble_right.CalcHeight(new GUIContent(msg.Content), (float)width)) + 30;
Rect position = new Rect((float)x, (float)y, (float)width, (float)num);
GUI.color = new Color(0.5f, 0.5f, 0.5f);
int num2 = (int)BlueStonez.label_interparkbold_11pt_left.CalcSize(new GUIContent(msg.SenderName)).x;
int num3 = (int)BlueStonez.label_interparkmed_10pt_left.CalcSize(new GUIContent(msg.SentDateString)).x;
GUI.Label(new Rect(position.x + position.width - (float)(num3 + num2 + 40), position.y - 16f, (float)(num2 + 2), 12f), msg.SenderName, BlueStonez.label_interparkbold_11pt_left);
GUI.Label(new Rect(position.x + position.width - (float)(num3 + 32), position.y - 15f, (float)(num3 + 2), 12f), msg.SentDateString, BlueStonez.label_interparkmed_10pt_left);
GUI.color = Color.white;
GUI.BeginGroup(position);
GUI.backgroundColor = new Color(0.376f, 0.631f, 0.886f, 0.5f);
if (ApplicationDataManager.IsMobile)
{
GUI.Label(new Rect(position.width - position.width, 0f, position.width, (float)num), msg.Content, BlueStonez.speechbubble_right);
}
else
{
GUI.TextArea(new Rect(position.width - position.width, 0f, position.width, (float)num), msg.Content, BlueStonez.speechbubble_right);
}
GUI.backgroundColor = Color.white;
GUI.EndGroup();
return(num);
}
public void GetMessage_WithId_ReturnsSentMessage()
{
// Arrange
Guid id = Guid.NewGuid();
RestResource resource = new MessageHeadersResource(id);
RestResponse response = new RestResponse()
{
StatusCode = HttpStatusCode.OK,
Content = "serialisedItem"
};
InboxMessage expectedResult = new InboxMessage();
mockRestClient
.Setup(rc => rc.Get(resource))
.Returns(response);
mockSerialiser
.Setup(s => s.Deserialise <InboxMessage>(response.Content))
.Returns(expectedResult);
// Act
InboxMessage actualResult = service.GetMessage(id);
// Assert
Assert.AreEqual(expectedResult, actualResult);
}
public async Task ReceiveViaInbox <TMessage>(TMessage message, IMessageBrokerContext messageBrokerContext, Func <Task> handler)
{
var messageId = messageBrokerContext.BrokeredMessage.MessageId;
if (string.IsNullOrWhiteSpace(messageId))
{
throw new ArgumentException("Message id to be processed cannot be empty.", nameof(messageId));
}
var inbox = _context.Set <InboxMessage>();
if (await inbox.AnyAsync(m => m.MessageId == messageId))
{
return;
}
//TODO: this whole class needs to be cleaned up and needs logging.
try
{
await handler();
var inboxMessage = new InboxMessage()
{
MessageId = messageId,
ReceivedByInboxAtUtc = DateTime.UtcNow
};
await inbox.AddAsync(inboxMessage);
}
catch (Exception ex)
{
throw;
}
}
/// <summary>
/// Обработчик сообщения.
/// </summary>
/// <param name="mes"></param>
public void ProcessCurrentMessage(InboxMessage mes)
{
//Проверим пользователя если вдруг его нет в базе, то добавить его.
this.Methods.CheckUserBeforeMessageProcess(mes.ChatId);
//запускаем метод из PullMethods для получения текущего состояния пользователя
State currentChatState = Methods.GetUserCurrentChatState(mes.ChatId);
//Получим тип состояния.
string typeName = this.Reflection.StatesNamespace.Trim(' ', '.') + "." + currentChatState.Name;
Type type = this.Reflection.Assembly.GetType(typeName, false);
if (type == null)
{
throw new NullReferenceException($"Не найден тип состояния [{typeName}]");
}
//Создадим экземпляр класса состояния и вызовем метод обработки сообщения у экземпляра класса
object instance = Activator.CreateInstance(type, currentChatState);
//ProcessMessage - название абстрактного метода в классе BaseState
MethodInfo method = type.GetMethod("ProcessMessage");
//Запускаем метод обработки входящего сообщения, получаем переход после обработки. Переход может быть нулевым.
Hop hop = method?.Invoke(instance, new object[] { mes.Bot, mes }) as Hop;
if (hop != null && string.IsNullOrEmpty(hop?.NextStateName?.Trim(' ')) == false)
{
this.Methods.ChangeCurrentChatState(mes.Bot, mes.ChatId, currentChatState, hop);
}
}
// Token: 0x06000B76 RID: 2934 RVA: 0x0004975C File Offset: 0x0004795C
public int DrawMessageList(int y, int scrollRectWidth, float scrollRectHeight, float curScrollY)
{
for (int i = this._messages.Values.Count - 1; i >= 0; i--)
{
InboxMessage msg = this._messages.Values[i];
y += this.DrawContent(msg, y + 12, scrollRectWidth) + 16;
}
if (this._messages.Count == 0)
{
GUI.Label(new Rect(0f, (float)y, (float)scrollRectWidth, 100f), "This thread is empty", BlueStonez.label_interparkbold_13pt);
}
else
{
float num = (float)y - scrollRectHeight;
num = Mathf.Clamp(num, 0f, num);
if (curScrollY >= num && this._threadView.MessageCount > this._messages.Count && !this.IsLoading)
{
this._curPageIndex++;
Singleton <InboxManager> .Instance.LoadMessagesForThread(this, this._curPageIndex);
}
}
if (this.IsLoading)
{
GUI.Label(new Rect(0f, (float)y, (float)scrollRectWidth, 30f), "Loading messages...", BlueStonez.label_interparkbold_13pt);
y += 30;
}
return(y);
}
/// <summary>
/// Handle the Send button. At this point we assume there are valid recipients and something
/// in the message body. We really ought to do some validation of the recipient names here.
/// </summary>
/// <param name="sender">The new message form</param>
/// <param name="e">Event arguments</param>
private void nmSend_Click(object sender, EventArgs e)
{
if (_currentConversation == null)
{
_currentConversation = new InboxConversation
{
Subject = nmSubject.Text,
Author = CIX.Username,
Date = DateTime.UtcNow.UTCToGMTBST()
};
}
if (_currentMessage == null)
{
_currentMessage = new InboxMessage
{
Author = (_currentConversation.ID > 0) ? CIX.Username : nmRecipients.Text,
Body = nmMessage.Text,
ConversationID = _currentConversation.ID,
Date = DateTime.UtcNow.UTCToGMTBST()
};
CIX.ConversationCollection.Add(_currentConversation, _currentMessage);
}
DialogResult = DialogResult.OK;
Close();
}
/// <summary>
/// Adds the inbox message.
/// </summary>
/// <param name="senderId">Sender identifier.</param>
/// <param name="receiverId">Receiver identifier.</param>
/// <param name="title">Title.</param>
/// <param name="content">Content.</param>
public void AddInboxMessage(string senderId, string receiverId, string title, string content)
{
InboxMessage newMsg = new InboxMessage(GenerateNewId(), senderId, receiverId, title, content);
_allInboxMessages.Add(newMsg);
Save();
}
// Token: 0x06000B77 RID: 2935 RVA: 0x00009054 File Offset: 0x00007254
public int DrawContent(InboxMessage msg, int y, int width)
{
if (msg.IsMine)
{
return(this.DrawMyMessage(msg, 100, y, width - 100));
}
return(this.DrawOtherMessage(msg, 0, y, width - 100));
}
/// <summary>
/// Add a new conversation with a given message.
/// </summary>
/// <param name="conversation">The conversation to which the message is to be added</param>
/// <param name="message">The message to be added to the conversation</param>
public void Add(InboxConversation conversation, InboxMessage message)
{
if (conversation.RemoteID == 0)
{
Add(conversation);
}
message.ConversationID = conversation.ID;
conversation.Messages.AddInternal(message);
NotifyConversationAdded(conversation);
}
private void Update(InboxMessage message)
{
var idx = Messages.FindIndex(m => m.id == message.id);
if (idx >= 0)
{
Messages[idx] = message;
}
else
{
Messages.Add(message);
}
}
public InboxMessageViewModel CreateModel(InboxMessage inboxMessage, UserProfile sender)
{
var message = _generalMessageViewModelFactory.CreateModel(inboxMessage, sender);
var invite = (WatchGroupInviteMessage)inboxMessage;
var appendix = new WatchGroupInviteViewModel
{
GroupId = invite.GroupId,
GroupTitle = invite.GroupTitle,
};
message.Appendix = appendix;
return(message);
}
public async Task <IActionResult> Accept([FromBody] WatchGroupInviteResponseForm responseForm)
{
var user = await _userManager.GetUserAsync(HttpContext.User);
var message = await _ctx.InboxMessages.FindAsync(responseForm.MessageId) as WatchGroupInviteMessage;
if (message == null || responseForm.InviterId != message.SenderId || user.Id != message.ReceiverId)
{
return(BadRequest());
}
var response = new InboxMessage
{
MessageType = MessageType.General,
Title = $"Message from {user.UserName}",
SenderId = user.Id,
DateSend = DateTime.Now,
ReceiverId = message.SenderId,
};
if (responseForm.Accepted)
{
var watchGroup = _ctx.WatchGroups
.Where(x => x.Id == message.GroupId)
.Include(x => x.Members)
.FirstOrDefault();
if (watchGroup == null)
{
return(BadRequest());
}
watchGroup.Members.Add(new WatchGroupUserProfile
{
WatchGroupId = watchGroup.Id,
UserProfileId = user.Id,
});
response.Description = $"{user.UserName} has accepted your invite";
}
else
{
response.Description = $"{user.UserName} has declined your invite";
}
_ctx.InboxMessages.Add(response);
_ctx.InboxMessages.Remove(message);
_ctx.SaveChanges();
return(Ok());
}
public override Hop ProcessMessage(TelegramBotClient bot, InboxMessage mes)
{
switch (mes.Type)
{
case MessageType.Text:
return(this.State.HopOnSuccess);
break;
}
return(null);
//base.ProcessMessageForState(db, mes, user);
}
private InboxMessage GetMessageModel(MessageReceiver mr, User sender)
{
InboxMessage inboxMessage = new InboxMessage();
inboxMessage.SenderEmailAddress = sender.EmailAddress;
inboxMessage.SenderName = sender.Name;
inboxMessage.SenderSurname = sender.Surname;
inboxMessage.Subject = mr.Message.Subject;
inboxMessage.Content = mr.Message.Content;
inboxMessage.Date = mr.Message.SendDate;
inboxMessage.IsRead = mr.Read;
inboxMessage.Id = mr.MessageId;
string date, dateDetail;
DateTime actualDate = DateTime.Now;
inboxMessage.DateDay = mr.Message.SendDate.ToString("dd'/'MM'/'yyyy");
if (inboxMessage.Date.Month != actualDate.Month || inboxMessage.Date.Day != actualDate.Day)
{
date = inboxMessage.Date.Day + " " + Month(inboxMessage.Date.Month);
if (inboxMessage.Date.Year != actualDate.Year)
{
date = date + " " + inboxMessage.Date.Year;
}
dateDetail = date + ", " + inboxMessage.Date.Hour + ":" + inboxMessage.Date.Minute;
}
else
{
date = "Today, " + inboxMessage.Date.Hour + ":" + inboxMessage.Date.Minute;
dateDetail = date;
}
inboxMessage.DateView = date;
inboxMessage.DateDetail = dateDetail;
string content;
if (inboxMessage.Content.Length > 20)
{
content = inboxMessage.Content.Substring(0, 20) + "...";
}
else
{
content = inboxMessage.Content;
}
inboxMessage.ContentView = content;
inboxMessage.Link = "Message?id=" + inboxMessage.Id;
return(inboxMessage);
}
/// <summary>
/// This notification is triggered if a mugshot is updated from the server. We use this
/// to refresh the images shown in the root message list.
/// </summary>
private void OnMugshotUpdated(object sender, MugshotEventArgs e)
{
Platform.UIThread(this, delegate
{
// Update in the thread list.
foreach (InboxItem item in inboxMessagePane.Items.Cast <InboxItem>())
{
InboxMessage message = item.Message;
if (message.Author == e.Mugshot.Username)
{
item.Image = e.Mugshot.RealImage;
item.Invalidate();
}
}
});
}
public InboxMessageViewModel CreateModel(InboxMessage inboxMessage, UserProfile sender)
{
return(new InboxMessageViewModel
{
MessageId = inboxMessage.Id,
MessageType = inboxMessage.MessageType,
Title = inboxMessage.Title,
Description = inboxMessage.Description,
Sender = new UserProfileViewModel
{
UserName = sender.UserName,
Id = sender.Id,
AvatarUrl = AppHttpContext.AppBaseUrl + "/api/profile/picture/" + sender.Id,
},
DateSend = inboxMessage.DateSend,
});
}
public override Hop ProcessMessage(TelegramBotClient bot, InboxMessage mes)
{
switch (mes.Type)
{
case MessageType.Text:
bot.SendTextMessageAsync(mes.ChatId, State.AnswerOnSuccess);
return(State.HopOnSuccess);
break;
default:
break;
}
return(null);
}
/// <summary>
/// Receives a message and verifies if it's been handled previously by checking the inbox
/// </summary>
/// <typeparam name="TMessage">The type of message being received</typeparam>
/// <param name="message">The message being received</param>
/// <param name="messageBrokerContext">The brokered message context received with the message</param>
/// <param name="handler">The message handler to be executed if the message is not found within the inbox</param>
/// <returns>An awaitable task</returns>
public async Task ReceiveViaInbox <TMessage>(TMessage message, IMessageBrokerContext messageBrokerContext, Func <Task> handler)
{
var messageId = messageBrokerContext?.BrokeredMessage?.MessageId;
if (string.IsNullOrWhiteSpace(messageId))
{
_logger.LogDebug("Unable to receve message using inbox because message id is null or whitespace. Executing handler.");
await handler();
return;
}
_logger.LogTrace($"Checking inbox for brokered message with message id '{messageId}'.");
var inbox = _context.Set <InboxMessage>();
if (await inbox.AnyAsync(m => m.MessageId == messageId))
{
_logger.LogTrace($"Message with id '{messageId}' found in inbox. Message will not be handled.");
return;
}
try
{
_logger.LogDebug("Executing message handler from inbox");
await handler();
var inboxMessage = new InboxMessage()
{
MessageId = messageId,
ReceivedByInboxAtUtc = DateTime.UtcNow
};
_logger.LogDebug("Message handler executed successfully from inbox");
_logger.LogTrace($"Adding inbox message with id '{inboxMessage.MessageId}' and date received '{inboxMessage.ReceivedByInboxAtUtc}'.");
await inbox.AddAsync(inboxMessage);
_logger.LogTrace($"Message with id '{messageId}' added to inbox.");
}
catch (Exception ex)
{
_logger.LogTrace($"Error adding message with id '{messageId}' to inbox: {ex.StackTrace}");
throw;
}
}
/// <summary>
/// Retrieve an entire conversation. Any new messages are added to the message set and
/// an event is fired.
/// </summary>
/// <param name="root">The root message to which this conversation belongs</param>
/// <param name="latestMesssageDate">Ref to a DateTime that is set to the date of the
/// most recent message in this conversation</param>
/// <returns>The number of messages retrieved</returns>
private static int GetConversation(InboxConversation root, ref DateTime latestMesssageDate)
{
int countOfRead = 0;
try
{
HttpWebRequest request = APIRequest.Get("personalmessage/" + root.RemoteID + "/message", APIRequest.APIFormat.XML);
Stream objStream = APIRequest.ReadResponse(request);
if (objStream != null)
{
using (XmlReader reader = XmlReader.Create(objStream))
{
XmlSerializer serializer = new XmlSerializer(typeof(PMessageSet));
PMessageSet inboxSet = (PMessageSet)serializer.Deserialize(reader);
foreach (CIXInboxMessage message in inboxSet.PMessages)
{
if (!root.Messages.Contains(message.MessageID))
{
InboxMessage newMessage = new InboxMessage
{
ConversationID = root.ID,
RemoteID = message.MessageID,
Body = message.Body,
Date = DateTime.Parse(message.Date),
Author = message.Sender
};
root.Messages.AddInternal(newMessage);
if (newMessage.Date > latestMesssageDate)
{
latestMesssageDate = newMessage.Date;
}
++countOfRead;
}
}
}
}
}
catch (Exception e)
{
CIX.ReportServerExceptions("ConversationCollection.GetConversation", e);
}
return(countOfRead);
}
private void ProcessInbox(DRequestCompletedEventArgs e, string QId)
{
try
{
JsonObject JDef = JsonStatus.Parse(e.ResponseString);
JsonArray JData = JDef.GetNamedArray("data");
foreach (JsonValue JItem in JData)
{
InboxMessage BoxMessage = new InboxMessage(JItem.GetObject());
Member.Activities.AddUI(new Activity(BoxMessage.Name, BoxMessage.OpenComment)
{
TimeStamp = BoxMessage.TimeStamp
});
}
}
catch (Exception)
{
}
}
/// <summary>
/// Sets the inbox item info.
/// </summary>
/// <param name="msg">Message.</param>
public void SetInboxItemInfo(InboxMessage msg)
{
messageId = msg.messageId;
titleLabel.text = msg.title;
messageLabel.text = msg.content;
senderLabel.text = "From " + msg.senderId;
isRead = msg.isRead;
if (!msg.isRead)
{
baseSprite.color = unReadColor;
notifySprite.enabled = true;
}
else
{
notifySprite.enabled = false;
}
}
public async Task <bool> SendInboxMessage(InboxMessageDto message)
{
InboxMessage im = new InboxMessage
{
SenderId = message.SenderId,
SenderName = message.SenderName,
SenderTeam = message.SenderTeam,
ReceiverId = message.ReceiverId,
ReceiverName = message.ReceiverName,
ReceiverTeam = message.ReceiverTeam,
Subject = message.Subject,
Body = message.Body,
MessageDate = message.MessageDate,
IsNew = message.IsNew
};
await _context.AddAsync(im);
return(await _context.SaveChangesAsync() > 1);
}
private InboxMessageViewModel MapInboxMessage(InboxMessage inboxMessage, UserProfile sender)
{
IMessageViewModelFactory factory;
switch (inboxMessage.MessageType)
{
case MessageType.General:
factory = new GeneralMessageViewModelFactory();
break;
case MessageType.WatchGroupInvite:
factory = new InviteMessageViewModelFactory();
break;
default:
return(null);
}
return(factory.CreateModel(inboxMessage, sender));
}
public void SetMessage(InboxMessage m)
{
message = m;
description.text = message.message;
message.items.ForEach(item =>
{
var prefab = Instantiate(itemPrefab, itemsCanvas);
prefab.SetInboxItem(item, itemsCanvas.rect.height);
});
claimButton.AddClickListener(() =>
{
claimButton.ShowIndicator();
inboxService.Claim(message, data =>
{
Destroy(gameObject);
});
});
CheckClaimButton();
signalBus.Subscribe <ResourcesSignal>(CheckClaimButton);
}
public IActionResult Inbox()
{
List <System.Security.Claims.Claim> c = User.Claims.Where(x => x.Type.Contains("mail")).ToList();
string email = c[0].Value;
int id = context.GetUserId(email);
List <InboxMessage> inboxMessages = new List <InboxMessage>();
InboxViewModel inboxViewModel = new InboxViewModel();
List <string> dates = new List <string>();
List <MessageReceiver> messageReceivers = context.MessageReceivers.Where(x => x.UserId == id).ToList();
foreach (var mr in messageReceivers)
{
int senderId = context.Messages.Where(x => x.Id == mr.MessageId).ToList()[0].SenderId;
User sender = context.Users.Where(x => x.Id == senderId).ToList()[0];
InboxMessage inboxMessage = GetMessageModel(mr, sender);
inboxMessages.Add(inboxMessage);
if (!dates.Contains(inboxMessage.DateDay))
{
dates.Add(inboxMessage.DateDay);
}
}
dates.Reverse();
inboxMessages.Sort((m1, m2) => m1.Date.CompareTo(m2.Date));
inboxMessages.Reverse();
inboxViewModel.inboxMessages = inboxMessages;
inboxViewModel.dates = dates;
return(View(inboxViewModel));
}
public IActionResult Message(int id)
{
List <System.Security.Claims.Claim> c = User.Claims.Where(x => x.Type.Contains("mail")).ToList();
string email = c[0].Value;
int userId = context.GetUserId(email);
context.MessageReceivers.Where(x => x.MessageId == id && x.UserId == userId).ToList()[0].Read = true;
context.SaveChanges();
MessageReceiver mr = context.MessageReceivers.Where(x => x.MessageId == id && x.UserId == userId).ToList()[0];
int senderId = context.Messages.Where(x => x.Id == mr.MessageId).ToList()[0].SenderId;
User sender = context.Users.Where(x => x.Id == senderId).ToList()[0];
InboxMessage message = GetMessageModel(mr, sender);
string cc = "";
if (mr.ReceiveType != 2)
{
foreach (MessageReceiver m in context.MessageReceivers.Where(x => x.MessageId == mr.MessageId && x.UserId != userId && x.ReceiveType == 1).ToList())
{
User u = context.Users.Where(x => x.Id == m.UserId).ToList()[0];
cc += u.Name + " " + u.Surname + " <" + u.EmailAddress + ">, ";
}
if (cc.Length > 0)
{
cc = cc.Substring(0, cc.Length - 2);
}
}
message.CC = cc;
MessageViewModel messageViewModel = new MessageViewModel();
messageViewModel.message = message;
return(View(messageViewModel));
}
async Task <InboxMessageBox> ReloadInternalAsync(bool all, IEnumerable <string>?targetChannelIDs, CancellationToken cancel)
{
List <InboxMessage> msgList = new List <InboxMessage>();
// Team info
this.TeamInfo = await Api !.GetTeamInfoAsync(cancel);
currentAccountInfoStr = this.TeamInfo.name;
if (all)
{
// Enum users
this.UserList = await Api.GetUsersListAsync(cancel);
// Clear cache
this.MessageListPerConversation.Clear();
// Muted channels list
this.MutedChannelList = await Api.GetMutedChannels(cancel);
}
// Enum conversations
this.ConversationList = await Api.GetConversationsListAsync(cancel);
if (LastSnapshotDay != DateTime.Now.Day)
{
LastSnapshotDay = DateTime.Now.Day;
SlackSnapshot snapshot = new SlackSnapshot
{
TeamInfo = this.TeamInfo,
UserList = this.UserList,
ConversationList = this.ConversationList,
MutedChannelList = this.MutedChannelList,
};
snapshot._PostData("slack_snapshot");
}
// Enum messages
foreach (var conv in ConversationList)
{
if (conv.id._IsFilled())
{
bool reload = false;
if (conv.IsTarget())
{
if (all)
{
reload = true;
}
else
{
if (targetChannelIDs !.Contains(conv.id, StrComparer.IgnoreCaseComparer))
{
reload = true;
}
}
if (MutedChannelList != null && MutedChannelList.Where(x => x._IsSamei(conv.id)).Any())
{
reload = false;
}
}
if (reload)
{
// Get the conversation info
SlackApi.Channel convInfo = await Api.GetConversationInfoAsync(conv.id, cancel);
// Get unread messages
SlackApi.Message[] messages = await Api.GetConversationHistoryAsync(conv.id, convInfo.last_read, this.Inbox.Options.MaxMessagesPerAdapter, cancel : cancel);
MessageListPerConversation[conv.id] = messages;
}
if (conv.IsTarget())
{
if (MessageListPerConversation.TryGetValue(conv.id, out SlackApi.Message[]? messages))
{
foreach (SlackApi.Message message in messages)
{
var user = GetUser(message.user);
string group_name = "";
if (conv.is_channel)
{
group_name = "#" + conv.name_normalized;
}
else if (conv.is_im)
{
group_name = "@" + GetUser(conv.user)?.profile?.real_name ?? "unknown";
}
else
{
group_name = "@" + conv.name_normalized;
}
InboxMessage m = new InboxMessage
{
Id = this.Guid + "_" + message.ts.ToString(),
Service = TeamInfo.name._DecodeHtml(),
FromImage = TeamInfo.icon?.image_132 ?? "",
From = (user?.profile?.real_name ?? "Unknown User")._DecodeHtml(),
ServiceImage = user?.profile?.image_512 ?? "",
Group = group_name._DecodeHtml(),
Body = message.text._DecodeHtml(),
Timestamp = message.ts._ToDateTimeOfSlack(),
};
m.Subject = this.TeamInfo.name._DecodeHtml();
m.Body = m.Body._SlackExpandBodyUsername(this.UserList);
if (message.upload)
{
m.Body += $"Filename: '{message.files!.FirstOrDefault()?.name ?? "Unknown Filename"}'";
}
msgList.Add(m);
}
}
}
}
}
InboxMessageBox ret = new InboxMessageBox(false)
{
MessageList = msgList.OrderByDescending(x => x.Timestamp).Take(this.Inbox.Options.MaxMessagesPerAdapter).ToArray(),
};
int numUnread = ret.MessageList.Length;
if (this.LastUnread != numUnread)
{
this.LastUnread = numUnread;
SlackStatus st = new SlackStatus
{
NumUnreadMessages = numUnread,
TeamInfo = this.TeamInfo,
};
st._PostData("slack_status");
}
ClearLastError();
if (numReload == 0)
{
ret.IsFirst = true;
}
numReload++;
return(ret);
}
/// <summary>
/// Обработчик события сообщения.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private void ProcessMessage(object sender, MessageEventArgs args)
{
InboxMessage mes = new InboxMessage(this.Bot.TelegramClient, args.Message);
proc.ProcessCurrentMessage(mes);
}
private void ProcessInbox( DRequestCompletedEventArgs e, string QId )
{
try
{
JsonObject JDef = JsonStatus.Parse( e.ResponseString );
JsonArray JData = JDef.GetNamedArray( "data" );
foreach( JsonValue JItem in JData )
{
InboxMessage BoxMessage = new InboxMessage( JItem.GetObject() );
AddActivity( new Activity( BoxMessage.Name, BoxMessage.OpenComment )
{
TimeStamp = BoxMessage.TimeStamp
} );
}
NotifyChanged( "Activities" );
}
catch( Exception )
{
}
}
public async Task <IActionResult> SendMessage(MessageToSendDto messageToSendDto)
{
int userId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
var user = await _repo.Find(x => x.Id == userId);
if (user.Status == UserStatus.inactive)
{
return(BadRequest("!!Your Account is inactive You cant's Send Messages "));
}
var users = await _repo.List();
string encryptedSubject = SecurityHelper.EncryptString(key, messageToSendDto.Subject);
string encryptedContent = SecurityHelper.EncryptString(key, messageToSendDto.Content);
if (await _permissionValidation.ValidatToGetDistanation(user.Id) == 1 || await _permissionValidation.ValidatToGetDistanation(user.Id) == 3)
{
var getAllUser = (from u in users
//join od in await _userRuleRepo.List() on u.RuleId equals od.RuleId
select new
{
u.Id,
u.Email
}).ToList();
var Msg = new Message
{
Subject = encryptedSubject,
Content = encryptedContent,
Date = DateTime.Now,
};
var builtmessage = await _messageRepo.Add(Msg);
foreach (var item in getAllUser)
{
var inboxMsg = new InboxMessage
{
message = builtmessage,
MessageFrom = user.Email,
UserId = item.Id,
MessageId = builtmessage.Id
};
var inboxedMessage = await _inboxRepo.Add(inboxMsg);
var sentMsg = new SentMessage
{
message = builtmessage,
MessageId = builtmessage.Id,
MessageTo = item.Email,
UserId = user.Id
};
var sentMessage = await _sentRepo.Add(sentMsg);
}
return(Ok("MESSAGE SENT TO ALL USERS"));
}
else if (await _permissionValidation.ValidatToGetDistanation(user.Id) == 4 || await _permissionValidation.ValidatToGetDistanation(user.Id) == 5)
{
var allAvailableDestination = (from d in await _distinationRepo.List()
where d.UserID == user.Id
select new
{
d.DestinationUserId,
}).ToList();
var Msg = new Message
{
Subject = encryptedSubject,
Content = encryptedContent,
Date = DateTime.Now,
};
var builtmessage = await _messageRepo.Add(Msg);
foreach (var item in allAvailableDestination)
{
var inboxMsg = new InboxMessage
{
message = builtmessage,
MessageFrom = user.Email,
UserId = item.DestinationUserId,
MessageId = builtmessage.Id
};
var inboxedMessage = await _inboxRepo.Add(inboxMsg);
var emailreciver = await _repo.Find(x => x.Id == item.DestinationUserId);
var sentMsg = new SentMessage
{
message = builtmessage,
MessageId = builtmessage.Id,
MessageTo = emailreciver.Email,
UserId = user.Id
};
var sentMessage = await _sentRepo.Add(sentMsg);
}
return(Ok("MESSAGE SENT TO The Specific USERS"));
}
else
{
return(Unauthorized("You don't any permission to Send message"));
}
}
public void Claim(InboxMessage message, Action <PlayerActionResponse> onSuccess = null)
{
serverAPI.DoPost($"/inbox/claim/{message.id}", null, onSuccess);
}
