/// <summary> /// Creates ParameterSubscriptionValueSets for the supplied ParameterValueSets. /// </summary> /// <param name="thing"> /// The <see cref="Thing"/> instance that will be inspected. /// </param> /// <param name="container"> /// The container instance of the <see cref="Thing"/> that is inspected. /// </param> /// <param name="transaction"> /// The current transaction to the database. /// </param> /// <param name="partition"> /// The database partition (schema) where the requested resource will be stored. /// </param> /// <param name="securityContext"> /// The security-context /// </param> private void CreateParameterSubscriptionValueSets( ParameterSubscription thing, Thing container, NpgsqlTransaction transaction, string partition, ISecurityContext securityContext) { if (!(container is CDP4Common.DTO.ParameterOrOverrideBase parameterOrOverrideBase)) { throw new InvalidOperationException("The container of a ParameterSubscription can only be a ParameterOrOverrideBase."); } var parameterValueSets = parameterOrOverrideBase is CDP4Common.DTO.Parameter ? this.ParameterValueSetService.GetShallow(transaction, partition, parameterOrOverrideBase.ValueSets, securityContext).OfType <CDP4Common.DTO.ParameterValueSetBase>().ToArray() : this.ParameterOverrideValueSetService.GetShallow(transaction, partition, parameterOrOverrideBase.ValueSets, securityContext).OfType <CDP4Common.DTO.ParameterValueSetBase>().ToArray(); foreach (var parameterValueSet in parameterValueSets) { var parameterSubscriptionValueSet = new ParameterSubscriptionValueSet(Guid.NewGuid(), 0) { SubscribedValueSet = parameterValueSet.Iid, ValueSwitch = ParameterSwitchKind.COMPUTED }; var valueArray = new ValueArray <string>(this.DefaultValueArrayFactory.CreateDefaultValueArray(parameterValueSet.Manual.Count)); parameterSubscriptionValueSet.Manual = valueArray; this.ParameterSubscriptionValueSetService.CreateConcept( transaction, partition, parameterSubscriptionValueSet, thing); } }
/// <summary> /// The mapping from a database record to data transfer object. /// </summary> /// <param name="reader"> /// An instance of the SQL reader. /// </param> /// <returns> /// A deserialized instance of <see cref="CDP4Common.DTO.ParameterSubscriptionValueSet"/>. /// </returns> public virtual CDP4Common.DTO.ParameterSubscriptionValueSet MapToDto(NpgsqlDataReader reader) { string tempModifiedOn; string tempManual; string tempValueSwitch; var valueDict = (Dictionary <string, string>)reader["ValueTypeSet"]; var iid = Guid.Parse(reader["Iid"].ToString()); var revisionNumber = int.Parse(valueDict["RevisionNumber"]); var dto = new CDP4Common.DTO.ParameterSubscriptionValueSet(iid, revisionNumber); dto.ExcludedPerson.AddRange(Array.ConvertAll((string[])reader["ExcludedPerson"], Guid.Parse)); dto.ExcludedDomain.AddRange(Array.ConvertAll((string[])reader["ExcludedDomain"], Guid.Parse)); dto.SubscribedValueSet = Guid.Parse(reader["SubscribedValueSet"].ToString()); if (valueDict.TryGetValue("ModifiedOn", out tempModifiedOn)) { dto.ModifiedOn = Utils.ParseUtcDate(tempModifiedOn); } if (valueDict.TryGetValue("Manual", out tempManual)) { dto.Manual = tempManual.FromHstoreToValueArray <string>(); } if (valueDict.TryGetValue("ValueSwitch", out tempValueSwitch)) { dto.ValueSwitch = Utils.ParseEnum <CDP4Common.EngineeringModelData.ParameterSwitchKind>(tempValueSwitch); } return(dto); }
/// <summary> /// Create a new <see cref="ParameterSubscriptionValueSet"/> from the updated <see cref="ParameterValueSetBase"/> /// </summary> /// <param name="oldValue">The old <see cref="ParameterSubscriptionValueSet"/></param> /// <param name="valueSetBase">The subscribed <see cref="ParameterValueSetBase"/></param> /// <param name="container">The container</param> /// <param name="transaction">The current transaction</param> /// <param name="partition">The current partition</param> private void CreateParameterSubscriptionValueSet(ParameterSubscriptionValueSet oldValue, ParameterValueSetBase valueSetBase, ParameterSubscription container, NpgsqlTransaction transaction, string partition) { var isOldValueNull = oldValue == null; var newValueSet = new ParameterSubscriptionValueSet(Guid.NewGuid(), 1) { Manual = new ValueArray <string>((oldValue == null) ? valueSetBase.Manual : oldValue.Manual), ValueSwitch = isOldValueNull ? CDP4Common.EngineeringModelData.ParameterSwitchKind.MANUAL : oldValue.ValueSwitch, SubscribedValueSet = valueSetBase.Iid }; this.ParameterSubscriptionValueSetService.CreateConcept(transaction, partition, newValueSet, container); }
public void VerifyThatCreateValueSetsUpdateOperationsWorks() { var valueset = new ParameterValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri); valueset.Manual = new ValueArray <string>(manual); this.parameter1.ValueSet.Add(valueset); var subscriptionvalueset = new ParameterSubscriptionValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri); subscriptionvalueset.Manual = new ValueArray <string>(manual); this.subscription1.ValueSet.Add(subscriptionvalueset); var modeldto = this.model2.ToDto(); var iterationDto = (Dto.Iteration) this.iteration2.ToDto(); var def2Dto = new Dto.ElementDefinition(this.def2Copy.Iid, 2); var parameterDto = new Dto.Parameter(this.parameter1Copy.Iid, 2); var newValueSet = new Dto.ParameterValueSet(Guid.NewGuid(), 2); var subscription = new Dto.ParameterSubscription(this.subscriptionCopy.Iid, 1); var subscriptionValueSet = new Dto.ParameterSubscriptionValueSet(Guid.NewGuid(), 1); iterationDto.Element.Add(def2Dto.Iid); def2Dto.Parameter.Add(parameterDto.Iid); parameterDto.ValueSet.Add(newValueSet.Iid); parameterDto.ParameterSubscription.Add(subscription.Iid); subscription.ValueSet.Add(subscriptionValueSet.Iid); var returnedDto = new List <Dto.Thing> { modeldto, iterationDto, def2Dto, parameterDto, newValueSet, subscription, subscriptionValueSet }; var transactionContext = TransactionContextResolver.ResolveContext(this.iteration2); var context = transactionContext.ContextRoute(); var operationCreator = new ValueSetOperationCreator(this.session.Object); var operationContainer = operationCreator.CreateValueSetsUpdateOperations(context, returnedDto, this.map); Assert.AreEqual(2, operationContainer.Operations.Count()); var operation = operationContainer.Operations.Single(x => x.OriginalThing.ClassKind == ClassKind.ParameterValueSet); var originalPvs = (Dto.ParameterValueSet)operation.OriginalThing; var modifiedPvs = (Dto.ParameterValueSet)operation.ModifiedThing; Assert.AreNotEqual(originalPvs.Manual, modifiedPvs.Manual); }
/// <summary> /// Obfuscates an <see cref="CDP4Common.DTO.ParameterSubscriptionValueSet" /> object /// </summary> /// <param name="thing">The <see cref="CDP4Common.DTO.ParameterValueSetBase" /> to obfuscate.</param> private void ObfuscateSubscriptionValueSet(ParameterSubscriptionValueSet thing) { var valueArrayCount = thing.Manual.Count; var newList = new List <string>(); for (var i = 0; i < valueArrayCount; i++) { newList.Add("-"); } var newArray = new ValueArray <string>(newList); thing.Manual = newArray; thing.ValueSwitch = ParameterSwitchKind.MANUAL; this.obfuscatedCache.Add(thing.Iid); }
/// <summary> /// Creates ParameterSubscriptionValueSets for the supplied ParameterValueSets. /// </summary> /// <param name="thing"> /// The <see cref="Thing"/> instance that will be inspected. /// </param> /// <param name="container"> /// The container instance of the <see cref="Thing"/> that is inspected. /// </param> /// <param name="transaction"> /// The current transaction to the database. /// </param> /// <param name="partition"> /// The database partition (schema) where the requested resource will be stored. /// </param> /// <param name="securityContext"> /// The security-context /// </param> private void CreateParameterSubscriptionValueSets( ParameterSubscription thing, Thing container, NpgsqlTransaction transaction, string partition, ISecurityContext securityContext) { if (!(container is CDP4Common.DTO.ParameterOrOverrideBase parameterOrOverrideBase)) { throw new InvalidOperationException("The container of a ParameterSubscription can only be a ParameterOrOverrideBase."); } var paramContainer = container is CDP4Common.DTO.Parameter ? (ParameterOrOverrideBase)this.ParameterService.GetShallow(transaction, partition, new[] { container.Iid }, securityContext).OfType <CDP4Common.DTO.Parameter>().SingleOrDefault() : this.ParameterOverrideService.GetShallow(transaction, partition, new[] { container.Iid }, securityContext).OfType <CDP4Common.DTO.ParameterOverride>().SingleOrDefault(); if (paramContainer == null || !paramContainer.ValueSets.Any()) { throw new InvalidOperationException($"Could not determine the value-set to subscribe on for the parameter-subscription {thing.Iid} to create on parameter/override {container.Iid}"); } var parameterValueSets = parameterOrOverrideBase is CDP4Common.DTO.Parameter ? this.ParameterValueSetService.GetShallow(transaction, partition, paramContainer.ValueSets, securityContext).OfType <CDP4Common.DTO.ParameterValueSetBase>().ToArray() : this.ParameterOverrideValueSetService.GetShallow(transaction, partition, paramContainer.ValueSets, securityContext).OfType <CDP4Common.DTO.ParameterValueSetBase>().ToArray(); foreach (var parameterValueSet in parameterValueSets) { var parameterSubscriptionValueSet = new ParameterSubscriptionValueSet(Guid.NewGuid(), 0) { SubscribedValueSet = parameterValueSet.Iid, ValueSwitch = ParameterSwitchKind.COMPUTED }; var valueArray = new ValueArray <string>(this.DefaultValueArrayFactory.CreateDefaultValueArray(parameterValueSet.Manual.Count)); parameterSubscriptionValueSet.Manual = valueArray; this.ParameterSubscriptionValueSetService.CreateConcept( transaction, partition, parameterSubscriptionValueSet, thing); } }
/// <summary> /// Update a database record from the supplied data transfer object. /// </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 updated. /// </param> /// <param name="parameterSubscriptionValueSet"> /// The ParameterSubscriptionValueSet DTO that is to be updated. /// </param> /// <param name="container"> /// The container of the DTO to be updated. /// </param> /// <returns> /// True if the concept was successfully updated. /// </returns> public virtual bool Update(NpgsqlTransaction transaction, string partition, CDP4Common.DTO.ParameterSubscriptionValueSet parameterSubscriptionValueSet, CDP4Common.DTO.Thing container = null) { bool isHandled; var valueTypeDictionaryAdditions = new Dictionary <string, string>(); var beforeUpdate = this.BeforeUpdate(transaction, partition, parameterSubscriptionValueSet, container, out isHandled, valueTypeDictionaryAdditions); if (!isHandled) { beforeUpdate = beforeUpdate && base.Update(transaction, partition, parameterSubscriptionValueSet, container); var valueTypeDictionaryContents = new Dictionary <string, string> { { "Manual", !this.IsDerived(parameterSubscriptionValueSet, "Manual") ? parameterSubscriptionValueSet.Manual.ToHstoreString() : string.Empty }, { "ValueSwitch", !this.IsDerived(parameterSubscriptionValueSet, "ValueSwitch") ? parameterSubscriptionValueSet.ValueSwitch.ToString() : string.Empty }, }.Concat(valueTypeDictionaryAdditions).ToDictionary(kvp => kvp.Key, kvp => kvp.Value); using (var command = new NpgsqlCommand()) { var sqlBuilder = new System.Text.StringBuilder(); sqlBuilder.AppendFormat("UPDATE \"{0}\".\"ParameterSubscriptionValueSet\"", partition); sqlBuilder.AppendFormat(" SET (\"ValueTypeDictionary\", \"Container\", \"SubscribedValueSet\")"); sqlBuilder.AppendFormat(" = (:valueTypeDictionary, :container, :subscribedValueSet)"); sqlBuilder.AppendFormat(" WHERE \"Iid\" = :iid;"); command.Parameters.Add("iid", NpgsqlDbType.Uuid).Value = parameterSubscriptionValueSet.Iid; command.Parameters.Add("valueTypeDictionary", NpgsqlDbType.Hstore).Value = valueTypeDictionaryContents; command.Parameters.Add("container", NpgsqlDbType.Uuid).Value = container.Iid; command.Parameters.Add("subscribedValueSet", NpgsqlDbType.Uuid).Value = !this.IsDerived(parameterSubscriptionValueSet, "SubscribedValueSet") ? parameterSubscriptionValueSet.SubscribedValueSet : Utils.NullableValue(null); command.CommandText = sqlBuilder.ToString(); command.Connection = transaction.Connection; command.Transaction = transaction; this.ExecuteAndLogCommand(command); } } return(this.AfterUpdate(beforeUpdate, transaction, partition, parameterSubscriptionValueSet, container)); }
/// <summary> /// Insert a new database record, or updates one if it already exists from the supplied data transfer object. /// 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="parameterSubscriptionValueSet"> /// The parameterSubscriptionValueSet DTO that is to be persisted. /// </param> /// <param name="container"> /// The container of the DTO to be persisted. /// </param> /// <returns> /// True if the concept was successfully persisted. /// </returns> public virtual bool Upsert(NpgsqlTransaction transaction, string partition, CDP4Common.DTO.ParameterSubscriptionValueSet parameterSubscriptionValueSet, CDP4Common.DTO.Thing container = null) { var valueTypeDictionaryAdditions = new Dictionary <string, string>(); base.Upsert(transaction, partition, parameterSubscriptionValueSet, container); var valueTypeDictionaryContents = new Dictionary <string, string> { { "Manual", !this.IsDerived(parameterSubscriptionValueSet, "Manual") ? parameterSubscriptionValueSet.Manual.ToHstoreString() : string.Empty }, { "ValueSwitch", !this.IsDerived(parameterSubscriptionValueSet, "ValueSwitch") ? parameterSubscriptionValueSet.ValueSwitch.ToString() : string.Empty }, }.Concat(valueTypeDictionaryAdditions).ToDictionary(kvp => kvp.Key, kvp => kvp.Value); using (var command = new NpgsqlCommand()) { var sqlBuilder = new System.Text.StringBuilder(); sqlBuilder.AppendFormat("INSERT INTO \"{0}\".\"ParameterSubscriptionValueSet\"", partition); sqlBuilder.AppendFormat(" (\"Iid\", \"ValueTypeDictionary\", \"Container\", \"SubscribedValueSet\")"); sqlBuilder.AppendFormat(" VALUES (:iid, :valueTypeDictionary, :container, :subscribedValueSet)"); command.Parameters.Add("iid", NpgsqlDbType.Uuid).Value = parameterSubscriptionValueSet.Iid; command.Parameters.Add("valueTypeDictionary", NpgsqlDbType.Hstore).Value = valueTypeDictionaryContents; command.Parameters.Add("container", NpgsqlDbType.Uuid).Value = container.Iid; command.Parameters.Add("subscribedValueSet", NpgsqlDbType.Uuid).Value = !this.IsDerived(parameterSubscriptionValueSet, "SubscribedValueSet") ? parameterSubscriptionValueSet.SubscribedValueSet : Utils.NullableValue(null); sqlBuilder.Append(" ON CONFLICT (\"Iid\")"); sqlBuilder.Append(" DO UPDATE "); sqlBuilder.Append(" SET (\"ValueTypeDictionary\", \"Container\", \"SubscribedValueSet\")"); sqlBuilder.Append(" = (:valueTypeDictionary, :container, :subscribedValueSet);"); command.CommandText = sqlBuilder.ToString(); command.Connection = transaction.Connection; command.Transaction = transaction; this.ExecuteAndLogCommand(command); } return(true); }
/// <summary> /// Set the values of the <see cref="Dto.ParameterSubscriptionValueSet"/> with the values of a original <see cref="ParameterSubscriptionValueSet"/> /// </summary> /// <param name="valueSet">The <see cref="Dto.ParameterSubscriptionValueSet"/></param> /// <param name="originalValueSet">The <see cref="ParameterSubscriptionValueSet"/></param> private void SetValueSetValues(Dto.ParameterSubscriptionValueSet valueSet, ParameterSubscriptionValueSet originalValueSet) { valueSet.Manual = originalValueSet.Manual; valueSet.ValueSwitch = originalValueSet.ValueSwitch; }
public void VerifyThatAfterUpdateUpdateTheOVerrideAndSubscription() { var valueset = new ParameterValueSet(Guid.NewGuid(), 0); valueset.Manual = new ValueArray <string>(new[] { "set" }); valueset.Published = new ValueArray <string>(new[] { "set" }); valueset.Computed = new ValueArray <string>(new[] { "set" }); valueset.ValueSwitch = ParameterSwitchKind.REFERENCE; this.parameter.ValueSet.Add(valueset.Iid); this.OldParameterContextProvider.Setup(x => x.GetsourceValueSet(null, It.IsAny <Guid?>())).Returns(valueset); var overrideValueSet = new ParameterOverrideValueSet(Guid.NewGuid(), 1); overrideValueSet.ParameterValueSet = valueset.Iid; overrideValueSet.Manual = new ValueArray <string>(new[] { "override" }); overrideValueSet.Published = new ValueArray <string>(new[] { "override" }); overrideValueSet.Computed = new ValueArray <string>(new[] { "override" }); overrideValueSet.ValueSwitch = ParameterSwitchKind.REFERENCE; this.parameterOverride.ValueSet.Add(overrideValueSet.Iid); var subscription1 = new ParameterSubscription(Guid.NewGuid(), 1); var subscription2 = new ParameterSubscription(Guid.NewGuid(), 2); var subscription1ValueSet = new ParameterSubscriptionValueSet(Guid.NewGuid(), 1); subscription1ValueSet.Manual = new ValueArray <string>(new [] { "sub1" }); subscription1ValueSet.SubscribedValueSet = valueset.Iid; var subscription2ValueSet = new ParameterSubscriptionValueSet(Guid.NewGuid(), 1); subscription2ValueSet.Manual = new ValueArray <string>(new[] { "sub2" }); subscription2ValueSet.SubscribedValueSet = overrideValueSet.Iid; subscription1.ValueSet.Add(subscription1ValueSet.Iid); subscription2.ValueSet.Add(subscription2ValueSet.Iid); 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.parameterOverrideValueSetService .Setup(x => x.GetShallow(null, "partition", It.Is <IEnumerable <Guid> >(y => y.Contains(overrideValueSet.Iid)), this.securityContext.Object)) .Returns(new[] { overrideValueSet }); this.parameterSubscriptionValueSetService .Setup(x => x.GetShallow(null, "partition", It.Is <IEnumerable <Guid> >(y => y.Contains(subscription1ValueSet.Iid)), this.securityContext.Object)) .Returns(new[] { subscription1ValueSet }); this.parameterSubscriptionValueSetService .Setup(x => x.GetShallow(null, "partition", It.Is <IEnumerable <Guid> >(y => y.Contains(subscription2ValueSet.Iid)), this.securityContext.Object)) .Returns(new[] { subscription2ValueSet }); this.parameter.ParameterType = this.cptParameterType.Iid; this.parameter.StateDependence = null; 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.valueSetService.Verify(x => x.CreateConcept(this.npgsqlTransaction, "partition", It.Is <ParameterValueSet>(y => y.Manual.Contains("set")), updatedParameter, -1), Times.Exactly(2)); this.parameterOverrideValueSetService.Verify(x => x.CreateConcept(this.npgsqlTransaction, "partition", It.Is <ParameterOverrideValueSet>(y => y.Manual.Contains("override")), this.parameterOverride, -1), Times.Exactly(2)); this.parameterSubscriptionValueSetService.Verify(x => x.CreateConcept(this.npgsqlTransaction, "partition", It.Is <ParameterSubscriptionValueSet>(y => y.Manual.Contains("sub1")), subscription1, -1), Times.Exactly(2)); this.parameterSubscriptionValueSetService.Verify(x => x.CreateConcept(this.npgsqlTransaction, "partition", It.Is <ParameterSubscriptionValueSet>(y => y.Manual.Contains("sub2")), subscription2, -1), Times.Exactly(2)); }