public RoleResponse GetRole(int roleId)
{
var roleList = _dbContext.RolePolicyDetail.Where(p => p.RoleId == roleId).ToList();
var roles = roleList.GroupBy(p => new { p.RoleId, p.Name });
foreach (var item in roles)
{
var obj = new RoleResponse();
obj.RoleId = item.Key.RoleId;
obj.Name = item.Key.Name;
obj.Policies = new List <PolicyResponse>();
foreach (var resouce in item.Where(p => p.PolicyId.HasValue))
{
var res = new PolicyResponse()
{
PolicyId = resouce.PolicyId,
Name = resouce.PolicyName,
Description = resouce.PolicyDescription
};
obj.Policies.Add(res);
}
return(obj);
}
return(null);
}
public List <RoleResponse> GetPartnerRoles()
{
var roleList = _dbContext.RolePolicyDetail.Where(p => !p.IsDeleted && p.RoleType == "Partner").ToList();
var roles = roleList.GroupBy(p => new { p.RoleId, p.Name, p.RoleType });
var response = new List <RoleResponse>();
foreach (var item in roles)
{
var obj = new RoleResponse();
obj.RoleId = item.Key.RoleId;
obj.Name = item.Key.Name;
obj.RoleType = item.Key.RoleType;
obj.Policies = new List <PolicyResponse>();
foreach (var resouce in item.Where(p => p.PolicyId.HasValue))
{
var res = new PolicyResponse()
{
PolicyId = resouce.PolicyId,
Name = resouce.PolicyName,
Description = resouce.PolicyDescription
};
obj.Policies.Add(res);
}
response.Add(obj);
}
return(response);
}
public IEnumerable <UserResponse> GetUsers(string userName = "")
{
var userList = _dbContext.UserRoleDetail.Where(p => p.IsActive).ToList();
var users = userList.GroupBy(p => new { p.UserId, p.FirstName, p.LastName, p.Mobile, p.Email, p.AzureAdId, p.CreatedBy, p.CreatedDate });
var response = new List <UserResponse>();
foreach (var item in users)
{
var obj = new UserResponse();
obj.UserId = item.Key.UserId;
obj.FirstName = item.Key.FirstName;
obj.LastName = item.Key.LastName;
obj.Email = item.Key.Email;
obj.Roles = new List <RoleResponse>();
foreach (var role in item.Where(p => p.RoleId.HasValue))
{
var res = new RoleResponse()
{
RoleId = role.RoleId,
Name = role.RoleName,
};
obj.Roles.Add(res);
}
response.Add(obj);
}
return(response);
}
public UserResponse GetUserById(int userId)
{
var userList = _dbContext.UserRoleDetail.Where(p => p.UserId == userId).ToList();
var users = userList.GroupBy(p => new { p.UserId, p.FirstName, p.LastName, p.Mobile, p.Email, p.AzureAdId, p.CreatedBy, p.CreatedDate });
foreach (var item in users)
{
var obj = new UserResponse();
obj.UserId = item.Key.UserId;
obj.FirstName = item.Key.FirstName;
obj.LastName = item.Key.LastName;
obj.Email = item.Key.Email;
obj.Roles = new List <RoleResponse>();
foreach (var role in item.Where(p => p.RoleId.HasValue))
{
var res = new RoleResponse()
{
RoleId = role.RoleId,
Name = role.RoleName,
};
obj.Roles.Add(res);
}
return(obj);
}
return(null);
}
private static async Task DeleteRole(RoleResponse role, ISystemRoleApi roleApi)
{
Debug.Assert(role.Id.HasValue, "Role ID must be set");
await roleApi.DeleteRolesAsync(new SqlQuery(), role.Id.Value);
Console.WriteLine("DeleteRolesAsync():: id={0}", role.Id);
}
private static async Task DeleteRole(RoleResponse role, ISystemApi systemApi)
{
Debug.Assert(role.id.HasValue, "Role ID must be set");
await systemApi.DeleteRolesAsync(role.id.Value);
Console.WriteLine("DeleteRolesAsync():: id={0}", role.id);
}
//[Authorize(Roles ="SAdmin")]
public async Task <HttpResponseMessage> GetPermission(MT_Role RMD)
{
Db = con.SurgeryCenterDb(RMD.Slug);
RoleResponse Response = new RoleResponse();
try
{
List <MT_Role> AnesList = new List <MT_Role>();
Query docRef = Db.Collection("MT_Role").WhereEqualTo("ROM_Is_Deleted", false).WhereEqualTo("ROM_Is_Active", true).WhereEqualTo("ROM_Surgery_Physician_Center_ID", RMD.ROM_Surgery_Physician_Center_ID).WhereEqualTo("ROM_Office_Type", RMD.ROM_Office_Type);
QuerySnapshot ObjQuerySnap = await docRef.GetSnapshotAsync();
if (ObjQuerySnap != null)
{
foreach (DocumentSnapshot Docsnapshot in ObjQuerySnap.Documents)
{
AnesList.Add(Docsnapshot.ConvertTo <MT_Role>());
}
Response.DataList = AnesList.OrderBy(o => o.ROM_Name).ToList();
}
Response.Status = con.StatusSuccess;
Response.Message = con.MessageSuccess;
}
catch (Exception ex)
{
Response.Status = con.StatusFailed;
Response.Message = con.MessageFailed + ", Exception : " + ex.Message;
}
return(ConvertToJSON(Response));
}
//[Authorize(Roles = "Admin")]
public async Task <HttpResponseMessage> Select(MT_Role RMD)
{
Db = con.SurgeryCenterDb(RMD.Slug);
RoleResponse Response = new RoleResponse();
try
{
MT_Role role = new MT_Role();
Query docRef = Db.Collection("MT_Role").WhereEqualTo("ROM_Unique_ID", RMD.ROM_Unique_ID).WhereEqualTo("ROM_Is_Deleted", false);
QuerySnapshot ObjQuerySnap = await docRef.GetSnapshotAsync();
if (ObjQuerySnap != null)
{
role = ObjQuerySnap.Documents[0].ConvertTo <MT_Role>();
Response.Data = role;
}
Response.Status = con.StatusSuccess;
Response.Message = con.MessageSuccess;
}
catch (Exception ex)
{
Response.Status = con.StatusFailed;
Response.Message = con.MessageFailed + ", Exception : " + ex.Message;
}
return(ConvertToJSON(Response));
}
public async Task <HttpResponseMessage> Remove(MT_Role RMD)
{
Db = con.SurgeryCenterDb(RMD.Slug);
RoleResponse Response = new RoleResponse();
try
{
DocumentReference docRef = Db.Collection("MT_Role").Document(RMD.ROM_Unique_ID);
WriteResult Result = await docRef.DeleteAsync();
if (Result != null)
{
Response.Status = con.StatusSuccess;
Response.Message = con.MessageSuccess;
Response.Data = null;
}
else
{
Response.Status = con.StatusNotDeleted;
Response.Message = con.MessageNotDeleted;
Response.Data = null;
}
}
catch (Exception ex)
{
Response.Status = con.StatusFailed;
Response.Message = con.MessageFailed + ", Exception : " + ex.Message;
}
return(ConvertToJSON(Response));
}
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 RoleResponse Read(long RoleID)
{
RoleResponse response = new RoleResponse();
try
{
using (IDbConnection conn = GetConnection())
{
response.role = conn.Get <Role>(RoleID);
if (response.role != null)
{
response.Status = true;
response.Description = "Successful";
}
else
{
response.Status = false;
response.Description = "No data";
}
}
}
catch (Exception ex)
{
response.Status = false;
response.Description = ex.Message;
}
return(response);
}
public RoleResponse GetRole(int id)
{
if (id == -1)
{
return(getInitialData());
}
var result = new RoleResponse();
//string qry = string.Format("select mm.menuid, menuname, menudescription, iconpath from menuprivileges mp inner join menumaster mm " +
// " on mm.menuid = mp.menuid where mp.roleid={0} and mm.parentmenuid in (select menuid from menumaster where menuname='apps')", id);
//result.AppMenu = this.menus.FromSql<menu>(qry);
//qry = string.Format("select menuid, menuname, menudescription, iconpath from menumaster where menuid not in (select menuid from menuprivileges " +
// "where roleid={0}) and parentmenuid in (select menuid from menumaster where menuname ='apps') ", id);
//result.AppMenuRestricted = this.menus.FromSql<menu>(qry);
//qry = string.Format("select mm.menuid, menuname, menudescription, iconpath from menuprivileges mp inner join menumaster mm " +
// " on mm.menuid = mp.menuid where mp.roleid={0} and mm.parentmenuid in (select menuid from menumaster where menuname='admin')", id);
//result.AdminMenu = this.menus.FromSql<menu>(qry);
//qry = string.Format("select menuid, menuname, menudescription, iconpath from menumaster where menuid not in (select menuid from menuprivileges " +
// "where roleid={0}) and parentmenuid in (select menuid from menumaster where menuname ='admin') ", id);
//result.AdminMenuRestricted = this.menus.FromSql<menu>(qry);
result.Role = Roles.Where(ob => ob.roleid == id).FirstOrDefault();
result.Privileges = menuprivileges.Where(ob => ob.roleid == id).ToList();
return(result);
}
public void CloneRoleUser()
{
var cloneName = "i am a clone of " + role.Name;
clone = client.Roles.CreateRoleClone(cloneName, role.Id);
Assert.AreEqual(clone.Name, cloneName);
}
public string SaveRolePermission(RoleResponse response, string transactionType)
{
int userId = 0; //get userid
#region Sql Parameter loading
List <SqlParameter> parms = new List <SqlParameter>
{
new SqlParameter {
ParameterName = UserRoleStoredProcedure.StoredProcedureParameters[0].ToString(),
Value = response.RoleId.AsDbValue()
},
new SqlParameter {
ParameterName = UserRoleStoredProcedure.StoredProcedureParameters[1].ToString(),
Value = response.RoleName.AsDbValue()
},
new SqlParameter {
ParameterName = UserRoleStoredProcedure.StoredProcedureParameters[2].ToString(),
Value = userId.AsDbValue()
},
new SqlParameter {
ParameterName = UserRoleStoredProcedure.StoredProcedureParameters[3].ToString(),
Value = transactionType
},
new SqlParameter
{
ParameterName = UserRoleStoredProcedure.StoredProcedureParameters[4].ToString(),
TypeName = UserRoleStoredProcedure.StoredProcedureTypeNames[0].ToString(),
SqlDbType = SqlDbType.Structured,
Value = response.RolePermissionList.ToList().ToDataTable()
}
};
#endregion
return(_tcContext.Set <StringReturn>().FromSqlRaw(UserRoleStoredProcedure.Sql, parms.ToArray()).AsEnumerable().First().Value);
}
public async Task <MainRoleResponse> RoleGetById(int roleId)
{
try
{
var isExist = _roleRepository.GetRoleById(roleId);
if (isExist.Result != null)
{
roleResponse = isExist.Result;
_response.roleResponse = roleResponse;
_response.Message = Constants.Role_Exist;
_response.Status = true;
}
else
{
_response.Message = Constants.Role_Not_Exist;
_response.Status = false;
}
;
}
catch (Exception ex)
{
var msg = ex.Message;
_response.Status = false;
_response.Message = Constants.DEFAULT_ERROR_MSG;
}
return(_response);
}
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());
}
}
public async Task <RoleResponse> GetRoleById(int roleId)
{
RoleResponse role = new RoleResponse();
try
{
role = (from r in ObjContext.Roles
where r.RoleId == roleId && r.IsDeleted == false
select new RoleResponse
{
RoleId = r.RoleId,
RoleName = r.RoleName,
RoleDescription = r.Description,
CreatedOn = r.CreatedOn,
CreatedBy = r.CreatedBy,
ModifiedBy = r.ModifiedBy,
}).FirstOrDefault();
return(role);
}
catch (System.Exception ex)
{
var msg = ex.Message;
throw;
}
}
/// <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 <List <UserResult> > GetAllUserAsync()
{
List <UserResult> userList = new List <UserResult>();
var users = await _userManager.Users.ToListAsync();
foreach (var user in users)
{
var userRoles = await _userManager.GetRolesAsync(user);
List <RoleResponse> roles = new List <RoleResponse>();
foreach (var nameRole in userRoles)
{
var role = await _roleManager.FindByNameAsync(nameRole);
RoleResponse userRole = _mapper.Map <RoleResponse>(role);
roles.Add(userRole);
}
PeopleDto peopleData = await _peopleRepository.GetByUserIdAsync(user.Id);
UserResult userResponse = _mapper.Map <UserResult>(peopleData);
userResponse.Success = true;
userResponse.PeopleId = peopleData.Id;
userResponse.PhoneNumber = user.PhoneNumber;
userResponse.UserRoles = roles;
userList.Add(userResponse);
}
return(userList);
}
public IActionResult Get(int id)
{
Role role = this._roleService.Get(id);
RoleResponse roleResponse = AutoMap.Map <Role, RoleResponse>(role);
return(Ok(new BaseResponse <RoleResponse>(roleResponse)));
}
public void GetUserRoles(RoleRequest request, RoleResponse response)
{
var roles = _uow.Repository <RoleEntity>().GetOverview().ToList();
if (roles != null)
{
response.Roles = _mapper.Map <List <Model.Role> >(roles);
}
}
public RoleResponse GetUserRoles(RoleRequest request)
{
var response = new RoleResponse();
RunCode(MethodBase.GetCurrentMethod().Name, request, response, (uow) =>
{
_manager.GetUserRoles(request, response);
});
return(response);
}
public async Task <IActionResult> Delete(string id)
{
var role = await _roleService.DeleteRole(id);
var roleDto = new RoleResponse {
RoleId = id
};
return(Ok(roleDto));
}
public IActionResult Modify([FromBody] RoleRequest budgetRequest)
{
Role role = AutoMap.Map <RoleRequest, Role>(budgetRequest);
this._roleService.Modify(role.Identity, role);
RoleResponse roleResponse = AutoMap.Map <RoleRequest, RoleResponse>(budgetRequest);
return(Ok(new BaseResponse <RoleResponse>(roleResponse)));
}
private void Edit(string id)
{
_role = new RoleResponse
{
Id = id,
Name = RoleList.FirstOrDefault(x => x.Id.Equals(id))?.Name
};
RoleDiaglogTitle = "Update role";
RoleDiaglogVisiable = true;
}
private async Task ShowDeleteConfirm(RoleResponse role)
{
var content = $"Are you sure to delete role '{role.Name}' ?";
var title = "Delete confirmation";
var confirmResult = await _confirmService.Show(content, title, ConfirmButtons.YesNo);
if (confirmResult == ConfirmResult.Yes)
{
await DeleteRole(role);
}
}
public async Task <HttpResponseMessage> IsDeleted(MT_Role RMD)
{
Db = con.SurgeryCenterDb(RMD.Slug);
RoleResponse Response = new RoleResponse();
try
{
List <MT_User_Right_Priviliages> priviliages = new List <MT_User_Right_Priviliages>();
Dictionary <string, object> initialData;
if (RMD.ROM_Priviliages != null)
{
foreach (MT_User_Right_Priviliages URP in RMD.ROM_Priviliages)
{
priviliages.Add(URP);
}
RMD.ROM_Priviliages = priviliages;
initialData = new Dictionary <string, object>
{
{ "ROM_Is_Deleted", RMD.ROM_Is_Deleted },
{ "ROM_Modify_Date", con.ConvertTimeZone(RMD.ROM_TimeZone, Convert.ToDateTime(RMD.ROM_Modify_Date)) },
};
}
else
{
initialData = new Dictionary <string, object>
{
{ "ROM_Is_Deleted", RMD.ROM_Is_Deleted },
{ "ROM_Modify_Date", con.ConvertTimeZone(RMD.ROM_TimeZone, Convert.ToDateTime(RMD.ROM_Modify_Date)) }
};
}
DocumentReference docRef = Db.Collection("MT_Role").Document(RMD.ROM_Unique_ID);
WriteResult Result = await docRef.UpdateAsync(initialData);
if (Result != null)
{
Response.Status = con.StatusSuccess;
Response.Message = con.MessageSuccess;
Response.Data = RMD;
}
else
{
Response.Status = con.StatusNotUpdate;
Response.Message = con.MessageNotUpdate;
Response.Data = null;
}
}
catch (Exception ex)
{
Response.Status = con.StatusFailed;
Response.Message = con.MessageFailed + ", Exception : " + ex.Message;
}
return(ConvertToJSON(Response));
}
/// <summary>
/// Validate request
/// </summary>
/// <param name="request"></param>
/// <param name="response"></param>
public void Validate(RoleRequest request, out RoleResponse response)
{
response = new RoleResponse();
if (request.Action != null && request.Action.Equals(ClinicEnums.Action.DELETE.ToString()))
{
ValidateForDelete(request, out response);
}
else
{
bool isHavePrivilege = true;
if (request.Data.RoleName == null || String.IsNullOrWhiteSpace(request.Data.RoleName))
{
errorFields.Add("Role Name");
}
if (request.Data.OrgID == 0)
{
errorFields.Add("Organization");
}
if (errorFields.Any())
{
response.Status = false;
response.Message = string.Format(Messages.ValidationErrorFields, String.Join(",", errorFields));
}
else if (request.Data.RoleName.Length > 30)
{
response.Status = false;
response.Message = $"Maximum Character for Role Name is 30";
}
if (request.Data.Id == 0)
{
isHavePrivilege = IsHaveAuthorization(ADD_PRIVILEGE_NAME, request.Data.Account.Privileges.PrivilegeIDs);
}
else
{
isHavePrivilege = IsHaveAuthorization(EDIT_PRIVILEGE_NAME, request.Data.Account.Privileges.PrivilegeIDs);
}
if (!isHavePrivilege)
{
response.Status = false;
response.Message = Messages.UnauthorizedAccess;
}
if (response.Status)
{
response = new RoleHandler(_unitOfWork).CreateOrEdit(request);
}
}
}
private bool Search(RoleResponse role)
{
if (string.IsNullOrWhiteSpace(searchString))
{
return(true);
}
if (role.Name.Contains(searchString, StringComparison.OrdinalIgnoreCase))
{
return(true);
}
return(false);
}
public void CheckArgumentExceptionforAppType()
{
RoleRequest roleRequest = new RoleRequest {
};
List <RoleModel> roleList = CreateRoleList();
Mock <RoleRepository> roleMock = new Mock <RoleRepository>();
roleMock.Setup(r => r.ReadRole(It.IsAny <string>())).Returns(roleList);
RoleResponse roleResponse = roleMock.Object.GetRoles(roleRequest);
Assert.IsTrue(roleResponse.Error.Message == "Invalid input :PAYLOAD");
}
