/// <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]); } }
/// <summary> /// Instantiate and deserialize the properties of a <paramref name="ActualFiniteStateList"/> /// </summary> /// <param name="jObject">The <see cref="JObject"/> containing the data</param> /// <returns>The <see cref="ActualFiniteStateList"/> to instantiate</returns> public static CDP4Common.DTO.ActualFiniteStateList FromJsonObject(JObject jObject) { var iid = jObject["iid"].ToObject <Guid>(); var revisionNumber = jObject["revisionNumber"].IsNullOrEmpty() ? 0 : jObject["revisionNumber"].ToObject <int>(); var actualFiniteStateList = new CDP4Common.DTO.ActualFiniteStateList(iid, revisionNumber); if (!jObject["actualState"].IsNullOrEmpty()) { actualFiniteStateList.ActualState.AddRange(jObject["actualState"].ToObject <IEnumerable <Guid> >()); } if (!jObject["excludedDomain"].IsNullOrEmpty()) { actualFiniteStateList.ExcludedDomain.AddRange(jObject["excludedDomain"].ToObject <IEnumerable <Guid> >()); } if (!jObject["excludedPerson"].IsNullOrEmpty()) { actualFiniteStateList.ExcludedPerson.AddRange(jObject["excludedPerson"].ToObject <IEnumerable <Guid> >()); } if (!jObject["excludeOption"].IsNullOrEmpty()) { actualFiniteStateList.ExcludeOption.AddRange(jObject["excludeOption"].ToObject <IEnumerable <Guid> >()); } if (!jObject["modifiedOn"].IsNullOrEmpty()) { actualFiniteStateList.ModifiedOn = jObject["modifiedOn"].ToObject <DateTime>(); } if (!jObject["owner"].IsNullOrEmpty()) { actualFiniteStateList.Owner = jObject["owner"].ToObject <Guid>(); } if (!jObject["possibleFiniteStateList"].IsNullOrEmpty()) { actualFiniteStateList.PossibleFiniteStateList.AddRange(jObject["possibleFiniteStateList"].ToOrderedItemCollection()); } if (!jObject["thingPreference"].IsNullOrEmpty()) { actualFiniteStateList.ThingPreference = jObject["thingPreference"].ToObject <string>(); } return(actualFiniteStateList); }
/// <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> /// Create the <see cref="ActualFiniteState"/>s for a <see cref="ActualFiniteStateList"/> /// </summary> /// <param name="pslCollection">The ordered collection of <see cref="PossibleFiniteStateList"/></param> /// <param name="pslIndex">The index of the <see cref="PossibleFiniteStateList"/> in the collection to process</param> /// <param name="possibleStateIds">The current collection of <see cref="Guid"/> to use for the <see cref="ActualFiniteState"/> to create</param> /// <param name="container">The <see cref="ActualFiniteStateList"/></param> /// <param name="transaction">The current <see cref="NpgsqlTransaction"/></param> /// <param name="partition">The partition in the database</param> /// <param name="oldActualStates">The old <see cref="ActualFiniteState"/></param> /// <param name="newOldStateMap">The resulting map that links the new to old <see cref="ActualFiniteState"/></param> private void CreateActualStates(IReadOnlyList <PossibleFiniteStateList> pslCollection, int pslIndex, IEnumerable <Guid> possibleStateIds, ActualFiniteStateList container, NpgsqlTransaction transaction, string partition, IReadOnlyList <ActualFiniteState> oldActualStates, ref Dictionary <ActualFiniteState, ActualFiniteState> newOldStateMap) { var currentPossibleStateIds = possibleStateIds == null ? new List <Guid>() : possibleStateIds.ToList(); // build the different PossibleStates combination taken from the PossibleFiniteStateLists and create an ActualState for each of these combinations foreach (var orderedItem in pslCollection[pslIndex].PossibleState.OrderBy(x => x.K)) { var newPossibleStateIds = currentPossibleStateIds.ToList(); newPossibleStateIds.Add(Guid.Parse(orderedItem.V.ToString())); // Last PossibleFiniteStateList in the ordered collection if (pslIndex == pslCollection.Count - 1) { // create actual state var newActualstate = new ActualFiniteState(Guid.NewGuid(), 1); newActualstate.PossibleState.AddRange(newPossibleStateIds); this.ActualFiniteStateService.CreateConcept(transaction, partition, newActualstate, container); var oldActualState = oldActualStates.FirstOrDefault(x => x.PossibleState.All(ps => newPossibleStateIds.Contains(ps))); newActualstate.Kind = oldActualState?.Kind ?? ActualFiniteStateKind.MANDATORY; newOldStateMap.Add(newActualstate, oldActualState); continue; } this.CreateActualStates(pslCollection, pslIndex + 1, newPossibleStateIds, container, transaction, partition, oldActualStates, ref newOldStateMap); } }