public async Task <CommandResult <CommentViewModel> > ExecuteAsync(CommentViewModel commentserviceVm)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = await _userManager.FindByIdAsync(userId);
try
{
var CommentUpdate = await _commentRepository.FindByIdAsync(commentserviceVm.Id);
if (CommentUpdate != null)
{
CommentUpdate.ContentOfRating = commentserviceVm.ContentOfRating;
CommentUpdate.UserId = Guid.Parse(commentserviceVm.UserId);
CommentUpdate.ServiceId = Guid.Parse(commentserviceVm.ServiceId);
var getUserService = await _getOwnServiceInformationQuery.ExecuteAsync(CommentUpdate.ServiceId.ToString());
_commentRepository.Update(CommentUpdate);
await _commentRepository.SaveAsync();
await LoggingUser <UpdateCommentServiceAsyncCommand> .InformationAsync(getUserService, userName.UserName, CommentUpdate.ContentOfRating);
await Logging <UpdateCommentServiceAsyncCommand> .InformationAsync(ActionCommand.COMMAND_UPDATE, userName.UserName, userName.UserName + " updated " + CommentUpdate.ContentOfRating);
return(new CommandResult <CommentViewModel>
{
isValid = true,
myModel = new CommentViewModel
{
Id = CommentUpdate.Id,
UserId = CommentUpdate.UserId.ToString(),
ServiceId = CommentUpdate.ServiceId.ToString(),
ContentOfRating = CommentUpdate.ContentOfRating
}
});
}
else
{
await Logging <UpdateCommentServiceAsyncCommand> .ErrorAsync(ActionCommand.COMMAND_UPDATE, userName.UserName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <CommentViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
}
catch (System.Exception ex)
{
await Logging <UpdateCommentServiceAsyncCommand> .ErrorAsync(ex, ActionCommand.COMMAND_UPDATE, userName.UserName, "Has error");
return(new CommandResult <CommentViewModel>
{
isValid = false,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <CommentViewModel> > ExecuteAsync(int id)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = await _userManager.FindByIdAsync(userId);
try
{
var commentDel = await _commentRepository.FindByIdAsync(id);
if (commentDel != null)
{
var getUserService = await _getOwnServiceInformationQuery.ExecuteAsync(commentDel.ServiceId.ToString());
_commentRepository.Remove(commentDel);
await _commentRepository.SaveAsync();
await LoggingUser <DeleteCommentServiceAsyncCommand> .InformationAsync(getUserService, userName.UserName, commentDel.ContentOfRating);
await Logging <DeleteCommentServiceAsyncCommand> .InformationAsync(ActionCommand.COMMAND_DELETE, userName.UserName, userName.UserName + " deleted " + commentDel.ContentOfRating);
return(new CommandResult <CommentViewModel>
{
isValid = true,
myModel = new CommentViewModel
{
Id = commentDel.Id,
}
});
}
else
{
await Logging <DeleteCommentServiceAsyncCommand> .ErrorAsync(ActionCommand.COMMAND_DELETE, userName.UserName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <CommentViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
}
catch (System.Exception ex)
{
await Logging <DeleteCommentServiceAsyncCommand> .ErrorAsync(ex, ActionCommand.COMMAND_DELETE, userName.UserName, "Has error");
return(new CommandResult <CommentViewModel>
{
isValid = true,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <CommentViewModel> > ExecuteAsync(CommentViewModel addComment)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = await _userManager.FindByIdAsync(userId);
try
{
var comment = new ServiceComment
{
ContentOfRating = addComment.ContentOfRating,
UserId = Guid.Parse(addComment.UserId),
ServiceId = Guid.Parse(addComment.ServiceId),
ParentId = addComment.ParentId
};
await _commentRepository.Add(comment);
await _commentRepository.SaveAsync();
var getOwnerService = await _getOwnServiceInformationQuery.ExecuteAsync(addComment.ServiceId);
await LoggingUser <AddCommentServiceAsyncCommand> .
InformationAsync(getOwnerService, userName.UserName, addComment.ContentOfRating);
await Logging <AddCommentServiceAsyncCommand> .InformationAsync(ActionCommand.COMMAND_ADD, userName.UserName, JsonConvert.SerializeObject(addComment));
return(new CommandResult <CommentViewModel>
{
isValid = true,
myModel = new CommentViewModel
{
ContentOfRating = comment.ContentOfRating,
Id = comment.Id,
ParentId = comment.ParentId,
ServiceId = comment.ServiceId.ToString(),
UserId = comment.UserId.ToString()
}
});
}
catch (Exception ex)
{
await Logging <AddCommentServiceAsyncCommand> .ErrorAsync(ex, ActionCommand.COMMAND_ADD, userName.UserName, "Has error");
return(new CommandResult <CommentViewModel>
{
isValid = false,
errorMessage = ex.InnerException.Message.ToString()
});
}
}
public override async Task <UserLog> GetLogsForUser(LoggingUser request, ServerCallContext context)
{
var res = await _loggingService.FindUserLog(request.SteamId);
return(new UserLog
{
SteamId = res.SteamId,
Logs =
{
res.Logs.Select(log => new RpcCommunication.Log
{
Action = log.Action,
Time = log.Time.ToBinary().ToString(),
Value = log.Value,
})
}
});
}
public async Task <CommandResult <NewsProviderViewModel> > ExecuteAsync(int id, string reason)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userRepository.FindByIdAsync(userId).Result.UserName;
try
{
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) || await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.NEWS, ActionSetting.CanUpdate))
{
var mappingProvider = await _newProviderRepository.FindByIdAsync(id);
if (mappingProvider == null)
{
return(new CommandResult <NewsProviderViewModel>
{
isValid = false,
errorMessage = "Cannot find your new"
});
}
var map = MappingNewProvider(mappingProvider);
_newProviderRepository.Update(map);
await _newProviderRepository.SaveAsync();
//Send mail service
var getProvider = await _providerRepository.FindSingleAsync(x => x.Id == mappingProvider.ProviderId);
var getEmail = await _userRepository.FindByIdAsync(getProvider.UserId.ToString());
//Set content for email
var getAllEmail = await _getAllEmailServiceQuery.ExecuteAsync();
var getFirstEmail = getAllEmail.Where(x => x.Name == EmailName.Reject_News).FirstOrDefault();
getFirstEmail.Message = getFirstEmail.Message.Replace(EmailKey.UserNameKey, getEmail.UserName)
.Replace(EmailKey.NewNameKey, mappingProvider.Title)
.Replace(EmailKey.ReasonKey, reason);
ContentEmail(_configEmail.Value.SendGridKey, getFirstEmail.Subject,
getFirstEmail.Message, getEmail.Email).Wait();
//Write Log
await LoggingUser <RejectNewsProviderServiceCommand> .
InformationAsync(getProvider.UserId.ToString(), userName, userName + "Tin tức:" + map.Title + "của bạn đã bị từ chối. Xin vui lòng kiểm tra lại email");
await Logging <RejectNewsProviderServiceCommand> .
InformationAsync(ActionCommand.COMMAND_REJECT, userName, JsonConvert.SerializeObject(map.Title + "has been rejecte.Please check your email"));
return(new CommandResult <NewsProviderViewModel>
{
isValid = true,
errorMessage = "You have been rejected. Please check your email"
});
}
else
{
await Logging <RejectNewsProviderServiceCommand> .
WarningAsync(ActionCommand.COMMAND_REJECT, userName, ErrorMessageConstant.ERROR_UPDATE_PERMISSION);
return(new CommandResult <NewsProviderViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_UPDATE_PERMISSION
});
}
}
catch (Exception ex)
{
await Logging <RejectNewsProviderServiceCommand> .
ErrorAsync(ex, ActionCommand.COMMAND_REJECT, userName, "Has error");
return(new CommandResult <NewsProviderViewModel>
{
isValid = false,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <ProviderServiceViewModel> > ExecuteAsync(string userProvider, string providerId)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userRepository.FindByIdAsync(userId).Result.UserName;
try
{
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) || await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.PROVIDER, ActionSetting.CanUpdate))
{
var getUserService = await _getPostUserServiceByUserIdQuery.ExecuteAsync(userProvider);
if (getUserService != null)
{
await _deleteServiceFromUserCommand.ExecuteAsync(getUserService.Id.ToString());
}
var mappingProvider = await _providerRepository.FindByIdAsync(Guid.Parse(providerId));
//Write Log
await Logging <ApproveProviderServiceCommand> .
WarningAsync(ActionCommand.COMMAND_APPROVE, userName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
if (mappingProvider == null)
{
return(new CommandResult <ProviderServiceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
//Check user is Provider
var getAllUserProvider = await _providerRepository.FindAllAsync(x => x.UserId == mappingProvider.UserId);
if (getAllUserProvider.Count() > 1)
{
return(new CommandResult <ProviderServiceViewModel>
{
isValid = false,
errorMessage = "This user cannot register over 1 provider"
});
}
mappingProvider.Status = Status.WaitingApprove;
_providerRepository.Update(mappingProvider);
var findUserId = await _userRepository.FindByIdAsync(mappingProvider.UserId.ToString());
var getAllRoleUser = await _userRepository.GetRolesAsync(findUserId);
var countRole = 0;
foreach (var item in getAllRoleUser)
{
if (item == ConstantRoles.Provider)
{
countRole++;
}
}
if (countRole == 0)
{
await _userRepository.AddToRoleAsync(findUserId, ConstantRoles.Provider);
}
await _providerRepository.SaveAsync();
var userMail = await _userRepository.FindByIdAsync(mappingProvider.UserId.ToString());
//Set content for email
var getEmailContent = await _getAllEmailServiceQuery.ExecuteAsync();
var getFirstEmail = getEmailContent.Where(x => x.Name == EmailName.Approve_Provider).FirstOrDefault();
var generateCode = _configuration.GetSection("Host").GetSection("LinkConfirmProvider").Value +
mappingProvider.OTPConfirm + '_' + mappingProvider.Id;
getFirstEmail.Message = getFirstEmail.Message.
Replace(EmailKey.UserNameKey, userMail.Email).
Replace(EmailKey.ConfirmLink, generateCode);
ContentEmail(_config.Value.SendGridKey, getFirstEmail.Subject,
getFirstEmail.Message, userMail.Email).Wait();
//Write log
await LoggingUser <ApproveProviderServiceCommand> .
InformationAsync(mappingProvider.UserId.ToString(), userName, userName + "Nhà cung cấp:" + mappingProvider.ProviderName + "đã được chấp thuận. Check mail để xác nhận dịch vụ");
await Logging <ApproveProviderServiceCommand> .
InformationAsync(ActionCommand.COMMAND_APPROVE, userName, mappingProvider.ProviderName + "has been approved");
return(new CommandResult <ProviderServiceViewModel>
{
isValid = true,
});
}
else
{
await Logging <ApproveProviderServiceCommand> .
WarningAsync(ActionCommand.COMMAND_APPROVE, userName, ErrorMessageConstant.ERROR_UPDATE_PERMISSION);
return(new CommandResult <ProviderServiceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_UPDATE_PERMISSION
});
}
}
catch (Exception ex)
{
await Logging <ApproveProviderServiceCommand> .
ErrorAsync(ex, ActionCommand.COMMAND_APPROVE, userName, "Has error");
return(new CommandResult <ProviderServiceViewModel>
{
isValid = false,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <PostServiceViewModel> > ExecuteAsync(string idService, string reason)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userRepository.FindByIdAsync(userId).Result.UserName;
try
{
//Check permission approve
if (await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.SERVICE, ActionSetting.CanUpdate) ||
await _checkUserIsAdminQuery.ExecuteAsync(userId))
{
//Check have current post
var getCurrentPost = await _postServiceRepository.FindByIdAsync(Guid.Parse(idService));
if (getCurrentPost != null)
{
var getUserId = await _getOwnServiceInformationQuery.ExecuteAsync(idService);
getCurrentPost.Status = Status.Active;
_postServiceRepository.Update(getCurrentPost);
await _postServiceRepository.SaveAsync();
var findEmailUser = await GetEmailUserAsync(getCurrentPost);
if (findEmailUser != ErrorMessageConstant.ERROR_CANNOT_FIND_ID)
{
//Set content for email
//Get all email
var getAllEmail = await _getAllEmailServiceQuery.ExecuteAsync();
var getFirstEmail = getAllEmail.Where(x => x.Name == EmailName.Reject_Service).FirstOrDefault();
getFirstEmail.Message = getFirstEmail.Message.
Replace(EmailKey.ServiceNameKey, getCurrentPost.ServiceName)
.Replace(EmailKey.UserNameKey, findEmailUser)
.Replace(EmailKey.ReasonKey, reason);
ContentEmail(_configEmail.Value.SendGridKey, getFirstEmail.Subject,
getFirstEmail.Message, findEmailUser).Wait();
}
else
{
await Logging <RejectPostServiceCommand> .
WarningAsync(ActionCommand.COMMAND_APPROVE, userName, "Cannot find email");
return(new CommandResult <PostServiceViewModel>
{
isValid = false,
errorMessage = "Cannot find email user"
});
}
//Write Log
await Logging <RejectPostServiceCommand> .
InformationAsync(ActionCommand.COMMAND_APPROVE, userName, getCurrentPost.ServiceName + "has been rejected");
await LoggingUser <RejectPostServiceCommand> .
InformationAsync(getUserId, userName, userName + "Dịch vụ " + getCurrentPost.ServiceName + "đã bị từ chối. Check mail để xác nhận");
return(new CommandResult <PostServiceViewModel>
{
isValid = true,
});
}
//Write log
await Logging <RejectPostServiceCommand> .
WarningAsync(ActionCommand.COMMAND_APPROVE, userName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <PostServiceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
else
{
await Logging <RejectPostServiceCommand> .
WarningAsync(ActionCommand.COMMAND_APPROVE, userName, ErrorMessageConstant.ERROR_UPDATE_PERMISSION);
return(new CommandResult <PostServiceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_UPDATE_PERMISSION
});
}
}
catch (System.Exception ex)
{
await Logging <RejectPostServiceCommand> .
ErrorAsync(ex, ActionCommand.COMMAND_APPROVE, userName, "Has error");
return(new CommandResult <PostServiceViewModel>
{
isValid = false,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <ServiceFollowingViewModel> > ExecuteAsync(ServiceFollowingViewModel serviceFollowingViewModel)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = await _userManager.FindByIdAsync(userId);
try
{
var checkUserHasFollow = await _serviceFollowingRepository.FindSingleAsync(x =>
x.ServiceId == Guid.Parse(serviceFollowingViewModel.ServiceId) &&
x.UserId == Guid.Parse(serviceFollowingViewModel.UserId));
var getOwnerService = await _getOwnServiceInformationQuery.ExecuteAsync(serviceFollowingViewModel.ServiceId);
if (checkUserHasFollow != null)
{
await Logging <FollowPostServiceCommand> .ErrorAsync(ActionCommand.COMMAND_ADD, userName.UserName, "You had follow this service");
return(new CommandResult <ServiceFollowingViewModel>
{
isValid = false,
errorMessage = "You had follow this service"
});
}
var postService = await _serviceRepository.FindByIdAsync(Guid.Parse(serviceFollowingViewModel.ServiceId));
if (postService == null)
{
await Logging <FollowPostServiceCommand> .ErrorAsync(ActionCommand.COMMAND_ADD, userName.UserName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <ServiceFollowingViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
var data = MappingData(serviceFollowingViewModel);
await _serviceFollowingRepository.Add(data);
await _serviceFollowingRepository.SaveAsync();
await LoggingUser <FollowPostServiceCommand> .
InformationAsync(getOwnerService, userName.UserName, userName.UserName + " had follow" + postService.ServiceName);
await Logging <FollowPostServiceCommand> .InformationAsync(ActionCommand.COMMAND_ADD, userName.UserName, JsonConvert.SerializeObject(serviceFollowingViewModel));
return(new CommandResult <ServiceFollowingViewModel>
{
isValid = true,
myModel = serviceFollowingViewModel
});
}
catch (Exception ex)
{
await Logging <FollowPostServiceCommand> .ErrorAsync(ex, ActionCommand.COMMAND_ADD, userName.UserName, "Has error");
return(new CommandResult <ServiceFollowingViewModel>
{
isValid = false,
errorMessage = ex.InnerException.Message.ToString()
});
}
}
public async Task <CommandResult <FollowingProviderServiceViewModel> > ExecuteAsync(FollowingProviderServiceViewModel vm)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = await _userManager.FindByIdAsync(userId);
try
{
var checkUserHasFollowProvider = await _providerFollowingRepository.FindAllAsync(x =>
x.ProviderId == Guid.Parse(vm.ProviderId) && x.UserId == Guid.Parse(vm.UserId));
if (checkUserHasFollowProvider.Count() != 0)
{
await Logging <FollowProviderServiceCommand> .
ErrorAsync(ActionCommand.COMMAND_ADD, userName.UserName, userName.UserName + "had follow provider");
return(new CommandResult <FollowingProviderServiceViewModel>
{
isValid = false,
errorMessage = "You had follow this provider"
});
}
var getProvider = await _providerRepository.FindByIdAsync(Guid.Parse(vm.ProviderId));
if (getProvider == null)
{
await Logging <FollowProviderServiceCommand> .
ErrorAsync(ActionCommand.COMMAND_ADD, userName.UserName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <FollowingProviderServiceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
var data = MappingData(vm);
await _providerFollowingRepository.Add(data);
await _providerFollowingRepository.SaveAsync();
await LoggingUser <FollowProviderServiceCommand> .
InformationAsync(getProvider.UserId.ToString(), userName.UserName, userName.UserName + " đã theo dõi provider của bạn");
await Logging <FollowProviderServiceCommand> .InformationAsync(ActionCommand.COMMAND_ADD, userName.UserName, JsonConvert.SerializeObject(data));
return(new CommandResult <FollowingProviderServiceViewModel>
{
isValid = true,
myModel = vm
});
}
catch (Exception ex)
{
await Logging <FollowProviderServiceCommand> .ErrorAsync(ex, ActionCommand.COMMAND_ADD, userName.UserName, "Has error:");
return(new CommandResult <FollowingProviderServiceViewModel>
{
isValid = false,
errorMessage = ex.InnerException.Message.ToString()
});
}
}
public async Task <CommandResult <ProviderServiceViewModel> > ExecuteAsync(string providerId, string reason)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userRepository.FindByIdAsync(userId).Result.UserName;
try
{
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) || await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.PROVIDER, ActionSetting.CanUpdate))
{
var mappingProvider = await _providerRepository.FindByIdAsync(Guid.Parse(providerId));
if (mappingProvider == null)
{
return(new CommandResult <ProviderServiceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
//Check user is Provider
if (_checkUserIsProviderQuery.ExecuteAsync(userId).Result.isValid == true)
{
var providerRole = await _roleRepository.FindByNameAsync(ConstantRoles.Provider);
_userRoleRepository.DeleteUserRole(mappingProvider.UserId, providerRole.Id);
}
mappingProvider.Status = Status.InActive;
_providerRepository.Update(mappingProvider);
await _providerRepository.SaveAsync();
var userMail = await _userRepository.FindByIdAsync(mappingProvider.UserId.ToString());
//Set content for email
var getEmailContent = await _getAllEmailServiceQuery.ExecuteAsync();
var getFirstEmail = getEmailContent.Where(x => x.Name == EmailName.Reject_Provider).FirstOrDefault();
getFirstEmail.Message = getFirstEmail.Message.Replace(EmailKey.UserNameKey, userMail.Email).Replace(EmailKey.ReasonKey, reason);
ContentEmail(_config.Value.SendGridKey, getFirstEmail.Subject,
getFirstEmail.Message, userMail.Email).Wait();
await LoggingUser <RejectProviderServiceCommand> .
InformationAsync(mappingProvider.UserId.ToString(), userName, userName + "Nhà cung cấp :" + mappingProvider.ProviderName + "của bạn đã bị từ chối.Kiểm tra mail để xem lí do");
await Logging <RejectProviderServiceCommand> .
InformationAsync(ActionCommand.COMMAND_REJECT, userName, mappingProvider.ProviderName + "has been rejected");
return(new CommandResult <ProviderServiceViewModel>
{
isValid = true,
});
}
else
{
await Logging <RejectProviderServiceCommand> .
WarningAsync(ActionCommand.COMMAND_REJECT, userName, ErrorMessageConstant.ERROR_UPDATE_PERMISSION);
return(new CommandResult <ProviderServiceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_UPDATE_PERMISSION
});
}
}
catch (Exception ex)
{
await Logging <RejectProviderServiceCommand> .
ErrorAsync(ex, ActionCommand.COMMAND_REJECT, userName, "Has error");
return(new CommandResult <ProviderServiceViewModel>
{
isValid = false,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <ServiceRatingViewModel> > ExecuteAsync(ServiceRatingViewModel serviceRatingViewModel)
{
var getUserId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userManager.FindByIdAsync(getUserId).Result.UserName;
try
{
//Check provider has available
var getService = await _serviceRepository.FindByIdAsync(Guid.Parse(serviceRatingViewModel.ServiceId));
if (getService == null)
{
await Logging <AddUpdateRatingServiceCommand>
.WarningAsync(ActionCommand.COMMAND_ADD, userName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <ServiceRatingViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
var getServiceRating = await _serviceRatingRepository.FindSingleAsync(x => x.ServiceId == Guid.Parse(serviceRatingViewModel.ServiceId) &&
x.UserId == Guid.Parse(serviceRatingViewModel.UserId));
if (getServiceRating != null)
{
var getUserService = _getOwnServiceInformationQuery.ExecuteAsync(serviceRatingViewModel.ServiceId);
getServiceRating.NumberOfRating = serviceRatingViewModel.NumberOfRating;
getServiceRating.DateModified = DateTime.Now;
_serviceRatingRepository.Update(getServiceRating);
await _serviceRatingRepository.SaveAsync();
await LoggingUser <AddUpdateRatingServiceCommand> .
InformationAsync(getUserId, userName, userName + "rated"
+ getService.ServiceName + " with" + getServiceRating.NumberOfRating);
await Logging <AddUpdateRatingServiceCommand> .InformationAsync(ActionCommand.COMMAND_ADD, userName,
JsonConvert.SerializeObject(serviceRatingViewModel));
return(new CommandResult <ServiceRatingViewModel>
{
isValid = true,
myModel = serviceRatingViewModel
});
}
var query = new ServiceRating
{
NumberOfRating = serviceRatingViewModel.NumberOfRating,
DateCreated = DateTime.Now,
ServiceId = Guid.Parse(serviceRatingViewModel.ServiceId),
UserId = Guid.Parse(getUserId)
};
await _serviceRatingRepository.Add(query);
await _serviceRatingRepository.SaveAsync();
await LoggingUser <AddUpdateRatingServiceCommand> .
InformationAsync(getUserId, userName, userName + "rated"
+ getService.ServiceName + " with" + query.NumberOfRating);
await Logging <AddUpdateRatingServiceCommand> .InformationAsync(ActionCommand.COMMAND_ADD, userName,
JsonConvert.SerializeObject(serviceRatingViewModel));
return(new CommandResult <ServiceRatingViewModel>
{
isValid = true,
myModel = serviceRatingViewModel
});
}
catch (Exception ex)
{
await Logging <AddUpdateRatingServiceCommand> .
ErrorAsync(ex, ActionCommand.COMMAND_ADD, userName, "Has Error");
return(new CommandResult <ServiceRatingViewModel>
{
isValid = false,
errorMessage = ex.InnerException.Message.ToString()
});
}
}
public async Task <CommandResult <FollowingProviderServiceViewModel> > ExecuteAsync(int idRegister)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = await _userManager.FindByIdAsync(userId);
try
{
var findIdRegister = await _providerFollowingRepository.FindByIdAsync(idRegister);
if (findIdRegister == null)
{
await Logging <RegisterEmailProviderServiceCommand>
.ErrorAsync(ActionCommand.COMMAND_UPDATE, userName.UserName, "Cannot find your following");
return(new CommandResult <FollowingProviderServiceViewModel>
{
isValid = false,
errorMessage = "Cannot find your following"
});
}
var getProvider = await _providerRepository.FindByIdAsync(findIdRegister.ProviderId);
if (getProvider == null)
{
await Logging <RegisterEmailProviderServiceCommand> .
ErrorAsync(ActionCommand.COMMAND_ADD, userName.UserName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <FollowingProviderServiceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
if (findIdRegister.IsReceiveEmail)
{
findIdRegister.IsReceiveEmail = !findIdRegister.IsReceiveEmail;
}
else
{
findIdRegister.IsReceiveEmail = !findIdRegister.IsReceiveEmail;
}
_providerFollowingRepository.Update(findIdRegister);
await _providerFollowingRepository.SaveAsync();
await LoggingUser <RegisterEmailProviderServiceCommand> .
InformationAsync(getProvider.UserId.ToString(), userName.UserName, userName.UserName + " had follow your provider");
await Logging <RegisterEmailProviderServiceCommand> .InformationAsync(ActionCommand.COMMAND_UPDATE, userName.UserName, JsonConvert.SerializeObject(findIdRegister));
return(new CommandResult <FollowingProviderServiceViewModel>
{
isValid = true,
myModel = new FollowingProviderServiceViewModel
{
UserId = findIdRegister.UserId.ToString(),
DateCreated = DateTime.Now,
IsReceiveEmail = findIdRegister.IsReceiveEmail,
ProviderId = findIdRegister.ProviderId.ToString()
}
});
}
catch (Exception ex)
{
await Logging <RegisterEmailProviderServiceCommand> .ErrorAsync(ex, ActionCommand.COMMAND_UPDATE, userName.UserName, "Has error");
return(new CommandResult <FollowingProviderServiceViewModel>
{
isValid = false,
errorMessage = ex.InnerException.Message.ToString()
});
}
}
public async Task <CommandResult <NewsProviderViewModel> > ExecuteAsync(int idNews)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userRepository.FindByIdAsync(userId).Result.UserName;
try
{//Check user has permission first
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) || await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.NEWS, ActionSetting.CanUpdate))
{
var mappingProvider = await _newProviderRepository.FindByIdAsync(idNews);
if (mappingProvider == null)
{
return(new CommandResult <NewsProviderViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
var map = MappingNewProvider(mappingProvider);
_newProviderRepository.Update(map);
await _newProviderRepository.SaveAsync();
var getProvider = await _providerRepository.FindSingleAsync(x => x.Id == mappingProvider.ProviderId);
var getEmail = await _userRepository.FindByIdAsync(getProvider.UserId.ToString());
//Set content for email
var getAllEmail = await _getAllEmailServiceQuery.ExecuteAsync();
var getFirstEmail = getAllEmail.Where(x => x.Name == EmailName.Approve_News).FirstOrDefault();
var generateCode = _configuration.GetSection("Host").GetSection("LinkConfirmNewsProvider").Value +
mappingProvider.CodeConfirm + '_' + mappingProvider.Id;
getFirstEmail.Message = getFirstEmail.Message.
Replace(EmailKey.UserNameKey, getEmail.UserName).
Replace(EmailKey.NewNameKey, mappingProvider.Title).
Replace(EmailKey.ConfirmLink, generateCode);;
ContentEmail(_configEmail.Value.SendGridKey, getFirstEmail.Subject,
getFirstEmail.Message, getEmail.Email).Wait();
await LoggingUser <ApproveNewsProviderServiceCommand> .
InformationAsync(getProvider.UserId.ToString(), userName, userName + "Tin tức" + map.Title + "của bạn đã được chấp thuận");
await Logging <ApproveNewsProviderServiceCommand> .
InformationAsync(ActionCommand.COMMAND_APPROVE, userName, userName + "Your news provider:" + map.Title + "has been approved");
return(new CommandResult <NewsProviderViewModel>
{
isValid = true,
});
}
else
{
await Logging <ApproveNewsProviderServiceCommand> .
WarningAsync(ActionCommand.COMMAND_APPROVE, userName, ErrorMessageConstant.ERROR_UPDATE_PERMISSION);
return(new CommandResult <NewsProviderViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_UPDATE_PERMISSION
});
}
}
catch (Exception ex)
{
await Logging <ApproveNewsProviderServiceCommand> .
ErrorAsync(ex, ActionCommand.COMMAND_APPROVE, userName, "Has error");
return(new CommandResult <NewsProviderViewModel>
{
isValid = false,
errorMessage = ex.InnerException.ToString()
});
}
}
