Exemple #1
0
    def requestTaskPost(self, request, page_name, org_entity, **kwargs):
        """POST request for requestTask.
    """

        # find all administrators for the organization
        fields = {"scope": org_entity}
        org_admins = gci_org_admin_logic.logic.getForFields(fields)

        # include student's message or use a default one
        post_dict = request.POST
        message = post_dict.get("message")
        if not message:
            message = self.DEFAULT_REQUEST_MSG

        # notification should be sent to all of the org admins
        gci_notifications.sendRequestTaskNotification(org_admins, message)

        # return to the list of all accepted organizations
        program = org_entity.scope
        url = redirects.getAcceptedOrgsRedirect(program, {"url_name": "gci/program"})

        return http.HttpResponseRedirect(url)
Exemple #2
0
    def requestTaskPost(self, request, page_name, org_entity, **kwargs):
        """POST request for requestTask.
    """

        # find all administrators for the organization
        fields = {'scope': org_entity}
        org_admins = gci_org_admin_logic.logic.getForFields(fields)

        # include student's message or use a default one
        post_dict = request.POST
        message = post_dict.get('message')
        if not message:
            message = self.DEFAULT_REQUEST_MSG

        # notification should be sent to all of the org admins
        gci_notifications.sendRequestTaskNotification(org_admins, message)

        # return to the list of all accepted organizations
        program = org_entity.scope
        url = redirects.getAcceptedOrgsRedirect(program,
                                                {'url_name': 'gci/program'})

        return http.HttpResponseRedirect(url)
Exemple #3
0
  def _getTimeDependentEntries(self, program_entity, params, id, user):
    """Returns a list with time dependent menu items.
    """
    items = []

    #TODO(ljvderijk) Add more timeline dependent entries
    timeline_entity = program_entity.timeline

    if timeline_helper.isActivePeriod(timeline_entity, 'org_signup'):
      # add the organization signup link
      items += [
          (redirects.getApplyRedirect(program_entity, {'url_name': 'org_app'}),
          "Apply to become an Organization", 'any_access')]

    if user and timeline_helper.isAfterEvent(timeline_entity, 
        'org_signup_start'):
      filter = {
          'applicant': user,
          'scope': program_entity,
          }

      if org_app_logic.logic.getForFields(filter, unique=True):
        # add the 'List my Organization Applications' link
        items += [
            (redirects.getListSelfRedirect(program_entity,
                                           {'url_name' : 'org_app'}),
             "List My Organization Applications", 'any_access')]

    # get the student entity for this user and program
    filter = {'user': user,
              'scope': program_entity,
              'status': 'active'}
    student_entity = student_logic.logic.getForFields(filter, unique=True)

    if student_entity:
      items += self._getStudentEntries(program_entity, student_entity,
                                       params, id, user)

    # get mentor and org_admin entity for this user and program
    filter = {'user': user,
              'program': program_entity,
              'status': 'active'}
    mentor_entity = mentor_logic.logic.getForFields(filter, unique=True)
    org_admin_entity = org_admin_logic.logic.getForFields(filter, unique=True)

    if mentor_entity or org_admin_entity:
      items += self._getOrganizationEntries(program_entity, org_admin_entity,
                                            mentor_entity, params, id, user)

    if user and not (student_entity or mentor_entity or org_admin_entity):
      if timeline_helper.isActivePeriod(timeline_entity, 'student_signup'):
        # this user does not have a role yet for this program
        items += [('/student/apply/%s' % (program_entity.key().id_or_name()),
            "Register as a Student", 'any_access')]

    deadline = 'accepted_organization_announced_deadline'

    if timeline_helper.isAfterEvent(timeline_entity, deadline):
      url = redirects.getAcceptedOrgsRedirect(program_entity, params)
      # add a link to list all the organizations
      items += [(url, "List participating Organizations", 'any_access')]

      if not student_entity:
        # add apply to become a mentor link
        items += [('/org/apply_mentor/%s' % (program_entity.key().id_or_name()),
         "Apply to become a Mentor", 'any_access')]

    deadline = 'accepted_students_announced_deadline'

    if timeline_helper.isAfterEvent(timeline_entity, deadline):
      items += [(redirects.getListProjectsRedirect(program_entity,
          {'url_name':'program'}),
          "List all student projects", 'any_access')]

    return items
Exemple #4
0
    def _getTimeDependentEntries(self, ghop_program_entity, params, id, user):
        """Returns a list with time dependent menu items.
    """

        from soc.modules.ghop.logic.models.org_app_survey import logic as \
            org_app_logic

        items = []

        timeline_entity = ghop_program_entity.timeline

        org_app_survey = org_app_logic.getForProgram(ghop_program_entity)

        if org_app_survey and \
            timeline_helper.isActivePeriod(timeline_entity, 'org_signup'):
            # add the organization signup link
            items += [
                (redirects.getTakeSurveyRedirect(org_app_survey,
                                                 {'url_name': 'ghop/org_app'}),
                 "Apply to become an Organization", 'any_access')
            ]

        if user and org_app_survey and timeline_helper.isAfterEvent(
                timeline_entity, 'org_signup_start'):

            main_admin_fields = {
                'main_admin': user,
                'survey': org_app_survey,
            }

            backup_admin_fields = {
                'backup_admin': user,
                'survey': org_app_survey
            }

            org_app_record_logic = org_app_logic.getRecordLogic()

            if org_app_record_logic.getForFields(main_admin_fields, unique=True) or \
                org_app_record_logic.getForFields(backup_admin_fields, unique=True):
                # add the 'List my Organization Applications' link
                items += [(redirects.getListSelfRedirect(
                    org_app_survey, {'url_name': 'ghop/org_app'}),
                           "List My Organization Applications", 'any_access')]

        # get the student entity for this user and program
        filter = {
            'user': user,
            'scope': ghop_program_entity,
            'status': ['active', 'inactive']
        }
        student_entity = ghop_student_logic.logic.getForFields(filter,
                                                               unique=True)

        if student_entity:
            items += self._getStudentEntries(ghop_program_entity,
                                             student_entity, params, id, user,
                                             'ghop')
        else:
            # if a user has a task assigned, he or she still may list it
            filter = {
                'user': user,
                'program': ghop_program_entity,
            }
            if user and ghop_task_logic.logic.getForFields(filter,
                                                           unique=True):
                items += [(ghop_redirects.getListStudentTasksRedirect(
                    ghop_program_entity, {'url_name': 'ghop/student'}),
                           "List my Tasks", 'any_access')]

            filter['status'] = 'AwaitingRegistration'
            if ghop_task_logic.logic.getForFields(filter, unique=True):
                if timeline_helper.isActivePeriod(timeline_entity,
                                                  'student_signup'):
                    # this user does not have a role yet for this program
                    items += [('/ghop/student/apply/%s' %
                               (ghop_program_entity.key().id_or_name()),
                               "Register as a Student", 'any_access')]

            # get mentor and org_admin entity for this user and program
            filter = {
                'user': user,
                'program': ghop_program_entity,
                'status': 'active'
            }
            mentor_entity = ghop_mentor_logic.logic.getForFields(filter,
                                                                 unique=True)
            org_admin_entity = ghop_org_admin_logic.logic.getForFields(
                filter, unique=True)

            if mentor_entity or org_admin_entity:
                items += self._getOrganizationEntries(ghop_program_entity,
                                                      org_admin_entity,
                                                      mentor_entity, params,
                                                      id, user)

        if timeline_helper.isAfterEvent(timeline_entity, 'org_signup_start'):
            url = redirects.getAcceptedOrgsRedirect(ghop_program_entity,
                                                    params)
            # add a link to list all the organizations
            items += [(url, "List participating Organizations", 'any_access')]

        return items
Exemple #5
0
    def _getTimeDependentEntries(self, gci_program_entity, params, id, user):
        """Returns a list with time dependent menu items.
    """

        items = []

        timeline_entity = gci_program_entity.timeline

        # add show ranking item
        if timeline_helper.isAfterEvent(timeline_entity,
                                        'tasks_publicly_visible'):
            items += [(gci_redirects.getShowRankingRedirect(
                gci_program_entity,
                {'url_name': 'gci/program'}), 'Show Ranking', 'any_access')]

        mentor_entity = None
        org_admin_entity = None

        org_app_survey = org_app_logic.getForProgram(gci_program_entity)

        if org_app_survey and \
            timeline_helper.isActivePeriod(org_app_survey, 'survey'):
            # add the organization signup link
            items += [
                (redirects.getTakeSurveyRedirect(org_app_survey,
                                                 {'url_name': 'gci/org_app'}),
                 "Apply to become an Organization", 'any_access')
            ]

        if user and org_app_survey and timeline_helper.isAfterEvent(
                org_app_survey, 'survey_start'):

            main_admin_fields = {
                'main_admin': user,
                'survey': org_app_survey,
            }

            backup_admin_fields = {
                'backup_admin': user,
                'survey': org_app_survey
            }

            org_app_record_logic = org_app_logic.getRecordLogic()

            if org_app_record_logic.getForFields(main_admin_fields, unique=True) or \
                org_app_record_logic.getForFields(backup_admin_fields, unique=True):
                # add the 'List my Organization Applications' link
                items += [(redirects.getListSelfRedirect(
                    org_app_survey, {'url_name': 'gci/org_app'}),
                           "List My Organization Applications", 'any_access')]

        # get the student entity for this user and program
        filter = {
            'user': user,
            'scope': gci_program_entity,
            'status': ['active', 'inactive']
        }
        student_entity = gci_student_logic.logic.getForFields(filter,
                                                              unique=True)

        # students can register after successfully completing their first
        # task. So if a user has completed one task he is still a student
        filter = {
            'user': user,
            'program': gci_program_entity,
        }
        has_completed_task = gci_task_logic.logic.getForFields(filter,
                                                               unique=True)

        if student_entity or (user and has_completed_task):
            items += self._getStudentEntries(gci_program_entity,
                                             student_entity, params, id, user,
                                             'gci')
        else:
            # get mentor and org_admin entity for this user and program
            filter = {
                'user': user,
                'program': gci_program_entity,
                'status': 'active'
            }
            mentor_entity = gci_mentor_logic.logic.getForFields(filter,
                                                                unique=True)
            org_admin_entity = gci_org_admin_logic.logic.getForFields(
                filter, unique=True)

            if timeline_helper.isAfterEvent(
                    timeline_entity,
                    'accepted_organization_announced_deadline'):
                if mentor_entity or org_admin_entity:
                    items += self._getOrganizationEntries(
                        gci_program_entity, org_admin_entity, mentor_entity,
                        params, id, user)
                if timeline_helper.isBeforeEvent(timeline_entity,
                                                 'program_end'):
                    # add apply to become a mentor link
                    items += [('/gci/org/apply_mentor/%s' %
                               (gci_program_entity.key().id_or_name()),
                               "Apply to become a Mentor", 'any_access')]

        if timeline_helper.isAfterEvent(
                timeline_entity, 'accepted_organization_announced_deadline'):
            url = redirects.getAcceptedOrgsRedirect(gci_program_entity, params)
            # add a link to list all the organizations
            items += [(url, "List participating Organizations", 'any_access')]

        user_fields = {'user': user, 'status': 'active'}
        host_entity = host_logic.getForFields(user_fields, unique=True)

        # for org admins this link should be visible only after accepted
        # organizations are announced and for other public after the tasks
        # are public but for program host it must be visible always
        if (host_entity or ((org_admin_entity or mentor_entity)
                            and timeline_helper.isAfterEvent(
                                timeline_entity, 'tasks_publicly_visible'))
                or (timeline_helper.isAfterEvent(timeline_entity,
                                                 'tasks_publicly_visible'))):
            url = gci_redirects.getListAllTasksRedirect(
                gci_program_entity, params)
            # add a link to list all the organizations
            items += [(url, "List all tasks", 'any_access')]

            if user:
                # add a link to show all tasks of interest
                items += [(gci_redirects.getListMyTasksRedirect(
                    gci_program_entity,
                    params), 'List my Tasks', 'any_access')]

        return items
Exemple #6
0
  def _getTimeDependentEntries(self, gci_program_entity, params, id, user):
    """Returns a list with time dependent menu items.
    """

    items = []

    timeline_entity = gci_program_entity.timeline

    # add show ranking item
    if timeline_helper.isAfterEvent(timeline_entity, 'tasks_publicly_visible'):
      items += [(gci_redirects.getShowRankingRedirect(
           gci_program_entity, {'url_name': 'gci/program'}),
           'Show Ranking', 'any_access')]

    mentor_entity = None
    org_admin_entity = None

    org_app_survey = org_app_logic.getForProgram(gci_program_entity)

    if org_app_survey and \
        timeline_helper.isActivePeriod(org_app_survey, 'survey'):
      # add the organization signup link
      items += [
          (redirects.getTakeSurveyRedirect(
               org_app_survey, {'url_name': 'gci/org_app'}),
          "Apply to become an Organization", 'any_access')]

    if user and org_app_survey and timeline_helper.isAfterEvent(
        org_app_survey, 'survey_start'):

      main_admin_fields = {
          'main_admin': user,
          'survey': org_app_survey,
          }

      backup_admin_fields = {
          'backup_admin': user,
          'survey': org_app_survey
          }

      org_app_record_logic = org_app_logic.getRecordLogic()

      if org_app_record_logic.getForFields(main_admin_fields, unique=True) or \
          org_app_record_logic.getForFields(backup_admin_fields, unique=True):
        # add the 'List my Organization Applications' link
        items += [
            (redirects.getListSelfRedirect(org_app_survey,
                                           {'url_name' : 'gci/org_app'}),
             "List My Organization Applications", 'any_access')]

    # get the student entity for this user and program
    filter = {'user': user,
              'scope': gci_program_entity,
              'status': ['active', 'inactive']}
    student_entity = gci_student_logic.logic.getForFields(filter, unique=True)

    # students can register after successfully completing their first
    # task. So if a user has completed one task he is still a student
    filter = {
        'user': user,
        'program': gci_program_entity,
        }
    has_completed_task = gci_task_logic.logic.getForFields(
        filter, unique=True)

    if student_entity or (user and has_completed_task):
      items += self._getStudentEntries(gci_program_entity, student_entity,
                                       params, id, user, 'gci')
    else:
      # get mentor and org_admin entity for this user and program
      filter = {
          'user': user,
          'program': gci_program_entity,
          'status': 'active'
          }
      mentor_entity = gci_mentor_logic.logic.getForFields(filter, unique=True)
      org_admin_entity = gci_org_admin_logic.logic.getForFields(
          filter, unique=True)

      if timeline_helper.isAfterEvent(
          timeline_entity, 'accepted_organization_announced_deadline'):
        if mentor_entity or org_admin_entity:
          items += self._getOrganizationEntries(
              gci_program_entity, org_admin_entity,
              mentor_entity, params, id, user)
        if timeline_helper.isBeforeEvent(timeline_entity, 'program_end'):
          # add apply to become a mentor link
          items += [
              ('/gci/org/apply_mentor/%s' % (
                  gci_program_entity.key().id_or_name()),
                  "Apply to become a Mentor", 'any_access')]

    if timeline_helper.isAfterEvent(
        timeline_entity, 'accepted_organization_announced_deadline'):
      url = redirects.getAcceptedOrgsRedirect(
          gci_program_entity, params)
      # add a link to list all the organizations
      items += [(url, "List participating Organizations", 'any_access')]

    user_fields = {
        'user': user,
        'status': 'active'
        }
    host_entity = host_logic.getForFields(user_fields, unique=True)

    # for org admins this link should be visible only after accepted
    # organizations are announced and for other public after the tasks
    # are public but for program host it must be visible always
    if (host_entity or
        ((org_admin_entity or mentor_entity) and timeline_helper.isAfterEvent(
        timeline_entity, 'tasks_publicly_visible')) or
        (timeline_helper.isAfterEvent(
        timeline_entity, 'tasks_publicly_visible'))):
      url = gci_redirects.getListAllTasksRedirect(
          gci_program_entity, params)
      # add a link to list all the organizations
      items += [(url, "List all tasks", 'any_access')]

      if user:
        # add a link to show all tasks of interest
        items += [(gci_redirects.getListMyTasksRedirect(
            gci_program_entity, params),
            'List my Tasks', 'any_access')]

    return items
Exemple #7
0
    def _getTimeDependentEntries(self, program_entity, params, id, user):
        """Returns a list with time dependent menu items.
    """

        from soc.modules.gsoc.logic.models.org_app_survey import logic as \
            org_app_logic

        items = []

        timeline_entity = program_entity.timeline

        org_app_survey = org_app_logic.getForProgram(program_entity)

        if org_app_survey and \
            timeline_helper.isActivePeriod(timeline_entity, 'org_signup'):
            # add the organization signup link
            items += [
                (redirects.getTakeSurveyRedirect(org_app_survey,
                                                 {'url_name': 'gsoc/org_app'}),
                 "Apply to become an Organization", 'any_access')
            ]

        if user and org_app_survey and timeline_helper.isAfterEvent(
                timeline_entity, 'org_signup_start'):

            main_admin_fields = {
                'main_admin': user,
                'survey': org_app_survey,
            }

            backup_admin_fields = {
                'backup_admin': user,
                'survey': org_app_survey
            }

            org_app_record_logic = org_app_logic.getRecordLogic()

            if org_app_record_logic.getForFields(main_admin_fields, unique=True) or \
                org_app_record_logic.getForFields(backup_admin_fields, unique=True):
                # add the 'List my Organization Applications' link
                items += [(redirects.getListSelfRedirect(
                    org_app_survey, {'url_name': 'gsoc/org_app'}),
                           "List My Organization Applications", 'any_access')]

        # get the student entity for this user and program
        filter = {
            'user': user,
            'scope': program_entity,
            'status': ['active', 'inactive']
        }
        student_entity = student_logic.getForFields(filter, unique=True)

        if student_entity:
            items += self._getStudentEntries(program_entity, student_entity,
                                             params, id, user, 'gsoc')

        # get mentor and org_admin entity for this user and program
        filter = {
            'user': user,
            'program': program_entity,
            'status': ['active', 'inactive']
        }
        mentor_entity = mentor_logic.getForFields(filter, unique=True)
        org_admin_entity = org_admin_logic.getForFields(filter, unique=True)

        if mentor_entity or org_admin_entity:
            items += self._getOrganizationEntries(program_entity,
                                                  org_admin_entity,
                                                  mentor_entity, params, id,
                                                  user)

        if user and not (student_entity or mentor_entity or org_admin_entity):
            if timeline_helper.isActivePeriod(timeline_entity,
                                              'student_signup'):
                # this user does not have a role yet for this program
                items += [('/gsoc/student/apply/%s' %
                           (program_entity.key().id_or_name()),
                           "Register as a Student", 'any_access')]

        deadline = 'accepted_organization_announced_deadline'

        if timeline_helper.isAfterEvent(timeline_entity, deadline):
            url = redirects.getAcceptedOrgsRedirect(program_entity, params)
            # add a link to list all the organizations
            items += [(url, "List participating Organizations", 'any_access')]

            if not student_entity and \
                timeline_helper.isBeforeEvent(timeline_entity, 'program_end'):
                # add apply to become a mentor link
                items += [('/gsoc/org/apply_mentor/%s' %
                           (program_entity.key().id_or_name()),
                           "Apply to become a Mentor", 'any_access')]

        deadline = 'accepted_students_announced_deadline'

        if timeline_helper.isAfterEvent(timeline_entity, deadline):
            items += [(redirects.getListProjectsRedirect(
                program_entity, {'url_name': 'gsoc/program'}),
                       "List all Student Projects", 'any_access')]

        return items
Exemple #8
0
  def _getTimeDependentEntries(self, program_entity, params, id, user):
    """Returns a list with time dependent menu items.
    """

    items = []

    timeline_entity = program_entity.timeline

    org_app_survey = org_app_logic.getForProgram(program_entity)

    if org_app_survey and \
        timeline_helper.isActivePeriod(org_app_survey, 'survey'):
      # add the organization signup link
      items += [
          (redirects.getTakeSurveyRedirect(
               org_app_survey, {'url_name': 'gsoc/org_app'}),
          "Apply to become an Organization", 'any_access')]

    if user and org_app_survey and timeline_helper.isAfterEvent(
        org_app_survey, 'survey_start'):

      main_admin_fields = {
          'main_admin': user,
          'survey': org_app_survey,
          }

      backup_admin_fields = {
          'backup_admin': user,
          'survey': org_app_survey
          }

      org_app_record_logic = org_app_logic.getRecordLogic()

      if org_app_record_logic.getForFields(main_admin_fields, unique=True) or \
          org_app_record_logic.getForFields(backup_admin_fields, unique=True):
        # add the 'List my Organization Applications' link
        items += [
            (redirects.getListSelfRedirect(org_app_survey,
                                           {'url_name' : 'gsoc/org_app'}),
             "List My Organization Applications", 'any_access')]

    # get the student entity for this user and program
    filter = {
        'user': user,
        'scope': program_entity,
        'status': ['active', 'inactive']
        }
    student_entity = student_logic.getForFields(filter, unique=True)

    if student_entity:
      items += self._getStudentEntries(program_entity, student_entity,
                                       params, id, user, 'gsoc')

    # get mentor and org_admin entity for this user and program
    filter = {
        'user': user,
        'program': program_entity,
        'status': ['active', 'inactive']
        }
    mentor_entity = mentor_logic.getForFields(filter, unique=True)
    org_admin_entity = org_admin_logic.getForFields(filter, unique=True)

    if mentor_entity or org_admin_entity:
      items += self._getOrganizationEntries(program_entity, org_admin_entity,
                                            mentor_entity, params, id, user)

    if not (student_entity or mentor_entity or org_admin_entity):
      if timeline_helper.isActivePeriod(timeline_entity, 'student_signup'):
        # this user does not have a role yet for this program
        items += [
            ('/gsoc/student/apply/%s' % (program_entity.key().id_or_name()),
            "Register as a Student", 'any_access')]

    deadline = 'accepted_organization_announced_deadline'

    if timeline_helper.isAfterEvent(timeline_entity, deadline):
      url = redirects.getAcceptedOrgsRedirect(program_entity, params)
      # add a link to list all the organizations
      items += [(url, "List participating Organizations", 'any_access')]

      if not student_entity and \
          timeline_helper.isBeforeEvent(timeline_entity, 'program_end'):
        # add apply to become a mentor link
        items += [
            ('/gsoc/org/apply_mentor/%s' % (program_entity.key().id_or_name()),
           "Apply to become a Mentor", 'any_access')]

    deadline = 'accepted_students_announced_deadline'

    if timeline_helper.isAfterEvent(timeline_entity, deadline):
      items += [(redirects.getListProjectsRedirect(program_entity,
          {'url_name':'gsoc/program'}),
          "List all Student Projects", 'any_access')]

    return items