Efi2Xsd/AccasXsd.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3 import sys,os
   4 import types
   5
   6 # CONTEXT est accessible (__init__.py de Noyau)
   7
   8 #import raw.efficas as efficas
   9 sys.path.insert(0,os.path.abspath(os.path.join(os.getcwd(),'..')))
  10
  11 # ds l init du SIMP il manque siValide et fenetreIhm
  12
  13 from .mapDesTypes import dictSIMPEficasXML, dictSIMPXMLEficas
  14 from .mapDesTypes import dictFACTEficasXML, dictFACTXMLEficas
  15 from .mapDesTypes import dictPROCEficasXML, dictPROCXMLEficas
  16 from .mapDesTypes import dictOPEREficasXML, dictOPERXMLEficas
  17 from .mapDesTypes import dictBLOCEficasXML, dictBLOCXMLEficas
  18 from .mapDesTypes import dictPourCast, dictNomsDesTypes
  19 from .mapDesTypes import listeParamDeTypeTypeAttendu, listeParamDeTypeStr, dictPourCast
  20 from .mapDesTypes import listeParamTjsSequence, listeParamSelonType
  21 from .mapDesTypes import Tuple
  22
  23
  24 from .balises import *
  25
  26 # -----------------
  27 class X_definition:
  28 # -----------------
  29
  30    def getCode(self):
  31        if hasattr(self,'code') : return
  32        obj=self
  33        while ( not hasattr(obj,'code') ): obj=obj.pere
  34        self.code = obj.code
  35
  36    #def genealogie(self,n):
  37    #    texte=self.nom
  38    #    obj=self
  39    #    j=1
  40    #    while ( hasattr(obj,'pere') ):
  41    #        texte=obj.pere.nom+'_'+texte
  42    #        obj=obj.pere
  43    #        j=j+1
  44    #        if j > n : return (True, 'T_'+texte)
  45    #    return (False, 'T_'+texte)
  46
  47    def definitNomDuTypePyxb(self):
  48        self.aCreer = True
  49        cata = CONTEXT.getCurrentCata()
  50        nom='T_'+self.nom
  51        if not (nom in cata.dictTypesXSD.keys()) :
  52           cata.dictTypesXSD[nom] = [self,]
  53           return nom
  54        self.aCreer = False
  55        if nom == 'T_Consigne' : return nom
  56        listePossible=cata.dictTypesXSD[nom]
  57        indice=0
  58        while (indice < len(listePossible)) :
  59           objAComparer=listePossible[indice]
  60           if self.compare(objAComparer) : return objAComparer.nomDuTypePyxb
  61           indice += 1
  62        self.aCreer = True
  63        cata.dictTypesXSD[nom].append(self)
  64        nomAlter='T_'+self.nom+'_'+str(indice)
  65        return nomAlter
  66
  67   # def existeDeja(self,nom):
  68   #     if nom in cata.dictTypesXSD.keys() :
  69   #         self.aCreer = False
  70   #         return cata.dictTypesXSD[nom]
  71   #     else :
  72   #         cata.dictTypesXSD[nom] = self
  73   #         return None
  74
  75 # ----------------------------------------
  76 class X_definitionComposee (X_definition):
  77 # ----------------------------------------
  78
  79    def CreeTexteComplexeVenantDesFils(self):
  80        texteComplexeVenantDesFils=""
  81        for nom in self.ordre_mc:
  82           mcFils = self.entites[nom]
  83           mcFils.dumpXsd()
  84           self.texteComplexe += mcFils.texteElt
  85           self.texteSimple   += mcFils.texteSimple
  86           texteComplexeVenantDesFils += mcFils.texteComplexe
  87        return texteComplexeVenantDesFils
  88
  89    def dumpXsd(self):
  90        #print ('------------------------------------------------')
  91        #print ('dumpXsd de ' , self.nom)
  92
  93        self.getCode()
  94        self.nomDuTypePyxb  = self.definitNomDuTypePyxb()
  95        self.texteSimple    = "" # on n ajoute pas de type simple
  96
  97        self.traduitMinMax()
  98        # pour accepter les PROC et ...
  99        #
 100        if self.aCreer :
 101           self.texteComplexe = debutTypeCompo.format(self.nomDuTypePyxb,self.minOccurs,self.maxOccurs)
 102           texteComplexeVenantDesFils=self.CreeTexteComplexeVenantDesFils()
 103           self.texteComplexe  = texteComplexeVenantDesFils + self.texteComplexe
 104           self.texteComplexe += finTypeCompo
 105        else :
 106           self.texteComplexe = ""
 107
 108        minDsSequence=0
 109        if hasattr(self, 'statut') and self.statut=='f'  : minDsSequence=0
 110        maxDsSequence=1
 111        if self.label in ('BLOC', 'FACT'):
 112           self.texteElt=eltCompoDsSequence.format(self.nom,self.code,self.nomDuTypePyxb,minDsSequence,maxDsSequence)
 113        else :
 114           self.texteElt=eltCompoDsSequenceSiProc.format(self.nom,self.code,self.nomDuTypePyxb)
 115        #print (self.texteComplexe)
 116        #print ('------------------------------------------------')
 117
 118    def traduitMinMax(self):
 119    # ____________________
 120    # valable pour bloc, proc et oper
 121       self.minOccurs = 0
 122       self.maxOccurs = 1
 123
 124    def compare(self,autreMC):
 125        if self.label != autreMC.label : return False
 126        for attr in (  'regles', 'fr',  'defaut', 'min' ,'max', 'position' , 'docu' ) :
 127            val1=getattr(self,attr)
 128            val2=getattr(autreMC,attr)
 129            if val1 != val2 : return False
 130        for defFille in self.entites.keys():
 131            if defFille not in autreMC.entites.keys() : return False
 132            if not self.entites[defFille].compare(autreMC.entites[defFille]) : return False
 133        return True
 134
 135 # ---------------------------------
 136 class X_FACT (X_definitionComposee):
 137 #--------- ------------------------
 138    def traduitMinMax(self):
 139        if self.max     == '**' or self.max  == float('inf') : self.maxOccurs="unbounded"
 140        else :                                                 self.maxOccurs = self.max
 141        self.minOccurs = self.min
 142        if self.statut =='f' : self.minOccurs=0
 143
 144 # ---------------------------------
 145 class X_OPER (X_definitionComposee):
 146 # ---------------------------------
 147     pass
 148
 149 # ----------------------------------
 150 class X_PROC (X_definitionComposee):
 151 #-----------------------------------
 152     pass
 153
 154 #-----------------------------------
 155 class X_BLOC (X_definitionComposee):
 156 #-----------------------------------
 157    def dumpXsd(self):
 158        #print ('------------------------------------------------')
 159        #print ('dumpXsd de ' , self.nom)
 160
 161        self.getCode()
 162        self.nomDuTypePyxb  = self.definitNomDuTypePyxb()
 163        self.texteSimple    = "" # on n ajoute pas de type simple
 164
 165        # Pour les blocs le minOccurs vaut 0 et le max 1
 166        if self.aCreer :
 167           self.texteComplexe = debutTypeSubst.format(self.nomDuTypePyxb)
 168           texteComplexeVenantDesFils=self.CreeTexteComplexeVenantDesFils()
 169           self.texteComplexe  = texteComplexeVenantDesFils + self.texteComplexe
 170           self.texteComplexe += finTypeSubst
 171        else :
 172           self.texteComplexe = ""
 173
 174        self.texteElt=substDsSequence.format(self.code,self.nomDuTypePyxb,0,1)
 175
 176        #print ('------------------------------------------------')
 177
 178    def compare(self,autreMC):
 179        if self.label != autreMC.label : return False
 180        for attr in ( 'condition', 'regles', ):
 181            val1=getattr(self,attr)
 182            val2=getattr(autreMC,attr)
 183            if val1 != val2 : return False
 184        for defFille in self.entites.keys():
 185            if defFille not in autreMC.entites.keys() : return False
 186            if not self.entites[defFille].compare(autreMC.entites[defFille]) : return False
 187        return True
 188
 189
 190 #--------------------------------
 191 class X_SIMP (X_definition):
 192 #--------------------------------
 193    def dumpXsd(self):
 194        #print ('exploreObjet SIMP')
 195        self.getCode()
 196        self.aCreer = True
 197
 198        #  --> homonymie on peut utiliser genealogie
 199        #self.traduitMinMax()
 200        #self.traduitValMinValMax()
 201        self.nomDuTypeDeBase = self.traduitType()
 202        self.nomDuTypePyxb   = self.definitNomDuTypePyxb()
 203        if self.aCreer == True :
 204          if self.into != None:
 205            self.texteSimple   =  debutTypeSimpleWithInto.format (self.nomDuTypePyxb, self.nomDuTypeDeBase)
 206            for val in self.into :
 207                self.texteSimple += typeSimpleWithInto.format(val)
 208            self.texteSimple  += finTypeSimpleWithInto
 209          else :
 210            self.texteSimple     = typeSimple.format(self.nomDuTypePyxb, self.nomDuTypeDeBase)
 211        else :
 212          # le type existe deja
 213          self.texteSimple=""
 214        self.texteComplexe   = ""
 215
 216        # on se sert des listes si maxOccurs est > 0
 217        # a gerer dans le dump
 218        if self.statut =='f' : minOccurs = 0
 219        else :                 minOccurs = 1
 220        self.texteElt = eltDsSequence.format(self.nom,self.code,self.nomDuTypePyxb,minOccurs,1)
 221
 222
 223    def traduitType(self):
 224        # il faut traduire le min et le max
 225        # il faut ajouter les regles
 226        # il faut gerer les types tuple et fichier
 227
 228        if hasattr(self.type[0], 'label') and self.type[0].label == "Tuple"  : return ('XXXXXXXX')
 229        return dictNomsDesTypes[self.type[0]]
 230
 231    def traduitValMinValMax(self):
 232        self.maxInclusive=self.val_max
 233        self.minInclusive=self.val_min
 234        if self.val_min == float('-inf') and val_max== float('inf') : return
 235        print ('il faut affiner le type du SIMP ', self.nom)
 236        if self.val_max == '**' or self.val_max == float('inf') : self.maxInclusive=None
 237        else : self.maxInclusive = self.val_max
 238        if self.val_min == '**' or self.val_max == float('-inf') : self.maxInclusive=None
 239        else : self.minInclusive = self.val_min
 240
 241    def traduitMinMax(self):
 242        if self.min == 1 and self.max == 1 :  return
 243        print ('il faut creer une liste ' , self.nom)
 244
 245    def compare(self,autreMC):
 246        if self.label != autreMC.label : return False
 247        for attr in ( 'type', 'ang', 'fr', 'into', 'intoSug' , 'siValide', 'defaut', 'min' ,'max' ,'homo' ,'position' ,'val_min' , 'val_max' , 'docu' , 'validators' , 'sug' ) :
 248            val1=getattr(self,attr)
 249            val2=getattr(autreMC,attr)
 250            if val1 != val2 : return False
 251        return True
 252
 253 #-----------------
 254 class X_JDC_CATA :
 255 #-----------------
 256
 257     def dumpXsd(self):
 258
 259         self.texteSimple   = ""
 260         self.texteComplexe = ""
 261         self.nomDuTypePyxb='T_'+self.code
 262         self.texteCata = debutTypeCata.format(self.nomDuTypePyxb)
 263         for commande in  self.commandes :
 264             commande.code=self.code
 265             commande.dumpXsd()
 266             self.texteSimple += commande.texteSimple
 267             self.texteSimple += commande.texteComplexe
 268             self.texteCata   += commande.texteElt
 269         self.texteCata += finTypeCata
 270         self.texteElt=eltCata.format(self.code,self.code, self.nomDuTypePyxb)
 271
 272         self.texteXSD  = texteDebut.format(self.code,self.code,self.code)
 273         self.texteXSD += self.texteSimple
 274         self.texteXSD += self.texteCata
 275         self.texteXSD += self.texteElt
 276         self.texteXSD += texteFin
 277         #print (self.texteSimple)
 278         #print (self.texteCata)
 279         #print (self.texteElt)
 280         print (self.texteXSD)
 281