Join the social network of Tech Nerds, increase skill rank, get work, manage projects...
 
  • How to set the Advanced filters in OpenERP(Odoo)?

    • 0
    • 2
    • 1
    • 1
    • 0
    • 0
    • 0
    • 0
    • 3.15k
    Comment on it

    Step-1 Install the web_advanced_filters module.
    Step-2 After that custmozie .py(Python file) file in web_advanced_filters module:
    In below example, I have custmozied .py file. You can directly copy the below python code in your .py file.

     class IrFilters(Model):
        _inherit = 'ir.filters'
        _evaluate_before_negate = ['one2many', 'many2many']
    
        def _is_frozen_get(self, cr, uid, ids, field_name, args, context=None):
            '''determine if this is fixed list of ids'''
            result = {}
            for this in self.browse(cr, uid, ids, context=context):
                try:
                    domain = safe_eval(this.domain)
                except:
                    domain = [expression.FALSE_LEAF]
                result[this.id] = (len(domain) == 1 and
                                   expression.is_leaf(domain[0]) and
                                   domain[0][0] == 'id')
            return result
    
        def _domain_get(self, cr, uid, ids, field_name, args, context=None):
            '''combine our domain with all domains to union/complement,
            this works recursively'''
            def eval_n(domain):
                '''parse a domain and normalize it'''
                try:
                    domain = safe_eval(domain)
                except:
                    domain = [expression.FALSE_LEAF]
                return expression.normalize_domain(
                    domain or [expression.FALSE_LEAF])
    
            result = {}
            for this in self.read(
                    cr, uid, ids,
                    ['domain_this', 'union_filter_ids', 'complement_filter_ids'],
                    context=context):
                domain = eval_n(this['domain_this'])
                for u in self.read(cr, uid, this['union_filter_ids'],
                                   ['domain', 'evaluate_always', 'model_id'],
                                   context=context):
                    if u['evaluate_always']:
                        matching_ids = self.pool[u['model_id']].search(
                            cr, uid, eval_n(u['domain']),
                            context=context)
                        domain = expression.OR([
                            domain,
                            [('id', 'in', matching_ids)],
                        ])
                    else:
                        domain = expression.OR([domain, eval_n(u['domain'])])
                for c in self.read(cr, uid, this['complement_filter_ids'],
                                   ['domain', 'evaluate_before_negate',
                                    'model_id'],
                                   context=context):
                    if c['evaluate_before_negate']:
                        matching_ids = self.pool[c['model_id']].search(
                            cr, uid, eval_n(c['domain']),
                            context=context)
                        domain = expression.AND([
                            domain,
                            [('id', 'not in', matching_ids)],
                        ])
                    else:
                        domain = expression.AND([
                            domain,
                            ['!'] + eval_n(c['domain'])])
                result[this['id']] = str(expression.normalize_domain(domain))
            return result
    
        def _domain_set(self, cr, uid, ids, field_name, field_value, args,
                        context=None):
            self.write(cr, uid, ids, {'domain_this': field_value})
    
        def _evaluate_get(self, cr, uid, ids, field_name, args, context=None):
            """check if this filter contains references to x2many fields. If so,
            then negation goes wrong in nearly all cases, so we evaluate the
            filter and remove its resulting ids"""
            result = {}
            for this in self.read(cr, uid, ids, ['model_id', 'domain'],
                                  context=context):
                result[this['id']] = {
                    'evaluate_before_negate': False,
                    'evaluate_always': False,
                }
                domain = expression.normalize_domain(
                    safe_eval(this['domain'] or 'False') or
                    [expression.FALSE_LEAF])
                for arg in domain:
                    if not expression.is_leaf(arg) or not isinstance(
                            arg[0], basestring):
                        continue
                    current_model = self.pool.get(this['model_id'])
                    if not current_model:
                        continue
                    has_x2many = False
                    has_auto_join = False
                    for field_name in arg[0].split('.'):
                        if field_name in MAGIC_COLUMNS:
                            continue
                        field = current_model._all_columns[field_name].column
                        has_x2many |= field._type in self._evaluate_before_negate
                        has_x2many |= isinstance(field, fields.function)
                        has_auto_join |= field._auto_join
                        has_auto_join |= isinstance(field, fields.function)
                        if hasattr(field, '_obj'):
                            current_model = self.pool.get(field._obj)
                        if not current_model or has_x2many and has_auto_join:
                            break
                    result[this['id']]['evaluate_before_negate'] |= has_x2many
                    result[this['id']]['evaluate_always'] |= has_auto_join
                    if result[this['id']]['evaluate_before_negate'] and\
                            result[this['id']]['evaluate_always']:
                        break
            return result
    
        _columns = {
            'is_frozen': fields.function(
                _is_frozen_get, type='boolean', string='Frozen'),
            'union_filter_ids': fields.many2many(
                'ir.filters', 'ir_filters_union_rel', 'left_filter_id',
                'right_filter_id', 'Add result of filters',
                domain=['|', ('active', '=', False), ('active', '=', True)]),
            'complement_filter_ids': fields.many2many(
                'ir.filters', 'ir_filters_complement_rel', 'left_filter_id',
                'right_filter_id', 'Remove result of filters',
                domain=['|', ('active', '=', False), ('active', '=', True)]),
            'active': fields.boolean('Active'),
            'domain': fields.function(
                _domain_get, type='text', string='Domain',
                fnct_inv=_domain_set),
            'domain_this': fields.text(
                'This filter\'s own domain', oldname='domain'),
            'evaluate_before_negate': fields.function(
                _evaluate_get, type='boolean', multi='evaluate',
                string='Evaluate this filter before negating',
                help='This is necessary if this filter contains positive operators'
                'on x2many fields'),
            'evaluate_always': fields.function(
                _evaluate_get, type='boolean', multi='evaluate',
                string='Always evaluate this filter before using it',
                help='This is necessary if this filter contains x2many fields with'
                '_auto_join activated'),
            'save_as_public': fields.function(
                lambda self, cr, uid, ids, *args, **kwargs:
                dict((i, False) for i in ids),
                fnct_inv=lambda *args, **kwargs: None,
                type='boolean',
                string='Share with all users'),
        }
    
        _defaults = {
            'active': True,
            'save_as_public': False,
        }
    
        def _evaluate(self, cr, uid, ids, context=None):
            assert len(ids) == 1
            this = self.browse(cr, uid, ids[0], context=context)
            return self.pool[this.model_id].search(
                cr, uid, safe_eval(this.domain), context=safe_eval(this.context))
    
        def button_save(self, cr, uid, ids, context=None):
            return {'type': 'ir.actions.act_window.close'}
    
        def button_freeze(self, cr, uid, ids, context=None):
            '''evaluate the filter and write a fixed [('id', 'in', [])] domain'''
            for this in self.browse(cr, uid, ids, context=context):
                ids = this._evaluate()
                removed_filter_ids = [f.id for f in itertools.chain(
                    this.union_filter_ids, this.complement_filter_ids)]
                this.write({
                    'domain': str([('id', 'in', ids)]),
                    'union_filter_ids': [(6, 0, [])],
                    'complement_filter_ids': [(6, 0, [])],
                })
                # if we removed inactive filters which are orphaned now, delete
                # them
                cr.execute('''delete from ir_filters
                           where
                            not active and id in %s
                            and not exists (select right_filter_id
                                from ir_filters_union_rel where left_filter_id=id)
                            and not exists (select right_filter_id
                                from ir_filters_complement_rel where
                                left_filter_id=id)
                            ''',
                           (tuple(removed_filter_ids),))
    
        def button_test(self, cr, uid, ids, context=None):
            for this in self.browse(cr, uid, ids, context=context):
                return {
                    'type': 'ir.actions.act_window',
                    'name': _('Testing %s') % this.name,
                    'res_model': this.model_id,
                    'domain': this.domain,
                    'view_type': 'form',
                    'view_mode': 'tree,form',
                    'context': {
                        'default_filter_id': this.id,
                    },
                }
    
        def _auto_init(self, cr, context=None):
            cr.execute(
                'SELECT count(attname) FROM pg_attribute '
                'WHERE attrelid = '
                '( SELECT oid FROM pg_class WHERE relname = %s) '
                'AND attname = %s', (self._table, 'domain_this'))
            if not cr.fetchone()[0]:
                cr.execute(
                    'ALTER table %s RENAME domain TO domain_this' % self._table)
            return super(IrFilters, self)._auto_init(cr, context=context)
    
        def _migrate_name_change(self, cr, uid, context=None):
            cr.execute(
                "select id from ir_module_module where name='advanced_filters' "
                "and author='Therp BV'")
            old_name_installed = cr.fetchall()
            if not old_name_installed:
                return
            cr.execute(
                "delete from ir_model_data where module='web_advanced_filters'")
            cr.execute(
                "update ir_model_data set module='web_advanced_filters' "
                "where module='advanced_filters'")
            cr.execute(
                "update ir_module_module set state='to remove' where "
                "name='advanced_filters' and state not in "
                "('uninstalled', 'to remove')")
    
        def create(self, cr, uid, values, context=None):
            values.setdefault(
                'user_id', False if values.get('save_as_public') else uid)
            return super(IrFilters, self).create(cr, uid, values, context=context)

 0 Comment(s)

Sign In
                           OR                           
                           OR                           
Register

Sign up using

                           OR                           
Forgot Password
Fill out the form below and instructions to reset your password will be emailed to you:
Reset Password
Fill out the form below and reset your password: