public RoleResponseModel UpdateRoleService(UpdateRoleModel request)
{
RoleResponseModel response = new RoleResponseModel();
var resDelete = _rolesRepository.DeleteRolePermission(request.roleId);
if (resDelete > 0)
{
var resUpdate = 0;
resUpdate = _rolesRepository.InsertRolePermission(request.roleId, request.permissionList);
if (resUpdate > 0)
{
response.success = true;
}
else
{
response.success = false;
}
}
else
{
response.success = false;
}
return(response);
}
public RoleResponseModel DeleteRoleService(RoleByIdModel requestId)
{
try
{
RoleResponseModel response = new RoleResponseModel();
var resRolePermission = _rolesRepository.DeleteRolePermission(requestId.roleId);
if (resRolePermission > 0)
{
var resRole = _rolesRepository.DeleteRole(requestId.roleId);
if (resRole > 0)
{
response.success = true;
}
else
{
response.success = false;
}
}
else
{
response.success = false;
}
return(response);
}
catch (Exception error)
{
Console.WriteLine("Error: " + error);
return(new RoleResponseModel()
{
success = false
});
}
}
public async Task <LoginResponseModel> ValidateUser(LoginRequestModel loginRequestModel)
{
var dbUser = await _userRepository.GetUserByEmail(loginRequestModel.Email);
if (dbUser == null)
{
return(null);
}
var hashedPassword = _cryptoService.HashPassword(loginRequestModel.Password, dbUser.Salt);
if (hashedPassword == dbUser.HashedPassword)
{
// User has entered correct password
var roleResponseModels = new List <RoleResponseModel>();
foreach (var r in dbUser.Roles)
{
var cur = new RoleResponseModel();
cur.Id = r.Id;
cur.Name = r.Name;
roleResponseModels.Add(cur);
}
var loginResponse = new LoginResponseModel
{
Id = dbUser.Id,
Email = dbUser.Email,
FirstName = dbUser.FirstName,
LastName = dbUser.LastName,
DateOfBirth = dbUser.DateOfBirth, // DateTime cannot be convert to DateTime? implicitly but DateTime? can be convert to DateTime
Roles = roleResponseModels
};
return(loginResponse);
}
return(null);
}
public IActionResult GetRoleDropDown()
{
IEnumerable <RoleOutputModel> OutPutData = null;
IsRoleInputModel filter = new IsRoleInputModel();
filter.IsSupervisor = true;
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(BaseAPI + "Base/");
var responseTask = client.PostAsJsonAsync <IsRoleInputModel>("GetRoleDropDown", filter);
responseTask.Wait();
var result = responseTask.Result;
if (result.IsSuccessStatusCode)
{
var content = result.Content.ReadAsStringAsync();
RoleResponseModel resutl = Newtonsoft.Json.JsonConvert.DeserializeObject <RoleResponseModel>(content.Result);
OutPutData = resutl.data;
}
else //web api sent error response
{
//log response status here..
OutPutData = Enumerable.Empty <RoleOutputModel>();
ModelState.AddModelError(string.Empty, "Terjadi kesalahan. Mohon hubungi admin.");
}
}
return(Json(OutPutData));
}
public RoleResponseModel GetRole(int id)
{
RoleResponseModel roleResponseModel;
try
{
RoleModel roleModel = RoleRepository.GetRole(id);
if (roleModel != null)
{
roleResponseModel = new RoleResponseModel()
{
RoleId = roleModel.RoleId,
Name = roleModel.Name,
Description = roleModel.Description
};
return(roleResponseModel);
}
}
catch (Exception ex)
{
Logger.LogFile($"Error getting a Role by id = {id}: {ex.Message}");
}
return(null);
}
public static RoleResponseModel ToModel(this Role role)
{
var model = new RoleResponseModel()
{
Id = role.Id,
IsActive = role.IsActive,
IsSystemRole = role.IsSystemRole,
RoleName = role.RoleName,
SystemName = role.SystemName
};
return(model);
}
public RoleResponseModel InsertRoleService(InsertRoleModel request)
{
RoleResponseModel response = new RoleResponseModel();
var result = _rolesRepository.NewRoleAttribute(request);
if (result)
{
response.success = true;
}
else
{
response.success = false;
}
return(response);
}
public ActionResult <RoleResponseModel> GetRole([FromBody] IsRoleInputModel data)
{
RoleResponseModel res = new RoleResponseModel();
try
{
RoleRepository repo = new RoleRepository(db);
List <RoleOutputModel> res2 = new List <RoleOutputModel>();
var query = repo.GetRoleDropDown();
if (data.IsSupervisor)
{
res2 = (from y in query
where y.Name == "SPV"
select new RoleOutputModel()
{
RoleCode = y.Name,
RoleID = y.ID,
RoleName = y.NormalizedName
}).ToList();
}
else
{
res2 = (from y in query
where y.Name != "SPV"
select new RoleOutputModel()
{
RoleCode = y.Name,
RoleID = y.ID,
RoleName = y.NormalizedName
}).ToList();
}
res.data = res2;
res.Message = "Success get data";
res.Response = true;
return(res);
}
catch (Exception ex)
{
res.Message = ex.Message;
res.Response = false;
return(res);
}
}
public ActionResult <RoleResponseModel> GetRole(int id)
{
int result = HeaderValidation.ValidateUserCredentials(Request.Headers[Username], Request.Headers[Password]);
if (result == -1)
{
return(StatusCode(401));
}
if (!HeaderValidation.ValidateUserPermissions(result))
{
return(StatusCode(403));
}
RoleResponseModel roleResponseModel = RoleService.GetRole(id);
if (roleResponseModel == null)
{
return(StatusCode(404));
}
return(StatusCode(200, roleResponseModel));
}
public RoleResponseModel DeleteRole([FromQuery] RoleByIdModel requestId)
{
RoleResponseModel result = _rolesService.DeleteRoleService(requestId);
return(result);
}
public RoleResponseModel UpdateRole([FromBody] UpdateRoleModel request)
{
RoleResponseModel result = _rolesService.UpdateRoleService(request);
return(result);
}
public RoleResponseModel InsertRole([FromBody] InsertRoleModel request)
{
RoleResponseModel result = _rolesService.InsertRoleService(request);
return(result);
}
