public async Task <ActionResult> View(int id)
{
var user = _userRetrievalShim.GetUser();
if (user == null)
{
return(StatusCode(403));
}
var pm = await _privateMessageService.Get(id);
if (await _privateMessageService.IsUserInPM(user, pm) == false)
{
return(StatusCode(403));
}
var posts = await _privateMessageService.GetPosts(pm);
var model = new PrivateMessageView
{
PrivateMessage = pm,
Posts = posts
};
await _privateMessageService.MarkPMRead(user, pm);
return(View(model));
}
// Token: 0x06001073 RID: 4211 RVA: 0x00014D00 File Offset: 0x00012F00
public static void Serialize(Stream stream, PrivateMessageView instance)
{
int num = 0;
using (MemoryStream memoryStream = new MemoryStream())
{
if (instance.ContentText != null)
{
StringProxy.Serialize(memoryStream, instance.ContentText);
}
else
{
num |= 1;
}
DateTimeProxy.Serialize(memoryStream, instance.DateSent);
Int32Proxy.Serialize(memoryStream, instance.FromCmid);
if (instance.FromName != null)
{
StringProxy.Serialize(memoryStream, instance.FromName);
}
else
{
num |= 2;
}
BooleanProxy.Serialize(memoryStream, instance.HasAttachment);
BooleanProxy.Serialize(memoryStream, instance.IsDeletedByReceiver);
BooleanProxy.Serialize(memoryStream, instance.IsDeletedBySender);
BooleanProxy.Serialize(memoryStream, instance.IsRead);
Int32Proxy.Serialize(memoryStream, instance.PrivateMessageId);
Int32Proxy.Serialize(memoryStream, instance.ToCmid);
Int32Proxy.Serialize(stream, ~num);
memoryStream.WriteTo(stream);
}
}
// Token: 0x06000B17 RID: 2839 RVA: 0x00008DA7 File Offset: 0x00006FA7
private void AddMessage(PrivateMessageView privateMessage)
{
if (privateMessage != null)
{
this.AddMessageToThread(privateMessage.FromCmid, privateMessage);
}
else
{
Debug.LogError("AddMessage called with NULL message");
}
}
// Token: 0x06000B16 RID: 2838 RVA: 0x000477A8 File Offset: 0x000459A8
private void OnPrivateMessageSent(int threadId, PrivateMessageView privateMessage)
{
if (privateMessage != null)
{
AutoMonoBehaviour <CommConnectionManager> .Instance.Client.Lobby.Operations.SendUpdateInboxMessages(privateMessage.ToCmid, privateMessage.PrivateMessageId);
privateMessage.IsRead = true;
this.AddMessageToThread(threadId, privateMessage);
}
else
{
Debug.LogError("PrivateMessage sending failed");
PopupSystem.ShowMessage(LocalizedStrings.Error, LocalizedStrings.YourMessageHasNotBeenSent);
}
}
// Token: 0x06000B18 RID: 2840 RVA: 0x00047810 File Offset: 0x00045A10
private void AddMessageToThread(int threadId, PrivateMessageView privateMessage)
{
InboxThread inboxThread;
if (!this._allThreads.TryGetValue(threadId, out inboxThread))
{
inboxThread = new InboxThread(new MessageThreadView
{
ThreadName = privateMessage.FromName,
ThreadId = threadId
});
this._allThreads.Add(inboxThread.ThreadId, inboxThread);
this._sortedAllThreads.Add(inboxThread);
}
inboxThread.AddMessage(privateMessage);
this.UpdateNewMessageCount();
}
// Token: 0x06000B7B RID: 2939 RVA: 0x00049BD8 File Offset: 0x00047DD8
internal void AddMessage(PrivateMessageView message)
{
if (!this._messages.ContainsKey(message.PrivateMessageId))
{
this._messages.Add(message.PrivateMessageId, new InboxMessage(message, (message.FromCmid != PlayerDataManager.Cmid) ? this._threadView.ThreadName : PlayerDataManager.Name));
this._threadView.MessageCount++;
if (!message.IsRead && message.ToCmid == PlayerDataManager.Cmid)
{
this._threadView.HasNewMessages = true;
}
if (message.DateSent > this._threadView.LastUpdate)
{
this._threadView.LastUpdate = message.DateSent;
this._threadView.LastMessagePreview = TextUtilities.ShortenText(message.ContentText, 25, true);
}
}
this.Scroll.y = float.MinValue;
}
// Token: 0x06000D52 RID: 3410 RVA: 0x0005C66C File Offset: 0x0005A86C
public static void ReportInboxPlayer(PrivateMessageView msg, string messageSender)
{
int reportedCmid = msg.FromCmid;
string reason = msg.ContentText;
if (AutoMonoBehaviour <CommConnectionManager> .Instance.Client.IsConnected)
{
PopupSystem.ShowMessage(LocalizedStrings.ReportPlayerCaps, string.Format(LocalizedStrings.ReportPlayerWarningMsg, messageSender), PopupSystem.AlertType.OKCancel, delegate()
{
AutoMonoBehaviour <CommConnectionManager> .Instance.Client.Lobby.Operations.SendPlayersReported(new List <int>
{
reportedCmid
}, 0, reason, Singleton <ChatManager> .Instance.GetAllChatMessagesForPlayerReport());
}, LocalizedStrings.Report, null, LocalizedStrings.Cancel, PopupSystem.ActionType.Negative);
}
else
{
PopupSystem.ShowMessage(LocalizedStrings.Error, LocalizedStrings.ReportPlayerErrorMsg, PopupSystem.AlertType.OK, null);
}
}
// Token: 0x06001074 RID: 4212 RVA: 0x00014DE8 File Offset: 0x00012FE8
public static PrivateMessageView Deserialize(Stream bytes)
{
int num = Int32Proxy.Deserialize(bytes);
PrivateMessageView privateMessageView = new PrivateMessageView();
if ((num & 1) != 0)
{
privateMessageView.ContentText = StringProxy.Deserialize(bytes);
}
privateMessageView.DateSent = DateTimeProxy.Deserialize(bytes);
privateMessageView.FromCmid = Int32Proxy.Deserialize(bytes);
if ((num & 2) != 0)
{
privateMessageView.FromName = StringProxy.Deserialize(bytes);
}
privateMessageView.HasAttachment = BooleanProxy.Deserialize(bytes);
privateMessageView.IsDeletedByReceiver = BooleanProxy.Deserialize(bytes);
privateMessageView.IsDeletedBySender = BooleanProxy.Deserialize(bytes);
privateMessageView.IsRead = BooleanProxy.Deserialize(bytes);
privateMessageView.PrivateMessageId = Int32Proxy.Deserialize(bytes);
privateMessageView.ToCmid = Int32Proxy.Deserialize(bytes);
return(privateMessageView);
}
public ViewResult View(int id)
{
var user = this.CurrentUser();
if (user == null)
{
return(this.Forbidden("Forbidden", null));
}
var pm = _privateMessageService.Get(id);
if (!_privateMessageService.IsUserInPM(user, pm))
{
return(this.Forbidden("Forbidden", null));
}
var model = new PrivateMessageView
{
PrivateMessage = pm,
Posts = _privateMessageService.GetPosts(pm)
};
_privateMessageService.MarkPMRead(user, pm);
return(View(model));
}
public ActionResult View(int id)
{
var user = _userRetrievalShim.GetUser(HttpContext);
if (user == null)
{
return(Forbid());
}
var pm = _privateMessageService.Get(id);
if (!_privateMessageService.IsUserInPM(user, pm))
{
return(Forbid());
}
var model = new PrivateMessageView
{
PrivateMessage = pm,
Posts = _privateMessageService.GetPosts(pm)
};
_privateMessageService.MarkPMRead(user, pm);
return(View(model));
}
// Token: 0x06000B49 RID: 2889 RVA: 0x00008ECB File Offset: 0x000070CB
public InboxMessage(PrivateMessageView view, string senderName)
{
this.MessageView = view;
this.SenderName = senderName;
}
public async Task <IHttpActionResult <PrivateMessageView <TUserView> > > Post([FromBody] PrivateMessageView <TUserView> value)
{
var account = await accountService.GetCurrentUserAsync();
if (account == null)
{
return(Unauthorized <PrivateMessageView <TUserView> >());
}
if (value.AccountRecipients.Count == 0)
{
return(BadRequest <PrivateMessageView <TUserView> >("Aucun destinataire"));
}
using (var transaction = session.BeginTransaction())
{
var recipientAccounts = await accountService.GetUsersAsync(value.AccountRecipients);
var html = await htmlSanitizerService.Sanitize(value.Text, account);
var privateMessage = new PrivateMessage <TUser>
{
Author = account,
Text = html,
Title = value.Title
};
session.Save(privateMessage);
var recipients = new List <PrivateMessageRecipient <TUser> >();
foreach (var recipientAccount in recipientAccounts)
{
var recipient = new PrivateMessageRecipient <TUser>
{
PrivateMessage = privateMessage,
Recipient = recipientAccount
};
recipients.Add(recipient);
await session.SaveAsync(recipient);
}
privateMessage.Recipients = recipients;
transaction.Commit();
return(Created("GetPrivateMessage", value.Id, forumsDataMapping.ToPrivateMessageView(privateMessage)));
}
}
