drinks-manager/app/views.py

import json
import sys

from pathlib import Path

from django.conf import settings
from django.contrib.auth import authenticate
from django.contrib.auth import get_user_model
from django.contrib.auth import login
from django.contrib.auth.decorators import login_required
from django.contrib.auth.forms import AuthenticationForm
from django.http.response import HttpResponseRedirect
from django.http.response import FileResponse
from django.http.response import HttpResponse
from django.shortcuts import render

from django.utils.translation import gettext as _
from django.utils.formats import decimal

from . import db_queries

from .models import Drink
from .models import Order
from .models import RegisterTransaction


def login_page(request):
    userlist = get_user_model().objects.filter(hide_from_userlist=False).filter(is_active=True).order_by("username")
    if request.method == "POST":
        form = AuthenticationForm(request.POST)
        username = request.POST['username']
        password = request.POST['password']
        user = authenticate(username=username,password=password)
        if user:
            if user.is_active:
                login(request, user)
                return HttpResponseRedirect("/")
        else:
            return render(request,'registration/login.html', {
                "form": form,
                "user_list": userlist,
                "error_message": _("Invalid username or password.")
            })
    else:
        if request.user.is_authenticated:
            return HttpResponseRedirect("/")
        form = AuthenticationForm()
    return render(request,'registration/login.html', {
        "form": form,
        "user_list": userlist
    })

@login_required
def index(request):
    context = {
        "available_drinks": Drink.objects.filter(available__gt=0).filter(deleted=False).order_by('product_name'),
    }
    return render(request, "index.html", context)

@login_required
def history(request):
    context = {
        "history": db_queries.select_history(request.user, language_code=request.LANGUAGE_CODE),
    }
    return render(request, "history.html", context)

@login_required
def order(request, drinkid):
    try:
        drink_ = Drink.objects.get(pk=drinkid)
        context = {"drink": drink_}
        return render(request, "order.html", context)
    except Drink.DoesNotExist:
        return HttpResponseRedirect("/")

@login_required
def deposit(request):
    return render(request, "deposit.html", {})


@login_required
def statistics(request):
    context = {
        "orders_per_month": db_queries.orders_per_month(request.user),
        "orders_per_weekday": db_queries.orders_per_weekday(request.user),
        "orders_per_drink": db_queries.orders_per_drink(request.user),
    }
    return render(request, "statistics.html", context)

@login_required
def transfer(request):
    userlist = get_user_model().objects.filter(hide_from_userlist=False).filter(is_active=True).order_by("username")
    return render(request, "transfer.html", {"user_list": userlist})

@login_required
def supply(request):
    return render(request, "supply.html")

@login_required
def redirect_home(request):
    return HttpResponseRedirect("/")

# API for XHR requests #

@login_required
def api_order_drink(request):
    # check request -> make order
    user = request.user
    try:
        if user.allow_order_with_negative_balance or user.balance > 0:
            drinkid = int(request.POST["drinkid"])
            amount = int(request.POST["numberofdrinks"])
            drink = Drink.objects.get(pk=drinkid)
            if ((drink.do_not_count and drink.available > 0) or (drink.available >= amount)) and not drink.deleted:
                Order.objects.create(drink=drink, user=user, amount=amount)
                return HttpResponse("success", status=200)
            else:
                return HttpResponse("notAvailable", status=400)
        else: raise Exception("Unexpected input or missing privileges.")
    except Exception as e:
        print(f"An exception occured while processing an order: User: {user.username} - Exception: {e}", file=sys.stderr)
        return HttpResponse(b"", status=500)

@login_required
def api_deposit(request):
    # check request -> deposit
    user = request.user
    try:
        amount = decimal.Decimal(request.POST["depositamount"])
        if 0.00 < amount < 9999.99:
            # create transaction
            RegisterTransaction.objects.create(
                transaction_sum=amount,
                comment=f"User deposit by user {user.username}",
                is_user_deposit=True,
                user=user)
            return HttpResponse("success", status=200)
        else: raise Exception("Deposit amount too big or small.")
    except Exception as e:
        print(f"An exception occured while processing a deposit transaction: User: {user.username} - Exception: {e}", file=sys.stderr)
        return HttpResponse(b"", status=500)

@login_required
def api_transfer(request):
    # check request -> transfer
    user = request.user
    try:
        recipient = get_user_model().objects.get(id=int(request.POST["recipientuser"]))
        if recipient.id == user.id:
            raise Exception(f"User {user.username} tried to transfer to themself.")
        amount = decimal.Decimal(request.POST["transferamount"])
        if 0.00 < amount <= user.balance:
            # create transaction
            RegisterTransaction.objects.create(
                transaction_sum=-amount,
                comment=f"Transfer to {recipient.username}",
                is_transfer=True,
                user=user)
            RegisterTransaction.objects.create(
                transaction_sum=amount,
                comment=f"Transfer from {user.username}",
                is_transfer=True,
                user=recipient)
            return HttpResponse("success", status=200)
        else: raise Exception("Transfer amount too big or small.")
    except Exception as e:
        print(f"An exception occured while processing a transfer transaction: User: {user.username} - Exception: {e}", file=sys.stderr)
        return HttpResponse(b"", status=500)

@login_required
def api_supply(request):
    # check request -> supply
    user = request.user
    try:
        price = decimal.Decimal(request.POST["supplyprice"])
        description = str(request.POST["supplydescription"])
        if 0.00 < price < 9999.99 and (user.allowed_to_supply or user.is_superuser):
            # create transaction
            RegisterTransaction.objects.create(
                transaction_sum=-price,
                comment=f"Supply: {description}",
                is_user_deposit=False,
                user=user
            )
            return HttpResponse("success", status=200)
        else: raise Exception("Unexpected input or missing privileges.")
    except Exception as e:
        print(f"An exception occured while processing a supply transaction: User: {user.username} - Exception: {e}", file=sys.stderr)
        return HttpResponse(b"", status=500)