public IEnumerable <ClearanceCode> GetAll() { lock (_session) { return(_session.GetAll <ClearanceCode>()); } }
public void Apply() { foreach (string tenantConnectionString in _tenantConnectionStrings) { using (IDocumentStore documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString)) using (IDocumentSession session = documentStore.OpenSession()) { var awsconfigs = session.GetAll <AWSInstanceConfiguration>(); var autobookconfigs = session.GetAll <AutoBookInstanceConfiguration>(); foreach (AutoBookInstanceConfiguration abic in autobookconfigs) { var aws = awsconfigs.Find(x => x.Id == abic.Id); if (aws != null) { abic.InstanceType = aws.InstanceType; abic.StorageSizeGb = aws.StorageSizeGb; abic.Cost = aws.Cost; } } awsconfigs.ForEach(aws => session.Delete(aws)); session.SaveChanges(); } } }
public IEnumerable <Restriction> GetAll() { lock (_session) { return(_session.GetAll <Restriction>().ToList()); } }
public IEnumerable <PipelineAuditEvent> GetAll() { lock (_session) { return(_session.GetAll <PipelineAuditEvent>()); } }
public IEnumerable <AutoBookTaskReport> GetAll() { lock (_session) { return(_session.GetAll <AutoBookTaskReport>()); } }
public IEnumerable <Demographic> GetByExternalRef(List <string> externalRefs) { var items = _session.GetAll <Demographic>(d => d.ExternalRef.In(externalRefs), indexName: Demographic_BySearch.DefaultIndexName, isMapReduce: false); return(items.ToList()); }
public IEnumerable <Recommendation> GetByScenarioId(Guid scenarioId) { lock (_session) { var recommendations = _session.GetAll <Recommendation>(recommendation => recommendation.ScenarioId == scenarioId, indexName: Recommendations_Default.DefaultIndexName, isMapReduce: false).ToList(); return(recommendations); } }
public void DeleteRange(IEnumerable <int> ids) { lock (_session) { var rules = _session.GetAll <RatingsPredictionSchedule>(s => s.Id.In(ids.ToList())); foreach (var rule in rules) { _session.Delete(rule); } } }
public void Delete(IEnumerable <int> ids) { lock (_session) { var rules = _session.GetAll <AutopilotRule>(s => s.Id.In(ids.ToList())); foreach (var rule in rules) { _session.Delete(rule); } } }
public void DeleteRangeByGroupId(IEnumerable <int> ids) { lock (_session) { var bookingPositionGroups = _session.GetAll <BookingPositionGroup>(s => s.Id.In(ids.ToList())); foreach (var positionGroup in bookingPositionGroups) { _session.Delete(positionGroup); } } }
public void DeleteBySalesAreaName(string name) { lock (_session) { var salesAreaDemographics = _session.GetAll <SalesAreaDemographic>(x => x.SalesArea == name); foreach (var salesAreaDemographic in salesAreaDemographics) { _session.Delete <SalesAreaDemographic>(salesAreaDemographic.Id); } } }
public void Apply() { foreach (string tenantConnectionString in _tenantConnectionStrings) { using (IDocumentStore documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString)) using (IDocumentSession session = documentStore.OpenSession()) { var programmeRuleId = (int)ToleranceRuleId.Programme; var programmeRuleTypeId = (int)RuleCategory.Tolerances; var rules = session.GetAll <Rule>(); if (!rules.Any(r => r.RuleId == programmeRuleId)) { session.Store( new Rule { RuleTypeId = programmeRuleTypeId, RuleId = programmeRuleId, Description = "Programme", InternalType = "Campaign", Type = "tolerances" }); session.SaveChanges(); } var isAllowedAutopilot = session.GetAll <RuleType>() .Any(rt => rt.AllowedForAutopilot && rt.Id == programmeRuleTypeId); var hasProgrammeAutopilotRule = session.GetAll <AutopilotRule>() .Any(rt => rt.RuleId == programmeRuleId); if (isAllowedAutopilot && !hasProgrammeAutopilotRule) { var newAutopilotRules = new List <AutopilotRule>(); newAutopilotRules.Add(AutopilotRule.Create((int)AutopilotFlexibilityLevel.Low, programmeRuleId, programmeRuleTypeId, 5, 5, 10, 10)); newAutopilotRules.Add(AutopilotRule.Create((int)AutopilotFlexibilityLevel.Medium, programmeRuleId, programmeRuleTypeId, 10, 10, 20, 20)); newAutopilotRules.Add(AutopilotRule.Create((int)AutopilotFlexibilityLevel.High, programmeRuleId, programmeRuleTypeId, 15, 15, 30, 30)); newAutopilotRules.Add(AutopilotRule.Create((int)AutopilotFlexibilityLevel.Extreme, programmeRuleId, programmeRuleTypeId, 20, 20, 40, 40)); foreach (var autopilotRule in newAutopilotRules) { session.Store(autopilotRule); } session.SaveChanges(); } } } }
///<summary>Find all scenarios with the given ids.</summary> /// <remarks>RavenDB will throw an exception (Lucene.Net.Search.BooleanQuery.TooManyClauses) /// if more than 1,024 items are passed to its in() function. /// </remarks> public IEnumerable <Scenario> FindByIds(IEnumerable <Guid> ids) { const int BatchSize = 1000; if (!ids.Any()) { return(new List <Scenario>(0)); } IReadOnlyCollection <Guid> sourceIds = ids.ToList(); lock (_session) { if (sourceIds.Count < BatchSize) { return(GetBatch(sourceIds)); } var result = new List <Scenario>(); int pageNumber = 0; do { var batch = sourceIds .Skip(BatchSize * pageNumber) .Take(BatchSize) .ToList(); if (batch.Count == 0) { return(result); } result.AddRange( GetBatch(batch) ); ++pageNumber; } while (true); //---------------------- IReadOnlyCollection <Scenario> GetBatch(IEnumerable <Guid> batch) => _session.GetAll <Scenario>( s => s.Id.In(batch), indexName: Scenarios_Default.DefaultIndexName, isMapReduce: false ); } }
public IEnumerable <RuleType> GetAll(bool onlyAllowedAutopilot = false) { return(_session .GetAll <RuleType>() .Where(p => onlyAllowedAutopilot == false || p.AllowedForAutopilot) .ToList()); }
public List <AWSInstanceConfiguration> GetAll() { lock (_session) { return(_session.GetAll <AWSInstanceConfiguration>()); } }
public IEnumerable <CampaignSettings> GetAll() { lock (_session) { return(_session.GetAll <CampaignSettings>().ToList()); } }
public void Apply() { foreach (string tenantConnectionString in _tenantConnectionStrings) { using (IDocumentStore documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString)) { using (IDocumentSession session = documentStore.OpenSession()) { var functionalArea = session .GetAll <FunctionalArea>() .Where(a => a.Description.Values.Contains("Slotting Controls")) .FirstOrDefault(); if (functionalArea != null) { var faultType = functionalArea.FaultTypes .Where(b => b.Description.Values.Contains("Miniumum Break Availability")) .Select(c => { c.Description["ARA"] = "Minimum Break Availability"; c.Description["ENG"] = "Minimum Break Availability"; return(c); }) .FirstOrDefault(); session.SaveChanges(); } } } } }
public void Apply() { foreach (string tenantConnectionString in _tenantConnectionStrings) { using (IDocumentStore documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString)) using (IDocumentSession session = documentStore.OpenSession()) { var passes = session.GetAll <Pass>(); passes .ForEach(pass => { if (pass.Tolerances.All(x => x.RuleId != (int)ToleranceRuleId.Programme)) { pass.Tolerances.Add(new Tolerance { RuleId = (int)ToleranceRuleId.Programme, Description = "Programme", InternalType = "Campaign", Type = "tolerances", Value = null, Ignore = true, ForceOverUnder = ForceOverUnder.None }); } }); session.SaveChanges(); } } }
/// <summary> /// Added field IsLibraried for scenarios and passes /// </summary> public void Apply() { foreach (string tenantConnectionString in _tenantConnectionStrings) { using (IDocumentStore documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString)) { using (IDocumentSession session = documentStore.OpenSession()) { var passes = session.GetAll <Pass>(); // Add new General rule to the Pass with default value 0 passes .ForEach(pass => { if (!pass.General.Any(rule => rule.RuleId == (int)RuleID.UseCampaignMaxSpotRatings)) { pass.General.Add(new General { RuleId = (int)RuleID.UseCampaignMaxSpotRatings, Description = "Use Max Spot Ratings Set By Campaigns", InternalType = "Defaults", Type = "general", Value = "0" }); } }); session.SaveChanges(); } } } }
public IEnumerable <IndexType> GetAll() { lock ( _session) { return(_session.GetAll <IndexType>()); } }
public List <KPIComparisonConfig> GetAll() { lock (_session) { return(_session.GetAll <KPIComparisonConfig>().ToList()); } }
public IEnumerable <ProgrammeClassification> GetAll() { lock (_session) { return(_session.GetAll <ProgrammeClassification>().ToList()); } }
public void DeleteRangeByExternalRefs(IEnumerable <string> externalRefs) { var products = _session.GetAll <Product>(s => s.Externalidentifier.In(externalRefs.ToList())); foreach (var product in products) { _session.Delete(product); } }
public void Apply() { foreach (string tenantConnectionString in _tenantConnectionStrings) { using (IDocumentStore documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString)) using (IDocumentSession session = documentStore.OpenSession()) { var scenarios = session.GetAll <Scenario>(); var passes = session.GetAll <Pass>(); var rules = session.GetAll <Rule>(); UpdateRules(rules); var notStartedRuns = session.GetAll <Run>() .FindAll(r => r.RunStatus == RunStatus.NotStarted && r.Scenarios.Any()); var notStartedRunScenarios = new List <Scenario>(); foreach (var run in notStartedRuns) { var scenarioIds = run.Scenarios.Select(x => x.Id); notStartedRunScenarios.AddRange(scenarios.FindAll(s => scenarioIds.Contains(s.Id))); } var scenarioPasses = GetScenariosPasses(notStartedRunScenarios, passes); var libraryScenarios = scenarios.FindAll(s => s.IsLibraried == true); var libraryScenariosPasses = GetScenariosPasses(libraryScenarios, passes); var libraryPasses = passes.FindAll(p => p.IsLibraried == true); scenarioPasses.ForEach(UpdatePassRules); libraryScenariosPasses.ForEach(UpdatePassRules); libraryPasses.ForEach(UpdatePassRules); session.SaveChanges(); } } }
public IEnumerable <Sponsorship> GetAll() { lock (_session) { return(_session.GetAll <Sponsorship>(p => !p.Id.In(ForceRavenDbToStreamResults), indexName: Sponsorship_ById.DefaultIndexName, isMapReduce: false)); } }
/// <summary> /// GetSchedule by list sales area names and schedule dates /// </summary> /// <param name="salesAreaNames"></param> /// <param name="fromDate"></param> /// <param name="toDate"></param> /// <returns></returns> public List <Schedule> GetSchedule(List <string> salesAreaNames, DateTime fromDate, DateTime toDate) { return(_session.GetAll <Schedule>( s => s.Date >= fromDate.Date && s.Date < toDate.Date.AddDays(1) && s.SalesArea.In(salesAreaNames), indexName: Schedules_ByIdAndBreakIdAndSalesAreaAndDate.DefaultIndexName, isMapReduce: false).ToList()); }
public IEnumerable <Break> FindByExternal(string externalref) { lock (_session) { List <Break> results = _session.GetAll <Break>(x => x.ExternalBreakRef == externalref, Breaks_ByManyFields.DefaultIndexName, isMapReduce: false ); return(results); } }
/// <summary> /// Add ProgrammeName to ProgrammeDictionary /// </summary> public void Apply() { foreach (string tenantConnectionString in _tenantConnectionStrings) { using (IDocumentStore documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString)) { using (IDocumentSession session = documentStore.OpenSession()) { var programmeDictionaries = session.GetAll <ProgrammeDictionary>(); var allProgrammes = session.GetAll <Programme>(); programmeDictionaries .ForEach(programmeDictionary => { var programme = allProgrammes.FirstOrDefault(p => p.ExternalReference == programmeDictionary.ExternalReference); if (programme != null) { programmeDictionary.ProgrammeName = programme.ProgrammeName; } }); session.SaveChanges(); } } } }
public void Apply() { foreach (string tenantConnectionString in _tenantConnectionStrings) { using (IDocumentStore documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString)) using (IDocumentSession session = documentStore.OpenSession()) { var runs = session.GetAll <Run>(); foreach (var run in runs) { if (run.ISR) { run.ISRDateRange = new DateRange() { Start = run.StartDate.Date, End = run.EndDate.Date }; } if (run.Smooth) { run.SmoothDateRange = new DateRange() { Start = run.StartDate.Date, End = run.EndDate.Date }; } if (run.Optimisation) { run.OptimisationDateRange = new DateRange() { Start = run.StartDate.Date, End = run.EndDate.Date }; } if (run.RightSizer) { run.RightSizerDateRange = new DateRange() { Start = run.StartDate.Date, End = run.EndDate.Date }; } } session.SaveChanges(); } } }
public void Apply() { var maximumValidUntilDate = new DateTimeOffset(DateTime.Now.AddYears(1)); var accessTokensToRemove = new List <AccessToken>(default(int)); using (IDocumentStore documentStore = DocumentStoreFactory.CreateStore(_masterConnectionString)) using (IDocumentSession session = documentStore.OpenSession()) { var existingTokens = session.GetAll <AccessToken>(accessToken => accessToken.ValidUntilValue <= maximumValidUntilDate); accessTokensToRemove.AddRange(existingTokens); BackupAccessTokens(accessTokensToRemove); accessTokensToRemove.ForEach(token => session.Delete(token)); session.SaveChanges(); } }