Skip to content
Snippets Groups Projects
Verified Commit e42bb27e authored by Jonathan Weth's avatar Jonathan Weth :keyboard:
Browse files

Add code for import of lessons

parent 9b61ba9f
No related branches found
No related tags found
1 merge request!13Resolve "Support import from MySQL"
Hide whitespace changes
Inline Side-by-side
aleksis/apps/untis/util/mysql/main.py
+ 128
− 2
View file @ e42bb27e
from datetime import datetime, date
from datetime import datetime, date, time
from django.db.models import Model, QuerySet
from django.utils.translation import gettext as _
from aleksis.apps.untis import models as mysql_models
from aleksis.apps.untis.util.mysql.api_helper import (
date_to_untis_date,
untis_colour_to_hex,
untis_split_first,
untis_split_third,
untis_date_to_date,
)
from aleksis.apps.chronos import models as chronos_models
from aleksis.core import models as core_models
from aleksis.core.util import messages
DB_NAME = "untis"
......@@ -232,4 +235,127 @@ def untis_import_mysql():
}
)
# Lessons
lessons = run_default_filter(mysql_models.Lesson.objects)
for lesson in lessons:
lesson_id = lesson.lesson_id
messages.info(None, message=_("Import lesson {}").format(lesson_id))
if not lesson.lesson_tt:
messages.warning(
None,
message=_("Skip lesson {} because there are missing times.").format(
lesson_id
),
)
continue
# Split data (,)
raw_lesson_data = lesson.lessonelement1.split(",")
raw_time_data = lesson.lesson_tt.split(",")
raw_time_data_2 = []
for el in raw_time_data:
# Split data (~)
raw_time_data_2.append(el.split("~"))
# Get time periods and rooms
time_periods = []
rooms_per_periods = []
for el in raw_time_data_2:
day = int(el[1])
hour = int(el[2])
room_ids = untis_split_third(el[3], conv=int)
# Get rooms
rooms = []
for room_id in room_ids:
r = rooms_ref[room_id]
rooms.append(r)
# Get time period
time_period = time_periods_ref[day - 1][hour - 1]
time_periods.append(time_period)
rooms_per_periods.append(rooms)
# Split data more (~)
raw_lesson_data_2 = []
for el in raw_lesson_data:
raw_lesson_data_2.append(el.split("~"))
# All part lessons (courses)
for i, el in enumerate(raw_lesson_data_2):
# Get plain ids
teacher_id = int(el[0])
subject_id = int(el[2])
class_ids = untis_split_third(el[17], conv=int)
# Get teacher
if teacher_id != 0:
teacher = teachers_ref[teacher_id]
else:
teacher = None
# Get subject
if subject_id != 0:
subject = subjects_ref[subject_id]
else:
messages.warning(
None,
message=_(
"Skip lesson {}, element {} because there is missing a subject.".format(
lesson_id, i
)
),
)
continue
# raise Exception("Subject needed.")
# Get classes
course_classes = []
for class_id in class_ids:
c = classes_ref[class_id]
course_classes.append(c)
# Build names and refs for course groups
short_name = "{}-{}".format(
"".join([c.short_name for c in course_classes]), subject.abbrev
)
name = "{}: {}".format(
", ".join([c.short_name for c in course_classes]), subject.abbrev
)
import_ref = "{}-{}".format(lesson_id, i)
# Get or create course group
course_group, created = core_models.Group.objects.get_or_create(
short_name=short_name, defaults={"name": name}
)
course_group.import_ref = import_ref
course_group.name = name
course_group.save()
course_group.parent_groups.set(course_classes)
# Create new lesson
date_start = untis_date_to_date(TERM.datefrom)
date_end = untis_date_to_date(TERM.dateto)
lesson = chronos_models.Lesson.objects.create(
subject=subject, date_start=date_start, date_end=date_end
)
# Set groups
lesson.groups.set([course_group])
# Set teacher
if teacher:
lesson.teachers.set([teacher])
# All times for this course
for j, time_period in enumerate(time_periods):
rooms = rooms_per_periods[j]
if i < len(rooms):
lesson.periods.add(time_period, through_defaults={"room": rooms[i]})
else:
lesson.periods.add(time_period)
aleksis/apps/untis/util/mysql/parse.py deleted 100644 → 0
+ 0
− 184
View file @ 9b61ba9f
from dashboard import caches
from .api import *
from .api_helper import untis_split_third
from .drive import drive
class Lesson(object):
def __init__(self):
self.filled = False
self.id = None
self.elements = []
self.times = []
def add_element(self, teacher, subject, rooms=[], classes=[]):
el = LessonElement()
el.create(teacher, subject, rooms, classes)
self.elements.append(el)
def add_time(self, day, hour, rooms=[]):
el = LessonTime()
el.create(day, hour, rooms)
self.times.append(el)
def create(self, raw_lesson, drive):
self.filled = True
# Split data (,)
lesson_id = raw_lesson.lesson_id
self.id = lesson_id
raw_lesson_data = raw_lesson.lessonelement1.split(",")
raw_time_data = raw_lesson.lesson_tt.split(",")
rtd2 = []
for el in raw_time_data:
rtd2.append(el.split("~"))
# print(rtd2)
for el in rtd2:
day = int(el[1])
hour = int(el[2])
room_ids = untis_split_third(el[3], conv=int)
rooms = []
for room_id in room_ids:
r = drive["rooms"][room_id]
rooms.append(r)
self.add_time(day, hour, rooms)
# print(raw_lesson_data)
# print(raw_time_data)
# Split data more (~)
rld2 = []
for el in raw_lesson_data:
rld2.append(el.split("~"))
# print(rld2)
for i, el in enumerate(rld2):
teacher_id = int(el[0])
subject_id = int(el[2])
class_ids = untis_split_third(el[17], conv=int)
# print("TEACHER – ", teacher_id, "; SUBJECT – ", subject_id, "; ROOMS – ", room_ids, "; CLASSES – ",
# class_ids)
if teacher_id != 0:
teacher = drive["teachers"][teacher_id]
else:
teacher = None
if subject_id != 0:
subject = drive["subjects"][subject_id]
else:
subject = None
rooms = []
classes = []
for class_id in class_ids:
c = drive["classes"][class_id]
classes.append(c)
# print("TEACHER – ", teacher, "; SUBJECT – ", subject, "; ROOMS – ", rooms,
# "; CLASSES – ", classes)
self.add_element(teacher, subject, rooms, classes)
class LessonElement(object):
def __init__(self):
self.teacher = None
self.subject = None
self.rooms = []
self.classes = []
def create(self, teacher, subject, rooms=[], classes=[]):
self.teacher = teacher
self.subject = subject
self.rooms = rooms
self.classes = classes
class LessonTime(object):
def __init__(self):
self.hour = None
self.day = None
self.rooms = []
def create(self, day, hour, rooms=[]):
self.day = day
self.hour = hour
self.rooms = rooms
def parse(force_update=False):
global drive
cached = caches.PARSED_LESSONS_CACHE.get()
if cached is not False and not force_update:
# print("Lessons come from cache")
return cached
lessons = []
# Load lessons from Django ORM
raw_lessons = get_raw_lessons()
for raw_lesson in raw_lessons:
if raw_lesson.lesson_tt and raw_lesson.lessonelement1:
# Create object
lesson_obj = Lesson()
lesson_obj.create(raw_lesson, drive)
lessons.append(lesson_obj)
# print("Lesson cache was refreshed")
caches.PARSED_LESSONS_CACHE.update(lessons)
return lessons
def get_lesson_by_id(id):
global drive
lesson = Lesson()
raw_lesson = run_one(models.Lesson.objects, filter_term=True).get(lesson_id=id)
lesson.create(raw_lesson, drive)
return lesson
def get_lesson_element_by_id_and_teacher(lesson_id, teacher, hour=None, weekday=None):
try:
lesson = get_lesson_by_id(lesson_id)
except Exception:
return None, None
el = None
i = 0
if teacher is not None:
for i, element in enumerate(lesson.elements):
if element.teacher is not None:
if element.teacher.id == teacher.id:
el = element
break
elif len(lesson.elements) > 0:
el = lesson.elements[0]
else:
el = None
t = None
for time in lesson.times:
if time.day == weekday and time.hour == hour:
t = time
room = None
if t is not None and len(t.rooms) > i:
room = t.rooms[i]
if el is not None:
return el, room
return None, None
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment