private void CheckAutoDevTimeProfileForZero1([NotNull] Simulator sim, [NotNull] HouseholdTrait householdTrait)
{
if (!PerformCleanupChecks)
{
return;
}
foreach (var autodev in householdTrait.Autodevs)
{
var tps = GetTimeProfile(autodev, sim.DeviceActions.It);
var profilesWithZero = new List <TimeBasedProfile>();
foreach (var profile in tps)
{
var lasttdp = profile.ObservableDatapoints[profile.ObservableDatapoints.Count - 1];
var secondlasttdp = profile.ObservableDatapoints[profile.ObservableDatapoints.Count - 2];
if (Math.Abs(lasttdp.Value) < 0.000001 && Math.Abs(secondlasttdp.Value) > 0.0000001)
{
profilesWithZero.Add(profile);
}
}
if (profilesWithZero.Count > 0)
{
var uniqueProfilesWithZero = profilesWithZero.Distinct();
var elements = new List <BasicElement>();
elements.AddRange(uniqueProfilesWithZero);
throw new DataIntegrityException(
"The opened time profiles for the device " + autodev.Device?.Name +
" has zero as last value. This will lead to odd drops in the autonomous device consumption. Please fix.",
elements);
}
}
}
private void CheckSleepDesire([NotNull] HouseholdTrait trait)
{
if (!PerformCleanupChecks)
{
return;
}
if (trait.Name.ToUpperInvariant().Contains("SLEEP"))
{
switch (trait.Desires.Count)
{
case 1:
if (trait.Desires[0].SicknessDesire != HealthStatus.HealthyOrSick)
{
throw new DataIntegrityException(
"Desire in the sleep trait " + trait.PrettyName +
" is not for both health and sickness.", trait);
}
break;
case 2:
// TODO: two desires... how to check they both apply to the same bed? The bed is only in the name. String matching sucks.
// leave it for now.
break;
default:
throw new DataIntegrityException("More than one desire in the sleep trait " + trait.PrettyName,
trait);
}
}
}
private static void CheckDesires([NotNull] HouseholdTrait trait)
{
foreach (var desire in trait.Desires)
{
if (desire.Threshold > 100)
{
throw new DataIntegrityException(
"The trait " + trait.Name +
" has a desire threshold over 100%. 100% is the maximum. Please fix.", trait);
}
foreach (var other in trait.Desires)
{
if (other != desire)
{
if (desire.Desire == other.Desire && desire.SicknessDesire == other.SicknessDesire &&
desire.Gender == other.Gender)
{
throw new DataIntegrityException(
"The desire " + desire.Desire.PrettyName + " seems to be twice in the trait " +
trait.Name + ". Please fix.", trait);
}
}
}
}
}
public HouseholdTraitPresenter([NotNull] ApplicationPresenter applicationPresenter, [NotNull] HouseholdTraitView view,
[NotNull] HouseholdTrait householdTrait)
: base(view, "ThisHouseholdTrait.HeaderString", householdTrait, applicationPresenter)
{
_hht = householdTrait;
_selectedAddCategory = CategoryOrDevice[0];
_autoSelectedAddCategory = CategoryOrDevice[0];
if (_hht.Locations.Count > 0)
{
SelectedAffLocation = _hht.Locations[0];
}
RefreshRelevantAffordancesForAdding();
if (_relevantAffordances.Count > 0)
{
SelectedAffordance = _relevantAffordances[0];
}
SelectedHouseholdTrait = Sim.HouseholdTraits[0];
RefreshUses();
RefreshClassifications();
foreach (TimeType type in Enum.GetValues(typeof(TimeType)))
{
TimeTypes.Add(type);
}
}
private void CheckPersonCounts([NotNull] HouseholdTrait householdTrait)
{
if (!PerformCleanupChecks)
{
return;
}
if (householdTrait.MinimumPersonsInCHH < 1 || householdTrait.MaximumPersonsInCHH > 20 ||
householdTrait.MaximumPersonsInCHH < 1)
{
householdTrait.MinimumPersonsInCHH = 1;
householdTrait.MaximumPersonsInCHH = 10;
throw new DataIntegrityException(
"The opened traits have either a minimum Person count of less than 1," +
" a maximum Person count less than 1 or more than 20. Or the number of times it can occur is more than 20 or less than 1.",
householdTrait);
}
if (householdTrait.MaximumNumberInCHH < 1 || householdTrait.MaximumNumberInCHH > 20)
{
householdTrait.MaximumNumberInCHH = 20;
throw new DataIntegrityException(
"The opened traits have either a minimum Person count of less than 1," +
" a maximum Person count less than 1 or more than 20. Or the number of times it can occur is more than 20 or less than 1.",
householdTrait);
}
}
public void LoadFromDatabaseTest()
{
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
var persons = db.LoadPersons();
db.ClearTable(HouseholdTrait.TableName);
var affordances = db.LoadAffordances(out var timeBasedProfiles, out _,
out var deviceCategories, out var realDevices, out var desires, out var loadTypes, out var timeLimits, out ObservableCollection <DeviceAction> deviceActions,
out ObservableCollection <DeviceActionGroup> deviceActionGroups, out var locations, out var variables, out _);
var tags = db.LoadTraitTags();
var householdTraits = db.LoadHouseholdTraits(locations, affordances,
realDevices, deviceCategories, timeBasedProfiles, loadTypes, timeLimits, desires, deviceActions,
deviceActionGroups, tags, variables);
var hht = new HouseholdTrait("bla", null, "blub", db.ConnectionString, "none", 1, 100, 10, 1, 1,
TimeType.Day, 1, 1, TimeType.Day, 1, 0, EstimateType.Theoretical, "", Guid.NewGuid().ToStrGuid());
hht.SaveToDB();
householdTraits.Add(hht);
var chht = new ModularHouseholdTrait(null, null, "hallo", db.ConnectionString,
householdTraits[0], null, ModularHouseholdTrait.ModularHouseholdTraitAssignType.Age, Guid.NewGuid().ToStrGuid());
chht.DeleteFromDB();
chht.SaveToDB();
var chht1 = new ModularHouseholdTrait(null, null, "hallo2", db.ConnectionString,
householdTraits[0], persons[0], ModularHouseholdTrait.ModularHouseholdTraitAssignType.Name, Guid.NewGuid().ToStrGuid());
chht1.SaveToDB();
chht1.DeleteFromDB();
db.Cleanup();
}
}
public void RegisterTrait([NotNull] HouseholdTrait trait)
{
if (_trait != trait)
{
return;
}
UsedCount++;
}
public HHTTrait([CanBeNull] int?pID, [CanBeNull] int?parentTraitID, [CanBeNull] HouseholdTrait thisTrait, [NotNull] string connectionString,
[NotNull] string name, StrGuid guid)
: base(name, TableName, connectionString, guid)
{
ID = pID;
_thisTrait = thisTrait;
ParentTraitID = parentTraitID;
TypeDescription = "Household Trait Subtrait";
}
public STTraitLimit([CanBeNull] int?pID, [NotNull] string connectionString, int settlementTemplateID, [NotNull] string name,
[CanBeNull] HouseholdTrait trait, int maximum, StrGuid guid) : base(name, TableName, connectionString, guid)
{
TypeDescription = "Settlement Template Household Trait Limit";
ID = pID;
_trait = trait;
_maximum = maximum;
_settlementTemplateID = settlementTemplateID;
}
private static void PickATrait([NotNull] Random r,
[NotNull] ModularHousehold chh,
[ItemNotNull][NotNull] List <HouseholdTrait> potentialTraits,
ref int traitexists,
ref int classificationexists,
ref int invalidForPerson,
[NotNull] Person p,
[CanBeNull] out HouseholdTrait trait,
[ItemNotNull][NotNull] List <STTraitLimit> limits,
ref int violatesLimit)
{
var trycount = 0;
trait = null;
while (trycount < 100 && trait == null)
{
var traitnumber = r.Next(potentialTraits.Count);
var success = true;
var traitsofThisPeron = chh.Traits.Where(t => t.DstPerson == p).Select(x => x.HouseholdTrait).ToList();
var classifications = traitsofThisPeron.Select(x => x.Classification).ToList();
var traitcount = chh.Traits.Count(x => x.HouseholdTrait == potentialTraits[traitnumber]);
var maximumNumber = potentialTraits[traitnumber].MaximumNumberInCHH;
if (traitcount >= maximumNumber)
{
success = false;
traitexists++;
}
if (traitsofThisPeron.Contains(potentialTraits[traitnumber]))
{
success = false;
traitexists++;
}
else if (classifications.Contains(potentialTraits[traitnumber].Classification))
{
success = false;
classificationexists++;
}
else if (!potentialTraits[traitnumber].IsValidForPerson(p))
{
success = false;
invalidForPerson++;
}
else if (!limits.All(x => x.IsPermitted(potentialTraits[traitnumber])))
{
success = false;
violatesLimit++;
}
if (success)
{
trait = potentialTraits[traitnumber];
}
trycount++;
}
}
public TemplatePersonTrait([CanBeNull] int?pID,
[CanBeNull] int?templatePersonID,
[NotNull] string name,
[NotNull] string connectionString,
[CanBeNull] HouseholdTrait trait, StrGuid guid) : base(name, TableName, connectionString, guid)
{
_trait = trait;
_templatePersonID = templatePersonID;
ID = pID;
TypeDescription = "Template Person Trait";
}
public bool IsPermitted([NotNull] HouseholdTrait trait)
{
if (trait != _trait)
{
return(true);
}
if (UsedCount < PermittedCount)
{
return(true);
}
return(false);
}
/*
* private void SaveDeviceDts([NotNull][ItemNotNull] List<CalcDeviceDto> deviceDtos)
* {
* List<HouseholdDefinition> deviceDefs = new List<HouseholdDefinition>();
* foreach (var deviceDto in deviceDtos)
* {
* HouseholdDefinition pd = new HouseholdDefinition();
* pd.Name = deviceDto.Name;
* pd.HouseholdKey = deviceDto.HouseholdKey;
* pd.Json = JsonConvert.SerializeObject(deviceDto, Formatting.Indented);
* deviceDefs.Add(pd);
* }
* _srls.SaveToDatabase(deviceDefs);
* }*/
private static void CollectDevicesFromTrait([NotNull] HouseholdTrait hht,
[NotNull][ItemNotNull] List <DeviceLocationTuple> deviceList)
{
var allDevices = hht.CollectDevicesFromTrait();
foreach (var dev in allDevices)
{
if (!deviceList.Any(x => x.Device == dev.Item2 && x.Location == dev.Item1))
{
deviceList.Add(new DeviceLocationTuple(dev.Item1, dev.Item2));
}
}
}
private void GeneralCleanupChecks([NotNull] HouseholdTrait trait)
{
if (!PerformCleanupChecks)
{
return;
}
var percentage = trait.EstimatedTimePerYearInH / 8760;
if (percentage > 0.03 && string.IsNullOrWhiteSpace(trait.ShortDescription))
{
throw new DataIntegrityException("The trait " + trait.PrettyName + " is missing a short description.",
trait);
}
if (trait.Name.ToUpperInvariant().Contains("(COPY)"))
{
throw new DataIntegrityException(
"The trait " + trait.PrettyName + " contains (copy) in the name. This is untidy. Please fix.",
trait);
}
if (string.IsNullOrEmpty(trait.Classification) || trait.Classification.ToUpperInvariant() == "UNKNOWN")
{
throw new DataIntegrityException(
"The household trait " + trait.Name + " is missing a classification. Please fix.", trait);
}
if (trait.Tags.Count == 0)
{
throw new DataIntegrityException(
"The household trait " + trait.Name + " is missing at least one tag. Please fix.", trait);
}
// check completeness
var affordancecount = trait.Locations.Select(x => x.AffordanceLocations.Count).Sum();
if (affordancecount == 0 && trait.Autodevs.Count == 0 && trait.Desires.Count == 0 &&
trait.SubTraits.Count == 0)
{
throw new DataIntegrityException(
"The household trait " + trait.Name + " seems to be empty. Please fix or delete!", trait);
}
if (affordancecount != 0 && trait.Desires.Count == 0)
{
throw new DataIntegrityException(
"The household trait " + trait.Name + " has affordances, but no desires. Please fix.", trait);
}
if (affordancecount == 0 && trait.Desires.Count != 0 &&
!trait.Name.ToUpperInvariant().Contains("DESIRE FOR FOOD") && !trait.Name.ToUpperInvariant().Contains("JOIN ONLY"))
{
throw new DataIntegrityException(
"The household trait " + trait.Name + " has desires, but no affordances. Please fix.", trait);
}
}
public void AddMoreDesiresTest()
{
Config.IsInUnitTesting = true;
CalcParameters parameters = CalcParametersFactory.MakeGoodDefaults();
HouseholdKey key = new HouseholdKey("hh5");
var persons = new List <ModularHouseholdPerson>();
var p = new Person("blub", 1, 1, 1, 1,
PermittedGender.Male, string.Empty, string.Empty, Guid.NewGuid().ToStrGuid());
var tt = new TraitTag("traittag", "", TraitLimitType.NoLimit, TraitPriority.All, Guid.NewGuid().ToStrGuid());
var mhp = new ModularHouseholdPerson(null, -1, p.PrettyName, "", p, tt, Guid.NewGuid().ToStrGuid());
persons.Add(mhp);
var hhVacations = new List <VacationTimeframe>();
Random r = new Random(1);
NormalRandom nr = new NormalRandom(0, 1, r);
//DeviceCategoryPicker picker = new DeviceCategoryPicker(r,null);
//var parameters = new CalcFactoryParameters(picker);
//CalcFactoryParameters.SetSkipChecking(true);
//var cloc = new CalcLocation("cloc", 1, Guid.NewGuid().ToStrGuid());
//var mock = new Mock<ILogFile>();
CalcParameters calcParameters = CalcParametersFactory.MakeGoodDefaults();
VacationDtoFactory vfac = new VacationDtoFactory(calcParameters, r);
CalcPersonDtoFactory cpf = new CalcPersonDtoFactory(parameters, r, nr, vfac);
var hhtDesires =
new List <ModularHousehold.PersonTraitDesireEntry>();
var d = new Desire("desire", 1, 1, 1, string.Empty, 1, false, 1, "", Guid.NewGuid().ToStrGuid());
var hhtDesire = new HHTDesire(1, 1, 1, d, HealthStatus.Healthy, 1, 1, string.Empty, "name", 1, 100,
PermittedGender.All, Guid.NewGuid().ToStrGuid());
var hht = new HouseholdTrait("blub", null, "", "", "", 1, 1, 1, 1, 1, TimeType.Day, 1, 1, TimeType.Day, 1,
1, EstimateType.FromCalculations,
"", Guid.NewGuid().ToStrGuid());
hhtDesires.Add(
new ModularHousehold.PersonTraitDesireEntry(
ModularHouseholdTrait.ModularHouseholdTraitAssignType.Age, null, hhtDesire, hht));
//var sharedDesireValues = new Dictionary<Desire, SharedDesireValue>();
var cpersons = cpf.MakePersonDtos(persons, key, hhVacations, hhtDesires, "hhname");
cpersons.Count.Should().Be(1);
var cp = cpersons[0];
//CalcPersonFactory.AddTraitDesires(hhtDesires, cpersons, 1, "name", sharedDesireValues);
cp.Desires.Count.Should().Be(1);
cp.Desires.Count.Should().Be(1);
p.PrettyName.Should().Be(cp.Name);
p.Age.Should().Be(cp.Age);
// id 1 for the dictionary
Assert.Equal(d.PrettyName, cp.Desires[0].Name);
}
private void CheckFoodTimeLimit([NotNull] HouseholdTrait trait)
{
if (!PerformCleanupChecks)
{
return;
}
foreach (var traitloc in trait.Locations)
{
if (trait.Name.ToLowerInvariant().Contains("lunch"))
{
foreach (var affordanceLocation in traitloc.AffordanceLocations)
{
var tl = affordanceLocation.TimeLimit;
if (tl == null)
{
throw new DataIntegrityException(
"The trait " + trait.Name + " has no time limit set for the affordance " +
affordanceLocation.Affordance?.PrettyName, trait);
}
if (!tl.Name.ToLowerInvariant().Contains("lunch"))
{
throw new DataIntegrityException(
"The trait " + trait.Name + " has a time limit set for the affordance " +
affordanceLocation.Affordance?.PrettyName + " set that is not lunch", trait);
}
}
}
if (trait.Name.ToLowerInvariant().Contains("dinner"))
{
foreach (var affordanceLocation in traitloc.AffordanceLocations)
{
var tl = affordanceLocation.TimeLimit;
if (tl == null)
{
throw new DataIntegrityException(
"The trait " + trait.Name + " has no time limit set for the affordance " +
affordanceLocation.Affordance?.PrettyName, trait);
}
if (!tl.Name.ToLowerInvariant().Contains("dinner"))
{
throw new DataIntegrityException(
"The trait " + trait.Name + " has a time limit set for the affordance " +
affordanceLocation.Affordance?.PrettyName + " set that is not dinner", trait);
}
}
}
}
}
private static void TagOfficeJob([NotNull] TimeLimitEntry timeLimitEntry, [NotNull] HouseholdTrait newTrait)
{
var livingTags = newTrait.Tags.Where(x => x.Tag.Name.Contains("Living Pattern / Office Job")).ToList();
if (livingTags.Count != 1)
{
throw new LPGException("More than one living pattern");
}
newTrait.DeleteHHTTag(livingTags[0]);
if (timeLimitEntry.Tag == null)
{
throw new LPGException("Tag was null");
}
newTrait.AddTag(timeLimitEntry.Tag);
}
private void CheckTraitLocations([NotNull] HouseholdTrait trait)
{
if (!PerformCleanupChecks)
{
return;
}
foreach (var hhtloc in trait.Locations)
{
if (hhtloc.Location.LocationDevices.Count > 0)
{
foreach (var hhtAffordance in hhtloc.AffordanceLocations)
{
if (hhtAffordance.Affordance == null)
{
throw new DataIntegrityException("Affordance was null");
}
if (!hhtAffordance.Affordance.NeedsLight &&
!hhtAffordance.Name.ToUpperInvariant().Contains("SLEEP") &&
!hhtAffordance.Name.ToUpperInvariant().Contains("NAP"))
{
throw new DataIntegrityException(
"The affordance " + hhtAffordance.Affordance.PrettyName + " is in the trait " +
trait.Name + " at the Location " + hhtloc.Location.PrettyName +
" which has light devices, but doesn't have 'needs light' enabled. Please fix.",
hhtAffordance.Affordance);
}
}
}
else
{
foreach (var affordance in hhtloc.AffordanceLocations)
{
if (affordance.Affordance == null)
{
throw new DataIntegrityException("Affordance was null");
}
if (affordance.Affordance.NeedsLight)
{
throw new DataIntegrityException(
"The affordance " + affordance.Affordance.PrettyName + " in the trait " + trait.Name +
" at the Location " + hhtloc.Location.PrettyName +
" has 'needs light' enabled, but the Location has no light. Please fix.",
affordance.Affordance);
}
}
}
}
}
private static void CheckAutonomousDevices([NotNull] HouseholdTrait trait)
{
var usedLocations = new List <Location>();
usedLocations.AddRange(trait.Locations.Select(x => x.Location));
foreach (var autodev in trait.Autodevs)
{
if (!usedLocations.Contains(autodev.Location))
{
throw new DataIntegrityException(
"The household trait " + trait.Name + " has the autonomous device " + autodev.Device?.Name +
" at the Location " + autodev.Location + ", which doesn't exist in the household. Please fix.",
trait);
}
}
}
public void TraitImportExportTest()
{
// WorkingDir wd = new WorkingDir(Utili.GetCurrentMethodAndClass());
using (var db1 = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
var sim1 = new Simulator(db1.ConnectionString);
using (var db2 = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
var sim2 = new Simulator(db2.ConnectionString);
//check if the basic thing is identical
/*sim1.HouseholdTraits[0].Should().BeEquivalentTo(sim2.HouseholdTraits[0], o => o.Excluding(
* x => IsInvalidMember(x)
* ).IgnoringCyclicReferences());*/
//check import
List <HouseholdTrait.JsonDto> dto1 = new List <HouseholdTrait.JsonDto>();
foreach (var trait in sim1.HouseholdTraits.It)
{
dto1.Add(trait.GetJson());
}
sim2.HouseholdTraits.DeleteItem(sim2.HouseholdTraits[0]);
var result = HouseholdTrait.ImportObjectFromJson(sim2, dto1);
if (sim1.HouseholdTraits.It.Count != sim2.HouseholdTraits.It.Count)
{
throw new LPGException("count not equal");
}
sim2.HouseholdTraits.It.Sort();
sim1.HouseholdTraits[0].Should().BeEquivalentTo(result[0], o => o.IgnoringCyclicReferences()
.Using <IRelevantGuidProvider>(x => x.Subject.RelevantGuid.Should().BeEquivalentTo(x.Expectation.RelevantGuid)).WhenTypeIs <IRelevantGuidProvider>()
.Excluding(x => IsInvalidMember(x)
));
result.Should().HaveCount(1);
sim1.HouseholdTraits[0].Name.Should().BeEquivalentTo(sim2.HouseholdTraits[0].Name);
sim1.HouseholdTraits[0].Should().BeEquivalentTo(sim2.HouseholdTraits[0], o => o.IgnoringCyclicReferences()
.Using <IRelevantGuidProvider>(x => x.Subject.RelevantGuid.Should().BeEquivalentTo(x.Expectation.RelevantGuid)).WhenTypeIs <IRelevantGuidProvider>()
.Excluding(x => IsInvalidMember(x)
));
}
}
}
private static void SetEstimate([NotNull] HouseholdTrait trait, double timeSpent, int timesExecuted)
{
if (Math.Abs(timeSpent) < 0.00001 || timesExecuted == 0)
{
trait.EstimatedDuration2InMinutes = -1;
trait.EstimatedTimeCount2 = -1;
trait.EstimatedTimeType2 = TimeType.Day;
trait.EstimatedTimes2 = -1;
trait.SaveToDB();
return;
}
var timeTotal = TimeSpan.FromMinutes(timeSpent);
var timePerExecution = TimeSpan.FromSeconds(timeTotal.TotalSeconds / timesExecuted); // average time
trait.EstimatedDuration2InMinutes = timePerExecution.TotalMinutes;
var timeBetweenActivations = TimeSpan.FromHours(365 * 24.0 / timesExecuted);
trait.EstimatedDuration2InMinutes = timePerExecution.TotalMinutes;
if (timeBetweenActivations.TotalHours < 24)
{
trait.EstimatedTimeType2 = TimeType.Day;
trait.EstimatedTimeCount2 = 1;
trait.EstimatedTimes2 = Math.Round(24 / timeBetweenActivations.TotalHours, 1);
return;
}
if (timeBetweenActivations.TotalDays < 7)
{
trait.EstimatedTimeType2 = TimeType.Week;
trait.EstimatedTimeCount2 = 1;
trait.EstimatedTimes2 = Math.Round(7 / timeBetweenActivations.TotalDays, 1);
return;
}
if (timeBetweenActivations.TotalDays < 30)
{
trait.EstimatedTimeType2 = TimeType.Month;
trait.EstimatedTimeCount2 = 1;
trait.EstimatedTimes2 = Math.Round(30 / timeBetweenActivations.TotalDays, 1);
return;
}
trait.EstimatedTimeType2 = TimeType.Year;
trait.EstimatedTimeCount2 = 1;
trait.EstimatedTimes2 = Math.Round(365 / timeBetweenActivations.TotalDays, 1);
}
public void ModularHouseholdTest()
{
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
db.ClearTable(ModularHousehold.TableName);
db.ClearTable(ModularHouseholdTrait.TableName);
db.ClearTable(ModularHouseholdPerson.TableName);
var persons = new ObservableCollection <Person>();
var result = new ObservableCollection <ModularHousehold>();
var householdTraits = new ObservableCollection <HouseholdTrait>();
var hht = new HouseholdTrait("blub", null, "blub", db.ConnectionString, "none", 1, 100, 10, 1, 1,
TimeType.Day, 1, 1, TimeType.Day, 1, 0, EstimateType.Theoretical, "", Guid.NewGuid().ToStrGuid());
hht.SaveToDB();
householdTraits.Add(hht);
var deviceSelections = new ObservableCollection <DeviceSelection>();
var ds = new DeviceSelection("ds", null, "bla", db.ConnectionString, Guid.NewGuid().ToStrGuid());
ds.SaveToDB();
deviceSelections.Add(ds);
var vacations = db.LoadVacations();
var hhTags = db.LoadHouseholdTags();
var traitTags = db.LoadTraitTags();
ModularHousehold.LoadFromDatabase(result, db.ConnectionString, householdTraits, deviceSelections, false,
persons, vacations, hhTags, traitTags);
(result.Count).Should().Be(0);
var chh = new ModularHousehold("blub", null, "blub", db.ConnectionString, ds, "src", null, null,
EnergyIntensityType.Random, CreationType.ManuallyCreated, Guid.NewGuid().ToStrGuid());
chh.SaveToDB();
chh.AddTrait(hht, ModularHouseholdTrait.ModularHouseholdTraitAssignType.Age, null);
chh.SaveToDB();
result.Clear();
ModularHousehold.LoadFromDatabase(result, db.ConnectionString, householdTraits, deviceSelections, false,
persons, vacations, hhTags, traitTags);
(result.Count).Should().Be(1);
(result[0].Traits.Count).Should().Be(1);
db.Cleanup();
}
}
public bool Import([NotNull] JsonDatabaseImportOptions calcDirectoryOptions)
{
_calculationProfiler.StartPart(Utili.GetCurrentMethodAndClass());
string jsonFileName = calcDirectoryOptions.Input;
if (jsonFileName == null)
{
Logger.Error("No file was set.");
return(false);
}
if (!File.Exists(jsonFileName))
{
Logger.Error("File does not exist");
return(false);
}
Logger.Info("Loading...");
var sim = new Simulator(_connectionString);
Logger.Info("Loading finished.");
switch (calcDirectoryOptions.Type)
{
case TypesToProcess.HouseholdTemplates: {
string json = File.ReadAllText(jsonFileName);
var hhts = JsonConvert.DeserializeObject <List <HouseholdTemplate.JsonDto> >(json);
Logger.Info("Started loading " + hhts.Count + " household templates");
HouseholdTemplate.ImportObjectFromJson(sim, hhts);
Logger.Info("Finished loading " + hhts.Count + " household templates");
break;
}
case TypesToProcess.ModularHouseholds: {
string json = File.ReadAllText(jsonFileName);
var hhts = JsonConvert.DeserializeObject <List <ModularHousehold.JsonModularHousehold> >(json);
Logger.Info("Started loading " + hhts.Count + " households");
ModularHousehold.ImportObjectFromJson(sim, hhts);
Logger.Info("Finished loading " + hhts.Count + " households");
break;
}
case TypesToProcess.None:
throw new LPGException("You need to set a type that you want to process");
case TypesToProcess.HouseholdTraits: {
string json = File.ReadAllText(jsonFileName);
var hhts = JsonConvert.DeserializeObject <List <HouseholdTrait.JsonDto> >(json);
Logger.Info("Started loading " + hhts.Count + " traits");
HouseholdTrait.ImportObjectFromJson(sim, hhts);
Logger.Info("Finished loading " + hhts.Count + " traits");
}
break;
case TypesToProcess.HouseholdTraitsWithDeviceCategories:
throw new LPGException("You need to set a type that you want to process");
default:
throw new ArgumentOutOfRangeException(nameof(JsonDatabaseImportOptions));
}
_calculationProfiler.StopPart(Utili.GetCurrentMethodAndClass());
return(true);
}
public void HouseholdTraitTest()
{
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
db.ClearTable(HouseholdTrait.TableName);
db.ClearTable(HHTAutonomousDevice.TableName);
db.ClearTable(HHTDesire.TableName);
db.ClearTable(HHTLocation.TableName);
db.ClearTable(HHTAffordance.TableName);
db.ClearTable(HHTTag.TableName);
var timeBasedProfiles = db.LoadTimeBasedProfiles();
var dateBasedProfiles = db.LoadDateBasedProfiles();
var devices = db.LoadRealDevices(out ObservableCollection <DeviceCategory> deviceCategories, out _, out ObservableCollection <VLoadType> loadTypes,
timeBasedProfiles);
var timeLimits = db.LoadTimeLimits(dateBasedProfiles);
var desires = db.LoadDesires();
var deviceActionGroups = db.LoadDeviceActionGroups();
var deviceActions = db.LoadDeviceActions(timeBasedProfiles, devices,
loadTypes, deviceActionGroups);
var locations = db.LoadLocations(devices, deviceCategories, loadTypes);
var variables = db.LoadVariables();
var affordances = db.LoadAffordances(timeBasedProfiles, out _,
deviceCategories, devices, desires, loadTypes, timeLimits, deviceActions, deviceActionGroups, locations,
variables);
var hht = new HouseholdTrait("blub", null, "blub", db.ConnectionString, "none", 1, 100, 10, 1, 1,
TimeType.Day, 1, 1, TimeType.Day, 1, 0, EstimateType.Theoretical, "", Guid.NewGuid().ToStrGuid());
hht.SaveToDB();
var hht2 = new HouseholdTrait("blub2", null, "blub2", db.ConnectionString, "none", 1, 100, 10, 1,
1, TimeType.Day, 1, 1, TimeType.Day, 1, 0, EstimateType.Theoretical, "", Guid.NewGuid().ToStrGuid());
hht2.SaveToDB();
var loc = new Location("loc1", -1, db.ConnectionString, Guid.NewGuid().ToStrGuid());
hht.AddAutomousDevice(devices[0], timeBasedProfiles[0], 0, loadTypes[0], timeLimits[0], loc, 0,
VariableCondition.Equal, variables[0]);
var hhtl = hht.AddLocation(locations[0]);
hht.SaveToDB();
var tag = new TraitTag("tag", db.ConnectionString,
TraitLimitType.NoLimit, TraitPriority.Mandatory, Guid.NewGuid().ToStrGuid());
tag.SaveToDB();
hht.AddTag(tag);
hht.AddAffordanceToLocation(hhtl, affordances[0], timeLimits[0], 100, 0, 0, 0, 0);
hht.SaveToDB();
hht.AddDesire(desires[0], 1, "Healthy", 1, 1, 0, 100, PermittedGender.All);
hht.SaveToDB();
hht.AddTrait(hht2);
hht.SaveToDB();
(hht.SubTraits.Count).Should().Be(1);
var hhts = new ObservableCollection <HouseholdTrait>();
var tags = db.LoadTraitTags();
HouseholdTrait.LoadFromDatabase(hhts, db.ConnectionString, locations, affordances, devices,
deviceCategories,
timeBasedProfiles, loadTypes, timeLimits, desires, deviceActions, deviceActionGroups, tags, false,
variables);
(hhts.Count).Should().Be(2);
var hht3 = hhts[0];
(hht3.MinimumPersonsInCHH).Should().Be(1);
(hht3.MaximumPersonsInCHH).Should().Be(100);
(hht3.Desires.Count).Should().Be(1);
(hht3.SubTraits.Count).Should().Be(1);
(hht3.Classification).Should().Be("none");
(hht3.Tags.Count).Should().Be(1);
(hht3.Tags[0].Tag.Name).Should().Be("tag");
foreach (var trait in hhts)
{
trait.DeleteFromDB();
}
hhts.Clear();
Logger.Info("Loading again...");
HouseholdTrait.LoadFromDatabase(hhts, db.ConnectionString, locations, affordances, devices,
deviceCategories,
timeBasedProfiles, loadTypes, timeLimits, desires, deviceActions, deviceActionGroups, tags, false,
variables);
(hhts.Count).Should().Be(0);
db.Cleanup();
}
}
public void HouseholdTraitAffordanceTest()
{
using (var db = new DatabaseSetup(Utili.GetCurrentMethodAndClass()))
{
db.ClearTable(HouseholdTrait.TableName);
db.ClearTable(HHTAutonomousDevice.TableName);
db.ClearTable(HHTDesire.TableName);
db.ClearTable(HHTLocation.TableName);
db.ClearTable(HHTAffordance.TableName);
db.ClearTable(HHTTrait.TableName);
db.ClearTable(HHTTag.TableName);
var timeBasedProfiles = db.LoadTimeBasedProfiles();
var dateBasedProfiles = db.LoadDateBasedProfiles();
var devices = db.LoadRealDevices(out ObservableCollection <DeviceCategory> deviceCategories, out _, out var loadTypes,
timeBasedProfiles);
var timeLimits = db.LoadTimeLimits(dateBasedProfiles);
var desires = db.LoadDesires();
var deviceActionGroups = db.LoadDeviceActionGroups();
var deviceActions = db.LoadDeviceActions(timeBasedProfiles, devices,
loadTypes, deviceActionGroups);
var locations = db.LoadLocations(devices, deviceCategories, loadTypes);
var variables = db.LoadVariables();
var affordances = db.LoadAffordances(timeBasedProfiles, out _,
deviceCategories, devices, desires, loadTypes, timeLimits, deviceActions, deviceActionGroups, locations,
variables);
var hht = new HouseholdTrait("blub", null, "blub", db.ConnectionString, "none", 1, 100, 10, 1, 1,
TimeType.Day, 1, 1, TimeType.Day, 1, 0, EstimateType.Theoretical, "", Guid.NewGuid().ToStrGuid());
hht.SaveToDB();
var loc = new Location("loc1", null, db.ConnectionString, Guid.NewGuid().ToStrGuid());
locations.Add(loc);
loc.SaveToDB();
Logger.Info("adding affordance");
hht.AddLocation(loc);
hht.AddAffordanceToLocation(loc, affordances[0], timeLimits[0], 100, 0, 0, 0, 0);
hht.SaveToDB();
Logger.Info("reloading ");
var hhts = new ObservableCollection <HouseholdTrait>();
var tags = db.LoadTraitTags();
HouseholdTrait.LoadFromDatabase(hhts, db.ConnectionString, locations, affordances, devices,
deviceCategories,
timeBasedProfiles, loadTypes, timeLimits, desires, deviceActions, deviceActionGroups, tags, false,
variables);
(hhts.Count).Should().Be(1);
var hht3 = hhts[0];
(hht3.Locations[0].AffordanceLocations.Count).Should().Be(1);
Logger.Info("deleting affordance");
hht3.DeleteAffordanceFromDB(hht3.Locations[0].AffordanceLocations[0]);
hhts.Clear();
Logger.Info("Loading again...");
HouseholdTrait.LoadFromDatabase(hhts, db.ConnectionString, locations, affordances, devices,
deviceCategories,
timeBasedProfiles, loadTypes, timeLimits, desires, deviceActions, deviceActionGroups, tags, false,
variables);
var hht4 = hhts[0];
(hht4.Locations[0].AffordanceLocations.Count).Should().Be(0);
db.Cleanup();
}
}
private void CheckAffordanceUse([NotNull] Simulator sim, [NotNull] HouseholdTrait trait)
{
if (!PerformCleanupChecks)
{
return;
}
var validaffordances = trait.CollectAffordances(true);
var allAffordances = trait.CollectAffordances(false);
if (validaffordances.Count != allAffordances.Count)
{
var uses = trait.CalculateUsedIns(sim);
if (uses.Count == 0)
{
throw new DataIntegrityException(
"The trait " + trait.PrettyName +
" has affordances that are never executed, but the trait is not used. Please delete!", trait);
}
{
foreach (var affordance in allAffordances)
{
if (!validaffordances.Contains(affordance))
{
throw new DataIntegrityException(
"The trait " + trait.PrettyName +
" has affordances that are never executed, but the trait is in use. At least one of the affordances is " +
affordance.Name + ". Please fix!", trait);
}
}
}
}
foreach (var location in trait.Locations)
{
if (location.AffordanceLocations.Count == 0)
{
if (trait.Autodevs.All(x => x.Location != location.Location))
{
throw new DataIntegrityException(
"The Location " + location.Location.Name + " in the household trait " + trait.Name +
" is empty. Please fix.", trait);
}
}
for (var index = 0; index < location.AffordanceLocations.Count; index++)
{
var affordance = location.AffordanceLocations[index];
if (!validaffordances.Contains(affordance.Affordance))
{
var s = "The affordance " + affordance.Affordance?.Name +
" is not executable by a single Person in the household trait " + trait.Name +
". Delete this affordance?";
Logger.Error(s);
var res =
MessageWindowHandler.Mw.ShowYesNoMessage(
"The affordance " + affordance.Affordance?.Name +
" is not executable by a single Person in the household trait " + trait.Name +
". Delete this affordance?", "Delete?");
if (res == LPGMsgBoxResult.Yes)
{
trait.DeleteAffordanceFromDB(affordance);
index = -1;
}
}
}
}
}
private static void GenerateNewTraits([NotNull] Simulator sim, [CanBeNull] HouseholdTrait basetrait, [NotNull] string baseName,
[ItemNotNull][NotNull] List <AffordanceEntry> affordances, [ItemNotNull][NotNull] List <TimeLimitEntry> timeLimits, TaggingType taggingType)
{
if (basetrait == null)
{
throw new LPGException("basetrait not found");
}
if (basetrait.Desires.Count != 1)
{
throw new LPGException("Not exactly one desire in " + basetrait.PrettyName);
}
//TODO: make sure all the affordances have different desires
var uniquedesires = new List <Desire>();
foreach (var affordance in affordances)
{
foreach (var affordanceDesire in affordance.Affordance.AffordanceDesires)
{
var d = affordanceDesire.Desire;
if (uniquedesires.Contains(d))
{
throw new LPGException("The desire " + d.PrettyName +
" is used in multiple affordances. Not ok.");
}
uniquedesires.Add(affordanceDesire.Desire);
}
}
foreach (var affordanceEntry in affordances)
{
foreach (var timeLimitEntry in timeLimits)
{
var newName = baseName + ", " + affordanceEntry.Name + ", from " + timeLimitEntry.Name;
if (sim.HouseholdTraits.FindFirstByName(newName) != null)
{
continue;
}
var newTrait = basetrait.MakeCopy(sim);
newTrait.Name = newName;
var aff = affordanceEntry.Affordance;
//desires
newTrait.RemoveDesire(newTrait.Desires[0]);
if (newTrait.Desires.Count != 0)
{
throw new LPGException("Too many desires");
}
var oldDesire = basetrait.Desires[0];
newTrait.AddDesire(aff.AffordanceDesires[0].Desire, oldDesire.DecayTime, oldDesire.HealthStatus,
oldDesire.Threshold, oldDesire.Weight, oldDesire.MinAge, oldDesire.MaxAge, oldDesire.Gender);
//location
if (newTrait.Locations.Count != 1)
{
throw new LPGException("More than one location");
}
var hhtloc = newTrait.Locations.First();
if (hhtloc.AffordanceLocations.Count != 1)
{
throw new LPGException("Not exactly one location");
}
newTrait.DeleteAffordanceFromDB(hhtloc.AffordanceLocations.First());
newTrait.AddAffordanceToLocation(hhtloc, affordanceEntry.Affordance, timeLimitEntry.TimeLimit, 100, 15, 15, 15, 15);
// Tag
if (taggingType == TaggingType.OfficeJob)
{
TagOfficeJob(timeLimitEntry, newTrait);
}
else if (taggingType == TaggingType.AdultSleep)
{
TagAdultSleep(sim, affordanceEntry, timeLimitEntry, newTrait);
}
else if (taggingType == TaggingType.AlarmClock)
{
TagAlarms(sim, timeLimitEntry, newTrait);
}
else
{
throw new LPGException("Unknown tagging type");
}
newTrait.SaveToDB();
}
}
}
private static void TagAdultSleep([NotNull] Simulator sim, [NotNull] AffordanceEntry affordanceEntry, [NotNull] TimeLimitEntry timeLimitEntry, [NotNull] HouseholdTrait newTrait)
{
var livingTags = newTrait.Tags.Where(x => x.Tag.Name.Contains("Living Pattern / Office Job")).ToList();
foreach (HHTTag livingTag in livingTags)
{
newTrait.DeleteHHTTag(livingTag);
}
TimeSpan endTime = timeLimitEntry.BeginTime.Add(TimeSpan.FromHours(affordanceEntry.Duration));
List <TraitTag> tags = new List <TraitTag>
{
GetTraitTagByName(sim, "Living Pattern / Part Time Job"),
GetTraitTagByName(sim, "Living Pattern / Retiree"),
GetTraitTagByName(sim, "Living Pattern / Stay at Home / Regular"),
GetTraitTagByName(sim, "Living Pattern / Two Shift Work"),
GetTraitTagByName(sim, "Living Pattern / University / Student Independent"),
GetTraitTagByName(sim, "Living Pattern / University / Student Living at Home")
};
if (endTime.Hours <= 6)
{
tags.Add(GetTraitTagByName(sim, "Living Pattern / Office Job / Early (5-7am)"));
tags.Add(GetTraitTagByName(sim, "Living Pattern / Office Job / Medium (7-9am)"));
tags.Add(GetTraitTagByName(sim, "Living Pattern / Office Job / Late (9-11am)"));
}
else if (endTime.Hours <= 8)
{
tags.Add(GetTraitTagByName(sim, "Living Pattern / Office Job / Medium (7-9am)"));
tags.Add(GetTraitTagByName(sim, "Living Pattern / Office Job / Late (9-11am)"));
}
else
{
tags.Add(GetTraitTagByName(sim, "Living Pattern / Office Job / Late (9-11am)"));
}
foreach (TraitTag tag in tags)
{
if (tag == null)
{
throw new LPGException("Tag not found");
}
newTrait.AddTag(tag);
}
}
private List <LoadingEntry> GetLoadingActions(bool ignoreMissingTables)
{
var actions = new List <LoadingEntry>
{
new LoadingEntry("Loadtypes",
() => VLoadType.LoadFromDatabase(LoadTypes.MyItems, ConnectionString, ignoreMissingTables),
LoadTypes),
new LoadingEntry("Holidays",
() => Holiday.LoadFromDatabase(Holidays.MyItems, ConnectionString, ignoreMissingTables), Holidays),
new LoadingEntry("Variables",
() => Variable.LoadFromDatabase(Variables.It, ConnectionString, ignoreMissingTables), Variables),
new LoadingEntry("Date Based Profiles",
() => DateBasedProfile.LoadFromDatabase(DateBasedProfiles.MyItems, ConnectionString,
ignoreMissingTables), DateBasedProfiles),
new LoadingEntry("Vacations",
() => Vacation.LoadFromDatabase(Vacations.MyItems, ConnectionString, ignoreMissingTables),
Vacations),
new LoadingEntry("Desires",
() => Desire.LoadFromDatabase(Desires.MyItems, ConnectionString, ignoreMissingTables), Desires),
new LoadingEntry("Time Profiles",
() => TimeBasedProfile.LoadFromDatabase(Timeprofiles.MyItems, ConnectionString, ignoreMissingTables),
Timeprofiles),
new LoadingEntry("Temperature Profiles",
() => TemperatureProfile.LoadFromDatabase(TemperatureProfiles.MyItems, ConnectionString,
ignoreMissingTables), TemperatureProfiles),
new LoadingEntry("Generators",
() => Generator.LoadFromDatabase(Generators.MyItems, ConnectionString, LoadTypes.MyItems,
DateBasedProfiles.MyItems, ignoreMissingTables), Generators),
new LoadingEntry("Energy Storages",
() => EnergyStorage.LoadFromDatabase(EnergyStorages.MyItems, ConnectionString, LoadTypes.MyItems, Variables.MyItems,
ignoreMissingTables), EnergyStorages),
new LoadingEntry("Transformation Devices",
() => TransformationDevice.LoadFromDatabase(TransformationDevices.MyItems, ConnectionString,
LoadTypes.MyItems, Variables.MyItems, ignoreMissingTables), TransformationDevices),
new LoadingEntry("Device Categories", () =>
{
DeviceCategory.LoadFromDatabase(DeviceCategories.MyItems, out _dcnone, ConnectionString,
RealDevices.MyItems, ignoreMissingTables);
DeviceCategories.DeviceCategoryNone = _dcnone;
}, DeviceCategories),
new LoadingEntry("Real Devices",
() => RealDevice.LoadFromDatabase(RealDevices.MyItems, DeviceCategories.MyItems,
DeviceCategories.DeviceCategoryNone, ConnectionString, LoadTypes.MyItems, Timeprofiles.MyItems,
ignoreMissingTables), RealDevices),
new LoadingEntry("Device Action Groups",
() => DeviceActionGroup.LoadFromDatabase(DeviceActionGroups.MyItems, ConnectionString,
ignoreMissingTables), DeviceActionGroups),
new LoadingEntry("Device Actions",
() => DeviceAction.LoadFromDatabase(DeviceActions.MyItems, ConnectionString, Timeprofiles.MyItems,
RealDevices.MyItems, LoadTypes.MyItems, DeviceActionGroups.MyItems, ignoreMissingTables),
DeviceActions),
new LoadingEntry("Device Tagging Sets",
() => DeviceTaggingSet.LoadFromDatabase(DeviceTaggingSets.MyItems, ConnectionString,
ignoreMissingTables, RealDevices.MyItems, LoadTypes.It), DeviceTaggingSets),
new LoadingEntry("Persons",
() => Person.LoadFromDatabase(Persons.MyItems, ConnectionString,
ignoreMissingTables), Persons),
new LoadingEntry("Locations",
() => Location.LoadFromDatabase(Locations.MyItems, ConnectionString, RealDevices.MyItems,
DeviceCategories.MyItems, LoadTypes.MyItems, ignoreMissingTables), Locations),
new LoadingEntry("Time Limits",
() => TimeLimit.LoadFromDatabase(TimeLimits.MyItems, DateBasedProfiles.MyItems, ConnectionString,
ignoreMissingTables), TimeLimits),
new LoadingEntry("Geographic Locations",
() => GeographicLocation.LoadFromDatabase(GeographicLocations.MyItems, ConnectionString,
Holidays.MyItems, TimeLimits.MyItems, ignoreMissingTables), GeographicLocations),
new LoadingEntry("Subaffordances",
() => SubAffordance.LoadFromDatabase(SubAffordances.MyItems, ConnectionString, Desires.MyItems,
ignoreMissingTables, Locations.It, Variables.It), SubAffordances),
new LoadingEntry("Affordances",
() => Affordance.LoadFromDatabase(Affordances.MyItems, ConnectionString, Timeprofiles.MyItems,
DeviceCategories.MyItems, RealDevices.MyItems, Desires.MyItems, SubAffordances.MyItems,
LoadTypes.MyItems, TimeLimits.MyItems, DeviceActions.MyItems, DeviceActionGroups.MyItems,
Locations.It, ignoreMissingTables, Variables.It), Affordances),
new LoadingEntry("Affordance Tagging Sets",
() => AffordanceTaggingSet.LoadFromDatabase(AffordanceTaggingSets.MyItems, ConnectionString,
ignoreMissingTables, Affordances.MyItems, LoadTypes.It), AffordanceTaggingSets),
new LoadingEntry("Trait Tags",
() => TraitTag.LoadFromDatabase(TraitTags.MyItems, ConnectionString, ignoreMissingTables),
TraitTags),
new LoadingEntry("Household Traits",
() => HouseholdTrait.LoadFromDatabase(HouseholdTraits.MyItems, ConnectionString, Locations.MyItems,
Affordances.MyItems, RealDevices.MyItems, DeviceCategories.MyItems, Timeprofiles.MyItems,
LoadTypes.MyItems, TimeLimits.MyItems, Desires.MyItems, DeviceActions.It, DeviceActionGroups.It,
TraitTags.It, ignoreMissingTables, Variables.It), HouseholdTraits),
new LoadingEntry("Device Selections",
() => DeviceSelection.LoadFromDatabase(DeviceSelections.MyItems, ConnectionString,
DeviceCategories.MyItems, RealDevices.MyItems, DeviceActions.It, DeviceActionGroups.It,
ignoreMissingTables), DeviceSelections),
new LoadingEntry("Household Tags",
() => HouseholdTag.LoadFromDatabase(HouseholdTags.It, ConnectionString, ignoreMissingTables),
HouseholdTags),
new LoadingEntry("Modular Households",
() => ModularHousehold.LoadFromDatabase(ModularHouseholds.MyItems, ConnectionString,
HouseholdTraits.MyItems, DeviceSelections.MyItems, ignoreMissingTables, Persons.MyItems,
Vacations.It, HouseholdTags.It, TraitTags.It), ModularHouseholds),
new LoadingEntry("Household Templates",
() => HouseholdTemplate.LoadFromDatabase(HouseholdTemplates.MyItems, ConnectionString,
HouseholdTraits.MyItems, ignoreMissingTables, Persons.MyItems, TraitTags.It, Vacations.It,
HouseholdTags.It, DateBasedProfiles.It), HouseholdTemplates),
new LoadingEntry("Template Persons",
() => TemplatePerson.LoadFromDatabase(TemplatePersons.It, ConnectionString, HouseholdTraits.It,
ignoreMissingTables, ModularHouseholds.It, Persons.It), TemplatePersons),
new LoadingEntry("Household Plans",
() => HouseholdPlan.LoadFromDatabase(HouseholdPlans.MyItems, ConnectionString, ignoreMissingTables,
Persons.MyItems, AffordanceTaggingSets.MyItems, ModularHouseholds.MyItems),
HouseholdPlans),
new LoadingEntry("House Types",
() => HouseType.LoadFromDatabase(HouseTypes.MyItems, ConnectionString, RealDevices.MyItems,
DeviceCategories.MyItems, Timeprofiles.MyItems, TimeLimits.MyItems, LoadTypes.MyItems,
TransformationDevices.MyItems, EnergyStorages.MyItems, Generators.MyItems, ignoreMissingTables,
Locations.MyItems, DeviceActions.It, DeviceActionGroups.It, Variables.It), HouseTypes),
new LoadingEntry("Transportation Device Categories",
() => TransportationDeviceCategory.LoadFromDatabase(TransportationDeviceCategories.It, ConnectionString,
ignoreMissingTables), TransportationDeviceCategories),
new LoadingEntry("Sites",
() => Site.LoadFromDatabase(Sites.It,
ConnectionString, ignoreMissingTables,
Locations.It), Sites),
new LoadingEntry("Transportation Devices",
() => TransportationDevice.LoadFromDatabase(TransportationDevices.It, ConnectionString, ignoreMissingTables,
TransportationDeviceCategories.It, LoadTypes.It), TransportationDevices),
new LoadingEntry("Transportation Device Sets",
() => TransportationDeviceSet.LoadFromDatabase(TransportationDeviceSets.It, ConnectionString,
ignoreMissingTables, TransportationDevices.It), TransportationDeviceSets),
new LoadingEntry("Travel Routes",
() => TravelRoute.LoadFromDatabase(TravelRoutes.It, ConnectionString, ignoreMissingTables,
TransportationDeviceCategories.It, Sites.It), TravelRoutes),
new LoadingEntry("Travel Route Sets",
() => TravelRouteSet.LoadFromDatabase(TravelRouteSets.It, ConnectionString, ignoreMissingTables,
TravelRoutes.It), TravelRouteSets),
new LoadingEntry("Charging Station Sets",
() => ChargingStationSet.LoadFromDatabase(ChargingStationSets.It,
ConnectionString, ignoreMissingTables,
LoadTypes.It, TransportationDeviceCategories.It, Sites.It), ChargingStationSets),
new LoadingEntry("Houses",
() => House.LoadFromDatabase(Houses.MyItems, ConnectionString, TemperatureProfiles.MyItems,
GeographicLocations.MyItems, HouseTypes.MyItems,
ModularHouseholds.MyItems, ChargingStationSets.MyItems,
TransportationDeviceSets.MyItems, TravelRouteSets.MyItems,
ignoreMissingTables), Houses),
new LoadingEntry("Settlements",
() => Settlement.LoadFromDatabase(Settlements.MyItems, ConnectionString,
TemperatureProfiles.MyItems, GeographicLocations.MyItems, ModularHouseholds.MyItems, Houses.MyItems,
ignoreMissingTables), Settlements),
new LoadingEntry("Settlement Templates",
() => SettlementTemplate.LoadFromDatabase(SettlementTemplates.It, ConnectionString,
HouseholdTemplates.It, HouseTypes.It, ignoreMissingTables, TemperatureProfiles.It,
GeographicLocations.It, HouseholdTags.It, HouseholdTraits.It), SettlementTemplates),
new LoadingEntry("Settings",
() => MyGeneralConfig = GeneralConfig.LoadFromDatabase(ConnectionString, ignoreMissingTables), null),
new LoadingEntry("Calculation Outcomes",
() => CalculationOutcome.LoadFromDatabase(CalculationOutcomes.MyItems, ConnectionString,
ignoreMissingTables), CalculationOutcomes)
};
return(actions);
}
