Initial Commit

src/main/docker/Dockerfile.native

@@ -0,0 +1,11 @@
+FROM registry.access.redhat.com/ubi8/ubi-minimal:8.10
+WORKDIR /work/
+RUN chown 1001 /work \
+    && chmod "g+rwX" /work \
+    && chown 1001:root /work
+COPY --chown=1001:root target/*-runner /work/application
+
+EXPOSE 8080
+USER 1001
+
+ENTRYPOINT ["./application", "-Dquarkus.http.host=0.0.0.0"]

src/main/docker/Dockerfile.native-micro

@@ -0,0 +1,11 @@
+FROM quay.io/quarkus/quarkus-micro-image:2.0
+WORKDIR /work/
+RUN chown 1001 /work \
+    && chmod "g+rwX" /work \
+    && chown 1001:root /work
+COPY --chown=1001:root target/*-runner /work/application
+
+EXPOSE 8080
+USER 1001
+
+ENTRYPOINT ["./application", "-Dquarkus.http.host=0.0.0.0"]

src/main/kotlin/de/arindy/mythodea/api/GreetingResource.kt

@@ -0,0 +1,19 @@
+package de.arindy.mythodea.api
+
+import jakarta.inject.Inject
+import jakarta.ws.rs.GET
+import jakarta.ws.rs.Path
+import jakarta.ws.rs.Produces
+import jakarta.ws.rs.QueryParam
+import jakarta.ws.rs.core.MediaType
+import java.time.Instant
+
+@Path("date/")
+class GreetingResource @Inject constructor(var repository: Repository) {
+
+    @GET
+    @Path("from")
+    @Produces(MediaType.APPLICATION_JSON)
+    fun from(@QueryParam("epochMillis") epochMillis: Long): MitrasperanDate =
+        mitrasperan(if (epochMillis > 0) Instant.ofEpochMilli(epochMillis) else Instant.now())
+}

src/main/kotlin/de/arindy/mythodea/api/MitrasperanCalendar.kt

@@ -0,0 +1,248 @@
+package de.arindy.mythodea.api
+
+import java.util.Calendar
+import java.util.Calendar.DAY_OF_MONTH
+import java.util.Calendar.HOUR_OF_DAY
+import java.util.Calendar.MINUTE
+import java.util.Calendar.MONTH
+import java.util.Calendar.SECOND
+import java.util.Calendar.YEAR
+import java.util.TimeZone
+
+class MitrasperanCalendar {
+
+    fun get(calendar: Calendar): MitrasperanDate {
+        calendar.set(HOUR_OF_DAY, 12)
+        calendar.set(MINUTE, 0)
+        calendar.set(SECOND, 0)
+        val moladStart = Calendar.getInstance(TimeZone.getTimeZone("Europe/Berlin"))
+        moladStart.set(2045, 10, 10, 0, 0, 0)
+        val moladEnd = Calendar.getInstance(TimeZone.getTimeZone("Europe/Berlin"))
+        moladEnd.set(2046, 10, 30, 0, 0, 0)
+        var startOfMolad = false
+        if (moladStart.get(YEAR) == calendar.get(YEAR) && moladStart.get(MONTH) == calendar.get(MONTH) && moladStart.get(
+                DAY_OF_MONTH
+            ) == calendar.get(DAY_OF_MONTH)
+        ) {
+            startOfMolad = true
+        }
+        if (calendar.after(moladStart) && calendar.before(moladEnd)) {
+            calendar.add(Calendar.DATE, -1)
+        }
+        val absDate = absoluteFromGregorianDate(calendar)
+        var y: Int
+        var m: Int
+        var day: Int
+        var temp: Int
+
+        /* Approximation */
+        val approx = (absDate + 1373429) / 366
+
+        /* Search forward from the approximation */
+        y = approx
+        while (true) {
+            temp = absoluteFromMitrasperanDate(MitrasperanDate(1, 7, y + 1))
+            if (absDate < temp) break
+            y++
+        }
+        val year = y
+
+        /* Starting month for search for month */
+        temp = absoluteFromMitrasperanDate(MitrasperanDate(1, 1, year))
+        val start = if (absDate < temp) 7
+        else 1
+
+        /* Search forward from either Tishri or Nisan */
+        m = start
+        while (true) {
+            temp = absoluteFromMitrasperanDate(MitrasperanDate(getLastDayOfMitrasperanMonth(m, year), m, year))
+            if (absDate <= temp) break
+            m++
+        }
+        val month = m
+
+        /* Calculate the day by subtraction */
+        temp = absoluteFromMitrasperanDate(MitrasperanDate(1, month, year))
+        day = absDate - temp + 1
+
+        if (startOfMolad) {
+            day++
+        }
+
+        return MitrasperanDate(day, if (month == 12 && !leapYear(year)) 13 else month, year(year), calendar.get(MONTH))
+    }
+
+    private fun leapYear(year: Int): Boolean {
+        return ((7 * year) + 1) % 19 < 7
+    }
+
+    private fun getLastDayOfGregorianMonth(month: Int, year: Int): Int {
+        return if ((month == 2) &&
+            ((year % 4) == 0) &&
+            ((year % 400) != 100) &&
+            ((year % 400) != 200) &&
+            ((year % 400) != 300)
+        ) 29
+        else intArrayOf(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)[month - 1]
+    }
+
+    private fun year(year: Int): Int {
+        return year - 5763
+    }
+
+    private fun absoluteFromGregorianDate(date: Calendar): Int {
+        /* Days so far this month */
+        var value = date.get(DAY_OF_MONTH)
+
+        /* Days in prior months this year */
+        var m = 1
+        while (m < date.get(MONTH) + 1) {
+            value += getLastDayOfGregorianMonth(m, date.get(YEAR))
+            m++
+        }
+
+        /* Days in prior years */
+        value += (365 * (date.get(YEAR) - 1))
+
+        /* Julian leap days in prior years ... */
+        value += ((date.get(YEAR) - 1) / 4)
+
+        /* ... minus prior century years ... */
+        value -= ((date.get(YEAR) - 1) / 100)
+
+        /* ... plus prior years divisible by 400 */
+        value += ((date.get(YEAR) - 1) / 400)
+
+        return (value)
+    }
+
+    private fun absoluteFromMitrasperanDate(date: MitrasperanDate): Int {
+        var value: Int
+        var m: Int
+
+        /* Days so far this month */
+        value = date.day
+        var returnValue = value
+
+        /* If before Tishri */
+        if (date.month < 7) {
+            /* Then add days in prior months this year before and */
+            /* after Nisan. */
+            m = 7
+            while (m <= getLastMonthOfMitrasperanYear(date.year)) {
+                value = getLastDayOfMitrasperanMonth(m, date.year)
+                returnValue += value
+                m++
+            }
+            m = 1
+            while (m < date.month) {
+                value = getLastDayOfMitrasperanMonth(m, date.year)
+                returnValue += value
+                m++
+            }
+        } else {
+            m = 7
+            while (m < date.month) {
+                value = getLastDayOfMitrasperanMonth(m, date.year)
+                returnValue += value
+                m++
+            }
+        }
+
+        /* Days in prior years */
+        value = mitrasperanCalendarElapsedDays(date.year)
+        returnValue += value
+
+        /* Days elapsed before absolute date 1 */
+        value = 1373429
+        returnValue -= value
+
+        return (returnValue)
+    }
+
+    private fun getLastMonthOfMitrasperanYear(year: Int): Int {
+        return if (leapYear(year)) 13
+        else 12
+    }
+
+    private fun getLastDayOfMitrasperanMonth(month: Int, year: Int): Int {
+        if ((month == 2) ||
+            (month == 4) ||
+            (month == 6) ||
+            (month == 10) ||
+            (month == 13)
+        ) return 29
+        if ((month == 12) && (!leapYear(year))) return 29
+        if ((month == 8) && (!longYear(year))) return 29
+        if ((month == 9) && (shortYear(year))) return 29
+        return 30
+    }
+
+    private fun daysInMitrasperanYear(year: Int): Int {
+        return (mitrasperanCalendarElapsedDays(year + 1) -
+            mitrasperanCalendarElapsedDays(year))
+    }
+
+    private fun longYear(year: Int): Boolean {
+        return (daysInMitrasperanYear(year) % 10) == 5
+    }
+
+    private fun shortYear(year: Int): Boolean {
+        return (daysInMitrasperanYear(year) % 10) == 3
+    }
+
+    private fun mitrasperanCalendarElapsedDays(year: Int): Int {
+        var monthsElapsed: Int
+        val hoursElapsed: Int
+        val parts: Int
+        var alternativeDay: Int
+
+        /* Months in complete cycles so far */
+        var value = 235 * ((year - 1) / 19)
+        monthsElapsed = value
+
+        /* Regular months in this cycle */
+        value = 12 * ((year - 1) % 19)
+        monthsElapsed += value
+
+        /* Leap months this cycle */
+        value = ((((year - 1) % 19) * 7) + 1) / 19
+        monthsElapsed += value
+
+        val partsElapsed = (((monthsElapsed % 1080) * 793) + 204)
+        hoursElapsed = (5 +
+            (monthsElapsed * 12) +
+            ((monthsElapsed / 1080) * 793) +
+            (partsElapsed / 1080))
+
+        /* Conjunction day */
+        val day = 1 + (29 * monthsElapsed) + (hoursElapsed / 24)
+
+        /* Conjunction parts */
+        parts = ((hoursElapsed % 24) * 1080) +
+            (partsElapsed % 1080)
+
+        /* If new moon is at or after midday, */
+        alternativeDay = if ((parts >= 19440) ||  /* ...or is on a Tuesday... */
+            (((day % 7) == 2) &&  /* at 9 hours, 204 parts or later */
+                (parts >= 9924) &&  /* of a common year */
+                (!leapYear(year))) ||  /* ...or is on a Monday at... */
+            (((day % 7) == 1) &&  /* 15 hours, 589 parts or later... */
+                (parts >= 16789) &&  /* at the end of a leap year */
+                (leapYear(year - 1)))
+        )  /* Then postpone Rosh HaShanah one day */
+            day + 1
+        else day
+
+        /* If Rosh HaShanah would occur on Sunday, Wednesday, */
+        /* or Friday */
+        if (((alternativeDay % 7) == 0) ||
+            ((alternativeDay % 7) == 3) ||
+            ((alternativeDay % 7) == 5)
+        )  /* Then postpone it one (more) day and return */
+            alternativeDay++
+
+        return (alternativeDay)
+    }
+
+}

src/main/kotlin/de/arindy/mythodea/api/MitrasperanDate.kt

@@ -0,0 +1,78 @@
+package de.arindy.mythodea.api
+
+import io.quarkus.logging.Log
+import java.time.Instant
+import java.util.Calendar
+import java.util.Date
+import java.util.TimeZone
+
+data class MitrasperanDate internal constructor(
+    val day: Int,
+    val month: Int,
+    val year: Int,
+    private val gregorianMonth: Int,
+    val yearNDE: Int = if (month <= 6 || gregorianMonth >= 7) year + 1 else year,
+    val yearNDK: Int = year - 19,
+    val dayString: String = DAYS[day - 1],
+    val monthString: String = MONTHS[month - 1]
+) {
+
+    constructor(day: Int, month: Int, year: Int) : this(day, month, year, -1)
+
+    companion object {
+        private val MONTHS = arrayOf(
+            "Wandelmond",
+            "Launing",
+            "Blütenmond",
+            "Brachmond",
+            "Weidmond",
+            "Naiba",
+            "Holzmond",
+            "Goldmond",
+            "Scheiding",
+            "Blaumond",
+            "Gilbhart",
+            "Eismond",
+            "Fralt",
+        )
+        private val DAYS = arrayOf(
+            "1. Erztag",
+            "1. Fyrstag",
+            "1. Bindetag",
+            "1. Meerstag",
+            "1. Wintstag",
+            "1. Mahntag",
+            "2. Erztag",
+            "2. Fyrstag",
+            "2. Bindetag",
+            "2. Meerstag",
+            "2. Wintstag",
+            "2. Mahntag",
+            "Weiße Vornacht",
+            "Weiße Nacht",
+            "Weiße Nacht",
+            "3. Erztag",
+            "3. Fyrstag",
+            "3. Bindetag",
+            "3. Meerstag",
+            "3. Wintstag",
+            "3. Mahntag",
+            "4. Erztag",
+            "4. Fyrstag",
+            "4. Bindetag",
+            "4. Meerstag",
+            "4. Wintstag",
+            "4. Mahntag",
+            "Schwarze Nacht",
+            "Schwarze Nacht",
+            "Pechnacht",
+        )
+    }
+}
+
+fun mitrasperan(date: Instant): MitrasperanDate {
+    val calendar = Calendar.getInstance(TimeZone.getTimeZone("Europe/Berlin"))
+    calendar.time = Date.from(date)
+    Log.info(calendar.time.toString())
+    return MitrasperanCalendar().get(calendar)
+}

src/main/resources/application.properties

@@ -0,0 +1 @@
+quarkus.http.port=8080

src/test/kotlin/org/acme/GreetingResourceIT.kt

@@ -0,0 +1,8 @@
+package de.arindy.mythodea.api
+
+import io.quarkus.test.junit.QuarkusIntegrationTest
+
+@QuarkusIntegrationTest
+class GreetingResourceIT : GreetingResourceTest() {
+
+}

src/test/kotlin/org/acme/GreetingResourceTest.kt

@@ -0,0 +1,9 @@
+package de.arindy.mythodea.api
+
+import io.quarkus.test.junit.QuarkusTest
+
+@QuarkusTest
+class GreetingResourceTest {
+
+
+}