private void UserMustBeInRole(RoleEnum roleEnum)
{
if (FrameworkSettings.CurrentUser == null || !FrameworkSettings.CurrentUser.IsInRole(roleEnum))
{
throw AccessDeniedException();
}
}
public UserDAL(string userName)
{
string sql = string.Empty;
try
{
sql = "select id,userName,RoleID,EmailAddr from users where userName = @userName";
SqlParameter[] par = new SqlParameter[1];
par[0] = new SqlParameter("@userName", userName);
DataSet ds = SqlHelper.Query(sql, par);
DataTable dt = ds.Tables[0];
if (dt.Rows.Count > 0)
{
DataRow dr = dt.Rows[0];
this.UserName = userName;
this.roleID = dr["RoleID"].ToString();
this.ID = Convert.ToInt32(dr[ID]);
this.EmailAddr = dr["EmailAddr"].ToString();
if (roleID == "1")
{
EnumRole = RoleEnum.Admin;
}
else
{
EnumRole = RoleEnum.Member;
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public void CreateAccount(string username, string password, RoleEnum role)
{
var account = new AccountRecord
{
Id = Accounts.DynamicPop(),
Username = username,
Password = password,
Nickname = username,
Role = role,
BanEndTime = DateTime.Now,
CreationTime = DateTime.Now,
EndSubscriptionTime = DateTime.Now,
CharacterSlots = 0,
HardwareId = string.Empty,
IsBanned = false,
IsBannedForLife = false,
IsConnected = false,
LastConnectionWorld = 0,
LastIP = string.Empty,
SecretAnswer = "Oui",
SecretQuestion = "Supprimer ce personnage ?",
Ticket = string.Empty,
Tokens = 0
};
account.AddInstantElement();
_logger.LogInformation($"Account => Username = {account.Username} | Password = {account.Password} | Role = {account.Role}\n");
}
protected Role(PlayerControl player, RoleEnum roleEnum)
{
Player = player;
RoleDictionary.Add(player.PlayerId, this);
RoleType = roleEnum;
RoleDetailsAttribute = RoleDetailsAttribute.GetRoleDetails(roleEnum);
}
protected void GetSalesAgent(IOffer offer, XElement input, string tagName = "sales-agent")
{
XElement sa = GetFirstElement(input, tagName);
RoleEnum saRole = GetRole(sa);
string name = GetText(sa, "name");
string phone = GetText(sa, "phone");
MyEntityContext ctx = Application.Context;
IAgent agent = ctx.Agents.Where(x => x.Name == name &&
x.Phone == phone).FirstOrDefault();
string op = "Got";
if (agent == null)
{
agent = ctx.Agents.Create();
agent.GUID = GetGUID();
agent.Name = name;
agent.Phone = phone;
agent.Role = saRole;
ctx.Add(agent);
ctx.SaveChanges();
op = "Added";
}
/*
* Console.WriteLine(string.Format("{3} agent: {0}:{1}:{2}",
* agent.Name, agent.Phone,
* agent.Role,
* op));
*/
offer.Agent = agent;
}
public void MultipleRolesLogin(string name, string password, RoleEnum roleEnum)
{
TypeUserName(name);
TypePassword(password);
ClickLogin();
SelectRole(roleEnum);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!UserUtils.isLogin())
{
Response.Redirect(Constants.LINK_LOGIN);
}
//Page.Header.DataBind();
if (!Page.IsPostBack)
{
if (userLogin != null)
{
//Clear old Notification
removeSession();
RoleEnum roleEnum = (RoleEnum)Enum.Parse(typeof(RoleEnum), userLogin.role_id.ToString());
menu_role menuRoleBiz = new menu_role();
MenuBiz menuBiz = new MenuBiz();
//Generate Navigator
litNavigator.Text = menuBiz.getNavigator(Request.PhysicalPath);
litMenu.Text = menuBiz.getMenuByRole(menuRoleBiz.getMenuByRole(userLogin.role_id), Request.PhysicalPath);
litUserData.Text = String.Format("Login by :: {0} {1} ( {2} )", userLogin.first_name, userLogin.last_name, roleEnum.ToString());
//Generate Alert
renderAlert();
}
}
}
/// <param name="userName"> </param>
/// <param name="password"> </param>
public static void generateCreateSpecifyUserSQL(UserDao userDao, string userName, string password, RoleEnum roleEnum, string ownAppIds)
{
User user = new User();
user.Name = userName;
user.Password = SignUtils.createPassword(password);
// token
user.Token = SignUtils.createToken(userName);
// set appids
user.OwnApps = ownAppIds;
// role
user.RoleId = roleEnum.Value;
Console.WriteLine("/* " + userName + "\t" + password + "*/");
// userDao.create(user);
IList<User> userList = new List<User>();
userList.Add(user);
printUserList(userList);
}
public static AspNetRoles GetRole(RoleEnum role)
{
using (var context = new BackofficeUnitOfWork())
{
return(GetRole(context, role));
}
}
public User(string name, RoleEnum role, string emailAddress, string hashedPassword)
{
Name = name;
Role = role;
EmailAddress = emailAddress;
HashedPassword = hashedPassword;
}
/// <summary>
/// Creates a new user where: Username == Email.
/// </summary>
/// <param name="newUser"></param>
/// <param name="role"></param>
/// <param name="password"></param>
/// <returns></returns>
public async Task <string> CreateUserAsync(AppUser newUser, RoleEnum role, string password)
{
var user = await _userManager.FindByEmailAsync(newUser.Email);
if (user != null)
{
throw new UniqueConstraintException("User email", newUser.Email);
}
newUser.UserName = newUser.Email;
var result = await _userManager.CreateAsync(newUser, password);
if (!result.Succeeded)
{
throw new Exception($"Couldn't create user ({string.Join(";", result.Errors.Select(x => x.Description))})");
}
result = await _userManager.AddToRoleAsync(newUser, Enum.GetName(typeof(RoleEnum), role));
if (!result.Succeeded)
{
throw new Exception($"Couldn't add roles to user ({string.Join(";", result.Errors.Select(x => x.Description))})");
}
return(await _userManager.GenerateEmailConfirmationTokenAsync(newUser));
}
// remove a role from the user
public void RemoveRoleFromUser(UserVO user, RoleEnum role)
{
if (DoesUserHaveRole(user, role))
{
for (int i = 0; i < Roles.Count; i++)
{
if (Roles[i].UserName.Equals(user.UserName))
{
IList <RoleEnum> userRoles = Roles[i].Roles;
foreach (RoleEnum curRole in userRoles)
{
if (curRole.Equals(role))
{
userRoles.Remove(role);
SendNotification(NotiConst.DEL_ROLE, role);
break;
}
}
break;
}
}
}
}
public static Role ToType(RoleEnum enumValue)
{
switch (enumValue)
{
case RoleEnum.Admin:
return(Admin);
case RoleEnum.Normal:
return(Normal);
case RoleEnum.ProgramEditor:
return(ProgramEditor);
case RoleEnum.ProjectSteward:
return(ProjectSteward);
case RoleEnum.SitkaAdmin:
return(SitkaAdmin);
case RoleEnum.Unassigned:
return(Unassigned);
default:
throw new ArgumentException(string.Format("Unable to map Enum: {0}", enumValue));
}
}
public static void CreateUserByRole(RoleEnum role, ApplicationUser user, string password, ApplicationDbContext db)
{
user.Id = Guid.NewGuid().ToString();
var store = new UserStore<ApplicationUser>(db);
var manager = new UserManager<ApplicationUser>(store);
using (var dbContextTransaction = db.Database.BeginTransaction())
{
try
{
manager.Create(user, password);
db.SaveChanges();
manager.AddToRole(user.Id, Enum.GetName(typeof(RoleEnum), (int)role));
db.SaveChanges();
dbContextTransaction.Commit();
}
catch (Exception)
{
dbContextTransaction.Rollback();
}
}
}
protected void GetSalesAgent(IOffer offer, XElement input, string tagName = "sales-agent")
{
XElement sa = GetFirstElement(input, tagName);
RoleEnum saRole = GetRole(sa);
string name = GetText(sa, "name");
string phone = GetText(sa, "phone");
MyEntityContext ctx = Application.Context;
IAgent agent = ctx.Agents.Where(x => x.Name == name &&
x.Phone == phone).FirstOrDefault();
if (agent == null)
{
agent = ctx.Agents.Create();
agent.GUID = GetGUID();
agent.Name = name;
agent.Phone = phone;
agent.Role = saRole;
ctx.Add(agent);
ctx.SaveChanges();
}
offer.Agent = agent;
// FIXME: Implement
}
//Find out if user is in role
public bool IsRole(RoleEnum roleName)
{
int permission = this.Permissions;
int role = (int)roleName;
return((0b1 & (permission >> (role - 1))) == 1); //Using bit shifting, find out if user has role
}
/// <summary>
/// Initializes a new instance of the <see cref="TeamMemberDto" /> class.
/// </summary>
/// <param name="userId">The team member (required).</param>
/// <param name="role">The role the user has within the team (required).</param>
public TeamMemberDto
(
string userId, RoleEnum role // Required parameters
// Optional parameters
) // BaseClass
{
// to ensure "userId" is required (not null)
if (userId == null)
{
throw new InvalidDataException("userId is a required property for TeamMemberDto and cannot be null");
}
else
{
this.UserId = userId;
}
// to ensure "role" is required (not null)
if (role == null)
{
throw new InvalidDataException("role is a required property for TeamMemberDto and cannot be null");
}
else
{
this.Role = role;
}
// Set non-required readonly properties with defaultValue
}
/// <summary>
/// Checkes whether the user is authorized to access the page
/// </summary>
/// <param name="controller">Controller</param>
/// <param name="action">Action</param>
/// <param name="userName">User Name</param>
/// <returns>Is user authorized</returns>
public bool IsUserAuthorized(string controller, string action, string userName)
{
UserDataHandler dataSource = new UserDataHandler();
RoleEnum usersRole;
if (userName.Equals("none"))
{
usersRole = RoleEnum.none;
}
else
{
string userRole = dataSource.getUserRole(userName);
if (userRole.Equals("User"))
{
usersRole = RoleEnum.user;
}
else if (userRole.Equals("Admin"))
{
usersRole = RoleEnum.admin;
}
else
{
MvcApplication.logger.log("Class:Page Authentication Function: isUserAuthorized Error: System Authentication Error.Check Database connection", 3);
throw new Exception("CustomizeDeveloperMessage: System Authentication Error.Check Database connection.");
}
}
// get required role from the Matrix (this will fail if we haven't registered the requested controller/action combination
RoleEnum requiredRole = SecurityMatrix.Matrix.First(x => x.Controller == controller && x.Action == action).MinimumRoleNeeded;
return(usersRole >= requiredRole);
}
public async Task Handle_ReturnsUser_WhenUsernameCasesDontMatch()
{
//arrange
const string expectedUsername = "******";
const RoleEnum expectedRole = default;
const string password = "******";
var user = new User
{
Username = expectedUsername,
Password = BCrypt.Net.BCrypt.EnhancedHashPassword(password, 4),
Role = expectedRole
};
DbContext.Users.Add(user);
await DbContext.SaveChangesAsync();
var query = new LogInQuery(expectedUsername.ToUpper(), password);
//act
GetUserViewModel?actual = await _handler.Handle(query);
//assert
Assert.Equal(user.Id, actual.Id);
Assert.Equal(expectedUsername, actual.Username);
Assert.Equal(expectedRole, actual.Role);
}
public bool SignIn(string log, string pswd, RoleEnum list)
{
using (Classes.Data.AppContext context = new Classes.Data.AppContext())
{
bool success = false;
IEnumerable <User> userList;
User usr = new User();
if (list == RoleEnum.student)
{
userList = context.GetStudents.Where((user) => user.Login == log);
}
else
{
userList = context.GetTeachers.Where((user) => user.Login == log);
}
foreach (User user in userList)
{
if (user.Login == log && user.Password == pswd)
{
usr = user;
success = true;
Session.GetInstance().User = user;
}
else
{
success = false;
}
}
return(success);
}
}
public User(string name, RoleEnum role, string emailAddress, string hashedPassword)
{
Name = name;
Role = role;
EmailAddress = emailAddress;
HashedPassword = hashedPassword;
}
public async Task AddRole([FromHeader] int userId, [FromHeader] RoleEnum role)
{
User appUser = await _db.Users.Include(u => u.UserRoles).ThenInclude(r => r.Role).FirstOrDefaultAsync(u => u.Id == userId);
if (appUser != null)
{
var curRole = appUser.UserRoles.FirstOrDefault(r => r.Role.RoleName == role);
if (curRole == null)
{
var roleUsr = await _db.Roles.FirstOrDefaultAsync(r => r.RoleName == role);
var usrRole = new UserRole {
Role = roleUsr, User = appUser
};
await _db.UserRoles.AddAsync(usrRole);
await _db.SaveChangesAsync();
}
else
{
Response.StatusCode = 400;
await Response.WriteAsync("Role is exist");
}
}
else
{
Response.StatusCode = 400;
await Response.WriteAsync("User not found");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FacilityInstitutionDto" /> class.
/// </summary>
/// <param name="institutionId">institutionId (required).</param>
/// <param name="role">role (required).</param>
/// <param name="fundId">fundId.</param>
public FacilityInstitutionDto(string institutionId = default(string), RoleEnum role = default(RoleEnum), string fundId = default(string))
{
// to ensure "institutionId" is required (not null)
this.InstitutionId = institutionId ?? throw new ArgumentNullException("institutionId is a required property for FacilityInstitutionDto and cannot be null");;
this.Role = role;
this.FundId = fundId;
}
public virtual JsonResult ChangeRoleAndPermissions(string operationNumber, RoleEnum role)
{
_cacheStorageService.Remove("AuthorizationInfo");
var auth = new AuthorizationOperationInfo
{
ActionList = new List <ActionEnum>(),
RoleList = new List <RoleEnum>
{
RoleEnum.PCRProjectTeamLeader,
role
},
UserName = IDBContext.Current.UserLoginName
};
foreach (var permission in RolePermissions[role])
{
auth.ActionList.Add(permission);
}
var authPermission = new AuthorizationInfo
{
Authorization = new Dictionary <string, AuthorizationOperationInfo>()
};
authPermission.Authorization.Add(operationNumber, auth);
_cacheStorageService.Add("AuthorizationInfo", authPermission);
return(Json(new { IsValid = true, ErrorMessage = "Permissions was changed" }));
}
public async Task <IActionResult> Register([FromRoute] RoleEnum role,
[FromBody] RegisterViewModel registerViewModel)
{
var user = UserFactory.New(role, x =>
{
x.Firstname = registerViewModel.Firstname;
x.Lastname = registerViewModel.Lastname;
x.Email = registerViewModel.Email;
x.UserName = registerViewModel.Username;
x.Role = role;
});
// Create user
var identityResults = new List <IdentityResult>
{
await _userManager.CreateAsync(user, registerViewModel.Password)
};
// Create the role if not exist
if (!await _roleManager.RoleExistsAsync(role.ToString()))
{
identityResults.Add(await _roleManager.CreateAsync(new UserRole(role.ToString())));
}
// Register the user to the role
identityResults.Add(await _userManager.AddToRoleAsync(user, role.ToString()));
if (identityResults.Aggregate(true, (b, result) => b && result.Succeeded))
{
return(Ok("Successfully registered!"));
}
return(BadRequest("Failed to register!"));
}
private void Set(double x, double y, RoleEnum role)
{
Debug.WriteLine("x " + x + " y " + y);
foreach (Control item in boardGrid.Children)
{
var row = Grid.GetRow(item as UIElement);
var column = Grid.GetColumn(item as UIElement);
if (x == column && y == row)
{
switch (role)
{
case RoleEnum.Player1:
item.Background = Brushes.Green;
break;
case RoleEnum.Player2:
item.Background = Brushes.Orange;
break;
case RoleEnum.Fire:
item.Background = Brushes.Red;
break;
case RoleEnum.Water:
item.Background = Brushes.Blue;
break;
default:
break;
}
}
else
{
switch (board[column, row])
{
case RoleEnum.Player1:
item.Background = Brushes.Green;
break;
case RoleEnum.Player2:
item.Background = Brushes.Orange;
break;
case RoleEnum.Fire:
item.Background = Brushes.Red;
break;
case RoleEnum.Water:
item.Background = Brushes.Blue;
break;
case RoleEnum.Empty:
default:
item.Background = ((row % 2 == 0 ? 0 : 1) + column) % 2 == 0 ? Brushes.Black : Brushes.Wheat;
break;
}
}
}
}
public UserDTO(long id, string name, string surname, string login, RoleEnum role)
{
Id = id;
Name = name;
Surname = surname;
Login = login;
Role = role;
}
public User(string name, string surname, string login, string password, RoleEnum role)
{
Name = name;
Surname = surname;
Login = login;
Password = password;
Role = role;
}
public User(string name, string department, RoleEnum role, string email, string password)
{
this.Name = name;
this.Department = department;
this.Role = role;
this.Email = email;
this.Password = password;
}
/// <summary>
/// Initializes a new instance of the <see cref="UsersMeResponseUserCompanies" /> class.
/// </summary>
/// <param name="id">事業所ID (required).</param>
/// <param name="displayName">表示名 (required).</param>
/// <param name="role">ユーザーの権限 (required).</param>
/// <param name="useCustomRole">カスタム権限（true: 使用する、false: 使用しない） (required).</param>
public UsersMeResponseUserCompanies(int id = default(int), string displayName = default(string), RoleEnum role = default(RoleEnum), bool useCustomRole = default(bool))
{
this.Id = id;
// to ensure "displayName" is required (not null)
this.DisplayName = displayName ?? throw new ArgumentNullException("displayName is a required property for UsersMeResponseUserCompanies and cannot be null");;
this.Role = role;
this.UseCustomRole = useCustomRole;
}
public bool CurrentUser_HasRole(RoleEnum role, RoleEnum role2, RoleEnum role3, ABUserAuth current_user = null)
{
if (current_user == null)
{
current_user = CurrentUser;
}
return(current_user.HasRole(role) || current_user.HasRole(role2) || current_user.HasRole(role3));
}
public UserAdministration AddAdministered(Guid subordinateId, RoleEnum role)
{
UserAdministration administration = new UserAdministration(Id, subordinateId, role);
Personnel.Add(administration);
return(administration);
}
public UserAdministration AddAdministrator(Guid superiorId, RoleEnum role)
{
UserAdministration administration = new UserAdministration(superiorId, Id, role);
Administrators.Add(administration);
return(administration);
}
public bool IsInRole(RoleEnum role)
{
return(this.AuthSession.HasRole(role.ToString()));
//if (this.Roles != null && this.Roles.Contains(role.ToLower()))
// return true;
//else
// return false;
}
public bool Login(string userName, string password)
{
try
{
string sql = @"select id,userName,RoleID,EmailAddr from users where userName=@userName and password=@password";
SqlParameter[] par = new SqlParameter[2];
par[0] = new SqlParameter("@userName", userName);
par[1] = new SqlParameter("@password", password);
DataSet ds = SqlHelper.Query(sql, par);
DataTable dt = ds.Tables[0];
if (dt.Rows.Count > 0)
{
DataRow dr = dt.Rows[0];
this.UserName = userName;
this.roleID = dr["RoleID"].ToString();
this.ID = Convert.ToInt32(dr[ID]);
this.EmailAddr = dr["EmailAddr"].ToString();
if (roleID == "1")
{
EnumRole = RoleEnum.Admin;
}
else
{
EnumRole = RoleEnum.Member;
}
return true;
}
return false;
}
catch (Exception ex)
{
throw ex;
}
}
public static bool UserInRole(RoleEnum role, HttpSessionStateBase session)
{
if (session == null) return false;
var emp = GetEmployeeSession(session);
if (emp == null) return false;
if (emp.RoleId == (int)role)
return true;
return false;
}
public List<Task> GetTasksByRole(RoleEnum role)
{
var id = role.GetEnumValue();
return DataProvider.RoleTasks.Filter(c => c.RoleId == id).Select(c => c.Task).ToList();
}
public List<Task> GetTasksByRole(RoleEnum role)
{
return _accountService.GetTasksByRole(role);
}
public bool IsInRole(RoleEnum role)
{
if ((RolesEnum & role) == role)
return true;
else
return false;
}
PageData<UserData> IAccountService.GetUsers(SortEnum sortType, string term, int pageId, int pageSize, RoleEnum currentUserRole)
{
var pageData = new PageData<UserData> { PageId = pageId, PageSize = pageSize };
var data = !string.IsNullOrWhiteSpace(term)
? _userRepository.GetQueryableData(o => o.UserName.Contains(term))
: _userRepository.GetQueryableData();
data = data.Where(o => o.RoleId != (int)RoleEnum.MainAdministrator);
if (currentUserRole == RoleEnum.Administrator)
data = data.Where(o => o.RoleId != (int)RoleEnum.Administrator);
pageData.Count = data.Count();
if (pageData.Count != 0)
{
switch (sortType)
{
case SortEnum.Default:
data = data.OrderBy(o => !o.IsActive).ThenBy(o => o.IsBanned).ThenBy(o => o.UserName);
break;
case SortEnum.Name:
data = data.OrderBy(o => o.UserName);
break;
case SortEnum.Email:
data = data.OrderBy(o => o.Email);
break;
case SortEnum.Actived:
data = data.OrderBy(o => !o.IsActive).ThenBy(o => o.IsBanned).ThenBy(o => o.UserName);
break;
case SortEnum.Banned:
data = data.OrderBy(o => !o.IsBanned).ThenBy(o => !o.IsActive).ThenBy(o => o.UserName);
break;
}
pageData.Data = data.Page(pageData.PageId, pageData.PageSize).Select(o => new UserData
{
Id = o.Id,
UserName = o.UserName,
Email = o.Email,
IsActive = o.IsActive,
PhotoPath = o.PhotoPath,
IsBanned = o.IsBanned,
RoleId = o.RoleId
}).ToList();
}
return pageData;
}
PageData<UserData> IAccountService.GetUsers(RoleEnum roleType, string term, int pageId, int pageSize, RoleEnum currentUserRole)
{
var pageData = new PageData<UserData> { PageId = pageId, PageSize = pageSize };
var data = !string.IsNullOrWhiteSpace(term)
? _userRepository.GetQueryableData(o => o.UserName.Contains(term) && ((int)roleType == (int)RoleEnum.None || o.RoleId == (int)roleType))
: _userRepository.GetQueryableData(o => ((int)roleType == (int)RoleEnum.None || o.RoleId == (int)roleType));
data = data.Where(o => o.RoleId != (int)RoleEnum.MainAdministrator);
if (currentUserRole == RoleEnum.Administrator)
data = data.Where(o => o.RoleId != (int)RoleEnum.Administrator);
pageData.Count = data.Count();
if (pageData.Count != 0)
{
pageData.Data = data.OrderBy(o => o.UserName).Page(pageData.PageId, pageData.PageSize).Select(o => new UserData
{
Id = o.Id,
UserName = o.UserName,
Email = o.Email,
IsActive = o.IsActive,
PhotoPath = o.PhotoPath,
IsBanned = o.IsBanned,
RoleId = o.RoleId
}).ToList();
}
return pageData;
}
