1
2
3
4
5
6
7
8
9
10
11
12
13
14 import xmlrpclib
15 from zephir.config import charset
16
17
18 BACKEND_EXCEPTIONS = ['libpq.OperationalError','libpq.IntegrityError']
19
21 """Gère les erreurs provenant du backend xml-rpc
22 """
24 """Définition du message d'erreur
25 """
26 txt = """<p>Erreur provenant du backend XML-RPC<br/>
27 <a href="javascript:history.back()">retour</a><br/></p>"""
28 if msg :
29 txt2 = """<p><b>Détail</b> : %s </p>""" % msg
30 self.msg = txt + txt2
31 else :
32 self.msg = txt
33
36
38 """Différencie une erreur backend simple
39 d'un pb d'intégrité référentielle
40 """
42 txt = """Interdiction due à un problème d'intégrité référentielle dans la base de données
43 """
44 if msg:
45 txt2 = """, dans la table : <b>""" + msg + "</b>"
46 self.msg = txt + txt2
47 else :
48 self.msg = "<p>" + txt + "</p>"
49
52
54 """Transforme les objets unicode contenus dans un objet en chaines
55 """
56 if type(objet) == list:
57 l = []
58 for item in objet:
59 l.append(convert(item))
60 return l
61 if type(objet) == dict:
62 dico={}
63 for cle in objet.keys():
64 dico[cle] = convert(objet[cle])
65 return dico
66 if type(objet) == unicode:
67 string = objet.encode(charset)
68 return string
69 return objet
70
72 """Récupère les codes et les messages d'erreur système
73 """
74
75 return_code = liste_backend[0]
76
77
78 retour = liste_backend[1]
79 try:
80 assert liste_backend[2]
81 database_msg = liste_backend[2]
82 except:
83 database_msg = ""
84
85 if not return_code :
86
87 if retour in BACKEND_EXCEPTIONS :
88
89 database_msg = database_msg.split("from")[1]
90 raise DatabaseError(database_msg)
91 else:
92
93 raise BackendError()
94 else :
95
96 retour = convert(retour)
97 return retour
98
100 if x[1].upper() > y[1].upper():
101 return 1
102 elif x[1].upper() == y[1].upper():
103 return 0
104 else:
105 return -1
106
108 """utilitaires de récupérations de dictionnaires clef-libellé (nomenclatures)
109 """
110
111 - def __init__(self, server, rne_rapport=None):
124
126 """Dictionnaire clefs,libelle pour les variantes
127 """
128 libelle = {}
129 for v in self.variante :
130 libelle[v['id']] = xmlrpclib.escape(v['libelle'])
131 return libelle
132
134 """Dictionnaire clefs, libelle pour les variantes d'un module considéré
135 """
136 libelle = {}
137 for v in self.variante :
138 if int(v['module']) == int(id_module) :
139 libelle[v['id']] = xmlrpclib.escape(v['libelle'])
140 return libelle
141
143 """Dictionnaire clef,libelle pour les modules
144 """
145
146 dico_libelle = {}
147 for module in self.module_list :
148 dico_libelle[module['id']] = xmlrpclib.escape(module['libelle'])
149 return dico_libelle
150
152 """Dictionnaire clef,libelle pour les établissements
153 """
154
155 dico_libelle = {}
156 for etab in self.etab_list :
157 dico_libelle[etab['rne']] = xmlrpclib.escape(etab['libelle'])
158 return dico_libelle
159
161 """Types d'établissement
162 """
163 return self.types
164
166 """Gère les appels au backend
167 """
168 - def __init__(self,server,rne_rapport=None):
169 self.server = server
170 self.nomenc=Nomenclature(self.server, rne_rapport)
171 self.rne_rapport = rne_rapport
172 try:
173 if rne_rapport is not None:
174 self.liste_serveurs = backend(self.server.serveurs.groupe_serveur({'rne':rne_rapport}))
175 else:
176 self.liste_serveurs = backend(self.server.serveurs.get_serveur())
177 self.serv_etabs = {}
178 self.etat_serv = {}
179 for serveur in self.liste_serveurs:
180
181 if self.serv_etabs.has_key(serveur["rne"]):
182 self.serv_etabs[serveur["rne"]].append(serveur['id'])
183 else:
184 self.serv_etabs[serveur["rne"]] = [serveur['id']]
185
186 liste_etat = []
187 try:
188 try:
189
190 etat2 = eval(serveur['params'])
191 except:
192 etat2 = backend(self.server.serveurs.get_status(serveur['id']))
193 if etat2['cle_ok'] == 1:
194
195 for cle in etat2.keys():
196 etat = etat2[cle]
197 if type(etat) == list:
198 if len(etat) == 3:
199 if etat[0] == 0:
200 liste_etat.append("erreur rapportée par zephir (cf. page d'état)")
201 try:
202 etat1 = int(serveur["status"])
203 if etat1 == 2:
204 liste_etat.append("contact perdu avec le serveur")
205 if etat1 in [3,4]:
206 liste_etat.append("file d'attente bloquée (problème uucp ou ssh)")
207 if etat1 in [0,4]:
208 liste_etat.append("erreur reportée par le serveur (cf. page de surveillance)")
209 except:
210 liste_etat.append("pas de statistiques reçues")
211 else:
212 liste_etat.append("pas de serveur enregistré")
213 except:
214 pass
215
216 self.etat_serv[serveur['id']] = liste_etat
217
218 except BackendError:
219 raise BackendError, "erreur lors de la récupération des données"
220
221 - def module(self, id_module=None):
222 """Module ou liste de modules
223 """
224 if id_module:
225 for module in self.nomenc.modules_list:
226 if int(module['id']) == int(id_module):
227 return module
228 return self.nomenc.module_list
229
231 """Dictionnaire clef-libelle pour les modules
232 """
233 return self.nomenc.get_module()
234
236 """Libellé d'un module
237 """
238 dico_module = self.dict_module()
239 return xmlrpclib.escape(dico_module[id_module])
240
241
243 """Variante d'un module
244 """
245 if id_variante:
246 for variante in self.nomenc.variante:
247 if int(variante['id']) == int(id_variante):
248 return [variante]
249 return self.nomenc.variante
250
252 """dictionnaire des variantes d'un module
253 """
254 return self.nomenc.get_variante_module(id_module)
255
257 """Liste des id des variantes d'un module
258 """
259 return self._dict_variante().keys()
260
266
278
280 """Libellé d'un serveur
281 """
282 for serveur in self.liste_serveurs:
283 if int(serveur['id']) == int(id_serveur):
284 return xmlrpclib.escape(serveur['libelle'])
285
287 """Liste des libellés des serveurs d'un établissement
288 """
289 list = []
290 for id in self.id_serveur_etab(rne):
291 string = self.nom_serveur(id) + " (%s)" % id
292 if self.etat_serv[id] != []:
293 string += xmlrpclib.escape(" : %s" % ", ".join(self.etat_serv[id]))
294 list.append(string)
295 else:
296 etat = ""
297
298 return list
299
301 """Liste des id des serveurs d'un établissement
302 """
303 if self.serv_etabs.has_key(rne):
304 return self.serv_etabs[rne]
305 else:
306 return []
307
309 """Détail d'un établissement
310 """
311 for etab in self.nomenc.etab_list:
312 if etab['rne'].upper() == rne.upper():
313
314 etab['type'] = xmlrpclib.escape(self.nom_type(str(etab['type'])))
315 return etab
316 return {}
317
319 """Nomenclature etab
320 """
321 return self.nomenc.get_etab()
322
324 """Liste des rne des etablissements
325 """
326 dico=self._dict_etab().items()
327 dico.sort(tri_etab)
328 liste=[]
329 for rne in dico:
330 liste.append(rne[0])
331 return liste
332
334 """liste des noms des etablissements
335 """
336 dico=self._dict_etab().items()
337 dico.sort(tri_etab)
338 liste=[]
339 for rne in dico:
340 liste.append(xmlrpclib.escape("%s (%s)" % (rne[1],rne[0])))
341 return liste
342
343
345 """libellé d'un établissement
346 """
347 return xmlrpclib.escape(self._dict_etab()[rne])
348
350 """Nomenclature des types d'etab
351 """
352 return self.nomenc.get_types()
353
355 """libelle d'un type d'etab
356 """
357 return xmlrpclib.escape(self._dict_type()[type])
358
359
360
361
363 """Liste des services d'un module
364 """
365 return backend(self.server.services.get_service_module(id))
366
367 if __name__ == "__main__" :
368
369 print Connecteur().module()
370
371
372
373
374
375
376
377
378 pass
379