major: add calculation for payments

.gitignore

@@ -353,4 +353,5 @@ tests*
 *.ps1
 *.pdf
 *.backup
-Dockerfile.*
+Dockerfile.*
+docker-compose.*

backend/src/__init__.py

@@ -34,7 +34,7 @@ login = LoginManager()
 login.login_view = 'auth.web_login'
 ma = Marshmallow()
 mail = Mail()
-migrate = Migrate()
+migrate = Migrate(transaction_per_migration=True)
 
 
 def create_app(config_class=Config):

backend/src/establishment/overview/routes.py

@@ -2,7 +2,7 @@ from flask import abort,  request
 from flask.json import jsonify
 from flask_login import current_user, login_required
 from . import bp
-from .utils import get_report, group_results, sum_entries
+from .utils import calculate_payments, get_report, group_results, sum_entries
 from src import LOGGER
 from models import Establishment, LoginToken
 from src.utils.routes_utils import render_custom_template as render_template
@@ -25,7 +25,7 @@ def get_report_from_user(establishment_id):
     LOGGER.info("Getting results.")
     results = get_report(**request.args, **{"establishment": establishment_id})
     LOGGER.debug(f"Results received.")
-    LOGGER.debug(str(results))
+    # LOGGER.debug(str(results))
     if results:
         result_list = group_results(results)
         tokens = establishment.LoginToken.all()
@@ -33,6 +33,7 @@ def get_report_from_user(establishment_id):
         for token in tokens:
             token_dates.extend(token.LoginTokenDates.all())
         sum_entries(result_list, token_dates)
+        calculate_payments(result_list)
     else:
         result_list = []
     # LOGGER.debug(result_list)

backend/src/establishment/overview/utils.py

@@ -1,7 +1,7 @@
 from src import LOGGER
 from datetime import date as dtdate, timedelta
 from flask_login import current_user
-from models import Establishment, Item, LoginToken, User, Receipt, ReceiptItem
+from models import Establishment, Item, LoginToken, User, Payment, Receipt, ReceiptItem
 from src import db, LOGGER
 from src.utils.view_utils import bought_with_prices as bwp
 
@@ -14,6 +14,12 @@ def group_results(results: tuple) -> list:
         sum: <sum of itemamounts*itemprices>,
         membership_dates: [
           (datetime.date(entry_date), datetime.date(exit_date))
+        ],
+        payments: [
+          {
+            date: datetime.date(payment date),
+            amount: <payment (ct)>
+          }
         ]
         item_infos: [
           {
@@ -55,15 +61,14 @@ def group_results(results: tuple) -> list:
     LOGGER.debug("Grouped.")
     return result_list
 
-def sum_entries(grouped_result_list, login_token_dates):
+def get_token_modifier_on_date(login_token_dates):
-    LOGGER.debug("Preparing dict")
-    dict_people_modifier = {}
     # dict_people_modifier:
     # {datetime.date(x,y,z): {
     #  'add': <list of usertokens>,
     #  'remove: <list of usertokens>
     #  }
     # }
+    dict_people_modifier = {}
     for tokendate in login_token_dates:
         if not tokendate.activation_date in dict_people_modifier:
             dict_people_modifier[tokendate.activation_date] = {}
@@ -72,11 +77,13 @@ def sum_entries(grouped_result_list, login_token_dates):
         dict_people_modifier[tokendate.activation_date]["add"].append(tokendate.token)
         if tokendate.deactivation_date != None:
             if not tokendate.deactivation_date in dict_people_modifier:
-                if not tokendate.deactivation_date in dict_people_modifier:
+                dict_people_modifier[tokendate.deactivation_date] = {}
-                    dict_people_modifier[tokendate.deactivation_date] = {}
+            if not "remove" in dict_people_modifier[tokendate.deactivation_date]:
-                if not "remove" in dict_people_modifier[tokendate.deactivation_date]:
+                dict_people_modifier[tokendate.deactivation_date]['remove'] = []
-                    dict_people_modifier[tokendate.deactivation_date]['remove'] = []
+            dict_people_modifier[tokendate.deactivation_date]["remove"].append(tokendate.token)
-                dict_people_modifier[tokendate.deactivation_date]["remove"].append(tokendate.token)
+    return dict_people_modifier
+
+def generate_better_list(dict_people_modifier):
     list_people_amount_per_date = [{"date": key, "people": value} for key, value in dict_people_modifier.items()]
     list_people_amount_per_date.sort(key=lambda x: x.get('date'))
     list_people_per_date = []
@@ -95,25 +102,34 @@ def sum_entries(grouped_result_list, login_token_dates):
                         list_people_per_date[-1]['people'].remove(person)
                     except ValueError as e:
                         LOGGER.debug(f'{person} not in list.')
-    LOGGER.debug("This is line 91")
+    return list_people_per_date
+
+def sum_entries(grouped_result_list, login_token_dates):
+    dict_people_modifier = get_token_modifier_on_date(login_token_dates)
+    LOGGER.debug(dict_people_modifier)
+    LOGGER.debug("Preparing dict")
+    list_people_per_date = generate_better_list(dict_people_modifier)
+    LOGGER.debug("This is line 106")
     for result_user in grouped_result_list:
         relevant_date_index = 0
-        if result_user.get('id'):
+        for result_date in result_user['item_infos']:
-            for result_date in result_user['item_infos']:
+            # TODO get relevant date index
-                # TODO get relevant date index
+            if not result_date.get('date'):
-                for i in range(relevant_date_index + 1, len(list_people_per_date)):
+                result_date['item_list'] = []
-                    if list_people_per_date[i].get('date') > result_date.get('date'):
+                continue
-                        LOGGER.debug(f"{list_people_per_date[i].get('date')} > {result_date.get('date')}")
+            for i in range(relevant_date_index + 1, len(list_people_per_date)):
-                        relevant_date_index = i-1
+                if list_people_per_date[i].get('date') > result_date.get('date'):
-                        break
+                    # LOGGER.debug(f"{list_people_per_date[i].get('date')} > {result_date.get('date')}")
-                    if i == len(list_people_per_date)-1:
+                    relevant_date_index = i-1
-                        if list_people_per_date[i].get('date') < result_date.get('date'):
+                    break
-                            relevant_date_index=i
+                if i == len(list_people_per_date)-1:
-                # LOGGER.debug(f"Relevant Date: {list_people_per_date[relevant_date_index].get('date')}, Index: {relevant_date_index}")
+                    if list_people_per_date[i].get('date') <= result_date.get('date'):
-                # LOGGER.debug(f"Result Date: {result_date.get('date')}")
+                        relevant_date_index=i
-                for result_item in result_date['item_list']:
+            # LOGGER.debug(f"Relevant Date: {list_people_per_date[relevant_date_index].get('date')}, Index: {relevant_date_index}")
-                    result_user['sum'] += result_item['amount'] * result_item['price']
+            # LOGGER.debug(f"Result Date: {result_date.get('date')}")
-                    list_people_per_date[relevant_date_index]['sum'] += result_item['amount'] * result_item['price']
+            for result_item in result_date['item_list']:
+                result_user['sum'] += result_item['amount'] * result_item['price']
+                list_people_per_date[relevant_date_index]['sum'] += result_item['amount'] * result_item['price']
     LOGGER.debug(list_people_per_date)
     for entry_people_per_date in list_people_per_date:
         for result_user in grouped_result_list:
@@ -121,10 +137,19 @@ def sum_entries(grouped_result_list, login_token_dates):
                 LOGGER.debug(f"Reducing sum of {result_user.get('id')} by {entry_people_per_date.get('sum')/len(entry_people_per_date.get('people'))}")
                 result_user['sum'] -= entry_people_per_date.get('sum')/len(entry_people_per_date.get('people'))
 
+def calculate_payments(grouped_result_list):
+    for result_user in grouped_result_list:
+        payments:list[Payment] = Payment.query.filter_by(token=result_user.get('id')).all()
+        if payments:
+            result_user['payments'] = [{"date": x.date, "amount": x.amount} for x in payments]
+            paymentsum = sum([x.amount for x in payments])
+            LOGGER.debug(f"Adding payments of a total of {paymentsum} to {result_user.get('id')}")
+            result_user['sum'] -= sum([x.amount for x in payments])
+
 def get_report(**kwargs):
     query_select_boughts = db.session.query(
-        bwp.c.token, User.email, bwp.c.date, bwp.c.item, Item.name, bwp.c.amount, bwp.c.price)
+        LoginToken.token, User.email, bwp.c.date, bwp.c.item, Item.name, bwp.c.amount, bwp.c.price)
-    query_select_boughts = query_select_boughts.select_from(User).join(LoginToken, LoginToken.user == User.id).join(
+    query_select_boughts = query_select_boughts.select_from(LoginToken).join(User, LoginToken.user == User.id).join(
         bwp, LoginToken.token == bwp.c.token, isouter = True).join(Item, Item.id == bwp.c.item, isouter = True)
     query_select_receipts = db.session.query(
         Receipt.from_user, User.email, Receipt.date, ReceiptItem.item, ReceiptItem.name, ReceiptItem.amount, -ReceiptItem.price)
@@ -161,7 +186,7 @@ def get_report(**kwargs):
             query_select_boughts = query_select_boughts.filter(bwp.c.date.between(
                 dtdate(int(year), 1, 1), dtdate(int(year), 12, 31)))
     query_select = query_select_boughts.union(query_select_receipts)
-    query_select = query_select.order_by(bwp.c.token, bwp.c.date, bwp.c.item)
+    query_select = query_select.order_by(LoginToken.token, bwp.c.date, bwp.c.item)
     LOGGER.debug(str(query_select))
     results = query_select.all()
     return tuple(results)

backend/web/templates/establishment/overview/overview.html

@@ -38,6 +38,23 @@
             </div>
         </div>
         {% endfor %}
+        {% if user.payments %}
+        <h3>Einzahlungen</h3>
+        {% for payments in user.payments %}
+        <div class="card-body">
+            <div class="col-sm-1"></div>
+            <div class="col">
+                <h4>{{ payments.date }}</h4>
+                <div class="row">
+                    <div class="col-sm-1"></div>
+                    <div class="col">
+                        {{ payments.amount/100 }} €
+                    </div>
+                </div>
+            </div>
+        </div>
+        {% endfor %}
+        {% endif %}
     </div>
     {% endif %}
 </div>