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));
}
