private void IdentitySignin(SecurityUser user, Int64 companyId, bool isPersist = false) { var claims = new List <Claim>(); claims.Add(new Claim(ClaimTypes.NameIdentifier, user.UserId.ToString())); claims.Add(new Claim(ClaimTypes.Name, user.UserName)); claims.Add(new Claim(iHUser.CompanyIdName, companyId.ToString())); var identity = new ClaimsIdentity(claims, DefaultAuthenticationTypes.ApplicationCookie); foreach (string role in user.Roles) { if (string.IsNullOrEmpty(role)) { continue; } string[] permissionLevels = role.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); foreach (string permissionLevel in permissionLevels) { identity.AddClaim(new Claim(ClaimTypes.Role, permissionLevel)); } } AuthenticationManager.SignIn(new AuthenticationProperties { AllowRefresh = true, IsPersistent = isPersist, ExpiresUtc = DateTime.UtcNow.AddDays(7) }, identity); }
public ActionResult GetOrderInfo(FormCollection fc) { if (fc.Get("Quantity") != null && fc.Get("Quantity") != null && Session["ItemId"] != null) { var email = User.Identity.Name; SecurityUser user = _securityUserService.GetUserByUserName(email); MenuItem menuItem = _menuItemService.GetMenuItemById(Convert.ToInt32(Session["ItemId"])); SecurityUser cook = _securityUserService.GetUserById(menuItem.CookId); Order order = new Order(); List <OrderItem> orderItems = new List <OrderItem>(); OrderItem orderItem = new OrderItem(); order.AddressId = Convert.ToInt32(fc.Get("address")); order.BusinessZoneId = user.BusinessZoneId; order.CustomerId = user.Id; order.DelivereyStatus = "Pending"; order.DeliveryBoyId = cook.DeliveryBoyId; order.Phone = user.Phone; order.DelivereyDate = DateTime.Today; orderItem.OrderId = 0; orderItem.MenuItemId = menuItem.Id; orderItem.Quantity = Convert.ToInt32(fc.Get("Quantity")); orderItem.Price = Convert.ToInt32(Session["Subtotal"]); orderItems.Add(orderItem); order.OrderItems = orderItems; // _orderService.OrderInsert(order); } else { return(RedirectToAction("Index", "Home")); } return(RedirectToAction("MyOrderList", "Account")); }
private static string GetContextDetail(HttpRequestBase request, SecurityUser user) { var result = new StringBuilder("\r\n"); if (user != null) { result.AppendFormat("User: '******'; Groups: '{1}'; Windows User: '******'\r\n", user.Name, user.SecurityGroupsDisplay, Environment.UserName); } if (request != null) { result.AppendFormat("URL: '{0}'\r\n", request.Url.OriginalString); if (request.RequestContext != null && request.RequestContext.HttpContext != null) { result.AppendFormat("Session: '{0}'\r\n", request.RequestContext.HttpContext.Session.SessionID); } result.AppendFormat("IP: '{0}'\r\n", GetIPAddress(request)); if (request.Form.Count > 0) { foreach (string key in request.Form.Keys) { result.AppendFormat("{0}={1}\r\n", key, request.Form[key]); } } if (request.QueryString.Count > 0) { foreach (string key in request.QueryString.Keys) { result.AppendFormat("{0}={1}\r\n", key, request.QueryString[key]); } } } return(result.ToString()); }
public async Task <FileStreamResult> GetUserPictureStreamResult(SecurityUser securityUser) { return(null); //return securityUser.UserPictureId.HasValue // ? await _storageService.GetFileStreamResultAsync(securityUser.UserPictureId.Value) // : null; }
public MaterialPermit(Permit permit) { id = 0; this.unit = Unit.Empty; docNumber = ""; docDate = DateTime.Today; person = permit.DriverName; vehicleMark = permit.Vehicle.VehicleMark.ToString(); licensePlate = permit.Vehicle.LicensePlate; createFlag = 0; creator = null; createDate = DateTime.MinValue; signedFlag = 0; signer = null; signDate = DateTime.MinValue; entryFlag = 0; entryPoint = null; entryDate = DateTime.MinValue; comment = "К пропуску № " + permit.ToString(); PermitId = permit.Id; baseDocument = "доверенность"; baseDocNumber = ""; baseDocDate = DateTime.Today; IsNew = false; Insert(); }
public MaterialPermit(Appoint appoint) { id = 0; this.unit = appoint.Unit; docNumber = ""; docDate = DateTime.Today; person = appoint.DriverName; vehicleMark = appoint.TrackMark; licensePlate = appoint.LicensePlate; createFlag = 0; creator = null; createDate = DateTime.MinValue; signedFlag = 0; signer = null; signDate = DateTime.MinValue; entryFlag = 0; entryPoint = null; entryDate = DateTime.MinValue; comment = ""; PermitId = appoint.PermitId; baseDocument = "доверенность"; baseDocNumber = appoint.Warrant; baseDocDate = DateTime.Today; IsNew = false; Insert(); }
private SecurityUserDto Update(SecurityUserDto securityUserDto) { SecurityUserDto updatedSecurityUserDto = null; using (TransactionScope scope = new TransactionScope()) { using (UnitOfWork unitOfWork = new UnitOfWork()) { SecurityUser securityUser = unitOfWork.SecurityUserRepository.GetByID(p => p.SecurityUserId == securityUserDto.SecurityUserId); securityUserDto.Password = securityUser.Password; securityUserDto.PasswordSalt = securityUser.PasswordSalt; _SecurityUserMapper.MapToSecurityUser(securityUser, securityUserDto); unitOfWork.SecurityUserRepository.Update(securityUser); unitOfWork.Save(); updatedSecurityUserDto = _SecurityUserMapper.MapToSecurityUserDto(unitOfWork.SecurityUserRepository.GetByID(p => p.SecurityUserId == securityUserDto.SecurityUserId)); } scope.Complete(); } return(updatedSecurityUserDto); }
SecurityUser CreateWebUser() { if (Repository == null) { CreateRepository(); } var user = new SecurityUser(Repository.Security); //Load profile if (System.IO.File.Exists(user.ProfilePath)) { user.Profile = SecurityUserProfile.LoadFromFile(user.ProfilePath); } user.Profile.Path = user.ProfilePath; setSessionValue(SessionUser, user); //Clear previous Session variables setSessionValue(SessionNavigationContext, null); setSessionValue(SessionDashboardExecutions, null); #if NETCOREAPP user.SessionID = SessionKey; #else user.SessionID = Session.SessionID; #endif return(user); }
public async Task <IActionResult> Edit(int id, [Bind("Id,Email")] SecurityUser securityUser) { if (id != securityUser.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(securityUser); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!SecurityUserExists(securityUser.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(securityUser)); }
public async Task ShouldMarkEployeeAsInvited() { var securityUserId = Guid.NewGuid(); var securityUser = new SecurityUser { Id = securityUserId, IsInvited = false, User = new User() }; _mock.Mock <ISecurityUserProvider>() .Setup(provider => provider.GetByIdAsync(securityUserId)) .ReturnsAsync(securityUser); await _controller.SetInvitationAccepted(securityUserId); Assert.AreEqual(securityUser.IsInvitationAccepted, true); _mock.Mock <IInventContext>() .Verify(context => context.Update(securityUser), Times.Once); _mock.Mock <IInventContext>() .Verify(context => context.SaveChangesAsync(default(CancellationToken)), Times.Once); }
public MaterialPermit(Unit unit) { id = 0; this.unit = unit; docNumber = ""; docDate = DateTime.Today; person = ""; vehicleMark = ""; licensePlate = ""; createFlag = 0; creator = null; createDate = DateTime.MinValue; signedFlag = 0; signer = null; signDate = DateTime.MinValue; entryFlag = 0; entryPoint = null; entryDate = DateTime.MinValue; comment = ""; PermitId = 0; baseDocument = "доверенность"; baseDocNumber = ""; baseDocDate = DateTime.Today; IsNew = false; Insert(); }
public async Task ShouldReturnUserSettingsDTOOnGetAction() { Guid userId = Guid.NewGuid(); Guid securityUserId = Guid.NewGuid(); var securityUser = new SecurityUser { Id = securityUserId }; var expected = new UserSettingsDTO(); var controller = _mock.Create <UserSettingsController>(); _mock.Mock <IUserManager>() .Setup(manager => manager.GetUserId(controller.User)) .Returns(userId); _mock.Mock <ISecurityUserProvider>() .Setup(provider => provider.GetByUserIdAsync(userId)) .ReturnsAsync(securityUser); _mock.Mock <IMapper>() .Setup(mapper => mapper.Map <UserSettingsDTO>(securityUser)) .Returns(expected); var actual = await controller.Get(); ContentAssert.AreEqual(expected, actual); }
public GenerateTokenResult GenerateToken(SecurityUser user) { var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_jwtKey)); var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256); var claims = new[] { new Claim(JwtRegisteredClaimNames.Sub, user.UserName), new Claim(JwtRegisteredClaimNames.Email, user.Email), new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()) }; var expirationDate = DateTime.Now.AddMinutes(30); var token = new JwtSecurityToken(_jwtIssuer, _jwtAudience, claims, expires: expirationDate, signingCredentials: creds); var result = new GenerateTokenResult { Token = new JwtSecurityTokenHandler().WriteToken(token), ExpirationDate = expirationDate }; return(result); }
/// <summary> /// Tente d'authentifier l'utilisateur. /// </summary> /// <param name="username">Le nom de l'utilisateur.</param> /// <param name="password">Le mot de passe.</param> /// <param name="domain">Le domaine.</param> public async Task <(User User, bool Result)> TryLogonUser(string username, string password, string domain) { if (!_isInitialized) { throw new Exception("Contexte non initialisé"); } // Récupérer l'utilisateur en base _traceManager.TraceDebug("SecurityContext.TryLogonUser : tentative de connexion : {0}", username); User user = await _authenticationService.GetUser(username); if (user == null) { return(null, false); } _traceManager.TraceDebug("SecurityContext.TryLogonUser : utilisateur trouvé : {0}", user.Username); // Récupérer le mode d'authentification var authMode = GetAuthenticationMode(); // Authentifie l'utilisateur if (!await authMode.TryLogonUser(username, password ?? string.Empty, domain)) { return(user, false); } _traceManager.TraceDebug("SecurityContext.TryLogonUser : connexion réussie"); CurrentUser = new SecurityUser(user); return(user, true); }
public UserRolesForm(int EmployeeID) { InitializeComponent(); employeeId = EmployeeID; manager = new ContextManager(); StaffEmployeeLogic employeeLogic = new StaffEmployeeLogic(manager); StaffEmployee employee = employeeLogic.Get(EmployeeID); if (employee != null) { if (employee.UserID != null) { userId = Convert.ToInt32(employee.UserID); SecurityUsersLogic usersLogic = new SecurityUsersLogic(manager); SecurityUser user = usersLogic.Get(Convert.ToInt32(userId)); LoginL.Text = user.Login; } else { MessageBox.Show("Логін користувача відсутній"); } } LFML.Text = employee.LastName + " " + employee.FirstName + " " + employee.MiddleName; FillRoles(); }
public SecurityUser GetByUserName(string userName) { IList <SecurityUserRole> list = db.GetList <SecurityUserRole>(@"select u.user_id, u.password, u.salt, r.permission_levels from security.security_users u inner join security.user_roles ur on ur.user_id = u.user_id inner join security.roles r on ur.role_id = r.role_id where user_name = @user_name", new { user_name = userName }); SecurityUser user = null; foreach (SecurityUserRole userRole in list) { if (user == null) { user = new SecurityUser(); user.UserId = userRole.UserId; user.Password = userRole.Password; user.Salt = userRole.Salt; user.Roles = new List <string>(); } user.Roles.Add(userRole.PermissionLevels); } return(user); }
/// <summary> /// Creates the identity. /// </summary> /// <param name="securityUser">The security user.</param> /// <param name="password">The password.</param> /// <param name="principal">The principal.</param> /// <returns>Returns the created user identity.</returns> /// <exception cref="PolicyViolationException"></exception> public IIdentity CreateIdentity(SecurityUser securityUser, string password, IPrincipal principal) { var pdp = ApplicationContext.Current.GetService <IPolicyDecisionService>(); ApplicationServiceContext.Current.GetService <IPolicyEnforcementService>().Demand(PermissionPolicyIdentifiers.AccessClientAdministrativeFunction, principal); try { var conn = this.CreateConnection(); IPasswordHashingService hash = ApplicationContext.Current.GetService <IPasswordHashingService>(); using (conn.Lock()) { DbSecurityUser dbu = new DbSecurityUser() { Password = hash.ComputeHash(password), SecurityHash = Guid.NewGuid().ToString(), PhoneNumber = securityUser.PhoneNumber, Email = securityUser.Email, CreationTime = DateTime.Now, CreatedByUuid = conn.Table <DbSecurityUser>().FirstOrDefault(o => o.UserName == AuthenticationContext.Current?.Principal?.Identity?.Name)?.Uuid ?? Guid.Parse("fadca076-3690-4a6e-af9e-f1cd68e8c7e8").ToByteArray(), UserName = securityUser.UserName, Key = securityUser.Key.Value }; conn.Insert(dbu); } return(new SQLiteIdentity(securityUser.UserName, false)); } catch (Exception e) { throw new DataPersistenceException($"Error creating {securityUser}", e); } }
/// <summary> /// Remove users from roles /// </summary> public void RemoveUsersFromRoles(string[] users, string[] roles, IPrincipal authPrincipal) { this.VerifyPrincipal(authPrincipal, PermissionPolicyIdentifiers.AlterRoles); // Add users to role using (var dataContext = new Data.ModelDataContext(this.m_configuration.ReadWriteConnectionString)) { foreach (var un in users) { SecurityUser user = dataContext.SecurityUsers.SingleOrDefault(u => u.UserName == un); if (user == null) { throw new KeyNotFoundException(String.Format("Could not locate user {0}", un)); } foreach (var rol in roles) { SecurityRole role = dataContext.SecurityRoles.SingleOrDefault(r => r.Name == rol); if (role == null) { throw new KeyNotFoundException(String.Format("Could not locate role {0}", rol)); } var securityUserRole = user.SecurityUserRoles.SingleOrDefault(ur => ur.RoleId == role.RoleId && ur.UserId == user.UserId); if (securityUserRole != null) { // Remove dataContext.SecurityUserRoles.DeleteOnSubmit(securityUserRole); } } } dataContext.SubmitChanges(); } }
/// <summary> /// Adds the specified users to the specified roles /// </summary> public void AddUsersToRoles(string[] users, string[] roles, IPrincipal authPrincipal) { this.VerifyPrincipal(authPrincipal, PermissionPolicyIdentifiers.AlterRoles); // Add users to role using (var dataContext = new Data.ModelDataContext(this.m_configuration.ReadWriteConnectionString)) { foreach (var un in users) { SecurityUser user = dataContext.SecurityUsers.SingleOrDefault(u => u.UserName == un); if (user == null) { throw new KeyNotFoundException(String.Format("Could not locate user {0}", un)); } foreach (var rol in roles) { SecurityRole role = dataContext.SecurityRoles.SingleOrDefault(r => r.Name == rol); if (role == null) { throw new KeyNotFoundException(String.Format("Could not locate role {0}", rol)); } if (!user.SecurityUserRoles.Any(o => o.RoleId == role.RoleId)) { user.SecurityUserRoles.Add(new SecurityUserRole() { UserId = user.UserId, RoleId = role.RoleId }); } } } dataContext.SubmitChanges(); } }
public async Task ShouldReturnSecurityUserByUserId() { var userId = Guid.NewGuid(); var expected = new SecurityUser() { UserId = userId, }; var securityUsers = new List <SecurityUser>() { expected, new SecurityUser() { UserId = Guid.NewGuid(), } }; _mock.Mock <IInventContext>() .Setup(context => context.SecurityUsers) .ReturnsAsDbSet(securityUsers); var actual = await _provider.GetByUserIdAsync(userId); ContentAssert.AreEqual(expected, actual); }
public SecurityUserPrincipal(IIdentity identity, string[] roles, SecurityUser user) : base(identity, roles) { UserId = user.Id; FirstName = user.FirstName; LastName = user.LastName; }
public void CreateUserAndRole() { using (TestDbContextWithUsers context = new TestDbContextWithUsers()) { SecurityUser user = new SecurityUser(); SecurityRole role = new SecurityRole(); UserRole userRole = new UserRole { Role = role, User = user }; context.Add(userRole); user.Name = "Admin"; user.Password = "******"; role.Name = "AdminRole"; role.AddMemberPermission <TestDbContextWithUsers, Company>(SecurityOperation.Read, OperationState.Deny, "Description", (s, t) => t.Description == "1"); Company cmopany = new Company() { CompanyName = "1", Description = "1" }; context.Add(cmopany); context.SaveChanges(); } using (TestDbContextWithUsers context = new TestDbContextWithUsers()) { var company = context.Company.First(); Assert.AreEqual("1", company.CompanyName); Assert.AreEqual("1", company.Description); } using (TestDbContextWithUsers context = new TestDbContextWithUsers()) { context.Logon("Admin", "1"); var company = context.Company.First(); Assert.AreEqual("1", company.CompanyName); Assert.IsNull(company.Description); } }
public async Task ShouldUpdateSecurityUser() { var usertId = Guid.NewGuid(); var securityUser = new SecurityUser(); var expected = new UserSettingsDTO(); var userSettingsDTO = new UserSettingsDTO(); _mock.Mock <ISecurityUserProvider>() .Setup(provider => provider.GetByUserIdAsync(usertId)) .ReturnsAsync(securityUser); _mock.Mock <IMapper>() .Setup(mapper => mapper.Map(userSettingsDTO, securityUser)) .Returns(securityUser); _mock.Mock <IMapper>() .Setup(mapper => mapper.Map <UserSettingsDTO>(securityUser)) .Returns(expected); var actual = await _service.UpdateAsync(userSettingsDTO, usertId); _mock.Mock <IInventContext>() .Verify(context => context.Update(securityUser)); _mock.Mock <IInventContext>() .Verify(context => context.SaveChangesAsync(default(CancellationToken))); ContentAssert.AreEqual(expected, actual); }
private static void SecuritySetUp() { using (PermissionProviderContext context = new PermissionProviderContext()) { SecurityUser user = new SecurityUser() { Name = "John", Password = "******" }; SecurityUser admin = new SecurityUser() { Name = "Admin", Password = "******" }; SecurityRole roleForUser = new SecurityRole(); // "Address" member of contacts "Ezra" will be denied roleForUser.AddMemberPermission <EFCoreDemoDbContext, Contact>(SecurityOperation.Read, OperationState.Deny, "Address", (db, obj) => obj.Name == "Ezra"); // Contact "Kevin" will be denied roleForUser.AddObjectPermission <EFCoreDemoDbContext, Contact>(SecurityOperation.Read, OperationState.Deny, (db, obj) => obj.Address == "California"); admin.AddRole(new SecurityRole()); user.AddRole(roleForUser); context.Add(user); context.Add(admin); context.SaveChanges(); } }
/// <summary> /// Initialise une nouvelle instance de la classe <see cref="KsmedEntitiesExt"/>. /// </summary> public KsmedEntitiesExt(EntityConnection connection, SecurityUser user, ILocalizationManager localizationManager) : base(connection) { _currentUser = user; _localizationManager = localizationManager; ObjectMaterialized += OnObjectMaterialized; }
public static void WriteWebException(Exception ex, HttpRequestBase request, SecurityUser user) { var currentEx = ex; var message = new StringBuilder("Unexpected error\r\n\r\n"); if (user != null) { message.AppendFormat("User: '******', Groups: '{1}'\r\n", user.Name, user.SecurityGroupsDisplay); } message.AppendFormat("\r\nURL:'{0}'\r\n", request.Url.OriginalString); if (request.Form.Count > 0) { foreach (string key in request.Form.Keys) { message.AppendFormat("{0}={1}\r\n", key, request.Form[key]); } } if (request.QueryString.Count > 0) { foreach (string key in request.QueryString.Keys) { message.AppendFormat("{0}={1}\r\n", key, request.QueryString[key]); } } while (currentEx != null) { message.AppendFormat("\r\n{0}\r\n({1})\r\n", currentEx.Message, currentEx.StackTrace); currentEx = currentEx.InnerException; } Helper.WriteLogEntryWeb(EventLogEntryType.Error, message.ToString()); }
private void button32_Click(object sender, EventArgs e) { if (!textBox8.Text.Equals("") & !textBox7.Text.Equals("")) { if (textBox8.Text.Equals(textBox9.Text)) { SecurityUserInterface admin = new SecurityUser(textBox7.Text, textBox8.Text); admin.setAdmin(true); controller.initAdmin(admin); controller.initDataBase(); controller.install(); } else { string message = "Пароли не совпадают"; string caption = "Ошибка"; DialogResult result; result = MessageBox.Show(message, caption); } } else { string message = "Не все поля заполнены."; string caption = "Ошибка"; DialogResult result; result = MessageBox.Show(message, caption); } }
public ActionResult Login(string userName, string userPassword) { IUserFacade userFacade = FacadeRepository.GetUserFacade(); SecurityUser securityUser = null; try { securityUser = userFacade.Authenticate(userName, userPassword); } catch (System.Threading.ThreadAbortException se) { ViewBag.Message = se.Message; } catch (SecurityException se) { ViewBag.Message = se.Message; } catch (Exception ex) { ViewBag.Message = ex.Message; } if (securityUser != null) { SecurityManager.CurrentUser = securityUser; Session[Constants.UserID] = securityUser.UserId; Session[Constants.RoleID] = securityUser.RoleId; Session[Constants.PermissionString] = securityUser.UserPermission; Session[Constants.Name] = securityUser.Name; UserName = securityUser.Name; if (Request.QueryString["ReturnUrl"] != null) { FormsAuthentication.RedirectFromLoginPage(userName, false); } else { FormsAuthentication.SetAuthCookie(userName, false); } if (!securityUser.MustChangePassword) { return(RedirectToAction("Index", "Home")); } else { Response.Redirect("User/ChangePassword.aspx?Id=" + securityUser.UserId + "&Pass="******"&Delete=True", false); } } else { ViewBag.WrongCredentials = "Username or password is incorrect."; } return(View()); }
public bool DeleteByID(long pID) { try { if (pID > 0) { SecurityUser vSecurityUser = rep.Find(pID); if (vSecurityUser != null) { //oSecurityUser.ID = pSecurityUser.ID; //oSecurityUser.LoginName = pSecurityUser.LoginName; //oSecurityUser.Password = pSecurityUser.Password; //oSecurityUser.EmployeeCode = pSecurityUser.EmployeeCode; //oSecurityUser.EmployeeName = pSecurityUser.EmployeeName; //oSecurityUser.Remarks = pSecurityUser.Remarks; //oSecurityUser.ActiveFlag = pSecurityUser.ActiveFlag; //oSecurityUser.CreateDate = pSecurityUser.CreateDate; //oSecurityUser.CreateBy = pSecurityUser.CreateBy; //oSecurityUser.CreateTerm = pSecurityUser.CreateTerm; //oSecurityUser.DeleteFlag = pSecurityUser.DeleteFlag; //oSecurityUser.DeleteDate = pSecurityUser.DeleteDate; //oSecurityUser.DeleteBy = pSecurityUser.DeleteBy; } rep.Edit(vSecurityUser); rep.SaveChanges(); return(true); } return(false); } catch (Exception ex) { throw ex; } }
//POST: /User/Create public ActionResult Create() { SecurityUser oNew = new SecurityUser(); oNew.ActiveFlag2 = true; return(View(oNew)); }
public ActionResult Create(UserCreateViewModel model) { if (ModelState.IsValid) { var user = new SecurityUser { UserName = model.Email, Email = model.Email, FullName = model.FullName }; user.PasswordHash = UserManager.PasswordHasher.HashPassword(model.Password); DBContext.Users.Add(user); DBContext.SaveChanges(); //user.Roles.Add(DBContext) //await UserManager.SendEmailAsync(user.Id, // LocalizedStrings.Account_ConfirmYourAccount, // string.Format(LocalizedStrings.Account_ConfirmYourAccountBody, callbackUrl)); return RedirectToAction("Index"); } //AddErrors(result); return View(model); }
public object Post(Login2 request) { if (request.Username == SecurityService.Reverse(request.Password)) { var user = new SecurityUser() { Username = request.Username, EmailAddress = request.Username + "@example.local", Timezone = -6 }; return new Login2Response {LoggedInUser = user}; } else if (request.Username.StartsWith("B")) { throw new Exception("No usernames start with B"); } else { return new HttpError("Invalid username and password"); } }
public static void CreateComplexSecuritySystem() { Session session = XpoDefault.Session; SecurityRole administratorRole = session.FindObject<SecurityRole>( new BinaryOperator("Name", SecurityStrategy.AdministratorRoleName)); ModelOperationPermissionData modelPermission = new ModelOperationPermissionData(session); modelPermission.Save(); if (administratorRole == null) { administratorRole = new SecurityRole(session); administratorRole.Name = SecurityStrategy.AdministratorRoleName; administratorRole.BeginUpdate(); administratorRole.Permissions.GrantRecursive(typeof(object), SecurityOperations.Read); administratorRole.Permissions.GrantRecursive(typeof(object), SecurityOperations.Write); administratorRole.Permissions.GrantRecursive(typeof(object), SecurityOperations.Create); administratorRole.Permissions.GrantRecursive(typeof(object), SecurityOperations.Delete); administratorRole.Permissions.GrantRecursive(typeof(object), SecurityOperations.Navigate); administratorRole.EndUpdate(); administratorRole.PersistentPermissions.Add(modelPermission); administratorRole.Save(); } string adminName = "kenneth"; SecurityUser administratorUser = session.FindObject<SecurityUser>( new BinaryOperator("UserName", adminName)); if (administratorUser == null) { //administratorUser = session.CreateObject<SecurityUser>(); administratorUser = new SecurityUser(session); administratorUser.UserName = adminName; administratorUser.IsActive = true; administratorUser.SetPassword(""); administratorUser.Roles.Add(administratorRole); administratorUser.Save(); } }
public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new SecurityUser { UserName = model.Email, Email = model.Email }; //, Hometown = model.Hometown }; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { // await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false); // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771 // Send an email with this link string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id); var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code } , protocol: Request.Url.Scheme); await UserManager.SendEmailAsync(user.Id, LocalizedStrings.Account_ConfirmYourAccount, string.Format(LocalizedStrings.Account_ConfirmYourAccountBody , callbackUrl )); //return RedirectToAction("Index", "Home"); return View("DisplayEmail"); } AddErrors(result); } // If we got this far, something failed, redisplay form return View(model); }
public static void Run(IKernel kernel) { const string userLogin = "******"; //TODO: add ver var types = new List<Type> { typeof(IBaseInitializer) }; //NOTE: var assemblies = AppDomain.CurrentDomain.GetAssemblies(); foreach (var assembly in assemblies) { try { types.AddRange(assembly.GetTypes() .Where(x => typeof(IBaseInitializer).IsAssignableFrom(x))); } catch { // ignored } } var unitOfWorkFactory = kernel.Get<IUnitOfWorkFactory>(); ISecurityUser sysuser; using (var unitOfWork = unitOfWorkFactory.CreateSystem()) { var userService = kernel.Get<IUserService>(); var user = userService.GetAll(unitOfWork).FirstOrDefault(x => x.Login == userLogin); if (user == null) { user = userService.Create(unitOfWork, new User { UserCategory = new UserCategory() { Name = "DataConversion", Hidden = true, }, Login = userLogin, LastName = "DataConversion", }); } sysuser = new SecurityUser(user); } using (var unitOfWork = unitOfWorkFactory.CreateSystemTransaction()) { var appContextBootstrapper = kernel.Get<IAppContextBootstrapper>(); using (appContextBootstrapper.LocalContextSecurity(sysuser)) { foreach (var initializer in types.Distinct().Select(type => kernel.Get(type)).OfType<IBaseInitializer>()) { initializer.Init(unitOfWork); } unitOfWork.Commit(); } //appContextBootstrapper.SetSecurityUser(new SecurityUser(sysuser)); //foreach (var initializer in types.Distinct().Select(type => kernel.Get(type)).OfType<IBaseInitializer>()) //{ // initializer.Init(unitOfWork); //} //unitOfWork.Commit(); //appContextBootstrapper.RemoveSecurityUser(); } }
public IEnumerable<ClaimFinancialAmount> ReadUsersClaimPaymentAmountData(ClaimHeader claimHeader, SecurityUser user, StaticValues.AuthorisationResult authorisationResult) { ArgumentCheck.ArgumentNullCheck(claimHeader, "claimHeader"); ArgumentCheck.ArgumentNullCheck(user, "user"); ArgumentCheck.ArgumentNullCheck(authorisationResult, "authorisationResult"); if (_Logger.IsDebugEnabled) { _Logger.Debug(string.Format("ReadUsersClaimPaymentAmountData({0}, {1}, {2})", claimHeader.ClaimHeaderID, user, authorisationResult)); } var flattenedTransactions = claimHeader .GetFlattenedTransactionData() .Where(t => t.TransactionHeaderIsInProgress); var amounts = from t in flattenedTransactions where t.ClaimTransactionSource == (short)StaticValues.ClaimTransactionSource.Payment && !t.IsClaimPaymentCancelled.GetValueOrDefault(false) && t.PaymentAuthorisationStatus == (short)StaticValues.PaymentAuthorisationStatus.PaymentAuthorised && t.AuthorisationLogs.Any(a => a.ActionedByUserID == user.UserID && a.AuthorisationResult == (short)authorisationResult) && t.TransactionAmountOriginal != null select CreateClaimFinancialAmount(t); return amounts.ToList(); }
public IEnumerable<ClaimFinancialAmount> ReadUsersClaimPaymentAmountData(ClaimHeader claimHeader, SecurityUser userID, StaticValues.AuthorisationResult authorisationResult, FinancialAmountParticipationFilter filter) { throw new System.NotImplementedException(); }
public IEnumerable<ClaimFinancialAmount> ReadUsersClaimPaymentAmountData(ClaimHeader claimHeader, SecurityUser userID, StaticValues.AuthorisationResult authorisationResult, FinancialAmountParticipationFilter filter, ClaimTransactionHeader claimTransactionHeader, bool isExcludedFromCurrent = false) { throw new System.NotImplementedException(); }
private void UpdateArray(DBEntities context, SecurityUserModel model, SecurityUser target) { model.Roles = model.Roles ?? new List<Guid>(); foreach (SecurityRole item in target.SecurityRole.ToList()) { if (!model.Roles.Contains(item.Id)) target.SecurityRole.Remove(item); } foreach (SecurityRole item in context.SecurityRole.Where( s => model.Roles.Contains(s.Id)).ToList()) { if (!target.SecurityRole.Any(any => item.Id == any.Id)) target.SecurityRole.Add(item); } model.Groups = model.Groups ?? new List<Guid>(); foreach (SecurityGroup item in target.SecurityGroup.ToList()) { if (!model.Groups.Contains(item.Id)) target.SecurityGroup.Remove(item); } foreach (SecurityGroup item in context.SecurityGroup.Where( s => model.Groups.Contains(s.Id)).ToList()) { if (!target.SecurityGroup.Any(any => item.Id == any.Id)) target.SecurityGroup.Add(item); } }
public async Task<ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl) { if (User.Identity.IsAuthenticated) { return RedirectToAction("Index", "Account"); } if (ModelState.IsValid) { // Get the information about the user from the external login provider var info = await AuthenticationManager.GetExternalLoginInfoAsync(); if (info == null) { return View("ExternalLoginFailure"); } var user = new SecurityUser { UserName = model.Email, Email = model.Email, FullName = model.FullName }; var result = await UserManager.CreateAsync(user); if (result.Succeeded) { result = await UserManager.AddLoginAsync(user.Id, info.Login); if (result.Succeeded) { await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false); return RedirectToLocal(returnUrl); } } AddErrors(result); } ViewBag.ReturnUrl = returnUrl; return View(model); }
public ActionResult Edit(string id, SecurityUser editedUser) { Guid userId; if (string.IsNullOrEmpty(id) || !Guid.TryParse(id, out userId)) { return new HttpStatusCodeResult(HttpStatusCode.BadRequest); } SecurityUser user = DBContext.Users.SingleOrDefault(u => u.PublicKey == userId); if (user == null) { //return HttpNotFound(); throw new HttpException(404, "User not found."); } user.FullName = editedUser.FullName; DBContext.SaveChanges(); return RedirectToAction("Index"); // return View(editedUser); }
public ActionResult Edit(Guid id, SecurityUserModel model, string button) { CheckReadOnly(); using (DBEntities context = Settings.CreateDataContext()) { ValidateGroup(context, model); if (!ModelState.IsValid) { return View(model); } SecurityUser target = null; if (model.Id != Guid.Empty) { target = SecurityUserHelper.Get(model.Id, context); if (target == null) { ModelState.AddModelError("", Resources.Resource.RowNotFound); return View(model); } } else { target = new SecurityUser(); target.Id = Guid.NewGuid(); context.AddToSecurityUser(target); } SecurityUserModel.CreateMap(); Mapper.Map(model, target); UpdateArray(context, model, target); try { context.SaveChanges(); } catch (Exception ex) { var sb = new StringBuilder(Resources.Resource.SaveError + ": " + ex.Message); if (ex.InnerException != null) sb.AppendLine(ex.InnerException.Message); ModelState.AddModelError("", sb.ToString()); return View(model); } if (button == "SaveAndExit") return RedirectToAction("Index"); else return RedirectToAction("Edit", new { target.Id }); } }