/// <summary> /// Initializes a new instance of the <see cref="MessageRouter"/> class. /// </summary> /// <param name="messageHandlerFactory">IMessageHandlerFactory to instantiate IMessageHandler.</param> /// <param name="queueRepository">IQueueRepository instance.</param> public MessageRouter(IMessageHandlerFactory messageHandlerFactory, IQueueRepository queueRepository) { this.messageHandlerFactory = messageHandlerFactory; this.queueRepository = queueRepository; this.VisibilityTimeOut = ConfigReader<int>.GetSetting(VisibilityTimeOutAppSettingName); diagnostics = new DiagnosticsProvider(this.GetType()); }
/// <summary> /// </summary> /// <param name="repository"> /// Used to provide all queues that this broker is for. There is a built in class, /// <see cref="MemoryQueueRepository" />, which you can use. /// </param> public StompBroker(IQueueRepository repository) { if (repository == null) { throw new ArgumentNullException("repository"); } _queues = repository; _tcpListener = new StompTcpListener { MessageReceived = OnMessageReceived, MessageSent = OnMessageDelivered }; _tcpListener.ClientConnected += OnClientConnected; _tcpListener.ClientDisconnected += OnClientDisconnected; ServerName = "Griffin.Queue/1.0"; var connectHandler = new ConnectHandler(new NoAuthenticationService(), ServerName); _frameHandlers.Add("ACK", new AckHandler()); _frameHandlers.Add("ABORT", new AbortHandler()); _frameHandlers.Add("BEGIN", new BeginHandler()); _frameHandlers.Add("COMMIT", new CommitHandler()); _frameHandlers.Add("CONNECT", connectHandler); _frameHandlers.Add("DISCONNECT", new MessageHandlers.DisconnectHandler()); _frameHandlers.Add("NACK", new NackHandler(_queues)); _frameHandlers.Add("SEND", new SendHandler(_queues)); _frameHandlers.Add("SUBSCRIBE", new SubscribeHandler(_queues)); _frameHandlers.Add("STOMP", connectHandler); }
public static async Task Scheduler( [TimerTrigger("0 */1 * * * *")] TimerInfo timer, // every minutes [Table(TableNames.CommSchedule)] CloudTable scheduleTable, [Inject] IQueueRepository queueRepository, ILogger log) { var rowRange = timer.ResolveRowRange(); // 1. Get the first segment of the scheduled messages. var exec = await scheduleTable.GetFirstSegmentOf <MessageSchedule>(CommSchedulePartitionKeys.Scheduled, rowRange); if (exec.Results.Count == 0) { return; } var schedules = exec.Results; // TODO: can do additional schedule filter here if it is required // var delayed = await schedules.MoveTo(scheduleTable // , s => CommSchedulePartitionKeys.Scheduled // , s => idGenerator.ScheduleId(timestamp, "!") // ); // // return; // 2. mark they as in progress var results = await schedules.MoveTo(scheduleTable, schedule => CommSchedulePartitionKeys.InProgress); // 3. push to send queue await results.DispatchTo(queueRepository); }
/// <summary> /// QueueItemsController constructor /// </summary> /// <param name="repository"></param> /// <param name="manager"></param> /// <param name="membershipManager"></param> /// <param name="userManager"></param> /// <param name="hub"></param> /// <param name="httpContextAccessor"></param> /// <param name="binaryObjectRepository"></param> /// <param name="configuration"></param> /// <param name="hubManager"></param> /// <param name="queueItemAttachmentRepository"></param> /// <param name="queueRepository"></param> /// <param name="scheduleRepository"></param> /// <param name="webhookPublisher"></param> public QueueItemsController( IQueueItemRepository repository, IQueueRepository queueRepository, IQueueItemManager manager, IMembershipManager membershipManager, ApplicationIdentityUserManager userManager, IHubContext <NotificationHub> hub, IHttpContextAccessor httpContextAccessor, IHubManager hubManager, IScheduleRepository scheduleRepository, IConfiguration configuration, IBinaryObjectRepository binaryObjectRepository, IQueueItemAttachmentRepository queueItemAttachmentRepository, IWebhookPublisher webhookPublisher, IOrganizationSettingManager organizationSettingManager) : base(repository, userManager, httpContextAccessor, membershipManager, configuration) { this.manager = manager; _hub = hub; this.queueRepository = queueRepository; this.hubManager = hubManager; scheduleRepo = scheduleRepository; Configuration = configuration; this.binaryObjectRepository = binaryObjectRepository; this.queueItemAttachmentRepository = queueItemAttachmentRepository; this.webhookPublisher = webhookPublisher; this.organizationSettingManager = organizationSettingManager; }
public Reconciler( ISapphireRepository sapphireRepository, ICompanyRepository companyRepository, IPurchaseOrderHeaderRepository purchaseOrderHeaderRepository, IQueueRepository queueRepository, IServiceLog serviceLog, IConsoleLogger consoleLogger, IImportService importService, IExportService exportService, IJobCostActivityService jobCostActivityService, IJobService jobService, IVariancePurchaseOrderService variancePurchaseOrderService) { _sapphireRepository = sapphireRepository; _companyRepository = companyRepository; _purchaseOrderHeaderRepository = purchaseOrderHeaderRepository; _queueRepository = queueRepository; _serviceLog = serviceLog; _consoleLogger = consoleLogger; _importService = importService; _exportService = exportService; _jobCostActivityService = jobCostActivityService; _jobService = jobService; _variancePurchaseOrderService = variancePurchaseOrderService; }
/// <summary> /// コンストラクタ /// </summary> /// <param name="settings">設定</param> /// <param name="logger">ロガー</param> /// <param name="timeProvider">DateTimeの提供元</param> /// <param name="dtAlarmRepository">アラームリポジトリ</param> /// <param name="dtEquipmentRepository">機器リポジトリ</param> /// <param name="dtAlarmConfigRepository">アラーム設定リポジトリ</param> /// <param name="queueRepository">Queueリポジトリ</param> /// <param name="failureRepository">Failureストレージリポジトリ</param> public AlarmRegisterService( OperationAppSettings settings, ILogger <AlarmRegisterService> logger, ITimeProvider timeProvider, IDtAlarmRepository dtAlarmRepository, IDtEquipmentRepository dtEquipmentRepository, IDtAlarmConfigRepository dtAlarmConfigRepository, IQueueRepository queueRepository, IFailureRepository failureRepository) { Assert.IfNull(settings); Assert.IfNull(logger); Assert.IfNull(timeProvider); Assert.IfNull(dtAlarmRepository); Assert.IfNull(dtEquipmentRepository); Assert.IfNull(dtAlarmConfigRepository); Assert.IfNull(queueRepository); Assert.IfNull(failureRepository); _settings = settings; _logger = logger; _timeProvider = timeProvider; _dtAlarmRepository = dtAlarmRepository; _dtEquipmentRepository = dtEquipmentRepository; _dtAlarmConfigRepository = dtAlarmConfigRepository; _queueRepository = queueRepository; _failureRepository = failureRepository; }
public DatabaseMessageQueue( [NotNull] ITimeService timeService, [NotNull] IQueueRepository queueRepository) { _timeService = timeService; _queueRepository = queueRepository; }
/// <summary> /// Leveraging the new Azure Functions Dependency Injection by sending common services in the constructor /// </summary> /// <param name="filesRepo">Cosmos Db repository for Cognitive Files</param> public NewCognitiveReq(ICognitiveFileRepository filesRepo, IUserAccountRepository usersRepo, IStorageRepository storageRepo, IQueueRepository queueRepo) { cognitiveFilesRepo = filesRepo; userAccountsRepo = usersRepo; filesStorageRepo = storageRepo; newReqsQueue = queueRepo; }
public TransformImage(IQueueRepository queueRepository) { _queueRepository = queueRepository; _sizes = Environment.GetEnvironmentVariable("Sizes") .Split(',') .Select(s => int.Parse(s)); }
/// <summary> /// Initializes a new instance of the <see cref="PublishQueueService"/> class. /// </summary> /// <param name="fileServiceFactory">IFileServiceFactory instance.</param> /// <param name="repositoryService">IRepository instance.</param> /// <param name="queueRepository">QueueRepository instance.</param> public PublishQueueService(IFileServiceFactory fileServiceFactory, IRepositoryService repositoryService, IQueueRepository queueRepository) { this.fileServiceFactory = fileServiceFactory; this.RepositoryService = repositoryService; this.QueueRepository = queueRepository; this.Diagnostics = new DiagnosticsProvider(this.GetType()); }
public ImportService(ISapphireRepository SapphireRepository, IPurchaseOrderHeaderRepository purchaseOrderHeaderRepository, IQueueRepository QueueRepository, IServiceLog ServiceLog) { _sapphireRepository = SapphireRepository; _purchaseOrderHeaderRepository = purchaseOrderHeaderRepository; _queueRepository = QueueRepository; _serviceLog = ServiceLog; }
public JobQueue(IQueueRepository queueRepo) { _queueRepo = queueRepo; MachineBalance = 0; internalQueue.AddRange(_queueRepo.getTasksForQueue()); UpdateBalances(internalQueue); }
/// <summary> /// Adds the object to the notification queue. /// </summary> /// <param name="request">Request to be added to notification queue.</param> public static void AddToNotificationQueue(this object request) { IQueueRepository queueRepository = DependencyResolver.Current.GetService(typeof(IQueueRepository)) as IQueueRepository; CloudQueueMessage message = queueRepository.Pack(request); queueRepository.NotificationQueue.AddMessage(message); }
public void Init() { queueRepository = A.Fake <IQueueRepository>(); system = A.Fake <IFileSystem>(); provider = A.Fake <ISendingProvider>(); CreateFile(SrcFile1); CreateFile(StreamFile1); fakeStream = new FileStream(StreamFile1, FileMode.Open, FileAccess.Read); queue = new FileTransferQueue(QueueName); queue.Enqueue(new FileItem { DestPath = DestFile1, SrcPath = SrcFile1 }); queue.Enqueue(new FileItem { DestPath = "./1.txt", Identifier = Identifier1 }); queue.Enqueue(new FileItem { DestPath = "./2.txt", Identifier = Identifier2 }); A.CallTo(() => queueRepository.Load(QueueName)).Returns(queue); A.CallTo(() => system.GetStream(A <string> .Ignored)).Returns(fakeStream); A.CallTo(() => provider.Send(A <Stream> .Ignored, A <string> .Ignored)).Returns(true); manager = new FileTransferQueueManager(QueueName, queueRepository, system, provider); manager.NotificationRaised += manager_NotificationRaised; }
/// <summary> /// コンストラクタ /// </summary> /// <param name="settings">設定</param> /// <param name="logger">ロガー</param> /// <param name="timeProvider">DateTimeの提供元</param> /// <param name="dtAlarmSmartPremonitorRepository">ディスクドライブ予兆監視アラーム定義リポジトリ</param> /// <param name="dtSmartAnalysisResultRepository">SMART解析判定結果リポジトリ</param> /// <param name="queueRepository">Queueリポジトリ</param> /// <param name="failureRepository">Failureストレージリポジトリ</param> public DiskDrivePremonitorService( UtilityAppSettings settings, ILogger <DiskDrivePremonitorService> logger, ITimeProvider timeProvider, IDtAlarmSmartPremonitorRepository dtAlarmSmartPremonitorRepository, IDtSmartAnalysisResultRepository dtSmartAnalysisResultRepository, IQueueRepository queueRepository, IFailureRepository failureRepository) { Assert.IfNull(settings); Assert.IfNull(logger); Assert.IfNull(timeProvider); Assert.IfNull(dtAlarmSmartPremonitorRepository); Assert.IfNull(dtSmartAnalysisResultRepository); Assert.IfNull(queueRepository); Assert.IfNull(failureRepository); _settings = settings; _logger = logger; _timeProvider = timeProvider; _dtAlarmSmartPremonitorRepository = dtAlarmSmartPremonitorRepository; _dtSmartAnalysisResultRepository = dtSmartAnalysisResultRepository; _queueRepository = queueRepository; _failureRepository = failureRepository; }
public FortuneService( IQueueRepository queueRepository, IMapper mapper) { _queueRepository = queueRepository; _mapper = mapper; }
public ThePrintersController(IHostingEnvironment env, IConfiguration configuration) { contentRoot = env.ContentRootPath; _configuration = configuration; _queueRepository = new DBQueueRepository(_configuration.GetConnectionString("ServiceDbLive"), _configuration.GetConnectionString("ServiceDbTest")); _printerRepository = new DBPrintRepository(_configuration.GetConnectionString("DBAccessCon")); }
public DirectoryService(IDirectoryRepository directoryRepository, IQueueService queueService, IQueueRepository queueRepository, ILogger logger) { _directoryRepository = directoryRepository; _queueService = queueService; _queueRepository = queueRepository; _logger = logger; }
public QueueService(IEmployeeRepository employeeRepository, IQueueRepository queueRepository, IUnitOfWork uow, IQueueLocalPhoneStoreRepository queueLocalPhoneRepository) { _employeeRepository = employeeRepository; _queueRepository = queueRepository; _queueLocalPhoneRepository = queueLocalPhoneRepository; _uow = uow; }
/// <summary> /// Initializes a new instance of the <see cref="MessageHandlerFactory"/> class. /// </summary> /// <param name="fileServiceFactory">IFileServiceFactory to instantiate IFileService.</param> /// <param name="repositoryService">IRepositoryService instance.</param> /// <param name="queueRepository">IQueueRepository instance.</param> /// <param name="blobRepository">IBlobRepository instance.</param> public MessageHandlerFactory(IFileServiceFactory fileServiceFactory, IRepositoryService repositoryService, IQueueRepository queueRepository, IBlobDataRepository blobRepository) { this.fileServiceFactory = fileServiceFactory; this.repositoryService = repositoryService; this.queueRepository = queueRepository; this.blobRepository = blobRepository; diagnostics = new DiagnosticsProvider(this.GetType()); }
/// <summary> /// Initializes a new instance of the <see cref="VerifyFileQueueService"/> class. /// </summary> /// <param name="fileServiceFactory">IFileServiceFactory instance.</param> /// <param name="repositoryService">IRepositoryService instance.</param> /// <param name="queueRepository">IQueueRepository instance.</param> /// <param name="blobDataRepository">IBlobRepository instance.</param> public VerifyFileQueueService(IFileServiceFactory fileServiceFactory, IRepositoryService repositoryService, IQueueRepository queueRepository, IBlobDataRepository blobDataRepository) { this.fileServiceFactory = fileServiceFactory; this.RepositoryService = repositoryService; this.QueueRepository = queueRepository; this.blobDataRepository = blobDataRepository; this.Diagnostics = new DiagnosticsProvider(this.GetType()); }
/// <summary> /// Initializes a new instance of the <see cref="UnsubscribeHandler"/> class. /// </summary> /// <param name="queueRepository">The queue repository.</param> /// <exception cref="System.ArgumentNullException">queueRepository</exception> public UnsubscribeHandler(IQueueRepository queueRepository) { if (queueRepository == null) { throw new ArgumentNullException("queueRepository"); } _queueRepository = queueRepository; }
public FortuneService( IQueueRepository queueRepository, IMapper mapper) { _queueRepository = queueRepository; _mapper = mapper; InitializeMessages(); }
public FileTransferQueueManager(string queueName, IQueueRepository queueRepository, IFileSystem system, ISendingProvider provider) { this.queueName = queueName; fileQueue = new FileTransferQueue(queueName); this.queueRepository = queueRepository; this.system = system; this.provider = provider; }
public BookingController(IComputerRepository computerRepository, IQueueRepository queueRepository, IHttpContextAccessor httpContextAccessor, UserManager <ApplicationUser> userManager) { _computerRepository = computerRepository; _queueRepository = queueRepository; _currentUserId = httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value; _userManager = userManager; }
public ApplicationService(IRepositoryService repositoryService, IProfileRepository profileRepository, IClientFactoryService clientFactoryService, IQueService queueService, IQueueRepository queueRepository) { this._repositoryService = repositoryService; this._profileRepository = profileRepository; this._clientFactoryService = clientFactoryService; this._queueService = queueService; this._queueRepository = queueRepository; }
public LocalPhoneStoreEmployeeService(IEmployeeRepository employeeRepository, ILocalPhoneStoreRepository localPhoneStoreRepository, IQueueRepository queueRepository, IQueueLocalPhoneStoreRepository queueLocalPhoneRepository, ILocalPhoneStoreEmployeeRepository localPhoneStoreEployeeRepository, IUnitOfWork uow) { _employeeRepository = employeeRepository; _localPhoneStoreRepository = localPhoneStoreRepository; _queueRepository = queueRepository; _queueLocalPhoneRepository = queueLocalPhoneRepository; _localPhoneStoreEployeeRepository = localPhoneStoreEployeeRepository; _uow = uow; }
public QueuesController( IQueueRepository repository, IQueueManager queueManager, IMembershipManager membershipManager, ApplicationIdentityUserManager userManager, IConfiguration configuration, IHttpContextAccessor httpContextAccessor) : base(repository, userManager, httpContextAccessor, membershipManager, configuration) { this.queueManager = queueManager; }
public PickupSubscriberModule( IQueueRepository queueRepository, ISubscriberCommandService subscriberCommandService, IMiscCommandService miscCommandService ) { _queueRepository = queueRepository; _subscriberCommandService = subscriberCommandService; _miscCommandService = miscCommandService; }
public Exporter(IQueueRepository source, ISalsaRepository destination, ISyncErrorHandler errorHandler, int batchSize, string name, string objectType, string queueName) { Name = name; _objectType = objectType; _queueName = queueName; _destination = destination; _errorHandler = errorHandler; _source = source; _batchSize = batchSize; }
public ManagementConfiguration() { queueRepositoryType = ConfigurationItem<string>.ReadSetting("QueueRepositoryType", string.Empty); queueRepository = new NullQueueRepository(); HasQueueRepository = false; dataStoreRepositoryType = ConfigurationItem<string>.ReadSetting("DataStoreRepositoryType", string.Empty); dataStoreRepository = new NullDataStoreRepository(); HasDataStoreRepository = false; }
public EventLogQueueRepositoryImpl(string applicationName) { if (Configuration.LoggingConnectionString == null) { FailoverToWindowsEventLog("EventLog connection string was not found in the configuration file", null, EventLogEntryType.Warning); } else { _queue = new BEKlibrary.EventLog.Datalayer.QueueRepository(); } }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IHostingEnvironment env, IQueueRepository r) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); r.AddTickets(TestDataProducer.GetTickets()); r.AddCategories(TestDataProducer.GeCategories()); } app.UseMvc(); }
public QueueApplication(IUnitOfWork unitOfWork, IQueueRepository queueRepository, IQueueHistoryRepository queueHistoryRepository, IDeliverymanRepository deliverymanRepository, ICompanyBranchRepository companyBranchRepository, IAddressRepository addressRepository, IOrderRepository orderRepository) : base(unitOfWork) { _queueRepository = queueRepository; _queueHistoryRepository = queueHistoryRepository; _deliverymanRepository = deliverymanRepository; _companyBranchRepository = companyBranchRepository; _addressRepository = addressRepository; _orderRepository = orderRepository; }
/// <summary> /// Initializes a new instance of the <see cref="QueueContainer"/> class. /// </summary> /// <param name="configuration">The queue configuration.</param> /// <param name="repository">The storage repository.</param> /// <exception cref="System.ArgumentNullException"> /// configuration /// or /// repository /// </exception> public QueueContainer(IQueueConfiguration configuration, IQueueRepository repository) { if (configuration == null) throw new ArgumentNullException("configuration"); if (repository == null) throw new ArgumentNullException("repository"); _name = configuration.Name; _configuration = configuration; _repository = repository; }
public SubscriberCommandService( IQueueRepository queueRepository, ISubscriberActivitiesRepository activitiesRepository, IListCommandService listCommandService, IMiscCommandService miscCommandService ) { _queueRepository = queueRepository; _activitiesRepository = activitiesRepository; _listCommandService = listCommandService; _miscCommandService = miscCommandService; }
public CalculationHelper(IActivityLogger activityLogger, IQueueRepository repository, IConfiguration configuration, ICalculationAgregator calculationAgregator, IQueueWatcher queueWatcher) { this.activityLogger = activityLogger; this.repository = repository; this.configuration = configuration; this.calculationAgregator = calculationAgregator; this.queueWatcher = queueWatcher; }
/// <summary> /// Initializes a new instance of the <see cref="QueueContainer"/> class. /// </summary> /// <param name="configuration">The queue configuration.</param> /// <param name="repository">The storage repository.</param> /// <exception cref="System.ArgumentNullException"> /// configuration /// or /// repository /// </exception> public QueueContainer(IQueueConfiguration configuration, IQueueRepository repository) { if (configuration == null) throw new ArgumentNullException(nameof(configuration)); if (repository == null) throw new ArgumentNullException(nameof(repository)); Name = configuration.Name; Configuration = configuration; Repository = repository; }
public void SetUp() { _mockLogger = new Mock <ILogger>(); _mockLogger.Setup(s => s.Logar(It.IsAny <string>(), It.IsAny <TipoLog>())); _torre = new global::Domain.TorreHanoi.TorreHanoi(3, _mockLogger.Object); var mockCacheManager = new Mock <ICacheManager>(); mockCacheManager.Setup(s => s.Set(It.IsAny <string>())); mockCacheManager.Setup(s => s.Get(It.IsAny <string>())).Returns(CriarMockGetCacheManager); _repository = new QueueRepository(mockCacheManager.Object); }
/// <summary> /// Initializes a new instance of the <see cref="MessageWorkerBase"/> class. /// </summary> /// <param name="processor">The parent processor.</param> /// <param name="name">The name of the worker.</param> /// <exception cref="ArgumentNullException"><paramref name="processor"/> is <see langword="null" />.</exception> protected MessageWorkerBase(IMessageProcessor processor, string name) { if (processor == null) throw new ArgumentNullException("processor"); if (name == null) throw new ArgumentNullException("name"); _name = name; _processor = processor; _container = _processor.Container; _configuration = _container.Configuration; _repository = _container.Repository; _random = new Random(); _pollTimer = new Timer(PollQueue); }
/// <summary> /// Initializes a new instance of the <see cref="StompBroker" /> class. /// </summary> /// <param name="repository"> /// Used to provide all queues that this broker is for. There is a built in class, /// <see cref="MemoryQueueRepository" />, which you can use. /// </param> /// <exception cref="System.ArgumentNullException">repository</exception> public StompBroker(IQueueRepository repository) { if (repository == null) throw new ArgumentNullException("repository"); _queues = repository; _tcpListener = new StompTcpListener {MessageReceived = OnMessageReceived, MessageSent = OnMessageDelivered}; _tcpListener.ClientConnected += OnClientConnected; _tcpListener.ClientDisconnected += OnClientDisconnected; ServerName = "Griffin.Queue/1.0"; var connectHandler = new ConnectHandler(new NoAuthenticationService(), ServerName); _frameHandlers.Add("ACK", new AckHandler()); _frameHandlers.Add("ABORT", new AbortHandler()); _frameHandlers.Add("BEGIN", new BeginHandler()); _frameHandlers.Add("COMMIT", new CommitHandler()); _frameHandlers.Add("CONNECT", connectHandler); _frameHandlers.Add("DISCONNECT", new DisconnectHandler()); _frameHandlers.Add("NACK", new NackHandler(_queues)); _frameHandlers.Add("SEND", new SendHandler(_queues)); _frameHandlers.Add("SUBSCRIBE", new SubscribeHandler(_queues)); _frameHandlers.Add("STOMP", connectHandler); }
/// <summary> /// Reuturns the message Router instance. /// </summary> /// <param name="nullMessageHandler">Indicates if the handler has to be returned or not.</param> /// <returns>MessaeRouter instance.</returns> private MessageRouter GetMessageRouter(bool nullMessageHandler) { this.processedMessage = new List<BaseMessage>(); this.fileServiceFactory = new StubIFileServiceFactory(); this.repositoryService = new StubIRepositoryService(); this.blobRepository = new StubIBlobDataRepository(); IMessageHandler messageHandler = null; if (!nullMessageHandler) { messageHandler = new StubIMessageHandler() { ProcessMessageBaseMessage = (message) => { this.processedMessage.Add(message); } }; } this.messageHandlerFactory = new StubIMessageHandlerFactory { GetMessageHandlerMessageHandlerEnum = (handler) => { return messageHandler; } }; this.queueRepository = new StubIQueueRepository() { GetQueuedMessagesInt32Int32 = (noofmessages, visibilityTimeout) => { return this.messages; } }; MessageRouter messageRouter = new MessageRouter(this.messageHandlerFactory, this.queueRepository); return messageRouter; }
public TwilioQueueProvider(IAccountSettings accountSettings, IQueueRepository queueRepository, ILogger logger) { _accountSettings = accountSettings; _queueRepository = queueRepository; _logger = logger; }
public SendHandler(IQueueRepository queueRepository) { if (queueRepository == null) throw new ArgumentNullException("queueRepository"); _queueRepository = queueRepository; }
/// <summary> /// Reuturns the PublishQueueServicer instance. /// </summary> /// <param name="nullMessageHandler">Indicates if the handler has to be returned or not.</param> /// <returns>MessaeRouter instance.</returns> private PublishQueueService GetPublishQueueService() { this.fileService = new StubIFileService() { PublishFilePublishMessage = (publishMessage) => { return "successfull"; }, GetFileByFileIdInt32 = (fileId) => { this.file = new File() { FileId = 1 }; return file; }, UpdateFileFile = (file) => { this.file = file; return true; }, }; this.fileServiceFactory = new StubIFileServiceFactory() { GetFileServiceString = (instanceName) => { return this.fileService; } }; this.repositoryService = new StubIRepositoryService() { GetRepositoryByIdInt32 = (repositoryId) => { return new Repository() { BaseRepository = new BaseRepository() { Name = "SkyDrive", BaseRepositoryId = 2 }, RepositoryId = 1, Name = "test" }; } }; this.queueRepository = new StubIQueueRepository() { AddMessageToQueueBaseMessage = (message) => { this.addedMessage = message; }, DeleteFromQueueBaseMessage = (message) => { this.deletedMessage = message; }, UpdateMessageBaseMessage = (message) => { this.updatedQueueContent = true; } }; PublishQueueService publishQueueService = new PublishQueueService(this.fileServiceFactory, this.repositoryService, this.queueRepository); return publishQueueService; }
/// <summary> /// Initializes a new instance of the NotificationService class. /// </summary> /// <param name="queueRepository"> /// Instance of queue repository. /// </param> public NotificationService(IQueueRepository queueRepository) { this._queueRepository = queueRepository; }
public QueueService(IQueueRepository queueRepository, IQueueProvider queueProvider, IAgentAuthenticationRepository agentAuthenticationRepository) { _queueRepository = queueRepository; _queueProvider = queueProvider; _agentAuthenticationRepository = agentAuthenticationRepository; }
public ImageManagerService(IQueueRepository queueRepository, IImageRepository imageRepository, ILogger logger) { this.queueRepository = queueRepository; this.imageRepository = imageRepository; this.logger = logger; }
public QueuePresenter(IQueueRepository queueRepository, IMessageRepository messageRepository) { this.queueRepository = queueRepository; this.messageRepository = messageRepository; Queues = new ObservableCollection<QueueModel>(); }
/// <summary> /// Reuturns the VerifyFileQueueService instance. /// </summary> /// <returns>VerifyFileQueueService instance.</returns> private VerifyFileQueueService GetVerifyFileQueueService() { this.fileService = new StubIFileService() { CheckIfFileExistsOnExternalRepositoryVerifyFileMessage = (message) => { return OperationStatus.CreateSuccessStatus(); }, GetFileByFileIdInt32 = (fileId) => { this.file = new File() { FileId = 1 }; return file; }, UpdateFileFile = (file) => { this.file = file; return true; }, }; this.fileServiceFactory = new StubIFileServiceFactory() { GetFileServiceString = (instanceName) => { return this.fileService; } }; this.repositoryService = new StubIRepositoryService() { GetRepositoryByIdInt32 = (repositoryId) => { return new Repository() { BaseRepository = new BaseRepository() { Name = "SkyDrive", BaseRepositoryId = 2 }, RepositoryId = 1, Name = "test" }; } }; this.queueRepository = new StubIQueueRepository() { DeleteFromQueueBaseMessage = (message) => { this.deletedMessage = message; }, UpdateMessageBaseMessage = (message) => { this.updatedQueueContent = true; } }; this.blobRepository = new StubIBlobDataRepository() { DeleteFileString = (filename) => { this.isDeletedFromBlob = true; return this.isDeletedFromBlob; } }; VerifyFileQueueService queueService = new VerifyFileQueueService(this.fileServiceFactory, this.repositoryService, this.queueRepository, this.blobRepository); return queueService; }
public SubscribeHandler(IQueueRepository queueRepository) { _queueRepository = queueRepository; }
private void InitializeQueueRepository() { Log.Debug("Initializing QueueRepositoryType."); if (string.IsNullOrEmpty(QueueRepositoryType)) { Log.Warning(ManagementResources.NoQueueRepositoryTypeSpecified); return; } Log.Information(string.Format(ManagementResources.AttemptCreationOfQueueRepository, QueueRepositoryType)); try { var type = new ReflectionService().GetType( candidate => candidate.Name.Equals(QueueRepositoryType, StringComparison.InvariantCultureIgnoreCase) || candidate.AssemblyQualifiedName.Equals(QueueRepositoryType, StringComparison.InvariantCultureIgnoreCase)); if (type == null) { Log.Error(string.Format(ManagementResources.QueueRepositoryTypeNotFound, QueueRepositoryType)); return; } queueRepository = (IQueueRepository)Activator.CreateInstance(type); HasQueueRepository = true; Log.Information(string.Format(ManagementResources.QueueRepositoryCreationSuccessful, QueueRepositoryType)); } catch (Exception ex) { Log.Error(string.Format(ManagementResources.QueueRepositoryCreationException, QueueRepositoryType, ex.CompactMessages())); } }
/// <summary> /// Initializes a new instance of the <see cref="MessageRouter"/> class. /// </summary> /// <param name="queueRepository">IQueueRepository instance.</param> public MessageRouter(IQueueRepository queueRepository) { this.queueRepository = queueRepository; }
public NackHandler(IQueueRepository queueRepository) { _queueRepository = queueRepository; }