def to_dict(self, term=""):
ret = Course.get_course_by_id(self.id)
if ret.error is not Error.OK:
return Ret(ret.error)
o_course = ret.body
from Section.models import Section
ret = Section.get_sections_by_course(o_course)
if ret.error is not Error.OK:
return Ret(ret.error)
sections = ret.body
section_list = []
for section in sections:
if term == "" or section.term == term:
section_list.append(section.to_dict())
return dict(
id=self.id,
subject=self.subject,
course_code=self.course_code,
title=self.title,
description=self.description,
sections=section_list,
)
def get_select_section(o_user, o_section):
try:
o_select_section = SelectSection.objects.get(user=o_user,
section=o_section)
except SelectSection.DoesNotExist:
return Ret(Error.USER_SECTION_NOT_MATCH)
return Ret(Error.OK, body=o_select_section)
def get_course_by_subject_code(subject, course_code):
try:
o_course = Course.objects.get(subject=subject,
course_code=course_code)
except:
return Ret(Error.COURSE_NOT_EXIST)
return Ret(Error.OK, body=o_course)
def delete_event_by_id(event_id):
ret = Event.get_event_by_id(event_id)
if ret.error is not Error.OK:
return Ret(ret.error)
o_event = ret.body
o_event.delete()
return Ret(Error.OK)
def delete_meetings_by_section(o_section):
ret = Meeting.get_meetings_by_section(o_section)
if ret.error is not Error.OK:
return Ret(ret.error)
meetings = ret.body
for meeting in meetings:
meeting.delete()
return Ret(Error.OK)
def choose_server():
ret = AlgoServer.get_server_list(raw=True)
if ret.error is not Error.OK:
return Ret(ret.error)
server_list = ret.body
if len(server_list) == 0:
return Ret(Error.NO_SERVER_AVAILABLE)
return Ret(Error.OK, server_list[0])
def select_section(o_user, o_section, bgcolor, color):
ret = SelectSection.get_select_section(o_user, o_section)
if ret.error is Error.OK:
return Ret(Error.SECTION_ALREADY_SELECTED)
ret = SelectSection.create(o_user, o_section, bgcolor, color)
if ret.error is not Error.OK:
return Ret(ret.error)
return Ret(Error.OK, body=ret.body)
def delete_assessment_by_course(o_course):
ret = Assessment.get_assessment_by_course(o_course)
if ret.error is not Error.OK:
return Ret(ret.error)
assessments = ret.body
for assessment in assessments:
assessment.delete()
return Ret(Error.OK)
def get_server_list(raw=False):
_server_list = AlgoServer.objects.all()
if raw:
return Ret(Error.OK, _server_list)
print('len', len(_server_list))
server_list = []
for o_server in _server_list:
server_list.append(o_server.to_dict())
return Ret(Error.OK, server_list)
def authenticate(username, password):
ret = User.get_user_by_username(username)
if ret.error is not Error.OK:
return Ret(ret.error)
o_user = ret.body
if o_user.password == User._hash(password):
return Ret(Error.OK, o_user)
return Ret(Error.ERROR_PASSWORD)
def delete_component_by_course(o_course):
ret = Component.get_component_by_course(o_course)
if ret.error is not Error.OK:
return Ret(ret.error)
components = ret.body
for component in components:
component.delete()
return Ret(Error.OK)
def create(cls, aname, path):
try:
o_algo = cls(
aname=aname,
path=path,
)
o_algo.save()
except:
return Ret(Error.ERROR_CREATE_ALGO)
return Ret(Error.OK, o_algo)
def create(cls, o_user, o_event):
try:
o_user_todo = cls(
user=o_user,
event=o_event,
)
o_user_todo.save()
except:
return Ret(Error.ERROR_CREATE_SELECTSECTION)
return Ret(Error.OK, o_user_todo)
def get_selected_section_by_details(o_user, o_course, term, category):
ret = SelectSection.get_selected_section_by_user(o_user)
if ret.error is not Error.OK:
return Ret(ret.error)
select_sections = ret.body
select_section_list = []
for select_section in select_sections:
if select_section.section.course == o_course and select_section.section.term == term and select_section.section.category == category:
select_section_list.append(select_section)
return Ret(Error.OK, select_section_list)
def create(cls, o_user, o_section, bgcolor, color):
try:
o_select_section = cls(
user=o_user,
section=o_section,
bgcolor=bgcolor,
color=color,
)
o_select_section.save()
except:
return Ret(Error.ERROR_CREATE_SELECTSECTION)
return Ret(Error.OK, o_select_section)
def create(cls, name, end_date, end_time, memo, status):
try:
o_event = cls(
name=name,
end_date=end_date,
end_time=end_time,
memo=memo,
status=status,
)
o_event.save()
except:
return Ret(Error.ERROR_CREATE_EVENT)
return Ret(Error.OK, o_event)
def create(cls, username, password):
ret = User.get_user_by_username(username)
if ret.error is Error.OK:
return Ret(Error.EXIST_USERNAME)
try:
o_user = cls(
username=username,
password=User._hash(password),
)
except:
return Ret(Error.ERROR_CREATE_USER)
return Ret(Error.OK, o_user)
def create(cls, username, raw_pass):
# check if the username exist
ret = User.get_user_by_username(username)
if ret.error is Error.OK:
return Ret(Error.EXIST_USERNAME)
try:
o_user = cls(
username=username,
password=md5_hash(raw_pass),
)
o_user.save()
except ValueError as err:
return Ret(Error.ERROR_CREATE_USER)
return Ret(Error.OK, o_user)
def get_sections_for_spider(course_code, term, section_code):
ret = Course.get_course_by_code(course_code)
if ret.error is not Error.OK:
return Ret(ret.error)
o_course = ret.body
ret = Section.get_sections_by_course(o_course)
if ret.error is not Error.OK:
return Ret(ret.error)
sections = ret.body
for section in sections:
if section.term == term and section.section_code == section_code:
return Ret(body=section)
return Ret(Error.SECTION_NOT_EXIST)
def to_dict(self):
ret = Meeting.get_meetings_by_section(self)
if ret.error is not Error.OK:
return Ret(ret.error)
meetings = ret.body
meeting_list = []
for meeting in meetings:
meeting_list.append(meeting.to_dict())
return dict(
id=self.id,
# course_id=self.course_id,
# course_code=self.course.course_code,
course=self.course.to_dict(),
section_code=self.section_code,
category=self.category,
term=self.term,
type=self.type,
status=self.status,
instruction_mode=self.instruction_mode,
instructor=self.instructor,
language=self.language,
class_capacity=self.class_capacity,
enrollment_total=self.enrollment_total,
available_seat=self.available_seat,
wait_capacity=self.wait_capacity,
wait_total=self.wait_total,
meetings=meeting_list,
)
def to_dict(self):
ret = TimeSlot.get_meetings_by_section(self)
if ret.error is not Error.OK:
return Ret(ret.error)
meetings = ret.body
meeting_list = []
for meeting in meetings:
meeting_list.append(meeting.to_dict())
return dict(
id=self.id,
course_id=self.course_id,
course_code=self.course.course_code,
course_title=self.course.title,
subject=self.course.subject,
# course_code=self.course.course_code,
# course=self.course.to_dict(),
section_code=self.section_code,
term=self.term,
instructor=self.instructor,
syllabus_url=self.syllabus_url,
course_home_url=self.course_home_url,
meetings=meeting_list,
)
def get_selected_section_by_user(o_user):
select_sections = SelectSection.objects.filter(user=o_user)
# sections = []
# for select_section in select_sections:
# sections.append(select_section.section)
return Ret(Error.OK, select_sections)
def get_user_from_session(request):
from User.models import User
"""get user from session if login"""
user_id = load_session(request, 'user', once_delete=False)
if user_id is None:
return Ret(Error.REQUIRE_LOGIN)
return User.get_user_by_id(user_id)
def select_and_create(o_algo):
if not isinstance(o_algo, Algorithm):
return Ret(Error.STRANGE)
# select a proper server for running
ret = AlgoServer.choose_server()
if ret.error is not Error.OK:
return Ret(ret.error)
o_server = ret.body
if not isinstance(o_server, AlgoServer):
return Ret(Error.STRANGE)
# run a study
ret = suggestion_client.create_algo(o_server.ip, o_server.port,
o_algo.aname, o_algo.path)
if ret.error is not Error.OK:
return error_response(ret.error)
return Ret(Error.OK, ret.body)
def get_course_by_term(term):
sections = Section.objects.filter(term=term)
course_list = []
for section in sections:
if section.course not in course_list:
course_list.append(section.course)
return Ret(Error.OK, body=course_list)
def get_terms():
terms = []
sections = Section.objects.all()
for section in sections:
if section.term not in terms:
terms.append(section.term)
return Ret(Error.OK, body=terms)
def get_user_event_by_date_range(start_date, end_date, o_user):
start = datetime.strptime(start_date, "%m/%d/%Y")
end = datetime.strptime(end_date, "%m/%d/%Y")
ret = UserTodo.get_user_todo_by_user(o_user)
if ret.error is not Error.OK:
return Ret(ret.error)
user_todos = ret.body
event_list = []
for user_todo in user_todos:
d = datetime.strptime(user_todo.event.end_date, "%m/%d/%Y")
print(start)
print(end)
print(d)
if start <= d <= end:
event_list.append(user_todo.event.to_dict())
return Ret(Error.OK, event_list)
def select_and_run(o_study):
if not isinstance(o_study, Study):
return Ret(Error.STRANGE)
if o_study.status == Study.STATUS_PAUSED:
return Ret(Error.STUDY_PAUSED)
# select a proper server for running
ret = AlgoServer.choose_server()
if ret.error is not Error.OK:
return Ret(ret.error)
o_server = ret.body
if not isinstance(o_server, AlgoServer):
return Ret(Error.STRANGE)
# run a study
ret = suggestion_client.run(o_server.ip, o_server.port, o_study.pk)
if ret.error is not Error.OK:
return error_response(ret.error)
return Ret(Error.OK, ret.body)
def get_assessment_by_course(o_course):
assessments = Assessment.objects.filter(course=o_course)
return Ret(Error.OK, assessments)
def get_component_by_course(o_course):
components = Component.objects.filter(course=o_course)
return Ret(Error.OK, components)