public async Task <ServerResponse <bool> > UpdateFriendRequestAsync(long accountId, long personId, EFriendRequestFlag eFriendRequestFlag)
{
return(await BaseInvokeAsync(async() =>
{
var friend = DbContext.Friends.FirstOrDefault(x =>
(x.RequestedById == accountId && x.RequestedToId == personId) ||
(x.RequestedById == personId && x.RequestedToId == accountId));
if (friend == null)
{
throw new NotFoundException(Constants.Errors.FriendNotExists);
}
if (Constants.FriendRequestFlagsWithErrors.ContainsKey(friend.FriendRequestFlag))
{
throw new ConflictException(Constants.FriendRequestFlagsWithErrors[friend.FriendRequestFlag]);
}
friend.FriendRequestFlag = eFriendRequestFlag;
friend.BecameFriendsTime = eFriendRequestFlag == EFriendRequestFlag.Approved ? (DateTime?)DateTime.Now : null;
await DbContext.SaveChangesAsync();
return ServerResponseBuilder.Build(true);
}));
}
public async Task <ServerResponse <PageResult <TagAdminResponse> > > GetAdminTagsByPageAsync(AdminTableFilterRequest adminTableFilterRequest)
{
return(await BaseInvokeAsync(async() =>
{
var query = DbContext.Tags.AsQueryable();
query = FilterAdminTags(query, adminTableFilterRequest);
var tagsCount = query.Count();
query = SortItems(query, adminTableFilterRequest);
query = FetchItems(query, adminTableFilterRequest);
var pageResult = new PageResult <TagAdminResponse>
{
Items = query.Select(x => new TagAdminResponse()
{
Id = x.Id,
Name = x.Name,
Notes = x.NoteTags.Select(y => y.Note.Name).ToArray(),
Tasks = x.MhTaskTags.Select(z => z.MhTask.Name).ToArray()
}).ToList(),
TotalCount = tagsCount
};
return ServerResponseBuilder.Build(await Task.FromResult(pageResult));
}));
}
public async Task <ServerResponse <bool> > InviteFriendAsync(long accountId, long personId)
{
return(await BaseInvokeAsync(async() =>
{
var friend = DbContext.Friends.FirstOrDefault(x =>
(x.RequestedById == accountId && x.RequestedToId == personId) ||
(x.RequestedById == personId && x.RequestedToId == accountId));
if (friend != null)
{
throw new ConflictException(Constants.Errors.RequestsAlreadyExists);
}
var appUser = DbContext.AppUsers.First(x => x.Id == accountId);
var person = DbContext.AppUsers.First(x => x.Id == personId);
friend = new Friend
{
RequestedBy = appUser,
RequestedTo = person,
FriendRequestFlag = EFriendRequestFlag.None,
RequestTime = DateTime.Now
};
await DbContext.Friends.AddAsync(friend);
await DbContext.SaveChangesAsync();
return ServerResponseBuilder.Build(true);
}));
}
public async Task <ServerResponse <List <FeedResponse> > > GetFeedsAsync(long appUserId,
FeedFilterRequest feedFilterRequest, Expression <Func <Feed, bool> > accessPredicate)
{
return(await BaseInvokeAsync(async() =>
{
var query = DbContext.Feeds
.AsQueryable()
.Where(x => x.AppUserId == appUserId.ToString())
.Where(accessPredicate)
.AsEnumerable();
query = FilterFeeds(query, feedFilterRequest);
query = query.OrderByDescending(x => x.CreateDate);
if (feedFilterRequest.Offset.HasValue)
{
query = query.Skip(feedFilterRequest.Offset.Value);
}
if (feedFilterRequest.Limit.HasValue)
{
query = query.Take(feedFilterRequest.Limit.Value);
}
return ServerResponseBuilder.Build(await query.ToAsyncEnumerable()
.Select(x => Mapper.Map <Feed, FeedResponse>(x))
.ToListAsync());
}));
}
public async Task <ServerResponse <long> > CreateNoteAsync(NoteRequest noteRequest)
{
return(await BaseInvokeAsync(async() =>
{
var note = new Note
{
Name = noteRequest.Name,
Description = noteRequest.Description,
VisibleType = noteRequest.VisibleType,
UpdateDate = DateTime.Now,
AppUserId = noteRequest.AppUserId
};
await DbContext.Notes.AddAsync(note);
if (noteRequest.TagIds.Any())
{
var noteTags = noteRequest.TagIds
.Join(DbContext.Tags, o => o, i => i.Id, (o, i) => i)
.Select(x => new NoteTag
{
Note = note,
Tag = x
});
await DbContext.NoteTags.AddRangeAsync(noteTags);
}
await DbContext.SaveChangesAsync();
return ServerResponseBuilder.Build(note.Id);
}, noteRequest));
}
public async Task <ServerResponse <AuthorizationTokenResponse> > RegisterAsync(RegistrationRequest request)
{
return(await BaseInvokeAsync(async() =>
{
if (DbContext.AppUsers.Any(x => x.Email == request.Email || x.Username == request.UserName))
{
throw new UnauthorizedException(Constants.Errors.UserAlreadyRegistered);
}
var appUser = new AppUser
{
Username = request.UserName,
Email = request.Email,
Password = HashPasswordHelper.Hash(request.Password),
UserRole = EUserRole.User,
CreatedDate = DateTime.Now
};
await DbContext.AddAsync(appUser);
await DbContext.SaveChangesAsync();
var tokenInfo = _tokenService.CreateToken(GetClaimsFromAppUser(appUser));
var authorizationTokenResponse = new AuthorizationTokenResponse()
{
Token = tokenInfo.Token,
ExpirationDate = tokenInfo.ExpiredDate,
AppUserViewModel = Mapper.Map <AppUser, AppUserViewModel>(appUser)
};
return ServerResponseBuilder.Build(authorizationTokenResponse);
}, request));
}
public async Task <ServerResponse <AuthorizationTokenResponse> > LoginAsync(LoginRequest request)
{
return(await BaseInvokeAsync(async() =>
{
var appUser = await DbContext.AppUsers
.AsQueryable()
.FirstOrDefaultAsync(x => x.Username == request.UserName);
if (appUser == null)
{
throw new UnauthorizedException(Constants.Errors.UsernameIsIncorrect);
}
if (!HashPasswordHelper.Verify(appUser.Password, request.Password))
{
throw new UnauthorizedException(Constants.Errors.PasswordIsIncorrect);
}
var tokenInfo = _tokenService.CreateToken(GetClaimsFromAppUser(appUser));
var authorizationTokenResponse = new AuthorizationTokenResponse()
{
Token = tokenInfo.Token,
ExpirationDate = tokenInfo.ExpiredDate,
AppUserViewModel = Mapper.Map <AppUser, AppUserViewModel>(appUser)
};
return ServerResponseBuilder.Build(authorizationTokenResponse);
}, request));
}
public async Task <ServerResponse <PageResult <AppUserViewModel> > > GetAdminUsersByPageAsync(AdminTableFilterRequest adminTableFilterRequest)
{
return(await BaseInvokeAsync(async() =>
{
var query = DbContext.AppUsers.AsQueryable();
query = FilterAppUsers(query, adminTableFilterRequest);
var usersCount = query.Count();
query = SortItems(query, adminTableFilterRequest);
query = FetchItems(query, adminTableFilterRequest);
var pageResult = new PageResult <AppUserViewModel>
{
Items = query.Select(x => new AppUserViewModel
{
Id = x.Id,
UserName = x.Username,
UserRole = x.UserRole,
CreatedDate = x.CreatedDate,
Email = x.Email
}).ToList(),
TotalCount = usersCount
};
return ServerResponseBuilder.Build(await Task.FromResult(pageResult));
}));
}
public async Task <ServerResponse <AppUserViewModel> > GetAppUserAsync(long appUserId)
{
return(await BaseInvokeWithTryCatchAsync(async() =>
{
var appUser = await DbContext.AppUsers
.FirstOrDefaultAsync(x => x.Id == appUserId);
return ServerResponseBuilder.Build(Mapper.Map <AppUser, AppUserViewModel>(appUser));
}));
}
public async Task <ServerResponse <List <TagResponse> > > GetTagsAsync()
{
return(await BaseInvokeAsync(async() =>
{
var query = DbContext.Tags
.AsQueryable()
.Select(x => Mapper.Map <Tag, TagResponse>(x));
return ServerResponseBuilder.Build(await query.ToListAsync());
}));
}
public async Task <ServerResponse <List <TagResponse> > > GetTagsByIdsAsync(List <long> tagIds)
{
return(await BaseInvokeAsync(async() =>
{
var query = DbContext.Tags
.AsQueryable()
.Where(x => tagIds.Contains(x.Id))
.Select(x => Mapper.Map <Tag, TagResponse>(x));
return ServerResponseBuilder.Build(await query.ToListAsync());
}));
}
public async Task <ServerResponse <bool> > CreateFeedAsync(Feed entity)
{
return(await BaseInvokeWithTryCatchAsync(async() =>
{
entity.Id = Guid.NewGuid();
entity.CreateDate = DateTime.Now;
entity.LastModifiedDate = entity.CreateDate;
await DbContext.Feeds.AddAsync(entity);
return ServerResponseBuilder.Build(true);
}));
}
public async Task <ServerResponse <long> > CreateMhTaskAsync(MhTaskRequest mhTaskRequest, MhTask parentMhTask = null)
{
return(await BaseInvokeAsync(async() =>
{
var mhTask = new MhTask
{
Name = mhTaskRequest.Name,
Description = mhTaskRequest.Description,
StartDate = mhTaskRequest.StartDate >= DateTime.Now ? mhTaskRequest.StartDate : DateTime.Now,
IsRecurring = mhTaskRequest.IsRecurring,
VisibleType = mhTaskRequest.VisibleType,
AppUserId = mhTaskRequest.AppUserId
};
if (parentMhTask != null)
{
mhTask.Parent = parentMhTask;
}
await DbContext.MhTasks.AddAsync(mhTask);
if (mhTaskRequest.IsRecurring)
{
var scheduleMhTask = new ScheduleMhTask
{
MhTask = mhTask,
MaxCount = mhTaskRequest.ScheduleMhTaskViewModel.MaxCount ?? 0,
ScheduleMhTaskType = mhTaskRequest.ScheduleMhTaskViewModel.ScheduleMhTaskType
};
await DbContext.ScheduleMhTasks.AddAsync(scheduleMhTask);
}
if (mhTaskRequest.TagIds.Any())
{
var mhTaskTags = mhTaskRequest.TagIds
.Join(DbContext.Tags, o => o, i => i.Id, (o, i) => i)
.Select(x => new MhTaskTag
{
MhTask = mhTask,
Tag = x
});
await DbContext.MhTaskTags.AddRangeAsync(mhTaskTags);
}
await AddToUpdateMhTask(DbContext, mhTask, Constants.Updates.CreateMhTask);
await DbContext.SaveChangesAsync();
return ServerResponseBuilder.Build(mhTask.Id);
}, mhTaskRequest));
}
public async Task <ServerResponse <List <long> > > GetFriendIds(long appUserId)
{
return(await BaseInvokeWithTryCatchAsync(async() =>
{
var friendIds = DbContext.Friends
.AsQueryable()
.Where(x => x.FriendRequestFlag == EFriendRequestFlag.Approved &&
(x.RequestedById == appUserId || x.RequestedToId == appUserId))
.Select(x => x.RequestedById == appUserId ? x.RequestedToId : x.RequestedById);
return ServerResponseBuilder.Build(await friendIds.ToListAsync());
}));
}
public async Task <ServerResponse <bool> > DeleteFeedAsync(Feed entity)
{
return(await BaseInvokeWithTryCatchAsync(async() =>
{
var feed = await DbContext.Feeds
.AsQueryable()
.FirstOrDefaultAsync(x =>
x.AppUserId == entity.AppUserId && x.FeedId == entity.FeedId);
DbContext.Feeds.Remove(feed);
return await Task.FromResult(ServerResponseBuilder.Build(true));
}));
}
public async Task <ServerResponse <bool> > CreateTagAsync(TagRequest tagRequest)
{
return(await BaseInvokeAsync(async() =>
{
var tag = new DAL.Entities.Tag
{
Name = tagRequest.Name
};
await DbContext.Tags.AddAsync(tag);
await DbContext.SaveChangesAsync();
return ServerResponseBuilder.Build(true);
}, tagRequest));
}
public async Task <ServerResponse <NoteResponse> > GetNoteAsync(long accountId, long id)
{
return(await BaseInvokeAsync(async() =>
{
var note = await DbContext.Notes
.AsQueryable()
.FirstOrDefaultAsync(x => x.Id == id && x.AppUserId == accountId);
if (note == null)
{
throw new NotFoundException(Constants.Errors.NoteNotExists);
}
return ServerResponseBuilder.Build(Mapper.Map <Note, NoteResponse>(note));
}));
}
public async Task <ServerResponse <MhTaskResponse> > GetMhTaskAsync(long accountId, long id)
{
return(await BaseInvokeAsync(async() =>
{
var mhTask = await DbContext.MhTasks
.AsQueryable()
.FirstOrDefaultAsync(x => x.Id == id && x.AppUserId == accountId);
if (mhTask == null)
{
throw new NotFoundException(Constants.Errors.TaskNotExists);
}
return ServerResponseBuilder.Build(Mapper.Map <MhTask, MhTaskResponse>(mhTask));
}));
}
public async Task <ServerResponse <bool> > UpdateFeedAsync(Feed entity)
{
return(await BaseInvokeWithTryCatchAsync(async() =>
{
var feed = await DbContext.Feeds
.AsQueryable()
.FirstOrDefaultAsync(x =>
x.AppUserId == entity.AppUserId && x.FeedId == entity.FeedId);
feed.FeedData = entity.FeedData;
feed.LastModifiedDate = DateTime.Now;
DbContext.Feeds.Update(feed);
return ServerResponseBuilder.Build(true);
}));
}
public async Task <ServerResponse <bool> > DeleteTagAsync(long id)
{
return(await BaseInvokeAsync(async() =>
{
var tag = await DbContext.Tags
.AsQueryable()
.FirstOrDefaultAsync(x => x.Id == id);
if (tag == null)
{
throw new NotFoundException(Constants.Errors.TagNotExists);
}
DbContext.Tags.Remove(tag);
await DbContext.SaveChangesAsync();
return ServerResponseBuilder.Build(true);
}));
}
public async Task <ServerResponse <List <NoteResponse> > > GetNotesAsync(long accountId, NoteFilterRequest noteFilterRequest)
{
return(await BaseInvokeAsync(async() =>
{
var query = DbContext.Notes
.AsQueryable()
.Include(x => x.NoteTags)
.ThenInclude(e => e.Tag)
.Where(x => x.AppUserId == accountId);
query = FilterNotes(query, noteFilterRequest);
query = query.OrderByDescending(x => x.Id);
query = FetchItems(query, noteFilterRequest);
return ServerResponseBuilder.Build(await query.ToAsyncEnumerable()
.Select(x => Mapper.Map <Note, NoteResponse>(x)).ToListAsync());
}));
}
public async Task <ServerResponse <bool> > DeleteFriendAsync(long accountId, long personId)
{
return(await BaseInvokeAsync(async() =>
{
var friends = DbContext.Friends
.AsQueryable()
.Where(x => (x.RequestedById == accountId && x.RequestedToId == personId) ||
(x.RequestedById == personId && x.RequestedToId == accountId));
if (!friends.Any())
{
throw new NotFoundException(Constants.Errors.FriendNotExists);
}
DbContext.Friends.RemoveRange(friends);
await DbContext.SaveChangesAsync();
return ServerResponseBuilder.Build(true);
}));
}
public async Task <ServerResponse <List <FriendViewModel> > > GetFriendsByRequestFlag(
long accountId, EFriendRequestFlag eFriendRequestFlag, FriendFilterRequest friendFilterRequest)
{
return(await BaseInvokeAsync(async() =>
{
var friends = DbContext.Friends
.Include(x => x.RequestedBy)
.Include(x => x.RequestedTo)
.Where(x =>
(x.RequestedById == accountId || x.RequestedToId == accountId) &&
x.FriendRequestFlag == eFriendRequestFlag);
friends = FilterFriends(friends, accountId, friendFilterRequest);
friends = friends.OrderByDescending(x => x.RequestTime);
friends = FetchItems(friends, friendFilterRequest);
return await Task.FromResult(ServerResponseBuilder.Build(friends.MapFriendsToViewModels(accountId)));
}));
}
public async Task <ServerResponse <bool> > UpdateTagAsync(TagRequest tagRequest)
{
return(await BaseInvokeAsync(async() =>
{
var tag = await DbContext.Tags
.AsQueryable()
.FirstOrDefaultAsync(x => x.Id == tagRequest.Id);
if (tag == null)
{
throw new NotFoundException(Constants.Errors.TagNotExists);
}
tag.Name = tagRequest.Name;
DbContext.Tags.Update(tag);
await DbContext.SaveChangesAsync();
return ServerResponseBuilder.Build(true);
}));
}
public async Task <ServerResponse <List <MhTaskResponse> > > GetMhTasksAsync(long accountId, MhTaskFilterRequest mhTaskFilterRequest)
{
return(await BaseInvokeAsync(async() =>
{
var query = DbContext.MhTasks
.AsQueryable()
.Include(x => x.ScheduleMhTask)
.Include(x => x.MhTaskTags)
.ThenInclude(e => e.Tag)
.Where(x => x.MhTaskState != EMhTaskState.Delete && x.AppUserId == accountId);
query = FilterMhTasks(query, mhTaskFilterRequest);
query = query.OrderBy(x => x.StartDate);
query = FetchItems(query, mhTaskFilterRequest);
return ServerResponseBuilder.Build(await query.ToAsyncEnumerable()
.Select(x => Mapper.Map <MhTask, MhTaskResponse>(x)).ToListAsync());
}));
}
public async Task <ServerResponse <bool> > DeleteMhTaskAsync(long id)
{
return(await BaseInvokeAsync(async() =>
{
var mhTask = await DbContext.MhTasks
.AsQueryable()
.FirstOrDefaultAsync(x => x.Id == id);
if (mhTask == null)
{
throw new NotFoundException(Constants.Errors.TaskNotExists);
}
mhTask.MhTaskState = EMhTaskState.Delete;
DbContext.MhTasks.Update(mhTask);
await AddToUpdateMhTask(DbContext, mhTask, Constants.Updates.DeleteMhTask);
await DbContext.SaveChangesAsync();
return ServerResponseBuilder.Build(true);
}));
}
public async Task <ServerResponse <bool> > UpdateNoteAsync(NoteRequest noteRequest)
{
return(await BaseInvokeAsync(async() =>
{
Note note = await DbContext.Notes
.AsQueryable()
.FirstOrDefaultAsync(x => x.Id == noteRequest.Id);
if (note == null)
{
throw new NotFoundException(Constants.Errors.NoteNotExists);
}
note.Name = noteRequest.Name;
note.Description = noteRequest.Description;
note.VisibleType = noteRequest.VisibleType;
note.UpdateDate = DateTime.Now;
DbContext.Notes.Update(note);
var noteTags = await DbContext.NoteTags
.AsQueryable()
.Where(x => x.NoteId == note.Id).ToListAsync();
DbContext.NoteTags
.RemoveRange(noteTags.Where(x => !noteRequest.TagIds.Contains(x.TagId)));
await DbContext.NoteTags.AddRangeAsync(
noteRequest.TagIds
.Join(DbContext.Tags, o => o, i => i.Id, (o, i) => i)
.Where(x => !noteTags.Select(y => y.TagId).Contains(x.Id))
.Select(x => new NoteTag {
Tag = x, Note = note
}));
await DbContext.SaveChangesAsync();
return ServerResponseBuilder.Build(true);
}, noteRequest));
}
public async Task <ServerResponse <List <FriendViewModel> > > GetSearchFriendsAsync(long accountId, FriendFilterRequest friendFilterRequest)
{
return(await BaseInvokeAsync(async() =>
{
var friends = DbContext.Friends
.AsQueryable()
.Where(x => x.RequestedById == accountId || x.RequestedToId == accountId)
.Select(x => x.RequestedById == accountId ? x.RequestedToId : x.RequestedById);
var searchFriends = DbContext.AppUsers
.AsQueryable()
.Where(x => !friends.Contains(x.Id) && x.Id != accountId);
searchFriends = FilterSearchFriends(searchFriends, friendFilterRequest);
searchFriends = searchFriends.OrderByDescending(x => x.CreatedDate);
searchFriends = FetchItems(searchFriends, friendFilterRequest);
return ServerResponseBuilder.Build(await searchFriends.ToAsyncEnumerable()
.Select(x => Mapper.Map <AppUser, FriendViewModel>(x)).ToListAsync());
}));
}
public async Task <ServerResponse <bool> > CancelFriendAsync(long accountId, long personId)
{
return(await BaseInvokeAsync(async() =>
{
var friend = DbContext.Friends.FirstOrDefault(x =>
(x.RequestedById == accountId && x.RequestedToId == personId) ||
(x.RequestedById == personId && x.RequestedToId == accountId));
if (friend == null)
{
throw new NotFoundException(Constants.Errors.FriendNotExists);
}
if (friend.FriendRequestFlag != EFriendRequestFlag.Approved)
{
throw new ConflictException(Constants.Errors.FriendNotApproved);
}
friend.FriendRequestFlag = EFriendRequestFlag.None;
await DbContext.SaveChangesAsync();
return ServerResponseBuilder.Build(true);
}));
}
public async Task <ServerResponse <bool> > UpdateMhTaskAsync(MhTaskRequest mhTaskRequest)
{
return(await BaseInvokeAsync(async() =>
{
MhTask mhTask;
if (mhTaskRequest.IsRecurring)
{
mhTask = await DbContext.MhTasks.Include(x => x.ScheduleMhTask)
.FirstOrDefaultAsync(x => x.Id == mhTaskRequest.Id);
}
else
{
mhTask = await DbContext.MhTasks
.AsQueryable()
.FirstOrDefaultAsync(x => x.Id == mhTaskRequest.Id);
}
if (mhTask == null)
{
throw new NotFoundException(Constants.Errors.TaskNotExists);
}
if (mhTask.MhTaskState == EMhTaskState.ReSchedule)
{
throw new ConflictException(Constants.Errors.TaskReSheduleCannotBeUpdated);
}
mhTask.Name = mhTaskRequest.Name;
mhTask.Description = mhTaskRequest.Description;
mhTask.StartDate = mhTaskRequest.StartDate;
mhTask.IsRecurring = mhTaskRequest.IsRecurring;
mhTask.VisibleType = mhTaskRequest.VisibleType;
if (mhTaskRequest.IsRecurring)
{
if (mhTask.ScheduleMhTask == null)
{
mhTask.ScheduleMhTask = new ScheduleMhTask();
}
mhTask.ScheduleMhTask.MaxCount = mhTaskRequest.ScheduleMhTaskViewModel.MaxCount ?? 0;
mhTask.ScheduleMhTask.ScheduleMhTaskType = mhTaskRequest.ScheduleMhTaskViewModel.ScheduleMhTaskType;
}
DbContext.MhTasks.Update(mhTask);
var mhTaskTags = await DbContext.MhTaskTags
.AsQueryable()
.Where(x => x.MhTaskId == mhTask.Id).ToListAsync();
DbContext.MhTaskTags.RemoveRange(mhTaskTags.Where(x => !mhTaskRequest.TagIds.Contains(x.TagId)));
await DbContext.MhTaskTags.AddRangeAsync(
mhTaskRequest.TagIds
.Join(DbContext.Tags, o => o, i => i.Id, (o, i) => i)
.Where(x => !mhTaskTags.Select(y => y.TagId).Contains(x.Id))
.Select(x => new MhTaskTag {
Tag = x, MhTask = mhTask
}));
await AddToUpdateMhTask(DbContext, mhTask, Constants.Updates.UpdateEntireMhTask);
await DbContext.SaveChangesAsync();
return ServerResponseBuilder.Build(true);
}, mhTaskRequest));
}
