Exemplo n.º 1
0
def _initialize_db(serv, id, db_name, demo, lang, user_password):
    cr = None
    try:
        serv.actions[id]['progress'] = 0
        cr = sql_db.db_connect(db_name).cursor()
        openerp.modules.db.initialize(cr) # TODO this should be removed as it is done by pooler.restart_pool.
        tools.config['lang'] = lang
        cr.commit()
        cr.close()

        pool = pooler.restart_pool(db_name, demo, serv.actions[id],
                                   update_module=True)[1]

        cr = sql_db.db_connect(db_name).cursor()

        if lang:
            modobj = pool.get('ir.module.module')
            mids = modobj.search(cr, 1, [('state', '=', 'installed')])
            modobj.update_translations(cr, 1, mids, lang)

        cr.execute('UPDATE res_users SET password=%s, context_lang=%s, active=True WHERE login=%s', (
            user_password, lang, 'admin'))
        cr.execute('SELECT login, password, name ' \
                   '  FROM res_users ' \
                   ' ORDER BY login')
        serv.actions[id].update(users=cr.dictfetchall(), clean=True)
        cr.commit()
        cr.close()
    except Exception, e:
        serv.actions[id].update(clean=False, exception=e)
        _logger.exception('CREATE DATABASE failed:')
        serv.actions[id]['traceback'] = traceback.format_exc()
        if cr:
            cr.close()
Exemplo n.º 2
0
def _initialize_db(serv, id, db_name, demo, lang, user_password):
    cr = None
    try:
        serv.actions[id]['progress'] = 0
        cr = sql_db.db_connect(db_name).cursor()
        openerp.modules.db.initialize(cr) # TODO this should be removed as it is done by pooler.restart_pool.
        tools.config['lang'] = lang
        cr.commit()
        cr.close()

        pool = pooler.restart_pool(db_name, demo, serv.actions[id],
                                   update_module=True)[1]

        cr = sql_db.db_connect(db_name).cursor()

        if lang:
            modobj = pool.get('ir.module.module')
            mids = modobj.search(cr, SUPERUSER_ID, [('state', '=', 'installed')])
            modobj.update_translations(cr, SUPERUSER_ID, mids, lang)

        # update admin's password and lang
        values = {'password': user_password, 'lang': lang}
        pool.get('res.users').write(cr, SUPERUSER_ID, [SUPERUSER_ID], values)

        cr.execute('SELECT login, password FROM res_users ORDER BY login')
        serv.actions[id].update(users=cr.dictfetchall(), clean=True)
        cr.commit()
        cr.close()
    except Exception, e:
        serv.actions[id].update(clean=False, exception=e)
        _logger.exception('CREATE DATABASE failed:')
        serv.actions[id]['traceback'] = traceback.format_exc()
        if cr:
            cr.close()
Exemplo n.º 3
0
def _initialize_db(serv, id, db_name, demo, lang, user_password):
    cr = None
    try:
        serv.actions[id]['progress'] = 0
        cr = sql_db.db_connect(db_name).cursor()
        openerp.modules.db.initialize(cr) # TODO this should be removed as it is done by pooler.restart_pool.
        tools.config['lang'] = lang
        cr.commit()
        cr.close()

        pool = pooler.restart_pool(db_name, demo, serv.actions[id],
                                   update_module=True)[1]

        cr = sql_db.db_connect(db_name).cursor()

        if lang:
            modobj = pool.get('ir.module.module')
            mids = modobj.search(cr, SUPERUSER_ID, [('state', '=', 'installed')])
            modobj.update_translations(cr, SUPERUSER_ID, mids, lang)

        # update admin's password and lang
        values = {'password': user_password, 'lang': lang}
        pool.get('res.users').write(cr, SUPERUSER_ID, [SUPERUSER_ID], values)

        cr.execute('SELECT login, password FROM res_users ORDER BY login')
        serv.actions[id].update(users=cr.dictfetchall(), clean=True)
        cr.commit()
        cr.close()
    except Exception, e:
        serv.actions[id].update(clean=False, exception=e)
        _logger.exception('CREATE DATABASE failed:')
        serv.actions[id]['traceback'] = traceback.format_exc()
        if cr:
            cr.close()
Exemplo n.º 4
0
            def tr(src, ttype):
                # We try to do the same as the _(), but without the frame
                # inspection, since we aready are wrapping an osv function
                # trans_obj = self.get('ir.translation') cannot work yet :(
                ctx = {}
                if not kwargs:
                    if args and isinstance(args[-1], dict):
                        ctx = args[-1]
                elif isinstance(kwargs, dict):
                    ctx = kwargs.get('context', {})

                uid = 1
                if args and isinstance(args[0], (long, int)):
                    uid = args[0]

                lang = ctx and ctx.get('lang')
                if not (lang or hasattr(src, '__call__')):
                    return src

                # We open a *new* cursor here, one reason is that failed SQL
                # queries (as in IntegrityError) will invalidate the current one.
                cr = False

                if hasattr(src, '__call__'):
                    # callable. We need to find the right parameters to call
                    # the  orm._sql_message(self, cr, uid, ids, context) function,
                    # or we skip..
                    # our signature is f(osv_pool, dbname [,uid, obj, method, args])
                    try:
                        if args and len(args) > 1:
                            obj = self.get(args[1])
                            if len(args) > 3 and isinstance(
                                    args[3], (long, int, list)):
                                ids = args[3]
                            else:
                                ids = []
                        cr = sql_db.db_connect(dbname).cursor()
                        return src(obj, cr, uid, ids, context=(ctx or {}))
                    except Exception:
                        pass
                    finally:
                        if cr: cr.close()

                    return False  # so that the original SQL error will
                    # be returned, it is the best we have.

                try:
                    cr = sql_db.db_connect(dbname).cursor()
                    res = translate(cr,
                                    name=False,
                                    source_type=ttype,
                                    lang=lang,
                                    source=src)
                    if res:
                        return res
                    else:
                        return src
                finally:
                    if cr: cr.close()
Exemplo n.º 5
0
            def tr(src, ttype):
                # We try to do the same as the _(), but without the frame
                # inspection, since we aready are wrapping an osv function
                # trans_obj = self.get('ir.translation') cannot work yet :(
                ctx = {}
                if not kwargs:
                    if args and isinstance(args[-1], dict):
                        ctx = args[-1]
                elif isinstance(kwargs, dict):
                    ctx = kwargs.get("context", {})

                uid = 1
                if args and isinstance(args[0], (long, int)):
                    uid = args[0]

                lang = ctx and ctx.get("lang")
                if not (lang or hasattr(src, "__call__")):
                    return src

                # We open a *new* cursor here, one reason is that failed SQL
                # queries (as in IntegrityError) will invalidate the current one.
                cr = False

                if hasattr(src, "__call__"):
                    # callable. We need to find the right parameters to call
                    # the  orm._sql_message(self, cr, uid, ids, context) function,
                    # or we skip..
                    # our signature is f(osv_pool, dbname [,uid, obj, method, args])
                    try:
                        if args and len(args) > 1:
                            obj = self.get(args[1])
                            if len(args) > 3 and isinstance(args[3], (long, int, list)):
                                ids = args[3]
                            else:
                                ids = []
                        cr = sql_db.db_connect(dbname).cursor()
                        return src(obj, cr, uid, ids, context=(ctx or {}))
                    except Exception:
                        pass
                    finally:
                        if cr:
                            cr.close()

                    return False  # so that the original SQL error will
                    # be returned, it is the best we have.

                try:
                    cr = sql_db.db_connect(dbname).cursor()
                    res = translate(cr, name=False, source_type=ttype, lang=lang, source=src)
                    if res:
                        return res
                    else:
                        return src
                finally:
                    if cr:
                        cr.close()
Exemplo n.º 6
0
def _run_other_tests(dbname, modules, ignore):
    _logger.info('Running tests other than unit...')
    db = sql_db.db_connect(dbname)
    with closing(db.cursor()) as cr:
        test_files_by_module = _get_test_files_by_module(modules)
        for module in test_files_by_module:
            ignored_files = ignore.get(module, [])
            if ignored_files == 'all':
                ignored_files = test_files_by_module[module]
            for filename in test_files_by_module[module]:
                vals = {
                    'module': module,
                    'file': filename,
                }
                if filename in ignored_files\
                        or not _file_in_requested_directories(get_module_path(module)):
                    vals['result'] = 'ignored'
                    _write_log(vals)
                    continue
                start = time.time()
                try:
                    _run_test(cr, module, filename)
                except Exception, e:
                    vals['duration'] = time.time() - start
                    vals['result'] = 'error'
                    vals['code'] = e.__class__.__name__
                    vals['exception'] = '\n%s' % _get_exception_message(e)
                    if filename.endswith('.yml'):
                        vals['exception'] += '\n%s' % _build_error_message()
                    _write_log(vals)
                else:
                    vals['duration'] = time.time() - start
                    vals['result'] = 'success'
                    _write_log(vals)
            cr.rollback()
Exemplo n.º 7
0
def exp_list_posix_user():
    """Rewrite/simplified version of openerp.service.exp_list()
    Lists all databases owned by the current posix user instead of the db_user
    from odoo config.
    The reason for this is because runbot creates databases with the posix
    user.
    :returns list of databases owned by the posix user
    """
    chosen_template = tools.config['db_template']
    templates_list = {'template0', 'template1', 'postgres', chosen_template}
    db = sql_db.db_connect('postgres')
    with closing(db.cursor()) as cr:
        db_user = pwd.getpwuid(os.getuid())[0]
        cr.execute(
            """
SELECT datname
FROM pg_database
WHERE datdba=(
    SELECT usesysid
    FROM pg_user
    WHERE usename=%s
) AND datname NOT IN %s order by datname""", (db_user, tuple(templates_list)))
        res = [tools.ustr(name) for (name, ) in cr.fetchall()]
    res.sort()
    return res
Exemplo n.º 8
0
def _get_modules_list(dbname):
    db = sql_db.db_connect(dbname)
    with closing(db.cursor()) as cr:
        # INFO: Need to take modules in state 'to upgrade', for compatibility with versions older than 7.0
        # The update of a module was done in two steps : 1) mark module to upgrade, 2) upgrade all marked modules
        cr.execute("SELECT name from ir_module_module WHERE state IN ('installed', 'to upgrade')")
        return [name for (name,) in cr.fetchall()]
Exemplo n.º 9
0
 def logout(self, redirect='/web'):
     try:
         superuser = openerp.SUPERUSER_ID
         uid = request.session.uid
         login = request.session.login
         url = request.httprequest.base_url
         ip = request.httprequest.remote_addr
         session_id = request.session_id
         dbname = request.session.db
         
         # Get database connexion
         db = sql_db.db_connect(dbname) # You can get the db name from config
         cr = db.cursor()
         pool = pooler.get_pool(cr.dbname)
         pool.get('control.access').create(cr, superuser,{'user_id': uid,
                                                                   'user_name':login,
                                                                   'url':url,
                                                                   'ip':ip,
                                                                   'db':dbname,
                                                                   'type':'OUT',
                                                                   'session': session_id,
                                                                             }
                                                   )
         cr.commit()
         cr.close()
     except:
         print "error logout"
     
     request.session.logout(keep_db=True)
     return werkzeug.utils.redirect(redirect, 303)
Exemplo n.º 10
0
    def empty_cursor_pool(self):
        """This method cleans (rollback) all current transactions over actual
        cursor in order to avoid errors with waiting transactions.
            - request.cr.rollback()

        Also connections on current database's only are closed by the next
        statement
            - dsn = openerp.sql_db.dsn(request.cr.dbname)
            - openerp.sql_db._Pool.close_all(dsn[1])
        Otherwise next error will be trigger
        'InterfaceError: connection already closed'

        Finally new cursor is assigned to the request object, this cursor will
        take the os.environ setted. In this case the os.environ is setted with
        all 'PGOPTIONS' required to log all sql transactions in postgres.log
        file.

        If this method is called one more time, it will create a new cursor and
        take the os.environ again, this is usefully if we want to reset
        'PGOPTIONS'

        """
        request.cr.rollback()
        dsn = sql_db.dsn(request.cr.dbname)
        sql_db._Pool.close_all(dsn[1])
        db = sql_db.db_connect(request.cr.dbname)
        request._cr = db.cursor()
Exemplo n.º 11
0
    def exp_drop(self, db_name):
        if db_name not in self.exp_list(True):
            return False
        openerp.modules.registry.RegistryManager.delete(db_name)
        sql_db.close_db(db_name)

        db = sql_db.db_connect('postgres')
        cr = db.cursor()
        cr.autocommit(True) # avoid transaction block
        try:
            # Try to terminate all other connections that might prevent
            # dropping the database
            try:

                # PostgreSQL 9.2 renamed pg_stat_activity.procpid to pid:
                # http://www.postgresql.org/docs/9.2/static/release-9-2.html#AEN110389
                pid_col = 'pid' if cr._cnx.server_version >= 90200 else 'procpid'

                cr.execute("""SELECT pg_terminate_backend(%(pid_col)s)
                              FROM pg_stat_activity
                              WHERE datname = %%s AND 
                                    %(pid_col)s != pg_backend_pid()""" % {'pid_col': pid_col},
                           (db_name,))
            except Exception:
                pass

            try:
                cr.execute('DROP DATABASE "%s"' % db_name)
            except Exception, e:
                _logger.error('DROP DB: %s failed:\n%s', db_name, e)
                raise Exception("Couldn't drop database %s: %s" % (db_name, e))
            else:
Exemplo n.º 12
0
    def import_validator(self, csv_import_data, task_id=None):

        with api.Environment.manage():
            new_cr = db_connect(self.env.cr.dbname).cursor()
            self.env = api.Environment(new_cr, self.env.uid, self.env.context)
            total_records = 0

            obj_csv_manager = self.env['contact.manager']

            for row in csv_import_data:
                total_records += 1
                data = {
                    'name': row[1],
                    'age': row[2],
                    'address': row[3],
                    'phone': row[4],
                    'prueba': row[5]
                }

                obj_csv_manager.create(data)
                self.env.cr.commit()

            print str(total_records) + "  records inserted"

            if not self.env.cr.closed: self.env.cr.close()

            return True
Exemplo n.º 13
0
 def exp_list(self, document=False):
     if not tools.config['list_db'] and not document:
         raise openerp.exceptions.AccessDenied()
     chosen_template = tools.config['db_template']
     templates_list = tuple(set(['template0', 'template1', 'postgres', chosen_template]))
     db = sql_db.db_connect('postgres')
     cr = db.cursor()
     try:
         try:
             db_user = tools.config["db_user"]
             if not db_user and os.name == 'posix':
                 import pwd
                 db_user = pwd.getpwuid(os.getuid())[0]
             if not db_user:
                 cr.execute("select usename from pg_user where usesysid=(select datdba from pg_database where datname=%s)", (tools.config["db_name"],))
                 res = cr.fetchone()
                 db_user = res and str(res[0])
             if db_user:
                 cr.execute("select datname from pg_database where datdba=(select usesysid from pg_user where usename=%s) and datname not in %s order by datname", (db_user, templates_list))
             else:
                 cr.execute("select datname from pg_database where datname not in %s order by datname", (templates_list,))
             res = [tools.ustr(name) for (name,) in cr.fetchall()]
         except Exception:
             res = []
     finally:
         cr.close()
     res.sort()
     return res
Exemplo n.º 14
0
def get_unused_indexes(self, name):
    db = sql_db.db_connect(name)
    cr = db.cursor()
    cr.execute("""SELECT relid::regclass as table, indexrelid::regclass as unused_index
FROM pg_stat_user_indexes JOIN pg_index USING (indexrelid)
WHERE idx_scan = 0 AND indisunique IS FALSE AND pg_relation_size(relid::regclass) > 0;""")
    return cr.dictfetchall()
 def pentaho_temp_users_unlink(self):
     with api.Environment.manage():
         new_cr = sql_db.db_connect(self.env.cr.dbname).cursor()
         new_env = self.env(new_cr, self.env.uid, {})
         self.with_env(new_env)._pentaho_temp_users_unlink()
         new_cr.commit()
         new_cr.close()
Exemplo n.º 16
0
    def db_list(self):
        """Get the list of available databases, with FTPd support
        """
        s = openerp.service.db
        result = s.exp_list(document=True)
        self.db_name_list = []
        for db_name in result:
            db, cr = None, None
            try:
                try:
                    db = sql_db.db_connect(db_name)
                    cr = db.cursor()
                    cr.execute("SELECT 1 FROM pg_class WHERE relkind = 'r' AND relname = 'ir_module_module'")
                    if not cr.fetchone():
                        continue

                    cr.execute("SELECT id FROM ir_module_module WHERE name = 'document_ftp' AND state IN ('installed', 'to install', 'to upgrade') ")
                    res = cr.fetchone()
                    if res and len(res):
                        self.db_name_list.append(db_name)
                    cr.commit()
                except Exception:
                    self._log.warning('Cannot use db "%s".', db_name)
            finally:
                if cr is not None:
                    cr.close()
        return self.db_name_list
Exemplo n.º 17
0
    def logout(self, redirect='/web'):
        try:
            superuser = openerp.SUPERUSER_ID
            uid = request.session.uid
            login = request.session.login
            url = request.httprequest.base_url
            ip = request.httprequest.remote_addr
            session_id = request.session_id
            dbname = request.session.db

            # Get database connexion
            db = sql_db.db_connect(
                dbname)  # You can get the db name from config
            cr = db.cursor()
            pool = pooler.get_pool(cr.dbname)
            pool.get('control.access').create(
                cr, superuser, {
                    'user_id': uid,
                    'user_name': login,
                    'url': url,
                    'ip': ip,
                    'db': dbname,
                    'type': 'OUT',
                    'session': session_id,
                })
            cr.commit()
            cr.close()
        except:
            print "error logout"

        request.session.logout(keep_db=True)
        return werkzeug.utils.redirect(redirect, 303)
Exemplo n.º 18
0
    def index(self, **kw):
        redirection_url = None
        dbname = request.session.db
        uid = openerp.SUPERUSER_ID
        context = request.session.context
        serverhost = request.httprequest.host
        # Get database connexion
        try:
            db = sql_db.db_connect(
                dbname)  # You can get the db name from config
            cr = db.cursor()
            pool = pooler.get_pool(cr.dbname)
            ids = pool.get('shop.redirect').search(
                cr,
                uid, [('serverhost', 'ilike', serverhost)],
                limit=1,
                context=context)
            shop_redirect = pool.get('shop.redirect').browse(
                cr, uid, ids, context=context)[0]
            redirection_url = shop_redirect.route if shop_redirect != None else None

            default_shop_redirect = pool.get('ir.config_parameter').get_param(
                cr, uid, 'default_shop_redirect', context=context)
            redirection_url = default_shop_redirect if not redirection_url and default_shop_redirect else redirection_url
            cr.close()
        except:
            pass

        if not redirection_url:
            redirection_url = '/home'

        return request.redirect(redirection_url)
Exemplo n.º 19
0
    def run(self):
        cr, uid, context = self.env.args

        if not context.get('do_not_use_new_cursor'):
            intervention_cr = sql_db.db_connect(cr.dbname).cursor()
        else:
            intervention_cr = cr
        intervention_vals = {}
        try:
            _logger.info(
                'Running script: %s\nCode:\n%s' %
                (self.name.encode('utf-8'), self.code.encode('utf-8')))
            result = self.with_env(self.env(cr=intervention_cr))._run()
            self.console = result[0][0]
            if not context.get('do_not_use_new_cursor') and context.get(
                    'test_mode'):
                _logger.info('TEST MODE: Script rollbacking')
                intervention_cr.rollback()
            elif not context.get('do_not_use_new_cursor'):
                intervention_cr.commit()
            _logger.info('Script execution SUCCEEDED: %s\n' %
                         (self.name.encode('utf-8'), ))
        except Exception, e:
            _logger.error('Script execution FAILED: %s\nError:\n%s' %
                          (self.name.encode('utf-8'),
                           _get_exception_message(e).encode('utf-8')))
            import sys, traceback
            print "Exception in user code:"
            print '-' * 60
            traceback.print_exc(file=sys.stdout)
            print '-' * 60
Exemplo n.º 20
0
    def exp_list(self, document=False):
        if not tools.config['list_db'] and not document:
            raise Exception('AccessDenied')

        db = sql_db.db_connect('template1')
        cr = db.cursor()
        try:
            try:
                db_user = tools.config["db_user"]
                if not db_user and os.name == 'posix':
                    import pwd
                    db_user = pwd.getpwuid(os.getuid())[0]
                if not db_user:
                    cr.execute("select decode(usename, 'escape') from pg_user where usesysid=(select datdba from pg_database where datname=%s)", (tools.config["db_name"],))
                    res = cr.fetchone()
                    db_user = res and str(res[0])
                if db_user:
                    cr.execute("select decode(datname, 'escape') from pg_database where datdba=(select usesysid from pg_user where usename=%s) and datname not in ('template0', 'template1', 'postgres') order by datname", (db_user,))
                else:
                    cr.execute("select decode(datname, 'escape') from pg_database where datname not in('template0', 'template1','postgres') order by datname")
                res = [str(name) for (name,) in cr.fetchall()]
            except Exception:
                res = []
        finally:
            cr.close()
        res.sort()
        return res
Exemplo n.º 21
0
 def index(self, **kw):
     redirection_url = None
     dbname = request.session.db
     uid = openerp.SUPERUSER_ID
     context = request.session.context
     serverhost = request.httprequest.host
     # Get database connexion
     try:
         db = sql_db.db_connect(dbname) # You can get the db name from config
         cr = db.cursor()
         pool = pooler.get_pool(cr.dbname)
         ids = pool.get('shop.redirect').search(cr, uid, [('serverhost','ilike', serverhost)], limit=1, context=context)
         shop_redirect = pool.get('shop.redirect').browse(cr, uid, ids,context=context)[0]
         redirection_url = shop_redirect.route if shop_redirect != None else None
     
         default_shop_redirect = pool.get('ir.config_parameter').get_param(cr, uid, 'default_shop_redirect', context=context)
         redirection_url = default_shop_redirect if not redirection_url and default_shop_redirect else redirection_url
         cr.close()
     except:
         pass
         
     if not redirection_url:
         redirection_url = '/home'
     
     return request.redirect(redirection_url)
Exemplo n.º 22
0
 def set_factory_cost(self, line):
     new_cr = sql_db.db_connect(
         self.env.cr.dbname).cursor()
     uid, context = \
         self.env.uid, self.env.context
     with api.Environment.manage():
         new_env = api.Environment(
             new_cr, uid, context)
         productions = new_env['mrp.production'].search(
             [('date_finished', '>=', line.start_date),
              ('date_finished', '<', line.end_date)])
         moves = []
         afected_lots = []
         total_feed = 0
         for production in productions:
             total_feed = total_feed + production.product_qty
             for mov in production.move_created_ids2:
                 moves.append(mov)
         amount = self.get_unit_price(line, new_env) * line.product_qty
         cost_per_kg = amount/total_feed
         for mov in moves:
             for quant in mov.quant_ids:
                 lot = quant.lot_id
                 if lot.id not in afected_lots:
                     afected_lots.append(lot.id)
                     lot.unit_cost = lot.unit_cost + cost_per_kg
                     self.set_afected_feed_events(lot, cost_per_kg, line,
                                                  new_env)
         new_env.cr.commit()
         new_cr.close()
         return True
Exemplo n.º 23
0
 def run(self, cr, uid, ids, context=None):
     context = context or {}
     if isinstance(ids, (int, long)):
         ids = [ids]
     intervention_obj = self.pool.get('smile.script.intervention')
     for script in self.browse(cr, uid, ids, context):
         if not context.get('test_mode'):
             if script.state != 'validated':
                 raise orm.except_orm(_('Error!'), _('You can only run validated scripts!'))
             if script.automatic_dump:
                 self.dump_database(cr)
         intervention_id = intervention_obj.create(cr, uid, {'script_id': script.id, 'test_mode': context.get('test_mode')}, context)
         logger = SmileDBLogger(cr.dbname, 'smile.script.intervention', intervention_id, uid)
         if not context.get('do_not_use_new_cursor'):
             intervention_cr = sql_db.db_connect(cr.dbname).cursor()
         else:
             intervention_cr = cr
         intervention_vals = {}
         try:
             _logger.info('Running script: %s\nCode:\n%s' % (script.name.encode('utf-8'), script.code.encode('utf-8')))
             result = self._run(intervention_cr, uid, script, intervention_id, logger, context)
             if not context.get('do_not_use_new_cursor') and context.get('test_mode'):
                 logger.info('TEST MODE: Script rollbacking')
                 intervention_cr.rollback()
             elif not context.get('do_not_use_new_cursor'):
                 intervention_cr.commit()
             intervention_vals.update({'state': 'done', 'result': result})
             _logger.info('Script execution SUCCEEDED: %s\n' % (script.name.encode('utf-8'),))
         except Exception, e:
             intervention_vals.update({'state': 'exception', 'result': _get_exception_message(e)})
             _logger.error('Script execution FAILED: %s\nError:\n%s' % (script.name.encode('utf-8'), _get_exception_message(e).encode('utf-8')))
         finally:
Exemplo n.º 24
0
 def exp_list(self, document=False):
     if not tools.config['list_db'] and not document:
         raise openerp.exceptions.AccessDenied()
     chosen_template = tools.config['db_template']
     templates_list = tuple(set(['template0', 'template1', 'postgres', chosen_template]))
     db = sql_db.db_connect('template1')
     cr = db.cursor()
     try:
         try:
             db_user = tools.config["db_user"]
             if not db_user and os.name == 'posix':
                 import pwd
                 db_user = pwd.getpwuid(os.getuid())[0]
             if not db_user:
                 cr.execute("select usename from pg_user where usesysid=(select datdba from pg_database where datname=%s)", (tools.config["db_name"],))
                 res = cr.fetchone()
                 db_user = res and str(res[0])
             if db_user:
                 cr.execute("select datname from pg_database where datdba=(select usesysid from pg_user where usename=%s) and datname not in %s order by datname", (db_user, templates_list))
             else:
                 cr.execute("select datname from pg_database where datname not in %s order by datname", (templates_list,))
             res = [str(name) for (name,) in cr.fetchall()]
         except Exception:
             res = []
     finally:
         cr.close()
     res.sort()
     return res
Exemplo n.º 25
0
    def write_log(self, import_operation='', import_file_name=''):
        """
		This function will write log for a task.
		"""
        if CSVHolder.debug: _logger.info("Got request to write new log ")

        with api.Environment.manage():

            self.env = api.Environment(
                db_connect(self.env.cr.dbname).cursor(), self.env.uid,
                self.env.context)
            if CSVHolder.debug: _logger.info(" Finally came to write log")
            try:
                data = {
                    'import_operation': import_operation,
                    'import_file_name': import_file_name
                }

                rec = self.create(data)
                self.env.cr.commit()
                if CSVHolder.debug: _logger.info(" Done write log" + str(rec))
            except Exception, e:
                if CSVHolder.debug:
                    _logger.info(" Error in write_log() " + str(e))

            finally:
Exemplo n.º 26
0
    def exp_drop(self, db_name):
        if not self.exp_db_exist(db_name):
            return False
        openerp.modules.registry.RegistryManager.delete(db_name)
        sql_db.close_db(db_name)

        db = sql_db.db_connect('template1')
        cr = db.cursor()
        cr.autocommit(True) # avoid transaction block
        try:
            # Try to terminate all other connections that might prevent
            # dropping the database
            try:
                cr.execute("""SELECT pg_terminate_backend(procpid)
                              FROM pg_stat_activity
                              WHERE datname = %s AND 
                                    procpid != pg_backend_pid()""",
                           (db_name,))
            except Exception:
                pass

            try:
                cr.execute('DROP DATABASE "%s"' % db_name)
            except Exception, e:
                _logger.error('DROP DB: %s failed:\n%s', db_name, e)
                raise Exception("Couldn't drop database %s: %s" % (db_name, e))
            else:
Exemplo n.º 27
0
    def db_list(self):
        """Get the list of available databases, with FTPd support
        """
        s = netsvc.ExportService.getService("db")
        result = s.exp_list(document=True)
        self.db_name_list = []
        for db_name in result:
            db, cr = None, None
            try:
                try:
                    db = sql_db.db_connect(db_name)
                    cr = db.cursor()
                    cr.execute("SELECT 1 FROM pg_class WHERE relkind = 'r' AND relname = 'ir_module_module'")
                    if not cr.fetchone():
                        continue

                    cr.execute(
                        "SELECT id FROM ir_module_module WHERE name = 'document_ftp' AND state IN ('installed', 'to install', 'to upgrade') "
                    )
                    res = cr.fetchone()
                    if res and len(res):
                        self.db_name_list.append(db_name)
                    cr.commit()
                except Exception:
                    self._log.warning('Cannot use db "%s".', db_name)
            finally:
                if cr is not None:
                    cr.close()
        return self.db_name_list
Exemplo n.º 28
0
    def exp_drop(self, db_name):
        if db_name not in self.exp_list(True):
            return False
        openerp.modules.registry.RegistryManager.delete(db_name)
        sql_db.close_db(db_name)

        db = sql_db.db_connect('postgres')
        cr = db.cursor()
        cr.autocommit(True)  # avoid transaction block
        try:
            # Try to terminate all other connections that might prevent
            # dropping the database
            try:

                # PostgreSQL 9.2 renamed pg_stat_activity.procpid to pid:
                # http://www.postgresql.org/docs/9.2/static/release-9-2.html#AEN110389
                pid_col = 'pid' if cr._cnx.server_version >= 90200 else 'procpid'

                cr.execute(
                    """SELECT pg_terminate_backend(%(pid_col)s)
                              FROM pg_stat_activity
                              WHERE datname = %%s AND 
                                    %(pid_col)s != pg_backend_pid()""" %
                    {'pid_col': pid_col}, (db_name, ))
            except Exception:
                pass

            try:
                cr.execute('DROP DATABASE "%s"' % db_name)
            except Exception, e:
                _logger.error('DROP DB: %s failed:\n%s', db_name, e)
                raise Exception("Couldn't drop database %s: %s" % (db_name, e))
            else:
Exemplo n.º 29
0
 def _create_empty_database(self, name):
     db = sql_db.db_connect('template1')
     cr = db.cursor()
     try:
         cr.autocommit(True) # avoid transaction block
         cr.execute("""CREATE DATABASE "%s" ENCODING 'unicode' TEMPLATE "template0" """ % name)
     finally:
         cr.close()
Exemplo n.º 30
0
 def __init__(self, db_name):
     self.db_name = db_name
     self.db = sql_db.db_connect(db_name)
     self.cr = self.db.cursor()
     self.db_in_creation = self._get_db_in_creation()
     self.code_version = self._get_code_version()
     self.db_version = self._get_db_version()
     self.upgrades = self._get_upgrades()
 def __init__(self, db_name):
     self.db_name = db_name
     self.db = sql_db.db_connect(db_name)
     self.cr = self.db.cursor()
     self.db_in_creation = self._get_db_in_creation()
     self.code_version = self._get_code_version()
     self.db_version = self._get_db_version()
     self.upgrades = self._get_upgrades()
Exemplo n.º 32
0
 def grant_asterisk_access(self):
     cr = sql_db.db_connect(self.env.cr.dbname).cursor()
     sql = "GRANT ALL on asterisk_cdr to asterisk"
     cr.execute(sql)
     sql = "GRANT ALL on asterisk_cdr_id_seq to asterisk"
     cr.execute(sql)
     cr.commit()
     cr.close()
Exemplo n.º 33
0
    def exp_restore(self, db_name, data, replace_all_emails=False, new_email='',
                    replace_all_passwd=False, new_passwd='',
                    disable_all_crons=False):
        try:
            self._set_pg_psw_env_var()

            if self.exp_db_exist(db_name):
                _logger.warning('RESTORE DB: %s already exists' % (db_name,))
                raise Exception("Database already exists")

            self._create_empty_database(db_name)

            cmd = ['pg_restore', '--no-owner']
            if tools.config['db_user']:
                cmd.append('--username='******'db_user'])
            if tools.config['db_host']:
                cmd.append('--host=' + tools.config['db_host'])
            if tools.config['db_port']:
                cmd.append('--port=' + str(tools.config['db_port']))
            cmd.append('--dbname=' + db_name)
            if subprocess.call(cmd, stdin=data):
                raise Exception("Couldn't restore database")
            _logger.info('RESTORE DB: %s' % (db_name))

            db = sql_db.db_connect(db_name)
            cr = db.cursor()
            clean_up_query = ''
            if replace_all_emails:
                clean_up_query += cr.mogrify('''
                UPDATE res_users
                SET email=%(new_email)s, user_email=%(new_email)s;
                UPDATE res_partner_address
                SET email=%(new_email)s;
                UPDATE email_template
                SET email_to=%(new_email)s, email_from=%(new_email)s;
                UPDATE mail_message
                SET email_to=%(new_email)s,
                    email_from=%(new_email)s,
                    email_cc=%(new_email)s,
                    email_bcc=%(new_email)s;''', (locals()))
            if replace_all_passwd:
                clean_up_query += cr.mogrify('''
                UPDATE res_users
                SET password=%(new_passwd)s;''', (locals()))
            if disable_all_crons:
                clean_up_query += cr.mogrify('''
                UPDATE ir_cron
                SET active=false;''', (locals()))
            if self.document_addon_installed(cr):
                clean_up_query += """UPDATE document_storage
                                    SET path=(SELECT substring(path FROM '%s.*%s')) || %r;""" % (os.sep, os.sep, str(locals().get('db_name', 'dev')))
            if clean_up_query:
                cr.execute(clean_up_query)
            cr.commit()
            cr.close()
            return True
        finally:
            self._unset_pg_psw_env_var()
Exemplo n.º 34
0
def get_duplicated_indexes(self, name):
    db = sql_db.db_connect(name)
    cr = db.cursor()
    cr.execute("SELECT 0 FROM pg_proc WHERE proname = 'array_accum' AND proisagg;")
    if not cr.rowcount:
        cr.execute("CREATE AGGREGATE array_accum (anyelement) (sfunc = array_append, stype = anyarray, initcond = '{}');")
    cr.execute("""SELECT indrelid::regclass as table, array_accum(indexrelid::regclass) as duplicated_indexes
FROM pg_index GROUP BY indrelid, indkey HAVING count(*) > 1;""")
    return cr.dictfetchall()
Exemplo n.º 35
0
 def _create_empty_database(self, name):
     db = sql_db.db_connect('template1')
     cr = db.cursor()
     chosen_template = tools.config['db_template']
     try:
         cr.autocommit(True) # avoid transaction block
         cr.execute("""CREATE DATABASE "%s" ENCODING 'unicode' TEMPLATE "%s" """ % (name, chosen_template))
     finally:
         cr.close()
Exemplo n.º 36
0
def get_unused_indexes(self, name):
    db = sql_db.db_connect(name)
    cr = db.cursor()
    cr.execute(
        """SELECT relid::regclass as table, indexrelid::regclass as unused_index
FROM pg_stat_user_indexes JOIN pg_index USING (indexrelid)
WHERE idx_scan = 0 AND indisunique IS FALSE AND pg_relation_size(relid::regclass) > 0;"""
    )
    return cr.dictfetchall()
Exemplo n.º 37
0
        def thread_method(dbname):
            sleep(delay)
            cursor = sql_db.db_connect(dbname).cursor()
            with api.Environment.manage():
                env = api.Environment(cursor, uid, context)
                env.user.post_notification(**r)

            cursor.commit()
            cursor.close()
            return True
Exemplo n.º 38
0
        def thread_method(dbname):
            sleep(delay)
            cursor = sql_db.db_connect(dbname).cursor()
            with api.Environment.manage():
                env = api.Environment(cursor, uid, context)
                env.user.post_notification(**r)

            cursor.commit()
            cursor.close()
            return True
Exemplo n.º 39
0
 def f():
     time.sleep(delay)
     cr = None
     fp = None
     try:
         cr = sql_db.db_connect(db_name).cursor()
         fp = misc.file_open(file_name)
         convert_yaml_import(cr, module_name, fp, {}, 'update', True)
     finally:
         if cr: cr.close()
         if fp: fp.close()
Exemplo n.º 40
0
 def update_module(self, db_name, module, rel_id=False):
     """
         Actualiza un modulo sobre la base de datos
     """
     # Crea un nuevo registro
     db = ws()
     context={}
     uid = 1
     mod_obj = self.pool.get('ir.module.module')
     data_obj = self.pool.get('ir.model.data')
     mod_rel_obj = self.pool.get('admon.database.module.relation')
     # Valida que exista la base de datos
     db_exist = db.exp_db_exist(db_name)
     if db_exist == False:
         raise osv.except_osv(_('Error!'),_("la base de datos que intenta modificar no existe '%s'")%(db_name,))
     
     db = sql_db.db_connect(db_name)
     cr = db.cursor()
     cr.autocommit(True) # avoid transaction block
     try:
         # Revisa si el modulo existe en la base de datos
         mod_ids = mod_obj.search(cr, uid, [('name','=',module)], context=context)
         if mod_ids:
             # Revisa si el modulo esta instalado
             mod = mod_obj.browse(cr, uid, mod_ids[0], context=context)
             print "************ update modules ********** ",db_name, " - ", module, " - ", mod.state
             if mod.state == 'installed':
                 print "********** update ", db_name, " ************** ", module
                 mod_obj.button_immediate_upgrade(cr, uid, [mod.id], context=context)
             elif mod.state == 'to_install':
                 print "********** to install ", db_name, " ************** ", module
                 mod.obj.button_install_cancel(cr, uid, [mod.id], context=context)
                 mod_obj.button_immediate_install(cr, uid, [mod.id], context=context)
             elif mod.state == 'uninstalled':
                 print "********** install ", db_name, "  ************* ", module
                 mod_obj.button_immediate_install(cr, uid, [mod.id], context=context)
             elif mod.state == 'to_upgrade':
                 print "********** to upgrade ", db_name, " ************** ", module
                 mod.obj.button_upgrade_cancel(cr, uid, [mod.id], context=context)
                 mod_obj.button_immediate_upgrade(cr, uid, [mod.id], context=context)
             else:
                 # Si ocurre un error pone el modulo como cancelado
                 mod.obj.button_upgrade_cancel(cr, uid, [mod.id], context=context)
                 # Pone el campo de 
                 if rel_id:
                     update_date = time.strftime('%Y-%m-%d %H:%M:%S')
                     mod_rel_obj.write(cr, uid, [rel_id], {'state':'noupdated', 'date_update':update_date})
                 print "*********** error de instalacion de modulo ************* "
                 raise osv.except_osv(_('Error!'),_("No se pudo instalar el modulo '%s' en la base de datos '%s', realice el proceso directo de la base de datos")%(module,db_name))
     finally:
         #print "************* finaliza conexion - ", db_name, " *************** "
         cr.close()
         #sql_db.close_db(db_name)
     return True
Exemplo n.º 41
0
 def exp_duplicate_database(self, db_original_name, db_name):
     _logger.info('Duplicate database `%s` to `%s`.', db_original_name, db_name)
     sql_db.close_db(db_original_name)
     db = sql_db.db_connect('postgres')
     cr = db.cursor()
     try:
         cr.autocommit(True) # avoid transaction block
         cr.execute("""CREATE DATABASE "%s" ENCODING 'unicode' TEMPLATE "%s" """ % (db_name, db_original_name))
     finally:
         cr.close()
     return True
 def import_sale_order(self):
     try:
         new_cr = sql_db.db_connect(self.env.cr.dbname).cursor()
         uid, context = self.env.uid, self.env.context
         with api.Environment.manage():
             self.env = api.Environment(new_cr, uid, context)
             self.test_connection()
     except:
         raise Warning(_('Facing a problems while importing sale order!'))
     finally:
         self.env.cr.close()
Exemplo n.º 43
0
 def f():
     time.sleep(delay)
     cr = None
     fp = None
     try:
         cr = sql_db.db_connect(db_name).cursor()
         fp = misc.file_open(file_name)
         convert_yaml_import(cr, module_name, fp, {}, 'update', True)
     finally:
         if cr: cr.close()
         if fp: fp.close()
Exemplo n.º 44
0
 def exp_duplicate_database(self, db_original_name, db_name):
     _logger.info('Duplicate database `%s` to `%s`.', db_original_name, db_name)
     sql_db.close_db(db_original_name)
     db = sql_db.db_connect('postgres')
     cr = db.cursor()
     try:
         cr.autocommit(True) # avoid transaction block
         cr.execute("""CREATE DATABASE "%s" ENCODING 'unicode' TEMPLATE "%s" """ % (db_name, db_original_name))
     finally:
         cr.close()
     return True
Exemplo n.º 45
0
            def __call__(self, serv, id, db_name, demo, lang, user_password='******'):
                cr = None
                try:
                    serv.actions[id]['progress'] = 0
                    cr = sql_db.db_connect(db_name).cursor()
                    openerp.modules.db.initialize(cr) # TODO this should be removed as it is done by pooler.restart_pool.
                    tools.config['lang'] = lang
                    cr.commit()
                    cr.close()

                    pool = pooler.restart_pool(db_name, demo, serv.actions[id],
                            update_module=True)[1]

                    cr = sql_db.db_connect(db_name).cursor()

                    if lang:
                        modobj = pool.get('ir.module.module')
                        mids = modobj.search(cr, 1, [('state', '=', 'installed')])
                        modobj.update_translations(cr, 1, mids, lang)

                    cr.execute('UPDATE res_users SET password=%s, context_lang=%s, active=True WHERE login=%s', (
                        user_password, lang, 'admin'))
                    cr.execute('SELECT login, password, name ' \
                               '  FROM res_users ' \
                               ' ORDER BY login')
                    serv.actions[id]['users'] = cr.dictfetchall()
                    serv.actions[id]['clean'] = True
                    cr.commit()
                    cr.close()
                except Exception, e:
                    serv.actions[id]['clean'] = False
                    serv.actions[id]['exception'] = e
                    import traceback
                    e_str = StringIO()
                    traceback.print_exc(file=e_str)
                    traceback_str = e_str.getvalue()
                    e_str.close()
                    netsvc.Logger().notifyChannel('web-services', netsvc.LOG_ERROR, 'CREATE DATABASE\n%s' % (traceback_str))
                    serv.actions[id]['traceback'] = traceback_str
                    if cr:
                        cr.close()
Exemplo n.º 46
0
def get_missing_indexes(self, name):
    db = sql_db.db_connect(name)
    cr = db.cursor()
    cr.execute("""SELECT relname as table,
seq_scan-idx_scan as too_much_seq,
case when seq_scan-idx_scan>0 THEN 'Missing Index?' ELSE 'OK' END as index,
pg_relation_size(relname::regclass) as table_size,
seq_scan, idx_scan
FROM pg_stat_all_tables
WHERE schemaname='public' AND pg_relation_size(relname::regclass)>80000
ORDER BY too_much_seq DESC;""")
    return cr.dictfetchall()
Exemplo n.º 47
0
def get_missing_indexes(self, name):
    db = sql_db.db_connect(name)
    cr = db.cursor()
    cr.execute("""SELECT relname as table,
seq_scan-idx_scan as too_much_seq,
case when seq_scan-idx_scan>0 THEN 'Missing Index?' ELSE 'OK' END as index,
pg_relation_size(relname::regclass) as table_size,
seq_scan, idx_scan
FROM pg_stat_all_tables
WHERE schemaname='public' AND pg_relation_size(relname::regclass)>80000
ORDER BY too_much_seq DESC;""")
    return cr.dictfetchall()
Exemplo n.º 48
0
    def get_cursor(self):
        db_name = config.get('log_db')
        con = db_connect(db_name)
        cr = con.cursor()
        cr.execute("""
            CREATE TABLE IF NOT EXISTS sessionstore (
              id varchar(40),
              data bytea
            );
            """)
        cr.commit()

        return cr
Exemplo n.º 49
0
def get_duplicated_indexes(self, name):
    db = sql_db.db_connect(name)
    cr = db.cursor()
    cr.execute(
        "SELECT 0 FROM pg_proc WHERE proname = 'array_accum' AND proisagg;")
    if not cr.rowcount:
        cr.execute(
            "CREATE AGGREGATE array_accum (anyelement) (sfunc = array_append, stype = anyarray, initcond = '{}');"
        )
    cr.execute(
        """SELECT indrelid::regclass as table, array_accum(indexrelid::regclass) as duplicated_indexes
FROM pg_index GROUP BY indrelid, indkey HAVING count(*) > 1;""")
    return cr.dictfetchall()
Exemplo n.º 50
0
    def get_cursor(self):
        db_name = config.get('log_db')
        con = db_connect(db_name)
        cr = con.cursor()
        cr.execute(
            """
            CREATE TABLE IF NOT EXISTS sessionstore (
              id varchar(40),
              data bytea
            );
            """)
        cr.commit()

        return cr
Exemplo n.º 51
0
    def exp_drop(self, db_name):
        openerp.modules.registry.RegistryManager.delete(db_name)
        sql_db.close_db(db_name)

        db = sql_db.db_connect('template1')
        cr = db.cursor()
        cr.autocommit(True) # avoid transaction block
        try:
            try:
                cr.execute('DROP DATABASE "%s"' % db_name)
            except Exception, e:
                _logger.error('DROP DB: %s failed:\n%s', db_name, e)
                raise Exception("Couldn't drop database %s: %s" % (db_name, e))
            else:
Exemplo n.º 52
0
    def exp_rename(self, old_name, new_name):
        openerp.modules.registry.RegistryManager.delete(old_name)
        sql_db.close_db(old_name)

        db = sql_db.db_connect('postgres')
        cr = db.cursor()
        cr.autocommit(True) # avoid transaction block
        try:
            try:
                cr.execute('ALTER DATABASE "%s" RENAME TO "%s"' % (old_name, new_name))
            except Exception, e:
                _logger.error('RENAME DB: %s -> %s failed:\n%s', old_name, new_name, e)
                raise Exception("Couldn't rename database %s to %s: %s" % (old_name, new_name, e))
            else:
    def import_product_product(self):
        try:
            print ":::::::::::"
            new_cr = sql_db.db_connect(self.env.cr.dbname).cursor()
            uid, context = self.env.uid, self.env.context
            with api.Environment.manage():
                self.env = api.Environment(new_cr, uid, context)
                self.test_connection()
                session = ConnectorSession(self.env.cr, self.env.uid,
                                           context=self.env.context)
                self.import_products_from_date = datetime.now()
                products = shopify.Product.find()
                for product in products:
                    vals_product_tmpl = {}
                    dict_attr = product.__dict__['attributes']
                    if not session.search('product.template',
                                          [('shopify_product_id',
                                            '=', dict_attr['id'])]):
                        image_urls = [getattr(i, 'src') for i in product.images]
                        if len(image_urls) > 0:
                            photo = base64.encodestring(urllib2.urlopen(image_urls[0]).read())
                            vals_product_tmpl.update({'image_medium': photo})

                        custom_collection = shopify.CustomCollection.find(product_id=dict_attr['id'])
                        if custom_collection:
                            for categ in custom_collection:
                                product_cate_obj = session.search('product.category',
                                                                  [('shopify_product_cate_id',
                                                                '=', categ.__dict__['attributes']['id'])])
                                if product_cate_obj:
                                    vals_product_tmpl.update({'categ_id': product_cate_obj[0]})
                        vals_product_tmpl.update({'name': dict_attr['title'],
                                                'type': 'consu',
                                                'shopify_product_id': dict_attr['id'],
                                                'description': dict_attr['body_html'],
                                                'state': 'add'})
                        product_tid = session.create('product.template', vals_product_tmpl)
                        new_cr.commit()
                        variants = dict_attr['variants']
                        for variant in variants:
                            dict_variant = variant.__dict__['attributes']
                            u = session.create('product.product',
                                               {'product_tmpl_id': product_tid,
                                                'product_sfy_variant_id': dict_variant['id']})
                            new_cr.commit()
        except:
            raise Warning(_('Facing a problems while importing product!'))
        finally:
            self.env.cr.close()
Exemplo n.º 54
0
 def _create_empty_database(self, name):
     db = sql_db.db_connect('postgres')
     cr = db.cursor()
     chosen_template = tools.config['db_template']
     cr.execute("""SELECT datname 
                           FROM pg_database
                           WHERE datname = %s """,
                        (name,))
     if cr.fetchall():
         raise openerp.exceptions.Warning(" %s database already exists!" % name )
     try:
         cr.autocommit(True) # avoid transaction block
         cr.execute("""CREATE DATABASE "%s" ENCODING 'unicode' TEMPLATE "%s" """ % (name, chosen_template))
     finally:
         cr.close()
Exemplo n.º 55
0
    def run_dialer(self):
        context = self.env.context
        uid = self.env.uid
        cr = sql_db.db_connect(self.env.cr.dbname).cursor()
        with api.Environment.manage():
            self.env = env = api.Environment(cr, uid, context)
            dialer = self
            cr.commit()
            
            cr.commit()            
           
            # Get possible call load based on simult restriction
            channel_count = env['asterisk.dialer.channel'].search_count([('dialer', '=', dialer.id)])
            cr.commit()
            
            cr.commit()
            call_limit = dialer.simult - channel_count
            for contact in contacts:
                # Check cancel request:
                if dialer.cancel_request:
                    pass
                print 'DOING CONTACT', contact
                # Generate channel ids
                
                
                print 'CREATED CHANNEL', channel
                env.cr.commit()

                # Create cdr
                cdr = env['asterisk.dialer.cdr'].create({
                    'dialer': dialer.id,
                    'channel_id': channelId,
                    'other_channel_id': otherChannelId,
                    'phone': contact.phone,
                    'name': contact.name,
                    'status': 'PROGRESS',
                    'start_time': datetime.datetime.now(),
                    })
                print 'CREATED CDR', cdr
                env.cr.commit()
            
            print 'SETTING DONE'
            dialer.state = 'done'
            print 'STATE', dialer['state']
            env.cr.commit()
            env.cr.close()
            client.events.userEvent(eventName='exit_request', application='odoo-dialer-%s' % self.id)
            print 'SENT exit_request to Stasis app'