def _compute_and_update_grade(self,
student,
course,
course_structure,
read_only=False):
"""
Freshly computes and updates the grade for the student and course.
If read_only is True, doesn't save any updates to the grades.
"""
course_grade = CourseGrade(student, course, course_structure)
course_grade.compute_and_update(read_only)
# END TMA GRADE TRACKING UPDATE
mongo_persist = dashboardStats()
collection = mongo_persist.connect()
add_user = {}
add_user['user_id'] = student.id
add_user['username'] = student.username
add_user['passed'] = course_grade.passed
add_user['percent'] = course_grade.percent
add_user['summary'] = course_grade.summary
mongo_persist.add_user_grade_info(collection, str(course.id), add_user)
log.info('mongo_tracking_insert')
# END TMA GRADE TRACKING UPDATE
return course_grade
def ensure_certif(request, course_id):
user_id = request.user.id
username = request.user.username
course_key = SlashSeparatedCourseKey.from_deprecated_string(course_id)
course_tma = get_course_by_id(course_key)
is_graded = course_tma.is_graded
grade_cutoffs = modulestore().get_course(
course_key, depth=0).grade_cutoffs['Pass'] * 100
grading_note = CourseGradeFactory().create(request.user, course_tma)
#TMA GRADE TRACKING UPDATE
mongo_persist = dashboardStats()
collection = mongo_persist.connect()
add_user = {}
add_user['user_id'] = request.user.id
add_user['username'] = request.user.username
add_user['passed'] = grading_note.passed
add_user['percent'] = grading_note.percent
add_user['summary'] = grading_note.summary
mongo_persist.add_user_grade_info(collection, str(course_id), add_user)
# END TMA GRADE TRACKING UPDATE
passed = grading_note.passed
percent = float(int(grading_note.percent * 1000) / 10)
overall_progress = get_overall_progress(request.user.id, course_key)
context = {
'passed': passed,
'percent': percent,
'is_graded': is_graded,
'grade_cutoffs': grade_cutoffs,
'overall_progress': overall_progress
}
return JsonResponse(context)
def overall_grades_infos(self):
mongo_persist = dashboardStats()
find_mongo_persist_course = mongo_persist.return_grades_values(
self.course_id)
context = {
"all_user":
find_mongo_persist_course['num_users'],
"user_finished":
find_mongo_persist_course['passed'],
'course_average_grade':
round(find_mongo_persist_course['average_grades'], 1),
'passed_average_grades':
round(find_mongo_persist_course['passed_average_grades'], 1)
}
return context
def load_persisted_grade(cls, user, course, course_structure):
"""
Initializes a CourseGrade object, filling its members with persisted values from the database.
If the grading policy is out of date, recomputes the grade.
If no persisted values are found, returns None.
"""
try:
persistent_grade = PersistentCourseGrade.read_course_grade(
user.id, course.id)
except PersistentCourseGrade.DoesNotExist:
return None
course_grade = CourseGrade(user, course, course_structure)
current_grading_policy_hash = course_grade.get_grading_policy_hash(
course.location, course_structure)
if current_grading_policy_hash != persistent_grade.grading_policy_hash:
return None
else:
course_grade._percent = persistent_grade.percent_grade # pylint: disable=protected-access
course_grade._letter_grade = persistent_grade.letter_grade # pylint: disable=protected-access
course_grade.course_version = persistent_grade.course_version
course_grade.course_edited_timestamp = persistent_grade.course_edited_timestamp
#TMA GRADE TRACKING UPDATE
mongo_persist = dashboardStats()
collection = mongo_persist.connect()
add_user = {}
add_user['user_id'] = user.id
add_user['username'] = user.username
add_user['passed'] = course_grade.passed
add_user['percent'] = course_grade.percent
add_user['summary'] = course_grade.summary
mongo_persist.add_user_grade_info(collection, str(course.id), add_user)
log.info('mongo_tracking_insert')
# END TMA GRADE TRACKING UPDATE
course_grade._log_event(log.info, u"load_persisted_grade") # pylint: disable=protected-access
return course_grade
def generate_xls(self):
log.warning(_("tma_grade_reports : start generate_xls"))
log.warning(_("tma_grade_reports : course_id : " + self.course_id))
#get request body
body = json.loads(self.request.body).get('fields')
log.warning(_("tma_grade_reports : microsite : " + self.microsite))
log.warning(_("tma_grade_reports : body : " + str(body)))
#get mongodb course's grades
mongo_persist = dashboardStats()
find_mongo_persist_course = mongo_persist.get_course(self.course_id)
#prepare workbook
_wb = self.prepare_workbook()
sheet_count = _wb.get_sheet('reports')
#form factory connection
form_factory = ensure_form_factory()
form_factory_db = 'ensure_form'
form_factory_collection = 'certificate_form'
form_factory.connect(db=form_factory_db,
collection=form_factory_collection)
#get register & certificate fields info
register_form_ = configuration_helpers.get_value('FORM_EXTRA')
certificates_form_ = configuration_helpers.get_value(
'CERTIFICATE_FORM_EXTRA')
#prepare workbook header
k = 0
for u in body:
if not ('final-grades' and 'summary') in u:
sheet_count.write(0, k, u)
k = k + 1
elif "summary" in u:
grade_breakdown = find_mongo_persist_course[0].get(
'users_info').get('summary').get('grade_breakdown')
for key, value in grade_breakdown.items():
sheet_count.write(0, k, value.get('category'))
k = k + 1
elif "final-grades" in u:
sheet_count.write(0, k, 'final grade')
k = k + 1
sheet_count.write(0, k, 'Eligible attestation')
k = k + 1
#sheets row
j = 1
#write differents workbook_rows
for _row in find_mongo_persist_course:
# get row user_id
user_id = _row['user_id']
#ensure user exist if False pass to next row
ensure_user_exist = True
try:
#get current row users mysql auth_user & aut_userprofile info
_user = User.objects.raw(
"SELECT a.id,a.email,a.username,a.date_joined,b.custom_field FROM auth_user a,auth_userprofile b WHERE a.id = b.user_id and a.id = %s",
[user_id])
#prepare dict of auth_user info
user = {}
#prepare dict of aut_userprofile info
user_profile = {}
#prepare dict of certificate form info
user_certif_profile = {}
#ensure only first occurance of _user is use
det = 0
#get current user certificates forms values
if certificates_form_ is not None:
form_factory.microsite = self.microsite
form_factory.user_id = user_id
try:
user_certif_profile = form_factory.getForm(
user_id=True, microsite=True).get('form')
log.ingo("user_certif_profile")
log.warning(user_certif_profile)
except:
pass
#hydrate user & user_profile dicts
for extract in _user:
if det < 1:
#hydrate user dict
user['id'] = extract.id
user['email'] = extract.email
user['username'] = extract.username
user['date_joined'] = extract.date_joined
#row from auth_userprofile mysql table
_user_profile = extract.custom_field
#bloc for with det == 1
det = 1
#hydrate user_profile dict
try:
user_profile = json.loads(_user_profile)
except:
pass
except:
ensure_user_exist = False
#write user xls line if exist
if ensure_user_exist:
k = 0
for n in body:
#insert user mysql value to xls
if n in user.keys():
if n == 'date_joined':
sheet_count.write(
j, k, str(user.get(n).strftime('%d-%m-%Y')))
else:
sheet_count.write(j, k, user.get(n))
k = k + 1
#insert register_form mysql value to xls
elif n in user_profile.keys():
_insert_value = return_select_value(
n, user_profile.get(n), register_form_)
sheet_count.write(j, k, _insert_value)
k = k + 1
#insert certificate_form mongodb value to xls
elif n in user_certif_profile.keys():
_insert_value = return_select_value(
n, user_certif_profile.get(n), certificates_form_)
sheet_count.write(j, k, _insert_value)
k = k + 1
#insert summary grades mongodb value to xls
elif "summary" in n:
grade_breakdown = _row.get('users_info').get(
'summary').get('grade_breakdown')
for key, value in grade_breakdown.items():
#insert grade value to xls
details = value['detail']
details = details.replace(
value['category'],
"").replace(" = ",
"").replace("of a possible ",
"").replace("%", "")
split = details.split(" ")
avg = str(
int(float(split[0]) / float(split[1]) *
100)) + "%"
sheet_count.write(j, k, avg)
k = k + 1
#insert final grades mongodb value to xls
elif "final-grades" in n:
sheet_count.write(
j, k,
str(_row.get('users_info').get('percent') * 100) +
"%")
k = k + 1
sheet_count.write(
j, k, str(_row.get('users_info').get('passed')))
k = k + 1
else:
sheet_count.write(j, k, '')
k = k + 1
j = j + 1
else:
pass
log.warning(_("tma_grade_reports : save file generate_xls"))
_wb.save(self.filepath)
_file = open(self.filepath, 'r')
_content = _file.read()
_file.close()
response = {'path': self.filename}
return JsonResponse(response)