public ProjectService(
IPipelineRepository pipelineRepository,
IProjectRepository projectRepository,
IValidationService validationService,
ICiDataProviderFactory ciDataProviderFactory,
ICronJobsManager cronJobsManager,
IPanelRepository panelRepository,
IStaticBranchPanelRepository staticBranchPanelRepository,
IConfiguration configuration,
ILogger <ProjectService> logger,
IStageRepository stageRepository,
IJobRepository jobRepository)
{
_ciDataProviderFactory = ciDataProviderFactory;
_cronJobsManager = cronJobsManager;
_validationService = validationService;
_projectRepository = projectRepository;
_pipelineRepository = pipelineRepository;
_panelRepository = panelRepository;
_staticBranchPanelRepository = staticBranchPanelRepository;
_configuration = configuration;
_logger = logger;
_stageRepository = stageRepository;
_jobRepository = jobRepository;
}
public OrderController(IOrderRepository orderRepository, ICatalogRepository catalogRepository, IPipelineRepository pipelineRepository, IOptions <JenkinsSettings> jenkinsSettings)
{
_orderRepository = orderRepository;
_catalogRepository = catalogRepository;
_pipelineRepository = pipelineRepository;
_jenkinsSettings = jenkinsSettings.Value;
}
public PipelineSegmentRunner(string pipelineName,
IPipelineRepository pipelineRepository,
IInternalPipelineRunner internalPipelineRunner)
{
if (pipelineName == null)
{
throw new ArgumentNullException("pipelineName");
}
if (string.IsNullOrWhiteSpace(pipelineName))
{
throw new ArgumentException("Pipeline name cannot be empty", "pipelineName");
}
if (pipelineRepository == null)
{
throw new ArgumentNullException("pipelineRepository");
}
if (internalPipelineRunner == null)
{
throw new ArgumentNullException("internalPipelineRunner");
}
this.pipelineName = pipelineName;
this.pipelineRepository = pipelineRepository;
this.internalPipelineRunner = internalPipelineRunner;
}
public ReceivePartModified()
{
StandardKernel Kernal = new StandardKernel();
Kernal.Load(Assembly.GetExecutingAssembly());
_serviceSettings = Kernal.Get <SettingRepository>();
_serviceTaskMgrJob = Kernal.Get <TaskMgrJobsRepository>();
_serviceTaskMgrXml = Kernal.Get <TaskMgrXmlRepository>();
_serviceJobWorkFlow = Kernal.Get <JobWorkflowRepository>();
_serviceIncomingData = Kernal.Get <IncomingDataRepository>();
_serviceJobStackErrorLog = Kernal.Get <JobStackErrorLogRepository>();
_serviceTransactionLog = Kernal.Get <TransactionLogRepository>();
_serviceInbox = Kernal.Get <InboxRepository>();
_servicePipeline = Kernal.Get <PipelineRepository>();
_serviceDataset = Kernal.Get <metadataDatasetRepository>();
_serviceNomStatus = Kernal.Get <NominationStatusRepository>();
_applicationLogs = Kernal.Get <ApplicationLogRepository>();
_serviceBatch = Kernal.Get <BatchRepository>();
_serviceNomination = Kernal.Get <NominationsRepository>();
_serviceMetadatCycle = Kernal.Get <metadataCycleRepository>();
unitOfWork = Kernal.Get <UnitOfWork>();
modalFactory = Kernal.Get <ModalFactory>();
_serviceShipperCompany = Kernal.Get <ShipperCompanyRepository>();
_serviceFileSysIncomingData = Kernal.Get <FileSysIncomingDataRepository>();
_serviceSqtsOpPerTransaction = Kernal.Get <SQTSOPPerTransactionRepository>();
#region get nmqr services
_serviceNmqrPerTransaction = Kernal.Get <NMQRPerTransactionRepository>();
#endregion
#region get sqts service
_serviceSqtsTrackOnNom = Kernal.Get <SQTSTrackOnNomRepository>();
_serviceSqtsFile = Kernal.Get <SQTSFileRepository>();
_serviceSqtsPerTransaction = Kernal.Get <SQTSPerTransactionRepository>();
#endregion
#region get email service
emailTempalteService = Kernal.Get <EmailTemplateRepository>();
emailQueueService = Kernal.Get <EmailQueueRepository>();
appLogService = Kernal.Get <ApplicationLogRepository>();
#endregion
var path = Path.Combine(HostingEnvironment.MapPath("~/App_Data"), "SQTSReductionReasons.xml");
FileInfo fileInfo = new FileInfo(path);
XmlDocument xmlRedReason = new XmlDocument();
if (System.IO.File.Exists(path) && !IsFileLocked(fileInfo))
{
try
{
xmlRedReason.Load(path);
var redResonNode = xmlRedReason.GetElementsByTagName("Reason");
if (redResonNode != null)
{
redReasonList = redResonNode.Cast <XmlNode>();
}
}
catch (Exception ex)
{
}
}
}
public DashboardService(INMQRPerTransactionRepository NMQRPerTransactionRepository, IPipelineRepository pipelinesRepository, INominationsRepository nominationRepository, IShipperCompanyRepository shipperCompanyRepository, IUnitOfWork unitOfWork)
{
this.pipelinesRepository = pipelinesRepository;
this.nominationRepository = nominationRepository;
this.shipperCompanyRepository = shipperCompanyRepository;
this.unitOfWork = unitOfWork;
this.NMQRPerTransactionRepository = NMQRPerTransactionRepository;
}
public PipelineService(IPipelineRepository pipelineRepository)
{
_pipelineRepository = pipelineRepository;
if (!string.IsNullOrEmpty(CurrentUser.DbName))
{
this._dbName = CurrentUser.DbName;
}
}
internal PipelineBuilder(string name,
IPipelineRepository pipelineRepository,
ISegmentRunnerFactory segmentRunnerFactory)
{
this.pipelineRepository = pipelineRepository;
this.segmentRunnerFactory = segmentRunnerFactory;
pipeline = pipelineRepository.CreateNew(name);
}
public EnvironmentController(
IDeploymentRepository deploymentRepository,
IEnvironmentRepository environmentRepository,
IPipelineRepository pipelineRepository)
{
_deploymentRepository = deploymentRepository;
_environmentRepository = environmentRepository;
_pipelineRepository = pipelineRepository;
}
public ContractService(IPipelineRepository IpipelineRepository, INominationsRepository INominationsRepository, IContractRepository IContractRepository, ILocationRepository ILocationRepository, ImetadataRequestTypeRepository ImetadataRequestTypeRepository, IModalFactory modalFactory)
{
_INominationsRepository = INominationsRepository;
_IContractRepository = IContractRepository;
_ILocationRepository = ILocationRepository;
_ImetadataRequestTypeRepository = ImetadataRequestTypeRepository;
this.IpipelineRepository = IpipelineRepository;
this.modalFactory = modalFactory;
}
internal PipelineRunner(string name,
IPipelineRepository pipelineRepository,
IInternalPipelineRunner internalPipelineRunner,
IPipelineContext context)
{
this.internalPipelineRunner = internalPipelineRunner;
this.context = context;
pipeline = pipelineRepository.Get(name);
}
public PipelineUpdateService(IPipelineRepository pipelineRepository, IPipelineProvider pipelineProvider,
ILogger <PipelineUpdateService> logger, IList <ITestLogParser> testLogParsers, ITestRepository testRepository, IPipelineArchiveRepository pipelineArchiveRepository)
{
_pipelineRepository = pipelineRepository;
_pipelineProvider = pipelineProvider;
_logger = logger;
_testLogParsers = testLogParsers;
_testRepository = testRepository;
_pipelineArchiveRepository = pipelineArchiveRepository;
}
public TwitterStreamProcessor(ITwitterCredentials credentials, ITweetFilter tweetFilter, ITweetTrim tweetTrimmer, IHashPairGenerator hashPairGenerator, IPipelineRepository repo)
{
_credentials = credentials;
_tweetFilter = tweetFilter;
_tweetTrimmer = tweetTrimmer;
_hashPairGenerator = hashPairGenerator;
_repo = repo;
_stream = Stream.CreateSampleStream(_credentials);
_stream.AddTweetLanguageFilter(LanguageFilter.English);
}
public DeploymentService(
IEnvironmentRepository environmentRepository,
IPipelineRepository pipelineRepository,
IDeploymentRepository deploymentRepository,
IDeploymentUtility deploymentUtility)
{
this.deploymentRepository = deploymentRepository;
this.environmentRepository = environmentRepository;
this.pipelineRepository = pipelineRepository;
this.deploymentUtility = deploymentUtility;
}
public PipelineService(
ILogger <IPipelineRepository> logger,
IPipelineRepository pipelineRepository,
IApiPipelineRequestModelValidator pipelineModelValidator,
IBOLPipelineMapper bolpipelineMapper,
IDALPipelineMapper dalpipelineMapper)
: base(logger,
pipelineRepository,
pipelineModelValidator,
bolpipelineMapper,
dalpipelineMapper)
{
}
public AbstractPipelineService(
ILogger logger,
IPipelineRepository pipelineRepository,
IApiPipelineRequestModelValidator pipelineModelValidator,
IBOLPipelineMapper bolPipelineMapper,
IDALPipelineMapper dalPipelineMapper)
: base()
{
this.PipelineRepository = pipelineRepository;
this.PipelineModelValidator = pipelineModelValidator;
this.BolPipelineMapper = bolPipelineMapper;
this.DalPipelineMapper = dalPipelineMapper;
this.logger = logger;
}
public PipelineService(
ILogger <IPipelineService> logger,
MediatR.IMediator mediator,
IPipelineRepository pipelineRepository,
IApiPipelineServerRequestModelValidator pipelineModelValidator,
IDALPipelineMapper dalPipelineMapper)
: base()
{
this.PipelineRepository = pipelineRepository;
this.PipelineModelValidator = pipelineModelValidator;
this.DalPipelineMapper = dalPipelineMapper;
this.logger = logger;
this.mediator = mediator;
}
/// <summary>
/// Initializes a new instance of the <see cref="PipelineManager"/>
/// class.
/// </summary>
/// <param name="repo">The repository of pipeline information.</param>
/// <param name="algs">The algorithm registry object.</param>
public PipelineManager(IPipelineRepository repo, IAlgorithmRegistrar algs)
{
if (repo == null)
{
throw new ArgumentNullException("repo");
}
if (algs == null)
{
throw new ArgumentNullException("algs");
}
_repo = repo;
_algorithmRegistry = algs;
}
public PathedNominationService(
IPipelineTransactionTypeMapRepository PipelineTransactionTypeMapRepository,
ImetadataTransactionTypeRepository metadataTransactionTypeRepository,
ICounterPartyRepository counterpartyRepository,
INominationsRepository NominationsRepository,
IBatchRepository BatchRepository,
IPipelineRepository PipelineRepository,
ISQTSTrackOnNomRepository SQTSTrackOnNomRepository,
ILocationRepository LocationRepository,
IContractService contractService,
IModalFactory modelFactory)
{
this.PipelineTransactionTypeMapRepository = PipelineTransactionTypeMapRepository;
this.metadataTransactionTypeRepository = metadataTransactionTypeRepository;
this.NominationsRepository = NominationsRepository;
this.BatchRepository = BatchRepository;
this.PipelineRepository = PipelineRepository;
this.SQTSTrackOnNomRepository = SQTSTrackOnNomRepository;
this.LocationRepository = LocationRepository;
this.counterpartyRepository = counterpartyRepository;
this.contractService = contractService;
this.modelFactory = modelFactory;
}
public PipelineService(IPipelineRepository repository, IPipelineTaskService taskService, IPipelineRunner runner)
{
_repository = repository;
_taskService = taskService;
_runner = runner;
}
public PipelineService(IPipelineRepository IPipelineRepository, IModalFactory modalFactory)
{
this._IPipelineRepository = IPipelineRepository;
this.modalFactory = modalFactory;
}
public PipelineController(IPipelineRepository pipelineRepository, ICatalogRepository catalogRepository)
{
_pipelineRepository = pipelineRepository;
_catalogRepository = catalogRepository;
}
public PipelineService(IPipelineRepository pipelineRepository, ITestRepository testRepository, ILogger <PipelineService> logger)
{
_testRepository = testRepository;
_logger = logger;
}
public ApiPipelineRequestModelValidator(IPipelineRepository pipelineRepository)
: base(pipelineRepository)
{
}
public DuplicateRepository(PipelineRepository pipelineRepo, PostGreSqlRepository postgreRepo)
{
_pipelineRepo = pipelineRepo;
_postgreRepo = postgreRepo;
}
public AbstractApiPipelineRequestModelValidator(IPipelineRepository pipelineRepository)
{
this.pipelineRepository = pipelineRepository;
}
public NotifierPipelineService(IPipelineRepository repository, IPipelineTaskService taskService, IPipelineRunner runner, IPipelineHubNotifier pipelineNotifier)
: base(repository, taskService, runner)
{
_notifier = pipelineNotifier;
}
public ApiPipelineServerRequestModelValidator(IPipelineRepository pipelineRepository)
{
this.PipelineRepository = pipelineRepository;
}
public LocationService(ILocationRepository ILocationRepository, IPipelineRepository IPipelineRepository, IModalFactory modalFactory)
{
_ILocationRepository = ILocationRepository;
_IPipelineRepository = IPipelineRepository;
this.modalFactory = modalFactory;
}
public PipelineHost(IPipelineTypeResolver typeResolver, IPipelineRepository pipelineRepository, PipelineFactory factory)
{
_typeResolver = typeResolver;
_factory = factory;
_pipelineRepository = pipelineRepository;
}
public ISegmentRunner CreatePipelineRunner(string pipelineName, IPipelineRepository pipelineRepository)
{
var internalPipelineRunner = new InternalPipelineRunner();
return(new PipelineSegmentRunner(pipelineName, pipelineRepository, internalPipelineRunner));
}
public CatalogController(ICatalogRepository catalogRepository, IPipelineRepository pipelineRepository)
{
_catalogRepository = catalogRepository;
_pipelineRepository = pipelineRepository;
}
public PipelineTaskService(IPipelineTaskRepository repository, IPipelineRepository pipelineRepository)
{
_repository = repository;
_pipelineRepository = pipelineRepository;
}
public HomeController()
{
_environmentRepository = Bootstrapper.Resolve<IEnvironmentRepository>();
_deploymentService = Bootstrapper.Resolve<IDeploymentService>();
_pipelineRepository = Bootstrapper.Resolve<IPipelineRepository>();
}
