redstring/redstring/server.py

"""
Logic for serving a collection of documents through a web frontend.
"""
import argparse
import json
import logging
import os
import random
import string

from flask import (
    abort,
    current_app,
    Flask,
    redirect,
    render_template,
    request,
    safe_join,
    url_for,
)

from redstring.library import generate_index_document, generate_default_document
from redstring.parser import (
    Document,
    DocumentTab,
    DocumentTag,
    DocumentSubtag,
    dump,
    load,
    parse_document_from_json,
    TagOptions,
)


CONFIG_ENVVAR = 'REDSTRING_CONFIG'

logger = logging.getLogger(__name__)

app = Flask(__name__)


@app.context_processor
def inject_edit():
    return {'edit': current_app.config['edit']}


@app.route('/', methods=['GET'])
def root():
    return redirect(url_for('index'))


@app.route('/index/', methods=['GET'])
def index():
    document = generate_index_document(current_app.config['root'])
    return render_template('doc.jinja', document=document, index=True)


@app.route('/doc/<document_id>', methods=['GET'])
def document(document_id):
    doc_path = safe_join(current_app.config['root'], f'{document_id}.json')
    if not os.path.isfile(doc_path):
        return abort(404)
    with open(doc_path) as f:
        doc = load(f)
    return render_template('doc.jinja', document=doc, index=False)


@app.route('/new/', methods=['GET'])
def new():
    if not current_app.config.get('edit'):
        return abort(404)

    document_id = 'new'
    new_doc = generate_default_document(document_id)
    doc_path = safe_join(current_app.config['root'], f'{document_id}.json')
    with open(doc_path, 'w') as f:
        dump(new_doc, f)
    return redirect(url_for('document', document_id=document_id))


@app.route('/edit/<document_id>', methods=['GET', 'POST'])
def edit(document_id):
    if not current_app.config.get('edit'):
        return abort(404)

    doc_path = safe_join(current_app.config['root'], f'{document_id}.json')

    # Check for content updates
    if request.method == 'POST':
        sent_json = request.json
        new_doc: Document = parse_document_from_json(sent_json)
        with open(doc_path, 'w') as f:
            dump(new_doc, f)
        return {}

    # Load the document to edit
    if not os.path.isfile(doc_path):
        return abort(404)
    with open(doc_path) as f:
        doc: Document = load(f)

    # Check for structural updates
    if add := request.args.get('add'):
        if add == 'tab':
            new_tab = DocumentTab('newtab', [])
            doc.tabs.append(new_tab)
            with open(doc_path, 'w') as f:
                dump(doc, f)
            return redirect(url_for('edit', document_id=document_id))
        elif add == 'tag':
            if tab_name := request.args.get('tab'):
                tab = doc.get_tab(tab_name)
                new_tag = DocumentTag('tag', '', TagOptions(private=True))
                tab.tags.append(new_tag)
                with open(doc_path, 'w') as f:
                    dump(doc, f)
                return redirect(url_for('edit', document_id=document_id))
            return abort(400)
        elif add == 'subtag':
            if tag_name := request.args.get('tag'):
                tag = doc.get_tag(tag_name)
                new_subtag = DocumentSubtag('subtag', '', TagOptions(private=True))
                tag.subtags.append(new_subtag)
                with open(doc_path, 'w') as f:
                    dump(doc, f)
                return redirect(url_for('edit', document_id=document_id))
            return abort(400)

    elif option := request.args.get('option'):
        if tag_name := request.args.get('tag'):
            tag = doc.get_tag(tag_name)
            if option == 'hyperlink':
                tag.options.hyperlink = not tag.options.hyperlink
            elif option == 'interlink':
                print(tag.options.options)
                tag.options.interlink = not tag.options.interlink
            elif option == 'private':
                tag.options.private = not tag.options.private
            else:
                return abort(400)
            with open(doc_path, 'w') as f:
                dump(doc, f)
            return redirect(url_for('edit', document_id=document_id))
        elif tab_name := request.args.get('tab'):
            tab = doc.get_tab(tab_name)
            if option == 'priority':
                value = request.args.get('value', 0)
                tab.options.priority = value
            elif option == 'hide_names':
                tab.options.hide_names = not tab.options.hide_names
            elif option == 'private':
                tab.options.private = not tab.options.private
            else:
                return abort(400)
            with open(doc_path, 'w') as f:
                dump(doc, f)
            return redirect(url_for('edit', document_id=document_id))

    # Otherwise, return the editor page
    else:
        return render_template('edit.jinja', document=doc, index=False)


def read_config(app, path):
    with open(path) as f:
        config = json.load(f)
    app.config['root'] = config['root']
    app.config['edit'] = config['edit']
    return config


def cli():
    parser = argparse.ArgumentParser(description="Run the redstring server.")
    parser.add_argument("--config", help="Config file path.")
    parser.add_argument("--debug", action="store_true")
    parser.add_argument("--port", type=int, default=5000)
    args = parser.parse_args()
    config_path = args.config or os.environ.get(CONFIG_ENVVAR) or '/etc/redstring.conf'
    config = read_config(app, config_path)
    app.run(debug=args.debug, port=args.port)


def wsgi():
    config_path = os.environ.get(CONFIG_ENVVAR) or '/etc/redstring.conf'
    config = read_config(app, config_path)
    logger.setLevel(logging.DEBUG)
    logger.debug(f'Loaded config from {config_path}: {config}')
    return app