public AsyncQueryHandlerWithLogging(IAsyncQueryHandler <TQuery, TResult> queryHandler, ILogger logger)
{
Condition.Requires(queryHandler, nameof(queryHandler)).IsNotNull();
Condition.Requires(logger, nameof(logger)).IsNotNull();
this.queryHandler = queryHandler;
this.logger = logger;
}
public GenericPermissionCheckAsyncQueryHandlerDecorator(IAsyncQueryHandler <TQuery, TResult> wrappedHandler, IIdentity currentUser, IAsyncPermissionCheck <TQuery> check, ILogger <GenericPermissionCheckAsyncQueryHandlerDecorator <TQuery, TResult> > logger)
{
this.wrappedHandler = wrappedHandler ?? throw new ArgumentNullException(nameof(wrappedHandler));
this.currentUser = currentUser ?? throw new ArgumentNullException(nameof(currentUser));
this.check = check ?? throw new ArgumentNullException(nameof(check));
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public SynchronisationController(
IAsyncQueryHandler <CommitQuery, CommitSynchronisation> queryHandler,
IAsyncCommandHandler <CommitSynchronisableCommits> commandHandler)
{
this.queryHandler = queryHandler;
this.commandHandler = commandHandler;
}
public UserController(
IQueryHandler <FindUsersBySearchTextQuery, IEnumerable <User> > handler,
IAsyncQueryHandler <FindUsersBySearchTextQuery, IEnumerable <User> > asyncHandler)
{
this.handler = handler;
this.asyncHandler = asyncHandler;
}
/// <param name="getProductsQueryHandler"></param>
/// <param name="getProductDetailsQueryHandler"></param>
/// <param name="addProductCommandHandler"></param>
/// <param name="editProductCommandHandler"></param>
public ProductsController(IQueryHandler <GetProductsQuery, GetProductsResponse> getProductsQueryHandler, IAsyncQueryHandler <GetProductDetailsQuery, GetProductDetailsResponse> getProductDetailsQueryHandler, IAsyncCommandHandler <AddProductCommand, AddProductResponse> addProductCommandHandler, IAsyncCommandHandler <EditProductCommand, EditProductResponse> editProductCommandHandler)
{
_getProductsQueryHandler = getProductsQueryHandler;
_getProductDetailsQueryHandler = getProductDetailsQueryHandler;
_addProductCommandHandler = addProductCommandHandler;
_editProductCommandHandler = editProductCommandHandler;
}
/// <summary>
/// Initialise a new instance of the Okta JWT Security Token Handler
/// </summary>
/// <param name="tokenService">The Token Service.</param>
/// <param name="tokenValidator">Token validator.</param>
/// <param name="userSessionUpdateOktaTokenService">User update okta token service.</param>
/// <param name="userSessionRetrievalByOktaIdService">User retrieval by okta id service.</param>
/// <param name="userRetrievalById">User retrieval by id service.</param>
/// <param name="userRetrievalByEmailService">User retrieval by email service.</param>
/// <param name="userRetrievalByOktaId">User retrieval by okta id.</param>
/// <param name="userUpdateService">Update user service.</param>
/// <param name="userCreationService">User creation service.</param>
/// <param name="oktaClient">Okta client.</param>
/// <param name="oktaTokenExpiryTime">Okta token expiry time.</param>
public OktaJwtSecurityTokenHandler(
ITokenService tokenService,
ISecurityTokenValidator tokenValidator,
IAsyncQueryHandler <UserSessionUpdateOktaTokenQuery, MeUserSession> userSessionUpdateOktaTokenService,
IAsyncQueryHandler <UserSessionRetrievalByOktaIdQuery, MeUserSession> userSessionRetrievalByOktaIdService,
IAsyncQueryHandler <UserRetrievalByIdQuery, MeUser> userRetrievalById,
IAsyncQueryHandler <UserRetrievalByOktaIdQuery, MeUser> userRetrievalByOktaId,
IAsyncQueryHandler <UserRetrievalByEmailQuery, MeUser> userRetrievalByEmailService,
IAsyncQueryHandler <UserUpdateQuery, MeUser> userUpdateService,
IAsyncQueryHandler <CreateUserQuery, MeUser> userCreationService,
IOktaClient oktaClient,
int oktaTokenExpiryTime)
{
_tokenHandler = tokenValidator;
_tokenService = tokenService;
_userSessionUpdateOktaTokenService = userSessionUpdateOktaTokenService;
_oktaTokenExpiryTime = oktaTokenExpiryTime;
_userSessionRetrievalByOktaIdService = userSessionRetrievalByOktaIdService;
_userRetrievalByEmailService = userRetrievalByEmailService;
_userCreationService = userCreationService;
_userRetrievalByOktaId = userRetrievalByOktaId;
_userRetrievalById = userRetrievalById;
_userUpdateService = userUpdateService;
_oktaClient = oktaClient;
}
public UnitInformationPageViewModel(
UnitInformationPageViewModelConfiguration configuration,
IAsyncQueryHandler <GetAssignmentQuery, Result <Assignment, Exception> > getAssignmentQueryHandler)
{
_configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
_getAssignmentQueryHandler = getAssignmentQueryHandler ?? throw new ArgumentNullException(nameof(getAssignmentQueryHandler));
}
public GetStudentGradeForAssignmentQueryHandler(
IAsyncQueryHandler <GetAssignmentAnswerKeyQuery, Result <AssignmentAnswerKey, Exception> > getAssignmentAnswerKeyQueryHandler,
IAsyncQueryHandler <GetStudentSubmissionForAssignmentQuery, Result <StudentAssignmentSubmission, Exception> > getStudentSubmissionForAssignmentQueryHandler)
{
_getAssignmentAnswerKeyQueryHandler = getAssignmentAnswerKeyQueryHandler ?? throw new ArgumentNullException(nameof(getAssignmentAnswerKeyQueryHandler));
_getStudentSubmissionForAssignmentQueryHandler = getStudentSubmissionForAssignmentQueryHandler ?? throw new ArgumentNullException(nameof(getStudentSubmissionForAssignmentQueryHandler));
}
public AsyncPollyQueryHandler(IAsyncQueryHandler <TQuery, TResult> handler, IAsyncPolicy policy)
{
Condition.Requires(handler, nameof(handler)).IsNotNull();
Condition.Requires(policy, nameof(policy)).IsNotNull();
this.handler = handler;
this.policy = policy;
}
public virtual Task <TResult> DispatchAsync <TQuery, TResult>(TQuery query, CancellationToken cancellationToken) where TQuery : IQuery <TResult>
{
cancellationToken.ThrowIfCancellationRequested();
IAsyncQueryHandler <TQuery, TResult> handler = this.Resolve <TQuery, TResult>(cancellationToken);
return(handler.HandleAsync(query, cancellationToken));
}
public ParallelQueryHandler(IAsyncQueryHandler <TQuery, TResult> queryHandler)
{
if (queryHandler == null)
{
throw new ArgumentNullException("queryHandler");
}
_queryHandler = queryHandler;
}
/// <summary>
/// Initialise a new instance of <see cref="AuthenticatedBaseController"/>.
/// </summary>
/// <param name="logger">The Logger.</param>
/// <param name="mapper">The Mapper.</param>
/// <param name="usersRetrievalByOktaIdService">User Retrieval By Okta Id Service.</param>
protected AuthenticatedBaseController(
IAsyncQueryHandler <CreateMELoggerQuery, LogMessageActionDefault> logger,
IMapper mapper,
IAsyncQueryHandler <UserRetrievalByOktaIdQuery, MeUser> usersRetrievalByOktaIdService)
: base(logger, mapper)
{
_usersRetrievalByOktaIdService = usersRetrievalByOktaIdService;
}
/// <param name="addUserMealCommandHandler"></param>
/// <param name="getUserMealsByDate"></param>
/// <param name="deleteUserMeals"></param>
public UserMealsController(IAsyncCommandHandler <AddUserMealCommand, AddUserMealResponse> addUserMealCommandHandler,
IAsyncQueryHandler <GetUserMealsByDateInternalQuery, GetUserMealsByDateResponse> getUserMealsByDate,
IAsyncCommandHandler <DeleteUserMealsCommand, DeleteUserMealsReponse> deleteUserMeals)
{
_addUserMealCommandHandler = addUserMealCommandHandler;
_getUserMealsByDate = getUserMealsByDate;
_deleteUserMeals = deleteUserMeals;
}
/// <summary>
/// Initializes a new instance of the <see cref="AccountController" /> class.
/// </summary>
/// <param name="logger">Initialise with IMELogger instance.</param>
/// <param name="mapper">The Mapper.</param>
/// <param name="usersRetrievalByOktaIdService">User Retrieval By Okta Id Service.</param>
/// <param name="rolePermissions">Role Permissions.</param>
public AccountController(
IAsyncQueryHandler <CreateMELoggerQuery, LogMessageActionDefault> logger,
IMapper mapper,
IAsyncQueryHandler <UserRetrievalByOktaIdQuery, MeUser> usersRetrievalByOktaIdService,
IRolePermissions rolePermissions)
: base(logger, mapper, usersRetrievalByOktaIdService)
{
_rolePermissions = rolePermissions;
}
/// <summary>
/// Permission Service.
/// </summary>
/// <param name="rolePermissions">Role Permissions.</param>
/// <param name="userRetrievalService">User Retrieval Service.</param>
/// <param name="authorizationSettings">Authorization Settings.</param>
public PermissionService(
IRolePermissions rolePermissions,
IAsyncQueryHandler <UserRetrievalByOktaIdQuery, MeUser> userRetrievalService,
IOptions <AuthorizationSettings> authorizationSettings)
{
_rolePermissions = rolePermissions;
_userRetrievalService = userRetrievalService;
_authorizationSettings = authorizationSettings;
}
public MessageLogger(
CommandBus commandBus,
IAsyncQueryHandler<GetRoutesQuery, GetRoutesQueryResponse> getRoutesQueryHandler,
IAsyncQueryHandler<GetRouteQuery, GetRouteQueryResponse> getRouteQueryHandler)
{
this.commandBus = commandBus;
this.getRoutesQueryHandler = getRoutesQueryHandler;
this.getRouteQueryHandler = getRouteQueryHandler;
}
public MessageLogger(
CommandBus commandBus,
IAsyncQueryHandler <GetRoutesQuery, GetRoutesQueryResponse> getRoutesQueryHandler,
IAsyncQueryHandler <GetRouteQuery, GetRouteQueryResponse> getRouteQueryHandler)
{
this.commandBus = commandBus;
this.getRoutesQueryHandler = getRoutesQueryHandler;
this.getRouteQueryHandler = getRouteQueryHandler;
}
public AssignmentPageViewModel(
AssignmentPageViewModelConfiguration configuration,
IAsyncQueryHandler <GetAssignmentAnswerKeyQuery, Result <AssignmentAnswerKey, Exception> > getAssignmentAsyncQueryHandler)
{
_configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
_getAssignmentAsyncQueryHandler = getAssignmentAsyncQueryHandler ?? throw new ArgumentNullException(nameof(getAssignmentAsyncQueryHandler));
AssignmentData = configuration.Assignment.ToAssignmentInProgress(configuration.StudentID);
}
public MainPageViewModel(
IAsyncQueryHandler <GetSubjectMatterUnitTableOfContentsQuery, Result <SubjectMatterUnitTableOfContents, Exception> > tableOfContentsQueryHandler,
IAsyncQueryHandler <GetSubjectMatterUnitQuery, Result <SubjectMatterUnit, Exception> > getSubjectMatterUnitQueryHandler)
{
_tableOfContentsQueryHandler = tableOfContentsQueryHandler ?? throw new ArgumentNullException(nameof(tableOfContentsQueryHandler));
_getSubjectMatterUnitQueryHandler = getSubjectMatterUnitQueryHandler ?? throw new ArgumentNullException(nameof(getSubjectMatterUnitQueryHandler));
Task.Run(async() => { await LoadTableOfContents(); });
}
/// <summary>
/// Initialise a new instance of <see cref="MedicalTeamUpdateService"/>.
/// </summary>
/// <param name="databaseAccess">Database access.</param>
/// <param name="connectionSettings">Connection settings.</param>
/// <param name="userRetrievalByIdService">User retrieval by Id service.</param>
public MedicalTeamUpdateService(
IDatabaseAccess databaseAccess,
IExaminationConnectionSettings connectionSettings,
IAsyncQueryHandler <UserRetrievalByIdQuery, MeUser> userRetrievalByIdService,
IOptions <UrgencySettings> urgencySettings)
{
_databaseAccess = databaseAccess;
_connectionSettings = connectionSettings;
_userRetrievalByIdService = userRetrievalByIdService;
_urgencySettings = urgencySettings.Value;
}
public EntityFrameworkDatabaseSeedDataAsyncInitializer(
IAsyncQueryHandler <GetSchoolInitializationStatusQuery, Result <bool, Exception> > getSchoolInitializationStatusQueryHandler,
IAsyncCommandHandler <SaveStudentDataCommand, Exception> saveStudentDataCommandHandler,
IAsyncCommandHandler <SaveCourseDataCommand, Exception> saveCourseDataCommandHandler,
IAsyncCommandHandler <SaveEnrollmentDataCommand, Exception> saveEnrollmentDataCommandHandler)
{
_getSchoolInitializationStatusQueryHandler = getSchoolInitializationStatusQueryHandler ?? throw new ArgumentNullException(nameof(getSchoolInitializationStatusQueryHandler));
_saveStudentDataCommandHandler = saveStudentDataCommandHandler ?? throw new ArgumentNullException(nameof(saveStudentDataCommandHandler));
_saveCourseDataCommandHandler = saveCourseDataCommandHandler ?? throw new ArgumentNullException(nameof(saveCourseDataCommandHandler));
_saveEnrollmentDataCommandHandler = saveEnrollmentDataCommandHandler ?? throw new ArgumentNullException(nameof(saveEnrollmentDataCommandHandler));
}
/// <summary>
/// Authorization Based Controller.
/// </summary>
/// <param name="logger">Logger.</param>
/// <param name="mapper">Mapper.</param>
/// <param name="usersRetrievalByOktaIdService">User Retrieval By Okta Id Service.</param>
/// <param name="authorizationService">Authorization Service.</param>
/// <param name="permissionService">Permission Service.</param>
protected AuthorizedBaseController(
IAsyncQueryHandler <CreateMELoggerQuery, LogMessageActionDefault> logger,
IMapper mapper,
IAsyncQueryHandler <UserRetrievalByOktaIdQuery, MeUser> usersRetrievalByOktaIdService,
IAuthorizationService authorizationService,
IPermissionService permissionService)
: base(logger, mapper, usersRetrievalByOktaIdService)
{
AuthorizationService = authorizationService;
PermissionService = permissionService;
}
public CreateExaminationService(
IDatabaseAccess databaseAccess,
IExaminationConnectionSettings connectionSettings,
IAsyncQueryHandler <LocationRetrievalByIdQuery, Models.Location> locationHandler,
IOptions <UrgencySettings> urgencySettings)
{
_databaseAccess = databaseAccess;
_connectionSettings = connectionSettings;
_locationHandler = locationHandler;
_urgencySettings = urgencySettings.Value;
}
public virtual void Validate <TQuery, TResult>(TQuery query, IAsyncQueryHandler <TQuery, TResult> queryHandler, IExecutionContext executionContext) where TQuery : IQuery <TResult>
{
ValidateQueryImplementation <TQuery, TResult>(queryHandler);
if (queryHandler is IPermissionRestrictedQueryHandler <TQuery, TResult> )
{
var permissions = ((IPermissionRestrictedQueryHandler <TQuery, TResult>)queryHandler).GetPermissions(query);
_permissionValidationService.EnforcePermission(permissions, executionContext.UserContext);
}
CheckAdditionalPermissionHandlers(queryHandler, executionContext, _permissionValidationService);
}
/// <param name="addMealCommandHandler"></param>
/// <param name="getMealsQueryHandler"></param>
/// <param name="mealDetailsQueryHandler"></param>
/// <param name="editMealCommandHandler"></param>
/// <param name="deleteMealCommandHandler"></param>
public MealsController(IAsyncCommandHandler <AddMealCommand, AddMealResponse> addMealCommandHandler,
IAsyncQueryHandler <GetMealsQuery, GetMealsResponse> getMealsQueryHandler,
IAsyncQueryHandler <GetMealDetailsQuery, GetMealDetailsResponse> mealDetailsQueryHandler,
IAsyncCommandHandler <EditMealCommand, EditMealResponse> editMealCommandHandler,
IAsyncCommandHandler <DeleteMealCommand, DeleteMealResponse> deleteMealCommandHandler)
{
_addMealCommandHandler = addMealCommandHandler;
_getMealsQueryHandler = getMealsQueryHandler;
_mealDetailsQueryHandler = mealDetailsQueryHandler;
_editMealCommandHandler = editMealCommandHandler;
_deleteMealCommandHandler = deleteMealCommandHandler;
}
/// <summary>
/// Initialise a new instance of <see cref="CaseBreakdownController"/>.
/// </summary>
public CaseBreakdownController(
IAsyncQueryHandler <CreateMELoggerQuery, LogMessageActionDefault> logger,
IMapper mapper,
IAsyncQueryHandler <UserRetrievalByOktaIdQuery, MeUser> usersRetrievalByOktaIdService,
IAuthorizationService authorizationService,
IPermissionService permissionService,
IAsyncQueryHandler <CreateEventQuery, EventCreationResult> eventCreationService,
IAsyncQueryHandler <ExaminationRetrievalQuery, Examination> examinationRetrievalService)
: base(logger, mapper, usersRetrievalByOktaIdService, authorizationService, permissionService)
{
_eventCreationService = eventCreationService;
_examinationRetrievalService = examinationRetrievalService;
}
/// <summary>
/// Get Location Name.
/// </summary>
/// <param name="permission">Permission to get location name for.</param>
/// <param name="service">The locations retrieval by id service.</param>
/// <returns>Single location</returns>
public static async Task <Location> GetLocationName(
this MEUserPermission permission,
IAsyncQueryHandler <LocationsRetrievalByIdQuery, IEnumerable <Location> > service)
{
var locationIds = new List <string>
{
permission.LocationId
};
var locations = await service.Handle(new LocationsRetrievalByIdQuery(true, locationIds));
return(locations.FirstOrDefault());
}
/// <param name="registerUserCommandHandler"></param>
/// <param name="loginUserCommandHandler"></param>
/// <param name="getUsersQueryHandler"></param>
/// <param name="userDetailsQueryHandler"></param>
/// <param name="disableUserCommandHandler"></param>
/// <param name="enableUserCommandHandler"></param>
public UsersController(IAsyncCommandHandler <RegisterUserCommand, RegisterUserResponse> registerUserCommandHandler,
IAsyncCommandHandler <LoginUserCommand, LoginUserResponse> loginUserCommandHandler,
IAsyncQueryHandler <GetUsersQuery, GetUsersResponse> getUsersQueryHandler,
IAsyncQueryHandler <GetUserDetailsQuery, UserDetailsResponse> userDetailsQueryHandler,
IAsyncCommandHandler <DisableUserCommand, DisableUserResponse> disableUserCommandHandler,
IAsyncCommandHandler <EnableUserCommand, EnableUserResponse> enableUserCommandHandler)
{
_registerUserCommandHandler = registerUserCommandHandler;
_loginUserCommandHandler = loginUserCommandHandler;
_getUsersQueryHandler = getUsersQueryHandler;
_userDetailsQueryHandler = userDetailsQueryHandler;
_disableUserCommandHandler = disableUserCommandHandler;
_enableUserCommandHandler = enableUserCommandHandler;
}
/// <summary>
/// Initialise a new instance of <see cref="PatientDetailsController"/>.
/// </summary>
/// <param name="logger">The Logger.</param>
/// <param name="mapper">The Mapper.</param>
/// <param name="usersRetrievalByOktaIdService">User Retrieval By Okta Id Service.</param>
/// <param name="authorizationService">Authorization Service.</param>
/// <param name="permissionService">Permission Service.</param>
/// <param name="examinationRetrievalService">Examination Retrieval Service.</param>
/// <param name="patientDetailsUpdateService">Patient Details Update Service.</param>
/// <param name="locationParentsService">Location Parents Service.</param>
public PatientDetailsController(
IAsyncQueryHandler <CreateMELoggerQuery, LogMessageActionDefault> logger,
IMapper mapper,
IAsyncQueryHandler <UserRetrievalByOktaIdQuery, MeUser> usersRetrievalByOktaIdService,
IAuthorizationService authorizationService,
IPermissionService permissionService,
IAsyncQueryHandler <ExaminationRetrievalQuery, Examination> examinationRetrievalService,
IAsyncQueryHandler <PatientDetailsUpdateQuery, Examination> patientDetailsUpdateService,
IAsyncQueryHandler <LocationParentsQuery, IEnumerable <Location> > locationParentsService)
: base(logger, mapper, usersRetrievalByOktaIdService, authorizationService, permissionService)
{
_examinationRetrievalService = examinationRetrievalService;
_patientDetailsUpdateService = patientDetailsUpdateService;
_locationParentsService = locationParentsService;
}
public DashboardsController(IGetRepository <IApplicationUser> applicationUserRepository,
IAsyncQueryHandler <BagsCountByBagTypesQuery> bagTypesCountQuery,
IAsyncQueryHandler <BagsCountByBrandsQuery> brandsCountQuery,
IAsyncQueryHandler <BagsCountByInsertDateQuery> insertDateCountQuery,
IAsyncQueryHandler <TotalBagsCountByInsertDateQuery> totalInsertDateCountQuery,
ITranslator <IQueryResult, IActionResult> queryTranslator,
ITranslator <ICommandResult, IActionResult> commandTranslator)
{
ApplicationUserRepository = applicationUserRepository ?? throw new System.ArgumentNullException(nameof(applicationUserRepository));
BagTypesCountQuery = bagTypesCountQuery ?? throw new System.ArgumentNullException(nameof(bagTypesCountQuery));
BrandsCountQuery = brandsCountQuery ?? throw new System.ArgumentNullException(nameof(brandsCountQuery));
InsertDateCountQuery = insertDateCountQuery ?? throw new System.ArgumentNullException(nameof(insertDateCountQuery));
TotalInsertDateCountQuery = totalInsertDateCountQuery ?? throw new System.ArgumentNullException(nameof(totalInsertDateCountQuery));
QueryTranslator = queryTranslator ?? throw new System.ArgumentNullException(nameof(queryTranslator));
CommandTranslator = commandTranslator ?? throw new System.ArgumentNullException(nameof(commandTranslator));
}
public CountriesController(SearchQueryHandler <Country, Domain.Tea.Country> searchCountriesCommand,
GetQueryHandler <Country, Domain.Tea.Country> getCountry,
IAsyncCommandHandler <UpdateCommand <Country>, Domain.Tea.Country> updateCommand,
IAsyncCommandHandler <CreateCommand <Country>, Domain.Tea.Country> createCommand,
IAsyncQueryHandler <SearchRefValuesQuery <Domain.Tea.Country> > searchRefValuesQuery,
ITranslator <IQueryResult, IActionResult> queryTranslator,
ITranslator <ICommandResult, IActionResult> commandTranslator)
{
SearchCountriesCommand = searchCountriesCommand ?? throw new System.ArgumentNullException(nameof(searchCountriesCommand));
GetCountry = getCountry ?? throw new System.ArgumentNullException(nameof(getCountry));
UpdateCommand = updateCommand ?? throw new System.ArgumentNullException(nameof(updateCommand));
CreateCommand = createCommand ?? throw new System.ArgumentNullException(nameof(createCommand));
SearchRefValuesQuery = searchRefValuesQuery ?? throw new System.ArgumentNullException(nameof(searchRefValuesQuery));
QueryTranslator = queryTranslator ?? throw new System.ArgumentNullException(nameof(queryTranslator));
CommandTranslator = commandTranslator ?? throw new System.ArgumentNullException(nameof(commandTranslator));
}
public AllRoutesController(IAsyncQueryHandler<GetRoutesQuery, GetRoutesQueryResponse> getRoutesQueryHandler)
{
this.getRoutesQueryHandler = getRoutesQueryHandler;
}
