/// <summary>
        /// Create a <see cref="ParameterValueSet"/> with a specific option and state. The old value set is used if it exists, otherwise default values are used
        /// </summary>
        /// <param name="oldValue">The old <see cref="ParameterValueSet"/></param>
        /// <param name="parameter">The current <see cref="Parameter"/></param>
        /// <param name="actualOption">The actual <see cref="CDP4Common.DTO.Option"/></param>
        /// <param name="actualState">The <see cref="ActualFiniteState"/></param>
        /// <param name="transaction">The transaction</param>
        /// <param name="partition">The partition</param>
        /// <param name="securityContext">The security context</param>
        /// <returns>The created <see cref="ParameterValueSet"/></returns>
        private ParameterValueSet CreateParameterValueSet(ParameterValueSet oldValue, Parameter parameter, Guid?actualOption, Guid?actualState, NpgsqlTransaction transaction, string partition, ISecurityContext securityContext)
        {
            this.DefaultValueSetFactory.Load(transaction, securityContext);
            var defaultValue = this.DefaultValueSetFactory.CreateDefaultValueArray(parameter.ParameterType);

            var isOldValueNull = oldValue == null;
            var valueSet       = new ParameterValueSet(Guid.NewGuid(), 1)
            {
                Manual       = new ValueArray <string>(isOldValueNull ? defaultValue : oldValue.Manual),
                Computed     = new ValueArray <string>(isOldValueNull ? defaultValue : oldValue.Computed),
                Reference    = new ValueArray <string>(isOldValueNull ? defaultValue : oldValue.Reference),
                Published    = new ValueArray <string>(isOldValueNull ? defaultValue : oldValue.Published),
                Formula      = new ValueArray <string>(isOldValueNull ? defaultValue : oldValue.Formula),
                ActualOption = actualOption,
                ActualState  = actualState,
                ValueSwitch  = isOldValueNull ? CDP4Common.EngineeringModelData.ParameterSwitchKind.MANUAL : oldValue.ValueSwitch
            };

            this.ParameterValueSetService.CreateConcept(transaction, partition, valueSet, parameter);
            return(valueSet);
        }
        /// <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);
        }
        /// <summary>
        /// Instantiate and deserialize the properties of a <paramref name="ParameterValueSet"/>
        /// </summary>
        /// <param name="jObject">The <see cref="JObject"/> containing the data</param>
        /// <returns>The <see cref="ParameterValueSet"/> to instantiate</returns>
        public static CDP4Common.DTO.ParameterValueSet FromJsonObject(JObject jObject)
        {
            var iid               = jObject["iid"].ToObject <Guid>();
            var revisionNumber    = jObject["revisionNumber"].IsNullOrEmpty() ? 0 : jObject["revisionNumber"].ToObject <int>();
            var parameterValueSet = new CDP4Common.DTO.ParameterValueSet(iid, revisionNumber);

            if (!jObject["actualOption"].IsNullOrEmpty())
            {
                parameterValueSet.ActualOption = jObject["actualOption"].ToObject <Guid?>();
            }

            if (!jObject["actualState"].IsNullOrEmpty())
            {
                parameterValueSet.ActualState = jObject["actualState"].ToObject <Guid?>();
            }

            if (!jObject["computed"].IsNullOrEmpty())
            {
                parameterValueSet.Computed = SerializerHelper.ToValueArray <string>(jObject["computed"].ToString());
            }

            if (!jObject["excludedDomain"].IsNullOrEmpty())
            {
                parameterValueSet.ExcludedDomain.AddRange(jObject["excludedDomain"].ToObject <IEnumerable <Guid> >());
            }

            if (!jObject["excludedPerson"].IsNullOrEmpty())
            {
                parameterValueSet.ExcludedPerson.AddRange(jObject["excludedPerson"].ToObject <IEnumerable <Guid> >());
            }

            if (!jObject["formula"].IsNullOrEmpty())
            {
                parameterValueSet.Formula = SerializerHelper.ToValueArray <string>(jObject["formula"].ToString());
            }

            if (!jObject["manual"].IsNullOrEmpty())
            {
                parameterValueSet.Manual = SerializerHelper.ToValueArray <string>(jObject["manual"].ToString());
            }

            if (!jObject["modifiedOn"].IsNullOrEmpty())
            {
                parameterValueSet.ModifiedOn = jObject["modifiedOn"].ToObject <DateTime>();
            }

            if (!jObject["published"].IsNullOrEmpty())
            {
                parameterValueSet.Published = SerializerHelper.ToValueArray <string>(jObject["published"].ToString());
            }

            if (!jObject["reference"].IsNullOrEmpty())
            {
                parameterValueSet.Reference = SerializerHelper.ToValueArray <string>(jObject["reference"].ToString());
            }

            if (!jObject["thingPreference"].IsNullOrEmpty())
            {
                parameterValueSet.ThingPreference = jObject["thingPreference"].ToObject <string>();
            }

            if (!jObject["valueSwitch"].IsNullOrEmpty())
            {
                parameterValueSet.ValueSwitch = jObject["valueSwitch"].ToObject <ParameterSwitchKind>();
            }

            return(parameterValueSet);
        }