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));
}
