public void Apply()
{
using (var documentStore = DocumentStoreFactory.CreateStore(_masterConnectionString, null))
using (var session = documentStore.OpenSession())
{
var existingFeatures = session.GetAll <TenantProductFeature>().Select(f => f.Name).ToHashSet();
var newFeatures = Enum.GetValues(typeof(ProductFeature))
.Cast <ProductFeature>()
.Except(new[] { default(ProductFeature) })
.Where(name => !existingFeatures.Contains(name.ToString()))
.ToList();
var defaultFeatures = new List <TenantProductFeature>();
// add all features with disabled state
foreach (int tenantId in session.GetAll <Tenant>().Select(t => t.Id))
{
defaultFeatures.AddRange(newFeatures
.Select(feature => new TenantProductFeature
{
Name = feature.ToString(),
TenantId = tenantId,
IsShared = IsShared(feature),
Enabled = false
}));
}
foreach (var feature in defaultFeatures)
{
session.Store(feature);
}
session.SaveChanges();
}
}
public void Apply()
{
foreach (var tenantConnectionString in _tenantConnectionStrings)
{
using (var documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString, null))
using (var session = documentStore.OpenSession())
{
foreach (var campaign in session.GetAll <Campaign>().Where(x => !x.TargetZeroRatedBreaks))
{
foreach (var salesAreaCampaignTarget in campaign.SalesAreaCampaignTarget)
{
foreach (var campaignTarget in salesAreaCampaignTarget.CampaignTargets)
{
foreach (var strikeWeight in campaignTarget.StrikeWeights)
{
foreach (var dayPart in strikeWeight.DayParts)
{
dayPart.TotalSpotCount = 0;
dayPart.ZeroRatedSpotCount = 0;
dayPart.Ratings = 0;
dayPart.BaseDemographRatings = 0;
dayPart.NominalValue = 0;
}
}
}
}
}
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 void Apply()
{
foreach (var tenantConnectionString in _tenantConnectionStrings)
{
using (var documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString))
using (var session = documentStore.OpenSession())
{
var scenarios = session.GetAll <Scenario>();
var demographics = session.GetAll <Demographic>();
foreach (var scenario in scenarios)
{
foreach (var campaignPassPriority in scenario.CampaignPassPriorities)
{
var demographicName = campaignPassPriority.Campaign.Demographic;
var demographic = demographics.FirstOrDefault(d => d.ShortName == demographicName);
if (demographic != null)
{
campaignPassPriority.Campaign.Demographic = demographic.Name;
}
}
}
session.SaveChanges();
}
}
}
/// <summary>
/// add "Sponsorship Exclusivity" to Rule Document
/// </summary>
public void Apply()
{
foreach (string tenantConnectionString in _tenantConnectionStrings)
{
using (IDocumentStore documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString))
{
using (IDocumentSession session = documentStore.OpenSession())
{
var ruleRepository = new RavenRuleRepository(session);
var rules = ruleRepository.GetAll();
if (!rules.Any(r => r.RuleId == 6 && r.RuleTypeId == 1))
{
var rule = new Rule()
{
RuleId = 6,
RuleTypeId = 1,
InternalType = "Defaults",
Description = "Sponsorship Exclusivity",
Type = "general"
};
ruleRepository.Add(rule);
ruleRepository.SaveChanges();
}
}
}
}
}
public void Apply()
{
foreach (var tenantConnectionString in _tenantConnectionStrings)
{
using (var documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString, null))
using (var session = documentStore.OpenSession())
{
var metadataRepository = new RavenMetadataRepository(session);
var metadataCategories = metadataRepository.GetByKey(MetaDataKeys.ProgramCategories);
if (metadataCategories != null && metadataCategories.Any())
{
var existedProgrammeCategories = session.GetAll <ProgrammeCategoryHierarchy>();
var categoriesToAdd = metadataCategories.Where(x => !existedProgrammeCategories.Any(pc => pc
.Name
.Equals(x.Value.ToString(), StringComparison.OrdinalIgnoreCase))).ToList();
if (categoriesToAdd.Any())
{
foreach (var programmeCategory in categoriesToAdd)
{
session.Store(
new ProgrammeCategoryHierarchy {
Name = programmeCategory.Value.ToString()
});
}
}
metadataRepository.DeleteByKey(MetaDataKeys.ProgramCategories);
}
session.SaveChanges();
}
}
}
public List <SystemTestResult> Execute(SystemTestCategories systemTestCategory)
{
var results = new List <SystemTestResult>();
try
{
string connectionString = _applicationConfiguration["db:Master:connectionString"];
using (IDocumentStore documentStore = DocumentStoreFactory.CreateStore(connectionString, System.Reflection.Assembly.GetExecutingAssembly()))
{
var databaseConfiguration = documentStore.DatabaseCommands.Admin.GetDatabaseConfiguration();
if (databaseConfiguration != null)
{
results.Add(new SystemTestResult(SystemTestResult.ResultTypes.Information, _category, "Database connectivity test OK", ""));
}
else
{
results.Add(new SystemTestResult(SystemTestResult.ResultTypes.Error, _category, string.Format("Database doesn't exist. Please check the connection string"), ""));
}
}
}
catch (Exception exception)
{
results.Add(new SystemTestResult(SystemTestResult.ResultTypes.Error, _category, string.Format("Unable to connect to database and run a query: {0}. Please check the connection to the Database Server", exception.Message), ""));
}
return(results);
}
public void Apply()
{
foreach (var tenantConnectionString in _tenantConnectionStrings)
{
using (var documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString))
using (var session = documentStore.OpenSession())
{
var functionalAreas = session.GetAll <FunctionalArea>();
var slottingControlsFunctionalArea =
functionalAreas.FirstOrDefault(fa => fa.Description.ContainsValue(SlottingControlsFunctionalAreaDescription));
var tarpsFaultType = slottingControlsFunctionalArea?.FaultTypes.FirstOrDefault(ft => ft.Id == TarpsFaultTypeId);
if (tarpsFaultType is null)
{
return;
}
foreach (var language in tarpsFaultType.Description.Keys.ToArray())
{
tarpsFaultType.Description[language] = TarpsFaultTypeDescriptionNew;
}
session.SaveChanges();
}
}
}
public void RollBack()
{
foreach (var tenantConnectionString in _tenantConnectionStrings)
{
using (var documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString, null))
using (var session = documentStore.OpenSession())
{
var templates = session.GetAll <BRSConfigurationTemplate>();
templates.ForEach(template =>
{
foreach (var kpiName in _kpiNames)
{
if (template.KPIConfigurations.Exists(x => x.KPIName == kpiName))
{
continue;
}
template.KPIConfigurations.Add(new BRSConfigurationForKPI
{
KPIName = kpiName,
PriorityId = ExcludedPriorityId
});
}
template.LastModified = DateTime.UtcNow;
});
session.SaveChanges();
}
}
}
public void Apply()
{
foreach (var tenantConnectionString in _tenantConnectionStrings)
{
using (var documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString, null))
using (var session = documentStore.OpenSession())
{
foreach (var campaign in session.GetAll <Campaign>().Where(x => !x.TargetZeroRatedBreaks))
{
campaign.CampaignPaybacks = null;
campaign.TargetXP = null;
campaign.RevenueBooked = null;
campaign.CreationDate = null;
campaign.AutomatedBooked = null;
campaign.TopTail = null;
campaign.Spots = null;
foreach (var campaignTarget in campaign.SalesAreaCampaignTarget)
{
foreach (var target in campaignTarget.CampaignTargets)
{
foreach (var strikeWeight in target.StrikeWeights)
{
strikeWeight.Payback = null;
}
}
}
}
session.SaveChanges();
}
}
}
public void Apply()
{
using (var documentStore = DocumentStoreFactory.CreateStore(_masterConnectionString, null))
using (var session = documentStore.OpenSession())
{
var existingFlag = session
.GetAll <TenantProductFeature>()
.FirstOrDefault(x => x.Name == nameof(ProductFeature.SAPPTargetAreaName));
if (existingFlag != null)
{
return;
}
foreach (int tenantId in session.GetAll <Tenant>().Select(t => t.Id))
{
session.Store(new TenantProductFeature
{
Name = nameof(ProductFeature.SAPPTargetAreaName),
TenantId = tenantId,
IsShared = true,
Enabled = false
});
}
session.SaveChanges();
}
}
public void Apply()
{
using (var documentStore = DocumentStoreFactory.CreateStore(_masterConnectionString, null))
using (var session = documentStore.OpenSession())
{
foreach (int tenantId in session.GetAll <Tenant>().Select(t => t.Id))
{
session.Store(new TenantProductFeature
{
Name = nameof(ProductFeature.NineValidationMinSpot),
TenantId = tenantId,
IsShared = false,
Enabled = true
});
session.Store(new TenantProductFeature
{
Name = nameof(ProductFeature.NineValidationRatingPredictions),
TenantId = tenantId,
IsShared = false,
Enabled = true
});
session.Store(new TenantProductFeature
{
Name = nameof(ProductFeature.IncludeChannelGroupFileForOptimiser),
TenantId = tenantId,
IsShared = false,
Enabled = true
});
}
session.SaveChanges();
}
}
public void Apply()
{
foreach (var tenantConnectionString in _tenantConnectionStrings)
{
using (var documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString, null))
using (var session = documentStore.OpenSession())
{
var allClashes = session.GetAll <Clash>();
foreach (var clash in allClashes)
{
clash.DefaultPeakExposureCount =
clash.DefaultOffPeakExposureCount = clash.ExposureCount;
if (clash.Differences is null)
{
clash.Differences = new List <ClashDifference>();
}
session.Store(clash);
}
session.SaveChanges();
}
}
}
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 (var cs in _tenantConnectionStrings)
{
using (var documentStore = DocumentStoreFactory.CreateStore(cs, null))
using (var dbContext = new RavenDbContext(documentStore.OpenSession(), documentStore.OpenAsyncSession()))
{
dbContext.Truncate <ProgrammeDictionary>();
var cache = new Dictionary <string, ProgrammeDictionary>();
foreach (var programme in dbContext.Specific.GetAllWithNoTracking <Programme>())
{
if (!cache.TryGetValue(programme.ExternalReference, out var dictionary))
{
dictionary = new ProgrammeDictionary {
ExternalReference = programme.ExternalReference
};
cache.Add(programme.ExternalReference, dictionary);
}
dictionary.ProgrammeName = programme.ProgrammeName;
dictionary.Description = programme.Description;
dictionary.Classification = programme.Classification;
}
dbContext.AddRange(cache.Values.ToArray());
}
}
}
public void Apply()
{
foreach (var tenantConnectionString in _tenantConnectionStrings)
{
using (var documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString, null))
using (var session = documentStore.OpenSession())
{
var allFunctionalAreas = session.GetAll <FunctionalArea>();
foreach (var functionalArea in allFunctionalAreas)
{
foreach (var faultType in functionalArea.FaultTypes)
{
if (_shortNames.TryGetValue(faultType.Id, out var shortName))
{
foreach (var language in Globals.SupportedLanguages)
{
faultType.ShortName.Add(language, shortName);
}
}
}
session.Store(functionalArea);
}
session.SaveChanges();
}
}
}
public void Apply()
{
foreach (var tenantConnectionString in _tenantConnectionStrings)
{
using (var documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString, null))
using (var session = documentStore.OpenSession())
{
var passesOld = new List <PassV1>();
var page = 0;
var pageSize = 1024;
QueryResult passQueryResult = null;
do
{
passQueryResult = session.Advanced.DocumentStore.DatabaseCommands.Query("Raven/DocumentsByEntityName",
new IndexQuery {
Query = "Tag:[[Passes]]", Start = page * pageSize, PageSize = pageSize
});
ParseRavenDocuments(passQueryResult, passesOld);
page++;
} while (page * pageSize <= (passQueryResult?.TotalResults ?? 0));
var passesNew = passesOld.Select(UpdatePassStructure).ToList();
passesNew.ForEach(pass => session.Store(pass));
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();
}
}
}
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();
}
}
}
protected override void Load(ContainerBuilder builder)
{
builder.Register(ctx => DocumentStoreFactory.Create(ctx.Resolve <DatabaseConfig>()))
.As <IDocumentStore>()
.SingleInstance();
builder.RegisterType <ExchangeService>().AsSelf();
}
public void Apply()
{
foreach (var tenantConnectionString in _tenantConnectionStrings)
{
using (var documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString))
using (var session = documentStore.OpenSession())
{
const int tarpsFaultTypeId = 82;
const string slottingControlsFunctionalAreaDescription = "Slotting Controls";
const string tarpsFaultTypeDescription = "Min TARPs not met";
var functionalAreas = session.GetAll <FunctionalArea>();
var slottingControlsFunctionalArea =
functionalAreas.FirstOrDefault(fa => fa.Description.ContainsValue(slottingControlsFunctionalAreaDescription));
if (slottingControlsFunctionalArea is null)
{
var descriptionDictionary = new Dictionary <string, string>();
foreach (var language in Globals.SupportedLanguages)
{
descriptionDictionary.Add(language, slottingControlsFunctionalAreaDescription);
}
slottingControlsFunctionalArea = new FunctionalArea
{
Description = descriptionDictionary,
FaultTypes = new List <FaultType>()
};
session.Store(slottingControlsFunctionalArea);
}
if (slottingControlsFunctionalArea.FaultTypes.All(
ft => ft.Id != tarpsFaultTypeId))
{
var faultTypeDescriptionDictionary = new Dictionary <string, string>();
foreach (var language in Globals.SupportedLanguages)
{
faultTypeDescriptionDictionary.Add(language, tarpsFaultTypeDescription);
}
slottingControlsFunctionalArea.FaultTypes.Add(new FaultType
{
Id = tarpsFaultTypeId,
Description = faultTypeDescriptionDictionary,
IsSelected = true
});
}
session.SaveChanges();
}
}
}
/// <summary>
/// Fixes scenarios/passes where the pass is referenced by multiple scenarios.
/// </summary>
public void Apply()
{
foreach (string tenantConnectionString in _tenantConnectionStrings)
{
using (IDocumentStore documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString))
using (IDocumentSession session = documentStore.OpenSession())
using (var identityGenerator = new RavenIdentityGenerator(documentStore))
{
// Get scenario/pass repositories
var scenarioRepository = new RavenScenarioRepository(session);
var passRepository = new RavenPassRepository(session);
// Get all scenarios
var scenarios = scenarioRepository.GetAll().OrderBy(s => s.CustomId);
// Check each scenario and passes
Dictionary <int, Guid> firstScenarioIdByPassId = new Dictionary <int, Guid>();
foreach (var scenario in scenarios)
{
bool scenarioChanged = false;
// Check each pass
foreach (var passRef in scenario.Passes)
{
if (firstScenarioIdByPassId.ContainsKey(passRef.Id)) // Another scenario references this pass
{
// Load pass
var pass = passRepository.Get(passRef.Id);
// Clone pass with new ID
var newPass = (Pass)pass.Clone();
newPass.Id = identityGenerator.GetIdentities <PassIdIdentity>(1)[0].Id;
newPass.Name = string.Format("Pass {0}", newPass.Id);
passRef.Id = newPass.Id; // Link scenario to this pass
passRepository.Add(newPass);
scenarioRepository.Update(scenario);
scenarioChanged = true;
}
else // No other scenarios reference this pass
{
firstScenarioIdByPassId.Add(passRef.Id, scenario.Id);
}
}
// Save changes
if (scenarioChanged)
{
passRepository.SaveChanges();
scenarioRepository.SaveChanges();
}
}
}
}
}
public void Apply()
{
foreach (var tenantConnectionString in _tenantConnectionStrings)
{
using (var documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString, null))
using (var session = documentStore.OpenSession())
{
var kpiPriorities = new List <KPIPriority>
{
new KPIPriority {
Id = 1, Name = "Exclude", WeightingFactor = 0
},
new KPIPriority {
Id = 2, Name = "Extremely Low", WeightingFactor = 0.3
},
new KPIPriority {
Id = 3, Name = "Low", WeightingFactor = 0.7
},
new KPIPriority {
Id = 4, Name = "Medium", WeightingFactor = 1
},
new KPIPriority {
Id = 5, Name = "High", WeightingFactor = 1.3
},
new KPIPriority {
Id = 6, Name = "Extremely High", WeightingFactor = 1.7
},
};
using (var bulkInsert = session.Advanced.DocumentStore.BulkInsert(null, new BulkInsertOptions()
{
OverwriteExisting = true
}))
{
kpiPriorities.ToList().ForEach(item => bulkInsert.Store(item));
}
var template = new BRSConfigurationTemplate
{
Name = "Default template",
IsDefault = true,
LastModified = DateTime.UtcNow,
KPIConfigurations = BRSHelper.KPIs.Select(kpi => new BRSConfigurationForKPI
{
KPIName = kpi,
PriorityId = 4
}).ToList()
};
session.Store(template);
session.SaveChanges();
}
}
}
public void Apply()
{
foreach (string tenantConnectionString in _tenantConnectionStrings)
{
using (IDocumentStore documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString))
{
using (IDocumentSession session = documentStore.OpenSession())
{
ExecutePatchScriptByIndexQuery(session, "Raven/DocumentsByEntityName", "Tag:[[Passes]]", ScriptToFixPasses);
}
}
}
}
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();
}
}
}
}
public void Apply()
{
foreach (var tenantConnectionString in _tenantConnectionStrings)
{
using (var documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString, null))
using (var session = documentStore.OpenSession())
{
var tenantSettings = session.Query <TenantSettings>().First();
tenantSettings.AutoBookTargetedZeroRatedBreaks = TenantSettings.DefaultAutoBookTargetedZeroRatedBreaks;
session.SaveChanges();
}
}
}
public void Apply()
{
foreach (var tenantConnectionString in _tenantConnectionStrings)
{
using (var documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString))
using (var session = documentStore.OpenSession())
{
const int programmeRequirementFaultTypeId = 78;
const string campaignRequirementFunctionalAreaName = "Campaign Requirement";
var functionalAreas = session.GetAll <FunctionalArea>();
var programmeRequirementFunctionalArea =
functionalAreas.FirstOrDefault(fa => fa.Description.ContainsValue(campaignRequirementFunctionalAreaName));
if (programmeRequirementFunctionalArea is null)
{
programmeRequirementFunctionalArea = new FunctionalArea
{
Description = new Dictionary <string, string>
{
{ "ENG", campaignRequirementFunctionalAreaName },
{ "ARA", campaignRequirementFunctionalAreaName }
},
FaultTypes = new List <FaultType>()
};
session.Store(programmeRequirementFunctionalArea);
}
if (programmeRequirementFunctionalArea.FaultTypes.All(
ft => ft.Id != programmeRequirementFaultTypeId))
{
programmeRequirementFunctionalArea.FaultTypes.Add(new FaultType
{
Id = programmeRequirementFaultTypeId,
Description = new Dictionary <string, string>
{
{ "ENG", "Programme Requirement (Achieved/Oversupply)" },
{ "ARA", "Programme Requirement (Achieved/Oversupply)" }
},
IsSelected = true
});
}
session.SaveChanges();
}
}
}
public void Apply()
{
foreach (var tenantConnectionString in _tenantConnectionStrings)
{
using (var documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString, null))
using (var session = documentStore.OpenSession())
{
var scenarios = session.GetAll <Scenario>();
scenarios.ForEach(x => x.DateUserModified = x.DateModified ?? DateTime.UtcNow);
session.SaveChanges();
}
}
}
public void Apply()
{
foreach (var tenantConnectionString in _tenantConnectionStrings)
{
using (var documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString, null))
using (var session = documentStore.OpenSession())
{
foreach (var campaign in session.GetAll <Campaign>().Where(x => !x.TargetZeroRatedBreaks))
{
campaign.TargetZeroRatedBreaks = false;
}
session.SaveChanges();
}
}
}
public void Apply()
{
foreach (string tenantConnectionString in _tenantConnectionStrings)
{
using (IDocumentStore documentStore = DocumentStoreFactory.CreateStore(tenantConnectionString))
using (IDocumentSession session = documentStore.OpenSession())
{
var autoBookDefaultParametersRepository = new RavenAutoBookDefaultParametersRepository(session);
autoBookDefaultParametersRepository.AddOrUpdate(GetAutoBookDefaultParameters());
autoBookDefaultParametersRepository.SaveChanges();
}
}
}
