def connect(self, cr, uid, server_id, context=None): if isinstance(server_id, (list, tuple)): server_id = server_id[0] if get_mode(): raise Warning(_( "Can not Connect to server because Odoo is in %s mode.") % ( get_mode())) return super(fetchmail_server, self).connect( cr, uid, server_id=server_id, context=context)
def send_email(self, cr, uid, message, mail_server_id=None, smtp_server=None, smtp_port=None, smtp_user=None, smtp_password=None, smtp_encryption=None, smtp_debug=False, context=None): # TODO # if we raise ValidationError then can not install modules with demo # data, we should find a way to raise message when sending from # interface # raise ValidationError(_( if get_mode(): _logger.warning( _("You Can not Send Mail Because Odoo is not in Production " "mode")) return True return super(ir_mail_server, self).send_email(cr, uid, message, mail_server_id=mail_server_id, smtp_server=smtp_server, smtp_port=smtp_port, smtp_user=smtp_user, smtp_password=smtp_password, smtp_encryption=smtp_encryption, smtp_debug=smtp_debug, context=None)
def button_try_not_prod(self): if not get_mode(): raise ValidationError( _('You can not try a category on a production database')) self.contracted_product = 'try_not_prod' # refresh modules data self.env['ir.module.module'].update_uninstallable_state() # marcamos a instalar por categoria self.env['ir.module.module'].set_to_install_from_category() # ejecutamos instalacion y actualizacion self.env['base.module.upgrade'].sudo().upgrade_module()
def _cron_update_adhoc_modules(self): if get_mode(): _logger.info( 'Update adhoc modules is disable by server_mode. ' 'If you want to enable it you should remove develop or test ' 'value for server_mode key on openerp server config file') return False try: self.get_adhoc_modules_data() except Exception, e: _logger.error("Error Updating ADHOC Modules Data. Error:\n%s" % (e))
def print_document(self, report, content, format, copies=1): """ Print a file Format could be pdf, qweb-pdf, raw, ... """ if len(self) != 1: _logger.error('Google cloud print called with %s but singleton is' 'expeted. Check printers configuration.' % self) return super(PrintingPrinter, self).print_document(report, content, format, copies=copies) # self.ensure_one() if self.printer_type != 'gcp': return super(PrintingPrinter, self).print_document(report, content, format, copies=copies) if get_mode(): _logger.warning( _("You Can not Send Mail Because Odoo is not in Production " "mode")) return True fd, file_name = mkstemp() try: os.write(fd, content) finally: os.close(fd) options = self.print_options(report, format, copies) _logger.debug('Sending job to Google Cloud printer %s' % (self.system_name)) # atrapamos el error y lo mandamos por el log para que no de piedrazo # y posiblemente rompa interfaz try: self.env['google.cloudprint.config'].submit_job( self.uri, format, file_name, options, ) except Exception, e: # access_token = self.get_access_token() _logger.error( 'Could not submit job to google cloud. This is what we get:\n' '%s' % e)
def update_adhoc_categories(self, client): contract_id = self._context.get('contract_id') fields = [ 'name', 'code', 'parent_id', 'visibility', 'description', 'sequence', ] updated_records = local_model = self.env['adhoc.module.category'] remote_model = client.model('adhoc.module.category.server') remote_datas = remote_model.search_read([], fields, 0, None, 'parent_left') for remote_data in remote_datas: # we dont wont or need id category_id = remote_data.pop('id') parent_data = remote_data.pop('parent_id') if parent_data: parent_code = remote_model.search_read( [('id', '=', parent_data[0])], ['code'])[0]['code'] parent = local_model.search([('code', '=', parent_code)], limit=1) remote_data['parent_id'] = parent.id local_record = local_model.search( [('code', '=', remote_data.get('code'))], limit=1) if remote_data['visibility'] in [ 'product_required', 'product_invisible' ]: remote_data['contracted_product'] = ( remote_model.get_related_contracted_product( category_id, contract_id)) # hacemos el commit para que no de error adhoc contra adhoc self._cr.commit() if local_record: # we dont deactivate categories that are being tryind if # server_mode is not production if ('contracted_product' in remote_data and not remote_data.get('contracted_product') and get_mode() and local_record.contracted_product == 'try_not_prod'): remote_data.pop('contracted_product') local_record.write(remote_data) else: # local_record.create(remote_data) local_record = local_record.create(remote_data) updated_records += local_record # remove records that has not been updated (they dont exist anymore) (local_model.search([]) - updated_records).unlink()
def _cron_scan_repositories(self): if get_mode(): _logger.info( 'Scan repositories is disable by server_mode. ' 'If you want to enable it you should remove develop or test ' 'value for server_mode key on openerp server config file') return False for repository in self.search([('auto_update', '=', True)]): try: repository.scan_repository() self._cr.commit() except: # TODO we should set a last update in each repository and # make cron run more frequently _logger.error("Error updating repository %s" % (repository.name))
def cron_check_databases(self): # TODO mejorar y solo verificar las que no fueron verificadas en el # ultimo intervalo de cron if get_mode(): _logger.info( 'Check databases cron is disable by server_mode. ' 'If you want to enable it you should remove develop or test ' 'value for server_mode key on openerp server config file') return False databases = self.with_context(do_not_raise=True).search([ ('check_database', '=', True), ('state', '!=', 'inactive'), ]) for db in databases: db.refresh_overall_state() db._cr.commit() return True
def check_automatic_backup_enable(self): """ Para que se hagan backups al hacer fix on con el cron, se requiere: 1. Que no haya server mode definido 2. Que haya un parametro database.backups.enable = 'True' """ if get_mode(): _logger.info( 'Backups are disable by server_mode test or develop. ' 'If you want to enable it you should remove develop or test ' 'value for server_mode key on openerp server config file') return False backups_enable = self.env['ir.config_parameter'].get_param( 'database.backups.enable') if backups_enable != 'True': _logger.info( 'Backups are disable. If you want to enable it you should add ' 'the parameter database.backups.enable with value True') return False return True
def cron_database_backup(self): """If backups enable in ir parameter, then: * Check if backups are enable * Make backup according to period defined * """ if get_mode(): _logger.warning( 'Backups are disable by server_mode test or develop.\ If you want to enable it you should remove develop or test\ value for server_mode key on openerp server config file') return False backups_enable = self.env['ir.config_parameter'].get_param( 'database.backups.enable') if backups_enable != 'True': _logger.warning( 'Backups are disable. If you want to enable it you should add\ the parameter database.backups.enable with value True') return False _logger.info('Running backups cron') current_date = fields.Datetime.now() # get databases databases = self.search([ ('backup_next_date', '<=', current_date), ]) # make bakcup # we make a loop to commit after each backup for database in databases: database.database_backup( bu_type='automatic', backup_format=database.backup_format) database._cr.commit() # clean databases databases = self.search([]) databases.database_backup_clean() # clean databas information self.update_backups_data()
def check_credentials(self, password): """ Si el usuario es admin permitimos login con pass de instancia tmb Si el usuario es otro, permitimos con pass intancia o admin solo si: * no produccion * producción y allow on production True """ passkey_allowed = True if not get_mode(): if not literal_eval( self.env['ir.config_parameter'].sudo().get_param( 'auth_admin_passkey.allow_on_production', 'True')): passkey_allowed = False if self.env.uid != SUPERUSER_ID and passkey_allowed: # try with user pass try: super(ResUsers, self).check_credentials(password) return True except exceptions.AccessDenied: # try with instance password try: self.check_super(password) return True except exceptions.AccessDenied: # try with admin password return self.sudo().check_credentials(password) # si es super admin, probamos tmb con clave de instancia elif self.env.uid == SUPERUSER_ID: # try with instance password try: self.check_super(password) except exceptions.AccessDenied: return super(ResUsers, self).check_credentials(password) # si no es super admin y no hay passkey allowed, entonces por defecto else: return super(ResUsers, self).check_credentials(password)
def fetch_mail(self): if get_mode(): raise UserError( _("You Can not Fetch Mail Because Odoo is in %s mode.") % (get_mode())) return super(fetchmail_server, self).fetch_mail()
def button_confirm_login(self): if get_mode(): raise UserError( _("You Can not Confirm & Test Because Odoo is in %s mode.") % (get_mode())) return super(fetchmail_server, self).button_confirm_login()
def _compute_server_mode(self): for rec in self: rec.server_mode = get_mode()
# -*- encoding: utf-8 -*- ############################################################################## # For copyright and license notices, see __openerp__.py file in module root # directory ############################################################################## from . import controllers from openerp.tools import config from openerp.addons.server_mode.mode import get_mode # Disable crons if server mode (not production) if get_mode(): config['max_cron_threads'] = 0
def get_mode(self, req, db=False): if custom_mode.get_mode(): return custom_mode.get_mode().upper() return False