// PUT odata/UserClaim(5)
public virtual async Task<IHttpActionResult> Put([FromODataUri] int key, UserClaim userClaim)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
if (key != userClaim.Id)
{
return BadRequest();
}
try
{
await MainUnitOfWork.UpdateAsync(userClaim);
}
catch (DbUpdateConcurrencyException)
{
if (!MainUnitOfWork.Exists(key))
{
return NotFound();
}
else
{
return Conflict();
}
}
return Ok(userClaim);
}
protected override void AddClaim(UserClaim item)
{
var claim = new NhUserClaim();
claim.GetType().GetProperty("Type").SetValue(claim, item.Type);
claim.GetType().GetProperty("Value").SetValue(claim, item.Value);
claim.GetType().GetProperty("Account").SetValue(claim, this);
this.ClaimsCollection.Add(claim);
}
public void Ctor_InitializesNothing()
{
var entity = new UserClaim();
entity.Id.ShouldEqual(0);
entity.User.ShouldBeNull();
entity.UserId.ShouldEqual(0);
entity.ClaimType.ShouldBeNull();
entity.ClaimValue.ShouldBeNull();
}
public static UserClaim FromIUserClaim(IUserClaim i)
{
UserClaim u = new UserClaim();
u.ClaimType = i.ClaimType;
u.ClaimValue = i.ClaimValue;
u.Id = i.Id;
u.SiteId = i.SiteId;
u.UserId = i.UserId;
return u;
}
public int ReplaceClaim(User user, UserClaim claim, UserClaim newClaim)
{
return(BusinessEngine.ReplaceClaim(user, claim, newClaim));
}
protected internal void AddClaim(UserClaim item) => this.ClaimCollection.Add(item);
private async Task <bool> DoesClaimExistsForUser(UserClaim userClaim)
{
return((await _userClaimsRepository.GetAsync(x => x.UserId == userClaim.UserId && x.ClaimId == userClaim.ClaimId)) is { });
private void SeedUsers(LegatoContext context)
{
var addGuitar = new UserClaim {
ClaimName = Constants.Constants.AddGuitarClaim
};
var removeGuitar = new UserClaim {
ClaimName = Constants.Constants.RemoveGuitarClaim
};
var editGuitar = new UserClaim {
ClaimName = Constants.Constants.EditGuitarClaim
};
var changeDisplayAmount = new UserClaim {
ClaimName = Constants.Constants.ChangeDisplayAmountClaim
};
var blockUser = new UserClaim {
ClaimName = Constants.Constants.BlockUserClaim
};
var getListOfUsers = new UserClaim {
ClaimName = Constants.Constants.GetListOfUsersClaim
};
var getCompromisedAttempts = new UserClaim {
ClaimName = Constants.Constants.GetCompromisedAttemptsClaim
};
var removeCompromisedAttempts = new UserClaim {
ClaimName = Constants.Constants.RemoveCompromisedAttemptsClaim
};
var user = new UserRole {
RoleName = "User", UserClaims = new List <UserClaim>()
};
var admin = new UserRole {
RoleName = "Admin", UserClaims = new List <UserClaim> {
addGuitar, removeGuitar, editGuitar, blockUser
}
};
var superuser = new UserRole
{
RoleName = "Superuser",
UserClaims = new List <UserClaim>
{
addGuitar,
removeGuitar,
editGuitar,
blockUser,
changeDisplayAmount,
getListOfUsers,
getCompromisedAttempts,
removeCompromisedAttempts
}
};
context.UserClaims.Add(addGuitar);
context.UserClaims.Add(removeGuitar);
context.UserClaims.Add(editGuitar);
context.UserClaims.Add(changeDisplayAmount);
context.UserClaims.Add(blockUser);
context.UserClaims.Add(getListOfUsers);
context.UserClaims.Add(getCompromisedAttempts);
context.UserClaims.Add(removeCompromisedAttempts);
context.UserRoles.Add(user);
context.UserRoles.Add(admin);
context.UserRoles.Add(superuser);
string adminPassword = Hashing.HashData("admin");
string superuserPassword = Hashing.HashData("superuser");
string userPassword = Hashing.HashData("user");
context.Users.Add(new UserModel {
Username = "******", EncryptedPassword = adminPassword, IsAuthenticated = false, UserRole = admin
});
context.Users.Add(new UserModel {
Username = "******", EncryptedPassword = superuserPassword, IsAuthenticated = false, UserRole = superuser
});
context.Users.Add(new UserModel {
Username = "******", EncryptedPassword = userPassword, IsAuthenticated = false, UserRole = user
});
// seeding fake user data
for (int i = 0; i < 100; i++)
{
string password = Hashing.HashData("qwerty");
context.Users.Add(new UserModel {
Username = Guid.NewGuid().ToString().Replace("-", string.Empty).Substring(0, 8),
EncryptedPassword = password, IsAuthenticated = false, UserRole = user
});
}
}
protected internal override void AddClaim(UserClaim item)
{
ClaimCollection.Add(new RelationalUserClaim { UserAccountID = this.ID, Type = item.Type, Value = item.Value });
}
protected internal override void RemoveClaim(UserClaim item)
{
ClaimCollection.Remove(item);
}
public ActionResult RSVP()
{
var vm = new RsvpViewModel();
var identity = Thread.CurrentPrincipal as ClaimsPrincipal;
string guestCode = null;
GuestCode dbCode = null;
using (var db = new WeddingManagementContext())
{
if (identity.HasClaim(c => c.Type == "GuestCode"))
{
guestCode = identity.FindFirst("GuestCode").Value.ToUpper();
dbCode = db.GuestCodes.FirstOrDefault(gc => gc.GuestCode1.ToUpper() == guestCode);
}
else
{
int userId = User.Identity.GetUserId <int>();
UserClaim guestCodeClaim = db.Users.FirstOrDefault(u => u.Id == userId).Claims.FirstOrDefault(c => c.ClaimType == "GuestCode");
if (guestCodeClaim != null)
{
dbCode = db.GuestCodes.FirstOrDefault(gc => gc.GuestCode1.ToUpper() == guestCodeClaim.ClaimValue.ToUpper());
}
}
if (dbCode != null)
{
vm.GuestCode = dbCode.GuestCode1;
if (dbCode.GuestId != null)
{
Guest dbGuest = db.Guests.FirstOrDefault(g => g.GuestId == dbCode.GuestId);
if (dbGuest != null)
{
vm.Name = dbGuest.Name;
vm.AllowedGuests = dbGuest.MaxAllowed;
if (dbGuest.RSVPFlag)
{
vm.Attending = dbGuest.NumberAttending >= 0;
}
if (dbGuest.NumberAttending >= 0)
{
vm.NumberOfGuests = dbGuest.NumberAttending;
}
}
}
else
{
// TODO: Consider redirecting to register guest if the code isn't attached to a guest.
}
}
}
return(View(vm));
}
/// TODO: look at combining with the UserRegisteredHandler
/// <summary>
/// Automatically provisions a user.
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="userId">The user identifier.</param>
/// <param name="claims">The claims.</param>
/// <returns></returns>
public User AutoProvisionUser(string provider, string userId, List <Claim> claims)
{
// create a list of claims that we want to transfer into our store
var filtered = new List <Claim>();
foreach (var claim in claims)
{
// if the external system sends a display name - translate that to the standard OIDC name claim
if (claim.Type == ClaimTypes.Name)
{
filtered.Add(new Claim(JwtClaimTypes.Name, claim.Value));
}
// if the JWT handler has an outbound mapping to an OIDC claim use that
else if (JwtSecurityTokenHandler.DefaultOutboundClaimTypeMap.ContainsKey(claim.Type))
{
filtered.Add(new Claim(JwtSecurityTokenHandler.DefaultOutboundClaimTypeMap[claim.Type], claim.Value));
}
// copy the claim as-is
else
{
filtered.Add(claim);
}
}
// if no display name was provided, try to construct by first and/or last name
if (!filtered.Any(x => x.Type == JwtClaimTypes.Name))
{
var first = filtered.FirstOrDefault(x => x.Type == JwtClaimTypes.GivenName)?.Value;
var last = filtered.FirstOrDefault(x => x.Type == JwtClaimTypes.FamilyName)?.Value;
if (first != null && last != null)
{
filtered.Add(new Claim(JwtClaimTypes.Name, first + " " + last));
}
else if (first != null)
{
filtered.Add(new Claim(JwtClaimTypes.Name, first));
}
else if (last != null)
{
filtered.Add(new Claim(JwtClaimTypes.Name, last));
}
}
// create a new unique subject id
var sub = Guid.NewGuid();
// check if a 'upn' (User Principal Name) claim is available otherwise check if display name is available, otherwise fallback to subject id
var name = filtered.FirstOrDefault(c => c.Type == "upn")?.Value ?? filtered.FirstOrDefault(c => c.Type == JwtClaimTypes.Name)?.Value ?? sub.ToString();
// create new user
var user = new User {
UserId = sub,
Username = name,
ProviderName = provider,
ProviderSubjectId = userId,
// set to someting since values are required (TODO?)
Password = "******",
Salt = "",
EffectiveDate = DateTime.UtcNow,
UserStatus = "Active",
TermsOfUseAcceptanceDate = DateTime.UtcNow,
CreateDate = DateTime.UtcNow,
LastModifiedDate = DateTime.UtcNow
};
logger.LogInformation($"About to create new user: {name}");
using (var ctx = contextFactory.NewUserDbContext()) {
//Probably not a great way of doing this, need a user for audit fields.
var theFirstUser = ctx.Users.OrderBy(x => x.UserId).First();
user.CreateUserId = theFirstUser.UserId;
user.LastModifiedUserId = theFirstUser.UserId;
/*
* // TODO: get role(s) from groups
* var roleName = "customer";
* var role = ctx.Roles.FirstOrDefault(r => r.Name == roleName);
*
* if (role == null) {
* role = new Role {
* Name = roleName,
* Description = roleName,
* CreateDate = DateTime.UtcNow,
* LastModifiedDate = DateTime.UtcNow,
* CreateUserId = theFirstUser.UserId,
* LastModifiedUserId = theFirstUser.UserId
* };
* ctx.AddRole(role);
* }
*
* user.UserRoles = new List<UserRole> {
* new UserRole {
* User = user,
* Role = role
* }
* };
*/
user.UserClaims = new List <UserClaim>();
foreach (var c in filtered)
{
var claim = new UserClaim()
{
UserId = user.UserId,
ProviderName = provider,
Type = c.Type,
Value = c.Value
};
user.UserClaims.Add(claim);
}
ctx.AddUser(user);
ctx.SaveChanges();
}
return(user);
}
public OperationResult <UserClaim> ChangeUserClaim(int id, [FromBody] UserClaim obj) => Controller.ChangeUserClaim(obj);
//[ValidationAspect(typeof(UserClaimValidator))]
public IResult Update(UserClaim entity)
{
_userDal.Update(entity);
return(new SuccessResult(Messages.ItemUpdated));
}
protected override void RemoveClaim(UserClaim item)
{
var removed = this.ClaimsCollection.SingleOrDefault(x => x.Type == item.Type && x.Value == item.Value);
this.ClaimsCollection.Remove(removed);
}
public bool Delete(UserClaim userClaim)
{
return(this.Database.Delete <UserClaim>(userClaim));
}
public async Task <bool> InsertAsync(UserClaim userClaim)
{
var result = await this.Database.InsertAsync <UserClaim>(userClaim);
return(result);
}
public object GetByLogin(CredenciaisAcesso credenciais)
{
bool credentialsIsValid = false;
if (credenciais != null && !string.IsNullOrWhiteSpace(credenciais.Usuario))
{
baseUser = _userRepository.GetByLogin(credenciais.Usuario);
if (credenciais.TipoConcessao == "password")
{
//converte em base64
var plainTextBytes = Encoding.UTF8.GetBytes(credenciais.Senha);
string encodedText = Convert.ToBase64String(plainTextBytes);
credenciais.Senha = encodedText;
credentialsIsValid = (baseUser != null && credenciais.Usuario == baseUser.Email && credenciais.Senha == baseUser.Senha);
}
else if (credenciais.TipoConcessao == "refresh_token")
{
if (!String.IsNullOrWhiteSpace(credenciais.RefreshToken))
{
RefreshToken refreshTokenBase = _refreshTokenRepository.GetRefreshToken(baseUser.PessoaId);
DateTime expirationDate = DateTime.Parse(credenciais.Expiration);
expirationDate = expirationDate + TimeSpan.FromSeconds(_tokenConfiguration.FinalExpiration);
DateTime atual = DateTime.Now;
credentialsIsValid = (refreshTokenBase != null &&
baseUser.PessoaId == refreshTokenBase.PessoaId &&
refreshTokenBase.Token == credenciais.RefreshToken && expirationDate >= atual);
}
}
}
if (credentialsIsValid)
{
var userClaim = UserClaim.ConvertEntityToClaim(baseUser);
var identity = new ClaimsIdentity(
new GenericIdentity(userClaim.Email, "Email"),
new[]
{
new Claim(ClaimTypes.Sid, userClaim.PessoaId.ToString()),
new Claim(ClaimTypes.Name, baseUser.Nome),
new Claim(ClaimTypes.Email, userClaim.Email),
new Claim(ClaimTypes.NameIdentifier, userClaim.PessoaId.ToString())
}
);
DateTime createDate = DateTime.Now.ToUniversalTime();
DateTime expirationDate = createDate.ToUniversalTime() + TimeSpan.FromSeconds(_tokenConfiguration.Seconds);
// Calcula o tempo máximo de validade do refresh token
// (o mesmo será invalidado automaticamente pelo Redis)
TimeSpan finalExpiration = TimeSpan.FromSeconds(_tokenConfiguration.FinalExpiration);
var handler = new JwtSecurityTokenHandler();
string token = CreateToken(identity, createDate, expirationDate, handler);
return(SuccessObject(createDate, expirationDate, token, finalExpiration, baseUser.PessoaId));
}
else
{
return(ExceptionObject());
}
}
public string Encode(UserClaim userClaim)
{
var defaultExpMinutes = new TimeSpan(0, 20, 0).TotalMinutes;
return(Encode(userClaim, defaultExpMinutes));
}
public async Task <string> ExecuteAsync(UserClaim userClaim)
{
return(await Task.FromResult(this.jwtFactory.Create(userClaim)));
}
// POST odata/UserClaim
public virtual async Task<IHttpActionResult> Post(UserClaim userClaim)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
try
{
await MainUnitOfWork.InsertAsync(userClaim);
}
catch (DbUpdateException)
{
if (MainUnitOfWork.Exists(userClaim.Id))
{
return Conflict();
}
else
{
throw;
}
}
return Created(userClaim);
}
public void RemoveUserClaim(UserClaim userClaim)
{
var claim = mapper.Map <UserClaim, IdentityUserClaim <string> >(userClaim);
repositoryOfUserClaim.Delete(claim);
}
public void Add(UserClaim entity)
{
Context.Set <UserClaim>().Add(entity);
}
public void OnActionExecuting(ActionExecutingContext context)
{
var response = new ApiResponseModel();
var validations = new List <Validation>();
var AuthToken = (context.HttpContext.Request.Headers.TryGetValue("AuthToken", out var authorizationToken)) ? authorizationToken.ToString() : string.Empty;
var ip = context.HttpContext.Connection.RemoteIpAddress;
var auditLoginRepo = new AuditLoginRepository(_uow);
var currentData = new AuditLogin();
try
{
if (string.IsNullOrEmpty(AuthToken))
{
validations.Add(new Validation()
{
Key = "Token", Value = "Please send your Token to Access this resource"
});
}
else
{
var val = AuthToken.Split(".");
if (val.Length != int.Parse(_uow.GetAppSettings("SecuredTokenLength")))
{
validations.Add(new Validation()
{
Key = "Token", Value = "Incorrect Token Format"
});
}
else
{
var UserClaim = Helper.Decrypt(val[0], _uow.GetAppSettings("passPhrase"), _uow.GetAppSettings("SaltFixed"), _uow.GetAppSettings("hashAlgorithm"), int.Parse(_uow.GetAppSettings("passwordIterations")), _uow.GetAppSettings("initVector"), int.Parse(_uow.GetAppSettings("keySize")));
var UserToken = Helper.Decrypt(val[1], _uow.GetAppSettings("passPhrase"), _uow.GetAppSettings("SaltFixed"), _uow.GetAppSettings("hashAlgorithm"), int.Parse(_uow.GetAppSettings("passwordIterations")), _uow.GetAppSettings("initVector"), int.Parse(_uow.GetAppSettings("keySize")));
var IpAddress = Helper.Decrypt(val[2], _uow.GetAppSettings("passPhrase"), _uow.GetAppSettings("SaltFixed"), _uow.GetAppSettings("hashAlgorithm"), int.Parse(_uow.GetAppSettings("passwordIterations")), _uow.GetAppSettings("initVector"), int.Parse(_uow.GetAppSettings("keySize")));;
var ExecutedDate = Helper.Decrypt(val[3], _uow.GetAppSettings("passPhrase"), _uow.GetAppSettings("SaltFixed"), _uow.GetAppSettings("hashAlgorithm"), int.Parse(_uow.GetAppSettings("passwordIterations")), _uow.GetAppSettings("initVector"), int.Parse(_uow.GetAppSettings("keySize")));;
UserClaim UserClaimResult = Helper.JSONDeserialize <UserClaim>(UserClaim);
_uow.OpenConnection("dbConnection");
currentData = auditLoginRepo.ReadByLambda(x => x.UserID == UserClaimResult.UserID).FirstOrDefault();
if (currentData == null)
{
validations.Add(new Validation()
{
Key = "User", Value = "We couldnt find your user id"
});
}
else
{
if (currentData.UserKey != UserToken)
{
validations.Add(new Validation()
{
Key = "User", Value = "Incorrect User Token"
});
}
else
{
if (currentData.IPAddress != IpAddress)
{
validations.Add(new Validation()
{
Key = "User", Value = "Oooppsss another user use your user id"
});
}
else
{
if (currentData.IPAddress != ip.ToString())
{
validations.Add(new Validation()
{
Key = "User", Value = "Oooppsss there is someone on middle"
});
}
else
{
////7GgDQjrzTdLDVkw/2q6U3xYt3Kk7pKtWp1WHyMHhE3s= --> 2020-05-22 13:35:53
var date = DateTime.Parse(ExecutedDate);
}
}
}
}
}
}
response.Validations = validations;
if (response.Validations.Count > 0)
{
context.HttpContext.Response.StatusCode = (int)ResponseMessageEnum.UnAuthorized;
context.Result = ApiHelper.Response(ResponseMessageEnum.UnAuthorized, response);
}
}
catch
{
context.Result = ApiHelper.Response(ResponseMessageEnum.InternalServerError, response);
}
}
public async Task AddUserClaimAsync(UserClaim userClaim)
{
_wpbDataContext.UserClaims.Add(userClaim);
await _wpbDataContext.SaveChangesAsync();
}
public bool MockDataCreator()
{
// Note By Fernando: This is a small "hack" to avoid the system to be initialized without Test-Data (FakeData). I've created this method to
// Feed data and fill database with some tests info, that will display a better and most complete panel with some Manufacturers, Models...
// You can skip the call of this method by commenting the line on UserHandler > Handle(CreateUser)
var usersOnDb = GetUsers().ToList(); //will check if database is empty (no one user exists - first user) before run
if (usersOnDb.Count == 0)
{
var users = new User[] {
new User("Created by loadFakeData",
new Name("Admin", "SystemAdmin"),
new Document("33557788-9", "55448899"),
new Phone("3699955566", "", "", ""),
new Email("*****@*****.**"),
new Address("Street Api", "12", "Solid Village", "City of NetCore", "7788"),
new UserAccount("admin", "admin")
)
};
_context.Users.AddRange(users);
_context.SaveChanges(); //I'm calling SaveChanges each time because i need DB to generate the Guids then it will be stored here to the Fks
var manufacturers = new Manufacturer[] {
new Manufacturer("Xiaomi"),
new Manufacturer("Motorola"),
new Manufacturer("Samsung"),
new Manufacturer("LG")
};
_context.Manufacturers.AddRange(manufacturers);
_context.SaveChanges();
var deviceModels = new DeviceModel[] {
new DeviceModel("Mi Max 2", manufacturers[0]), //0
new DeviceModel("Redmi Note 10", manufacturers[0]), //1
new DeviceModel("Moto G8", manufacturers[1]), //2
new DeviceModel("Galaxy S20 Plus", manufacturers[2]), //3
new DeviceModel("Galaxy S10e", manufacturers[2]), //4
new DeviceModel("LG V60", manufacturers[3]), //5
};
_context.DeviceModels.AddRange(deviceModels);
_context.SaveChanges();
var claims = new Claim[] {
new Claim("dashboard", ""),
new Claim("manufacturer", ""),
new Claim("devicemodel", ""),
new Claim("user", ""),
new Claim("equipment", ""),
};
_context.Claims.AddRange(claims);
_context.SaveChanges();
var userClaims = new UserClaim[] {
new UserClaim(users[0], claims[0]),
new UserClaim(users[0], claims[1]),
new UserClaim(users[0], claims[2]),
new UserClaim(users[0], claims[3]),
new UserClaim(users[0], claims[4]),
};
_context.UserClaims.AddRange(userClaims);
_context.SaveChanges();
var equipments = new Equipment[] {
new Equipment("8c4997076d138ae6", "864166044650604", "864167058640512", "36-555-777", "EC:D0:8F:2F:09:D5", "25",
"Android 7.1", "5588997788234", "Android", "7.1.1", deviceModels[0], users[0]), //mimax2
new Equipment("8c4997076d138bc6", "864166044650605", "864167058640513", "36-555-778", "EC:D0:8F:2F:09:D1", "25",
"Android 7.1", "5588997788231", "Android", "7.1.1", deviceModels[1], users[0]), //note10
new Equipment("8c4997076d138bd6", "864166044650655", "864167058640556", "36-555-790", "EC:D0:8F:2F:09:D6", "27",
"Android 8.1", "5588997788333", "Android", "8.1", deviceModels[1], users[0]), //note10
new Equipment("8c4997076d138ae7", "864166044650603", "864167058640514", "36-555-779", "EC:D0:8F:2F:09:D7", "27",
"Android 8.1", "5588997788232", "Android", "8.1", deviceModels[2], users[0]), //g8
new Equipment("8c4997076d138cc7", "864166044650601", "864167058640517", "36-555-780", "EC:D0:8F:2F:09:D2", "27",
"Android 8.1", "5588997788235", "Android", "8.1", deviceModels[3], users[0]), //s20
new Equipment("8c4997076d138dc7", "864166044650608", "864167058640518", "36-555-781", "EC:D0:8F:2F:09:D3", "27",
"Android 8.1", "5588997788236", "Android", "8.1", deviceModels[4], users[0]), //ss10e
new Equipment("8c4997076d138cc7", "864166044650602", "864167058640519", "36-555-784", "EC:D0:8F:2F:09:D8", "28",
"Android 9", "5588997788245", "Android", "9", deviceModels[5], users[0]), //v60
};
_context.Equipments.AddRange(equipments);
_context.SaveChanges();
}
return(true);
}
private void OnDeleteClaimClicked(UserClaim claim)
{
Collection.Remove(claim);
HandleModificationState.EntityDeleted(claim);
}
public OperationResult <UserClaim> AddClaim(int id, [FromBody] UserClaim obj)
{
obj.UserId = id;
return(Controller.AddUserClaim(obj));
}
protected internal void RemoveClaim(UserClaim item) => this.ClaimCollection.Remove(item);
public UserClaim ChangeUserClaim(UserClaim obj)
{
return(Run(() => Change(obj)));
}
public IList <User> GetUsersForClaim(UserClaim claim)
{
return(BusinessEngine.GetUsersForClaim(claim));
}
public UserClaim AddUserClaim(UserClaim obj)
{
return(Run(() => Add(obj), saveChanges: true));
}
public bool Insert(UserClaim userClaim)
{
return(this.Database.Insert <UserClaim>(userClaim));
}
public bool HasClaim(UserClaim claim)
{
return(UserModel.Claims.Contains(claim));
}
public async Task InitializeTenant(DbContext context, Tenant tenant,
CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
var found = await context.Set <Tenant>()
.Where(e => e.Name == tenant.Name && e.HostName == e.HostName)
.FirstOrDefaultAsync(cancellationToken);
if (found == null)
{
await context.Set <Tenant>().AddAsync(tenant, cancellationToken);
//await context.SaveChangesAsync();
}
var foundId = found != null ? found.Id : tenant.Id;
var foundName = found != null ? found.Name : tenant.Name;
var hasCompany = await context.Set <Company>()
.AnyAsync(c => c.TenantId == foundId && c.Code == foundName, cancellationToken);
if (!hasCompany)
{
var company = new Company
{
Code = tenant.Name,
Name = tenant.Name,
Tenant = found != null ? found : tenant,
DateCreated = DateTime.UtcNow
};
await context.Set <Company>().AddAsync(company, cancellationToken);
//await context.SaveChangesAsync();
var passwordHasher = new PasswordHasher <User>();
var user = new User
{
Company = company,
Tenant = tenant,
Active = true,
IsSystemAdministrator = true,
UserName = "******",
NormalizedUserName = "******",
Password = "******",
NormalizedEmail = "*****@*****.**",
Email = "*****@*****.**",
RecoveryEmail = "*****@*****.**",
Deleted = false,
DateCreated = DateTime.UtcNow,
EmailConfirmed = true,
IsConfirmed = true,
SecurityStamp = Guid.NewGuid().ToString()
};
user.PasswordHash = passwordHasher.HashPassword(user, "12345678");
await context.Set <User>().AddAsync(user, cancellationToken);
var role = new Role()
{
Active = true,
Name = "Superuser",
NormalizedName = "SUPERUSER",
Company = company,
Tenant = company.Tenant
};
await context.Set <Role>().AddAsync(role, cancellationToken);
var claim = new Claim(CompanyClaimTypes.Role, role.Name);
var userClaim = new UserClaim
{
ClaimType = claim.Type,
ClaimValue = claim.Value,
User = user
};
await context.Set <UserClaim>().AddAsync(userClaim, cancellationToken);
var userRole = new UserRole
{
Role = role,
User = user
};
await context.Set <UserRole>().AddAsync(userRole, cancellationToken);
}
if (context.ChangeTracker.HasChanges())
{
await context.SaveChangesAsync(cancellationToken);
}
}
/// <summary>
/// Adds to or updates a <see cref="UserClaim"/> in a target <see cref="CategoryPolicy"/> object.
/// </summary>
/// <param name="categoryPolicy">The target <see cref="CategoryPolicy"/> object where the <see cref="UserClaim"/> needs to be updated or added into.</param>
/// <param name="policies">The list of <see cref="CategoryPolicy"/> where the target <see cref="CategoryPolicy"/> object is contained.</param>
/// <returns>The updated list of <see cref="SampleQueriesPolicies"/>
/// with the new <see cref="UserClaim"/> added or updated at the target <see cref="CategoryPolicy"/> object.</returns>
public static SampleQueriesPolicies ModifyUserClaim(SampleQueriesPolicies policies, CategoryPolicy categoryPolicy)
{
if (policies == null || policies.CategoryPolicies.Count == 0)
{
throw new ArgumentNullException(nameof(SampleQueriesPolicies), "The list of policies cannot be null or empty.");
}
if (categoryPolicy == null)
{
throw new ArgumentNullException(nameof(CategoryPolicy), "The category policy cannot be null.");
}
// Search the target category policy from the list of policies
CategoryPolicy tempCategoryPolicy = policies.CategoryPolicies.Find(x => x.CategoryName == categoryPolicy.CategoryName);
if (tempCategoryPolicy == null)
{
throw new InvalidOperationException($"The specified category policy doesn't exist: {categoryPolicy.CategoryName}");
}
// This will be used later to insert the updated category policy back into the list of policies
int tempCategoryPolicyIndex = policies.CategoryPolicies.FindIndex(x => x == tempCategoryPolicy);
// Fetch the first user claim from the argument supplied
UserClaim userClaim = categoryPolicy.UserClaims.FirstOrDefault();
if (userClaim == null)
{
throw new ArgumentNullException(nameof(CategoryPolicy), "User claim information missing.");
}
// Get the location of the provided user claim from the temp. category policy
int userClaimIndex = tempCategoryPolicy.UserClaims.FindIndex(x => x.UserPrincipalName == userClaim.UserPrincipalName);
// Add new user claim request
if (userClaimIndex < 0)
{
// Check first whether we have default user claim values in the temp. category policy
CategoryPolicy defaultCategoryPolicyTemplate = new CategoryPolicy
{
UserClaims = new List <UserClaim>()
{
new UserClaim()
}
};
if (tempCategoryPolicy.UserClaims.First().UserPrincipalName ==
defaultCategoryPolicyTemplate.UserClaims.First().UserPrincipalName)
{
/* This is the first claim for this category policy;
* clear the default user claim and add the new user claim. */
tempCategoryPolicy.UserClaims.Clear();
tempCategoryPolicy.UserClaims.Add(userClaim);
}
else // we already have other unique user claim values in this category policy
{
// Insert the new user claim info. to the end of list of user claims
tempCategoryPolicy.UserClaims.Add(userClaim);
}
}
else // Update user claim request
{
// Update the current index with new user claim info.
tempCategoryPolicy.UserClaims.Insert(userClaimIndex, userClaim);
// Delete the original user claim pushed to the next index
tempCategoryPolicy.UserClaims.RemoveAt(++userClaimIndex);
}
// Update the modified category policy back into list of policies
policies.CategoryPolicies.Insert(tempCategoryPolicyIndex, tempCategoryPolicy);
// Delete the original category policy pushed to the next index
policies.CategoryPolicies.RemoveAt(++tempCategoryPolicyIndex);
return(policies);
}
protected internal override void AddClaim(UserClaim item)
{
base.AddClaim(item);
}
public async Task <IActionResult> ManageUserClaims(string userId, int projectId)
{
Global.ProjectId = projectId;
var project = _projectRepository.GetProject(projectId);
Global.Project = project;
var uId = userManager.GetUserId(User);
var currentUser = await userManager.FindByIdAsync(uId);
var uClaims = await userManager.GetClaimsAsync(currentUser);
Global.globalCurrentUserClaims = uClaims.ToList();
var user = await userManager.FindByIdAsync(userId);
var IsManagerLevel = ClaimsLevel.IsManager(User.Claims.ToList(), projectId);
if (IsManagerLevel == false)
{
return(RedirectToAction("AccessDenied", "Account"));
}
else if (userId == userManager.GetUserId(User) || userId == project.OwnerId)
{
return(RedirectToAction("AccessDenied", "Account"));
}
if (user == null)
{
ViewBag.ErrorMessage = $"User with id {userId} doesn't exist";
return(View("NotFound"));
}
var existingUserClaims = await userManager.GetClaimsAsync(user);
//foreach(var claim in existingUserClaims)
//{
// Console.WriteLine("------");
// Console.WriteLine(claim.Type);
// Console.WriteLine(claim.Value);
//}
var viewModel = new ClaimsViewModel
{
UserId = userId,
ProjectId = projectId
};
for (var i = 0; i < ClaimsPile.AllClaims.Count; i++)
{
UserClaim userClaim = new UserClaim
{
ClaimType = ClaimsPile.AllClaims[i].Type
};
var projectList = new List <string>();
if (existingUserClaims.Count == 4)
{
projectList = existingUserClaims[i].Value.Split(" ").ToList();
}
for (int j = 0; j < projectList.Count; j++)
{
if (projectList[j] == projectId.ToString())
{
userClaim.IsSelected = true;
break;
}
}
viewModel.Claims.Add(userClaim);
}
foreach (var claim in viewModel.Claims)
{
Console.WriteLine(claim.ClaimType);
Console.WriteLine(claim.IsSelected);
}
return(View(viewModel));
}
protected internal override void AddClaim(UserClaim item)
{
ClaimCollection.Add(item);
}
public async Task OnPostAsync()
{
// Arrange
const string originalUserClaim2Type = "Claim 2 Type";
const string newUserClaim2Type = "New Claim Type";
var databaseName = $"{DatabaseNamePrefix}.{nameof(OnPostAsync)}";
var options = new DbContextOptionsBuilder <IdentityServerDbContext>()
.UseInMemoryDatabase(databaseName)
.Options;
var userClaim1 = new UserClaim
{
ClaimType = "Claim 1 Type",
ClaimValue = "Claim 1 Value"
};
var userClaim2 = new UserClaim
{
ClaimType = originalUserClaim2Type,
ClaimValue = "Claim 2 Value"
};
var userClaim3 = new UserClaim
{
ClaimType = "Claim 3 Type",
ClaimValue = "Claim 3 Value"
};
var userClaim4 = new UserClaim
{
ClaimType = "Claim 4 Type",
ClaimValue = "Claim 4 Value"
};
var user = new User
{
Email = "Email"
};
user.Claims.Add(userClaim1);
user.Claims.Add(userClaim2);
user.Claims.Add(userClaim3);
using (var context = new IdentityServerDbContext(options, _configurationStoreOptions.Object, _operationalStoreOptions.Object))
{
context.Add(user);
await context.SaveChangesAsync().ConfigureAwait(false);
}
IActionResult post;
// Act
using (var context = new IdentityServerDbContext(options, _configurationStoreOptions.Object, _operationalStoreOptions.Object))
{
_userManager.Setup(x => x.Users).Returns(context.Users);
var model = new ClaimsModel(_userManager.Object)
{
UserModel = user
};
model.UserModel.Claims.Single(x => x.ClaimType.Equals(userClaim2.ClaimType)).ClaimType = newUserClaim2Type;
model.UserModel.Claims.Remove(userClaim3);
model.UserModel.Claims.Add(userClaim4);
post = await model.OnPostAsync().ConfigureAwait(false);
}
// Assert
_userManager.Verify(x => x.ReplaceClaimAsync(
It.Is <User>(y => y.Id.Equals(user.Id)),
It.Is <Claim>(y => y.Type.Equals(userClaim1.ClaimType) && y.Value.Equals(userClaim1.ClaimValue)),
It.IsAny <Claim>()),
Times.Never);
_userManager.Verify(x => x.ReplaceClaimAsync(
It.Is <User>(y => y.Id.Equals(user.Id)),
It.Is <Claim>(y => y.Type.Equals(originalUserClaim2Type) && y.Value.Equals(userClaim2.ClaimValue)),
It.Is <Claim>(y => y.Type.Equals(newUserClaim2Type) && y.Value.Equals(userClaim2.ClaimValue))),
Times.Once);
_userManager.Verify(
x => x.AddClaimsAsync(
It.Is <User>(y => y.Id.Equals(user.Id)),
It.Is <IEnumerable <Claim> >(y => y.SingleOrDefault(z => z.Type.Equals(userClaim4.ClaimType) && z.Value.Equals(userClaim4.ClaimValue)) != null)),
Times.Once);
_userManager.Verify(
x => x.RemoveClaimsAsync(
It.Is <User>(y => y.Id.Equals(user.Id)),
It.Is <IEnumerable <Claim> >(y => y.SingleOrDefault(z => z.Type.Equals(userClaim3.ClaimType) && z.Value.Equals(userClaim3.ClaimValue)) != null)),
Times.Once);
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("../Details/Claims", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(User.Id), key);
Assert.Equal(user.Id, value);
});
}
protected internal override void AddClaim(UserClaim item)
{
ClaimCollection.Add(new RelationalUserClaimInt {
UserAccountID = this.Key, Type = item.Type, Value = item.Value
});
}
protected internal override void RemoveClaim(UserClaim item)
{
ClaimCollection.Remove((RelationalUserClaimInt)item);
}
