コード例 #1
0
        public override void Remove(Parameter item)
        {
            base.Remove(item);
            // find a Property in OptionsParameterModelType with the same name and remove it.

            OptionsParameterModelType.Remove(prop => prop.Name == item.Name);
        }
コード例 #2
0
        /// <summary>
        /// Format the value of a sequence given the modeled element format.  Note that only sequences of strings are supported
        /// </summary>
        /// <param name="parameter">The parameter to format</param>
        /// <returns>return the separator</returns>
        public static string NeedsFormattedSeparator(Parameter parameter)
        {
            if (parameter == null)
            {
                throw new ArgumentNullException("parameter");
            }

            SequenceType sequence = parameter.ModelType as SequenceType;
            if (sequence == null)
            {
                return null;
            }

            PrimaryType primaryType = sequence.ElementType as PrimaryType;
            EnumType enumType = sequence.ElementType as EnumType;
            if (enumType != null)
            {
                primaryType = New<PrimaryType>(KnownPrimaryType.String);
            }

            if (primaryType != null && primaryType.KnownPrimaryType != KnownPrimaryType.String)
            {
                throw new InvalidOperationException(
                    string.Format(CultureInfo.InvariantCulture,
                    "Cannot generate a formatted sequence from a " +
                                  "non-string array parameter {0}", parameter));
            }

            return parameter.CollectionFormat.GetSeparator();
        }
コード例 #3
0
        private static Property CreateParameterGroupProperty(Parameter parameter)
        {
            Property groupProperty = New<Property>(new
            {
                IsReadOnly = false, //Since these properties are used as parameters they are never read only
                Name = parameter.Name,
                IsRequired = parameter.IsRequired,
                DefaultValue = parameter.DefaultValue,
                //Constraints = parameter.Constraints, Omit these since we don't want to perform parameter validation
                Documentation = parameter.Documentation,
                ModelType = parameter.ModelType,
                SerializedName = default(string) //Parameter is never serialized directly
            });

            // Copy over extensions
            foreach (var key in parameter.Extensions.Keys)
            {
                groupProperty.Extensions[key] = parameter.Extensions[key];
            }

            return groupProperty;
        }
コード例 #4
0
        public override Parameter Add(Parameter item)
        {
            var parameter = base.Add(item) as ParameterJs;

            if (parameter.IsLocal && !parameter.IsRequired)
            {
                OptionsParameterModelType.Add(New<Core.Model.Property>(new
                {
                    IsReadOnly = false,
                    Name = parameter.Name,
                    IsRequired = parameter.IsRequired,
                    DefaultValue = parameter.DefaultValue,
                    Documentation = parameter.Documentation,
                    ModelType = parameter.ModelType,
                    SerializedName = parameter.SerializedName,
                    Constraints = parameter.Constraints,
                    // optionalProperty.Constraints.AddRange(parameter.Constraints);
                    Extensions = parameter.Extensions // optionalProperty.Extensions.AddRange(parameter.Extensions);
                }));
            }
            
            return parameter;
        }
コード例 #5
0
        private static string GetParameterGroupName(string methodGroupName, string methodName, Parameter parameter)
        {
            if (parameter.Extensions.ContainsKey(SwaggerExtensions.ParameterGroupExtension))
            {
                JContainer extensionObject = parameter.Extensions[SwaggerExtensions.ParameterGroupExtension] as JContainer;
                if (extensionObject != null)
                {
                    string specifiedGroupName = extensionObject.Value<string>("name");
                    string parameterGroupName;
                    if (specifiedGroupName == null)
                    {
                        string postfix = extensionObject.Value<string>("postfix") ?? "Parameters";
                        parameterGroupName = methodGroupName + "-" + methodName + "-" + postfix;
                    }
                    else
                    {
                        parameterGroupName = specifiedGroupName;
                    }
                    return parameterGroupName;
                }
            }

            return null;
        }
コード例 #6
0
ファイル: CodeModel.gen.cs プロジェクト: devigned/autorest
 public virtual void Remove(Parameter item)
 {
     _parameters.Remove(item);
 }
コード例 #7
0
ファイル: CodeModel.gen.cs プロジェクト: devigned/autorest
 public virtual Parameter Insert(Parameter item)
 {
     if( !_parameters.Contains(item))
     {
         // disambiguation is performed when the item's parent reference is changed
         item.Method = this;
         _parameters.Insert(0, item);
     }
     return item;
 }
コード例 #8
0
ファイル: CodeModel.gen.cs プロジェクト: devigned/autorest
 partial void BeforeAdd(Parameter item);
コード例 #9
0
ファイル: MethodPy.cs プロジェクト: devigned/autorest
        /// <summary>
        /// Provides the parameter documentation string.
        /// </summary>
        /// <param name="parameter">Parameter to be documented</param>
        /// <returns>Parameter documentation string correct notation</returns>
        public static string GetParameterDocumentationString(Parameter parameter)
        {
            if (parameter == null)
            {
                throw new ArgumentNullException("parameter");
            }

            string docString = ":param ";

            docString += parameter.Name + ":";

            if (!string.IsNullOrWhiteSpace(parameter.Documentation))
            {
                docString += " " + parameter.Documentation;
            }

            return docString;
        }
コード例 #10
0
ファイル: MethodPy.cs プロジェクト: devigned/autorest
        private string BuildSerializeDataCall(Parameter parameter, string functionName)
        {
            string divChar = ClientModelExtensions.NeedsFormattedSeparator(parameter);
            string divParameter = string.Empty;
            
            string parameterName = (MethodGroup as MethodGroupPy)?.ConstantProperties?.FirstOrDefault(each => each.Name.RawValue == parameter.Name.RawValue && each.DefaultValue.RawValue == parameter.DefaultValue.RawValue)?.Name.Else(parameter.Name) ?? parameter.Name;
            
            if (!string.IsNullOrEmpty(divChar))
            {
                divParameter = string.Format(CultureInfo.InvariantCulture, ", div='{0}'", divChar);
            }

            //TODO: This creates a very long line - break it up over multiple lines.
            return string.Format(CultureInfo.InvariantCulture,
                    "self._serialize.{0}(\"{1}\", {1}, '{2}'{3}{4}{5})",
                        functionName,
                        parameterName,
                        parameter.ModelType.ToPythonRuntimeTypeString(),
                        parameter.SkipUrlEncoding() ? ", skip_quote=True" : string.Empty,
                        divParameter,
                        BuildValidationParameters(parameter.Constraints));
        }
コード例 #11
0
        public static string GetParameterDocumentationType(Parameter parameter)
        {
            if (parameter == null)
            {
                throw new ArgumentNullException(nameof(parameter));
            }
            string typeName = "object";
            if (parameter.ModelType is PrimaryTypeJs)
            {
                typeName = parameter.ModelType.Name;
            }
            else if (parameter.ModelType is Core.Model.SequenceType)
            {
                typeName = "array";
            }
            else if (parameter.ModelType is EnumType)
            {
                typeName = "string";
            }

            return typeName.ToLower(CultureInfo.InvariantCulture);
        }
コード例 #12
0
 /// <summary>
 /// Provides the parameter name in the correct jsdoc notation depending on 
 /// whether it is required or optional
 /// </summary>
 /// <param name="parameter">Parameter to be documented</param>
 /// <returns>Parameter name in the correct jsdoc notation</returns>
 public static string GetParameterDocumentationName(Parameter parameter)
 {
     if (parameter == null)
     {
         throw new ArgumentNullException(nameof(parameter));
     }
     if (parameter.IsRequired)
     {
         return parameter.Name;
     }
     else
     {
         return string.Format(CultureInfo.InvariantCulture, "[{0}]", parameter.Name);
     }
 }