Jyrä

# -*- coding: utf-8 -*-
"""
Sign-up system.
Copyright (C) 2010, 2011  Jyrki Launonen

This file is part of slavemaster.

Slavemaster is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Slavemaster is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License
along with Slavemaster.  If not, see <http://www.gnu.org/licenses/>.
"""

from django.contrib.auth.decorators import login_required
from django.http import HttpResponseServerError, HttpResponseRedirect
from django.shortcuts import get_object_or_404, render_to_response
from django.core.urlresolvers import reverse
from django.template import RequestContext
from django.contrib.auth.models import User as DjangoUser
from django.conf import settings
from django.utils.safestring import mark_safe
import datetime

from csrf.helper import postOnly, checkPost #pylint:disable=E0611
from accounts.models import User, getDjangoUserTable, getUserTable
from events.models import Event, Task, getEventSliceTable, \
   getSignupTimesTable, EventDynamic
from events.forms import DynamicInfoForm
from system.models import getSignupTable, WorkTimes, UserSignups
from system.forms import TaskParticipationForm, WorkTimeForm
from utils.timebar import TimeBarForm
from utils.sessionmessage import setMessage
from utils.acl import isInCharge, setInCharge
from utils.sqladb import Meta
from collections import namedtuple

__all__ = [
   "getSignupInfo",
   "getSelectedUser",
   "eventSignup",
   "thanks",
   "postHandler",
   "deleteSignup",
]



PROGRESSION = (
   '1: Ilmoittautumisen tiedot',
   '2: Tietojen tarkistus ja kiitokset',
)

PROGRESSION_VIEWS = (
   'system-signup',
   'system-signup-thanks',
)



def getSignupInfo(session,
                  event,
                  **kwargs):
   """Get event signup info in sane format.
      Usage: (tasks, days, times, dyninfo) = getSignupInfo(
                  session,    # Currently used Meta.Session() instance
                  event,      # Event instance
                  **kwargs)
      
      kwargs MUST contain EITHER pk = signup_info.id OR ptc = signup_info.
      kwargs CAN contain 
         * signup_table (as returned by getSignupTable(...)),
         * TrueFalse tuple containing stringrepresentations for True and False.
      Returned
         * tasks  is a QuerySet of Task-model objects.
         * days is a list of object(.day = datetime.day, .amount = int(0->3),
            .amountStr = str).
         * times  is a list of object(.day = datetime.day,
            .timeA = str, .timeB = str).
         * dyninfo is a list of object(.key, .value) -pairs.
         * stamps is a named tuple of create- and modify-times.
   """
   
   TrueFalse   = kwargs.pop("TrueFalse", ("Kyllä", "Ei"))
   pk          = kwargs.pop("pk", None)
   ptc         = kwargs.pop("ptc", None)
   signup_table = kwargs.pop("signup_table", None) or \
      getSignupTable(session, event.id)
   
   if None not in (pk, ptc) or (pk == ptc and pk == None):
      raise RuntimeError, "Both or neither of pk and ptc is None"

   signup_info = ptc
   if pk is not None:
      signup_info = session.query(signup_table). \
         filter(signup_table.id == int(pk)). \
         one()

   # Find out names of selected tasks
   tasks_root = Task.objects.filter(event = event). \
      order_by('name'). \
      only('id', 'name')

   tasks_selected = []
   TaskInfo = namedtuple("TaskInfo", "name id")
   for task in tasks_root:
      if signup_info.task(task.id, default = False) == True:
         tasks_selected.append(
            TaskInfo(name = task.name, id = task.id)
         )

   # Get daily work times   
   days = []
   WorkTime = namedtuple("WorkTime", "day amount amountStr")
   if event.use_multiday:
      for i in range(1 + (event.date_end - event.date_begin).days):
         amount = signup_info.daily(i)
   
         # NOTE: WorkTimes.CHOICES: Not really a dict, but works.
         days.append(WorkTime(
            day       = event.date_begin + datetime.timedelta(i),
            amount    = amount,
            amountStr = WorkTimes.CHOICES[amount][1],
         ))
   else:
      amount = signup_info.daily(None)
      days = WorkTime(
         day       = None,
         amount    = amount,
         amountStr = WorkTimes.CHOICES3[amount][1],
      )

   # Create sensible "times" from previously selected timedata
   slices_table = getEventSliceTable()
   slice_mapping = getSignupTimesTable(session, event.id, signup_table)
   
   slices = session.query(slices_table). \
      join((slices_table, slice_mapping.slice)). \
      filter(slice_mapping.signup_id == signup_info.id). \
      order_by(slices_table.timeA). \
      all()

   start = None
   stop  = None
   times = []

   TimeRange = namedtuple("TimeRange", "day timeA timeB day_end")
   for index, t in enumerate(slices):
      # Recreate the table as init does not get called
      t = slices_table(timeA = t.timeA,
                       timeB = t.timeB,
                       SQLA_Model = True)
      if start is None:
         start = t.startTime
         stop  = t.endTime
      else:
         # Add range, if there is gap in time or if in last range.
         if t.startTime != stop or index == len(slices) - 1:
            if index == len(slices) - 1:
               stop  = t.endTime
            
            # Calculate date for the range.
            # Also add end day date if it is different than start day...
            #  If: Stop is not exactly at 00:00 if stop is start's tomorrow
            day_start = event.date_begin + datetime.timedelta(start[0]-1)
            day_end   = None
            if stop[0] > start[0] and (stop[1] != 0 or stop[2] != 0):
               day_end = event.date_begin + datetime.timedelta(stop[0]-1)
            
            # Add the time range to the result list
            times.append(TimeRange(
               day    = day_start,
               timeA  = "%02i:%02i" % (start[1], start[2]),
               timeB  = "%02i:%02i" % (stop[1], stop[2]),
               day_end= day_end,
            ))
            start = t.startTime
         stop  = t.endTime


   # Dynamic infos
   dynamic_header = EventDynamic.objects. \
      filter(event = event). \
      order_by('priority'). \
      only('dynamic__id',
           'dynamic__name')

   # Make dynamics to a list of key-value -pairs.
   dynamic_result = []
   DynamicInfo = namedtuple("DynamicInfo", "key value need_nbr")
   for dyn_object in dynamic_header:
      value = signup_info.dynamic(dyn_object.dynamic.id)
      
      # Boolean needs to be converted to sane representation.
      # Other types give already a good repr.
      if isinstance(value, bool):
         value = TrueFalse[0] if value else TrueFalse[1]
      
      dynamic_result.append(DynamicInfo(
         key   = dyn_object.dynamic.name,
         value = value,
         need_nbr = isinstance(value, str) or isinstance(value, unicode),
      ))
   
   # Timestamps
   Timestamps = namedtuple('Timestamps', 'create modify')
   stamps = Timestamps(create = signup_info.ctime,
                       modify = signup_info.mtime)
   
   return (tasks_selected, days, times, dynamic_result, stamps)
#


def _noSignUp(request, event):
   # Simplifying function to return page that tells "Signup is not active"

   ended = False

   if event.recruitIsPast:
      ended = True

   # Set permission flags.
   setInCharge(request, event)

   return render_to_response("system/noSignup.html", {
                              'event'   : event,
                              'ended'   : ended,
                              }, context_instance = RequestContext(request))
#


def getSelectedUser(request, event):
   """Return User model for selected user or None, if
      no user is selected or required access level is not met.
      Second part of the returned tuple tells, if we selected
      other user than self.
      Third part tells, if returned first is DjangoUser (False)
      or User (True), which means if False, that user should
      be redirected to change his/her info.
   """
   isOther  = False
   djUid    = None
   djMod    = None
   
   UserSelection = namedtuple("UserSelection",
                              "user account isOther isValid returnView")

   try:
      if isInCharge(request, event):
         if "userid" in request.POST:
            # This type of request comes from admin interface, signup info
            djUid = int(request.POST["userid"])
            usel = None
         else:
            usel = request.session.get("selected_user", None)

            if usel is not None:
               # usel = "uid:uname"
               djUid = usel.split(":", 1)[0]

         if djUid is not None:
            isOther = True
            djMod = DjangoUser.objects.get(id = djUid)

            if usel is None:
               # Store selection from POST for future use
               request.session["selected_user"] = \
                  "{0}:{1}".format(djMod.id, djMod.username)

      if djUid is None:
         djUid = request.user.id
         djMod = request.user

      return UserSelection(
         user        = djMod,
         account     = User.objects.get(account__id = djUid),
         isOther     = isOther,
         isValid     = True,
         returnView  = None,
      )


   except User.DoesNotExist:
      # User hasn't entered own info. Redirect to there.
      if isOther:
         setMessage(request,
            u"Ei voi jatkaa, käyttäjällä \"%s\" ei ole syötetty kaikkia käyttäjätietoja." % djMod.username)
         #
      else:
         setMessage(request,
            u"Et ole vielä syöttänyt kaikkia käyttäjätietojasi, ne tarvitaan ilmoittautumiseen.")
         #
      return UserSelection(
         user        = request.user,
         account     = None,
         isOther     = isOther,
         isValid     = False,
         returnView  = None,
      )
   #


def isPreview(request, event):
   return "preview" in request.GET or "nosave" in request.POST# and
      #isInCharge(request, event)
   #


def _getPtc(session, event, user_instance):
   """Return a tuple containing signup object and signup_table.
      The signup object may be None, if there is no info for given user id.
      Don't create any.
      Will return None for signup_table if signup_table does not exist."""
   
   signup_table = getSignupTable(session, event.id)
   if signup_table is None:
      return None, None
   
   ptc = session.query(signup_table). \
      filter(signup_table.user_id == user_instance.id). \
      all()
   
   if len(ptc) == 1:
      return ptc[0], signup_table
   return None, signup_table
#


#@login_required
def eventSignup(request, eventName):
   # General variables
   event            = get_object_or_404(Event, name = eventName)

   # Check login-information etc:
   # If user is not logged in,
   #  * and recruit is not open, don't continue.
   #  * and recruit is open, redirect to login with info of wanted
   #        operation so even if user needs to register, he/she will
   #        be redirected here instantly.
   selected_user = getSelectedUser(request, event)

   if not request.user.is_authenticated():
      is_preview = isPreview(request, event)
      if     not isInCharge(request, event) \
         and not selected_user.isOther \
         and not event.hasRecruit \
         and not is_preview:
         return _noSignUp(request, event)

      return_address = reverse('system-signup',
                               kwargs = { 'eventName' : eventName })
      
      if is_preview:
         return_address += "?preview"
      
      resp = HttpResponseRedirect(reverse('user_login'))
      resp.set_cookie("NextLocation", return_address)
      return resp

   


   # Does the User-object exist?
   if not selected_user.isValid:
      # No.
      uri = reverse('user_changeinfo')
      if selected_user.isOther:
         # Clear selection and go to event
         return HttpResponseRedirect(uri + \
                                     "?return=%s" % event.get_absolute_url())
      
      # Redirect to edit and change 'em.
      return_address = reverse('system-signup',
                               kwargs = { 'eventName' : eventName })
      
      if isPreview(request, event):
         return_address += "?preview"
      
      resp = HttpResponseRedirect(uri)
      resp.set_cookie("NextLocation", return_address)
      return resp

   session = Meta.Session()

   ptc = None

   # Previewing is always allowed. If not requested, check more..
   if not isPreview(request, event):
      # Not a preview: get old values if available

      # Current possible PTC
      ptc = _getPtc(session, event, selected_user.account)[0]

      # If ptc exists (i.e. it is completed) and it is not requested for edit
      if ptc is not None and "edit" not in request.GET and not ptc.deleted:
         # "Redirect" to confirm, as it does show also the info
         return thanks(request, eventName = None,
                       event_object = event, ptc_object = ptc)
   
      # Ensure that signup is active before continuing
      if not event.hasRecruit and not selected_user.isOther:
         return _noSignUp(request, event)

   elif settings.TEMPLATE_DEBUG:
      # Preview. Only show old values if running in debug-mode.
      ptc = _getPtc(session, event, selected_user.account)[0]


   # Create TimeBar
   timebar_form = TimeBarForm(event = event,
                              ptc = ptc,
                              session = session)

   # Possible working times per day -form
   worktimes_form = WorkTimeForm(event = event, ptc = ptc)

   # AddInfo's
   if event.add_info.count() > 0:
      addinfo_form = DynamicInfoForm(
         event    = event,
         ptc      = ptc,
         isOther  = selected_user.isOther,
      )
   else:
      addinfo_form = None

   # Task form
   task_form = TaskParticipationForm(event = event, ptc = ptc)
   
   # Set permission flags.
   setInCharge(request, event)

   resp = render_to_response("system/signupTime.html", {
                             # Event variables
                             'theuser'          : selected_user.account \
                                 if selected_user.isOther else None,
                             'event'            : event,
                             'worktimes_form'   : worktimes_form,

                             # TimeBar variables
                             'timebar'          : timebar_form,
                             'timeidlist'       : u", ".join([
                                 '"%s"' % tid for tid in timebar_form.timeidlist
                             ]),

                             # AddInfo variables
                             'addinfo_form'     : addinfo_form,
                             
                             # Task form
                             'task_form'        : task_form,

                             # General progression variables
                             'part'             : 1,
                             'progression'      : PROGRESSION,
                             'preview'          : isPreview(request, event),

                             }, context_instance = RequestContext(request))

   # Delete possible redirection to "this".
   if "NextLocation" in request.COOKIES:
      resp.delete_cookie("NextLocation")
   return resp
#


@login_required
def thanks(request, eventName, event_object = None, ptc_object = None):
   "'Thank You!'-view. May be used also as 'Alredy signed up'-view."
   event = event_object or get_object_or_404(Event, name = eventName)
   selected_user = getSelectedUser(request, event)

   # If User-object does not exist, go there and change 'em.
   if not selected_user.isValid:
      # We don't need to check isOther, since EventAdm's are redirected
      # to first task anyways. Okay, this should perhaps be managed somehow.
      return HttpResponseRedirect(reverse('user_changeinfo'))

   if selected_user.isOther:
      # Clear selection.
      del request.session["selected_user"]

   session = Meta.Session()

   # Get previously selected data
   ptc = ptc_object
   signup_table = None
   if ptc_object is None:
      ptc, signup_table = _getPtc(session, event, selected_user.account)

   # Sign up info can be changed, if event has still recruit active.
   can_change = event.hasRecruit

   if not can_change and ptc is None:
      # No data, no recruit. Go back.
      return _noSignUp(request, event)

   (tasks, days, times, dyninfo, stamps) = \
      getSignupInfo(session, event,
                    ptc          = ptc,
                    signup_table = signup_table)


   from mailing.models import Email
   from mailing import sendMailToUsers

   # Determine what mails should be sent to user now that he/she has signed up.
   eventMails = Email.objects.filter(
      event     = event,
      outdated  = False,
      draft     = False,
      receiver  = "f_event")

   nonSent = []
   userId = request.user.id

   for m in eventMails:
      if m.recipients.filter(id = userId).count() == 0:
         nonSent.append(m)

   # Send all nonsent (event signup) messages.
   user = (request.user,)
   for m in nonSent:
      sendMailToUsers(m, user)

   
   # Set permission flags.
   setInCharge(request, event)

   return render_to_response("system/signupThanks.html", {
                             # General 
                             'event'        : event,
                             'theuser'      : selected_user.account \
                                 if selected_user.isOther else None,
                             'can_change'   : can_change,
                             'signed_previously' : ptc_object is not None,
                             
                             # The info's
                             'tasks'        : tasks,
                             'days'         : days,
                             'times'        : times,
                             'dyns'         : dyninfo,
                             'stamps'       : stamps,
                             'use_multiday' : event.use_multiday,
                             
                              }, context_instance = RequestContext(request))
#


@postOnly
@login_required
def postHandler(request, eventName):
   """Process signup step POST data and redirect to next_view view"""
   current      = request.POST.get("current", None)
   event_object = get_object_or_404(Event, name = eventName)
   errors       = False
   preview      = isPreview(request, event_object)
   get_args     = u""
   
   # Ensure that signup is active
   if     not isInCharge(request, event_object) \
      and request.POST.get("userid", None) is None \
      and not event_object.hasRecruit \
      and not preview:
      return _noSignUp(request, event_object)

   # Determine correct user:
   #   getSelectedUser may return DjangoUser, we need accounts.User
   selected_user = getSelectedUser(request, event_object)

   if not selected_user.isValid:
      # DjangoUser has no accounts.User. Fail all.
      return HttpResponseServerError("User info not found.")
   # else: We got user = accounts.User

   # Convert integer-string to integer
   try:
      current = int(current)
   except ValueError:
      current = None

   if current == None:
      return HttpResponseServerError('SignUp processing condition failed')

   # If preview, then add it to args
   if preview:
      get_args = "?preview"


   # Try parsing input data
   #try:#TODO: Enable try when not DEBUG.
   if True:
      if current == -1:
         # Just set a message. Will advance to first view.
         is_alter = request.POST.get("alter", False)
         is_delete = request.POST.get("delete", False)
         if is_alter == True and is_delete == True:
            return HttpResponseServerError('Browser sent confusing data! '\
                                           'Don\'t know what to do, sorry.')

         if is_alter == False and is_delete == False:
            return HttpResponseServerError('Browser was too silent! '\
                                           'Don\'t know what to do, sorry.')

         if is_alter:
            setMessage(request, u"Ilmoittautuminen on avattu muokattavaksi. "\
                       "Muista lopuksi tallentaa muutokset.")
            get_args = u"?edit"
         else:
            # is_delete.
            return HttpResponseRedirect(reverse('system-signup-delete',
                                                args = [eventName]))

      elif current == 0:
         # EventSignup, parsing signup times and dynamic info

         # Handle time selection
         timebar = TimeBarForm(data = request.POST,
                               event = event_object)

         # Handle DynInfo selections
         dyns = DynamicInfoForm(
            event_object,
            request.POST,
            isOther = selected_user.isOther,
         )

         # Handle given worktimes
         wtimes = WorkTimeForm(data = request.POST,
                               event = event_object)
         
         # Handle selected tasks
         tasks  = TaskParticipationForm(event = event_object,
                                        data = request.POST)

         # Save valid information
         if not preview and \
            timebar.is_valid() and \
            dyns.is_valid() and \
            wtimes.is_valid() and \
            tasks.is_valid():
            
            # get current participation
            session = Meta.Session()
            ptc, signup_table = _getPtc(session,
                                        event_object,
                                        selected_user.account)
            
            isNew = False
            if ptc is None:
               # user_id is accounts.User.id
               ptc = signup_table(user_id = selected_user.account.id)
               isNew = True
            else:
               # Touch the time stamp so it will be updated upon save.
               ptc.touch()

            # "Save" forms' info to sign up info
            wtimes.save(ptc)
            dyns.save(ptc)
            tasks.save(event_object, ptc)
            
            # Undelete, if deleted (otherwise, just default)
            ptc.deleted = False

            # Add info to session and commit.
            if isNew:
               session.add(ptc)
            session.commit()
            
            # Timebar contents refer to previously created sign up info,
            # so save it now and commit then.
            timebar.save(session, event_object.id, ptc)
            session.commit()
            
            # Add quick-find info
            UserSignups.objects.get_or_create(
               user      = selected_user.account,
               event     = event_object,
               defaults  = {'signup_id' : ptc.id},
            )
            
            
            if isInCharge(request, event_object) and selected_user.isOther:
               # Don't continue the normal way now, this is special operation case.
               # TODO: URL should be quoted?
               setMessage(request,
                  mark_safe(u"Käyttäjä [<span class=\"username\">%s</span>] "\
                            u"on nyt lisätty tapahtumaan." % \
                            selected_user.account.username
                  )
               )
               return HttpResponseRedirect(
                  reverse("user_select_clear") + \
                  "?return=%s" % event_object.get_absolute_url()
               )

         else:
            if not wtimes.is_valid():
               setMessage(request,
                  u"Päivittäisten aikojen käsittelyssä tapahtui virhe.")
               errors = True

            if not timebar.is_valid():
               setMessage(request,
                  u"Aikojen käsittelyssä tapahtui virhe.")
               errors = True

            if not tasks.is_valid():
               setMessage(request,
                  u"Työtehtävien käsittelyssä tapahtui virhe.")
               errors = True

            if not dyns.is_valid():
               # Set message that contains All error messages for dynamic fields.
               # Means, iterate over errors, convert field names to labels and
               # add the errormessage for it (django generates).
               # This creates two-stage unsorted list.
               fields = [
                  "<li>%s: %s</li>" % (dyns.fields[k].label, v)
                  for k, v in dyns.errors.iteritems()
               ]
               
               setMessage(request,
                  u"Tiedoissa on vikaa: <ul>%s</ul>" % u" ".join(fields))

               errors = True
         #

      else:
         return HttpResponseServerError('Invalid index')
   #except ValueError:
      #return HttpResponseServerError("Invalid value in data")

   # Determine next_view action
   if not errors:
      # Next index
      current = current + 1

      # Sanity checking
      if current >= len(PROGRESSION_VIEWS):
         current = len(PROGRESSION_VIEWS) - 1
      elif current < 0:
         current = 0

   # Not actually "current", but "where we should go now".
   next_view = PROGRESSION_VIEWS[current]

   uri = reverse(next_view, kwargs = { 'eventName': eventName })
   return HttpResponseRedirect(uri + get_args)
#


@login_required
@checkPost
def deleteSignup(request, eventName):
   event = get_object_or_404(Event, name = eventName)
   selected_user = getSelectedUser(request, event)
   
   if not selected_user.isOther and not event.hasRecruit:
      setMessage(request, u"Ilmoittautumisen peruuttaminen ei onnistu: "\
                 u"ilmoittautumisaika on päättynyt. "\
                 u"Ota yhteys vastuuhenkilöön."
      )
      return HttpResponseRedirect(reverse('adm-event',
                                          args = [eventName]))
   
   session = Meta.Session()
   user_table     = getDjangoUserTable()
   account_table  = getUserTable()
   signup_table   = getSignupTable(session, event.id)
   
   signup = session.query(signup_table). \
      filter(user_table.id == selected_user.user.id). \
      join((account_table, signup_table.user),
           (user_table, account_table.account)). \
      all()

   if len(signup) == 0 or signup[0].deleted == True:
      if selected_user.isOther:
         # Delete selection so it won't confuse admins later
         del request.session["selected_user"]

      # No such signup. err...
      return HttpResponseRedirect(reverse('adm-event',
                                          args = [eventName]))

   #else signup found, not deleted
   if request.method == 'POST':
      if selected_user.isOther:
         # Delete selection so it won't confuse admins later
         del request.session["selected_user"]


      if request.POST.get("confirm", None) != "confirm":
         setMessage(request,
                    u"Ilmoittautumista EI peruutettu.")
         return HttpResponseRedirect(reverse('adm-event',
                                             args = [eventName]))

      signup = signup[0]
      signup.deleted = True
      session.commit()

      if not selected_user.isOther:
         setMessage(request,
                    u"Ilmoittautumisesi on nyt merkitty peruutetuksi :(")
      else:
         setMessage(request,
                    u"Henkilön {0} ilmoittautuminen on nyt peruttu.".\
                    format(unicode(selected_user.account)))
      return HttpResponseRedirect(reverse('adm-event',
                                          args = [eventName]))

   #else GET-request, show confirm

   return render_to_response(
      "system/confirmDelete.html",
      {
         'event'     : event,
         'theuser'   : selected_user.account \
            if selected_user.isOther else None,
      },
      context_instance = RequestContext(request)
   )