public AddUserToMessageMetadataStep(
IIdentityContext identityContext,
ILogger <AddUserToMessageMetadataStep> logger)
{
_identityContext = identityContext;
_logger = logger;
}
public ExtractTenantFromMessageMetadataStep(
IIdentityContext identityContext,
ILogger <ExtractTenantFromMessageMetadataStep> logger)
{
_identityContext = identityContext;
_logger = logger;
}
public Handler(
IIdentityContext identityContext,
IMapping mapper,
IMessageBus busPublisher) : base(identityContext, mapper)
{
_busPublisher = busPublisher;
}
public UserProfileController(IUserManager <GearUser> userManager, IIdentityContext identityContext, IProfileContext profileContext, ICountryService countryService)
{
_userManager = userManager;
_identityContext = identityContext;
_profileContext = profileContext;
_countryService = countryService;
}
public NotificationService(
IHubContext <NotificationHub> hubContext,
IIdentityContext identityContext)
{
_hubContext = hubContext;
_identityContext = identityContext;
}
public Handler(
IIdentityContext identityContext,
IMapping mapper,
IMessageBus messageBus) : base(identityContext, mapper)
{
_messageBus = messageBus;
}
private static void ConfigureContainer(
ConfigurationExpression container,
IDataSettings dataSettings,
IIdentityContext identityContext)
{
container.AddRegistry(new PawPawRegistry(dataSettings, identityContext));
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, IIdentityContext identityContext, RoleManager <IdentityRole> _roleManager, UserManager <Usuario> _userManager)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseDatabaseErrorPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseCookiePolicy();
app.UseAuthentication();
ConfigureDataBase(identityContext, _roleManager, _userManager);
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
public IdentityUserManager(UserManager <GearUser> userManager, IHttpContextAccessor httpContextAccessor, RoleManager <GearRole> roleManager, IIdentityContext identityContext)
{
UserManager = userManager;
_httpContextAccessor = httpContextAccessor;
RoleManager = roleManager;
IdentityContext = identityContext;
}
public GearWebInstallerService(INotify <GearRole> notify, IPermissionService permissionService, SignInManager <GearUser> signInManager, IIdentityContext applicationDbContext, IHostingEnvironment hostingEnvironment)
{
_notify = notify;
_permissionService = permissionService;
_signInManager = signInManager;
_applicationDbContext = applicationDbContext;
_hostingEnvironment = hostingEnvironment;
}
public IdentityUserManager(UserManager <GearUser> userManager, IHttpContextAccessor httpContextAccessor, RoleManager <GearRole> roleManager, IIdentityContext identityContext, ICommunicationHub hub)
{
UserManager = userManager;
_httpContextAccessor = httpContextAccessor;
RoleManager = roleManager;
IdentityContext = identityContext;
_hub = hub;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="context"></param>
/// <param name="logger"></param>
/// <param name="applicationDbContext"></param>
/// <param name="processParser"></param>
public ProcessController(IProcessesDbContext context,
ILogger <ProcessController> logger, IIdentityContext applicationDbContext, IProcessParser processParser)
{
Context = context;
_logger = logger;
_applicationDbContext = applicationDbContext;
_processParser = processParser;
}
public UniqueUsernameValidator(
ICredentialRequirmentValidator credentialValidator,
IIdentityContext identityContext)
{
RuleFor(model => model)
.MustAsync(async(model, token) => !await identityContext.UsernameExists(model))
.WithMessage((model, value) => $"Username: {value} is not available");
}
public ApplicationDbContext(
IOptions <OperationalStoreOptions> operationalStoreOptions,
DbContextOptions <ApplicationDbContext> options,
IIdentityContext identityContext) : base(options)
{
_operationalStoreOptions = operationalStoreOptions;
_identityContext = identityContext;
}
/// <summary>
/// Constructor of service for managing user accounts.
/// </summary>
/// <param name="identityContext">Identity service.</param>
/// <param name="mapper">Mapping service.</param>
/// <param name="appSettings">Application settings.</param>
/// <exception cref="ArgumentNullException"></exception>
public AccountService(IIdentityContext identityContext,
IMapper mapper,
IOptions <AppSettings> appSettings)
{
_identityContext = identityContext ?? throw new ArgumentNullException(nameof(identityContext));
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
_appSettings = appSettings.Value ?? throw new ArgumentNullException(nameof(appSettings));
}
public Validator(ICredentialRequirmentValidator validator, IIdentityContext context)
{
RuleFor(model => model.NewPassword).Password(validator);
RuleFor(model => model.Username).ExistingUsername(validator, context);
RuleFor(model => model.NewUsername).UniqueUsername(validator, context);
}
public ExistingUsernameValidator(
ICredentialRequirmentValidator credentialRequirmentValidator,
IIdentityContext identityContext)
{
RuleFor(model => model)
.MustAsync(async(model, token) => await identityContext.UsernameExists(model))
.WithMessage((model, value) => $"Username {value} doesn't exists");
}
public static void ConfigureContainer(
IDataSettings dataSettings,
IIdentityContext identityContext)
{
var container = ObjectFactory.Container;
container.Configure(expression =>
ConfigureContainer(expression, dataSettings, identityContext));
}
public static HttpConfiguration Configure(
HttpConfiguration config,
IDataSettings dataSettings,
IIdentityContext identityContext)
{
PawPawWebDependencyResolverModule.ConfigureContainer(dataSettings, identityContext);
Register(config);
return(config);
}
/// <summary>
/// Seed application context.
/// </summary>
/// <param name="context">Application context.</param>
public static async Task SeedAsync(IIdentityContext context)
{
if (!context.Accounts.Any())
{
await context.Accounts.AddRangeAsync(GetPreconfiguredAccountModels());
await context.SaveChangesAsync(new CancellationToken());
}
}
public async Task <Habit> SaveHabit(
[Service] IHabitsService habits,
[Service] IUsersService users,
[Service] IIdentityContext identity,
HabitInput input)
{
await users.EnsureCreated(identity.UserId);
return(Habit.FromDomain(await habits.SaveHabit(HabitInput.ToDomain(input, identity.UserId))));
}
/// <summary>
/// Constructor of service for managing user accounts.
/// </summary>
/// <param name="identityContext">Identity service.</param>
/// <param name="mapper">Mapping service.</param>
/// <param name="appSettings">Application settings.</param>
/// <param name="accountDeletedEventProducer">Producer of account deletion event.</param>
/// <exception cref="ArgumentNullException"></exception>
public AccountService(IIdentityContext identityContext,
IMapper mapper,
IOptions <AppSettings> appSettings,
IEventProducer <IAccountDeleted, Guid> accountDeletedEventProducer)
{
_identityContext = identityContext ?? throw new ArgumentNullException(nameof(identityContext));
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
_appSettings = appSettings.Value ?? throw new ArgumentNullException(nameof(appSettings));
_accountDeletedEventProducer = accountDeletedEventProducer ?? throw new ArgumentNullException(nameof(accountDeletedEventProducer));
}
public NotifyExpenseRemovedCommandHandler(
IIdentityContext identityContext,
ILogger <NotifyExpenseRemovedCommandHandler> logger,
INotificationService notificationService,
OperationContext operationContext)
{
_identityContext = identityContext;
_logger = logger;
_notificationService = notificationService;
_operationContext = operationContext;
}
public NotifyExpenseAddedCommandHandler(
IIdentityContext identityContext,
ILogger <NotifyExpenseAddedCommandHandler> logger,
INotificationService notificationService,
IEventsPublisher eventsPublisher)
{
_identityContext = identityContext;
_logger = logger;
_notificationService = notificationService;
_eventsPublisher = eventsPublisher;
}
public static void UniqueUsername <TRequest>(
this IRuleBuilderInitial <TRequest, string> builder,
ICredentialRequirmentValidator validator,
IIdentityContext context)
{
builder
.Cascade(CascadeMode.StopOnFirstFailure)
.NotEmpty()
.SetValidator(new UsernameRequirmentValidator(validator))
.SetValidator(new UniqueUsernameValidator(validator, context));
}
public UsersController(UserManager <GearUser> userManager, RoleManager <GearRole> roleManager,
BaseLdapUserManager <LdapUser> ldapUserManager,
ILogger <UsersController> logger, IStringLocalizer localizer, IIdentityContext identityContext, IUserManager <GearUser> customUserManager)
{
_userManager = userManager;
_roleManager = roleManager;
_ldapUserManager = ldapUserManager;
Logger = logger;
_localizer = localizer;
_identityContext = identityContext;
_customUserManager = customUserManager;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="context"></param>
/// <param name="userManager"></param>
/// <param name="httpContextAccessor"></param>
/// <param name="emailSender"></param>
/// <param name="urlHelper"></param>
/// <param name="localizer"></param>
/// <param name="hub"></param>
/// <param name="countryService"></param>
public OrganizationService(IIdentityContext context, IUserManager <GearUser> userManager, IHttpContextAccessor httpContextAccessor,
IEmailSender emailSender, IUrlHelper urlHelper, IStringLocalizer localizer, ICommunicationHub hub, ICountryService countryService)
{
_context = context;
_userManager = userManager;
_httpContextAccessor = httpContextAccessor;
_emailSender = emailSender;
_urlHelper = urlHelper;
_localizer = localizer;
_hub = hub;
_countryService = countryService;
}
public RolesController(SignInManager <GearUser> signInManager, ILogger <RolesController> logger, IPermissionService permissionService, IClientsContext configurationDbContext, IIdentityContext applicationDbContext, RoleManager <GearRole> roleManager, IUserManager <GearUser> userManager, INotify <GearRole> notify, IPermissionsContext permissionsContext)
{
_signInManager = signInManager;
_logger = logger;
_permissionService = permissionService;
ConfigurationDbContext = configurationDbContext;
_applicationDbContext = applicationDbContext;
_roleManager = roleManager;
_userManager = userManager;
_notify = notify;
_permissionsContext = permissionsContext;
}
public ExpensesDbContext(
DbContextOptions options,
IIdentityContext identityContext)
: base(options)
{
Tenant = identityContext.TenantId !.Value;
UserId = identityContext.UserId;
Expenses = Set <Expense>();
ExpenseItems = Set <Expense>();
Campaigns = Set <Campaign>();
CampaignsView = Set <CampaignVm>();
}
private static void SetTenantFor(IIdentityContext identityContext, HttpContext httpContext)
{
var tenantId = TenantResolver.Resolver(httpContext);
if (!identityContext.HasAssociatedTenant && !string.IsNullOrEmpty(tenantId))
{
identityContext.SetCurrentTenant(long.Parse(tenantId));
}
else
{
throw new Exception("Tenant cannot be identified");
}
}
