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 });
}
}
