/// <summary>
/// Serialize the <see cref="LogarithmicScale"/>
/// </summary>
/// <param name="logarithmicScale">The <see cref="LogarithmicScale"/> to serialize</param>
/// <returns>The <see cref="JObject"/></returns>
private JObject Serialize(LogarithmicScale logarithmicScale)
{
var jsonObject = new JObject();
jsonObject.Add("alias", this.PropertySerializerMap["alias"](logarithmicScale.Alias.OrderBy(x => x, this.guidComparer)));
jsonObject.Add("classKind", this.PropertySerializerMap["classKind"](Enum.GetName(typeof(CDP4Common.CommonData.ClassKind), logarithmicScale.ClassKind)));
jsonObject.Add("definition", this.PropertySerializerMap["definition"](logarithmicScale.Definition.OrderBy(x => x, this.guidComparer)));
jsonObject.Add("excludedDomain", this.PropertySerializerMap["excludedDomain"](logarithmicScale.ExcludedDomain.OrderBy(x => x, this.guidComparer)));
jsonObject.Add("excludedPerson", this.PropertySerializerMap["excludedPerson"](logarithmicScale.ExcludedPerson.OrderBy(x => x, this.guidComparer)));
jsonObject.Add("exponent", this.PropertySerializerMap["exponent"](logarithmicScale.Exponent));
jsonObject.Add("factor", this.PropertySerializerMap["factor"](logarithmicScale.Factor));
jsonObject.Add("hyperLink", this.PropertySerializerMap["hyperLink"](logarithmicScale.HyperLink.OrderBy(x => x, this.guidComparer)));
jsonObject.Add("iid", this.PropertySerializerMap["iid"](logarithmicScale.Iid));
jsonObject.Add("isDeprecated", this.PropertySerializerMap["isDeprecated"](logarithmicScale.IsDeprecated));
jsonObject.Add("isMaximumInclusive", this.PropertySerializerMap["isMaximumInclusive"](logarithmicScale.IsMaximumInclusive));
jsonObject.Add("isMinimumInclusive", this.PropertySerializerMap["isMinimumInclusive"](logarithmicScale.IsMinimumInclusive));
jsonObject.Add("logarithmBase", this.PropertySerializerMap["logarithmBase"](Enum.GetName(typeof(CDP4Common.SiteDirectoryData.LogarithmBaseKind), logarithmicScale.LogarithmBase)));
jsonObject.Add("mappingToReferenceScale", this.PropertySerializerMap["mappingToReferenceScale"](logarithmicScale.MappingToReferenceScale.OrderBy(x => x, this.guidComparer)));
jsonObject.Add("maximumPermissibleValue", this.PropertySerializerMap["maximumPermissibleValue"](logarithmicScale.MaximumPermissibleValue));
jsonObject.Add("minimumPermissibleValue", this.PropertySerializerMap["minimumPermissibleValue"](logarithmicScale.MinimumPermissibleValue));
jsonObject.Add("modifiedOn", this.PropertySerializerMap["modifiedOn"](logarithmicScale.ModifiedOn));
jsonObject.Add("name", this.PropertySerializerMap["name"](logarithmicScale.Name));
jsonObject.Add("negativeValueConnotation", this.PropertySerializerMap["negativeValueConnotation"](logarithmicScale.NegativeValueConnotation));
jsonObject.Add("numberSet", this.PropertySerializerMap["numberSet"](Enum.GetName(typeof(CDP4Common.SiteDirectoryData.NumberSetKind), logarithmicScale.NumberSet)));
jsonObject.Add("positiveValueConnotation", this.PropertySerializerMap["positiveValueConnotation"](logarithmicScale.PositiveValueConnotation));
jsonObject.Add("referenceQuantityKind", this.PropertySerializerMap["referenceQuantityKind"](logarithmicScale.ReferenceQuantityKind));
jsonObject.Add("referenceQuantityValue", this.PropertySerializerMap["referenceQuantityValue"](logarithmicScale.ReferenceQuantityValue));
jsonObject.Add("revisionNumber", this.PropertySerializerMap["revisionNumber"](logarithmicScale.RevisionNumber));
jsonObject.Add("shortName", this.PropertySerializerMap["shortName"](logarithmicScale.ShortName));
jsonObject.Add("thingPreference", this.PropertySerializerMap["thingPreference"](logarithmicScale.ThingPreference));
jsonObject.Add("unit", this.PropertySerializerMap["unit"](logarithmicScale.Unit));
jsonObject.Add("valueDefinition", this.PropertySerializerMap["valueDefinition"](logarithmicScale.ValueDefinition.OrderBy(x => x, this.guidComparer)));
return(jsonObject);
}
public void Setup()
{
RxApp.MainThreadScheduler = Scheduler.CurrentThread;
this.cache = new ConcurrentDictionary <CacheKey, Lazy <Thing> >();
this.navigation = new Mock <IThingDialogNavigationService>();
this.permissionService = new Mock <IPermissionService>();
this.permissionService.Setup(x => x.CanRead(It.IsAny <Thing>())).Returns(true);
this.permissionService.Setup(x => x.CanWrite(It.IsAny <Thing>())).Returns(true);
this.session = new Mock <ISession>();
this.session.Setup(x => x.PermissionService).Returns(this.permissionService.Object);
var person = new Person(Guid.NewGuid(), this.cache, null)
{
Container = this.siteDir
};
this.session.Setup(x => x.ActivePerson).Returns(person);
this.siteDir = new SiteDirectory(Guid.NewGuid(), this.cache, null);
this.siteDir.Person.Add(person);
var testScale = new LogarithmicScale();
this.rdl = new SiteReferenceDataLibrary(Guid.NewGuid(), this.cache, null)
{
Name = "testRDL", ShortName = "test"
};
this.rdl.Scale.Add(testScale);
var qkf = new QuantityKindFactor();
this.derivedQuantityKind = new DerivedQuantityKind {
Name = "derivedQuantityKind", ShortName = "dqk"
};
this.derivedQuantityKind.QuantityKindFactor.Add(qkf);
this.rdl.ParameterType.Add(new SimpleQuantityKind {
Name = "testSQK", ShortName = "tSQK"
});
this.siteDir.SiteReferenceDataLibrary.Add(this.rdl);
this.cache.TryAdd(new CacheKey(this.rdl.Iid, null), new Lazy <Thing>(() => this.rdl));
var transactionContext = TransactionContextResolver.ResolveContext(this.siteDir);
this.transaction = new ThingTransaction(transactionContext, null);
this.session.Setup(x => x.RetrieveSiteDirectory()).Returns(this.siteDir);
this.session.Setup(x => x.OpenReferenceDataLibraries).Returns(new HashSet <ReferenceDataLibrary>(this.siteDir.SiteReferenceDataLibrary));
var dal = new Mock <IDal>();
this.session.Setup(x => x.DalVersion).Returns(new Version(1, 1, 0));
this.session.Setup(x => x.Dal).Returns(dal.Object);
dal.Setup(x => x.MetaDataProvider).Returns(new MetaDataProvider());
this.viewmodel = new DerivedQuantityKindDialogViewModel(this.derivedQuantityKind, this.transaction, this.session.Object, true, ThingDialogKind.Create, this.navigation.Object, null);
}
public void VerifyInspectSelectedDefaultScale()
{
var scale1 = new LogarithmicScale(Guid.NewGuid(), null, null);
var vm = new SimpleQuantityKindDialogViewModel(this.simpleQuantityKind, this.transaction, this.session.Object, true, ThingDialogKind.Inspect, this.navigation.Object, this.rdl);
Assert.IsFalse(vm.InspectSelectedScaleCommand.CanExecute(null));
vm.SelectedDefaultScale = scale1;
Assert.IsTrue(vm.InspectSelectedScaleCommand.CanExecute(null));
vm.InspectSelectedScaleCommand.Execute(null);
this.navigation.Verify(x => x.Navigate(It.IsAny<MeasurementScale>(), It.IsAny<ThingTransaction>(), this.session.Object, false, ThingDialogKind.Inspect, this.navigation.Object, It.IsAny<Thing>(), null));
}
/// <summary>
/// Initializes a new instance of the <see cref="LogarithmicScaleDialogViewModel"/> class.
/// </summary>
/// <param name="logarithmicScale">
/// The Simple quantity Kind.
/// </param>
/// <param name="transaction">
/// The <see cref="ThingTransaction"/> that contains the log of recorded changes.
/// </param>
/// <param name="session">
/// The <see cref="ISession"/> in which the current <see cref="Thing"/> is to be added or updated
/// </param>
/// <param name="isRoot">
/// Assert if this <see cref="LogarithmicScaleDialogViewModel"/> is the root of all <see cref="IThingDialogViewModel"/>
/// </param>
/// <param name="dialogKind">
/// The kind of operation this <see cref="LogarithmicScaleDialogViewModel"/> performs
/// </param>
/// <param name="thingDialogNavigationService">
/// The <see cref="IThingDialogNavigationService"/> that is used to navigate to a dialog of a specific <see cref="Thing"/>.
/// </param>
/// <param name="container">
/// The <see cref="Thing"/> that contains the created <see cref="Thing"/> in this Dialog
/// </param>
/// <param name="chainOfContainers">
/// The optional chain of containers that contains the <paramref name="container"/> argument
/// </param>
/// <exception cref="ArgumentException">
/// The container must be of type <see cref="ReferenceDataLibrary"/>.
/// </exception>
public LogarithmicScaleDialogViewModel(LogarithmicScale logarithmicScale, IThingTransaction transaction, ISession session, bool isRoot, ThingDialogKind dialogKind, IThingDialogNavigationService thingDialogNavigationService, Thing container = null, IEnumerable <Thing> chainOfContainers = null)
: base(logarithmicScale, transaction, session, isRoot, dialogKind, thingDialogNavigationService, container, chainOfContainers)
{
this.WhenAnyValue(vm => vm.Container).Subscribe(_ =>
{
this.PopulatePossibleUnit();
this.PopulatePossibleReferenceQuantityKind();
});
this.WhenAnyValue(vm => vm.SelectedUnit).Subscribe(_ => this.UpdateOkCanExecute());
}
public void VerifThatUpdatingContainerPopulatesPossiblePossibleScales()
{
Assert.IsEmpty(this.viewmodel.PossiblePossibleScale);
this.viewmodel.Container = null;
var rdl = this.siteDir.SiteReferenceDataLibrary.First();
var testScale = new LogarithmicScale();
rdl.Scale.Add(testScale);
this.viewmodel.Container = rdl;
Assert.IsNotEmpty(this.viewmodel.PossiblePossibleScale);
}
public void Setup()
{
RxApp.MainThreadScheduler = Scheduler.CurrentThread;
this.cache = new ConcurrentDictionary <CacheKey, Lazy <Thing> >();
this.serviceLocator = new Mock <IServiceLocator>();
this.navigation = new Mock <IThingDialogNavigationService>();
ServiceLocator.SetLocatorProvider(() => this.serviceLocator.Object);
this.serviceLocator.Setup(x => x.GetInstance <IThingDialogNavigationService>()).Returns(this.navigation.Object);
this.session = new Mock <ISession>();
var person = new Person(Guid.NewGuid(), this.cache, null)
{
Container = this.siteDir
};
this.session.Setup(x => x.ActivePerson).Returns(person);
this.siteDir = new SiteDirectory(Guid.NewGuid(), this.cache, null);
this.siteDir.Person.Add(person);
var rdl = new SiteReferenceDataLibrary(Guid.NewGuid(), this.cache, null)
{
Name = "testRDL", ShortName = "test"
};
this.scaleReferenceQuantityValue = new ScaleReferenceQuantityValue();
var testLogarithmicScale = new LogarithmicScale(Guid.NewGuid(), this.cache, null)
{
Name = "Test Derived QK", ShortName = "tdqk"
};
var simpleQuantityKind = new SimpleQuantityKind();
rdl.ParameterType.Add(simpleQuantityKind);
rdl.Scale.Add(testLogarithmicScale);
this.siteDir.SiteReferenceDataLibrary.Add(rdl);
this.session.Setup(x => x.RetrieveSiteDirectory()).Returns(this.siteDir);
var chainOfContainers = new[] { rdl };
var clone = testLogarithmicScale.Clone(false);
this.cache.TryAdd(new CacheKey(testLogarithmicScale.Iid, null), new Lazy <Thing>(() => testLogarithmicScale));
var transactionContext = TransactionContextResolver.ResolveContext(this.siteDir);
this.transaction = new ThingTransaction(transactionContext, clone);
var dal = new Mock <IDal>();
this.session.Setup(x => x.DalVersion).Returns(new Version(1, 1, 0));
this.session.Setup(x => x.Dal).Returns(dal.Object);
dal.Setup(x => x.MetaDataProvider).Returns(new MetaDataProvider());
this.viewmodel = new ScaleReferenceQuantityValueDialogViewModel(this.scaleReferenceQuantityValue, this.transaction, this.session.Object, true, ThingDialogKind.Create, null, clone, chainOfContainers);
}
public void SetUp()
{
this.scaleReferenceQuantityValueRuleChecker = new ScaleReferenceQuantityValueRuleChecker();
this.siteReferenceDataLibrary = new SiteReferenceDataLibrary();
this.logarithmicScale = new LogarithmicScale {
Iid = Guid.NewGuid()
};
this.scaleReferenceQuantityValue = new ScaleReferenceQuantityValue();
this.siteReferenceDataLibrary.Scale.Add(this.logarithmicScale);
this.logarithmicScale.ReferenceQuantityValue.Add(this.scaleReferenceQuantityValue);
}
public void TestGetAllPossibleScaleSpecialized()
{
var quantityKind = new SpecializedQuantityKind();
var scale = new LogarithmicScale();
quantityKind.PossibleScale.Add(scale);
quantityKind.General = new SimpleQuantityKind();
quantityKind.General.PossibleScale.Add(new RatioScale());
quantityKind.General.PossibleScale.Add(new CyclicRatioScale());
quantityKind.General.PossibleScale.Add(scale);
Assert.AreEqual(3, quantityKind.AllPossibleScale.Count);
}
public void Setup()
{
RxApp.MainThreadScheduler = Scheduler.CurrentThread;
this.serviceLocator = new Mock<IServiceLocator>();
this.navigation = new Mock<IThingDialogNavigationService>();
ServiceLocator.SetLocatorProvider(() => this.serviceLocator.Object);
this.serviceLocator.Setup(x => x.GetInstance<IThingDialogNavigationService>()).Returns(this.navigation.Object);
this.permissionService = new Mock<IPermissionService>();
this.permissionService.Setup(x => x.CanRead(It.IsAny<Thing>())).Returns(true);
this.permissionService.Setup(x => x.CanWrite(It.IsAny<Thing>())).Returns(true);
this.session = new Mock<ISession>();
this.session.Setup(x => x.PermissionService).Returns(this.permissionService.Object);
var person = new Person(Guid.NewGuid(), null, null) { Container = this.siteDir };
this.session.Setup(x => x.ActivePerson).Returns(person);
var simpleUnit = new SimpleUnit(Guid.NewGuid(), null, null);
this.siteDir = new SiteDirectory(Guid.NewGuid(), null, null);
this.siteDir.Person.Add(person);
var testScale = new LogarithmicScale();
this.rdl = new SiteReferenceDataLibrary(Guid.NewGuid(), null, null) { Name = "testRDL", ShortName = "test" };
this.rdl.Unit.Add(simpleUnit);
this.rdl.Scale.Add(testScale);
var svd1 = new ScaleValueDefinition(Guid.NewGuid(), null, null) { Name = "ReferenceSVD", ShortName = "RSVD" };
var svd2 = new ScaleValueDefinition(Guid.NewGuid(), null, null) { Name = "DependentSVD", ShortName = "DSVD" };
this.ratioScale = new RatioScale(Guid.NewGuid(), null, null) { Name = "ratioScale", ShortName = "dqk" };
this.ratioScale.ValueDefinition.Add(svd1);
this.ratioScale.ValueDefinition.Add(svd2);
this.rdl.ParameterType.Add(new SimpleQuantityKind { Name = "testSQK", ShortName = "tSQK" });
this.siteDir.SiteReferenceDataLibrary.Add(this.rdl);
var transactionContext = TransactionContextResolver.ResolveContext(this.siteDir);
this.transaction = new ThingTransaction(transactionContext, null);
this.session.Setup(x => x.RetrieveSiteDirectory()).Returns(this.siteDir);
this.session.Setup(x => x.OpenReferenceDataLibraries).Returns(new HashSet<ReferenceDataLibrary>(this.siteDir.SiteReferenceDataLibrary));
var dal = new Mock<IDal>();
this.session.Setup(x => x.DalVersion).Returns(new Version(1, 1, 0));
this.session.Setup(x => x.Dal).Returns(dal.Object);
dal.Setup(x => x.MetaDataProvider).Returns(new MetaDataProvider());
this.viewmodel = new RatioScaleDialogViewModel(this.ratioScale, this.transaction, this.session.Object, true, ThingDialogKind.Create, this.navigation.Object);
}
public void VerifThatUpdatingGeneralUpdatesPossiblePossibleScales()
{
Assert.IsNotEmpty(this.viewmodel.PossibleGeneral);
Assert.IsNull(this.viewmodel.SelectedGeneral);
var scale1 = new LogarithmicScale(Guid.NewGuid(), null, null);
var scale2 = new RatioScale(Guid.NewGuid(), null, null);
this.rdl.Scale.Add(scale1);
this.rdl.Scale.Add(scale2);
var generalQuantityKind = this.viewmodel.PossibleGeneral.First();
Assert.AreEqual(0, generalQuantityKind.PossibleScale.Count);
generalQuantityKind.PossibleScale.Add(scale1);
generalQuantityKind.PossibleScale.Add(scale2);
this.viewmodel.SelectedGeneral = generalQuantityKind;
Assert.AreEqual(2, this.viewmodel.GeneralizationScale.Count);
Assert.AreEqual(0, this.viewmodel.PossiblePossibleScale.Count);
}
/// <summary>
/// Persist the <see cref="LogarithmicScale"/> containment tree to the ORM layer. Update if it already exists.
/// This is typically used during the import of existing data to the Database.
/// </summary>
/// <param name="transaction">
/// The current <see cref="NpgsqlTransaction"/> to the database.
/// </param>
/// <param name="partition">
/// The database partition (schema) where the requested resource will be stored.
/// </param>
/// <param name="logarithmicScale">
/// The <see cref="LogarithmicScale"/> instance to persist.
/// </param>
/// <returns>
/// True if the persistence was successful.
/// </returns>
private bool UpsertContainment(NpgsqlTransaction transaction, string partition, LogarithmicScale logarithmicScale)
{
var results = new List <bool>();
foreach (var alias in this.ResolveFromRequestCache(logarithmicScale.Alias))
{
results.Add(this.AliasService.UpsertConcept(transaction, partition, alias, logarithmicScale));
}
foreach (var definition in this.ResolveFromRequestCache(logarithmicScale.Definition))
{
results.Add(this.DefinitionService.UpsertConcept(transaction, partition, definition, logarithmicScale));
}
foreach (var hyperLink in this.ResolveFromRequestCache(logarithmicScale.HyperLink))
{
results.Add(this.HyperLinkService.UpsertConcept(transaction, partition, hyperLink, logarithmicScale));
}
foreach (var mappingToReferenceScale in this.ResolveFromRequestCache(logarithmicScale.MappingToReferenceScale))
{
results.Add(this.MappingToReferenceScaleService.UpsertConcept(transaction, partition, mappingToReferenceScale, logarithmicScale));
}
foreach (var referenceQuantityValue in this.ResolveFromRequestCache(logarithmicScale.ReferenceQuantityValue))
{
results.Add(this.ReferenceQuantityValueService.UpsertConcept(transaction, partition, referenceQuantityValue, logarithmicScale));
}
foreach (var valueDefinition in this.ResolveFromRequestCache(logarithmicScale.ValueDefinition))
{
results.Add(this.ValueDefinitionService.UpsertConcept(transaction, partition, valueDefinition, logarithmicScale));
}
return(results.All(x => x));
}
