Beispiel #1
0
        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()
                });
            }
        }
Beispiel #2
0
        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()
                });
            }
        }
Beispiel #3
0
        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()
                });
            }
        }
Beispiel #6
0
        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()
                });
            }
        }
Beispiel #7
0
        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()
                });
            }
        }
Beispiel #9
0
        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()
                });
            }
        }
Beispiel #10
0
        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()
                });
            }
        }
Beispiel #12
0
        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()
                });
            }
        }
Beispiel #14
0
        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()
                });
            }
        }
Beispiel #15
0
        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()
                });
            }
        }
Beispiel #16
0
        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()
                });
            }
        }
Beispiel #17
0
        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()
                });
            }
        }
Beispiel #18
0
        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()
                });
            }
        }
Beispiel #19
0
        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()
                });
            }
        }
Beispiel #22
0
        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()
                });
            }
        }
Beispiel #24
0
        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()
                });
            }
        }
Beispiel #28
0
        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()
                });
            }
        }