~ltp-devs/loco-team-portal/0.2

# -*- coding: utf-8 -*-
from django.template import RequestContext
from django.http import HttpResponse, HttpResponseRedirect, Http404
from django.shortcuts import (render_to_response, redirect, get_object_or_404, get_list_or_404)
from django.contrib.auth.decorators import login_required
from django.utils import simplejson
from django.utils.translation import ugettext as _
from django.db.models import Count

from .models import (TeamEvent, GlobalEvent, Attendee, TeamEventComment)
from teams.models import Team

from .forms import (TeamEventForm, TeamEventCommentForm,
                    GlobalEventForm, AttendeeRegistrationForm)

from common.forms import FilterHistoryList
from common import launchpad

import datetime
import vobject


def event_list(request):
    """
    a list with all events (teamevents and globalevents)
    """
    team_event_list = TeamEvent.objects.next_events()
    global_event_list = GlobalEvent.objects.next_events().annotate(num_teamevents=Count('teamevent'))
    is_on_lc = launchpad.is_user_on_loco_council(request.user)
    context = {
        'team_event_list': team_event_list,
        'global_event_list': global_event_list,
        'user_is_on_lc': is_on_lc,
    }
    return render_to_response('events/event_list.html', context,
                  RequestContext(request))


def event_list_ical(events, name):
    """Return any list events as an ical"""
    filename = "%s.ics" % name.replace(' ', '-').lower()
    response = HttpResponse(mimetype='text/calendar')
    response['Content-Disposition'] = 'attachment; filename=%s' % filename.encode('ascii', 'replace')
    calendar = vobject.iCalendar()
    calendar.add('prodid').value = '-//loco.ubuntu.com//EN'
    calendar.add('calscale').value = 'GREGORIAN'
    calendar.add('method').value = 'PUBLISH'
    calendar.add('x-wr-calname').value = name
    calendar.add('x-wr-caldesc').value = name
    for event in events:
        event.as_ical(calendar)
    response.write(calendar.serialize())

    return response


def event_ical(request, team_slug, team_event_id):
    """
    Return a ical list with a single events in ical format.
    """
    team_event_object = get_object_or_404(TeamEvent, pk=team_event_id)
    return event_list_ical([team_event_object], team_event_object.name)


def team_event_list_ical(request, team_slug):
    """
    Return a ical list with a single team events in ical format.
    """
    team = get_object_or_404(Team, lp_name=team_slug)
    team_events = TeamEvent.objects.filter(teams__lp_name=team_slug)
    return event_list_ical(team_events, team.name)


def teams_event_list_ical(request):
    """
    Return a ical list with team events in ical format.
    """
    return event_list_ical(TeamEvent.objects.all(), 'All Ubuntu LoCo Team Events')


def global_event_list_ical(request):
    """
    Return a ical list with global events in ical format.
    """
    return event_list_ical(GlobalEvent.objects.all(), 'Ubuntu Global Events')


def event_history_list(request):
    """
    a list with all historical events (teamevents and globalevents)
    """
    team_event_list = TeamEvent.objects.history_events().select_related('global_event', 'venue')

    if request.method == 'POST':
        form = FilterHistoryList(request.POST)
        if form.is_valid():

            filtering = form.cleaned_data['filtering']

            scope = form.cleaned_data['scope']

            if u'my' in scope:
                filtering_date = datetime.datetime.strptime(filtering, "%Y-%m")

                team_event_list = TeamEvent.objects.history_events().filter(date_begin__year=filtering_date.year, date_begin__month=filtering_date.month)
            elif u'y' in scope:
                filtering_date = datetime.datetime.strptime(filtering, "%Y-%m")

                team_event_list = TeamEvent.objects.history_events().filter(date_begin__year=filtering_date.year)
        else:
            team_event_list = TeamEvent.objects.history_events().select_related('global_event', 'venue')

    else:
        form = FilterHistoryList()
        team_event_list = TeamEvent.objects.history_events().select_related('global_event', 'venue')

    global_event_list = GlobalEvent.objects.history_events().annotate(num_teamevents=Count('teamevent'))

    context = {
        'form': form,
        'team_event_list': team_event_list,
        'global_event_list': global_event_list,
    }
    return render_to_response('events/event_history_list.html', context,
                  RequestContext(request))


#################################################################
# Team Events
#################################################################
def team_event_detail(request, team_slug, team_event_id, event_slug=None):
    """
    detailed view for a team event
    """
    team_event = get_object_or_404(TeamEvent, pk=team_event_id)
    is_member = False
    for team_object in team_event.teams.all():
        is_member = is_member or launchpad.is_team_member(request.user, team_object)

    if request.user.is_authenticated():
        if request.method == 'POST':
            form = TeamEventCommentForm(data=request.POST)
            if form.is_valid():
                team_event_comment = form.save(commit=False)
                team_event_comment.team_event = team_event
                team_event_comment.commenter_profile = request.user.get_profile()
                team_event_comment.save()
                request.user.message_set.create(message=_('Your comment has been saved.'))
                return redirect(team_event)
        else:
            form = TeamEventCommentForm()
    else:
        form = None

    context = {
        'team_event': team_event,
        'user_is_attending': team_event.is_attending(request.user),
        'user_is_team_member': is_member,
        'form': form,
    }
    return render_to_response('events/team_event_detail.html',
                                         context, RequestContext(request))


@login_required
def team_event_delete(request, team_slug, team_event_id):
    """
    delete a event
    """
    team_event_object = get_object_or_404(TeamEvent, pk=team_event_id)

    is_on_lc = launchpad.is_user_on_loco_council(request.user)
    #check if user is admin or owner of a team
    is_contact = False
    for team in team_event_object.teams.all():
        if launchpad.is_admin_or_owner(request.user.username, team):
            is_contact = True
            break

    if is_on_lc or is_contact:
        if request.method == 'POST':
            team_event_object.delete()
            request.user.message_set.create(message=_('Team Event removed.'))
            return redirect('event-list')
        else:
            context = {'team_event_object': team_event_object}
            return render_to_response('events/team_event_delete_confirm.html', context, RequestContext(request))
    else:
        request.user.message_set.create(message='%s %s' % (_('You can not remove this team event.'), _('You are not an admin/owner of the Launchpad team or on the LoCo Council.')))
        return redirect(team_event_object)


@login_required
def team_event_select(request):
    teams = Team.objects.filter(lp_name__in=[g.name for g in request.user.groups.all()])
    if len(teams) == 0:
        request.user.message_set.create(message='%s %s' % (_('You can not add a new team event.'), _('You are not a member of any LoCo Teams.')))
        return redirect('event-list')
    elif len(teams) == 1:
        from django.core import urlresolvers
        url = urlresolvers.reverse('team-event-new', args=[teams[0].lp_name])
        if 'global_event_id' in request.GET:
            return HttpResponseRedirect('%s?global_event_id=%s' % (url, request.GET.get('global_event_id', None)))
        else:
            return HttpResponseRedirect(url)
    else:
        context = {'teams': teams, 'global_event_id': request.GET.get('global_event_id', None)}
        return render_to_response('events/team_event_new_select.html', context, RequestContext(request))


def team_events_rss(request, team_slug):
    return redirect('/feeds/events/%s/' % team_slug, permanent=True)


@login_required
def team_event_new(request, team_slug):
    """
    new team event
    """
    team_object = get_object_or_404(Team, lp_name=team_slug)

    is_on_lc = launchpad.is_user_on_loco_council(request.user)
    is_member = launchpad.is_team_member(request.user, team_object)

    if is_on_lc or is_member:
        global_event = None
        if request.method == 'POST':
            form = TeamEventForm(data=request.POST, teams=[team_object])
            if form.is_valid():
                team_event = form.save(commit=False)
                team_event.created_by = request.user
                team_event.save()
                team_event.teams.add(team_object)
                return HttpResponseRedirect(team_event.get_absolute_url())
        else:
            form = TeamEventForm(initial={'global_event': request.GET.get('global_event_id', None)}, teams=[team_object])
            if 'global_event_id' in request.GET:
                global_event = get_object_or_404(GlobalEvent, pk=request.GET.get('global_event_id'))
        context = {
            'team_object': team_object,
            'form': form,
            'global_event': global_event,
        }
        return render_to_response('events/team_event_new.html',
                                         context, RequestContext(request))
    else:
        # XXX: Once we move to a new ACL system, this needs fixing.
        request.user.message_set.create(message='%s %s' % (_('You can not add a new event for this team.'), _('You are not a member of the team or on the LoCo Council.')))
        return redirect(team_object)


@login_required
def team_event_copy(request, team_slug, team_event_id):
    """
    new team event
    """

    team_event = get_object_or_404(TeamEvent, pk=team_event_id)
    teams = team_event.teams.all()

    is_on_lc = launchpad.is_user_on_loco_council(request.user)
    is_member = False
    for team in teams:
        is_member = launchpad.is_team_member(request.user, team)
        if is_member:
            team_object = team
            break

    if is_on_lc or is_member:
        if request.method == 'POST':
            form = TeamEventForm(instance=team_event, data=request.POST, teams=teams)
            team_event.id = team_event.pk = None
            if form.is_valid():
                team_event = form.save()
                team_event.teams.add(team_object)
                return HttpResponseRedirect(team_event.get_absolute_url())
        else:
            form = TeamEventForm(instance=team_event, teams=teams)
        context = {
            'team_object': team_object,
            'form': form,
        }
        return render_to_response('events/team_event_new.html',
                                         context, RequestContext(request))
    else:
        # XXX: Once we move to a new ACL system, this needs fixing.
        request.user.message_set.create(message='%s %s' % (_('You can not add a new event for this team.'), _('You are not a member of the team or on the LoCo Council.')))
        return redirect(team_object)


@login_required
def team_event_update(request, team_slug, team_event_id):
    """
    update team event
    """
    team_event = get_object_or_404(TeamEvent, pk=team_event_id)
    teams = team_event.teams.all()
    #check if user is admin or owner of a team
    is_member = False
    for team in teams:
        if launchpad.is_team_member(request.user, team):
            is_member = True
            break

    is_on_lc = launchpad.is_user_on_loco_council(request.user)

    if is_on_lc or is_member:
        if request.method == 'POST':
            form = TeamEventForm(data=request.POST, instance=team_event, teams=teams)
            if form.is_valid():
                form.save()
                request.user.message_set.create(message=_('Team Event updated.'))
                return redirect(team_event)
        else:
            form = TeamEventForm(instance=team_event, teams=teams)

        context = {
            'form': form,
        }
        return render_to_response(
            'events/team_event_update.html',
            context, RequestContext(request)
        )
    else:
        request.user.message_set.create(message='%s %s' % (_('You can not update this team event.'), _('You are not a member of the team or on the LoCo Council.')))
        return redirect(team_event)


@login_required
def team_event_register(request, team_slug, team_event_id):
    """
    register as attendee for a team event
    """
    team_event_object = get_object_or_404(TeamEvent, pk=team_event_id)
    if team_event_object.is_attending(request.user):
        attendee_object = team_event_object.attendee_set.get(attendee_profile=request.user.get_profile())
    else:
        attendee_object = Attendee(team_event=team_event_object, attendee_profile=request.user.get_profile())

    if request.method == 'POST':
        form = AttendeeRegistrationForm(instance=attendee_object, data=request.POST)
        if form.is_valid():
            form.save()
            request.user.message_set.create(message=_('Your registration has been saved.'))
            return redirect(team_event_object)
    else:
        form = AttendeeRegistrationForm(instance=attendee_object, initial={'guests': 0})

    is_past_event = False
    if team_event_object.date_end < datetime.datetime.now():
        is_past_event = True

    context = {
        'form': form,
        'is_past_event': is_past_event,
    }

    return render_to_response('events/team_event_register.html',
                                     context, RequestContext(request))


@login_required
def team_event_comment_new(request, team_slug, team_event_id):
    """
    create a comment for a team event
    """
    team_event_object = get_object_or_404(TeamEvent, pk=team_event_id)

    if request.method == 'POST':
        form = TeamEventCommentForm(data=request.POST)
        if form.is_valid():
            team_event_comment = form.save(commit=False)
            team_event_comment.team_event = team_event_object
            team_event_comment.commenter_profile = request.user.get_profile()
            team_event_comment.save()
            request.user.message_set.create(message=_('Comment saved.'))
            return redirect(team_event_object)
    else:
        form = TeamEventCommentForm()

    context = {
        'team_event_object': team_event_object,
        'form': form,
    }
    return render_to_response('events/team_event_comment_new.html',
                                     context, RequestContext(request))


#################################################################
# Global Events
#################################################################
def global_event_detail(request, global_event_id):
    """
    detailed view for a global event
    """
    global_event = get_object_or_404(GlobalEvent, pk=global_event_id)
    team_events = global_event.teamevent_set.all().order_by('venue__continent__name')
    for event in team_events:
        event.v = "z-v"
        event.ctr = "z-ctr"
        event.ctn = "z-ctn"
        if event.venue and event.venue is not None:
            event.v = event.venue
            if event.v.country:
                event.ctr = str(event.v.country)
            if event.v.continent:
                event.ctn = str(event.v.continent)
    add_team_event = (request.user and request.user.is_authenticated() and \
                      request.user.groups.exclude(name__exact='ubuntu-lococouncil'))
    is_on_lc = launchpad.is_user_on_loco_council(request.user)

    context = {
        'global_event': global_event,
        'team_events': team_events,
        'add_team_event': add_team_event,
        'user_is_on_lc': is_on_lc,
    }
    return render_to_response('events/global_event_detail.html',
                                         context, RequestContext(request))


@login_required
def global_event_delete(request, global_event_id):
    """
    delete a event
    """
    global_event_object = get_object_or_404(GlobalEvent, pk=global_event_id)

    is_on_lc = launchpad.is_user_on_loco_council(request.user)

    if is_on_lc:
        if request.method == 'POST':
            global_event_object.delete()
            request.user.message_set.create(message=_('Global Event removed.'))
            return redirect('event-list')
        else:
            context = {'global_event_object': global_event_object}
            return render_to_response('events/global_event_delete_confirm.html', context, RequestContext(request))
    else:
        request.user.message_set.create(message='%s %s' % (_('You can not remove this global event.'), _('You are not on the LoCo Council.')))
        return redirect(global_event_object)


@login_required
def global_event_new(request,):
    """
    new global event
    """
    is_on_lc = launchpad.is_user_on_loco_council(request.user)
    if is_on_lc:
        if request.method == 'POST':
            form = GlobalEventForm(data=request.POST)
            if form.is_valid():
                form.save()
                request.user.message_set.create(message=_('New Global Event created.'))
                return redirect('event-list')
        else:
            form = GlobalEventForm()

        context = {
            'form': form,
        }
        return render_to_response('events/global_event_new.html',
                                         context, RequestContext(request))
    else:
        request.user.message_set.create(message='%s %s' % (_('You can not add a new global event.'), _('You are not on the LoCo Council.')))
        return redirect('event-list')


@login_required
def global_event_update(request, global_event_id):
    """
    update global event
    """
    global_event_object = get_object_or_404(GlobalEvent, pk=global_event_id)

    is_on_lc = launchpad.is_user_on_loco_council(request.user)
    if is_on_lc:
        if request.method == 'POST':
            form = GlobalEventForm(data=request.POST, instance=global_event_object)
            if form.is_valid():
                form.save()
                request.user.message_set.create(message=_('Global Event updated.'))
                return redirect(global_event_object)
        else:
            form = GlobalEventForm(instance=global_event_object)

        context = {
            'form': form,
        }
        return render_to_response('events/global_event_update.html',
                                         context, RequestContext(request))
    else:
        request.user.message_set.create(message='%s %s' % (_('You can not update this global event.'), _('You are not on the LoCo Council.')))
        return redirect(global_event_object)


def team_event_locations(request):
    """
    the longitude and latitude for upcoming team events
    """
    locations = []
    for event in TeamEvent.objects.next_events().exclude(venue__latitude__isnull=True, venue__longitude__isnull=True):
        location = {}
        location['url'] = event.get_absolute_url()
        location['title'] = event.name
        # TODO: create an separate view with template for the content
        if event.venue is None:
            continue
        location['content'] = '<p>Location: <a href="%s">%s</a></p><p>Start date: %s</p><p>End date: %s</p>' % (event.get_absolute_url(),
                                                                                                                event.venue.name,
                                                                                                                str(event.date_begin),
                                                                                                                str(event.date_end))
        location['lng'] = event.venue.longitude
        location['lat'] = event.venue.latitude
        locations.append(location)

    json = simplejson.dumps(locations)

    return HttpResponse(json)


def global_event_locations(request, global_event_id):
    """
    the longitude and latitude global event
    """
    global_event_object = get_object_or_404(GlobalEvent, pk=global_event_id)
    locations = []
    for event in global_event_object.teamevent_set.has_location():
        location = {}
        location['url'] = event.get_absolute_url()
        location['title'] = event.name
        # TODO: create an separate view with template for the content
        location['content'] = '<p>Location: <a href="%s">%s</a></p><p>Start date: %s</p><p>End date: %s</p>' % (event.get_absolute_url(),
                                                                                                                event.venue.name,
                                                                                                                str(event.date_begin),
                                                                                                                str(event.date_end))
        location['lng'] = event.venue.longitude
        location['lat'] = event.venue.latitude
        locations.append(location)

    json = simplejson.dumps(locations)

    return HttpResponse(json)


def global_jam(request):
    global_event_object = get_list_or_404(GlobalEvent.objects.order_by('-date_begin'), name='Ubuntu Global Jam')[0]
    return global_event_detail(request, global_event_object.id)


def global_jam_dashboard(request):
    global_event_object = get_list_or_404(GlobalEvent.objects.order_by('-date_begin'), name='Ubuntu Global Jam')[0]
    context = {
        'global_event_object': global_event_object,
    }
    return render_to_response('events/global_jam_dashboard.html', context, RequestContext(request))


@login_required
def team_event_comment_edit(request):
    """
    update a comment for a team event
    """
    if request.method == 'POST':
        response_dict = {}
        id = request.POST.get('id', False)
        comment = request.POST.get('comment', False)
        if id and comment:
            try:
                comment_obj = TeamEventComment.objects.get(pk=id)
                if comment_obj.commenter_profile.user == request.user:
                    comment_obj.comment = comment
                    comment_obj.save()
                    response_dict.update({'success': True, 'response': comment_obj.comment})
                else:
                    response_dict.update({'success': False, 'response': _('Your are not authorized to edit this comment.')})
            except TeamEventComment.DoesNotExist:
                response_dict.update({'success': False, 'response': _('This comment does not exist.')})
        else:
            response_dict.update({'success': False, 'response': _('Missing arguments.')})
    else:
        response_dict.update({'success': False, 'response': _('You can\'t edit this comment using this method.')})
    return HttpResponse(simplejson.dumps(response_dict), mimetype='application/json')


@login_required
def team_event_comment_delete(request, pk):
    """
    delete a comment for a team event
    """
    next = request.GET.get('next', None)
    comment = get_object_or_404(TeamEventComment, pk=pk)
    if comment.commenter_profile.user == request.user:
        comment.delete()
        request.user.message_set.create(message=_('Your comment has been removed.'))
        if next:
            redirect_to = next
        else:
            redirect_to = '/'
        return redirect(redirect_to)
    else:
        raise Http404