zephir.utils.creolewrap

Package zephir :: Package utils :: Module creolewrap |
[frames] | no frames]

# Source Code for Module zephir.utils.creolewrap

      1  # -*- coding: UTF-8 -*-
      2  ###########################################################################
      3  # Eole NG - 2007
      4  # Copyright Pole de Competence Eole  (Ministere Education - Academie Dijon)
      5  # Licence CeCill  cf /root/LicenceEole.txt
      6  # eole@ac-dijon.fr
      7  #
      8  # creolewrap.py
      9  #
     10  # classe abstraite permettant de gérer les configurations
     11  # creole1 et creole2 dans zephir
     12  #
     13  ###########################################################################
     14
     15  import os, traceback
     16  # import creole1 et creole2
     17  import dico, base64, cjson
     18  from copy import copy
     19  from creole3 import upgrade
     20  from creole.error import TypeEoleError
     21  from zephir.config import charset
     22  from creole import eosfunc, cfgparser
     23  from glob import glob
     24
     25  # creole3 (eole2.4/tiramisu)
     26  from creole3.var_loader import CreoleVarLoader
     27  from creole3.loader import config_save_values, config_load_values, \
     28  config_get_values, config_load_store, modes_level
     29  from tiramisu.value import Multi
     30  from tiramisu.option import ChoiceOption, OptionDescription, BoolOption, IntOption
     31  from tiramisu.error import PropertiesOptionError
     32  from tiramisu.setting import owners
     33  from tiramisu.config import Config
     34  type_option_convert = {BoolOption: bool, IntOption: int}
     35
     36  # HACK pour simuler les variables de conteneurs dans Zéphir (attention, toutes les ips sont à 127.0.0.1)
     37  eosfunc.containers_file = '/usr/share/zephir/dictionnaires/fake_containers.conf'
     38  cfgparser.config.containers_file = '/usr/share/zephir/dictionnaires/fake_containers.conf'
     39  EDict = cfgparser.EoleDict
     40
     41  # creole3
     42  #
     43  # fonctions nécessaires :
     44  #
     45  # - get_vars
     46  # - init_from_zephir ?
     47  # - load_values
     48  # - get_var
     49  # - set_value
     50  # - save
     51  # - parsedico
     52  # - get_menu
     53  #
     54  # attributs utilisés :
     55  #
     56  # - liste_vars
     57  # - mode / version
     58  # -
     59
     60 -def check_hidden(properties):
     61      """regarde si une famille/variable creole 3 est cachée
     62      """
     63      hidden_properties = set(['hidden', 'disabled'])
     64      if hidden_properties.intersection(properties):
     65          return True
     66      return False
     67
     68 -class ZephirDict:
     69      """sert de wrapper par dessus les dictionnaires creole1 et creole2
     70      """
     71
     72 -    def __init__(self, dicos=[], confdir='', mode='config', version='creole2'):
     73          """initialise un objet dictionnaire avec la bonne api
     74          """
     75          self.version = version
     76          self.separators = {}
     77          self.multivars = []
     78          self.autovars = []
     79          self.confdir = confdir
     80          self.mode = mode
     81          self.index = 0
     82          # initialisiation du dictionnaire
     83          if self.version == "creole2":
     84              self.dico = EDict(logfile='/dev/null')
     85          elif self.version == "creole3":
     86              self.creoledirs = []
     87          elif self.version == "creole1":
     88              self.dico_zephir = None
     89              self.dico = None
     90          self.dicos = []
     91          # XXX virer condition si pas CREOLE 1
     92          if self.version != 'creole1':
     93              # chargement de tous les dictionnaires disponibles
     94              for creoledir in dicos:
     95                 if os.path.isdir(creoledir):
     96                      list_dic = glob(creoledir + '/*.xml')
     97                      list_dic.sort()
     98                      self.dicos.extend(list_dic)
     99                      if self.version == 'creole2':
    100                          self.dico.read_dir(creoledir)
    101              if self.version == 'creole2':
    102                  self._update_vars()
    103          self.load_values(mode, dicos)
    104
    105 -    def get_config_file(self, mode, write=False):
    106          """calcule le nom du fichier de configuration a utiliser en fonction du mode
    107          write : si True, indique qu'on cherche à sauvegarder le fichier
    108                  si False, recherche le fichier à lire pour récupérer les valeurs déjà connues
    109          """
    110          config_file = ""
    111          if self.confdir != '':
    112              # le fichier doit exister
    113              # dans le cas de creole3, on crée un dictionnaire avec les valeurs sauvegardées
    114              # (chargements successifs de fichiers de valeurs non gérés)
    115              serv_file = os.path.join(self.confdir, 'zephir.eol')
    116              mod_file = os.path.join(self.confdir, 'module.eol')
    117              var_file = os.path.join(self.confdir, 'dico.eol')
    118              migration_file = os.path.join(self.confdir, 'migration.eol')
    119              if mode == 'modif_config' and os.path.isfile(serv_file):
    120                  config_file = serv_file
    121              elif mode in ['config','modif_config','modif_dico']:
    122                  if os.path.isfile(var_file):
    123                      config_file = var_file
    124                  elif os.path.isfile(mod_file):
    125                      config_file = mod_file
    126              elif mode in ['migration', 'modif_migration'] and os.path.isfile(migration_file):
    127                  config_file = migration_file
    128          return config_file
    129
    130 -    def set_owner(self, owner):
    131          """spécifique creole3 : initialise le propriétaire d'une valeur
    132          """
    133          if self.dico is not None:
    134              if owner not in dir(owners):
    135                  owners.addowner(owner)
    136              self.dico.cfgimpl_get_settings().setowner(getattr(owners, owner))
    137
    138 -    def load_dicos_creole3(self, dicos, from_zephir=False):
    139          # creole 3: on doit charger tous les dictionnaires en une passe
    140          self.dico = CreoleVarLoader()
    141          if from_zephir:
    142              self.creoledirs = []
    143              dicos = [base64.decodestring(dico_zeph) for dico_zeph in dicos[:-1]]
    144              # chargement de tous les dictionnaires disponibles
    145              self.dico.read_string(dicos, 'creole')
    146              self.groups = self.dico.groups
    147          elif dicos:
    148              self.creoledirs = dicos
    149              self.dico.read_dir(dicos, 'creole')
    150              # stockage des séparateurs
    151              self.separators = {}
    152              for sep, data in self.dico.separators.items():
    153                  self.separators[sep] = (data[0], data[1] is not None)
    154              # stockage des groupes (master/slave)
    155              self.groups = self.dico.groups
    156          # après chargement des dictionnaires,
    157          # on ne conserve que la configuration tiramisu
    158          self.dico = self.dico.get_config()
    159          self.dico.read_write()
    160          # désactivation des propriétés 'hidden'
    161          # pour permettre l'accès aux variables cachées
    162          self.dico.cfgimpl_get_settings().remove('hidden')
    163
    164 -    def migrate_creole3(self, dicos):
    165          """fonction de migration d'une configuration creole2 vers creole3
    166          pour creole3, le fonctionnement est le suivant
    167          - stockage des valeurs par défaut de module/variante de la version cible dans un dictionnaire python
    168          - chargement de l'ancien fichier de configuration avec le loader creole (appel auto des fonctions de migration)
    169            et récupération des valeurs dans un dictionnaire
    170          - fusion des valeurs par défaut et des valeurs migrées
    171          - rechargement de la configuration avec ces valeurs
    172          """
    173          # fichier des valeurs actuelles
    174          current_eol = os.path.join(self.confdir, 'zephir.eol')
    175          migration_eol = os.path.join(self.confdir, 'migration.eol')
    176          # on essaye de charger les données de module.eol et dico.eol en premier
    177          def_values = {}
    178          for path_conf in dicos:
    179              for conf_file in ('module.eol','dico.eol'):
    180                  fic_defaults = os.path.join(os.path.dirname(path_conf),conf_file)
    181                  if os.path.isfile(fic_defaults):
    182                      try:
    183                          new_vals = cjson.decode(open(fic_defaults).read().strip(), all_unicode = True)
    184                          def_values.update(new_vals)
    185                      except:
    186                          pass
    187          # migration des valeurs de la configuration actuelle
    188          serv_prefix = '-'.join(self.confdir.split(os.path.sep)[-2:])
    189          # modification du préfixe de log dans creole.log (ajout de RNE-N°SERV)
    190          upgrade.log.name = "creole3.upgrade.{0}".format(serv_prefix)
    191          migration_values, version = upgrade.upgrade(self.dico, unicode(current_eol, charset))
    192          def_values.update(migration_values)
    193          # application des valeurs sur la configuration
    194          settings = self.dico.cfgimpl_get_settings()
    195          settings.remove('disabled')
    196          settings.remove('frozen')
    197          config_load_store(self.dico, 'creole', def_values, unset_default=True)
    198          self.dico.impl_set_information('upgrade', version)
    199          # self.dico.impl_set_information('creole', unicode(migration_eol, charset))
    200          settings.append('frozen')
    201          settings.append('disabled')
    202
    203 -    def _load_values_creole3(self, mode, dicos, config_file):
    204          if dicos:
    205              self.load_dicos_creole3(dicos)
    206          # if not config_file and not dicos and self.creoledirs:
    207          elif self.creoledirs:
    208              # création d'un nouvelle configuration depuis la description existante si
    209              # retour aux valeurs par défaut quand les dictionnaires sont déjà chargés
    210              cfg_descr = self.dico.cfgimpl_get_description()
    211              self.dico = Config(cfg_descr)
    212              self.dico.impl_set_information('creole', unicode(config_file, charset))
    213              self.dico.read_write()
    214              self.dico.cfgimpl_get_settings().remove('hidden')
    215          # chargement du fichier de valeurs
    216          if mode == 'migration':
    217              self.migrate_creole3(dicos)
    218          elif config_file:
    219              store_values = {}
    220              config_files = [config_file]
    221              # cas particulier pour creole3. Dans le cas de chargement des valeurs par défaut
    222              # d'une variante, on charge aussi les valeurs au niveau module
    223              if os.path.basename(config_file) == 'dico.eol':
    224                  config_files.insert(0, os.path.join(os.path.dirname(config_file), 'module.eol'))
    225              for conf_file in config_files:
    226                  if os.path.isfile(conf_file):
    227                      try:
    228                          store_values.update(cjson.decode(open(conf_file).read().strip(), all_unicode = True))
    229                      except:
    230                          pass
    231              # on désactive les tests sur frozen pour pouvoir recharger les valeurs
    232              settings = self.dico.cfgimpl_get_settings()
    233              settings.remove('frozen')
    234              settings.remove('disabled')
    235              # valeurs passées sous forme de dictionnaires
    236              config_load_store(self.dico, 'creole', store_values)
    237              settings.append('disabled')
    238              settings.append('frozen')
    239          if hasattr(self, 'dico'):
    240              self._update_vars()
    241
    242 -    def _load_values_creole2(self, mode, dicos, config_file):
    243          # reset des valeurs
    244          self.dico.reset_defaults()
    245          if config_file != "" and mode != 'migration':
    246              self.dico.load_values(config_file, check=False)
    247          elif mode in ['migration', 'modif_migration']:
    248              # on essaye de charger les données de module.eol et dico.eol en premier
    249              for path_conf in dicos:
    250                  for conf_file in ('module.eol','dico.eol'):
    251                      if os.path.isfile(os.path.join(os.path.dirname(path_conf),conf_file)):
    252                          self.dico.load_values(os.path.join(os.path.dirname(path_conf),conf_file), check=False)
    253              # import des valeurs creole1 du serveur
    254              if os.path.isfile(self.confdir+os.sep+'zephir.eol'):
    255                  # détection du format de l'ancien dictionnaire (creole 1 ou 2)
    256                  first_line = open(self.confdir+os.sep+'zephir.eol').read().strip().split('\n')[0]
    257                  if not (first_line.startswith('[') and first_line.endswith(']')):
    258                      # migration depuis une config creole1
    259                      res = self.dico.import_values_creole1(self.confdir+os.sep+'zephir.eol')
    260                  else:
    261                      # récupération des valeurs migrées par upgrade.py
    262                      res = self.dico.import_values(self.confdir+os.sep+'zephir.eol')
    263          elif os.path.isfile(self.confdir+os.sep+'module.eol'):
    264              # on prend les valeurs par défaut du module
    265              self.dico.load_values(self.confdir+os.sep+'module.eol', check=False)
    266
    267 -    def _load_values_creole1(self, mode, dicos, config_file):
    268          if dicos == [] and self.dico_zephir:
    269              dicos = self.dico_zephir
    270          # initialisiation du dictionnaire. Dans creole1, les dictionnaires et les valeurs sont dans
    271          # les même fichiers
    272          self.dico = dico.DicoEole(dico_zephir=dicos)
    273          # on conserve les dictionnaires pour pouvoir réinitialiser si chargement d'un autre fichier
    274          self.dico_zephir = dicos
    275          # dictionnaire des valeurs par défaut ou déjà remplies
    276          dico_actuel = None
    277          if config_file != "":
    278              fic = open(config_file)
    279              data = fic.readlines()
    280              lines = [ unicode(line,'ISO-8859-1').encode(charset) for line in data ]
    281              fic.close()
    282              # on parse ce dico
    283              dico_actuel = dico.DicoEole(dico_zephir=[lines]).ParseDico()
    284
    285          if dico_actuel is not None:
    286              # des valeurs ont déjà été saisies
    287              dico_final = {}
    288              # on réinsère les données existantes dans le dictionnaire
    289              for variable, data in self.dico.dictionnaire.items():
    290                  # si la variable existait déjà, on reprend sa valeur
    291                  if dico_actuel.has_key(data[0]):
    292                      data[1] = dico_actuel[data[0]][0]
    293                  dico_final[variable] = data
    294              # on remet le dictionnaire modifié en place dans self.dico
    295              self.dico.dictionnaire = dico_final
    296          self.liste_vars = self.dico.liste_vars
    297
    298 -    def load_values(self, mode, dicos=[], config_file=None):
    299          # lecture des valeurs actuelles selon le mode demandé
    300          if config_file is None:
    301              config_file = self.get_config_file(mode)
    302          if self.version == 'creole3':
    303              self._load_values_creole3(mode, dicos, config_file)
    304          elif self.version != 'creole1':
    305              self._load_values_creole2(mode, dicos, config_file)
    306          else:
    307              self._load_values_creole1(mode, dicos, config_file)
    308          self.mode = mode
    309
    310 -    def get_help(self, name, family=False):
    311          """Récupère l'aide de la variable
    312          - définie dans une balise help pour creole2 (chaine vide si non défini)
    313          - pour creole 1, on renvoie une chaine vide
    314          """
    315          if self.version == 'creole3':
    316              try:
    317                  if family:
    318                      opt = self.dico.unwrap_from_path('creole.' + name)
    319                  else:
    320                      opt = self.dico.vars[self.dico.liste_vars[name]]
    321              except:
    322                  opt = None
    323              if opt: return opt.impl_getdoc()
    324          elif self.version == 'creole2':
    325              if family:
    326                  section = 'families'
    327              else:
    328                  section = 'variables'
    329              if name in self.dico.helps.get(section, {}):
    330                  return self.dico.helps[section][name]
    331          return ""
    332
    333 -    def init_from_zephir(self, dicos):
    334          """charge les dictionnaire depuis une liste de chaines xml
    335          @param dicos: contenu des dictionnaires à implémenter + valeurs actuelles en fin de liste
    336          """
    337          # chargement depuis des valeurs envoyées, on ne sait pas dans quel mode on est
    338          self.mode = None
    339          if self.version != 'creole1':
    340              if self.dicos == []:
    341                  # Les dictionnaires n'ont pas été chargés précédemment, on utilise ceux fournis
    342                  if self.version == 'creole3':
    343                      self.load_dicos_creole3(dicos, True)
    344                  else:
    345                      self.dico = EDict(logfile='/dev/null')
    346                      self.dicos = [base64.decodestring(dico_zeph) for dico_zeph in dicos[:-1]]
    347                      # chargement de tous les dictionnaires disponibles
    348                      for xml_dict in self.dicos:
    349                          self.dico.read_string(xml_dict)
    350              # prise en compte du dictionnaire de valeurs
    351              if self.version == "creole3":
    352                  values = eval(dicos[-1])
    353                  settings = self.dico.cfgimpl_get_settings()
    354                  # on désactive les tests sur frozen pour pouvoir recharger les valeurs
    355                  settings.remove('frozen')
    356                  settings.remove('disabled')
    357                  config_load_store(self.dico, 'creole', values)
    358                  self.dico.impl_set_information('orig_values', values)
    359                  settings.append('frozen')
    360                  settings.append('disabled')
    361              else:
    362                  # chargement des valeurs actuelles
    363                  val_dict = eval(dicos[-1])
    364                  self.dico.store._sections = val_dict
    365                  self.dico._load_values()
    366              if len(dicos) > 1:
    367                  # si dictionnaires réinitialisés,
    368                  # on réinitialise les données de structure
    369                  self._update_vars()
    370          else:
    371              dicos = base64.decodestring(dicos)
    372              dicos = [dicos.splitlines(True)]
    373              self.dico = dico.DicoEole(dico_zephir=dicos)
    374              self.liste_vars = self.dico.liste_vars
    375
    376 -    def _update_vars(self):
    377          """regénère les structures après chargement des dictionnaires
    378          """
    379          if self.version != 'creole1':
    380              # création d'un liste pour ordonner les variables
    381              self.index = 0
    382              self.vars = []
    383              # création de self.liste_vars
    384              self.liste_vars = {}
    385              ind = 0
    386              if self.version == 'creole3':
    387                  # dictionnaire pour retrouver le chemin d'une variable donnée
    388                  self.var_paths = {}
    389                  # liste des familles ordonnée
    390                  self.families = []
    391                  self.expert_families = []
    392                  # lecture du cache ordonné des variables
    393                  # on n'a pas besoin de conserver la liste des variables multi/auto
    394                  descr_cache = self.dico.cfgimpl_get_description()._cache_paths
    395                  for cache_index, descr in enumerate(descr_cache[0]):
    396                      if isinstance(descr, OptionDescription):
    397                          if getattr(descr, '_group_type', '') == 'family':
    398                              current_mode = 'normal'
    399                              # vérification du mode expert au niveau de la famille
    400                              if 'expert' in descr._properties:
    401                                  self.expert_families.append(descr)
    402                                  current_mode = 'expert'
    403                              else:
    404                                  self.families.append(descr)
    405                      else:
    406                          current_path = descr_cache[1][cache_index]
    407                          self.vars.append(descr)
    408                          self.liste_vars[descr._name] = ind
    409                          self.var_paths[descr._name] = (current_path, current_mode)
    410                          ind += 1
    411              else:
    412                  # creole 2
    413                  for family in self.dico.family_order:
    414                      for var in self.dico.families[family]['vars']:
    415                          self.vars.append(var)
    416                          self.liste_vars[var] = ind
    417                          ind += 1
    418                          if self.dico.variables[var].multi == True:
    419                              self.multivars.append(var)
    420                              self.multivars.extend(self.dico.groups.get(var,[]))
    421                          if self.dico.variables[var].auto != []:
    422                              self.autovars.append(var)
    423                  # séparateurs (sections dans un onglet)
    424                  self.separators = self.dico.separators
    425
    426 -    def get_value(self, var):
    427          if self.version == 'creole3':
    428              # Si la variable est 'disabled', on ne peut pas accéder à la valeur
    429              try:
    430                  val = getattr(self.dico, self.var_paths[var][0]) or ''
    431              except PropertiesOptionError, e:
    432                  val = ''
    433              if not val:
    434                  # au cas ou la valeur serait None ou une liste vide
    435                  # on renvoie une chaîne vide
    436                  val = ['']
    437              elif type(val) == Multi:
    438                  val = list(val)
    439              elif type(val) not in (unicode, str):
    440                  val = [str(val)]
    441              else:
    442                  val = [val]
    443          else:
    444              val = self.dico.get_value(var)
    445          return val
    446
    447 -    def get_enumeration(self, var):
    448          vals = []
    449          allow_other = False
    450          if self.version == 'creole3':
    451              try:
    452                  option = self.vars[self.liste_vars[var]]
    453              except AttributeError, e:
    454                  option = None
    455              if option and isinstance(option, ChoiceOption):
    456                  vals = list(option.impl_get_values())
    457                  allow_other = option.impl_is_openvalues()
    458          elif self.version != 'creole1':
    459              eolvar = self.dico.get_variable(var)
    460              checks = eolvar.checks
    461              for check in checks:
    462                  if check[0] == u'valid_enum':
    463                      # récupération des valeurs possibles
    464                      for param in check[1]:
    465                          if param['name'] == 'checkval':
    466                              if param['value'] == "False":
    467                                  allow_other = True
    468                          else:
    469                              vals.extend(eval(param['value']))
    470          else:
    471              conditions = self.dico.dictionnaire[self.dico.liste_vars[var]][3]
    472              # recherche des enumérations
    473              for cond in conditions:
    474                  if cond.startswith('enumeration'):
    475                      try:
    476                          vals = eval(cond.split('??')[1])
    477                      except:
    478                          # si rien n'est spécifié, on propose oui,non par défaut
    479                          vals = ['oui','non']
    480                      break
    481          return vals, allow_other
    482
    483 -    def get_first(self):
    484          """retourne les paramètres de la variable nom,valeur,libelle,variable cachée
    485          """
    486          if self.version == 'creole1':
    487              self.dico.get_first()
    488          else:
    489              self.index = 0
    490          try:
    491              return self._get_var_details()
    492          except PropertiesOptionError, e:
    493              # pour creole3, on gère le cas ou la première
    494              # variable serait désactivée
    495              return self.get_next()
    496
    497 -    def get_next(self):
    498          if self.version == 'creole1':
    499              self.dico.get_next()
    500          else:
    501              prev_index = self.index
    502              self.index = self.index + 1
    503          try:
    504              return self._get_var_details()
    505          except PropertiesOptionError, e:
    506              # variable non accessible, on passe à la suivante
    507              return self.get_next()
    508          except (KeyError, IndexError), e:
    509              self.index = prev_index
    510              raise dico.PositionError, 'fin de la liste des variables'
    511
    512 -    def get_var(self, varname=None):
    513          """retourne les paramètres d'une variable
    514          """
    515          try:
    516              return self._get_var_details(varname)
    517          except PropertiesOptionError, e:
    518              # FIXME variable disabled, à gérer différement ?
    519              return ['']
    520
    521 -    def _get_var_details(self, varname=None):
    522          """adapte la représentation des variables
    523          """
    524          # récupération des infos
    525          if self.version == 'creole3':
    526              # creole3 : on  ne récupère pas toutes les informations
    527              # (nom et description seulement). Le formulaire de saisie
    528              # est géré indépendament
    529              if varname != None:
    530                  self.index = self.liste_vars[varname]
    531              opt = self.vars[self.index]
    532              # adaptation du mode
    533              if 'expert' in opt._properties:
    534                  mode = 'expert'
    535              else:
    536                  # pas de distinction entre basic et normal
    537                  mode = 'normal'
    538              hidden = check_hidden(opt._properties)
    539              obligatoire = 'mandatory' in opt._properties
    540              mime = opt._opt_type
    541              val = getattr(self.dico, self.var_paths[opt._name][0])
    542              if not val:
    543                  if isinstance(val, Multi):
    544                      val = ['']
    545                  else:
    546                      val = ''
    547              data = opt._name, val, opt.impl_getdoc(), hidden, obligatoire, mime, mode
    548          elif self.version == 'creole2':
    549              if varname != None:
    550                  var = self.dico.get_variable(varname)
    551                  self.index = self.vars.index(varname)
    552              else:
    553                  var = self.dico.get_variable(self.vars[self.index])
    554              obligatoire = False
    555              if 'obligatoire' in [ check[0] for check in var.checks ]:
    556                  obligatoire = True
    557              mime = var.mime
    558              mode = var.mode
    559              val = var.get_value()
    560              if type(val) != list:
    561                  val = [val]
    562              if val == []:
    563                  val = ['']
    564              data = var.name, val, var.description, var.hidden, obligatoire, mime, mode
    565          elif self.version == 'creole1':
    566              if varname != None:
    567                  name, val, description, hidden = self.dico.get_var(varname)
    568              else:
    569                  name, val, description, hidden = self.dico.get_current()
    570              checks = self.dico.dictionnaire[self.dico.liste_vars[name]][3]
    571              if 'obligatoire' in checks:
    572                  obligatoire = True
    573                  liste_funcs = copy(checks)
    574                  liste_funcs.remove('obligatoire')
    575                  # liste_funcs = checks.remove('obligatoire')
    576              else:
    577                  obligatoire = False
    578                  liste_funcs = checks
    579              # pas de mode expert au niveau variable dans Creole 1
    580              mode = 'normal'
    581              data = name, [val], description, hidden, obligatoire, liste_funcs, mode
    582          return data
    583
    584 -    def get_prec_value(self, varname):
    585          """ renvoit la valeur précédente """
    586          if self.version != 'creole1':
    587              try:
    588                  value = self.dico.get_prec_value(varname)
    589              except:
    590                  value = ''
    591          else:
    592              try:
    593                  value = self.dico.get_var(varname)[1]
    594              except:
    595                  value = ''
    596          return value
    597
    598 -    def get_default_value(self, varname):
    599          """ renvoit la valeur par défaut """
    600          try:
    601              if self.version == 'creole3':
    602                  value = self.vars[self.liste_vars[varname]].impl_getdefault()
    603              else:
    604                  value = self.dico.get_var(varname)[1]
    605          except:
    606              value = ''
    607          return value
    608
    609 -    def set_value(self, value, invisible=False, force=False):
    610          if self.version == 'creole3':
    611              def convert_value(option, value):
    612                  _type = type(option)
    613                  if _type in type_option_convert:
    614                      if option.impl_is_multi():
    615                          vals = []
    616                          for val in value:
    617                              if val is None:
    618                                  vals.append(val)
    619                              else:
    620                                  vals.append(type_option_convert[_type](val))
    621                          return vals
    622                      else:
    623                          if value is not None:
    624                              return type_option_convert[_type](value)
    625                  else:
    626                      # forçage de la valeur en unicode dans le cas d'une chaîne
    627                      if option.impl_is_multi():
    628                          vals = []
    629                          for val in value:
    630                              if type(val) == str:
    631                                  vals.append(unicode(val, charset))
    632                              else:
    633                                  vals.append(val)
    634                          return vals
    635                      else:
    636                          if type(value) == str:
    637                              return unicode(value, charset)
    638                  return value
    639              try:
    640                  option = self.vars[self.index]
    641                  varname = option._name
    642                  # reprise du fonctionnement de eole-genconfig (conversion + mode permissive)
    643                  value = convert_value(option, value)
    644                  self.dico.cfgimpl_get_settings().setpermissive(tuple(modes_level), opt=option)
    645                  setattr(self.dico, self.var_paths[varname][0], value)
    646                  # rechargement des familles/variables accessibles
    647                  self._update_vars()
    648              except Exception, e:
    649                  raise dico.InvalidDataError, e.args[0]
    650          elif self.version != 'creole1':
    651              try:
    652                  self.dico.set_value(self.vars[self.index], value, force=force)
    653              except Exception, e:
    654                  raise dico.InvalidDataError, e.args[0]
    655          else:
    656              if type(value) == list:
    657                  value = value[0]
    658              self.dico.set_value(value, invisible, force=force)
    659
    660 -    def save(self, eol_file='/dev/null', force=False, encode=False):
    661          if self.version == 'creole3':
    662              # vérifier eole_file : config.impl_get_information(namespace)
    663              check_mandatory=not force
    664              if eol_file and eol_file != '/dev/null':
    665                  # FIXME : validation nécessaire ?
    666                  config_save_values(self.dico, 'creole', eol_file=eol_file, check_mandatory=check_mandatory)
    667              data = [str(config_get_values(self.dico, 'creole', check_mandatory))]
    668          elif self.version != 'creole1':
    669              # sauvegarde du fichier de valeurs
    670              self.dico.save_values(eol_file,force=force)
    671              # on retourne le dictionnaire des valeurs pour recréer le ConfigParser
    672              data = [str(self.dico.store._sections)]
    673          else:
    674              data = self.dico.save(eol_file, encode=encode)
    675          return data
    676
    677 -    def get_dict(self):
    678          # on envoie le dictionnaire sous forme de fichier texte
    679          data = []
    680          if self.version != 'creole1':
    681              for dic in self.dicos:
    682                  f = open(dic)
    683                  content = f.read()
    684                  f.close()
    685                  data.append(base64.encodestring(content))
    686              if self.version == 'creole3':
    687                  val_store = config_get_values(self.dico, 'creole', check_mandatory=False, ignore_autofreeze=True)
    688                  data.append(str(val_store))
    689              else:
    690                  # suite à correction du bug #1280 , on assigne manuellement les valeurs
    691                  # dans le ConfigParser du dictionnaire
    692                  for varname in self.dico.variables.keys():
    693                      var = self.dico.variables[varname]
    694                      if var.val == [] or var.val == ['']:
    695                          # la variable est hidden (ou une famille la contenant)
    696                          # on prend la valeur par défaut si pas de valeur
    697                          var.val = var.get_value(default=True)
    698                      # passage des chaines unicode en str
    699                      for list_val in [var.val, var.valprec, var.valdefault]:
    700                          for ind in range(len(list_val)):
    701                              if type(list_val[ind]) == unicode:
    702                                  list_val[ind] = list_val[ind].encode(charset)
    703                      # assignation des valeurs en interne dans le dictionnaire
    704                      if not self.dico.store.has_section(varname):
    705                          self.dico.store.add_section(varname)
    706                      self.dico.store.set(varname, 'val', var.val)
    707                      self.dico.store.set(varname, 'valprec', var.valprec)
    708                      self.dico.store.set(varname, 'valdefault', var.valdefault)
    709                  data.append(str(self.dico.store._sections))
    710              return data
    711          else:
    712              return [base64.encodestring(self.save())]
    713
    753
    754 -    def parsedico(self, separator=', '):
    755          # renvoie la configuration sous forme d'un dictionnaire {variable:valeur}
    756          data = {}
    757          if self.version == 'creole3':
    758              # passage en mode lecture pour activer les 'settings de base'
    759              data_dict = self.dico.make_dict(flatten=True)
    760              # mise en place des séparateurs
    761              for varname, vals in data_dict.items():
    762                  if not vals:
    763                      # cas spécifique : valeur None ou liste vide
    764                      vals = ''
    765                  elif isinstance(vals, Multi):
    766                      str_vals = []
    767                      for val in vals:
    768                          if type(val) == unicode:
    769                              str_vals.append(val.encode(charset))
    770                          else:
    771                              str_vals.append(str(val))
    772                      vals = separator.join(str_vals)
    773                  elif type(vals) == unicode:
    774                      vals = vals.encode(charset)
    775                  else:
    776                      vals = str(vals)
    777                  data[varname] = vals
    778          elif self.version != 'creole1':
    779              for varname in self.dico.variables.keys():
    780                  data[varname] = separator.join(self.dico.get_value(varname))
    781          else:
    782              for varname, values in self.dico.ParseDico().items():
    783                  data[varname] = values[0]
    784          return data
    785