from conservancy.apps.blog.models import Entry, EntryTag # relative import

# from django.views.generic.list_detail import object_list

from django.views.generic import ListView

from django.views.generic.dates import YearArchiveView, MonthArchiveView, DayArchiveView, DateDetailView

from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger

from conservancy.apps.staff.models import Person

from django.shortcuts import get_object_or_404, render_to_response

from datetime import datetime

def OR_filter(field_name, objs):

    from django.db.models import Q

    return reduce(lambda x, y: x | y,

                  [Q(**{field_name: x.id}) for x in objs])

def last_name(person):

    return person.formal_name.rpartition(' ')[2]

def custom_index(request, queryset, *args, **kwargs):

    """Blog list view that allows scrolling and also shows an index by

    year.

    """

    kwargs = kwargs.copy()

    kwargs['extra_context'] = kwargs.get('extra_context', {}).copy()

    extra_context = kwargs['extra_context']

    date_field = kwargs['date_field']

    del kwargs['date_field']

    if not kwargs.get('allow_future', False):

        queryset = queryset.filter(**{'%s__lte' % date_field: datetime.now()})

    else:

        date_list = queryset.dates(date_field, 'year')

        extra_context['date_list'] = date_list

    # return object_list(request, queryset, *args, **kwargs)

    kwargs['queryset'] = queryset

    kwargs['extra_context'] = extra_context

    paginate_by = kwargs.get('paginate_by', 6)  # Show 6 news items per page, by default

    paginator = Paginator(queryset, paginate_by)

    page = request.GET.get('page')

    try:

        blog_entries = paginator.page(page)

    except PageNotAnInteger:

        # If page is not an integer, deliver first page.

        blog_entries = paginator.page(1)

    except EmptyPage:

        # If page is out of range (e.g. 9999), deliver last page of results.

        blog_entires = paginator.page(paginator.num_pages)

    extra_context['blog_entries'] = blog_entries

def techblog_redirect(request):

    """Redirect from the old 'techblog' to the new blog

    """

    path = request.path[len('/technology'):]

    if path == '/blog/':

        path += "?author=bkuhn"

    return relative_redirect(request, path)

def query(request):

    """Page to query the blog based on authors and tags

    """

    if request.GET:

        d = request.GET.copy()

        if 'authors' in d.getlist('all'):

            d.setlist('author', []) # remove author queries

        if 'tags' in d.getlist('all'):

            d.setlist('tag', []) # remove tag queries

        d.setlist('all', []) # remove "all" from the query string

        base_url = '/blog/'

        if 'rss' in d:

            base_url = '/feeds/blog/'

            d.setlist('rss', []) # remove it

        query_string = d.urlencode()

        return relative_redirect(request, '%s%s%s' % (base_url, '?' if query_string else '', query_string))

    else:

        authors = sorted(Person.objects.filter(currently_employed=True,

                                               entry__isnull=False).distinct(),

                         key=last_name)

        tags = EntryTag.objects.all().order_by('label')

        return render_to_response('blog/query.html',

def relative_redirect(request, path):

    from django import http

    from django.conf import settings

    host = request.get_host()

    if settings.FORCE_CANONICAL_HOSTNAME:

        host = settings.FORCE_CANONICAL_HOSTNAME

    url = "%s://%s%s" % (request.is_secure() and 'https' or 'http', host, path)

    return http.HttpResponseRedirect(url)

class BlogYearArchiveView(YearArchiveView):

    make_object_list = True

    allow_future = True

    extra_context = {}

    def get_context_data(self, **kwargs):

        context = super(BlogYearArchiveView, self).get_context_data(**kwargs)

        context.update(self.extra_context)

        return context

class BlogMonthArchiveView(MonthArchiveView):

    allow_future = True

from django.shortcuts import render_to_response

from django import forms

from conservancy.apps.contacts.models import ContactEntry

from django.forms import ModelForm

def subscribe(request):

    """Mailing list subscription form

    """

    class ContactEntryForm(ModelForm):

        class Meta:

            model = ContactEntry

    ContactEntryForm.base_fields['subscribe_conservancy'].label = 'Receive Software Freedom Conservancy updates'

    if request.method == 'POST':

        form = ContactEntryForm(request.POST)

        if form.is_valid():

            form.save()

            return render_to_response('contacts/subscribe_success.html',

    else:

        form = ContactEntryForm()

    return render_to_response('contacts/subscribe.html',

# from django.views.generic.list_detail import object_list

from django.shortcuts import render_to_response

from django.http import Http404, HttpResponse

from django.template import loader

from django.core.exceptions import ObjectDoesNotExist

from conservancy.apps.events.models import Event

# for debugging...

from django.http import HttpResponse

def event_detail(request, year, slug, queryset, **kwargs):

    """This view shows event detail.

    Nothing special, but it is necessary because

    django.views.generic.date_based.object_detail only works with

    slugs that are unique and specified by day, but we make slugs

    unique by year.

    """

    try:

        event = queryset.get(date__year=year, slug__exact=slug)

    except ObjectDoesNotExist:

        raise Http404, "Event does not exist"

def custom_index(request, queryset, *args, **kwargs):

    """Scrollable index of future and past events, with date index.

    """

    future_events = None

    if not request.GET.has_key("page"):

        future_events = Event.future.all().order_by("date")

    date_list = queryset.dates(kwargs['date_field'], 'year')

    kwargs = dict(kwargs, extra_context={'date_list': date_list,

                                         'future_events': future_events})

    del kwargs['date_field']

    del kwargs['allow_future']

    # return object_list(request, queryset, *args, **kwargs)

    return HttpResponse("FIXME: events must be updated like blog and news.")

def future_event_ics(request, queryset, *args, **kwargs):

    """ICS calendar view of future events

    This view just renders information into a template that looks like

    an ics file.  If in the future we want a 'real' implementation of

from conservancy.apps.fundgoal.models import FundraisingGoal

from django.shortcuts import get_object_or_404, render_to_response

from django.http import JsonResponse

def view(request):

    """JSON version of request

    """

    keysForJSON = [ 'fundraiser_goal_amount', 'fundraiser_so_far_amount', 'fundraiser_donation_count',

                    'fundraiser_donation_count_disclose_threshold' ]

    GET = request.GET

    codeNames =  []

    if 'code_name' in GET: codeNames += GET.getlist('code_name')

    returnDict = {}

    for fundGoal in FundraisingGoal.objects.filter(fundraiser_code_name__in=codeNames):

        codeName = fundGoal.fundraiser_code_name

        returnDict[codeName] = {}

        for kk in keysForJSON:

            if hasattr(fundGoal, kk):

                returnDict[codeName][kk] = getattr(fundGoal, kk)

    return JsonResponse( returnDict)

# from django.views.generic.list_detail import object_list

from django.views.generic import ListView

from django.shortcuts import render_to_response

from django.views.generic.dates import YearArchiveView, MonthArchiveView, DayArchiveView, DateDetailView

from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger

from conservancy.apps.news.models import ExternalArticle

from conservancy.apps.news.models import PressRelease

from conservancy.apps.events.models import Event

from datetime import datetime

# for debugging...

from django.http import HttpResponse

class NewsListView(ListView):

    extra_context = {}

    def get_context_data(self, **kwargs):

        context = super(NewsListView, self).get_context_data(**kwargs)

        # context['key'] = 'value'

        context.update(self.extra_context)

        return context

def listing(request, *args, **kwargs):

    news_queryset = PressRelease.objects.all()

#    if (not kwargs.has_key('allow_future')) or not kwargs['allow_future']:

    news_queryset = news_queryset.filter(**{'%s__lte' % kwargs['date_field']:

                          datetime.now()})

    date_list = news_queryset.dates(kwargs['date_field'], 'year')

    paginate_by = kwargs.get('paginate_by', 6)  # Show 6 news items per page, by default

    paginator = Paginator(news_queryset, paginate_by)

    page = request.GET.get('page')

    try:

        news = paginator.page(page)

    except PageNotAnInteger:

        # If page is not an integer, deliver first page.

        news = paginator.page(1)

    except EmptyPage:

        # If page is out of range (e.g. 9999), deliver last page of results.

        news = paginator.page(paginator.num_pages)

class NewsYearArchiveView(YearArchiveView):

    # queryset = Article.objects.all()

    # date_field = "pub_date"

    make_object_list = True

    allow_future = True

# def archive_year(request, **kwargs):

#     callable = NewsYearArchiveView.as_view(**kwargs)

#     return callable(request)

class NewsMonthArchiveView(MonthArchiveView):

    allow_future = True

# def archive_month(request, **kwargs):

#     # return HttpResponse("archive_month")

#     callable = NewsMonthArchiveView.as_view(**kwargs)

#     return callable(request)

class NewsDayArchiveView(DayArchiveView):

    allow_future = True

# def archive_day(request, **kwargs):

#     # return HttpResponse("archive_day")

from django.shortcuts import render_to_response

from django import forms

from conervancy.apps.summit_registration.models import SummitRegistration

def register(request):

    """Summit registration form view

    """

    class SummitForm(ModelForm):

        class Meta:

            model = SummitRegistration

    SummitForm.base_fields['email'].label = 'Email address'

    SummitForm.base_fields['phone'].label = 'Phone number'

    SummitForm.base_fields['address'].label = 'Mailing address'

    SummitForm.base_fields['cle_credit'].label = 'Attending for CLE credit?'

    if request.method == 'POST':

        form = SummitForm(request.POST)

        if form.is_valid():

            form.save()

            return render_to_response('summit_registration/register_success.html',

    else:

        form = SummitForm()

    return render_to_response('summit_registration/register.html',

from conservancy.apps.supporters.models import Supporter

from django.shortcuts import get_object_or_404, render_to_response

from django.contrib.syndication.views import Feed

from django.utils.feedgenerator import Rss201rev2Feed 

from conservancy.apps.news.models import PressRelease

from conservancy.apps.blog.models import Entry as BlogEntry

from django.shortcuts import render_to_response

from django.conf import settings

from datetime import datetime

import itertools

import operator

class ConservancyFeedBase(Feed):

    def copyright_holder(self): return "Software Freedom Conservancy"

    def license_no_html(self): return "Licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported License."

    def item_copyright(self, item):

        year = 2008

        for attr in ('pub_date', 'date_created', 'date_last_modified'):

            if hasattr(item, attr):

                if hasattr(getattr(item, attr), 'year'):

                    year = getattr(getattr(item, attr), 'year')

                    break

        return 'Copyright (C) %d, %s.  %s' % (year, self.copyright_holder(), self.license_no_html())

    def item_extra_kwargs(self, item):

        year = 2008

        for attr in ('pub_date', 'date_created', 'date_last_modified'):

        def OR_filter(field_name, subfield_name, objs):

            from django.db.models import Q

            return reduce(lambda x, y: x | y,

                          [Q(**{'%s__%s' % (field_name, subfield_name): x})

                           for x in objs])

        queryset = BlogEntry.objects.filter(pub_date__lte=datetime.now())

        if 'author' in GET:

            authors = GET.getlist('author')

            queryset = queryset.filter(OR_filter('author', 'username', authors))

        if 'tag' in GET:

            tags = GET.getlist('tag')

            queryset = queryset.filter(OR_filter('tags', 'slug', tags))

        return queryset.order_by('-pub_date')[:10]

def view(request):

    """Listing of all available feeds

    """

    feeds = (PressReleaseFeed, BlogFeed, OmnibusFeed)

from django.shortcuts import render_to_response

from conservancy.apps.supporters.models import Supporter as Supporter

from conservancy.apps.news.models import PressRelease

from conservancy.apps.blog.models import Entry as BlogEntry

from datetime import datetime, timedelta

def view(request):

    """Conservancy front page view

    Performs all object queries necessary to render the front page.

    """

    supporters_count = len(Supporter.objects.all().filter(display_until_date__gte=datetime.now()))

    press_releases = PressRelease.objects.all().filter(pub_date__lte=datetime.now(), sites=2)[:5]

    blog = BlogEntry.objects.all().filter(pub_date__lte=datetime.now())[:3]

    c = {

        'press_releases': press_releases,

        'supporters_count': supporters_count,

        'blog' : blog

    }

from django.shortcuts import render_to_response

from conservancy.apps.supporters.models import Supporter as Supporter

from datetime import datetime, timedelta

def view(request):

    """Conservancy Sponsors Page view

    Performs object queries necessary to render the sponsors page.

    """

    supporters = Supporter.objects.all().filter(display_until_date__gte=datetime.now())

    supporters_count = len(supporters)

    anonymous_count  = len(supporters.filter(display_name = 'Anonymous'))

    supporters = supporters.exclude(display_name = 'Anonymous').order_by('ledger_entity_id')

    c = {

        'supporters' : supporters,

        'supporters_count' : supporters_count,

        'anonymous_count' : anonymous_count

    }

def handler500(request):

    return handler(request, '500')

def fundgoal_lookup(fundraiser_sought):

    try:

        return FundraisingGoal.objects.get(fundraiser_code_name=fundraiser_sought)

    except FundraisingGoal.DoesNotExist:

     # we have no object!  do something

        return None

def index(request, *args, **kwargs):

    # return HttpResponse("Hello, static world: " + request.get_full_path())

    path = request.get_full_path()

    path = path.lstrip('/')

    if path[-1:] == '/':

        path += 'index.html'

    STATIC_ROOT = '/home/www/website/www/conservancy/static/'

    fullpath = STATIC_ROOT + path

    if not os.path.exists(fullpath):

        # return HttpResponse("Sorry that's a 404: " + path)

        return handler404(request)

    template = loader.get_template(path)

    if kwargs.has_key('fundraiser_sought'):

        kwargs['fundgoal'] = fundgoal_lookup(kwargs['fundraiser_sought'])

    context = RequestContext(request, kwargs)

    return HttpResponse(template.render(context))

def debug(request):

    path = request.get_full_path()

    path = path.lstrip('/')

    return HttpResponse("Hello, static world: " + path)