public async Task <ServiceResult <CommentThreadError> > CommentThreadAsync(int threadId, string content, string authorNickname) { if (string.IsNullOrWhiteSpace(content)) { return(ServiceResult.CreateFailed(CommentThreadError.InvalidContent)); } var threadsRepository = _unitOfWork.GetRepository <Thread>(); var thread = await threadsRepository.GetFirstOrDefaultAsync(t => t.Id == threadId, t => t.Author, t => t.Section); var usersRepository = _unitOfWork.UserRepository; var author = await usersRepository.GetFirstOrDefaultAsync(u => u.Username == authorNickname); var commentaryRepository = _unitOfWork.GetRepository <Commentary>(); var newComment = new Commentary { Author = author, Thread = thread, CommentTime = DateTime.UtcNow, Content = content }; commentaryRepository.Create(newComment); await _unitOfWork.SaveAsync(); return(ServiceResult <CommentThreadError> .CreateSuccess()); }
public async Task <ServiceResult <DeleteThreadError> > DeleteThread(int threadId, string username) { var userRepository = _unitOfWork.GetRepository <User>(); var user = await userRepository.FirstOrDefaultAsync(s => s.Username == username); if (user == null) { return(ServiceResult <DeleteThreadError> .CreateFailed(DeleteThreadError.UserNotFound)); } var threadRepository = _unitOfWork.GetRepository <Thread>(); var thread = await threadRepository.FirstOrDefaultAsync(t => t.Id == threadId, t => t.Author); if (thread == null) { return(ServiceResult <DeleteThreadError> .CreateFailed(DeleteThreadError.ThreadNotFound)); } if (thread.AuthorId != user.Id) { return(ServiceResult <DeleteThreadError> .CreateFailed(DeleteThreadError.UserNotAuthor)); } threadRepository.Delete(thread); await _unitOfWork.SaveAsync(); return(ServiceResult <DeleteThreadError> .CreateSuccess()); }
public async Task <ServiceResult <UserThreadsInfo, GetUserThreadsInfoError> > GetUserThreadsInfo(GetUserThreadsInfoDto request) { var userRepository = _unitOfWork.UserRepository; var currentUser = await userRepository.FirstOrDefaultAsync(u => u.Username == request.Username); if (currentUser == null) { return(ServiceResult <UserThreadsInfo, GetUserThreadsInfoError> .CreateFailed(GetUserThreadsInfoError.NotFound)); } if (request.StartIndex < 0 || request.Size > MaxGetQuerySize) { return(ServiceResult <UserThreadsInfo, GetUserThreadsInfoError> .CreateFailed(GetUserThreadsInfoError.InvalidPaginationArguments)); } var threadsRepository = _unitOfWork.GetRepository <Thread>(); var threads = threadsRepository.All(t => t.Author.Username == request.Username, t => t.Author, t => t.Section) .OrderByDescending(t => t.CreationDateTimeUtc).Skip(request.StartIndex).Take(request.Size).ToList(); var result = new UserThreadsInfo { Amount = threads.Count, UserThreads = threads.Select(t => new UserThreadInfo { Id = t.Id, Title = t.Title, CreationDateTimeUtc = t.CreationDateTimeUtc, Section = t.Section.Name }).ToList(), Size = request.Size, StartIndex = request.StartIndex }; return(ServiceResult <UserThreadsInfo, GetUserThreadsInfoError> .CreateSuccess(result)); }
public async Task <ServiceResult <ThreadCommentsInfo, GetThreadCommentsError> > GetThreadCommentsInfo(int threadId, int startIndex, int size) { if (startIndex < 0 || size > MaxGetQuerySize) { return(ServiceResult <ThreadCommentsInfo, GetThreadCommentsError> .CreateFailed(GetThreadCommentsError.InvalidPaginationArguments)); } var threadRepository = _unitOfWork.GetRepository <Thread>(); var thread = await threadRepository.FirstOrDefaultAsync(t => t.Id == threadId); if (thread == null) { return(ServiceResult <ThreadCommentsInfo, GetThreadCommentsError> .CreateFailed(GetThreadCommentsError.ThreadNotFound)); } var commentRepository = _unitOfWork.GetRepository <Commentary>(); var comments = await commentRepository.All(c => c.ThreadId == threadId, c => c.Author) .OrderByDescending(c => c.CommentTimeUtc).Skip(startIndex).Take(size).ToListAsync(); var result = new ThreadCommentsInfo { Amount = comments.Count, Comments = comments.Select(c => new ThreadCommentInfo { AuthorNickname = c.Author.Username, Content = c.Content, CommentTimeUtc = c.CommentTimeUtc }).ToList(), Size = size, StartIndex = startIndex }; return(ServiceResult <ThreadCommentsInfo, GetThreadCommentsError> .CreateSuccess(result)); }
public async Task <ServiceResult <SectionThreadsInfo, GetSectionThreadsInfoError> > GetSectionThreads(string sectionName, int startIndex, int size) { var sectionRepository = _unitOfWork.GetRepository <Section>(); var section = await sectionRepository.FirstOrDefaultAsync(s => s.Name == sectionName); if (section == null) { return(ServiceResult <SectionThreadsInfo, GetSectionThreadsInfoError> .CreateFailed(GetSectionThreadsInfoError.InvalidSection)); } if (startIndex < 0 || size > MaxGetQuerySize) { return(ServiceResult <SectionThreadsInfo, GetSectionThreadsInfoError> .CreateFailed(GetSectionThreadsInfoError.InvalidPaginationArguments)); } var threadRepository = _unitOfWork.GetRepository <Thread>(); var threads = await threadRepository.All(t => t.SectionId == section.Id, t => t.Author) .OrderByDescending(t => t.CreationDateTimeUtc).Skip(startIndex).Take(size).ToListAsync(); var result = new SectionThreadsInfo { Amount = threads.Count, Threads = threads.Select(t => new SectionThreadInfo { Id = t.Id, Title = t.Title, CreationDateTimeUtc = t.CreationDateTimeUtc, AuthorUsername = t.Author.Username }).ToList(), Size = size, StartIndex = startIndex }; return(ServiceResult <SectionThreadsInfo, GetSectionThreadsInfoError> .CreateSuccess(result)); }
public async Task <ServiceResult <UserInfo, UpdateProfileImageError> > UpdateProfileImage(string username, string imageExternalId) { var userRepository = _unitOfWork.UserRepository; var currentUser = await userRepository.FirstOrDefaultAsync(u => u.Username == username); if (currentUser == null) { return(ServiceResult <UserInfo, UpdateProfileImageError> .CreateFailed(UpdateProfileImageError.UserNotFound)); } var imagesRepository = _unitOfWork.GetRepository <UploadedImage>(); var profileImage = await imagesRepository.FirstOrDefaultAsync(i => i.ExternalId == imageExternalId); if (profileImage == null) { return(ServiceResult <UserInfo, UpdateProfileImageError> .CreateFailed(UpdateProfileImageError.ImageNotFound)); } var userInfo = new UserInfo { Username = currentUser.Username, Email = currentUser.Email, ProfileImageExternalId = profileImage.ExternalId, }; currentUser.ProfileImageId = profileImage.Id; userRepository.Update(currentUser); await _unitOfWork.SaveAsync(); return(ServiceResult <UserInfo, UpdateProfileImageError> .CreateSuccess(userInfo)); }
public async Task <ServiceResult <LoadedImage, LoadImageError> > LoadImageAsync(string externalId) { var imagesRepository = _unitOfWork.GetRepository <UploadedImage>(); var imageDetails = await imagesRepository.SingleOrDefaultAsync(i => i.ExternalId == externalId); if (imageDetails == null) { return(ServiceResult <LoadedImage, LoadImageError> .CreateFailed(LoadImageError.IncorrectExternalId)); } var imageExtension = Path.GetExtension(imageDetails.FilePath); var imageName = $"{externalId}{imageExtension}"; var firebaseStorage = new FirebaseStorage(_firebaseImageStorageConfiguration.StorageBucket) .Child(_firebaseImageStorageConfiguration.ImagesDirectory) .Child(imageName); try { var fileBytes = await firebaseStorage.GetAsync(imageDetails.FilePath); return(ServiceResult <LoadedImage, LoadImageError> .CreateSuccess(new LoadedImage(fileBytes, imageDetails.MediaType))); } catch (FirebaseStorageException) { return(ServiceResult <LoadedImage, LoadImageError> .CreateFailed(LoadImageError.ImageNotExists)); } }
public async Task <ServiceResult <ThreadsInfo, GetThreadsInfoError> > GetPopularThreads(int startIndex, int size) { if (startIndex < 0 || size > MaxGetQuerySize) { return(ServiceResult <ThreadsInfo, GetThreadsInfoError> .CreateFailed(GetThreadsInfoError.InvalidPaginationArguments)); } var threadRepository = _unitOfWork.GetRepository <Thread>(); var threads = await threadRepository.All(null, t => t.Likes, t => t.Author, t => t.Section) .OrderByDescending(t => t.Likes.Where(l => l.IsLike).Count() - t.Likes.Where(l => !l.IsLike).Count()) .Skip(startIndex).Take(size).ToListAsync(); var result = new ThreadsInfo { Amount = threads.Count, Threads = threads.Select(t => new ThreadInfo { Id = t.Id, Title = t.Title, Content = t.Content, SectionName = t.Section.Name, CreationDateTimeUtc = t.CreationDateTimeUtc, AuthorUsername = t.Author.Username, LikesDislikes = t.Likes.Where(l => l.IsLike).Count() - t.Likes.Where(l => !l.IsLike).Count() }).ToList(), Size = size, StartIndex = startIndex }; return(ServiceResult <ThreadsInfo, GetThreadsInfoError> .CreateSuccess(result)); }
public async Task <ServiceResult <ThreadInfo, LikeDislikeThreadError> > LikeDislikeThread(int threadId, string username, bool isLike) { var userRepository = _unitOfWork.GetRepository <User>(); var user = await userRepository.FirstOrDefaultAsync(s => s.Username == username); if (user == null) { return(ServiceResult <ThreadInfo, LikeDislikeThreadError> .CreateFailed(LikeDislikeThreadError.UserNotFound)); } var threadRepository = _unitOfWork.GetRepository <Thread>(); var thread = await threadRepository.FirstOrDefaultAsync(t => t.Id == threadId, t => t.Author); if (thread == null) { return(ServiceResult <ThreadInfo, LikeDislikeThreadError> .CreateFailed(LikeDislikeThreadError.ThreadNotFound)); } var likesRepository = _unitOfWork.GetRepository <LikeDislike>(); var currentLike = await likesRepository.FirstOrDefaultAsync(l => l.ThreadId == threadId && l.User == user, l => l.Thread, l => l.User); if (currentLike == null) { currentLike = new LikeDislike { User = user, Thread = thread, IsLike = isLike }; likesRepository.Create(currentLike); } else if (currentLike.IsLike != isLike) { currentLike.IsLike = isLike; likesRepository.Update(currentLike); } else { likesRepository.Delete(currentLike); } await _unitOfWork.SaveAsync(); var updatedThread = await threadRepository.FirstOrDefaultAsync(t => t.Id == thread.Id, t => t.Author, t => t.Likes, t => t.Section); var result = new ThreadInfo { Id = updatedThread.Id, Title = updatedThread.Title, Content = updatedThread.Content, SectionName = updatedThread.Section.Name, CreationDateTimeUtc = updatedThread.CreationDateTimeUtc, AuthorUsername = updatedThread.Author.Username, LikesDislikes = updatedThread.Likes.Where(l => l.IsLike).Count() - thread.Likes.Where(l => !l.IsLike).Count() }; return(ServiceResult <ThreadInfo, LikeDislikeThreadError> .CreateSuccess(result)); }
public async Task <ServiceResult <CreateThreadErrorType> > CreateThreadAsync(string title, string content, string sectionName, string authorNickname) { if (string.IsNullOrWhiteSpace(title)) { return(ServiceResult.CreateFailed(CreateThreadErrorType.InvalidTitle)); } if (string.IsNullOrWhiteSpace(content)) { return(ServiceResult.CreateFailed(CreateThreadErrorType.InvalidContent)); } var threadsRepository = _unitOfWork.GetRepository <Thread>(); var sectionsRepository = _unitOfWork.GetRepository <Section>(); var usersRepository = _unitOfWork.UserRepository; var author = await usersRepository.GetFirstOrDefaultAsync(u => u.Username == authorNickname); var section = await sectionsRepository.GetFirstOrDefaultAsync(s => s.Name == sectionName); var thread = new Thread { Title = title, Content = content, Author = author, Section = section }; threadsRepository.Create(thread); await _unitOfWork.SaveAsync(); return(ServiceResult <CreateThreadErrorType> .CreateSuccess()); }
public ServiceResult DVT_MaDVT() { var dvtCount = this.procedureHelper.GetData <int>("DVT_GetDVTCount", new { })[0]; var newCode = "DVT" + (dvtCount + 1).ToString("D" + MAX_CODE_LENGTH.ToString()); return(ServiceResult.CreateSuccess(newCode)); }
public async Task <ServiceResult <ThreadInfo, CreateThreadError> > CreateThread(CreateThreadDto request) { var sectionRepository = _unitOfWork.GetRepository <Section>(); var section = await sectionRepository.FirstOrDefaultAsync(s => s.Name == request.SectionName); if (section == null) { return(ServiceResult <ThreadInfo, CreateThreadError> .CreateFailed(CreateThreadError.SectionNotFound)); } var userRepository = _unitOfWork.GetRepository <User>(); var author = await userRepository.FirstOrDefaultAsync(s => s.Username == request.AuthorUsername); if (author == null) { return(ServiceResult <ThreadInfo, CreateThreadError> .CreateFailed(CreateThreadError.UserNotFound)); } if (string.IsNullOrWhiteSpace(request.Title)) { return(ServiceResult <ThreadInfo, CreateThreadError> .CreateFailed(CreateThreadError.InvalidTitle)); } if (string.IsNullOrWhiteSpace(request.Content)) { return(ServiceResult <ThreadInfo, CreateThreadError> .CreateFailed(CreateThreadError.InvalidContent)); } var threadRepository = _unitOfWork.GetRepository <Thread>(); var creationDateTimeUtc = DateTime.UtcNow; var thread = new Thread { Title = request.Title, Content = request.Content, Author = author, Section = section, CreationDateTimeUtc = creationDateTimeUtc }; threadRepository.Create(thread); await _unitOfWork.SaveAsync(); var threadInfo = new ThreadInfo { Id = thread.Id, Title = thread.Title, Content = thread.Content, SectionName = section.Name, CreationDateTimeUtc = creationDateTimeUtc, AuthorUsername = author.Username, LikesDislikes = 0 }; return(ServiceResult <ThreadInfo, CreateThreadError> .CreateSuccess(threadInfo)); }
public async Task <ServiceResult <SignUpErrorType> > SignUpAsync(SignUpDto signUpDto) { var isValidUsername = CheckIfValidUsername(signUpDto.Username); if (!isValidUsername) { return(ServiceResult.CreateFailed(SignUpErrorType.InvalidUsername)); } var isValidPassword = CheckIfValidPassword(signUpDto.Password); if (!isValidPassword) { return(ServiceResult.CreateFailed(SignUpErrorType.InvalidPassword)); } var isValidEmail = CheckIfValidEmail(signUpDto.Email); if (!isValidEmail) { return(ServiceResult.CreateFailed(SignUpErrorType.InvalidEmail)); } var isValidPasswordConfirmation = signUpDto.PasswordConfirmation == signUpDto.Password; if (!isValidPasswordConfirmation) { return(ServiceResult.CreateFailed(SignUpErrorType.PasswordAndConfirmationNotSame)); } var userRepository = _unitOfWork.UserRepository; var duplicateUser = await userRepository.GetFirstOrDefaultAsync(u => u.Username == signUpDto.Username); if (duplicateUser != null) { return(ServiceResult.CreateFailed(SignUpErrorType.DuplicateUsername)); } duplicateUser = await userRepository.GetFirstOrDefaultAsync(u => u.Email == signUpDto.Email); if (duplicateUser != null) { return(ServiceResult.CreateFailed(SignUpErrorType.DuplicateEmail)); } var passwordHash = _hasher.GetHash(signUpDto.Password); var newUser = new User { Username = signUpDto.Username, Email = signUpDto.Email, PasswordHash = passwordHash, ProfileImageId = null }; userRepository.Create(newUser); await _unitOfWork.SaveAsync(); return(ServiceResult <SignUpErrorType> .CreateSuccess()); }
public async Task <ServiceResult <SavedImage, SaveImageError> > SaveImageAsync(string filePath, Stream imageStream) { if (string.IsNullOrEmpty(filePath)) { return(ServiceResult <SavedImage, SaveImageError> .CreateFailed(SaveImageError.EmptyFilePath)); } if (imageStream.Length > _imageStorageConfiguration.MaximumImageSize) { return(ServiceResult <SavedImage, SaveImageError> .CreateFailed(SaveImageError.TooBigImage)); } var imageExtension = Path.GetExtension(filePath); var mediaType = MimeMapping.MimeUtility.GetMimeMapping(filePath); var isMediaTypeAllowed = _imageStorageConfiguration.AllowedImageMediaTypes.Any(t => t == mediaType); if (!isMediaTypeAllowed) { return(ServiceResult <SavedImage, SaveImageError> .CreateFailed(SaveImageError.NotAllowedMediaType)); } var externalId = Guid.NewGuid().ToString(); var uploadedImageName = $"{externalId}{imageExtension}"; var firebaseStorage = new FirebaseStorage(_firebaseImageStorageConfiguration.StorageBucket) .Child(_firebaseImageStorageConfiguration.ImagesDirectory) .Child(uploadedImageName); string downloadUri; try { downloadUri = await firebaseStorage.PutAsync(imageStream); } catch (FirebaseStorageException) { return(ServiceResult <SavedImage, SaveImageError> .CreateFailed(SaveImageError.StorageError)); } var uploadedImage = new UploadedImage { FilePath = downloadUri, ExternalId = externalId, MediaType = mediaType }; var imagesRepository = _unitOfWork.GetRepository <UploadedImage>(); imagesRepository.Create(uploadedImage); await _unitOfWork.SaveAsync(); return(ServiceResult <SavedImage, SaveImageError> .CreateSuccess(new SavedImage(uploadedImage.ExternalId))); }
public async Task <ServiceResult <SectionsCount, GetSectionsCountError> > GetSectionsCount() { var sectionRepository = _unitOfWork.GetRepository <Section>(); var sections = sectionRepository.All(null); var count = await sections.CountAsync(); var result = new SectionsCount { Count = count }; return(ServiceResult <SectionsCount, GetSectionsCountError> .CreateSuccess(result)); }
public async Task <ServiceResult <ThreadsCount, GetThreadsCountError> > GetPopularThreadsCount() { var threadRepository = _unitOfWork.GetRepository <Thread>(); var threads = threadRepository.All(null); var count = await threads.CountAsync(); var result = new ThreadsCount { Count = count }; return(ServiceResult <ThreadsCount, GetThreadsCountError> .CreateSuccess(result)); }
public async Task <ServiceResult <SignInErrorType> > SignInAsync(string username, string password, bool rememberMe, SignInHandler signInHandler) { var userRepository = _unitOfWork.UserRepository; var passwordHash = _hasher.GetHash(password); var user = await userRepository.GetFirstOrDefaultAsync(u => u.Username == username && u.PasswordHash == passwordHash); if (user == null) { return(ServiceResult.CreateFailed(SignInErrorType.InvalidCredentials)); } await signInHandler(user.Username, user.Id, rememberMe); return(ServiceResult <SignInErrorType> .CreateSuccess()); }
public async Task <ServiceResult <ThreadCommentInfo, CommentThreadError> > CommentThread(CommentThreadDto request) { var userRepository = _unitOfWork.GetRepository <User>(); var user = await userRepository.FirstOrDefaultAsync(s => s.Username == request.AuthorUsername); if (user == null) { return(ServiceResult <ThreadCommentInfo, CommentThreadError> .CreateFailed(CommentThreadError.UserNotFound)); } var threadRepository = _unitOfWork.GetRepository <Thread>(); var thread = await threadRepository.FirstOrDefaultAsync(t => t.Id == request.ThreadId, t => t.Commentaries); if (thread == null) { return(ServiceResult <ThreadCommentInfo, CommentThreadError> .CreateFailed(CommentThreadError.ThreadNotFound)); } if (string.IsNullOrWhiteSpace(request.Content)) { return(ServiceResult <ThreadCommentInfo, CommentThreadError> .CreateFailed(CommentThreadError.InvalidContent)); } var commentRepository = _unitOfWork.GetRepository <Commentary>(); var commentTimeUtc = DateTime.UtcNow; var newComment = new Commentary { Author = user, Thread = thread, CommentTimeUtc = commentTimeUtc, Content = request.Content }; commentRepository.Create(newComment); await _unitOfWork.SaveAsync(); var result = new ThreadCommentInfo { Content = newComment.Content, AuthorNickname = user.Username, CommentTimeUtc = commentTimeUtc }; return(ServiceResult <ThreadCommentInfo, CommentThreadError> .CreateSuccess(result)); }
public async Task <ServiceResult <UserInfo, GetUserInfoError> > GetUserInfoByUsername(string username) { var userRepository = _unitOfWork.UserRepository; var currentUser = await userRepository.FirstOrDefaultAsync(u => u.Username == username, u => u.ProfileImage); if (currentUser == null) { return(ServiceResult <UserInfo, GetUserInfoError> .CreateFailed(GetUserInfoError.NotFound)); } var userInfo = new UserInfo { Username = currentUser.Username, Email = currentUser.Email, ProfileImageExternalId = currentUser.ProfileImage?.ExternalId }; return(ServiceResult <UserInfo, GetUserInfoError> .CreateSuccess(userInfo)); }
public async Task <ServiceResult <UpdateProfileErrorType> > UpdateUserProfileAsync(CurrentUserIdentityProvider currentUserIdentityProvider, UpdateUserProfileDto dto) { var userRepository = _unitOfWork.UserRepository; var imageRepostiory = _unitOfWork.GetRepository <UploadedImage>(); var newImage = await imageRepostiory.GetFirstOrDefaultAsync(i => i.ExternalId == dto.UserProfileImageExternalId); if (newImage == null) { return(ServiceResult.CreateFailed(UpdateProfileErrorType.InvalidProfileImage)); } var currentUser = await GetCurrentUserAsync(currentUserIdentityProvider); currentUser.ProfileImageId = newImage.Id; userRepository.Update(currentUser); await _unitOfWork.SaveAsync(); return(ServiceResult.CreateSuccess <UpdateProfileErrorType>()); }
public async Task <ServiceResult <DeleteThreadErrorType> > DeleteThreadAsync(int threadId, string username) { var threadsRepository = _unitOfWork.GetRepository <Thread>(); var thread = await threadsRepository.GetFirstOrDefaultAsync(t => t.Id == threadId, t => t.Author, t => t.Section); if (thread == null) { return(ServiceResult.CreateFailed(DeleteThreadErrorType.InvalidThread)); } if (thread.Author.Username != username) { return(ServiceResult.CreateFailed(DeleteThreadErrorType.NotAuthor)); } threadsRepository.Delete(thread); await _unitOfWork.SaveAsync(); return(ServiceResult <DeleteThreadErrorType> .CreateSuccess()); }
public async Task <ServiceResult <SectionThreadsCount, GetSectionThreadsCountError> > GetSectionThreadsCount(string sectionName) { var sectionRepository = _unitOfWork.GetRepository <Section>(); var section = await sectionRepository.FirstOrDefaultAsync(s => s.Name == sectionName); if (section == null) { return(ServiceResult <SectionThreadsCount, GetSectionThreadsCountError> .CreateFailed(GetSectionThreadsCountError.InvalidSection)); } var threadRepository = _unitOfWork.GetRepository <Thread>(); var threads = threadRepository.All(t => t.SectionId == section.Id); var count = await threads.CountAsync(); var result = new SectionThreadsCount { Count = count }; return(ServiceResult <SectionThreadsCount, GetSectionThreadsCountError> .CreateSuccess(result)); }
public async Task <ServiceResult <ThreadCommentsCount, GetThreadCommentsCountError> > GetThreadCommentsCount(int threadId) { var threadRepository = _unitOfWork.GetRepository <Thread>(); var thread = await threadRepository.FirstOrDefaultAsync(t => t.Id == threadId, t => t.Commentaries); if (thread == null) { return(ServiceResult <ThreadCommentsCount, GetThreadCommentsCountError> .CreateFailed(GetThreadCommentsCountError.ThreadNotFound)); } var commentRepository = _unitOfWork.GetRepository <Commentary>(); var comments = commentRepository.All(c => c.ThreadId == threadId, c => c.Author); var count = await comments.CountAsync(); var result = new ThreadCommentsCount { Count = count }; return(ServiceResult <ThreadCommentsCount, GetThreadCommentsCountError> .CreateSuccess(result)); }
public async Task <ServiceResult <UserThreadsCount, GetUserThreadsCountError> > GetUserThreadsCount(string username) { var userRepository = _unitOfWork.UserRepository; var currentUser = await userRepository.FirstOrDefaultAsync(u => u.Username == username); if (currentUser == null) { return(ServiceResult <UserThreadsCount, GetUserThreadsCountError> .CreateFailed(GetUserThreadsCountError.UserNotFound)); } var threadsRepository = _unitOfWork.GetRepository <Thread>(); var threads = await threadsRepository.WhereAsync(t => t.Author.Username == username, t => t.Author, t => t.Section); var count = threads.Count(); var result = new UserThreadsCount { Count = count }; return(ServiceResult <UserThreadsCount, GetUserThreadsCountError> .CreateSuccess(result)); }
public async Task <ServiceResult <ThreadInfo, GetThreadInfoError> > GetThreadInfo(int threadId) { var threadRepository = _unitOfWork.GetRepository <Thread>(); var thread = await threadRepository.FirstOrDefaultAsync(t => t.Id == threadId, t => t.Author, t => t.Likes, t => t.Section); if (thread == null) { return(ServiceResult <ThreadInfo, GetThreadInfoError> .CreateFailed(GetThreadInfoError.NotFound)); } var result = new ThreadInfo { Id = thread.Id, Title = thread.Title, Content = thread.Content, SectionName = thread.Section.Name, CreationDateTimeUtc = thread.CreationDateTimeUtc, AuthorUsername = thread.Author.Username, LikesDislikes = thread.Likes.Where(l => l.IsLike).Count() - thread.Likes.Where(l => !l.IsLike).Count() }; return(ServiceResult <ThreadInfo, GetThreadInfoError> .CreateSuccess(result)); }
public async Task <ServiceResult <SectionsInfo, GetSectionsError> > GetSections(int startIndex, int size) { if (startIndex < 0 || size > MaxGetQuerySize) { return(ServiceResult <SectionsInfo, GetSectionsError> .CreateFailed(GetSectionsError.InvalidPaginationArguments)); } var sectionRepository = _unitOfWork.GetRepository <Section>(); var sections = await sectionRepository.All(null) .OrderBy(s => s.Name).Skip(startIndex).Take(size).ToListAsync(); var result = new SectionsInfo { Amount = sections.Count, Sections = sections.Select(s => new SectionInfo { Name = s.Name }).ToList(), Size = size, StartIndex = startIndex }; return(ServiceResult <SectionsInfo, GetSectionsError> .CreateSuccess(result)); }