@ -1,7 +1,7 @@
/ * *
* TheCitadelofRicks
*
* Copyright 2019 < seil0 @mosad . xyz >
* Copyright 2019 - 2020 < seil0 @mosad . xyz >
*
* 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
@ -22,88 +22,100 @@
package org.mosad.thecitadelofricks.controller
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.async
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import com.google.gson.Gson
import kotlinx.coroutines.*
import org.jsoup.Jsoup
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.*
import java.util.*
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.Executors
import kotlin.collections.ArrayList
import kotlin.collections.HashSet
import kotlin.concurrent.scheduleAtFixedRate
import kotlin.time.Duration.Companion.hours
import kotlin.time.Duration.Companion.minutes
import kotlin.time.ExperimentalTime
class CacheController {
private val logger : Logger = LoggerFactory . getLogger ( CacheController :: class . java )
// hso parser links (hardcoded)
private val courseListURL = " https://www.hs-offenburg.de/studium/vorlesungsplaene/ "
private val mensaMenuURL = " https://www.swfr.de/de/essen-trinken/speiseplaene/mensa-offenburg/ "
private val mensaName = " Offenburg "
init {
initUpdates ( )
scheduledUpdates ( )
}
// cache objects
companion object {
companion object {
private val logger : Logger = LoggerFactory . getLogger ( CacheController :: class . java )
lateinit var courseList : CourseList
lateinit var mensaMenu : MensaMenu
var timetableList = ArrayList < TimetableCourseWeek > ( ) // this list contains all timetables
var courseList = CoursesList ( CoursesMeta ( ) , sortedMapOf ( ) )
var mensaMenu = MensaMenu ( MensaMeta ( 0 , " " ) , MensaWeek ( ) , MensaWeek ( ) )
var timetableList = ConcurrentHashMap < String , TimetableCourseWeek > ( ) // this list contains all timetables
/ * *
* get a timetable , since they may not cached , we need to make sure it ' s cached , otherwise download
* get a timetable , since they may not be cached , we need to make sure it ' s cached , otherwise download
* @param courseName the name of the course to be requested
* @param weekIndex request week number ( current week = 0 )
* @return the timetable of a course ( courseName )
* @return timetable of the course ( Type : [ TimetableCourseWeek ] )
* /
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 " )
val jobTimetable = GlobalScope . async {
timetable = TimetableParser ( ) . getTimeTable ( timetableLink )
weekNumberYear = TimetableParser ( ) . getWeekNumberYear ( timetableLink )
}
jobTimetable . await ( )
timetableList . add (
TimetableCourseWeek (
TimetableCourseMeta (
currentTime ,
courseName ,
weekIndex ,
weekNumberYear ,
timetableLink
) ,
timetable
)
)
logger . info ( " added new timetable for $courseName , week $weekIndex " )
}
fun getTimetable ( courseName : String , weekIndex : Int ) : TimetableCourseWeek {
// TODO just for testing
if ( courseName == " TEST_A " || courseName == " TEST_B " ) {
val currentTime = System . currentTimeMillis ( ) / 1000
val timetableLink = " https://mosad.xyz "
val weekNumberYear = 0
val year = 0
val instr = CacheController :: class . java . getResourceAsStream ( " /html/Timetable_normal-week.html " )
val timetableParser =
TimetableParser ( htmlDoc = Jsoup . parse ( instr !! , " UTF-8 " , " https://www.hs-offenburg.de/ " ) )
val timetableTest = timetableParser . parseTimeTable ( )
return TimetableCourseWeek (
TimetableCourseMeta (
currentTime ,
courseName ,
weekIndex ,
weekNumberYear ,
year ,
timetableLink
) , timetableTest ?: TimetableWeek ( )
)
}
return @runBlocking timetableList . stream ( ) . filter { x -> x . meta . courseName == courseName && x . meta . weekIndex == weekIndex } . findAny ( ) . orElse ( null )
val key = " $courseName - $weekIndex "
return if ( timetableList . containsKey ( key ) ) {
timetableList [ key ] !!
} else {
val timetableLink = courseList . courses [ courseName ]
?. courseLink
?. replace ( " week=0 " , " week= $weekIndex " ) ?: " "
val currentTime = System . currentTimeMillis ( ) / 1000
val timetableParser = TimetableParser ( timetableLink )
val calendarWeek = timetableParser . parseCalendarWeek ( )
val timetable = timetableParser . parseTimeTable ( )
TimetableCourseWeek (
TimetableCourseMeta (
currentTime ,
courseName ,
weekIndex ,
calendarWeek ?. week ?: 0 ,
calendarWeek ?. year ?: 0 ,
timetableLink
) , timetable ?: TimetableWeek ( )
) . also { if ( timetable != null ) timetableList [ key ] = it }
}
}
/ * *
* get every explicit lesson in a week
* get every explicit lesson in a week for a selected course
* @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
@ -121,11 +133,11 @@ class CacheController {
}
/ * *
* get every explicit lesson in a week
* get every lesson of a subject in a week
* @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 of every lesson with lessonSubject for one week
* @return a ArrayList < [ Lesson ] > of every lesson with lessonSubject for one week
* /
fun getLesson ( courseName : String , lessonSubject : String , weekIndex : Int ) : ArrayList < Lesson > {
val lessonList = ArrayList < Lesson > ( )
@ -133,143 +145,151 @@ class CacheController {
// get all lessons from the weeks timetable
val flatMap = getTimetable ( courseName , weekIndex ) . timetable . days . flatMap { it . timeslots . asIterable ( ) }
flatMap . forEach {
it . forEach { lesson ->
if ( lesson . lessonSubject . contains ( lessonSubject ) ) {
lessonList . add ( lesson )
}
}
// TODO Java 11
//it.stream().filter { x -> x.lessonSubject.contains(lessonSubject) }.findAny().ifPresent { x -> println("${x.lessonSubject}, ${x.lessonTeacher}") }
it . stream ( ) . filter { x -> x . lessonSubject . contains ( lessonSubject ) } . findAny ( ) . ifPresent { x -> lessonList . add ( x ) }
}
return lessonList
}
}
/ * *
* 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 ( courseListURL ) ?. let {
courseList =
CourseList (
CourseMeta (
System . currentTimeMillis ( ) / 1000 ,
it . size
) , it
)
}
// private cache functions
logger . info ( " updated courses successful at ${Date(courseList.meta.updateTime * 1000)} " )
}
/ * *
* this function updates the courseList
* during the update process the old data will be returned for an API request
* /
private fun asyncUpdateCourseList ( ) = GlobalScope . launch {
CourseListParser ( ) . getCourseLinks ( StartupController . courseListURL ) ?. let {
courseList = CoursesList ( CoursesMeta ( System . currentTimeMillis ( ) / 1000 , it . size ) , it . toSortedMap ( ) )
}
/ * *
* 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 ( mensaMenuURL )
val mensaNextWeek = MensaParser ( ) . getMensaMenu ( MensaParser ( ) . getMenuLinkNextWeek ( mensaMenuURL ) )
// only update if we get valid data
if ( mensaCurrentWeek != null && mensaNextWeek != null ) {
mensaMenu =
MensaMenu (
MensaMeta (
System . currentTimeMillis ( ) / 1000 ,
mensaName
) , mensaCurrentWeek , mensaNextWeek
)
// TODO just for testing
courseList . courses [ " TEST_A " ] = Course ( " TEST_A " , " https://mosad.xyz " )
courseList . courses [ " TEST_B " ] = Course ( " TEST_B " , " https://mosad.xyz " )
logger . info ( " Updated courses successful at ${Date(courseList.meta.updateTime * 1000)} " )
}
logger . info ( " updated mensamenu successful at ${Date(mensaMenu.meta.updateTime * 1000)} " )
}
/ * *
* this function updates the mensa menu list
* during the update process the old data will be returned for an API request
* /
private fun asyncUpdateMensa ( ) = GlobalScope . launch {
val mensaCurrentWeek = MensaParser ( ) . getMensaMenu ( StartupController . mensaMenuURL )
val mensaNextWeek = MensaParser ( ) . getMensaMenu ( MensaParser ( ) . getMenuLinkNextWeek ( StartupController . mensaMenuURL ) )
// only update if we get valid data
if ( mensaCurrentWeek != null && mensaNextWeek != null ) {
mensaMenu = MensaMenu ( MensaMeta ( System . currentTimeMillis ( ) / 1000 , StartupController . mensaName ) , mensaCurrentWeek , mensaNextWeek )
}
/ * *
* this function updates all existing timetables
* during the update process the old data will be returned for a API request
* /
private fun asyncUpdateTimetables ( ) = GlobalScope . launch {
timetableList . forEach { timetableCourse ->
val updateURL = timetableCourse . meta . link
timetableCourse . timetable = TimetableParser ( ) . getTimeTable ( updateURL )
timetableCourse . meta . updateTime = System . currentTimeMillis ( ) / 1000
logger . info ( " Updated mensamenu successful at ${Date(mensaMenu.meta.updateTime * 1000)} " )
}
logger . info ( " updated ${timetableList.size} timetables successful! " )
}
/ * *
* 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 courses on startup
val jobCourseUpdate = GlobalScope . async {
CourseListParser ( ) . getCourseLinks ( courseListURL ) ?. let {
courseList =
CourseList (
CourseMeta (
System . currentTimeMillis ( ) / 1000 ,
it . size
) , it
)
/ * *
* this function updates all existing timetables
* during the update process the old data will be returned for an API request
* a FixedThreadPool is used to make parallel requests for faster updates
* /
private fun asyncUpdateTimetables ( ) = GlobalScope . launch {
logger . info ( " Updating ${timetableList.size} timetables ... " )
// create a new ThreadPool with 5 threads
val executor = Executors . newFixedThreadPool ( 5 )
try {
timetableList . forEach { timetableCourse ->
executor . execute {
val timetableParser = TimetableParser ( timetableCourse . value . meta . link )
timetableCourse . value . timetable = timetableParser . parseTimeTable ( ) ?: return @execute
timetableCourse . value . meta . weekNumberYear =
timetableParser . parseCalendarWeek ( ) ?. week ?: return @execute
timetableCourse . value . meta . updateTime = System . currentTimeMillis ( ) / 1000
