public IRoleCommand CreateRole(string roleName) { var role = new Role(RoleIdentifier.of(roleName)); repository.Save(role); return(new RoleCommand(role, repository)); }
public async Task<IdentityResult> SetRoleAsync(Guid userId, RoleIdentifier roleIdentifier) { var rolesToRemove = (await _userManager.GetRolesAsync(userId)).ToArray(); await _userManager.RemoveFromRolesAsync(userId, rolesToRemove); return await AddRoleAsync(userId, roleIdentifier); }
public IRoleCommand MergeAuthoritiesWith(RoleIdentifier id) { var other = _repository.FindOne(new Role.By(id)); _role.MergeAuthoritiesWith(other); return(this); }
public void ImportAuthorities(string data, params Role[] roles) { var import = new Import <RoleAuthority>() .New(row => new RoleAuthority(new Role(RoleIdentifier.of(row["RoleName"].ToString())), new Function())) .Map((obj, row) => obj.Function.Area = row["Area"].ToString()) .Map((obj, row) => obj.Function.Controller = row["Controller"].ToString()) .Map((obj, row) => obj.Function.Action = row["Action"].ToString()) .Map((obj, row) => obj.Function.Description = row["Description"].ToString()) .Map((obj, row) => obj.Function.MenuAction = row["MenuAction"].ToString()) .Map((obj, row) => obj.Function.MenuDescription = row["MenuDescription"].ToString()) .Map((obj, row) => obj.Function.Group = row["Group"].ToString()) .Map((obj, row) => obj.Function.GroupIco = row["GroupIco"].ToString()); var authoritiesForRoles = import.MapTo(data); //保存功能到数据库 repository.Save(authoritiesForRoles.Select(x => x.Function)); //保存授权 foreach (var role in roles) { foreach (var item in authoritiesForRoles) { var roleNames = item.Id.RoleId.RoleName.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries); role.AddAuthority(new RoleAuthority(role, item.Function) { IsAuthorized = roleNames.Contains(role.Id.RoleName) }); } } }
public async Task <bool> StopVirtualMachine(string name, string cloudServiceName) { if (string.IsNullOrEmpty(name)) { throw new ArgumentNullException("name"); } if (string.IsNullOrEmpty(cloudServiceName)) { throw new ArgumentNullException("cloudServiceName"); } if (!ValidateVirtualMachineName(name)) { throw new ArgumentException(Properties.Resources.Error_InvalidVirtualMachineName, "name"); } if (!ValidateCloudServiceName(cloudServiceName)) { throw new ArgumentException(Properties.Resources.Error_InvalidCloudServiceName, "name"); } var getProductionDeploymentRequest = new GetProductionDeploymentRequest(this.client); var deployment = await getProductionDeploymentRequest.Submit(cloudServiceName); var roleIdentifier = new RoleIdentifier(cloudServiceName, deployment.Name, name); var shutdownRequest = new ShutdownRoleRequest(this.client); await shutdownRequest.Submit(roleIdentifier); return(true); }
public IAccountCommand AddRole(RoleIdentifier id) { var role = repository.FindOne(new Role.By(id)); account.AddRole(role); return(this); }
public Role GetRole(RoleIdentifier id) { if (!repository.IsExisted(new Role.By(id))) { throw new DomainErrorException("角色不存在"); } return(repository.FindOne(new Role.By(id))); }
public async Task <TDto> CreateAsync <TDto>(TDto dto, string password, RoleIdentifier roleIdentifier) { var entity = Mapper.Map <User>(dto); var result = await EntityRepository.CreateAsync(entity, password, roleIdentifier); return(Mapper.Map <TDto>(result)); }
public async Task<User> UpdateAsync(User entity, RoleIdentifier roleIdentifier) { var dbEntity = await base.UpdateAsync(entity); await SetRoleAsync(entity.Id, roleIdentifier); return dbEntity; }
public ActionResult DeleteConfirmed(int id) { RoleIdentifier roleIdentifier = db.RoleIdentifier.Find(id); db.RoleIdentifier.Remove(roleIdentifier); db.SaveChanges(); return(RedirectToAction("Index")); }
public ActionResult Edit([Bind(Include = "roleIdentifierID,role")] RoleIdentifier roleIdentifier) { if (ModelState.IsValid) { db.Entry(roleIdentifier).State = EntityState.Modified; db.SaveChanges(); return(RedirectToAction("Index")); } return(View(roleIdentifier)); }
public async Task<User> CreateAsync(User entity, string password, RoleIdentifier roleIdentifier) { var dbEntity = await base.CreateAsync(entity); await AddPasswordAsync(entity.Id, password); await AddRoleAsync(entity.Id, roleIdentifier); return dbEntity; }
public ActionResult Create([Bind(Include = "roleIdentifierID,role")] RoleIdentifier roleIdentifier) { if (ModelState.IsValid) { db.RoleIdentifier.Add(roleIdentifier); db.SaveChanges(); return(RedirectToAction("Index")); } return(View(roleIdentifier)); }
public async Task <TDto> UpdateAsync <TDto>(TDto dto, RoleIdentifier roleIdentifier) { var entity = Mapper.Map <User>(dto); var dbEntity = await EntityRepository.GetByIdAsync(entity.Id); var updatedEntity = Mapper.Map(dto, dbEntity); var result = await EntityRepository.UpdateAsync(updatedEntity, roleIdentifier); return(Mapper.Map <TDto>(result)); }
// GET: RoleIdentifiers/Delete/5 public ActionResult Delete(int?id) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } RoleIdentifier roleIdentifier = db.RoleIdentifier.Find(id); if (roleIdentifier == null) { return(HttpNotFound()); } return(View(roleIdentifier)); }
protected static RoleIdentifier 角色(string roleName) { return(RoleIdentifier.of(roleName)); }
public Role GetByIdentifier(RoleIdentifier identifier) { return(Query.FirstOrDefault(r => r.Identifier == identifier)); }
public IRoleCommand UpdateRole(RoleIdentifier id) { return(new RoleCommand(GetRole(id), repository)); }
public async Task<IdentityResult> AddRoleAsync(Guid userId, RoleIdentifier roleIdentifier) { var role = _roleDefinitionProvider.Get(roleIdentifier); return await _userManager.AddToRoleAsync(userId, role.Name); }
public TDto GetByIdentifier <TDto>(RoleIdentifier identifier) { var entity = EntityRepository.GetByIdentifier(identifier); return(Mapper.Map <TDto>(entity)); }
public RoleDefinition Get(RoleIdentifier identifier) { return(Get(identifier, rd => rd.Identifier)); }