public async Task <Role> CreateAsync(string name) { var role = new Role { Name = name }; await roleRepository.AddAsync(role); await dataContext.SaveChangesAsync(); return(role); }
public virtual async Task <Result> Create(RoleCreateRequestDto dto) { //验证请求数据合法性 var result = dto.Valid(); if (!result.Success) { return(result); } //调用领域服务 var createResult = await IocManager.Instance.Resolve <RoleCreateService>() .Create(dto.Name, dto.RoleId, dto.Description, AuthContextService.CurrentUser.Guid, dto.Permissions); if (!createResult.Success) { return(createResult); } //数据持久化 _operateLog.Record(ASFPermissions.RoleCreate, dto, "Success"); //记录日志 await _roleRepository.AddAsync(createResult.Data); return(Result.ReSuccess()); }
public async Task <ApiRequestResult> AddAsync(RoleDto dto) { var command = dto.EntityMap <RoleDto, Role>(); await _roleRepository.AddAsync(command); return(ApiRequestResult.Success("添加成功")); }
public async Task <MainRoleResponse> AddRole(RoleRequest roleRequest) { var role = _mapper.Map <Roles>(roleRequest); try { var isExist = _roleRepository.GetRolesByIdAndName(roleRequest); if (role.RoleId == 0 && isExist.Result == null) { role.CreatedBy = roleRequest.UserId.ToString(); var dataRole = await _roleRepository.AddAsync(role); //_response.Message = dataRole == null ? Constants.Role_Not_Created : Constants.Role_Created_Success; } else { _response.Message = Constants.Role_Already_Exists; _response.Status = false; return(_response); } _response.Message = Constants.Role_Created_Success; _response.Status = true; } catch (Exception) { _response.Status = false; _response.Message = Constants.DEFAULT_ERROR_MSG; } return(_response); }
public async Task <bool> Handle(CreateRoleCommand request, CancellationToken cancellationToken) { var role = new Role() { Name = request.Name, Desc = request.Desc, Users = request.UserIds.Select(uid => new User() { Id = uid }).ToList() }; await _roleRepository.AddAsync(role); if (await Commit()) { request.Id = role.Id; var key = GirvsEntityCacheDefaults <Role> .ByIdCacheKey.Create(role.Id.ToString()); _bus.RaiseEvent(new RemoveCacheEvent(key), cancellationToken); _bus.RaiseEvent(new RemoveCacheListEvent(GirvsEntityCacheDefaults <Role> .ListCacheKey.Create()), cancellationToken); } return(true); }
public async Task <BaseResponse> CreateRoleAsync(CreateRoleRequestModel model) { var roleExists = await _roleRepository.ExistsAsync(u => u.Name == model.Name); if (roleExists) { throw new BadRequestException($"Role with name '{model.Name}' already exists."); } var role = new Role { Id = Guid.NewGuid(), Name = model.Name, Description = model.Description }; await _roleRepository.AddAsync(role); await _roleRepository.SaveChangesAsync(); return(new BaseResponse { Status = true, Message = "Role created successfully" }); }
public async Task <IdentityResult> CreateAsync(Role role, CancellationToken cancellationToken) { role.Id = !string.IsNullOrEmpty(role.Id) ? role.Id : DataUtil.GenerateUniqueId(); await _roleRepository.AddAsync(role); return(IdentityResult.Success); }
public async Task <RoleDto> addAsync(RoleDto roleDto) { var role1 = roleDto.RoleDtoToRole(); var role2 = await _roleRepository.AddAsync(role1); return(role2.RoleToRoleDto()); }
public async Task <Result> Create([FromBody] RoleCreateRequestDto dto) { //验证请求数据合法性 var result = dto.Valid(); if (!result.Success) { return(result); } //调用领域服务 int createOfAccountId = HttpContext.User.UserId(); var createResult = await this._serviceProvider.GetRequiredService <RoleCreateService>() .Create(dto.Name, dto.Description, createOfAccountId, dto.Permissions); if (!createResult.Success) { return(createResult); } //数据持久化 _operateLog.Record(ASFPermissions.RoleCreate, dto, "Success"); //记录日志 await _roleRepository.AddAsync(createResult.Data); await _unitOfWork.CommitAsync(autoRollback : true); return(Result.ReSuccess()); }
public async Task CreateAsync(Role role) { if (role == null) { throw new ArgumentNullException(nameof(role)); } await _roleRepository.AddAsync(role); }
public async Task<IResultModel> Add(RoleAddModel model) { if (await _repository.Exists(model.Name)) return ResultModel.HasExists; var entity = _mapper.Map<RoleEntity>(model); var result = await _repository.AddAsync(entity); return ResultModel.Result(result); }
public async Task HandleAsync(CreateRoleCommand command, CancellationToken cancellationToken = default) { var nameIsNotTakenVerificationResult = await _roleVerificationService.VerifyNameIsNotTakenAsync(command.Name); if (!nameIsNotTakenVerificationResult.Success) { throw new ConflictException(nameIsNotTakenVerificationResult.Errors); } var role = _mapper.Map <CreateRoleCommand, Role>(command); await _roleRepository.AddAsync(role); }
protected override async Task CustomSeedAsync() { var roles = new List <string> { "SUPER_ADMIN", "GESTION_UTILISATEUR", "CREATION_UTILISATEUR", "CONSULTATION_UTILISATEUR", "GESTION_INTERVENANT", "CONSULTATION_INTERVENANT", "GESTION_FORMATION", "CONSULTATION_FORMATION", }; await Task.WhenAll(roles.Select(r => _roleRepository.AddAsync(new Role(r)))); }
public async Task <ActionResult> AddNewRole(SaveRoleResource saveRoleResource) { var role = mapper.Map <Role>(saveRoleResource); await roleRepository.AddAsync(role); await unitOfWork.SaveAsync(); var categoryResource = mapper.Map <KeyValuePairResource>(role); return(Ok(categoryResource)); }
public async Task <IdentityResult> CreateAsync(Role role, CancellationToken cancellationToken) { try { await _roleRepository.AddAsync(role); return(await Task.FromResult(IdentityResult.Success).ConfigureAwait(false)); } catch (Exception) { throw; } }
public async Task <IResultModel> Add(RoleAddModel model) { if (await _repository.Exists(model.Name)) { return(ResultModel.HasExists); } var moduleInfo = _mapper.Map <Role>(model); var result = await _repository.AddAsync(moduleInfo); return(ResultModel.Result(result)); }
public async Task AddAsync(AddRoleCommand command) { command.Name = command.Name.ToLower(); var role = await _repository.GetAsync(command.Name); if (!(role is null)) { throw new RoleException($"Role name: {command.Name} exist."); } await _repository.AddAsync(new Role { Name = command.Name }); }
public async Task <GenericResponse <Role> > SaveAsync(Role role) { try{ await roleRepository.AddAsync(role); await unityOfWork.CompleteAsync(); return(new GenericResponse <Role>(role)); } catch (Exception ex) { return(new GenericResponse <Role>($"Error while saving role. Message:{ex.Message}")); } }
public async Task <bool> Create(Role entity) { await _roleRepository.AddAsync(entity); try { await _unitOfWork.Commit(); return(true); } catch (Exception) { return(false); } }
public async Task <bool> AddAsync(Role role) { bool result = false; if (role != null && !await _roleRepository.NameExistsAsync(role.Name)) { role.NewEntity(); await _roleRepository.AddAsync(role); result = true; } return(result); }
public async Task <RoleResponse> SaveAsync(Role role) { try { await roleRepository.AddAsync(role); await unitOfWork.CompleteAsync(); return(new RoleResponse(role)); } catch (Exception ex) { return(new RoleResponse($"Error when saving the role: {ex.Message}")); } }
public async Task <RoleResponse> SaveAsync(Role role) { try { await _roleRepository.AddAsync(role); await _unitOfWork.CompleteAsync(); return(new RoleResponse(role)); } catch (Exception ex) { return(new RoleResponse($"An error ocurred while saving role: {ex.Message}")); } }
public async Task <RoleResponse> SaveAsync(Role role) { try { await roleRepository.AddAsync(role); await unitOfWork.CompleteAsync(); return(new RoleResponse(role)); } catch (Exception ex) { return(new RoleResponse($"Ошибка при сохранении Роли: {ex.Message}")); } }
public async Task <SaveRoleResponse> SaveAsync(Role role) { try { await _roleRepository.AddAsync(role); await _unitOfWork.CompleteAsync(); return(new SaveRoleResponse(role)); } catch (Exception ex) { // Do some logging stuff return(new SaveRoleResponse($"An error occurred when saving the Department: {ex.Message}")); } }
public async Task AddAsync_Should_Add_Role() { var role = new Role(Guid.NewGuid(), Array.Empty <byte>(), "RoleRepositoryTestAddAsync"); var roleEntity = new RoleEntity { Id = role.Id, Name = role.Name, RowVersion = role.RowVersion.ToArray() }; _mapperMock.Setup(x => x.Map <Role, RoleEntity>(It.IsAny <Role>())) .Returns(roleEntity); Func <Task> result = async() => await _repository.AddAsync(role); await result.Should().NotThrowAsync <Exception>(); var addedRole = await _context.Roles.FindAsync(role.Id); addedRole.Should().NotBeNull(); }
public async Task <IResultModel> Install(SystemInstallModel model) { await _moduleInfoService.Sync(); await _permissionService.Sync(model.Permissions); var role = new RoleEntity { Name = "系统管理员" }; await _roleRepository.AddAsync(role); var account = new AccountEntity { UserName = "******", Password = "******", Name = "管理员" }; await _accountRepository.AddAsync(account); await _accountRoleRepository.AddAsync(new AccountRoleEntity { AccountId = account.Id, RoleId = role.Id }); UpdateConfig(new SystemConfigModel { Title = "腾迪权限管理系统", Auditing = false, Toolbar = new SystemToolbar { Fullscreen = true, Skin = true, Logout = true, UserInfo = true } }); return(ResultModel.Success()); }
public override async Task <int> HandleCommand(InsertRoleCommand request, CancellationToken cancellationToken) { var id = 0; using (var conn = DALHelper.GetConnection()) { conn.Open(); using (var trans = conn.BeginTransaction()) { try { request.Model.CreatedDate = DateTime.Now; request.Model.CreatedBy = request.LoginSession.Id; request.Model.ModifiedDate = DateTime.Now; request.Model.ModifiedBy = request.LoginSession.Id; id = await roleRepository.AddAsync(request.Model); } catch (Exception ex) { throw ex; } finally { if (id > 0) { trans.Commit(); } else { try { trans.Rollback(); } catch { } } } } } return(id); }
public async Task <IResultModel> Install(SystemInstallModel model) { await _moduleInfoService.Sync(); await _permissionService.Sync(model.Permissions); var role = new Role { Name = "系统管理员" }; await _roleRepository.AddAsync(role); await _accountService.Add(new AccountAddModel { UserName = "******", Password = "******", Name = "管理员", Roles = new List <Guid> { role.Id } }); UpdateConfig(new SystemConfigModel { Title = "通用权限管理系统", Auditing = false, Toolbar = new SystemToolbar { Fullscreen = true, Skin = true } }); return(ResultModel.Success()); }
public async Task CreateRoleAsync(Role Role) { await roleRepository.AddAsync(Role); }
public async Task AddAsync(Role entity) { await _roleRepository.AddAsync(entity); }