BookStack Code Mirror - api-scripts/blob - go-export-page-content/api.go

   1 package main
   2
   3 import (
   4         "crypto/tls"
   5         "encoding/json"
   6         "fmt"
   7         "io/ioutil"
   8         "net/http"
   9         "net/url"
  10         "strconv"
  11         "strings"
  12 )
  13
  14 type BookStackApi struct {
  15         BaseURL     string
  16         TokenID     string
  17         TokenSecret string
  18 }
  19
  20 func NewBookStackApi(baseUrl string, tokenId string, tokenSecret string) *BookStackApi {
  21         api := &BookStackApi{
  22                 BaseURL:     baseUrl,
  23                 TokenID:     tokenId,
  24                 TokenSecret: tokenSecret,
  25         }
  26
  27         return api
  28 }
  29
  30 func (bs BookStackApi) authHeader() string {
  31         return fmt.Sprintf("Token %s:%s", bs.TokenID, bs.TokenSecret)
  32 }
  33
  34 func (bs BookStackApi) getRequest(method string, urlPath string, data map[string]string) *http.Request {
  35         method = strings.ToUpper(method)
  36         completeUrlStr := fmt.Sprintf("%s/api/%s", strings.TrimRight(bs.BaseURL, "/"), strings.TrimLeft(urlPath, "/"))
  37
  38         queryValues := url.Values{}
  39         for k, v := range data {
  40                 queryValues.Add(k, v)
  41         }
  42         encodedData := queryValues.Encode()
  43
  44         r, err := http.NewRequest(method, completeUrlStr, strings.NewReader(encodedData))
  45         if err != nil {
  46                 panic(err)
  47         }
  48
  49         r.Header.Add("Authorization", bs.authHeader())
  50
  51         if method != "GET" && method != "HEAD" {
  52                 r.Header.Add("Content-Type", "application/x-www-form-urlencoded")
  53                 r.Header.Add("Content-Length", strconv.Itoa(len(encodedData)))
  54         } else {
  55                 r.URL.RawQuery = encodedData
  56         }
  57
  58         return r
  59 }
  60
  61 func (bs BookStackApi) doRequest(method string, urlPath string, data map[string]string) []byte {
  62         client := &http.Client{
  63                 Transport: &http.Transport{
  64                         TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
  65                 },
  66         }
  67         r := bs.getRequest(method, urlPath, data)
  68         res, err := client.Do(r)
  69         if err != nil {
  70                 panic(err)
  71         }
  72
  73         defer res.Body.Close()
  74
  75         body, err := ioutil.ReadAll(res.Body)
  76         if err != nil {
  77                 panic(err)
  78         }
  79
  80         return body
  81 }
  82
  83 func (bs BookStackApi) getFromListResponse(responseData []byte, models any) ListResponse {
  84         var response ListResponse
  85
  86         if err := json.Unmarshal(responseData, &response); err != nil {
  87                 panic(err)
  88         }
  89
  90         if err := json.Unmarshal(response.Data, models); err != nil {
  91                 panic(err)
  92         }
  93
  94         return response
  95 }
  96
  97 func (bs BookStackApi) GetBooks(count int, page int) ([]Book, int) {
  98         var books []Book
  99
 100         data := bs.doRequest("GET", "/books", getPagingParams(count, page))
 101         response := bs.getFromListResponse(data, &books)
 102
 103         return books, response.Total
 104 }
 105
 106 func (bs BookStackApi) GetChapters(count int, page int) ([]Chapter, int) {
 107         var chapters []Chapter
 108
 109         data := bs.doRequest("GET", "/chapters", getPagingParams(count, page))
 110         response := bs.getFromListResponse(data, &chapters)
 111
 112         return chapters, response.Total
 113 }
 114
 115 func (bs BookStackApi) GetPages(count int, page int) ([]Page, int) {
 116         var pages []Page
 117
 118         data := bs.doRequest("GET", "/pages", getPagingParams(count, page))
 119         response := bs.getFromListResponse(data, &pages)
 120
 121         return pages, response.Total
 122 }
 123
 124 func (bs BookStackApi) GetPage(id int) Page {
 125         var page Page
 126
 127         data := bs.doRequest("GET", fmt.Sprintf("/pages/%d", id), nil)
 128         if err := json.Unmarshal(data, &page); err != nil {
 129                 panic(err)
 130         }
 131
 132         return page
 133 }
 134
 135 func getPagingParams(count int, page int) map[string]string {
 136         return map[string]string{
 137                 "count":  strconv.Itoa(count),
 138                 "offset": strconv.Itoa(count * (page - 1)),
 139         }
 140 }