public async Task VerifyThatSessionMustBeSetToReadIteration()
{
var iterationDto = new CDP4Common.DTO.Iteration(Guid.NewGuid(), 0);
var dal = new CdpServicesDal();
Assert.That(async() => await dal.Read(iterationDto, new CancellationToken()), Throws.TypeOf <InvalidOperationException>());
}
/// <summary>
/// Retrieves all data necessary for the transfer of an iteration
/// </summary>
/// <param name="iteration">The <see cref="Iteration"/></param>
/// <param name="siteDirectoryData">All SiteDirectory DTOs</param>
/// <param name="zip">The zip file</param>
/// <param name="siteDir">The <see cref="SiteDirectory"/> object</param>
/// <returns>List of things relevant for a particular iteration</returns>
private List <Thing> RetrieveIterationThings(CDP4Common.DTO.Iteration iteration, List <Thing> siteDirectoryData, ZipFile zip, CDP4Common.SiteDirectoryData.SiteDirectory siteDir)
{
var engineeringModelSetup =
siteDir.Model.SingleOrDefault(x => x.IterationSetup.Any(y => y.IterationIid == iteration.Iid));
if (engineeringModelSetup == null)
{
throw new ArgumentException("Could not locate the engineeringModel setup information");
}
// read engineeringmodel
var engineeringModelFilePath = $"{engineeringModelSetup.EngineeringModelIid}.json";
var engineeringModelZipEntry =
zip.Entries.SingleOrDefault(x => x.FileName.EndsWith(engineeringModelFilePath));
var returned = this.ReadInfoFromArchiveEntry(engineeringModelZipEntry, this.Credentials.Password);
var iterationFilePath = $"{iteration.Iid}.json";
var iterationZipEntry = zip.Entries.SingleOrDefault(x => x.FileName.EndsWith(iterationFilePath));
returned.AddRange(this.ReadIterationArchiveEntry(iterationZipEntry, this.Credentials.Password));
// use the loaded sitedirectory information to determine the required model reference data library
var modelRdl = engineeringModelSetup.RequiredRdl.Single();
// add the modelRdlDto to the returned collection to make sure it's content gets dereferenced
if (returned.All(x => x.Iid != modelRdl.Iid))
{
var modelRdlDto = siteDirectoryData.Single(x => x.Iid == modelRdl.Iid);
returned.Add(modelRdlDto);
}
// based on engineering model setup load rdl chain
var modelRdlFilePath = $"{modelRdl.Iid}.json";
var modelRdlZipEntry = zip.Entries.SingleOrDefault(x => x.FileName.EndsWith(modelRdlFilePath));
var modelRdlItems = this.ReadInfoFromArchiveEntry(modelRdlZipEntry, this.Credentials.Password);
returned.AddRange(modelRdlItems);
// load the reference data libraries as per the containment chain
var requiredRdl = modelRdl.RequiredRdl;
while (requiredRdl != null)
{
// add the rdlDto to the returned collection to make sure it's content gets dereferenced
var requiredRdlDto = siteDirectoryData.Single(x => x.Iid == requiredRdl.Iid);
returned.Add(requiredRdlDto);
var siteRdlFilePath = $"{requiredRdl.Iid}.json";
var siteRdlZipEntry = zip.Entries.SingleOrDefault(x => x.FileName.EndsWith(siteRdlFilePath));
var siteRdlItems = this.ReadInfoFromArchiveEntry(siteRdlZipEntry, this.Credentials.Password);
returned.AddRange(siteRdlItems);
// set the requiredRdl for the next iteration
requiredRdl = requiredRdl.RequiredRdl;
}
return(returned);
}
public void SetUp()
{
RxApp.MainThreadScheduler = Scheduler.CurrentThread;
this.uri = new Uri("http://www.rheageoup.com");
this.SetupRecognizePackUir();
this.assembler = new Assembler(this.uri);
this.session = new Mock <ISession>();
var dtos = new List <CDP4Common.DTO.Thing>();
var siteDirectory = new CDP4Common.DTO.SiteDirectory(Guid.NewGuid(), 0);
dtos.Add(siteDirectory);
var engineeringModel = new CDP4Common.DTO.EngineeringModel(Guid.NewGuid(), 0);
dtos.Add(engineeringModel);
var iteration = new CDP4Common.DTO.Iteration(Guid.NewGuid(), 0);
engineeringModel.Iteration.Add(iteration.Iid);
dtos.Add(iteration);
this.assembler.Synchronize(dtos);
this.session.Setup(x => x.DataSourceUri).Returns("test");
this.session.Setup(x => x.Assembler).Returns(this.assembler);
this.panelNavigationService = new Mock <IPanelNavigationService>();
this.thingDialogNavigationService = new Mock <IThingDialogNavigationService>();
this.dialogNavigationService = new Mock <IDialogNavigationService>();
this.serviceLocator = new Mock <IServiceLocator>();
this.excelQuery = new Mock <IExcelQuery>();
this.excelQuery.Setup(x => x.IsActiveWorkbookAvailable(It.IsAny <NetOffice.ExcelApi.Application>())).Returns(true);
this.officeApplicationWrapper = new Mock <IOfficeApplicationWrapper>();
this.permittingPermissionService = new Mock <IPermissionService>();
this.permittingPermissionService.Setup(x => x.CanRead(It.IsAny <Thing>())).Returns(true);
this.permittingPermissionService.Setup(x => x.CanWrite(It.IsAny <Thing>())).Returns(true);
this.pluginSettingsService = new Mock <IPluginSettingsService>();
this.amountOfRibbonControls = 10;
this.order = 1;
this.ribbonPart = new ParameterSheetGeneratorRibbonPart(this.order, this.panelNavigationService.Object, this.thingDialogNavigationService.Object, this.dialogNavigationService.Object, this.pluginSettingsService.Object, this.officeApplicationWrapper.Object);
ServiceLocator.SetLocatorProvider(() => this.serviceLocator.Object);
this.serviceLocator.Setup(x => x.GetInstance <IThingDialogNavigationService>())
.Returns(this.thingDialogNavigationService.Object);
}
/// <summary>
/// Update a <see cref="Parameter"/> with new <see cref="ParameterValueSet"/>
/// </summary>
/// <param name="parameter">The <see cref="Parameter"/></param>
/// <param name="iteration">The <see cref="Iteration"/></param>
/// <param name="transaction">The current transaction</param>
/// <param name="partition">The current partition</param>
/// <param name="securityContext">The security context</param>
/// <param name="newOldActualStateMap">The map that links the new to old <see cref="ActualFiniteState"/></param>
/// <param name="newOldValueSetMap">The resulting map that links the new to old <see cref="ParameterValueSet"/></param>
private void UpdateParameter(Parameter parameter, Iteration iteration, NpgsqlTransaction transaction, string partition, ISecurityContext securityContext, IReadOnlyDictionary <ActualFiniteState, ActualFiniteState> newOldActualStateMap, ref Dictionary <ParameterValueSet, ParameterValueSet> newOldValueSetMap)
{
var oldValueSets = this.ParameterValueSetService.GetShallow(transaction, partition, parameter.ValueSet, securityContext)
.Where(i => i is ParameterValueSet).Cast <ParameterValueSet>().ToList();
if (parameter.IsOptionDependent)
{
foreach (var orderedItem in iteration.Option.OrderBy(x => x.K))
{
var actualOption = Guid.Parse(orderedItem.V.ToString());
this.CreateParameterValueSets(parameter, actualOption, transaction, partition, securityContext, newOldActualStateMap, oldValueSets, ref newOldValueSetMap);
}
}
else
{
this.CreateParameterValueSets(parameter, null, transaction, partition, securityContext, newOldActualStateMap, oldValueSets, ref newOldValueSetMap);
}
}
/// <summary>
/// Update a <see cref="ActualFiniteStateList"/> by allocating new <see cref="ActualFiniteState"/>
/// </summary>
/// <param name="actualFiniteStateList">The <see cref="ActualFiniteStateList"/></param>
/// <param name="iteration">The <see cref="Iteration"/></param>
/// <param name="transaction">The current <see cref="NpgsqlTransaction"/></param>
/// <param name="partition">The partition</param>
/// <param name="securityContext">The <see cref="ISecurityContext"/></param>
public void UpdateActualFinisteStateList(ActualFiniteStateList actualFiniteStateList, Iteration iteration, NpgsqlTransaction transaction, string partition, ISecurityContext securityContext)
{
// delete the old ActualFiniteState
var oldActualStates = this.ActualFiniteStateService.GetShallow(transaction, partition, actualFiniteStateList.ActualState, securityContext)
.OfType <ActualFiniteState>().ToList();
// Gets the possible finite state list of the current processed ActualFiniteStateList
var pslCollection =
this.PossibleFiniteStateListService
.GetShallow(transaction, partition, actualFiniteStateList.PossibleFiniteStateList.Select(item => Guid.Parse(item.V.ToString())), securityContext)
.OfType <PossibleFiniteStateList>()
.ToList();
if (pslCollection.Count != actualFiniteStateList.PossibleFiniteStateList.Count)
{
throw new InvalidOperationException("All the Possible finite state lists could not be retrieved.");
}
// Build the ordered collection of PossibleFiniteStateList for the current ActualFiniteStateList
var orderedPslCollection = new List <PossibleFiniteStateList>(pslCollection.Count);
foreach (var item in actualFiniteStateList.PossibleFiniteStateList.OrderBy(x => x.K))
{
var psl = pslCollection.Single(x => x.Iid.ToString() == item.V.ToString());
orderedPslCollection.Add(psl);
}
var newOldActualStateMap = new Dictionary <ActualFiniteState, ActualFiniteState>();
this.CreateActualStates(orderedPslCollection, 0, null, actualFiniteStateList, transaction, partition, oldActualStates, ref newOldActualStateMap);
this.StateDependentParameterUpdateService.UpdateAllStateDependentParameters(actualFiniteStateList, iteration, transaction, partition, securityContext, newOldActualStateMap);
// This is where value-set are cleaned up
// delete old actual states which will clean up all value sets that depend on it
foreach (var actualState in oldActualStates)
{
if (!this.ActualFiniteStateService.DeleteConcept(transaction, partition, actualState, actualFiniteStateList))
{
throw new InvalidOperationException(string.Format("The actual finite state {0} could not be deleted", actualState.Iid));
}
}
}
/// <summary>
/// Instantiate and deserialize the properties of a <paramref name="Iteration"/>
/// </summary>
/// <param name="jObject">The <see cref="JObject"/> containing the data</param>
/// <returns>The <see cref="Iteration"/> to instantiate</returns>
public static CDP4Common.DTO.Iteration FromJsonObject(JObject jObject)
{
var iid = jObject["iid"].ToObject <Guid>();
var revisionNumber = jObject["revisionNumber"].IsNullOrEmpty() ? 0 : jObject["revisionNumber"].ToObject <int>();
var iteration = new CDP4Common.DTO.Iteration(iid, revisionNumber);
if (!jObject["actualFiniteStateList"].IsNullOrEmpty())
{
iteration.ActualFiniteStateList.AddRange(jObject["actualFiniteStateList"].ToObject <IEnumerable <Guid> >());
}
if (!jObject["defaultOption"].IsNullOrEmpty())
{
iteration.DefaultOption = jObject["defaultOption"].ToObject <Guid?>();
}
if (!jObject["diagramCanvas"].IsNullOrEmpty())
{
iteration.DiagramCanvas.AddRange(jObject["diagramCanvas"].ToObject <IEnumerable <Guid> >());
}
if (!jObject["domainFileStore"].IsNullOrEmpty())
{
iteration.DomainFileStore.AddRange(jObject["domainFileStore"].ToObject <IEnumerable <Guid> >());
}
if (!jObject["element"].IsNullOrEmpty())
{
iteration.Element.AddRange(jObject["element"].ToObject <IEnumerable <Guid> >());
}
if (!jObject["excludedDomain"].IsNullOrEmpty())
{
iteration.ExcludedDomain.AddRange(jObject["excludedDomain"].ToObject <IEnumerable <Guid> >());
}
if (!jObject["excludedPerson"].IsNullOrEmpty())
{
iteration.ExcludedPerson.AddRange(jObject["excludedPerson"].ToObject <IEnumerable <Guid> >());
}
if (!jObject["externalIdentifierMap"].IsNullOrEmpty())
{
iteration.ExternalIdentifierMap.AddRange(jObject["externalIdentifierMap"].ToObject <IEnumerable <Guid> >());
}
if (!jObject["goal"].IsNullOrEmpty())
{
iteration.Goal.AddRange(jObject["goal"].ToObject <IEnumerable <Guid> >());
}
if (!jObject["iterationSetup"].IsNullOrEmpty())
{
iteration.IterationSetup = jObject["iterationSetup"].ToObject <Guid>();
}
if (!jObject["modifiedOn"].IsNullOrEmpty())
{
iteration.ModifiedOn = jObject["modifiedOn"].ToObject <DateTime>();
}
if (!jObject["option"].IsNullOrEmpty())
{
iteration.Option.AddRange(jObject["option"].ToOrderedItemCollection());
}
if (!jObject["possibleFiniteStateList"].IsNullOrEmpty())
{
iteration.PossibleFiniteStateList.AddRange(jObject["possibleFiniteStateList"].ToObject <IEnumerable <Guid> >());
}
if (!jObject["publication"].IsNullOrEmpty())
{
iteration.Publication.AddRange(jObject["publication"].ToObject <IEnumerable <Guid> >());
}
if (!jObject["relationship"].IsNullOrEmpty())
{
iteration.Relationship.AddRange(jObject["relationship"].ToObject <IEnumerable <Guid> >());
}
if (!jObject["requirementsSpecification"].IsNullOrEmpty())
{
iteration.RequirementsSpecification.AddRange(jObject["requirementsSpecification"].ToObject <IEnumerable <Guid> >());
}
if (!jObject["ruleVerificationList"].IsNullOrEmpty())
{
iteration.RuleVerificationList.AddRange(jObject["ruleVerificationList"].ToObject <IEnumerable <Guid> >());
}
if (!jObject["sharedDiagramStyle"].IsNullOrEmpty())
{
iteration.SharedDiagramStyle.AddRange(jObject["sharedDiagramStyle"].ToObject <IEnumerable <Guid> >());
}
if (!jObject["sourceIterationIid"].IsNullOrEmpty())
{
iteration.SourceIterationIid = jObject["sourceIterationIid"].ToObject <Guid?>();
}
if (!jObject["stakeholder"].IsNullOrEmpty())
{
iteration.Stakeholder.AddRange(jObject["stakeholder"].ToObject <IEnumerable <Guid> >());
}
if (!jObject["stakeholderValue"].IsNullOrEmpty())
{
iteration.StakeholderValue.AddRange(jObject["stakeholderValue"].ToObject <IEnumerable <Guid> >());
}
if (!jObject["stakeholderValueMap"].IsNullOrEmpty())
{
iteration.StakeholderValueMap.AddRange(jObject["stakeholderValueMap"].ToObject <IEnumerable <Guid> >());
}
if (!jObject["thingPreference"].IsNullOrEmpty())
{
iteration.ThingPreference = jObject["thingPreference"].ToObject <string>();
}
if (!jObject["topElement"].IsNullOrEmpty())
{
iteration.TopElement = jObject["topElement"].ToObject <Guid?>();
}
if (!jObject["valueGroup"].IsNullOrEmpty())
{
iteration.ValueGroup.AddRange(jObject["valueGroup"].ToObject <IEnumerable <Guid> >());
}
return(iteration);
}
/// <summary>
/// Reads the data related to the provided <see cref="CDP4Common.EngineeringModelData.Iteration"/> from the data-source
/// </summary>
/// <param name="iteration">
/// An instance of <see cref="CDP4Common.EngineeringModelData.Iteration"/> that needs to be read from the data-source
/// </param>
/// <param name="cancellationToken">
/// The <see cref="CancellationToken"/>
/// </param>
/// <param name="attributes">
/// An instance of <see cref="IQueryAttributes"/> to be used with the request
/// </param>
/// <returns>
/// A list of <see cref="Thing"/> that are contained by the provided <see cref="CDP4Common.EngineeringModelData.EngineeringModel"/> including the Reference-Data.
/// All the <see cref="Thing"/>s that have been updated since the last read will be returned.
/// </returns>
public override async Task <IEnumerable <Thing> > Read(CDP4Common.DTO.Iteration iteration, CancellationToken cancellationToken, IQueryAttributes attributes = null)
{
return(await this.Read((Thing)iteration, cancellationToken, attributes));
}
/// <summary> /// Reads the data related to the provided <see cref="CDP4Common.DTO.Iteration"/> from the data-source /// </summary> /// <param name="iteration"> /// An instance of <see cref="CDP4Common.DTO.Iteration"/> that needs to be read from the data-source /// </param> /// <param name="cancellationToken"> /// The <see cref="CancellationToken"/> /// </param> /// <param name="attributes"> /// An instance of <see cref="IQueryAttributes"/> to be used with the request /// </param> /// <returns> /// A list of <see cref="Thing"/> that are contained by the provided <see cref="CDP4Common.DTO.EngineeringModel"/> including the Reference-Data. /// All the <see cref="Thing"/>s that have been updated since the last read will be returned. /// </returns> public abstract Task <IEnumerable <Thing> > Read(Iteration iteration, CancellationToken cancellationToken, IQueryAttributes attributes = null);
/// <summary>
/// Update all the relevant <see cref="CDP4Common.DTO.ParameterBase"/>
/// </summary>
/// <param name="actualFiniteStateList">The updated <see cref="CDP4Common.DTO.ActualFiniteStateList"/></param>
/// <param name="iteration">The <see cref="CDP4Common.DTO.Iteration"/></param>
/// <param name="transaction">The current transaction</param>
/// <param name="partition">The current partition</param>
/// <param name="securityContext">The security context</param>
/// <param name="newOldActualStateMap">The map that links the new to old <see cref="CDP4Common.DTO.ActualFiniteState"/></param>
public void UpdateAllStateDependentParameters(ActualFiniteStateList actualFiniteStateList, Iteration iteration, NpgsqlTransaction transaction, string partition, ISecurityContext securityContext, IReadOnlyDictionary <ActualFiniteState, ActualFiniteState> newOldActualStateMap)
{
if (iteration == null)
{
throw new ArgumentNullException("iteration");
}
var parameters = this.ParameterService.GetShallow(transaction, partition, null, securityContext).Where(i => i is Parameter).Cast <Parameter>()
.Where(x => x.StateDependence == actualFiniteStateList.Iid).ToList();
var parameterOverrides = this.ParameterOverrideService.GetShallow(transaction, partition, null, securityContext).Where(i => i is ParameterOverride).Cast <ParameterOverride>()
.Where(x => parameters.Select(p => p.Iid).Contains(x.Parameter)).ToList();
// update the parameters with the new actual states
var newOldParameterValueSetMap = new Dictionary <Parameter, IDictionary <ParameterValueSet, ParameterValueSet> >();
foreach (var parameter in parameters)
{
var tmpMap = new Dictionary <ParameterValueSet, ParameterValueSet>();
this.UpdateParameter(parameter, iteration, transaction, partition, securityContext, newOldActualStateMap, ref tmpMap);
newOldParameterValueSetMap.Add(parameter, tmpMap);
}
// update the parameter override from the updated parameters
var parameterOrOVerrideValueSetMap = new Dictionary <ParameterOrOverrideBase, IReadOnlyDictionary <ParameterValueSetBase, ParameterValueSetBase> >();
foreach (var pair in newOldParameterValueSetMap)
{
parameterOrOVerrideValueSetMap.Add(pair.Key, pair.Value.ToDictionary(newSet => (ParameterValueSetBase)newSet.Key, oldSet => (ParameterValueSetBase)oldSet.Value));
}
foreach (var parameterOverride in parameterOverrides)
{
var tmpMap = new Dictionary <ParameterValueSetBase, ParameterValueSetBase>();
var overridenParameter = parameters.Single(x => x.Iid == parameterOverride.Parameter);
this.UpdateParameterOverride(parameterOverride, transaction, partition, securityContext, newOldParameterValueSetMap[overridenParameter], ref tmpMap);
parameterOrOVerrideValueSetMap.Add(parameterOverride, tmpMap);
}
// update the parameter subscription from the updated parameter/overide value sets
var parameterOrOverrides = parameters.Cast <ParameterOrOverrideBase>().Union(parameterOverrides).ToList();
var parameterSubscriptions = this.ParameterSubscriptionService.GetShallow(transaction, partition, null, securityContext).Where(i => i is ParameterSubscription).Cast <ParameterSubscription>()
.Where(x => parameterOrOverrides.SelectMany(p => p.ParameterSubscription).Contains(x.Iid));
foreach (var parameterSubscription in parameterSubscriptions)
{
var subscribedParameterOrOverride = parameterOrOverrides.Single(x => x.ParameterSubscription.Contains(parameterSubscription.Iid));
this.UpdateParameterSubscription(parameterSubscription, transaction, partition, securityContext, parameterOrOVerrideValueSetMap[subscribedParameterOrOverride]);
}
}
