public async Task <AccountRegistrationResponse> RegisterUserAsync(AccountRegistrationRequest request)
{
var existsUser = await GetUserByPhoneAsync(request.Phone);
if (existsUser?.CreateUserPlace == CreateUserPlace.FromRegistration)
{
return(new AccountRegistrationResponse()
{
Code = ResponseCode.UserWithTheSamePhoneExists
});
}
var user = _userEntityFactory.Create(
request.Name,
request.LastName,
request.Phone,
request.Password,
CreateUserPlace.FromRegistration);
_userRepository.Add(user);
await _userRepository.SaveChangesAsync();
return(new AccountRegistrationResponse()
{
User = _mapper.Map <UserModel>(user)
});
}
public async Task InactivateAsync(long userId)
{
var userEntity = UserEntityFactory.Create(userId);
userEntity.Inactivate();
await UserRepository.UpdateStatusAsync(userEntity);
await UnitOfWork.SaveChangesAsync();
}
public async Task InactivateAsync(long userId)
{
var userEntity = UserEntityFactory.Create(userId);
userEntity.Inactivate();
await UserRepository.UpdatePartialAsync(userEntity.UserId, new { userEntity.Status });
await DatabaseUnitOfWork.SaveChangesAsync();
}
public async Task <IDataResult <long> > AddAsync(AddUserModel addUserModel)
{
var validation = new AddUserModelValidator().Validate(addUserModel);
if (validation.IsError)
{
return(DataResult <long> .Error(validation.Message));
}
addUserModel.SignIn = SignInService.CreateSignIn(addUserModel.SignIn);
var userEntity = UserEntityFactory.Create(addUserModel);
userEntity.Add();
await UserRepository.AddAsync(userEntity);
await UnitOfWork.SaveChangesAsync();
return(DataResult <long> .Success(userEntity.UserId));
}
public async Task <IDataResult <long> > AddAsync(AddUserModel addUserModel)
{
var validation = new AddUserModelValidator().Valid(addUserModel);
if (!validation.Success)
{
return(new ErrorDataResult <long>(validation.Message));
}
UserDomainService.GenerateHash(addUserModel.SignIn);
var userEntity = UserEntityFactory.Create(addUserModel);
userEntity.Add();
await UserRepository.AddAsync(userEntity);
await UnitOfWork.SaveChangesAsync();
return(new SuccessDataResult <long>(userEntity.UserId));
}
public async Task <CommentModel> CreateCommentAsync(AddCommentRequest request)
{
var user = await _userService.GetUserByPhoneAsync(request.Phone);
if (user == null)
{
user = _userEntityFactory.Create(
request.Name,
null,
request.Phone,
null,
CreateUserPlace.FromComment);
_userRepository.Add(user);
}
var comment = _commentFactory.Create(user, request.Text, request.Stars);
_commentRepository.Add(comment);
await _commentRepository.SaveChangesAsync();
return(_mapper.Map <CommentModel>(comment));
}
public async Task <IResult> UpdateAsync(UpdateUserModel updateUserModel)
{
var validation = new UpdateUserModelValidator().Valid(updateUserModel);
if (!validation.Success)
{
return(ErrorResult(validation.Message));
}
var userEntity = await UserRepository.SelectAsync(updateUserModel.UserId);
var userDomain = UserDomainFactory.Create(userEntity);
userDomain.Update(updateUserModel);
userEntity = UserEntityFactory.Create(userDomain);
await UserRepository.UpdateAsync(userEntity.UserId, userEntity);
await DatabaseUnitOfWork.SaveChangesAsync();
return(SuccessResult());
}
public async Task <OrderModel> CreateAsync(MakeOrderRequest request)
{
try
{
// Get or create user
var user = await _userService.GetUserByPhoneAsync(request.Phone);
if (user == null)
{
user = _userEntityFactory.Create(
request.Name,
request.LastName,
request.Phone,
null,
CreateUserPlace.FromOrder);
_userRepository.Add(user);
}
// Create order
var order = _orderEntityFactory.Create(
request.Address,
user,
request.CalculateTotalPrice(),
request.Comment);
_orderRepository.Add(order);
// Create order items
foreach (var requestOrderPosition in request.OrderPositions)
{
var orderItem = _orderItemFactory.Create(
requestOrderPosition.ProductId,
requestOrderPosition.Price,
requestOrderPosition.Count,
order);
_orderItemRepository.Add(orderItem);
}
// Change user statistic
var statistic = await _userStatisticRepository.GetOneAsync(user.Id);
if (statistic == null)
{
statistic = new UserStatisticEntity {
User = user
};
statistic.OrdersCount++;
statistic.TotalOrdersPrice += order.TotalPrice;
statistic.Bonus += order.TotalPrice * _bonusPart;
_userStatisticRepository.Add(statistic);
}
else
{
statistic.OrdersCount++;
statistic.TotalOrdersPrice += order.TotalPrice;
statistic.Bonus += order.TotalPrice * _bonusPart;
_userStatisticRepository.Update(statistic);
}
await _orderRepository.SaveChangesAsync();
return(_mapper.Map <OrderModel>(order));
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
return(null);
}
}
