public async Task <ActionResult> AddAsync([FromBody] RoleRequest newRole)
{
await this.roleService.AddNewRoleAsync(newRole);
//return Created(newRole.Name, null);
return(StatusCode(StatusCodes.Status201Created));
}
public RoleListResponse GetRoles([FromBody] RoleRequest role)
{
RoleListResponse roleListResponse = new RoleListResponse();
try
{
roleListResponse.Roles = new List <RoleRow>();
var existedRole = _roleManager.Roles.Where((a => (a.Name == role.Name || string.IsNullOrEmpty(role.Name)) &&
(a.Id == role.Id || string.IsNullOrEmpty(role.Id)))).ToList();
foreach (var item in existedRole)
{
roleListResponse.Roles.Add(new RoleRow()
{
Id = item.Id, Name = item.Name
});
}
roleListResponse.ToSuccess <RoleListResponse>();
roleListResponse.LstCount = existedRole.Count();
return(roleListResponse);
}
catch (Exception ex)
{
return(roleListResponse.ToApiError <RoleListResponse>());
}
}
private async Task SaveAsync()
{
form.Validate();
if (form.IsValid)
{
var roleRequest = new RoleRequest()
{
Name = Name, Id = Id
};
var response = await _roleManager.SaveAsync(roleRequest);
if (response.Succeeded)
{
_snackBar.Add(localizer[response.Messages[0]], Severity.Success);
await hubConnection.SendAsync(ApplicationConstants.SignalR.SendUpdateDashboard);
MudDialog.Close();
}
else
{
foreach (var message in response.Messages)
{
_snackBar.Add(localizer[message], Severity.Error);
}
}
}
}
public IHttpActionResult AddRoles()
{
try
{
RoleRequest roleRequest = CreateRoleRequest(ESportUtils.ADMIN_ROLE, "Administrador de sistema");
roleService.AddRole(roleRequest);
roleRequest = CreateRoleRequest(ESportUtils.CLIENT_ROLE, "Cliente de ESport");
roleService.AddRole(roleRequest);
ControllerResponse response = ControllerHelper.CreateSuccessResponse("Roles agregados correctamente");
response.Data = roleService.GetAllRoles();
return(Ok(response));
}
catch (BadRequestException e)
{
return(BadRequest(e.Message));
}
catch (RepositoryException e)
{
return(CreateBadResponse(e.Message));
}
catch (OperationException e)
{
return(InternalServerError(e));
}
catch (Exception)
{
return(CreateBadResponse("Ocurrió un error al realizar operación"));
}
}
public ActionResult ModifyRole(RoleRequest param, int Id)
{
if (!ModelState.IsValid)
{
return(View());
}
var request = new RoleRequest();
request.RoleName = param.RoleName;
request.RoleDesc = param.RoleDesc;
request.IsRoleActive = param.IsRoleActive;
request.RoleId = Id;
request.SystemIp = ipaddress;
request.Computername = ComputerDetails;
var success = _dolphinApi.ModifyRole(request);
if (success != null)
{
if (success.ResponseCode.Equals("00"))
{
TempData["SuccessMsg"] = success.ResponseMessage;
return(RedirectToAction("listrole"));
}
else
{
ViewBag.ErrorMsg = success.ResponseMessage;
}
}
else
{
ViewBag.ErrorMsg = "Unsuccessful operation";
}
return(View());
}
public async Task <IHttpActionResult> PostRole(RoleRequest item)
{
try
{
string currentUserEmail = HttpUtilities.GetUserNameFromToken(this.Request);
string message = ValidationUtilities.ValidateRole(item);
if (string.IsNullOrEmpty(message))
{
Mapper.Initialize(cfg => cfg.CreateMap <RoleRequest, Role>()
.ForMember(i => i.CreatedBy, j => j.UseValue(currentUserEmail))
);
var RoleMap = Mapper.Map <RoleRequest, Role>(item);
RoleMap.Id = Guid.NewGuid().ToString();
Role current = await InsertAsync(RoleMap);
return(CreatedAtRoute("Tables", new { id = current.Id }, current));
}
else
{
return(BadRequest(message));
}
}
catch (Exception ex)
{
HttpUtilities.ServerError(ex, Request);
return(null);
}
}
public async Task <IActionResult> Add(RoleRequest roleDto)
{
try
{
if (roleDto == null)
{
return(BadRequest());
}
var roleModel = new RolePermissionModel()
{
Name = roleDto.Name,
Permissions = roleDto.Permissions,
RoleId = roleDto.RoleId
};
var role = await _roleService.AddRole(roleModel);
if (role != null)
{
var roleResponseDto = new RoleResponse {
Name = role.Name, Permissions = role.Permissions, RoleId = role.RoleId
};
return(CreatedAtAction(nameof(GetRole), new { id = role.RoleId }, roleResponseDto));
}
return(StatusCode(StatusCodes.Status404NotFound));
}
catch
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task <IActionResult> UpdateRole([FromBody] RoleRequest roleDto)
{
try
{
if (roleDto == null)
{
return(BadRequest());
}
var role = new RolePermissionModel()
{
Name = roleDto.Name,
Permissions = roleDto.Permissions,
RoleId = roleDto.RoleId
};
var result = await _roleService.UpdateRole(role);
if (result)
{
return(Ok(roleDto));
}
return(UnprocessableEntity(new { message = $"Unable to update role", key = "restrict" }));
}
catch
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task <ActionResult> UpdateAsync([FromRoute] Guid id, [FromBody] RoleRequest role)
{
role.Id = id;
await this.roleService.UpdateRoleAsync(role);
return(NoContent());
}
private void ValidateRoleId(RoleRequest request)
{
if (String.IsNullOrWhiteSpace(request.RoleId))
{
throw new BadRequestException("El Id del Rol no puede ser nulo");
}
}
public RequestParams GetWhere(RoleRequest request)
{
if (request == null)
{
return(null);
}
RequestParams rp = new RequestParams();
//追加查询参数
//if (!string.IsNullOrEmpty(request.email))
//{
// rp.Params.Add(new Params() { key = "email", value = request.email, searchType = EnumBase.SearchType.Eq });
//}
//添加排序(多个排序条件,可以额外添加)
//if (!string.IsNullOrEmpty(request.sortKey))
//{
// rp.Sort.Add(new Sort() { key = request.sortKey, searchType = (EnumBase.OrderType)request.sortType });
//}
//else
//{
// rp.Sort = null;
//}
//添加分页
if (request.pageIndex > 0)
{
rp.Paging.pageIndex = request.pageIndex;
rp.Paging.pageSize = request.pageSize;
}
else
{
rp.Paging = null;
}
return(rp);
}
public UserProfileResponse SetRole(Guid userId, RoleRequest request)
{
var roleId = _roleService.GetRoleId(request.Role);
_userRoleService.CreateUserRole(userId, roleId);
return(GetUserProfile(userId));
}
public List <RoleEntity> QueryRoleList(RoleRequest request, out int total)
{
total = 0;
List <RoleEntity> list = new List <RoleEntity>();
StringBuilder sq = new StringBuilder();
sq.Append(" select * from ( ");
sq.Append(" select {2} ");
sq.Append(" from dbo.tblAdminRole a with(nolock) ");
sq.Append(" where {0} ");
sq.Append(" ) c where {1} ");
DynamicParameters dp = new DynamicParameters();
string where_1 = " 1=1 ";
if (!string.IsNullOrWhiteSpace(request.RoleName))
{
where_1 += " and a.RoleName=@RoleName";
dp.Add("RoleName", request.RoleName, DbType.String);
}
dp.Add("PageIndex", request.PageIndex, DbType.Int32, ParameterDirection.Input);
dp.Add("PageSize", request.PageSize, DbType.Int32, ParameterDirection.Input);
string sql_list = string.Format(sq.ToString(), where_1, " c.Num > (@PageIndex - 1) * @PageSize and c.Num <= @PageIndex * @PageSize", "ROW_NUMBER() over(order by a.CreateTime desc) as Num,* ");
string sql_count = string.Format(sq.ToString(), where_1, "1=1", "count(0) as nums");
using (IDbConnection conn = new SqlConnection(DbConnectionStringConfig.Default.MyShopConnectionString))
{
total = conn.Query <int>(sql_count, dp).FirstOrDefault();
list = conn.Query <RoleEntity>(sql_list, dp).ToList();
}
return(list);
}
public async Task <Result <string> > SaveAsync(RoleRequest request)
{
if (string.IsNullOrEmpty(request.Id))
{
var existingRole = await _roleManager.FindByNameAsync(request.Name);
if (existingRole != null)
{
return(Result <string> .Fail($"Similar Role already exists."));
}
var response = await _roleManager.CreateAsync(new IdentityRole(request.Name));
return(Result <string> .Success("Role Created."));
}
else
{
var existingRole = await _roleManager.FindByIdAsync(request.Id);
if (existingRole.Name == "Administrator" || existingRole.Name == "Basic")
{
return(Result <string> .Fail($"Not allowed to modify {existingRole.Name} Role."));
}
existingRole.Name = request.Name;
existingRole.NormalizedName = request.Name.ToUpper();
await _roleManager.UpdateAsync(existingRole);
return(Result <string> .Success("Role Updated."));
}
}
public ActionResult CreateOrEditRole()
{
RoleResponse _response = new RoleResponse();
if (Request.QueryString["id"] != null)
{
var request = new RoleRequest
{
Data = new RoleModel
{
Id = long.Parse(Request.QueryString["id"].ToString())
}
};
RoleResponse resp = new RoleHandler(_unitOfWork).GetDetail(request);
RoleModel _model = resp.Entity;
ViewBag.Response = _response;
ViewBag.Organisasi = BindDropDownOrganization();
ViewBag.ActionType = ClinicEnums.Action.Edit;
return(View(_model));
}
else
{
ViewBag.Response = _response;
ViewBag.Organisasi = BindDropDownOrganization();
ViewBag.ActionType = ClinicEnums.Action.Add;
return(View());
}
}
/// <summary>
/// Get the list of roles based on the company
/// </summary>
/// <param name="roleRequest"></param>
/// <param name="context"></param>
/// <returns>RoleResponse</returns>
public RoleResponse GetRoles(RoleRequest roleRequest, ILambdaContext context = null)
{
RoleRepository roleRepository = new RoleRepository();
RoleResponse roleResponse = new RoleResponse();
Authorizer authorizer = new Authorizer();
try
{
if (authorizer.ValidateUser(roleRequest.UserId, roleRequest.CompanyId, roleRequest.Payload.AppType))
{
return(roleRepository.GetRoles(roleRequest));
}
else
{
roleResponse.Error = ResponseBuilder.Forbidden();
return(roleResponse);
}
}
catch (Exception getRolesException)
{
LambdaLogger.Log(getRolesException.ToString());
roleResponse.Error = ResponseBuilder.InternalError();
return(roleResponse);
}
}
public async Task <MainRoleResponse> UpdateRole(RoleRequest roleRequest)
{
try
{
var getRole = _roleRepository.GetRoleById(roleRequest.RoleId);
if (getRole.Result != null)
{
var role = _mapper.Map <Roles>(getRole.Result);
role.RoleName = roleRequest.RoleName;
role.Description = roleRequest.Description;
role.ModifiedOn = DateTime.Now;
role.ModifiedBy = roleRequest.UserId.ToString();
var dataRole = await _roleRepository.UpdateAsync(role);
}
else
{
_response.Message = Constants.Role_Not_Update;
_response.Status = false;
return(_response);
}
_response.Message = Constants.Role_Update_Success;
_response.Status = true;
return(_response);
}
catch (Exception ex)
{
var msg = ex.Message;
_response.Status = false;
_response.Message = Constants.DEFAULT_ERROR_MSG;
}
return(_response);
}
/// <summary>
///获取某个角色下的菜单
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public Response <IEnumerable <ProjectRoleMenu> > GetRoleMenu(RoleRequest request)
{
Response <IEnumerable <ProjectRoleMenu> > response = new Response <IEnumerable <ProjectRoleMenu> >();
if (request == null)
{
ArgumentNullException ex = new ArgumentNullException("GetRoleMenu request");
LogError(ex);
response.ErrorCode = ErrorCode.Argument;
response.Exception = ex;
return(response);
}
try
{
RoleAccessor accessor = new RoleAccessor();
response.Result = accessor.GetRoleMenuByProjectRoleID(request.ProjectRoleID);
response.IsSuccess = true;
}
catch (Exception ex)
{
LogError(ex);
response.IsSuccess = false;
response.ErrorCode = ErrorCode.Technical;
}
return(response);
}
private void validateRoleDescription(RoleRequest request)
{
if (String.IsNullOrWhiteSpace(request.Description))
{
throw new BadRequestException("La descripción del Rol no puede ser nulo");
}
}
public async Task <IActionResult> PutRole(int id, [FromBody] RoleRequest roleRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ApplicationRole role = await rolemanager.FindByIdAsync(id.ToString());
if (role == null)
{
return(BadRequest());
}
role.Name = roleRequest.Name;
IdentityResult result = await rolemanager.UpdateAsync(role);
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest(result.Errors));
}
public RoleResponse SetUpNewRole(RoleRequest request)
{
var param = new UserRole();
param.Rolename = request.RoleName;
param.Roledesc = request.RoleDesc;
param.Isroleactive = request.IsRoleActive;
bool success = InsertRole(param);
if (success)
{
Log.InfoFormat(request.Computername, request.SystemIp, request.CreatedBy, Constants.ActionType.SetupUserRole.ToString());
_audit.InsertAudit(request.CreatedBy, Constants.ActionType.SetupUserRole.ToString(), "Setup User Role", DateTime.Now, request.Computername, request.SystemIp);
return(new RoleResponse
{
ResponseCode = "00",
ResponseMessage = "Record successfully created"
});
}
else
{
Log.InfoFormat(request.Computername, request.SystemIp, request.CreatedBy, Constants.ActionType.SetupUserRole.ToString());
return(new RoleResponse
{
ResponseCode = "01",
ResponseMessage = "Unable to create record"
});
}
}
public async Task Put(int id, RoleRequest request)
{
var model = await _roleRepository.GetByIdAsync(id);
model.Name = request.Name;
await _roleRepository.Put(model);
}
public RoleResponse RoleDetails(RoleRequest request)
{
try
{
var success = GetRoleDetailsById(request.RoleId);
if (success != null)
{
var result = new List <RoleDetailsObj>
{
success
};
return(new RoleResponse {
ResponseCode = "00", ResponseMessage = "Success", RoleDetails = result
});
}
else
{
return(new RoleResponse {
ResponseCode = "01", ResponseMessage = "Success", RoleDetails = new List <RoleDetailsObj>()
});
}
}
catch (Exception ex)
{
Log.ErrorFormat("GetRoleDetails", ex.ToString());
return(new RoleResponse()
{
ResponseCode = "XX", ResponseMessage = "System error", RoleDetails = new List <RoleDetailsObj>()
});
}
}
public ActionResult GetRoleData()
{
var _draw = Request.Form.GetValues("draw").FirstOrDefault();
var _start = Request.Form.GetValues("start").FirstOrDefault();
var _length = Request.Form.GetValues("length").FirstOrDefault();
var _sortColumn = Request.Form.GetValues("columns[" + Request.Form.GetValues("order[0][column]").FirstOrDefault() + "][name]").FirstOrDefault();
var _sortColumnDir = Request.Form.GetValues("order[0][dir]").FirstOrDefault();
var _searchValue = Request.Form.GetValues("search[value]").FirstOrDefault();
int _pageSize = _length != null?Convert.ToInt32(_length) : 0;
int _skip = _start != null?Convert.ToInt32(_start) : 0;
var request = new RoleRequest
{
Draw = _draw,
SearchValue = _searchValue,
SortColumn = _sortColumn,
SortColumnDir = _sortColumnDir,
PageSize = _pageSize,
Skip = _skip
};
var response = new RoleHandler(_unitOfWork).GetListData(request);
return(Json(new { data = response.Data, recordsFiltered = response.RecordsFiltered, recordsTotal = response.RecordsTotal, draw = response.Draw }, JsonRequestBehavior.AllowGet));
}
private async Task SaveAsync()
{
form.Validate();
if (form.IsValid)
{
var roleRequest = new RoleRequest()
{
Name = Name, Id = Id
};
var response = await _roleManager.SaveAsync(roleRequest);
if (response.Succeeded)
{
_snackBar.Add(localizer[response.Messages[0]], Severity.Success);
MudDialog.Close();
}
else
{
foreach (var message in response.Messages)
{
_snackBar.Add(localizer[message], Severity.Error);
}
}
}
}
public IHttpActionResult RemoveRole(RoleRequest roleRequest)
{
try
{
ControllerHelper.ValidateUserRole(Request, new string[] { ESportUtils.ADMIN_ROLE });
roleService.RemoveRole(roleRequest);
return(CreateSuccessResponse("El rol se eliminó satisfactoriamente"));
}
catch (BadRequestException e)
{
return(CreateBadResponse(e.Message));
}
catch (RepositoryException e)
{
return(CreateBadResponse(e.Message));
}
catch (OperationException e)
{
return(CreateBadResponse(e.Message));
}
catch (Exception)
{
return(CreateBadResponse("Ocurrió un error al agregar rol"));
}
}
public IActionResult GetUserRoles()
{
var request = new RoleRequest();
var response = _service.GetUserRoles(request);
return(response.Success ? Ok(response) : StatusCode(404, response.Errors));
}
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 <JsonResult> AddRole(Guid requestId, Guid roleId)
{
var roleRequest = this.roleRequestService.Get(ru => ru.RoleId == roleId && ru.RequestId == requestId);
if (roleRequest == null)
{
roleRequest = new RoleRequest {
RequestId = requestId, RoleId = roleId
};
this.roleRequestService.Create(roleRequest);
}
else
{
return(Json(null));
}
var roleRequests = await this.roleRequestService.GetManyAsync(ru => ru.RequestId == requestId);
string roleNames = "";
foreach (var _roleRequest in roleRequests)
{
var role = this.roleService.GetById(_roleRequest.RoleId);
roleNames += role.Name + ",";
}
//JsonResult jsonResult = role == null ? Json(null) : Json(new { RoleName = role.Name });
return(Json(new { RoleNames = roleNames }));
}
public static Role ToModel(this RoleRequest roleContract)
{
return(new Role {
Name = roleContract.Name,
ClaimScope = roleContract.ClaimScope.Value,
Default = false
});
}
public void DropMembers()
{
Ektron.Cms.Content.EkContent contObj;
role_request = new RoleRequest();
role_request.RoleId = m_nRoleId;
//role_request.IncludeMember = True
role_request.IsAssigned = true;
role_request.RoleType = Convert.ToInt32(m_strSelectedItem);
role_request.SortDirection = "";
role_request.SortOrder = "";
role_request.PageSize = m_refContentApi.RequestInformationRef.PagingSize;
role_request.CurrentPage = m_intCurrentPage;
contObj = m_refContentApi.EkContentRef;
DropRoleMembersToolBar();
// m_RoleMembers = contObj.GetAllRoleMembers(m_nRoleId)
m_RoleMembers = contObj.GetAllRoleMembers(ref role_request);
m_intTotalPages = role_request.TotalPages;
Populate_Members_RoleMemberGrid(true);
}
public void AddMembers()
{
Ektron.Cms.Content.EkContent contObj;
contObj = m_refContentApi.EkContentRef;
if (Page.IsPostBack && Request.Form[isSearchPostData.UniqueID] != "")
{
AddRoleMembersToolBar();
CollectSearchText();
DisplayUsers();
}
else
{
AddRoleMembersToolBar();
role_request = new RoleRequest();
role_request.RoleId = m_nRoleId;
//role_request.IncludeMember = True
role_request.IsAssigned = false;
role_request.RoleType = Convert.ToInt32(m_strSelectedItem);
role_request.SortDirection = "";
role_request.SortOrder = "";
role_request.PageSize = m_refContentApi.RequestInformationRef.PagingSize;
role_request.CurrentPage = m_intCurrentPage;
//m_RoleMembers = contObj.GetAllNonRoleMembers(m_nRoleId, m_IncludeMembershipItems)
m_RoleMembers = contObj.GetAllRoleMembers(ref role_request);
m_intTotalPages = role_request.TotalPages;
Populate_Members_RoleMemberGrid(true);
}
}
private void DisplayUsers()
{
Ektron.Cms.Content.EkContent contObj;
if (Request.QueryString["OrderBy"] == "")
{
OrderBy = "user_name";
}
else
{
OrderBy = Request.QueryString["OrderBy"];
}
contObj = m_refContentApi.EkContentRef;
role_request = new RoleRequest();
role_request.RoleId = m_nRoleId;
role_request.SearchText = m_strSearchText;
if (m_strOperation == "addmembers")
{
role_request.IsAssigned = false;
}
else
{
role_request.IsAssigned = true;
}
role_request.RoleType = Convert.ToInt32(m_strSelectedItem);
role_request.PageSize = m_refContentApi.RequestInformationRef.PagingSize;
role_request.CurrentPage = m_intCurrentPage;
m_RoleMembers = contObj.GetAllRoleMembers(ref role_request);
m_intTotalPages = role_request.TotalPages;
if (m_strOperation == "")
{
ViewRoleMembersToolBar();
}
if (m_strOperation == "addmembers")
{
Populate_Members_RoleMemberGrid(true);
}
else
{
Populate_Members_RoleMemberGrid(false);
}
}
public void ViewRoleMembers()
{
if (Page.IsPostBack && Request.Form[isSearchPostData.UniqueID] != "")
{
CollectSearchText();
DisplayUsers();
}
else
{
Ektron.Cms.Content.EkContent contObj;
contObj = m_refContentApi.EkContentRef;
role_request = new RoleRequest();
role_request.RoleId = m_nRoleId;
//role_request.IncludeMember = True
role_request.SearchText = m_strSearchText;
role_request.IsAssigned = true;
role_request.RoleType = Convert.ToInt32(m_strSelectedItem);
role_request.PageSize = m_refContentApi.RequestInformationRef.PagingSize;
role_request.CurrentPage = m_intCurrentPage;
m_RoleMembers = contObj.GetAllRoleMembers(ref role_request); //contObj.GetAllRoleMembers(m_nRoleId)
m_intTotalPages = role_request.TotalPages;
ViewRoleMembersToolBar();
Populate_Members_RoleMemberGrid(false);
}
}
