/// <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;
}
