py_tasks_melange: comparison app/soc/modules/ghop/views/models/task.py

equal deleted inserted replaced

-:8a18ac7ca909
+:aa5ebb226b22
 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
 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!')
 # 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['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']
 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,
 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',
 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 = []
 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
 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,
 fields['modified_on'] = datetime.datetime.now()
 if not entity:
 fields['link_id'] = 't%i' % (int(time.time()*100))
 fields['modified_by'] = role_entity
 fields['created_by'] = role_entity
 fields['created_on'] = datetime.datetime.now()
 else:
 fields['link_id'] = entity.link_id
 fields['modified_by'] = role_entity
 if 'status' not in fields:
 return
 @decorators.merge_params
 @decorators.check_access
 def suggestTask(self, request, access_type, page_name=None,
 params=None, **kwargs):
 """View used to allow mentors to create or edit a task.
 Tasks created by mentors must be approved by org admins
 before they are published.
 """
 for key_name in task_keys:
 task_entity = ghop_task_logic.logic.getFromKeyName(key_name)
 # Of course only the tasks from this organization and those with a valid
 # state can be updated.
 if task_entity and task_entity.scope.key() == org_entity.key() and \
 task_entity.status in ['Unapproved', 'Unpublished']:
 task_entity.status = changed_status
 'List of Published tasks.')
 filter = {
 'scope': org_entity,
 'status': ['Open', 'Reopened', 'ClaimRequested', 'Claimed',
 'ActionNeeded', 'Closed', 'AwaitingRegistration',
 'NeedsWork', 'NeedsReview'],
 }
 ap_list = lists.getListContent(request, ap_params, filter, idx=2,
 need_content=True)
 entity, comment_entity = ghop_task_logic.logic.updateTaskStatus(entity)
 if comment_entity:
 comment_entities.append(comment_entity)
 context['entity'] = entity
 context['entity_key_name'] = entity.key().id_or_name()
 context['entity_type'] = params['name']
 context['entity_type_url'] = params['url_name']
 user_account = user_logic.logic.getForCurrentAccount()
 # get some entity specific context
 self.updatePublicContext(context, entity, comment_entities,
 ws_entities, user_account, params)
 validation = self._constructActionsList(context, entity,
 user_account, params)
 context = dicts.merge(params['context'], context)
 if request.method == 'POST':
 return self.publicPost(request, context, params, entity,
 user_account, validation, **kwargs)
 else: # request.method == 'GET'
 return self.publicGet(request, context, params, entity,
 user_account, **kwargs)
 st_filter, unique=True)
 if student_entity:
 properties['student'] = student_entity
 changes.extend([ugettext('User-Student'),
 ugettext('Action-Claim Requested'),
 ugettext('Status-%s' % (properties['status']))
 ])
 elif (validation == 'claim_withdraw' or
 validation == 'needs_review') and action == 'withdraw':
 properties = {
 'user': None,
 'student': None,
 'status': 'Reopened',
 mentors_str += mentor.name() + ", "
 if mentors_str:
 context['mentors_str'] = mentors_str[:-2]
 else:
 context['mentors_str'] = "Not Assigned"
 context['difficulty_str'] = entity.tags_string(entity.difficulty)
 context['task_type_str'] = entity.tags_string(entity.task_type)
 def _constructActionsList(self, context, entity,
 user_account, params):
 """Constructs a list of actions for the task page and extends
 the comment form with this list.
 This method also returns the validation used by POST method to
 validate the user input data.
 Args:
 context: the context that should be updated
 entity: a task used to set context
 else:
 validation, student_actions = self._constructStudentActions(
 context, entity, user_account)
 actions += student_actions
 # create the difficultly level field containing the choices
 # defined in the program entity
 dynafields = [
 {'name': 'action',
 'base': forms.ChoiceField,
 'label': 'Action',
 actions = []
 if entity.status in ['Open', 'Reopened']:
 task_filter = {
 'user': user_account,
 'status': ['ClaimRequested', 'Claimed', 'ActionNeeded',
 'NeedsWork', 'NeedsReview']
 }
 task_entities = ghop_task_logic.logic.getForFields(task_filter)
 if len(task_entities) >= entity.program.nr_simultaneous_tasks:
 if entity.user and user_account.key() == entity.user.key():
 if entity.status  == 'ClaimRequested':
 context['header_msg'] = self.DEF_TASK_REQ_CLAIMED_BY_YOU_MSG
 actions.append(('withdraw', 'Withdraw from the task'))
 validation = 'claim_withdraw'
 elif entity.status in ['Claimed', 'NeedsWork',
 'NeedsReview', 'ActionNeeded']:
 context['header_msg'] = self.DEF_TASK_CLAIMED_BY_YOU_MSG
 actions.extend([
 ('withdraw', 'Withdraw from the task'),
 ('needs_review', 'Submit work and Request for review')])
 elif entity.status == 'AwaitingRegistration':
 context['header_msg'] = self.DEF_STUDENT_SIGNUP_MSG
 elif entity.status == 'Closed':
 context['header_msg'] = self.DEF_TASK_CMPLTD_BY_YOU_MSG
 else:
 if entity.status in ['ClaimRequested', 'Claimed',
 'ActionNeeded', 'NeedsWork',
 'NeedsReview']:
 context['header_msg'] = self.DEF_TASK_CLAIMED_MSG
 if entity.status in ['AwaitingRegistration', 'Closed']:
 context['header_msg'] = self.DEF_TASK_CLOSED_MSG

changeset 3034	aa5ebb226b22
parent 3033	8a18ac7ca909
child 3038	34eeacafc5dc