🚨 format python code using black

2021-10-27 19:22:25 +02:00
1 parent 9c4a5b3d84
commit a052397990
@@ -16,7 +16,7 @@ from main.utils import users_format_js, users_with_perm

 def register(request):
    products = Product.objects.filter(active=True)
-    cheapest_product_price = list(products.aggregate(Min('sale_price_int')).values())[0] or 0
+    cheapest_product_price = list(products.aggregate(Min("sale_price_int")).values())[0] or 0

    half_a_year_ago = datetime.now() - timedelta(days=180)
    users = User.objects.filter(profile__balance__gte=cheapest_product_price)
@@ -34,24 +34,28 @@ def register(request):
            order = orderform.save(commit=False)

            if order.is_external():
-                order_sum = sum([ol['amount'] * ol['unit_price_ext'] for ol in formset.cleaned_data])
+                order_sum = sum([ol["amount"] * ol["unit_price_ext"] for ol in formset.cleaned_data])
            else:
-                order_sum = sum([ol['amount'] * ol['unit_price_int'] for ol in formset.cleaned_data])
+                order_sum = sum([ol["amount"] * ol["unit_price_int"] for ol in formset.cleaned_data])

            # empty order?
            if order_sum == 0:
-                messages.error(request, 'Du har ikke valgt hva du skal kjøpe...')
-                return HttpResponseRedirect(reverse('register'))
+                messages.error(request, "Du har ikke valgt hva du skal kjøpe...")
+                return HttpResponseRedirect(reverse("register"))

            if not order.is_external():
                profile = order.customer.profile
                # can she afford it?
                if profile.balance < order_sum:
-                    messages.error(request, '{0} {1} har ikke råd, mangler {2} kr.'.format(
-                        order.customer.first_name,
-                        order.customer.last_name,
-                        int(order_sum - profile.balance)))
-                    return HttpResponseRedirect(reverse('register'))
+                    messages.error(
+                        request,
+                        "{0} {1} har ikke råd, mangler {2} kr.".format(
+                            order.customer.first_name,
+                            order.customer.last_name,
+                            int(order_sum - profile.balance),
+                        ),
+                    )
+                    return HttpResponseRedirect(reverse("register"))
                # substract order from balance
                profile.balance -= order_sum
                profile.save()
@@ -61,106 +65,117 @@ def register(request):

            orderlines = []
            for ol in formset.cleaned_data:
-                if ol['amount'] > 0:
-                    product = Product.objects.get(pk=ol['product'])
+                if ol["amount"] > 0:
+                    product = Product.objects.get(pk=ol["product"])

                    if order.is_external():
-                        unit_price = ol['unit_price_ext']
+                        unit_price = ol["unit_price_ext"]
                    else:
-                        unit_price = ol['unit_price_int']
+                        unit_price = ol["unit_price_int"]

                    OrderLine.objects.create(
                        order=order,
                        product=product,
-                        amount=ol['amount'],
-                        unit_price=unit_price)
+                        amount=ol["amount"],
+                        unit_price=unit_price,
+                    )

-                    product.inventory_amount -= ol['amount']
+                    product.inventory_amount -= ol["amount"]
                    product.save()

-                    orderlines.append("{0} {1}".format(ol['amount'], product))
+                    orderlines.append("{0} {1}".format(ol["amount"], product))

            if order.is_external():
-                messages.success(request, 'Ekstern kjøpte {0}.'.format(", ".join(orderlines)))
+                messages.success(request, "Ekstern kjøpte {0}.".format(", ".join(orderlines)))
            else:
-                messages.success(request, '{0} {1} kjøpte {2}.'.format(
-                    order.customer.first_name,
-                    order.customer.last_name,
-                    ", ".join(orderlines)
-                ))
+                messages.success(
+                    request,
+                    "{0} {1} kjøpte {2}.".format(
+                        order.customer.first_name,
+                        order.customer.last_name,
+                        ", ".join(orderlines),
+                    ),
+                )

-            return redirect('register')
+            return redirect("register")
        else:
            # TODO specify error(s)
-            messages.error(request, 'Skjemaet er ikke gyldig.')
+            messages.error(request, "Skjemaet er ikke gyldig.")
            orderform = OrderForm(request.POST)
            formset = OrderLineFormSet(request.POST)
    else:
        orderform = OrderForm()
        formset = OrderLineFormSet()
-        
-    return render(request, 'register.html', locals())
+
+    return render(request, "register.html", locals())


 def deposit(request):
-    users = User.objects.all().order_by('first_name', 'last_name')
+    users = User.objects.all().order_by("first_name", "last_name")
    users_js = users_format_js(users)
-    allowed_users = users_with_perm('add_transaction')
-    error_message_template = '{0} {1} kan ikke sette inn {2} kr, det overskrider maks saldo ({3} kr) med {4} kr'
+    allowed_users = users_with_perm("add_transaction")
+    error_message_template = "{0} {1} kan ikke sette inn {2} kr, det overskrider maks saldo ({3} kr) med {4} kr"

    limit_deposists = settings.BBS_LIMIT_DEPOSITS

    if request.method == "POST":
        form = DepositForm(request.POST)
        if form.is_valid():
-            amount = form.cleaned_data['amount']
-            user = form.cleaned_data['user']
+            amount = form.cleaned_data["amount"]
+            user = form.cleaned_data["user"]
            if amount + user.profile.balance > settings.BBS_SALDO_MAX and amount + user.profile.balance != 1337:
-                messages.error(request, error_message_template.format(
-                    user.first_name,
-                    user.last_name,
-                    amount,
-                    settings.BBS_SALDO_MAX,
-                    amount + user.profile.balance - settings.BBS_SALDO_MAX
-                ))
-                return HttpResponseRedirect(reverse('deposit'))
+                messages.error(
+                    request,
+                    error_message_template.format(
+                        user.first_name,
+                        user.last_name,
+                        amount,
+                        settings.BBS_SALDO_MAX,
+                        amount + user.profile.balance - settings.BBS_SALDO_MAX,
+                    ),
+                )
+                return HttpResponseRedirect(reverse("deposit"))

            transaction = form.save()
            profile = transaction.user.profile
            profile.balance += transaction.amount
            profile.save()

-            messages.success(request, '{0} {1} satte inn {2} kr. Ny saldo er {3}'.format(
-                transaction.user.first_name,
-                transaction.user.last_name,
-                transaction.amount,
-                profile.balance))
-            return HttpResponseRedirect(reverse('deposit'))
+            messages.success(
+                request,
+                "{0} {1} satte inn {2} kr. Ny saldo er {3}".format(
+                    transaction.user.first_name,
+                    transaction.user.last_name,
+                    transaction.amount,
+                    profile.balance,
+                ),
+            )
+            return HttpResponseRedirect(reverse("deposit"))
        else:
-            messages.error(request, 'Skjemaet er ikke gyldig.')
+            messages.error(request, "Skjemaet er ikke gyldig.")
            form = DepositForm(request.POST)
    else:
        form = DepositForm()

-    return render(request, 'deposit.html', locals())
+    return render(request, "deposit.html", locals())


-def log(request, limit=datetime.now()-timedelta(days=2)):
+def log(request, limit=datetime.now() - timedelta(days=2)):
    if limit:
        # display last two days of orders and transactions
-        orders = Order.objects.filter(created__gte=limit).order_by('-created')
-        transactions = Transaction.objects.filter(created__gte=limit).order_by('-created')
+        orders = Order.objects.filter(created__gte=limit).order_by("-created")
+        transactions = Transaction.objects.filter(created__gte=limit).order_by("-created")

        # no action in the last two days?
        # ...then display the last 5 items
        if len(orders) == 0:
-            orders = Order.objects.all().order_by('-created')[:5]
+            orders = Order.objects.all().order_by("-created")[:5]

        if len(transactions) == 0:
-            transactions = Transaction.objects.all().order_by('-created')[:5]
+            transactions = Transaction.objects.all().order_by("-created")[:5]
    else:
        # display everything
-        orders = Order.objects.all().order_by('-created')
-        transactions = Transaction.objects.all().order_by('-created')
+        orders = Order.objects.all().order_by("-created")
+        transactions = Transaction.objects.all().order_by("-created")

-    return render(request, 'log.html', locals())
+    return render(request, "log.html", locals())
@@ -16,58 +16,66 @@ def report(request):
    # end of day
    end_time = datetime.now().replace(hour=23, minute=59, second=59, microsecond=999)

-    if request.GET.get('start_time', False) or request.GET.get('end_time', False):
+    if request.GET.get("start_time", False) or request.GET.get("end_time", False):
        form = DateRangeForm(request.GET)
        if form.is_valid():
-            start_time = form.cleaned_data['start_time']
+            start_time = form.cleaned_data["start_time"]
            # end of day
-            end_time = form.cleaned_data['end_time'].replace(hour=23, minute=59, second=59, microsecond=999)
+            end_time = form.cleaned_data["end_time"].replace(hour=23, minute=59, second=59, microsecond=999)

    else:
-        form = DateRangeForm(initial={
-            'start_time': start_time.strftime("%Y-%m-%d"),
-            'end_time': end_time.strftime("%Y-%m-%d")
-        })
+        form = DateRangeForm(
+            initial={
+                "start_time": start_time.strftime("%Y-%m-%d"),
+                "end_time": end_time.strftime("%Y-%m-%d"),
+            }
+        )

    # Inventory
-    products = Product.objects\
-        .filter(transactions__created__range=[start_time, end_time])\
-        .values('name', 'transactions__unit_price', 'transactions__amount')\
-        .order_by('name')
+    products = (
+        Product.objects.filter(transactions__created__range=[start_time, end_time])
+        .values("name", "transactions__unit_price", "transactions__amount")
+        .order_by("name")
+    )
    # group by name and sum
    inventory_products = {}
-    for k, g in groupby(products, lambda x: x['name']):
+    for k, g in groupby(products, lambda x: x["name"]):
        group = []
        for el in g:
-            el['transactions__price'] = el['transactions__amount'] * el['transactions__unit_price']
+            el["transactions__price"] = el["transactions__amount"] * el["transactions__unit_price"]
            group.append(el)
-        inventory_products.update({k: {
-            'name': k,
-            "transactions": group,
-            "transactions_sum": sum(map(lambda x: x['transactions__price'], group)),
-            "transactions_units": sum(map(lambda x: x['transactions__amount'], group))
-        }})
+        inventory_products.update(
+            {
+                k: {
+                    "name": k,
+                    "transactions": group,
+                    "transactions_sum": sum(map(lambda x: x["transactions__price"], group)),
+                    "transactions_units": sum(map(lambda x: x["transactions__amount"], group)),
+                }
+            }
+        )

    itrans = InventoryTransaction.objects.filter(created__range=[start_time, end_time])
-    inv_in = sum(map(lambda x: x[1].get('transactions_sum', 0), inventory_products.items()))
+    inv_in = sum(map(lambda x: x[1].get("transactions_sum", 0), inventory_products.items()))

    # out
-    out_products = Product.objects\
-        .filter(orderlines__order__created__range=[start_time, end_time])\
-        .values('name', 'orderlines__unit_price', 'orderlines__amount')\
-        .order_by('name')
+    out_products = (
+        Product.objects.filter(orderlines__order__created__range=[start_time, end_time])
+        .values("name", "orderlines__unit_price", "orderlines__amount")
+        .order_by("name")
+    )
    # group by name and sum
-    for k, g in groupby(out_products, lambda x: x['name']):
+    for k, g in groupby(out_products, lambda x: x["name"]):
        group = []
        for el in g:
-            el['orderlines__price'] = el['orderlines__amount'] * el['orderlines__unit_price']
+            el["orderlines__price"] = el["orderlines__amount"] * el["orderlines__unit_price"]
            group.append(el)

        product = {
-            'name': k,
+            "name": k,
            "orderlines": group,
-            "orderlines_sum": sum(map(lambda x: x['orderlines__price'], group)),
-            "orderlines_units": sum(map(lambda x: x['orderlines__amount'], group))
+            "orderlines_sum": sum(map(lambda x: x["orderlines__price"], group)),
+            "orderlines_units": sum(map(lambda x: x["orderlines__amount"], group)),
        }
        if k in inventory_products:
            # add diff
@@ -76,42 +84,42 @@ def report(request):
            inventory_products.update({k: product})

    for p in inventory_products.items():
-            p[1]['value_diff'] = p[1].get('transactions_sum', 0) - p[1].get('orderlines_sum', 0)
-            p[1]['units_diff'] = p[1].get('transactions_units', 0) - p[1].get('orderlines_units', 0)
+        p[1]["value_diff"] = p[1].get("transactions_sum", 0) - p[1].get("orderlines_sum", 0)
+        p[1]["units_diff"] = p[1].get("transactions_units", 0) - p[1].get("orderlines_units", 0)

-    inv_out = sum(map(lambda x: x[1].get('orderlines_sum', 0), inventory_products.items()))
+    inv_out = sum(map(lambda x: x[1].get("orderlines_sum", 0), inventory_products.items()))

    inv_diff = inv_in - inv_out

    # Deposits and sales
-    saldo_profiles = sum(UserProfile.objects.all().values_list('balance', flat=True))
-    deposits = sum(Transaction.objects.all().values_list('amount', flat=True))
-    purchases = sum(Order.objects.all().values_list('order_sum', flat=True))
+    saldo_profiles = sum(UserProfile.objects.all().values_list("balance", flat=True))
+    deposits = sum(Transaction.objects.all().values_list("amount", flat=True))
+    purchases = sum(Order.objects.all().values_list("order_sum", flat=True))
    saldo = deposits - purchases

-    deposits_start = sum(Transaction.objects.filter(created__lt=start_time).values_list('amount', flat=True))
-    purchases_start = sum(Order.objects.filter(created__lt=start_time).values_list('order_sum', flat=True))
+    deposits_start = sum(Transaction.objects.filter(created__lt=start_time).values_list("amount", flat=True))
+    purchases_start = sum(Order.objects.filter(created__lt=start_time).values_list("order_sum", flat=True))
    saldo_start = deposits_start - purchases_start

-    deposits_end = sum(Transaction.objects.filter(created__lt=end_time).values_list('amount', flat=True))
-    purchases_end = sum(Order.objects.filter(created__lt=end_time).values_list('order_sum', flat=True))
+    deposits_end = sum(Transaction.objects.filter(created__lt=end_time).values_list("amount", flat=True))
+    purchases_end = sum(Order.objects.filter(created__lt=end_time).values_list("order_sum", flat=True))
    saldo_end = deposits_end - purchases_end

    deposits_diff = deposits_end - deposits_start
    purchases_diff = purchases_end - purchases_start
    saldo_diff = saldo_end - saldo_start

-    return render(request, 'report.html', locals())
+    return render(request, "report.html", locals())


 def inventory(request):
-    products = Product.objects.all().order_by('-active', 'inventory_amount', 'name')
-    transactions = InventoryTransaction.objects.all().order_by('-created')
+    products = Product.objects.all().order_by("-active", "inventory_amount", "name")
+    transactions = InventoryTransaction.objects.all().order_by("-created")
    products_active = products.filter(active=True)
    wholesale_value = sum([p.wholesale_value for p in products_active])
-    num_products = sum(products_active.values_list('inventory_amount', flat=True))
+    num_products = sum(products_active.values_list("inventory_amount", flat=True))

-    return render(request, 'inventory.html', locals())
+    return render(request, "inventory.html", locals())


 def inventory_add(request):
@@ -125,12 +133,12 @@ def inventory_add(request):
            itrans.product.save()
            itrans.save()
            messages.success(request, "Satt inn {0} stk {1}.".format(itrans.amount, itrans.product))
-            return redirect('inventory-add')
+            return redirect("inventory-add")

        else:
-            messages.error(request, 'Feil med skjemaet, se under.')
+            messages.error(request, "Feil med skjemaet, se under.")
            form = InventoryTransactionForm(data=request.POST)
    else:
        form = InventoryTransactionForm()

-    return render(request, 'inventory_add.html', locals())
+    return render(request, "inventory_add.html", locals())
@@ -1,5 +1,3 @@
-
-
 import time
 from datetime import datetime, timedelta
 from django.http import JsonResponse
@@ -13,13 +11,13 @@ from main.models import Product, OrderLine, Order

 def stats_list(request):
    products = Product.objects.filter(active=True)
-    order_groups = ['hourly', 'daily', 'monthly', 'yearly']
+    order_groups = ["hourly", "daily", "monthly", "yearly"]

-    return render(request, 'stats.html', {'products': products, 'order_groups': order_groups})
+    return render(request, "stats.html", {"products": products, "order_groups": order_groups})


 class OrdersView(View):
-    grouping = 'orders'
+    grouping = "orders"

    def get_range(self):
        raise NotImplementedError
@@ -42,16 +40,16 @@ class OrdersView(View):

        orders_grouped = self.group_by(orders)
        data = {
-            'start': str(orders[0].created),
-            'orders': [[k, v] for k, v in orders_grouped.items()],
-            'total': sum(orders_grouped.values()),
-            'grouping': self.grouping
+            "start": str(orders[0].created),
+            "orders": [[k, v] for k, v in orders_grouped.items()],
+            "total": sum(orders_grouped.values()),
+            "grouping": self.grouping,
        }
        return JsonResponse(data)


 class OrdersHourlyView(OrdersView):
-    grouping = 'hourly'
+    grouping = "hourly"

    def get_range(self):
        return range(0, 24)
@@ -61,7 +59,7 @@ class OrdersHourlyView(OrdersView):


 class OrdersDailyView(OrdersView):
-    grouping = 'daily'
+    grouping = "daily"

    def get_range(self):
        return range(0, 7)
@@ -71,7 +69,7 @@ class OrdersDailyView(OrdersView):


 class OrdersMonthlyView(OrdersView):
-    grouping = 'monthly'
+    grouping = "monthly"

    def get_range(self):
        return range(1, 13)
@@ -81,14 +79,14 @@ class OrdersMonthlyView(OrdersView):


 class OrdersYearlyView(OrdersView):
-    grouping = 'yearly'
+    grouping = "yearly"

    def get_range(self):
-        first = Order.objects.order_by('created').first()
+        first = Order.objects.order_by("created").first()
        last = timezone.now().year
        first = first.created.year if first else last

-        return range(first, last+1)
+        return range(first, last + 1)

    def get_key(self, order):
        return order.created.year
@@ -112,16 +110,14 @@ def stats_products_realtime(request):
    for product, value in products.items():
        serialized_products[product.name] = value

-    response = {
-        'products': serialized_products
-    }
+    response = {"products": serialized_products}

    return JsonResponse(response)


 def stats_products_per_user(request, user_id=None):
    if not user_id:
-        return JsonResponse({'error': 'Missing param user_id'})
+        return JsonResponse({"error": "Missing param user_id"})

    order_lines = OrderLine.objects.filter(order__customer__pk=user_id).order_by("order__created")
    products = {}
@@ -135,8 +131,5 @@ def stats_products_per_user(request, user_id=None):

    serialized_products = []
    for product, value in products.items():
-        serialized_products.append({
-            'name': product.name,
-            'data': value
-        })
+        serialized_products.append({"name": product.name, "data": value})
    return JsonResponse(serialized_products, safe=False)
@@ -13,40 +13,39 @@ def create_user(request):
        form = SimpleCreateUserForm(data=request.POST)
        if form.is_valid():
            user = form.save()
-            messages.success(request, "Hurra! {} {} er lagt til".format(user.first_name, user.last_name))
-            return redirect('create-user')
+            messages.success(
+                request,
+                "Hurra! {} {} er lagt til".format(user.first_name, user.last_name),
+            )
+            return redirect("create-user")

        else:
-            messages.error(request, 'Feil med skjemaet, se under.')
+            messages.error(request, "Feil med skjemaet, se under.")
            form = SimpleCreateUserForm(data=request.POST)
    else:
        form = SimpleCreateUserForm()

-    return render(request, 'registration/create_user.html', {'form': form})
+    return render(request, "registration/create_user.html", {"form": form})


@login_required
 def profile(request):
    transactions = Transaction.objects.filter(user=request.user.pk)
-    transaction_totals = {
-        'sum': sum([t.amount for t in transactions])
-    }
+    transaction_totals = {"sum": sum([t.amount for t in transactions])}
    orders = Order.objects.filter(customer=request.user.pk)
-    orders_totals = {
-        'sum': sum([o.order_sum for o in orders])
-    }
+    orders_totals = {"sum": sum([o.order_sum for o in orders])}

    # order_lines = OrderLine.objects.filter(order__customer__pk=1).order_by("order__created")
-    order_report = _orders_monthly(filter_by={'customer': request.user.pk})
-    top_months = order_report.order_by('-sum')[:5]
+    order_report = _orders_monthly(filter_by={"customer": request.user.pk})
+    top_months = order_report.order_by("-sum")[:5]

-    return render(request, 'profile.html', locals())
+    return render(request, "profile.html", locals())


-def _orders_monthly(filter_by={}, order_by='month'):
+def _orders_monthly(filter_by={}, order_by="month"):

-    truncate_date = connection.ops.date_trunc_sql('month', 'created')
-    qs = Order.objects.filter(**filter_by).extra({'month': truncate_date})
-    order_report = qs.values('month').annotate(sum=Sum('order_sum'), num=Count('pk')).order_by(order_by)
+    truncate_date = connection.ops.date_trunc_sql("month", "created")
+    qs = Order.objects.filter(**filter_by).extra({"month": truncate_date})
+    order_report = qs.values("month").annotate(sum=Sum("order_sum"), num=Count("pk")).order_by(order_by)

    return order_report