/// <summary>
/// Serialize the <see cref="SpecializedQuantityKind"/>
/// </summary>
/// <param name="specializedQuantityKind">The <see cref="SpecializedQuantityKind"/> to serialize</param>
/// <returns>The <see cref="JObject"/></returns>
private JObject Serialize(SpecializedQuantityKind specializedQuantityKind)
{
var jsonObject = new JObject();
jsonObject.Add("alias", this.PropertySerializerMap["alias"](specializedQuantityKind.Alias.OrderBy(x => x, this.guidComparer)));
jsonObject.Add("category", this.PropertySerializerMap["category"](specializedQuantityKind.Category.OrderBy(x => x, this.guidComparer)));
jsonObject.Add("classKind", this.PropertySerializerMap["classKind"](Enum.GetName(typeof(CDP4Common.CommonData.ClassKind), specializedQuantityKind.ClassKind)));
jsonObject.Add("defaultScale", this.PropertySerializerMap["defaultScale"](specializedQuantityKind.DefaultScale));
jsonObject.Add("definition", this.PropertySerializerMap["definition"](specializedQuantityKind.Definition.OrderBy(x => x, this.guidComparer)));
jsonObject.Add("excludedDomain", this.PropertySerializerMap["excludedDomain"](specializedQuantityKind.ExcludedDomain.OrderBy(x => x, this.guidComparer)));
jsonObject.Add("excludedPerson", this.PropertySerializerMap["excludedPerson"](specializedQuantityKind.ExcludedPerson.OrderBy(x => x, this.guidComparer)));
jsonObject.Add("general", this.PropertySerializerMap["general"](specializedQuantityKind.General));
jsonObject.Add("hyperLink", this.PropertySerializerMap["hyperLink"](specializedQuantityKind.HyperLink.OrderBy(x => x, this.guidComparer)));
jsonObject.Add("iid", this.PropertySerializerMap["iid"](specializedQuantityKind.Iid));
jsonObject.Add("isDeprecated", this.PropertySerializerMap["isDeprecated"](specializedQuantityKind.IsDeprecated));
jsonObject.Add("modifiedOn", this.PropertySerializerMap["modifiedOn"](specializedQuantityKind.ModifiedOn));
jsonObject.Add("name", this.PropertySerializerMap["name"](specializedQuantityKind.Name));
jsonObject.Add("possibleScale", this.PropertySerializerMap["possibleScale"](specializedQuantityKind.PossibleScale.OrderBy(x => x, this.guidComparer)));
jsonObject.Add("quantityDimensionSymbol", this.PropertySerializerMap["quantityDimensionSymbol"](specializedQuantityKind.QuantityDimensionSymbol));
jsonObject.Add("revisionNumber", this.PropertySerializerMap["revisionNumber"](specializedQuantityKind.RevisionNumber));
jsonObject.Add("shortName", this.PropertySerializerMap["shortName"](specializedQuantityKind.ShortName));
jsonObject.Add("symbol", this.PropertySerializerMap["symbol"](specializedQuantityKind.Symbol));
jsonObject.Add("thingPreference", this.PropertySerializerMap["thingPreference"](specializedQuantityKind.ThingPreference));
return(jsonObject);
}
/// <summary>
/// Initializes a new instance of the <see cref="SpecializedQuantityKindDialogViewModel"/> class.
/// </summary>
/// <param name="specializedQuantityKind">
/// The Specialized 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="SpecializedQuantityKindDialogViewModel"/> is the root of all <see cref="IThingDialogViewModel"/>
/// </param>
/// <param name="dialogKind">
/// The kind of operation this <see cref="SpecializedQuantityKindDialogViewModel"/> 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 SpecializedQuantityKindDialogViewModel(SpecializedQuantityKind specializedQuantityKind, IThingTransaction transaction, ISession session, bool isRoot, ThingDialogKind dialogKind, IThingDialogNavigationService thingDialogNavigationService, Thing container = null, IEnumerable <Thing> chainOfContainers = null)
: base(specializedQuantityKind, transaction, session, isRoot, dialogKind, thingDialogNavigationService, container, chainOfContainers)
{
this.WhenAnyValue(vm => vm.Container).Subscribe(_ => { this.PopulatePossiblePossibleScales(); this.PopulatePossibleGeneral(); });
this.WhenAnyValue(vm => vm.SelectedDefaultScale).Subscribe(_ => this.UpdateOkCanExecute());
this.WhenAnyValue(vm => vm.SelectedGeneral).Subscribe(_ => { this.PopulatePossiblePossibleScales(); this.UpdateOkCanExecute(); });
}
public void VerifyThatParameterTypeEventsAreCaught()
{
var textParamType = new TextParameterType(Guid.NewGuid(), this.assembler.Cache, this.uri);
CDPMessageBus.Current.SendObjectChangeEvent(textParamType, EventKind.Added);
Assert.AreEqual(1, this.ParameterTypesBrowserViewModel.ParameterTypes.Count);
CDPMessageBus.Current.SendObjectChangeEvent(textParamType, EventKind.Removed);
Assert.IsFalse(this.ParameterTypesBrowserViewModel.ParameterTypes.Any());
var booleanParamType = new BooleanParameterType(Guid.NewGuid(), this.assembler.Cache, this.uri);
CDPMessageBus.Current.SendObjectChangeEvent(booleanParamType, EventKind.Added);
Assert.AreEqual(1, this.ParameterTypesBrowserViewModel.ParameterTypes.Count);
CDPMessageBus.Current.SendObjectChangeEvent(booleanParamType, EventKind.Removed);
Assert.IsFalse(this.ParameterTypesBrowserViewModel.ParameterTypes.Any());
var defaultScale = new CyclicRatioScale(Guid.NewGuid(), this.assembler.Cache, this.uri);
var simpleQuantityKind =
new SimpleQuantityKind(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
DefaultScale = defaultScale
};
CDPMessageBus.Current.SendObjectChangeEvent(simpleQuantityKind, EventKind.Added);
Assert.AreEqual(1, this.ParameterTypesBrowserViewModel.ParameterTypes.Count);
CDPMessageBus.Current.SendObjectChangeEvent(simpleQuantityKind, EventKind.Removed);
Assert.IsFalse(this.ParameterTypesBrowserViewModel.ParameterTypes.Any());
var specializedQuantityKind =
new SpecializedQuantityKind(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
DefaultScale = defaultScale
};
CDPMessageBus.Current.SendObjectChangeEvent(specializedQuantityKind, EventKind.Added);
Assert.AreEqual(1, this.ParameterTypesBrowserViewModel.ParameterTypes.Count);
CDPMessageBus.Current.SendObjectChangeEvent(specializedQuantityKind, EventKind.Removed);
Assert.IsFalse(this.ParameterTypesBrowserViewModel.ParameterTypes.Any());
var derivedQuantityKind =
new DerivedQuantityKind(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
DefaultScale = defaultScale
};
CDPMessageBus.Current.SendObjectChangeEvent(derivedQuantityKind, EventKind.Added);
Assert.AreEqual(1, this.ParameterTypesBrowserViewModel.ParameterTypes.Count);
CDPMessageBus.Current.SendObjectChangeEvent(derivedQuantityKind, EventKind.Removed);
Assert.IsFalse(this.ParameterTypesBrowserViewModel.ParameterTypes.Any());
}
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);
this.siteDir = new SiteDirectory(Guid.NewGuid(), null, null);
this.siteDir.Person.Add(person);
this.rdl = new SiteReferenceDataLibrary(Guid.NewGuid(), null, null)
{
Name = "testRDL", ShortName = "test"
};
this.specializedQuantityKind = new SpecializedQuantityKind(Guid.NewGuid(), null, null)
{
Name = "specializedQuantityKind", ShortName = "sqk"
};
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 SpecializedQuantityKindDialogViewModel(this.specializedQuantityKind, this.transaction, this.session.Object, true, ThingDialogKind.Create, null, null, null);
}
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()
{
// QuantityKind tree: rootQk -> specializedQk -> derivedQk -> simpleQk
this.simpleQk = new SimpleQuantityKind(Guid.NewGuid(), 0);
this.derivedQkFactor = new QuantityKindFactor(Guid.NewGuid(), 0)
{
QuantityKind = this.simpleQk.Iid
};
this.derivedQk = new DerivedQuantityKind(Guid.NewGuid(), 0)
{
QuantityKindFactor =
{
new OrderedItem {
K = 1, V = this.derivedQkFactor.Iid.ToString()
}
}
};
this.specializedQk = new SpecializedQuantityKind(Guid.NewGuid(), 0)
{
General = this.derivedQk.Iid
};
this.rootQkFactor = new QuantityKindFactor(Guid.NewGuid(), 0)
{
QuantityKind = this.specializedQk.Iid
};
this.rootQk = new DerivedQuantityKind(Guid.NewGuid(), 0)
{
QuantityKindFactor =
{
new OrderedItem {
K = 1, V = this.rootQkFactor.Iid.ToString()
}
}
};
// cyclic factor
this.derivedQkCyclicFactor = new QuantityKindFactor(Guid.NewGuid(), 0)
{
QuantityKind = this.rootQk.Iid
};
// outside RDL factor
this.outsideRdlQk = new SimpleQuantityKind(Guid.NewGuid(), 0);
this.derivedQkOutsideRdlFactor = new QuantityKindFactor(Guid.NewGuid(), 0)
{
QuantityKind = this.outsideRdlQk.Iid
};
// RDL chain: mrdl -> srdl
this.srdl = new SiteReferenceDataLibrary(Guid.NewGuid(), 0)
{
ParameterType =
{
this.simpleQk.Iid
}
};
this.mrdl = new ModelReferenceDataLibrary(Guid.NewGuid(), 0)
{
ParameterType =
{
this.derivedQk.Iid,
this.specializedQk.Iid,
this.rootQk.Iid
},
RequiredRdl = this.srdl.Iid
};
// setup services
this.npgsqlTransaction = null;
this.securityContext = new Mock <ISecurityContext>();
this.siteReferenceDataLibraryService = new Mock <ISiteReferenceDataLibraryService>();
this.siteReferenceDataLibraryService
.Setup(x => x.Get(
this.npgsqlTransaction,
It.IsAny <string>(),
null,
It.IsAny <ISecurityContext>()))
.Returns(new List <ReferenceDataLibrary>
{
this.srdl
});
this.quantityKindFactorService = new Mock <IQuantityKindFactorService>();
this.quantityKindFactorService
.Setup(x => x.Get(
this.npgsqlTransaction,
It.IsAny <string>(),
It.IsAny <IEnumerable <Guid> >(),
It.IsAny <ISecurityContext>()))
.Returns <NpgsqlTransaction, string, IEnumerable <Guid>, ISecurityContext>(
(transaction, partition, iids, context) =>
{
iids = iids.ToList();
return(new List <Thing>
{
this.derivedQkFactor,
this.rootQkFactor,
this.derivedQkCyclicFactor,
this.derivedQkOutsideRdlFactor
}.Where(qkf => iids.Contains(qkf.Iid)));
});
this.quantityKindService = new Mock <IQuantityKindService>();
this.quantityKindService
.Setup(x => x.Get(
this.npgsqlTransaction,
It.IsAny <string>(),
It.IsAny <IEnumerable <Guid> >(),
It.IsAny <ISecurityContext>()))
.Returns <NpgsqlTransaction, string, IEnumerable <Guid>, ISecurityContext>(
(transaction, partition, iids, context) =>
{
iids = iids.ToList();
return(new List <Thing>
{
this.simpleQk,
this.derivedQk,
this.specializedQk,
this.rootQk,
this.outsideRdlQk
}.Where(qk => iids.Contains(qk.Iid)));
});
this.sideEffect = new DerivedQuantityKindSideEffect
{
SiteReferenceDataLibraryService = this.siteReferenceDataLibraryService.Object,
QuantityKindFactorService = this.quantityKindFactorService.Object,
QuantityKindService = this.quantityKindService.Object
};
}
/// <summary>
/// Persist the <see cref="SpecializedQuantityKind"/> 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="specializedQuantityKind">
/// The <see cref="SpecializedQuantityKind"/> instance to persist.
/// </param>
/// <returns>
/// True if the persistence was successful.
/// </returns>
private bool UpsertContainment(NpgsqlTransaction transaction, string partition, SpecializedQuantityKind specializedQuantityKind)
{
var results = new List <bool>();
foreach (var alias in this.ResolveFromRequestCache(specializedQuantityKind.Alias))
{
results.Add(this.AliasService.UpsertConcept(transaction, partition, alias, specializedQuantityKind));
}
foreach (var definition in this.ResolveFromRequestCache(specializedQuantityKind.Definition))
{
results.Add(this.DefinitionService.UpsertConcept(transaction, partition, definition, specializedQuantityKind));
}
foreach (var hyperLink in this.ResolveFromRequestCache(specializedQuantityKind.HyperLink))
{
results.Add(this.HyperLinkService.UpsertConcept(transaction, partition, hyperLink, specializedQuantityKind));
}
return(results.All(x => x));
}
public void TestGetDerivedQuantityDimensionExpression()
{
var quantityKind = new SpecializedQuantityKind();
Assert.Throws <NotSupportedException>(() => { var test = quantityKind.QuantityDimensionExpression; });
}
public void Setup()
{
this.npgsqlTransaction = null;
this.securityContext = new Mock <ISecurityContext>();
// There is a chain a -> b -> c
this.specializedQuantityKindC = new SpecializedQuantityKind {
Iid = Guid.NewGuid()
};
this.specializedQuantityKindB =
new SpecializedQuantityKind {
Iid = Guid.NewGuid(), General = this.specializedQuantityKindC.Iid
};
this.specializedQuantityKindA =
new SpecializedQuantityKind {
Iid = Guid.NewGuid(), General = this.specializedQuantityKindB.Iid
};
this.specializedQuantityKindD = new SpecializedQuantityKind {
Iid = Guid.NewGuid()
};
// Outside the rdl chain
this.specializedQuantityKindE = new SpecializedQuantityKind {
Iid = Guid.NewGuid()
};
// There is a chain librayA -> LibraryB
this.referenceDataLibraryB =
new SiteReferenceDataLibrary {
Iid = Guid.NewGuid(), ParameterType = { this.specializedQuantityKindD.Iid }
};
this.referenceDataLibraryA = new ModelReferenceDataLibrary
{
Iid = Guid.NewGuid(),
ParameterType =
{
this.specializedQuantityKindA.Iid,
this.specializedQuantityKindB.Iid,
this.specializedQuantityKindC.Iid
},
RequiredRdl = this.referenceDataLibraryB.Iid
};
this.siteReferenceDataLibraryService = new Mock <ISiteReferenceDataLibraryService>();
this.siteReferenceDataLibraryService
.Setup(
x => x.Get(
this.npgsqlTransaction,
It.IsAny <string>(),
null,
It.IsAny <ISecurityContext>()))
.Returns(new List <ReferenceDataLibrary> {
this.referenceDataLibraryB
});
this.specializedQuantityKindService = new Mock <ISpecializedQuantityKindService>();
this.specializedQuantityKindService
.Setup(
x => x.Get(
this.npgsqlTransaction,
It.IsAny <string>(),
new List <Guid>
{
this.specializedQuantityKindD.Iid,
this.specializedQuantityKindA.Iid,
this.specializedQuantityKindB.Iid,
this.specializedQuantityKindC.Iid
},
It.IsAny <ISecurityContext>())).Returns(
new List <SpecializedQuantityKind>
{
this.specializedQuantityKindD,
this.specializedQuantityKindA,
this.specializedQuantityKindB,
this.specializedQuantityKindC
});
}
