2 # -*- coding: utf-8 -*-
4 import raw.efficas as efficas
7 sys.path.insert(0,os.path.abspath(os.path.join(os.getcwd(),'..')))
13 # ds l init du SIMP il manque siValide et fenetreIhm
15 from mapDesTypes import dictSIMPEficasXML, dictSIMPXMLEficas
16 from mapDesTypes import dictFACTEficasXML, dictFACTXMLEficas
17 from mapDesTypes import dictPROCEficasXML, dictPROCXMLEficas
18 from mapDesTypes import dictOPEREficasXML, dictOPERXMLEficas
19 from mapDesTypes import dictBLOCEficasXML, dictBLOCXMLEficas
20 from mapDesTypes import dictPourCast
21 from mapDesTypes import listeParamDeTypeTypeAttendu, listeParamDeTypeStr, dictPourCast
22 from mapDesTypes import listeParamTjsSequence, listeParamSelonType
25 # ------------------------------
26 class objetDefinitionAccas:
27 # ------------------------------
29 def argumentXMLToEficas(self):
30 # ---------------------------
31 # Attention, pas de validation pour l instant
32 # il faut verifier la coherence entre les types contenus dans defaut, sug ... et le typeAttendu
33 # tout cela dans une fonction verifie pas faite -)
35 # Recuperation parametres
36 self.dictArgsEficas={}
37 for nomXMLArg in dir(self) :
38 if nomXMLArg in self.dictATraiter :
39 nomEficasArg=self.dictATraiter[nomXMLArg]
40 argu=getattr(self,nomXMLArg)
41 if argu==None : continue
43 if type(nomEficasArg) == types.DictionaryType:
44 for nomXML in list(nomEficasArg.keys()):
45 arguDecoupe=getattr(argu,nomXML)
46 nomEficasDecoupe=nomEficasArg[nomXML]
47 if arguDecoupe == None : continue
48 self.dictArgsEficas[nomEficasDecoupe]=arguDecoupe
50 self.dictArgsEficas[nomEficasArg] = argu
52 # Cast dans le bon type des parametres si necessaire
53 if 'min' in list(self.dictArgsEficas.keys()):
54 self.dictArgsEficas['min']=int(self.dictArgsEficas['min'])
56 if 'max' in list(self.dictArgsEficas.keys()):
57 if self.dictArgsEficas['max']== -1 : self.dictArgsEficas['max']="**"
58 else : self.dictArgsEficas['max']=int(self.dictArgsEficas['max'])
60 for param in list(self.dictArgsEficas.keys()):
61 if param in listeParamDeTypeStr :
62 self.dictArgsEficas[param]=unicode(self.dictArgsEficas[param])
64 # En 2.7 a revoir en 3 ? necessaire
65 self.nomObj=str(self.nom)
67 def getAccasEquivalent(self):
68 # ---------------------------
69 return self.nomObj, self.objAccas
72 # ---------------------------------------------------------
73 class objetComposeDefinitionAccas (objetDefinitionAccas):
74 # ---------------------------------------------------------
75 def exploreArbre(self,cata):
76 # --------------------------
78 for obj in self.content(): liste.append(obj)
80 # PNPNPN essayer de comprendre reverse ou non
83 if hasattr(obj,'explore') : obj.explore(cata)
84 if hasattr(obj,'getAccasEquivalent') :
85 nom,objetAccas=obj.getAccasEquivalent()
86 self.dictArgsEficas[nom]=objetAccas
88 # ----------------------------------------------------
89 class monSIMP (efficas.T_SIMP, objetDefinitionAccas):
90 # ----------------------------------------------------
92 def explore(self,cata):
93 # --------------------
94 #print ("je passe dans explore pour SIMP ", self.nom)
95 self.dictATraiter= dictSIMPXMLEficas
96 self.argumentXMLToEficas()
97 #print (self.dictArgsEficas)
100 self.objAccas=A_SIMP.SIMP(**self.dictArgsEficas)
101 self.objAccas.nom=self.nomObj
103 def argumentXMLToEficas(self):
104 # ----------------------------
106 objetDefinitionAccas.argumentXMLToEficas(self)
108 if self.attendTuple() :
109 #nbDElts=type(listeDElt[0])
110 print self.nomTypeAttendu
113 self.traiteLesSequences()
114 #self.convertitLesTypes()
116 def attendListe(self):
118 if 'max' in self.dictArgsEficas :
119 if self.dictArgsEficas['max'] > 1 : return True
120 if self.dictArgsEficas['max'] == "**" : return True
123 def attendTuple(self):
125 if self.dictArgsEficas['typ'] != 'tuple' : return False
130 if self.dictArgsEficas['typ'] == 'TXM' : return True
134 def traiteLesSequences(self):
135 # ---------------------------
136 listeDeListe=self.attendListe()
137 for param in listeParamTjsSequence :
138 if param in self.dictArgsEficas :
139 if listeDeListe == False:
140 #print ('________________________________')
142 for i in range(len(self.dictArgsEficas[param])):
144 # ici on ne sait pas si on est un type simple ou complexe ?
145 listeDElt.append(self.dictArgsEficas[param][i].content()[0])
146 listeRetour=self.convertitListeDsLeBonType(listeDElt)
148 #print ('________________________________')
149 self.dictArgsEficas[param]=listeRetour
152 # on transforme en liste pour traiter chaque elt de la liste
153 for i in range(len(self.dictArgsEficas[param])):
154 if self.dictArgsEficas[param][i].typesimple != None :
155 lesElts=self.dictArgsEficas[param][i].typesimple
157 lesElts=self.dictArgsEficas[param][i].content()
158 if (not(isinstance(lesElts,list)) and not (isinstance(lesElts,tuple))):
160 lesEltsTransformes=self.convertitListeDsLeBonType(lesElts)
161 lesEltsTransformes=self.convertitListeDsLeBonType(lesElts)
162 listeResultat.append(lesEltsTransformes)
163 self.dictArgsEficas[param]=listeResultat
164 #print ('fin de traiteLesSequences pour', self.nom, ' param :', param, 'listeResultat',self.dictArgsEficas[param])
167 def convertitListeDsLeBonType(self,listeDElt):
168 # -------------------------------------------
169 # Cas des Tuples non traites
170 typeAttendu = self.dictArgsEficas['typ']
171 if typeAttendu in list(dictPourCast.keys()):
173 castDsLeTypeAttendu=dictPourCast[typeAttendu]
174 for valeurACaster in listeDElt :
175 val=castDsLeTypeAttendu(valeurACaster)
176 nouvelleListe.append(val)
178 elif self.attendTuple() :
179 nbDElts=type(listeDElt[0]).n
181 else : return listeDElt
185 def convertitLesTypes(self):
186 # ------------------------
187 # Cas des Tuples non traites
188 # Cas des fonctions utilisateurs non traites
190 typeAttendu = self.dictArgsEficas['typ']
191 if typeAttendu in list(dictPourCast.keys()):
192 castDsLeTypeAttendu=dictPourCast[typeAttendu]
193 for param in listeParamDeTypeTypeAttendu :
194 if param in list(self.dictArgsEficas.keys()):
195 if param in listeParamEnListeSelonType or param in listeParamTjsEnListe :
196 print ('typeAttendu',typeAttendu)
197 print (self.dictArgsEficas[param])
198 print (self.dictArgsEficas[param].content())
199 print (self.dictArgsEficas[param].content())
201 valeurACaster=self.dictArgsEficas[param].typesimple
202 if not isinstance(valeurACaster, (list, tuple)) :
203 val=castDsLeTypeAttendu(valeurACaster)
204 self.dictArgsEficas[param]=val
207 for val in valeurACaster : liste.append(castDsLeTypeAttendu(val))
208 self.dictArgsEficas[param]=liste
211 # -------------------------------------------------------
212 class monFACT(efficas.T_FACT, objetComposeDefinitionAccas):
213 # -------------------------------------------------------
214 def explore(self,cata):
215 # --------------------
216 #print "je passe dans explore pour FACT ", self.nom
218 self.dictATraiter= dictFACTXMLEficas
219 self.argumentXMLToEficas()
220 self.exploreArbre(cata)
221 self.objAccas=A_FACT.FACT(**self.dictArgsEficas)
224 # ---------------------------------------------------------
225 class monPROC(efficas.T_PROC, objetComposeDefinitionAccas):
226 # ---------------------------------------------------------
227 def explore(self,cata):
228 # --------------------
229 print "je passe dans explore pour PROC ", self.nom
230 self.dictATraiter= dictPROCXMLEficas
231 self.argumentXMLToEficas()
232 self.exploreArbre(cata)
233 self.dictArgsEficas['op']=None
235 self.objAccas=A_PROC.PROC(**self.dictArgsEficas)
236 setattr(cata, self.nomObj,self.objAccas)
237 cata.contexteXML[self.nomObj]=self.objAccas
239 # ---------------------------------------------------------
240 class monOPER(efficas.T_OPER, objetComposeDefinitionAccas):
241 # ---------------------------------------------------------
242 def explore(self,cata):
243 # ------------------------
244 print "je passe dans explore pour OPER", self.nom
246 self.dictATraiter= dictOPERXMLEficas
247 self.argumentXMLToEficas()
248 self.exploreArbre(cata)
250 textCreationClasse='class '+str(self.typeCree)+'(ASSD): pass\n'
251 exec(textCreationClasse,globals())
252 maClasseCreee=globals()[self.typeCree]
253 self.dictArgsEficas['sd_prod'] = maClasseCreee
254 cata.contexteXML[self.typeCree] = maClasseCreee
256 self.dictArgsEficas['op'] = None
257 self.objAccas=A_OPER.OPER(**self.dictArgsEficas)
258 setattr(cata, self.nomObj,self.objAccas)
259 cata.contexteXML[self.nomObj] = self.objAccas
261 # ---------------------------------------------------------
262 class monBLOC(efficas.T_BLOC, objetComposeDefinitionAccas):
263 # ---------------------------------------------------------
264 def explore(self,cata):
265 # ------------------------
266 print ('je passe dans explore pour BLOC', self.nom)
268 self.dictATraiter= dictBLOCXMLEficas
269 self.argumentXMLToEficas()
270 self.exploreArbre(cata)
271 self.objAccas=A_BLOC.BLOC(**self.dictArgsEficas)
272 setattr(cata, self.nomObj,self.objAccas)
273 cata.contexteXML[self.nomObj] = self.objAccas
275 # ------------------------------
276 class monCata(efficas.T_cata):
277 # ------------------------------
278 def exploreCata(self):
279 # PNPNPN --> il faut revoir ce mecanisme
280 self.modeleMetier = None
281 # On positionne le contexte ACCAS
282 self.JdC = JDC_CATA (code = 'Atmo', execmodul = None,)
284 objAExplorer=self.commandes[0]
285 for obj in objAExplorer.content():
286 if hasattr(obj,'explore') : obj.explore(self)
291 # for etape in self.contexteXML.values() :
294 efficas.T_SIMP._SetSupersedingClass(monSIMP)
295 efficas.T_FACT._SetSupersedingClass(monFACT)
296 efficas.T_PROC._SetSupersedingClass(monPROC)
297 efficas.T_OPER._SetSupersedingClass(monOPER)
298 efficas.T_BLOC._SetSupersedingClass(monBLOC)
299 efficas.T_cata._SetSupersedingClass(monCata)
301 if __name__ == "__main__":
303 # print dir(efficas.T_SIMP)
305 #xml = open('cata_test1.xml').read()
306 with open('cata.xml') as fd :
308 SchemaMed = efficas.CreateFromDocument(xml)
309 SchemaMed.exploreCata()