__author__  = 'Andy Mikhailenko'

__license__ = 'GNU Lesser General Public License (GPL), Version 3'

__url__     = 'http://bitbucket.org/neithere/django-view-shortcuts/'

from django.utils.translation import ugettext_lazy as _

from decorators import cached_property

def filter_date(items, field_name, year, month=None, day=None):

    """

    Filters given queryset by date if any provided. Accepts three scopes: year, month and day.

    Similar to date_based generic view but for ordinary views.

    Instead of:

        def my_entry_list(request, year=None, month=None, day=None):

            entries = Entry.objects.all()

            if year and month and day:

                entries = entries.filter(pub_date__month=month)

            if year:

                entries = entries.filter(pub_date__year=year)

    ...You can just write:

        def my_entry_list(request, year=None, month=None, day=None):

            entries = Entry.objects.all()

            entries = filter_date(entries, 'pub_date', year, month, day)

def filter_date_range(items, start, end):

    """

    Filters given queryset by date range.

    Useful for queries with lookups (i.e. 'foo__bar') where nested date lookups

    are not possible (e.g. things like 'foo__somedate__year__gte' are not allowed).

    Usage:

    filter_date_range(queryset, start, end)

    where "start" and "end" are tuples of this form: (field_name, year, [month, [day])

    Example:

        def my_entry_list(request, from_year=None, to_year=None):

            people = Entry.objects.all()

            # show all entries of this year

            people = filter_date_range(people, ('joined', from_year), ('left', to_year))

    """

    def __make_qargs(mode, field_name, year, month, day):

        q_field = '%s__%s' % (field_name, mode)

        q_date  = '%s-%s-%s' % (year, month, day)

        return {q_field:q_date}

    def __make_qargs_till(field_name, year, month='12', day='31'):

        return __make_qargs('lte', field_name, year, month, day)

    def __make_qargs_from(field_name, year, month='01', day='01'):

        return __make_qargs('gte', field_name, year, month, day)

    qargs = dict(__make_qargs_from(*start), **__make_qargs_till(*end))

    items = items.filter(**qargs)

    return items

    """

    Filters given queryset by given field.

    This filter does not significantly shorten your code but does make it a bit more readable.

    Instead of:

        def my_entry_list(request, foo=None, bar=None):

            entries = Entry.objects.all()

            if foo:

                entries = entries.filter(foo=foo)

            if bar:

                entries = entries.filter(bar=bar)

    ...You can write:

        def my_entry_list(request, foo=None, bar=None):

            entries = Entry.objects.all()

            entries = filter_field(entries, 'foo', foo)

    Filters given queryset by given field with its value automatically taken from

    given Request parameter. If the param is not specified, it's assumed to be

    of the same name with the field.

    Instead of:

        def my_entry_list(request):

            entries = Entry.objects.all()

            if request.GET.get('foo'):

                entries = entries.filter(foo=request.GET.get('foo'))

            if request.GET.get('barbar'):

                entries = entries.filter(bar=request.GET.get('barbar'))

    You can write:

        def my_entry_list(request):

            entries = Entry.objects.all()

            entries = filter_param(entries, request, 'foo')

        items = items.filter(**{field_name:value})

    return items

class FilterList(list):

    """Filters given queryset by multiple fields with their values automatically

    taken from given HttpRequest parameters. If a parameter is not specified,

        def _generate_filters(request, qs, params, single, sort_by_usage):

            single_triggered = False

            for p in params:

                    lookup, param = p

                else:

                    lookup = param = p

                value = request.GET.get(param)

                if value and not single_triggered:

                    if single:

                        single_triggered = True

                yield f

        super(FilterList, self).__init__(

            _generate_filters(request, qs, params, single, sort_by_usage)

        )

        return self._qs.model.objects.filter(**lookup_params)

class Filter(object):

    """ A facet filter. Objects of this class are instantiated by filter_params()

    and returned along with the queryset.

    Filter objects can then be passed to template and used to generate UI

    for tuning the queryset.

    By default the choices are sorted by usage (most referenced on top). To reset

    Usage: see FilterList.

    Each filter subclass knows how to display a filter for a field that passes a

    certain test -- e.g. being a DateField or ForeignKey.

    """

        self.param = param

        self.qs = qs

        self.lookup = lookup

        self.active = active

        self.sort_by_usage = sort_by_usage

    def __repr__(self):

        return u'<%s "%s": %s>' % (self.__class__.__name__, self.param, self.active)

    @classmethod

    @classmethod

    @cached_property

    def urlencode(self):

        """Returns possible choices, each annotated with the number of linked

        objects. Multiple FKs from one model to another are supported as well as

        explicit choice lists and implicit ones (i.e. any possible values).

        Resulting list contains FilterChoice objects.

        An existing choice will be excluded from results if:

          a) it is not used by any object in current queryset;

          b) it is used but is not in the field's explicit list of choices

             (i.e. the "choices" keyword).

        """

        return list(self.generate_choices())

    def get_active_choices(self):

        "Returns list of currently selected options for this filter."

        for c in self.choices:

            if c.active:

                yield c

    def get_first_active_choice(self):

        "Returns one of currently selected options for this filter (usually enough)."

        for c in self.get_active_choices():

        """Counts related objects for each choice in given queryset (i.e. discover

        how popular is each option). Returns annotated queryset.

        """

        choices = choices.annotate(items_count=models.Count(by))

        if self.sort_by_usage:

            choices = choices.order_by('-items_count')

        return choices

class RelationFilter(Filter):

    def extra_title(self):

        if isinstance(self.field, models.ManyToManyField):

            return self.field.rel.to._meta.verbose_name

    def generate_choices(self):

        # TODO: when multiple filters are active, count only intersections (? - can be heavy)

        related_name = getattr(self.field.rel, 'related_name', None) or \

                self.qs.model._meta.module_name

        # get all possible choices

        for c in choices:

            yield FilterChoice(self, unicode(c), c.pk, c.items_count)

'''

class DateFadeoutFilter(Filter):

    "Represents dates as single-level categories by remoteness from now."

    # see django.contrib.admin.filterspecs.DateFieldFilterSpec

    pass

class DateDrilldownFilter(Filter):

    "Represents dates as nested levels for year, month and day."

    pass

'''

class BooleanFilter(Filter):

    def generate_choices(self):

        # retrieve unique values and count how many times each is used

        choices = self.qs.values(self.lookup).distinct()

                v = unicode(c.get(self.lookup))

                if v == val:

                    yield FilterChoice(self, name, val, c['items_count'])

class AllValuesFilter(Filter):

    def generate_choices(self):

        # retrieve unique values and count how many times each is used

        for c in choices:

            yield FilterChoice(self, _title(c), _value(c), c['items_count'])

class FilterChoice(object):

    def __init__(self, filter, title, value, items_count):

        self.title = title

        self.value = value

        self.items_count = items_count

    @cached_property

    def urlencode(self):

        return urlencode({self.filter.param: self.value})

    @cached_property

    def active(self):

        "Returns True if the choice value equals to the filter's current value."

        except TypeError, ValueError:

            return False

def filter_params(qs, request, params, single=False):

    warnings.warn("filter_params() is deprecated, use FilterList() instead.",

                  DeprecationWarning, 2)

>>> s3.category=[c2]

>>> s3.save()

>>> qs = Story.objects.all()

>>> request = mock_request()

>>> isinstance(filters, FilterList)

True

>>> len(filters)

>>> filters.object_list

[<Story: s1>, <Story: s2>, <Story: s3>]

>>> request = mock_request(author=a1.pk)

>>> filters

[<RelationFilter "category": False>, <RelationFilter "author": True>, <AllValuesFilter "status": False>, <BooleanFilter "paid": False>]

>>> filters.active

>>> filters.object_list

[<Story: s1>, <Story: s3>]

>>> request = mock_request(author=a1.pk, status=Story.PUBLISHED)

>>> filters.active

[<RelationFilter "author": True>, <AllValuesFilter "status": True>]

>>> filters.urlencode

'author=1&status=pub'

>>> filters

[<RelationFilter "category": False>, <RelationFilter "author": True>, <AllValuesFilter "status": True>, <BooleanFilter "paid": False>]

>>> filters.object_list

    - yes (2) --> [paid=True]

    - no (1) --> [paid=False]

>>> qs_predefined = Story.objects.filter(status=Story.PUBLISHED)

>>> for f in filters:

...     print u'%s:   [%s]' % (f.title, f.urlencode)

...     for c in f.choices:

    - yes (1) --> [paid=True]

    - no (1) --> [paid=False]

>>> qs_predefined = Story.objects.filter(author__name__contains='J')

>>> filters._qs            # predefined query

[<Story: s1>, <Story: s3>]

>>> filters.clean_query    # query made from scratch, no traces of predefined stuff

class RequestFactory(Client):

    """

    Class that lets you create mock Request objects for use in testing.

    Usage:

    rf = RequestFactory()

    get_request = rf.get('/hello/')

    post_request = rf.post('/submit/', {'foo': 'bar'})

    This class re-uses the django.test.client.Client interface, docs here:

    http://www.djangoproject.com/documentation/testing/#the-test-client

    just as if that view had been hooked up using a URLconf.

    Source: http://www.djangosnippets.org/snippets/963/

    """

    def request(self, **request):