version 1.2.7

* update coroutines 1.3.7 -> 1.3.8

.drone.yml

@@ -6,4 +6,25 @@ steps:
   image: gradle:jdk11
   commands:
   - gradle test
-
+  
+- name: build
+  image: gradle:jdk11
+  commands:
+    - gradle bootJar
+  when:
+    event:
+      - tag
+        
+- name: docker  
+  image: plugins/docker
+  settings:
+    username:
+      from_secret: docker_username
+    password:
+      from_secret: docker_password
+    repo: mosadxyz/tcor
+    tags:
+      - latest
+  when:
+    event:
+      - tag

Dockerfile

@@ -0,0 +1,8 @@
+FROM adoptopenjdk/openjdk11:alpine-jre
+RUN addgroup -S spring && adduser -S spring -G spring
+#RUN groupadd -r spring && useradd -r -g spring spring # for openjdk:xx builds
+USER spring:spring
+ARG JAR_FILE=build/libs/*.jar
+COPY ${JAR_FILE} thecitadelofricks.jar
+ENTRYPOINT ["java","-Djavax.net.ssl.trustStore=/tcor/cacerts", "-Djavax.net.ssl.trustStorePassword=changeit", "-jar","/thecitadelofricks.jar"]
+VOLUME /tcor

build.gradle

@@ -1,12 +1,12 @@
 plugins {
     id 'org.jetbrains.kotlin.jvm' version '1.3.72'
     id 'org.jetbrains.kotlin.plugin.spring' version '1.3.72'
-    id 'org.springframework.boot' version '2.3.0.RELEASE'
+    id 'org.springframework.boot' version '2.3.2.RELEASE'
     id 'io.spring.dependency-management' version '1.0.9.RELEASE'
 }
 
 group 'org.mosad'
-version '1.2.2'
+version '1.2.7'
 
 repositories {
     jcenter()
@@ -14,9 +14,8 @@ repositories {
 
 dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-web'
-    implementation 'org.jetbrains.kotlin:kotlin-reflect'
     implementation 'org.jetbrains.kotlin:kotlin-stdlib'
-    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.7'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.8'
     implementation 'org.jsoup:jsoup:1.13.1'
     implementation 'com.google.code.gson:gson:2.8.6'
 

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.4-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.5-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -82,6 +82,7 @@ esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
+
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
@@ -129,6 +130,7 @@ fi
 if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    
     JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath

gradlew.bat

@@ -29,6 +29,9 @@ if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
 
@@ -81,6 +84,7 @@ set CMD_LINE_ARGS=%*
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
+
 @rem Execute Gradle
 "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
 

src/main/kotlin/org/mosad/thecitadelofricks/APIController.kt

@@ -40,6 +40,7 @@ import org.springframework.web.bind.annotation.RequestParam
 import org.springframework.web.bind.annotation.RestController
 import java.time.LocalDateTime
 import java.util.*
+import kotlin.collections.ArrayList
 
 @RestController
 class APIController {
@@ -48,7 +49,7 @@ class APIController {
 
     companion object {
         const val apiVersion = "1.2.0"
-        const val softwareVersion = "1.2.3"
+        const val softwareVersion = "1.2.7"
         val startTime = System.currentTimeMillis() / 1000
     }
 
@@ -58,10 +59,11 @@ class APIController {
     }
 
     @RequestMapping("/courseList")
-    fun courseList(): CoursesList {
+    fun courseList(): CoursesListRet {
         logger.info("courseList request at ${LocalDateTime.now()}!")
         updateCourseListRequests()
-        return courseList
+
+        return CoursesListRet(courseList.meta, ArrayList(courseList.courses.values))
     }
 
     @RequestMapping("/mensamenu")
@@ -121,7 +123,7 @@ class APIController {
     // TODO remove this with API version 2.0.0
     @Deprecated("courses is replaced by courseList", replaceWith = ReplaceWith("courseList()"))
     @RequestMapping("/courses")
-    fun courses(): CoursesList {
+    fun courses(): CoursesListRet {
         return courseList()
     }
 

src/main/kotlin/org/mosad/thecitadelofricks/DataTypes.kt

@@ -29,9 +29,10 @@ import kotlin.collections.HashMap
 // data classes for the course part
 data class Course(val courseName: String, val courseLink: String)
 
-data class CoursesMeta(val updateTime: Long, val totalCourses: Int)
+data class CoursesMeta(val updateTime: Long = 0, val totalCourses: Int = 0)
 
-data class CoursesList(val meta: CoursesMeta, val courses: ArrayList<Course>)
+data class CoursesList(val meta: CoursesMeta = CoursesMeta(), val courses: SortedMap<String, Course>)
+data class CoursesListRet(val meta: CoursesMeta = CoursesMeta(), val courses: ArrayList<Course> = ArrayList())
 
 // data classes for the Mensa part
 data class Meal(val day: String, val heading: String, val parts: ArrayList<String>, val additives: String)
@@ -63,7 +64,6 @@ data class TimetableCourseWeek(val meta: TimetableCourseMeta = TimetableCourseMe
 
 
 // data classes for the status part
-data class TimetableCounter(var courseName: String, var requests: Int)
 
 data class Status(
     val time: LocalDateTime,

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

@@ -23,22 +23,19 @@
 package org.mosad.thecitadelofricks.controller
 
 import com.google.gson.Gson
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.async
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
+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.BufferedWriter
-import java.io.File
-import java.io.FileWriter
+import java.io.*
 import java.util.*
 import java.util.concurrent.Executors
 import kotlin.collections.ArrayList
+import kotlin.collections.HashMap
 import kotlin.collections.HashSet
 import kotlin.concurrent.scheduleAtFixedRate
 
@@ -52,9 +49,9 @@ class CacheController {
     companion object{
         private val logger: Logger = LoggerFactory.getLogger(CacheController::class.java)
 
-        var courseList = CoursesList(CoursesMeta(0, 0), ArrayList())
+        var courseList = CoursesList(CoursesMeta(), sortedMapOf())
         var mensaMenu = MensaMenu(MensaMeta(0,""), MensaWeek(), MensaWeek())
-        var timetableList = ArrayList<TimetableCourseWeek>() // this list contains all timetables
+        var timetableList = HashMap<String, TimetableCourseWeek>() // this list contains all timetables
 
         /**
          * get a timetable, since they may not be cached, we need to make sure it's cached, otherwise download
@@ -63,30 +60,36 @@ class CacheController {
          * @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")
+            // 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 instr = javaClass.getResourceAsStream("/html/Timetable_normal-week.html")
 
-                    val jobTimetable = async {
-                        timetable = TimetableParser().getTimeTable(timetableLink)
-                        weekNumberYear = TimetableParser().getWeekNumberYear(timetableLink)
-                    }
+                val htmlDoc = Jsoup.parse(instr,"UTF-8", "https://www.hs-offenburg.de/")
+                val timetableTest = TimetableParser().parseTimeTable(htmlDoc)
 
-                    jobTimetable.await()
-                    timetableList.add(TimetableCourseWeek(TimetableCourseMeta(currentTime, courseName, weekIndex, weekNumberYear, timetableLink), timetable))
-
-                    logger.info("added new timetable for $courseName, week $weekIndex")
-                }
+                return@runBlocking TimetableCourseWeek(TimetableCourseMeta(currentTime, courseName, weekIndex, weekNumberYear, timetableLink), timetableTest)
             }
 
-            return@runBlocking timetableList.stream().filter { x -> x.meta.courseName == courseName && x.meta.weekIndex == weekIndex }.findAny().orElse(null)
+            return@runBlocking timetableList.getOrPut("$courseName-$weekIndex") {
+                val timetableLink = courseList.courses[courseName]
+                    ?.courseLink
+                    ?.replace("week=0", "week=$weekIndex") ?: ""
+                val currentTime = System.currentTimeMillis() / 1000
+                var timetable = TimetableWeek()
+                var weekNumberYear = 0
+
+                val timetableJobs = listOf(
+                    async { timetable = TimetableParser().getTimeTable(timetableLink) },
+                    async { weekNumberYear = TimetableParser().getWeekNumberYear(timetableLink) }
+                )
+
+                timetableJobs.awaitAll()
+                TimetableCourseWeek(TimetableCourseMeta(currentTime, courseName, weekIndex, weekNumberYear, timetableLink), timetable)
+            }
         }
 
         /**
@@ -134,9 +137,13 @@ class CacheController {
          */
         private fun asyncUpdateCourseList() = GlobalScope.launch {
             CourseListParser().getCourseLinks(StartupController.courseListURL)?.let {
-                courseList = CoursesList(CoursesMeta(System.currentTimeMillis() / 1000, it.size), it)
+                courseList = CoursesList(CoursesMeta(System.currentTimeMillis() / 1000, it.size), it.toSortedMap())
             }
 
+            // 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)}")
         }
 
@@ -170,10 +177,10 @@ class CacheController {
             try {
                 timetableList.forEach { timetableCourse ->
                     executor.execute {
-                        timetableCourse.timetable = TimetableParser().getTimeTable(timetableCourse.meta.link)
-                        timetableCourse.meta.updateTime = System.currentTimeMillis() / 1000
+                        timetableCourse.value.timetable = TimetableParser().getTimeTable(timetableCourse.value.meta.link)
+                        timetableCourse.value.meta.updateTime = System.currentTimeMillis() / 1000
 
-                        saveTimetableToCache(timetableCourse) // save the updated timetable to the cache directory
+                        saveTimetableToCache(timetableCourse.value) // save the updated timetable to the cache directory
                     }
 
                 }
@@ -190,12 +197,16 @@ class CacheController {
          * @param timetable a timetable of the type [TimetableCourseWeek]
          */
         private fun saveTimetableToCache(timetable: TimetableCourseWeek) {
-            println(timetable.timetable.toString())
-
             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()
+
+            try {
+                writer.write(Gson().toJson(timetable))
+            } catch (e: Exception) {
+                logger.error("something went wrong while trying to write a cache file", e)
+            } finally {
+                writer.close()
+            }
         }
 
         /**

src/main/kotlin/org/mosad/thecitadelofricks/controller/StartupController.kt

@@ -134,7 +134,8 @@ class StartupController {
 
                 try {
                     val timetableObject = JsonParser.parseString(bufferedReader.readLine()).asJsonObject
-                    CacheController.timetableList.add(Gson().fromJson(timetableObject, TimetableCourseWeek().javaClass))
+                    val timetable = Gson().fromJson(timetableObject, TimetableCourseWeek().javaClass)
+                    CacheController.timetableList.put("${timetable.meta.courseName}-${timetable.meta.weekIndex}", timetable)
                 } catch (ex: Exception) {
                     logger.error("error while reading cache", ex)
                 } finally {

src/main/kotlin/org/mosad/thecitadelofricks/hsoparser/CourseListParser.kt

@@ -29,26 +29,25 @@ import java.net.SocketTimeoutException
 
 class CourseListParser {
 
-    private var logger: org.slf4j.Logger = LoggerFactory.getLogger(MensaParser::class.java)
+    private var logger: org.slf4j.Logger = LoggerFactory.getLogger(CourseListParser::class.java)
 
     /**
      * return a list of all courses at courseListURL
      * @param courseListURL the url to the course list page
      * @return a ArrayList<Course> with all courses or null if the request was not successful
      */
-    fun getCourseLinks(courseListURL: String): ArrayList<Course>? {
-        val courseLinkList = ArrayList<Course>()
+    fun getCourseLinks(courseListURL: String): HashMap<String, Course>? {
+        val courseLinkList = HashMap<String, Course>()
         try {
             val courseHTML = Jsoup.connect(courseListURL).get()
 
             courseHTML.select("ul.index-group").select("li.Class").select("a[href]").forEachIndexed { _, element ->
-                courseLinkList.add(
-                    Course(
-                        element.text(),
-                        element.attr("href").replace("http", "https")
-                    )
+                courseLinkList[element.text()] = Course(
+                    element.text(),
+                    element.attr("href").replace("http", "https")
                 )
             }
+            logger.info("successfully retrieved course List")
         } catch (ex: SocketTimeoutException) {
             logger.warn("timeout from hs-offenburg.de, updating on next attempt!")
             return null

src/main/kotlin/org/mosad/thecitadelofricks/hsoparser/TimetableParser.kt

@@ -181,4 +181,5 @@ class TimetableParser {
 
         println(" \n")
     }
+
 }

src/main/resources/application.properties

@@ -11,5 +11,5 @@ logging.level.org.springframework.web=INFO
 # ----------------------------------------
 
 # EMBEDDED SERVER CONFIGURATION (ServerProperties)
-server.address=127.0.0.1
+server.address=0.0.0.0
 server.port=8080