flaschengeist/flaschengeist/plugins/pricelist/__init__.py

"""Pricelist plugin"""

from flask import Blueprint, jsonify, request, current_app
from werkzeug.local import LocalProxy
from werkzeug.exceptions import BadRequest, Forbidden, Unauthorized

from flaschengeist import logger
from flaschengeist.controller import userController
from flaschengeist.plugins import Plugin
from flaschengeist.utils.decorators import login_required, extract_session
from flaschengeist.utils.HTTP import no_content

from . import models
from . import pricelist_controller, permissions


class PriceListPlugin(Plugin):
    name = "pricelist"
    permissions = permissions.permissions
    blueprint = Blueprint(name, __name__, url_prefix="/pricelist")
    plugin = LocalProxy(lambda: current_app.config["FG_PLUGINS"][PriceListPlugin.name])
    models = models

    def __init__(self, cfg):
        super().__init__(cfg)
        config = {"discount": 0}
        config.update(cfg)


@PriceListPlugin.blueprint.route("/drink-types", methods=["GET"])
@PriceListPlugin.blueprint.route("/drink-types/<int:identifier>", methods=["GET"])
def get_drink_types(identifier=None):
    """Get DrinkType(s)

    Route: ``/pricelist/drink-types`` | Method: ``GET``
    Route: ``/pricelist/drink-types/<identifier>`` | Method: ``GET``

    Args:
        identifier: If querying a spicific DrinkType

    Returns:
        JSON encoded (list of) DrinkType(s) or HTTP-error
    """
    if identifier is None:
        result = pricelist_controller.get_drink_types()
    else:
        result = pricelist_controller.get_drink_type(identifier)
    return jsonify(result)


@PriceListPlugin.blueprint.route("/drink-types", methods=["POST"])
@login_required(permission=permissions.CREATE_TYPE)
def new_drink_type(current_session):
    """Create new DrinkType

    Route ``/pricelist/drink-types`` | Method: ``POST``

    POST-data: ``{name: string}``

    Args:
        current_session: Session sent with Authorization Header

    Returns:
        JSON encoded DrinkType or HTTP-error
    """
    data = request.get_json()
    if "name" not in data:
        raise BadRequest
    drink_type = pricelist_controller.create_drink_type(data["name"])
    return jsonify(drink_type)


@PriceListPlugin.blueprint.route("/drink-types/<int:identifier>", methods=["PUT"])
@login_required(permission=permissions.EDIT_TYPE)
def update_drink_type(identifier, current_session):
    """Modify DrinkType

    Route ``/pricelist/drink-types/<identifier>`` | METHOD ``PUT``

    POST-data: ``{name: string}``

    Args:
        identifier: Identifier of DrinkType
        current_session: Session sent with Authorization Header

    Returns:
        JSON encoded DrinkType or HTTP-error
    """
    data = request.get_json()
    if "name" not in data:
        raise BadRequest
    drink_type = pricelist_controller.rename_drink_type(identifier, data["name"])
    return jsonify(drink_type)


@PriceListPlugin.blueprint.route("/drink-types/<int:identifier>", methods=["DELETE"])
@login_required(permission=permissions.DELETE_TYPE)
def delete_drink_type(identifier, current_session):
    """Delete DrinkType

    Route: ``/pricelist/drink-types/<identifier>`` | Method: ``DELETE``

    Args:
        identifier: Identifier of DrinkType
        current_session: Session sent with Authorization Header

    Returns:
        HTTP-NoContent or HTTP-error
    """
    pricelist_controller.delete_drink_type(identifier)
    return no_content()


@PriceListPlugin.blueprint.route("/tags", methods=["GET"])
@PriceListPlugin.blueprint.route("/tags/<int:identifier>", methods=["GET"])
def get_tags(identifier=None):
    """Get Tag(s)

    Route: ``/pricelist/tags`` | Method: ``GET``
    Route: ``/pricelist/tags/<identifier>`` | Method: ``GET``

    Args:
        identifier: Identifier of Tag

    Returns:
        JSON encoded (list of) Tag(s) or HTTP-error
    """
    if identifier:
        result = pricelist_controller.get_tag(identifier)
    else:
        result = pricelist_controller.get_tags()
    return jsonify(result)


@PriceListPlugin.blueprint.route("/tags", methods=["POST"])
@login_required(permission=permissions.CREATE_TAG)
def new_tag(current_session):
    """Create Tag

    Route: ``/pricelist/tags`` | Method: ``POST``

    POST-data: ``{name: string, color: string}``

    Args:
        current_session: Session sent with Authorization Header

    Returns:
        JSON encoded Tag or HTTP-error
    """
    data = request.get_json()
    drink_type = pricelist_controller.create_tag(data)
    return jsonify(drink_type)


@PriceListPlugin.blueprint.route("/tags/<int:identifier>", methods=["PUT"])
@login_required(permission=permissions.EDIT_TAG)
def update_tag(identifier, current_session):
    """Modify Tag

    Route: ``/pricelist/tags/<identifier>`` | Methods: ``PUT``

    POST-data: ``{name: string, color: string}``

    Args:
        identifier: Identifier of Tag
        current_session: Session sent with Authorization Header

    Returns:
        JSON encoded Tag or HTTP-error
    """
    data = request.get_json()
    tag = pricelist_controller.update_tag(identifier, data)
    return jsonify(tag)


@PriceListPlugin.blueprint.route("/tags/<int:identifier>", methods=["DELETE"])
@login_required(permission=permissions.DELETE_TAG)
def delete_tag(identifier, current_session):
    """Delete Tag

    Route: ``/pricelist/tags/<identifier>`` | Methods: ``DELETE``

    Args:
        identifier: Identifier of Tag
        current_session: Session sent with Authorization Header

    Returns:
        HTTP-NoContent or HTTP-error
    """
    pricelist_controller.delete_tag(identifier)
    return no_content()


@PriceListPlugin.blueprint.route("/drinks", methods=["GET"])
@PriceListPlugin.blueprint.route("/drinks/<int:identifier>", methods=["GET"])
def get_drinks(identifier=None):
    """Get Drink(s)

    Route: ``/pricelist/drinks`` | Method: ``GET``
    Route: ``/pricelist/drinks/<identifier>`` | Method: ``GET``

    Args:
        identifier: Identifier of Drink

    Returns:
        JSON encoded (list of) Drink(s) or HTTP-error
    """
    public = True
    try:
        extract_session()
        public = False
    except Unauthorized:
        public = True

    if identifier:
        result = pricelist_controller.get_drink(identifier, public=public)
    else:
        result = pricelist_controller.get_drinks(public=public)
    logger.debug(f"GET drink {result}")
    return jsonify(result)


@PriceListPlugin.blueprint.route("/drinks/search/<string:name>", methods=["GET"])
def search_drinks(name):
    """Search Drink

    Route: ``/pricelist/drinks/search/<name>`` | Method: ``GET``

    Args:
        name: Name to search

    Returns:
        JSON encoded list of Drinks or HTTP-error
    """
    public = True
    try:
        extract_session()
        public = False
    except Unauthorized:
        public = True
    return jsonify(pricelist_controller.get_drinks(name, public=public))


@PriceListPlugin.blueprint.route("/drinks", methods=["POST"])
@login_required(permission=permissions.CREATE)
def create_drink(current_session):
    """Create Drink

        Route: ``/pricelist/drinks`` | Method: ``POST``

        POST-data :
    ``{
        article_id?: string
        cost_per_package?: float,
        cost_per_volume?: float,
        name: string,
        package_size?: number,
        receipt?: list[string],
        tags?: list[Tag],
        type: DrinkType,
        uuid?: string,
        volume?: float,
        volumes?: list[
            {
                ingredients?: list[{
                    id: int
                    drink_ingredient?: {
                        ingredient_id: int,
                        volume: float
                    },
                    extra_ingredient?: {
                        id: number,
                    }
                }],
                prices?: list[
                    {
                        price: float
                        public: boolean
                    }
                ],
                volume: float
            }
        ]
    }``

        Args:
            current_session: Session sent with Authorization Header

        Returns:
            JSON encoded Drink or HTTP-error
    """
    data = request.get_json()
    return jsonify(pricelist_controller.set_drink(data))


@PriceListPlugin.blueprint.route("/drinks/<int:identifier>", methods=["PUT"])
@login_required(permission=permissions.EDIT)
def update_drink(identifier, current_session):
    """Modify Drink

        Route: ``/pricelist/drinks/<identifier>`` | Method: ``PUT``

        POST-data :
    ``{
        article_id?: string
        cost_per_package?: float,
        cost_per_volume?: float,
        name: string,
        package_size?: number,
        receipt?: list[string],
        tags?: list[Tag],
        type: DrinkType,
        uuid?: string,
        volume?: float,
        volumes?: list[
            {
                ingredients?: list[{
                    id: int
                    drink_ingredient?: {
                        ingredient_id: int,
                        volume: float
                    },
                    extra_ingredient?: {
                        id: number,
                    }
                }],
                prices?: list[
                    {
                        price: float
                        public: boolean
                    }
                ],
                volume: float
            }
        ]
    }``

        Args:
            identifier: Identifier of Drink
            current_session: Session sent with Authorization Header

        Returns:
            JSON encoded Drink or HTTP-error
    """
    data = request.get_json()
    logger.debug(f"update drink {data}")
    return jsonify(pricelist_controller.update_drink(identifier, data))


@PriceListPlugin.blueprint.route("/drinks/<int:identifier>", methods=["DELETE"])
@login_required(permission=permissions.DELETE)
def delete_drink(identifier, current_session):
    """Delete Drink

    Route: ``/pricelist/drinks/<identifier>`` | Method: ``DELETE``

    Args:
        identifier: Identifier of Drink
        current_session: Session sent with Authorization Header

    Returns:
        HTTP-NoContent or HTTP-error
    """
    pricelist_controller.delete_drink(identifier)
    return no_content()


@PriceListPlugin.blueprint.route("/prices/<int:identifier>", methods=["DELETE"])
@login_required(permission=permissions.DELETE_PRICE)
def delete_price(identifier, current_session):
    """Delete Price

    Route: ``/pricelist/prices/<identifier>`` | Methods: ``DELETE``

    Args:
        identifier: Identiefer of Price
        current_session: Session sent with Authorization Header

    Returns:
        HTTP-NoContent or HTTP-error
    """
    pricelist_controller.delete_price(identifier)
    return no_content()


@PriceListPlugin.blueprint.route("/volumes/<int:identifier>", methods=["DELETE"])
@login_required(permission=permissions.DELETE_VOLUME)
def delete_volume(identifier, current_session):
    """Delete DrinkPriceVolume

    Route: ``/pricelist/volumes/<identifier>`` | Method: ``DELETE``

    Args:
        identifier: Identifier of DrinkPriceVolume
        current_session: Session sent with Authorization Header

    Returns:
        HTTP-NoContent or HTTP-error
    """
    pricelist_controller.delete_volume(identifier)
    return no_content()


@PriceListPlugin.blueprint.route("/ingredients/extraIngredients", methods=["GET"])
@login_required()
def get_extra_ingredients(current_session):
    """Get ExtraIngredients

    Route: ``/pricelist/ingredients/extraIngredients`` | Method: ``GET``

    Args:
        current_session: Session sent with Authorization Header

    Returns:
        JSON encoded list of ExtraIngredients or HTTP-error
    """
    return jsonify(pricelist_controller.get_extra_ingredients())


@PriceListPlugin.blueprint.route("/ingredients/<int:identifier>", methods=["DELETE"])
@login_required(permission=permissions.DELETE_INGREDIENTS_DRINK)
def delete_ingredient(identifier, current_session):
    """Delete Ingredient

    Route: ``/pricelist/ingredients/<identifier>`` | Method: ``DELETE``

    Args:
        identifier: Identifier of Ingredient
        current_session: Session sent with Authorization Header

    Returns:
        HTTP-NoContent or HTTP-error
    """
    pricelist_controller.delete_ingredient(identifier)
    return no_content()


@PriceListPlugin.blueprint.route("/ingredients/extraIngredients", methods=["POST"])
@login_required(permission=permissions.EDIT_INGREDIENTS)
def set_extra_ingredient(current_session):
    """Create ExtraIngredient

    Route: ``/pricelist/ingredients/extraIngredients`` | Method: ``POST``

    POST-data: ``{ name: string, price: float }``

    Args:
        current_session: Session sent with Authorization Header

    Returns:
        JSON encoded ExtraIngredient or HTTP-error
    """
    data = request.get_json()
    return jsonify(pricelist_controller.set_extra_ingredient(data))


@PriceListPlugin.blueprint.route("/ingredients/extraIngredients/<int:identifier>", methods=["PUT"])
@login_required(permission=permissions.EDIT_INGREDIENTS)
def update_extra_ingredient(identifier, current_session):
    """Modify ExtraIngredient

    Route: ``/pricelist/ingredients/extraIngredients`` | Method: ``PUT``

    POST-data: ``{ name: string, price: float }``

    Args:
        identifier: Identifier of ExtraIngredient
        current_session: Session sent with Authorization Header

    Returns:
        JSON encoded ExtraIngredient or HTTP-error
    """
    data = request.get_json()
    return jsonify(pricelist_controller.update_extra_ingredient(identifier, data))


@PriceListPlugin.blueprint.route("/ingredients/extraIngredients/<int:identifier>", methods=["DELETE"])
@login_required(permission=permissions.DELETE_INGREDIENTS)
def delete_extra_ingredient(identifier, current_session):
    """Delete ExtraIngredient

    Route: ``/pricelist/ingredients/extraIngredients`` | Method: ``DELETE``

    Args:
        identifier: Identifier of ExtraIngredient
        current_session: Session sent with Authorization Header

    Returns:
        HTTP-NoContent or HTTP-error
    """
    pricelist_controller.delete_extra_ingredient(identifier)
    return no_content()


@PriceListPlugin.blueprint.route("/settings/min_prices", methods=["GET"])
@login_required()
def get_pricelist_settings_min_prices(current_session):
    """Get MinPrices

    Route: ``/pricelist/settings/min_prices`` | Method: ``GET``

    Args:
        current_session: Session sent with Authorization Header

    Returns:
        JSON encoded list of MinPrices
    """
    # TODO: Handle if no prices are set!
    try:
        min_prices = PriceListPlugin.plugin.get_setting("min_prices")
    except KeyError:
        min_prices = []
    return jsonify(min_prices)


@PriceListPlugin.blueprint.route("/settings/min_prices", methods=["POST"])
@login_required(permission=permissions.EDIT_MIN_PRICES)
def post_pricelist_settings_min_prices(current_session):
    """Create MinPrices

    Route: ``/pricelist/settings/min_prices`` | Method: ``POST``

    POST-data: ``list[int]``

    Args:
        current_session: Session sent with Authorization Header

    Returns:
        HTTP-NoContent or HTTP-error
    """
    data = request.get_json()
    if not isinstance(data, list) or not all(isinstance(n, int) for n in data):
        raise BadRequest
    data.sort()
    PriceListPlugin.plugin.set_setting("min_prices", data)
    return no_content()



@PriceListPlugin.blueprint.route("/users/<userid>/pricecalc_columns", methods=["GET", "PUT"])
@login_required()
def get_columns(userid, current_session):
    """Get pricecalc_columns of an user

    Route: ``/users/<userid>/pricelist/pricecac_columns`` | Method: ``GET`` or ``PUT``
    POST-data: On ``PUT`` json encoded array of floats

    Args:
        userid: Userid identifying the user
        current_session: Session sent with Authorization Header

    Returns:
        GET: JSON object containing the shortcuts as float array or HTTP error
        PUT: HTTP-created or HTTP error
    """
    if userid != current_session.user_.userid:
        raise Forbidden

    user = userController.get_user(userid)
    if request.method == "GET":
        return jsonify(user.get_attribute("pricecalc_columns", []))
    else:
        data = request.get_json()
        if not isinstance(data, list) or not all(isinstance(n, str) for n in data):
            raise BadRequest
        data.sort(reverse=True)
        user.set_attribute("pricecalc_columns", data)
        userController.persist()
        return no_content()


@PriceListPlugin.blueprint.route("/drinks/<int:identifier>/picture", methods=["POST", "GET", "DELETE"])
@login_required(permission=permissions.EDIT)
def set_picture(identifier, current_session):
    """Get, Create, Delete Drink Picture

    Route: ``/pricelist/<identifier>/picture`` | Method: ``GET,POST,DELETE``

    POST-data: (if remaining) ``Form-Data: mime: 'image/*'``

    Args:
        identifier: Identifier of Drink
        current_session: Session sent with Authorization

    Returns:
        Picture or HTTP-error
    """
    if request.method == "DELETE":
        pricelist_controller.delete_drink_picture(identifier)
        return no_content()

    file = request.files.get("file")
    if file:
        picture = models._Picture()
        picture.mimetype = file.content_type
        picture.binary = bytearray(file.stream.read())
        return jsonify(pricelist_controller.save_drink_picture(identifier, picture))
    else:
        raise BadRequest


@PriceListPlugin.blueprint.route("/picture/<identifier>", methods=["GET"])
def _get_picture(identifier):
    """Get Picture

    Args:
        identifier: Identifier of Picture

    Returns:
        Picture or HTTP-error
    """
    if request.method == "GET":
        size = request.args.get("size")
        response = pricelist_controller.get_drink_picture(identifier, size)
        return response.make_conditional(request)