public User DecorateUser(User user)
{
IUserBuilder buildUser = null;
if (_deviceName != null)
{
if (buildUser is null)
{
buildUser = User.Builder(user);
}
buildUser.Custom("device", _deviceName);
}
if (_osName != null)
{
if (buildUser is null)
{
buildUser = User.Builder(user);
}
buildUser.Custom("os", _osName);
}
// If you pass in a user with a null or blank key, one will be assigned to them.
if (String.IsNullOrEmpty(user.Key))
{
if (buildUser is null)
{
buildUser = User.Builder(user);
}
var anonUserKey = GetOrCreateAnonUserKey();
buildUser.Key(anonUserKey).Anonymous(true);
}
return(buildUser is null ? user : buildUser.Build());
}
public CreateUserCommandHandler(
IUserBuilder userBuilder,
IEntityRepository <User> userRepository)
{
this.userBuilder = userBuilder;
this.userRepository = userRepository;
}
User DecorateUser(User user)
{
IUserBuilder buildUser = null;
if (UserMetadata.DeviceName != null)
{
if (buildUser is null)
{
buildUser = User.Builder(user);
}
buildUser.Custom("device", UserMetadata.DeviceName);
}
if (UserMetadata.OSName != null)
{
if (buildUser is null)
{
buildUser = User.Builder(user);
}
buildUser.Custom("os", UserMetadata.OSName);
}
// If you pass in a user with a null or blank key, one will be assigned to them.
if (String.IsNullOrEmpty(user.Key))
{
if (buildUser is null)
{
buildUser = User.Builder(user);
}
buildUser.Key(deviceInfo.UniqueDeviceId()).Anonymous(true);
}
return(buildUser is null ? user : buildUser.Build());
}
public bool AddUser(IUserBuilder userBuilder)
{
_user = userBuilder.Build();
AddUserToDb(_user);
return(true);
}
public void Setup()
{
cardBuilder = new CreditCardBuilder();
walletBuilder = new WalletBuilder(cardBuilder);
userBuilder = new UserBuilder(walletBuilder);
sut = new Users(userBuilder);
}
public UserAppService(IDataService <User> userDataService,
IUserDtoBuilder userDtoBuilder,
IUserBuilder userBuilder)
{
this.userDataService = userDataService;
this.userDtoBuilder = userDtoBuilder;
this.userBuilder = userBuilder;
}
public UserController(
IUserBuilder userBuilder,
IUserEditor userEditor
)
{
_userBuilder = userBuilder;
_userEditor = userEditor;
}
public override void InjectAttributes(ref IUserBuilder userBuilder)
{
if (classType != ClassType.Unset)
{
userBuilder.Custom("class-type", classType.ToString());
}
else
{
userBuilder.Custom("class-type", "");
}
}
public static IUserBuilder GetAdditionalPolicies(IServiceProvider services, Func <AdditionalPoliciesCallbackArgs, IUserBuilder> additionalPoliciesCallback)
{
IUserBuilder additionalPolicies = null;
if (additionalPoliciesCallback != null)
{
additionalPolicies = additionalPoliciesCallback(new AdditionalPoliciesCallbackArgs(services));
}
return(additionalPolicies);
}
public AuthController(
IUnitOfWork unitOfWork,
IUserBuilder userBuilder,
ITokenGenerator tokenGenerator,
IPasswordHasher passwordHasher)
{
_unitOfWork = unitOfWork;
_userBuilder = userBuilder;
_tokenGenerator = tokenGenerator;
_passwordHasher = passwordHasher;
}
public static IUserBuilder GetPrefixPolicies(IServiceProvider services, IUserBuilder builder, UserBuilderOptions options)
{
if (options.UseClaimsCache)
{
builder = new CachedClaimsUserBuilder(services.GetRequiredService <IClaimCache>(), builder);
}
if (options.ConfigurePrefixPolicies != null)
{
builder = options.ConfigurePrefixPolicies(new PrefixPoliciesCallbackArgs(services, builder));
}
return(builder);
}
public AnimalAppService(IDataService <Animal> animalDataService,
IAnimalDtoBuilder animalDtoBuilder,
IAnimalBuilder animalBuilder,
IFileStorageService fileStorageService,
IFileBuilder fileBuilder,
IAnimalSpecificationBuilder animalSpecificationBuilder, IUserBuilder userBuilder)
{
this.animalDataService = animalDataService;
this.animalDtoBuilder = animalDtoBuilder;
this.animalBuilder = animalBuilder;
this.fileStorageService = fileStorageService;
this.fileBuilder = fileBuilder;
this.animalSpecificationBuilder = animalSpecificationBuilder;
this.userBuilder = userBuilder;
}
/// <summary>
/// Make the IUserBuilder policy one that needs whitelisted users and assignes them roles.
/// Be sure you have added an IUserBuilder to the services if using this mode.
/// </summary>
/// <param name="services">The service collection to add to.</param>
/// <param name="optionsCallback">Configure options.</param>
/// <returns>The service collection.</returns>
public static IServiceCollection AddUserBuilderForUserWhitelistWithRoles(this IServiceCollection services, Action <UserBuilderOptions> optionsCallback = null)
{
var options = new UserBuilderOptions();
optionsCallback?.Invoke(options);
services.AddSingleton <IClaimCache>(s => new ClaimCache(options.CacheClaimTypes));
services.AddScoped(s =>
{
var usersRepo = s.GetRequiredService <IUsersRepository>();
var loggerFactory = s.GetRequiredService <ILoggerFactory>();
var log = loggerFactory.CreateLogger("Authentication");
IUserBuilder builder = GetAdditionalPolicies(s, options.ConfigureAddititionalPolicies);
builder = new UserRoleBuilder(usersRepo, log, builder);
builder = new UserWhitelistAuthorizer(usersRepo, log, builder);
builder = GetPrefixPolicies(s, builder, options);
return(builder);
});
return(services);
}
public UserBuilder(string userType)
{
switch (userType.ToLower())
{
case "cardriver":
userBuilder = new CarDriverBuilder();
break;
case "motodriver":
userBuilder = new MotoDriverBuilder();
break;
case "admin":
userBuilder = new AdminBuilder();
break;
case "saler":
userBuilder = new CoperatorBuilder();
break;
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="next">The next item in the chain.</param>
public UserAuthorizerBuilderLink(IUserBuilder next)
{
this.Next = next;
}
public HypermediaUserBuilder(String entryPoint, ILoggerFactory loggerFactory, IUserBuilder next = null)
: base(next)
{
this.entryPoint = entryPoint;
this.loggerFactory = loggerFactory;
}
public CachedClaimsUserBuilder(IClaimCache claimCache, IUserBuilder next)
: base(next)
{
this.claimCache = claimCache;
}
public UserService(IUserBuilder builder, IUserRepository repository, IRoleRepository roleRepository)
{
this.builder = builder;
this.repository = repository;
this.roleRepository = roleRepository;
}
public override void InjectAttributes(ref IUserBuilder userBuilder)
{
userBuilder.Custom("level-id", SceneManager.GetActiveScene().buildIndex);
userBuilder.Custom("level-name", levelName);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="userBuilder">The User Builder Helper class.</param>
public Users(IUserBuilder userBuilder)
{
this.userBuilder = userBuilder;
People = new List <IUser>();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="next">The next policy</param>
public AllAccessAuthorizer(IUserBuilder next = null)
: base(next)
{
}
public UserService(IUserRepository <User> userRepository, IUserBuilder <User> userBuilder)
{
_userRepository = userRepository;
_userBuilder = userBuilder;
}
public UserService(DemoContext context, IUserBuilder userBuilder)
{
_context = context;
_userBuilder = userBuilder;
_context.Configuration.LazyLoadingEnabled = false;
}
public PrefixPoliciesCallbackArgs(IServiceProvider services, IUserBuilder next)
{
this.Services = services;
this.Next = next;
}
public AuthenticationService(IOptions <AppSettings> appSettings, IUserRepository <User> userRepository, IUserBuilder <User> userBuilder)
{
_appSettings = appSettings.Value;
_userRepository = userRepository;
_userBuilder = userBuilder;
}
public UserRoleBuilder(IUsersRepository userRepo, ILogger log, IUserBuilder next = null)
: base(next)
{
this.userRepo = userRepo;
this.log = log;
}
public override void InjectAttributes(ref IUserBuilder userBuilder)
{
if (email.isSet)
{
if (email.isPrivate)
{
userBuilder.Email(email.value).AsPrivateAttribute();
}
else
{
userBuilder.Email(email.value);
}
}
if (fullName.isSet)
{
if (fullName.isPrivate)
{
userBuilder.Name(fullName.value).AsPrivateAttribute();
}
else
{
userBuilder.Name(fullName.value);
}
}
if (firstName.isSet)
{
if (firstName.isPrivate)
{
userBuilder.FirstName(firstName.value).AsPrivateAttribute();
}
else
{
userBuilder.FirstName(firstName.value);
}
}
if (lastName.isSet)
{
if (lastName.isPrivate)
{
userBuilder.LastName(lastName.value).AsPrivateAttribute();
}
else
{
userBuilder.LastName(lastName.value);
}
}
if (country.isSet)
{
if (country.isPrivate)
{
userBuilder.Country(country.value).AsPrivateAttribute();
}
else
{
userBuilder.Country(country.value);
}
}
if (ipAddress.isSet)
{
if (ipAddress.isPrivate)
{
userBuilder.IPAddress(ipAddress.value).AsPrivateAttribute();
}
else
{
userBuilder.IPAddress(ipAddress.value);
}
}
if (avatar.isSet)
{
if (avatar.isPrivate)
{
userBuilder.Avatar(avatar.value).AsPrivateAttribute();
}
else
{
userBuilder.Avatar(avatar.value);
}
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="claimValue">The claim value to lookup to consider the user valid.</param>
/// <param name="next">The next user builder in the chain.</param>
public AccessClaimAuthorizer(String claimValue, IUserBuilder next = null)
: base(next)
{
this.claimValue = claimValue;
}
public abstract void InjectAttributes(ref IUserBuilder userBuilder);
public UserBuilder(IUserBuilder builder)
{
userBuilder = builder;
}
