public bool NewRoleAttribute(InsertRoleModel request)
{
try
{
int resRole = InsertRole(request.roleName, request.username);
int roleId = SelectRoleId(request.roleName);
int resRolePermisison = 0;
if (roleId >= 0)
{
resRolePermisison = InsertRolePermission(roleId, request.permissionList);
}
if (resRole == 1 && resRolePermisison == 0)
{
DeleteRole(roleId);
return(false);
}
else if (resRole == 1 && resRolePermisison >= 1)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception error)
{
Console.WriteLine("Error: " + error);
return(false);
}
}
private async Task <TResponse <bool> > CanInsert(InsertRoleModel request)
{
try
{
var role = await ReadOnlyRepository.QueryFirstOrDefaultAsync <RoleModel>(SqlQuery.ROLE_FIND_BY_NAME,
new
{
request.Name
});
if (role.IsSuccess)
{
if (role.Data != null)
{
return(await Fail <bool>(ErrorEnum.ROLE_HAS_EXIST.GetStringValue()));
}
return(await Ok(true));
}
return(await Fail <bool>(role.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
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 async Task <TResponse <bool> > Add(int userId,
InsertRoleModel request,
int permissionId)
{
try
{
var checkValid = await _userService.CheckPermission(userId,
permissionId);
if (checkValid.IsSuccess)
{
var canInsert = await CanInsert(request);
if (canInsert.IsSuccess)
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.ROLE_INSERT,
new
{
request.Name,
UserCreated = userId,
DateCreated = DateTime.Now,
UserUpdated = userId,
DateUpdated = DateTime.Now
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
return(await Ok(true));
}
return(await Fail <bool>(ErrorEnum.BAD_REQUEST.GetStringValue()));
}
return(await Fail <bool>(result.Message));
}
return(await Fail <bool>(canInsert.Message));
}
return(await Fail <bool>(checkValid.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public ActionResult Save([FromBody] InsertRoleModel insertRoleModel)
{
if (ModelState.IsValid)
{
var inserrdata = _roleMasterRepository.InsertRoleMaster(insertRoleModel);
if (inserrdata != 0)
{
responsemessage2 = new ResponseMessage2("success", "");
}
else
{
responsemessage2 = new ResponseMessage2("Failed", "");
}
}
return(Ok(responsemessage2));
}
public async Task <TResponse <bool> > Add(InsertRoleModel model)
{
try
{
var response = await HttpService.Send <bool>(_baseUrl + ApiUrl.ROLE_INSERT, model, HttpMethod.Post);
if (response.IsSuccess)
{
return(await Ok(response.Data));
}
return(await Fail <bool>(response.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task <IActionResult> Add(InsertRoleModel model)
{
if (ModelState.IsValid)
{
var result = await _roleService.Add(model);
if (result.IsSuccess)
{
StatusMessage = SuccessNotifcation("Insert role success!");
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", result.Message);
return(View(model));
}
return(View(model));
}
public int InsertRoleMaster(InsertRoleModel insertRoleModel) // Working Ok
{
try
{
// using (OracleConnection con = connection )
using (con = new OracleConnection(MyConnectionString))
{
OracleCommand cmd = new OracleCommand("pkg_api_integration.PROC_VSEC_ROLEMASTER_INS", con);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("P_ROLEID", OracleDbType.Int32, DBNull.Value, ParameterDirection.Input);
cmd.Parameters.Add("P_PARENTROLEID", OracleDbType.Int32, DBNull.Value, ParameterDirection.Input);
cmd.Parameters.Add("P_ROLESNAME", OracleDbType.Varchar2, insertRoleModel.shortName, ParameterDirection.Input);
cmd.Parameters.Add("P_DISPLAYNAME", OracleDbType.Varchar2, insertRoleModel.name, ParameterDirection.Input);
cmd.Parameters.Add("P_ACTIVEFLAG", OracleDbType.Char, insertRoleModel.status.ToLower() == "enabled" ? "Y" : "N", ParameterDirection.Input);
cmd.Parameters.Add("P_ACTION", OracleDbType.Varchar2, "I", ParameterDirection.Input);
cmd.Parameters.Add("P_USER", OracleDbType.Varchar2, "Admin", ParameterDirection.Input);
cmd.Parameters.Add("P_STATUSFLAG", OracleDbType.Varchar2, 200, "", ParameterDirection.Output); //.Value = 200;
cmd.Parameters.Add("P_ERROR", OracleDbType.Varchar2, 2000, "", ParameterDirection.Output); //.Value = 2000;
con.Open();
res = cmd.ExecuteNonQuery();
if (res >= -1)
{
return(res);
}
else
{
return(res);
}
}
}
catch (Exception ex)
{
return(res);
}
finally
{
con.Close();
}
}
/// <summary>
/// Add Role
/// </summary>
/// <param name="userId"></param>
/// <param name="request"></param>
/// <returns></returns>
public async Task <TResponse <bool> > Add(int userId,
InsertRoleModel request)
{
try
{
var canInsert = await CanInsert(request);
if (canInsert.IsSuccess)
{
var result = await WriteRepository.ExecuteScalarAsync <int>(SqlQuery.ROLE_INSERT, new
{
request.Name,
request.Description,
UserCreated = userId,
UserUpdated = userId,
});
if (result.IsSuccess)
{
if (result.Data == 0)
{
return(await Fail <bool>(string.Format(ErrorEnum.SqlQueryCanNotExecute.GetStringValue(), "ROLE_INSERT")));
}
return(await Ok(true));
}
return(await Fail <bool>(result.Message));
}
return(await Fail <bool>(canInsert.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public RoleResponseModel InsertRole([FromBody] InsertRoleModel request)
{
RoleResponseModel result = _rolesService.InsertRoleService(request);
return(result);
}
public int InsertRoleMaster(InsertRoleModel insertRoleModel)
{
return(roleMasterDAL.InsertRoleMaster(insertRoleModel));
}
public async Task <ActionResult <bool> > Add(InsertRoleModel request)
{
return(Ok(await _roleService.Add(await GetUserId(),
request,
GetPermissionId())));
}
