public ModelResult <Role> EditRole(Role role, RoleInput roleInput)
{
ValidationStateDictionary validationState = new ValidationStateDictionary();
validationState.Add(typeof(RoleInput), validator.Validate(roleInput));
if (!validationState.IsValid)
{
return(new ModelResult <Role>(validationState));
}
Role originalRole = role;
Role newRole;
using (TransactionScope transaction = new TransactionScope())
{
newRole = originalRole.Apply(roleInput);
validateRole(newRole, originalRole, validationState);
if (!validationState.IsValid)
{
return(new ModelResult <Role>(validationState));
}
newRole = repository.Save(newRole);
transaction.Complete();
}
pluginEngine.ExecuteAll("RoleSaved", new { context, role = new RoleReadOnly(newRole) });
pluginEngine.ExecuteAll("RoleEdited", new { context, role = new RoleReadOnly(newRole), roleOriginal = new RoleReadOnly(originalRole) });
return(new ModelResult <Role>(newRole, validationState));
}
public ModelResult <Role> AddRole(RoleInput roleInput)
{
ValidationStateDictionary validationState = new ValidationStateDictionary();
validationState.Add(typeof(RoleInput), validator.Validate(roleInput));
if (!validationState.IsValid)
{
return(new ModelResult <Role>(validationState));
}
Role role;
using (TransactionScope transaction = new TransactionScope())
{
role = roleInput.ToRole();
validateRole(role, validationState);
if (!validationState.IsValid)
{
return(new ModelResult <Role>(validationState));
}
role = repository.Save(role);
transaction.Complete();
}
pluginEngine.ExecuteAll("RoleSaved", new { context, role = new RoleReadOnly(role) });
pluginEngine.ExecuteAll("RoleAdded", new { context, role = new RoleReadOnly(role) });
return(new ModelResult <Role>(role, validationState));
}
public bool Update(RoleInput roleInput, out string message)
{
IQueryable <RoleInfo> roleInfos = _dbContext.Set <RoleInfo>();
RoleInfo role1 = roleInfos.Where(r => r.RoleId == roleInput.RoleId).FirstOrDefault();//判断角色是否存在
if (role1 != null)
{
RoleInfo role2 = roleInfos.Where(r => r.RoleName == roleInput.RoleName).FirstOrDefault();//名字是否被使用
if (role2 == null || role1.RoleName == roleInput.RoleName)
{
try
{
role1.RoleName = roleInput.RoleName;
role1.Description = roleInput.Description;
_dbContext.Set <RoleInfo>().Update(role1);
if (_dbContext.SaveChanges() > 0)
{
message = "修改成功！";
return(true);
}
message = "失败！内部出现异常！";
return(false);
}
catch (Exception ex)
{
message = ex.Message;
return(false);
}
}
message = "该角色名已被使用！";
return(false);
}
message = "找不到该角色！数据可能被篡改！";
return(false);
}
public async Task CreateEditRole(RoleInput input)
{
var permissions =
input.AssignedPermissions.Select(assignedPermission => new Permission(assignedPermission.Name))
.ToList();
if (input.Id == 0)
{
var role = input.MapTo <Role>();
await _roleManager.CreateAsync(role);
await CurrentUnitOfWork.SaveChangesAsync();
await _roleManager.SetGrantedPermissionsAsync(role, permissions);
await _rolesAppNotificationsSender.SendRoleCreatedNotification((await GetCurrentUserAsync()), role);
}
else
{
var role = await _roleManager.GetRoleByIdAsync(input.Id);
var mapped = input.MapTo(role);
await _roleManager.UpdateAsync(mapped);
await CurrentUnitOfWork.SaveChangesAsync();
await _roleManager.SetGrantedPermissionsAsync(mapped, permissions);
await _rolesAppNotificationsSender.SendRoleEditedNotification((await GetCurrentUserAsync()), role);
}
}
public void SavePost(RoleInput input)
{
try
{
var role = _roleManager.FindById(input.Id) ?? new Role();
role.Name = input.Name;
role.DisplayName = input.DisplayName;
role.ParentId = input.ParentId;
role.TenantId = input.TenantId;
if (input.Id == 0)
{
_roleManager.Create(role);
}
else
{
_roleManager.Update(role);
}
_roleStore.SetNavs(role.Id, input.ParentNavIds);
_moduleManager.SetEvent(role.Id, input.ChildNavIds);
//_roleStore.SetFuns(role.Id, input.FunIds);
CurrentUnitOfWork.SaveChanges();
}
catch (Exception ex)
{
throw new UserFriendlyException(ex.Message);
}
}
public async Task <ApiItemResult> EditRole([FromBody] RoleInput roleInput)
{
var result = new ApiItemResult();
if (!ModelState.IsValid)
{
result.Code = 400;
result.Message = "编辑角色失败：" + ModelState.FirstErrorMessage();
return(result);
}
if (roleInput.RoleId.IsNullOrEmpty())
{
result.Code = 400;
result.Message = "编辑角色失败：必须提供参数 RoleId";
return(result);
}
var role = await _roleService.SaveAsync(roleInput, ModelState);
if (role == null)
{
result.Code = 400;
result.Message = "编辑角色失败：" + ModelState.FirstErrorMessage();
return(result);
}
result.Code = 200;
result.Message = "编辑角色成功";
result.Item = role;
return(result);
}
public void Update(RoleInput entity)
{
this.DbHelper.Execute(this.Table, proc =>
proc.AsUpdate(entity, "Name", "Modifier", "ModifyTime")
.Where("Id", entity.Id)
);
}
public async Task <ApiResultData <Role> > EditRole(RoleInput roleInput)
{
var result = new ApiResultData <Role>();
if (roleInput.RoleId.IsNullOrEmpty())
{
result.Code = 400;
result.Message = "编辑角色失败：必须提供参数 RoleId";
return(result);
}
if (!await _roleService.SaveAsync(roleInput, ModelState))
{
result.Code = 400;
result.Message = "编辑角色失败：" + ModelState.FirstErrorMessage();
return(result);
}
// 角色名称不能重复
var role = await _roleService.GetItemAsync(roleInput.Name);
result.Code = 200;
result.Message = "编辑角色成功";
result.Data = role;
return(result);
}
public GetResults <RoleDto> GetRoles(RoleInput input)
{
var result = GetDefault <GetResults <RoleDto> >();
var filterExp = BuildExpression(input);
var query = _roleRepository.Find(filterExp, r => r.Id, SortOrder.Descending, input.Current, input.Size);
if (input.UserId > 0)
{
query = query.Where(x => x.UserRoles.Any((z => z.UserId == input.UserId)));
}
result.Total = _roleRepository.Find(filterExp).Count();
result.Data = query.Select(roleDto => new RoleDto()
{
Id = roleDto.Id,
Name = roleDto.RoleName,
Permissions = roleDto.RolePermissions.Select(p => new BaseEntityDto()
{
Id = p.Permission.Id,
Name = p.Permission.Name
}).ToList()
}).ToList();
return(result);
}
public async Task <ApiResultData <Role> > AddRole(RoleInput roleInput)
{
var result = new ApiResultData <Role>();
if (roleInput.RoleId.HasValue)
{
// Guid.Empty 也不允许
result.Code = 400;
result.Message = "添加角色失败：无需提供参数 RoleId";
return(result);
}
roleInput.RoleId = Guid.NewGuid();
if (!await _roleService.SaveAsync(roleInput, ModelState))
{
result.Code = 400;
result.Message = "添加角色失败：" + ModelState.FirstErrorMessage();
return(result);
}
// 角色名称不能重复
var role = await _roleService.GetItemAsync(roleInput.Name);
result.Code = 200;
result.Message = "添加角色成功";
result.Data = role;
return(result);
}
/// <summary>
/// 角色新增
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <bool> AddRole(RoleInput input)
{
var role = Mapper.Map <Role>(input);
role.TerantId = CurrentUser.Terant.Id;
await _roleRep.InsertAsync(role);
var users = await _userRep.Select
.WhereIf(
input.UserIds?.Any() ?? false,
u => !u.IsDeleted && input.UserIds.Contains(u.Id))
.ToListAsync();
role.UserRoles = new List <UserRole>();
foreach (var user in users)
{
role.UserRoles.Add(new UserRole()
{
RoleId = role.Id,
UserId = user.Id
});
}
await UnitOfWork.GetRepository <UserRole>().InsertAsync(role.UserRoles);
try
{
UnitOfWork.Commit(); return(true);
}
catch (Exception e)
{
UnitOfWork.Rollback();
Logger.LogError(e.ToString());
return(false);
}
}
public Task <IActionResult> Create([FromBody] RoleInput input)
{
return(Task.Run <IActionResult>(() =>
{
if (!ModelState.IsValid)
{
return BadRequest();
}
var roleExists = _db.Where <Role>(r => r.Name == input.Name).Any();
if (roleExists)
{
return new StatusCodeResult((int)HttpStatusCode.Conflict);
}
var role = new Role()
{
Name = input.Name,
Permissions = input.Permissions
};
_db.Add(role);
return Ok(new { success = true });
}));
}
public Task <IActionResult> Update(string id, [FromBody] RoleInput input)
{
return(Task.Run <IActionResult>(() =>
{
if (!ModelState.IsValid)
{
return BadRequest();
}
var roleExists = _db.Single <Role>(r => r.Id == id) != null;
if (!roleExists)
{
return new StatusCodeResult((int)HttpStatusCode.NotFound);
}
var role = new Role()
{
Id = id,
Name = input.Name,
Permissions = input.Permissions
};
_db.Replace(r => r.Id == id, role);
return Ok(new { success = true });
}));
}
public async Task <ApiItemResult> AddRole([FromBody] RoleInput roleInput)
{
var result = new ApiItemResult();
if (roleInput.RoleId.HasValue)
{
// Guid.Empty 也不允许
result.Code = 400;
result.Message = "添加角色失败：无需提供参数 RoleId";
return(result);
}
var role = await _roleService.SaveAsync(roleInput, ModelState);
if (role == null)
{
result.Code = 400;
result.Message = "添加角色失败：" + ModelState.FirstErrorMessage();
return(result);
}
result.Code = 200;
result.Message = "添加角色成功";
result.Item = role;
return(result);
}
public override void OnEnter(BInput input)
{
RoleInput tinput = input as RoleInput;
this.m_ftime = Time.time;
this.m_over = false;
Debug.Log("ActionAddHP");
}
public ResponseModelBase <RoleOutput> Create(RoleInput entity)
{
var roleEntity = Mapper.Map <Role>(entity);
var result = _roleService.Create(roleEntity);
var roleOutput = Mapper.Map <RoleOutput>(result);
return(new ResponseModelBase <RoleOutput>().OkResult(roleOutput, result.Validations.ErrorMessages));
}
public override void OnEnter(BInput input)
{
DarkBattleTimer.Instance.IsRunning = false;
RoleInput tinput = input as RoleInput;
tinput.Parent.ToAttackPerson();
Debug.Log("ActionChoose");
}
public ActionResult InserRole()
{
var model = new RoleInput {
TenantId = AbpSession.TenantId
};
return(View("Easyman.FwWeb.Views.Admin.EditRole", model));
}
public override void OnEnter(BInput input)
{
RoleInput pInput = (RoleInput)input;
Animation playerAnim = pInput.Parent.RoleObject.GetComponent <Animation>();
playerAnim[StateDef.PlayerAnimationClipName.WalkBackR].time = 0;
playerAnim[StateDef.PlayerAnimationClipName.WalkBackR].wrapMode = WrapMode.Loop;
playerAnim.Play(StateDef.PlayerAnimationClipName.WalkBackR);
}
public void Delete(RoleInput entity)
{
entity.IsDeleted = 1;
this.DbHelper.Execute(this.Table, proc =>
proc.AsUpdate(entity, "IsDeleted", "Modifier", "ModifyTime")
.Where("Id", entity.Id)
);
}
public override ActionResult Excute(BInput input)
{
RoleInput tinput = input as RoleInput;
if (tinput.Parent.RoleActionFlag.HasFlag((long)StateDef.PlayerActionFlag.AddHP))
{
return ActionResult.SUCCESS;
}
return ActionResult.FAILURE;
}
public async Task <ServiceResult> SubmitAsync([FromBody] RoleInput input)
{
if (!string.IsNullOrWhiteSpace(input.Id))
{
return(await _roleService.UpdateAsync(input.Id, input));
}
else
{
return(await _roleService.AddAsync(input));
}
}
/// <summary>
/// 验证角色名称是否已经被使用
/// </summary>
private async Task <bool> ValidateExistsAsync(RoleInput roleInput, ModelStateDictionary modelState)
{
var foundRole = await _manager.GetItemAsync(roleInput.Name);
if (foundRole != null && roleInput.RoleId != foundRole.RoleId)
{
modelState.AddModelError("Name", $"角色名称【{roleInput.Name}】已经被使用");
return(false);
}
return(true);
}
private Expression <Func <Role, bool> > BuildExpression(RoleInput input)
{
Expression <Func <Role, bool> > filterExp = x => true;
if (!string.IsNullOrWhiteSpace(input.Name))
{
filterExp = (x => x.RoleName.Contains(input.Name));
}
return(filterExp);
}
public override void OnEnter(BInput input)
{
RoleInput tinput = input as RoleInput;
Animation playerAnim = tinput.Parent.RoleObject.GetComponent <Animation>();
playerAnim[StateDef.PlayerAnimationClipName.IdleR].time = 0;
playerAnim[StateDef.PlayerAnimationClipName.IdleR].wrapMode = WrapMode.Loop;
playerAnim.Play(StateDef.PlayerAnimationClipName.IdleR);
m_fTime = DarkBattleTimer.Instance.PastedTime;
m_over = false;
duration = tinput.Agility;
}
public override ActionResult Excute(BInput input)
{
RoleInput tinput = input as RoleInput;
if (tinput.Parent.RoleActionFlag.HasFlag((long)StateDef.PlayerActionFlag.Hit))
{
Debug.logger.Log("????????????????????");
//tinput.Parent.RoleActionFlag.RemoveFlag((long)StateDef.PlayerActionFlag.Hit);
return(ActionResult.SUCCESS);
}
return(ActionResult.RUNNING);
}
public async Task <bool> Add(RoleInput addInput)
{
WebCoreRole entity = mapper.Map <WebCoreRole>(addInput);
entity.CreatedBy = GetCurrentUserLogin();
entity.CreatedDate = DateTime.Now;
entity.ModifiedBy = entity.CreatedBy;
entity.ModifiedDate = entity.CreatedDate;
entity.UpdateToken = Guid.NewGuid();
IdentityResult result = await roleManager.CreateAsync(entity);
return(result.Succeeded);
}
/// <summary>
/// 添加
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <ServiceResult> AddAsync(RoleInput input)
{
var result = new ServiceResult();
var entity = ObjectMapper.Map <RoleInput, RoleEntity>(input);
entity.CreateTime = DateTime.Now;
entity.Creater = "admin";
await _roleRepository.InsertAsync(entity, true);
result.IsSuccess();
return(result);
}
public IActionResult InputPartial(EntityId <string> idModel = null)
{
RoleInput input = null;
if (idModel == null)
{
input = new RoleInput();
}
else
{
input = roleService.GetInputById(idModel);
}
return(PartialView(input));
}
//excute
public override ActionResult Excute(BInput input)
{
if (Time.time - this.m_ftime > m_duration)
{
this.m_over = true;
}
if (this.m_over)
{
RoleInput tinput = input as RoleInput;
tinput.Parent.RoleActionFlag.RemoveFlag((long)StateDef.PlayerActionFlag.AddHP);
return(ActionResult.SUCCESS);
}
return(ActionResult.RUNNING);
}
