def load(self, cr, module): """ Load a given module in the registry. At the Python level, the modules are already loaded, but not yet on a per-registry level. This method populates a registry with the given modules, i.e. it instanciates all the classes of a the given module and registers them in the registry. """ from .. import models loaded_models = OrderedSet() def mark_loaded(model): # recursively mark model and its children loaded_models.add(model._name) for child_name in model._inherit_children: mark_loaded(self[child_name]) lazy_property.reset_all(self) # Instantiate registered classes (via the MetaModel automatic discovery # or via explicit constructor call), and add them to the pool. for cls in models.MetaModel.module_to_models.get(module.name, []): # models register themselves in self.models model = cls._build_model(self, cr) mark_loaded(model) return map(self, loaded_models)
def setup_models(self, cr, partial=False): """ Complete the setup of models. This must be called after loading modules and before using the ORM. :param partial: ``True`` if all models have not been loaded yet. """ lazy_property.reset_all(self) # load custom models ir_model = self['ir.model'] cr.execute('SELECT * FROM ir_model WHERE state=%s', ('manual', )) for model_data in cr.dictfetchall(): ir_model._instanciate(cr, SUPERUSER_ID, model_data, {}) # prepare the setup on all models for model in self.models.itervalues(): model._prepare_setup(cr, SUPERUSER_ID) # do the actual setup from a clean state self._m2m = {} for model in self.models.itervalues(): model._setup_base(cr, SUPERUSER_ID, partial) for model in self.models.itervalues(): model._setup_fields(cr, SUPERUSER_ID) for model in self.models.itervalues(): model._setup_complete(cr, SUPERUSER_ID)
def setup_models(self, cr, partial=False): """ Complete the setup of models. This must be called after loading modules and before using the ORM. :param partial: ``True`` if all models have not been loaded yet. """ lazy_property.reset_all(self) env = openerp.api.Environment(cr, SUPERUSER_ID, {}) # load custom models ir_model = env['ir.model'] cr.execute('SELECT * FROM ir_model WHERE state=%s', ('manual', )) for model_data in cr.dictfetchall(): ir_model._instanciate(model_data) # prepare the setup on all models models = [env[model_name] for model_name in self.models] for model in models: model._prepare_setup() # do the actual setup from a clean state self._m2m = {} for model in models: model._setup_base(partial) for model in models: model._setup_fields(partial) for model in models: model._setup_complete()
def setup_models(self, cr, partial=False): """ Complete the setup of models. This must be called after loading modules and before using the ORM. :param partial: ``True`` if all models have not been loaded yet. """ lazy_property.reset_all(self) # load custom models ir_model = self['ir.model'] cr.execute('select model, transient from ir_model where state=%s', ('manual',)) for (model_name, transient) in cr.fetchall(): ir_model.instanciate(cr, SUPERUSER_ID, model_name, transient, {}) # prepare the setup on all models for model in self.models.itervalues(): model._prepare_setup(cr, SUPERUSER_ID) # do the actual setup from a clean state self._m2m = {} for model in self.models.itervalues(): model._setup_base(cr, SUPERUSER_ID, partial) for model in self.models.itervalues(): model._setup_fields(cr, SUPERUSER_ID) for model in self.models.itervalues(): model._setup_complete(cr, SUPERUSER_ID)
def load(self, cr, module): """ Load a given module in the registry. At the Python level, the modules are already loaded, but not yet on a per-registry level. This method populates a registry with the given modules, i.e. it instanciates all the classes of a the given module and registers them in the registry. """ models_to_load = [] # need to preserve loading order lazy_property.reset_all(self) # call hook before adding stuff in the registry for model in self.models.itervalues(): model._before_registry_update(cr, SUPERUSER_ID) # Instantiate registered classes (via the MetaModel automatic discovery # or via explicit constructor call), and add them to the pool. for cls in openerp.osv.orm.MetaModel.module_to_models.get( module.name, []): # models register themselves in self.models model = cls._build_model(self, cr) if model._name not in models_to_load: # avoid double-loading models whose declaration is split models_to_load.append(model._name) # call hook after models have been instantiated for model in self.models.itervalues(): model._after_registry_update(cr, SUPERUSER_ID) return [self.models[m] for m in models_to_load]
def setup_models(self, cr, partial=False): """ Complete the setup of models. This must be called after loading modules and before using the ORM. :param partial: ``True`` if all models have not been loaded yet. """ lazy_property.reset_all(self) env = openerp.api.Environment(cr, SUPERUSER_ID, {}) # load custom models ir_model = env['ir.model'] cr.execute('SELECT * FROM ir_model WHERE state=%s', ('manual',)) for model_data in cr.dictfetchall(): ir_model._instanciate(model_data) # prepare the setup on all models models = env.values() for model in models: model._prepare_setup() # do the actual setup from a clean state self._m2m = {} for model in models: model._setup_base(partial) for model in models: model._setup_fields(partial) for model in models: model._setup_complete()
def load(self, cr, module): """ Load a given module in the registry. At the Python level, the modules are already loaded, but not yet on a per-registry level. This method populates a registry with the given modules, i.e. it instanciates all the classes of a the given module and registers them in the registry. """ models_to_load = [] # need to preserve loading order lazy_property.reset_all(self) # call hook before adding stuff in the registry for model in self.models.itervalues(): model._before_registry_update(cr, SUPERUSER_ID) # Instantiate registered classes (via the MetaModel automatic discovery # or via explicit constructor call), and add them to the pool. for cls in openerp.osv.orm.MetaModel.module_to_models.get(module.name, []): # models register themselves in self.models model = cls._build_model(self, cr) if model._name not in models_to_load: # avoid double-loading models whose declaration is split models_to_load.append(model._name) # call hook after models have been instantiated for model in self.models.itervalues(): model._after_registry_update(cr, SUPERUSER_ID) return [self.models[m] for m in models_to_load]
def load(self, cr, module): """ Load a given module in the registry. At the Python level, the modules are already loaded, but not yet on a per-registry level. This method populates a registry with the given modules, i.e. it instanciates all the classes of a the given module and registers them in the registry. """ from .. import models models_to_load = [] # need to preserve loading order lazy_property.reset_all(self) # Instantiate registered classes (via the MetaModel automatic discovery # or via explicit constructor call), and add them to the pool. for cls in models.MetaModel.module_to_models.get(module.name, []): # models register themselves in self.models model = cls._build_model(self, cr) if model._name not in models_to_load: # avoid double-loading models whose declaration is split models_to_load.append(model._name) return [self.models[m] for m in models_to_load]