brotherton-erpnext/erpnext/education/utils.py

375 lines
12 KiB
Python
Raw Normal View History

2016-07-19 08:47:33 +00:00
# -*- coding: utf-8 -*-
# Copyright (c) 2015, Frappe Technologies and contributors
from __future__ import unicode_literals, division
2016-07-19 08:47:33 +00:00
import frappe
from frappe import _
class OverlapError(frappe.ValidationError): pass
def validate_overlap_for(doc, doctype, fieldname, value=None):
2017-04-12 13:54:12 +00:00
"""Checks overlap for specified field.
:param fieldname: Checks Overlap for this field
2016-07-19 08:47:33 +00:00
"""
2016-07-19 08:47:33 +00:00
existing = get_overlap_for(doc, doctype, fieldname, value)
if existing:
frappe.throw(_("This {0} conflicts with {1} for {2} {3}").format(doc.doctype, existing.name,
doc.meta.get_label(fieldname) if not value else fieldname , value or doc.get(fieldname)), OverlapError)
2016-07-19 08:47:33 +00:00
def get_overlap_for(doc, doctype, fieldname, value=None):
2017-04-12 13:54:12 +00:00
"""Returns overlaping document for specified field.
:param fieldname: Checks Overlap for this field
2016-07-19 08:47:33 +00:00
"""
existing = frappe.db.sql("""select name, from_time, to_time from `tab{0}`
where `{1}`=%(val)s and schedule_date = %(schedule_date)s and
(
(from_time > %(from_time)s and from_time < %(to_time)s) or
(to_time > %(from_time)s and to_time < %(to_time)s) or
(%(from_time)s > from_time and %(from_time)s < to_time) or
(%(from_time)s = from_time and %(to_time)s = to_time))
and name!=%(name)s and docstatus!=2""".format(doctype, fieldname),
2016-07-19 08:47:33 +00:00
{
"schedule_date": doc.schedule_date,
"val": value or doc.get(fieldname),
"from_time": doc.from_time,
"to_time": doc.to_time,
"name": doc.name or "No Name"
}, as_dict=True)
return existing[0] if existing else None
2016-07-21 19:58:41 +00:00
def validate_duplicate_student(students):
unique_students= []
for stud in students:
if stud.student in unique_students:
frappe.throw(_("Student {0} - {1} appears Multiple times in row {2} & {3}")
.format(stud.student, stud.student_name, unique_students.index(stud.student)+1, stud.idx))
else:
unique_students.append(stud.student)
2018-11-19 10:43:21 +00:00
return None
2018-11-20 12:08:01 +00:00
# LMS Utils
2018-11-19 10:43:21 +00:00
def get_current_student():
"""Returns current student from frappe.session.user
Returns:
2019-05-30 11:05:15 +00:00
object: Student Document
2018-11-19 10:43:21 +00:00
"""
email = frappe.session.user
if email in ('Administrator', 'Guest'):
return None
try:
student_id = frappe.get_all("Student", {"student_email_id": email}, ["name"])[0].name
return frappe.get_doc("Student", student_id)
except (IndexError, frappe.DoesNotExistError):
2019-04-22 07:24:43 +00:00
return None
2018-11-19 10:43:21 +00:00
def get_portal_programs():
"""Returns a list of all program to be displayed on the portal
Programs are returned based on the following logic
is_published and (student_is_enrolled or student_can_self_enroll)
Returns:
list of dictionary: List of all programs and to be displayed on the portal along with access rights
2018-11-19 10:43:21 +00:00
"""
published_programs = frappe.get_all("Program", filters={"is_published": True})
if not published_programs:
return None
program_list = [frappe.get_doc("Program", program) for program in published_programs]
portal_programs = [{'program': program, 'has_access': allowed_program_access(program.name)} for program in program_list if allowed_program_access(program.name) or program.allow_self_enroll]
return portal_programs
2019-05-30 11:05:15 +00:00
def allowed_program_access(program, student=None):
"""Returns enrollment status for current student
Args:
2019-05-30 11:05:15 +00:00
program (string): Name of the program
student (object): instance of Student document
Returns:
2019-05-30 11:05:15 +00:00
bool: Is current user enrolled or not
2018-11-19 10:43:21 +00:00
"""
2019-05-30 11:05:15 +00:00
if has_super_access():
return True
2018-11-19 10:43:21 +00:00
if not student:
student = get_current_student()
if student and get_enrollment('program', program, student.name):
return True
2018-11-19 10:43:21 +00:00
else:
return False
2018-11-19 10:43:21 +00:00
def get_enrollment(master, document, student):
"""Gets enrollment for course or program
2018-11-19 10:43:21 +00:00
Args:
2019-05-30 11:05:15 +00:00
master (string): can either be program or course
document (string): program or course name
student (string): Student ID
Returns:
2019-05-30 11:05:15 +00:00
string: Enrollment Name if exists else returns empty string
"""
if master == 'program':
2019-05-30 11:05:15 +00:00
enrollments = frappe.get_all("Program Enrollment", filters={'student':student, 'program': document, 'docstatus': 1})
if master == 'course':
enrollments = frappe.get_all("Course Enrollment", filters={'student':student, 'course': document})
if enrollments:
2019-05-30 11:05:15 +00:00
return enrollments[0].name
else:
2019-05-30 11:05:15 +00:00
return None
@frappe.whitelist()
def enroll_in_program(program_name, student=None):
"""Enroll student in program
Args:
program_name (string): Name of the program to be enrolled into
student (string, optional): name of student who has to be enrolled, if not
provided, a student will be created from the current user
2019-05-30 11:05:15 +00:00
Returns:
string: name of the program enrollment document
"""
if has_super_access():
return
if not student == None:
student = frappe.get_doc("Student", student)
else:
# Check if self enrollment in allowed
program = frappe.get_doc('Program', program_name)
if not program.allow_self_enroll:
return frappe.throw("You are not allowed to enroll for this course")
student = get_current_student()
if not student:
student = create_student_from_current_user()
# Check if student is already enrolled in program
enrollment = get_enrollment('program', program_name, student.name)
if enrollment:
return enrollment
# Check if self enrollment in allowed
program = frappe.get_doc('Program', program_name)
if not program.allow_self_enroll:
return frappe.throw("You are not allowed to enroll for this course")
# Enroll in program
program_enrollment = student.enroll_in_program(program_name)
return program_enrollment.name
def has_super_access():
"""Check if user has a role that allows full access to LMS
Returns:
bool: true if user has access to all lms content
"""
2019-05-30 11:05:15 +00:00
current_user = frappe.get_doc('User', frappe.session.user)
roles = set([role.role for role in current_user.roles])
return bool(roles & {'Administrator', 'Instructor', 'Education Manager', 'System Manager', 'Academic User'})
@frappe.whitelist()
def add_activity(course, content_type, content, program):
if has_super_access():
return None
student = get_current_student()
if not student:
return frappe.throw("Student with email {0} does not exist".format(frappe.session.user), frappe.DoesNotExistError)
enrollment = get_or_create_course_enrollment(course, program)
if content_type == 'Quiz':
return
else:
return enrollment.add_activity(content_type, content)
2018-11-19 10:43:21 +00:00
@frappe.whitelist()
def evaluate_quiz(quiz_response, quiz_name, course, program):
import json
student = get_current_student()
quiz_response = json.loads(quiz_response)
quiz = frappe.get_doc("Quiz", quiz_name)
result, score, status = quiz.evaluate(quiz_response, quiz_name)
if has_super_access():
return {'result': result, 'score': score, 'status': status}
if student:
enrollment = get_or_create_course_enrollment(course, program)
if quiz.allowed_attempt(enrollment, quiz_name):
enrollment.add_quiz_activity(quiz_name, quiz_response, result, score, status)
return {'result': result, 'score': score, 'status': status}
else:
return None
@frappe.whitelist()
def get_quiz(quiz_name, course):
try:
quiz = frappe.get_doc("Quiz", quiz_name)
questions = quiz.get_questions()
except:
frappe.throw("Quiz {0} does not exist".format(quiz_name))
return None
questions = [{
'name': question.name,
'question': question.question,
'type': question.question_type,
'options': [{'name': option.name, 'option': option.option}
for option in question.options],
} for question in questions]
if has_super_access():
return {'questions': questions, 'activity': None}
student = get_current_student()
course_enrollment = get_enrollment("course", course, student.name)
status, score, result = check_quiz_completion(quiz, course_enrollment)
return {'questions': questions, 'activity': {'is_complete': status, 'score': score, 'result': result}}
2019-06-05 11:59:48 +00:00
def get_topic_progress(topic, course_name, program):
2019-06-03 09:11:05 +00:00
"""
Return the porgress of a course in a program as well as the content to continue from.
:param topic_name:
:param course_name:
"""
student = get_current_student()
2019-06-05 07:59:51 +00:00
if not student:
return None
2019-06-03 09:11:05 +00:00
course_enrollment = get_or_create_course_enrollment(course_name, program)
progress = student.get_topic_progress(course_enrollment.name, topic)
if not progress:
2019-06-05 07:38:53 +00:00
return None
2019-06-03 09:11:05 +00:00
count = sum([activity['is_complete'] for activity in progress])
if count == 0:
2019-06-05 07:38:53 +00:00
return {'completed': False, 'started': False}
2019-06-03 09:11:05 +00:00
elif count == len(progress):
2019-06-05 07:38:53 +00:00
return {'completed': True, 'started': True}
2019-06-03 09:11:05 +00:00
elif count < len(progress):
2019-06-05 07:38:53 +00:00
return {'completed': False, 'started': True}
2019-06-05 11:59:48 +00:00
def get_course_progress(course, program):
2019-06-05 07:38:53 +00:00
"""
Return the porgress of a course in a program as well as the content to continue from.
:param topic_name:
:param course_name:
"""
course_progress = []
for course_topic in course.topics:
topic = frappe.get_doc("Topic", course_topic.topic)
2019-06-05 11:59:48 +00:00
progress = get_topic_progress(topic, course.name, program)
2019-06-05 07:38:53 +00:00
if progress:
course_progress.append(progress)
if course_progress:
number_of_completed_topics = sum([activity['completed'] for activity in course_progress])
total_topics = len(course_progress)
2019-06-05 11:59:48 +00:00
if total_topics == 1:
return course_progress[0]
2019-06-05 07:38:53 +00:00
if number_of_completed_topics == 0:
return {'completed': False, 'started': False}
if number_of_completed_topics == total_topics:
return {'completed': True, 'started': True}
if number_of_completed_topics < total_topics:
return {'completed': False, 'started': True}
return None
2019-06-03 09:11:05 +00:00
2019-06-05 11:59:48 +00:00
def get_program_progress(program):
program_progress = []
if not program.courses:
return None
for program_course in program.courses:
course = frappe.get_doc("Course", program_course.course)
progress = get_course_progress(course, program.name)
if progress:
progress['name'] = course.name
progress['course'] = course.course_name
program_progress.append(progress)
if program_progress:
return program_progress
return None
def get_program_completion(program):
topics = frappe.db.sql("""select `tabcourse topic`.topic, `tabcourse topic`.parent
from `tabcourse topic`,
`tabprogram course`
where `tabcourse topic`.parent = `tabprogram course`.course
2019-06-06 06:00:56 +00:00
and `tabprogram course`.parent = %(program)s""", {'program': program})
2019-06-05 11:59:48 +00:00
progress = []
for topic in topics:
topic_doc = frappe.get_doc('Topic', topic[0])
topic_progress = get_topic_progress(topic_doc, topic[1], program.name)
if topic_progress:
progress.append(topic_progress)
if progress:
number_of_completed_topics = sum([activity['completed'] for activity in progress if activity])
total_topics = len(progress)
try:
return int((float(number_of_completed_topics)/total_topics)*100)
except ZeroDivisionError:
return 0
return 0
2019-03-06 10:15:35 +00:00
def create_student_from_current_user():
2018-11-23 11:46:22 +00:00
user = frappe.get_doc("User", frappe.session.user)
2019-05-30 11:05:15 +00:00
2018-11-19 10:43:21 +00:00
student = frappe.get_doc({
"doctype": "Student",
2018-11-23 11:46:22 +00:00
"first_name": user.first_name,
"last_name": user.last_name,
"student_email_id": user.email,
2018-12-06 14:47:39 +00:00
"user": frappe.session.user
2018-11-19 10:43:21 +00:00
})
2019-05-30 11:05:15 +00:00
2018-11-19 10:43:21 +00:00
student.save(ignore_permissions=True)
return student
def get_or_create_course_enrollment(course, program):
2019-04-22 07:24:43 +00:00
student = get_current_student()
course_enrollment = get_enrollment("course", course, student.name)
if not course_enrollment:
program_enrollment = get_enrollment('program', program, student.name)
if not program_enrollment:
frappe.throw("You are not enrolled in program {0}".format(program))
return
return student.enroll_in_course(course_name=course, program_enrollment=get_enrollment('program', program, student.name))
else:
return frappe.get_doc('Course Enrollment', course_enrollment)
2018-11-19 10:43:21 +00:00
def check_content_completion(content_name, content_type, enrollment_name):
activity = frappe.get_all("Course Activity", filters={'enrollment': enrollment_name, 'content_type': content_type, 'content': content_name})
if activity:
return True
else:
return False
def check_quiz_completion(quiz, enrollment_name):
attempts = frappe.get_all("Quiz Activity", filters={'enrollment': enrollment_name, 'quiz': quiz.name}, fields=["name", "activity_date", "score", "status"])
status = False if quiz.max_attempts == 0 else bool(len(attempts) >= quiz.max_attempts)
score = None
result = None
if attempts:
if quiz.grading_basis == 'Last Highest Score':
attempts = sorted(attempts, key = lambda i: int(i.score), reverse=True)
score = attempts[0]['score']
result = attempts[0]['status']
if result == 'Pass':
status = True
2019-03-06 10:15:35 +00:00
return status, score, result