Merge pull request #2134 from digma-ai/feature/digmathon-changes

Update Digmathon

Author: shaykeren

ide-common/build.gradle.kts

@@ -31,6 +31,7 @@ dependencies {
     api(libs.maven.artifact)
     api(libs.glovoapp.versioning)
     api(libs.byte.buddy)
+    api(libs.jackson.datetime)
 
 
     implementation(project(":model"))

ide-common/src/main/kotlin/org/digma/intellij/plugin/common/ObjectMapperFactory.kt

@@ -3,19 +3,39 @@ package org.digma.intellij.plugin.common
 import com.fasterxml.jackson.databind.ObjectMapper
 import com.fasterxml.jackson.databind.SerializationFeature
 import com.fasterxml.jackson.databind.util.StdDateFormat
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule
 
 
 /**
  * a factory for ObjectMapper to be used by components and services that need an ObjectMapper,
  * makes sure all will use the same configuration.
  */
 fun createObjectMapper(): ObjectMapper {
+    //Note that it is risky to change configuration or install modules.
+    // because there are components that already use this object mapper as is
+    // and changes to configuration may cause issues. its probably mainly dates that were
+    // serialized to persistence.
+    //but, probably installing the JavaTimeModule should be OK because it's backwards compatible.
+    //users of this factory may change configuration on the instance they create.
     val objectMapper = ObjectMapper()
     objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
     objectMapper.setDateFormat(StdDateFormat())
     return objectMapper
 }
 
+
+fun createObjectMapperWithJavaTimeModule(): ObjectMapper {
+    //install the JavaTimeModule for better serialization of dates
+    val objectMapper = ObjectMapper()
+    objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
+    objectMapper.registerModules(JavaTimeModule())
+    objectMapper.setDateFormat(StdDateFormat())
+    return objectMapper
+}
+
+
+
+
 /**
  * ObjectMapper is fully thread safe and does not need to be created many times.
  * usually its more convenient to create a class member in classes that need to use an ObjectMapper

ide-common/src/main/kotlin/org/digma/intellij/plugin/digmathon/DigmathonProductKey.kt

@@ -9,11 +9,13 @@ import java.nio.charset.StandardCharsets
 
 
 private const val MY_SERVICE = "org.digma.digmathon.productKey"
-private const val MY_KEY = "product-key-2024.4"
+
+//change MY_KEY for every new dismathon
+private const val MY_KEY = "product-key-2024.5"
 
 class DigmathonProductKey {
 
-    private val myHash = "b9fe040958b98f68533511125bc104435bfefd4293b328060992767d51333321"
+    private val myHash = "89e0f23f9a0a670b2bb7393a1280aa59eaf7c59c22b77d869b5c9c7af021785f"
 
     @Throws(InvalidProductKeyException::class)
     fun validateAndSave(productKey: String) {

ide-common/src/main/kotlin/org/digma/intellij/plugin/digmathon/DigmathonService.kt

@@ -1,5 +1,6 @@
 package org.digma.intellij.plugin.digmathon
 
+import com.fasterxml.jackson.core.type.TypeReference
 import com.intellij.collaboration.async.disposingScope
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.application.ApplicationManager
@@ -12,17 +13,18 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 import org.digma.intellij.plugin.common.allowSlowOperation
+import org.digma.intellij.plugin.common.createObjectMapperWithJavaTimeModule
 import org.digma.intellij.plugin.common.findActiveProject
 import org.digma.intellij.plugin.errorreporting.ErrorReporter
 import org.digma.intellij.plugin.log.Log
 import org.digma.intellij.plugin.notifications.NotificationUtil
 import org.digma.intellij.plugin.persistence.PersistenceService
 import org.digma.intellij.plugin.posthog.ActivityMonitor
+import java.time.Instant
 import java.time.LocalDate
 import java.time.LocalDateTime
 import java.time.ZoneId
 import java.time.ZonedDateTime
-import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicReference
 import java.util.function.Supplier
 import kotlin.time.Duration.Companion.minutes
@@ -31,25 +33,24 @@ import kotlin.time.Duration.Companion.minutes
 @Service(Service.Level.APP)
 class DigmathonService : Disposable {
 
-
     private val logger = Logger.getInstance(this::class.java)
 
     private val digmathonInfo = AtomicReference(
         DigmathonInfo(
-            LocalDate.of(2024, 4, 5).atStartOfDay().atZone(ZoneId.systemDefault()),
-            LocalDate.of(2024, 4, 17).atStartOfDay().atZone(ZoneId.systemDefault())
+            LocalDate.of(2024, 5, 1).atStartOfDay().atZone(ZoneId.systemDefault()),
+            LocalDate.of(2024, 5, 14).atStartOfDay().atZone(ZoneId.systemDefault())
         )
     )
 
-    private val isDigmathonActive = AtomicBoolean(digmathonInfo.get().isActive())
-
-    val viewedInsights = PersistenceService.getInstance().getDigmathonInsightsViewed()
-        ?.split(",")?.toMutableSet() ?: mutableSetOf()
+    val viewedInsights: MutableMap<String, Instant> = readInsightsViewedFromPersistence()
 
     var isUserFinishedDigmathon = PersistenceService.getInstance().isFinishDigmathonGameForUser()
 
 
     companion object {
+
+        private val objectMapper = createObjectMapperWithJavaTimeModule()
+
         @JvmStatic
         fun getInstance(): DigmathonService {
             return service<DigmathonService>()
@@ -64,27 +65,7 @@ class DigmathonService : Disposable {
 
     init {
 
-        //for development,simulate a 5 minutes event that starts 2 minutes after IDE start and lasts for 5 minutes
-//        val simulateStart = System.getProperty("org.digma.digmathon.simulate.startAfterMinutes")
-//        val simulatePeriod = System.getProperty("org.digma.digmathon.simulate.periodMinutes")
-//
-//        if (simulateStart != null) {
-//            val startAfter = simulateStart.toLong()
-//            val endAfter = (simulatePeriod.toLongOrNull() ?: 10) + startAfter
-//
-//            digmathonInfo.set(
-//                DigmathonInfo(
-//                    LocalDateTime.now().plusMinutes(startAfter).atZone(ZoneId.systemDefault()),
-//                    LocalDateTime.now().plusMinutes(endAfter).atZone(ZoneId.systemDefault())
-//                )
-//            )
-//            DigmathonProductKey().clear()
-//            isDigmathonActive.set(digmathonInfo.get().isActive())
-//            isUserFinishedDigmathon = false
-//        }
-
-
-        if (isDigmathonActive.get() && digmathonInfo.get().isEnded()) {
+        if (isDigmathonStartedForUser() && digmathonInfo.get().isEnded()) {
             end()
         } else {
 
@@ -97,11 +78,11 @@ class DigmathonService : Disposable {
                 while (isActive && digmathonInfo.get().isActive()) {
                     try {
 
-                        if (!isDigmathonActive.get() && digmathonInfo.get().isActive()) {
+                        if (!isDigmathonStartedForUser() && digmathonInfo.get().isActive()) {
                             start()
                         }
 
-                        if (isDigmathonActive.get() && digmathonInfo.get().isEnded()) {
+                        if (isDigmathonStartedForUser() && digmathonInfo.get().isEnded()) {
                             end()
                             cancel("digmathon ended")
                         }
@@ -116,23 +97,46 @@ class DigmathonService : Disposable {
                     }
                 }
 
-                if (digmathonInfo.get().isEnded()) {
+                //the job may be canceled by the system, do a last check
+                if (isDigmathonStartedForUser() && digmathonInfo.get().isEnded()) {
                     end()
                 }
             }
         }
     }
 
 
+    //this is needed so that we can call start and end only once
+    private fun isDigmathonStartedForUser(): Boolean {
+        return PersistenceService.getInstance().isDigmathonStartedForUser()
+    }
+
+    private fun markStartedDigmathonForUser() {
+        PersistenceService.getInstance().setDigmathonStartedForUser(true)
+    }
+
+    private fun markEndedDigmathonForUser() {
+        PersistenceService.getInstance().setDigmathonStartedForUser(false)
+    }
+
+
     private fun start() {
-        isDigmathonActive.set(true)
+        //reset persistence properties every time a new digmathon starts
+        PersistenceService.getInstance().setFinishDigmathonGameForUser(false)
+        PersistenceService.getInstance().setDigmathonInsightsViewed(null)
+        PersistenceService.getInstance().setDigmathonInsightsViewedLastUpdated(null)
+        markStartedDigmathonForUser()
         fireStateChangedEvent()
         reportEvent("start")
     }
 
 
     private fun end() {
-        isDigmathonActive.set(false)
+        //reset persistence properties for next time
+        PersistenceService.getInstance().setFinishDigmathonGameForUser(false)
+        PersistenceService.getInstance().setDigmathonInsightsViewed(null)
+        PersistenceService.getInstance().setDigmathonInsightsViewedLastUpdated(null)
+        markEndedDigmathonForUser()
         DigmathonProductKey().clear()
         fireStateChangedEvent()
         fireProductKeyStateChanged()
@@ -201,43 +205,62 @@ class DigmathonService : Disposable {
     }
 
 
-    data class DigmathonInfo(val startTime: ZonedDateTime, val endTime: ZonedDateTime) {
-
-        fun isActive(): Boolean {
-            val now = LocalDateTime.now().atZone(ZoneId.systemDefault())
-
-            return (now.equals(startTime) || now.isAfter(startTime)) &&
-                    now.isBefore(endTime)
-        }
-
-        fun isEnded(): Boolean {
-            return !isActive()
-        }
-    }
-
-
     private fun reportEvent(eventType: String, details: Map<String, String> = mapOf()) {
         findActiveProject()?.let {
             ActivityMonitor.getInstance(it).reportDigmathonEvent(eventType, details)
         }
     }
 
     fun addInsightsViewed(insightsTypesViewed: List<String>) {
-        if (digmathonInfo.get().isActive()) {
-            this.viewedInsights.addAll(insightsTypesViewed)
+        if (digmathonInfo.get().isActive() && !allInsightsExists(insightsTypesViewed)) {
+            //add only new insight types
+            insightsTypesViewed.forEach {
+                this.viewedInsights.computeIfAbsent(it) { Instant.now() }
+            }
             flushInsightsViewedToPersistence()
         }
     }
 
+    private fun allInsightsExists(insightsTypesViewed: List<String>): Boolean {
+        return this.viewedInsights.keys.containsAll(insightsTypesViewed)
+    }
+
+
     private fun flushInsightsViewedToPersistence() {
-        PersistenceService.getInstance().setDigmathonInsightsViewed(viewedInsights.joinToString(","))
+        try {
+            val json = objectMapper.writeValueAsString(viewedInsights)
+            PersistenceService.getInstance().setDigmathonInsightsViewed(json)
+        } catch (e: Throwable) {
+            ErrorReporter.getInstance().reportError("DigmathonService.flushInsightsViewedToPersistence", e)
+        }
+    }
+
+    private fun readInsightsViewedFromPersistence(): MutableMap<String, Instant> {
+        val json = PersistenceService.getInstance().getDigmathonInsightsViewed() ?: return mutableMapOf()
+        return try {
+            val ref = object : TypeReference<Map<String, Instant>>() {}
+            val viewedInsights = objectMapper.readValue(json, ref)
+            viewedInsights.toMutableMap()
+        } catch (e: Throwable) {
+            ErrorReporter.getInstance().reportError("DigmathonService.readInsightsViewedFromPersistence", e)
+            mutableMapOf()
+        }
+    }
+
+
+    fun getDigmathonInsightsViewedLastUpdated(): Instant? {
+        return PersistenceService.getInstance().getDigmathonInsightsViewedLastUpdated()
+    }
+
+    fun updateDigmathonInsightsViewedLastUpdated() {
+        PersistenceService.getInstance().setDigmathonInsightsViewedLastUpdated(Instant.now())
     }
 
     fun setFinishDigmathonGameForUser() {
-        PersistenceService.getInstance().setFinishDigmathonGameForUser()
+        PersistenceService.getInstance().setFinishDigmathonGameForUser(true)
         isUserFinishedDigmathon = true
         fireUserFinishedDigmathon()
-        reportEvent("user finished game")
+        reportEvent("user finished digmathon")
     }
 
 
@@ -246,4 +269,20 @@ class DigmathonService : Disposable {
             .userFinishedDigmathon()
     }
 
+
+    data class DigmathonInfo(val startTime: ZonedDateTime, val endTime: ZonedDateTime) {
+
+        fun isActive(): Boolean {
+            val now = LocalDateTime.now().atZone(ZoneId.systemDefault())
+
+            return (now.equals(startTime) || now.isAfter(startTime)) &&
+                    now.isBefore(endTime)
+        }
+
+        fun isEnded(): Boolean {
+            return !isActive()
+        }
+    }
+
+
 }

ide-common/src/main/kotlin/org/digma/intellij/plugin/persistence/PersistenceData.kt

@@ -91,6 +91,8 @@ internal data class PersistenceData(
 
     var isFinishDigmathonGameForUser: Boolean = false,
     var digmathonViewedInsights: String? = null,
+    @OptionTag(converter = InstantConverter::class)
+    var digmathonViewedInsightsLastUpdated: Instant? = null,
+    var digmathonStartedForUser: Boolean = false
 
-
-    )
+)

ide-common/src/main/kotlin/org/digma/intellij/plugin/persistence/PersistenceService.kt

@@ -300,20 +300,38 @@ class PersistenceService {
         return state.loadWarningAppearedTimestamp != null
     }
 
-    fun setFinishDigmathonGameForUser() {
-        state.isFinishDigmathonGameForUser = true
+    fun setFinishDigmathonGameForUser(isFinished: Boolean) {
+        state.isFinishDigmathonGameForUser = isFinished
     }
 
     fun isFinishDigmathonGameForUser(): Boolean {
         return state.isFinishDigmathonGameForUser
     }
 
-    fun setDigmathonInsightsViewed(insights: String) {
+    //nullable so it can be reset every time a new digmathon starts
+    fun setDigmathonInsightsViewed(insights: String?) {
         state.digmathonViewedInsights = insights
     }
 
     fun getDigmathonInsightsViewed(): String? {
         return state.digmathonViewedInsights
     }
 
+    fun setDigmathonInsightsViewedLastUpdated(instant: Instant?) {
+        state.digmathonViewedInsightsLastUpdated = instant
+    }
+
+    fun getDigmathonInsightsViewedLastUpdated(): Instant? {
+        return state.digmathonViewedInsightsLastUpdated
+    }
+
+    fun isDigmathonStartedForUser(): Boolean {
+        return state.digmathonStartedForUser
+    }
+
+    fun setDigmathonStartedForUser(started: Boolean) {
+        state.digmathonStartedForUser = started
+    }
+
+
 }

src/main/kotlin/org/digma/intellij/plugin/ui/insights/InsightsMessageRouterHandler.kt

@@ -87,7 +87,11 @@ class InsightsMessageRouterHandler(project: Project) : AbstractInsightsMessageRo
                 DigmathonService.getInstance().addInsightsViewed(insightTypeList.map { it.first })
                 //stop sending this message if user finished the digmathon
                 if (!DigmathonService.getInstance().isUserFinishedDigmathon) {
-                    RecentActivityService.getInstance(project).setDigmathonProgressData(DigmathonService.getInstance().viewedInsights)
+                    RecentActivityService.getInstance(project)
+                        .setDigmathonProgressData(
+                            DigmathonService.getInstance().viewedInsights,
+                            DigmathonService.getInstance().getDigmathonInsightsViewedLastUpdated()
+                        )
                 }
             }
         }