/// <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="parameterSubscription"> /// The ParameterSubscription 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.ParameterSubscription parameterSubscription, CDP4Common.DTO.Thing container = null) { bool isHandled; var valueTypeDictionaryAdditions = new Dictionary <string, string>(); var beforeUpdate = this.BeforeUpdate(transaction, partition, parameterSubscription, container, out isHandled, valueTypeDictionaryAdditions); if (!isHandled) { beforeUpdate = beforeUpdate && base.Update(transaction, partition, parameterSubscription, container); using (var command = new NpgsqlCommand()) { var sqlBuilder = new System.Text.StringBuilder(); sqlBuilder.AppendFormat("UPDATE \"{0}\".\"ParameterSubscription\"", partition); sqlBuilder.AppendFormat(" SET \"Container\""); sqlBuilder.AppendFormat(" = :container"); sqlBuilder.AppendFormat(" WHERE \"Iid\" = :iid;"); command.Parameters.Add("iid", NpgsqlDbType.Uuid).Value = parameterSubscription.Iid; command.Parameters.Add("container", NpgsqlDbType.Uuid).Value = container.Iid; command.CommandText = sqlBuilder.ToString(); command.Connection = transaction.Connection; command.Transaction = transaction; this.ExecuteAndLogCommand(command); } } return(this.AfterUpdate(beforeUpdate, transaction, partition, parameterSubscription, 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="parameterSubscription"> /// The parameterSubscription 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.ParameterSubscription parameterSubscription, CDP4Common.DTO.Thing container = null) { var valueTypeDictionaryAdditions = new Dictionary <string, string>(); base.Upsert(transaction, partition, parameterSubscription, container); using (var command = new NpgsqlCommand()) { var sqlBuilder = new System.Text.StringBuilder(); sqlBuilder.AppendFormat("INSERT INTO \"{0}\".\"ParameterSubscription\"", partition); sqlBuilder.AppendFormat(" (\"Iid\", \"Container\")"); sqlBuilder.AppendFormat(" VALUES (:iid, :container)"); command.Parameters.Add("iid", NpgsqlDbType.Uuid).Value = parameterSubscription.Iid; command.Parameters.Add("container", NpgsqlDbType.Uuid).Value = container.Iid; sqlBuilder.Append(" ON CONFLICT (\"Iid\")"); sqlBuilder.Append(" DO UPDATE "); sqlBuilder.Append(" SET \"Container\""); sqlBuilder.Append(" = :container;"); command.CommandText = sqlBuilder.ToString(); command.Connection = transaction.Connection; command.Transaction = transaction; this.ExecuteAndLogCommand(command); } return(true); }
/// <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.ParameterSubscription"/>. /// </returns> public virtual CDP4Common.DTO.ParameterSubscription MapToDto(NpgsqlDataReader reader) { string tempModifiedOn; string tempThingPreference; 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.ParameterSubscription(iid, revisionNumber); dto.ExcludedDomain.AddRange(Array.ConvertAll((string[])reader["ExcludedDomain"], Guid.Parse)); dto.ExcludedPerson.AddRange(Array.ConvertAll((string[])reader["ExcludedPerson"], Guid.Parse)); dto.Owner = Guid.Parse(reader["Owner"].ToString()); dto.ValueSet.AddRange(Array.ConvertAll((string[])reader["ValueSet"], Guid.Parse)); if (valueDict.TryGetValue("ModifiedOn", out tempModifiedOn)) { dto.ModifiedOn = Utils.ParseUtcDate(tempModifiedOn); } if (valueDict.TryGetValue("ThingPreference", out tempThingPreference) && tempThingPreference != null) { dto.ThingPreference = tempThingPreference.UnEscape(); } return(dto); }
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 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> /// Update a <see cref="ParameterSubscription"/> with new <see cref="CDP4Common.DTO.ParameterSubscriptionValueSet"/> /// </summary> /// <param name="parameterSubscription">The <see cref="ParameterSubscription"/></param> /// <param name="transaction">The current transaction</param> /// <param name="partition">The current partition</param> /// <param name="securityContext">The security context</param> /// <param name="newOldValueSetBaseMap">The map linking the old subscribed <see cref="ParameterValueSetBase"/> to the new ones</param> private void UpdateParameterSubscription(ParameterSubscription parameterSubscription, NpgsqlTransaction transaction, string partition, ISecurityContext securityContext, IReadOnlyDictionary <ParameterValueSetBase, ParameterValueSetBase> newOldValueSetBaseMap) { var oldValueSets = this.ParameterSubscriptionValueSetService.GetShallow(transaction, partition, parameterSubscription.ValueSet, securityContext) .Where(i => i is ParameterSubscriptionValueSet).Cast <ParameterSubscriptionValueSet>().ToList(); foreach (var newOldParameterValueSetPair in newOldValueSetBaseMap) { if (newOldParameterValueSetPair.Value != null) { var oldValueSet = oldValueSets.SingleOrDefault(x => x.SubscribedValueSet == newOldParameterValueSetPair.Value.Iid); this.CreateParameterSubscriptionValueSet(oldValueSet, newOldParameterValueSetPair.Key, parameterSubscription, transaction, partition); } else { this.CreateParameterSubscriptionValueSet(null, newOldParameterValueSetPair.Key, parameterSubscription, transaction, partition); } } }
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)); }
/// <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); }