public AccountController(IDbConnection db, IMetricTracker metrics, ICacheClient cache, IMailController mailController, IUserService userService, IUserAuthenticationService authenticationService)
: base(db, metrics, cache)
{
_mailController = mailController;
_userService = userService;
_authenticationService = authenticationService;
}
public AuthenticationController(IUserService userService, IUserAuthenticationService service,
IAuditingService audit)
{
_service = service;
_userService = userService;
_audit = audit;
}
public AccountController(IMappingService mappingService,
IUserAuthenticationService userAuthenticationService,
IUserService userService) : base(mappingService)
{
authenticationService = userAuthenticationService;
this.userService = userService;
}
public AccountDetailPageVM(INavigationService navService, IPageDialogService pageDialogService, IEventAggregator eventAggregator, IUserAuthenticationService userService)
: base(navService)
{
_pageDialogService = pageDialogService;
_eventAggregator = eventAggregator;
_userService = userService;
}
public void TryAuthenticate()
{
Throw <ArgumentNullException> .If.IsNull(LoginString)?.Now(nameof(LoginString), $"{nameof(LoginString)} cannot be null.");
Throw <ArgumentNullException> .If.IsNull(Password)?.Now(nameof(Password), $"{nameof(Password)} cannot be null.");
IUserAuthenticationService service = authServiceFactory.Create(AuthenticationType, new AuthenticationDetails(LoginString, Password));
Throw <ArgumentNullException> .If.IsNull(service)?.Now(nameof(service), $"{authServiceFactory} produced a null auth service.");
try
{
IAuthToken token = service.TryAuthenticate();
if (token == null || !token.isValid)
{
OnInvalidAuthToken?.Invoke(token);
}
OnValidAuthToken?.Invoke(token);
}
catch (ServerLoginException e)
{
OnAuthServerError?.Invoke(e.Message);
}
}
public LoginCredentialsValidator(IUserAuthenticationService userAuthenticationService)
{
_userAuthenticationService = userAuthenticationService;
RuleFor(x => x.EmailAddress)
.NotEmpty()
.WithMessage("Email address is required");
RuleFor(x => x.Password)
.NotEmpty()
.WithMessage("Password is required");
When(x => !string.IsNullOrEmpty(x.EmailAddress), () => {
RuleFor(x => x)
.NotEmpty()
.MustAsync(AuthenticateEmailAddress)
.WithMessage("User not found for the given email address");
});
When(x => !string.IsNullOrEmpty(x.EmailAddress) && !string.IsNullOrEmpty(x.Password), () => {
RuleFor(x => x)
.NotEmpty()
.MustAsync(AuthenticatePassword)
.WithMessage("Password is invalid for the given email address");
});
}
public EmployeeController(IUserAuthenticationService auth,
IEmployeePaymentService empPayService,
IListingService listingService) : base(auth)
{
EmployeePaymentService = empPayService;
ListingService = listingService;
}
/// <summary>
/// Initializes a new instance of the <see cref="Functions"/> class.
/// </summary>
/// <param name="userAuthenticationService">The user authentication service to use to identify the calling user.</param>
/// <param name="blobRepository">The blob respository to use for storing audio files.</param>
public Functions(
IUserAuthenticationService userAuthenticationService,
IBlobRepository blobRepository)
{
this.UserAuthenticationService = userAuthenticationService;
this.BlobRepository = blobRepository;
}
public DebugTestJob(IUserContextManager userContextManager,
IUserAuthenticationService userAuthenticationService,
IUserAuthorizationService userAuthorizationService,
IJobExecutionObserver jobExecutionObserver)
: base(userContextManager, userAuthenticationService, userAuthorizationService, jobExecutionObserver)
{
}
public CheckedOutPageVM(INavigationService navigationService, IUserAuthenticationService userService, IEventAggregator aggregator, IWcclsApiService apiService)
: base(navigationService)
{
_userService = userService;
_eventAggregator = aggregator;
_apiService = apiService;
_eventAggregator.GetEvent <AccountsChangedEvent>().Subscribe(() => {
int countOld = _listUsersCur.Count;
_listUsersCur = _userService
.GetLoggedInUsers()
.OrderBy(x => x.Nickname)
.ToList();
//They changed the number of users.
if (countOld != _listUsersCur.Count)
{
//They may have gone from having no users to one or more or visa versa
RaisePropertyChanged(() => IsUserLoggedIn);
TaskUtils.FireAndForget(RefreshCheckOuts);
}
}, ThreadOption.UIThread);
_listUsersCur = _userService
.GetLoggedInUsers()
.OrderBy(x => x.Nickname)
.ToList();
}
/// <summary>
/// Initializes a new instance of the <see cref="ApiFunctions"/> class.
/// </summary>
/// <param name="categoriesService">The categories services to use.</param>
/// <param name="userAuthentication">The user authentication service to use.</param>
public ApiFunctions(
ICategoriesService categoriesService,
IUserAuthenticationService userAuthentication)
{
this.CategoriesService = categoriesService;
this.UserAuthenticationService = userAuthentication;
}
private void attachUserToContext(HttpContext context, IUserAuthenticationService userService, string token)
{
try
{
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Jwt.Secret);
tokenHandler.ValidateToken(token, new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(key),
ValidateIssuer = false,
ValidateAudience = false,
// set clockskew to zero so tokens expire exactly at token expiration time (instead of 5 minutes later)
ClockSkew = TimeSpan.Zero
}, out SecurityToken validatedToken);
var jwtToken = (JwtSecurityToken)validatedToken;
var userId = int.Parse(jwtToken.Claims.First(x => x.Type == "userid").Value);
var userLogin = JsonSerializer.Deserialize <User>(jwtToken.Claims.First(x => x.Type == "userdata").Value);
// attach user to context on successful jwt validation
context.Items["UserLogin"] = userLogin;//userService.GetById(userId);
}
catch
{
// do nothing if jwt validation fails
// user is not attached to context so request won't have access to secure routes
}
}
public AddUserVM(INavigationService navigationService, IWcclsApiService apiService, IPageDialogService pageDialogService, IUserAuthenticationService userService)
: base(navigationService)
{
_apiService = apiService;
_pageDialogService = pageDialogService;
_userService = userService;
}
public DebugTestJob(IUserContextManager userContextManager,
IUserAuthenticationService userAuthenticationService,
IUserAuthorizationService userAuthorizationService,
ITracer tracer)
: base(userContextManager, userAuthenticationService, userAuthorizationService, tracer)
{
}
public Functions(
IUserAuthenticationService userAuthenticationService,
IHealthService healthService)
{
this.UserAuthenticationService = userAuthenticationService;
this.HealthService = healthService;
}
public AccountController(IUserService userService, IUserAuthenticationService authService, IMailService mailService, IFormsAuthenticationAdapter adapter)
{
_userService = userService;
_authService = authService;
_mailService = mailService;
_adapter = adapter;
}
public AccountController(
IUserService userService,
ILocalizationService <UserResource> localizer, IUserAuthenticationService authenticationService)
{
_userService = userService;
_localizer = localizer;
_authenticationService = authenticationService;
}
public AppStartupController(IHubRegistrationService hubRegistrationService,
IUserAuthenticationService userAuthenticationService,
IOptionsMonitor <Auth0Config> auth0ConfigAccessor)
{
_hubRegistrationService = hubRegistrationService;
_userAuthenticationService = userAuthenticationService;
_auth0ConfigAccessor = auth0ConfigAccessor;
}
public WebWorkContext(
IHttpContextAccessor httpContextAccessor,
IUserAuthenticationService authenticationService)
{
this._httpContextAccessor = httpContextAccessor;
this._authenticationService = authenticationService;
GID = Guid.NewGuid();
}
public AuthenticationController(IMapper mapper,
IUserAuthenticationService authService,
IPasswordRecoveryService passwordRecoveryService)
: base(mapper)
{
_authService = authService;
_passwordRecoveryService = passwordRecoveryService;
}
public Handler(
IUserAuthenticationService userAuthenticationService,
IUserRepository repository
)
{
_userAuthenticationService = userAuthenticationService;
_repository = repository;
}
public WopiRequestHandlerFactory(IUserAuthenticationService userAuthenticationService, IUserFileMetadataProvider userFileMetadataProvider, IOptionsSnapshot <Features> features, ILogger <WopiRequestHandlerFactory>?logger = default)
{
_userAuthenticationService = userAuthenticationService ?? throw new ArgumentNullException(nameof(userAuthenticationService));
_userFileMetadataProvider = userFileMetadataProvider ?? throw new ArgumentNullException(nameof(userFileMetadataProvider));
_features = features?.Value ?? throw new ArgumentNullException(nameof(features));
_logger = logger;
}
public DomainUserService(IUserAuthenticationService domainService)
{
if (domainService == null)
{
throw new ArgumentNullException(nameof(domainService));
}
this.domainService = domainService;
}
/// <summary>
/// Initializes a new instance of the <see cref="WorkerApiFunctions"/> class.
/// </summary>
/// <param name="categoriesService">The categories services to use.</param>
/// <param name="userAuthentication">The user authentication service to use.</param>
/// <param name="eventGridSubscriberService">The event grid subcriber service to use.</param>
public WorkerApiFunctions(
ICategoriesService categoriesService,
IUserAuthenticationService userAuthentication,
IEventGridSubscriberService eventGridSubscriberService)
{
this.CategoriesService = categoriesService;
this.UserAuthenticationService = userAuthentication;
this.EventGridSubscriberService = eventGridSubscriberService;
}
public UserService(
IUnitOfWork unitOfWork,
IUserAuthenticationService userAuthenticationService,
IUserRepository userRepository)
{
this._unitOfWork = unitOfWork;
this._userAuthenticationService = userAuthenticationService;
this._userRepository = userRepository;
}
public DomainUserService(IUserAuthenticationService domainService)
{
if (domainService == null)
{
throw new ArgumentNullException(nameof(domainService));
}
this.domainService = domainService;
}
public AuthController(IUserService userService, IUserRegisterationService userRegisterationService, IUserAuthenticationService authService, ICustomerActivityService activityService, ILogService logService, IWorkContext workContext)
{
_userService = userService;
_userRegisterationService = userRegisterationService;
_authService = authService;
_activityService = activityService;
_logService = logService;
_workContext = workContext;
}
public UserController(IUserService userService,
IMapper mapper,
IWorkContext workContext,
IUserAuthenticationService userAuthenticationService)
{
_userService = userService;
_mapper = mapper;
_workContext = workContext;
_userAuthenticationService = userAuthenticationService;
}
public BasicAuthenticationHandler(
IOptionsMonitor <AuthenticationSchemeOptions> options,
ILoggerFactory logger,
UrlEncoder encoder,
ISystemClock clock,
IUserAuthenticationService authenticationService
) : base(options, logger, encoder, clock)
{
this.authenticationService = authenticationService;
}
public async Task Invoke(HttpContext context, IUserAuthenticationService userService)
{
var token = context.Request.Headers["Authorization"].FirstOrDefault()?.Split(" ").Last();
if (token != null)
{
attachUserToContext(context, userService, token);
}
await _next(context);
}
public AuthenticationController(
IUserAuthenticationService authenticationService,
IUserService userService,
IActivationCodeService activationCodeService,
IEmailService emailService)
{
_authenticationService = authenticationService;
_userService = userService;
_activationCodeService = activationCodeService;
_emailService = emailService;
}
public AccountsPageVM(INavigationService navigationService, IWcclsApiService apiService, IUserAuthenticationService userService, IEventAggregator aggregator)
: base(navigationService)
{
_apiService = apiService;
_userService = userService;
_eventAggregator = aggregator;
_eventAggregator
.GetEvent <AccountsChangedEvent>()
.Subscribe(() => { LoadUsers(); }, ThreadOption.UIThread);
LoadUsers();
}
public AuthenticationController(ISiteMap siteMap, ISession session, IUserAuthenticationService userAuthenticationService)
{
_siteMap = siteMap;
_session = session;
_userAuthenticationService = userAuthenticationService;
}
/// <summary>
/// Initializes a new instance of the <see cref="UserInfo"/> class.
/// </summary>
/// <param name="name">The name.</param>
public UserInfo(string name)
{
Name = name;
_authenticationService = InversionOfControl.IoC.Resolve<IUserAuthenticationService>();
}
/// <summary>
/// Default Authentication Constructor
/// </summary>
public BasicAuthenticationFilter(IUserAuthenticationService authenticationService)
{
_authenticationService = authenticationService;
}
public AccountController(IDocumentSession session, IMetricTracker metrics, IUserAuthenticationService authenticationService)
: base(session, metrics)
{
_authenticationService = authenticationService;
}
/// <summary>
/// AuthenticationFilter constructor with isActive parameter
/// </summary>
/// <param name="isActive"></param>
/// <param name="authenticationService"></param>
public BasicAuthenticationFilter(bool isActive, IUserAuthenticationService authenticationService)
: base(isActive)
{
_authenticationService = authenticationService;
}
public AccountController(IUserAuthenticationService uerAuthenticationService, ISessionStateRepository sessionStateRepository)
: base(sessionStateRepository)
{
UserAuthenticationService = uerAuthenticationService;
}
/// <summary>
/// Initializes data that might not be available when the constructor is called.
/// </summary>
/// <param name="requestContext">The HTTP context and route data.</param>
protected override void Initialize(RequestContext requestContext)
{
if (FormsService == null) {
FormsService = IoC.Resolve<IFormsAuthenticationService>();
}
if (UserAuthenticationService == null)
{
UserAuthenticationService = IoC.Resolve<IUserAuthenticationService>();
}
base.Initialize(requestContext);
}
