Merge

lodel/leapi/datahandlers/base_classes.py

             logger.warning('Class of the back_reference given is not an allowed class')
             return False
         value = datas[fname]
-        if not target_class.is_exist(value):
+        target_uidfield = target_class.uid_fieldname()[0]  # multi uid broken here
+        obj = target_class.get([(target_uidfield, '=', value)])
+        if len(obj) == 0:
             logger.warning('Object referenced does not exist')
             return False
-        # target_uidfield = target_class.uid_fieldname()[0] #multi uid broken here
-        # obj = target_class.get([(target_uidfield, '=', value)])
-        # if len(obj) == 0:
-        #    logger.warning('Object referenced does not exist')
-        #    return False
         return True
 
     # @brief Utility method designed to fetch referenced objects

lodel/leapi/leobject.py

         elif len(res) == 0:
             return None
         return res[0]
-
-    # @brief Checks if an object exists
-    @classmethod
-    def is_exist(cls, uid):
-        if cls.uid_fieldname() is None:
-            raise LodelFatalError(
-                "No uid defined for class %s" % cls.__name__)
-        from .query import is_exist
-        return is_exist(cls, uid)

lodel/leapi/query.py

 
 from lodel.context import LodelContext
 LodelContext.expose_modules(globals(), {
-    'lodel.leapi.exceptions': ['LeApiError', 'LeApiErrors', 
+    'lodel.leapi.exceptions': ['LeApiError', 'LeApiErrors',
         'LeApiDataCheckError', 'LeApiDataCheckErrors', 'LeApiQueryError',
         'LeApiQueryErrors'],
     'lodel.plugin.hooks': ['LodelHook'],
     'lodel.logger': ['logger']})
 
-##@brief Tool to check if a target_class's object exists and is stored
-#@param target_class : class where the object is supposed to be
-#@param uid : a unique id in target_class
-#@returns true if an object with unique id uid exists in target_class, false if not
-def is_exist(target_class, uid):
-	from .leobject import LeObject
-	if not inspect.isclass(target_class) or not issubclass(target_class, LeObject):
-		raise TypeError("target class has to be a child class of LeObject but %s was given"% target_class)
-	datasource = target_class._ro_datasource
-	return datasource.is_exist(target_class,uid)
-
-
 ##@todo check datas when running query
 class LeQuery(object):
-    
+
     ##@brief Hookname prefix
     _hook_prefix = None
     ##@brief arguments for the LeObject.check_data_value()
     #@return query result
     def _query(self, **datas):
         raise NotImplementedError("Asbtract method")
-    
+
     ##@return a dict with query infos
     def dump_infos(self):
         return {'target_class': self._target_class}
         self.subqueries = None
         query_filters = [] if query_filters is None else query_filters
         self.set_query_filter(query_filters)
-    
+
     ##@brief Abstract FilteredQuery execution method
     #
     # This method takes care to execute subqueries before calling super execute
     #<pre>contributeur IN (1,2,3,5)</pre> will be transformed into :
     #<pre>(
     #       (
-    #           contributeur, 
+    #           contributeur,
     #           {
     #               auteur: 'lodel_id',
     #               traducteur: 'lodel_id'
             raise LeApiQueryError("Trying to create an insert query on an \
 abstract LeObject : %s" % target_class)
         super().__init__(target_class)
-    
+
     ## @brief Implements an insert query operation, with only one insertion
     # @param datas : datas to be inserted
     def _query(self, datas):
     #@todo change strategy with instance update. We have to accept datas for
     #the execute method
     def __init__(self, target, query_filters=None):
-        ##@brief This attr is set only if the target argument is an 
+        ##@brief This attr is set only if the target argument is an
         #instance of a LeObject subclass
         self.__leobject_instance_datas = None
         target_class = target
             #Instance update
             #Building query_filter
             filters = [(
-                uid_name, 
-                '=', 
+                uid_name,
+                '=',
                 str(self.__leobject_instance_datas[uid_name]))]
             res = self._rw_datasource.update(
                 self._target_class, filters, [],
         l_datas=self._ro_datasource.select(
             target = self._target_class,
             field_list = fl,
-            filters = self._query_filter[0], 
-            relational_filters = self._query_filter[1], 
-            order = self._order, 
-            group = self._group, 
-            limit = self._limit, 
+            filters = self._query_filter[0],
+            relational_filters = self._query_filter[1],
+            order = self._order,
+            group = self._group,
+            limit = self._limit,
             offset = self._offset)
         return l_datas
 
     ##@return a dict with query infos
     def dump_infos(self):
         ret = super().dump_infos()
-        ret.update({  'field_list' : self._field_list, 
-                        'order' : self._order, 
-                        'group' : self._group, 
-                        'limit' : self._limit, 
-                        'offset': self._offset, 
+        ret.update({  'field_list' : self._field_list,
+                        'order' : self._order,
+                        'group' : self._group,
+                        'limit' : self._limit,
+                        'offset': self._offset,
        })
         return ret
 
                 res %= (n, subq)
         res += ">"
         return res
-
-

lodel/plugin/plugins.py

 #
 #@todo Check if the symlink in the lodelcontext dir is obsolete !!!
 #@warning The plugins dir is at two locations : in lodel package and in
-#instance directory. Some stuff seems to still needs plugins to be in 
+#instance directory. Some stuff seems to still needs plugins to be in
 #the instance directory but it seems to be a really bad idea...
 
 ##@defgroup plugin_init_specs Plugins __init__.py specifications
 
 ##@brief List storing the mandatory variables expected in a plugin __init__.py
 #file
-MANDATORY_VARNAMES = [PLUGIN_NAME_VARNAME, LOADER_FILENAME_VARNAME, 
+MANDATORY_VARNAMES = [PLUGIN_NAME_VARNAME, LOADER_FILENAME_VARNAME,
     PLUGIN_VERSION_VARNAME]
 
 ##@brief Default plugin type
         elif len(args) > 3:
             raise PluginError("Expected between 1 and 3 positional arguments \
 but %d arguments found" % len(args))
-        else: 
+        else:
             for i,v in enumerate(args):
                 self.__version[i] = int(v)
         #Checks that version numbering is correct
     @property
     def revision(self):
         return self.__version[2]
-    
+
     ##@brief Check and prepare comparisoon argument
     #@return A PluginVersion instance
     #@throw PluginError if invalid argument provided
                 raise PluginError("Cannot compare argument '%s' with \
 a PluginVerison instance" % other)
         return other
-    
+
     ##@brief Allow accessing to versions parts using interger index
     #@param key int : index
     #@return major for key == 0, minor for key == 1, revision for key == 2
 #
 #Automatic script registration on child class declaration
 class MetaPlugType(type):
-        
+
     ##@brief Dict storing all plugin types
     #
     #key is the _type_conf_name and value is the class
             return
         #Regitering a new plugin type
         MetaPlugType._all_ptypes[self._type_conf_name] = self
-    
+
     ##@brief Accessor to the list of plugin types
     #@return A copy of _all_ptypes attribute (a dict with typename as key
     #and the class as value)
     @classmethod
     def all_types(cls):
         return copy.copy(cls._all_ptypes)
-    
+
     ##@brief Accessor to the list of plugin names
     #@return a list of plugin name
     @classmethod
     def all_ptype_names(cls):
         return list(cls._all_ptypes.keys())
-    
+
     ##@brief Given a plugin type name return a Plugin child class
     #@param ptype_name str : a plugin type name
     #@return A Plugin child class
         if ptype_name not in cls._all_ptypes:
             raise PluginError("Unknown plugin type '%s'" % ptype_name)
         return cls._all_ptypes[ptype_name]
-    
+
     ##@brief Call the clear classmethod on each child classes
     @classmethod
     def clear_cls(cls):
         for pcls in cls._all_ptypes.values():
             pcls.clear_cls()
-        
+
 
 ##@brief Handle plugins
 #@ingroup lodel2_plugins
 # 2. Settings fetch all confspecs
 # 3. the loader call load_all to register hooks etc
 class Plugin(object, metaclass=MetaPlugType):
-    
+
     ##@brief Stores Plugin instances indexed by name
     _plugin_instances = dict()
-    
+
     ##@brief Attribute used by load_all and load methods to detect circular
     #dependencies
     _load_called = []
 
     ##@brief Attribute that stores plugins list from discover cache file
     _plugin_list = None
-    
+
     #@brief Designed to store, in child classes, the confspec indicating \
     #where plugin list is stored
     _plist_confspecs = None
     # @param plugin_name str : plugin name
     # @throw PluginError
     def __init__(self, plugin_name):
-        
+
         ##@brief The plugin name
         self.name = plugin_name
         ##@brief The plugin package path
         self.path = self.plugin_path(plugin_name)
-        
+
         ##@brief Stores the plugin module
         self.module = None
         ##@brief Stores the plugin loader module
         self.__confspecs = dict()
         ##@brief Boolean flag telling if the plugin is loaded or not
         self.loaded = False
-        
+
         # Importing __init__.py infos in it
         plugin_module = self.module_name()
         self.module = LodelContext.module(plugin_module)
     #@throw PluginError if the filename was not valid
     #@todo Some strange things append :
     #when loading modules in test self.module.__name__ does not contains
-    #the package... but in prod cases the self.module.__name__ is 
+    #the package... but in prod cases the self.module.__name__ is
     #the module fullname... Just a reminder note to explain the dirty
     #if on self_modname
     def _import_from_init_var(self, varname):
         base_mod = '.'.join(filename.split('.')[:-1])
         module_name = self_modname+"."+base_mod
         return importlib.import_module(module_name)
-   
+
     ##@brief Return associated module name
     def module_name(self):
-        path_array = self.path.split('/')
-        if not self.path.startswith('./plugins'):
-            raise PluginError("Bad path for plugin %s : %s" % (
-                self.name, self.path))
-        return '.'.join(['lodel'] + path_array[path_array.index('plugins'):])
+        #WOOT WE LOVE DIRTY WORKAROUNDS !!!
+        return "lodel.plugins."+os.path.basename(self.path)
+        #END OF DIRTY WORKAROUND
 
     ##@brief Check dependencies of plugin
     #@return A list of plugin name to be loaded before
             raise PluginError(  "Bad dependencie for '%s' :"%self.name,
                                 ', '.join(errors))
         return result
-    
+
     ##@brief Check if the plugin should be activated
     #
     #Try to fetch a function called @ref ACTIVATE_METHOD_NAME in __init__.py
             logger.debug(msg)
             test_fun = lambda:True
         return test_fun()
-        
+
     ##@brief Load a plugin
     #
-    #Loading a plugin means importing a file. The filename is defined in the 
+    #Loading a plugin means importing a file. The filename is defined in the
     #plugin's __init__.py file in a LOADER_FILENAME_VARNAME variable.
     #
     #The loading process has to take care of other things :
             raise PluginError("Circular dependencie in Plugin detected. Abording")
         else:
             self._load_called.append(self.name)
-        
+
         #Dependencie load
         for dependencie in self.check_deps():
             activable = dependencie.activable()
                     plugin_name = self.name,
                     dep_name = dependencie.name,
                     reason = activable)
-        
+
         #Loading the plugin
         try:
             self.__loader_module = self._import_from_init_var(LOADER_FILENAME_VARNAME)
             raise PluginError(msg)
         logger.debug("Plugin '%s' loaded" % self.name)
         self.loaded = True
-    
+
     ##@brief Returns the loader module
     #
     #Accessor for the __loader__ python module
             raise PluginError(msg)
         LodelHook.call_hook(
             "lodel2_plugins_loaded", cls, cls._plugin_instances)
-   
+
 
     ##@return a copy of __confspecs attr
     @property
         return res
 
     ##@brief Register a new plugin
-    # 
+    #
     #@param plugin_name str : The plugin name
     #@return a Plugin instance
     #@throw PluginError
             msg = "No plugin named '%s' loaded"
             msg %= plugin_name
             raise PluginError(msg)
-    
+
     ##@brief Given a plugin name returns the plugin path
     # @param plugin_name str : The plugin name
     # @return the plugin directory path
             pass
 
         return plist[plugin_name]['path']
-    
+
     ##@brief Return the plugin module name
     #
     #This module name is the "virtual" module where we imported the plugin.
         return "%s.%s" % (VIRTUAL_PACKAGE_NAME, plugin_name)
 
     ##@brief Start the Plugin class
-    # 
+    #
     # Called by Settings.__bootstrap()
     #
     # This method load path and preload plugins
     def start(cls, plugins):
         for plugin_name in plugins:
             cls.register(plugin_name)
-    
+
     ##@brief Attempt to "restart" the Plugin class
     @classmethod
     def clear(cls):
         if cls._load_called != []:
             cls._load_called = []
         MetaPlugType.clear_cls()
-    
+
     ##@brief Designed to be implemented by child classes
     @classmethod
     def clear_cls(cls):
         pass
-    
+
     ##@brief Reccursively walk throught paths to find plugin, then stores
     #found plugin in a static var
     #
         result = dict()
         for pinfos in tmp_res:
             pname = pinfos['name']
-            if (    pname in result 
+            if (    pname in result
                     and pinfos['version'] > result[pname]['version'])\
                 or pname not in result:
                 result[pname] = pinfos
                 pass
         cls._plugin_list = result
         return result
-    
+
     ##@brief Return discover result
     #@param refresh bool : if true invalidate all plugin list cache
     #@note If discover cache file not found run discover first
             'version': PluginVersion(pversion),
             'path': path,
             'type': ptype}
-    
+
     ##@brief Import init file from a plugin path
     #@param path str : Directory path
     #@return a tuple (init_module, module_name)
     ##@brief Decorator constructor
     #@param component_name str : the name of the component to enhance
     #@param method_name str : the name of the method to inject (if None given
-    #@param method_type int : take value in one of 
+    #@param method_type int : take value in one of
     #CustomMethod::INSTANCE_METHOD CustomMethod::CLASS_METHOD or
     #CustomMethod::STATIC_METHOD
     #use the function name
             raise ValueError("Excepted value for method_type was one of \
 CustomMethod::INSTANCE_METHOD CustomMethod::CLASS_METHOD or \
 CustomMethod::STATIC_METHOD, but got %s" % self._type)
-    
+
     ##@brief called just after __init__
     #@param fun function : the decorated function
     def __call__(self, fun):
                 self._custom_methods[self._comp_name].__module__))
         self._fun = fun
         self._custom_methods[self._comp_name].append(self)
-    
+
     ##@brief Textual representation
     #@return textual representation of the CustomMethod instance
     def __repr__(self):
             classname = self._comp_name,
             module_name = self._fun.__module__,
             fun_name = self._fun.__name__)
-    
+
     ##@brief Return a well formed method
     #
     #@note the type of method depends on the _type attribute
 
     ##@brief Handle custom method dynamic injection in LeAPI dyncode
     #
-    #Called by lodel2_dyncode_loaded hook defined at 
+    #Called by lodel2_dyncode_loaded hook defined at
     #lodel.plugin.core_hooks.lodel2_plugin_custom_methods()
     #
     #@param cls

lodel/plugins/Makefile.am

 
 install-data-hook:
 	mkdir -p ${DESTDIR}$(pluginsdir); cp -R * ${DESTDIR}$(pluginsdir) && rm ${DESTDIR}$(pluginsdir)/Makefile* ;\
-	cd ${DESTDIR}; \
-	mkdir -p $(lodel2confdir); \
+	mkdir -p ${DESTDIR}$(lodel2confdir); \
 	if [ ! -d ${DESTDIR}$(lodel2confdir)/plugins ]; \
     then \
         ln -rs -t ${DESTDIR}$(lodel2confdir) $(pluginsdir); \

lodel/plugins/webui/interface/controllers/admin.py

 ##@brief These functions are called by the rules defined in ../urls.py
 ## To administrate the instance of the editorial model
 
-##@brief Controller's function to redirect on the home page of the admin 
+##@brief Controller's function to redirect on the home page of the admin
 # @param request : the request (get or post)
 # @note the response is given in a html page called in get_response_function
 def index_admin(request):
     # We have to be identified to admin the instance
-    # temporary, the acl will be more restrictive 
+    # temporary, the acl will be more restrictive
     #if WebUiClient.is_anonymous():
     #    return get_response('users/signin.html')
     return get_response('admin/admin.html')
 
-##@brief Controller's function to update an object of the editorial model 
+##@brief Controller's function to update an object of the editorial model
 # @param request : the request (get or post)
 # @note the response is given in a html page (in templates/admin) called in get_response_function
 def admin_update(request):
     #if WebUiClient.is_anonymous():
     #    return get_response('users/signin.html')
     msg=''
-    
+
     datas = process_form(request)
     if not(datas is False):
         if 'lodel_id' not in datas:
         except LeApiDataCheckErrors as e:
             raise HttpErrors(
                 title='Form validation errors', errors = e._exceptions)
-            
-            
+
+
 
     # Display of the form with the object's values to be updated
     if 'classname' in request.GET:
             raise HttpException(400)
         logger.warning('Composed uids broken here')
         uid_field = target_leo.uid_fieldname()[0]
-    
+
     # We need the uid of the object
     test_valid = 'lodel_id' in request.GET \
         and len(request.GET['lodel_id']) == 1
     else:
         # Check if the object actually exists
         # We get it from the database
-        if not target_leo.is_exist(lodel_id):
+        query_filters = list()
+        query_filters.append((uid_field,'=',lodel_id))
+        obj = target_leo.get(query_filters)
+        if len(obj) == 0:
             raise HttpException(404)
     return get_response('admin/admin_edit.html', target=target_leo, lodel_id =lodel_id)
 
-##@brief Controller's function to create an object of the editorial model 
+##@brief Controller's function to create an object of the editorial model
 # @param request : the request (get or post)
 # @note the response is given in a html page (in templates/admin) called in get_response_function
 def admin_create(request):
         raise HttpException(400)
     return get_response('admin/admin_create.html', target=target_leo)
 
-##@brief Controller's function to delete an object of the editorial model 
+##@brief Controller's function to delete an object of the editorial model
 # @param request : the request (get)
 # @note the response is given in a html page (in templates/admin) called in get_response_function
 def admin_delete(request):
             raise HttpException(400)
         logger.warning('Composed uids broken here')
         uid_field = target_leo.uid_fieldname()[0]
-        
+
     # We also need the uid of the object to delete
     test_valid = 'lodel_id' in request.GET \
         and len(request.GET['lodel_id']) == 1
             msg = 'Object successfully deleted';
     else:
             msg = 'Oops something wrong happened...object still here'
-            
+
     return get_response('admin/admin_delete.html', target=target_leo, lodel_id =lodel_id, msg = msg)
 
-        
-        
+
+
 def admin_classes(request):
     # We have to be identified to admin the instance
     # temporary, the acl will be more restrictive
     #if WebUiClient.is_anonymous():
     #    return get_response('users/signin.html')
     return get_response('admin/list_classes_delete.html', my_classes = dyncode.dynclasses)
-    
+
 def admin_class(request):
     # We have to be identified to admin the instance
     # temporary, the acl will be more restrictive
                 if hasattr(dh, 'default'):
                     value = dh.default
                 else:
-                    #if not explicit default value, enforcing default as 
+                    #if not explicit default value, enforcing default as
                     #an empty list
                     value = []
             else:
         del(res)
         raise HttpErrors(errors, title="Form validation error")
     return res
-

lodel/plugins/webui/interface/controllers/listing.py

 def issue(request):
     lodel_id = request.GET['lodel_id']
     return get_response('listing/issue.html', lodel_id=lodel_id[0], my_classes=dyncode )
-    
+
 ##@brief Controller's function to display a type (class) of the editorial model
 # @param request : the request (get or post)
 # @note the response is given in a html page called in get_response_function
             classname = None
     else:
         raise HttpException(400)
-    
+
     logger.warning('Composed uids broken here')
     uid_field = target_leo.uid_fieldname()[0]
 
     if not test_valid:
         raise HttpException(400)
     else:
-        if not target_leo.is_exist(lodel_id):
+        query_filters = list()
+        query_filters.append((uid_field,'=',lodel_id))
+        obj = target_leo.get(query_filters)
+        if len(obj) == 0:
             raise HttpException(404)
     return get_response('listing/show_object.html', lodel_id=lodel_id, classname=classname)
 
             classname = None
     else:
         raise HttpException(400)
-    
+
     logger.warning('Composed uids broken here')
     uid_field = target_leo.uid_fieldname()[0]
 
     if not test_valid:
         raise HttpException(400)
     else:
-        if not target_leo.is_exist(lodel_id):
+        query_filters = list()
+        query_filters.append((uid_field,'=',lodel_id))
+        obj = target_leo.get(query_filters)
+        if len(obj) == 0:
             raise HttpException(404)
 
     return get_response('listing/show_object_detailled.html', lodel_id=lodel_id, classname=classname)

lodel/plugins/webui/templates/admin/editable_component.html

             <input id="{{fieldname}}" name="field_input_{{fieldname}}" class="form-control" type="password"  value="{{sval}}" >
     {% elif field.base_type == 'char' or field.base_type == 'int' %}
 		<input id="{{fieldname}}" class="form-control" name="field_input_{{fieldname}}" type="text" value="{{value}}" >
+		{% elif field.base_type == 'text' %}
+			<textarea class="form-control" name="field_input_{{fieldname}}">{{value}}</textarea>
+		{% elif field.base_type == 'datetime' %}
+			<input class="form-control" type="date" value="{{value}}" name="field_input_{{fieldname}}">
     {% elif field.base_type == 'ref' %}
         {% if value is iterable %}
             {% set sval=value|join(',') %}

progs/create_datas_simpleem.sh → progs/create_data_simpleem.sh

 
 usage() {
     echo -e "Usage : $0 host_of_server instance_name host_of_db number_of_iterations >&2"
-    echo -e "Example : create_datas locahost instance_00001 localhost:28015 1000"
-    echo -e "Example : create_datas locahost instance_00001 localhost 1000"
+    echo -e "Example : create_data_simpleem locahost instance_00001 localhost:28015 1000"
+    echo -e "Example : create_data_simpleem locahost instance_00001 localhost 1000"
     exit 1
 }
 
 N=$4
 HOSTDB=$3
 dbname=lodel2_$instance
-dbuser=admin 
+dbuser=admin
 dbpwd=pass
 curl_options='--silent -o /dev/null -s -w %{url_effective};%{http_code};%{time_connect};%{time_starttransfer};%{time_total}\n'
 
     FN=$(lenmax=20;wcount=1; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/")
     LC=''
     curl -o /dev/null -s -d "field_input_lastname=$LN&field_input_firstname=$FN&field_input_linked_containers=$LC&classname=Person" http://$host/$instance/admin/create?classname=Person
-    
+
     # Classe User
     PWD='pwgen 10'
     LOGIN="${FN,,}$(printf "%d" $RANDOM)"
     curl -o /dev/null -s -d "field_input_lastname=$LN&field_input_firstname=$FN&field_input_password=$PWD&field_input_login=$LOGIN&classname=User" http://$host/$instance/admin/create?classname=User
-    
+
     # Classe Entry, champs à remplir : name, description, role, linked_texts
     ENLT='' #$(printf "use $dbname\nDBQuery.shellBatchSize = 30000\n db.Article.find({}, {lodel_id:1, _id:0})" | mongo  $HOSTDB/admin -u $dbuser -p $dbpwd | sed "1,3d" | sed -e "s/{ \"lodel_id\" : //g" | sed -e "s/ }//g" | shuf | head -n 3; )
     ENROLE=$(shuf -e 'geography' 'subject' 'keywords' | head -n 1)
         fi
     done
     COLLD=$tmp
-    COLT=$(lenmax=100;wcount=20; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/") 
-    COLST=$(lenmax=100;wcount=20; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/") 
+    COLT=$(lenmax=100;wcount=20; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/")
+    COLST=$(lenmax=100;wcount=20; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/")
     LG=$(shuf -e 'fr' 'en' 'es' 'ger' 'it'| head -n 1)
-    DESC=$(lenmax=500;wcount=100; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/") 
-    PBN=$(lenmax=500;wcount=100; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/") 
+    DESC=$(lenmax=500;wcount=100; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/")
+    PBN=$(lenmax=500;wcount=100; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/")
     ISSN=$(</dev/urandom tr -dc 0-9 | head -c8;echo;)
     curl $curl_options -d "field_input_title=$COLT&field_input_subtitle=$COLST&field_input_language=$LG&field_input_linked_directors=$COLLD&field_input_description=$DESC&field_input_publisher_note=$PBN&field_input_issn=$ISSN&classname=Collection" http://$host/$instance/admin/create?classname=Collection
     collection=$(printf "use $dbname\n db.Collection.find({}, {lodel_id:1, _id:0}).sort({_id:-1}).limit(1)" | mongo  $HOSTDB/admin -u $dbuser -p $dbpwd | sed "1,3d" | sed -e "s/{ \"lodel_id\" : //g" | sed -e "s/ }//g" | sed "\$d";)
         NB=$(shuf -e '25' '30' '35' '40' '45' '50' '55' '60' '65' | head -n 1) # Nombre de textes pour le numéro
         NBR=$(($NB/3)) # Nombre de reviews
         NBA=$(($NBR*2)) # Nombre d'articles
-        
+
         # Classe Issue, champs à remplir : title, subtitle, language, linked_directors, description, publisher_note, isbn, print_isbn, number, cover, print_pub_date, e_pub_date, abstract, collection, linked_parts, linked_texts
         NBLD=$(shuf -e '1' '2' '3' '4' | head -n 1)
         directors=$(printf "use $dbname\n DBQuery.shellBatchSize = 30000\n db.Person.find({}, {lodel_id:1, _id:0})" | mongo  $HOSTDB/admin -u $dbuser -p $dbpwd | sed "1,4d" | sed -e "s/{ \"lodel_id\" : //g" | sed -e "s/ }//g" | sed "\$d" | shuf | head -n $NBLD;)
             fi
         done
         ISSLD=$tmp
-        ISST=$(lenmax=100;wcount=20; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/") 
-        ISSST=$(lenmax=100;wcount=20; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/") 
+        ISST=$(lenmax=100;wcount=20; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/")
+        ISSST=$(lenmax=100;wcount=20; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/")
         LG=$(shuf -e 'fr' 'en' 'es' 'ger' 'it'| head -n 1)
-        DESC=$(lenmax=500;wcount=100; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/") 
-        PBN=$(lenmax=500;wcount=100; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/") 
+        DESC=$(lenmax=500;wcount=100; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/")
+        PBN=$(lenmax=500;wcount=100; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/")
         ISBN=$(</dev/urandom tr -dc 0-9 | head -c10;echo;)
         PISBN=$(</dev/urandom tr -dc 0-9 | head -c10;echo;)
-        ISSNU=$(lenmax=30;wcount=10; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/") 
-        ISSCOV=$(lenmax=100;wcount=15; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/") 
+        ISSNU=$(lenmax=30;wcount=10; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/")
+        ISSCOV=$(lenmax=100;wcount=15; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/")
         M=$(shuf -e '01' '02' '03' '04' '05' '06' '07' '08' '09' '10' '11' '12' | head -n 1)
         JJ=$(shuf -e '01' '02' '03' '04' '05' '06' '07' '08' '09' '10' '11' '12' '13' '14' '15' '16' '17' '18' '19' '20' '21' '22' '23' '24' '25' '26' '27' '28'  | head -n 1)
         AA=$(shuf -e '2012' '2005' '2010' '2015' '2016'| head -n 1)
         ISSLTXT=''
         curl $curl_options -d "field_input_title=$ISST&field_input_subtitle=$ISSST&field_input_language=$LG&field_input_linked_directors=$ISSLD&field_input_description=$DESC&field_input_publisher_note=$PBN&field_input_isbn=$ISBN&field_input_print_isbn=$PISBN&field_input_number=$ISSNU&field_input_cover=$ISSCOV&field_input_print_pub_date=$PPDATE&field_input_e_pub_date=$EPDATE&field_input_abstract=$ISSAB&field_input_collection=$collection&field_input_linked_parts=$ISSLPA&field_input_linked_texts=$ISSLTXT&classname=Issue" http://$host/$instance/admin/create?classname=Issue
         issue=$(printf "use $dbname\n db.Issue.find({}, {lodel_id:1, _id:0}).sort({_id:-1}).limit(1)" | mongo  $HOSTDB/admin -u $dbuser -p $dbpwd | sed "1,3d" | sed -e "s/{ \"lodel_id\" : //g" | sed -e "s/ }//g" | sed "\$d" )
-       
+
         # On entre les textes correspondants aux numéros indépendemment des parts
         NBT=$(shuf -e '2' '3' '4' '5' '6' '8' | head -n 1)
         for i in `eval echo {1..$NBT}`;
                 fi
             done
             PALD=$tmp
-            PAT=$(lenmax=100;wcount=20; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/") 
-            PAST=$(lenmax=100;wcount=20; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/") 
+            PAT=$(lenmax=100;wcount=20; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/")
+            PAST=$(lenmax=100;wcount=20; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/")
             LG=$(shuf -e 'fr' 'en' 'es' 'ger' 'it'| head -n 1)
-            DESC=$(lenmax=500;wcount=100; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/") 
-            PBN=$(lenmax=500;wcount=100; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/") 
+            DESC=$(lenmax=500;wcount=100; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/")
+            PBN=$(lenmax=500;wcount=100; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/")
             issue=$(printf "use $dbname\nDBQuery.shellBatchSize = 1000\n db.Issue.find({collection:$collection}, {lodel_id:1, _id:0})" | mongo  $HOSTDB/admin -u $dbuser -p $dbpwd | sed "1,4d" | sed -e "s/{ \"lodel_id\" : //g" | sed -e "s/ }//g" | sed "\$d" | shuf | head -n 1;)
             PALTXT=''
             PALP=''
             curl $curl_options -d "field_input_title=$PAT&field_input_subtitle=$PAST&field_input_language=$LG&field_input_linked_directors=$PALD&field_input_description=$DESC&field_input_publisher_note=$PBN&field_input_publication=$issue&field_input_linked_parts=$PALP&field_input_linked_texts=$PALTXT&classname=Part" http://$host/$instance/admin/create?classname=Part
             part=$(printf "use $dbname\n db.Part.find({}, {lodel_id:1, _id:0}).sort({_id:-1}).limit(1)" | mongo  $HOSTDB/admin -u $dbuser -p $dbpwd | sed "1,3d" | sed -e "s/{ \"lodel_id\" : //g" | sed -e "s/ }//g" | sed "\$d" )
-       
+
             # On entre les textes correspondants aux  parts
             NBPANBT=$(shuf -e '2' '3' '4' | head -n 1)
             for i in `eval echo {1..$NBPANBT}`;
                         fi
                 done
                 PALD=$tmp
-                PAT=$(lenmax=100;wcount=20; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/") 
-                PAST=$(lenmax=100;wcount=20; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/") 
+                PAT=$(lenmax=100;wcount=20; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/")
+                PAST=$(lenmax=100;wcount=20; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/")
                 LG=$(shuf -e 'fr' 'en' 'es' 'ger' 'it'| head -n 1)
-                DESC=$(lenmax=500;wcount=100; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/") 
-                PBN=$(lenmax=500;wcount=100; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/") 
+                DESC=$(lenmax=500;wcount=100; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/")
+                PBN=$(lenmax=500;wcount=100; rlenmax=$(expr $lenmax - 1); echo $(shuf /usr/share/dict/words | head -n $wcount | tr -s "\n" " ") | sed -E "s/^(.{$rlenmax}).*$/\1/")
                 PALTXT=''
                 PALP=''
                 curl $curl_options -d "field_input_title=$PAT
                 &field_input_description=$DESC&field_input_publisher_note=$PBN&field_input_publication=$part
                 &field_input_linked_parts=$PALP&field_input_linked_texts=$PALTXT&classname=Part" http://$host/$instance/admin/create?classname=Part
                 part=$(printf "use $dbname\n db.Part.find({}, {lodel_id:1, _id:0}).sort({_id:-1}).limit(1)" | mongo  $HOSTDB/admin -u $dbuser -p $dbpwd | sed "1,3d" | sed -e "s/{ \"lodel_id\" : //g" | sed -e "s/ }//g" | sed "\$d" )
-       
+
                 # On entre les textes correspondants aux numéros indépendemment des parts
                 for i in `eval echo {1..$NBA}`;
                 do
             done
         done
     done
-done
+done