public ScheduleService(
ITreatmentWayRepository repoTreatmentWay,
ICommentRepository repoComment,
IScheduleUpdateRepository repoScheduleUpdate,
ISchedulePartRepository repoSchedulePart,
IPartRepository repoPart,
IInkObjectRepository repoObject,
IScheduleRepository repoSchedule,
IChemicalRepository repoChemical,
IProcessRepository repoProcess,
ISupplierRepository repoSup,
IInkRepository repoInk,
IMapper mapper,
MapperConfiguration configMapper)
{
_repoTreatmentWay = repoTreatmentWay;
_repoScheduleUpdate = repoScheduleUpdate;
_configMapper = configMapper;
_mapper = mapper;
_repoSchedulePart = repoSchedulePart;
_repoInk = repoInk;
_repoSup = repoSup;
_repoProcess = repoProcess;
_repoChemical = repoChemical;
_repoSchedule = repoSchedule;
_repoObject = repoObject;
_repoPart = repoPart;
_repoComment = repoComment;
}
public ProcessService(ISession session)
: base(session)
{
_processRepository = new ProcessRepository(session);
_parameterService = new ParameterService(session);
_processMacroService = new ProcessMacroService(session);
}
public BillingService(
IProcessRepository process,
IApportionmentRepository apportionment,
ISubsidyRepository accountSubsidy,
IReportRepository report,
IToolBillingRepository tool,
IRoomBillingRepository room,
IStoreBillingRepository store,
IMiscBillingRepository misc,
IBillingTypeRepository billingType,
IRoomDataRepository readRoomData,
IToolDataRepository readToolData,
IStoreDataRepository readStoreData,
IMiscDataRepository readMiscData,
IOrgRechargeRepository orgRecharge,
IExternalInvoiceRepository externalInvoice)
{
Process = process;
Apportionment = apportionment;
AccountSubsidy = accountSubsidy;
Report = report;
Tool = tool;
Room = room;
Store = store;
Misc = misc;
BillingType = billingType;
RoomData = readRoomData;
ToolData = readToolData;
StoreData = readStoreData;
MiscData = readMiscData;
OrgRecharge = orgRecharge;
ExternalInvoice = externalInvoice;
}
//object _syncLock=new object();
public ProcessWatchDog(ILogger logger, IStateManager stateManager,
IBatchEngineSubscribers batchEngineSubscribers, ICacheAside cacheAside,
ISerializersFactory serializersFactory, IEntityFactory entityFactory, IEventAggregator eventAggregator,
IProcessDataStorage storage, IPubSubFactory pubSubFactory, IResolver resolver,
IBatchLoggerFactory loggerFactory, IProcessRepository registeredProcesses,
ProcessVolumePipeline volumePipeline) : base("WatchDog", logger)
{
_stateManager = stateManager;
_batchEngineSubscribers = batchEngineSubscribers;
_cacheAside = cacheAside;
_eventAggregator = eventAggregator;
_storage = storage;
_pubSubFactory = pubSubFactory;
_resolver = resolver;
_loggerFactory = loggerFactory;
_registeredProcesses = registeredProcesses;
_volumePipeline = volumePipeline;
_groupsHandler = new GroupsHandler(logger, batchEngineSubscribers, stateManager, serializersFactory, entityFactory, resolver, loggerFactory);
Interval = TimeSpan.FromMinutes(3);
_subGroupRemoved = eventAggregator.Subscribe4Broadcast <ProcessGroupRemovedMessage>(RemoveGroup);
_subRem = eventAggregator.Subscribe <TextMessage>(ProcessRemoved, Constants.EventProcessFinished);
_serializer = SerializersFactory.Instance.GetSerializer(typeof(GroupMessage));
this._volumeGenSub = eventAggregator.Subscribe <TextMessage>(OnVolumeGenerated, Constants.EventProcessVolumeGenerated);
_checkGroupSub =
eventAggregator.Subscribe <TextMessage>(CheckProcessGroup, Constants.EventCheckGroupCommand);
_retrySub = eventAggregator.Subscribe <TextMessage>(OnVolumeGenerated, Constants.EventProcessRetry);
_healthSub = eventAggregator.Subscribe4Broadcast <HealthMessage>(PublishHealth);
_systemLogger = _loggerFactory.GetSystemLogger();
this._processAddedSub = eventAggregator.Subscribe <TextMessage>(OnProcessGroupAdded, Constants.EventProcessGroupAdded);
_volErrorSub = eventAggregator.Subscribe <VolumeErrorMessage>(OnProcessVolumeError);
}
public ProcessService(IProcessQueries processQueries, IProcessRepository processRepository,
IStorageQueries storageQueries)
{
this._processQueries = processQueries;
this._processRepository = processRepository;
this._storageQueries = storageQueries;
}
public ParameterService(IParameterRepository parameterRepository, IProcessRepository processRepository, IDeviceRepository deviceRepository, IAlarmService alarmService)
{
_parameterRepository = parameterRepository;
_deviceRepository = deviceRepository;
_processRepository = processRepository;
_alarmService = alarmService;
}
public ProcessService(IMapper mapper,
IRepository <Consultant> consultantRepository,
IRepository <Candidate> candidateRepository,
IRepository <CandidateProfile> candidateProfileRepository,
IRepository <Community> communityRepository,
IRepository <Office> officeRepository,
IProcessRepository processRepository,
IProcessStageRepository processStageRepository,
IHrStageRepository hrStageRepository,
ITechnicalStageRepository technicalStageRepository,
IClientStageRepository clientStageRepository,
IOfferStageRepository offerStageRepository,
IUnitOfWork unitOfWork)
{
_consultantRepository = consultantRepository;
_candidateRepository = candidateRepository;
_candidateProfileRepository = candidateProfileRepository;
_communityRepository = communityRepository;
_officeRepository = officeRepository;
_mapper = mapper;
_processRepository = processRepository;
_processStageRepository = processStageRepository;
_hrStageRepository = hrStageRepository;
_technicalStageRepository = technicalStageRepository;
_clientStageRepository = clientStageRepository;
_offerStageRepository = offerStageRepository;
_unitOfWork = unitOfWork;
}
public ModelNameService(
IModelNameRepository repoBrand,
IGlueRepository repoGlue,
IGlueIngredientRepository repoGlueIngredient,
IMailExtension mailExtension,
IArticleNoRepository repoArticleNo,
IProcessRepository repoProcess,
IArtProcessRepository repoArtProcess,
IIngredientRepository repoIngredient,
IBPFCEstablishRepository repoBPFC,
IModelNoRepository repoModelNO,
ISupplierRepository supplierRepository,
IConfiguration configuration,
IPlanRepository repoPlan,
IMapper mapper,
MapperConfiguration configMapper)
{
_configMapper = configMapper;
_mapper = mapper;
_repoModelName = repoBrand;
_repoGlueIngredient = repoGlueIngredient;
_repoGlue = repoGlue;
_repoModelNO = repoModelNO;
_repoArticleNo = repoArticleNo;
_repoProcess = repoProcess;
_repoArtProcess = repoArtProcess;
_repoBPFC = repoBPFC;
_repoIngredient = repoIngredient;
_supplierRepository = supplierRepository;
_configuration = configuration;
_mailExtension = mailExtension;
_repoPlan = repoPlan;
}
public FileService(IColumnControlRepository columnControlRepository, ISulamericaRepository sulamericaRepository, IUnimedRepository unimedRepository, IProcessRepository processRepository)
{
_columnControlRepository = columnControlRepository;
_sulamericaRepository = sulamericaRepository;
_unimedRepository = unimedRepository;
_processRepository = processRepository;
}
public ProcessController(IPostalCodeRepository repoPostalCode, IProcessRepository repo, IJobService jobService, PropertyCrawler.Data.AppContext contexte)
{
_repoPostalCode = repoPostalCode;
_repo = repo;
_jobService = jobService;
_context = contexte;
}
public Bus(IEntityFactory entityFactory, IVolumeHandler volumeHandler, IPubSubFactory pubSubFactory, IStateManager stateManager, IProcessDataStorage storage,
IDistributedMutexFactory distributedMutexFactory, IResolver resolver, IBatchLoggerFactory batchLoggerFactory)
{
EntityFactory = entityFactory;
VolumeHandler = volumeHandler;
PubSubFactory = pubSubFactory;
_stateManager = stateManager;
_storage = storage;
DistributedMutexFactory = distributedMutexFactory;
_resolver = resolver;
_batchLoggerFactory = batchLoggerFactory;
_cts = new CancellationTokenSource();
_cancellationToken = _cts.Token;
HookExceptionEvents();
_logger = batchLoggerFactory.GetSystemLogger();
EventAggregator = new TinyEventAggregator();
var wrapper = new BusStateManager(_stateManager, _logger, resolver);
_stateManager = wrapper;
var originalStorage = _storage;
_storage = new CacheBusWrapper(_logger, originalStorage, resolver);
_cacheCommandPipeline = new CacheStoragePipeline(_logger, _cancellationToken, originalStorage);
_cacheAside = new CacheAside(_stateManager, _storage, EventAggregator, _logger, batchLoggerFactory);
_processRepository = _resolver.Resolve <IProcessRepository>();
//var taskListener = resolver.Resolve<ITaskListener>();
//if (!ReferenceEquals(taskListener, _processRepository))
//{
// Console.WriteLine("ALERT");
//}
_taskExecutorsRepo = new TaskExecutorsPool(_logger, _cacheAside, _cancellationToken, _stateManager, _processRepository, EventAggregator, resolver, _logger);
//BuildCommandHandlerPipeline();
_statePersistencePipeline = new StatePersistencePipeline(_logger, _cancellationToken);
this._databasePipeline = new DatabasePipeline(_logger, _cancellationToken, 0);//todo 500
_taskProcessorPipeline = GetTaskProcessorPipeLine();
//_grouPipeline=new GroupHandlerPipeline(_stateManager, _logger, _branchEngineSubscriber);
//_volumePipeline = new ProcessVolumePipeline(_cancellationToken, _logger, _stateManager, _cacheAside, _processRepository, VolumeHandler, resolver, EventAggregator, _branchEngineSubscriber);
_branchEngineSubscriber = new BatchEngineSubscribers();
//_watchDog = new ProcessWatchDog(_logger, StateManager, _branchEngineSubscriber, _cacheAside, SerializersFactory.Instance, EntityFactory, EventAggregator, Storage);
//watchDog.Start(_cancellationToken);//todo
// _grouPipeline = new Pipeline<GroupMessage>(_watchDog);
//_watchDogPipeline = new Pipeline<IWatchDogMessage>(_watchDog);
_taskProducer = new TaskProducerWorker(_logger, _cacheAside, VolumeHandler, resolver, batchLoggerFactory);
_leaderManager = DistributedMutexFactory.CreateDistributedMutex(NodeSettings.Instance.LockKey, RunLocalWatchDog, () => SwitchToPubSubWatchDog(null), batchLoggerFactory.GetSystemLogger());
}
public SupplierService(IProcessRepository repoProcess, ISupplierRepository repoSupplier, IHttpContextAccessor accessor, IMapper mapper, MapperConfiguration configMapper)
{
_configMapper = configMapper;
_mapper = mapper;
_repoSupplier = repoSupplier;
_accessor = accessor;
_repoProcess = repoProcess;
}
public ParameterService(ISession session)
: base(session)
{
_parameterRepository = new ParameterRepository(session);
_processRepository = new ProcessRepository(session);
_deviceRepository = new DeviceRepository(session);
_alarmService = new AlarmService(session);
}
public ProcessVolumePipeline(CancellationToken token, IFrameworkLogger logger, IStateManager stateManager,
ICacheAside cacheAside, IProcessRepository processRepository, IVolumeHandler volumeHandler,
IResolver resolver, IEventAggregator eventAggregator, IBatchEngineSubscribers batchEngineSubscribers)
: base(new ProcessVolumeRequestHandler(logger, stateManager, cacheAside, processRepository, volumeHandler,
token, resolver, eventAggregator, batchEngineSubscribers))
{
RegisterFeatureDecorator(new ConsumerFilter <ProcessExecutionContext>(token, logger, "VolumeGeneratorConsumer"));
}
public SysInfoHostedService(ILogger <SysInfoHostedService> logger, IProcessRepository processRepository, IConfiguration configuration)
: base(logger)
{
_processRepository = processRepository;
_refreshRateInMs = configuration.ReadIntConfigValue("ShellQueryRateMs", 50);
_cpuHighValue = configuration.ReadIntConfigValue("cpuHighValue", 90);
_memoryLowValue = configuration.ReadIntConfigValue("memoryLowValue", 1024);
}
public RoleUserService(IProcessRepository repoProcess, ISupplierRepository repoSup, IInkRepository repoInk, IMapper mapper, MapperConfiguration configMapper)
{
_configMapper = configMapper;
_mapper = mapper;
_repoInk = repoInk;
_repoSup = repoSup;
_repoProcess = repoProcess;
}
public ChemicalService(IChemicalRepository repoChemical, IProcessRepository repoProcess, ISupplierRepository repoSup, IInkRepository repoInk, IMapper mapper, MapperConfiguration configMapper)
{
_configMapper = configMapper;
_mapper = mapper;
_repoInk = repoInk;
_repoSup = repoSup;
_repoProcess = repoProcess;
_repoChemical = repoChemical;
}
public TreatmentWayService(ITreatmentWayRepository repoTreatmentWay, IProcessRepository repoProcess, ISupplierRepository repoSupplier, IHttpContextAccessor accessor, IMapper mapper, MapperConfiguration configMapper)
{
_configMapper = configMapper;
_mapper = mapper;
_repoSupplier = repoSupplier;
_repoTreatmentWay = repoTreatmentWay;
_accessor = accessor;
_repoProcess = repoProcess;
}
public ProcessActionController(
IProcessRepository _Process
, IUserRepository _user
, IProcessActionRepository _ProcessAction
)
{
ProcessRepository = _Process;
userRepository = _user;
ProcessActionRepository = _ProcessAction;
}
public ProcessListHostedService(ILogger <ProcessListHostedService> logger, IProcessRepository processRepository, IConfiguration configuration)
: base(logger)
{
_processRepository = processRepository;
int.TryParse(configuration["TasklistRefreshRateMS"], out _refreshRate);
if (_refreshRate == 0)
{
_refreshRate = 50;
}
}
public ProcessController(IProcessRepository process, ILogManager logger, IHttpContextAccessor accessor)
{
_processes = process;
_logger = logger;
if (accessor.HttpContext.Request.Query.ContainsKey("entityid"))
{
_entityId = int.Parse(accessor.HttpContext.Request.Query["entityid"]);
}
}
public ProcessListWebSocket(WebSocketConnectionManager connectionManager, IProcessRepository processRepository, IConfiguration configuration)
: base(connectionManager)
{
_processRepository = processRepository;
int.TryParse(configuration["TasklistRefreshRateMS"], out _refreshRate);
if (_refreshRate == 0)
{
_refreshRate = 50;
}
}
public WorkflowsPluginsProcessor(IProcessRepository processRepository, ILogger logger, List <Tuple <string, string> > sdkSteps, List <string> workflows)
{
this.processRepository = processRepository;
this.logger = logger;
this.sdkSteps = sdkSteps;
this.workflows = workflows;
stoppedWorkflows = new List <Guid>();
stoppedPlugins = new List <Guid>();
}
public ProcessManager(IProcessRepository repo,
IBinaryObjectManager binaryObjectManager,
IBinaryObjectRepository binaryObjectRepository,
IBlobStorageAdapter blobStorageAdapter)
{
this.repo = repo;
this.binaryObjectManager = binaryObjectManager;
this.binaryObjectRepository = binaryObjectRepository;
this.blobStorageAdapter = blobStorageAdapter;
}
public AddMessageTriggerToProcessCommandHandler(
IProcessRepository processRepository,
ITriggerRepository triggerRepository,
IMessageTriggerFactory messageTriggerFactory)
{
Contract.Requires <ArgumentNullException>(processRepository != null);
Contract.Requires <ArgumentNullException>(triggerRepository != null);
Contract.Requires <ArgumentNullException>(messageTriggerFactory != null);
this.processRepository = processRepository;
this.messageTriggerFactory = messageTriggerFactory;
this.triggerRepository = triggerRepository;
}
public static void MarkAsError(this ProcessExecutionContext context, IStateManager stateManager,
string errorMessage, IProcessRepository registeredProcesses, IBatchEngineSubscribers batchEngineSubscribers,
IFrameworkLogger fLogger)
{
context.Logger.Error(errorMessage);
context.WritableProcessState.Status = CompletionStatus.Finished;
context.WritableProcessState.Result = ResultStatus.Error;
context.WritableProcessState.CompleteTime = DateTime.UtcNow;
stateManager.SaveProcess(context.WritableProcessState);
context.WritableProcessState.TriggerProcessEvents(registeredProcesses, context, true, context.ProcessState.IsStopped, batchEngineSubscribers, fLogger, errorMessage);
}
public UpdateProcessCommandHandler(IProcessRepository processRepository, IProcessQueries processQueries,
ICompanyRepository companyRepository, ICompanyQueries companyQueries,
IGTINService gTINService)
{
this.processRepository = processRepository;
this.processQueries = processQueries;
this.companyRepository = companyRepository;
this.companyQueries = companyQueries;
this.gTINService = gTINService;
}
public ProcessService(
ILogger <ProcessService> logger,
IOptionsMonitor <AppOptions> appOptions,
IPermissionRepository permissionRepository,
IRoleRepository roleRepository,
IProcessRepository processRepository) : base(logger, appOptions)
{
Guard.Against.Null(processRepository, nameof(processRepository));
_processRepository = processRepository;
_permissionRepository = permissionRepository;
_roleRepository = roleRepository;
}
//private readonly Action<ProcessExecutionContext, bool> _invokeProcessCompletion;
public VolumeGenerator(IBaseProcess process, IStateManager stateManager, IVolumeHandler volumeHandler,
IResolver resolver, CancellationToken cancellationToken, IProcessRepository registeredProcesses,
IBatchEngineSubscribers batchEngineSubscribers, IFrameworkLogger logger)
{
_process = process;
_stateManager = stateManager;
this._volumeHandler = volumeHandler;
_resolver = resolver;
_cancellationToken = cancellationToken;
_registeredProcesses = registeredProcesses;
_batchEngineSubscribers = batchEngineSubscribers;
_logger = logger;
}
public ProjectSettingsAccessService(
IPrjSettingsRepository prjSettingsRepository,
IProcessRepository processRepository,
IFunctionRepository functionRepository,
IHolidayRepository holidayRepository,
IWeekdayRepository weekdayRepository)
{
this.prjSettingsRepository = prjSettingsRepository;
this.processRepository = processRepository;
this.functionRepository = functionRepository;
this.holidayRepository = holidayRepository;
this.weekdayRepository = weekdayRepository;
}
public wateroutController(IProcessRepository _processRepository)
{
processService = new ProcessService(_processRepository);
}
static ProcessService()
{
_repository = RepositoryFactory.GetRepository<IProcessRepository, Guid, Process>();
_workItemRepository = RepositoryFactory.GetRepository<IWorkItemRepository, long, WorkItem>();
}
public RemoteProcessRepository(IProcessRepository processRepository)
{
Contract.Requires<ArgumentNullException>(processRepository != null);
this.processRepository = processRepository;
}
public ProcessService(IProcessRepository processRepository)
{
this.processRepository = processRepository;
}
