#!/usr/bin/python2.5

#

# Copyright 2009 the Melange authors.

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#   http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

"""Views for Tasks.

"""

__authors__ = [

    '"Madhusudan.C.S" <madhusudancs@gmail.com>',

    '"Lennard de Rijk" <ljvderijk@gmail.com>',

  ]

import datetime

import time

from google.appengine.ext import db

from django import forms

from django import http

from django.utils.translation import ugettext

from soc.logic import cleaning

from soc.logic import dicts

from soc.logic.models import host as host_logic 

from soc.logic.models import student as student_logic

from soc.logic.models import user as user_logic

from soc.views import helper

from soc.views import out_of_band

from soc.views.helper import decorators

from soc.views.helper import dynaform

from soc.views.helper import lists

from soc.views.helper import params as params_helper

from soc.views.helper import requests

from soc.views.helper import redirects

from soc.views.helper import responses

from soc.views.helper import widgets

from soc.views.models import base

from soc.modules.ghop.logic import cleaning as ghop_cleaning

from soc.modules.ghop.logic.models import comment as ghop_comment_logic

from soc.modules.ghop.logic.models import mentor as ghop_mentor_logic

from soc.modules.ghop.logic.models import organization as ghop_org_logic

from soc.modules.ghop.logic.models import org_admin as ghop_org_admin_logic

from soc.modules.ghop.logic.models import program as ghop_program_logic

from soc.modules.ghop.logic.models import task as ghop_task_logic

from soc.modules.ghop.models import task as ghop_task_model

from soc.modules.ghop.views.helper import access

from soc.modules.ghop.views.helper import redirects as ghop_redirects

from soc.modules.ghop.views.models import organization as ghop_org_view

from soc.modules.ghop.tasks import task_update

import soc.modules.ghop.logic.models.task

class View(base.View):

  """View methods for the Tasks.

  """

  DEF_AWAITING_REG_MSG = ugettext(

      'The task is open but you cannot claim this task since you '

      'have not completed the student signup after finishing your '

      'first task.')

  DEF_CAN_EDIT_TASK_MSG = ugettext(

      'The task can be edited by clicking on the edit link '

      'next to the title above.')

  DEF_MAX_TASK_LIMIT_MSG_FMT = ugettext(

      'The task is open but you cannot claim this task since you '

      'have already claimed %d task(s).')

  DEF_SIGNIN_TO_COMMENT_MSG = ugettext(

      '<a href=%s>Sign in</a> to perform any action or comment on '

      'this task.')

  DEF_STUDENT_SIGNUP_MSG = ugettext(

      'You have successfully completed this task. Sign up as a student '

      'before you proceed further.')

  DEF_TASK_CLAIMED_BY_YOU_MSG = ugettext( 

      'You have claimed this task!')

  DEF_TASK_CLAIMED_BY_STUDENT_MSG = ugettext(

      'This task has been claimed by a student!')

  DEF_TASK_CLAIMED_MSG = ugettext(

      'The task is already claimed and the work is in progress.')

  DEF_TASK_CLAIM_REQUESTED_MSG = ugettext(

      'A student has requested to claim this task. Accept or '

      'reject the request.')

  DEF_TASK_CLOSED_MSG = ugettext('This task is closed.')

  DEF_TASK_CMPLTD_BY_YOU_MSG = ugettext(

      'You have successfully completed this task!')

  DEF_TASK_NO_MORE_SUBMIT_MSG = ugettext(

      'You have submitted the work to this task, but deadline has passed '

      'You cannot submit any more work until your mentor extends the '

      'deadline.')

  DEF_TASK_MENTOR_REOPENED_MSG = ugettext(

      'The task has been reopened.')

  DEF_TASK_NEEDS_REVIEW_MSG = ugettext(

      'Student has submitted his work for this task! It needs review.')

  DEF_TASK_OPEN_MSG = ugettext(

      'This task is open. If you are a GHOP student, you can claim it!')

  DEF_TASK_REOPENED_MSG = ugettext(

      'This task has been reopened. If you are a GHOP student, '

      'you can claim it!')

  DEF_TASK_REQ_CLAIMED_BY_YOU_MSG = ugettext(

      'You have requested to claim this task!')

  DEF_TASK_UNPUBLISHED_MSG = ugettext(

      'The task is not yet published. It can be edited by clicking on '

      'the edit button below.')

  DEF_WS_MSG_FMT = ugettext(

      '(To see the work submitted <a href=#ws%d>click here</a>.)')

  def __init__(self, params=None):

    """Defines the fields and methods required for the task View class

    to provide the user with the necessary views.

    Params:

      params: a dict with params for this View

    """

    rights = access.GHOPChecker(params)

    # TODO: create and suggest_task don't need access checks which use state

    # also feels like roles are being checked twice?

    rights['create'] = [

        ('checkCanOrgAdminOrMentorEdit', ['scope_path', True]),

        ('checkRoleAndStatusForTask',

            [['ghop/org_admin'], ['active'], 

            []])]

    rights['edit'] = [

        ('checkCanOrgAdminOrMentorEdit', ['scope_path', False]),

        ('checkRoleAndStatusForTask',

            [['ghop/org_admin'], ['active'], 

            ['Unapproved', 'Unpublished', 'Open']])]

    rights['delete'] = ['checkIsDeveloper']

    rights['show'] = ['checkStatusForTask']

    rights['list_org_tasks'] = [

        ('checkCanOrgAdminOrMentorEdit', ['scope_path', False])]

    rights['suggest_task'] = [

        ('checkCanOrgAdminOrMentorEdit', ['scope_path', True]),

        ('checkRoleAndStatusForTask',

            [['ghop/org_admin', 'ghop/mentor'], ['active'], 

            ['Unapproved']])]

    rights['search'] = ['allow']

    new_params = {}

    new_params['logic'] = soc.modules.ghop.logic.models.task.logic

    new_params['rights'] = rights

    new_params['name'] = "Task"

    new_params['module_name'] = "task"

    new_params['sidebar_grouping'] = 'Tasks'

    new_params['module_package'] = 'soc.modules.ghop.views.models'

    new_params['url_name'] = 'ghop/task'

    new_params['scope_view'] = ghop_org_view

    new_params['scope_redirect'] = redirects.getCreateRedirect

    new_params['list_heading'] = 'modules/ghop/task/list/heading.html' 

    new_params['list_row'] = 'modules/ghop/task/list/row.html'

    new_params['extra_dynaexclude'] = ['task_type', 'mentors', 'user',

                                       'student', 'program', 'status', 

                                       'deadline', 'created_by',

                                       'created_on', 'modified_by',

                                       'modified_on', 'history',

                                       'link_id', 'difficulty']

    patterns = []

    patterns += [

        (r'^%(url_name)s/(?P<access_type>suggest_task)/%(scope)s$',

        '%(module_package)s.%(module_name)s.suggest_task',

        'Mentors suggest %(name)s'),

        (r'^%(url_name)s/(?P<access_type>suggest_task)/%(key_fields)s$',

        '%(module_package)s.%(module_name)s.suggest_task',

        'Mentors edit a %(name)s'),

        (r'^%(url_name)s/(?P<access_type>list_org_tasks)/%(scope)s$',

        '%(module_package)s.%(module_name)s.list_org_tasks',

        'List Organization %(name)s'),

        (r'^%(url_name)s/(?P<access_type>search)/'

         '(?P<scope_path>%(ulnp)s)/%(lnp)s$',

        '%(module_package)s.%(module_name)s.search',

        'Search for %(name)ss'),

        ]

    new_params['extra_django_patterns'] = patterns

    new_params['create_dynafields'] = [

        {'name': 'arbit_tags',

         'base': forms.fields.CharField,

         'label': 'Arbitrary Tags',

         'required': False,

         'group': ugettext('Tags'),

         'help_text': ugettext(

             'Enter arbitrary Tags for this task separated by comma.\n'

             '<b>Note:</b> Tag names are case sensitive. If the tag is same '

             'as the program mandated tag, it will be considered as a '

             'mandatory tag.')

         },

        ]

    new_params['create_extra_dynaproperties'] = {

        'description': forms.fields.CharField(required=True,

            widget=widgets.FullTinyMCE(attrs={'rows': 25, 'cols': 100})),

        'scope_path': forms.CharField(widget=forms.HiddenInput,

            required=True),

        'time_to_complete': forms.IntegerField(min_value=1,

                                               required=True),

        'clean_description': cleaning.clean_html_content('description'),

        'clean_arbit_tags': cleaning.str2set('arbit_tags'),

        }

    new_params['edit_extra_dynaproperties'] = {

        'link_id': forms.CharField(widget=forms.HiddenInput)

        }

    new_params['public_template'] = 'modules/ghop/task/public.html'

    params = dicts.merge(params, new_params, sub_merge=True)

    super(View, self).__init__(params=params)

    # holds the base form for the task creation and editing

    self._params['base_create_form'] = self._params['create_form']

    self._params['base_edit_form'] = self._params['edit_form'] 

    # extend create and edit form for org admins

    dynafields = [

        {'name': 'mentors_list',

         'required': True,

         'base': forms.fields.CharField,

         'label': 'Assign mentors',

         'help_text': 'Assign mentors to this task by '

             'giving their link_ids separated by comma.',

         },

        {'name': 'published',

         'required': False,

         'initial': False,

         'base': forms.fields.BooleanField,

         'label': 'Publish the task',

         'help_text': ugettext('By ticking this box, the task will be'

                               'made public and can be claimed by students.'),

         }

        ]

    dynaproperties = params_helper.getDynaFields(dynafields)

    dynaproperties['clean_mentors_list'] = ghop_cleaning.cleanMentorsList(

        'mentors_list')

    create_form = dynaform.extendDynaForm(

        dynaform=self._params['create_form'],

        dynaproperties=dynaproperties)

    self._params['create_form'] = create_form

    edit_form = dynaform.extendDynaForm(

        dynaform=self._params['edit_form'],

        dynaproperties=dynaproperties)

    self._params['edit_form'] = edit_form

    # create the comment form

    dynafields = [

        {'name': 'comment',

         'base': forms.CharField,

         'widget': widgets.FullTinyMCE(attrs={'rows': 10, 'cols': 40}),

         'label': 'Comment',

         'required': False,

         'example_text': 'Comment is optional.<br/>'

             'Choose an appropriate Action below and Save your '

             'changes.<br /><br />Caution, you will not be able '

             'to edit your comment!',

         },

         ]

    dynaproperties = params_helper.getDynaFields(dynafields)

    dynaproperties['clean_comment'] = cleaning.clean_html_content('comment')

    dynaproperties['clean'] = ghop_cleaning.cleanTaskComment(

        'comment', 'action', 'work_submission')

    comment_form = dynaform.newDynaForm(dynamodel=None, 

        dynabase=helper.forms.BaseForm, dynainclude=None, 

        dynaexclude=None, dynaproperties=dynaproperties)

    self._params['comment_form'] = comment_form

  def _getTagsForProgram(self, form_name, params, **kwargs):

    """Extends form dynamically from difficulty levels in program entity.

    Args:

     form_name: the Form entry in params to extend

     params: the params for the view

    """

    # obtain program_entity using scope_path which holds 

    # the org_entity key_name

    org_entity = ghop_org_logic.logic.getFromKeyName(kwargs['scope_path'])

    program_entity = ghop_program_logic.logic.getFromKeyName(

        org_entity.scope_path)

    # get a list difficulty levels stored for the program entity

    tds = ghop_task_model.TaskDifficultyTag.get_by_scope(

        program_entity) 

    difficulties = []

    for td in tds:

      difficulties.append((td.tag, td.tag))

    # get a list of task type tags stored for the program entity

    tts = ghop_task_model.TaskTypeTag.get_by_scope(program_entity) 

    type_tags = []

    for tt in tts:

      type_tags.append((tt.tag, tt.tag))

    # create the difficultly level field containing the choices 

    # defined in the program entity

    dynafields = [

        {'name': 'difficulty',

         'base': forms.ChoiceField,

         'label': 'Difficulty level',

         'required': True,

         'passthrough': ['initial', 'required', 'choices',

                         'label', 'help_text'],

         'choices': difficulties,

         'group': ugettext('Tags'),

         'help_text': ugettext('Difficulty Level of this task.'),

         },

         {'name': 'type_tags',

         'base': forms.MultipleChoiceField,

         'label': 'Task Types',

         'required': True,

         'passthrough': ['initial', 'required', 'choices',

                         'label', 'help_text'],

         'choices': type_tags,

         'group': ugettext('Tags'),

         'help_text': ugettext('Task Type tags mandated by the program. You '

                               'must select one or more of them.'),

         },

       ]

    dynaproperties = params_helper.getDynaFields(dynafields)

    extended_form = dynaform.extendDynaForm(

        dynaform=params[form_name],

        dynaproperties=dynaproperties)

    return extended_form

  @decorators.check_access

  def create(self, request, access_type,

             page_name=None, params=None, **kwargs):

    """Replaces the create Form with the dynamic one.

    For args see base.View.create().

    """

    params = dicts.merge(params, self._params)

    # extend create_form to include difficulty levels

    params['create_form'] = self._getTagsForProgram(

        'create_form', params, **kwargs)

    return super(View, self).create(request, 'allow', page_name=page_name,

                                    params=params, **kwargs)

  @decorators.merge_params

  @decorators.check_access

  def edit(self, request, access_type,

           page_name=None, params=None, seed=None, **kwargs):

    """See base.View.edit().

    """

    logic = params['logic']

    context = helper.responses.getUniversalContext(request)

    helper.responses.useJavaScript(context, params['js_uses_all'])

    context['page_name'] = page_name

    try:

      entity = logic.getFromKeyFieldsOr404(kwargs)

    except out_of_band.Error, error:

      msg = self.DEF_CREATE_NEW_ENTITY_MSG_FMT % {

          'entity_type_lower' : params['name'].lower(),

          'entity_type' : params['name'],

          'create' : params['missing_redirect']

          }

      error.message_fmt = error.message_fmt + msg

      return helper.responses.errorResponse(

          error, request, context=context)

    # extend edit_form to include difficulty levels

    params['edit_form'] = self._getTagsForProgram(

        'edit_form', params, **kwargs)

    if entity.status == 'Unapproved':

      dynafields = [

          {'name': 'approved',

           'required': False,

           'initial': False,

           'base': forms.fields.BooleanField,

           'label': 'Approve the task',

           'help_text': 'By ticking this box, the task will be'

               'will be approved for publishing.',

          }

          ]

      dynaproperties = params_helper.getDynaFields(dynafields)

      edit_form = dynaform.extendDynaForm(

          dynaform=params['edit_form'],

          dynaproperties=dynaproperties)

      params['edit_form'] = edit_form

    if request.method == 'POST':

      return self.editPost(request, entity, context, params=params)

    else:

      return self.editGet(request, entity, context, params=params)

  def _editGet(self, request, entity, form):

    """See base.View._editGet().

    """

    if entity.task_type:

      form.fields['type_tags'].initial = entity.tags_string(

          entity.task_type, ret_list=True)

    if entity.arbit_tag:

      form.fields['arbit_tags'].initial = entity.tags_string(

          entity.arbit_tag)

    if entity.difficulty:

      form.fields['difficulty'].initial = entity.tags_string( 

          entity.difficulty)

    if entity.mentors and 'mentors_list' in form.fields:

      mentor_entities = db.get(entity.mentors)

      mentors_list = []

      for mentor in mentor_entities:

        mentors_list.append(mentor.link_id)

      form.fields['mentors_list'].initial = ', '.join(mentors_list)

    form.fields['link_id'].initial = entity.link_id

    # checks if the task is already approved or not and sets

    # the form approved field

    if 'approved' in form.fields:

      if entity.status == 'Unapproved':

        form.fields['approved'].initial = False

      else:

        form.fields['approved'].initial = True

    # checks if the task is already published or not and sets

    # the form published field 

    if 'published' in form.fields:

      if entity.status == 'Unapproved' or entity.status == 'Unpublished':

        form.fields['published'].initial = False

      else:

        form.fields['published'].initial = True

    return super(View, self)._editGet(request, entity, form)

  def _editPost(self, request, entity, fields):

    """See base._editPost().

    """

    super(View, self)._editPost(request, entity, fields)

    # TODO: this method can be made more clear, it seems a bit of a mess

    if not entity:

      program_entity = fields['scope'].scope

      fields['program'] = program_entity

    else:

      program_entity = entity.program 

    user_account = user_logic.logic.getForCurrentAccount()

    filter = {

        'user': user_account,

        'status': 'active'

        }

    if not entity:

      filter['scope'] = fields['scope']

    else:

    role_entity = ghop_org_admin_logic.logic.getForFields(

        filter, unique=True)

    if role_entity:

      # this user can publish/approve the task

      if fields.get('approved') and fields.get('published'):

        fields['status'] = 'Open'

      elif not fields.get('approved'):

        fields['status'] = 'Unapproved'

      else:

        fields['status'] = 'Unpublished'