BookStack

Get / Post / Delete options 
 works roughly like this: 
 # Import all markdown files into a book
find . -name '*.md' -print0 | while IFS= read -r -d '' file; do
 python bookstack-api.py markdown_inport "$file"
done

# Trash all pages containing a search query:
python bookstack-api.py search_delete "encryption_cipher_text"
 
 Note on import: It does not handle any images, tags. The page title is the filename 
 #!/usr/bin/env python3

import os
import sys
import requests

# This is where BookStack API details can be hard-coded if you prefer
# to write them in this script instead of using environment variables.
default_bookstack_options = {
 "url": 'https://brain.vandragt.com',
 "token_id": 'n0N3L...rDvED',
 "token_secret": 'jshjIdU...TeWqCtZX',
 "book_id": 17,
}

# Gather the BookStack API options either from the hard-coded details above otherwise
# it defaults back to environment variables.
def gather_api_options() -> dict:
 return {
 "url": default_bookstack_options["url"] or os.getenv("BS_URL"),
 "token_id": default_bookstack_options["token_id"] or os.getenv("BS_TOKEN_ID"),
 "token_secret": default_bookstack_options["token_secret"] or os.getenv("BS_TOKEN_SECRET"),
 "book_id": default_bookstack_options["book_id"] or os.getenv("BS_BOOK_ID"),
 }

# Send a multipart post request to BookStack, at the given endpoint with the given data.
def bookstack_delete(endpoint: str) -> dict:
 # Fetch the API-specific options
 bs_api_opts = gather_api_options()

 # Format the request URL and the authorization header, so we can access the API
 request_url = bs_api_opts["url"].rstrip("/") + "/api/" + endpoint.lstrip("/")
 request_headers = {
 "Authorization": "Token {}:{}".format(bs_api_opts["token_id"], bs_api_opts["token_secret"])
 }

 # Make the request to bookstack with the gathered details
 response = requests.delete(request_url, headers=request_headers)

 # Throw an error if the request was not successful
 response.raise_for_status()

 # Return the response data decoded from it's JSON format
 return 

# Send a get request to BookStack, at the given endpoint with the given data.
def bookstack_get(endpoint: str, data: dict) -> dict:
 # Fetch the API-specific options
 bs_api_opts = gather_api_options()

 # Format the request URL and the authorization header, so we can access the API
 request_url = bs_api_opts["url"].rstrip("/") + "/api/" + endpoint.lstrip("/")
 request_headers = {
 "Authorization": "Token {}:{}".format(bs_api_opts["token_id"], bs_api_opts["token_secret"])
 }

 # Make the request to bookstack with the gathered details
 response = requests.get(request_url, headers=request_headers, params=data)

 # Throw an error if the request was not successful
 response.raise_for_status()

 # Return the response data decoded from it's JSON format
 return response.json()

# Send a post request to BookStack, at the given endpoint with the given data.
def bookstack_post(endpoint: str, data: dict) -> dict:
 # Fetch the API-specific options
 bs_api_opts = gather_api_options()

 # Format the request URL and the authorization header, so we can access the API
 request_url = bs_api_opts["url"].rstrip("/") + "/api/" + endpoint.lstrip("/")
 request_headers = {
 "Authorization": "Token {}:{}".format(bs_api_opts["token_id"], bs_api_opts["token_secret"])
 }

 # Make the request to bookstack with the gathered details
 response = requests.post(request_url, headers=request_headers, data=data)

 # Throw an error if the request was not successful
 response.raise_for_status()

 # Return the response data decoded from it's JSON format
 return response.json()

# Error out and exit the app
def error_out(message: str):
 print(message)
 exit(1)

def search_delete():
 if len(sys.argv) < 3:
 error_out("search_delete <query> arguments need to be provided")
 
 get_data = {
 "query": sys.argv[2],
 "count": 100
 }

 # Send the upload request and get back the attachment data
 try:
 json = bookstack_get("/search", get_data)
 except requests.HTTPError as e:
 error_out("Upload failed with status {} and data: {}".format(e.response.status_code, e.response.text))

 for page in json['data']:
 try:
 bookstack_delete("/pages/{}".format(page['id']))
 except requests.HTTPError as e:
 error_out("Upload failed with status {} and data: {}".format(e.response.status_code, e.response.text))

 print("deleted: {}".format(page['name']))

def import_markdown():
 if len(sys.argv) < 3:
 error_out("import_markdown <file_path> arguments need to be provided")

 # Gather details from the command line arguments and create a file name
 # from the file path
 file_path = sys.argv[2]
 file_name = os.path.basename(file_path)
 book_id = bs_api_opts["book_id"]

 # Ensure the file exists
 if not os.path.isfile(file_path):
 error_out("Could not find provided file: {}".format(file_path))

 with open(file_path, 'r') as file:
 markdown_content = file.read()

 # Gather the data we'll be sending to BookStack.
 # The format matches that what the "requests" library expects
 # to be provided for its "files" parameter.
 post_data = {
 "name": file_name,
 "markdown": markdown_content,
 "book_id": book_id
 }

 # Send the upload request and get back the attachment data
 try:
 page = bookstack_post("/pages", post_data)
 except requests.HTTPError as e:
 error_out("Upload failed with status {} and data: {}".format(e.response.status_code, e.response.text))

 # Output the results
 print("File successfully uploaded to book {}.".format(book_id))
 print(" - page ID: {}".format(page['id']))
 print(" - page Name: {}".format(page['name']))

# Run this when called on command line
if __name__ == '__main__':
 # Check arguments provided
 if len(sys.argv) < 2:
 error_out("<callback> arguments need to be provided")

 bs_api_opts = gather_api_options()
 callback = sys.argv[1]

 # callback
 possibles = globals().copy()
 possibles.update(locals())
 method = possibles.get(callback)
 if not method:
 raise NotImplementedError("Method %s not implemented" % method_name)
 method()