public LandmarkRunTriggerModelValidation(IRunRepository runRepository)
{
RuleFor(c => c.ScenarioId).NotEmpty().WithMessage("Scenario id missing");
RuleFor(c => c).Custom((command, context) =>
{
var run = runRepository.FindByScenarioId(command.ScenarioId);
var scenario = run?.Scenarios.Find(s => s.Id == command.ScenarioId);
if (run is null || scenario is null)
{
context.AddFailure($"Run for scenario {command.ScenarioId} was not found");
return;
}
if (!run.IsCompleted)
{
context.AddFailure("Run is not completed yet");
}
if (!run.IsOptimiserNeeded)
{
context.AddFailure("Run has no optimizations enabled");
}
});
}
public ScheduleController(ISchedule schedule, ITrainRepository trainRepo, IRunRepository runRepo, IAgenciesRepository agenciesRepo)
{
_schedule = schedule;
_trainRepo = trainRepo;
_runRepo = runRepo;
_agenciesRepo = agenciesRepo;
}
public RunsController(IRunRepository runRepository, UserManager <ApplicationUser> userManager,
IMapper mapper)
{
_runRepository = runRepository;
_userManager = userManager;
_mapper = mapper;
}
public RunDomainModelHandler(IRunRepository runRepository,
ISqlServerDbContext dbContext)
{
_runRepository =
runRepository ?? throw new ArgumentNullException(nameof(runRepository));
_dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
}
public RouteRepository(iBalekaDBContext dbContext, IRunRepository _runRepo, IEventRepository _eventRepo)
: base(dbContext)
{
runRepo = _runRepo;
eventRepo = _eventRepo;
DbContext = dbContext;
}
public LandmarkRunService(
ILandmarkApiClient landmarkApi,
IRunRepository runRepository,
IScenarioResultRepository scenarioResultRepository,
ILandmarkAutoBookPayloadProvider landmarkAutoBookPayloadProvider,
IHubNotification <LandmarkRunStatusNotification> runStatusChangedNotifier,
IHubNotification <InfoMessageNotification> infoMessageNotification,
ILandmarkHttpPoliciesHolder policiesHolder,
IAuditEventRepository auditEventRepository,
IClock clock,
IKPICalculationScopeFactory kpiCalculationScopeFactory,
IMapper mapper)
{
_landmarkApi = landmarkApi;
_runRepository = runRepository;
_scenarioResultRepository = scenarioResultRepository;
_landmarkAutoBookPayloadProvider = landmarkAutoBookPayloadProvider;
_runStatusChangedNotifier = runStatusChangedNotifier;
_infoMessageNotification = infoMessageNotification;
_policiesHolder = policiesHolder;
_auditEventRepository = auditEventRepository;
_clock = clock;
_kpiCalculationScopeFactory = kpiCalculationScopeFactory;
_mapper = mapper;
}
public RunsValidator(
IBRSConfigurationTemplateRepository brsConfigurationTemplateRepository,
ITenantSettingsRepository tenantSettingsRepository,
IRunRepository runRepository,
IScenarioRepository scenarioRepository,
ISalesAreaRepository salesAreaRepository,
ICampaignRepository campaignRepository,
IDemographicRepository demographicRepository,
IDeliveryCappingGroupRepository deliveryCappingGroupRepository,
IFeatureManager featureManager,
IRunTypeRepository runTypeRepository,
IAnalysisGroupRepository analysisGroupRepository,
IMapper mapper
)
{
_brsConfigurationTemplateRepository = brsConfigurationTemplateRepository;
_tenantSettingsRepository = tenantSettingsRepository;
_runRepository = runRepository;
_scenarioRepository = scenarioRepository;
_salesAreaRepository = salesAreaRepository;
_campaignRepository = campaignRepository;
_demographicRepository = demographicRepository;
_deliveryCappingGroupRepository = deliveryCappingGroupRepository;
_featureManager = featureManager;
_runTypeRepository = runTypeRepository;
_analysisGroupRepository = analysisGroupRepository;
_mapper = mapper;
}
public ScenarioResultsController(ISalesAreaRepository salesAreaRepository, IRunRepository runRepository, IFailuresRepository failuresRepository,
IScenarioResultRepository scenarioResultRepository, IResultsFileRepository resultsFileRepository, IOutputFileRepository outputFileRepository,
IRecommendationRepository recommendationRepository, ICampaignRepository campaignRepository, IProductRepository productRepository, IMapper mapper,
IClashRepository clashRepository, IScenarioRepository scenarioRepository, IScenarioCampaignResultRepository scenarioCampaignResultRepository,
IScenarioCampaignFailureRepository scenarioCampaignFailureRepository, IFunctionalAreaRepository functionalAreaRepository,
ITenantSettingsRepository tenantSettingsRepository, IFactory storageClientFactory, AWSSettings awsSettings,
IRecommendationAggregator recommendationAggregator, IScenarioCampaignResultReportCreator scenarioCampaignResultReportCreator,
IKPICalculationScopeFactory kpiCalculationScopeFactory)
{
_salesAreaRepository = salesAreaRepository;
_runRepository = runRepository;
_scenarioResultRepository = scenarioResultRepository;
_resultsFileRepository = resultsFileRepository;
_outputFileRepository = outputFileRepository;
_failuresRepository = failuresRepository;
_recommendationRepository = recommendationRepository;
_campaignRepository = campaignRepository;
_productRepository = productRepository;
_clashRepository = clashRepository;
_scenarioRepository = scenarioRepository;
_scenarioCampaignResultRepository = scenarioCampaignResultRepository;
_mapper = mapper;
_tenantSettingsRepository = tenantSettingsRepository;
_scenarioCampaignFailureRepository = scenarioCampaignFailureRepository;
_functionalAreaRepository = functionalAreaRepository;
_storageClientFactory = storageClientFactory;
_awsSettings = awsSettings;
_recommendationAggregator = recommendationAggregator;
_scenarioCampaignResultReportCreator = scenarioCampaignResultReportCreator;
_kpiCalculationScopeFactory = kpiCalculationScopeFactory;
}
public RunningController(
IRunRepository runRepository,
ITagRepository tagRepository
)
{
this.runRepository = runRepository;
this.tagRepository = tagRepository;
}
public TicketService(ITicketRepository tickRepo, IReservationRepository resRepo,
IStrategyFactory strategyFactory, IRunRepository runRepository)
{
_tickRepo = tickRepo;
_resRepo = resRepo;
_strategyFactory = strategyFactory;
_runRepository = runRepository;
}
public RunService(IRunRepository runRepository, Func <IUnitOfWork> unitOfWorkFactory)
{
Guard.WhenArgument(runRepository, nameof(IRunRepository)).IsNull().Throw();
Guard.WhenArgument(unitOfWorkFactory, nameof(Func <IUnitOfWork>)).IsNull().Throw();
this.runRepository = runRepository;
this.unitOfWorkFactory = unitOfWorkFactory;
}
public TicketService(ITicketRepository tickRepo, IReservationRepository resRepo,
IPriceCalculationStrategy priceCalculationStrategy, IRunRepository runRepository)
{
_tickRepo = tickRepo;
_resRepo = resRepo;
_priceStr = priceCalculationStrategy;
_runRepository = runRepository;
}
public OrdersQueryHandler(IOrderRepository orderRepository, IUserRepository userRepository,
IOptionsRepository optionsRepository, IRunRepository runRepository)
{
_orderRepository = orderRepository;
_userRepository = userRepository;
_optionsRepository = optionsRepository;
_runRepository = runRepository;
}
public RunCommandHandler(IRunRepository runRepository, IEventPublisher eventPublisher, IRunnerRandomizer randomizer, IMapper mapper, ISystemClock clock, IIllMakeRepository illMakeRepository)
{
_runRepository = runRepository;
_eventPublisher = eventPublisher;
_randomizer = randomizer;
_mapper = mapper;
_clock = clock;
_illMakeRepository = illMakeRepository;
}
public Schedule(
IRunRepository runRepo,
ITrainRepository trainRepo,
IReservationRepository reservationRepository,
IReservationService resService)
{
_runRepo = runRepo;
_trainRepo = trainRepo;
_reservationRepository = reservationRepository;
_resService = resService;
}
/// <summary>
/// Configures the builder to use a repository
/// </summary>
/// <returns>The current builder for chaining</returns>
public MLOpsBuilder UseMetaDataRepositories(IDbContextFactory contextFactory)
{
this.experimentRepository = new ExperimentRepository(contextFactory);
this.runRepository = new RunRepository(contextFactory, new Clock());
this.dataRepository = new DataRepository(contextFactory);
this.metricRepository = new MetricRepository(contextFactory);
this.confusionMatrixRepository = new ConfusionMatrixRepository(contextFactory);
this.hyperParameterRepository = new HyperParameterRepository(contextFactory);
return(this);
}
public DeliveryCappingGroupController(
IDeliveryCappingGroupRepository repository,
IRunRepository runRepository,
IModelDataValidator <DeliveryCappingGroupModel> validator,
IMapper mapper
)
{
_repository = repository;
_validator = validator;
_mapper = mapper;
_runRepository = runRepository;
}
public void Initialize()
{
var options = new DbContextOptionsBuilder <MLOpsDbContext>()
.UseInMemoryDatabase(databaseName: "MLOpsNET")
.Options;
this.contextFactory = new DbContextFactory(() => new MLOpsDbContext(options, RelationalEntityConfigurator.OnModelCreating));
this.clockMock = new Mock <IClock>();
this.sut = new RunRepository(contextFactory, clockMock.Object, new RunResolver(), new RegisteredModelResolver());
}
public ManageAutoBooksCreateAndDelete(
IAuditEventRepository auditEventRepository,
IConfiguration configuration,
IAutoBookInstanceConfigurationRepository autoBookInstanceConfigurationRepository,
IAutoBooks autoBooks,
IRunRepository runRepository)
{
_auditEventRepository = auditEventRepository;
_configuration = configuration;
_autoBookInstanceConfigurationRepository = autoBookInstanceConfigurationRepository;
_autoBooks = autoBooks;
_runRepository = runRepository;
}
public BRSIndicatorController(
IBRSIndicatorManager brsManager,
IRunRepository runRepository,
IScenarioResultRepository scenarioResultRepository,
IBRSConfigurationTemplateRepository brsConfigurationTemplateRepository,
IMapper mapper)
{
_brsManager = brsManager;
_runRepository = runRepository;
_scenarioResultRepository = scenarioResultRepository;
_brsConfigurationTemplateRepository = brsConfigurationTemplateRepository;
_mapper = mapper;
}
internal MLOpsContext(IModelRepository modelRepository,
IExperimentRepository experimentRepository,
IRunRepository runRepository,
IDataRepository dataRepository,
IMetricRepository metricRepository,
IConfusionMatrixRepository confusionMatrixRepository,
IHyperParameterRepository hyperParameterRepository,
IDeploymentRepository deploymentRepository)
{
if (modelRepository == null)
{
throw new ArgumentNullException(nameof(modelRepository));
}
if (experimentRepository == null)
{
throw new ArgumentNullException(nameof(experimentRepository));
}
if (runRepository == null)
{
throw new ArgumentNullException(nameof(runRepository));
}
if (dataRepository == null)
{
throw new ArgumentNullException(nameof(dataRepository));
}
if (metricRepository == null)
{
throw new ArgumentNullException(nameof(metricRepository));
}
if (confusionMatrixRepository == null)
{
throw new ArgumentNullException(nameof(confusionMatrixRepository));
}
if (hyperParameterRepository == null)
{
throw new ArgumentNullException(nameof(hyperParameterRepository));
}
if (deploymentRepository == null)
{
throw new ArgumentNullException(nameof(deploymentRepository));
}
this.LifeCycle = new LifeCycleCatalog(experimentRepository, runRepository, new Clock());
this.Data = new DataCatalog(dataRepository);
this.Evaluation = new EvaluationCatalog(metricRepository, confusionMatrixRepository);
this.Model = new ModelCatalog(modelRepository, runRepository);
this.Training = new TrainingCatalog(hyperParameterRepository);
this.Deployment = new DeploymentCatalog(deploymentRepository, modelRepository, experimentRepository);
}
public RunController(
MyContext myContext,
IRunRepository runRepository,
IUnitOfWork unitOfWork,
IMapper mapper,
ILogger <RunController> logger,
IJwtHelper jwtHelper)
{
_myContext = myContext;
_runRepository = runRepository;
_unitOfWork = unitOfWork;
_mapper = mapper;
_logger = logger;
_jwtHelper = jwtHelper;
}
public RunController(ITicketRepository tick, IRunRepository run,
IReservationService resServ,
ITicketService tickServ,
ICalculationFactory calcFact,
IReservationRepository reservationRepo,
ITrainRepository trainRepo)
{
_tickRepo = tick;
_runRepo = run;
_resServ = resServ;
_tickServ = tickServ;
_calcFact = calcFact;
_reservationRepo = reservationRepo;
_trainRepo = trainRepo;
}
/// <summary>
/// Configures the builder to use a repository
/// </summary>
/// <returns>The current builder for chaining</returns>
public MLOpsBuilder UseMetaDataRepositories(IDbContextFactory contextFactory)
{
var runResolver = new RunResolver();
var experimentResolver = new ExperimentResolver(runResolver);
this.experimentRepository = new ExperimentRepository(contextFactory, experimentResolver);
this.runRepository = new RunRepository(contextFactory, new Clock(), runResolver, new RegisteredModelResolver());
this.dataRepository = new DataRepository(contextFactory, new DataResolver(), new DataCalculator());
this.metricRepository = new MetricRepository(contextFactory);
this.confusionMatrixRepository = new ConfusionMatrixRepository(contextFactory);
this.hyperParameterRepository = new HyperParameterRepository(contextFactory);
this.deploymentRepository = new DeploymentRepository(contextFactory, new Clock(), new DeploymentTargetResolver());
return(this);
}
public RunController(ITicketRepository tick, IRunRepository run,
IReservationService resServ,
ITicketService tickServ,
IPriceCalculationStrategy priceCalcStrategy,
IReservationRepository reservationRepo,
ITrainRepository trainRepo)
{
_tickRepo = tick;
_runRepo = run;
_resServ = resServ;
_tickServ = tickServ;
_priceCalc = priceCalcStrategy;
_reservationRepo = reservationRepo;
_trainRepo = trainRepo;
}
public RunController(ITicketRepository tick, IRunRepository run,
IReservationService resServ,
ITicketService tickServ,
IStrategyFactory strategyFactory,
IReservationRepository reservationRepo,
ITrainRepository trainRepo)
{
_tickRepo = tick;
_runRepo = run;
_resServ = resServ;
_tickServ = tickServ;
_strategyFactory = strategyFactory;
_reservationRepo = reservationRepo;
_trainRepo = trainRepo;
}
/// <summary>
/// Starts the run
/// </summary>
/// <param name="run"></param>
/// <param name="runRepository"></param>
/// <returns></returns>
private List <RunInstance> StartRun(Run run, IRunRepository runRepository)
{
DateTime executeStartedDateTime = DateTime.UtcNow;
// Flag as scheduled
run.ExecuteStartedDateTime = executeStartedDateTime;
foreach (var scenario in run.Scenarios)
{
scenario.Status = ScenarioStatuses.Scheduled;
scenario.StartedDateTime = executeStartedDateTime; // Default, may be overriden for when scenario is actually started
}
runRepository.Update(run);
runRepository.SaveChanges(); // Persist changes before we exit lock, don't wait for HTTP request handler to call SaveChanges
return(_runManager.AllScenariosStartRun(run.Id));
}
public IPriceCalculationStrategy GetStrategy(IRunRepository runRepository, ITrainRepository trainRepository, DTO dto = null)
{
var defStrategy = new DefaultPriceCalculationStrategy(runRepository, trainRepository);
if (dto == null &&
dto.TeaCount == 0 &&
dto.CoffeeCount == 0 &&
dto.CookiesCount == 0)
{
return(defStrategy);
}
else
{
return(new PriceCalculationDecorator(defStrategy, dto.TeaCount, dto.CoffeeCount, dto.CookiesCount));
}
}
private static bool OtherActiveRunsWithWorkingScenarios(IRunRepository runRepository, Guid currentRunId)
{
foreach (Run run in runRepository.GetAllActive())
{
if (run.Id == currentRunId)
{
continue;
}
foreach (var scenario in run.Scenarios)
{
if (scenario.Status == ScenarioStatuses.InProgress || scenario.Status == ScenarioStatuses.Scheduled || scenario.Status == ScenarioStatuses.Starting)
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// Creates run from template
/// </summary>
/// <param name="templateRun"></param>
/// <param name="runRepository"></param>
/// <returns></returns>
private Run CreateRunFromTemplate(Run templateRun, IRunRepository runRepository)
{
using (var scope = _repositoryFactory.BeginRepositoryScope())
{
// Get sales areas for the run
var salesAreaRepository = scope.CreateRepository <ISalesAreaRepository>();
var salesAreas = RunManager.GetSalesAreas(templateRun, salesAreaRepository.GetAll());
// Set the default run start date time using today's date and time from template run, use it as the starting point to try and
// find some schedule data.
DateTime startingDateTime = new DateTime(DateTime.UtcNow.Year, DateTime.UtcNow.Month, DateTime.UtcNow.Day, templateRun.StartDate.Hour, templateRun.StartDate.Minute, templateRun.StartDate.Second, templateRun.StartDate.Millisecond, templateRun.StartDate.Kind);
// Clone template run, reset it, set date range
Run cloneRun = (Run)templateRun.Clone();
cloneRun.Id = Guid.NewGuid();
cloneRun.Description = $"Deployment Test ({GetVersion().Version})";
cloneRun.CreatedDateTime = DateTime.UtcNow;
cloneRun.ExecuteStartedDateTime = null;
cloneRun.LastModifiedDateTime = cloneRun.CreatedDateTime;
cloneRun.IsLocked = false;
cloneRun.Scenarios.ForEach(scenario => scenario.ResetToPendingStatus());
cloneRun.StartDate = GetRunStartDate(startingDateTime, salesAreas, 90);
if (cloneRun.StartDate == DateTime.MaxValue)
{
throw new Exception("Unable to determine start date for test run due to insufficient data");
}
cloneRun.EndDate = cloneRun.StartDate.AddDays(1);
cloneRun.Real = false; // Flag that it's not a real run
// Clear IDs so that we can assign new ones
//IdUpdater.ClearIds(cloneRun);
cloneRun.Id = Guid.Empty;
cloneRun.CustomId = 0;
// Set new IDs
IdUpdater.SetIds(cloneRun, _identityGeneratorResolver);
// Save run
runRepository.Add(cloneRun);
runRepository.SaveChanges();
return(cloneRun);
}
}
public RunController(IRunRepository<Run> _repo)
{
_runRepo = _repo;
}
