public async Task <ReviewDto> DeleteAsync(int id) { var review = await GetReviewByIdOrThrowAsync(id); _reviewRepository.Delete(review); await SaveProvider.SaveAsync(); return(Mapper.Map <ReviewDto>(review)); }
public async Task <OrderDto> DeleteAsync(int id) { var order = await GetOrderByIdOrThrowAsync(id); _serviceOrderRepository.Delete(order); await SaveProvider.SaveAsync(); return(Mapper.Map <OrderDto>(order)); }
public async Task <ServiceTypeDto> DeleteAsync(int id) { var service = await GetByIdOrThrowAsync(id); _serviceTypeRepository.Delete(service); await SaveProvider.SaveAsync(); return(Mapper.Map <ServiceTypeDto>(service)); }
public async Task <EmployeeProfileDto> DeleteEmployeeAsync(Guid id) { var employeeProfile = await GetEmployeeByIdOrThrowAsync(id); _employeeRepository.Delete(employeeProfile); await SaveProvider.SaveAsync(); return(Mapper.Map <EmployeeProfileDto>(employeeProfile)); }
public async Task <ServiceTypeDto> CreateAsync(ServiceTypeCreateDto item) { if (await _serviceTypeRepository.AnyServiceAsync(x => x.Name == item.Name)) { throw new FieldLogicException($"Service type with name {item.Name} already exists!", nameof(item.Name)); } var service = Mapper.Map <ServiceType>(item); _serviceTypeRepository.Create(service); await SaveProvider.SaveAsync(); return(Mapper.Map <ServiceTypeDto>(service)); }
public async Task <EmployeeProfileDto> UpdateEmployeeAsync(EmployeeProfileUpdateDto employeeProfileDto) { var employeeProfile = await GetEmployeeByIdOrThrowAsync(employeeProfileDto.Id); Mapper.Map(employeeProfileDto, employeeProfile); employeeProfile.ServiceType = await _serviceTypeRepository.GetByNameOrCreateNewAsync(employeeProfileDto.ServiceType); employeeProfile.ServiceTypeId = employeeProfile.ServiceType.Id; _employeeRepository.Update(employeeProfile); await SaveProvider.SaveAsync(); return(Mapper.Map <EmployeeProfileDto>(employeeProfile)); }
public async Task <OrderDto> CreateAsync(OrderCreateDto orderDto) { if (!await _employeeRepository.AnyEmployeeAsync(x => x.Id == orderDto.EmployeeId)) { throw new NotFoundLogicException($"Employee with id {orderDto.EmployeeId} not found!", nameof(orderDto.EmployeeId)); } if (!await _userRepository.AnyUserAsync(x => x.Id == orderDto.ClientId)) { throw new NotFoundLogicException($"Client with id {orderDto.ClientId} not found!", nameof(orderDto.ClientId)); } var order = Mapper.Map <ServiceOrder>(orderDto); order.Date = DateTime.Now; _serviceOrderRepository.Create(order); await SaveProvider.SaveAsync(); return(Mapper.Map <OrderDto>(order)); }
public async Task <EmployeeProfileDto> CreateEmployeeAsync(EmployeeProfileCreateDto employeeProfileDto) { if (!await _userRepository.AnyUserAsync(x => x.Id == employeeProfileDto.UserId)) { throw new NotFoundLogicException($"User with id {employeeProfileDto.UserId} not found!", nameof(employeeProfileDto.UserId)); } if (await _employeeRepository.AnyEmployeeAsync(x => x.UserId == employeeProfileDto.UserId)) { throw new LogicException($"Employee profile for user with id {employeeProfileDto.UserId} has been already created!"); } var employeeProfile = Mapper.Map <EmployeeProfileCreateDto, EmployeeProfile>(employeeProfileDto); employeeProfile.ServiceType = await _serviceTypeRepository.GetByNameOrCreateNewAsync(employeeProfileDto.ServiceType); _employeeRepository.Create(employeeProfile); await SaveProvider.SaveAsync(); return(Mapper.Map <EmployeeProfileDto>(employeeProfile)); }
public async Task <ReviewDto> CreateAsync(ReviewCreateDto reviewDto) { if (!await _userRepository.AnyUserAsync(x => x.Id == reviewDto.ClientId)) { throw new NotFoundLogicException($"Client with id {reviewDto.ClientId} not found!", nameof(reviewDto.ClientId)); } if (!await _employeeRepository.AnyEmployeeAsync(x => x.Id == reviewDto.EmployeeId)) { throw new NotFoundLogicException($"Employee with id {reviewDto.EmployeeId} not found!", nameof(reviewDto.EmployeeId)); } var review = Mapper.Map <Review>(reviewDto); review.Date = DateTime.Now; _reviewRepository.Create(review); await SaveProvider.SaveAsync(); return(Mapper.Map <ReviewDto>(review)); }
public async Task <UserDto> UpdateProfileAsync(UserDto userDto) { var user = await GetUserByIdOrThrowAsync(userDto.Id); var oldImagePublicId = user.ImagePublicId; Mapper.Map(userDto, user); _userRepository.Update(user); await SaveProvider.SaveAsync(); if (user.ImagePublicId != oldImagePublicId) { await _pictureService.DeleteImageAsync(oldImagePublicId); await _pictureService.ChangeImageTagAsync(user.ImagePublicId, CloudinaryTagDefaults.Employee); } await _pictureService.DeleteTemporaryImagesAsync(); return(userDto); }
public async Task <UserAuthDto> CreateAsync(UserCreateDto userDto) { if (await _userRepository.AnyUserAsync(x => x.Email == userDto.Email)) { throw new FieldLogicException($"User with email {userDto.Email} already exists!", nameof(userDto.Email)); } var user = Mapper.Map <User>(userDto); user.HashedPassword = _passwordHasher.HashPassword(user, userDto.Password); user.RoleId = await _roleRepository.GetRoleIdByNameAsync(userDto.Role); _userRepository.Create(user); await SaveProvider.SaveAsync(); await _pictureService.ChangeImageTagAsync(user.ImagePublicId, CloudinaryTagDefaults.Employee); await _pictureService.DeleteTemporaryImagesAsync(); return(Mapper.Map <UserAuthDto>(user)); }
private async Task <OrderDto> SetOrderStatusAsync(int id, OrderStatus status) { var order = await GetOrderByIdOrThrowAsync(id); switch (status) { case OrderStatus.Declined when order.Status == OrderStatus.WaitingForEmployee: break; case OrderStatus.InProgress when order.Status == OrderStatus.WaitingForEmployee: break; case OrderStatus.Done when order.Status == OrderStatus.InProgress: break; default: throw new LogicException($"Unable to change status from {order.Status} to {status}"); } order.Status = status; await SaveProvider.SaveAsync(); return(Mapper.Map <OrderDto>(order)); }