public ReportsController(IPatientRepository patientRepository, IVisitRepository visitRepository,
IQueryRepository queryRepository)
{
this.patientRepository = patientRepository;
this.visitRepository = visitRepository;
this.queryRepository = queryRepository;
}
public CampaignsController(
IQueryRepository<Query.Campaigns.Campaign> repository,
ICommandCoordinator coordinator)
{
_repository = repository;
_coordinator = coordinator;
}
public CardPaymentFactory(
IRepository<Account> accounts,
IRepository<UserPaymentProfile> paymentProfiles,
IRepository<Currency> currencies,
IQueryRepository<CorrespondentAccount> correspondentAccounts,
TransactionReferenceBook transactionReferenceBook,
MoneyConverter moneyConverter,
PaymentFormFactory paymentFormFactory)
{
Argument.NotNull(accounts, "accounts");
Argument.NotNull(paymentProfiles, "paymentProfiles");
Argument.NotNull(currencies, "currencies");
Argument.NotNull(correspondentAccounts, "correspondentAccounts");
Argument.NotNull(transactionReferenceBook, "transactionReferenceBook");
Argument.NotNull(moneyConverter, "moneyConverter");
Argument.NotNull(paymentFormFactory, "paymentFormFactory");
_settings = new BankSettings();
_currencies = currencies;
_correspondentAccounts = correspondentAccounts;
_paymentProfiles = paymentProfiles;
_accounts = accounts;
_transactionReferenceBook = transactionReferenceBook;
_moneyConverter = moneyConverter;
_paymentFormFactory = paymentFormFactory;
}
public CourseController(
ICourseApplicationService courseAppService,
IQueryRepository queryRepository)
{
_CourseAppService = courseAppService;
_QueryRepository = queryRepository;
}
public DepartmentController(
IDepartmentApplicationService departmentAppService,
IQueryRepository queryRepository)
{
_DepartmentAppService = departmentAppService;
_QueryRepository = queryRepository;
}
public InstructorController(
IInstructorApplicationService instructorAppService,
IQueryRepository queryRepository)
{
_QueryRepository = queryRepository;
_InstructorAppService = instructorAppService;
}
public ArticleFactory(IQueryRepository queryRepository, IValidator<Article> articleValidator,
IValidator<Comment> commentValidator, IMappingService mappingService)
{
_queryRepository = queryRepository;
_articleValidator = articleValidator;
_commentValidator = commentValidator;
_mappingService = mappingService;
}
public ArticleHandler(IQueryRepository queryRepository, ICommandRepository commandRepository, IMapper mapper,
IQueuePusher queue)
{
_queryRepository = queryRepository;
_commandRepository = commandRepository;
_mapper = mapper;
_queue = queue;
}
public ExecuteSqlQueryEvent(IQueryRepository queryRepository, string sql, IEnumerable<object> args)
: base(queryRepository)
{
Check.NotNull(queryRepository, "queryRepository");
Check.NotEmpty(sql, "sql");
Args = args;
Sql = sql;
}
public SimpleRepositoryQueryEvent(IQueryRepository repository, IQueryStrategy queryStrategy, object additionalQueryData, bool? throwExceptionIfZeroOrManyFound)
: base(repository)
{
Check.NotNull(repository, "repository");
Check.NotNull(queryStrategy, "queryStrategy");
AdditionalQueryData = additionalQueryData;
QueryStrategy = queryStrategy;
ThrowExceptionIfZeroOrManyFound = throwExceptionIfZeroOrManyFound;
}
public AnalyticsController(IPatientRepository patientRepository, IVisitRepository visitRepository,
IDemographicFormDataRepository dfdRepository,
IHappinessFormDataRepository hfdRepository, IAdverseEventFormDataRepository aefdRepository,
IQueryRepository queryRepository)
{
this.patientRepository = patientRepository;
this.visitRepository = visitRepository;
this.dfdRepository = dfdRepository;
this.hfdRepository = hfdRepository;
this.aefdRepository = aefdRepository;
this.queryRepository = queryRepository;
}
public UserCardLimitsPolicy(IRepository<UserCard> userCardRepository,
IQueryRepository<CardTransaction> cardTransactionRepository,
BankingSystemSchedule schedule)
{
Argument.NotNull(userCardRepository, "userCardRepository");
Argument.NotNull(cardTransactionRepository, "cardTransactionRepository");
Argument.NotNull(schedule, "schedule");
_userCardRepository = userCardRepository;
_cardTransactionRepository = cardTransactionRepository;
_schedule = schedule;
_settings = new BankSettings();
}
public GetPosts(IQueryRepository<Post> the_post_repository,
GetPostsByRadius the_get_posts_by_radius,
GetPostsByHashTag the_get_posts_by_hash_tag,
GetHashTagByName the_get_hash_tag_by_name,
IQueryRepository<Connection> the_connection_repository)
{
post_repository = Guard.IsNotNull(the_post_repository, "the_post_repository");
connection_repository = Guard.IsNotNull(the_connection_repository, "the_connection_repository");
get_posts_by_radius = Guard.IsNotNull(the_get_posts_by_radius, "the_get_posts_by_radius");
get_posts_by_hash_tag = Guard.IsNotNull(the_get_posts_by_hash_tag, "the_get_posts_by_hash_tag");
get_hash_tag_by_name = Guard.IsNotNull(the_get_hash_tag_by_name, "the_get_hash_tag_by_name");
}
public AppVersionController(IQueryRepository queries,
CommandExecutor<CreateVersion> createExecutor,
CommandExecutor<RenameVersion> renameExecutor,
CommandExecutor<DeleteVersion> deleteExecutor,
CommandExecutor<AssignVersion> assignExecutor,
CommandExecutor<UnAssignVersion> unAssignExecutor)
{
_queries = queries;
_createExecutor = createExecutor;
_renameExecutor = renameExecutor;
_deleteExecutor = deleteExecutor;
_assignExecutor = assignExecutor;
_unAssignExecutor = unAssignExecutor;
}
public BuildController(IQueryRepository queries,
CommandExecutor<CreateBuild> createExecutor,
CommandExecutor<CreateBulkOfBuilds> bulkCreateExecutor,
CommandExecutor<RenameBuild> renameExecutor,
CommandExecutor<DeleteBuild> deleteExecutor,
CommandExecutor<AssignBuild> assignExecutor,
CommandExecutor<UnAssignBuild> unAssignExecutor)
{
_queries = queries;
_createExecutor = createExecutor;
_bulkCreateExecutor = bulkCreateExecutor;
_renameExecutor = renameExecutor;
_deleteExecutor = deleteExecutor;
_assignExecutor = assignExecutor;
_unAssignExecutor = unAssignExecutor;
}
public static EntityStateWrapperContainer Create(IQueryRepository queryRepository, CreateInstructorWithCourses.CommandModel commandModel)
{
// could use Course.CreatePartial here and attachEntities using EntityStateWrapperContainer
var courses = commandModel.SelectedCourses == null
? new Course[0].ToList()
: queryRepository.GetEntities<Course>(new FindByIdsSpecificationStrategy<Course>(p => p.CourseID, commandModel.SelectedCourses)).ToList();
var instructor = new Instructor
{
HireDate = commandModel.HireDate,
FirstMidName = commandModel.FirstMidName,
LastName = commandModel.LastName,
Courses = courses,
OfficeAssignment = new OfficeAssignment { Location = commandModel.OfficeLocation },
};
return new EntityStateWrapperContainer().AddEntity(instructor);
}
public EntityStateWrapperContainer Modify(IQueryRepository queryRepository, ContosoUniversity.Domain.Core.Behaviours.Instructors.InstructorModifyAndCourses.CommandModel commandModel)
{
var retVal = new EntityStateWrapperContainer();
// Removals first
Courses.Clear();
if (OfficeAssignment != null && commandModel.OfficeLocation == null)
retVal.DeleteEntity(OfficeAssignment);
// Update properties
FirstMidName = commandModel.FirstMidName;
LastName = commandModel.LastName;
HireDate = commandModel.HireDate;
OfficeAssignment = new OfficeAssignment { Location = commandModel.OfficeLocation };
if (commandModel.SelectedCourses != null)
{
Courses = queryRepository.GetEntities<Course>(
new FindByIdsSpecificationStrategy<Course>(p => p.CourseID, commandModel.SelectedCourses)).ToList();
}
retVal.ModifyEntity(this);
return retVal;
}
public CreateProjectCommandHandler(
[NotNull] IAuthorityProvider authorityProvider,
[NotNull] INotificationRuleProvider notificationRuleProvider,
[NotNull] IUserAuthorityValidator userAuthorityValidator,
[NotNull] IProjectRepository repositoryProjects,
[NotNull] IRoleProvider roleProvider,
[NotNull] ISdlPolicyProvider sdlPolicyProvider,
[NotNull] ITimeService timeService,
[NotNull] IUnitOfWork unitOfWork,
[NotNull] IUserPrincipal userPrincipal,
[NotNull] IQueryRepository queryRepository,
[NotNull] IReportRepository reportRepository,
[NotNull] ILicenceProvider licenceProvider,
[NotNull] IPluginProvider pluginProvider,
[NotNull] ITelemetryScopeProvider telemetryScopeProvider)
: base(userAuthorityValidator, unitOfWork, userPrincipal)
{
if (authorityProvider == null)
{
throw new ArgumentNullException(nameof(authorityProvider));
}
if (notificationRuleProvider == null)
{
throw new ArgumentNullException(nameof(notificationRuleProvider));
}
if (userAuthorityValidator == null)
{
throw new ArgumentNullException(nameof(userAuthorityValidator));
}
if (repositoryProjects == null)
{
throw new ArgumentNullException(nameof(repositoryProjects));
}
if (roleProvider == null)
{
throw new ArgumentNullException(nameof(roleProvider));
}
if (sdlPolicyProvider == null)
{
throw new ArgumentNullException(nameof(sdlPolicyProvider));
}
if (timeService == null)
{
throw new ArgumentNullException(nameof(timeService));
}
if (userPrincipal == null)
{
throw new ArgumentNullException(nameof(userPrincipal));
}
if (queryRepository == null)
{
throw new ArgumentNullException(nameof(queryRepository));
}
if (reportRepository == null)
{
throw new ArgumentNullException(nameof(reportRepository));
}
if (licenceProvider == null)
{
throw new ArgumentNullException(nameof(licenceProvider));
}
if (pluginProvider == null)
{
throw new ArgumentNullException(nameof(pluginProvider));
}
if (telemetryScopeProvider == null)
{
throw new ArgumentNullException(nameof(telemetryScopeProvider));
}
_authorityProvider = authorityProvider;
_notificationRuleProvider = notificationRuleProvider;
_repositoryProjects = repositoryProjects;
_roleProvider = roleProvider;
_sdlPolicyProvider = sdlPolicyProvider;
_userPrincipal = userPrincipal;
_queryRepository = queryRepository;
_reportRepository = reportRepository;
_licenceProvider = licenceProvider;
_pluginProvider = pluginProvider;
_telemetryScopeProvider = telemetryScopeProvider;
_timeService = timeService;
}
public HomeController(IQueryRepository queryRepository)
{
_queryRepository = queryRepository;
}
public IQueryRepository _SetQueryRepository(IQueryRepository obj)
{
_IQueryRepository = obj; return obj;
}
public GetEntityRepositoryQueryEvent(IQueryRepository repository, IQueryStrategy specification, IQueryStrategy queryStrategy, object additionalQueryData)
: this(repository, specification, queryStrategy, additionalQueryData, null)
{
}
public MainController(IQueryRepository queryRepository)
{
_QueryRepository = queryRepository;
}
public GetUserById(IQueryRepository<User> the_user_repository)
{
user_repository = Guard.IsNotNull(the_user_repository, "the_user_repository");
}
public StudentController(IQueryRepository queryRepository)
{
_QueryRepository = queryRepository;
}
public GetConnections(IQueryRepository<Connection> the_connection_repository)
{
connection_repository = Guard.IsNotNull(the_connection_repository, "the_connection_repository");
}
public QueryController(IQueryRepository queryRepository, IAccountRepository accountRepository)
{
this._queryRepository = queryRepository;
this._accountRepository = accountRepository;
}
protected SimpleRepositoryQueryEvent(IQueryRepository repository, IQueryStrategy specificationStrategy, IQueryStrategy queryStrategy, object additionalQueryData)
: this(repository, specificationStrategy, queryStrategy, additionalQueryData, null)
{
}
public AggregateCustomerSalesController(IQueryRepository repository)
{
_QueryRepository = repository;
}
protected RepositoryQueryEvent(IQueryRepository queryRepository)
{
Check.NotNull(queryRepository, "queryRepository");
QueryRepository = queryRepository;
}
public GetPostById(IQueryRepository<Post> the_post_repository)
{
post_repository = Guard.IsNotNull(the_post_repository, "the_post_repository");
}
public AccountsController(IQueryRepository queryRepository)
{
_queryRepository = queryRepository;
}
