TheCitadelofRicks/src/main/kotlin/org/mosad/thecitadelofricks/controller/CacheController.kt

250 lines
11 KiB
Kotlin
Raw Normal View History

2019-10-20 11:52:44 +02:00
/**
* TheCitadelofRicks
*
* Copyright 2019-2020 <seil0@mosad.xyz>
2019-10-20 11:52:44 +02:00
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301, USA.
*
*/
package org.mosad.thecitadelofricks.controller
import com.google.gson.Gson
2019-10-20 11:52:44 +02:00
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.async
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import org.mosad.thecitadelofricks.*
import org.mosad.thecitadelofricks.hsoparser.CourseListParser
import org.mosad.thecitadelofricks.hsoparser.MensaParser
import org.mosad.thecitadelofricks.hsoparser.TimetableParser
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import java.io.BufferedWriter
import java.io.File
import java.io.FileWriter
2019-10-20 11:52:44 +02:00
import java.util.*
import java.util.concurrent.Executors
2019-10-20 11:52:44 +02:00
import kotlin.collections.ArrayList
import kotlin.collections.HashSet
2019-10-20 11:52:44 +02:00
import kotlin.concurrent.scheduleAtFixedRate
class CacheController {
init {
initUpdates()
scheduledUpdates()
}
companion object{
private val logger: Logger = LoggerFactory.getLogger(CacheController::class.java)
var courseList = CoursesList(CoursesMeta(0, 0), ArrayList())
var mensaMenu = MensaMenu(MensaMeta(0,""), MensaWeek(), MensaWeek())
2019-10-20 11:52:44 +02:00
var timetableList = ArrayList<TimetableCourseWeek>() // this list contains all timetables
/**
2020-03-02 22:34:10 +01:00
* get a timetable, since they may not be cached, we need to make sure it's cached, otherwise download
2019-10-20 11:52:44 +02:00
* @param courseName the name of the course to be requested
* @param weekIndex request week number (current week = 0)
* @return timetable of the course (Type: [TimetableCourseWeek])
2019-10-20 11:52:44 +02:00
*/
fun getTimetable(courseName: String, weekIndex: Int): TimetableCourseWeek = runBlocking {
val currentTime = System.currentTimeMillis() / 1000
var timetable = TimetableWeek()
var weekNumberYear = 0
// check if the timetable already exists and is up to date
when (timetableList.stream().filter { x -> x.meta.courseName == courseName && x.meta.weekIndex == weekIndex }.findAny().orElse(null)) {
// there is no such course yet, create one
null -> {
val courseLink = courseList.courses.stream().filter { x -> x.courseName == courseName }.findFirst().orElse(null).courseLink
val timetableLink = courseLink.replace("week=0","week=$weekIndex")
2020-02-16 17:17:39 +01:00
val jobTimetable = async {
2019-10-20 11:52:44 +02:00
timetable = TimetableParser().getTimeTable(timetableLink)
weekNumberYear = TimetableParser().getWeekNumberYear(timetableLink)
}
jobTimetable.await()
2020-02-16 17:17:39 +01:00
timetableList.add(TimetableCourseWeek(TimetableCourseMeta(currentTime, courseName, weekIndex, weekNumberYear, timetableLink), timetable))
2019-10-20 11:52:44 +02:00
logger.info("added new timetable for $courseName, week $weekIndex")
}
}
return@runBlocking timetableList.stream().filter { x -> x.meta.courseName == courseName && x.meta.weekIndex == weekIndex }.findAny().orElse(null)
}
/**
2020-03-02 22:34:10 +01:00
* get every explicit lesson in a week for a selected course
2019-10-20 11:52:44 +02:00
* @param courseName the name of the course to be requested
* @param weekIndex request week number (current week = 0)
* @return a HashSet of explicit lessons for one week
*/
fun getLessonSubjectList(courseName: String, weekIndex: Int): HashSet<String> = runBlocking {
val lessonSubjectList = ArrayList<String>()
// get every lesson subject for the given week
val flatMap = getTimetable(courseName, weekIndex).timetable.days.flatMap { it.timeslots.asIterable() }
flatMap.forEach {
it.stream().filter { x -> x.lessonSubject.isNotEmpty() }.findAny().ifPresent { x -> lessonSubjectList.add(x.lessonSubject) }
}
return@runBlocking HashSet(lessonSubjectList)
}
/**
* get every lesson of a subject in a week
2019-10-20 11:52:44 +02:00
* @param courseName the name of the course to be requested
* @param lessonSubject the lesson subject to be requested
* @param weekIndex request week number (current week = 0)
* @return a ArrayList<[Lesson]> of every lesson with lessonSubject for one week
2019-10-20 11:52:44 +02:00
*/
fun getLesson(courseName: String, lessonSubject: String, weekIndex: Int): ArrayList<Lesson> {
val lessonList = ArrayList<Lesson>()
// get all lessons from the weeks timetable
val flatMap = getTimetable(courseName, weekIndex).timetable.days.flatMap { it.timeslots.asIterable() }
flatMap.forEach {
it.stream().filter { x -> x.lessonSubject.contains(lessonSubject) }.findAny().ifPresent { x -> lessonList.add(x) }
2019-10-20 11:52:44 +02:00
}
return lessonList
}
2020-02-16 17:17:39 +01:00
// private cache functions
2019-10-20 11:52:44 +02:00
2020-02-16 17:17:39 +01:00
/**
* this function updates the courseList
* during the update process the old data will be returned for a API request
*/
private fun asyncUpdateCourseList() = GlobalScope.launch {
CourseListParser().getCourseLinks(StartupController.courseListURL)?.let {
courseList = CoursesList(CoursesMeta(System.currentTimeMillis() / 1000, it.size), it)
}
2019-10-20 11:52:44 +02:00
2020-02-16 17:17:39 +01:00
logger.info("Updated courses successful at ${Date(courseList.meta.updateTime * 1000)}")
2019-10-20 11:52:44 +02:00
}
2020-02-16 17:17:39 +01:00
/**
* this function updates the mensa menu list
* during the update process the old data will be returned for a API request
*/
private fun asyncUpdateMensa() = GlobalScope.launch {
val mensaCurrentWeek = MensaParser().getMensaMenu(StartupController.mensaMenuURL)
val mensaNextWeek = MensaParser().getMensaMenu(MensaParser().getMenuLinkNextWeek(StartupController.mensaMenuURL))
2019-10-20 11:52:44 +02:00
2020-02-16 17:17:39 +01:00
// only update if we get valid data
if (mensaCurrentWeek != null && mensaNextWeek != null) {
mensaMenu = MensaMenu(MensaMeta(System.currentTimeMillis() / 1000, StartupController.mensaName), mensaCurrentWeek, mensaNextWeek)
}
2020-02-16 17:17:39 +01:00
logger.info("Updated mensamenu successful at ${Date(mensaMenu.meta.updateTime * 1000)}")
}
2020-02-16 17:17:39 +01:00
/**
* this function updates all existing timetables
* during the update process the old data will be returned for a API request
* a FixedThreadPool is used to make parallel requests for faster updates
*/
private fun asyncUpdateTimetables() = GlobalScope.launch {
logger.info("Updating ${timetableList.size} timetables ...")
2020-02-16 17:17:39 +01:00
// create a new ThreadPool with 5 threads
val executor = Executors.newFixedThreadPool(5)
2020-02-16 17:17:39 +01:00
try {
timetableList.forEach { timetableCourse ->
executor.execute {
timetableCourse.timetable = TimetableParser().getTimeTable(timetableCourse.meta.link)
timetableCourse.meta.updateTime = System.currentTimeMillis() / 1000
2019-10-20 11:52:44 +02:00
2020-02-16 17:17:39 +01:00
saveTimetableToCache(timetableCourse) // save the updated timetable to the cache directory
}
2020-02-16 17:17:39 +01:00
}
} catch (ex: Exception) {
logger.error("Error while updating the timetables", ex)
} finally {
executor.shutdown()
2019-10-20 11:52:44 +02:00
}
}
2020-02-16 17:17:39 +01:00
/**
* save a timetable to the cache directory
* this is only call on async updates, it is NOT call when first getting the timetable
* @param timetable a timetable of the type [TimetableCourseWeek]
*/
private fun saveTimetableToCache(timetable: TimetableCourseWeek) {
println(timetable.timetable.toString())
2019-10-20 11:52:44 +02:00
2020-02-16 17:17:39 +01:00
val file = File(StartupController.dirTcorCache, "timetable-${timetable.meta.courseName}-${timetable.meta.weekIndex}.json")
val writer = BufferedWriter(FileWriter(file))
writer.write(Gson().toJson(timetable))
writer.close()
2019-10-20 11:52:44 +02:00
}
2020-02-16 17:17:39 +01:00
/**
* before the APIController is up, get the data fist
* runBlocking: otherwise the api would return no data to requests for a few seconds after startup
*/
private fun initUpdates() = runBlocking {
// get all course links on startup, make sure there are course links
val jobCourseUpdate = asyncUpdateCourseList()
val jobMensa = asyncUpdateMensa()
2019-10-20 11:52:44 +02:00
2020-02-16 17:17:39 +01:00
jobCourseUpdate.join()
jobMensa.join()
2019-10-20 11:52:44 +02:00
2020-02-16 17:17:39 +01:00
logger.info("Initial updates successful")
2019-10-20 11:52:44 +02:00
}
2020-02-16 17:17:39 +01:00
/**
* update the CourseList every 24h, the Timetables every 3h and the Mensa Menu every hour
* doesn't account the change between winter and summer time!
*/
private fun scheduledUpdates() {
val currentTime = System.currentTimeMillis()
val initDelay24h = (86400000 - ((currentTime + 3600000) % 86400000)) + 60000
val initDelay3h = (10800000 - ((currentTime + 3600000) % 10800000)) + 60000
val initDelay1h = (3600000 - ((currentTime + 3600000) % 3600000)) + 60000
// update courseList every 24 hours (time in ms)
Timer().scheduleAtFixedRate(initDelay24h, 86400000) {
asyncUpdateCourseList()
}
2019-10-20 11:52:44 +02:00
2020-02-16 17:17:39 +01:00
// update all already existing timetables every 3 hours (time in ms)
Timer().scheduleAtFixedRate(initDelay3h, 10800000) {
asyncUpdateTimetables()
}
2019-10-20 11:52:44 +02:00
2020-02-16 17:17:39 +01:00
// update courses every hour (time in ms)
Timer().scheduleAtFixedRate(initDelay1h, 3600000) {
2020-02-16 17:17:39 +01:00
asyncUpdateMensa()
}
// post to status.mosad.xyz every hour, if an API key is present
if (StartupController.cachetAPIKey != "0") {
Timer().scheduleAtFixedRate(initDelay1h, 3600000) {
CachetAPIController.postTotalRequests()
}
}
2019-10-20 11:52:44 +02:00
}
2020-02-16 17:17:39 +01:00
}
2019-10-20 11:52:44 +02:00
}