public ItSystemUsageService(
IGenericRepository <ItSystemUsage> usageRepository,
IAuthorizationContext authorizationContext,
IItSystemRepository systemRepository,
IItContractRepository contractRepository,
IOptionsService <SystemRelation, RelationFrequencyType> frequencyService,
IGenericRepository <SystemRelation> relationRepository,
IGenericRepository <ItInterface> interfaceRepository,
IReferenceService referenceService,
ITransactionManager transactionManager,
IDomainEvents domainEvents,
ILogger logger,
IGenericRepository <ItSystemUsageSensitiveDataLevel> sensitiveDataLevelRepository)
{
_usageRepository = usageRepository;
_authorizationContext = authorizationContext;
_systemRepository = systemRepository;
_contractRepository = contractRepository;
_frequencyService = frequencyService;
_transactionManager = transactionManager;
_domainEvents = domainEvents;
_relationRepository = relationRepository;
_interfaceRepository = interfaceRepository;
_referenceService = referenceService;
_logger = logger;
_sensitiveDataLevelRepository = sensitiveDataLevelRepository;
}
public ItSystemUsageRightsController(
IGenericRepository <ItSystemRight> rightRepository,
IGenericRepository <ItSystemUsage> objectRepository,
IDomainEvents domainEvents)
: base(rightRepository, objectRepository, domainEvents)
{
}
public CreateBookingHandler(IBookingRepository bookingRepository,
IRoomRepository roomRepository,
IDomainEvents domainEvents) : base(domainEvents)
{
_bookingRepository = bookingRepository;
_roomRepository = roomRepository;
}
public CreateQuestionHandler(
IMapper mapper,
IDomainEvents domainEvents)
{
_mapper = mapper;
_domainEvents = domainEvents;
}
public IncrementAnswerVotesOnVotePosted(
IDomainEvents domainEvents,
IAnswersRepository answersRepository)
{
_domainEvents = domainEvents;
_answersRepository = answersRepository;
}
public UserService(TimeSpan ttl,
string baseUrl,
string mailSuffix,
string defaultUserPassword,
bool useDefaultUserPassword,
IGenericRepository <User> userRepository,
IGenericRepository <Organization> orgRepository,
IGenericRepository <PasswordResetRequest> passwordResetRequestRepository,
IMailClient mailClient,
ICryptoService cryptoService,
IAuthorizationContext authorizationContext,
IDomainEvents domainEvents)
{
_ttl = ttl;
_baseUrl = baseUrl;
_mailSuffix = mailSuffix;
_defaultUserPassword = defaultUserPassword;
_useDefaultUserPassword = useDefaultUserPassword;
_userRepository = userRepository;
_orgRepository = orgRepository;
_passwordResetRequestRepository = passwordResetRequestRepository;
_mailClient = mailClient;
_cryptoService = cryptoService;
_authorizationContext = authorizationContext;
_domainEvents = domainEvents;
_crypt = new SHA256Managed();
if (useDefaultUserPassword && string.IsNullOrWhiteSpace(defaultUserPassword))
{
throw new ArgumentException(nameof(defaultUserPassword) + " must be defined, when it must be used.");
}
}
public ItProjectRightController(
IGenericRepository <ItProjectRight> rightRepository,
IGenericRepository <ItProject> objectRepository,
IDomainEvents domainEvents)
: base(rightRepository, objectRepository, domainEvents)
{
}
public UnitOfWorkScopeFactory(IDbContextFactoryProducerSingleton dbContextFactory = null, IAmbientDbContextLocator contextLocator = null, IGenericRepositoryFactory repositoryFactory = null, IDomainEvents domainEvents = null)
{
_dbContextFactory = dbContextFactory;
_contextLocator = contextLocator;
_repositoryFactory = repositoryFactory;
_domainEvents = domainEvents;
}
public BaseManager(
ILogger logger,
IDomainEvents domainEvents
)
{
Logger = logger;
Events = domainEvents;
}
public void RemoveDomainEvent(IDomainEvents eventItem)
{
if (_domainEvents is null)
{
return;
}
_domainEvents.Remove(eventItem);
}
public EventDispatcher(IDocumentStore store, IDomainEvents domainEvents, CriticalError criticalError, Settings settings, IEnumerable <IEventPublisher> eventPublishers)
{
this.store = store;
this.criticalError = criticalError;
this.settings = settings;
this.eventPublishers = eventPublishers;
this.domainEvents = domainEvents;
}
public ReclassifyErrorsHandler(IDocumentStore store, IDomainEvents domainEvents, ShutdownNotifier notifier, IEnumerable <IFailureClassifier> classifiers)
{
this.store = store;
this.classifiers = classifiers;
this.domainEvents = domainEvents;
reclassifier = new Reclassifier(notifier);
}
public ArchiveAllInGroupHandler(IDocumentStore store, IDomainEvents domainEvents, ArchiveDocumentManager documentManager, ArchivingManager archiveOperationManager, RetryingManager retryingManager)
{
this.store = store;
this.documentManager = documentManager;
this.archiveOperationManager = archiveOperationManager;
this.retryingManager = retryingManager;
this.domainEvents = domainEvents;
}
public FailedMessagesService(IFailedMessagesStoreFactory failedMessagesStoreFactory,
IDomainEvents domainEvents)
{
this.failedMessagesStoreFactory = failedMessagesStoreFactory;
this.domainEvents = domainEvents;
failedMessageStores = new Dictionary <string, IFailedMessagesStore>();
}
public RetryProcessor(IDispatchMessages sender, IDomainEvents domainEvents, ReturnToSenderDequeuer returnToSender, RetryingManager retryingManager)
{
this.sender = sender;
this.returnToSender = returnToSender;
this.retryingManager = retryingManager;
this.domainEvents = domainEvents;
corruptedReplyToHeaderStrategy = new CorruptedReplyToHeaderStrategy(RuntimeEnvironment.MachineName);
}
public ChatService(IDomainEvents domainEvents,
IClientFactory clientFactory,
IClientRepository clientRepository)
{
DomainEvents = domainEvents;
ClientFactory = clientFactory;
ClientRepository = clientRepository;
}
public void Setup()
{
factory = MockRepository.GenerateStub <IFailedMessagesStoreFactory>();
domainEvents = MockRepository.GenerateStub <IDomainEvents>();
service = new FailedMessagesService(factory, domainEvents);
store = MockRepository.GenerateStub <IFailedMessagesStore>();
store.Stub(x => x.GetAllMessages()).Return(new List <FailedMessage>());
factory.Stub(x => x.CreateFailedMessagesStore(adressOfFailedMessagesStore)).Return(store);
}
public AllInOneDbContext(
DbContextOptions <AllInOneDbContext> options,
IUserSession session,
IDomainEvents domainEvents
) : base(options)
{
_session = session;
_domainEvents = domainEvents;
}
public ItContractItSystemUsageController(
IGenericRepository <ItContractItSystemUsage> repository,
IGenericRepository <ItSystemUsage> usageRepository,
IDomainEvents domainEvent)
{
_repository = repository;
_usageRepository = usageRepository;
_domainEvent = domainEvent;
}
protected GenericRightsController(
IGenericRepository <TRight> rightRepository,
IGenericRepository <TObject> objectRepository,
IDomainEvents domainEvents)
{
RightRepository = rightRepository;
_objectRepository = objectRepository;
_domainEvents = domainEvents;
}
public OrganizationUnitRightController(
IGenericRepository <OrganizationUnitRight> rightRepository,
IGenericRepository <OrganizationUnit> objectRepository,
IDomainEvents domainEvents,
IOrgUnitService orgUnitService)
: base(rightRepository, objectRepository, domainEvents)
{
_orgUnitService = orgUnitService;
}
public ItContractRepository(
IGenericRepository <ItContract> contractRepository,
IGenericRepository <ItSystemUsage> systemUsageRepository,
IDomainEvents domainEvents)
{
_contractRepository = contractRepository ?? throw new ArgumentNullException(nameof(contractRepository));
_systemUsageRepository = systemUsageRepository ?? throw new ArgumentNullException(nameof(systemUsageRepository));
_domainEvents = domainEvents;
}
public void Setup()
{
factory = MockRepository.GenerateStub<IFailedMessagesStoreFactory>();
domainEvents = MockRepository.GenerateStub<IDomainEvents>();
service = new FailedMessagesService(factory, domainEvents);
store = MockRepository.GenerateStub<IFailedMessagesStore>();
store.Stub(x => x.GetAllMessages()).Return(new List<FailedMessage>());
factory.Stub(x => x.CreateFailedMessagesStore(adressOfFailedMessagesStore)).Return(store);
}
public VoteForHandler(
IDomainEvents domainEvents,
IVotersRepository votersRepository,
IIdentityService <VoterIdentity> identityService)
{
_domainEvents = domainEvents;
_votersRepository = votersRepository;
_identityService = identityService;
}
public CreateVoterHandler(
IMapper mapper,
IVotersRepository voters,
IDomainEvents domainEvents)
{
_mapper = mapper;
_voters = voters;
_domainEvents = domainEvents;
}
public OrganizationRightsService(
IAuthorizationContext authorizationContext,
IGenericRepository <OrganizationRight> organizationRightRepository,
IOrganizationalUserContext userContext,
IDomainEvents domainEvents)
{
_authorizationContext = authorizationContext;
_organizationRightRepository = organizationRightRepository;
_userContext = userContext;
_domainEvents = domainEvents;
}
public EmailMessageService(ILogger <EmailMessageService> logger,
IEmailMessageRepository repository,
IDomainEvents domainEvents,
IEmailNotification emailNotification,
IDateTimeProvider dateTimeProvider)
: base(repository, domainEvents)
{
_logger = logger;
_repository = repository;
_emailNotification = emailNotification;
_dateTimeProvider = dateTimeProvider;
}
public ItInterfaceService(
IGenericRepository <ItInterface> repository,
IGenericRepository <DataRow> dataRowRepository,
IItSystemRepository systemRepository,
IAuthorizationContext authorizationContext,
ITransactionManager transactionManager,
IDomainEvents domainEvents)
{
_repository = repository;
_dataRowRepository = dataRowRepository;
_systemRepository = systemRepository;
_authorizationContext = authorizationContext;
_transactionManager = transactionManager;
_domainEvents = domainEvents;
}
public ChatApplication(IChatFacade chatFacade,
ITextualCommandMapper textualCommandMapper,
IMessageBroker messageBroker,
ICommunicator <string> communicator,
IDomainEvents domainEvents)
{
ChatFacade = chatFacade;
TextualCommandMapper = textualCommandMapper;
MessageBroker = messageBroker;
Communicator = communicator;
DomainEvents = domainEvents;
BindCommunicatorEvents();
BindDomainEvents();
}
public ErrorQueueImport(IBuilder builder, ISendMessages forwarder, IDocumentStore store, IDomainEvents domainEvents, CriticalError criticalError, LoggingSettings loggingSettings, Settings settings, BodyStorageFeature.BodyStorageEnricher bodyStorageEnricher)
{
this.builder = builder;
this.forwarder = forwarder;
this.store = store;
this.criticalError = criticalError;
this.loggingSettings = loggingSettings;
this.settings = settings;
this.bodyStorageEnricher = bodyStorageEnricher;
this.domainEvents = domainEvents;
enrichers = builder.BuildAll <IEnrichImportedMessages>().Where(e => e.EnrichErrors).ToArray();
var failedEnrichers = builder.BuildAll <IFailedMessageEnricher>().ToArray();
failedMessageFactory = new FailedMessageFactory(failedEnrichers);
}
public KLEStandardRepository(
IKLEDataBridge kleDataBridge,
ITransactionManager transactionManager,
IGenericRepository <TaskRef> existingTaskRefRepository,
IGenericRepository <ItSystemUsage> systemUsageRepository,
IGenericRepository <TaskUsage> taskUsageRepository,
IOperationClock clock,
ILogger logger,
IDomainEvents domainEvents) : this(new KLEParentHelper(), new KLEConverterHelper(clock), taskUsageRepository)
{
_kleDataBridge = kleDataBridge;
_transactionManager = transactionManager;
_existingTaskRefRepository = existingTaskRefRepository;
_systemUsageRepository = systemUsageRepository;
_logger = logger;
_domainEvents = domainEvents;
}
public HomeController(IDomainEvents domainEvents)
{
_domainEvents = domainEvents;
}
public CommentHub(IDomainEvents domainEvents)
{
_domainEvents = domainEvents;
}
//
// GET: /Api/
public TestController(IDomainEvents domainEvents)
{
_domainEvents = domainEvents;
}
