예제 #1
0
 def test_yrel_nfield_ylookup(self):
     self.assertDictEqual(
         _get_dissected_lookup(Continent, 'countries__gt'), {
             'relation': ['countries'],
             'field': '',
             'supplement': 'gt',
             'translatable': False,
         })
예제 #2
0
 def test_nrel_yfield_ytranslatable_ylookup(self):
     self.assertDictEqual(
         _get_dissected_lookup(Continent, 'name__icontains'), {
             'relation': [],
             'field': 'name',
             'supplement': 'icontains',
             'translatable': True,
         })
예제 #3
0
 def test_nrel_yfield_ntranslatable_nlookup(self):
     self.assertDictEqual(
         _get_dissected_lookup(Continent, 'code'), {
             'relation': [],
             'field': 'code',
             'supplement': '',
             'translatable': False,
         })
예제 #4
0
 def test_ynestedrel_yfield_ytranslatable_nlookup(self):
     self.assertDictEqual(
         _get_dissected_lookup(Continent, 'countries__cities__name'), {
             'relation': ['countries', 'cities'],
             'field': 'name',
             'supplement': '',
             'translatable': True,
         })
예제 #5
0
 def test_yrel_yfield_ntranslatable_ylookup(self):
     self.assertDictEqual(
         _get_dissected_lookup(Continent, 'countries__code__icontains'), {
             'relation': ['countries'],
             'field': 'code',
             'supplement': 'icontains',
             'translatable': False,
         })
예제 #6
0
    def _get_translations_query(*args, **kwargs):
        connector = kwargs.pop('_connector', None)
        negated = kwargs.pop('_negated', False)

        children = list(args) + sorted(kwargs.items())

        for index, child in enumerate(children):
            if isinstance(child, tuple):
                dissected = _get_dissected_lookup(model, child[0])
                if dissected['translatable']:
                    query_default = False
                    query_languages = None
                    if isinstance(lang, (list, tuple)):
                        query_languages = []
                        for x in lang:
                            if x == default:
                                query_default = True
                            else:
                                query_languages.append(x)
                    else:
                        if lang == default:
                            query_default = True
                            query_languages = None
                        else:
                            query_default = False
                            query_languages = lang

                    q = Q()

                    if query_default:
                        q |= Q(**{child[0]: child[1]})

                    if query_languages:
                        relation = LOOKUP_SEP.join(dissected['relation'] +
                                                   ['translations'])
                        field_supp = (LOOKUP_SEP + dissected['supplement']) \
                            if dissected['supplement'] else ''
                        lang_supp = (LOOKUP_SEP + 'in') \
                            if isinstance(query_languages, (list, tuple)) \
                            else ''

                        q |= Q(
                            **{
                                '{}__field'.format(relation):
                                dissected['field'],
                                '{}__text{}'.format(relation, field_supp):
                                child[1],
                                '{}__language{}'.format(relation, lang_supp):
                                query_languages
                            })
                else:
                    q = Q(**{child[0]: child[1]})
            elif isinstance(child, TQ):
                if child.lang:
                    getter = _fetch_translations_query_getter(
                        model, child.lang)
                    q = getter(*child.children,
                               _connector=child.connector,
                               _negated=child.negated)
                else:
                    q = _get_translations_query(*child.children,
                                                _connector=child.connector,
                                                _negated=child.negated)
            elif isinstance(child, Q):
                q = _get_translations_query(*child.children,
                                            _connector=child.connector,
                                            _negated=child.negated)
            children[index] = q

        query = Q(*children, _connector=connector, _negated=negated)

        return query