← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to ivle/worksheet/utils.py

  • Committer: William Grant
  • Date: 2009-12-07 10:12:10 UTC
  • mto: This revision was merged to the branch mainline in revision 1343.
  • Revision ID: grantw@unimelb.edu.au-20091207101210-xjmc2dbjugqw0s4g
Make the "Add a new project set" link actually do something.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/worksheet/utils.py
23
23
This module provides functions for tutorial and worksheet computations.
24
24
"""
25
25
 
26
 
from storm.locals import And, Asc, Desc
 
26
from storm.locals import And, Asc, Desc, Store
 
27
import genshi
 
28
 
27
29
import ivle.database
 
30
from ivle.database import ExerciseAttempt, ExerciseSave, Worksheet, \
 
31
                          WorksheetExercise, Exercise
28
32
 
29
33
__all__ = ['get_exercise_status', 'get_exercise_stored_text',
30
34
           'get_exercise_attempts', 'get_exercise_attempt',
31
35
          ]
32
36
 
33
 
def get_exercise_status(store, user, exercise):
 
37
def get_exercise_status(store, user, worksheet_exercise, as_of=None):
34
38
    """Given a storm.store, User and Exercise, returns information about
35
39
    the user's performance on that problem.
 
40
    @param store: A storm.store
 
41
    @param user: A User.
 
42
    @param worksheet_exercise: An Exercise.
 
43
    @param as_of: Optional datetime. If supplied, gets the status as of as_of.
36
44
    Returns a tuple of:
37
45
        - A boolean, whether they have successfully passed this exercise.
38
46
        - An int, the number of attempts they have made up to and
39
47
          including the first successful attempt (or the total number of
40
48
          attempts, if not yet successful).
41
49
    """
42
 
    ExerciseAttempt = ivle.database.ExerciseAttempt
43
50
    # A Storm expression denoting all active attempts by this user for this
44
51
    # exercise.
45
52
    is_relevant = ((ExerciseAttempt.user_id == user.id) &
46
 
                   (ExerciseAttempt.exercise_id == exercise.id) &
47
 
                   (ExerciseAttempt.active == True))
 
53
            (ExerciseAttempt.ws_ex_id == worksheet_exercise.id) &
 
54
            (ExerciseAttempt.active == True))
 
55
    if as_of is not None:
 
56
        is_relevant &= ExerciseAttempt.date <= as_of
48
57
 
49
58
    # Get the first successful active attempt, or None if no success yet.
50
59
    # (For this user, for this exercise).
66
75
 
67
76
    return first_success is not None, num_attempts
68
77
 
69
 
def get_exercise_stored_text(store, user, exercise):
70
 
    """Given a storm.store, User and Exercise, returns an
 
78
def get_exercise_stored_text(store, user, worksheet_exercise):
 
79
    """Given a storm.store, User and WorksheetExercise, returns an
71
80
    ivle.database.ExerciseSave object for the last saved/submitted attempt for
72
81
    this question (note that ExerciseAttempt is a subclass of ExerciseSave).
73
82
    Returns None if the user has not saved or made an attempt on this
75
84
    If the user has both saved and submitted, it returns whichever was
76
85
    made last.
77
86
    """
78
 
    ExerciseSave = ivle.database.ExerciseSave
79
 
    ExerciseAttempt = ivle.database.ExerciseAttempt
80
87
 
81
88
    # Get the saved text, or None
82
89
    saved = store.find(ExerciseSave,
83
90
                ExerciseSave.user_id == user.id,
84
 
                ExerciseSave.exercise_id == exercise.id).one()
 
91
                ExerciseSave.ws_ex_id == worksheet_exercise.id).one()
85
92
 
86
93
    # Get the most recent attempt, or None
87
94
    attempt = store.find(ExerciseAttempt,
88
95
            ExerciseAttempt.user_id == user.id,
89
 
            ExerciseAttempt.exercise_id == exercise.id,
90
96
            ExerciseAttempt.active == True,
 
97
            ExerciseAttempt.ws_ex_id == worksheet_exercise.id
91
98
        ).order_by(Asc(ExerciseAttempt.date)).last()
92
99
 
93
100
    # Pick the most recent of these two
102
109
        else:
103
110
            return None
104
111
 
105
 
def _get_exercise_attempts(store, user, exercise, as_of=None,
 
112
def _get_exercise_attempts(store, user, worksheet_exercise, as_of=None,
106
113
        allow_inactive=False):
107
114
    """Same as get_exercise_attempts, but doesn't convert Storm's iterator
108
115
    into a list."""
109
 
    ExerciseAttempt = ivle.database.ExerciseAttempt
110
116
 
111
117
    # Get the most recent attempt before as_of, or None
112
118
    return store.find(ExerciseAttempt,
113
119
            ExerciseAttempt.user_id == user.id,
114
 
            ExerciseAttempt.exercise_id == exercise.id,
 
120
            ExerciseAttempt.ws_ex_id == worksheet_exercise.id,
115
121
            True if allow_inactive else ExerciseAttempt.active == True,
116
122
            True if as_of is None else ExerciseAttempt.date <= as_of,
117
123
        ).order_by(Desc(ExerciseAttempt.date))
118
124
 
119
 
def get_exercise_attempts(store, user, exercise, as_of=None,
 
125
def get_exercise_attempts(store, user, worksheet_exercise, as_of=None,
120
126
        allow_inactive=False):
121
127
    """Given a storm.store, User and Exercise, returns a list of
122
128
    ivle.database.ExerciseAttempt objects, one for each attempt made for the
126
132
        attempts made before or at this time.
127
133
    allow_inactive: If True, will return disabled attempts.
128
134
    """
129
 
    return list(_get_exercise_attempts(store, user, exercise, as_of,
 
135
    return list(_get_exercise_attempts(store, user, worksheet_exercise, as_of,
130
136
        allow_inactive))
131
137
 
132
 
def get_exercise_attempt(store, user, exercise, as_of=None,
 
138
def get_exercise_attempt(store, user, worksheet_exercise, as_of=None,
133
139
        allow_inactive=False):
134
 
    """Given a storm.store, User and Exercise, returns an
 
140
    """Given a storm.store, User and WorksheetExercise, returns an
135
141
    ivle.database.ExerciseAttempt object for the last submitted attempt for
136
142
    this question.
137
143
    Returns None if the user has not made an attempt on this
141
147
        attempts made before or at this time.
142
148
    allow_inactive: If True, will return disabled attempts.
143
149
    """
144
 
    return _get_exercise_attempts(store, user, exercise, as_of,
 
150
    return _get_exercise_attempts(store, user, worksheet_exercise, as_of,
145
151
        allow_inactive).first()
146
152
 
147
 
def save_exercise(store, user, exercise, text, date):
 
153
def save_exercise(store, user, worksheet_exercise, text, date):
148
154
    """Save an exercise for a user.
149
155
 
150
 
    Given a store, User, Exercise and text and date, save the text to the
 
156
    Given a store, User, WorksheetExercise, text and date, save the text to the
151
157
    database. This will create the ExerciseSave if needed.
152
158
    """
153
159
    saved = store.find(ivle.database.ExerciseSave,
154
160
                ivle.database.ExerciseSave.user_id == user.id,
155
 
                ivle.database.ExerciseSave.exercise_id == exercise.id).one()
 
161
                ivle.database.ExerciseSave.ws_ex_id == worksheet_exercise.id
 
162
                ).one()
156
163
    if saved is None:
157
 
        saved = ivle.database.ExerciseSave(user=user, exercise=exercise)
 
164
        saved = ivle.database.ExerciseSave(user=user, 
 
165
                                        worksheet_exercise=worksheet_exercise)
158
166
        store.add(saved)
159
167
 
160
168
    saved.date = date
161
169
    saved.text = text
162
170
 
163
 
def calculate_score(store, user, worksheet):
 
171
def calculate_score(store, user, worksheet, as_of=None):
164
172
    """
165
173
    Given a storm.store, User, Exercise and Worksheet, calculates a score for
166
174
    the user on the given worksheet.
 
175
    @param store: A storm.store
 
176
    @param user: A User.
 
177
    @param worksheet: A Worksheet.
 
178
    @param as_of: Optional datetime. If supplied, gets the score as of as_of.
167
179
    Returns a 4-tuple of ints, consisting of:
168
180
    (No. mandatory exercises completed,
169
181
     Total no. mandatory exercises,
178
190
    # Get the student's pass/fail for each exercise in this worksheet
179
191
    for worksheet_exercise in worksheet.worksheet_exercises:
180
192
        exercise = worksheet_exercise.exercise
 
193
        worksheet = worksheet_exercise.worksheet
181
194
        optional = worksheet_exercise.optional
182
195
 
183
 
        done, _ = get_exercise_status(store, user, exercise)
 
196
        done, _ = get_exercise_status(store, user, worksheet_exercise, as_of)
184
197
        # done is a bool, whether this student has completed that problem
185
198
        if optional:
186
199
            opt_total += 1
190
203
            if done: mand_done += 1
191
204
 
192
205
    return mand_done, mand_total, opt_done, opt_total
 
206
 
 
207
def calculate_mark(mand_done, mand_total):
 
208
    """Calculate a subject mark, given the result of all worksheets.
 
209
    @param mand_done: The total number of mandatory exercises completed by
 
210
        some student, across all worksheets.
 
211
    @param mand_total: The total number of mandatory exercises across all
 
212
        worksheets in the offering.
 
213
    @return: (percent, mark, mark_total)
 
214
        percent: The percentage of exercises the student has completed, as an
 
215
            integer between 0 and 100 inclusive.
 
216
        mark: The mark the student has received, based on the percentage.
 
217
        mark_total: The total number of marks available (currently hard-coded
 
218
            as 5).
 
219
    """
 
220
    # We want to display a students mark out of 5. However, they are
 
221
    # allowed to skip 1 in 5 questions and still get 'full marks'.
 
222
    # Hence we divide by 16, essentially making 16 percent worth
 
223
    # 1 star, and 80 or above worth 5.
 
224
    if mand_total > 0:
 
225
        percent_int = (100 * mand_done) // mand_total
 
226
    else:
 
227
        # Avoid Div0, just give everyone 0 marks if there are none available
 
228
        percent_int = 0
 
229
    # percent / 16, rounded down, with a maximum mark of 5
 
230
    max_mark = 5
 
231
    mark = min(percent_int // 16, max_mark)
 
232
    return (percent_int, mark, max_mark)
 
233
 
 
234
def update_exerciselist(worksheet):
 
235
    """Runs through the worksheetstream, generating the appropriate
 
236
    WorksheetExercises, and de-activating the old ones."""
 
237
    exercises = []
 
238
    # Turns the worksheet into an xml stream, and then finds all the 
 
239
    # exercise nodes in the stream.
 
240
    worksheetdata = genshi.XML(worksheet.get_xml())
 
241
    for kind, data, pos in worksheetdata:
 
242
        if kind is genshi.core.START:
 
243
            # Data is a tuple of tag name and a list of name->value tuples
 
244
            if data[0] == 'exercise':
 
245
                src = ""
 
246
                optional = False
 
247
                for attr in data[1]:
 
248
                    if attr[0] == 'src':
 
249
                        src = attr[1]
 
250
                    if attr[0] == 'optional':
 
251
                        optional = attr[1] == 'true'
 
252
                if src != "":
 
253
                    exercises.append((src, optional))
 
254
    ex_num = 0
 
255
    # Set all current worksheet_exercises to be inactive
 
256
    db_worksheet_exercises = Store.of(worksheet).find(WorksheetExercise,
 
257
        WorksheetExercise.worksheet_id == worksheet.id)
 
258
    for worksheet_exercise in db_worksheet_exercises:
 
259
        worksheet_exercise.active = False
 
260
    
 
261
    for exerciseid, optional in exercises:
 
262
        worksheet_exercise = Store.of(worksheet).find(WorksheetExercise,
 
263
            WorksheetExercise.worksheet_id == worksheet.id,
 
264
            Exercise.id == WorksheetExercise.exercise_id,
 
265
            Exercise.id == exerciseid).one()
 
266
        if worksheet_exercise is None:
 
267
            exercise = Store.of(worksheet).find(Exercise,
 
268
                Exercise.id == exerciseid
 
269
            ).one()
 
270
            if exercise is None:
 
271
                raise NotFound()
 
272
            worksheet_exercise = WorksheetExercise()
 
273
            worksheet_exercise.worksheet_id = worksheet.id
 
274
            worksheet_exercise.exercise_id = exercise.id
 
275
            Store.of(worksheet).add(worksheet_exercise)
 
276
        worksheet_exercise.active = True
 
277
        worksheet_exercise.seq_no = ex_num
 
278
        worksheet_exercise.optional = optional
 
279