/// <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="parameterOverrideValueSet">
/// The ParameterOverrideValueSet 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.ParameterOverrideValueSet parameterOverrideValueSet, CDP4Common.DTO.Thing container = null)
{
bool isHandled;
var valueTypeDictionaryAdditions = new Dictionary <string, string>();
var beforeUpdate = this.BeforeUpdate(transaction, partition, parameterOverrideValueSet, container, out isHandled, valueTypeDictionaryAdditions);
if (!isHandled)
{
beforeUpdate = beforeUpdate && base.Update(transaction, partition, parameterOverrideValueSet, container);
using (var command = new NpgsqlCommand())
{
var sqlBuilder = new System.Text.StringBuilder();
sqlBuilder.AppendFormat("UPDATE \"{0}\".\"ParameterOverrideValueSet\"", partition);
sqlBuilder.AppendFormat(" SET (\"Container\", \"ParameterValueSet\")");
sqlBuilder.AppendFormat(" = (:container, :parameterValueSet)");
sqlBuilder.AppendFormat(" WHERE \"Iid\" = :iid;");
command.Parameters.Add("iid", NpgsqlDbType.Uuid).Value = parameterOverrideValueSet.Iid;
command.Parameters.Add("container", NpgsqlDbType.Uuid).Value = container.Iid;
command.Parameters.Add("parameterValueSet", NpgsqlDbType.Uuid).Value = !this.IsDerived(parameterOverrideValueSet, "ParameterValueSet") ? parameterOverrideValueSet.ParameterValueSet : Utils.NullableValue(null);
command.CommandText = sqlBuilder.ToString();
command.Connection = transaction.Connection;
command.Transaction = transaction;
this.ExecuteAndLogCommand(command);
}
}
return(this.AfterUpdate(beforeUpdate, transaction, partition, parameterOverrideValueSet, 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="parameterOverrideValueSet">
/// The parameterOverrideValueSet 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.ParameterOverrideValueSet parameterOverrideValueSet, CDP4Common.DTO.Thing container = null)
{
var valueTypeDictionaryAdditions = new Dictionary <string, string>();
base.Upsert(transaction, partition, parameterOverrideValueSet, container);
using (var command = new NpgsqlCommand())
{
var sqlBuilder = new System.Text.StringBuilder();
sqlBuilder.AppendFormat("INSERT INTO \"{0}\".\"ParameterOverrideValueSet\"", partition);
sqlBuilder.AppendFormat(" (\"Iid\", \"Container\", \"ParameterValueSet\")");
sqlBuilder.AppendFormat(" VALUES (:iid, :container, :parameterValueSet)");
command.Parameters.Add("iid", NpgsqlDbType.Uuid).Value = parameterOverrideValueSet.Iid;
command.Parameters.Add("container", NpgsqlDbType.Uuid).Value = container.Iid;
command.Parameters.Add("parameterValueSet", NpgsqlDbType.Uuid).Value = !this.IsDerived(parameterOverrideValueSet, "ParameterValueSet") ? parameterOverrideValueSet.ParameterValueSet : Utils.NullableValue(null);
sqlBuilder.Append(" ON CONFLICT (\"Iid\")");
sqlBuilder.Append(" DO UPDATE ");
sqlBuilder.Append(" SET (\"Container\", \"ParameterValueSet\")");
sqlBuilder.Append(" = (:container, :parameterValueSet);");
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.ParameterOverrideValueSet"/>.
/// </returns>
public virtual CDP4Common.DTO.ParameterOverrideValueSet MapToDto(NpgsqlDataReader reader)
{
string tempModifiedOn;
string tempPublished;
string tempFormula;
string tempComputed;
string tempManual;
string tempReference;
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.ParameterOverrideValueSet(iid, revisionNumber);
dto.ExcludedPerson.AddRange(Array.ConvertAll((string[])reader["ExcludedPerson"], Guid.Parse));
dto.ExcludedDomain.AddRange(Array.ConvertAll((string[])reader["ExcludedDomain"], Guid.Parse));
dto.ParameterValueSet = Guid.Parse(reader["ParameterValueSet"].ToString());
if (valueDict.TryGetValue("ModifiedOn", out tempModifiedOn))
{
dto.ModifiedOn = Utils.ParseUtcDate(tempModifiedOn);
}
if (valueDict.TryGetValue("Published", out tempPublished))
{
dto.Published = tempPublished.FromHstoreToValueArray <string>();
}
if (valueDict.TryGetValue("Formula", out tempFormula))
{
dto.Formula = tempFormula.FromHstoreToValueArray <string>();
}
if (valueDict.TryGetValue("Computed", out tempComputed))
{
dto.Computed = tempComputed.FromHstoreToValueArray <string>();
}
if (valueDict.TryGetValue("Manual", out tempManual))
{
dto.Manual = tempManual.FromHstoreToValueArray <string>();
}
if (valueDict.TryGetValue("Reference", out tempReference))
{
dto.Reference = tempReference.FromHstoreToValueArray <string>();
}
if (valueDict.TryGetValue("ValueSwitch", out tempValueSwitch))
{
dto.ValueSwitch = Utils.ParseEnum <CDP4Common.EngineeringModelData.ParameterSwitchKind>(tempValueSwitch);
}
return(dto);
}
/// <summary>
/// Create a new <see cref="ParameterOverrideValueSet"/> from the old values
/// </summary>
/// <param name="oldValue">The old <see cref="ParameterOverrideValueSet"/></param>
/// <param name="parameterValueSet">The <see cref="ParameterValueSet"/></param>
/// <param name="container">The <see cref="ParameterOverride"/></param>
/// <param name="transaction">The current transaction</param>
/// <param name="partition">The current partition</param>
/// <returns>The new <see cref="ParameterOverrideValueSet"/></returns>
private ParameterOverrideValueSet CreateParameterOverrideValueSet(ParameterOverrideValueSet oldValue, ParameterValueSet parameterValueSet, ParameterOverride container, NpgsqlTransaction transaction, string partition)
{
var isOldValueNull = oldValue == null;
var newValueSet = new ParameterOverrideValueSet(Guid.NewGuid(), 1)
{
Manual = new ValueArray <string>(isOldValueNull ? parameterValueSet.Manual : oldValue.Manual),
Computed = new ValueArray <string>(isOldValueNull ? parameterValueSet.Computed : oldValue.Computed),
Reference = new ValueArray <string>(isOldValueNull ? parameterValueSet.Reference : oldValue.Reference),
Published = new ValueArray <string>(isOldValueNull ? parameterValueSet.Published : oldValue.Published),
Formula = new ValueArray <string>(isOldValueNull ? parameterValueSet.Formula : oldValue.Formula),
ParameterValueSet = parameterValueSet.Iid,
ValueSwitch = isOldValueNull ? CDP4Common.EngineeringModelData.ParameterSwitchKind.MANUAL : oldValue.ValueSwitch
};
this.ParameterOverrideValueSetService.CreateConcept(transaction, partition, newValueSet, container);
return(newValueSet);
}
public void VerifyCopyElementDefWorks()
{
var modelSetupService = new Mock <IEngineeringModelSetupService>();
var modelSetup = new EngineeringModelSetup(Guid.NewGuid(), 0);
modelSetupService.Setup(x => x.GetEngineeringModelSetup(It.IsAny <NpgsqlTransaction>(), It.IsAny <Guid>())).Returns(modelSetup);
this.copySourceDtos = new List <Thing>();
var boolParamTypeId = Guid.NewGuid();
var mrdl = new ModelReferenceDataLibrary(Guid.NewGuid(), 1);
mrdl.ParameterType.Add(boolParamTypeId);
var sourceIteration = new Iteration(Guid.NewGuid(), 1);
var sourceElementDef1 = new ElementDefinition(Guid.NewGuid(), 1);
var sourceElementDef2 = new ElementDefinition(Guid.NewGuid(), 1);
var sourceUsage1 = new ElementUsage(Guid.NewGuid(), 1)
{
ElementDefinition = sourceElementDef2.Iid
};
sourceElementDef1.ContainedElement.Add(sourceUsage1.Iid);
sourceIteration.Element.Add(sourceElementDef1.Iid);
sourceIteration.Element.Add(sourceElementDef2.Iid);
var parameter1 = new Parameter(Guid.NewGuid(), 1)
{
ParameterType = boolParamTypeId
};
var pvs1 = new ParameterValueSet(Guid.NewGuid(), 1)
{
Manual = new ValueArray <string>(new[] { "true" }),
Computed = new ValueArray <string>(new[] { "-" }),
Reference = new ValueArray <string>(new[] { "-" }),
Published = new ValueArray <string>(new[] { "-" }),
ValueSwitch = ParameterSwitchKind.MANUAL
};
var parameter2 = new Parameter(Guid.NewGuid(), 1)
{
ParameterType = boolParamTypeId
};
var pvs2 = new ParameterValueSet(Guid.NewGuid(), 1)
{
Manual = new ValueArray <string>(new[] { "true" }),
Computed = new ValueArray <string>(new[] { "-" }),
Reference = new ValueArray <string>(new[] { "-" }),
Published = new ValueArray <string>(new[] { "-" }),
ValueSwitch = ParameterSwitchKind.MANUAL
};
parameter1.ValueSet.Add(pvs1.Iid);
sourceElementDef1.Parameter.Add(parameter1.Iid);
parameter2.ValueSet.Add(pvs2.Iid);
sourceElementDef2.Parameter.Add(parameter2.Iid);
var override2 = new ParameterOverride(Guid.NewGuid(), 1);
override2.Parameter = parameter2.Iid;
var ovs = new ParameterOverrideValueSet(Guid.NewGuid(), 1)
{
ParameterValueSet = pvs2.Iid
};
override2.ValueSet.Add(ovs.Iid);
sourceUsage1.ParameterOverride.Add(override2.Iid);
this.copySourceDtos.Add(sourceIteration);
this.copySourceDtos.Add(sourceElementDef1);
this.copySourceDtos.Add(sourceElementDef2);
this.copySourceDtos.Add(sourceUsage1);
this.copySourceDtos.Add(parameter1);
this.copySourceDtos.Add(pvs1);
this.copySourceDtos.Add(parameter2);
this.copySourceDtos.Add(pvs2);
this.copySourceDtos.Add(override2);
this.copySourceDtos.Add(ovs);
var targetIteration = new Iteration(Guid.NewGuid(), 1);
this.serviceProvider.Setup(x => x.MapToReadService(It.IsAny <string>())).Returns <string>(x => new TestSourceService(this.copySourceDtos, x));
this.serviceProvider.Setup(x => x.MapToReadService(It.Is <string>(t => t == ClassKind.ModelReferenceDataLibrary.ToString())))
.Returns <string>(x => new TestSourceService(new List <Thing> {
mrdl
}, x));
this.serviceProvider.Setup(x => x.MapToReadService(It.Is <string>(t => t == ClassKind.Iteration.ToString())))
.Returns <string>(x => new TestSourceService(new List <Thing> {
sourceIteration, targetIteration
}, x));
var customOperationSideEffectProcessor = new Mock <IOperationSideEffectProcessor>();
customOperationSideEffectProcessor.Setup(x => x.BeforeCreate(It.IsAny <Thing>(), It.IsAny <Thing>(), It.IsAny <NpgsqlTransaction>(), It.IsAny <string>(), It.IsAny <ISecurityContext>())).
Returns(true);
var paramSubscriptionService = new ParameterSubscriptionService
{
ParameterSubscriptionDao = new Mock <IParameterSubscriptionDao>().Object,
PermissionService = this.permissionService.Object,
};
var parameterContextProvider = new OldParameterContextProvider
{
ParameterValueSetService = new TestSourceService(this.copySourceDtos, ClassKind.ParameterValueSet.ToString())
};
var paramGroupService = new ParameterGroupService
{
PermissionService = this.permissionService.Object,
TransactionManager = this.transactionManager.Object,
ParameterGroupDao = new Mock <IParameterGroupDao>().Object
};
var valueSetService = new Mock <IParameterValueSetService>();
valueSetService.Setup(x => x.GetShallow(It.IsAny <NpgsqlTransaction>(), It.IsAny <string>(), It.IsAny <IEnumerable <Guid> >(), It.IsAny <ISecurityContext>()))
.Returns <NpgsqlTransaction, string, IEnumerable <Guid>, ISecurityContext>((a, b, c, d) =>
{
var list = new List <ParameterValueSet>();
foreach (var guid in c)
{
var vs = new ParameterValueSet(guid, 1)
{
Manual = new ValueArray <string>(new [] { "-" }),
Computed = new ValueArray <string>(new [] { "-" }),
Reference = new ValueArray <string>(new [] { "-" }),
Published = new ValueArray <string>(new [] { "-" })
};
list.Add(vs);
}
return(list);
});
var overrideValueSetService = new Mock <IParameterOverrideValueSetService>();
overrideValueSetService.Setup(x => x.GetShallow(It.IsAny <NpgsqlTransaction>(), It.IsAny <string>(), It.IsAny <IEnumerable <Guid> >(), It.IsAny <ISecurityContext>()))
.Returns <NpgsqlTransaction, string, IEnumerable <Guid>, ISecurityContext>((a, b, c, d) =>
{
var list = new List <ParameterOverrideValueSet>();
foreach (var guid in c)
{
var vs = new ParameterOverrideValueSet(guid, 1)
{
Manual = new ValueArray <string>(new[] { "-" }),
Computed = new ValueArray <string>(new[] { "-" }),
Reference = new ValueArray <string>(new[] { "-" }),
Published = new ValueArray <string>(new[] { "-" })
};
list.Add(vs);
}
return(list);
});
var paramDao = new TestParameterDao();
var paramService = new ParameterService
{
PermissionService = this.permissionService.Object,
ParameterDao = paramDao,
OperationSideEffectProcessor = customOperationSideEffectProcessor.Object,
TransactionManager = this.transactionManager.Object,
OldParameterContextProvider = parameterContextProvider,
ParameterSubscriptionService = paramSubscriptionService,
ParameterValueSetService = valueSetService.Object
};
var paramOverrideDao = new TestParameterOverrideDao();
var paramOverrideService = new ParameterOverrideService
{
PermissionService = this.permissionService.Object,
ParameterOverrideDao = paramOverrideDao,
TransactionManager = this.transactionManager.Object,
OperationSideEffectProcessor = customOperationSideEffectProcessor.Object,
ParameterSubscriptionService = paramSubscriptionService,
ParameterOverrideValueSetService = overrideValueSetService.Object
};
var usageDao = new Mock <IElementUsageDao>();
var usageService = new ElementUsageService
{
PermissionService = this.permissionService.Object,
ParameterOverrideService = paramOverrideService,
ElementUsageDao = usageDao.Object,
TransactionManager = this.transactionManager.Object,
OperationSideEffectProcessor = customOperationSideEffectProcessor.Object
};
var edDao = new TestElementDefinitionDao();
var edService = new ElementDefinitionService
{
PermissionService = this.permissionService.Object,
ElementDefinitionDao = edDao,
ElementUsageService = usageService,
ParameterService = paramService,
TransactionManager = this.transactionManager.Object,
OperationSideEffectProcessor = customOperationSideEffectProcessor.Object,
ParameterGroupService = paramGroupService
};
this.serviceProvider.Setup(x => x.MapToPersitableService(ClassKind.ElementDefinition.ToString())).Returns(edService);
this.serviceProvider.Setup(x => x.MapToPersitableService(ClassKind.ElementUsage.ToString())).Returns(usageService);
this.serviceProvider.Setup(x => x.MapToPersitableService(ClassKind.Parameter.ToString())).Returns(paramService);
this.serviceProvider.Setup(x => x.MapToPersitableService(ClassKind.ParameterOverride.ToString())).Returns(paramOverrideService);
this.serviceProvider.Setup(x => x.MapToPersitableService(ClassKind.ParameterSubscription.ToString())).Returns(paramSubscriptionService);
this.serviceProvider.Setup(x => x.MapToPersitableService(ClassKind.ParameterGroup.ToString())).Returns(paramGroupService);
var postOperation = new CdpPostOperation();
var copyinfo = new CopyInfo
{
ActiveOwner = Guid.NewGuid(),
Options = new CopyInfoOptions
{
CopyKind = CopyKind.Deep,
KeepOwner = true,
KeepValues = true
},
Source = new CopySource
{
IterationId = sourceIteration.Iid,
Thing = new CopyReference
{
Iid = sourceElementDef1.Iid,
ClassKind = ClassKind.ElementDefinition
},
TopContainer = new CopyReference
{
Iid = Guid.NewGuid(),
ClassKind = ClassKind.EngineeringModel
}
},
Target = new CopyTarget
{
IterationId = targetIteration.Iid,
Container = new CopyReference
{
Iid = targetIteration.Iid,
ClassKind = ClassKind.Iteration
},
TopContainer = new CopyReference
{
Iid = Guid.NewGuid(),
ClassKind = ClassKind.EngineeringModel
}
}
};
postOperation.Copy.Add(copyinfo);
this.serviceProvider.Setup(x => x.MapToReadService(ClassKind.EngineeringModelSetup.ToString())).Returns(modelSetupService.Object);
this.operationProcessor.Process(postOperation, null, $"Iteration_{targetIteration.Iid.ToString().Replace("-", "_")}", null);
Assert.AreEqual(2, edDao.WrittenThingCount);
Assert.AreEqual(2, paramDao.WrittenThingCount);
Assert.AreEqual(1, paramOverrideDao.WrittenThingCount);
usageDao.Verify(x => x.Write(It.IsAny <NpgsqlTransaction>(), It.IsAny <string>(), It.IsAny <ElementUsage>(), It.IsAny <Thing>()), Times.Once);
}
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));
}
