]>
Commit | Line | Data |
---|---|---|
1 | #!/usr/bin/env python3 | |
2 | # -*- coding: utf-8 -*- | |
3 | ||
4 | from configuration import CONFIG,DEFAUT | |
5 | from gestion_erreurs import debug, warning, erreur, initialise_erreurs | |
6 | from gestion_couleurs import rgb_vers_tuple, tuple_vers_rgb | |
7 | from gestion_unites import choix_unite | |
8 | import datetime | |
9 | import json | |
10 | import unidecode | |
11 | import copy | |
12 | ||
13 | ### Les données "tournent" selon : | |
14 | ### python -> json -> (export/import) -> formulaire HTML -> données POST -> python etc | |
15 | ||
16 | ############ Fonctions de conversion | |
17 | ||
18 | def convertit_jours_vers_python(chaine,liste_err): | |
19 | """ convertit une chaine de type 1a 3m 1s 10j en jours | |
20 | Renvoie un nombre de jours en float | |
21 | Si un des caractères n'est ni un nombre, ni une lettre "autorisée" ni une espace, | |
22 | on affiche un warning et on ignore ce caractère | |
23 | """ | |
24 | # debug("conversion de "+chaine+" vers un nb de jours",liste_err) | |
25 | chainenombre = "" | |
26 | agejours = 0. | |
27 | for lettre in chaine: | |
28 | if lettre.isdigit(): | |
29 | chainenombre += lettre | |
30 | else: | |
31 | if lettre == 'a' or lettre == 'A': | |
32 | # On a trouvé l'année, on ajoute tout ce qui est trouvé jusque là | |
33 | agejours += int(chainenombre)*CONFIG["jours_dans_annee"] | |
34 | chainenombre = "" | |
35 | elif lettre == 'm' or lettre == 'M': | |
36 | # On a trouvé le mois | |
37 | agejours += int(chainenombre)*CONFIG["jours_dans_mois"] | |
38 | chainenombre = "" | |
39 | elif lettre == 's' or lettre == 'S': | |
40 | # la semaine | |
41 | agejours += int(chainenombre)*CONFIG["jours_dans_semaine"] | |
42 | chainenombre = "" | |
43 | elif lettre == 'j' or lettre == 'J': | |
44 | # On a trouvé le jour | |
45 | agejours += int(chainenombre) | |
46 | chainenombre = "" | |
47 | elif lettre != ' ': | |
48 | # autre caractère : bizarre ? | |
49 | warning("problème à la conversion de "+chaine+". Caractère invalide : "+lettre,liste_err) | |
50 | # à la fin s'il reste qqch on le garde dans les jours | |
51 | if chainenombre != "": | |
52 | agejours += int(chainenombre) | |
53 | if agejours<0: | |
54 | warning("L'âge est négatif !",liste_err) | |
55 | agejours = 0 | |
56 | # debug("On a convertit ! Résultat : "+str(agejours),liste_err) | |
57 | return agejours | |
58 | ||
59 | # python -> json | |
60 | def convertit_age_vers_texte(nombre): | |
61 | """ convertit un nombre de jours en un truc plus lisible en mois, années, jours | |
62 | et renvoie une chaîne sous la forme 3a2m1j par exemple""" | |
63 | annees = int(nombre / CONFIG["jours_dans_annee"]) | |
64 | restant = nombre - annees*CONFIG["jours_dans_annee"] | |
65 | mois = int(restant/CONFIG["jours_dans_mois"]) | |
66 | jours= round(nombre - mois*CONFIG["jours_dans_mois"] - annees*CONFIG["jours_dans_annee"]) | |
67 | ||
68 | chaine = "" | |
69 | if annees >0: | |
70 | chaine += str(annees)+"a" | |
71 | if mois >0: | |
72 | chaine += str(mois)+"m" | |
73 | if jours>0 or nombre ==0: # si c'est la naissance, faut beien écrire 0j quand même | |
74 | chaine += str(jours)+"j" | |
75 | return chaine | |
76 | ||
77 | ########################## | |
78 | ||
79 | # fonction qui calcule "auto" le maxi du graphique en fonction du max | |
80 | def calcule_max_graphique(l_jours): | |
81 | """ calcule l'age maxi sur le graphique""" | |
82 | if l_jours == []: | |
83 | return CONFIG["jours_defaut_donneesvides"] | |
84 | else: | |
85 | jour_maxi = max(l_jours)# pas la peine d'aller très au delà du jour max | |
86 | jour_maxi = int(jour_maxi* 1.2)+3 # on rajoute un peu | |
87 | return jour_maxi | |
88 | ||
89 | ||
90 | def simplifie_nom(chaine): | |
91 | """ simplifie le nom chaine afin d'en faire une extension | |
92 | pour le nom du fichier. Met tout en minuscules et vire les caractères spéciaux | |
93 | et max 15 caractères""" | |
94 | chaine2 = "" | |
95 | for l in chaine: | |
96 | if l.isalpha(): | |
97 | chaine2+=l | |
98 | chaine2 = unidecode.unidecode(chaine2) | |
99 | return chaine2[:15] | |
100 | ||
101 | def convertit_donnee_vers_python(chaine,typedonnee,liste_err): | |
102 | """ convertit une chaine vers un float qui est le type donnee voulu. | |
103 | La virgule peut être . ou , et on vire d'éventuels espaces. | |
104 | Taille invalide : on renvoie 0 avec un warning. | |
105 | Si la chaine est en fait déjà au format float, on laisse tel quel""" | |
106 | if type(chaine) == float: | |
107 | return chaine | |
108 | chaine2 = chaine.replace(",",".") | |
109 | chaine2 = chaine2.replace(" ","") | |
110 | ||
111 | ||
112 | try: | |
113 | donnee = float(chaine2) | |
114 | except: | |
115 | warning(typedonnee+" impossible à lire : "+chaine,liste_err) | |
116 | donnee = 0 | |
117 | ||
118 | # Pour le poids, un cas particulier | |
119 | if typedonnee == "poids" and donnee > CONFIG["poids_maxi_conversion"]: | |
120 | donnee = donnee/1000 # conversion en grammes | |
121 | if not( 0<=donnee<CONFIG[typedonnee+"_maxi"]): | |
122 | warning(typedonnee+" incohérent(e) : "+str(donnee),liste_err) | |
123 | donnee = 0 | |
124 | return donnee | |
125 | ||
126 | ||
127 | ######################### | |
128 | ||
129 | # web -> python | |
130 | def convertit_date_vers_python(chaine,liste_err): | |
131 | """ prend une chaine comme renvoyée par un champ de formulaire date | |
132 | aaaa-mm-jj et en fait une date python | |
133 | renvoie "" si ne marche pas""" | |
134 | liste = chaine.split("-") | |
135 | if len(liste) != 3: | |
136 | warning("La date : "+chaine+" est invalide !",liste_err) | |
137 | return "" | |
138 | else: | |
139 | debug("Conversion de la date "+chaine+". Découpage : "+str(liste),liste_err) | |
140 | try: | |
141 | date = datetime.date(int(liste[0]),int(liste[1]),int(liste[2])) | |
142 | except: | |
143 | date = "" | |
144 | warning("Impossible de lire la date "+chaine+". Format accepté : aaaa-mm-jj",liste_err) | |
145 | return date | |
146 | ||
147 | # python -> json | |
148 | def convertit_date_vers_texte(date): | |
149 | """ convertit une date python en format texte aaaa-mm-jj""" | |
150 | if date == "": | |
151 | return "" | |
152 | else: | |
153 | #return (str(date.year)+"-"+str(date.month)+"-"+str(date.day)) | |
154 | return str(date) | |
155 | ||
156 | def delta_date(date1,datenaissance): | |
157 | """ renvoie le nombre de jours (entier) entre date1 et datenaissance format "datetime" | |
158 | datenaissance est supposée antérieure. Erreur sinon.""" | |
159 | d = date1 - datenaissance | |
160 | jours = d.days | |
161 | if jours<0: | |
162 | warning("La différence entre les dates est négative... :/") | |
163 | return -1 | |
164 | return jours | |
165 | ||
166 | ||
167 | ||
168 | ################### On regroupe tout ce qui gère les données en une fonction | |
169 | ||
170 | def web_vers_python(data,liste_err, court=False): | |
171 | """ prend en argument le dictionnaire de requête et renvoie la config, et les | |
172 | tableaux de donnée | |
173 | court : si True est précisé, on ne met que le nom dans la config (enfant | |
174 | additionnel)""" | |
175 | ||
176 | # Régler la configuration | |
177 | config = gere_configuration(data,liste_err, court) | |
178 | ||
179 | # récupérer les données | |
180 | listes_jours = {} | |
181 | listes_donnees = {} | |
182 | for typed in CONFIG["liste_typedonnees"]: | |
183 | listes_jours[typed],listes_donnees[typed] = gere_donnees(data,config["naissance"],typed,liste_err) | |
184 | ||
185 | # Si on veut extrapoler au-delà du jour maxi, on adapte | |
186 | ||
187 | # Si on a choisi la même échelle de données | |
188 | if config.get("memechelle") == "oui": | |
189 | config["non_sauve"]["maxi"] = calcule_max_graphique([j for lj in listes_jours.values() for j in lj]) | |
190 | # En cas d'extrapolation, on prend le maxi | |
191 | if config["non_sauve"]["calculextradata_type"] !="" and config["non_sauve"]["calculextradata_age"]>config["non_sauve"]["maxi"]: | |
192 | config["non_sauve"]["maxi"] = int(config["non_sauve"]["calculextradata_age"]) +1 | |
193 | config["non_sauve"]["unite"] = choix_unite(config["non_sauve"]["maxi"]) | |
194 | ||
195 | return (config,listes_jours,listes_donnees) | |
196 | ||
197 | ||
198 | ||
199 | ########### Fonctions qui gèretn les données web vers python | |
200 | ||
201 | def gere_checkbox(chaine): | |
202 | """ prend en arg une chaine, et renvoie "oui" si c'est "on" (sortie de la checkbox) | |
203 | et chaîne vide si n'importe quoi d'autre""" | |
204 | if chaine == "on": | |
205 | return "oui" | |
206 | else: | |
207 | return "" | |
208 | ||
209 | def gere_symbole(chaine): | |
210 | """ prend en arg une chaîne genre "o", ">" et vérifie si c'est un symbole valide. | |
211 | Renvoie ce symbole-là ou le défaut""" | |
212 | if chaine in CONFIG["liste_symboles"]: | |
213 | return chaine | |
214 | else: | |
215 | return DEFAUT["symbole"] | |
216 | ||
217 | def gere_configuration(data,liste_err, court=False): | |
218 | """ prend en argument le dictionnaire de requête (configuration imparfaite), et | |
219 | construit le dictionnaire de configuration qui va bien. | |
220 | Vérifie que chaque entrée est cohérente évidemment. | |
221 | court : si mis à True, on ne met que le nom dans la configuraion, | |
222 | ainsi que la date de naissance et le sexe""" | |
223 | # Initialisation | |
224 | configuration = {"non_sauve": {}} | |
225 | ||
226 | # Pour le nom, osef qu'il soit vide | |
227 | nom = data.get("nom","") | |
228 | # Par contre s'il est trop long on le tronque | |
229 | configuration["nom"] = nom[:CONFIG["longueur_max_nom_bebe"]] | |
230 | ||
231 | naissance = data.get("naissance","") | |
232 | if naissance !="": | |
233 | naissance = convertit_date_vers_python(naissance,liste_err) | |
234 | configuration["naissance"] = naissance | |
235 | ||
236 | sexe = data.get("sexe","") | |
237 | if not (sexe in ["F","M","N"]): | |
238 | warning("Le sexe de l'enfant est invalide ! "+sexe,liste_err) | |
239 | sexe = "N" | |
240 | configuration["sexe"] = sexe | |
241 | ||
242 | if not(court): | |
243 | ||
244 | prematurite = data.get("prematurite","") | |
245 | j = convertit_jours_vers_python(prematurite,liste_err) | |
246 | configuration["prematurite"] = convertit_age_vers_texte(j) | |
247 | ||
248 | configuration["agecorrige"] = gere_checkbox(data.get("agecorrige","")) | |
249 | ||
250 | # Type de courbe. Au pire on met P | |
251 | tyc = data.get("typecourbe","") | |
252 | if not (tyc in ["P","Z"]): | |
253 | tyc = "P" | |
254 | configuration["typecourbe"] = tyc | |
255 | ||
256 | # unité | |
257 | unite = data.get("unite","") | |
258 | if not (unite in CONFIG["liste_unites"]): | |
259 | unite = "" | |
260 | #warning("L'unité "+unite+" n'est pas reconnue !",liste_err) | |
261 | configuration["unite"] = unite | |
262 | ||
263 | # grille | |
264 | configuration["grille"] = gere_checkbox(data.get("grille","")) | |
265 | ||
266 | # tracer ou non les courbes vides | |
267 | configuration["tracevide"] = gere_checkbox(data.get("tracevide","")) | |
268 | ||
269 | # Même échelle sur tous les graphiques | |
270 | configuration["memechelle"] = gere_checkbox(data.get("memechelle","")) | |
271 | ||
272 | ||
273 | # maxi. 0 signifie qu'on veut pas de maxi | |
274 | maxi = data.get("maxi","") | |
275 | if maxi == "": | |
276 | configuration["maxi"] = 0 | |
277 | else: | |
278 | configuration["maxi"] = int(convertit_jours_vers_python(maxi,liste_err)) | |
279 | ||
280 | # dimensions du graphique | |
281 | largeur = data.get("largeur","") | |
282 | if largeur == "": | |
283 | largeur = DEFAUT["largeur_graphique"] | |
284 | else: | |
285 | try: | |
286 | largeur = int(largeur) | |
287 | except: | |
288 | warning("La largeur "+largeur+"est invalide !",liste_err) | |
289 | largeur = DEFAUT["largeur_graphique"] | |
290 | if largeur > CONFIG["largeur_graphique_max"]: | |
291 | largeur = CONFIG["largeur_graphique_max"] | |
292 | warning("Largeur du graphique trop grande !",liste_err) | |
293 | elif largeur < CONFIG["largeur_graphique_min"]: | |
294 | largeur = CONFIG["largeur_graphique_min"] | |
295 | warning("Largeur du graphique trop petite !",liste_err) | |
296 | configuration["largeur"] = largeur | |
297 | ||
298 | hauteur = data.get("hauteur","") | |
299 | if hauteur == "": | |
300 | hauteur = DEFAUT["hauteur_graphique"] | |
301 | else: | |
302 | try: | |
303 | hauteur = int(hauteur) | |
304 | except: | |
305 | warning("La hauteur "+hauteur+"est invalide !",liste_err) | |
306 | hauteur = DEFAUT["hauteur_graphique"] | |
307 | if hauteur > CONFIG["hauteur_graphique_max"]: | |
308 | hauteur = CONFIG["hauteur_graphique_max"] | |
309 | warning("Hauteur du graphique trop grande !",liste_err) | |
310 | elif hauteur < CONFIG["hauteur_graphique_min"]: | |
311 | hauteur = CONFIG["hauteur_graphique_min"] | |
312 | warning("Hauteur du graphique trop petite !",liste_err) | |
313 | configuration["hauteur"] = hauteur | |
314 | ||
315 | # existence et position de la légende | |
316 | configuration["legende"] = gere_checkbox(data.get("legende","")) | |
317 | ||
318 | positionlegende = data.get("positionlegende","") | |
319 | if not(positionlegende in ['upper left','upper right','lower left','lower right']): | |
320 | positionlegende = "upper left" | |
321 | configuration["positionlegende"] = positionlegende | |
322 | ||
323 | configuration["couleurs"] = {} | |
324 | # gérer les couleurs | |
325 | for clecouleur in DEFAUT["couleurs"]: | |
326 | coul = rgb_vers_tuple(data.get("couleur_"+clecouleur,""),DEFAUT["couleurs"].get(clecouleur, ""),liste_err) | |
327 | configuration["couleurs"][clecouleur] = coul | |
328 | ||
329 | # symbole | |
330 | configuration["symbole"] = gere_symbole( data.get("symbole", "")) | |
331 | ||
332 | configuration["non_sauve"]["grilleamelio"] = gere_checkbox(data.get("grilleamelio","")) | |
333 | ||
334 | ||
335 | #### La partie extrapolation n'a pas besoin d'être sauvée | |
336 | configuration["non_sauve"]["prolongercourbes"] = gere_checkbox(data.get("prolongercourbes","")) | |
337 | ||
338 | # Valeur par défaut : 1 | |
339 | debug(data.get("nbextradata", "aaargh"), liste_err) | |
340 | nbextradata = data.get("nbextradata",1) | |
341 | try: | |
342 | nbextradata = int(nbextradata) | |
343 | except: | |
344 | warning("Le nombre de données sur lequel on extrapole est invalide : "+nbextradata, liste_err) | |
345 | nbextradata = 1 | |
346 | configuration["non_sauve"]["nbextradata"] = nbextradata | |
347 | ||
348 | if data.get("calculextradata_type","") in CONFIG["liste_typedonnees"]: | |
349 | configuration["non_sauve"]["calculextradata_type"] = data.get("calculextradata_type","") | |
350 | configuration["non_sauve"]["calculextradata_age"] = convertit_jours_vers_python(data.get("calculextradata_age","0j"),liste_err) | |
351 | else: | |
352 | configuration["non_sauve"]["calculextradata_type"] = "" | |
353 | # On ne met rien dans l'âge, pas la peine | |
354 | ||
355 | ctyped = data.get("calculextratemps_type","") | |
356 | if ctyped in CONFIG["liste_typedonnees"]: | |
357 | configuration["non_sauve"]["calculextratemps_type"] = ctyped | |
358 | configuration["non_sauve"]["calculextratemps_val"] = convertit_donnee_vers_python(data.get("calculextratemps_val",""), ctyped, liste_err) | |
359 | else: | |
360 | configuration["non_sauve"]["calculextratemps_type"] = "" | |
361 | ||
362 | # Tracer les calculs sur la grille | |
363 | configuration["non_sauve"]["calculextradata_trace"] = gere_checkbox(data.get("calculextradata_trace")) | |
364 | configuration["non_sauve"]["calculextratemps_trace"] = gere_checkbox(data.get("calculextratemps_trace")) | |
365 | ||
366 | ||
367 | return configuration | |
368 | ||
369 | ||
370 | ||
371 | ## web vers python : données | |
372 | def gere_donnees(data,naissance,typedonnee,liste_err): | |
373 | """ prend en argument le dictionnaire de requête, et la date de | |
374 | naissance (éventuellement vide), et construit deux listes : | |
375 | l_jours et l_data correspondantes. | |
376 | Il faut donner en argument le type de données : voir | |
377 | CONFIG["liste_typedonnees"]""" | |
378 | if typedonnee not in CONFIG["liste_typedonnees"]: | |
379 | warning("gere_donnees : le type de données : "+typedonnee+" est invalide !! Types acceptés : "+str(CONFIG["liste_typedonnees"]),liste_err) | |
380 | return ([],[]) | |
381 | ||
382 | # On construit une liste de couples d'abord | |
383 | liste_donnees = [] | |
384 | ||
385 | i = 0 | |
386 | # On va chercher si y'a des données à donnee_i | |
387 | while typedonnee+"_"+str(i) in data.keys(): | |
388 | if data[typedonnee+"_"+str(i)] != "": | |
389 | donnee = convertit_donnee_vers_python(data[typedonnee+"_"+str(i)],typedonnee,liste_err) | |
390 | age = data.get("age_"+str(i),"") | |
391 | if age !="": | |
392 | age = convertit_jours_vers_python(age,liste_err) | |
393 | liste_donnees.append((age,donnee)) | |
394 | else: | |
395 | date = data.get("date_"+str(i),"") | |
396 | datep = convertit_date_vers_python(date,liste_err) | |
397 | # on vérifie la date | |
398 | if naissance == "": | |
399 | warning("La date de naissance n'a pas été précisée. Du coup on ne peut pas calculer l'âge de l'enfant le "+date,liste_err) | |
400 | elif datep != "": # la date est valide et on a une date de naissance | |
401 | age = delta_date(datep,naissance) | |
402 | liste_donnees.append((age,donnee)) | |
403 | i+=1 | |
404 | ||
405 | # Trier la liste | |
406 | liste_donnees.sort(key=lambda x : x[0]) | |
407 | ||
408 | # splitter la liste | |
409 | l_jours = [x[0] for x in liste_donnees] | |
410 | l_donnee = [x[1] for x in liste_donnees] | |
411 | ||
412 | return (l_jours,l_donnee) | |
413 | ||
414 | ||
415 | # python vers Json | |
416 | #### export vers json | |
417 | ||
418 | def donnees_vers_json(l_jours,l_poids,l_jourst,l_taille,config): | |
419 | """ retourne le json à renvoyer""" | |
420 | gros_dico = copy.deepcopy(config) | |
421 | gros_dico["version"] = CONFIG["version"] | |
422 | l_jours2 = [convertit_age_vers_texte(d) for d in l_jours] | |
423 | l_jourst2 = [convertit_age_vers_texte(d) for d in l_jourst] | |
424 | gros_dico["data_j"] = l_jours2 | |
425 | gros_dico["data_p"] = l_poids | |
426 | gros_dico["data_jours_taille"] = l_jourst2 | |
427 | gros_dico["data_taille"] = l_taille | |
428 | # gérer la date de naissance | |
429 | if gros_dico.get("naissance","") != "": | |
430 | gros_dico["naissance"] = convertit_date_vers_texte(gros_dico["naissance"]) | |
431 | # Calcul de toutes les dates de données | |
432 | l_dates_poids = [convertit_date_vers_texte( config["naissance"] + datetime.timedelta(days=jours) ) for jours in l_jours] | |
433 | l_dates_taille = [convertit_date_vers_texte( config["naissance"] + datetime.timedelta(days=jours) ) for jours in l_jourst] | |
434 | gros_dico["data_dates_poids"]= l_dates_poids | |
435 | gros_dico["data_dates_taille"] = l_dates_taille | |
436 | ||
437 | ||
438 | # gérer l'age maxi | |
439 | gros_dico["maxi"] = convertit_age_vers_texte(gros_dico["maxi"]) | |
440 | # gérer les couleurs | |
441 | for clecouleur in DEFAUT["couleurs"]: | |
442 | gros_dico["couleurs"][clecouleur] = tuple_vers_rgb(gros_dico["couleurs"][clecouleur]) | |
443 | ||
444 | # Enlever ce qui ne se sauvegarde pas si y'a | |
445 | if "non_sauve" in gros_dico: | |
446 | del gros_dico["non_sauve"] | |
447 | ||
448 | return json.dumps(gros_dico, indent=2,ensure_ascii=False ) | |
449 | ||
450 | def fusionne_donnees(listes_jours,listes_donnees, listes_dates): | |
451 | """ prend en argument deux dicos de listes. Chaque liste de jours est associée à une liste | |
452 | de données (par la même clé de type de données). Il faut les fusionner pour avoir une liste de dictionnaires, de type | |
453 | {"age":truc, "donnee1":truc, "donnee2":truc, ...} triée par ordre de jours. Si jamais une des données est vide, | |
454 | le champ du dictionnaire n'est pas rempli | |
455 | Le troisième paquet de listes (les dates) peut être vide ou bien simiaire : même clés.""" | |
456 | ||
457 | def fini(lj): | |
458 | """ teste si les listes sont toutes vides """ | |
459 | for l in lj.values(): | |
460 | if l!=[]: | |
461 | return False | |
462 | return True | |
463 | ||
464 | def mini(lj): | |
465 | """ renvoie la clé de la liste où il y a le min """ | |
466 | cle_mini = CONFIG["liste_typedonnees"][0] | |
467 | for (cle,liste) in lj.items(): | |
468 | if lj[cle_mini]== []: | |
469 | cle_mini = cle | |
470 | elif lj[cle] != []: | |
471 | if convertit_jours_vers_python(lj[cle][0],initialise_erreurs())<convertit_jours_vers_python(lj[cle_mini][0],initialise_erreurs()): | |
472 | cle_mini = cle | |
473 | return cle_mini | |
474 | ||
475 | liste_f = [] | |
476 | while not(fini(listes_jours)): | |
477 | typedonnee = mini(listes_jours) | |
478 | # On extrait les données dans les deux listes (jours et données) | |
479 | jour = listes_jours[typedonnee].pop(0) | |
480 | donnee = listes_donnees[typedonnee].pop(0) | |
481 | ||
482 | if liste_f == [] or jour != liste_f[-1]["age"]: # Si le jour est un "nouveau" jour | |
483 | liste_f.append({"age":jour}) | |
484 | # On met à jour l'élément (ou on l'ajoute) | |
485 | liste_f[-1][typedonnee] = donnee | |
486 | ||
487 | # Si il y a une date associée, on la met ! | |
488 | if listes_dates[typedonnee] != []: | |
489 | date = listes_dates[typedonnee].pop(0) | |
490 | liste_f[-1]["date"] = convertit_date_vers_texte(date) | |
491 | ||
492 | ||
493 | return liste_f | |
494 | ||
495 | ||
496 | ### COnversion json vers formulaire | |
497 | # Json -> formulaire HTML | |
498 | def fichier_json_vers_configdonnees(chaine,liste_err): | |
499 | """ prend le json importé (chaine) et l'exporte vers les valeurs du formulaire | |
500 | Renvoyé sous forme de dictionnaire (mais adapté au formulaire web)""" | |
501 | debug("json vers config : Prêt à interpréter le json",liste_err) | |
502 | try: | |
503 | valform = json.loads(chaine) | |
504 | except : | |
505 | erreur("Impossible de lire le fichier json !",liste_err) | |
506 | return {} | |
507 | # Il faut maintenant récupérer les l_jours et l_poids puis les remettre | |
508 | # sous forme de age_i et poids_i | |
509 | ||
510 | listes_jours = {} | |
511 | listes_donnees = {} | |
512 | listes_dates = {} | |
513 | for typed in CONFIG["liste_typedonnees"]: | |
514 | if typed == "poids": # pour la rétrocompatibilité | |
515 | listes_jours[typed] = valform.get("data_j",[]) | |
516 | listes_donnees[typed] = valform.get("data_p",[]) | |
517 | listes_dates[typed] = valform.get("data_dates_"+typed,[]) | |
518 | else: | |
519 | listes_jours[typed] = valform.get("data_jours_"+typed,[]) | |
520 | listes_donnees[typed] = valform.get("data_"+typed,[]) | |
521 | listes_dates[typed] = valform.get("data_dates_"+typed,[]) | |
522 | ||
523 | ||
524 | debug("Avant fusion : listes jours "+str(listes_jours),liste_err) | |
525 | liste_donnees = fusionne_donnees(listes_jours,listes_donnees, listes_dates) | |
526 | debug("Fusion de listes ok. Liste moche : "+str(liste_donnees),liste_err) | |
527 | for i in range(len(liste_donnees)): | |
528 | for (cle,val) in liste_donnees[i].items(): | |
529 | valform[cle+"_"+str(i)] = val | |
530 | ||
531 | valform["nb_data"] = max(len(liste_donnees) +2,DEFAUT["nb_data"]) | |
532 | ||
533 | return valform | |
534 | ||
535 | ||
536 | ||
537 | #### Pour l'insertion d'une 2e (ou plus) courbe sur le graphique, ue fonction qui sépare tout ça | |
538 | def eclate_donnees_additionnelles(conf, ljours, ldonnees, symb, couleur): | |
539 | """ conf est la config (on ne garde que le nom) pour un enfant additionnel, | |
540 | ljours et ldonnees les dictionnaires de listes contenant les données. | |
541 | symb est le symbole choisi pour cette courbe additionnelle (déjà vérifié) | |
542 | On fabrique un joli dictionnaire typed -> (conf lj, ldonnee) avec le nom de l'enfant, | |
543 | et les données pour chaque typed""" | |
544 | ||
545 | retour = {} | |
546 | conf["symbole"] = symb # On ajoute le symbole additionnel | |
547 | conf["couleurcourbe"] = couleur # la couleur | |
548 | for typed in CONFIG["liste_typedonnees"]: | |
549 | retour[typed] = (conf, ljours[typed], ldonnees[typed]) | |
550 | ||
551 | return retour |