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]); } }