当前位置：首页 > 文章列表 > Golang > Go问答 > 在swagger ui中如何展示模型

在swagger ui中如何展示模型

来源：stackoverflow 2024-02-28 08:42:25 0浏览收藏

本篇文章给大家分享《在swagger ui中如何展示模型》，覆盖了Golang的常见基础知识，其实一个语言的全部知识点一篇文章是不可能说完的，但希望通过这些问题，让读者对自己的掌握程度有一定的认识(B 数)，从而弥补自己的不足，更好的掌握它。

问题内容

我有一本用 golang 构建的书本 api，一切正常，我正在尝试为文档添加 swagger，我已经做到了，但我遇到了问题，我只能看到路线，但是当我点击它，看不到描述，也看不到任何型号信息，这是我在 main.go 上的代码

package main

import (
    //"fmt"
    "time"
    "github.com/cosimmichael/assessment/app/db_client"
    "github.com/cosimmichael/assessment/app/controllers"
    "github.com/gin-gonic/gin"
    "github.com/gin-contrib/cors"

    // "github.com/swaggo/gin-swagger"
    // "github.com/swaggo/files"

    //"github.com/swaggo/swag/example/celler/controller"
    //_ "github.com/swaggo/swag/example/celler/docs"
    _ "github.com/cosimmichael/assessment/app/docs"
    //"github.com/swaggo/swag/example/celler/httputil"

    swaggerfiles "github.com/swaggo/files"
    ginswagger "github.com/swaggo/gin-swagger"


    // you need to import go mod  init for this parkage to work
    // "github.com/cosimmichael/assessment/app/strutil"
    // "github.com/cosimmichael/assessment/app/routers"
    // "net/http"
)

// @title simple book dashboard api
// @version 1.0
// @description this is for book management.
// @termsofservice http://swagger.io/terms/

// @contact.name books api support
// @contact.url http://www.swagger.io/support
// @contact.email [email protected]

// @license.name apache 2.0
// @license.url http://www.apache.org/licenses/license-2.0.html

// @host localhost:3000
// @basepath /api/v1/products
// @query.collection.format multi

// @securitydefinitions.basic basicauth

// @securitydefinitions.apikey apikeyauth
// @in header
// @name authorization, x-api-key

// @securitydefinitions.oauth2.application oauth2application
// @tokenurl https://example.com/oauth/token
// @scope.write grants write access
// @scope.admin grants read and write access to administrative information

// @securitydefinitions.oauth2.implicit oauth2implicit
// @authorizationurl https://example.com/oauth/authorize
// @scope.write grants write access
// @scope.admin grants read and write access to administrative information

// @securitydefinitions.oauth2.password oauth2password
// @tokenurl https://example.com/oauth/token
// @scope.read grants read access
// @scope.write grants write access
// @scope.admin grants read and write access to administrative information

// @securitydefinitions.oauth2.accesscode oauth2accesscode
// @tokenurl https://example.com/oauth/token
// @authorizationurl https://example.com/oauth/authorize
// @scope.admin grants read and write access to administrative information

// @x-extension-openapi {"example": "value on a json format"}

func main(){
    db_client.initialisedbconnection()

    r := gin.default()
    //r.use(cors.default())
    r.use(cors.new(cors.config{
        alloworigins:     []string{"http://localhost:8080"},
        allowmethods:     []string{"put", "patch","post","get","delete"},
        allowheaders:     []string{"origin","authorization","x-api-key","content-type"},
        exposeheaders:    []string{"content-length"},
        allowcredentials: true,
        alloworiginfunc: func(origin string) bool {
            return origin == "http://localhost:8080"
        },
        maxage: 12 * time.hour,
    }))
    // router.handleroutes()
    r.post("api/v1/products/login", controller.login)
    r.post("api/v1/products/create", controller.createproducts)
    r.get("api/v1/products", controller.getproducts)
    r.get("api/v1/products/:id/show", controller.getsingleproduct)
    r.put("api/v1/products/:id/update", controller.updatesingleproduct)
    r.delete("api/v1/products/:id/delete", controller.deletesingleproduct)
    //r.post("api/v1/products/check", controller.checkheader)

    r.get("/swagger/*any", ginswagger.wraphandler(swaggerfiles.handler))

    if err := r.run(":3000"); err != nil {
        panic(err.error())
    }
    // router.handleroutes()
    // fmt.println("server starting.. @ port :3000")
    // http.listenandserve(":3000", nil)
}

这是我在控制器上的代码

package controller

import (
    "net/http"
    "strconv"
    "github.com/gin-gonic/gin"
    "github.com/cosimmichael/assessment/app/db_client"
    "github.com/cosimmichael/assessment/app/model"
    // "github.com/swaggo/swag/example/celler/httputil"
    // "github.com/swaggo/swag/example/celler/model"
)


type testheader struct {
    token   string    `header:"x-api-key"`
}

// login godoc
// @summary log in to admin account 
// @description authentication
// @id get-string-by-int
// @accept  json
// @produce  json
// @param admin body admin true "add account"
 
// @router /login [post]
func login(c *gin.context) {
    var reqbody model.admin
    if err := c.shouldbindjson(&reqbody); err != nil {
        c.json(http.statusunprocessableentity, gin.h{
            "error": true,
            "message": "invalid request body",
        })
        return
    }
    
    row := db_client.dbclient.queryrow("select id, username, password from admin where username = ?;", reqbody.username)
    var myacc model.admin

    if err := row.scan(&myacc.id, &myacc.username, &myacc.password); err != nil {
        c.json(http.statusunprocessableentity, gin.h{
            "error": true,
            "message": "something is wrong with request",
        })
        return
    }

    if myacc.password == reqbody.password {
        c.json(http.statuscreated, gin.h{
            "error": false,
            "user": myacc.username,
            "token": "7b215b90-df8d-4077-8852-0907b0c1034e",
        })
        return
    }else{
        c.json(http.statuscreated, gin.h{
            "error": true,
            "message": "invalid details",
        })
        return
    }

}
 
// createproducts godoc
// @summary create new book
// @description saving new book detail
// @id get-string-by-int
// @accept  json
// @produce  json
// @param post body post true "add post"
 
// @router /create [post]
func createproducts(c *gin.context) {
    h := testheader{}
    if err := c.shouldbindheader(&h); err != nil {
        c.json(http.statusinternalservererror, gin.h{
            "error": true,
            "message": "access denied",
        })
        return
    }
    if h.token != "7b215b90-df8d-4077-8852-0907b0c1034e"{
        c.json(http.statusinternalservererror, gin.h{
            "error": true,
            "message": "invalid access",
        })
        return
    }
    var reqbody model.post
    if err := c.shouldbindjson(&reqbody); err != nil {
        c.json(http.statusunprocessableentity, gin.h{
            "error": true,
            "message": "invalid request body",
        })
        return
    }

    if reqbody.title == ""{
        c.json(http.statusinternalservererror, gin.h{
            "error": true,
            "message": "insert product title",
        })
        return
    }

    var posts []model.post
    rows, err := db_client.dbclient.query("select id, title, description from products;")
    if err != nil {
        c.json(http.statusunprocessableentity, gin.h{
            "error": true,
            "message": "invalid request body",
        })
        return
    }

    for rows.next(){
        var singlepost model.post
        rows.scan(&singlepost.id, &singlepost.title, &singlepost.description)
        if singlepost.title == reqbody.title {
            c.json(http.statuscreated, gin.h{
                "error": true,
                "message": "title already exists",
            })
            return
        }
        posts = append(posts, singlepost)
    }


    res, err := db_client.dbclient.exec("insert into products (title, description) values (?, ?);", 
        reqbody.title,//"testing",
        reqbody.description,//"just testing something",
    )
    if err != nil {
        c.json(http.statusinternalservererror, gin.h{
            "error": true,
            "message": "invalid request body2",
        })
        return
    }

    id, err := res.lastinsertid()
    if err != nil {
        c.json(http.statusinternalservererror, gin.h{
            "error": true,
            "message": "invalid request body3",
        })
        return
    }

    c.json(http.statuscreated, gin.h{
        "error": false,
        "id": id,
    })
}

// getproducts godoc
// @summary get all books info
// @description fetch all books from database
// @id get-string-by-int
// @accept  json
// @produce  json
 
// @router / [get]
func getproducts(c *gin.context){
    var posts []model.post
    h := testheader{}
    if err := c.shouldbindheader(&h); err != nil {
        c.json(http.statusinternalservererror, gin.h{
            "error": true,
            "message": "access denied",
        })
        return
    }
    if h.token != "7b215b90-df8d-4077-8852-0907b0c1034e"{
        c.json(http.statusinternalservererror, gin.h{
            "error": true,
            "message": "invalid access",
        })
        return
    }
    rows, err := db_client.dbclient.query("select id, title, description from products;")
    if err != nil {
        c.json(http.statusunprocessableentity, gin.h{
            "error": true,
            "message": "invalid request body",
        })
        return
    }

    for rows.next(){
        var singlepost model.post
        if err := rows.scan(&singlepost.id, &singlepost.title, &singlepost.description); err != nil {
            c.json(http.statusunprocessableentity, gin.h{
                "error": true,
                "message": "invalid request body",
            })
            return
        }
        posts = append(posts, singlepost)
    }

    c.json(http.statusok, posts)
}

// getsingleproduct godoc
// @summary get a single book info
// @description fetch a book from database by id
// @id get-string-by-int
// @accept  json
// @produce  json
// @param id path int true "post id"
 
// @router /:id/show [get]
func getsingleproduct(c *gin.context){
    idstr := c.param("id")
    id, _ := strconv.atoi(idstr)
    h := testheader{}
    if err := c.shouldbindheader(&h); err != nil {
        c.json(http.statusinternalservererror, gin.h{
            "error": true,
            "message": "access denied",
        })
        return
    }
    if h.token != "7b215b90-df8d-4077-8852-0907b0c1034e"{
        c.json(http.statusinternalservererror, gin.h{
            "error": true,
            "message": "invalid access",
        })
        return
    }

    row := db_client.dbclient.queryrow("select id, title, description from products where id = ?;", id)
    var post model.post
    if err := row.scan(&post.id, &post.title, &post.description); err != nil {
        c.json(http.statusunprocessableentity, gin.h{
            "error": true,
            "message": "something is wrong with request",
        })
        return
    }
    c.json(http.statusok, post)
}

// updatesingleproduct godoc
// @summary get a books info
// @description change info of a book
// @id get-string-by-int
// @accept  json
// @produce  json
// // @param id path int true "post id"

// @router /:id/update [put]
func updatesingleproduct(c *gin.context){
    var reqbody model.post
    h := testheader{}
    if err := c.shouldbindheader(&h); err != nil {
        c.json(http.statusinternalservererror, gin.h{
            "error": true,
            "message": "access denied",
        })
        return
    }
    if h.token != "7b215b90-df8d-4077-8852-0907b0c1034e"{
        c.json(http.statusinternalservererror, gin.h{
            "error": true,
            "message": "invalid access",
        })
        return
    }
    idstr := c.param("id")
    id, _ := strconv.atoi(idstr)

    if err := c.shouldbindjson(&reqbody); err != nil {
        c.json(http.statusunprocessableentity, gin.h{
            "error": true,
            "message": "invalid request body",
        })
        return
    }

    if reqbody.title == ""{
        c.json(http.statusinternalservererror, gin.h{
            "error": true,
            "message": "insert product title",
        })
        return
    }

    //checking if user changed the title value
    row := db_client.dbclient.queryrow("select id, title, description from products where id = ?;", id)
    var post model.post
    row.scan(&post.id, &post.title, &post.description)
    if post.title != reqbody.title {
        //user changed tille
        var posts []model.post
        rows, _ := db_client.dbclient.query("select id, title, description from products;")

        for rows.next(){
            var singlepost model.post
            rows.scan(&singlepost.id, &singlepost.title, &singlepost.description)
            if singlepost.title == reqbody.title {
                c.json(http.statuscreated, gin.h{
                    "error": true,
                    "message": "another product already has this title",
                })
                return
            }
            posts = append(posts, singlepost)
        }
    }
    


    _, err := db_client.dbclient.exec("update products set title = ?, description = ? where id = ?;", 
        reqbody.title,
        reqbody.description,
        id,
    )
    if err != nil {
        c.json(http.statusinternalservererror, gin.h{
            "error": true,
            "message": "invalid request body2",
        })
        return
    }

    c.json(http.statuscreated, gin.h{
        "error": false,
        "id": id,
        "newtitle": reqbody.title,
        "newdescription": reqbody.description,
    })

}

// deletesingleproduct godoc
// @summary delete a book
// @description remove a book from database
// @id get-string-by-int
// @accept  json
// @produce  json
// @param id path int true "post id"

// @router /:id/delete [delete]
func deletesingleproduct(c *gin.context){
    idstr := c.param("id")
    id, _ := strconv.atoi(idstr)
    h := testheader{}
    if err := c.shouldbindheader(&h); err != nil {
        c.json(http.statusinternalservererror, gin.h{
            "error": true,
            "message": "access denied",
        })
        return
    }
    if h.token != "7b215b90-df8d-4077-8852-0907b0c1034e"{
        c.json(http.statusinternalservererror, gin.h{
            "error": true,
            "message": "invalid access",
        })
        return
    }

    _,err := db_client.dbclient.exec("delete from products where id = ?;", id)
    if err != nil {
        c.json(http.statusinternalservererror, gin.h{
            "error": true,
            "message": "invalid request body2",
        })
        return
    }
    
    var posts []model.post
    rows, err := db_client.dbclient.query("select id, title, description from products;")
    if err != nil {
        c.json(http.statusunprocessableentity, gin.h{
            "error": true,
            "message": "invalid request body",
        })
        return
    }

    for rows.next(){
        var singlepost model.post
        if err := rows.scan(&singlepost.id, &singlepost.title, &singlepost.description); err != nil {
            c.json(http.statusunprocessableentity, gin.h{
                "error": true,
                "message": "invalid request body",
            })
            return
        }
        posts = append(posts, singlepost)
    }

    c.json(http.statusok, posts)
}

关于管理模型

package model

// admin example

type admin struct {
    id int64        `json: "id" example:"1"`
    username string     `json: "username" example:"admin name"`
    password string     `json: "password" example:"h56yggy7uj"`
}

我的帖子模型

package model

type Post struct {
    ID int64            `json: "id"`
    Title string        `json: "title"`
    Description *string     `json: "description"`
}

请我不知道我做错了什么，我需要帮助，因为我希望显示所有信息