Exemple #1
0
 public RemoveOperation(OperationBuilder builder, LazyItemEvaluator <P, I, M, D> lazyEvaluator)
     : base(builder, lazyEvaluator)
 {
 }
        private void ProcessItemSpec(string rootDirectory, string itemSpec, IElementLocation itemSpecLocation, OperationBuilder builder)
        {
            builder.ItemSpec = new ItemSpec <P, I>(itemSpec, _outerExpander, itemSpecLocation, rootDirectory);

            foreach (ItemSpecFragment fragment in builder.ItemSpec.Fragments)
            {
                if (fragment is ItemSpec <P, I> .ItemExpressionFragment itemExpression)
                {
                    AddReferencedItemLists(builder, itemExpression.Capture);
                }
            }
        }
 public override void WriteExtras(OperationBuilder builder)
 {
 }
        private void ProcessItemSpec(string itemSpec, IElementLocation itemSpecLocation, OperationBuilder builder)
        {
            builder.ItemSpec = new ItemSpec <P, I>(itemSpec, _outerExpander, itemSpecLocation);

            var itemCaptures = builder.ItemSpec.Fragments.OfType <ItemExpressionFragment <P, I> >().Select(i => i.Capture);

            AddReferencedItemLists(builder, itemCaptures);
        }
 public override void WriteBody(OperationBuilder builder)
 {
 }
Exemple #6
0
        private OperationBuilder BuildDescription(string description, string notes, string summary,
                                                  IEnumerable <HttpResponseMetadata> responsesMetadatas, IEnumerable <Parameter> parameters,
                                                  IEnumerable <Tag> tags = null, Func <OperationBuilder, Action> addModel = null)
        {
            OperationBuilder op = new OperationBuilder();

            op.OperationId(description).Summary(summary).Description(notes);

            if (responsesMetadatas != null)
            {
                foreach (var metadata in responsesMetadatas)
                {
                    var schema = metadata.GetSchema(_modelCatalog);
                    if (schema != null)
                    {
                        op.Response(metadata.Code, r => r.Description(string.IsNullOrEmpty(metadata.Message) ? "N/A" : metadata.Message).Schema(schema));
                    }
                    else
                    {
                        op.Response(metadata.Code, r => r.Description(string.IsNullOrEmpty(metadata.Message) ? "N/A" : metadata.Message));
                    }
                }
            }

            addModel?.Invoke(op);

            if (parameters != null)
            {
                foreach (var param in parameters)
                {
                    if (string.IsNullOrEmpty(param.Type) && param.In != ParameterIn.Body)
                    {
                        param.Type = "string";
                    }
                    if (param.Type == "file")
                    {
                        op.ConsumeMimeTypes(new[] { "multipart/form-data", "application/x-www-form-urlencoded" });
                    }
                    op.Parameter(param);
                }
            }

            if (_baseTag != null)
            {
                op.Tag(_baseTag.Name);
            }

            if (tags != null)
            {
                foreach (var tag in tags)
                {
                    if (!_tagCatalog.Contains(tag))
                    {
                        _tagCatalog.AddTag(tag);
                    }

                    op.Tag(tag.Name);
                }
            }

            _routeMetadataBuilder[description] = desc => desc.AsSwagger(with =>
            {
                with.Operation(op);
            });

            return(op);
        }
Exemple #7
0
 private Action AddModel <T>(OperationBuilder op)
 {
     op.AddResponseSchema <T>(_modelCatalog);
     return(null);
 }
 protected override void WriteExtras(OperationBuilder builder)
 {
 }
 protected override void WriteKey(OperationBuilder builder)
 {
 }