def __init__(
self,
versionCode,
- fichierCata,
+ cataFile,
formatFichierOut="python",
formatFichierIn="python",
default=False,
:type versionCode: string
:param versionCode: unique versionCode for the catalog
- :type fichierCata: string
- :param fichierCata: path of the file containing the catalog itself
+ :type cataFile: string
+ :param cataFile: path of the file containing the catalog itself
:type fileFormatOut: string
:param fileFormatOut: format of the files generated when using this catalog
"""
self.versionCode = versionCode
- self.fichierCata = fichierCata
+ self.cataFile = cataFile
self.formatFichierOut = formatFichierOut
self.formatFichierIn = formatFichierIn
self.default = default
code=cataTuple[0],
ssCode=cataTuple[1],
versionCode=cataTuple[0] + cataTuple[1],
- fichierCata=cataTuple[2],
+ cataFile=cataTuple[2],
formatFichierOut=cataTuple[3],
formatFichierIn=cataTuple[4],
)
desc = CatalogDescription(
code=cataTuple[0],
versionCode=cataTuple[1],
- fichierCata=cataTuple[2],
+ cataFile=cataTuple[2],
ssCode=cataTuple[3],
formatFichierOut="MAP",
formatFichierIn="MAP",
desc = CatalogDescription(
code=cataTuple[0],
versionCode=cataTuple[1],
- fichierCata=cataTuple[2],
+ cataFile=cataTuple[2],
formatFichierOut=cataTuple[3],
formatFichierIn="python",
)
desc = CatalogDescription(
code=cataTuple[0],
versionCode=cataTuple[1],
- fichierCata=cataTuple[2],
+ cataFile=cataTuple[2],
formatFichierOut=cataTuple[3],
formatFichierIn=cataTuple[4],
)
desc = CatalogDescription(
code=cataTuple[0],
versionCode=cataTuple[1],
- fichierCata=cataTuple[2],
+ cataFile=cataTuple[2],
formatFichierOut=cataTuple[3],
formatFichierIn=cataTuple[4],
defaut=cataTuple[5],
from Accas.extensions.eficas_translation import tr
from Accas.extensions.eficas_exception import EficasException
+debug = 0
# -----------------------------
class ReaderCataCommun(object):
#if ret == QDialog.Accepted:
if ret == 1:
cata = cataListeChoix[widgetChoix.CBChoixCata.currentIndex()]
- self.fichierCata = cata.fichierCata
+ self.cataFile = cata.cataFile
self.versionCode = cata.versionCode
self.appliEficas.formatFichierOut = cata.formatFichierOut
self.appliEficas.formatFichierIn = cata.formatFichierIn
# La version a ete fixee
for cata in listeCataPossibles:
if self.versionCode == cata.versionCode:
- self.fichierCata = cata.fichierCata
+ self.cataFile = cata.cataFile
self.versionCode = cata.versionCode
self.appliEficas.formatFichierOut = cata.formatFichierOut
self.appliEficas.formatFichierIn = cata.formatFichierIn
cataChoiceList.append(cata)
# le catalogue est fixe dans la ligne de commande
- if self.appliEficas.fichierCata != None:
+ if self.appliEficas.cataFile != None:
trouve = False
for catalogue in listeTousLesCatas:
- if os.path.abspath(catalogue.fichierCata) == ( os.path.abspath(self.appliEficas.fichierCata)):
+ if os.path.abspath(catalogue.cataFile) == ( os.path.abspath(self.appliEficas.cataFile)):
listeCataPossibles = (catalogue,)
trouve = True
break
if not trouve:
# utilise par Telemac
catalogue = CatalogDescription.createFromTuple(
- ( self.code, self.code, self.appliEficas.fichierCata, "python", "python",)
+ ( self.code, self.code, self.appliEficas.cataFile, "python", "python",)
)
listeCataPossibles = (catalogue,)
# La version a ete fixee
for cata in listeCataPossibles:
if self.versionCode == cata.versionCode:
- self.fichierCata = cata.fichierCata
+ self.cataFile = cata.cataFile
self.appliEficas.formatFichierIn = cata.formatFichierIn
self.appliEficas.formatFichierOut = cata.formatFichierOut
else:
if self.appliEficas.salome == 0: sys.exit(1)
elif len(cataListeChoix) == 1:
- self.fichierCata = cataListeChoix[0].fichierCata
+ self.cataFile = cataListeChoix[0].cataFile
self.versionCode = cataListeChoix[0].versionCode
self.appliEficas.formatFichierOut = cataListeChoix[0].formatFichierOut
self.appliEficas.formatFichierIn = cataListeChoix[0].formatFichierIn
self.demandeCatalogue = True
self.askChoixCatalogue(cataListeChoix)
- if self.fichierCata == None:
+ if self.cataFile == None:
if self.appliEficas.salome == 0:
print( "Pas de catalogue pour code %s, version %s" % (self.code, self.versionCode))
sys.exit(1)
self.appliEficas.formatFichierIn = "python"
self.appliEficas.formatFichierOut = "python"
self.versionCode = self.appliEficas.versionCode
- self.fichierCata = self.appliEficas.fichierCata
+ # TODO
+ # En transitoire pour garder la versionQT5 compatbile avec la nouvelle API
+ # Bien reflechir pour conserver la possibilité du prefs_Code.py
+ if self.editor.cataFile != None :
+ self.cataFile = self.editor.cataFile
+ else :
+ self.cataFile = self.appliEficas.cataFile
+ if debug : print ('ReaderCata self.cataFile =', self.cataFile)
self.openCata()
self.traiteIcones()
self.cataitem = None
dans le repertoire Cata
"""
# import du catalogue
- if self.fichierCata == None:
+ if self.cataFile == None:
self.choisitCata()
- self.cata = self.importCata(self.fichierCata)
+ self.cata = self.importCata(self.cataFile)
if self.code == "NonConnu": self.code = self.cata.JdC.code
modeleMetier = None
dicoEltDif = {}
)
exit()
try:
- nomCataXsd = os.path.splitext(os.path.basename(self.fichierCata))[0]
- fichierCataTrunc = os.path.splitext(
- os.path.basename(self.fichierCata)
+ nomCataXsd = os.path.splitext(os.path.basename(self.cataFile))[0]
+ cataFileTrunc = os.path.splitext(
+ os.path.basename(self.cataFile)
)[0]
- nomCataXsd = fichierCataTrunc + "_driver"
+ nomCataXsd = cataFileTrunc + "_driver"
- if os.path.dirname(self.fichierCata) == "":
+ if os.path.dirname(self.cataFile) == "":
pathCata = "./raw/" + nomCataXsd + ".py"
else:
pathCata = (
- os.path.dirname(self.fichierCata)
+ os.path.dirname(self.cataFile)
+ "/raw/"
+ nomCataXsd
+ ".py"
)
self.cata.fileModeleMetier = (
- os.path.dirname(self.fichierCata)
+ os.path.dirname(self.cataFile)
+ "/raw/"
+ nomCataXsd
+ ".xsd"
self.cata.modeleMetier = modeleMetier
if not self.cata:
self.appliEficas.afficheMessage(
- "Catalogue", "Impossible d'importer le catalogue " + self.fichierCata
+ "Catalogue", "Impossible d'importer le catalogue " + self.cataFile
)
self.appliEficas.close()
if self.appliEficas.salome == 0:
self.titre = (
self.versionEficas + tr(" avec le catalogue ")
- + os.path.basename(self.fichierCata)
+ + os.path.basename(self.cataFile)
)
self.editor.titre = self.titre
if hasattr(self.appliEficas, 'setWindowTitle') :
if hasattr(self.cata, "modifieCatalogueDeterministe"):
self.cata.modifieCatalogueDeterministe(self.cata)
- def importCata(self, fichierCata):
+ def importCata(self, cataFile):
"""
Realise l'import du catalogue dont le chemin d'acces est donne par cata
"""
- nomCata = os.path.splitext(os.path.basename(fichierCata))[0]
- repCata = os.path.abspath(os.path.dirname(fichierCata))
+ if debug : print ('importCata cataFile', cataFile)
+ nomCata = os.path.splitext(os.path.basename(cataFile))[0]
+ repCata = os.path.abspath(os.path.dirname(cataFile))
+ if debug : print ('importCata nomCata', cataFile)
+ if debug : print ('importCata repCata', cataFile)
sys.path[:0] = [repCata]
self.appliEficas.listePathAEnlever.append(repCata)
# try: self.appliEficas.mesScripts[self.code] = __import__(mesScriptsNomFichier)
# except: pass
- try:
+ #try:
+ if 1 :
#import importlib.util
from importlib import util
- cataSpec = util.spec_from_file_location(nomCata, fichierCata)
+ cataSpec = util.spec_from_file_location(nomCata, cataFile)
leCata = util.module_from_spec(cataSpec)
cataSpec.loader.exec_module(leCata)
return leCata
- except Exception as e:
+ #except Exception as e:
+ else :
self.appliEficas.afficheMessage("catalog python", "unable to load catalog file")
import traceback
traceback.print_exc()
Retrouve l'ordre des mots-cles dans le catalogue, cad :
Attention s appuie sur les commentaires
"""
- nomCata = os.path.splitext(os.path.basename(self.fichierCata))[0]
- repCata = os.path.dirname(self.fichierCata)
- self.commandesOrdreCatalogue = analyse_ordre_impose.analyseCatalogue( self.fichierCata)
+ nomCata = os.path.splitext(os.path.basename(self.cataFile))[0]
+ repCata = os.path.dirname(self.cataFile)
+ self.commandesOrdreCatalogue = analyse_ordre_impose.analyseCatalogue( self.cataFile)
def traiteIcones(self):
if self.appliEficas.maConfiguration.ficIcones == None:
if self.salome : name = "prefs_salome_" + self.appliEficas.code
else : name = "prefs_" + self.appliEficas.code
- if self.appliEficas.fichierCata != None :
- dirCata=os.path.dirname(self.appliEficas.fichierCata)
+ if self.appliEficas.cataFile != None :
+ dirCata=os.path.dirname(self.appliEficas.cataFile)
sys.path.append(os.path.abspath(dirCata))
self.appliEficas.listePathAEnlever.append(dirCata)
try:
Editeur de jdc
"""
- def __init__(self, appliEficas, fichier=None, jdc=None, include=0):
- # ----------------------------------------------------------------------------#
+
+ def __init__(self, appliEficas, cataFile = None, dataSetFile = None, jdc=None, include=0):
+ # ----------------------------------------------------------------------------------------#
if debug: print("dans le init de Editor")
+ if debug : print (self, appliEficas, cataFile, dataSetFile, jdc, include)
self.appliEficas = appliEficas
- self.fichier = fichier
- self.fichierComplet = fichier
- if fichier != None: self.extensionFichier = os.path.splitext(fichier)[1]
+ self.dataSetFile = dataSetFile
+ self.fichierComplet = dataSetFile
+ if dataSetFile != None: self.extensionFichier = os.path.splitext(dataSetFile)[1]
else: self.extensionFichier = None
self.jdc = jdc
+ self.cataFile = cataFile
self.first = True
self.jdc_item = None
self.dicoNouveauxMC = {}
self.dicoNouveauxFact = {}
self.dict_reels = {}
self.liste_simp_reel = []
- self.idEditor = uuid1().hex
- self.appliEficas.editorManager.dictEditors[self.idEditor]=self
+ self.editorId = uuid1().hex
+ self.appliEficas.editorManager.dictEditors[self.editorId]=self
# ces attributs sont mis a jour par definitCode appelee par newEditor
# ------- construction du jdc --------------
if self.readercata.cata == None:
- if self.fichier is not None:
- print ('fichier comm mais pas de cata')
+ if self.dataSetFile is not None:
+ print ('dataSetFile comm mais pas de cata')
return # Sortie Salome
self.nouveau = 0
- if self.fichier is not None: # fichier jdc fourni
+ if self.dataSetFile is not None: # fichier jdc fourni
if jdc == None:
# print ('PNPN : chgt try en if')
try:
#if 1 :
- self.jdc = self.readFile(self.fichier)
+ self.jdc = self.readFile(self.dataSetFile)
except Exception as e :
#else :
- print("mauvaise lecture du fichier")
+ print("mauvaise lecture du dataSetFile")
raise EficasException("str(e)")
if self.appliEficas.salome:
try:
- self.appliEficas.addJdcInSalome(self.fichier)
+ self.appliEficas.addJdcInSalome(self.dataSetFile)
except Exception as e:
print("mauvais enregistrement dans Salome")
raise EficasException("str(e)")
fn = str(fn)
jdcName = os.path.basename(fn)
- # Il faut convertir le contenu du fichier en fonction du format
+ # Il faut convertir le contenu du dataSetFile en fonction du format
formatIn = self.appliEficas.formatFichierIn
if self.extensionFichier == ".xml" and self.appliEficas.withXSD:
formatIn = "xml"
# --------------------------#
def getJdcFichierSource(self):
# --------------------------#
- if self.fichier == None: return "fichier source non defini"
- if os.path.isfile(self.fichier):
- f = open(self.fichier, "r")
+ if self.dataSetFile == None: return "fichier source non defini"
+ if os.path.isfile(self.dataSetFile):
+ f = open(self.dataSetFile, "r")
texteSource = f.read()
f.close()
return texteSource
texteGlobal, testOK = self.jdc.verifRegles()
return texteGlobal
- # ---------------------#
- def getFileName(self):
- # ---------------------#
- return self.fichier
+ # -------------------------#
+ def getDataSetFileName(self):
+ # --------------------------#
+ return self.dataSetFile
+
+ # -------------------------#
+ def getCataFileName(self):
+ # --------------------------#
+ return self.cataFile
+
+ # -------------------------#
+ def getEditorId(self):
+ # --------------------------#
+ return self.editorId
+
# -------------------#
def initModif(self):
def saveFileLegerAs(self, fileName=None):
# --------------------------------------#
if fileName != None:
- self.fichier = fileName
+ self.dataSetFile = fileName
return self.saveFileLeger(fileName)
return self.saveFileLeger()
if fichier == None:
self.informe("Sauvegarde", "nom de fichier obligatoire pour sauvegarde")
return 0, None
- self.fichier = fichier
+ self.dataSetFile = fichier
self.myWriter = writer.plugins["UQ"]()
ret, comm = self.myWriter.creeNomsFichiers(fichier)
# print (ret,comm)
if self.myWriter != self.XMLWriter:
self.XMLWriter.gener(self.jdc)
self.XMLWriter.writeDefault(fichier)
- return (1, self.fichier)
+ return (1, self.dataSetFile)
if self.jdc.isValid() and hasattr(self.myWriter, "writeDefault"):
self.myWriter.writeDefault(fichier)
elif self.code == "TELEMAC" and hasattr(self.myWriter, "writeDefault"):
self.myWriter.writeDefault(fichier)
self.modified = 0
- return (1, self.fichier)
+ return (1, self.dataSetFile)
#
import os
from uuid import uuid1
+from multiprocessing import Lock
+debug = 1
# --------------------------
class EditorManager(object):
# --------------------------
"""
- classe mere des managers d editeur pour Qt et le web
- permettent de gerer plusieurs ouvertures de fichiers simultannees en IHM
- utilisee sans etre derivee pour le dumpXSD ou les transformations
+ classe mere du manager d editeur pour Qt
+ permet de gerer plusieurs ouvertures de fichiers simultannees en Web ou TUI
+ utilisee sans etre derivee dans ces 2 cas
"""
# remplace par l index du viewManager
# --------------------------------
self.appliEficas = appliEficas
self.mesIndexes = {}
- self.dictEditors = {}
self.editors = []
self.doubles = {}
+ self.lock = Lock()
+ self.dictEditors = {}
+ # TODO : doit on prevoir l inverse ? a t on besoin pour une session de connaitre tous ces editeurs
+ # reflechir au close
+ # TODO
- # -----------------------------------------------------------------
- def getEditor(self, cata = None, fichier=None, jdc=None, include=0):
- # -----------------------------------------------------------------
+ # -----------------------------------------------------
+ def getEditor(self, fichier=None, jdc=None, include=0):
+ # ------------------------------------------------------
"""
Retourne un nouvel editeur ou None si doublon
"""
+ # TODO : reflechir
+ print ('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
+ print ('getEditor dans editor : pas programme --> derive en QT, utiliser getTUIEditor ou getWebEditor')
+ print ('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
+ return None
+
+ # ----------------------------------------------------------------------------------------
+ def getTUIEditor(self,sId = None, cataFile = None, dataSetFile=None, jdc=None, include=0):
+ # -----------------------------------------------------------------------------------------
+ """
+ Retourne un nouvel editeur ou None si doublon
+ """
+ if cataFile == None :
+ self.appliEficas.afficheMessage(sId, 'Eficas',
+ 'nom de catalogue obligatoire pour obtenir un editor')
+ return (None, 1, 'nom de catalogue obligatoire pour obtenir un editor')
+ with self.lock :
+ for editor in self.dictEditors.values():
+ if self.samePath(dataSetFile, editor.getDataSetFileName()) and self.samePath(cataFile, editor.getCataFileName()):
+ break
+ else:
+ from editor import Editor
+ editor = WebEditor(self.appliEficas, cataFile, dataSetFile)
+
+ if editor.jdc: # le fichier est bien un jdc
+ self.dictEditors[editor.editorId]=editor
+ self.editors.append(editor)
+ if editor.editorId in self.appliEficas.dictEditorIdSessionId :
+ self.appliEficas.dictEditorIdSessionId[editor.editorId].append(sId)
+ else :
+ self.appliEficas.dictEditorIdSessionId[editor.editorId]=[sId,]
+ else:
+ return (None, 1, 'impossible d allouer l editor')
+
+ # ----------------------------------------------------------------------------------------
+ def getWebEditor(self,sId = None, cataFile = None, dataSetFile=None, jdc=None, include=0):
+ # -----------------------------------------------------------------------------------------
+ """
+ Retourne un nouvel editeur ou None si doublon
+ """
+ if cataFile == None :
+ self.appliEficas.afficheMessage(sId, 'Eficas',
+ 'nom de catalogue obligatoire pour obtenir un editor')
+ return (None, 1, 'nom de catalogue obligatoire pour obtenir un editor')
+ with self.lock :
+ for editor in self.dictEditors.values():
+ if self.samePath(dataSetFile, editor.getDataSetFileName()) and self.samePath(cataFile, editor.getCataFileName()):
+ break
+ else:
+ from InterfaceGUI.Web.web_editor import WebEditor
+ editor = WebEditor(self.appliEficas, cataFile, dataSetFile)
+
+ if editor.jdc: # le fichier est bien un jdc
+ self.dictEditors[editor.editorId]=editor
+ self.editors.append(editor)
+ if editor.editorId in self.appliEficas.dictEditorIdSessionId :
+ self.appliEficas.dictEditorIdSessionId[editor.editorId].append(sId)
+ else :
+ self.appliEficas.dictEditorIdSessionId[editor.editorId]=[sId,]
+ else:
+ return (None, 1, 'impossible d allouer l editor')
+ return (editor, 0, '')
- if fichier == None :
- self.appliEficas.afficheMessage('Eficas',
- 'nom de fichier obligatoire pour obtenir un editor')
- return None
- for indexEditor in self.dictEditors:
- editor = self.dictEditors[indexEditor]
- if self.samePath(fichier, editor.getFileName()):
- self.appliEficas.afficheMessage('Eficas sans Ihm', 'Fichier deja ouvert')
- return None
- from Editeur.editor import Editor
- editor = Editor(self.appliEficas, fichier, jdc, include)
- if not editor.jdc :
- self.appliEficas.afficheMessage('Eficas sans Ihm', 'impossible d allouer un editor')
- return None
- self.editors.append(editor)
- self.dictEditors[editor.idEditor] = editor
- return editor
-
-
+
+ # --------------------------
+ def getEditorById(self, eId):
+ # ---------------------------
+ debug = 1
+ if eId in self.dictEditors:
+ return (self.dictEditors[eId], 0, "")
+ if debug : print ("getEditorById : {} non trouve ".format(eId))
+ return (None, 1, "getEditorById : {} non trouve ".format(eId))
+
# -------------------------
def samePath(self, f1, f2):
#-------------------------------
def indexChanged(self, newIndex):
#--------------------------------
+ # cette fonction n a de sens qu en QT ou ?
+ # comment gerer le contexte?
if newIndex in self.dictEditors:
editor = self.dictEditors[newIndex]
if editor.jdc != None:
return
self.dictEditors[index].saveFileLegerAs(fileName)
-
-
-
from Editeur.getVersion import getEficasVersion
from Accas.extensions.eficas_translation import tr
+from threading import Lock
+sessionCount = 0
+lock = Lock()
+
+activeLogging=0
+if activeLogging :
+ from Editeur.loggingEnvironnement import loggingEnvironnement, fonctionLoguee
+else :
+ fonctionLoguee = lambda func: func
+
+
+#-----------------
class EficasAppli:
+#-----------------
"""
Class implementing the main user interface.
"""
#---------------------------------------------------------------------------------------------------------------------------------------------
- def __init__(self, code=None, versionCode=None, salome=1, multi=False, langue="fr", ssCode=None, fichierCata=None, GUIPath=None, appWeb=None):
+ def __init__(self, code=None, versionCode=None, salome=1, multi=False, langue="fr", ssCode=None, cataFile=None, GUIPath=None, appWeb=None):
#---------------------------------------------------------------------------------------------------------------------------------------------
"""
Constructor d appli eficas. classe mere de appli-qtEficas et de appli-web eficas et utilisee sans IHM pour les
self.multi = multi
self.salome = salome
self.appWeb = appWeb
+ self.dictEditorIdSessionId = {}
+ self.dictTypeDeSession = {} # contient le type de la session ( QT, WEB pour rediriger les messages)
version = getEficasVersion()
self.versionEficas = "Eficas Salome " + version
self.mesScripts = {}
self.listePathAEnlever = []
- if fichierCata == None: self.fichierCata = session.d_env.fichierCata
- else: self.fichierCata = fichierCata
+ if cataFile == None: self.cataFile = session.d_env.cataFile
+ else: self.cataFile = cataFile
self.versionCode = versionCode
if session.d_env.versionCode: self.versionCode = session.d_env.versionCode
self.definitCode(code, ssCode)
if code == None: return
else :
- # Est-ce que configBase a un interet avec le web ?
from Editeur.configuration import BaseConfiguration
self.maConfiguration = BaseConfiguration(self)
def getEditor(self, fichier=None, jdc=None, include=0):
#------------------------------------------------------
#PN reflechir a ce que cela veut dire d avoir plusieurs editeurs
+ # en TUI
if (hasattr(self, "editor")) and self.editor != None:
print("un seul editeur par application eficas_appli sans Ihm ? ")
# sys.exit()
self.editor = self.editorManager.getEditor(fichier, jdc, include)
return self.editor
+ #--------------------------------------------------------------------------------
+ def getWebEditor(self, sId, cataFile = None, datasetFile=None, jdc=None, include=0):
+ #--------------------------------------------------------------------------------
+ debug = 1
+ if sId == None :
+ titre = 'Requete non valide'
+ message = 'Le parametre identifiant la Session Eficas est obligatoire'
+ self.propageToWebApp('afficheMessage', titre+texte, 'rouge')
+ self.dictTypeDeSession[sId] = 'Web'
+ (editor, CR, message) = self.editorManager.getWebEditor(sId, cataFile,datasetFile, jdc, include)
+ if debug :
+ print ('getWebEditor id de sesssion :', sId, ' editor : ', editor.editorId)
+ print (editor, CR, message)
+ return (editor, CR, message)
+
+ #------------------------------------------------------------------------------------------
+ def getTUIEditor (self,sId = None, cataFile = None, datasetFile=None, jdc=None, include=0):
+ #-------------------------------------------------------------------------------------------
+ if sId == None :
+ self.affichageMessage('Requete non valide', 'Le parametre identifiant la Session Eficas est obligatoire',True)
+ self.dictTypeDeSession[sId] = 'TUI'
+ (editor, CR, message) = self.editorManager.getTUIEditor(sId, cata, fichier, fichier, jdc, include)
+ return (editor, CR, message)
- #--------------------------
- def getEditorById(self,id):
- #--------------------------
- return self.editorManager.getEditorById(id)
+ #---------------------------
+ def getEditorById(self, eId):
+ #----------------------------
+ return self.editorManager.getEditorById(eId)
#----------------------------------
def setCurrentEditorById(self,id):
#----------------------------------
return self.editorManager.setCurrentEditorById(self,id)
- #---------------------------
- def openDataSet(self, fichier):
- #---------------------------
- try:
- monEditor = self.editorManager.openFile(fichier)
- except EficasException as exc:
- self.afficheMessage( 'erreur ouverture fichier', str(exc),critical=True)
- monEditor = None
- return monEditor
-
#------------------
def fileSave(self):
#-------------------
texteXSD = currentCata.dumpXsd(avecEltAbstrait)
return texteXSD
- #---------------------------------------------------
- def afficheMessage(self, titre, texte,critical=True):
- #----------------------------------------------------
- print ('__________________________')
- print (tr(titre))
- print ('')
- print (tr(texte))
- print ('__________________________')
-
#-------------------
def saveUQFile(self):
self.withUQ = True
self.formatFichierIn = "pythonUQ" # par defaut
+ #----------------------
+ def getSessionId(self):
+ #----------------------
+ # TODO doit on mettre le type de session en parametre ?
+ # tant qu on a pas pris un editor la session est tague TUI
+ global sessionCount
+ try :
+ with lock:
+ sessionCount += 1
+ self.dictTypeDeSession[sessionCount]='TUI'
+ return (sessionCount, 0, '')
+ except :
+ return (sessionCount, 1, 'impossible de donner un id : {}.format(str(e))')
+
+ #---------------------------------------------------------------------------
+ def propageToWebApp(self, fction, sessionId, *args, **kwargs):
+ #---------------------------------------------------------------------------
+ #if fction =='propageValide' :
+ debug=1
+ if debug : print ('PNPNPN : WebEficasAppli.toWebApp', fction, *args, **kwargs)
+ if self.appWeb == None : return
+ self.appWeb.fromConnecteur(fction, sessionId, *args, **kwargs)
+
+ #--------------------------------------------------------------------------
+ def afficheMessage (self, titre, texte, critical=True, emitEditorId = None ):
+ #--------------------------------------------------------------------------
+ print ('*******************************')
+ if emitEditor != None :
+ print ('message emis par ', emitEditorId)
+
+ print (titre)
+ print ('-------------------------------')
+ print (texte)
+ print ('-------------------------------')
+ if critical : exit(1)
+
+ #--------------------------------------------------------------------------
+ # Est-ce que cela sera utilise ?
+ def propageMessage (self, titre, texte, critical=True, emitEditorId = None ):
+ #--------------------------------------------------------------------------
+ if emitEditorId == None :
+ self.afficheMessage(titre, texte, critical)
+ return
+ for sessionId in self.dictEditorIdSessionId[emitEditorId]:
+ if self.dictTypeDeSession[sessionId] == 'TUI':
+ self.afficheMessage(self, titre, texte, critical, emitEditorId )
+ elif self.dictTypeDeSession[sessionId] == 'Web':
+ if critical : self.propageToWebApp('afficheMessage', sessionId, titre+texte, 'rouge')
+ else : self.propageToWebApp('afficheMessage', sessionId, titre+texte)
+ else :
+ print ('propageInfo de Appli : pb de type de session dans eficas')
+
+ #-------------------------------------------------------------------------------------
+ def propageChange (self, emitSessionId, emitEditorId, toAll , fction, *args, **kwargs):
+ #--------------------------------------------------------------------------------------
+ debug = 1
+ if debug :
+ print ("------------------------------------------ Eficas")
+ print ('propageChange avec les arguments ')
+ print ( emitSessionId, emitEditorId, toAll , fction, *args, **kwargs)
+ print (self.dictEditorIdSessionId)
+ print ("------------------------------------------ ")
+ for sessionId in self.dictEditorIdSessionId[emitEditorId]:
+ print ('sessionId', sessionId)
+ if not toAll and sessionId == emitSessionId : continue
+ if self.dictTypeDeSession[sessionId] == 'TUI':
+ print ('la session est TUI, on ne fait rien')
+ continue # Rien a faire le JDC est correcte
+ elif self.dictTypeDeSession[sessionId] == 'Web': # on verra le QT apres
+ print ('on propage pour ', sessionId )
+ self.propageToWebApp(fction, sessionId, *args, **kwargs)
+
+ #---------------------------------------------------------------------------
+ #PN --> normalement les codes retours et les messages de retour sont suffisants
+ #def displayMessageInSid (self, Sid, titre, texte, critical=True ):
+ #---------------------------------------------------------------------------
if __name__ == "__main__":
# Modules Eficas
sys.exit(res)
-def getEficas( code=None, ssCode = None, versionCode = None , multi=False, langue="en", GUIPath=None, appWeb = None, fichierCata = None):
-# ---------------------------------------------------------------------------------------------------------------------------------------
+def getEficas( code=None, ssCode = None, versionCode = None , multi=False, langue="en", appWeb = None, cataFile = None):
+# --------------------------------------------------------------------------------------------------------------------------
"""
instancie l'appli EFICAS sans Ihm
"""
if options.code != None:
code = options.code
- if GUIPath in ('QT5', 'cinqC') :
- pathAbso=os.path.abspath(os.path.join(os.path.dirname(__file__),'..','InterfaceGUI',GUIPath))
- if pathAbso not in sys.path : sys.path.insert(0,pathAbso)
- from qt_eficas import QtEficasAppli as EficasAppli
- if GUIPath in ( 'Web') :
- pathAbso=os.path.abspath(os.path.join(os.path.dirname(__file__),'..','InterfaceGUI',GUIPath))
- if pathAbso not in sys.path : sys.path.insert(0,pathAbso)
- from web_eficas import WebEficasAppli as EficasAppli
- else :
- print ('lancement de Eficas avec GUIPath = {}'.format(GUIPath))
- from Editeur.eficas_appli import EficasAppli
-
- Eficas = EficasAppli(code=code, multi=multi, langue=langue, ssCode=ssCode, versionCode=versionCode, fichierCata=fichierCata, GUIPath=GUIPath, appWeb=appWeb)
+ #if GUIPath in ('QT5', 'cinqC') :
+ # print ('Attention : Pour lancer l application QT5 utiliser lanceQTEficas')
+ # return
+ #pathAbso=os.path.abspath(os.path.join(os.path.dirname(__file__),'..','InterfaceGUI',GUIPath))
+ #if pathAbso not in sys.path : sys.path.insert(0,pathAbso)
+ #from qt_eficas import QtEficasAppli as EficasAppli
+ #if GUIPath in ( 'Web') :
+ # pathAbso=os.path.abspath(os.path.join(os.path.dirname(__file__),'..','InterfaceGUI',GUIPath))
+ # if pathAbso not in sys.path : sys.path.insert(0,pathAbso)
+ # from web_eficas import WebEficasAppli as EficasAppli
+ #else :
+ print ('lancement de Eficas sans QT ')
+ from Editeur.eficas_appli import EficasAppli
+ Eficas = EficasAppli(code=code, multi=multi, langue=langue, ssCode=ssCode, salome = 0 , versionCode=versionCode, cataFile=cataFile, appWeb=appWeb)
return Eficas
options = session.parse(sys.argv)
if code != None:
options.code = code
- if options.fichierCata == None:
+ if options.cataFile == None:
print("Use -c cata_name.py")
return
monEditor = monEficas.getEditor()
texteXSD = monEditor.dumpXsd(avecEltAbstrait=options.avecEltAbstrait)
- fichierCataTrunc = os.path.splitext(os.path.basename(options.fichierCata))[0]
- # if fichierCataTrunc[0:4] in ('cata','Cata'): fichierCataTrunc=fichierCataTrunc[4:]
- # if fichierCataTrunc[0] in ('_','-') : fichierCataTrunc=fichierCataTrunc[1:]
- fileXSD = fichierCataTrunc + ".xsd"
+ cataFileTrunc = os.path.splitext(os.path.basename(options.cataFile))[0]
+ # if cataFileTrunc[0:4] in ('cata','Cata'): cataFileTrunc=cataFileTrunc[4:]
+ # if cataFileTrunc[0] in ('_','-') : cataFileTrunc=cataFileTrunc[1:]
+ fileXSD = cataFileTrunc + ".xsd"
f = open(str(fileXSD), "w")
f.write(str(texteXSD))
options = session.parse(sys.argv)
if code != None:
options.code = code
- if options.fichierCata == None:
+ if options.cataFile == None:
print("Use -c cata_name.py")
return
try:
options = session.parse(sys.argv)
if code != None:
options.code = code
- if options.fichierCata == None:
+ if options.cataFile == None:
print("Use -c cata_name.py")
return
monEditor = monEficas.getEditor()
texteStructure = monEditor.dumpStructure()
- fichierCataTrunc = os.path.splitext(os.path.basename(options.fichierCata))[0]
- fileStructure = fichierCataTrunc + ".txt"
+ cataFileTrunc = os.path.splitext(os.path.basename(options.cataFile))[0]
+ fileStructure = cataFileTrunc + ".txt"
f = open(str(fileStructure), "w")
f.write(str(texteStructure))
f.close()
options = session.parse(sys.argv)
if code != None:
options.code = code
- if options.fichierCata == None:
+ if options.cataFile == None:
print("Use -c cata_name.py")
return
fichier = options.comm[0]
-def createObjetPythonFromDocumentAccas(fichierCata=None, fichier=None, code=None):
+def createObjetPythonFromDocumentAccas(cataFile=None, fichier=None, code=None):
# --------------------------------------------------------------------------------
# activeSurcharge permet de surcharger [ pour
# acceder aux objets Accas comme en python
if fichier == None:
print("file is needed")
return None
- if fichierCata == None:
+ if cataFile == None:
print("cata file is needed")
return None
activeSurcharge()
from .editorSsIhm import JDCEditorSsIhm
- monEficas = getEficas(code="Essai", fichierCata=fichierCata)
+ monEficas = getEficas(code="Essai", cataFile=cataFile)
monEditeur = JDCEditorSsIhm(monEficas, fichier)
return monEditeur.jdc
loggerForTrace.info('monEficasConnecteur=accasConnecteur("{}")'.format(code))
-def fonctionLoguee(laFonction, debug=True):
+def fonctionLoguee(laFonction, debug=False):
#-------------------------------------------
from inspect import getfullargspec
from functools import wraps
--- /dev/null
+#!/usr/bin/env python
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+import os, sys
+
+from Editeur.eficas_appli import EficasAppli
+from InterfaceGUI.Web.web_editor_manager import WebEditorManager
+from Accas.extensions.eficas_exception import EficasException
+
+activeLogging=0
+if activeLogging :
+ from Editeur.loggingEnvironnement import loggingEnvironnement, fonctionLoguee
+else :
+ fonctionLoguee = lambda func: func
+
+#--------------------------------#
+class WebEficasAppli(EficasAppli):
+#--------------------------------#
+ """
+ Class implementing the main QT user interface.
+ """
+
+ #---------------------------------------------------------------------------------------------------------------------------------------------------------
+ def __init__(self, code=None, versionCode=None, salome=0, multi=False, langue="fr", ssCode=None, cataFile=None, GUIPath="InterfaceGUI.QT5", appWeb=None):
+ #---------------------------------------------------------------------------------------------------------------------------------------------------------
+ """
+ Constructor
+ """
+ EficasAppli.__init__( self, code, versionCode, salome, multi, langue, ssCode, cataFile, GUIPath, appWeb)
+ self.editorManager = WebEditorManager(self)
+ if self.appWeb == None :
+ super().afficheMessage ('lancement Eficas WEB' , 'le parametre appWeb est obligatoire')
+ return
+
+
+ #------------------------------------------
+ def toWebApp(self,fction, *args, **kwargs):
+ #------------------------------------------
+ #if fction =='propageValide' :
+ debug=0
+ if debug : print ('PNPNPN : WebEficasAppli.toWebApp', fction, sid, eid, *args, **kwargs)
+ if self.appWeb == None : return
+ #if fction =='propageValide' : print ('self.appWeb.toWebApp propageValide', self.monEditeur.getNodeById(args[0]).nom)
+ self.appWeb.fromConnecteur(fction, *args, **kwargs)
+
+
+ @fonctionLoguee
+ #------------------------------------------------
+ def openDataset(self, sid, cataFile, datasetFile):
+ #--------------------------------------------------
+ try:
+ (monEditor, codeErreur, message) = self.editorManager.openDataset(sid, cataFile, datasetFile)
+ except EficasException as exc:
+ self.afficheMessage('erreur ouverture fichier', str(exc),critical=True)
+ monEditor = None
+ return (monEditor, codeErreur, message)
+
+ @fonctionLoguee
+ #-----------------------------------------------------
+ def afficheMessage (self, titre, texte,critical=True):
+ #-----------------------------------------------------
+#TODO : le afficheMessage doit tenir compte de qui
+ if critical :
+ self.toWebApp('afficheMessage', titre+texte, 'rouge')
+ else :
+ self.toWebApp('afficheMessage', titre+texte)
+
+
+if __name__ == "__main__":
+ print ('todo')
"--cata",
action="store",
type="string",
- dest="fichierCata",
+ dest="cataFile",
help=tr("catalogue a utiliser"),
)
if not hasattr(options, "studies"):
options.studies = []
options.comm = []
- if not hasattr(options, "fichierCata"):
- options.fichierCata = None
+ if not hasattr(options, "cataFile"):
+ options.cataFile = None
if not hasattr(options, "versionCode"):
options.versionCode = None
if not hasattr(options, "fichierXMLOut"):
def dumpAvecEltAbstraitDesCommandes(self):
cata = CONTEXT.getCurrentCata()
- fichierCataSourceExt = os.path.basename(cata.cata.__file__)
- fichierCataSource, extension = os.path.splitext(fichierCataSourceExt)
- importCataSource = __import__(fichierCataSource, {}, {})
+ cataFileSourceExt = os.path.basename(cata.cata.__file__)
+ cataFileSource, extension = os.path.splitext(cataFileSourceExt)
+ importCataSource = __import__(cataFileSource, {}, {})
texte = ""
for m in sys.modules:
continue
if monModule.__name__[0:12] == "InterfaceQT":
continue
- if monModule.__name__ == fichierCataSource:
+ if monModule.__name__ == cataFileSource:
continue
texte = texte + "try : import " + monModule.__name__ + " \n"
texte = texte + "except : pass \n"
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-
-import types
-from Accas.extensions.eficas_translation import tr
-
-#--------------------------
-class SaisieValeur(object):
-#--------------------------
- """
- Classe contenant les methodes communes aux panels
- permettant de choisir des valeurs
- """
-
- def valeurChanged(self,valeur=None):
- #-----------------------------------
- # pour la partie Web
- debug=0
- if debug : print('valeurChanged', valeur, type(valeur))
- nouvelleValeurFormat=self.politique.getValeurTexte(nouvelleValeur)
- validite,commentaire=self.politique.recordValeur(nouvelleValeurFormat)
- if commentaire != "" :
- if validite : self.editor.afficheCommentaire(commentaire)
- else : self.editor.afficheMessage(commentaire,'red')
- self.inSaisieValeur=False
- self.setValide()
-
-
- def LEvaleurPressed(self, valeur=None):
- #---------------------------------------
- # pour la partie Qt
- debug=0
- if debug : print('LEvaleurPressed', valeur, type(valeur))
- if not hasattr(self, "inSaisieValeur"): self.inSaisieValeur = False
- if self.inSaisieValeur: return
- self.inSaisieValeur = True
-
- if valeur == None:
- try:
- nouvelleValeur = str(self.lineEditVal.text())
- except UnicodeEncodeError as e:
- self.editor.afficheMessage("pb d encoding", Qt.red)
- validite, commentaire = self.politique.recordValeur(None)
- self.lineEditVal.setText("")
- self.setValide()
- self.inSaisieValeur = False
- return
- else:
- try:
- # la 1 ligne est tres bizarre. remplacee par le 3nd le 01 10 19
- # if hasattr(self,"lineEditVal"):self.lineEditVal.setText(tr(valeur.nom))
- if hasattr(self, "lineEditVal"): self.lineEditVal.setText(tr(valeur))
- except:
- if hasattr(self, "lineEditVal"): self.lineEditVal.setText(valeur)
- nouvelleValeur = valeur
-
- if self.node.item.definition.validators != None:
- if self.node.item.definition.validators.verifItem(nouvelleValeur) != 1:
- commentaire = self.node.item.definition.validators.infoErreurItem()
- self.editor.afficheMessage(commentaire, Qt.red)
- self.inSaisieValeur = False
- return
-
- nouvelleValeurFormat = self.politique.getValeurTexte(nouvelleValeur)
- validite, commentaire = self.politique.recordValeur(nouvelleValeurFormat)
- if commentaire != "":
- if validite: self.editor.afficheCommentaire(commentaire)
- else: self.editor.afficheMessage(commentaire, 'red')
- self.inSaisieValeur = False
- self.setValide()
-
- def TraiteLEValeur(self, valeurTraitee=None):
- #---------------------------------------------
- # pour Qt
- # lit la chaine entree dans le lineedit
- # et la tranforme en chaine de valeurs
- # attention eventuellement aux complexes
-
- listeValeurs = []
- if valeurTraitee == None:
- valeurBrute = str(self.LEValeur.text())
- else:
- valeurBrute = valeurTraitee
- if valeurBrute == str(""): return listeValeurs, 1
- return self.traiteValeurSaisie(valeurBrute)
-
- def traiteValeurSaisie(self, valeurSaisie):
- #---------------------------------------
- # appelé directerment pour le web
- # ou pour QT via la fonction TraiteLEValeur
- listeValeurs = []
- valeurBrute = valeurSaisie
- try: valeur = eval(valeurBrute, {})
- except: valeur = valeurBrute
-
- # pour traiter 11.0 - 30.0 pour le CIST
- # if (valeurTraitee and (type(valeurTraitee) in types.StringTypes) and (self.node.item.waitTxm())) :
- if (
- valeurTraitee
- and isinstance(valeurTraitee, str)
- and (self.node.item.waitTxm())
- ):
- valeur = str(valeurTraitee)
-
- if type(valeur) in (list, tuple):
- if self.node.item.waitComplex():
- indice = 0
- while indice < len(valeur):
- v = valeur[indice]
-
- if v == "RI" or v == "MP":
- try:
- t = tuple([v, valeur[indice + 1], valeur[indice + 2]])
- listeValeurs.append(t)
- indice = indice + 3
- except:
- commentaire = tr(
- "Veuillez entrer le complexe sous forme aster ou sous forme python"
- )
- self.editor.afficheMessage(commentaire)
- return listeValeurs, 0
-
- else: # ce n'est pas un tuple a la mode aster
- listeValeurs.append(v)
- indice = indice + 1
-
- else: # on n'attend pas un complexe
- listeValeurs = valeurBrute.split(",")
-
- elif type(valeur) == bytes:
- listeValeurs = valeur.split(",")
- else:
- # listeValeurs.append(valeurBrute)
- listeValeurs.append(valeur)
-
- return listeValeurs, 1
-
-
-class SaisieSDCO(object):
- def LESDCOReturnPressed(self):
- """
- Lit le nom donne par l'utilisateur au concept de type CO qui doit être
- la valeur du MCS courant et stocke cette valeur
- """
- self.editor.initModif()
- anc_val = self.node.item.getValeur()
- if anc_val != None:
- # il faut egalement propager la destruction de l'ancien concept
- self.node.item.deleteValeurCo(valeur=anc_val)
- # et on force le recalcul des concepts de sortie de l'etape
- self.node.item.object.etape.getType_produit(force=1)
- # et le recalcul du contexte
- self.node.item.object.etape.parent.resetContext()
- nomConcept = str(self.LESDCO.text())
- if nomConcept == "":
- return
-
- test, commentaire = self.node.item.setValeurCo(nomConcept)
- if test:
- commentaire = tr("Valeur du mot-clef enregistree")
- self.node.updateNodeValid()
- else:
- cr = self.node.item.getCr()
- commentaire = tr("Valeur du mot-clef non autorisee :") + cr.getMessFatal()
from InterfaceGUI.QT5.gereIcones import ContientIcones
from InterfaceGUI.QT5.gereIcones import FacultatifOuOptionnel
-from InterfaceGUI.Common.traiteSaisie import SaisieValeur
+from InterfaceGUI.QT5.traiteSaisie import SaisieValeur
nomMax = 230
debutTitre = self.editor.titre
self.listeWidget = []
self.dicoCmd = {}
- if self.editor.fichier != None:
- nouveauTitre = debutTitre + " " + os.path.basename(self.editor.fichier)
+ if self.editor.dataSetFile != None:
+ nouveauTitre = debutTitre + " " + os.path.basename(self.editor.dataSetFile)
else:
nouveauTitre = debutTitre
self.editor.appliEficas.setWindowTitle(nouveauTitre)
# Modules Eficas
-from InterfaceGUI.Common.traiteSaisie import SaisieValeur
+from InterfaceGUI.QT5.traiteSaisie import SaisieValeur
from InterfaceGUI.QT5.monPlusieursBasePanel import MonPlusieursBasePanel
from Accas.extensions.eficas_translation import tr
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetCB import Ui_WidgetCB
from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique
-from InterfaceGUI.Common.traiteSaisie import SaisieValeur
+from InterfaceGUI.QT5.traiteSaisie import SaisieValeur
from PyQt5.QtWidgets import QComboBox, QCompleter
from PyQt5.QtCore import Qt, QEvent
from InterfaceGUI.QT5.feuille import Feuille
from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique
-from InterfaceGUI.Common.traiteSaisie import SaisieValeur
+from InterfaceGUI.QT5.traiteSaisie import SaisieValeur
from UiQT5.desWidgetCBIntoSug import Ui_WidgetCBIntoSug
from PyQt5.QtWidgets import QComboBox, QCompleter
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetCB import Ui_WidgetCB
from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique
-from InterfaceGUI.Common.traiteSaisie import SaisieValeur
+from InterfaceGUI.QT5.traiteSaisie import SaisieValeur
from PyQt5.QtWidgets import QComboBox, QCompleter
self.editor.afficheCommentaire(mess)
# Notation scientifique
- if test:
- from InterfaceGUI.Common.politiquesValidation import Validation
- validation = Validation(self.node, self.editor)
- validation.ajoutDsDictReelEtape()
+ # 5 mars 24 : completement idiot ?
+ #if test:
+ # from InterfaceGUI.Common.politiquesValidation import Validation
+ # validation = Validation(self.node, self.editor)
+ # validation.ajoutDsDictReelEtape()
def afficheOptionnel(self):
# N a pas de parentQt. doit donc etre redefini
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetPlusieursBase import Ui_WidgetPlusieursBase
from InterfaceGUI.Common.politiquesValidation import PolitiquePlusieurs
-from InterfaceGUI.Common.traiteSaisie import SaisieValeur
+from InterfaceGUI.QT5.traiteSaisie import SaisieValeur
from InterfaceGUI.QT5.gereListe import GereListe
from InterfaceGUI.QT5.gereListe import GerePlie
from InterfaceGUI.QT5.gereListe import LECustom
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetPlusieursInto import Ui_WidgetPlusieursInto
from InterfaceGUI.Common.politiquesValidation import PolitiquePlusieurs
-from InterfaceGUI.Common.traiteSaisie import SaisieValeur
+from InterfaceGUI.QT5.traiteSaisie import SaisieValeur
from InterfaceGUI.QT5.gereListe import GerePlie
from InterfaceGUI.QT5.gereListe import GereListe
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetPlusieursIntoOrdonne import Ui_WidgetPlusieursIntoOrdonne
from InterfaceGUI.Common.politiquesValidation import PolitiquePlusieurs
-from InterfaceGUI.Common.traiteSaisie import SaisieValeur
+from InterfaceGUI.QT5.traiteSaisie import SaisieValeur
from InterfaceGUI.QT5.gereListe import GereListe
from InterfaceGUI.QT5.gereListe import GerePlie
from InterfaceGUI.QT5.gereListe import LECustom
from UiQT5.desWidgetPlusieursPlie import Ui_WidgetPlusieursPlie
from InterfaceGUI.Common.politiquesValidation import PolitiquePlusieurs
-from InterfaceGUI.Common.traiteSaisie import SaisieValeur
+from InterfaceGUI.QT5.traiteSaisie import SaisieValeur
pattern_blanc = re.compile(r"^\s*$")
from InterfaceGUI.QT5.feuille import Feuille
from InterfaceGUI.Common.politiquesValidation import PolitiquePlusieurs
-from InterfaceGUI.Common.traiteSaisie import SaisieValeur
+from InterfaceGUI.QT5.traiteSaisie import SaisieValeur
from InterfaceGUI.QT5.gereListe import GereListe
from InterfaceGUI.QT5.gereListe import LECustom
from UiQT5.Tuple2 import Ui_Tuple2
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetRadioButton import Ui_WidgetRadioButton
from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique
-from InterfaceGUI.Common.traiteSaisie import SaisieValeur
+from InterfaceGUI.QT5.traiteSaisie import SaisieValeur
class MonWidgetRadioButtonCommun(Feuille):
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetSDCOInto import Ui_WidgetSDCOInto
-from InterfaceGUI.Common.traiteSaisie import SaisieSDCO
+from InterfaceGUI.QT5.traiteSaisie import SaisieSDCO
from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetSimpBase import Ui_WidgetSimpBase
from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique
-from InterfaceGUI.Common.traiteSaisie import SaisieValeur
+from InterfaceGUI.QT5.traiteSaisie import SaisieValeur
class MonWidgetSimpBase(Ui_WidgetSimpBase, Feuille):
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetSimpBool import Ui_WidgetSimpBool
from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique
-from InterfaceGUI.Common.traiteSaisie import SaisieValeur
+from InterfaceGUI.QT5.traiteSaisie import SaisieValeur
class MonWidgetSimpBool(Ui_WidgetSimpBool, Feuille):
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetSimpComplexe import Ui_WidgetSimpComplexe
from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique
-from InterfaceGUI.Common.traiteSaisie import SaisieValeur
+from InterfaceGUI.QT5.traiteSaisie import SaisieValeur
class MonWidgetSimpComplexe(Ui_WidgetSimpComplexe, Feuille):
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetSimpSalome import Ui_WidgetSimpSalome
from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique
-from InterfaceGUI.Common.traiteSaisie import SaisieValeur
+from InterfaceGUI.QT5.traiteSaisie import SaisieValeur
class MonWidgetSimpSalome(Ui_WidgetSimpSalome, Feuille):
from InterfaceGUI.QT5.feuille import Feuille
from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique
-from InterfaceGUI.Common.traiteSaisie import SaisieValeur
+from InterfaceGUI.QT5.traiteSaisie import SaisieValeur
class MonWidgetSimpTuple(Feuille):
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetUniqueSDCO import Ui_WidgetUniqueSDCO
from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique
-from InterfaceGUI.Common.traiteSaisie import SaisieSDCO
+from InterfaceGUI.QT5.traiteSaisie import SaisieSDCO
class MonWidgetUniqueSDCO(Ui_WidgetUniqueSDCO, Feuille, SaisieSDCO):
Editeur de jdc
"""
- def __init__( self, appliEficas, fichier=None, jdc=None, QWParent=None, include=0):
+ def __init__( self, appliEficas, cataFile = None, fichier=None, jdc=None, QWParent=None, include=0):
# -----------------------------------------------------------------------------------------------
QWidget.__init__(self, None)
self.sb = None
self.QWParent = QWParent
- Editor.__init__(self, appliEficas, fichier, jdc, include)
+ Editor.__init__(self, appliEficas=appliEficas, cataFile = cataFile , dataSetFile = fichier , jdc = jdc, include = include)
# on enleve la gestion du dicEditor necessaire dans les autres cas
- # mais ici l index est le numero de page et non l idEditor
- del self.appliEficas.editorManager.dictEditors[self.idEditor]
+ # mais ici l index est le numero de page et non l editorId
+ del self.appliEficas.editorManager.dictEditors[self.editorId]
if self.jdc:
comploader.chargerComposants(self.appliEficas.GUIPath)
# qApp.restoreOverrideCursor()
if self.fileInfo != None:
self.lastModified = self.fileInfo.lastModified()
- nouveauTitre = self.titre + " " + os.path.basename(self.fichier)
+ nouveauTitre = self.titre + " " + os.path.basename(self.dataSetFile)
self.appliEficas.setWindowTitle(nouveauTitre)
return jdc
path = self.maConfiguration.saveDir
monNomFichier = ""
- if self.fichier is not None and self.fichier != "":
- maBase = str(QFileInfo(self.fichier).baseName()) + ".input"
- monPath = str(QFileInfo(self.fichier).absolutePath())
+ if self.dataSetFile is not None and self.dataSetFile != "":
+ maBase = str(QFileInfo(self.dataSetFile).baseName()) + ".input"
+ monPath = str(QFileInfo(self.dataSetFile).absolutePath())
monNomFichier = os.path.join(monPath, maBase)
elif hasattr(self, "monNomFichierInput"):
monNomFichier = self.monNomFichierInput
extension = ".comm"
newName = None
- fn = self.fichier
- if self.fichier is None or saveas:
+ fn = self.dataSetFile
+ if self.dataSetFile is None or saveas:
if path is None:
path = self.maConfiguration.saveDir
bOK, fn = self.determineNomFichier(path, extension)
if not (self.writeFile(fn, formatLigne=formatLigne)):
return (0, None)
- self.fichier = fn
+ self.dataSetFile = fn
self.modified = False
if self.fileInfo is None or saveas:
- self.fileInfo = QFileInfo(self.fichier)
+ self.fileInfo = QFileInfo(self.dataSetFile)
self.fileInfo.setCaching(0)
self.lastModified = self.fileInfo.lastModified()
if newName is not None:
self.tree.racine.updateNodeLabel()
if self.jdc.cata.modeleMetier:
- self.jdc.toXml(self.fichier)
+ self.jdc.toXml(self.dataSetFile)
if self.jdc.cata.modeleMetier and self.jdc.isValid():
if self.myWriter != self.XMLWriter:
self.XMLWriter.gener(self.jdc)
res = msgBox.exec_()
if res == 0:
self.myWriter.writeDefault(fn)
- return (1, self.fichier)
+ return (1, self.dataSetFile)
if res == 2:
return (0, None)
if self.appliEficas.salome:
sys.exit(1)
if self.appliEficas.salome:
- self.appliEficas.addJdcInSalome(self.fichier)
+ self.appliEficas.addJdcInSalome(self.dataSetFile)
self.modified = 0
nouveauTitre = (
- self.titre + " " + str(os.path.basename(self.fichier))
+ self.titre + " " + str(os.path.basename(self.dataSetFile))
)
self.appliEficas.setWindowTitle(nouveauTitre)
- return (1, self.fichier)
+ return (1, self.dataSetFile)
# ---------------------------------------#
def sauvePourPersalys(self, fichier=None):
critique=False,
)
return
- if self.fichier is None:
+ if self.dataSetFile is None:
if path is None:
path = self.maConfiguration.saveDir
bOK, fn = self.determineNomFichier(path, "comm")
ulfile = os.path.abspath(fn)
self.appliEficas.maConfiguration.saveDir = os.path.split(ulfile)[0]
fn = QDir.toNativeSeparators(fn)
- self.fichier = fn
+ self.dataSetFile = fn
else:
- fn = self.fichier
+ fn = self.dataSetFile
ret, comm = Editor.sauvePourPersalys(self, fn)
if not ret:
if not comm:
# --------------------------------------------#
def saveUQFile(self, fichier=None, path=None):
# -------------------------------------------#
- if self.fichier is None:
+ if self.dataSetFile is None:
if path is None:
path = self.maConfiguration.saveDir
bOK, fn = self.determineNomFichier(path, "comm")
ulfile = os.path.abspath(fn)
self.appliEficas.maConfiguration.saveDir = os.path.split(ulfile)[0]
fn = QDir.toNativeSeparators(fn)
- self.fichier = fn
+ self.dataSetFile = fn
else:
- fn = self.fichier
+ fn = self.dataSetFile
if self.jdc.isValid() == 0:
msgBox = QMessageBox(None)
if res == 0:
ret, fichier = Editor.saveUQFile(self, fn)
if ret:
- self.fichier = fichier
+ self.dataSetFile = fichier
if self.appliEficas.salome and ret:
- self.appliEficas.addJdcInSalome(self.fichier)
- return (1, self.fichier)
+ self.appliEficas.addJdcInSalome(self.dataSetFile)
+ return (1, self.dataSetFile)
if self.appliEficas.salome:
self.appliEficas.close()
else:
titre = "Probleme de sauvegarde des fichiers"
texte = "Impossible de sauvegarder {}".format(fn)
QMessageBox.information(self, titre, texte)
- return (0, self.fichier)
- return (1, self.fichier)
+ return (0, self.dataSetFile)
+ return (1, self.dataSetFile)
# --------------------------------------#
def exeUQ(self, fichier=None, path=None):
# --------------------------------------#
- # if self.modified or not self.fichier :
+ # if self.modified or not self.dataSetFile :
sauvegarde, fichier = self.saveUQFile()
if not sauvegarde:
return 0
the name of the saved file
"""
if fileName != None:
- self.fichier = fileName
+ self.dataSetFile = fileName
return self.saveFile()
return self.saveFile(path, 1, "beautifie")
#----------------------
index = self.myQtab.currentIndex()
editor = self.dictEditors[index]
- oldName = editor.fichier
+ oldName = editor.dataSetFile
ok, newName = editor.saveFileAs()
if ok:
fileName = os.path.basename(newName)
if fn != None:
titre = fn.split("/")[-1]
editor = self.getEditor(fichier=fn, jdc=jdc, include=1)
- self.appliEficas.addToRecentList(editor.getFileName())
+ self.appliEficas.addToRecentList(editor.getDataSetFileName())
#------------------------------------------------------------------
double = None
for indexEditor in self.dictEditors:
editor = self.dictEditors[indexEditor]
- if self.samePath(fichier, editor.getFileName()):
+ if self.samePath(fichier, editor.getDataSetFileName()):
msgBox = QMessageBox()
msgBox.setWindowTitle(tr("Fichier"))
msgBox.setText(tr("Le fichier <b>%s</b> est deja ouvert", str(fichier)))
double = editor
else:
from qt_editor import QtEditor
- editor = QtEditor(self.appliEficas, fichier, jdc, self.myQtab, include)
+ editor = QtEditor(self.appliEficas, cataFile=None, fichier=fichier, jdc=jdc, QWParent=self.myQtab, include=include)
if double != None: self.doubles[editor] = double
if editor.jdc: # le fichier est bien un jdc
self.editors.append(editor)
return 1
return 2
if editor.modified:
- fn = editor.getFileName()
+ fn = editor.getDataSetFileName()
if fn is None:
fn = tr("Noname")
msgBox = QMessageBox(None)
"""
#----------------------------------------------------------------------------------------------------------------------------------------------
- def __init__(self, code=None, versionCode=None, salome=1, multi=False, langue="fr", ssCode=None, fichierCata=None, GUIPath="InterfaceGUI.QT5", appWeb = None):
+ def __init__(self, code=None, versionCode=None, salome=1, multi=False, langue="fr", ssCode=None, cataFile=None, GUIPath="InterfaceGUI.QT5", appWeb = None):
#----------------------------------------------------------------------------------------------------------------------------------------------
"""
Constructor
QMainWindow.__init__(self)
Ui_Eficas.__init__(self)
self.setupUi(self)
- EficasAppli.__init__( self, code, versionCode, salome, multi, langue, ssCode, fichierCata, GUIPath, appWeb)
+ EficasAppli.__init__( self, code, versionCode, salome, multi, langue, ssCode, cataFile, GUIPath, appWeb)
self.editorManager = QtEditorManager(self)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+import types
+from Accas.extensions.eficas_translation import tr
+
+#--------------------------
+class SaisieValeur(object):
+#--------------------------
+ """
+ Classe contenant les methodes communes aux panels
+ permettant de choisir des valeurs
+ """
+
+ def valeurChanged(self,valeur=None):
+ #-----------------------------------
+ # pour la partie Web
+ debug=0
+ if debug : print('valeurChanged', valeur, type(valeur))
+ nouvelleValeurFormat=self.politique.getValeurTexte(nouvelleValeur)
+ validite,commentaire=self.politique.recordValeur(nouvelleValeurFormat)
+ if commentaire != "" :
+ if validite : self.editor.afficheCommentaire(commentaire)
+ else : self.editor.afficheMessage(commentaire,'red')
+ self.inSaisieValeur=False
+ self.setValide()
+
+
+ def LEvaleurPressed(self, valeur=None):
+ #---------------------------------------
+ # pour la partie Qt
+ debug=0
+ if debug : print('LEvaleurPressed', valeur, type(valeur))
+ if not hasattr(self, "inSaisieValeur"): self.inSaisieValeur = False
+ if self.inSaisieValeur: return
+ self.inSaisieValeur = True
+
+ if valeur == None:
+ try:
+ nouvelleValeur = str(self.lineEditVal.text())
+ except UnicodeEncodeError as e:
+ self.editor.afficheMessage("pb d encoding", Qt.red)
+ validite, commentaire = self.politique.recordValeur(None)
+ self.lineEditVal.setText("")
+ self.setValide()
+ self.inSaisieValeur = False
+ return
+ else:
+ try:
+ # la 1 ligne est tres bizarre. remplacee par le 3nd le 01 10 19
+ # if hasattr(self,"lineEditVal"):self.lineEditVal.setText(tr(valeur.nom))
+ if hasattr(self, "lineEditVal"): self.lineEditVal.setText(tr(valeur))
+ except:
+ if hasattr(self, "lineEditVal"): self.lineEditVal.setText(valeur)
+ nouvelleValeur = valeur
+
+ if self.node.item.definition.validators != None:
+ if self.node.item.definition.validators.verifItem(nouvelleValeur) != 1:
+ commentaire = self.node.item.definition.validators.infoErreurItem()
+ self.editor.afficheMessage(commentaire, Qt.red)
+ self.inSaisieValeur = False
+ return
+
+ nouvelleValeurFormat = self.politique.getValeurTexte(nouvelleValeur)
+ validite, commentaire = self.politique.recordValeur(nouvelleValeurFormat)
+ if commentaire != "":
+ if validite: self.editor.afficheCommentaire(commentaire)
+ else: self.editor.afficheMessage(commentaire, 'red')
+ self.inSaisieValeur = False
+ self.setValide()
+
+ def TraiteLEValeur(self, valeurTraitee=None):
+ #---------------------------------------------
+ # pour Qt
+ # lit la chaine entree dans le lineedit
+ # et la tranforme en chaine de valeurs
+ # attention eventuellement aux complexes
+
+ listeValeurs = []
+ if valeurTraitee == None:
+ valeurBrute = str(self.LEValeur.text())
+ else:
+ valeurBrute = valeurTraitee
+ if valeurBrute == str(""): return listeValeurs, 1
+ return self.traiteValeurSaisie(valeurBrute)
+
+ def traiteValeurSaisie(self, valeurSaisie):
+ #---------------------------------------
+ # appelé directerment pour le web
+ # ou pour QT via la fonction TraiteLEValeur
+ listeValeurs = []
+ valeurBrute = valeurSaisie
+ try: valeur = eval(valeurBrute, {})
+ except: valeur = valeurBrute
+
+ # pour traiter 11.0 - 30.0 pour le CIST
+ # if (valeurTraitee and (type(valeurTraitee) in types.StringTypes) and (self.node.item.waitTxm())) :
+ if (
+ valeurTraitee
+ and isinstance(valeurTraitee, str)
+ and (self.node.item.waitTxm())
+ ):
+ valeur = str(valeurTraitee)
+
+ if type(valeur) in (list, tuple):
+ if self.node.item.waitComplex():
+ indice = 0
+ while indice < len(valeur):
+ v = valeur[indice]
+
+ if v == "RI" or v == "MP":
+ try:
+ t = tuple([v, valeur[indice + 1], valeur[indice + 2]])
+ listeValeurs.append(t)
+ indice = indice + 3
+ except:
+ commentaire = tr(
+ "Veuillez entrer le complexe sous forme aster ou sous forme python"
+ )
+ self.editor.afficheMessage(commentaire)
+ return listeValeurs, 0
+
+ else: # ce n'est pas un tuple a la mode aster
+ listeValeurs.append(v)
+ indice = indice + 1
+
+ else: # on n'attend pas un complexe
+ listeValeurs = valeurBrute.split(",")
+
+ elif type(valeur) == bytes:
+ listeValeurs = valeur.split(",")
+ else:
+ # listeValeurs.append(valeurBrute)
+ listeValeurs.append(valeur)
+
+ return listeValeurs, 1
+
+
+class SaisieSDCO(object):
+ def LESDCOReturnPressed(self):
+ """
+ Lit le nom donne par l'utilisateur au concept de type CO qui doit être
+ la valeur du MCS courant et stocke cette valeur
+ """
+ self.editor.initModif()
+ anc_val = self.node.item.getValeur()
+ if anc_val != None:
+ # il faut egalement propager la destruction de l'ancien concept
+ self.node.item.deleteValeurCo(valeur=anc_val)
+ # et on force le recalcul des concepts de sortie de l'etape
+ self.node.item.object.etape.getType_produit(force=1)
+ # et le recalcul du contexte
+ self.node.item.object.etape.parent.resetContext()
+ nomConcept = str(self.LESDCO.text())
+ if nomConcept == "":
+ return
+
+ test, commentaire = self.node.item.setValeurCo(nomConcept)
+ if test:
+ commentaire = tr("Valeur du mot-clef enregistree")
+ self.node.updateNodeValid()
+ else:
+ cr = self.node.item.getCr()
+ commentaire = tr("Valeur du mot-clef non autorisee :") + cr.getMessFatal()
self.inhibeExpand = True
self.childrenComplete=[]
self.oldValidite='init'
- self.editor.idUnique = self.tree.racine.item.idUnique
+ self.item.idUnique = self.tree.racine.item.idUnique
+ # Est-ce que l editeur a besoin de cet idUnique ?? a priori non
#print ('fin __init__ JDCTree')
# def handleContextMenu(self,item,coord):
def construitChildrenComplete(self):
+ #------------------------------------------
# PN a tester avec des blocs de blocs
from . import compobloc
liste=[]
liste.append(itemFils)
return liste
-
-
- #-----------------------------------
+ #-------------------------
def getDicoForFancy(self):
- #-----------------------------------
+ #-------------------------
return self.item.getDicoForFancy()
#-----------------------------------
self.oldStatut = statut
monDictPartiel={}
monDictPartiel['statut']=statut
+ #TODO remonter au pere si le statut change
self.editor.connecteur.toWebApp('updateNodeInfo',self.getIdUnique(), monDictPartiel)
def updateOptionnels(self):
if self.item.nature == 'MCList' or self.item.nature == 'JDC' or self.item.nature=='MCSIMP' : return
monDictPartiel={}
monDictPartiel['infoOptionnels'] = self.item.calculOptionnelInclutBlocs()
- self.editor.connecteur.toWebApp('updateNodeInfo',self.getIdUnique(), monDictPartiel)
-
- #def chercheNoeudCorrespondant(self,objSimp):
- #-------------------------------------------
- # sublist = self.item._getSubList()
- # for node in self.childrenComplete:
- # if node.item.object==objSimp : return node
- # return None
- #def afficheCeNiveau(self):
- #-------------------------
- #def affichePanneau(self) :
- #-------------------------
- #def createPopUpMenu(self):
- #-------------------------
- #def commentIt(self):
- #-------------------------
- #def unCommentIt(self):
- #-------------------------
- #def addComment( self, after=True ):
- #-----------------------------------
- #def addParameters( self, after=True ):
- #-------------------------------------
- #def select( self ):
- #------------------
- #------------------------------------------------------------------
- # Methodes de creation et destruction de noeuds
- #------------------------------------------------------------------
- #def appendBrother(self,name,pos='after',plier=False):
- #----------------------------------------------------
- #def verifiePosition(self,name,pos,aLaRacine=False):
- #----------------------------------------------------
- #def deplace(self):
- #-----------------
- #def deleteMultiple(self,liste=()):
- #--------------------------------
+ return monDictPartiel
- #def updateNodeValid(self):
- #-----------------------
-
- #def updateNodeLabelInBlack(self):
- #-------------------------------
- #def updateNodeLabelInBlue(self):
- #-------------------------------
- #def updatePlusieursNodeLabelInBlue(self,liste):
- #----------------------------------------------
- #def updateNodeTexteInBlack(self):
- #--------------------------------
- #def updateNodeTexte(self):
- #----------------------------
- #def updateNodeTexteInBlue(self):
- #--------------------------------
- #def updateNodes(self):
- #--------------------------------
- #def updateValid(self) :
+ def updateNodeInfo(self):
#----------------------
- #def updateTexte(self):
- #----------------------
- #def forceRecalculChildren(self,niveau):
- #--------------------------------------
- #def doPaste(self,node_selected,pos='after'):
- #--------------------------------------------
- #def doPasteCommande(self,objet_a_copier,pos='after'):
- #-----------------------------------------------------
- #def doPastePremier(self,objet_a_copier):
- #---------------------------------------
- #def plieToutEtReafficheSaufItem(self, itemADeplier):
- #---------------------------------------------------
- #def plieToutEtReaffiche(self):
- #-----------------------------
- #def deplieToutEtReaffiche(self):
- #-----------------------------
- #def setPlie(self):
- #-----------------
- #def setPlieChildren(self):
- #-----------------------------
- #def setDeplie(self):
- #-----------------------------
- #def setDeplieChildren(self):
- #-----------------------------
- #def selectAvant(self):
- #-----------------------------
- #def selectApres(self):
- #---------------------
+ if self.item.nature == 'MCList' or self.item.nature == 'JDC' : print ('dans updateNodeInfo reflechir SVP')
+ monDico= self.item.getDicoForFancy()
+ return monDico
+
+
class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
- def traiteValeurSaisie(self,valeur):
+ def traiteValeurSaisie(self, valeur):
if self.item.get_definition().max==1 : self.politique = PolitiqueUnique (self, self.editor)
else : self.politique = PolitiquePlusieurs(self, self.editor)
if self.item.definition.validators != None :
if self.item.definition.validators.verifItem(nouvelleValeur) !=1 :
commentaire=self.node.item.definition.validators.infoErreurItem()
- return (self.item.idUnique, commentaire, false)
+ return (self.item.idUnique, 100 ,commentaire)
nouvelleValeurFormat=self.politique.getValeurTexte(valeur)
validite,commentaire=self.politique.recordValeur(nouvelleValeurFormat)
- if validite : self.treeParent.updateOptionnels()
- return (self.item.idUnique, commentaire, validite)
+ #if validite : self.treeParent.updateOptionnels()
+ return (self.item.idUnique, 0, 'commentaire')
class SIMPTreeItem(SIMPTreeItemCommun):
itemNode = Node
Editeur de jdc
"""
- #--------------------------------------------------------------------------
- def __init__ (self,appliEficas,fichier = None, jdc= None, session = None ):
- #--------------------------------------------------------------------------
+ #---------------------------------------------------------------------------------------------
+ def __init__ (self,appliEficas,cataFile = None, dataSetFile = None, jdc = None, include = None ):
+ #-------------------------------------------------------------------------------------------
- self.connecteur=appliEficas
+ self.editorManager=appliEficas.editorManager
self.dicoIdNode={}
- Editor.__init__(self,appliEficas,fichier)
+ Editor.__init__(self,appliEficas, cataFile, dataSetFile, jdc, include)
comploader.chargerComposants('Web')
self.tree=None
if self.jdc:
if self.tree == None : return {}
return obj.getDicoForFancy()
- #-------------------------------------
- @fonctionLoguee
- def afficheMessage(self,txt,couleur=None):
- #---------------------------------------
- self.connecteur.toWebApp('afficheMessage', txt, couleur)
- Editor.afficheMessage(self,'message to webapp',txt,couleur)
-
- #-------------------------------------
- @fonctionLoguee
- def afficheAlerte(self,titre,message):
- #-------------------------------------
- self.connecteur.toWebApp('afficheAlerte', titre , message)
- Editor.afficheMessage(self,titre,message)
-
#---------------------------
@fonctionLoguee
def getListeCommandes(self):
if not monNode : return (False, 'Node {} non trouve'.format(id))
return monNode.fauxNoeudGraphique.updateSDName(sdnom)
- #---------------------------------
- @fonctionLoguee
- def changeValeur(self,id,valeur) :
- #---------------------------------
+ #-----------------------------------------
+ #@fonctionLoguee
+ def changeValeur(self,sId, nodeId, valeur) :
+ #-----------------------------------------
"""
id : identifiant unique
valeur : valeur saisie dans le formulaire
doit-on mettre l ancienne valeur en retour qui serait utile si validité = Non
"""
- monNode=self.getNodeById(id)
- if not monNode : return (id, False, 'Node {} non trouve'.format(id))
- #print (' change Valeur', monNode)
- #(idUnique, commentaire, validite)=monNode.fauxNoeudGraphique.traiteValeurSaisie(valeur)
- #print ('retour ChangeValeur',idUnique, commentaire, validite )
- #
- return monNode.fauxNoeudGraphique.traiteValeurSaisie(valeur)
-
+ debug = 1
+ if debug : print (' changeValeur sId, nodeId, valeur' ,sId, nodeId, valeur)
+ monNode=self.getNodeById(nodeId)
+ if debug : print ('monNode : ', monNode)
+ if not monNode : return (nodeId, False, 'Node {} non trouve'.format(nodeId))
+ if debug : print (' change Valeur', monNode)
+ idRetour, commentaire, validite = monNode.fauxNoeudGraphique.traiteValeurSaisie(valeur)
+ if validite :
+ self.appliEficas.propageChange(sId, self.editorId, False, 'updateNodeInfo', nodeId, monNode.fauxNoeudGraphique.updateNodeInfo())
+# (self, emitSessionId, emitEditorID, toAll , 'updateNodeInfo', *args, **kwargs)
+ print ('if validite : self.treeParent.updateOptionnels')
+ return (idRetour, commentaire, validite)
+ if not validite :
+ return (idRetour, commentaire, validite)
+
+ #--------------------------------
+ def afficheMessage(self, texte):
+ #------------------------------------
+ # on ne fait rien
+ # contraitement a QT le commentaire est dans le retour de la fonction
+ debug = 0
+ if debug : print (texte)
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-
-import os
-from Accas.extensions.eficas_translation import tr
-from Editeur.editor_manager import EditorManager
-
-#-----------------------------------#
-class WebEditorManager(EditorManager):
-#-----------------------------------#
- """
- classe qui gere quel est l editor web actif
- """
-
- #--------------------------------
- def __init__(self, appliEficas):
- #--------------------------------
- super().__init__(appliEficas)
- self.dictEditors={}
- self.dictSessions = {}
-
-
- #---------------------------------------
- def afficheInfos(self,txt,couleur=None):
- #---------------------------------------
- """
- Est-ce que le web_manager a des infos a afficher ?
- sans session ?
- """
- self.appliEficas.toWebApp('afficheInfos', txt, couleur)
-
-
- # ------------------------------------------------------
- def getEditor(self, sId=None, cata=None, fichier=None
- # ------------------------------------------------------
- """
- Retourne un nouvel editeur ou le meme si doublon
- gere la liste des connexions pour propager les infos
- il faut aussi la machine dont il provient
- """
- for indexEditor in self.dictEditors:
- editor = self.dictEditors[indexEditor]
- if self.samePath(cata, editor.getCataName()) and self.samePath(fichier, editor.getFileName()):
- double = editor
- break
- else:
- double = None
- from web_editor import WebEditor
- editor = WebEditor(self.appliEficas, fichier)
- if editor.jdc: # le fichier est bien un jdc
- self.editors.append(editor)
- self.dictEditors[editor.idUnique]=editor
- else:
- editor=None
- # if double :
- # il faut mettre les sessions à jours
- return editor
-
-
- # --------------------------
- def getEditorById(self, id):
- # ---------------------------
- if id in self.dictEditors:
- return self.dictEditors[id]
- return None
-
- # --------------------------
- def getIdByEditor(self, editor):
- # ---------------------------
- for (id, valEditor) in self.dictEditors.items():
- if editor == valEditor : return id
- return None
-
-
+++ /dev/null
-#!/usr/bin/env python
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-import os, sys
-
-from Editeur.eficas_appli import EficasAppli
-from InterfaceGUI.Web.web_editor_manager import WebEditorManager
-from Accas.extensions.eficas_exception import EficasException
-
-activeLogging=0
-if activeLogging :
- from Editeur.loggingEnvironnement import loggingEnvironnement, fonctionLoguee
-else :
- fonctionLoguee = lambda func: func
-
-#--------------------------------#
-class WebEficasAppli(EficasAppli):
-#--------------------------------#
- """
- Class implementing the main QT user interface.
- """
-
- #---------------------------------------------------------------------------------------------------------------------------------------------------------
- def __init__(self, code=None, versionCode=None, salome=0, multi=False, langue="fr", ssCode=None, fichierCata=None, GUIPath="InterfaceGUI.QT5", appWeb=None):
- #---------------------------------------------------------------------------------------------------------------------------------------------------------
- """
- Constructor
- """
- EficasAppli.__init__( self, code, versionCode, salome, multi, langue, ssCode, fichierCata, GUIPath, appWeb)
- self.editorManager = WebEditorManager(self)
- if self.appWeb == None :
- super().afficheMessage ('lancement Eficas WEB' , 'le parametre appWeb est obligatoire')
- return
-
-
- #-----------------------------------------
- def toWebApp(self,fction, sid, eid *args, **kwargs):
- #-----------------------------------------
- #if fction =='propageValide' :
- debug=0
- if debug : print ('PNPNPN : WebEficasAppli.toWebApp', fction, sid, eid, *args, **kwargs)
- if self.appWeb == None : return
- #if fction =='propageValide' : print ('self.appWeb.toWebApp propageValide', self.monEditeur.getNodeById(args[0]).nom)
- self.appWeb.fromConnecteur(fction, sid, eid, *args, **kwargs)
-
- #-----------------------
- def createEditor(self):
- #-----------------------
- monEditor = self.editorManager.getEditor(self)
- return monEditor
-
-
- @fonctionLoguee
- #---------------------------
- def openFile(self, fichier):
- #---------------------------
- try:
- monEditor = self.editorManager.getEditor(fichier)
- except EficasException as exc:
- self.afficheMessage('erreur ouverture fichier', str(exc),critical=True)
- monEditor = None
- return monEditor
-
- @fonctionLoguee
- #-----------------------------------------------------
- def afficheMessage (self, titre, texte,critical=True):
- #-----------------------------------------------------
-#TODO : le afficheMessage doit tenir compte de qui
- if critical :
- self.toWebApp('afficheMessage', titre+texte, 'rouge')
- else :
- self.toWebApp('afficheMessage', titre+texte)
-
-
-if __name__ == "__main__":
- print ('todo')
Editeur de jdc 5C
"""
- def __init__ (self,appliEficas,fichier = None, jdc=None, QWParent=None, include=0):
+ def __init__ (self,appliEficas,cataFile = None, fichier = None, jdc=None, QWParent=None, include=0):
#------------------------------------------------------------------------------------------------
debug = 0
QWidget.__init__(self,None)
self.setupUi(self)
- Editor.__init__(self,appliEficas, fichier, jdc=jdc)
+ Editor.__init__(self,appliEficas, cataFile=None, fichier=fichier, jdc=jdc, QWParent=QWParent, include=include)
comploader.chargerComposants(self.appliEficas.GUIPath)
self.initQTSignals()
self.inhibeSplitter=0
# coding: utf-8
#!/usr/bin/env python3
-import sys
+import sys, os
code='Essai'
#code=None
app.config['UPLOAD_FOLDER'] = 'data/'
app.config['THUMBNAIL_FOLDER'] = 'data/thumbnail/'
app.config['MAX_CONTENT_LENGTH'] = 50 * 1024 * 1024
+#PNPN
+#app.config['SESSION_REFRESH_EACH_REQUEST'] = False
ALLOWED_EXTENSIONS = set(['py','comm','txt', 'gif', 'png', 'jpg', 'jpeg', 'bmp', 'rar', 'zip', '7zip', 'doc', 'docx'])
IGNORED_FILES = set(['.gitignore'])
import os
sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'..'))
from Editeur.eficas_go import getEficas
- eficasAppli=getEficas(code, langue='ang',GUIPath= 'Web',appWeb=app)
+ eficasAppli=getEficas(code, langue='ang',appWeb=app)
return eficasAppli
eficasAppli=createWebAppli(app)
debug=1
-if debug :
- monEficasEditeur=eficasAppli.getEditor()
- print ('les commandes dans le catalogue')
- print ('_______________________________')
- print (monEficasEditeur.getListeCommandes())
-
-def fromConnecteur(maFonction,*args,**kwargs):
+# Plus possible, il faut d autres parametres a getEditor
+# si on veut la liste des commandes il faut enrichir l API
+#if debug :
+# monEficasEditeur=eficasAppli.getEditor()
+# print ('les commandes dans le catalogue')
+# print ('_______________________________')
+# print (monEficasEditeur.getListeCommandes())
+
+def fromConnecteur(maFonction, sessionId,*args,**kwargs):
fnct=globals()[maFonction]
- fnct(*args,**kwargs)
+ fnct(sessionId, *args,**kwargs)
#TODO : Rattacher à une session
# gérer un appel register callback
# - ReAffichage d'un noeud (et ses enfants)
# - Changement d'un nom de mot-cle reference
-def propageValide(id, valid): #TODO: RENAME TO ... propagateValidation
+def propageValide(sId, id, valid): #TODO: RENAME TO ... propagateValidation
+ if sId != session['eficasSession'] : return
print ('Flask/propageValide: ', id, valid)
sse.publish( {'id':id, 'valid':valid, 'message': "Hello from propageValide!"}, type='propageValide')
-def updateNodeInfo(id, info):
+def updateNodeInfo(sId, id, info):
+ print ('Flask/updateNodeInfo', sId, id, info, session['eficasSession'])
+ print ('--------- sId',sId)
+ print ('--------- moimeme',session['eficasSession'])
+ print ('--------- monEditeur',session['eficasEditor'])
+ #if sId != session['eficasSession'] : return
print ('Flask/updateNodeInfo: ', id, info)
sse.publish( {'id':id, 'info':info, 'message': "Hello from updateNodeInfo!"}, type='updateNodeInfo')
-def appendChildren(id, fcyTreeJson, pos):
+def appendChildren(sId, id, fcyTreeJson, pos):
+ if sId != session['eficasSession'] : return
print ('Flask/appendChildren: ', id, fcyTreeJson, pos)
sse.publish( {'id':id, 'fcyTreeSrc':fcyTreeJson, 'pos':pos, 'message': "Hello from appendChildren!"}, type='appendChildren')
-def deleteChildren(idList):
+def deleteChildren(sId, idList):
+ if sId != session['eficasSession'] : return
#print ('Flask/deleteChildren: ', idList)
sse.publish( {'idList':idList,'message': "Hello from deleteChildren!"}, type='deleteChildren')
#TODO: Câbler la sélection du catalogue avant d'activer les appels suivants
# car si la page Web n'est pas rendue et que le connecteur génère une erreur... boom !
-def afficheMessage(txt, couleur): #TODO: RENAME TO ... displayWarning
+def afficheMessage(sId, txt, couleur): #TODO: RENAME TO ... displayWarning
+ if sId != session['eficasSession'] : return
print ('Flask/afficheMessage: ', txt, couleur)
# sse.publish( {'txt':txt, 'color':couleur, 'messageClass':"alert-warning" ,'message': "Hello from afficheMessage!"},
# type='displayMessage')
-def afficheAlerte(titre, message): #TODO: RENAME TO ... displayDanger
+def afficheAlerte(sId, titre, message): #TODO: RENAME TO ... displayDanger
+ if sId != session['eficasSession'] : return
print ('Flask/afficheAlerte: ', titre, message) #TODO: titre & message VS txt ?
# sse.publish( {'txt':titre, 'color':couleur, 'messageClass':"alert-danger", 'message': "Hello from afficheAlerte!"},
# type='displayMessage')
id=req['id'];value=req['value']
# id, value = req.values() # Dangereux correspondance implicite
value = str(value) #On peut écrire Pi
- eficasEditeur=eficasAppli.getEditorById(session['eficasEditeur'])
- rId,message,changeDone = eficasEditeur.changeValeur(id,value);
+
+ (eficasEditor, code, message) =eficasAppli.getEditorById(session['eficasEditor'])
+ #eficasEditor=eficasAppli.getEditorById(session['eficasEditor'])
+ sId = session['eficasSession']
+ print ('uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu', sId)
+
+ (rId,message,changeDone) = eficasEditor.changeValeur(sId, id,value);
assert(rId==id)
#changeDone = True
print ("changeDone : ",changeDone)
# Ne pas recuperer et ne pas renvoyer le noeud dans le cas du SIMP
# (le changeDone et l''ancienne valeur ds la WebApp suffit
- node = eficasEditeur.getDicoForFancy(eficasEditeur.getNodeById(id))
+ node = eficasEditor.getDicoForFancy(eficasEditor.getNodeById(id))
print("Flask/updateSimp node : ",node)
# return jsonify([myTreeDico])
# Print the dictionary
id=req['id'];sdnom=req['sdnom']
sdnom = str(sdnom) #On peut écrire Pi
- eficasEditeur=eficasAppli.getEditorById(session['eficasEditeur'])
- changeDone,message = eficasEditeur.updateSDName(id,sdnom);
+ eficasEditor=eficasAppli.getEditorById(session['eficasEditor'])
+ changeDone,message = eficasEditor.updateSDName(id,sdnom);
#changeDone = True
print ("changeDone : ",changeDone)
# Print the dictionary
print("/removeNode ",req);print("/removeNode ",req['id']);
id = req['id'];
- eficasEditeur=eficasAppli.getEditorById(session['eficasEditeur'])
- ret,message = eficasEditeur.suppNode(id);
+ eficasEditor=eficasAppli.getEditorById(session['eficasEditor'])
+ ret,message = eficasEditor.suppNode(id);
print ("/removeNode : ret : ",ret," message : ",message)
return make_response(json.dumps( {'ret':ret, 'message':message} ))
print(__file__+"/appendChild : ",req);
id=req['id'];name=req['name'];pos=req['pos'];
# id, value = req.values() # Dangereux correspondance implicite
- #rId,message,changeDone = eficasEditeur.appendChild(id,name,pos);
- newId = eficasEditeur.appendChild(id,name,pos);
+ #rId,message,changeDone = eficasEditor.appendChild(id,name,pos);
+ newId = eficasEditor.appendChild(id,name,pos);
print (__file__+"/appendChild : newId : ",newId);
return make_response(json.dumps( {'id':newId} ))
@app.route('/')
def index():
-
-#PN decider de ce qu on appelle
-# Lecture du cata
-# Lecture du fichier
- #eficasEditeur = eficasAppli.litFichierComm('../Codes/WebTest/web_tres_simple_avec_2Fact.comm')
- #eficasAppli.litFichierComm('../WebTest/edg_REP1300_FULL_PN.comm')
-
- eficasEditeur = eficasAppli.openFile('../Codes/WebTest/web_tres_simple_avec_2Fact.comm')
- print ('_____________________________________')
- print (eficasAppli)
- print ('dans index : eficasEditeur', eficasEditeur)
- if not(eficasEditeur) :
+ print ('_______________________________________________')
+ print (session)
+ print ('_______________________________________________')
+ (eficasSession, codeErreur, message) =eficasAppli.getSessionId()
+ debug=1
+ if not codeErreur :
+ session['eficasSession'] = eficasSession
+ if debug : print (' enrolement de session : ', eficasSession)
+ else :
+ afficheMessage(message, 'red')
+ if not(eficasEditor) :
+ return render_template('commandes_2.html',
+ titre='Pb a l enrolement ',
+ listeCommandes = [],
+ tree= None
+ )
+ cataFile = os.path.abspath('../Codes/WebTest/cata_essai.py')
+ dataSetFile = os.path.abspath('../Codes/WebTest/web_tres_simple_avec_2Fact.comm')
+ if eficasSession == 3:
+ dataSetFile = os.path.abspath('../Codes/WebTest/web_tres_simple_incomplet.comm')
+ (eficasEditor, codeErreur, message) = eficasAppli.getWebEditor(eficasSession, cataFile, dataSetFile)
+ # TODO : separer les erreurs ouverture cata / ouvertur fichier
+ if debug : print ('dans index : eficasEditor : ', eficasEditor, ' code Erreur : ', codeErreur,'message : ', message)
+ if not codeErreur :
+ session['eficasEditor']=eficasEditor.getEditorId()
+ else :
+ afficheMessage(message, 'red')
+ if not(eficasEditor) :
+ return render_template('commandes_2.html',
+ titre='Pb a l enrolement ',
+ listeCommandes = [],
+ tree= None
+ )
+
+ if not(eficasEditor) :
return render_template('commandes_2.html',
titre='Pb a la lecture',
listeCommandes = [],
tree= None
)
- #myFancyTreeDico=session['eficasEditeur'].getDicoForFancy(session['eficasEditeur'].tree.racine)
- session['eficasEditeur']=eficasEditeur.idUnique
- eficasEditeur=eficasAppli.getEditorById(session['eficasEditeur'])
- myFancyTreeDico=eficasEditeur.getDicoForFancy(eficasEditeur.tree.racine)
+ (eficasEditor, code, message) =eficasAppli.getEditorById(session['eficasEditor'])
+ if codeErreur :
+ afficheMessage(message, 'red')
+ if not(eficasEditor) :
+ return render_template('commandes_2.html',
+ titre='Pb a l ouverture du dataSet ',
+ listeCommandes = [],
+ tree= None
+ )
+ if debug : print ('idEditor = ', session['eficasEditor'])
+ if debug : print ('eficasEditor : ',eficasEditor)
+
+ myFancyTreeDico=eficasEditor.getDicoForFancy(eficasEditor.tree.racine)
myFancyTreeJS=json.dumps([myFancyTreeDico],indent=4) #TODO : remove indent if not DEBUG
#print("---- myFancyTreeDico ----")
return render_template('commandes_2.html',
titre=code,
- listeCommandes = eficasEditeur.getListeCommandes(),
+ listeCommandes = eficasEditor.getListeCommandes(),
tree=myFancyTreeJS,
# tree=tree4Fancy,
)
# etape = str(escape(request.args.get("etape", "")))
+@app.route('/get_eficasSession')
+def get_eficasSession():
+ if 'eficasSession' in session : print ( session['eficasSession'])
+ else : print ('pas de eficasSession')
+ return render_template('commandes_2.html',
+ titre=session['eficasSession'],
+ listeCommandes = [],
+ tree=None,
+ )
+
+@app.route('/get_eficasEditor')
+def get_eficasEditor():
+ if 'eficasEditor' in session : print ( session['eficasEditor'])
+ else : print ('pas de eficasEditor')
+ return render_template('commandes_2.html',
+ titre=session['eficasEditor'],
+ listeCommandes = [],
+ tree=None,
+ )
+
#TODO:
#from fileManagement import *
