Efi2Xsd/readerEfiXsd.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3 import sys,os
   4 import raw.efficas as efficas
   5 import types
   6
   7 sys.path.insert(0,os.path.abspath(os.path.join(os.getcwd(),'..')))
   8
   9
  10 from Accas import *
  11
  12
  13 # ds l init du SIMP il manque siValide et fenetreIhm
  14
  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
  23
  24
  25 # ------------------------------
  26 class objetDefinitionAccas:
  27 # ------------------------------
  28
  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 -)
  34
  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
  42
  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
  49               else :
  50                 self.dictArgsEficas[nomEficasArg] = argu
  51
  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'])
  55
  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'])
  59
  60       for param in list(self.dictArgsEficas.keys()):
  61           if param in listeParamDeTypeStr :
  62              self.dictArgsEficas[param]=unicode(self.dictArgsEficas[param])
  63
  64       # En 2.7 a revoir en 3 ? necessaire
  65       self.nomObj=str(self.nom)
  66
  67    def getAccasEquivalent(self):
  68    # ---------------------------
  69        return self.nomObj, self.objAccas
  70 #
  71
  72 # ---------------------------------------------------------
  73 class objetComposeDefinitionAccas (objetDefinitionAccas):
  74 # ---------------------------------------------------------
  75     def exploreArbre(self,cata):
  76     # --------------------------
  77       liste=[]
  78       for obj in self.content(): liste.append(obj)
  79       #liste.reverse()
  80       # PNPNPN essayer de comprendre reverse ou non
  81
  82       for obj in liste:
  83           if  hasattr(obj,'explore') : obj.explore(cata)
  84           if  hasattr(obj,'getAccasEquivalent') :
  85               nom,objetAccas=obj.getAccasEquivalent()
  86               self.dictArgsEficas[nom]=objetAccas
  87
  88 # ----------------------------------------------------
  89 class monSIMP (efficas.T_SIMP,  objetDefinitionAccas):
  90 # ----------------------------------------------------
  91
  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)
  98
  99
 100       self.objAccas=A_SIMP.SIMP(**self.dictArgsEficas)
 101       self.objAccas.nom=self.nomObj
 102
 103    def argumentXMLToEficas(self):
 104    # ----------------------------
 105       #print self.nom
 106       objetDefinitionAccas.argumentXMLToEficas(self)
 107
 108       if self.attendTuple() :
 109           #nbDElts=type(listeDElt[0])
 110           print self.nomTypeAttendu
 111
 112
 113       self.traiteLesSequences()
 114       #self.convertitLesTypes()
 115
 116    def attendListe(self):
 117    # ---------------
 118       if 'max' in self.dictArgsEficas :
 119         if self.dictArgsEficas['max'] > 1 : return True
 120         if self.dictArgsEficas['max'] == "**"  : return True
 121       return False
 122
 123    def attendTuple(self):
 124    # -----------------
 125        if self.dictArgsEficas['typ'] != 'tuple' : return False
 126        return True
 127
 128    def attendTXM(self):
 129    # ----------------
 130        if self.dictArgsEficas['typ'] == 'TXM' : return True
 131        return False
 132
 133
 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 ('________________________________')
 141                 listeDElt=[]
 142                 for i in range(len(self.dictArgsEficas[param])):
 143                 # ou typesimple ?
 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)
 147                 #print (listeRetour)
 148                 #print ('________________________________')
 149                 self.dictArgsEficas[param]=listeRetour
 150               else :
 151                  listeResultat=[]
 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
 156                      else :
 157                         lesElts=self.dictArgsEficas[param][i].content()
 158                      if (not(isinstance(lesElts,list)) and not (isinstance(lesElts,tuple))):
 159                         lesElts=(lesElts,)
 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])
 165
 166
 167    def convertitListeDsLeBonType(self,listeDElt):
 168    # -------------------------------------------
 169    # Cas des Tuples non traites
 170        typeAttendu = self.dictArgsEficas['typ']
 171        if typeAttendu in list(dictPourCast.keys()):
 172           nouvelleListe=[]
 173           castDsLeTypeAttendu=dictPourCast[typeAttendu]
 174           for valeurACaster in listeDElt :
 175               val=castDsLeTypeAttendu(valeurACaster)
 176               nouvelleListe.append(val)
 177           return nouvelleListe
 178        elif self.attendTuple() :
 179           nbDElts=type(listeDElt[0]).n
 180
 181        else : return listeDElt
 182
 183
 184
 185    def convertitLesTypes(self):
 186    # ------------------------
 187    # Cas des Tuples non traites
 188    # Cas des fonctions utilisateurs non traites
 189
 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())
 200                    return
 201                 valeurACaster=self.dictArgsEficas[param].typesimple
 202                 if not isinstance(valeurACaster, (list, tuple)) :
 203                    val=castDsLeTypeAttendu(valeurACaster)
 204                    self.dictArgsEficas[param]=val
 205                 else :
 206                    liste=[]
 207                    for val in valeurACaster : liste.append(castDsLeTypeAttendu(val))
 208                    self.dictArgsEficas[param]=liste
 209
 210
 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
 217
 218       self.dictATraiter= dictFACTXMLEficas
 219       self.argumentXMLToEficas()
 220       self.exploreArbre(cata)
 221       self.objAccas=A_FACT.FACT(**self.dictArgsEficas)
 222
 223
 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
 234
 235       self.objAccas=A_PROC.PROC(**self.dictArgsEficas)
 236       setattr(cata, self.nomObj,self.objAccas)
 237       cata.contexteXML[self.nomObj]=self.objAccas
 238
 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
 245       self.cata=cata
 246       self.dictATraiter= dictOPERXMLEficas
 247       self.argumentXMLToEficas()
 248       self.exploreArbre(cata)
 249
 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
 255
 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
 260
 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)
 267       self.cata=cata
 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
 274
 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,)
 283       self.contexteXML={}
 284       objAExplorer=self.commandes[0]
 285       for obj in objAExplorer.content():
 286          if  hasattr(obj,'explore') : obj.explore(self)
 287       #print dir(self.JdC)
 288
 289
 290    #def dumpXSD(self):
 291    #   for etape in self.contexteXML.values() :
 292    #       etape.dumpXSD()
 293
 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)
 300
 301 if __name__ == "__main__":
 302 #   print dir(efficas)
 303 #   print dir(efficas.T_SIMP)
 304
 305    #xml = open('cata_test1.xml').read()
 306    xml = open('cata.xml').read()
 307    SchemaMed = efficas.CreateFromDocument(xml)
 308    SchemaMed.exploreCata()
 309    #SchemaMed.dumpXSD()
 310