public void TestPostAssignRoleUser()
{
string failureResult = "";
try
{
// Arrange
var dbContext = DbContextMocker.UserRoleDbContext();
var dbUserContext = DbContextMocker.UserDbContext();
var controller = new UsersRoleRepository(dbUserContext, dbContext);
var request = new AssignUserRole
{
username = "******",
rolename = "user",
IsAssign = true
};
// Act
var response = controller.AssignRoleUser(request, null);
dbContext.Dispose();
}
catch (Exception ex)
{
failureResult = ex.Message;
}
// Assert
//Assert.IsType<OkObjectResult>(response);
// var result = Assert.IsType<OkObjectResult>(response);
Assert.Equal("", failureResult);
}
public string AssignUserRole(AssignUserRole objAssignUserRole)
{
int noRowCount = 0;
objDataAccess = DataAccess.NewDataAccess();
objDbCommand = objDataAccess.GetCommand(true, IsolationLevel.Serializable);
objDbCommand.AddInParameter("UserDetailId", objAssignUserRole.UserDetailId);
objDbCommand.AddInParameter("RoleId", objAssignUserRole.RoleId);
objDbCommand.AddInParameter("CreatedBy", SessionUtility.STSessionContainer.UserID);
try
{
noRowCount = objDataAccess.ExecuteNonQuery(objDbCommand, "[dbo].uspAssignUserRole", CommandType.StoredProcedure);
if (noRowCount > 0)
{
objDbCommand.Transaction.Commit();
return("Save Successfully");
}
else
{
objDbCommand.Transaction.Rollback();
return("Save Failed");
}
}
catch (Exception ex)
{
objDbCommand.Transaction.Rollback();
throw new Exception("Database Error Occured", ex);
}
finally
{
objDataAccess.Dispose(objDbCommand);
}
}
public List <AssignUserRole> GetListActiveUser()
{
List <AssignUserRole> list = new List <AssignUserRole>();
string sqlString = "Select u.ID, u.FULLNAME, IsNull(ur.ROLE_ID,0) as ROLE_ID From USERS u " +
"Left Join USERROLES ur ON ur.USER_ID = u.ID " +
"WHERE u.ISACTIVE = 1";
DataTable dt = QueryTable(sqlString);
if (dt.Rows.Count > 0)
{
foreach (DataRow dr in dt.Rows)
{
AssignUserRole aur = new AssignUserRole
{
UserID = Convert.ToInt32(dr[0]),
Fullname = dr[1].ToString(),
RoleID = Convert.ToInt32(dr[2])
};
list.Add(aur);
}
}
return(list);
}
public int SaveUserRoleAssign(AssignUserRole usr)
{
//TODO: Check for Insert or Update
string sqlString = string.Empty;
object result = CheckUserRole(usr.UserID);
SqlParameter[] param = new SqlParameter[]
{
new SqlParameter("@USERID", usr.UserID),
new SqlParameter("@ROLEID", usr.RoleID)
};
if (result != null)
{
//run update
sqlString = "UPDATE [dbo].[USERROLES] SET [USER_ID] = @USERID, [ROLE_ID] = @ROLEID WHERE [ID] = @ID";
Array.Resize(ref param, 3);
param[2] = new SqlParameter("@ID", result);
}
else
{
//run insert
sqlString = "INSERT INTO [USERROLES] ([USER_ID],[ROLE_ID]) VALUES (@USERID, @ROLEID)";
}
return(ExecNonQuery(sqlString, param));
}
public ActionResult AssignRole(int id = 0)
{
AssignUserRole aur = new AssignUserRole();
ViewBag.UserList = aur.GetUserList(id);
ViewBag.RoleList = aur.GetRoleList(id);
return(View());
}
public ActionResult AssignRole(AssignUserRole asgn)
{
if (ModelState.IsValid)
{
asgn.SaveUserRole();
return(RedirectToAction("Index"));
}
return(RedirectToAction("AssignRole"));
}
public ActionResult Save(AssignUserRole objAssignUserRole)
{
if (ModelState.IsValid)
{
RoleManagementBLL objRoleManagementBll = new RoleManagementBLL();
objRoleManagementBll.AssignUserRole(objAssignUserRole);
}
return(RedirectToAction("Index", "AssignUserRole"));
}
public ActionResult Get()
{
RoleManagementBLL objRoleManagementBll = new RoleManagementBLL();
var model = new AssignUserRole
{
userDetail = objRoleManagementBll.GetUserListForDropDownForSave(),
roleInfo = objRoleManagementBll.GetRoleListForDropDownForSave()
};
return(View("UserPartial", model));
}
public ActionResult Edit(AssignUserRole objAssignUserRole)
{
objAssignUserRole.UrmId = Convert.ToInt16(Session["UrmId"]);
if (ModelState.IsValid)
{
RoleManagementBLL objRoleManagementBll = new RoleManagementBLL();
objRoleManagementBll.UpdateUserRole(objAssignUserRole);
Session.Remove("UrmId");
}
return(RedirectToAction("Index", "AssignUserRole"));
}
public ActionResult RoleAddToUser(string UserName, string RoleName)
{
var context = new ApplicationDbContext();
if (context == null)
{
throw new ArgumentNullException("context", "Context must not be null.");
}
Employee user = context.Employees.Where(u => u.FullName.Equals(UserName, StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault();
Role role = context.Roles.Where(u => u.RoleName.Equals(RoleName, StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault();
AssignUserRole assignUserRole = new AssignUserRole
{
EmployeeId = user.EmployeeID,
RoleId = role.RoleID
};
var EmpRoleToAdd = (from emprole in context.AssignUserRoles
where emprole.EmployeeId == user.EmployeeID && emprole.RoleId == role.RoleID
select emprole).FirstOrDefault();
if (EmpRoleToAdd == null)
{
context.AssignUserRoles.Add(assignUserRole);
context.SaveChanges();
ViewBag.Message = "Role created successfully !";
}
else
{
ViewBag.Message = " This Role already exists for this user !";
}
// Repopulate Dropdown Lists
var rolelist = context.Roles.OrderBy(r => r.RoleName).ToList().Select(rr => new SelectListItem {
Value = rr.RoleName.ToString(), Text = rr.RoleName
}).ToList();
ViewBag.Roles = rolelist;
var userlist = context.Employees.OrderBy(u => u.FullName).ToList().Select(uu =>
new SelectListItem {
Value = uu.FullName.ToString(), Text = uu.FullName
}).ToList();
ViewBag.Users = userlist;
return(View("Index"));
}
public ActionResult Edit(int id)
{
RoleManagementBLL objRoleManagementBll = new RoleManagementBLL();
var model = new AssignUserRole
{
userDetail = objRoleManagementBll.GetUserListForDropDownForSave(),
roleInfo = objRoleManagementBll.GetRoleListForDropDownForSave()
};
var assignRoleInfo = objRoleManagementBll.GetUserListForDropDownForEdit(id);
Session["UrmId"] = assignRoleInfo.UrmId;
ViewBag.roleId = assignRoleInfo.RoleId;
ViewBag.UserDetailId = assignRoleInfo.UserDetailId;
ViewBag.isActive = assignRoleInfo.IsActive;
return(View(model));
}
private async Task SeedCreateUsers(UserManager <IdentityUser> userManager, AssignUserRole assignUsername)
{
IList <Users> Users = await FindByUserName(assignUsername.username);
if (await userManager.FindByNameAsync(assignUsername.username) == null)
{
var user = new IdentityUser
{
UserName = assignUsername.username,
Email = Users[0].Email
};
var result = await userManager.CreateAsync(user, Users[0].Password);
if (result.Succeeded)
{
await userManager.AddToRoleAsync(user, assignUsername.rolename);
}
}
}
public AssignUserRole GetUserListForDropDownForEdit(int id)
{
objDataAccess = DataAccess.NewDataAccess();
objDbCommand = objDataAccess.GetCommand(true, IsolationLevel.ReadCommitted);
DbDataReader objDbDataReader = null;
//List<AssignUserRole> objUserList = new List<AssignUserRole>();
AssignUserRole objAssignUserRole = new AssignUserRole();
try
{
objDbCommand.AddInParameter("UrmId", id);
objDbCommand.AddInParameter("CreatedBy", SessionUtility.STSessionContainer.UserID);
objDbDataReader = objDataAccess.ExecuteReader(objDbCommand, "[dbo].uspGetAssignUserRoleForEdit", CommandType.StoredProcedure);
if (objDbDataReader.HasRows)
{
while (objDbDataReader.Read())
{
objAssignUserRole = new AssignUserRole();
BuildModelForAssignUserRole(objDbDataReader, objAssignUserRole);
//objUserList.Add(objAssignUserRole);
}
}
}
catch (Exception ex)
{
throw new Exception("Error : " + ex.Message);
}
finally
{
if (objDbDataReader != null)
{
objDbDataReader.Close();
}
objDataAccess.Dispose(objDbCommand);
}
return(objAssignUserRole);
}
public int AssignRoleUser(AssignUserRole assignUserRole, UserManager <IdentityUser> userManager)
{
var param = new SqlParameter[] {
new SqlParameter()
{
ParameterName = "@username",
SqlDbType = System.Data.SqlDbType.VarChar,
Size = 100,
Direction = System.Data.ParameterDirection.Input,
Value = assignUserRole.username.ToString()
},
new SqlParameter()
{
ParameterName = "@rolename",
SqlDbType = System.Data.SqlDbType.VarChar,
Size = 100,
Direction = System.Data.ParameterDirection.Input,
Value = assignUserRole.rolename.ToString()
},
new SqlParameter()
{
ParameterName = "@IsInsert",
SqlDbType = System.Data.SqlDbType.Bit,
Direction = System.Data.ParameterDirection.Input,
Value = Convert.ToBoolean(assignUserRole.IsAssign)
},
};
// IQueryable<Users> studentList = _dbRole.User_new.FromSqlRaw("EXEC ProcAddRoletoUser @username, @rolename, @IsDelete", param[0].Value, param[1].Value, param[2].Value).IgnoreQueryFilters();
string SQLQuery = $"EXECUTE ProcAddRoletoUser @username='******', @rolename='{param[1].Value}', @IsInsert={param[2].Value}";
int Uid = _dbRole.Database.ExecuteSqlRaw(SQLQuery);
if (userManager != null)
{
SeedCreateUsers(userManager, assignUserRole).Wait();
}
//_dbRole.User_new.ExecuteSqlCommand("EXEC ProcAddRoletoUser @username, @rolename, @IsDelete", username.Value, rolename.Value, IsInsert.Value);
return(Uid);
}
public List <AssignUserRole> GetListActiveRoles()
{
List <AssignUserRole> list = new List <AssignUserRole>();
string sqlString = "SELECT [ID], [NAME] FROM [ROLES] WHERE [ISACTIVE] = 1";
DataTable dt = QueryTable(sqlString);
if (dt.Rows.Count > 0)
{
foreach (DataRow dr in dt.Rows)
{
AssignUserRole rle = new AssignUserRole
{
RoleID = Convert.ToInt32(dr["ID"]),
RoleName = dr["NAME"].ToString()
};
list.Add(rle);
}
}
return(list);
}
public async Task <IActionResult> CreateUserRole([FromBody] AssignUserRole assignUserRole)
{
try
{
_logger.LogInfo("Attempted submission attempted");
if (assignUserRole == null)
{
_logger.LogWarn("Empty request submitted");
return(BadRequest(ModelState));
}
if (!ModelState.IsValid)
{
_logger.LogWarn("User data was incomplete");
return(BadRequest(ModelState));
}
int UID = _UserRoleRepository.AssignRoleUser(assignUserRole, _userManager);
var UserAudit = await _UserRepository.FindByUserName(assignUserRole.username.ToString());
var User_new = _Mapper.Map <IList <Users> >(UserAudit);
_logger.LogInfo("User Role created");
Audit_logs audit = new Audit_logs()
{
uid = User_new[0].id,
action = "Create User Role",
log = $"{assignUserRole.rolename} Role has created for USER:{assignUserRole.username}",
datetime = DateTime.Now
};
await _audit_Logs.Create(audit);
return(NoContent());
}
catch (Exception ex)
{
return(InternalError($"{ex.Message}-{ex.InnerException}"));
}
}
private void BuildModelForAssignUserRole(DbDataReader objDataReader, AssignUserRole objAssignUserRole)
{
DataTable objDataTable = objDataReader.GetSchemaTable();
foreach (DataRow dr in objDataTable.Rows)
{
String column = dr.ItemArray[0].ToString();
switch (column)
{
case "UrmId":
if (!Convert.IsDBNull(objDataReader["UrmId"]))
{
objAssignUserRole.UrmId = Convert.ToInt32(objDataReader["UrmId"]);
}
break;
case "UserDetailId":
if (!Convert.IsDBNull(objDataReader["UserDetailId"]))
{
objAssignUserRole.UserDetailId = Convert.ToByte(objDataReader["UserDetailId"]);
}
break;
case "Username":
if (!Convert.IsDBNull(objDataReader["Username"]))
{
objAssignUserRole.Username = objDataReader["Username"].ToString();
}
break;
case "RoleId":
if (!Convert.IsDBNull(objDataReader["RoleId"]))
{
objAssignUserRole.RoleId = Convert.ToByte(objDataReader["RoleId"]);
}
break;
case "RoleName":
if (!Convert.IsDBNull(objDataReader["RoleName"]))
{
objAssignUserRole.RoleName = objDataReader["RoleName"].ToString();
}
break;
case "IsActive":
if (!Convert.IsDBNull(objDataReader["IsActive"]))
{
objAssignUserRole.IsActive = Convert.ToBoolean(objDataReader["IsActive"].ToString());
}
break;
case "UserStatus":
if (!Convert.IsDBNull(objDataReader["UserStatus"]))
{
objAssignUserRole.UserStatus = objDataReader["UserStatus"].ToString();
}
break;
case "CreatedBy":
if (!Convert.IsDBNull(objDataReader["CreatedBy"]))
{
objAssignUserRole.CreatedBy = Convert.ToInt16(objDataReader["CreatedBy"]);
}
break;
case "CreatedDate":
if (!Convert.IsDBNull(objDataReader["CreatedDate"]))
{
objAssignUserRole.CreatedDate = Convert.ToDateTime(objDataReader["CreatedDate"].ToString());
}
break;
case "UpdatedBy":
if (!Convert.IsDBNull(objDataReader["UpdatedBy"]))
{
objAssignUserRole.UpdatedBy = Convert.ToInt16(objDataReader["UpdatedBy"].ToString());
}
break;
case "UpdatedDate":
if (!Convert.IsDBNull(objDataReader["UpdatedDate"]))
{
objAssignUserRole.UpdatedDate = Convert.ToDateTime(objDataReader["UpdatedDate"].ToString());
}
break;
case "SortedBy":
if (!Convert.IsDBNull(objDataReader["SortedBy"]))
{
objAssignUserRole.SortedBy = Convert.ToByte(objDataReader["SortedBy"].ToString());
}
break;
case "Remarks":
if (!Convert.IsDBNull(objDataReader["Remarks"]))
{
objAssignUserRole.Remarks = objDataReader["Remarks"].ToString();
}
break;
default:
break;
}
}
}
