19102024_upgrade model iterable

Author: pythonhtmlcssjsarduino

flask_app/admin/editions/__init__.py

@@ -82,8 +82,10 @@ def modify_edition_page(event_name, edition_name):
     form.rdv_lng.render_kw = {}
     form.parcours.render_kw = {}
     if edition.first_inscription <= datetime.now():
-        form.edition_date.render_kw["disabled"]= "disabled" # si ils peuvent s'iscrire ne plus modifier la date de l'edition
+        # si ils peuvent s'iscrire ne plus modifier la date de l'edition
+        form.edition_date.render_kw["disabled"]= "disabled"
         form.parcours.render_kw["disabled"]= "disabled"
+        form.parcours.data = [str((p.name, p.description)) for p in edition.parcours]
         form.first_inscription.render_kw["disabled"]= "disabled"
         form.name.render_kw["disabled"]= "disabled"
         form.rdv_lat.render_kw["disabled"]= "disabled"
@@ -93,14 +95,13 @@ def modify_edition_page(event_name, edition_name):
     #? fin desactivation des champs
     ic(form.parcours.data)
     ic([str((p.name, p.description)) for p in edition.parcours])
-    ic(request.form.to_dict())
 
     if form.validate_on_submit():
         print(form.parcours.data)
         if form.name.data == edition.name or not event.editions.filter_by(name=form.name.data).first():
             edition.name = form.name.data
             edition.edition_date = form.edition_date.data
-            edition.parcours = event.parcours.filter(Parcours.name.in_(form.parcours.data)).all()
+            edition.parcours = event.parcours.filter(Parcours.name.in_([eval(p)[0] for p in form.parcours.data])).all()
             edition.first_inscription = form.first_inscription.data
             edition.last_inscription = form.last_inscription.data
             edition.rdv_lat = form.rdv_lat.data

flask_app/admin/editions/passages/__init__.py

@@ -1,8 +1,9 @@
 import time
 from flask import Blueprint, redirect, render_template, flash, request, jsonify
 from flask_app import admin_required, db, set_route, lang_url_for as url_for
+from flask_app.admin.parcours import calc_points_dist
 from flask_login import login_required, current_user
-from flask_app.models import  Event, Edition, PassageKey, Stand, Parcours, Passage, User, Inscription
+from flask_app.models import  Event, Edition, PassageKey, Stand, Parcours, Passage, User, Inscription, Trace
 from datetime import datetime
 from flask_app.admin.editions.passages.form import NewKeyForm, ChronoLoginForm, ChronoLoginForm, SetPassageForm
 import secrets
@@ -29,18 +30,18 @@ def dashboard(event_name, edition_name):
 
         if form.validate_on_submit():
             if not edition.passage_keys.filter_by(name=form.name.data).first():
-                stands = [Stand.query.get(int(stand.data)) for stand in form.stands]
+                stands = [Stand.query.get(int(stand.data)) for stand in form.stands if stand.data]
                 key_code=secrets.token_urlsafe(5)
                 while PassageKey.query.filter_by(key=key_code).first():
                     key_code=secrets.token_urlsafe(5)
                 key = PassageKey(event_id=event.id,
                                 edition_id=edition.id,
-                                parcours_id=stand.parcours.id,
-                                stand_id=stand.id,
+                                stands=stands,
                                 key=key_code,
                                 name=form.name.data)
                 db.session.add(key)
-                #db.session.commit()
+                db.session.commit()
+                ic(key, edition, edition.id)
 
                 return redirect(url_for("admin.editions.passages.dashboard", event_name=event.name, edition_name=edition.name))
             else:
@@ -67,6 +68,40 @@ def chrono_home():
 
     return render_template('chrono_home.html', user_data=user, form=form)
 
+
+def parcours_chrono_list_dist(parcours:Parcours, dist_stand:list[int]):
+    part_list = []
+    dist_list = []
+    start = parcours.start_stand
+    new_stand=start
+    last_point=None
+    dist=0
+    # si aucun depart alors ne mettre aucun stand
+    if start:
+        part_list.append(start)
+        turn_nb = 0
+        while True:
+            if new_stand == start:
+                turn_nb +=1
+            old_stand = new_stand
+            # si l'ancien stand a une trace qui part d lui
+            trace:Trace = old_stand.start_trace.filter_by(turn_nb=turn_nb).first()
+            if trace :
+                new_stand = trace.end
+                dist += (calc_points_dist(new_stand.lat, new_stand.lng, last_point[0], last_point[1]) if last_point else 0)
+                last_point = new_stand.lat, new_stand.lng
+
+                if new_stand.id==dist_stand[0]:
+                    dist_stand = dist_stand[1:]
+                    dist_list.append(dist)
+                    if len(dist_stand)==0:
+                        break
+
+                dist += trace.get
+            else:
+                break
+
+
 @set_route(passages, '/chrono/<key_code>')
 def chrono_page(key_code):
     user = current_user if current_user.is_authenticated else None
@@ -76,19 +111,69 @@ def chrono_page(key_code):
         flash('l\'edition n\'est pas aujourd\'hui', 'warning')
         return redirect(url_for("admin.editions.passages.chrono_home")) """
 
-    key_passages = Passage.query.filter_by(key=key).order_by(Passage.time_stamp.desc()).all()
+    key_passages = []
+    user_passages_stand = {}
+    user_passages_passage = {}
+    passage:Passage
+    for passage in Passage.query.filter_by(key=key).order_by(Passage.time_stamp.asc()).all():
+        ic(passage)
+        passage_user = passage.inscription.inscrit
+        passage_stand = passage.key.stands.filter_by(parcours=passage.inscription.parcours).first()
+        passage_chronos_list = list(passage.inscription.parcours.iter_chrono_list())
+        if passage_user.id not in user_passages_stand.keys():
+            user_passages_stand[passage_user.id] = []
+        user_passages_stand[passage_user.id].append(passage_stand.id)
+        if passage_user.id not in user_passages_passage.keys():
+            user_passages_passage[passage_user.id] = []
+        user_passages_passage[passage_user.id].append(passage.id)
+
+        return_list = []
+        delta_list = []
+        offset = 0
+        for index, passed_stand_id in enumerate(user_passages_stand[passage_user.id]):
+            index += offset
+            if index +1 >= len(passage_chronos_list):
+                return_list.append(False)
+                delta_list.append(None)
+
+            for stand in passage_chronos_list[index:]:
+                if passed_stand_id == stand.id:
+                    ic(user_passages_passage[passage_user.id], Passage.query.get(user_passages_passage[passage_user.id][0]), Passage.query.get(user_passages_passage[passage_user.id][index]))
+                    return_list.append(True)
+                    delta = Passage.query.get(user_passages_passage[passage_user.id][index]).time_stamp-Passage.query.get(user_passages_passage[passage_user.id][0]).time_stamp
+                    days = delta.days
+                    hours, remainder = divmod(delta.seconds, 3600)
+                    minutes, seconds = divmod(remainder, 60)
+                    delta_list.append(f"{f'{days} days, 'if days>0 else ''}{hours:02}:{minutes:02}:{seconds:02}")
+                    break
+                else:
+                    return_list.append(None)
+                    delta_list.append(None)
+                    offset+=1
+
+        dist_list = []
+        dist =  0
+        for element in passage.inscription.parcours:
+            if isinstance(element, Stand):
+                if element.chrono:
+                    dist_list.append(round(dist, 3))
+            else:
+                dist += element.get_dist()
+            
+        key_passages.append((passage, passage_chronos_list, return_list, delta_list, dist_list))
+
     ic(key_passages)
-    return render_template('chrono.html', user_data=user, key=key, passages=key_passages)
+    return render_template('chrono.html', user_data=user, key=key, passages=reversed(key_passages))
 
 @set_route(passages, '/chrono/set', methods=['post'])
 def set_passage():
     form = SetPassageForm()
     inscription = Inscription.query.filter(Inscription.dossard == form.dossard.data).first()
     if not inscription:
-        return jsonify({"success": False, 'error':'not valide dossard', 'request':{'dossard':form.dossard.data, 'time':form.time.data, 'key':form.key.data}})
+        return jsonify({"success": False, 'saved':False, 'error':'not valide dossard', 'request':{'dossard':form.dossard.data, 'time':form.time.data, 'key':form.key.data}})
     key = PassageKey.query.filter_by(key=form.key.data).first()
     if not key:
-        return jsonify({"success": False, 'error':'not valide key', 'request':{'dossard':form.dossard.data, 'time':form.time.data, 'key':form.key.data}})
+        return jsonify({"success": False, 'saved':False, 'error':'not valide key', 'request':{'dossard':form.dossard.data, 'time':form.time.data, 'key':form.key.data}})
 
     pass_time = datetime.fromtimestamp(form.time.data/1000)
     ic(key)#type:ignore
@@ -97,9 +182,11 @@ def set_passage():
     user_passages = Passage.query.filter_by(inscription=inscription).order_by(Passage.time_stamp).all()
     ic(user_passages) #type:ignore
 
+    stand = key.stands.filter_by(parcours=inscription.parcours).first()
+
     parcours = inscription.parcours
 
     passage = Passage(key_id = key.id, time_stamp=pass_time, inscription_id= inscription.id)
 
 
-    return jsonify({"success": True, 'request':{'dossard':form.dossard.data, 'time':form.time.data, 'key':form.key.data}})
+    return jsonify({"success": True, 'saved':True, 'request':{'dossard':form.dossard.data, 'time':form.time.data, 'key':form.key.data}})