/// <summary>
/// Executes the <see cref="CreateSubscriptionCommand"/>
/// </summary>
private async Task ExecuteCreateSubscriptionCommand()
{
if (this.SelectedThing == null)
{
return;
}
var parameterOrOverrideRow = this.SelectedThing as ParameterOrOverrideBaseRowViewModel;
if (parameterOrOverrideRow == null)
{
return;
}
Tuple <DomainOfExpertise, Participant> tuple;
this.Session.OpenIterations.TryGetValue(this.Thing.GetContainerOfType <Iteration>(), out tuple);
var subscription = new ParameterSubscription
{
Owner = tuple.Item1
};
var transactionContext = TransactionContextResolver.ResolveContext(this.Thing);
var transaction = new ThingTransaction(transactionContext);
var clone = parameterOrOverrideRow.Thing.Clone(false);
transaction.Create(subscription);
transaction.CreateOrUpdate(clone);
clone.ParameterSubscription.Add(subscription);
await this.DalWrite(transaction);
}
/// <summary>
/// Initializes a new instance of the <see cref="ParameterSubscriptionDialogViewModel" /> class
/// </summary>
/// <param name="parameterSubscription">
/// The parameterSubscription.
/// </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="DialogViewModelBase{T}" /> is the root of all <see cref="DialogViewModelBase{T}" />
/// </param>
/// <param name="dialogKind">
/// The kind of operation this <see cref="DialogViewModelBase{T}" /> 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 Container <see cref="Thing" /> of the created <see cref="MultiRelationshipRule" />
/// </param>
/// <param name="chainOfContainers">
/// The optional chain of containers that contains the <paramref name="container" /> argument
/// </param>
public ParameterSubscriptionDialogViewModel(ParameterSubscription parameterSubscription, IThingTransaction transaction, ISession session, bool isRoot, ThingDialogKind dialogKind, IThingDialogNavigationService thingDialogNavigationService, Thing container = null, IEnumerable <Thing> chainOfContainers = null)
: base(parameterSubscription, transaction, session, isRoot, dialogKind, thingDialogNavigationService, container, chainOfContainers)
{
this.WhenAnyValue(vm => vm.DisplayedValueSet).Where(x => x != null).Subscribe(_ => this.LoadValueSetGrid());
this.IsNameVisible = this.Thing.ParameterType is CompoundParameterType || this.Thing.IsOptionDependent || this.Thing.StateDependence != null;
this.CheckValueValidation();
}
public void VerifyThatParameterSubscriptionHasRightOwnerValue()
{
this.parameter5Subscription = new ParameterSubscription(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
Owner = this.activeDomain
};
this.parameter5ForSubscription.ParameterSubscription.Add(this.parameter5Subscription);
var valueSet = new ParameterValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri);
this.SetScalarValueSet(valueSet);
var valueSetSub = new ParameterSubscriptionValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri);
valueSetSub.SubscribedValueSet = valueSet;
this.parameter5Subscription.ValueSet.Add(valueSetSub);
var row = new ParameterSubscriptionRowViewModel(this.parameter5Subscription, this.session.Object, null, false);
Assert.AreEqual(0, row.ContainedRows.Count);
Assert.AreEqual("PTName", row.Name);
Assert.AreEqual("[other]", row.OwnerName);
Assert.AreEqual("formula", row.Formula);
Assert.AreEqual("ref", row.Reference);
Assert.That(row.ScaleName, Is.Null.Or.Empty);
}
public void CheckThatMultipleSubscriptionCannotBeCreatedForSameOwner()
{
var subOwnerGuid = Guid.NewGuid();
var existingSub = new ParameterSubscription(Guid.NewGuid(), 1)
{
Owner = subOwnerGuid
};
var parameterSubscription = new ParameterSubscription(Guid.NewGuid(), 1)
{
Owner = subOwnerGuid
};
var parameter = new Parameter(Guid.NewGuid(), 1)
{
Owner = Guid.NewGuid()
};
parameter.ValueSet = new List <Guid> {
Guid.NewGuid()
};
parameter.ParameterSubscription.Add(existingSub.Iid);
this.parameterService
.Setup(x => x.GetShallow(this.npgsqlTransaction, "partition", It.Is <IEnumerable <Guid> >(i => i.Single() == parameter.Iid), this.securityContext.Object))
.Returns(new Thing[] { parameter });
this.parameterSubscriptionService.Setup(x => x.GetShallow(this.npgsqlTransaction, "partition", It.Is <IEnumerable <Guid> >(y => y.Contains(existingSub.Iid)), this.securityContext.Object)).Returns(new List <Thing> {
existingSub
});
Assert.IsFalse(this.sideEffect.BeforeCreate(parameterSubscription, parameter, this.npgsqlTransaction, "partition", this.securityContext.Object));
}
public void VerifySubscriptionsAreCreated()
{
var originalThing = this.parameterOverride.DeepClone <Thing>();
this.parameterOverride.Owner = this.parameter.Owner;
var subscription1 = new ParameterSubscription(Guid.NewGuid(), 0)
{
Owner = Guid.NewGuid()
};
var subscription2 = new ParameterSubscription(Guid.NewGuid(), 0)
{
Owner = Guid.NewGuid()
};
this.parameter.ParameterSubscription.Add(subscription1.Iid);
this.parameter.ParameterSubscription.Add(subscription2.Iid);
this.parameterSubscriptionService.Setup(x => x.GetShallow(null, It.IsAny <string>(), null, this.securityContext.Object)).Returns(new[] { subscription2, subscription1 });
this.sideEffect.AfterCreate(this.parameterOverride, this.elementUsage, originalThing, this.npgsqlTransaction, "partition", this.securityContext.Object);
this.parameterSubscriptionService.Verify(x => x.CreateConcept(null, It.IsAny <string>(), It.IsAny <ParameterSubscription>(), It.IsAny <ParameterOverride>(), It.IsAny <long>()), Times.Exactly(2));
this.subscriptionValueSetService.Verify(x => x.CreateConcept(null, It.IsAny <string>(), It.IsAny <ParameterSubscriptionValueSet>(), It.IsAny <ParameterSubscription>(), It.IsAny <long>()), Times.Exactly(2));
}
public void VerifyThatWhenAParameterSubscriptionIsPostedValueSetsAreCreated()
{
this.parameterValueSetService
.Setup(x => x.GetShallow(It.IsAny <NpgsqlTransaction>(), "partition", It.IsAny <IEnumerable <Guid> >(), It.IsAny <ISecurityContext>()))
.Returns(new[] { new ParameterValueSet(Guid.NewGuid(), 0)
{
Manual = new ValueArray <string>(new[] { "1", "2" })
} });
var parameterSubscription = new ParameterSubscription(Guid.NewGuid(), 1)
{
Owner = Guid.NewGuid()
};
var originalparameterSubscription = new ParameterSubscription(parameterSubscription.Iid, 1);
var parameter = new Parameter(Guid.NewGuid(), 1)
{
Owner = Guid.NewGuid()
};
parameter.ValueSet = new List <Guid> {
Guid.NewGuid()
};
this.parameterService
.Setup(x => x.GetShallow(It.IsAny <NpgsqlTransaction>(), "partition", It.Is <IEnumerable <Guid> >(enu => enu.Contains(parameter.Iid)), It.IsAny <ISecurityContext>()))
.Returns(new[] { parameter });
this.sideEffect.AfterCreate(parameterSubscription, parameter, originalparameterSubscription, this.npgsqlTransaction, "partition", this.securityContext.Object);
this.parameterSubscriptionValueSetService.Verify(x => x.CreateConcept(this.npgsqlTransaction, "partition", It.Is <ParameterSubscriptionValueSet>(s => s.Manual.Count == 2), It.IsAny <ParameterSubscription>(), It.IsAny <long>()), Times.Once);
}
public void VerifyThatInlineEditWorkSimpleNoOptionNoState()
{
this.subscription = new ParameterSubscription(Guid.NewGuid(), this.assembler.Cache, this.uri);
this.parameter.IsOptionDependent = false;
this.parameter.ParameterSubscription.Add(this.subscription);
this.parameter.StateDependence = null;
var set1 = new ParameterValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri);
this.parameter.ValueSet.Add(set1);
var subset1 = new ParameterSubscriptionValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
SubscribedValueSet = set1
};
this.subscription.ValueSet.Add(subset1);
var row = new ParameterSubscriptionRowViewModel(this.subscription, this.session.Object, null, false);
Assert.AreEqual(0, row.ContainedRows.Count);
row.Switch = ParameterSwitchKind.REFERENCE;
row.CreateCloneAndWrite(ParameterSwitchKind.REFERENCE, "Switch");
this.session.Verify(x => x.Write(It.Is <OperationContainer>(op => ((CDP4Common.DTO.ParameterSubscriptionValueSet)op.Operations.Single().ModifiedThing).ValueSwitch == ParameterSwitchKind.REFERENCE)));
}
public void VerifyThatUpdateValueSetUpdates(IViewModelBase <Thing> container, string scenario)
{
var valueset = new ParameterValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri);
this.parameter.ValueSet.Add(valueset);
this.subscription = new ParameterSubscription(Guid.NewGuid(), this.assembler.Cache, this.uri);
this.parameter.ParameterSubscription.Add(subscription);
var subscriptionValueSet = new ParameterSubscriptionValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
SubscribedValueSet = valueset
};
this.subscription.ValueSet.Add(subscriptionValueSet);
var row = new ParameterSubscriptionRowViewModel(this.subscription, this.session.Object, container, false);
var revInfo = typeof(Thing).GetProperty("RevisionNumber");
revInfo.SetValue(subscriptionValueSet, 10);
Assert.AreEqual("-", row.Manual);
subscriptionValueSet.Manual = new ValueArray <string>(new List <string> {
"test"
});
CDPMessageBus.Current.SendObjectChangeEvent(subscriptionValueSet, EventKind.Updated);
Assert.AreEqual("test", row.Manual);
row.Dispose();
}
public void VerifyOwnerChangedSideEffects()
{
var domain1 = new DomainOfExpertise(Guid.NewGuid(), 0);
var domain2 = new DomainOfExpertise(Guid.NewGuid(), 0);
var subscription = new ParameterSubscription(Guid.NewGuid(), 1)
{
Owner = domain2.Iid
};
this.parameterOverride.ParameterSubscription.Add(subscription.Iid);
this.parameterOverride.Owner = domain1.Iid;
var originalThing = this.parameterOverride.DeepClone <Thing>();
this.parameterOverride.Owner = domain2.Iid;
this.parameterSubscriptionService.
Setup(x => x.GetShallow(It.IsAny <NpgsqlTransaction>(), It.IsAny <string>(), It.Is <IEnumerable <Guid> >(y => y.Contains(subscription.Iid)), this.securityContext.Object)).
Returns(new[] { subscription });
this.parameterSubscriptionService.
Setup(x => x.DeleteConcept(It.IsAny <NpgsqlTransaction>(), It.IsAny <string>(), It.IsAny <ParameterSubscription>(), It.IsAny <ParameterOverride>())).Returns(true);
this.sideEffect.AfterUpdate(this.parameterOverride, this.elementUsage, originalThing, this.npgsqlTransaction, "partition", this.securityContext.Object);
this.parameterSubscriptionService.Verify(x => x.DeleteConcept(It.IsAny <NpgsqlTransaction>(), It.IsAny <string>(), It.IsAny <ParameterSubscription>(), It.IsAny <ParameterOverride>()));
}
/// <summary>
/// Add the listener associated to the <see cref="ParameterSubscription" />
/// </summary>
/// <param name="parameterSubscription">The <see cref="ParameterSubscription" /></param>
private void AddParameterSubscriptionListener(ParameterSubscription parameterSubscription)
{
if (this.ParameterBaseListener.ContainsKey(parameterSubscription))
{
return;
}
Func <ObjectChangedEvent, bool> discriminator = objectChange => objectChange.ChangedThing.RevisionNumber > this.RevisionNumber;
Action <ObjectChangedEvent> action = x => this.PopulateParameters();
if (this.AllowMessageBusSubscriptions)
{
var listener = CDPMessageBus.Current.Listen <ObjectChangedEvent>(parameterSubscription)
.Where(discriminator)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(action);
this.ParameterBaseListener.Add(parameterSubscription, listener);
}
else
{
var parameterOrOverrideObserver = CDPMessageBus.Current.Listen <ObjectChangedEvent>(typeof(ParameterSubscription));
this.ParameterBaseListener.Add(parameterSubscription,
this.MessageBusHandler.GetHandler <ObjectChangedEvent>().RegisterEventHandler(parameterOrOverrideObserver, new ObjectChangedMessageBusEventHandlerSubscription(parameterSubscription, discriminator, action)));
}
}
public void VerifyOwnerChangedSideEffects()
{
this.parameter.ParameterType = this.boolPt.Iid;
var domain1 = new DomainOfExpertise(Guid.NewGuid(), 0);
var domain2 = new DomainOfExpertise(Guid.NewGuid(), 0);
var originalThing = this.parameter.DeepClone <Thing>();
this.parameter.Owner = domain1.Iid;
var updatedParameter = new Parameter(this.parameter.Iid, 0)
{
ParameterType = this.boolPt.Iid, Owner = domain2.Iid, AllowDifferentOwnerOfOverride = true
};
var parameterOverride1 = new ParameterOverride(Guid.NewGuid(), 0)
{
Parameter = updatedParameter.Iid, Owner = domain2.Iid
};
var domain2Subscription = new ParameterSubscription(Guid.NewGuid(), 0)
{
Owner = domain2.Iid
};
updatedParameter.ParameterSubscription.Add(domain2Subscription.Iid);
parameterOverride1.ParameterSubscription.Add(domain2Subscription.Iid);
this.parameterSubscriptionService.Setup(x => x.GetShallow(It.IsAny <NpgsqlTransaction>(), It.IsAny <string>(), It.IsAny <IEnumerable <Guid> >(), this.securityContext.Object))
.Returns(new List <Thing> {
domain2Subscription
});
this.parameterSubscriptionService.Setup(x => x.DeleteConcept(It.IsAny <NpgsqlTransaction>(),
It.IsAny <string>(), It.IsAny <Thing>(), It.IsAny <Thing>())).Returns(true);
this.sideEffect.AfterUpdate(updatedParameter, this.elementDefinition, originalThing, this.npgsqlTransaction, "partition", this.securityContext.Object);
// Check that the subscription owned by domain2 is deleted since domain2 is now the owner of the parameter
this.parameterSubscriptionService.Verify(x => x.DeleteConcept(this.npgsqlTransaction, "partition", It.IsAny <ParameterSubscription>(), It.IsAny <Parameter>()),
Times.Once);
// Since that is the only subscription, no updates are performed on ParameterSubscriptionValueSet
this.parameterSubscriptionValueSetService.Verify(x => x.CreateConcept(this.npgsqlTransaction, "partition", It.IsAny <ParameterSubscriptionValueSet>(), It.IsAny <ParameterSubscription>(), -1),
Times.Never);
// Check that since AllowDifferentOwnerOfOverride is True the owner of the parameterOverrides are not updated
this.parameterOverrideService.Verify(x => x.UpdateConcept(this.npgsqlTransaction, "partition", It.IsAny <ParameterOverride>(), It.IsAny <ElementUsage>()),
Times.Never);
var updatedParameter1 = new Parameter(this.parameter.Iid, 0)
{
ParameterType = this.boolPt.Iid, Owner = domain2.Iid, AllowDifferentOwnerOfOverride = false
};
updatedParameter1.ParameterSubscription.Add(domain2Subscription.Iid);
this.sideEffect.AfterUpdate(updatedParameter1, this.elementDefinition, originalThing, this.npgsqlTransaction, "partition", this.securityContext.Object);
// Check that since AllowDifferentOwnerOfOverride is False the owner of the parameterOverride is updated
this.parameterOverrideService.Verify(x => x.UpdateConcept(this.npgsqlTransaction, "partition", It.IsAny <ParameterOverride>(), It.IsAny <ElementUsage>()),
Times.Once);
}
public void VerifyThatParameterSubscriptionReturnsValueSets()
{
var parameterSubscription = new ParameterSubscription(Guid.NewGuid(), 1);
parameterSubscription.ValueSet.AddRange(this.valuesets);
CollectionAssert.AreEqual(this.valuesets, parameterSubscription.ValueSets);
}
public void VerifyThatNestedParameterExcelRowPropertiesAreSetForParameterSubscription()
{
var parameter = new Parameter(Guid.NewGuid(), this.cache, this.uri)
{
ParameterType = this.length,
Scale = this.meter,
Owner = this.systemEngineering
};
var parameterValueSet = new ParameterValueSet(Guid.NewGuid(), this.cache, this.uri)
{
Manual = new ValueArray <string>(new List <string> {
"A"
}),
Computed = new ValueArray <string>(new List <string> {
"B"
}),
Formula = new ValueArray <string>(new List <string> {
"C"
}),
ValueSwitch = ParameterSwitchKind.MANUAL
};
parameter.ValueSet.Add(parameterValueSet);
this.satellite.Parameter.Add(parameter);
var parameterSubscription = new ParameterSubscription(Guid.NewGuid(), this.cache, this.uri)
{
Owner = this.powerEngineering
};
var parameterSubscriptionValueSet = new ParameterSubscriptionValueSet(Guid.NewGuid(), this.cache, this.uri)
{
Manual = new ValueArray <string>(new List <string> {
"AA"
}),
ValueSwitch = ParameterSwitchKind.MANUAL,
SubscribedValueSet = parameterValueSet
};
parameterSubscription.ValueSet.Add(parameterSubscriptionValueSet);
parameter.ParameterSubscription.Add(parameterSubscription);
var nestedElementTreeGenerator = new NestedElementTreeGenerator();
var nestedElements = nestedElementTreeGenerator.Generate(this.option, this.powerEngineering);
var rootnode = nestedElements.Single(ne => ne.ShortName == "SAT");
var nestedparameter = rootnode.NestedParameter.Single();
var excelRow = new NestedParameterExcelRow(nestedparameter);
Assert.AreEqual("=SAT.l", excelRow.ActualValue);
Assert.AreEqual("SAT\\l\\option1\\", excelRow.ModelCode);
Assert.AreEqual("Length", excelRow.Name);
Assert.AreEqual("PWR [SYS]", excelRow.Owner);
Assert.AreEqual("l [m]", excelRow.ParameterTypeShortName);
Assert.AreEqual("NPS", excelRow.Type);
}
public void TestException()
{
this.parameterSubscription = new ParameterSubscription();
Assert.Throws <ContainmentException>(() =>
{
Console.WriteLine(this.parameterSubscription.ParameterType);
});
}
/// <summary>
/// Remove the listener associated to the <see cref="ParameterSubscription"/>
/// </summary>
/// <param name="parameterSubscription">The <see cref="ParameterSubscription"/></param>
private void RemoveParameterSubscriptionListener(ParameterSubscription parameterSubscription)
{
IDisposable disposable;
if (this.ParameterBaseListener.TryGetValue(parameterSubscription, out disposable))
{
disposable.Dispose();
this.ParameterBaseListener.Remove(parameterSubscription);
}
}
/// <summary>
/// Create <see cref="ParameterSubscription"/> for this <paramref name="parameterOverride"/> from its <see cref="Parameter"/>
/// </summary>
/// <param name="transaction">The current transaction</param>
/// <param name="partition">The current partition</param>
/// <param name="parameterOverride">The <see cref="ParameterOverride"/></param>
/// <param name="securityContext">The <see cref="ISecurityContext"/></param>
/// <param name="overrideValueset">The <see cref="ParameterOverrideValueSet"/> to subscribe on</param>
private void CreateSubscriptionFromParameter(NpgsqlTransaction transaction, string partition, ParameterOverride parameterOverride, ISecurityContext securityContext, IReadOnlyList <ParameterOverrideValueSet> overrideValueset)
{
var parameters = this.ParameterService.GetShallow(transaction, partition, new[] { parameterOverride.Parameter }, securityContext).OfType <Parameter>().ToArray();
if (parameters.Length != 1)
{
throw new InvalidOperationException("None or more than one parameters were returned");
}
var parameter = parameters.Single();
var existingSubscriptions = this.ParameterSubscriptionService
.GetShallow(transaction, partition, null, securityContext)
.OfType <ParameterSubscription>()
.ToList();
var parameterSubscriptions = existingSubscriptions.Where(x => parameter.ParameterSubscription.Contains(x.Iid)).ToList();
this.DefaultValueArrayFactory.Load(transaction, securityContext);
var defaultArray = this.DefaultValueArrayFactory.CreateDefaultValueArray(parameter.ParameterType);
var existingOverrideSubscriptions = existingSubscriptions.Where(x => parameterOverride.ParameterSubscription.Contains(x.Iid)).ToList();
var subscriptionValueSets =
this.ParameterSubscriptionValueSetService
.GetShallow(transaction, partition, parameterSubscriptions.SelectMany(x => x.ValueSet), securityContext)
.OfType <ParameterSubscriptionValueSet>()
.ToList();
foreach (var parameterSubscription in parameterSubscriptions)
{
if (parameterSubscription.Owner == parameterOverride.Owner || existingOverrideSubscriptions.Any(x => x.Owner == parameterSubscription.Owner))
{
continue;
}
var newSubscription = new ParameterSubscription(Guid.NewGuid(), 0)
{
Owner = parameterSubscription.Owner
};
this.ParameterSubscriptionService.CreateConcept(transaction, partition, newSubscription, parameterOverride);
foreach (var parameterOverrideValueSet in overrideValueset)
{
var subscriptionValueset =
this.ParameterSubscriptionValueSetFactory.CreateWithOldValues(
subscriptionValueSets.FirstOrDefault(x => x.SubscribedValueSet == parameterOverrideValueSet.ParameterValueSet),
parameterOverrideValueSet.Iid,
defaultArray);
this.ParameterSubscriptionValueSetService.CreateConcept(transaction, partition, subscriptionValueset, newSubscription);
}
}
}
public void VerifyThatAfterUpdateUpdateTheOVerrideAndSubscription()
{
var subscription1 = new ParameterSubscription(Guid.NewGuid(), 1);
var subscription2 = new ParameterSubscription(Guid.NewGuid(), 2);
var originalThing = this.parameter.DeepClone <Thing>();
this.parameterOverride.ParameterSubscription.Add(subscription2.Iid);
this.parameter.ParameterSubscription.Add(subscription1.Iid);
this.parameterOverrideService.Setup(
x => x.GetShallow(this.npgsqlTransaction, "partition", null, this.securityContext.Object))
.Returns(new List <Thing> {
this.parameterOverride
});
this.parameterSubscriptionService.Setup(x =>
x.GetShallow(this.npgsqlTransaction, "partition",
It.Is <IEnumerable <Guid> >(g => g.Contains(subscription1.Iid) && g.Contains(subscription2.Iid)),
this.securityContext.Object))
.Returns(new List <Thing> {
subscription1, subscription2
});
this.valueSetService.Setup(x => x.DeleteConcept(null, "partition", It.IsAny <ParameterValueSet>(), this.parameter))
.Returns(true);
this.parameter.ParameterType = this.cptParameterType.Iid;
this.parameter.StateDependence = null;
var valueset = new ParameterValueSet(Guid.NewGuid(), 0);
this.parameter.ValueSet.Add(valueset.Iid);
var updatedParameter = new Parameter(this.parameter.Iid, 0)
{
StateDependence = this.actualList.Iid
};
updatedParameter.ValueSet.Add(valueset.Iid);
updatedParameter.ParameterType = this.cptParameterType.Iid;
updatedParameter.ParameterSubscription.Add(subscription1.Iid);
this.sideEffect.AfterUpdate(updatedParameter, this.elementDefinition, originalThing, this.npgsqlTransaction, "partition", this.securityContext.Object);
this.parameterOverrideValueSetService.Verify(x => x.CreateConcept(this.npgsqlTransaction, "partition", It.IsAny <ParameterOverrideValueSet>(), this.parameterOverride, -1),
Times.Exactly(2));
this.parameterSubscriptionValueSetService.Verify(x => x.CreateConcept(this.npgsqlTransaction, "partition", It.IsAny <ParameterSubscriptionValueSet>(), subscription1, -1),
Times.Exactly(2));
this.parameterSubscriptionValueSetService.Verify(x => x.CreateConcept(this.npgsqlTransaction, "partition", It.IsAny <ParameterSubscriptionValueSet>(), subscription2, -1),
Times.Exactly(2));
}
public void VerifyThatValueSetInlineEditWorksCompoundOptionState()
{
this.subscription = new ParameterSubscription(Guid.NewGuid(), this.assembler.Cache, this.uri);
this.cptParameter.ParameterSubscription.Add(subscription);
this.subscription.ValueSet.Add(new ParameterSubscriptionValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
SubscribedValueSet = this.valueset1
});
this.subscription.ValueSet.Add(new ParameterSubscriptionValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
SubscribedValueSet = this.valueset2
});
this.subscription.ValueSet.Add(new ParameterSubscriptionValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
SubscribedValueSet = this.valueset3
});
this.subscription.ValueSet.Add(new ParameterSubscriptionValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
SubscribedValueSet = this.valueset4
});
var row = new ParameterSubscriptionRowViewModel(this.subscription, this.session.Object, null, false);
var option1Row =
row.ContainedRows.OfType <ParameterOptionRowViewModel>().Single(x => x.ActualOption == this.option1);
var option2Row =
row.ContainedRows.OfType <ParameterOptionRowViewModel>().Single(x => x.ActualOption == this.option2);
var o1s1Row = option1Row.ContainedRows.OfType <ParameterStateRowViewModel>()
.Single(x => x.ActualState == this.actualState1);
var o1s2Row = option1Row.ContainedRows.OfType <ParameterStateRowViewModel>()
.Single(x => x.ActualState == this.actualState2);
var o2s1Row = option2Row.ContainedRows.OfType <ParameterStateRowViewModel>()
.Single(x => x.ActualState == this.actualState1);
var o2s2Row = option2Row.ContainedRows.OfType <ParameterStateRowViewModel>()
.Single(x => x.ActualState == this.actualState2);
var o1s1c1Row = o1s1Row.ContainedRows.OfType <ParameterComponentValueRowViewModel>().First();
var o1s1c2Row = o1s1Row.ContainedRows.OfType <ParameterComponentValueRowViewModel>().Last();
var o1s2c1Row = o1s2Row.ContainedRows.OfType <ParameterComponentValueRowViewModel>().First();
var o1s2c2Row = o1s2Row.ContainedRows.OfType <ParameterComponentValueRowViewModel>().Last();
var o2s1c1Row = o2s1Row.ContainedRows.OfType <ParameterComponentValueRowViewModel>().First();
var o2s1c2Row = o2s1Row.ContainedRows.OfType <ParameterComponentValueRowViewModel>().Last();
var o2s2c1Row = o2s2Row.ContainedRows.OfType <ParameterComponentValueRowViewModel>().First();
var o2s2c2Row = o2s2Row.ContainedRows.OfType <ParameterComponentValueRowViewModel>().Last();
o1s1c1Row.Switch = ParameterSwitchKind.REFERENCE;
o1s1c1Row.CreateCloneAndWrite(ParameterSwitchKind.REFERENCE, "Switch");
this.session.Verify(x => x.Write(It.Is <OperationContainer>(op => ((CDP4Common.DTO.ParameterSubscriptionValueSet)op.Operations.Single().ModifiedThing).ValueSwitch == ParameterSwitchKind.REFERENCE)));
}
/// <summary>
/// Update the <see cref="ThingTransaction"/> with new <see cref="ParameterSubscription"/>s
/// </summary>
/// <param name="transaction">
/// The subject <see cref="IThingTransaction"/> that is to be updated
/// </param>
/// <param name="owner">
/// The <see cref="DomainOfExpertise"/> that is be the owner of the created <see cref="ParameterSubscription"/>s and should therefore
/// not be the owner of the <see cref="Parameter"/>s or <see cref="ParameterOverride"/>s that are subscribed to
/// </param>
/// <param name="parameterOrOverrides">
/// An <see cref="Action{IThingTransaction, ParameterOrOverrideBase, ParameterSubscription}"/> for which new <see cref="ParameterSubscription"/>s will be created.
/// </param>
private void UpdateTransactionWithParameterSubscriptions(IThingTransaction transaction, DomainOfExpertise owner, IEnumerable <ParameterOrOverrideBase> parameterOrOverrides, Action <IThingTransaction, ParameterOrOverrideBase, ParameterSubscription> updateAction)
{
foreach (var parameterOrOverride in parameterOrOverrides)
{
var subscription = new ParameterSubscription
{
Owner = owner
};
var clone = parameterOrOverride.Clone(false);
updateAction(transaction, clone, subscription);
}
}
public void VerifyThatConverReturnsExpectedResuly()
{
object result;
result = this.dataTypeConverter.Convert(null, null, null, null);
Assert.IsNull(result);
var parameterSubscription = new ParameterSubscription(Guid.NewGuid(), null, null);
result = this.dataTypeConverter.Convert(parameterSubscription, null, null, null);
Assert.AreEqual(typeof(ParameterSubscription), result);
}
public void Setup()
{
this.booleanParameterType = new BooleanParameterType(Guid.NewGuid(), null, null)
{
ShortName = "bool"
};
this.elementDefinition1 = new ElementDefinition(Guid.NewGuid(), null, null)
{
ShortName = "Sat"
};
this.elementDefinition2 = new ElementDefinition(Guid.NewGuid(), null, null)
{
ShortName = "Bat"
};
this.elementUsage = new ElementUsage(Guid.NewGuid(), null, null)
{
ShortName = "battery_1",
ElementDefinition = this.elementDefinition2
};
this.elementDefinition1.ContainedElement.Add(this.elementUsage);
this.parameter = new Parameter(Guid.NewGuid(), null, null);
this.parameter.ParameterType = this.booleanParameterType;
this.elementDefinition2.Parameter.Add(this.parameter);
this.parameterOverride = new ParameterOverride(Guid.NewGuid(), null, null);
this.parameterOverride.Parameter = this.parameter;
this.parameterSubscriptionValueSet = new ParameterSubscriptionValueSet();
this.parameterValueSetBase = new ParameterValueSet();
this.parameterValueSetBase.Published = new ValueArray <string>(new List <string> {
"computed"
});
this.parameterValueSetBase.Computed = new ValueArray <string>(new List <string> {
"computed"
});
this.parameterValueSetBase.Reference = new ValueArray <string>(new List <string> {
"ref"
});
this.parameterValueSetBase.ActualState = new ActualFiniteState();
this.parameterValueSetBase.ActualOption = new Option();
this.parameterSubscriptionValueSet.SubscribedValueSet = this.parameterValueSetBase;
this.parameterSubscriptionValueSet.Manual = new ValueArray <string>(new List <string> {
"manual"
});
this.parameterSubscription = new ParameterSubscription();
this.parameterSubscription.ValueSet.Add(this.parameterSubscriptionValueSet);
this.parameterSubscription.Owner = new DomainOfExpertise();
}
/// <summary>
/// Add the listener associated to the <see cref="ParameterSubscription"/>
/// </summary>
/// <param name="parameterSubscription">The <see cref="ParameterSubscription"/></param>
private void AddParameterSubscriptionListener(ParameterSubscription parameterSubscription)
{
if (this.ParameterBaseListener.ContainsKey(parameterSubscription))
{
return;
}
var listener = CDPMessageBus.Current.Listen <ObjectChangedEvent>(parameterSubscription)
.Where(objectChange => objectChange.ChangedThing.RevisionNumber > this.RevisionNumber)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => this.PopulateParameters());
this.ParameterBaseListener.Add(parameterSubscription, listener);
}
private void SetValueSet(ParameterSubscription subscription, ParameterOrOverrideBase param, IReadOnlyList <string> values)
{
var i = 0;
foreach (var parameterValueSet in param.ValueSets)
{
var valueset = new ParameterSubscriptionValueSet(Guid.NewGuid(), this.cache, this.uri)
{
SubscribedValueSet = (ParameterValueSetBase)parameterValueSet
};
this.SetValueSet(valueset, values[i]);
subscription.ValueSet.Add(valueset);
i++;
}
}
/// <summary>
/// Serialize the <see cref="ParameterSubscription"/>
/// </summary>
/// <param name="parameterSubscription">The <see cref="ParameterSubscription"/> to serialize</param>
/// <returns>The <see cref="JObject"/></returns>
private JObject Serialize(ParameterSubscription parameterSubscription)
{
var jsonObject = new JObject();
jsonObject.Add("classKind", this.PropertySerializerMap["classKind"](Enum.GetName(typeof(CDP4Common.CommonData.ClassKind), parameterSubscription.ClassKind)));
jsonObject.Add("excludedDomain", this.PropertySerializerMap["excludedDomain"](parameterSubscription.ExcludedDomain.OrderBy(x => x, this.guidComparer)));
jsonObject.Add("excludedPerson", this.PropertySerializerMap["excludedPerson"](parameterSubscription.ExcludedPerson.OrderBy(x => x, this.guidComparer)));
jsonObject.Add("iid", this.PropertySerializerMap["iid"](parameterSubscription.Iid));
jsonObject.Add("modifiedOn", this.PropertySerializerMap["modifiedOn"](parameterSubscription.ModifiedOn));
jsonObject.Add("owner", this.PropertySerializerMap["owner"](parameterSubscription.Owner));
jsonObject.Add("revisionNumber", this.PropertySerializerMap["revisionNumber"](parameterSubscription.RevisionNumber));
jsonObject.Add("thingPreference", this.PropertySerializerMap["thingPreference"](parameterSubscription.ThingPreference));
jsonObject.Add("valueSet", this.PropertySerializerMap["valueSet"](parameterSubscription.ValueSet.OrderBy(x => x, this.guidComparer)));
return(jsonObject);
}
public void VerifyThatParameterSubscriptionModelCodeReturnsExpectedResult()
{
var parameterValueSet = new ParameterValueSet();
this.parameter.ValueSet.Add(parameterValueSet);
var subscription = new ParameterSubscription();
var subscriptionValueSet = new ParameterSubscriptionValueSet();
subscription.ValueSet.Add(subscriptionValueSet);
subscriptionValueSet.SubscribedValueSet = parameterValueSet;
this.parameter.ParameterSubscription.Add(subscription);
Assert.AreEqual(@"Bat.bool", subscriptionValueSet.ModelCode(0));
}
public void Setup()
{
this.BuildSiteDirData();
this.BuildModelData();
this.map = new Dictionary <Thing, Thing>();
this.def2Copy = new ElementDefinition(Guid.NewGuid(), null, null);
this.parameter1Copy = new Parameter(Guid.NewGuid(), null, null);
this.subscriptionCopy = new ParameterSubscription(Guid.NewGuid(), null, null);
this.def2Copy.Parameter.Add(this.parameter1Copy);
this.parameter1Copy.ParameterSubscription.Add(this.subscriptionCopy);
this.map.Add(this.def2, this.def2Copy);
this.map.Add(this.parameter1, this.parameter1Copy);
this.map.Add(this.subscription1, this.subscriptionCopy);
}
public void SetUp()
{
this.uri = new Uri("http://www.rheagroup.com");
this.cache = new ConcurrentDictionary <CDP4Common.Types.CacheKey, Lazy <Thing> >();
this.siteReferenceDataLibrary = new SiteReferenceDataLibrary(Guid.NewGuid(), this.cache, this.uri);
this.systemEngineering = new DomainOfExpertise(Guid.NewGuid(), this.cache, this.uri);
this.powerEngineering = new DomainOfExpertise(Guid.NewGuid(), this.cache, this.uri);
this.simpleQuantityKind = new SimpleQuantityKind(Guid.NewGuid(), this.cache, this.uri);
this.equipments = new Category(Guid.NewGuid(), this.cache, this.uri)
{
ShortName = "EQT", Name = "Equipments"
};
this.siteReferenceDataLibrary.DefinedCategory.Add(this.equipments);
var engineeringModel = new EngineeringModel(Guid.NewGuid(), this.cache, this.uri);
this.iteration = new Iteration(Guid.NewGuid(), this.cache, this.uri);
engineeringModel.Iteration.Add(this.iteration);
var elementDefinition = new ElementDefinition(Guid.NewGuid(), this.cache, this.uri)
{
Owner = this.powerEngineering
};
elementDefinition.Category.Add(this.equipments);
this.iteration.Element.Add(elementDefinition);
var parameter = new Parameter(Guid.NewGuid(), this.cache, this.uri)
{
Owner = this.powerEngineering, ParameterType = this.simpleQuantityKind
};
elementDefinition.Parameter.Add(parameter);
var parameterSubscription = new ParameterSubscription(Guid.NewGuid(), this.cache, this.uri)
{
Owner = this.systemEngineering
};
parameter.ParameterSubscription.Add(parameterSubscription);
this.session = new Mock <ISession>();
this.session.Setup(x => x.QuerySelectedDomainOfExpertise(this.iteration)).Returns(this.systemEngineering);
this.parameterSubscriptionBatchService = new ParameterSubscriptionBatchService();
}
public void VerifyThatParameterBaseValueSetWorks()
{
var parameter = new Parameter();
var poverride = new ParameterOverride();
var subscription = new ParameterSubscription();
var parameterValueSet = new ParameterValueSet();
var overrideValueset = new ParameterOverrideValueSet();
var subscriptionValueset = new ParameterSubscriptionValueSet();
parameter.ValueSet.Add(parameterValueSet);
poverride.ValueSet.Add(overrideValueset);
subscription.ValueSet.Add(subscriptionValueset);
Assert.AreSame(parameter.ValueSet, parameter.ValueSets);
Assert.AreSame(poverride.ValueSet, poverride.ValueSets);
Assert.AreSame(subscription.ValueSet, subscription.ValueSets);
}
public void VerifyThatComputedAndReferenceValueAreUpdated(IViewModelBase <Thing> container, string scenario)
{
this.subscription = new ParameterSubscription(Guid.NewGuid(), this.assembler.Cache, this.uri);
this.parameter.IsOptionDependent = false;
this.parameter.ParameterSubscription.Add(this.subscription);
this.parameter.StateDependence = null;
var set1 = new ParameterValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri);
var liststring = new List <string> {
"abc"
};
set1.Reference = new ValueArray <string>(liststring);
set1.Published = new ValueArray <string>(liststring);
this.parameter.ValueSet.Add(set1);
var subset1 = new ParameterSubscriptionValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
SubscribedValueSet = set1
};
this.subscription.ValueSet.Add(subset1);
var row = new ParameterSubscriptionRowViewModel(this.subscription, this.session.Object, container, false);
Assert.AreEqual("abc", row.Computed);
Assert.AreEqual("abc", row.Reference);
var updated = new List <string> {
"123"
};
set1.Published = new ValueArray <string>(updated);
set1.Reference = new ValueArray <string>(updated);
var rev = typeof(Thing).GetProperty("RevisionNumber");
rev.SetValue(set1, 50);
CDPMessageBus.Current.SendObjectChangeEvent(set1, EventKind.Updated);
Assert.AreEqual("123", row.Computed);
Assert.AreEqual("123", row.Reference);
}
public void VerifyThatTheWhenOwnerOfTheParameterAndSubscriptionAreEqualExceptionIsThrown()
{
var owner = Guid.NewGuid();
var parameterSubscription = new ParameterSubscription(Guid.NewGuid(), 1)
{
Owner = owner
};
var parameter = new Parameter(Guid.NewGuid(), 1)
{
Owner = owner
};
parameter.ValueSet.Add(Guid.NewGuid());
Assert.Throws <Cdp4ModelValidationException>(() => this.sideEffect.BeforeCreate(parameterSubscription, parameter, this.npgsqlTransaction, "partition", this.securityContext.Object));
Assert.Throws <Cdp4ModelValidationException>(() => this.sideEffect.BeforeUpdate(parameterSubscription, parameter, this.npgsqlTransaction, "partition", this.securityContext.Object, null));
}
