Exemple #1
0
        public override ConfigSectionNode ProvideMetadata(MemberInfo member, object instance, IMetadataGenerator context, ConfigSectionNode dataRoot, NodeOverrideRules overrideRules = null)
        {
            var tperm = member.NonNull(nameof(member)) as Type;

            if (tperm == null || !typeof(Permission).IsAssignableFrom(tperm))
            {
                return(null);
            }

            var node = dataRoot.AddChildNode("permission");

            MetadataUtils.AddMetadataTokenIdAttribute(node, tperm);
            if (instance is Permission perm)
            {
                node.AddAttributeNode("name", perm.Name);
                node.AddAttributeNode("path", perm.Path);
                node.AddAttributeNode("description", perm.Description);
                node.AddAttributeNode("level", perm.Level);
            }
            else
            {
                node.AddAttributeNode("name", tperm.Name.Replace("Permission", string.Empty));
                node.AddAttributeNode("ns", tperm.Namespace);
            }
            return(dataRoot);
        }
        public override ConfigSectionNode ProvideMetadata(MemberInfo member, object instance, IMetadataGenerator context, ConfigSectionNode dataRoot, NodeOverrideRules overrideRules = null)
        {
            var tdoc = member.NonNull(nameof(member)) as Type;

            if (tdoc == null || !typeof(Doc).IsAssignableFrom(tdoc))
            {
                return(null);
            }

            var typed = tdoc.IsSubclassOf(typeof(TypedDoc));

            var    ndoc = dataRoot.AddChildNode("data-doc");
            Schema schema;

            if (instance is Doc doc)
            {
                schema = doc.Schema;
            }
            else if (typed)
            {
                schema = Schema.GetForTypedDoc(tdoc);
            }
            else
            {
                schema = null;
            }

            MetadataUtils.AddMetadataTokenIdAttribute(ndoc, tdoc);
            ndoc.AddAttributeNode("kind", typed ? "typed" : "dynamic");

            CustomMetadataAttribute.Apply(typeof(Schema), schema, context, ndoc, overrideRules);

            return(ndoc);
        }
        private (Lazy <ConfigSectionNode> request, Lazy <ConfigSectionNode> response) writeCommon(
            string defTitle,
            string defDescription,
            MemberInfo info,
            ApiDocGenerator gen,
            ApiDocAttribute attr,
            ConfigSectionNode data)
        {
            MetadataUtils.AddMetadataTokenIdAttribute(data, info);

            var title = attr.Title.Default(defTitle);

            if (title.IsNotNullOrWhiteSpace())
            {
                data.AddAttributeNode("title", title);
            }

            var descr = attr.Description.Default(defDescription);

            if (descr.IsNotNullOrWhiteSpace())
            {
                data.AddAttributeNode("description", descr);
            }

            var drequest  = new Lazy <ConfigSectionNode>(() => data.AddChildNode("request"));
            var dresponse = new Lazy <ConfigSectionNode>(() => data.AddChildNode("response"));

            writeCollection(attr.RequestHeaders, "header", drequest, ':');
            writeCollection(attr.RequestQueryParameters, "param", drequest, '=');
            writeCollection(attr.ResponseHeaders, "header", dresponse, ':');

            if (attr.Connection.IsNotNullOrWhiteSpace())
            {
                data.AddAttributeNode("connection", attr.Connection);
            }

            if (attr.RequestBody.IsNotNullOrWhiteSpace())
            {
                drequest.Value.AddAttributeNode("body", attr.RequestBody);
            }

            if (attr.ResponseContent.IsNotNullOrWhiteSpace())
            {
                dresponse.Value.AddAttributeNode("content", attr.ResponseContent);
            }

            writeTypeCollection(attr.TypeSchemas, TYPE_REF, data, gen);

            return(drequest, dresponse);
        }