public async Task <CommandResult <CityProvinceViewModel> > ExecuteAsync(CityProvinceViewModel vm)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userManager.FindByIdAsync(userId).Result.UserName;
try
{//Check user has permission first
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) || await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.LOCATION, ActionSetting.CanUpdate))
{
var getId = await _cityProvinceRepository.FindByIdAsync(vm.Id);
if (getId == null)
{
await Logging <UpdateCityProvinceServiceCommand> .WarningAsync(ActionCommand.COMMAND_UPDATE, userName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <CityProvinceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
getId.City = vm.City;
getId.Province = vm.Province;
getId.ImgPath = vm.ImgPath;
_cityProvinceRepository.Update(getId);
await _cityProvinceRepository.SaveAsync();
await Logging <UpdateCityProvinceServiceCommand> .
InformationAsync(ActionCommand.COMMAND_UPDATE, userName, JsonConvert.SerializeObject(getId));
return(new CommandResult <CityProvinceViewModel>
{
isValid = true,
myModel = vm
});
}
else
{
await Logging <UpdateCityProvinceServiceCommand>
.WarningAsync(ActionCommand.COMMAND_UPDATE, userName, ErrorMessageConstant.ERROR_UPDATE_PERMISSION);
return(new CommandResult <CityProvinceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_UPDATE_PERMISSION
});
}
}
catch (Exception ex)
{
await Logging <UpdateCityProvinceServiceCommand> .ErrorAsync(ex, ActionCommand.COMMAND_UPDATE, userName, "Has error");
return(new CommandResult <CityProvinceViewModel>
{
isValid = false,
errorMessage = ex.InnerException.Message.ToString()
});
}
}
public async Task <CommandResult <CityProvinceViewModel> > ExecuteAsync(int id)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userManager.FindByIdAsync(userId).Result.UserName;
try
{
//Check user has permission first
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) || await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.LOCATION, ActionSetting.CanDelete))
{
var getById = await _cityProvinceRepository.FindByIdAsync(id);
if (getById == null)
{
await Logging <DeleteCityProvinceServiceCommand> .WarningAsync(ActionCommand.COMMAND_DELETE, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <CityProvinceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
var city_Province = getById.City + "_" + getById.Province;
_cityProvinceRepository.Remove(getById);
await _cityProvinceRepository.SaveAsync();
await Logging <DeleteCityProvinceServiceCommand> .
InformationAsync(ActionCommand.COMMAND_DELETE, userName, "Has delete " + city_Province);
return(new CommandResult <CityProvinceViewModel>
{
isValid = true,
errorMessage = "Has Delete"
});
}
else
{
await Logging <DeleteCityProvinceServiceCommand> .
WarningAsync(ActionCommand.COMMAND_DELETE, ErrorMessageConstant.ERROR_DELETE_PERMISSION);
return(new CommandResult <CityProvinceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_DELETE_PERMISSION
});
}
}
catch (Exception ex)
{
await Logging <DeleteCityProvinceServiceCommand> .ErrorAsync(ex, ActionCommand.COMMAND_DELETE, userName, "Has error");
return(new CommandResult <CityProvinceViewModel>
{
isValid = false,
errorMessage = ex.InnerException.Message.ToString()
});
}
}
public async Task <CommandResult <Email> > ExecuteAsync(EmailViewModel emailViewModel)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = await _userManager.FindByIdAsync(userId);
try
{
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) || await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.EMAIL, ActionSetting.CanUpdate))
{
var checkId = await _emailRepository.FindByIdAsync(emailViewModel.Id);
if (checkId == null)
{
await Logging <UpdateNewEmailServiceCommand> .WarningAsync(ActionCommand.COMMAND_UPDATE, userName.UserName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <Email>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
var mappingEmail = MappingEmail(checkId, emailViewModel);
_emailRepository.Update(mappingEmail);
await _emailRepository.SaveAsync();
await Logging <UpdateNewEmailServiceCommand> .
InformationAsync(ActionCommand.COMMAND_UPDATE, userName.UserName, JsonConvert.SerializeObject(mappingEmail));
return(new CommandResult <Email>
{
isValid = true,
myModel = checkId
});
}
else
{
await Logging <UpdateNewEmailServiceCommand> .
WarningAsync(ActionCommand.COMMAND_UPDATE, userName.UserName, ErrorMessageConstant.ERROR_UPDATE_PERMISSION);
return(new CommandResult <Email>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_UPDATE_PERMISSION
});
}
}
catch (Exception ex)
{
await Logging <UpdateNewEmailServiceCommand> .
ErrorAsync(ex, ActionCommand.COMMAND_UPDATE, userName.UserName, "Has error");
return(new CommandResult <Email>
{
isValid = false,
errorMessage = ex.InnerException.Message.ToString()
});
}
}
public async Task <CommandResult <AppRoleViewModel> > ExecuteAsync(Guid id)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userManager.FindByIdAsync(userId).Result.UserName;
try
{
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) ||
await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.ROLE, ActionSetting.CanDelete))
{
var role = await _roleManager.FindByIdAsync(id.ToString());
if (role != null)
{
await _roleManager.DeleteAsync(role);
await Logging <DeleteRoleAsyncCommand> .InformationAsync(ActionCommand.COMMAND_DELETE, userName, "Had delete" + role.Name);
return(new CommandResult <AppRoleViewModel>
{
isValid = true,
});
}
await Logging <DeleteRoleAsyncCommand>
.WarningAsync(ActionCommand.COMMAND_DELETE, userName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <AppRoleViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
else
{
await Logging <DeleteRoleAsyncCommand>
.WarningAsync(ActionCommand.COMMAND_DELETE, userName, ErrorMessageConstant.ERROR_DELETE_PERMISSION);
return(new CommandResult <AppRoleViewModel>
{
errorMessage = ErrorMessageConstant.ERROR_DELETE_PERMISSION,
isValid = false
});
}
}
catch (System.Exception ex)
{
await Logging <DeleteRoleAsyncCommand>
.ErrorAsync(ex, ActionCommand.COMMAND_DELETE, userName, "Has error");
return(new CommandResult <AppRoleViewModel>
{
isValid = false,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <FunctionViewModelinFunctionService> > ExecuteAsync(string id)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = await _userManager.FindByIdAsync(userId);
try
{
//Check user has permission first
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) || await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.FUNCTION, ActionSetting.CanDelete))
{
var getChildItem = await _functionRepository.FindAllAsync(x => x.ParentId == id);
if (getChildItem.Count() > 0)
{
foreach (var item in getChildItem)
{
item.ParentId = null;
_functionRepository.Update(item);
}
}
_functionRepository.Remove(id);
await _functionRepository.SaveAsync();
await Logging <DeleteFunctionServiceCommand> .InformationAsync(ActionCommand.COMMAND_DELETE, userName.UserName, "Delete " + id);
return(new CommandResult <FunctionViewModelinFunctionService>
{
isValid = true,
myModel = null
});
}
else
{
await Logging <DeleteFunctionServiceCommand>
.WarningAsync(ActionCommand.COMMAND_DELETE, userName.UserName, ErrorMessageConstant.ERROR_DELETE_PERMISSION);
return(new CommandResult <FunctionViewModelinFunctionService>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_DELETE_PERMISSION
});
}
}
catch (System.Exception ex)
{
await Logging <DeleteFunctionServiceCommand> .ErrorAsync(ex, ActionCommand.COMMAND_DELETE, userName.UserName, "Has error");
return(new CommandResult <FunctionViewModelinFunctionService>
{
isValid = false,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <FunctionViewModelinFunctionService> > ExecuteAsync(FunctionViewModelinFunctionService function)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = await _userManager.FindByIdAsync(userId);
try
{
//Check user has permission first
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) || await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.FUNCTION, ActionSetting.CanCreate))
{
var mappingFunction = MappingFunction(function);
await _functionRepository.Add(mappingFunction);
await _functionRepository.SaveAsync();
await Logging <AddFunctionServiceCommand> .InformationAsync(ActionCommand.COMMAND_ADD, userName.UserName, JsonConvert.SerializeObject(mappingFunction));
return(new CommandResult <FunctionViewModelinFunctionService>
{
isValid = true,
myModel = new FunctionViewModelinFunctionService
{
IconCss = mappingFunction.IconCss,
Id = mappingFunction.Id,
Name = mappingFunction.Name,
ParentId = mappingFunction.ParentId,
Status = mappingFunction.Status,
URL = mappingFunction.URL
}
});
}
else
{
await Logging <AddFunctionServiceCommand>
.WarningAsync(ActionCommand.COMMAND_ADD, userName.UserName, ErrorMessageConstant.ERROR_ADD_PERMISSION);
return(new CommandResult <FunctionViewModelinFunctionService>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_ADD_PERMISSION
});
}
}
catch (System.Exception ex)
{
await Logging <AddFunctionServiceCommand> .ErrorAsync(ex, ActionCommand.COMMAND_ADD, userName.UserName, "Has error");
return(new CommandResult <FunctionViewModelinFunctionService>
{
isValid = false,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <AppRoleViewModel> > ExecuteAync(AppRoleViewModel roleVm)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userManager.FindByIdAsync(userId).Result.UserName;
try
{
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) ||
await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.ROLE, ActionSetting.CanCreate))
{
var role = new AppRole()
{
Name = roleVm.Name,
Description = roleVm.Description
};
var result = await _roleManager.CreateAsync(role);
await Logging <AddRoleAsyncCommand> .InformationAsync(ActionCommand.COMMAND_ADD, userName, JsonConvert.SerializeObject(role));
return(new CommandResult <AppRoleViewModel>
{
isValid = result.Succeeded,
myModel = new AppRoleViewModel
{
Description = role.Description,
Name = role.Name,
Id = role.Id
}
});
}
else
{
await Logging <AddRoleAsyncCommand> .WarningAsync(ActionCommand.COMMAND_ADD, userName, ErrorMessageConstant.ERROR_ADD_PERMISSION);
return(new CommandResult <AppRoleViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_ADD_PERMISSION
});
}
}
catch (System.Exception ex)
{
await Logging <AddRoleAsyncCommand> .ErrorAsync(ex, ActionCommand.COMMAND_ADD, userName, "Has error");
return(new CommandResult <AppRoleViewModel>
{
isValid = false,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <CityProvinceViewModel> > ExecuteAsync(CityProvinceViewModel listAddViewModel)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userManager.FindByIdAsync(userId).Result.UserName;
try
{//Check user has permission first
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) || await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.LOCATION, ActionSetting.CanCreate))
{
//Check User Has Permission Create
var listModel = MappingCityProvince(listAddViewModel);
await _cityProvinceRepository.Add(listModel);
await _cityProvinceRepository.SaveAsync();
await Logging <AddCityProvinceServiceCommand> .InformationAsync(ActionCommand.COMMAND_ADD, userName, JsonConvert.SerializeObject(listModel));
return(new CommandResult <CityProvinceViewModel>
{
isValid = true,
myModel = new CityProvinceViewModel()
{
Id = listModel.Id,
City = listModel.City,
Province = listModel.Province,
ImgPath = listModel.ImgPath
}
});
}
else
{
await Logging <AddCityProvinceServiceCommand> .WarningAsync(ActionCommand.COMMAND_ADD, userName, ErrorMessageConstant.ERROR_ADD_PERMISSION);
return(new CommandResult <CityProvinceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_ADD_PERMISSION
});
}
}
catch (Exception ex)
{
await Logging <AddCityProvinceServiceCommand> .ErrorAsync(ex, ActionCommand.COMMAND_ADD, userName, "Has error");
return(new CommandResult <CityProvinceViewModel>
{
isValid = false,
errorMessage = ex.InnerException.Message.ToString()
});
}
}
public async Task <CommandResult <TagViewModel> > ExecuteAsync(TagViewModel userVm)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userManager.FindByIdAsync(userId).Result.UserName;
try
{
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) ||
await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.TAG, ActionSetting.CanCreate))
{
Tag tag = new Tag();
tag.TagName = userVm.TagName;
await _tagRepository.Add(tag);
await _tagRepository.SaveAsync();
await Logging <AddTagServiceAsyncCommand> .InformationAsync(ActionCommand.COMMAND_ADD, userName, JsonConvert.SerializeObject(tag));
return(new CommandResult <TagViewModel>
{
isValid = true,
myModel = new TagViewModel
{
Id = tag.Id.ToString(),
TagName = tag.TagName
}
});
}
else
{
await Logging <AddTagServiceAsyncCommand> .
WarningAsync(ActionCommand.COMMAND_ADD, userName, ErrorMessageConstant.ERROR_ADD_PERMISSION);
return(new CommandResult <TagViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_ADD_PERMISSION
});
}
}
catch (System.Exception ex)
{
await Logging <AddTagServiceAsyncCommand> .ErrorAsync(ex, ActionCommand.COMMAND_ADD, userName, "Has error");
return(new CommandResult <TagViewModel>
{
isValid = false,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <Email> > ExecuteAsync(EmailViewModel emailVIewModel)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = await _userManager.FindByIdAsync(userId);
try
{
//Check user has permission first
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) || await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.EMAIL, ActionSetting.CanCreate))
{
var mappingEmail = MappingEmail(emailVIewModel);
await _emailRepository.Add(mappingEmail);
await _emailRepository.SaveAsync();
await Logging <AddNewEmailServiceCommand> .
InformationAsync(ActionCommand.COMMAND_ADD, userName.UserName, JsonConvert.SerializeObject(mappingEmail));
return(new CommandResult <Email>
{
isValid = true,
myModel = mappingEmail
});
}
else
{
await Logging <AddNewEmailServiceCommand> .
WarningAsync(ActionCommand.COMMAND_ADD, userName.UserName, ErrorMessageConstant.ERROR_ADD_PERMISSION);
return(new CommandResult <Email>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_ADD_PERMISSION
});
}
}
catch (Exception ex)
{
await Logging <AddNewEmailServiceCommand> .ErrorAsync(ex, ActionCommand.COMMAND_ADD, userName.UserName, "You have error");
return(new CommandResult <Email>
{
isValid = false,
errorMessage = ex.InnerException.Message.ToString()
});
}
}
public async Task <CommandResult <CategoryServiceViewModel> > ExecuteAsync(CategoryServiceViewModel userVm)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = await _userManager.FindByIdAsync(userId);
try
{
//Check user has permission first
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) || await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.CATEGORY, ActionSetting.CanUpdate))
{
var categoryUpdate = await _categoryRepository.FindByIdAsync(userVm.Id);
if (categoryUpdate != null)
{
categoryUpdate.CategoryName = userVm.CategoryName;
categoryUpdate.Description = userVm.Description;
categoryUpdate.ImgPath = userVm.ImgPath;
_categoryRepository.Update(categoryUpdate);
await _categoryRepository.SaveAsync();
await Logging <UpdateCategoryServiceCommand> .
InformationAsync(ActionCommand.COMMAND_UPDATE, userName.UserName, JsonConvert.SerializeObject(userVm));
return(new CommandResult <CategoryServiceViewModel>
{
isValid = true,
myModel = userVm,
});
}
else
{
await Logging <UpdateCategoryServiceCommand> .
WarningAsync(ActionCommand.COMMAND_UPDATE, userName.UserName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <CategoryServiceViewModel>
{
isValid = false,
myModel = userVm,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
}
else
{
await Logging <UpdateCategoryServiceCommand> .
WarningAsync(ActionCommand.COMMAND_UPDATE, userName.UserName, ErrorMessageConstant.ERROR_UPDATE_PERMISSION);
return(new CommandResult <CategoryServiceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_UPDATE_PERMISSION
});
}
}
catch (Exception ex)
{
await Logging <UpdateCategoryServiceCommand> .
ErrorAsync(ex, ActionCommand.COMMAND_UPDATE, userName.UserName, "Has error: ");
return(new CommandResult <CategoryServiceViewModel>
{
isValid = false,
myModel = userVm,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <NewsProviderViewModel> > ExecuteAsync(NewsProviderViewModel vm)
{
var userId = _httpContext.HttpContext.User.Identity.Name;
var userName = _userManager.FindByIdAsync(userId).Result.UserName;
try
{
var findProviderNew = await _providerNewsRepository.FindByIdAsync(vm.Id);
if (findProviderNew != null)
{
var getIsProvider = await _checkUserIsProviderQuery.ExecuteAsync(userId);
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) ||
await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.NEWS, ActionSetting.CanUpdate) ||
(getIsProvider.isValid && getIsProvider.myModel.Id == findProviderNew.ProviderId.ToString()))
{
var mappingNewsProvider = await MappingProvider(findProviderNew, vm, userId);
_providerNewsRepository.Update(mappingNewsProvider);
await _providerNewsRepository.SaveAsync();
await Logging <UpdateNewsProviderServiceCommand> .
InformationAsync(ActionCommand.COMMAND_UPDATE, userName, mappingNewsProvider.Author + "had been updated");
//Get Provider Information
var providerInformation = await _providerRepository.FindByIdAsync(Guid.Parse(vm.ProviderId));
var findUser = await _userManager.FindByIdAsync(providerInformation.UserId.ToString());
//Set content for email
var getEmailContent = await _getAllEmailServiceQuery.ExecuteAsync();
var generateCode = _configuration.GetSection("Host").GetSection("LinkConfirmNewsProvider").Value +
mappingNewsProvider.CodeConfirm + '_' + mappingNewsProvider.Id;
var getFirstEmail = getEmailContent.Where(x => x.Name == EmailName.Approve_News).FirstOrDefault();
getFirstEmail.Message = getFirstEmail.Message.Replace(EmailKey.UserNameKey, findUser.Email).
Replace(EmailKey.ConfirmLink, generateCode);
ContentEmail(_config.Value.SendGridKey, getFirstEmail.Subject,
getFirstEmail.Message, findUser.Email).Wait();
return(new CommandResult <NewsProviderViewModel>
{
isValid = true,
myModel = vm
});
}
else
{
await Logging <UpdateNewsProviderServiceCommand> .
WarningAsync(ActionCommand.COMMAND_UPDATE, userName, ErrorMessageConstant.ERROR_UPDATE_PERMISSION);
return(new CommandResult <NewsProviderViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_UPDATE_PERMISSION
});
}
}
else
{
await Logging <UpdateNewsProviderServiceCommand> .
WarningAsync(ActionCommand.COMMAND_UPDATE, userName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <NewsProviderViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
}
catch (System.Exception ex)
{
await Logging <UpdateNewsProviderServiceCommand> .
ErrorAsync(ex, ActionCommand.COMMAND_UPDATE, userName, "Has error");
return(new CommandResult <NewsProviderViewModel>
{
isValid = false,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <FunctionViewModelinFunctionService> > ExecuteAsync(string sourceId, string targetId, Dictionary <string, int> items)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = await _userManager.FindByIdAsync(userId);
try
{
//Check user has permission first
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) || await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.FUNCTION, ActionSetting.CanUpdate))
{
//Update parent id for source
var category = await _functionRepository.FindByIdAsync(sourceId);
if (category != null)
{
category.ParentId = targetId;
_functionRepository.Update(category);
//Get all sibling
var sibling = await _functionRepository.FindAllAsync(x => items.ContainsKey(x.Id));
foreach (var child in sibling)
{
_functionRepository.Update(child);
}
await _functionRepository.SaveAsync();
await Logging <UpdateParentIdServiceCommand> .
InformationAsync(ActionCommand.COMMAND_UPDATE, userName.UserName, JsonConvert.SerializeObject(sibling));
return(new CommandResult <FunctionViewModelinFunctionService>
{
isValid = true,
myModel = new FunctionViewModelinFunctionService
{
IconCss = category.IconCss,
Id = category.Id,
Name = category.Name,
ParentId = category.ParentId,
Status = category.Status,
URL = category.URL
}
});
}
await Logging <UpdateParentIdServiceCommand> .WarningAsync(ActionCommand.COMMAND_UPDATE, userName.UserName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <FunctionViewModelinFunctionService>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
else
{
await Logging <UpdateParentIdServiceCommand> .WarningAsync(ActionCommand.COMMAND_UPDATE, userName.UserName, ErrorMessageConstant.ERROR_UPDATE_PERMISSION);
return(new CommandResult <FunctionViewModelinFunctionService>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_UPDATE_PERMISSION
});
}
}
catch (System.Exception ex)
{
await Logging <UpdateParentIdServiceCommand> .ErrorAsync(ex, ActionCommand.COMMAND_UPDATE, userName.UserName, "Has error");
return(new CommandResult <FunctionViewModelinFunctionService>
{
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 <PostServiceViewModel> > ExecuteAsync(PostServiceViewModel vm)
{
var userId = _httpContext.HttpContext.User.Identity.Name;
var userName = _userManager.FindByIdAsync(userId).Result.UserName;
try
{
var getPermissionForService = await IsOwnService(Guid.Parse(vm.Id));
if (getPermissionForService.isValid || await _checkUserIsAdminQuery.ExecuteAsync(userId) ||
await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.SERVICE, ActionSetting.CanUpdate))
{
var currentService = getPermissionForService.myModel;
var service = await _serviceRepository.FindByIdAsync(Guid.Parse(vm.Id));
if (service == null)
{
return(new CommandResult <PostServiceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
List <Tag> newTag = new List <Tag>();
var tagDelete = await RemoveTag(Guid.Parse(vm.Id), vm.tagofServices);
foreach (var item in vm.tagofServices)
{
if (item.isAdd == true)
{
newTag.Add(new Tag
{
TagName = item.TagName
});
}
}
//Update Image
List <ServiceImage> lstService = new List <ServiceImage>();
foreach (var item in vm.listImages)
{
if (item.ImageId == 0)
{
ServiceImage serviceImage = new ServiceImage()
{
DateCreated = DateTime.Now,
Path = item.Path,
isAvatar = item.IsAvatar,
ServiceId = Guid.Parse(vm.Id)
};
lstService.Add(serviceImage);
}
else
{
var imageId = await _serviceImageRepository.FindByIdAsync(item.ImageId);
if (imageId != null)
{
imageId.isAvatar = item.IsAvatar;
imageId.DateModified = DateTime.Now;
_serviceImageRepository.Update(imageId);
}
}
}
var deletImage = await RemoveImage(Guid.Parse(vm.Id), vm.listImages);
_serviceImageRepository.RemoveMultiple(deletImage);
await _tagServiceRepository.Add(newTag);
_tagServiceRepository.RemoveMultiple(tagDelete);
var mappingService = await MappingService(vm, service, userId);
mappingService.TagServices = null;
foreach (var tag in newTag)
{
Model.Entities.ServiceModel.TagService mappingTag = new Model.Entities.ServiceModel.TagService();
mappingTag.TagId = tag.Id;
mappingTag.ServiceId = Guid.Parse(vm.Id);
await _serviceOfTagRepository.Add(mappingTag);
}
_serviceRepository.Update(mappingService);
await _serviceRepository.SaveAsync();
//Cotentemail
var findEmailUser = await GetEmailUserAsync(mappingService);
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.Approve_Service).FirstOrDefault();
var generateCode = _configuration.GetSection("Host").GetSection("LinkConfirmService").Value +
mappingService.codeConfirm + '_' + mappingService.Id;
getFirstEmail.Message = getFirstEmail.Message.
Replace(EmailKey.ServiceNameKey, mappingService.ServiceName).
Replace(EmailKey.UserNameKey, findEmailUser).
Replace(EmailKey.ConfirmLink, generateCode);
ContentEmail(_configEmail.Value.SendGridKey, getFirstEmail.Subject,
getFirstEmail.Message, findEmailUser).Wait();
}
else
{
await Logging <UpdatePostServiceCommand> .
WarningAsync(ActionCommand.COMMAND_APPROVE, userName, "Cannot find email user");
return(new CommandResult <PostServiceViewModel>
{
isValid = false,
errorMessage = "Cannot find email user"
});
}
await Logging <UpdatePostServiceCommand> .
InformationAsync(ActionCommand.COMMAND_UPDATE, userName, JsonConvert.SerializeObject(vm));
return(new CommandResult <PostServiceViewModel>
{
isValid = true,
});
}
await Logging <UpdatePostServiceCommand> .
WarningAsync(ActionCommand.COMMAND_UPDATE, userName, ErrorMessageConstant.ERROR_UPDATE_PERMISSION);
return(new CommandResult <PostServiceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_UPDATE_PERMISSION
});
}
catch (System.Exception ex)
{
await Logging <UpdatePostServiceCommand> .
ErrorAsync(ex, ActionCommand.COMMAND_UPDATE, userName, "Has error");
return(new CommandResult <PostServiceViewModel>
{
isValid = false,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <AppUserViewModelinUserService> > ExecuteAsync(AppUserViewModelinUserService userVm)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userManager.FindByIdAsync(userId).Result.UserName;
try
{
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) ||
await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.USER, ActionSetting.CanUpdate))
{
var user = await _userManager.FindByIdAsync(userVm.Id.ToString());
user.FullName = userVm.FullName;
user.Status = userVm.Status;
user.Email = userVm.Email;
user.PhoneNumber = userVm.PhoneNumber;
user.Avatar = userVm.Avatar;
user.UserName = userVm.UserName;
var userRoles = _userManager.GetRolesAsync(user);
List <Guid> roleId = new List <Guid>();
foreach (var item in userRoles.Result.ToList())
{
var getId = _roleRepository.FindByNameAsync(item).Result.Id;
roleId.Add(getId);
}
foreach (var item in roleId)
{
_userRoleRepository.DeleteUserRole(user.Id, item);
}
var selectedRole = userVm.NewRoles.ToArray();
selectedRole = selectedRole ?? new string[] { };
await _userManager.AddToRolesAsync(user, selectedRole.Except(userRoles.Result).ToArray());
//var userRoles1 = await _userManager.GetRolesAsync(user);
await _userManager.UpdateAsync(user);
await Logging <UpdateUserAsyncCommand> .InformationAsync(ActionCommand.COMMAND_UPDATE, userName, JsonConvert.SerializeObject(user));
return(new CommandResult <AppUserViewModelinUserService>
{
isValid = true,
myModel = new AppUserViewModelinUserService
{
FullName = userVm.FullName,
Email = userVm.Email,
PhoneNumber = userVm.PhoneNumber,
Id = userVm.Id,
Avatar = userVm.Avatar,
DateCreated = user.DateCreated,
UserName = user.UserName,
Roles = userVm.Roles.ToList()
}
});
}
else
{
await Logging <UpdateUserAsyncCommand> .
WarningAsync(ActionCommand.COMMAND_UPDATE, userName, ErrorMessageConstant.ERROR_UPDATE_PERMISSION);
return(new CommandResult <AppUserViewModelinUserService>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_UPDATE_PERMISSION
});
}
}
catch (Exception ex)
{
await Logging <UpdateUserAsyncCommand> .
ErrorAsync(ex, ActionCommand.COMMAND_UPDATE, userName, "Has error");
return(new CommandResult <AppUserViewModelinUserService>
{
isValid = false,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <PostServiceViewModel> > ExecuteAsync(PostServiceViewModel vm)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userManager.FindByIdAsync(userId).Result.UserName;
try
{
//var checkUserIsAdmin = await _checkUserIsAdminQuery.ExecuteAsync(userId);
if (await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.SERVICE, ActionSetting.CanCreate) ||
await _checkUserIsAdminQuery.ExecuteAsync(userId))
{
//Add new tag when isAdd equal true
List <Tag> newTag = new List <Tag>();
foreach (var item in vm.tagofServices)
{
if (item.isAdd == true)
{
newTag.Add(new Tag
{
TagName = item.TagName
});
}
}
await _tagServiceRepository.Add(newTag);
//Mapping between ViewModel and Model of Service
var mappingService = await MappingService(vm, userId);
await _postServiceRepository.Add(mappingService);
//Mapping between ViewModel and Model of UserService
var mappingUserService = MappingUserService(mappingService.Id, !string.IsNullOrEmpty(vm.UserId) ? Guid.Parse(vm.UserId) : Guid.Parse(userId));
await _userServiceRepository.Add(mappingUserService);
//Add new Tag with Id in TagService
foreach (var item in newTag)
{
Model.Entities.ServiceModel.TagService mappingTag = new Model.Entities.ServiceModel.TagService();
mappingTag.TagId = item.Id;
mappingService.TagServices.Add(mappingTag);
}
await _tagServiceRepository.SaveAsync();
//Write Log
await Logging <RegisterServiceFromUserCommand> .
InformationAsync(ActionCommand.COMMAND_ADD, userName, JsonConvert.SerializeObject(vm));
var findUserInformation = await _userManager.FindByIdAsync(vm.UserId);
//Send mail for user if admin
if ((await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.SERVICE, ActionSetting.CanCreate) ||
await _checkUserIsAdminQuery.ExecuteAsync(userId)))
{
//Set content for email
//Generate code
//Create Generate code
var generateCode = _configuration.GetSection("Host").GetSection("LinkConfirmService").Value +
mappingService.codeConfirm + '_' + mappingService.Id;
var getEmailContent = await _getAllEmailServiceQuery.ExecuteAsync();
var getFirstEmail = getEmailContent.Where(x => x.Name == EmailName.Approve_Service).FirstOrDefault();
getFirstEmail.Message = getFirstEmail.Message.
Replace(EmailKey.UserNameKey, findUserInformation.Email).
Replace(EmailKey.ConfirmLink, generateCode);;
ContentEmail(_config.Value.SendGridKey, getFirstEmail.Subject,
getFirstEmail.Message, _userManager.FindByIdAsync(!string.IsNullOrEmpty(vm.UserId) ? vm.UserId : userId).Result.Email).Wait();
}
//End send mail for user
return(new CommandResult <PostServiceViewModel>
{
isValid = true,
myModel = new PostServiceViewModel
{
Id = mappingService.Id.ToString(),
DateCreated = mappingService.DateCreated,
IsProvider = false,
Author = findUserInformation.UserName + "(" + findUserInformation.Email + ")",
UserId = vm.UserId,
AvtService = mappingService.ServiceImages.Where(x => x.isAvatar == true).FirstOrDefault().Path,
listImages = mappingService.ServiceImages.Select(x => new PostServiceImageViewModel
{
ImageId = x.Id,
IsAvatar = x.isAvatar,
Path = x.Path
}).ToList(),
CategoryId = vm.CategoryId,
CategoryName = vm.CategoryName,
Description = vm.Description,
PriceOfService = vm.PriceOfService,
ServiceName = vm.ServiceName,
Status = mappingService.Status,
tagofServices = mappingService.TagServices.Select(x => new TagofServiceViewModel
{
TagId = x.TagId.ToString(),
TagName = _tagServiceRepository.FindSingleAsync(t => t.Id == x.TagId).Result.TagName
}).ToList(),
}
});
}
else
{
await Logging <RegisterServiceFromUserCommand> .
WarningAsync(ActionCommand.COMMAND_ADD, userName, ErrorMessageConstant.ERROR_ADD_PERMISSION);
return(new CommandResult <PostServiceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_ADD_PERMISSION
});
}
}
catch (System.Exception ex)
{
await Logging <RegisterServiceFromUserCommand> .
ErrorAsync(ex, ActionCommand.COMMAND_ADD, userName, "Had error");
return(new CommandResult <PostServiceViewModel>
{
isValid = true,
myModel = vm,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <CategoryServiceViewModel> > ExecuteAsync(int id)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = await _userManager.FindByIdAsync(userId);
try
{
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) || await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.CATEGORY, ActionSetting.CanDelete))
{
var categoryDel = await _categoryRepository.FindByIdAsync(id);
if (categoryDel != null)
{
_categoryRepository.Remove(categoryDel);
await _categoryRepository.SaveAsync();
var myModelReturn = new CategoryServiceViewModel
{
CategoryName = categoryDel.CategoryName,
Description = categoryDel.Description,
Id = categoryDel.Id
};
await Logging <DeleteCategoryServiceCommand> .
InformationAsync(ActionCommand.COMMAND_DELETE, userName.UserName, JsonConvert.SerializeObject(myModelReturn));
return(new CommandResult <CategoryServiceViewModel>
{
isValid = true,
myModel = myModelReturn
});
}
else
{
await Logging <DeleteCategoryServiceCommand>
.WarningAsync(ActionCommand.COMMAND_DELETE, userName.UserName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <CategoryServiceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
}
else
{
await Logging <DeleteCategoryServiceCommand>
.WarningAsync(ActionCommand.COMMAND_DELETE, userName.UserName, ErrorMessageConstant.ERROR_DELETE_PERMISSION);
return(new CommandResult <CategoryServiceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_DELETE_PERMISSION
});
}
}
catch (System.Exception ex)
{
await Logging <DeleteCategoryServiceCommand> .ErrorAsync(ex, ActionCommand.COMMAND_DELETE, "Has error");
return(new CommandResult <CategoryServiceViewModel>
{
isValid = false,
errorMessage = ex.InnerException.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 <PostServiceViewModel> > ExecuteAsync(string idService)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userManager.FindByIdAsync(userId).Result.UserName;
try
{
//Get Id Service and Check it has permission by checkUserIsProvider
var findIdService = await _postServiceRepository.FindByIdAsync(Guid.Parse(idService));
var checkUserIsProvider = await _checkUserIsProvider.ExecuteAsync(userId);
if (findIdService != null)
{
var findProviderService = await _providerServiceRepository.FindSingleAsync(x => x.ServiceId == findIdService.Id);
//Check permission can delete
if (findProviderService != null ||
await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.SERVICE, ActionSetting.CanDelete) ||
await _checkUserIsAdminQuery.ExecuteAsync(userId) ||
findProviderService.ProviderId == Guid.Parse(checkUserIsProvider.myModel.Id.ToString()))
{
_providerServiceRepository.Remove(findProviderService);
_postServiceRepository.Remove(findIdService);
await _postServiceRepository.SaveAsync();
await Logging <DeleteServiceFromProviderCommand> .
InformationAsync(ActionCommand.COMMAND_DELETE, userName, findIdService.ServiceName + " has been removed");
return(new CommandResult <PostServiceViewModel>
{
isValid = true
});
}
else
{
await Logging <DeleteServiceFromProviderCommand> .
WarningAsync(ActionCommand.COMMAND_DELETE, userName, ErrorMessageConstant.ERROR_DELETE_PERMISSION);
return(new CommandResult <PostServiceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_DELETE_PERMISSION
});
}
}
else
{
await Logging <DeleteServiceFromProviderCommand> .
WarningAsync(ActionCommand.COMMAND_DELETE, userName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <PostServiceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
}
catch (System.Exception ex)
{
await Logging <DeleteServiceFromProviderCommand> .
ErrorAsync(ex, ActionCommand.COMMAND_DELETE, userName, "Had error");
return(new CommandResult <PostServiceViewModel>
{
isValid = false,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <FunctionViewModelinFunctionService> > ExecuteAsync(FunctionViewModelinFunctionService function)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = await _userManager.FindByIdAsync(userId);
try
{
//Check user has permission first
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) || await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.FUNCTION, ActionSetting.CanUpdate))
{
var functionDb = await _functionRepository.FindByIdAsync(function.Id);
if (functionDb != null)
{
functionDb.IconCss = function.IconCss;
functionDb.Id = function.Id;
functionDb.Name = function.Name;
functionDb.ParentId = function.ParentId;
functionDb.Status = function.Status;
functionDb.URL = function.URL;
_functionRepository.Update(functionDb);
await _functionRepository.SaveAsync();
await Logging <UpdateFunctionServiceCommand> .
InformationAsync(ActionCommand.COMMAND_UPDATE, userName.UserName, JsonConvert.SerializeObject(functionDb));
return(new CommandResult <FunctionViewModelinFunctionService>
{
isValid = true,
myModel = function,
});
}
await Logging <UpdateFunctionServiceCommand>
.WarningAsync(ActionCommand.COMMAND_UPDATE, userName.UserName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <FunctionViewModelinFunctionService>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
else
{
await Logging <UpdateFunctionServiceCommand>
.WarningAsync(ActionCommand.COMMAND_UPDATE, userName.UserName, ErrorMessageConstant.ERROR_UPDATE_PERMISSION);
return(new CommandResult <FunctionViewModelinFunctionService>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_UPDATE_PERMISSION
});
}
}
catch (System.Exception ex)
{
await Logging <UpdateFunctionServiceCommand> .ErrorAsync(ex, ActionCommand.COMMAND_UPDATE, userName.UserName, ErrorMessageConstant.ERROR_UPDATE_PERMISSION);
return(new CommandResult <FunctionViewModelinFunctionService>
{
isValid = false,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <AppUserViewModelinUserService> > ExecuteAsync(AppUserViewModelinUserService userVm)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userManager.FindByIdAsync(userId).Result.UserName;
try
{
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) ||
await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.USER, ActionSetting.CanCreate))
{
var user = new AppUser()
{
UserName = userVm.UserName,
Avatar = userVm.Avatar,
Email = userVm.Email,
FullName = userVm.FullName,
DateCreated = DateTime.Now,
PhoneNumber = userVm.PhoneNumber,
Status = Model.Enums.Status.Active
};
//Check email and username has been available
var findUserName = await _userManager.FindByNameAsync(userVm.UserName);
if (findUserName != null)
{
return(new CommandResult <AppUserViewModelinUserService>
{
isValid = false,
errorMessage = "User has been available"
});
}
//Check email hase been available
var findEmail = await _userManager.FindByEmailAsync(userVm.Email);
if (findEmail != null)
{
return(new CommandResult <AppUserViewModelinUserService>
{
isValid = false,
errorMessage = "Email has been available"
});
}
//Add user
var result = await _userManager.CreateAsync(user, userVm.Password);
if (result.Succeeded && userVm.Roles.Count > 0)
{
var appUser = await _userManager.FindByNameAsync(user.UserName);
if (appUser != null)
{
await _userManager.AddToRolesAsync(appUser, userVm.Roles);
}
}
await Logging <AddUserAsyncCommand> .InformationAsync(ActionCommand.COMMAND_ADD, userName, JsonConvert.SerializeObject(userVm));
return(new CommandResult <AppUserViewModelinUserService>
{
isValid = true,
myModel = new AppUserViewModelinUserService
{
UserName = userVm.UserName,
Avatar = userVm.Avatar,
Email = userVm.Email,
FullName = userVm.FullName,
DateCreated = DateTime.Now,
PhoneNumber = userVm.PhoneNumber,
Id = user.Id,
Status = Model.Enums.Status.Active,
Roles = _userManager.GetRolesAsync(user).Result.ToList()
}
});
}
else
{
await Logging <AddUserAsyncCommand> .WarningAsync(ActionCommand.COMMAND_ADD, userName, ErrorMessageConstant.ERROR_ADD_PERMISSION);
return(new CommandResult <AppUserViewModelinUserService>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_ADD_PERMISSION
});
}
}
catch (System.Exception ex)
{
await Logging <AddUserAsyncCommand> .ErrorAsync(ex, ActionCommand.COMMAND_ADD, userName, "Has error");
return(new CommandResult <AppUserViewModelinUserService>
{
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 <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 <AppRoleViewModel> > ExecuteAsync(AppRoleViewModel roleVm)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userManager.FindByIdAsync(userId).Result.UserName;
try
{
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) ||
await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.ROLE, ActionSetting.CanUpdate))
{
var role = await _roleManager.FindByIdAsync(roleVm.Id.ToString());
if (role != null)
{
role.Description = roleVm.Description;
role.Name = roleVm.Name;
await _roleManager.UpdateAsync(role);
await Logging <UpdateRoleAsyncCommand> .
InformationAsync(ActionCommand.COMMAND_UPDATE, userName, JsonConvert.SerializeObject(role));
return(new CommandResult <AppRoleViewModel>
{
isValid = true,
myModel = new AppRoleViewModel
{
Description = role.Description,
Id = role.Id,
Name = role.Name
}
});
}
await Logging <UpdateRoleAsyncCommand> .
WarningAsync(ActionCommand.COMMAND_UPDATE, userName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <AppRoleViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
else
{
await Logging <UpdateRoleAsyncCommand> .
WarningAsync(ActionCommand.COMMAND_UPDATE, userName, ErrorMessageConstant.ERROR_UPDATE_PERMISSION);
return(new CommandResult <AppRoleViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_UPDATE_PERMISSION
});
}
}
catch (System.Exception ex)
{
await Logging <UpdateRoleAsyncCommand>
.ErrorAsync(ex, ActionCommand.COMMAND_UPDATE, userName, "Has error");
return(new CommandResult <AppRoleViewModel>
{
isValid = false,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <NewsProviderViewModel> > ExecuteAsync(NewsProviderViewModel vm)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userManager.FindByIdAsync(userId).Result.UserName;
try
{
var getIsProvider = await _checkUserIsProviderQuery.ExecuteAsync(userId);
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) ||
await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.NEWS, ActionSetting.CanCreate) ||
getIsProvider.isValid)
{
var mappingProvider = await MappingProvider(vm, Guid.Parse(vm.ProviderId), userId);
mappingProvider.CodeConfirm = RandomCodeSupport.RandomString(6);
await _newProviderRepository.Add(mappingProvider);
await _newProviderRepository.SaveAsync();
vm.Id = mappingProvider.Id;
vm.Status = mappingProvider.Status;
await Logging <RegisterNewsProviderServiceCommand> .
InformationAsync(ActionCommand.COMMAND_ADD, userName, JsonConvert.SerializeObject(vm));
//Send mail confirm
//Get Provider Information
var providerInformation = await _providerRepository.FindByIdAsync(Guid.Parse(vm.ProviderId));
var findUser = await _userManager.FindByIdAsync(providerInformation.UserId.ToString());
//Set content for email
var getEmailContent = await _getAllEmailServiceQuery.ExecuteAsync();
if (getIsProvider.isValid)
{
var getFirstEmail = getEmailContent.Where(x => x.Name == EmailName.Receive_Register_News).FirstOrDefault();
getFirstEmail.Message = getFirstEmail.Message.Replace(EmailKey.UserNameKey, findUser.Email);
ContentEmail(_config.Value.SendGridKey, getFirstEmail.Subject,
getFirstEmail.Message, findUser.Email).Wait();
}
else
{
var generateCode = _configuration.GetSection("Host").GetSection("LinkConfirmNewsProvider").Value +
mappingProvider.CodeConfirm + '_' + mappingProvider.Id;
var getFirstEmail = getEmailContent.Where(x => x.Name == EmailName.Approve_News).FirstOrDefault();
getFirstEmail.Message = getFirstEmail.Message.Replace(EmailKey.UserNameKey, findUser.Email).
Replace(EmailKey.ConfirmLink, generateCode);
ContentEmail(_config.Value.SendGridKey, getFirstEmail.Subject,
getFirstEmail.Message, findUser.Email).Wait();
}
return(new CommandResult <NewsProviderViewModel>
{
isValid = true,
myModel = vm
});
}
else
{
await Logging <RegisterNewsProviderServiceCommand> .
WarningAsync(ActionCommand.COMMAND_ADD, userName, ErrorMessageConstant.ERROR_DELETE_PERMISSION);
return(new CommandResult <NewsProviderViewModel>
{
isValid = true,
errorMessage = ErrorMessageConstant.ERROR_ADD_PERMISSION
});
}
}
catch (System.Exception ex)
{
await Logging <RegisterNewsProviderServiceCommand> .
ErrorAsync(ex, ActionCommand.COMMAND_ADD, userName, "Has error");
return(new CommandResult <NewsProviderViewModel>
{
isValid = false,
myModel = vm,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <Provider> > ExecuteAsync(string id)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userManager.FindByIdAsync(userId).Result.UserName;
try
{
var newId = Guid.Parse(id);
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) || await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.PROVIDER, ActionSetting.CanDelete))
{
var getId = await _providerRepository.FindByIdAsync(newId);
if (getId != null)
{
//Remove Provider Role
var providerId = await _roleRepository.FindByNameAsync("Provider");
_userRoleRepository.DeleteUserRole(getId.UserId, providerId.Id);
//End remove provider Role
_providerRepository.Remove(newId);
await _providerRepository.SaveAsync();
await Logging <DeleteProviderServiceCommand> .
InformationAsync(ActionCommand.COMMAND_DELETE, userName, getId.ProviderName + "has been deleted");
return(new CommandResult <Provider>
{
isValid = true,
myModel = getId
});
}
else
{
await Logging <DeleteProviderServiceCommand> .
WarningAsync(ActionCommand.COMMAND_DELETE, userName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <Provider>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
}
else
{
await Logging <DeleteProviderServiceCommand> .
WarningAsync(ActionCommand.COMMAND_DELETE, userName, ErrorMessageConstant.ERROR_DELETE_PERMISSION);
return(new CommandResult <Provider>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_DELETE_PERMISSION
});
}
}
catch (System.Exception ex)
{
await Logging <DeleteProviderServiceCommand> .
ErrorAsync(ex, ActionCommand.COMMAND_APPROVE, userName, "Has error");
return(new CommandResult <Provider>
{
isValid = false,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <ProviderServiceViewModel> > ExecuteAsync(ProviderServiceViewModel vm)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userManager.FindByIdAsync(userId).Result.UserName;
try
{
//Check category has available
var availableCategory = await _providerRepository.FindSingleAsync(x => x.ProviderName.ToLower() == vm.ProviderName.ToLower());
if (availableCategory != null)
{
return(new CommandResult <ProviderServiceViewModel>
{
isValid = false,
errorMessage = "Provider Name has available"
});
}
var checkUserIsProvider = await _checkUserIsProviderQuery.ExecuteAsync(userId);
var mappingProvider = await MappingProvider(vm, Guid.Parse(userId), userId);
//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"
});
}
var userEmail = "";
if (vm.UserId == null)
{
var findUser = await _userManager.FindByIdAsync(userId);
userEmail = findUser.Email;
}
else
{
var findUser = await _userManager.FindByIdAsync(vm.UserId);
userEmail = findUser.Email;
}
mappingProvider.OTPConfirm = RandomCodeSupport.RandomString(6);
await _providerRepository.Add(mappingProvider);
await _providerRepository.SaveAsync();
var getEmailContent = await _getAllEmailServiceQuery.ExecuteAsync();
if ((await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.PROVIDER, ActionSetting.CanCreate) ||
await _checkUserIsAdminQuery.ExecuteAsync(userId)))
{
var checkUser = !string.IsNullOrEmpty(vm.UserId) ? vm.UserId : userId;
var findUserId = await _userManager.FindByIdAsync(checkUser);
var getAllRole = await _userManager.GetRolesAsync(findUserId);
var flagProvider = 0;
foreach (var item in getAllRole)
{
if (item == ConstantRoles.Provider)
{
flagProvider++;
}
}
if (flagProvider == 0)
{
await _userManager.AddToRoleAsync(findUserId, ConstantRoles.Provider);
}
//Set content for email
var generateCode = _configuration.GetSection("Host").GetSection("LinkConfirmProvider").Value +
mappingProvider.OTPConfirm + '_' + mappingProvider.Id;
var getFirstEmail = getEmailContent.Where(x => x.Name == EmailName.Approve_Provider).FirstOrDefault();
getFirstEmail.Message = getFirstEmail.Message.Replace(EmailKey.UserNameKey, userEmail).Replace(EmailKey.ConfirmLink, generateCode);
ContentEmail(_config.Value.SendGridKey, getFirstEmail.Subject,
getFirstEmail.Message, findUserId.Email).Wait();
}
else
{
var getFirstEmail = getEmailContent.Where(x => x.Name == EmailName.Receive_Register_Provider).FirstOrDefault();
getFirstEmail.Message = getFirstEmail.Message.Replace(EmailKey.UserNameKey, userEmail);
//Check if UserId null
var checkUser = !string.IsNullOrEmpty(vm.UserId) ? vm.UserId : userId;
var findUserId = await _userManager.FindByIdAsync(checkUser);
ContentEmail(_config.Value.SendGridKey, getFirstEmail.Subject,
getFirstEmail.Message, findUserId.Email).Wait();
}
vm.Id = mappingProvider.Id.ToString();
vm.Status = mappingProvider.Status;
await Logging <RegisterProviderServiceCommand> .
InformationAsync(ActionCommand.COMMAND_ADD, userName, JsonConvert.SerializeObject(vm));
return(new CommandResult <ProviderServiceViewModel>
{
isValid = true,
myModel = vm
});
}
catch (System.Exception ex)
{
await Logging <RegisterProviderServiceCommand> .
ErrorAsync(ex, ActionCommand.COMMAND_ADD, userName, "Has error");
return(new CommandResult <ProviderServiceViewModel>
{
isValid = false,
myModel = vm,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <ProviderServiceViewModel> > ExecuteAsync(ProviderServiceViewModel vm)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userRepository.FindByIdAsync(userId).Result.UserName;
try
{
var checkIsProvider = await _checkUserIsProviderQuery.ExecuteAsync(userId);
var getProvider = await _providerRepository.FindByIdAsync(Guid.Parse(vm.Id));
if (getProvider != null)
{
if (getProvider.UserId == Guid.Parse(userId) ||
await _checkUserIsAdminQuery.ExecuteAsync(userId) ||
await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.PROVIDER, ActionSetting.CanUpdate))
{
var mapping = await MappingProvider(getProvider, vm, userId);
_providerRepository.Update(mapping);
await _providerRepository.SaveAsync();
await Logging <UpdateProviderServiceCommand> .
InformationAsync(ActionCommand.COMMAND_UPDATE, userName, JsonConvert.SerializeObject(vm));
if ((await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.PROVIDER, ActionSetting.CanCreate) ||
await _checkUserIsAdminQuery.ExecuteAsync(userId)))
{
var findUserId = await _userRepository.FindByIdAsync(vm.UserId);
//Set content for email
var getEmailContent = await _getAllEmailServiceQuery.ExecuteAsync();
var generateCode = _configuration.GetSection("Host").GetSection("LinkConfirmProvider").Value +
mapping.OTPConfirm + '_' + mapping.Id;
var getFirstEmail = getEmailContent.Where(x => x.Name == EmailName.Approve_Provider).FirstOrDefault();
getFirstEmail.Message = getFirstEmail.Message.Replace(EmailKey.UserNameKey, findUserId.Email).Replace(EmailKey.ConfirmLink, generateCode);
ContentEmail(_config.Value.SendGridKey, getFirstEmail.Subject,
getFirstEmail.Message, findUserId.Email).Wait();
}
return(new CommandResult <ProviderServiceViewModel>
{
isValid = true,
myModel = vm
});
}
else
{
await Logging <UpdateProviderServiceCommand> .
WarningAsync(ActionCommand.COMMAND_UPDATE, userName, ErrorMessageConstant.ERROR_UPDATE_PERMISSION);
return(new CommandResult <ProviderServiceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_UPDATE_PERMISSION
});
}
}
else
{
await Logging <UpdateProviderServiceCommand> .
WarningAsync(ActionCommand.COMMAND_UPDATE, userName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <ProviderServiceViewModel>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
}
catch (System.Exception ex)
{
await Logging <UpdateProviderServiceCommand> .
ErrorAsync(ex, ActionCommand.COMMAND_UPDATE, userName, "Has error");
return(new CommandResult <ProviderServiceViewModel>
{
isValid = false,
errorMessage = ex.InnerException.ToString()
});
}
}
public async Task <CommandResult <ProviderNew> > ExecuteAsync(int id)
{
var userId = _httpContextAccessor.HttpContext.User.Identity.Name;
var userName = _userManager.FindByIdAsync(userId).Result.UserName;
try
{
var getId = await _providerNewRepository.FindByIdAsync(id);
if (getId != null)
{
var checkUserIsProvider = await _checkUserIsProviderQuery.ExecuteAsync(userId);
//Check permission
if (await _checkUserIsAdminQuery.ExecuteAsync(userId) ||
await _getPermissionActionQuery.ExecuteAsync(userId, ConstantFunctions.NEWS, ActionSetting.CanDelete) ||
(checkUserIsProvider.isValid && checkUserIsProvider.myModel.Id == getId.ProviderId.ToString()))
{
_providerNewRepository.Remove(getId.Id);
await _providerNewRepository.SaveAsync();
//Write Log
await Logging <DeleteNewsProviderServiceCommand> .
InformationAsync(ActionCommand.COMMAND_DELETE, userName, "Has been delete news provider:" + getId.Title + "_" + getId.Author);
return(new CommandResult <ProviderNew>
{
isValid = true,
myModel = getId
});
}
else
{
await Logging <DeleteNewsProviderServiceCommand> .
WarningAsync(ActionCommand.COMMAND_DELETE, userName, ErrorMessageConstant.ERROR_DELETE_PERMISSION);
return(new CommandResult <ProviderNew>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_DELETE_PERMISSION
});
}
}
else
{
await Logging <DeleteNewsProviderServiceCommand> .
WarningAsync(ActionCommand.COMMAND_DELETE, userName, ErrorMessageConstant.ERROR_CANNOT_FIND_ID);
return(new CommandResult <ProviderNew>
{
isValid = false,
errorMessage = ErrorMessageConstant.ERROR_CANNOT_FIND_ID
});
}
}
catch (System.Exception ex)
{
await Logging <DeleteNewsProviderServiceCommand> .
ErrorAsync(ex, ActionCommand.COMMAND_APPROVE, userName, "Has error");
return(new CommandResult <ProviderNew>
{
isValid = false,
errorMessage = ex.InnerException.ToString()
});
}
}
