flaschengeist/flaschengeist/plugins/pricelist/pricelist_controller.py

from werkzeug.exceptions import BadRequest, NotFound
from sqlalchemy.exc import IntegrityError
from uuid import uuid4

from flaschengeist import logger
from flaschengeist.config import config
from flaschengeist.database import db
from flaschengeist.utils.picture import save_picture, get_picture, delete_picture
from flaschengeist.utils.decorators import extract_session

from .models import Drink, DrinkPrice, Ingredient, Tag, DrinkType, DrinkPriceVolume, DrinkIngredient, ExtraIngredient
from .permissions import EDIT_VOLUME, EDIT_PRICE, EDIT_INGREDIENTS_DRINK


def update():
    db.session.commit()


def get_tags():
    return Tag.query.all()


def get_tag(identifier):
    if isinstance(identifier, int):
        ret = Tag.query.get(identifier)
    elif isinstance(identifier, str):
        ret = Tag.query.filter(Tag.name == identifier).one_or_none()
    else:
        logger.debug("Invalid identifier type for Tag")
        raise BadRequest
    if ret is None:
        raise NotFound
    return ret


def create_tag(data):
    try:
        if "id" in data:
            data.pop("id")
        allowed_keys = Tag().serialize().keys()
        values = {key: value for key, value in data.items() if key in allowed_keys}
        tag = Tag(**values)
        db.session.add(tag)
        update()
        return tag
    except IntegrityError:
        raise BadRequest("Name already exists")


def update_tag(identifier, data):
    tag = get_tag(identifier)
    allowed_keys = Tag().serialize().keys()
    values = {key: value for key, value in data.items() if key in allowed_keys}
    for key, value in values.items():
        setattr(tag, key, value)
    try:
        update()
    except IntegrityError:
        raise BadRequest("Name already exists")


def delete_tag(identifier):
    tag = get_tag(identifier)
    db.session.delete(tag)
    try:
        update()
    except IntegrityError:
        raise BadRequest("Tag still in use")


def get_drink_types():
    return DrinkType.query.all()


def get_drink_type(identifier):
    if isinstance(identifier, int):
        ret = DrinkType.query.get(identifier)
    elif isinstance(identifier, str):
        ret = DrinkType.query.filter(Tag.name == identifier).one_or_none()
    else:
        logger.debug("Invalid identifier type for DrinkType")
        raise BadRequest
    if ret is None:
        raise NotFound
    return ret


def create_drink_type(name):
    try:
        drink_type = DrinkType(name=name)
        db.session.add(drink_type)
        update()
        return drink_type
    except IntegrityError:
        raise BadRequest("Name already exists")


def rename_drink_type(identifier, new_name):
    drink_type = get_drink_type(identifier)
    drink_type.name = new_name
    try:
        update()
    except IntegrityError:
        raise BadRequest("Name already exists")
    return drink_type


def delete_drink_type(identifier):
    drink_type = get_drink_type(identifier)
    db.session.delete(drink_type)
    try:
        update()
    except IntegrityError:
        raise BadRequest("DrinkType still in use")


def _create_public_drink(drink):
    _volumes = []
    for volume in drink.volumes:
        _prices = []
        for price in volume.prices:
            price: DrinkPrice
            if price.public:
                _prices.append(price)
        volume.prices = _prices
        if len(volume.prices) > 0:
            _volumes.append(volume)
    drink.volumes = _volumes
    if len(drink.volumes) > 0:
        return drink
    return None


def get_drinks(name=None, public=False, limit=None, offset=None, search_name=None, search_key=None, ingredient=False):
    count = None
    if name:
        query = Drink.query.filter(Drink.name.contains(name))
    else:
        query = Drink.query
    if ingredient:
        query = query.filter(Drink.cost_per_volume >= 0)
    if search_name:
        if search_key == "name":
            query = query.filter(Drink.name.contains(search_name))
        elif search_key == "article_id":
            query = query.filter(Drink.article_id.contains(search_name))
        elif search_key == "drink_type":
            query = query.filter(Drink.type.has(DrinkType.name.contains(search_name)))
        elif search_key == "tags":
            query = query.filter(Drink.tags.any(Tag.name.contains(search_name)))
        else:
            query = query.filter(
                (Drink.name.contains(search_name))
                | (Drink.article_id.contains(search_name))
                | (Drink.type.has(DrinkType.name.contains(search_name)))
                | (Drink.tags.any(Tag.name.contains(search_name)))
            )

    if limit is not None:
        count = query.count()
        query = query.limit(limit)
    if offset is not None:
        query = query.offset(offset)
    drinks = query.all()
    if public:
        return [_create_public_drink(drink) for drink in drinks if _create_public_drink(drink)], count
    return drinks, count


def get_drink(identifier, public=False):
    drink = None
    if isinstance(identifier, int):
        drink = Drink.query.get(identifier)
    elif isinstance(identifier, str):
        drink = Drink.query.filter(Tag.name == identifier).one_or_none()
    else:
        raise BadRequest("Invalid identifier type for Drink")
    if drink is None:
        raise NotFound
    if public:
        return _create_public_drink(drink)
    return drink


def set_drink(data):
    return update_drink(-1, data)


def update_drink(identifier, data):
    try:
        session = extract_session()
        if "id" in data:
            data.pop("id")
        volumes = data.pop("volumes") if "volumes" in data else None
        tags = []
        if "tags" in data:
            _tags = data.pop("tags")
            if isinstance(_tags, list):
                for _tag in _tags:
                    if isinstance(_tag, dict) and "id" in _tag:
                        tags.append(get_tag(_tag["id"]))
        drink_type = data.pop("type")
        if isinstance(drink_type, dict) and "id" in drink_type:
            drink_type = drink_type["id"]
        drink_type = get_drink_type(drink_type)
        if identifier == -1:
            drink = Drink()
            db.session.add(drink)
        else:
            drink = get_drink(identifier)
        for key, value in data.items():
            if hasattr(drink, key):
                setattr(drink, key, value if value != "" else None)

        if drink_type:
            drink.type = drink_type
        if volumes is not None and session.user_.has_permission(EDIT_VOLUME):
            drink.volumes = []
            drink.volumes = set_volumes(volumes)
        if len(tags) > 0:
            drink.tags = tags
        db.session.commit()
        return drink
    except (NotFound, KeyError):
        raise BadRequest


def set_volumes(volumes):
    retVal = []
    if not isinstance(volumes, list):
        raise BadRequest
    for volume in volumes:
        retVal.append(set_volume(volume))
    return retVal


def delete_drink(identifier):
    drink = get_drink(identifier)
    if drink.uuid:
        path = config["pricelist"]["path"]
        delete_picture(f"{path}/{drink.uuid}")
    db.session.delete(drink)
    db.session.commit()


def get_volume(identifier):
    return DrinkPriceVolume.query.get(identifier)


def get_volumes(drink_id=None):
    if drink_id:
        return DrinkPriceVolume.query.filter(DrinkPriceVolume.drink_id == drink_id).all()
    return DrinkPriceVolume.query.all()


def set_volume(data):
    session = extract_session()
    allowed_keys = DrinkPriceVolume().serialize().keys()
    values = {key: value for key, value in data.items() if key in allowed_keys}
    prices = None
    ingredients = None
    if "prices" in values:
        prices = values.pop("prices")
    if "ingredients" in values:
        ingredients = values.pop("ingredients")
    vol_id = values.pop("id", None)
    if vol_id < 0:
        volume = DrinkPriceVolume(**values)
        db.session.add(volume)
    else:
        volume = get_volume(vol_id)
        if not volume:
            raise NotFound
        for key, value in values.items():
            setattr(volume, key, value if value != "" else None)

    if prices and session.user_.has_permission(EDIT_PRICE):
        set_prices(prices, volume)
    if ingredients and session.user_.has_permission(EDIT_INGREDIENTS_DRINK):
        set_ingredients(ingredients, volume)
    return volume


def set_prices(prices, volume):
    if isinstance(prices, list):
        _prices = []
        for _price in prices:
            price = set_price(_price)
            _prices.append(price)
        volume.prices = _prices


def set_ingredients(ingredients, volume):
    if isinstance(ingredients, list):
        _ingredietns = []
        for _ingredient in ingredients:
            ingredient = set_ingredient(_ingredient)
            _ingredietns.append(ingredient)
        volume.ingredients = _ingredietns


def delete_volume(identifier):
    volume = get_volume(identifier)
    db.session.delete(volume)
    db.session.commit()


def get_price(identifier):
    if isinstance(identifier, int):
        return DrinkPrice.query.get(identifier)
    raise NotFound


def get_prices(volume_id=None):
    if volume_id:
        return DrinkPrice.query.filter(DrinkPrice.volume_id_ == volume_id).all()
    return DrinkPrice.query.all()


def set_price(data):
    allowed_keys = list(DrinkPrice().serialize().keys())
    allowed_keys.append("description")
    logger.debug(f"allowed_key {allowed_keys}")
    values = {key: value for key, value in data.items() if key in allowed_keys}
    price_id = values.pop("id", -1)
    if price_id < 0:
        price = DrinkPrice(**values)
        db.session.add(price)
    else:
        price = get_price(price_id)
        if not price:
            raise NotFound
        for key, value in values.items():
            setattr(price, key, value)

    return price


def delete_price(identifier):
    price = get_price(identifier)
    db.session.delete(price)
    db.session.commit()


def set_drink_ingredient(data):
    allowed_keys = DrinkIngredient().serialize().keys()
    values = {key: value for key, value in data.items() if key in allowed_keys}
    if "cost_per_volume" in values:
        values.pop("cost_per_volume")
    if "name" in values:
        values.pop("name")
    ingredient_id = values.pop("id", -1)
    if ingredient_id < 0:
        drink_ingredient = DrinkIngredient(**values)
        db.session.add(drink_ingredient)
    else:
        drink_ingredient = DrinkIngredient.query.get(ingredient_id)
        if not drink_ingredient:
            raise NotFound
        for key, value in values.items():
            setattr(drink_ingredient, key, value if value != "" else None)
    return drink_ingredient


def get_ingredient(identifier):
    return Ingredient.query.get(identifier)


def set_ingredient(data):
    drink_ingredient_value = None
    extra_ingredient_value = None
    if "drink_ingredient" in data:
        drink_ingredient_value = data.pop("drink_ingredient")
    if "extra_ingredient" in data:
        extra_ingredient_value = data.pop("extra_ingredient")
    ingredient_id = data.pop("id", -1)
    if ingredient_id < 0:
        ingredient = Ingredient(**data)
        db.session.add(ingredient)
    else:
        ingredient = get_ingredient(ingredient_id)
        if not ingredient:
            raise NotFound
    if drink_ingredient_value:
        ingredient.drink_ingredient = set_drink_ingredient(drink_ingredient_value)
    if extra_ingredient_value:
        if "id" in extra_ingredient_value:
            ingredient.extra_ingredient = get_extra_ingredient(extra_ingredient_value.get("id"))
    return ingredient


def delete_ingredient(identifier):
    ingredient = get_ingredient(identifier)
    if ingredient.drink_ingredient:
        db.session.delete(ingredient.drink_ingredient)
    db.session.delete(ingredient)
    db.session.commit()


def get_extra_ingredients():
    return ExtraIngredient.query.all()


def get_extra_ingredient(identifier):
    return ExtraIngredient.query.get(identifier)


def set_extra_ingredient(data):
    allowed_keys = ExtraIngredient().serialize().keys()
    if "id" in data:
        data.pop("id")
    values = {key: value for key, value in data.items() if key in allowed_keys}
    extra_ingredient = ExtraIngredient(**values)
    db.session.add(extra_ingredient)
    db.session.commit()
    return extra_ingredient


def update_extra_ingredient(identifier, data):
    allowed_keys = ExtraIngredient().serialize().keys()
    if "id" in data:
        data.pop("id")
    values = {key: value for key, value in data.items() if key in allowed_keys}
    extra_ingredient = get_extra_ingredient(identifier)
    if extra_ingredient:
        for key, value in values.items():
            setattr(extra_ingredient, key, value)
    db.session.commit()
    return extra_ingredient


def delete_extra_ingredient(identifier):
    extra_ingredient = get_extra_ingredient(identifier)
    db.session.delete(extra_ingredient)
    db.session.commit()


def save_drink_picture(identifier, file):
    drink = get_drink(identifier)
    old_uuid = None
    if drink.uuid:
        old_uuid = drink.uuid
    drink.uuid = str(uuid4())
    db.session.commit()
    path = config["pricelist"]["path"]
    save_picture(file, f"{path}/{drink.uuid}")
    if old_uuid:
        delete_picture(f"{path}/{old_uuid}")
    return drink


def get_drink_picture(identifier, size=None):
    path = config["pricelist"]["path"]
    drink = None
    if isinstance(identifier, int):
        drink = get_drink(identifier)
    if isinstance(identifier, str):
        drink = Drink.query.filter(Drink.uuid == identifier).one_or_none()
    if drink:
        return get_picture(f"{path}/{drink.uuid}", size)
    raise FileNotFoundError


def delete_drink_picture(identifier):
    drink = get_drink(identifier)
    if drink.uuid:
        delete_picture(f"{config['pricelist']['path']}/{drink.uuid}")
        drink.uuid = None
        db.session.commit()