public ActionResult AssignNewRoles(AssignRole model)
{
DSRCManagementSystemEntities1 db = new DSRCManagementSystemEntities1();
var UserIDs = model.unemployees.Split(',');
var DataId = model.RoleID;
var Data = Convert.ToInt32(DataId);
foreach (string userID in UserIDs)
{
int RoleID = Convert.ToByte(Data);
int UserID = Convert.ToInt32(userID);
var x = db.UserRoles.Where(o => o.UserID == UserID).ToList();
foreach (var y in x)
{
db.UserRoles.DeleteObject(y);
db.SaveChanges();
var user = db.UserRoles.CreateObject();
int z = Convert.ToInt32(y.UserID);
user.UserID = z;
user.RoleID = db.Master_Roles.FirstOrDefault(o => o.RoleName == MasterEnum.NewuserRole.NewEmployeeRole).RoleID;
db.UserRoles.AddObject(user);
db.SaveChanges();
}
}
return(Json("Success", JsonRequestBehavior.AllowGet));
}
public void Invalid_actorId_is_not_valid_for_role_assignment()
{
_authCommands.CreatePermission(new CreatePermission
{
Name = "Test",
Module = "Test"
});
var createRole = new CreateRole
{
RoleId = Guid.NewGuid(),
Permissions = _authQueries.GetPermissions().Select(p => p.Id).ToList()
};
_authCommands.CreateRole(createRole);
var assignRole = new AssignRole
{
ActorId = Guid.NewGuid(),
RoleId = createRole.RoleId
};
var result = _authQueries.GetValidationResult(assignRole);
result.IsValid.Should().BeFalse();
result.Errors.Single().ErrorMessage.Should().Be(ErrorsCodes.ActorDoesNotExist.ToString());
}
public ActionResult AssignRolesToUsersAsync()
{
AssignRole assignRoles = new AssignRole();
assignRoles.UserList = getUsers();
assignRoles.UserRolesList = getRoles();
return View(assignRoles);
}
protected void OnRowDataBound(object sender, GridViewRowEventArgs e)
{
if (e.Row.RowType == DataControlRowType.DataRow)
{
AssignRole assignrole = (AssignRole)e.Row.DataItem;
string assignrolecode = assignrole.AssignRoleCode.ToString();
string employeecode = assignrole.EmployeeCode.ToString();
string employeename = dCon.GetEmployeeByCode(employeecode).EmployeeName;
Label employeelabel = (e.Row.FindControl("lblEmployeeName") as Label);
if (employeelabel != null)
{
employeelabel.Text = employeename;
}
string rolecode = assignrole.TemporaryRoleCode.ToString();
string rolename = dCon.GetRoleName(rolecode);
Label rolelabel = (e.Row.FindControl("lblRoleName") as Label);
if (rolelabel != null)
{
rolelabel.Text = rolename;
}
if (rolecode == "ActHead")
{
Label startdate = (e.Row.FindControl("lblStartDate") as Label);
DateTime d1 = (DateTime)assignrole.StartDate;
startdate.Text = d1.ToShortDateString();
Label enddate = (e.Row.FindControl("lblEndDate") as Label);
DateTime d2 = (DateTime)assignrole.EndDate;
enddate.Text = d2.ToShortDateString();
}
}
}
public Employee getTargetEmployeeWithAssignedRole(ADProjectDb db, int employeeId)
{
Employee targetEmployee = db.Employee
.Where(e => e.EmployeeId == employeeId)
.SingleOrDefault();
AssignRole assignRole = db.Employee
.Where(e => e.EmployeeId == employeeId)
.Select(e => e.AssignRole).FirstOrDefault();
Role assignedRole_Role = null;
try
{
assignedRole_Role = db.AssignRole.Where(ar => ar.EmployeeId == employeeId)
.Select(ar => ar.Role).FirstOrDefault();
assignRole.Role = assignedRole_Role;
}
catch (Exception exception)
{
Debug.WriteLine(exception);
}
targetEmployee.AssignRole = assignRole;
return(targetEmployee);
}
public void SaveDelegation(ADProjectDb db, int delegatedEmployeeId, DateTime startDate, DateTime endDate, int assignedRoleId)
{
AssignRole assignRole = new AssignRole();
Employee delegatedEmployee = db.Employee
.Where(emp => emp.EmployeeId == delegatedEmployeeId)
.FirstOrDefault();
//One employee can only have 1 assigned role at a time
if (delegatedEmployee.AssignRole != null)
{
DeleteDelegation(db, delegatedEmployeeId);
}
Employee departmentHead = GetDepartmentHead(db);
assignRole.Employee = delegatedEmployee;
assignRole.EmployeeId = delegatedEmployee.EmployeeId;
assignRole.AssignedBy = departmentHead;
assignRole.StartDate = startDate;
assignRole.EndDate = endDate;
assignRole.RoleId = assignedRoleId;
delegatedEmployee.AssignRole = assignRole;
db.SaveChanges();
}
public async Task <ActionResult> AssignRoleToUser([FromBody] AssignRole model)
{
var user = await _userManager.FindByIdAsync(model.UserId);
if (user == null)
{
return(NotFound());
}
var currentRoles = await _userManager.GetRolesAsync(user);
var rolesNotExist = model.Roles.Except(_roleManager.Roles.Select(x => x.Name)).ToArray();
if (rolesNotExist.Any())
{
return(this.BadRequest());
}
var removeResult = await _userManager.RemoveFromRolesAsync(user, currentRoles.ToArray());
if (!removeResult.Succeeded)
{
ModelState.AddModelError("", "Failed to remove user roles");
return(BadRequest());
}
var result = await _userManager.AddToRolesAsync(user, model.Roles);
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest());
}
public ActionResult AssignRoles(AssignRole assignRole)
{
if (ModelState.IsValid)
{
var UserManager = new UserManager <ApplicationUser>
(new UserStore <ApplicationUser>(context));
var user = UserManager.FindByName(assignRole.userName);
UserManager.AddToRole(user.Id, assignRole.roleName);
context.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ListUser = db.Users.
Select(x => new SelectListItem()
{
Text = x.UserName, Value = x.UserName
})
.Distinct()
.ToList();
ViewBag.ListRole = db.Roles.
Select(x => new SelectListItem()
{
Text = x.Name, Value = x.Name
})
//.Where(x=>x.Name!="Admin")
.Distinct()
.ToList();
return(View());
}
public virtual async Task <IActionResult> AssignRoleAsync([FromBody][Required] AssignRole <TIdentity> assignRole, CancellationToken cancellationToken = default)
{
await this.IdentityManager
.AssignUserRoleAsync(assignRole, cancellationToken);
return(this.Ok());
}
public int UpdateAssignRole(AssignRole role)
{
using (EntityModel em = new EntityModel())
{
em.Entry(role).State = System.Data.Entity.EntityState.Modified;
return(em.SaveChanges());
}
}
public async Task AddRole(CommandContext ctx, params string[] message)
{
await ctx.TriggerTypingAsync();
using (var databaseContext = new DynamicDBContext())
{
Server dbServer = GetServerFromDatabase(databaseContext, ctx.Guild.Id);
// Get server roles.
var serverRoles = ctx.Guild.Roles;
foreach (var serverRole in serverRoles)
{
if (serverRole.Name == ctx.RawArgumentString)
{
// Check if role is already in database
if (IsRoleInDatabase(dbServer, serverRole.Id))
{
await ctx.RespondAsync("The role is already on the list.");
return;
}
// User who triggered is owner, we can add role without problem
if (ctx.User == ctx.Guild.Owner)
{
AssignRole assingRole = new AssignRole(serverRole.Id);
assingRole.Server = dbServer;
databaseContext.Add(assingRole);
databaseContext.SaveChanges();
await ctx.RespondAsync("Role added to the role list.");
}
// User who triggered isn't owner, we need to check if role is lower than the highest role he has
else
{
var userTheHighestRolePosition = GetTheHighestRolePosition(ctx.Member.Roles.ToList());
// Role is lower than the highest role user has
if (serverRole.Position < userTheHighestRolePosition)
{
AssignRole assingRole = new AssignRole(serverRole.Id);
assingRole.Server = dbServer;
databaseContext.Add(assingRole);
databaseContext.SaveChanges();
await ctx.RespondAsync("Role added to the role list.");
}
// Role is equal or higher than the highest role user has
else
{
await ctx.RespondAsync("You can not add this role because it is equal or higher than your highest role.");
}
}
return;
}
}
await ctx.RespondAsync("The given role does not exist.");
}
}
public void DeleteAssignRole(string assignrolecode)
{
using (EntityModel em = new EntityModel())
{
AssignRole asrl = em.AssignRoles.Where(x => x.AssignRoleCode == assignrolecode).First();
em.AssignRoles.Remove(asrl);
em.SaveChanges();
}
}
public int UpdateTemporaryRoleCode(string assignrolecode, string temporaryrolecode)
{
using (EntityModel em = new EntityModel())
{
AssignRole asrl = em.AssignRoles.Where(x => x.AssignRoleCode == assignrolecode).First();
asrl.TemporaryRoleCode = temporaryrolecode;
return(em.SaveChanges());
}
}
public int UpdateEndDate(string assignrolecode, DateTime enddate)
{
using (EntityModel em = new EntityModel())
{
AssignRole asrl = em.AssignRoles.Where(x => x.AssignRoleCode == assignrolecode).First();
asrl.EndDate = enddate;
return(em.SaveChanges());
}
}
protected void Page_Init(object sender, EventArgs e)
{
// The code below helps to protect against XSRF attacks
var requestCookie = Request.Cookies[AntiXsrfTokenKey];
Guid requestCookieGuidValue;
if (requestCookie != null && Guid.TryParse(requestCookie.Value, out requestCookieGuidValue))
{
// Use the Anti-XSRF token from the cookie
_antiXsrfTokenValue = requestCookie.Value;
Page.ViewStateUserKey = _antiXsrfTokenValue;
}
else
{
// Generate a new Anti-XSRF token and save to the cookie
_antiXsrfTokenValue = Guid.NewGuid().ToString("N");
Page.ViewStateUserKey = _antiXsrfTokenValue;
var responseCookie = new HttpCookie(AntiXsrfTokenKey)
{
HttpOnly = true,
Value = _antiXsrfTokenValue
};
if (FormsAuthentication.RequireSSL && Request.IsSecureConnection)
{
responseCookie.Secure = true;
}
Response.Cookies.Set(responseCookie);
}
Page.PreLoad += master_Page_PreLoad;
if (!String.IsNullOrEmpty(Context.User.Identity.Name))
{
userDepartmentCode = employeeController.GetDeptCodeByUserName(Context.User.Identity.Name);
Department department = storeClerkController.GetDeptByCode(userDepartmentCode);
Employee employee = employeeController.GetEmployeeByUsername(Context.User.Identity.Name);
if (employee != null)
{
AssignRole assignRole = deptHeadController.ListAssignRole().Where(ar => ar.EmployeeCode == employee.EmployeeCode).FirstOrDefault();
if (assignRole != null)
{
if (assignRole.TemporaryRoleCode == "Rep")
{
tempRoleCode = assignRole.TemporaryRoleCode;
}
else if (DateTime.Now.Date >= Convert.ToDateTime(assignRole.StartDate).Date &&
DateTime.Now.Date <= Convert.ToDateTime(assignRole.EndDate).Date)
{
tempRoleCode = assignRole.TemporaryRoleCode;
}
}
}
}
}
protected void gv_SelectedIndexChanged(object sender, EventArgs e)
{
string assignrolecode = (string)gv.SelectedDataKey.Value;
AssignRole a = dCon.GetAssignRoleInfo(assignrolecode);
lblEmpName.Text = dCon.GetEmployeeByCode(a.EmployeeCode).EmployeeName;
lblEmpCode.Text = a.EmployeeCode;
//string rolename=dCon.GetRoleName(a.TemporaryRoleCode);
tbxStartDate.Text = a.StartDate.ToString();
tbxEndDate.Text = a.EndDate.ToString();
}
public void AddRoleToDatabase(ulong serverId, ulong roleId)
{
using (var databaseContext = new DynamicDBContext())
{
AssignRole assingRole = new AssignRole(roleId)
{
Server = GetServerFromDatabase(databaseContext, serverId)
};
databaseContext.Add(assingRole);
databaseContext.SaveChanges();
}
}
public int AddTemporaryRole(string assignrolecode, string temporaryrolecode, string employeecode)
{
using (EntityModel em = new EntityModel())
{
AssignRole asrl = new AssignRole();
asrl.AssignRoleCode = assignrolecode;
asrl.TemporaryRoleCode = temporaryrolecode;
asrl.EmployeeCode = employeecode;
em.AssignRoles.Add(asrl);
return(em.SaveChanges());
}
}
protected string GetDeptRepName(string deptCode)
{
try
{
AssignRole assignRole = dCtrl.ListOfAssignRoleInDepartment(deptCode).Where(ar => ar.TemporaryRoleCode.ToUpper() == "REP").FirstOrDefault();
return(scCtrl.GetEmployee(assignRole.EmployeeCode).EmployeeName);
}
catch (Exception ex)
{
return("");
}
}
public int UpdateAssignRole(string assignrolecode, string temporaryrolecode,
DateTime startdate, DateTime enddate)
{
using (EntityModel em = new EntityModel())
{
AssignRole asrl = em.AssignRoles.Where(x => x.AssignRoleCode == assignrolecode).First();
asrl.TemporaryRoleCode = temporaryrolecode;
asrl.StartDate = (DateTime)startdate;
asrl.EndDate = (DateTime)enddate;
return(em.SaveChanges());
}
}
public ActionResult AssignNewRole(AssignRole model)
{
var userId = (int)Session["UserId"];
DSRCManagementSystemEntities1 db = new DSRCManagementSystemEntities1();
int BranchId = (int)db.Users.FirstOrDefault(o => o.UserID == userId).BranchId;
var userIDs1 = model.unuserid;
var UserIDs = model.multiselectemployees.Split(',');
var DataId = model.RoleID;
var Data = Convert.ToInt32(DataId);
List <int> UserID = model.SelectedEmpList;
var RoleName = MasterEnum.NewuserRole.NewEmployeeRole;
var RoleID = db.Master_Roles.FirstOrDefault(o => o.RoleName == RoleName).RoleID;
var employees1 = (from rc in db.Users
join p in db.UserRoles on rc.UserID equals p.UserID
join r in db.Master_Roles on p.RoleID equals r.RoleID
//where (rc.FirstName != null && rc.LastName != null && p.RoleID == Data && r.RoleID != RoleID && rc.BranchId == BranchId)
where (p.RoleID == Data && r.RoleID != RoleID && rc.BranchId == BranchId)
select new AssignRole()
{
userid = rc.UserID,
}).Distinct().ToList();
List <int> ex = UserID.Except(employees1.Select(e => e.userid)).ToList();
foreach (int userID1 in ex)
{
var x = db.UserRoles.Where(o => o.UserID == userID1).ToList();
foreach (var y in x)
{
db.UserRoles.DeleteObject(y);
db.SaveChanges();
}
}
foreach (int userID in ex)
{
var Assignobj = db.UserRoles.CreateObject();
Assignobj.RoleID = Convert.ToByte(Data);
Assignobj.UserID = Convert.ToInt32(userID);
db.UserRoles.AddObject(Assignobj);
db.SaveChanges();
var UpdateRoleID = db.Users.Where(o => o.UserID == userID).Select(o => o).FirstOrDefault();
if (UpdateRoleID != null)
{
UpdateRoleID.RoleID = Convert.ToByte(Data);
}
db.SaveChanges();
}
return(Json("Success", JsonRequestBehavior.AllowGet));
}
private string GetDepartmentRepEmail(string deptCode)
{
List <Employee> employees = employeeDAO.SearchByDept(deptCode);
foreach (Employee e in employees)
{
AssignRole assignRole = assignRoleDAO.SearchByEmployeeCode(e.EmployeeCode).Where(ar => ar.TemporaryRoleCode == "Rep").FirstOrDefault();
if (assignRole != null)
{
return(GetUserEmail(e.UserName));
}
}
return(null);
}
public void AssignRoleToActor(AssignRole model)
{
var result = _authQueries.GetValidationResult(model);
if (result.IsValid == false)
{
throw new ApplicationException(result.Errors.First().ErrorMessage);
}
var actor = _repository.GetActor(model.ActorId);
var role = _repository.Roles.Single(r => r.Id == model.RoleId);
actor.AssignRole(role);
_repository.SaveChanges();
}
protected void btnAssign_Click(object sender, EventArgs e)
{
string employeecode = lblEmpCode.Text;
string assignrolecode = (string)gv.SelectedDataKey.Value;
AssignRole assignRole = dCon.GetAssignRoleInfo(assignrolecode);
string rolecodeselected = assignRole.TemporaryRoleCode;
if (rolecodeselected == "ActHead")
{
if (tbxStartDate.Text == "" || tbxEndDate.Text == "")
{
lblSuccessMsg.Text = "";
lblErrorMsg.Text = "Can't be empty";
}
else
{
DateTime startdateselected = Convert.ToDateTime(tbxStartDate.Text);
DateTime enddateselected = Convert.ToDateTime(tbxEndDate.Text);
bool checkvalue = dCon.CheckDates(assignrolecode, rolecodeselected, startdateselected, enddateselected, Master.UserDepartmentCode);
if (assignrolecode != null)
{
if (checkvalue)
{
dCon.UpdateAssignRole(assignrolecode, rolecodeselected, startdateselected, enddateselected);
lblSuccessMsg.Text = "Assign Role updated";
lblErrorMsg.Text = "";
}
else
{
lblSuccessMsg.Text = "";
lblErrorMsg.Text = "Already present for this period";
}
}
else
{
lblSuccessMsg.Text = "";
lblErrorMsg.Text = "Can't update, there's no temporaryrole";
}
}
}
else
{
lblSuccessMsg.Text = "";
lblErrorMsg.Text = "Can't update";
}
BindGrid();
}
public void DeleteDelegation(ADProjectDb db, int employeeId)
{
AssignRole assignRole = db.Employee
.Where(emp => emp.EmployeeId == employeeId)
.Select(emp => emp.AssignRole)
.SingleOrDefault();
Employee employee = db.Employee
.Where(emp => emp.EmployeeId == employeeId)
.SingleOrDefault();
employee.AssignRole = null;
db.AssignRole.Remove(assignRole);
db.SaveChanges();
}
public WCFAssignRole GetAssignRole(string assignrolecode, string email, string password)
{
if (loginService.ValidateUser(email, password))
{
AssignRole a = dCon.GetAssignRoleInfo(assignrolecode);
string emName = dCon.GetEmployeeName(a.EmployeeCode);
WCFAssignRole ass = new WCFAssignRole(a.AssignRoleCode, a.TemporaryRoleCode, a.EmployeeCode,
string.Format("{0:dd/MM/yyyy}", a.StartDate), string.Format("{0:dd/MM/yyyy}", a.EndDate),
a.AssignedBy, emName);
return(ass);
}
else
{
return(null);
}
}
public int AddAssignRole(string assignrolecode, string temporaryrolecode, string employeecode,
DateTime startdate, DateTime enddate, string assignedby)
{
using (EntityModel em = new EntityModel())
{
AssignRole asrl = new AssignRole();
asrl.AssignRoleCode = assignrolecode;
asrl.TemporaryRoleCode = temporaryrolecode;
asrl.EmployeeCode = employeecode;
asrl.StartDate = startdate;
asrl.EndDate = enddate;
asrl.AssignedBy = assignedby;
em.AssignRoles.Add(asrl);
return(em.SaveChanges());
}
}
public async Task <IActionResult> AssignRole(AssignRole model)
{
if (!ModelState.IsValid)
{
_logger.LogError(GetModelStateErrorMessage());
return(BadRequest(ModelState));
}
ApplicationUser user = await _userManager.FindByEmailAsync(model.Email);
var result = await _userManager.AddToRoleAsync(user, model.Role);
if (!result.Succeeded)
{
string errorString = string.Join(" | ", result.Errors.Select(c => c.Description).ToList());
_logger.LogError(errorString);
return(StatusCode(StatusCodes.Status500InternalServerError, errorString));
}
return(Ok("Success"));
}
protected void OnRowDeleting(object sender, GridViewDeleteEventArgs e)
{
string assignrolecode = (string)gv.DataKeys[e.RowIndex].Values[0];
AssignRole ass = dCon.GetAssignRoleInfo(assignrolecode);
//if (ass.TemporaryRoleCode == "ActHead")
// {
dCon.DeleteAssignRole(assignrolecode);
//}
/* else
* {
* Employee emp = dCon.GetEmployeeInfo(ass.EmployeeCode);
* Role role = dCon.getRoleNameByUsername(emp.UserName);
* em.Users.Where(x => x.UserName == emp.UserName).FirstOrDefault<User>().Roles.Remove(role);
* em.SaveChanges();
* dCon.DeleteAssignRole(assignrolecode);
* }*/
BindGrid();
}
public Employee GetAuthenticatedEmployee(ADProjectDb db, string username, string password)
{
Employee validatedEmployee = null;
List <Employee> employees = db.Employee.ToList();
foreach (var emp in employees)
{
if (emp.Username == username && emp.Password == password)
{
validatedEmployee = emp;
break;
}
}
if (validatedEmployee == null)
{
return(validatedEmployee);
}
//To handle lazy loading of EmployeeRole and AssignedRole
Role role = db.Employee.Where(e => e.EmployeeId == validatedEmployee.EmployeeId)
.Select(e => e.Role).SingleOrDefault();
AssignRole assignRole = db.Employee.Where(e => e.EmployeeId == validatedEmployee.EmployeeId)
.Select(e => e.AssignRole).SingleOrDefault();
Role assignedRole_Role = null;
try
{
assignedRole_Role = db.AssignRole.Where(ar => ar.EmployeeId == validatedEmployee.EmployeeId)
.Select(ar => ar.Role).FirstOrDefault();
assignRole.Role = assignedRole_Role;
} catch (Exception exception)
{
Debug.WriteLine(exception);
}
validatedEmployee.Role = role;
validatedEmployee.AssignRole = assignRole;
return(validatedEmployee);
}
