from app.tasks import run_update_db
from app import cites

"""For Documentation see =fortuneFastApi.org="""
from http import HTTPStatus
import logging

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, TypeAdapter

DESCRIPTION="""Every one goes with a quote.
See <a href="https://man.freebsd.org/cgi/man.cgi?query=fortune&apropos=0&sektion=6&manpath=FreeBSD+15.0-RELEASE+and+Ports.quarterly&format=html">fortune</a>.
Quotes are from <a href="https://github.com/BerndPaffenholz/fortune-mod.git">here</a>
which is a clone from <a href="https://github.com/shlomif/fortune-mod">fortune-mod</a>.
The fortunes from directory <code>off</code> are omitted.
"""

app = FastAPI(
    title="Fortune - Cookies",
    description=DESCRIPTION,
    summary="Cool sayings for everyone.",
    version="1.6",
    #terms_of_service="https://www.p4ffi.de/Impressum.html",
    contact={
        "name": "Bernd Paffenholz",
        "url": "https://www.p4ffi.de/Impressum.html",
        "email": "kontakt@p4ffi.de",
    },
    license_info={
        "name": "GPLv3",
        "url": "https://www.gnu.org/licenses/gpl-3.0.en.html",
    },
)

<<Mount static files>>

log = logging.getLogger("fortunes")
log.setLevel(logging.<<loglevel>>)
log_format = logging.Formatter(fmt='%(levelname)s: %(message)s')
handler = logging.StreamHandler()
handler.setFormatter(log_format)
log.addHandler(handler)

cites.init_app(app)

run_update_db_id = run_update_db.delay()
log.info("Task %s started.",run_update_db_id)

class Cookie(BaseModel):
    text: str
    category: str

class StatsEntry(BaseModel):
    category: str
    count: int

Stats = TypeAdapter(StatsEntry)

@app.get('/fortunes/v1', response_model=Cookie, tags=["fortunes"])
def get_one_random_cookie():
    try:
        found = cites.find_one()
        return found
    except LookupError as not_found:
        raise HTTPException(status_code=404, detail=not_found.args[0])

from app import webhook
@app.post('/fortunes/v1', tags=["fortunes"], status_code=HTTPStatus.ACCEPTED, \
          description='Webhook for github pull request. See <a href="https://docs.github.com/de/webhooks/using-webhooks/">github webhooks</a>')
@webhook.webhook_PR_github
def update_fortunes_database() -> dict:
    try:
        log.debug("post requested.")
        result = run_update_db.delay()
        return {"update-task-id": result.id}
    except Exception:
        raise HTTPException(status_code=500, detail="Problem with the workflow.")

@app.get('/fortunes/v1/categories', response_model=dict[str,int], tags=["categories"])
def get_category_stats():
    try:
        return cites.list_categories()
    except Exception:
        raise HTTPException(status_code=500, detail="Problem with the database.")

@app.get('/fortunes/v1/categories/{category}', response_model=Cookie, tags=["categories"])
def get_one_random_fortune_from_category(category: str):
    try:
        cookie = cites.find_one(category)
    except LookupError as problem:
        raise HTTPException(status_code=500, detail=f"Problem with category '{category}'.")
    if cookie is None:
        raise HTTPException(status_code=404, detail=f"Category '{category}' not found.")
    return cookie

import logging
from typing import List, Any
from fastapi import Depends, Request, HTTPException, status
from fastapi.security import APIKeyHeader
from pydantic import BaseModel
import hashlib
import hmac

event = APIKeyHeader(name="X-GitHub-Event")
signature = APIKeyHeader(name="X-Hub-Signature-256")

class PullRequestBase(BaseModel):
    ref: str

class PullRequest(BaseModel):
    base: PullRequestBase
    merged: bool

class PayloadPullRequest(BaseModel):
    action: str
    pull_request: PullRequest

log = logging.getLogger("fortunes")

def webhook_PR_github (func):
    log.debug(f"webhook_PR_github")
    with open('/run/secrets/github',mode='r') as file:
        secret = file.read()
    async def webhook_pullrequest_from_git (payload: PayloadPullRequest, req: Request, \
                                            key: str = Depends(signature), event: str = Depends(event)):
        log.debug(f"checking for security {key},{event}")
        body = await req.body()
        log.debug("checking for security %s", payload)
        verify_signature(body, secret, key)
        log.debug(f"{payload}")
        if event == "pull_request" and \
           payload.action == "closed" and \
           payload.pull_request.base.ref == "main" and\
           payload.pull_request.merged:
            return func()
        log.info("Request not satisfying.")
        raise HTTPException(status.HTTP_200_OK)
    return webhook_pullrequest_from_git

def verify_signature(payload_body, secret_token, signature_header):
    if not signature_header:
        raise HTTPException(status_code=403, detail="signature header missing!")
    hash_object = hmac.new(secret_token.encode('utf-8'), msg=payload_body, digestmod=hashlib.sha256)
    expected_signature = "sha256=" + hash_object.hexdigest()
    log.debug(f"expected_signature {expected_signature}")
    if not hmac.compare_digest(expected_signature, signature_header):
        raise HTTPException(status_code=403, detail="signatures didn't match!")

import logging
<<cites-import-standard>>

from pymongo import MongoClient
<<cites-import-specific>>

log = logging.getLogger("fortunes")

with open('/run/secrets/mongo',mode='r') as file:
    username = file.readline().strip()
    password = file.readline().strip()

mongodb = MongoClient("mongodb://mongo:27017/",username=username,password=password)
DATABASENAME = "fortune"
citesdb = mongodb[DATABASENAME].sayings
confdb = mongodb[DATABASENAME].config

def close_db(_e=None):
    if mongodb is not None:
        mongodb.close()

def find_one (cat=None):
    query = ([] if cat is None else [{"$match": {"category": cat} }]) + \
        [{"$sample": {"size": 1}}]
    try:
        cursor = citesdb.aggregate(query)
        if cursor.alive:
            sample = cursor.next()
            return { k:sample[k] for k in ("text", "category") }
        return None
    except Exception as exc:
        log.error(exc)
        raise LookupError("Problem with sample.")

def list_categories () -> dict:
    counts = citesdb.aggregate([{ "$group": { "_id": "$category", "count": { "$count": {} } } }])
    stats = {c["_id"]: c["count"] for c in counts}
    return stats

def init_app(_app):
    if not DATABASENAME in mongodb.list_database_names():
        log.warning("no database")
        mongodb[DATABASENAME].config.insert_one({"name": 'git-commit-id', "value": None})
        return False
    return True

def add_saying_with_category (saying, category):
    citesdb.insert_one({"category": category, "text": saying })

def remove_category (category):
    citesdb.delete_many({"category": category })

def read_category_file_add_to_collection (file):
    count = 0
    saying = ""
    category = file.name

    remove_category(category)

    with file.open("r") as contents:
        for line in contents:
            if line == "%\n":
                if saying != "":
                    count += 1
                    add_saying_with_category (saying, category)
                    saying = ""
            else:
                saying += line

    log.debug({category: count})
    return {category: count}

def list_files_for_cites ():
    source = Path('/fortune-mod/fortune-mod/datfiles')
    lof = [str(f) for f in source.iterdir() if f.is_file() and f.suffix == ""]
    return lof

from pathlib import Path
from subprocess import check_output, call

def get_current_git_commit_id ():
    call(['git', 'pull', '--ff-only'],cwd="/fortune-mod")
    return check_output(['git', 'log', '-1', '--format=%H'], shell=False, text=True,cwd="/fortune-mod")

def get_db_git_commit_id ():
    commit_value = confdb.find_one({"name":"git-commit-id"})
    return "" if commit_value is None else commit_value["value"] or ""

def update_git_commit_id ():
    git_id = get_current_git_commit_id()
    confdb.update_one({"name":"git-commit-id"}, {"$set":{"value":git_id}}, upsert=True)

import operator
from functools import reduce
from pathlib import Path

from celery import Celery, chain, group
from celery.schedules import crontab
from celery.utils.log import get_task_logger
import app.cites as cites

app = Celery('tasks', backend='rpc://guest@rabbitmq', broker='pyamqp://guest@rabbitmq//')
app.conf.timezone = 'Europe/Berlin'
logger = get_task_logger("fortunes")

@app.on_after_configure.connect
def setup_periodic_tasks(sender, **kwargs):
    # Executes every morning at 0500
    sender.add_periodic_task(
        crontab(minute=0,hour=5),
        run_update_db.s()
    )

@app.task
def run_update_db():
    logger.debug("Run the task 'run_update_db'.")
    if cites.get_current_git_commit_id() != cites.get_db_git_commit_id():
        logger.debug("Mid in run_update_db")
        res = chain(list_files.s(), map_in_group.s(), compare_categories.s(), update_gitid.si())
        return res()
    else:
        logger.info("Update not triggered.")
    return False

@app.task
def list_files():
    logger.debug("list files")
    return cites.list_files_for_cites()

@app.task
def map_in_group (filelist):
    logger.debug("map_in_group %s", filelist)
    load_files_group = group([load_one_file.s(f) for f in filelist])()
    loaded_files = load_files_group.get(disable_sync_subtasks=False)
    logger.debug("returns %s", loaded_files)
    return loaded_files

@app.task(ignore_result=False)
def load_one_file(filename):
    logger.debug("load_one_file %s", filename)
    return cites.read_category_file_add_to_collection(Path(filename))

@app.task(ignore_result=False)
def compare_categories (results):
    logger.debug("compare_categories %s", results)
    new_loaded_categories = reduce(operator.or_,results)
    current_categories = cites.list_categories()
    to_be_dropped = filter(lambda cat: cat not in new_loaded_categories, current_categories.keys())
    for cat in to_be_dropped:
        logger.info("dropping %s", cat)
        cites.remove_category(cat)
    return True

@app.task
def update_gitid ():
    logger.debug("Update git id")
    cites.update_git_commit_id()
    return True

celery multi start -A app.tasks worker -B -s /var/log/celery/celerybeat-schedule --loglevel=<<loglevel>>

from fastapi.staticfiles import StaticFiles
app.mount("/static", StaticFiles(directory="/static"), name="static")

from fastapi.responses import FileResponse

@app.get("/favicon.ico", include_in_schema=False)
def get_icon():
    return FileResponse("/static/favicon.ico")

<!DOCTYPE html>
<html>
  <head><title>Fortunes</title></head>
  <body>
    <button onclick="fetch('/fortunes/v1').then(x => x.text()).then(y => document.getElementById('out').innerHTML=JSON.parse(y).text)">Fresh Fortune</button>
    <pre id="out"></pre>
  </body>
</html>

MONGO_INITDB_ROOT_USERNAME=username
MONGO_INITDB_ROOT_PASSWORD=password

ME_CONFIG_MONGODB_URL="mongodb://username:password@mongo:27017/"

services:

  mongo:
    image: mongo:latest
    restart: always
    networks:
      - fortune
    healthcheck:
      test: ["CMD","mongosh", "--eval", "db.adminCommand('ping')"]
      interval: 10s
      timeout: 3s
      retries: 5
    env_file: mongo.env
    volumes:
      - "datastore:/data/db"

  rabbitmq:
    image: rabbitmq:4.2
    restart: always
    healthcheck:
      test: ["CMD", "rabbitmq-diagnostics", "-q", "ping"]
      interval: 5s
      timeout: 3s
      retries: 3
    networks:
      - fortune
    volumes:
      - "./rabbitmq/50-timeout.conf:/etc/rabbitmq/conf.d/50-timeout.conf"

  fortune:
    image: berndpaffenholz/fortune:1.6.6
    restart: always
    build: .
    networks:
      - fortune
      - behind-proxy
    secrets:
      - github
      - mongo
    volumes:
      - "./static:/static"
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.fortune.entrypoints=web-secure"
      - "traefik.http.routers.fortune.rule=Host(`api.p4ffi.de`)"
      - "traefik.http.routers.fortune.service=fortune"
      - "traefik.http.routers.fortune.tls=true"
      - "traefik.http.routers.fortune.tls.certresolver=letsencrypt"
      - "traefik.http.routers.fortune.tls.domains[0].main=api.p4ffi.de"
      - "traefik.http.services.fortune.loadbalancer.server.port=80"
      - "traefik.docker.network=behind-proxy"
    depends_on:
      mongo:
        condition: service_healthy
      rabbitmq:
        condition: service_healthy

secrets:
  github:
    file: ./secrets
  mongo:
    file: ./mongosecrets

volumes:
  datastore:

networks:
  fortune:
  behind-proxy:
    external: true

# consumer timeout for use with fortune
consumer_timeout = 172800000

GET https://api.p4ffi.de/fortunes/v1

GET http://localhost:80/fortunes/v1

GET https://api.p4ffi.de/fortunes/v1/categories