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 <ReviewDto> DeleteAsync(int id)
{
var review = await GetReviewByIdOrThrowAsync(id);
_reviewRepository.Delete(review);
await SaveProvider.SaveAsync();
return(Mapper.Map <ReviewDto>(review));
}
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));
}
/// <summary>
/// Set configuration For Initialize Game Service.
/// </summary>
/// <param name="configuration">(NOTNULL)configuration For Initialize Game Service</param>
public static void ConfigurationInstance(GameServiceClientConfiguration configuration)
{
if (configuration == null)
{
throw new GameServiceException("Configuration Cant Be Null").LogException(typeof(GameService),
DebugLocation.Internal, "ConfigurationInstance");
}
if (SynchronizationContext.Current == null)
{
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
}
SynchronizationContext = SynchronizationContext.Current;
if (IsAuthenticated())
{
throw new GameServiceException("Must Logout First To ReConfiguration").LogException(typeof(GameService),
DebugLocation.Internal, "ConfigurationInstance");
}
Configuration = configuration;
HandlerType = EventHandlerType.UnityContext;
DownloadManager = new DownloadManager(Configuration);
Achievement = new AchievementProvider();
Assets = new AssetsProvider();
Data = new DataProvider();
Table = new TableProvider();
CloudFunction = new CloudFunctionProvider();
Leaderboard = new LeaderboardProvider();
LoginOrSignUp = new LoginOrSignUpProvider();
Player = new PlayerProvider();
Save = new SaveProvider();
GSLive = new GsLive();
Social = new Social.Social();
}
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));
}
