1 #!/usr/bin/python2.5

     2 #

     3 # Copyright 2009 the Melange authors.

     4 #

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

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

     7 # You may obtain a copy of the License at

     8 #

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

    10 #

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

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

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

    14 # See the License for the specific language governing permissions and

    15 # limitations under the License.

    16 

    17 """Survey (Model) query functions.

    18 """

    19 

    20 __authors__ = [

    21   '"Daniel Diniz" <ajaksu@gmail.com>',

    22   '"James Levy" <jamesalexanderlevy@gmail.com>',

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

    24   ]

    25 

    26 

    27 import logging

    28 

    29 from google.appengine.ext import db

    30 

    31 from soc.cache import sidebar

    32 from soc.logic.models import linkable as linkable_logic

    33 from soc.logic.models.news_feed import logic as newsfeed_logic

    34 from soc.logic.models.user import logic as user_logic

    35 from soc.logic.models import work

    36 from soc.models.program import Program

    37 from soc.models import student_project

    38 from soc.models.survey import Survey

    39 from soc.models.survey import SurveyContent

    40 from soc.models.survey_record import SurveyRecord

    41 from soc.models.survey_record_group import SurveyRecordGroup

    42 from soc.models.work import Work

    43 

    44 #TODO(James): Ensure this facilitates variable # of surveys 

    45 GRADES = {'pass': True, 'fail': False}

    46 PROJECT_STATUSES = {

    47 'accepted': {True: 'mid_term_passed', False: 'mid_term_failed'},

    48 'mid_term_passed': {True: 'passed', False: 'final_failed'}

    49 }

    50 

    51 class Logic(work.Logic):

    52   """Logic methods for the Survey model.

    53   """

    54 

    55   def __init__(self, model=Survey, base_model=Work,

    56                scope_logic=linkable_logic):

    57     """Defines the name, key_name and model for this entity.

    58     """

    59 

    60     super(Logic, self).__init__(model=model, base_model=base_model,

    61                                 scope_logic=scope_logic)

    62 

    63   def createSurvey(self, survey_fields, schema, survey_content=False):

    64     """Create a new survey from prototype.

    65 

    66     params:

    67       survey_fields = dict of survey field items (see SurveyContent model)

    68       schema = metadata about survey fields (SurveyContent.schema)

    69       survey_content = existing SurveyContent entity

    70     """

    71 

    72     if not survey_content:

    73       survey_content = SurveyContent()

    74     else:

    75       # wipe clean existing dynamic properties if they exist

    76       for prop in survey_content.dynamic_properties():

    77         delattr(survey_content, prop)

    78 

    79     for name, value in survey_fields.items():

    80       setattr(survey_content, name, value)

    81 

    82     survey_content.schema = str(schema)

    83 

    84     db.put(survey_content)

    85 

    86     return survey_content

    87 

    88   def updateSurveyRecord(self, user, survey, survey_record, fields):

    89     """ Create a new survey record, or get an existing one.

    90 

    91     params:

    92       user = user taking survey

    93       survey = survey entity

    94       survey_record = existing record, if one exists

    95       fields = submitted responses to survey fields

    96     """

    97     if survey_record:

    98       create = False

    99       for prop in survey_record.dynamic_properties():

   100         delattr(survey_record, prop)

   101     else:

   102       create = True

   103       survey_record = SurveyRecord(user=user, survey=survey)

   104 

   105     schema = eval(survey.survey_content.schema)

   106 

   107     for name, value in fields.items():

   108       if name == 'project':

   109         project = student_project.StudentProject.get(value)

   110         survey_record.project = project

   111       elif name == 'grade':

   112         survey_record.grade = GRADES[value]

   113       else:

   114         pick_multi = name in schema and schema[name]['type'] == 'pick_multi'

   115         if pick_multi and hasattr(fields, 'getlist'): # it's a multidict

   116           setattr(survey_record, name, ','.join(fields.getlist(name)))

   117         else:

   118           setattr(survey_record, name, value)

   119 

   120     # if creating evaluation record, set SurveyRecordGroup

   121     db.put(survey_record)

   122     if 'evaluation' in survey.taking_access and create:

   123       if not project: return False

   124       role = self.getUserRole(user, survey, project)

   125       survey_record_group = self.setSurveyRecordGroup(survey,

   126       survey_record, project)

   127       if survey_record_group:  db.put(survey_record_group)

   128 

   129     return survey_record

   130 

   131   def setSurveyRecordGroup(self, survey, survey_record, project):

   132     """First looks for an existing SurveyRecordGroup, using the

   133     project and its current status as a filter.

   134 

   135     IOW SurveyRecordGroup cannot consist of surveys taken with

   136     two different statuses.

   137 

   138     This means that a student cannot take a survey after the mentor

   139     has taken the accompanying survey and the project has since

   140     changed. (Assuming we want this strict behavior)

   141 

   142     params:

   143       survey = survey entity

   144       survey_record = saved response to survey

   145       project = student project for survey taker

   146     """

   147 

   148     group_query = SurveyRecordGroup.all(

   149     ).filter("project = ", project

   150     ).filter("initial_status = ", project.status

   151     )

   152 

   153     if survey.taking_access == 'mentor evaluation':

   154       survey_record_group = group_query.filter(

   155       "mentor = ", None ).get()

   156     elif survey.taking_access == 'student evaluation':

   157       survey_record_group = group_query.filter(

   158       "student = ", None ).get()

   159 

   160     if not survey_record_group:

   161       #create Survey Record Group if it doesn't already exist

   162       survey_record_group = SurveyRecordGroup(

   163       project=project,

   164       initial_status = project.status

   165       )

   166 

   167     if survey.taking_access == 'mentor evaluation':

   168       survey_record_group.mentor_record = survey_record

   169     elif survey.taking_access == 'student evaluation':

   170       survey_record_group.student_record = survey_record

   171 

   172     return survey_record_group

   173 

   174   def getUserRole(self, user, survey, project):

   175     """Gets the role of a user for a project, used for SurveyRecordGroup.

   176 

   177     params:

   178       user: user taking survey

   179       survey: survey entity

   180       project: student project for this user

   181     """

   182 

   183     if survey.taking_access == 'mentor evaluation':

   184       mentors = self.getMentorforProject(user, project)

   185 

   186       if len(mentors) < 1 or len(mentors) > 1:

   187         logging.warning('Unable to determine mentor for \

   188         user %s. Results returned: %s ' % (

   189         user.key().name(), str(mentors)) )

   190         return False

   191 

   192       this_mentor = mentors[0]

   193 

   194     if survey.taking_access == 'student evaluation':

   195       students = self.getStudentforProject(user, project)

   196 

   197       if len(students) < 1 or len(students) > 1:

   198         logging.warning('Unable to determine student for \

   199         user %s. Results returned: %s ' % (

   200         user.key().name(), str(students)) )

   201         return False

   202 

   203       this_student = students[0]

   204 

   205   def getStudentforProject(self, user, project):

   206     """Get student projects for a given User.

   207 

   208     params:

   209       user = survey taking user

   210       project = survey taker's student project

   211     """

   212     from soc.logic.models.student import logic as student_logic

   213     import soc.models.student

   214 

   215     # TODO this should be done per Student or Program

   216     # TODO filter for accepted, midterm_passed, etc?

   217     user_students = student_logic.getForFields({'user': user}) 

   218     if not user_students: return []

   219     return set([project.student for project in sum(

   220     (list(s.student_projects.run())

   221     for s in user_students), []) if project.key() == project.key()])

   222 

   223   def getMentorforProject(self, user, project):

   224     """Get Student Projects that are being mentored by the given User.

   225 

   226     params:

   227       user = survey taking user

   228       project = survey taker's student project

   229     """

   230 

   231     from soc.logic.models.mentor import logic as mentor_logic

   232     import soc.models.mentor

   233 

   234     # TODO filter for accepted, midterm_passed, etc?

   235     # TODO this should be done a program basis not user

   236 

   237     user_mentors = mentor_logic.getForFields({'user': user}) 

   238 

   239     if not user_mentors:

   240       return []

   241 

   242     return set([project.mentor for project in sum(

   243             (list(mentor.student_projects.run())

   244              for mentor in user_mentors), [])

   245         if project.key() == project.key()])

   246 

   247   def activateGrades(self, survey):

   248     """Activates the grades on a Grading Survey.

   249 

   250     TODO(James) Fix this Docstring

   251 

   252     params:

   253       survey = survey entity

   254     """

   255     if survey.taking_access != "mentor evaluation":

   256       logging.error("Cannot grade survey %s with taking access %s"

   257       % (survey.key().name(), survey.taking_access))

   258       return False

   259 

   260     program = survey.scope

   261 

   262     for project in program.student_projects.fetch(1000):

   263       this_record_group = SurveyRecordGroup.all().filter(

   264       "project = ", project).filter(

   265       "initial_status = ", project.status).get()

   266 

   267       if not this_record_group:

   268          logging.warning('neither mentor nor student has \

   269          taken the survey for project %s' % project.key().name() )

   270          continue

   271 

   272       if not this_record_group.mentor_record:

   273         # student has taken survey, but not mentor

   274         logging.warning('not continuing without mentor record...')

   275         continue

   276 

   277       status_options = PROJECT_STATUSES.get(project.status)

   278 

   279       if not status_options:

   280         logging.warning('unable to find status options for project \

   281         status %s' % project.status)

   282         continue

   283 

   284       new_project_grade = this_record_group.mentor_record.grade

   285       new_project_status = status_options.get(new_project_grade)

   286 

   287       if getattr(this_record_group, 'final_status'):

   288          logging.warning('project %s record group should not \

   289          yet have a final status %s' % (

   290          project.key().name(), this_record_group.final_status ) )

   291          continue

   292 

   293       # assign the new status to the project and s

   294       project.status = new_project_status

   295       this_record_group.final_status = new_project_status

   296 

   297   def getKeyNameFromPath(self, path):

   298     """Gets survey key name from a request path.

   299 

   300     params:

   301       path = path of the current request

   302     """

   303 

   304     # TODO determine if kwargs in the request contains this information

   305     return '/'.join(path.split('/')[-4:]).split('?')[0]

   306 

   307   def getProjects(self, survey, user):

   308     """Get projects linking user to a program.

   309 

   310     Serves as access handler (since no projects == no access).

   311     And retrieves projects to choose from (if mentors have >1 projects).

   312 

   313     params:

   314       survey = survey entity

   315       user = survey taking user

   316     """

   317     this_program = survey.scope

   318 

   319     if 'mentor' in survey.taking_access:

   320       these_projects = self.getMentorProjects(user, this_program)

   321 

   322     if 'student' in survey.taking_access:

   323       these_projects = self.getStudentProjects(user, this_program)

   324 

   325     logging.info(these_projects)

   326 

   327     if len(these_projects) == 0:

   328       return False

   329 

   330     return these_projects

   331 

   332   def getDebugUser(self, survey, this_program):

   333     """Debugging method impersonates other roles.

   334 

   335     Tests taking survey, saving response, and grading.

   336 

   337     params:

   338       survey = survey entity

   339       this_program = program scope of survey

   340     """

   341 

   342     if 'mentor' in survey.taking_access:

   343       from soc.models.mentor import Mentor

   344       role = Mentor.get_by_key_name(

   345       this_program.key().name() + "/org_1/test")

   346 

   347     if 'student' in survey.taking_access:

   348       from soc.models.student import Student

   349       role = Student.get_by_key_name(

   350       this_program.key().name() + "/test")

   351 

   352     if role: return role.user

   353 

   354   def getKeyValuesFromEntity(self, entity):

   355     """See base.Logic.getKeyNameValues.

   356     """

   357 

   358     return [entity.prefix, entity.scope_path, entity.link_id]

   359 

   360   def getKeyValuesFromFields(self, fields):

   361     """See base.Logic.getKeyValuesFromFields.

   362     """

   363 

   364     return [fields['prefix'], fields['scope_path'], fields['link_id']]

   365 

   366   def getKeyFieldNames(self):

   367     """See base.Logic.getKeyFieldNames.

   368     """

   369 

   370     return ['prefix', 'scope_path', 'link_id']

   371 

   372   def getScope(self, entity):

   373     """Gets Scope for entity.

   374 

   375     params:

   376       entity = Survey entity

   377     """

   378 

   379     if getattr(entity, 'scope', None):

   380       return entity.scope

   381 

   382     import soc.models.program

   383     import soc.models.organization

   384     import soc.models.user

   385     import soc.models.site

   386 

   387     # use prefix to generate dict key

   388     scope_types = {"program": soc.models.program.Program,

   389     "org": soc.models.organization.Organization,

   390     "user": soc.models.user.User,

   391     "site": soc.models.site.Site}

   392 

   393     # determine the type of the scope

   394     scope_type = scope_types.get(entity.prefix)

   395 

   396     if not scope_type:

   397       # no matching scope type found

   398       raise AttributeError('No Matching Scope type found for %s' % entity.prefix)

   399 

   400     # set the scope and update the entity

   401     entity.scope = scope_type.get_by_key_name(entity.scope_path)

   402     entity.put()

   403 

   404     # return the scope

   405     return entity.scope

   406 

   407 logic = Logic()

   408 

   409 

   410 class ResultsLogic(work.Logic):

   411   """Logic methods for listing results for Surveys.

   412   """

   413 

   414   def __init__(self, model=SurveyRecord,

   415                base_model=None, scope_logic=None):

   416     """Defines the name, key_name and model for this entity.

   417     """

   418 

   419     super(ResultsLogic, self).__init__(model=model, base_model=base_model,

   420                                 scope_logic=scope_logic)

   421 

   422 

   423 results_logic = ResultsLogic()