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 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 <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 <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 <SaveImageResult> SaveImageAsync(string filePath, Stream imageStream)
{
if (string.IsNullOrEmpty(filePath))
{
return(SaveImageResult.CreateUnsuccessful(SaveImageError.EmptyFilePath));
}
if (imageStream.Length > _configuration.MaximumImageSize)
{
return(SaveImageResult.CreateUnsuccessful(SaveImageError.TooBigImage));
}
var imageExtension = Path.GetExtension(filePath);
var mediaType = MimeMapping.MimeUtility.GetMimeMapping(filePath);
var isMediaTypeAllowed = _configuration.AllowedImageMediaTypes.Any(t => t == mediaType);
if (!isMediaTypeAllowed)
{
return(SaveImageResult.CreateUnsuccessful(SaveImageError.NotAllowedMediaType));
}
var externalId = Guid.NewGuid().ToString();
var uploadedImageName = $"{externalId}{imageExtension}";
var uploadedImage = new UploadedImage
{
FilePath = uploadedImageName,
ExternalId = externalId,
MediaType = mediaType
};
Directory.CreateDirectory(_configuration.ImagesDirectory);
var uploadPath = Path.Combine(_configuration.ImagesDirectory, uploadedImageName);
using (var outputStream = new FileStream(uploadPath, FileMode.Create))
{
await imageStream.CopyToAsync(outputStream);
}
var imagesRepository = _unitOfWork.GetRepository <UploadedImage>();
imagesRepository.Create(uploadedImage);
await _unitOfWork.SaveAsync();
return(SaveImageResult.CreateSuccessful(uploadedImage.ExternalId));
}
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>());
}