public async Task <IEnumerable <ChatView <TUserView> > > GetAll([FromQuery] int offset = 0)
{
var account = await userService.GetCurrentUserAsync();
if (account != null && offset == 0)
{
using (var transaction = session.BeginTransaction())
{
var myLastChat = await queryLastChatViewByAccount.Build(session, account).FirstOrDefaultAsync();
var lastChat = await queryLastChats.Build(session).FirstOrDefaultAsync();
if (myLastChat == null)
{
myLastChat = new LastChatView <TUser> {
Account = account, Chat = lastChat
};
await session.SaveAsync(myLastChat);
transaction.Commit();
}
else if (lastChat != myLastChat.Chat)
{
myLastChat.Chat = lastChat;
await session.UpdateAsync(myLastChat);
transaction.Commit();
}
}
}
return((await queryChats.Build(session, offset).ToListAsync()).Select(c => chatDataMapping.ToChatDto(c)));
}
public async Task <IEnumerable <ForumView> > GetAll()
{
var account = await userService.GetCurrentUserAsync();
var query = await session.SelectAllFrom <Data.Forums.Forum>().OrderBy(f => f.Name).Asc().ToListAsync();
var forums = new List <Data.Forums.Forum>();
foreach (var q in query)
{
if (q.ReadRole == null || await userService.HasRole(account, q.ReadRole))
{
forums.Add(q);
}
}
if (account != null && forums.Any())
{
var lastViewed = await session.SelectAllFrom <LastForumView <TUser> >().Where(l => l.Account.Equals(account)).Where(l => l.Forum.In(forums.ToArray())).ToListAsync();
var dto = new List <ForumView>();
foreach (var forum in forums)
{
var numberOfNewMessages = await GetForumNewMessages(forum, lastViewed);
dto.Add(forumDataMapping.ToForumView(forum, numberOfNewMessages));
}
return(dto);
}
return(forums.Select(f => forumDataMapping.ToForumView(f, 0)));
}
public async Task <IHttpActionResult <PollAndVoteView <TUserView> > > GetPollAndVote(int id)
{
var account = await accountService.GetCurrentUserAsync();
var poll = await session.Select <PollAndVote>().All(x => x.Poll).All(x => x.Answer).From(x => x.Poll).LeftJoin(x => x.Answer).On(x => x.Poll == x.Answer.Poll).AndOn(x => x.Answer.Account.Equals(account)).Where(x => x.Poll.Id == id).SingleOrDefaultAsync();
if (poll == null || poll.Poll.Deleted)
{
return(NotFound <PollAndVoteView <TUserView> >());
}
return(Ok(pollDataMapping.ToPollAndVoteDto(poll.Poll, poll.Answer)));
}
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)));
}
}
public async Task <IHttpActionResult <PhotoView> > PostFormData()
{
var form = Request.Form;
var files = form.Files["files"];
using (var transaction = session.BeginTransaction())
{
var md5 = MD5.Create();
var bytes = new byte[files.Length];
using (var stream = files.OpenReadStream())
{
stream.Read(bytes, 0, bytes.Length);
}
var baseName = BitConverter.ToString(md5.ComputeHash(bytes));
var memoryStream = new MemoryStream(bytes);
var fullSizeImage = new Image(memoryStream);
var imageFormat = fullSizeImage.CurrentImageFormat;
var extension = imageFormat.Encoder.Extension;
var localFileName = baseName + "." + extension;
var photo = await session.SelectAllFrom <Photo <TUser> >().Where(i => i.FileName == localFileName).FirstOrDefaultAsync();
if (photo == null)
{
using (var stream = new MemoryStream())
{
fullSizeImage.Save(stream);
ArraySegment <byte> buffer;
if (stream.TryGetBuffer(out buffer))
{
var url = await imageStore.SaveAsync(buffer.Array, stream.Length, localFileName);
photo = new Photo <TUser>
{
CreationTime = DateTime.UtcNow,
FileName = localFileName,
Width = fullSizeImage.Width,
Height = fullSizeImage.Height,
Length = stream.Length,
Url = url,
Uploader = await accountService.GetCurrentUserAsync()
};
await session.SaveAsync(photo);
}
}
}
transaction.Commit();
return(Ok(forumsDataMapping.ToPhotoView(photo)));
}
}
public async Task <IHttpActionResult <IEnumerable <ThreadView <TUserView> > > > GetFromForum(int forumId, [FromQuery] int offset = 0, [FromQuery] int limit = 10)
{
var forum = await session.LoadAsync <Data.Forums.Forum>(forumId);
var account = await accountService.GetCurrentUserAsync();
if (forum.ReadRole != null && !await accountService.HasRole(account, forum.ReadRole))
{
return(Unauthorized <IEnumerable <ThreadView <TUserView> > >());
}
if (account != null)
{
using (var transaction = session.BeginTransaction())
{
var lastViewed = await session.SelectAllFrom <LastForumView <TUser> >().Where(l => l.Forum == forum && l.Account.Equals(account)).FirstOrDefaultAsync();
if (lastViewed == null)
{
lastViewed = new LastForumView <TUser> {
Account = account, Forum = forum, LastView = DateTime.UtcNow
};
await session.SaveAsync(lastViewed);
}
else
{
lastViewed.LastView = DateTime.UtcNow;
await session.UpdateAsync(lastViewed);
}
transaction.Commit();
}
var query = session.Select <ThreadBean>().All(x => x.Thread).All(x => x.LastViewed).All(x => x.Thread.Author).From(x => x.Thread).LeftJoin(x => x.LastViewed).On(x => x.Thread == x.LastViewed.Thread)
.AndOn(t => t.LastViewed.Account.Equals(account))
.LeftJoinOnId(x => x.Thread.Author)
.Where(t => t.Thread.Forum == forum).OrderBy(t => t.Thread.Sticky).Desc().OrderBy(t => t.Thread.CreationDate).Desc().Limit(offset, limit);
var results = await query.ToListAsync();
return(Ok(results.Select(b => forumsDataMapping.ToThreadView(b.Thread, b.LastViewed))));
}
else
{
var query = session.SelectAllFrom <Thread <TUser> >(x => x.Author).Where(t => t.Forum == forum).OrderBy(t => t.Sticky).Desc().OrderBy(t => t.CreationDate).Desc().Limit(offset, limit);
return(Ok((await query.ToListAsync()).Select(t => forumsDataMapping.ToThreadView(t, null))));
}
}
public async Task <IHttpActionResult <PollChosenAnswerView <TUserView> > > AddAnswer(int pollId, [FromBody] PollPossibleAnswerView value)
{
// Checks that provided Poll is visible
var poll = await session.LoadAsync <Poll <TUser> >(pollId);
if (poll.Deleted)
{
return(BadRequest <PollChosenAnswerView <TUserView> >("Deleted poll"));
}
var account = await accountService.GetCurrentUserAsync();
// Checks that account hasn't voted yet
var answers = await session.SelectAllFrom <PollChosenAnswer <TUser> >()
.Where(x => x.Account.Equals(account))
.SingleOrDefaultAsync();
if (answers != null)
{
return(BadRequest <PollChosenAnswerView <TUserView> >("Already answered"));
}
using (var transaction = session.BeginTransaction())
{
var answer = await session.LoadAsync <PollPossibleAnswer <TUser> >(value.Id);
if (answer.Poll != poll)
{
return(BadRequest <PollChosenAnswerView <TUserView> >("Not a possible answer"));
}
var chosenAnswer = new PollChosenAnswer <TUser>
{
Poll = poll,
Answer = answer,
Account = account
};
await session.SaveAsync(chosenAnswer);
answer.Count++;
await session.UpdateAsync(answer);
transaction.Commit();
return(Created("GetPollChosenAnswer", chosenAnswer.Id, pollDataMapping.ToPollChosenAnswerDto(chosenAnswer)));
}
}
public async Task Put(int id, [FromBody] CommentView <TUserView> value)
{
var account = await userService.GetCurrentUserAsync();
using (var transaction = session.BeginTransaction())
{
var comment = await session.LoadAsync <Comment <TUser> >(id);
if (await userService.IsUser(account, comment.Author))
{
comment.Text = value.Text;
await session.UpdateAsync(comment);
transaction.Commit();
}
}
}