private static void TestStringEqual(IProcessorFactory factory, object superImportantReference)
{
const string FILTER_VALUE = "Hello, World!";
var processor = factory.Create(
ProcessorType.StringEqual,
superImportantReference,
FILTER_VALUE);
if (!processor.TryProcess(FILTER_VALUE))
{
throw new InvalidOperationException("This should have matched.");
}
if (processor.TryProcess("Goodbye, Cruel World!"))
{
throw new InvalidOperationException("This should not have matched.");
}
if (processor.TryProcess(10))
{
throw new InvalidOperationException("This should not have matched.");
}
if (processor.TryProcess(new object()))
{
throw new InvalidOperationException("This should not have matched.");
}
}
public HomeController(IProcessorFactory factory, PayChannelService payChannelService,
PayOrderService payOrderService)
{
this.factory = factory;
this._payChannelService = payChannelService;
this._payOrderService = payOrderService;
}
private static void TestGreaterThan(IProcessorFactory factory, object superImportantReference)
{
const int FILTER_VALUE = 10;
var processor = factory.Create(
ProcessorType.GreaterThan,
superImportantReference,
FILTER_VALUE);
if (processor.TryProcess(FILTER_VALUE - 5))
{
throw new InvalidOperationException("This should not have been greater than.");
}
if (!processor.TryProcess(FILTER_VALUE + 5))
{
throw new InvalidOperationException("This should have been greater than.");
}
if (processor.TryProcess("This isn't a number."))
{
throw new InvalidOperationException("This should have failed because the input is invalid.");
}
if (processor.TryProcess(new object()))
{
throw new InvalidOperationException("This should have failed because the input is invalid.");
}
}
static FacturanetProcessorFactory()
{
ProcessorFactoryCollection = new List <IProcessorFactory>();
IProcessorFactory processorFactory;
string cfgDriverAssembly = ConfigurationManager.AppSettings["ModuleAssembly"];
string cfgDriverType = ConfigurationManager.AppSettings["ModuleType"];
processorFactory = (IProcessorFactory)(Activator.CreateInstance(
cfgDriverAssembly,
cfgDriverType)).Unwrap();
ProcessorFactoryCollection.Add(processorFactory);
////////////////////////////////////////////////////////////
// TODO: habría que hacer que se cargue un array de factories
////////////////////////////////////////////////////////////
#if DEBUG
string cfgDriverAssemblyMock = ConfigurationManager.AppSettings["ModuleAssemblyTest"];
string cfgDriverTypeMock = ConfigurationManager.AppSettings["ModuleTypeTest"];
ProcessorFactoryMock = (IProcessorFactory)(Activator.CreateInstance(
cfgDriverAssemblyMock,
cfgDriverTypeMock)).Unwrap();
#endif
Instance = new FacturanetProcessorFactory();
}
private static void TestLessThan(IProcessorFactory factory, object superImportantReference)
{
const int FILTER_VALUE = 10;
var processor = factory.Create(
ProcessorType.LessThan,
superImportantReference,
FILTER_VALUE);
if (!processor.TryProcess(FILTER_VALUE - 5))
{
throw new InvalidOperationException("This should have been less than.");
}
if (processor.TryProcess(FILTER_VALUE + 5))
{
throw new InvalidOperationException("This should not have been less than.");
}
if (processor.TryProcess("This isn't a number."))
{
throw new InvalidOperationException("This should have failed because the input is invalid.");
}
if (processor.TryProcess(new object()))
{
throw new InvalidOperationException("This should have failed because the input is invalid.");
}
}
public TasksController(
ILoggerFactory loggerFactory,
IProcessorFactory processorFactory)
{
_logger = loggerFactory.CreateLogger <TasksController>();
_processorFactory = processorFactory;
}
protected CompressionSettings()
{
_inputQueueFactory = CreateDefaultInputQueueFactory();
_reader = CreateDefaultReader();
_writer = CreateDefaultWriter();
_processorFactory = CreateProcessorFactory();
}
public ProcessorThreadPool(string name, int threadCount, IProcessorFactory processorFactory)
{
_name = name;
_threadCount = threadCount;
_processorFactory = processorFactory;
_log = Log.For(this);
}
protected PonyTextContext(AbstractTextElement textElement, IProcessorFactory processorFactory)
{
this.textElement = textElement;
ProcessorFactory = processorFactory;
MacroTable = new MacroTable();
ContextProperty = new PropertyConfiguration();
Metadata = new ContextMetadata();
}
private void RegisterDefaultContent(IProcessorFactory processorFactory)
{
processorFactory.RegisterContentFor <GetUserBlogsProcessor>(MetaWeblogActions.GetUsersBlogs);
processorFactory.RegisterContentFor <GetCategoriesProcessor>(MetaWeblogActions.GetCategories);
processorFactory.RegisterContentFor <GetRecentPostsProcessor>(MetaWeblogActions.GetRecentPosts);
processorFactory.RegisterContentFor <NewPostProcessor>(MetaWeblogActions.NewPost);
processorFactory.RegisterContentFor <DeletePostProcessor>(MetaWeblogActions.DeletePost);
}
public ProcessorThreadPool(string name, int threadCount, IProcessorFactory processorFactory)
{
this.name = name;
this.threadCount = threadCount;
this.processorFactory = processorFactory;
_log = Log.For(this);
}
public BootstrapperClass(IProcessorFactory processorFactory, IBootstrapperSettings bootstrapSettings, ILogger logger)
{
this.processorFactory = processorFactory;
this.bootstrapSettings = bootstrapSettings;
this.logger = logger;
Debug.Assert(this.bootstrapSettings != null, "Bootstrapper settings should not be null");
Debug.Assert(this.bootstrapSettings.Phase != AnalysisPhase.Unspecified, "Expecting the processing phase to be specified");
}
public VkDataFeedsParserProcess(IVkGroupRepository groupRepository, IUnitOfWorkProvider transactionProvider, IProcessorFactory processorFactory, IConfigurationProvider configProvider, IDateTimeHelper dateTimeHelper, IWebUtilities webUtilities, ILog log)
{
this.log = log;
this.processorFactory = processorFactory;
this.configProvider = configProvider;
this.dateTimeHelper = dateTimeHelper;
this.webUtilities = webUtilities;
this.groupRepository = groupRepository;
this.transactionProvider = transactionProvider;
}
public HomeController(
IProcessorFactory factory,
IServiceBus bus,
MerchantService merchantService
)
{
this.factory = factory;
this.bus = bus;
this._merchantService = merchantService;
}
public Engine(
IProcessorFactory processorFactory,
IJournalsMetaDataService journalsMetaService,
IHelpProvider helpProvider,
ILogger logger)
{
this.processorFactory = processorFactory ?? throw new ArgumentNullException(nameof(processorFactory));
this.journalsMetaService = journalsMetaService ?? throw new ArgumentNullException(nameof(journalsMetaService));
this.helpProvider = helpProvider ?? throw new ArgumentNullException(nameof(helpProvider));
this.logger = logger;
}
public MetaWeblogController(
IRequestMapperFactory requestMapperFactory,
IResponseMapperFactory responseMapperFactory,
IHttpResponseMessageMapperFactory httpResponseMessageMapperFactory,
IProcessorFactory processorFactory)
{
this.requestMapperFactory = requestMapperFactory;
this.responseMapperFactory = responseMapperFactory;
this.httpResponseMessageMapperFactory = httpResponseMessageMapperFactory;
this.processorFactory = processorFactory;
}
public MessageDispatcher(int numberOfProcessors, IProcessorFactory processorFactory)
{
_processors = Enumerable
.Range(0, numberOfProcessors)
.Select(i => processorFactory.Create(i.ToString(), this))
.ToList();
foreach (var processor in _processors)
{
processor.OnDone += Done;
}
}
/// <summary>
/// Processor a XML file into the MongoDB.
/// </summary>
/// <param name="directoryPath">the directory of all the files to process</param>
private static void ProcessFiles(string directoryPath)
{
foreach (var FileName in Directory.GetFiles(directoryPath))
{
IProcessor Processor = IProcessorFactory.GetProcessor(FileName);
if (Processor != null)
{
Processor.ProcessFile();
}
}
}
public ProcessorThreadPool(string name, int threadCount, IProcessorFactory processorFactory)
{
Guard.AgainstNull(processorFactory, nameof(processorFactory));
if (threadCount < 1)
{
throw new ThreadCountZeroException();
}
_name = name ?? Guid.NewGuid().ToString();
_threadCount = threadCount;
_processorFactory = processorFactory;
_log = Log.For(this);
}
static void Main(string[] args)
{
//register the container
Container container = GetRegisteredContainer();
//simulate the internal state of the program
_processorFactory = container.GetInstance <ProcessorFactory>();
//each of this request below simulate independant executing of the program
RunRequest(RequestType.Internal);
RunRequest(RequestType.External);
//just to hold the program
Console.ReadKey();
}
public DirectoryProcessor(string direcoryName, IJournalMeta journalMeta, IProcessorFactory processorFactory)
{
if (journalMeta == null)
{
throw new ArgumentNullException(nameof(journalMeta));
}
if (processorFactory == null)
{
throw new ArgumentNullException(nameof(processorFactory));
}
this.DirectoryName = direcoryName;
this.journalMeta = journalMeta;
this.processorFactory = processorFactory;
}
public PersonService(IProcessorFactory processor, IMapper mapper)
{
_processor = processor;
_mapper = mapper;
}
public StageProcessor(ISubscriberRepository subscriberRepository, IProcessorFactory processorFactory) : base(subscriberRepository)
{
_processorFactory = processorFactory;
}
public PersonProjection(IProcessorFactory processor, IMapper mapper)
{
_processor = processor;
_mapper = mapper;
}
public BootstrapperClass(IProcessorFactory processorFactory, IBootstrapperSettings bootstrapSettings, ILogger logger)
: this(processorFactory, bootstrapSettings, logger, assemblyPath => AssemblyName.GetAssemblyName(assemblyPath).Version)
{
}
public OrderController(ILogger <OrderController> logger, IProcessorFactory processorFactory, IMapper mapper)
{
_logger = logger;
_processorFactory = processorFactory;
_mapper = mapper;
}
public MappingProcessor(IProcessorFactory processorFactory, IPropertyPipelineFactory propertyPipelineFactory)
{
_processorFactory = processorFactory ?? throw new ArgumentNullException(nameof(processorFactory));
_propertyPipelineFactory = propertyPipelineFactory ?? throw new ArgumentNullException(nameof(propertyPipelineFactory));
}
public CasePlanInstanceProcessor(IProcessorFactory processorFactory, ISubscriberRepository subscriberRepository)
{
_processorFactory = processorFactory;
_subscriberRepository = subscriberRepository;
}
public ReportBuilder(IReportProvider reportProvider, IReportMerger reportMerger, IProcessorFactory processorFactory)
{
this.reportProvider = reportProvider;
this.reportMerger = reportMerger;
this.processorFactory = processorFactory;
}
public PaymentBusinessService(IProcessorFactory processorFactory)
{
_processorFactory = processorFactory ?? throw new ArgumentNullException(nameof(processorFactory));
}
public ProcessInstanceProcessor(IProcessorFactory processorFactory)
{
_processorFactory = processorFactory;
}
public SimpleTextContext(IProcessorFactory processorFactory)
: base(new TextElementCollection(), processorFactory)
{
}
private static void TestStringEqual(IProcessorFactory factory, object superImportantReference)
{
const string FILTER_VALUE = "Hello, World!";
var processor = factory.Create(
ProcessorType.StringEqual,
superImportantReference,
FILTER_VALUE);
if (!processor.TryProcess(FILTER_VALUE))
{
throw new InvalidOperationException("This should have matched.");
}
if (processor.TryProcess("Goodbye, Cruel World!"))
{
throw new InvalidOperationException("This should not have matched.");
}
if (processor.TryProcess(10))
{
throw new InvalidOperationException("This should not have matched.");
}
if (processor.TryProcess(new object()))
{
throw new InvalidOperationException("This should not have matched.");
}
}
public KafkaConsumer(IProcessorFactory processorFactory, IConfiguration configuration, ILogger <KafkaConsumer> logger)
{
_processorFactory = processorFactory;
_configuration = configuration;
_logger = logger;
}
/// <summary>
/// Create new <see cref="HomeController" /> instance.
/// </summary>
/// <param name="processorFactory">factory for create processor class.</param>
public HomeController(IProcessorFactory processorFactory)
{
Processor = processorFactory.CreateProcessor();
}
public Calculator(IProcessorFactory processorFactory)
{
Processor = processorFactory.CreateProcessor();
}
