develop

.github/workflows/test-coverage.yml

@@ -17,6 +17,11 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
+
+      - name: Restore keys.properties
+        run: echo "$KEYS_FILE" | base64 -d > keys.properties
+        env:
+          KEYS_FILE: ${{ secrets.KEYS_FILE }}
 
       - name: Make gradlew executable
         run: chmod +x ./gradlew

.gitignore

@@ -1,6 +1,7 @@
 .gradle
 build/
 .idea
+.csv
 !gradle/wrapper/gradle-wrapper.jar
 !**/src/main/**/bauild/
 !**/src/test/**/build/
@@ -16,7 +17,8 @@ build/
 out/
 !**/src/main/**/out/
 !**/src/test/**/out/
-
+keys.properties
+local.properties
 ### Kotlin ###
 .kotlin
 

build.gradle.kts

@@ -1,5 +1,113 @@
+import org.gradle.declarative.dsl.schema.FqName.Empty.packageName
+import java.io.FileInputStream
+import java.util.*
+
 plugins {
-    kotlin("jvm") version "2.1.20"
+    kotlin("jvm") version "2.1.0"
+    id("com.github.gmazzo.buildconfig") version "4.1.2"
+    jacoco
+}
+val localProperties = Properties().apply {
+    val localFile = rootProject.file("Keys.properties")
+    if (localFile.exists()) {
+        FileInputStream(localFile).use { load(it) }
+    }
+}
+val mongoUri = localProperties.getProperty("MONGO.URI")
+val databaseName = localProperties.getProperty("DATABASE.NAME")
+
+buildConfig {
+    packageName("org.example")
+    buildConfigField("String", "MONGO_URI", "\"${mongoUri}\"")
+    buildConfigField("String", "DATABASE_NAME", "\"${databaseName}\"")
+    buildConfigField("String", "APP_VERSION", "\"${project.version}\"")
+}
+jacoco {
+    toolVersion = "0.8.7"
+}
+java {
+    toolchain {
+        languageVersion.set(JavaLanguageVersion.of(17))
+    }
+}
+tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
+    exclude("**/test/**") // Excludes all test packages
+    // or be more specific
+    // exclude("com/example/mypackage/test/**")
+}
+fun findTestedProductionClasses(): List<String> {
+    val testFiles = fileTree("src/test/kotlin") {
+        include("**/*Test.kt")
+    }.files
+    return testFiles.map { file ->
+        val relativePath = file.relativeTo(file("src/test/kotlin")).path
+            .removeSuffix("Test.kt")
+            .replace("\\", "/")
+        "**/${relativePath}.class"
+    }
+}
+tasks.test {
+    finalizedBy(tasks.jacocoTestReport)
+}
+tasks.jacocoTestReport {
+    dependsOn(tasks.test)
+    val includedClasses = findTestedProductionClasses()
+    classDirectories.setFrom(
+        fileTree("$buildDir/classes/kotlin/main") {
+            include(includedClasses)
+        }
+    )
+    sourceDirectories.setFrom(files("src/main/kotlin"))
+    doFirst {
+        println("=== INCLUDED PRODUCTION CLASSES ===")
+        includedClasses.forEach {
+            println(it)
+        }
+    }
+    reports {
+        html.required.set(true)
+        xml.required.set(true)
+    }
+}
+tasks.jacocoTestCoverageVerification {
+    dependsOn(tasks.jacocoTestReport)
+
+    // Use the same includedClasses for verification as in the report
+    val includedClasses = findTestedProductionClasses()
+
+    classDirectories.setFrom(
+        fileTree("$buildDir/classes/kotlin/main") {
+            include(includedClasses)
+        }
+    )
+    violationRules {
+        rule {
+            // Generic instruction coverage (default counter)
+            limit {
+                minimum = "0.8".toBigDecimal()
+            }
+
+            limit {
+                counter = "LINE"
+                value = "COVEREDRATIO"
+                minimum = "0.8".toBigDecimal()
+            }
+
+            limit {
+                counter = "METHOD"
+                value = "COVEREDRATIO"
+                minimum = "0.8".toBigDecimal()
+            }
+            limit {
+                counter = "CLASS"
+                value = "COVEREDRATIO"
+                minimum = "0.8".toBigDecimal()
+            }
+        }
+    }
+}
+tasks.check {
+    dependsOn(tasks.jacocoTestCoverageVerification)
 }
 
 group = "org.example"
@@ -11,11 +119,21 @@ repositories {
 
 dependencies {
     testImplementation(kotlin("test"))
+    implementation("io.insert-koin:koin-core:4.0.2")
+    testImplementation("org.junit.jupiter:junit-jupiter:5.10.2")
+    testImplementation("io.mockk:mockk:1.13.10")
+    testImplementation("com.google.truth:truth:1.4.2")
+    // MongoDB driver
+    implementation("org.mongodb:mongodb-driver-sync:4.9.1")
+
+    // Kotlin serialization for MongoDB (optional but helpful)
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.1")
 }
 
 tasks.test {
     useJUnitPlatform()
+    testLogging {
+        events ("passed", "skipped", "failed")
+        showStandardStreams = true
+    }
 }
-kotlin {
-    jvmToolchain(17)
-}

local.properties

@@ -0,0 +1,8 @@
+## This file must *NOT* be checked into Version Control Systems,
+# as it contains information specific to your local configuration.
+#
+# Location of the SDK. This is only used by Gradle.
+# For customization when using a Version Control System, please read the
+# header note.
+#Fri May 02 18:44:35 EEST 2025
+sdk.dir=C\:\\Users\\20180\\AppData\\Local\\Android\\Sdk

src/main/kotlin/Main.kt

@@ -1,5 +1,54 @@
 package org.example
 
+import com.mongodb.client.model.Filters
+import di.appModule
+import di.useCasesModule
+import org.bson.Document
+import org.example.di.dataModule
+import org.example.di.repositoryModule
+import data.datasource.mongo.MongoConfig
+import org.example.common.Constants.MongoCollections.USERS_COLLECTION
+import org.example.data.repository.UsersRepositoryImpl
+import org.example.domain.entity.User
+import org.example.presentation.AuthApp
+import org.koin.core.context.GlobalContext.startKoin
+import java.time.LocalDateTime
+import java.util.UUID
+
 fun main() {
     println("Hello, PlanMate!")
-}
+    startKoin { modules(appModule, useCasesModule, repositoryModule, dataModule) }
+    createAdminUser()
+    AuthApp().run()
+}
+
+fun createAdminUser() {
+    println("Creating admin user...")
+    try {
+        val collection = MongoConfig.database.getCollection(USERS_COLLECTION)
+
+        // Check if admin1 already exists
+        val existingAdmin = collection.find(Filters.eq("username", "mohannad")).first()
+        if (existingAdmin != null) {
+            println("Admin user already exists")
+            return
+        }
+
+        // Create a new admin user with string UUID
+        val adminId = UUID.randomUUID()
+        val adminDoc = Document()
+            .append("_id", adminId.toString())
+            .append("username", "mohannad")
+            .append("hashedPassword", UsersRepositoryImpl.encryptPassword("12345678"))
+            .append("role", User.UserRole.ADMIN.name)
+            .append("createdAt", LocalDateTime.now().toString())
+
+        collection.insertOne(adminDoc)
+        println("Created admin user: admin / 12345678")
+
+    } catch (e: Exception) {
+        println("Error creating admin: ${e.message}")
+        e.printStackTrace()
+    }
+}
+

src/main/kotlin/common/Constants.kt

@@ -0,0 +1,37 @@
+package org.example.common
+
+object Constants {
+    object APPS {
+        const val AUTH_APP = "AUTH_APP"
+        const val ADMIN_APP = "ADMIN_APP"
+        const val MATE_APP = "MATE_APP"
+    }
+
+    object Files {
+        const val PREFERENCES_FILE_NAME = "preferences.csv"
+        const val LOGS_FILE_NAME = "logs.csv"
+        const val PROJECTS_FILE_NAME = "projects.csv"
+        const val TASKS_FILE_NAME = "tasks.csv"
+        const val USERS_FILE_NAME = "users.csv"
+    }
+
+    object PreferenceKeys {
+        const val CURRENT_USER_ID = "CURRENT_USER_ID"
+        const val CURRENT_USER_NAME = "CURRENT_USER_NAME"
+        const val CURRENT_USER_ROLE = "CURRENT_USER_ROLE"
+    }
+
+    object MongoCollections {
+        const val LOGS_COLLECTION = "LOGS_COLLECTION"
+        const val TASKS_COLLECTION = "TASKS_COLLECTION"
+        const val PROJECTS_COLLECTION = "PROJECTS_COLLECTION"
+        const val USERS_COLLECTION = "USERS_COLLECTION"
+    }
+
+    object NamedDataSources {
+        const val LOGS_DATA_SOURCE = "LOGS_DATA_SOURCE"
+        const val TASKS_DATA_SOURCE = "TASKS_DATA_SOURCE"
+        const val PROJECTS_DATA_SOURCE = "PROJECTS_DATA_SOURCE"
+        const val USERS_DATA_SOURCE = "USERS_DATA_SOURCE"
+    }
+}

src/main/kotlin/data/datasource/DataSource.kt

@@ -0,0 +1,11 @@
+package data.datasource
+
+import java.util.UUID
+
+interface DataSource<T> {
+    fun getAll(): List<T>
+    fun getById(id: UUID): T
+    fun add(newItem: T)
+    fun delete(item: T)
+    fun update(updatedItem: T)
+}

src/main/kotlin/data/datasource/csv/CsvStorage.kt

@@ -0,0 +1,45 @@
+package data.datasource.csv
+
+import data.datasource.DataSource
+import java.io.File
+import java.io.FileNotFoundException
+
+abstract class CsvStorage<T>(val file: File) : DataSource<T> {
+    abstract fun toCsvRow(item: T): String
+    abstract fun fromCsvRow(fields: List<String>): T
+
+    override fun getAll(): List<T> {
+        if (!file.exists()) throw FileNotFoundException()
+        val lines = file.readLines()
+
+        if (lines.isEmpty() || lines[0] != getHeaderString().trim()) {
+            throw IllegalArgumentException("Invalid CSV format: missing or incorrect header")
+        }
+
+        return lines.drop(1)  // Skip header
+            .filter { it.isNotEmpty() }
+            .map { row -> fromCsvRow(row.split(",")) }
+    }
+
+    override fun add(newItem: T) {
+        if (!file.exists()) {
+            file.createNewFile()
+            file.writeText(getHeaderString())
+        }
+        file.appendText(toCsvRow(newItem))
+    }
+
+    fun write(items: List<T>) {
+        if (!file.exists()) {
+            file.createNewFile()
+            file.writeText(getHeaderString())
+        }
+        val str = StringBuilder()
+        items.forEach {
+            str.append(toCsvRow(it))
+        }
+        file.writeText(str.toString())
+    }
+
+    protected abstract fun getHeaderString(): String
+}