پاکسازی درخواست‌های مانده در سیستم DownloadManager هنگام اجرای برنامه

مجوز ارتباط Cleartext HTTP به آی‌پی جدید PocketBase در network_security_config
اصلاح سیستم دانلود به‌روزرسانی با Ktor و حل مشکل گیر کردن در ۰٪
2026-09-21 18:57:32 +03:30 · 2026-09-21 18:31:32 +03:30 · 2026-09-21 18:08:35 +03:30 · 2026-09-21 17:50:52 +03:30 · 2026-09-11 16:45:51 +03:30 · 2026-09-11 15:24:21 +03:30
23 changed files with 758 additions and 337 deletions
@@ -6,6 +6,18 @@
        <option name="selectionMode" value="DROPDOWN" />
        <DialogSelection />
      </SelectionState>
+      <SelectionState runConfigName="androidTest">
+        <option name="selectionMode" value="DROPDOWN" />
+        <DialogSelection />
+      </SelectionState>
+      <SelectionState runConfigName="main">
+        <option name="selectionMode" value="DROPDOWN" />
+        <DialogSelection />
+      </SelectionState>
+      <SelectionState runConfigName="unitTest">
+        <option name="selectionMode" value="DROPDOWN" />
+        <DialogSelection />
+      </SelectionState>
    </selectionStates>
  </component>
 </project>
@@ -30,8 +30,8 @@ android {
        applicationId = "com.oqba26.monthlypaymentapp"
        minSdk = 25
        targetSdk = 34
-        versionCode = 6
-        versionName = "1.0.5"
+        versionCode = 8
+        versionName = "1.0.7"
        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
        vectorDrawables { useSupportLibrary = true }
    }
@@ -55,8 +55,7 @@ android {

    buildTypes {
        debug {
-            buildConfigField("String", "SUPABASE_URL", "\"https://ftufsygeartwukonclkz.supabase.co\"")
-            buildConfigField("String", "SUPABASE_KEY", "\"sb_publishable_H4mAU1Ds-vZ22HwMSfCaBQ_QjBfmRd5\"")
+            buildConfigField("String", "POCKETBASE_URL", "\"http://194.146.68.50/\"")
        }
        release {
            val storeFileProp = getProp("RELEASE_STORE_FILE")
@@ -68,8 +67,7 @@ android {
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
-            buildConfigField("String", "SUPABASE_URL", "\"https://ftufsygeartwukonclkz.supabase.co\"")
-            buildConfigField("String", "SUPABASE_KEY", "\"sb_publishable_H4mAU1Ds-vZ22HwMSfCaBQ_QjBfmRd5\"")
+            buildConfigField("String", "POCKETBASE_URL", "\"http://194.146.68.50/\"")
        }
    }

@@ -111,10 +109,7 @@ dependencies {
    implementation("androidx.compose.material:material-icons-extended-android:1.6.7")
    implementation("org.burnoutcrew.composereorderable:reorderable:0.9.6")

-    // Supabase
-    implementation(libs.supabase.postgrest)
-    implementation(libs.supabase.auth)
-    implementation(libs.supabase.realtime)
+    // PocketBase / Ktor Network
    implementation(libs.ktor.client.okhttp)
    implementation(libs.ktor.client.content.negotiation)
    implementation(libs.ktor.serialization.kotlinx.json)
@@ -16,12 +16,12 @@
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.MonthlyPaymentApp"
+        android:usesCleartextTraffic="true"
        android:networkSecurityConfig="@xml/network_security_config">

        <activity
            android:name=".MainActivity"
            android:exported="true"
-            android:label="@string/app_name"
            android:theme="@style/Theme.MonthlyPaymentApp">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
@@ -1,10 +1,13 @@
@file:OptIn(ExperimentalMaterial3Api::class)
 package com.oqba26.monthlypaymentapp
 import android.Manifest
+import android.content.Intent
 import android.content.pm.PackageManager
 import android.os.Build
 import android.os.Bundle
+import android.provider.Settings
 import android.widget.Toast
+import androidx.core.net.toUri
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.BackHandler
 import androidx.activity.compose.rememberLauncherForActivityResult
@@ -96,6 +99,7 @@ import com.oqba26.monthlypaymentapp.ui.screens.PersonDetailScreen
 import com.oqba26.monthlypaymentapp.ui.screens.PersonScreen
 import com.oqba26.monthlypaymentapp.ui.screens.SettingsScreen
 import com.oqba26.monthlypaymentapp.ui.theme.MonthlyPaymentManagement2Theme
+import com.oqba26.monthlypaymentapp.utils.DownloadState
 import com.oqba26.monthlypaymentapp.utils.UpdateInfo
 import com.oqba26.monthlypaymentapp.utils.UpdateManager
 import com.oqba26.monthlypaymentapp.viewmodel.ContactViewModel
@@ -213,24 +217,41 @@ fun MainAppHost(viewModel: PersonViewModel) {
            updateInfo = info,
            onDismiss = { updateInfo = null },
            onConfirm = {
-                val id = updateManager.downloadAndInstall(info.url, "MonthlyPaymentApp_v${info.versionName}.apk")
-                if (id != -1L) {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && !context.packageManager.canRequestPackageInstalls()) {
+                    Toast.makeText(context, "لطفاً اجازه نصب برنامه‌های ناشناخته را بدهید", Toast.LENGTH_LONG).show()
+                    val intent = Intent(Settings.ACTION_MANAGE_UNKNOWN_APP_SOURCES).apply {
+                        data = "package:${context.packageName}".toUri()
+                        flags = Intent.FLAG_ACTIVITY_NEW_TASK
+                    }
+                    context.startActivity(intent)
+                    return@UpdateDialog
+                }
+
                isDownloading = true
+                downloadProgress = 0f
+                if (!info.isForceUpdate) {
+                    updateInfo = null
+                }
+
                scope.launch {
-                        updateManager.getDownloadProgress(id).collect { progress ->
-                            downloadProgress = progress
-                            if (progress >= 1f) {
+                    val fileName = "MonthlyPaymentApp_v${info.versionName}.apk"
+                    updateManager.downloadApk(info.url, fileName).collect { state ->
+                        when (state) {
+                            is DownloadState.Progress -> {
+                                downloadProgress = state.progress
+                            }
+                            is DownloadState.Success -> {
                                isDownloading = false
-                                if (!info.isForceUpdate) {
-                                    updateInfo = null
+                                updateManager.installApk(state.file)
+                            }
+                            is DownloadState.Error -> {
+                                isDownloading = false
+                                Toast.makeText(context, "خطا در دانلود: ${state.message}", Toast.LENGTH_LONG).show()
+                                updateManager.openInBrowser(info.url)
                            }
                        }
                    }
                }
-                    if (!info.isForceUpdate) {
-                        updateInfo = null
-                    }
-                }
            }
        )
    }
@@ -252,15 +273,23 @@ fun MainAppHost(viewModel: PersonViewModel) {
                            style = MaterialTheme.typography.titleLarge,
                            modifier = Modifier.padding(bottom = 16.dp)
                        )
+                        if (downloadProgress > 0f) {
                            LinearProgressIndicator(
                                progress = { downloadProgress },
                                modifier = Modifier.fillMaxWidth().height(8.dp),
                                color = MaterialTheme.colorScheme.primary,
                                trackColor = MaterialTheme.colorScheme.surfaceVariant,
                            )
+                        } else {
+                            LinearProgressIndicator(
+                                modifier = Modifier.fillMaxWidth().height(8.dp),
+                                color = MaterialTheme.colorScheme.primary,
+                                trackColor = MaterialTheme.colorScheme.surfaceVariant,
+                            )
+                        }
                        Spacer(modifier = Modifier.height(8.dp))
                        Text(
-                            text = "${(downloadProgress * 100).toInt()}%",
+                            text = if (downloadProgress > 0f) "${(downloadProgress * 100).toInt()}%" else "در حال اتصال...",
                            style = MaterialTheme.typography.bodyMedium
                        )
                    }
@@ -490,7 +519,7 @@ fun AuthenticatedContent(viewModel: PersonViewModel, contactViewModel: ContactVi
                )
            }
            composable(Screen.Archive.route) {
-                ArchiveScreen(viewModel)
+                ArchiveScreen(viewModel = viewModel, navController = navController)
            }
            composable(Screen.Settings.route) {
                val authViewModel: AuthViewModel = hiltViewModel()
@@ -20,8 +20,8 @@ object RepositoryModule {

    @Provides
    @Singleton
-    fun provideNetworkRepository(): NetworkRepository {
-        return NetworkRepository()
+    fun provideNetworkRepository(settingsRepository: SettingsRepository): NetworkRepository {
+        return NetworkRepository(settingsRepository)
    }

    @Provides
@@ -25,6 +25,9 @@ interface PaymentDao {
    @Query("DELETE FROM payments WHERE id = :paymentId")
    suspend fun deleteById(paymentId: String)

+    @Query("DELETE FROM payments WHERE personId = :personId")
+    suspend fun deletePaymentsForPerson(personId: String)
+
    /** حذف گروهی — برای اعمال [com.oqba26.monthlypaymentapp.data.sync.MergePlan] در یک کوئری. */
    @Query("DELETE FROM payments WHERE id IN (:ids)")
    suspend fun deleteByIds(ids: List<String>)
@@ -1,11 +1,13 @@
-@file:OptIn(kotlinx.serialization.InternalSerializationApi::class)
+@file:OptIn(InternalSerializationApi::class)

 package com.oqba26.monthlypaymentapp.data.model

 import androidx.room.Entity
 import androidx.room.PrimaryKey
+import kotlinx.serialization.InternalSerializationApi
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
+import kotlinx.serialization.Transient
 import java.util.UUID

@Serializable
@@ -24,12 +26,12 @@ data class PaymentRecord(
    
    @SerialName("timestamp") val timestamp: Long = System.currentTimeMillis(),
    
-    @SerialName("description") val description: String? = "", // ⭐️ تغییر به String? برای پذیرش مقادیر null
+    @SerialName("description") val description: String? = "",

    @SerialName("createdAt") val createdAt: Long? = null,

    @SerialName("category") val category: String = "salary",

-    @kotlinx.serialization.Transient
+    @Transient
    val needsSync: Boolean = false
 )
@@ -1,11 +1,13 @@
-@file:OptIn(kotlinx.serialization.InternalSerializationApi::class)
+@file:OptIn(InternalSerializationApi::class)

 package com.oqba26.monthlypaymentapp.data.model

 import androidx.room.Entity
 import androidx.room.PrimaryKey
+import kotlinx.serialization.InternalSerializationApi
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
+import kotlinx.serialization.Transient

@Serializable
@Entity(tableName = "persons")
@@ -33,6 +35,6 @@ data class Person(

    @SerialName("startYear") val startYear: Int = 1403,

-    @kotlinx.serialization.Transient
+    @Transient
    val needsSync: Boolean = false
 )
@@ -1,38 +1,10 @@
-@file:OptIn(io.github.jan.supabase.annotations.SupabaseInternal::class)
-
 package com.oqba26.monthlypaymentapp.data.remote

 import com.oqba26.monthlypaymentapp.BuildConfig
-import io.github.jan.supabase.createSupabaseClient
-import io.github.jan.supabase.gotrue.Auth
-import io.github.jan.supabase.postgrest.Postgrest
-import io.github.jan.supabase.realtime.Realtime
-import io.github.jan.supabase.serializer.KotlinXSerializer
-import io.ktor.client.plugins.HttpTimeout
-import kotlinx.serialization.json.Json

 object ApiClient {

-    val client = createSupabaseClient(
-        supabaseUrl = BuildConfig.SUPABASE_URL,
-        supabaseKey = BuildConfig.SUPABASE_KEY
-    ) {
-        defaultSerializer = KotlinXSerializer(Json {
-            ignoreUnknownKeys = true
-            isLenient = true
-            encodeDefaults = true
-        })
-
-        httpConfig {
-            install(HttpTimeout) {
-                requestTimeoutMillis = 60000
-                connectTimeoutMillis = 60000
-                socketTimeoutMillis = 60000
-            }
-        }
-
-        install(Postgrest)
-        install(Auth)
-        install(Realtime)
+    val pocketBase: PocketBaseClient by lazy {
+        PocketBaseClient(baseUrl = BuildConfig.POCKETBASE_URL)
    }
 }
@@ -0,0 +1,388 @@
+package com.oqba26.monthlypaymentapp.data.remote
+
+import android.util.Log
+import io.ktor.client.HttpClient
+import io.ktor.client.engine.okhttp.OkHttp
+import io.ktor.client.plugins.HttpTimeout
+import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
+import io.ktor.client.request.delete
+import io.ktor.client.request.get
+import io.ktor.client.request.header
+import io.ktor.client.request.parameter
+import io.ktor.client.request.patch
+import io.ktor.client.request.post
+import io.ktor.client.request.prepareGet
+import io.ktor.client.request.setBody
+import io.ktor.client.statement.bodyAsChannel
+import io.ktor.client.statement.bodyAsText
+import io.ktor.http.ContentType
+import io.ktor.http.HttpHeaders
+import io.ktor.http.contentType
+import io.ktor.http.isSuccess
+import io.ktor.serialization.kotlinx.json.json
+import io.ktor.utils.io.ByteReadChannel
+import io.ktor.utils.io.readUTF8Line
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import kotlin.time.Duration.Companion.seconds
+
+@Serializable
+data class PocketBaseListResponse<T>(
+    val page: Int = 1,
+    val perPage: Int = 500,
+    val totalPages: Int = 1,
+    val totalItems: Int = 0,
+    val items: List<T> = emptyList(),
+)
+
+@Serializable
+data class PocketBaseAuthResponse(
+    val token: String,
+    val record: JsonObject? = null,
+)
+
+@Serializable
+data class PocketBaseConnectEvent(
+    val clientId: String,
+)
+
+@Serializable
+data class PocketBaseSubscribeRequest(
+    val clientId: String,
+    val subscriptions: List<String>,
+)
+
+/**
+ * کلاینت اختصاصی جهت ارتباط با APIهای REST و سیستم ریل‌تایم (SSE) بک‌اند PocketBase
+ */
+class PocketBaseClient(
+    val baseUrl: String = POCKETBASE_DEFAULT_URL
+) {
+    companion object {
+        const val POCKETBASE_DEFAULT_URL = "http://194.146.68.50/"
+        @PublishedApi
+        internal const val TAG = "PocketBaseClient"
+    }
+
+    val json = Json {
+        ignoreUnknownKeys = true
+        isLenient = true
+        encodeDefaults = true
+        coerceInputValues = true
+    }
+
+    val httpClient = HttpClient(OkHttp) {
+        install(ContentNegotiation) {
+            json(json)
+        }
+        install(HttpTimeout) {
+            requestTimeoutMillis = 60000
+            connectTimeoutMillis = 60000
+            socketTimeoutMillis = 60000
+        }
+    }
+
+    @Volatile
+    var authToken: String? = null
+
+    /**
+     * ایجاد کاربر جدید در PocketBase
+     */
+    suspend fun createUser(
+        collection: String = "users",
+        email: String,
+        password: String
+    ): String? {
+        return try {
+            val cleanBaseUrl = baseUrl.trimEnd('/')
+            val url = "$cleanBaseUrl/api/collections/$collection/records"
+            val response = httpClient.post(url) {
+                contentType(ContentType.Application.Json)
+                setBody(
+                    mapOf(
+                        "email" to email,
+                        "password" to password,
+                        "passwordConfirm" to password
+                    )
+                )
+            }
+            if (!response.status.isSuccess()) {
+                val errorText = response.bodyAsText()
+                Log.e(TAG, "خطا در ساخت کاربر: $errorText")
+                return null
+            }
+            val jsonText = response.bodyAsText()
+            val parsed = json.parseToJsonElement(jsonText).jsonObject
+            parsed["id"]?.jsonPrimitive?.content
+        } catch (e: Exception) {
+            Log.e(TAG, "خطا در ایجاد کاربر", e)
+            null
+        }
+    }
+
+    /**
+     * احراز هویت با نام کاربری/ایمیل و رمز عبور
+     */
+    suspend fun authWithPassword(
+        collection: String = "users",
+        identity: String,
+        password: String
+    ): PocketBaseAuthResponse {
+        val cleanBaseUrl = baseUrl.trimEnd('/')
+        val url = "$cleanBaseUrl/api/collections/$collection/auth-with-password"
+        val response = httpClient.post(url) {
+            contentType(ContentType.Application.Json)
+            setBody(mapOf("identity" to identity, "password" to password))
+        }
+
+        if (!response.status.isSuccess()) {
+            val errorText = response.bodyAsText()
+            throw RuntimeException("خطا در احراز هویت PocketBase: $errorText")
+        }
+
+        val authResp = response.bodyAsText()
+        val parsed = json.decodeFromString<PocketBaseAuthResponse>(authResp)
+        authToken = parsed.token
+        return parsed
+    }
+
+    /**
+     * دریافت لیست رکوردها از یک کالکشن
+     */
+    suspend inline fun <reified T> getRecords(
+        collectionName: String,
+        page: Int = 1,
+        perPage: Int = 500,
+        filter: String? = null,
+        sort: String? = null
+    ): List<T> {
+        val cleanBaseUrl = baseUrl.trimEnd('/')
+        val response = httpClient.get("$cleanBaseUrl/api/collections/$collectionName/records") {
+            parameter("page", page)
+            parameter("perPage", perPage)
+            if (!filter.isNullOrEmpty()) {
+                parameter("filter", filter)
+            }
+            if (!sort.isNullOrEmpty()) {
+                parameter("sort", sort)
+            }
+            authToken?.let { token ->
+                header(HttpHeaders.Authorization, "Bearer $token")
+            }
+        }
+
+        if (!response.status.isSuccess()) {
+            val errorText = response.bodyAsText()
+            Log.e(TAG, "خطا در دریافت $collectionName: $errorText")
+            return emptyList()
+        }
+
+        val bodyText = response.bodyAsText()
+        val listResp = json.decodeFromString<PocketBaseListResponse<T>>(bodyText)
+        return listResp.items
+    }
+
+    /**
+     * ایجاد رکورد جدید در PocketBase
+     */
+    suspend inline fun <reified T> createRecord(
+        collectionName: String,
+        body: T
+    ): T {
+        val cleanBaseUrl = baseUrl.trimEnd('/')
+        val url = "$cleanBaseUrl/api/collections/$collectionName/records"
+        val response = httpClient.post(url) {
+            contentType(ContentType.Application.Json)
+            authToken?.let { token ->
+                header(HttpHeaders.Authorization, "Bearer $token")
+            }
+            setBody(body)
+        }
+
+        if (!response.status.isSuccess()) {
+            val errorText = response.bodyAsText()
+            throw RuntimeException("خطا در ثبت رکورد $collectionName: $errorText")
+        }
+
+        val respText = response.bodyAsText()
+        return json.decodeFromString<T>(respText)
+    }
+
+    /**
+     * بروزرسانی رکورد بر اساس آی‌دی PocketBase
+     */
+    suspend inline fun <reified T> updateRecord(
+        collectionName: String,
+        pbRecordId: String,
+        body: T
+    ): T {
+        val cleanBaseUrl = baseUrl.trimEnd('/')
+        val url = "$cleanBaseUrl/api/collections/$collectionName/records/$pbRecordId"
+        val response = httpClient.patch(url) {
+            contentType(ContentType.Application.Json)
+            authToken?.let { token ->
+                header(HttpHeaders.Authorization, "Bearer $token")
+            }
+            setBody(body)
+        }
+
+        if (!response.status.isSuccess()) {
+            val errorText = response.bodyAsText()
+            throw RuntimeException("خطا در ویرایش رکورد $collectionName ($pbRecordId): $errorText")
+        }
+
+        val respText = response.bodyAsText()
+        return json.decodeFromString<T>(respText)
+    }
+
+    /**
+     * حذف رکورد
+     */
+    suspend fun deleteRecord(
+        collectionName: String,
+        pbRecordId: String
+    ): Boolean {
+        val cleanBaseUrl = baseUrl.trimEnd('/')
+        val url = "$cleanBaseUrl/api/collections/$collectionName/records/$pbRecordId"
+        val response = httpClient.delete(url) {
+            authToken?.let { token ->
+                header(HttpHeaders.Authorization, "Bearer $token")
+            }
+        }
+        return response.status.isSuccess()
+    }
+
+    /**
+     * حذف رکورد بر اساس فیلتر
+     */
+    suspend fun deleteRecordByFilter(
+        collectionName: String,
+        filterQuery: String
+    ): Boolean {
+        return try {
+            val cleanBaseUrl = baseUrl.trimEnd('/')
+            val searchResp = httpClient.get("$cleanBaseUrl/api/collections/$collectionName/records") {
+                parameter("filter", filterQuery)
+                authToken?.let { token ->
+                    header(HttpHeaders.Authorization, "Bearer $token")
+                }
+            }
+
+            if (searchResp.status.isSuccess()) {
+                val jsonText = searchResp.bodyAsText()
+                val parsed = json.parseToJsonElement(jsonText).jsonObject
+                val items = parsed["items"]?.jsonArray
+                if (!items.isNullOrEmpty()) {
+                    items.forEach { item ->
+                        val pbId = item.jsonObject["id"]?.jsonPrimitive?.content
+                        if (pbId != null) {
+                            deleteRecord(collectionName, pbId)
+                        }
+                    }
+                    return true
+                }
+            }
+            false
+        } catch (e: Exception) {
+            Log.e(TAG, "خطا در حذف رکورد برای $collectionName ($filterQuery)", e)
+            false
+        }
+    }
+
+    /**
+     * آپسرت رکورد (اگر بر اساس فیلتر وجود داشت ویرایش می‌شود وگرنه ایجاد می‌شود)
+     */
+    suspend inline fun <reified T> upsertRecord(
+        collectionName: String,
+        filterQuery: String,
+        body: T
+    ) {
+        try {
+            val cleanBaseUrl = baseUrl.trimEnd('/')
+            val searchResp = httpClient.get("$cleanBaseUrl/api/collections/$collectionName/records") {
+                parameter("filter", filterQuery)
+                authToken?.let { token ->
+                    header(HttpHeaders.Authorization, "Bearer $token")
+                }
+            }
+
+            var existingPbId: String? = null
+            if (searchResp.status.isSuccess()) {
+                val jsonText = searchResp.bodyAsText()
+                val parsed = json.parseToJsonElement(jsonText).jsonObject
+                val items = parsed["items"]?.jsonArray
+                if (!items.isNullOrEmpty()) {
+                    val firstItem = items[0].jsonObject
+                    existingPbId = firstItem["id"]?.jsonPrimitive?.content
+                }
+            }
+
+            if (existingPbId != null) {
+                updateRecord(collectionName, existingPbId, body)
+            } else {
+                createRecord(collectionName, body)
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "خطا در upsert برای $collectionName ($filterQuery)", e)
+            throw e
+        }
+    }
+
+    /**
+     * اتصال ریل‌تایم SSE
+     */
+    fun listenRealtime(subscriptions: List<String>): Flow<String> = flow {
+        val cleanBaseUrl = baseUrl.trimEnd('/')
+        while (true) {
+            try {
+                httpClient.prepareGet("$cleanBaseUrl/api/realtime") {
+                    header("Accept", "text/event-stream")
+                    authToken?.let { token ->
+                        header(HttpHeaders.Authorization, "Bearer $token")
+                    }
+                }.execute { response ->
+                    val channel: ByteReadChannel = response.bodyAsChannel()
+                    var currentEvent = ""
+
+                    while (!channel.isClosedForRead) {
+                        val line = channel.readUTF8Line() ?: break
+                        val trimmed = line.trim()
+                        if (trimmed.startsWith("event:")) {
+                            currentEvent = trimmed.substringAfter("event:").trim()
+                        } else if (trimmed.startsWith("data:")) {
+                            val dataJson = trimmed.substringAfter("data:").trim()
+                            if (currentEvent == "PB_CONNECT") {
+                                val connectObj = json.decodeFromString<PocketBaseConnectEvent>(dataJson)
+                                subscribeRealtime(cleanBaseUrl, connectObj.clientId, subscriptions)
+                                Log.d(TAG, "اتصال ریل‌تایم برقرار شد. ClientId: ${connectObj.clientId}")
+                            } else if (currentEvent.isNotEmpty()) {
+                                emit(currentEvent)
+                            }
+                        }
+                    }
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "خطا در ریل‌تایم PocketBase، تلاش مجدد...", e)
+            }
+            delay(3.seconds)
+        }
+    }
+
+    private suspend fun subscribeRealtime(cleanBaseUrl: String, clientId: String, subscriptions: List<String>) {
+        val url = "$cleanBaseUrl/api/realtime"
+        httpClient.post(url) {
+            contentType(ContentType.Application.Json)
+            authToken?.let { token ->
+                header(HttpHeaders.Authorization, "Bearer $token")
+            }
+            setBody(PocketBaseSubscribeRequest(clientId = clientId, subscriptions = subscriptions))
+        }
+    }
+}
@@ -53,12 +53,24 @@ class LocalPersonRepository(
            val personPlan = SyncMerger.planPersons(localPersons, persons, pendingIds)
            val paymentPlan = SyncMerger.planPayments(localPayments, payments, pendingIds)

-            // پرداخت‌ها اول حذف می‌شوند تا اگر کلید خارجی اضافه شد، ترتیب درست باشد.
-            if (paymentPlan.deleteIds.isNotEmpty()) paymentDao.deleteByIds(paymentPlan.deleteIds)
-            if (personPlan.deleteIds.isNotEmpty()) personDao.deleteByIds(personPlan.deleteIds)
-
            if (personPlan.upserts.isNotEmpty()) personDao.insertAll(personPlan.upserts)
            if (paymentPlan.upserts.isNotEmpty()) paymentDao.insertAllPaymentRecords(paymentPlan.upserts)
+
+            // خودترمیمی: اگر رکوردهایی در دیتابیس محلی هستند که در سرور وجود ندارند و در صف هم نیستند،
+            // آن‌ها را دوباره برای ارسال به سرور ثبت می‌کنیم تا سرور و کلاینت همگام شوند.
+            val serverPersonIds = persons.map { it.id }.toSet()
+            val missingPersons = localPersons.filter { it.id !in serverPersonIds && it.id !in pendingIds }
+            for (p in missingPersons) {
+                personDao.insertAll(listOf(p.copy(needsSync = true)))
+                syncQueueDao.insert(SyncQueue(entityId = p.id, type = SyncType.PERSON, operation = SyncOperation.INSERT))
+            }
+
+            val serverPaymentIds = payments.map { it.id }.toSet()
+            val missingPayments = localPayments.filter { it.id !in serverPaymentIds && it.id !in pendingIds }
+            for (p in missingPayments) {
+                paymentDao.insertAllPaymentRecords(listOf(p.copy(needsSync = true)))
+                syncQueueDao.insert(SyncQueue(entityId = p.id, type = SyncType.PAYMENT, operation = SyncOperation.INSERT))
+            }
        }
    }

@@ -135,6 +147,7 @@ class LocalPersonRepository(
    suspend fun deletePersonLocally(personId: String) {
        database.withTransaction {
            personDao.deleteById(personId)
+            paymentDao.deletePaymentsForPerson(personId)
            syncQueueDao.insert(SyncQueue(entityId = personId, type = SyncType.PERSON, operation = SyncOperation.DELETE))
        }
    }
@@ -6,72 +6,50 @@ import com.oqba26.monthlypaymentapp.data.model.AuthResponse
 import com.oqba26.monthlypaymentapp.data.model.PaymentRecord
 import com.oqba26.monthlypaymentapp.data.model.Person
 import com.oqba26.monthlypaymentapp.data.remote.ApiClient
-import io.github.jan.supabase.gotrue.auth
-import io.github.jan.supabase.gotrue.providers.builtin.Email
-import io.github.jan.supabase.postgrest.from
-import io.github.jan.supabase.postgrest.query.Order
-import io.github.jan.supabase.realtime.PostgresAction
-import io.github.jan.supabase.realtime.channel
-import io.github.jan.supabase.realtime.postgresChangeFlow
-import io.github.jan.supabase.realtime.realtime
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.launch
-import kotlinx.serialization.json.buildJsonObject
-import kotlinx.serialization.json.put
 import java.util.UUID

-class NetworkRepository {
+class NetworkRepository(
+    private val settingsRepository: SettingsRepository? = null
+) {

-    private val supabase = ApiClient.client
+    private val pocketBase = ApiClient.pocketBase
    private val _personsFlow = MutableStateFlow<List<Person>>(emptyList())
    private val _paymentsFlow = MutableStateFlow<List<PaymentRecord>>(emptyList())
    private val repositoryScope = CoroutineScope(Dispatchers.IO)

    /**
     * تا وقتی حداقل یک [refresh] موفق انجام نشده باشد `false` است.
-     *
-     * چرا لازم است: مقدار اولیه‌ی `_personsFlow`/`_paymentsFlow` لیست خالی است و از لیست خالیِ
-     * واقعی (کاربری که هنوز داده‌ای ثبت نکرده) قابل تشخیص نیست. merge کردن روی آن لیست خالیِ
-     * قالبی، همه‌ی داده‌ی محلی را پاک می‌کند. مصرف‌کننده باید منتظر `true` بماند.
     */
    private val _hasServerData = MutableStateFlow(false)
    fun hasServerDataFlow(): Flow<Boolean> = _hasServerData.asStateFlow()

+    init {
+        settingsRepository?.authTokenFlow?.let { authFlow ->
+            repositoryScope.launch {
+                authFlow.collect { token ->
+                    pocketBase.authToken = token
+                }
+            }
+        }
+    }
+
    // --- Realtime Operations ---
    fun observeRealtimeChanges() {
        repositoryScope.launch {
            try {
-                // اطمینان از اتصال قبل از اشتراک در کانال
-                supabase.realtime.connect()
-                
-                val myChannel = supabase.channel("db-changes")
-                
-                // گوش دادن به تغییرات جدول اشخاص
-                myChannel.postgresChangeFlow<PostgresAction>(schema = "public") {
-                    table = "persons"
-                }.collect {
-                    Log.d("Supabase-Realtime", "Change detected in persons table")
+                pocketBase.listenRealtime(listOf("persons", "payments")).collect { event ->
+                    Log.d("PocketBase-Realtime", "Change detected in PocketBase: $event")
                    refresh()
                }
-
-                // گوش دادن به تغییرات جدول پرداخت‌ها
-                launch {
-                    myChannel.postgresChangeFlow<PostgresAction>(schema = "public") {
-                        table = "payments"
-                    }.collect {
-                        Log.d("Supabase-Realtime", "Change detected in payments table")
-                        refresh()
-                    }
-                }
-                
-                myChannel.subscribe()
-                Log.d("Supabase-Realtime", "Subscribed to all changes")
            } catch (e: Exception) {
-                Log.e("Supabase-Realtime", "Realtime connection error, retrying...", e)
+                Log.e("PocketBase-Realtime", "Realtime connection error, retrying...", e)
            }
        }
    }
@@ -79,49 +57,33 @@ class NetworkRepository {
    // --- Auth Operations ---
    suspend fun register(request: AuthRequest): AuthResponse? {
        return try {
-            supabase.auth.signUpWith(Email) {
-                email = request.email
-                password = request.password
-            }
-            val session = supabase.auth.currentSessionOrNull()
-            AuthResponse(token = session?.accessToken ?: "success", userId = session?.user?.id)
+            pocketBase.createUser("users", request.email, request.password)
+            val authResp = pocketBase.authWithPassword("users", request.email, request.password)
+            val userId = authResp.record?.get("id")?.toString()?.replace("\"", "")
+            AuthResponse(token = authResp.token, userId = userId)
        } catch (e: Exception) {
-            Log.e("Supabase", "register error", e)
+            Log.e("PocketBase", "register error", e)
            null
        }
    }

    suspend fun login(request: AuthRequest): AuthResponse? {
        return try {
-            supabase.auth.signInWith(Email) {
-                email = request.email
-                password = request.password
-            }
-            val session = supabase.auth.currentSessionOrNull()
-            AuthResponse(token = session?.accessToken ?: "", userId = session?.user?.id)
+            val authResp = pocketBase.authWithPassword("users", request.email, request.password)
+            val userId = authResp.record?.get("id")?.toString()?.replace("\"", "")
+            AuthResponse(token = authResp.token, userId = userId)
        } catch (e: Exception) {
-            Log.e("Supabase", "login error", e)
+            Log.e("PocketBase", "login error", e)
            null
        }
    }

    // --- Person Operations ---
-    /**
-     * ارسال شخص به سرور با upsert.
-     *
-     * upsert (و نه insert) عمداً انتخاب شده تا این عملیات idempotent باشد: اگر تلاش اول
-     * به سرور رسیده باشد ولی پاسخش به‌خاطر timeout به ما نرسیده باشد، تلاش دوم رکورد
-     * تکراری نمی‌سازد. صف سینک متکی به همین خاصیت است تا بتواند بی‌خطر retry کند.
-     *
-     * اعتبارسنجی تکراری‌بودن نام اینجا انجام نمی‌شود؛ آن کار در PersonViewModel روی
-     * داده‌ی محلی (که همیشه کامل است) انجام می‌گیرد. کش _personsFlow ممکن است خالی یا
-     * قدیمی باشد و نتیجه‌ی غلط بدهد.
-     */
    suspend fun addPerson(person: Person): Boolean {
        return try {
            val trimmedName = person.name.trim()
            if (trimmedName.isEmpty()) {
-                Log.w("Supabase", "addPerson skipped: blank name")
+                Log.w("PocketBase", "addPerson skipped: blank name")
                return false
            }

@@ -131,22 +93,22 @@ class NetworkRepository {
                person.copy(name = trimmedName)
            }

-            supabase.from("persons").upsert(personToUpsert)
+            pocketBase.upsertRecord("persons", "id='${personToUpsert.id}'", personToUpsert)
            true
        } catch (e: Exception) {
-            Log.e("Supabase", "addPerson error", e)
+            Log.e("PocketBase", "addPerson error", e)
            false
        }
    }

    suspend fun deletePersonAndPayments(personId: String): Boolean {
        return try {
-            supabase.from("persons").delete {
-                filter { eq("id", personId) }
-            }
+            pocketBase.deleteRecordByFilter("payments", "personId='$personId'")
+            pocketBase.deleteRecordByFilter("persons", "id='$personId'")
            true
        } catch (e: Exception) {
-            Log.e("Supabase", "deletePerson error", e); false
+            Log.e("PocketBase", "deletePerson error", e)
+            false
        }
    }

@@ -173,68 +135,59 @@ class NetworkRepository {
            }
            if (isDuplicate) return 409

-            supabase.from("persons").update(
-                buildJsonObject {
-                    put("name", trimmedName)
-                    put("phoneNumber", phoneNumber?.trim())
-                    put("monthlyCommitment", monthlyCommitment)
-                    put("startMonth", startMonth)
-                    put("startYear", startYear)
-                },
-            ) {
-                filter { eq("id", personId) }
+            val updatedPerson = currentPerson?.copy(
+                name = trimmedName,
+                phoneNumber = phoneNumber?.trim(),
+                monthlyCommitment = monthlyCommitment,
+                startMonth = startMonth,
+                startYear = startYear
+            )
+            if (updatedPerson != null) {
+                pocketBase.upsertRecord("persons", "id='$personId'", updatedPerson)
            }
            200
        } catch (e: Exception) {
-            Log.e("Supabase", "updatePerson error", e)
+            Log.e("PocketBase", "updatePerson error", e)
            500
        }
    }

    suspend fun updatePersonArchivedStatus(personId: String, isArchived: Boolean): Boolean {
        return try {
-            supabase.from("persons").update(
-                buildJsonObject {
-                    put("isArchived", isArchived)
-                }
-            ) {
-                filter { eq("id", personId) }
+            val currentPerson = _personsFlow.value.find { it.id == personId }
+            if (currentPerson != null) {
+                pocketBase.upsertRecord("persons", "id='$personId'", currentPerson.copy(isArchived = isArchived))
            }
            true
        } catch (e: Exception) {
-            Log.e("Supabase", "updateArchived error", e); false
+            Log.e("PocketBase", "updateArchived error", e)
+            false
        }
    }

    suspend fun updatePersonDisplayOrder(personId: String, displayOrder: Long): Boolean {
        return try {
-            supabase.from("persons").update(
-                buildJsonObject {
-                    put("displayOrder", displayOrder)
-                }
-            ) {
-                filter { eq("id", personId) }
+            val currentPerson = _personsFlow.value.find { it.id == personId }
+            if (currentPerson != null) {
+                pocketBase.upsertRecord("persons", "id='$personId'", currentPerson.copy(displayOrder = displayOrder))
            }
            true
        } catch (e: Exception) {
-            Log.e("Supabase", "updateOrder error", e); false
+            Log.e("PocketBase", "updateOrder error", e)
+            false
        }
    }

    fun getPersonsFlow(): Flow<List<Person>> = _personsFlow.asStateFlow()

    // --- Payment Operations ---
-    /**
-     * ارسال پرداخت به سرور با upsert — به همان دلیل idempotent بودن که در [addPerson] توضیح داده شد.
-     * ضمناً همین باعث می‌شود ویرایش پرداخت (SyncOperation.UPDATE) هم درست کار کند؛ قبلاً insert
-     * بود و روی رکورد موجود شکست می‌خورد.
-     */
    suspend fun addPayment(paymentRecord: PaymentRecord): Boolean {
        return try {
-            supabase.from("payments").upsert(paymentRecord)
+            pocketBase.upsertRecord("payments", "id='${paymentRecord.id}'", paymentRecord)
            true
        } catch (e: Exception) {
-            Log.e("Supabase", "addPayment error", e); false
+            Log.e("PocketBase", "addPayment error", e)
+            false
        }
    }

@@ -244,16 +197,14 @@ class NetworkRepository {
        
        while (retries <= maxRetries) {
            try {
-                supabase.from("payments").delete {
-                    filter { eq("id", paymentId) }
-                }
-                Log.d("Supabase", "deletePayment Success: $paymentId")
+                pocketBase.deleteRecordByFilter("payments", "id='$paymentId'")
+                Log.d("PocketBase", "deletePayment Success: $paymentId")
                return true
            } catch (e: Exception) {
                retries++
-                Log.e("Supabase", "deletePayment error (Attempt $retries): ${e.message}", e)
+                Log.e("PocketBase", "deletePayment error (Attempt $retries): ${e.message}", e)
                if (retries > maxRetries) return false
-                kotlinx.coroutines.delay(1000L * retries) // Exponential backoff-ish
+                delay(1000L * retries)
            }
        }
        return false
@@ -263,31 +214,20 @@ class NetworkRepository {

    /**
     * واکشی کامل داده‌ها از سرور.
-     *
-     * @return true فقط اگر **هر دو** واکشی موفق بوده باشند.
-     *
-     * دو تضمین مهم که فراخوان‌ها به آن تکیه می‌کنند:
-     *  ۱. در صورت شکست، flow‌ها **دست‌نخورده** می‌مانند. قبلاً خطا بلعیده می‌شد و صدازننده
-     *     نمی‌فهمید واکشی شکست خورده؛ نتیجه‌اش merge روی داده‌ی ناقص و پاک شدن داده‌ی محلی بود.
-     *  ۲. مقداردهی flow‌ها اتمیک است — یا هر دو با هم به‌روز می‌شوند یا هیچ‌کدام. قبلاً اگر
-     *     واکشی پرداخت‌ها شکست می‌خورد، لیست اشخاص جدید کنار لیست پرداخت‌های قدیمی می‌نشست.
     */
    suspend fun refresh(): Boolean {
        return try {
-            val persons = supabase.from("persons").select().decodeList<Person>()
-            val payments = supabase.from("payments").select {
-                order("timestamp", order = Order.DESCENDING)
-            }.decodeList<PaymentRecord>()
+            val persons = pocketBase.getRecords<Person>("persons")
+            val payments = pocketBase.getRecords<PaymentRecord>("payments", sort = "-timestamp")

-            // فقط بعد از موفقیت هر دو واکشی مقداردهی می‌کنیم
            _personsFlow.value = persons
            _paymentsFlow.value = payments
            _hasServerData.value = true

-            Log.d("Supabase", "Refresh Success: ${persons.size} persons, ${payments.size} payments")
+            Log.d("PocketBase", "Refresh Success: ${persons.size} persons, ${payments.size} payments")
            true
        } catch (e: Exception) {
-            Log.e("Supabase", "refresh error — داده‌های محلی دست‌نخورده باقی می‌مانند", e)
+            Log.e("PocketBase", "refresh error", e)
            false
        }
    }
@@ -75,13 +75,9 @@ object SyncMerger {
            person.copy(id = resolvedId, name = name, needsSync = false)
        }

-        val serverIds = resolved.map { it.id }.toSet()
-
        return MergePlan(
            upserts = resolved.filterNot { it.id in protectedIds },
-            deleteIds = local
-                .map { it.id }
-                .filterNot { it in serverIds || it in protectedIds }
+            deleteIds = emptyList() // هرگز رکوردهای محلی را به خاطر غیبت در سرور حذف نمی‌کنیم
        )
    }

@@ -91,15 +87,12 @@ object SyncMerger {
        pendingIds: Set<String>
    ): MergePlan<PaymentRecord> {
        val protectedIds = protectedPaymentIds(local, pendingIds)
-        val serverIds = server.map { it.id }.toSet()

        return MergePlan(
            upserts = server
                .filterNot { it.id in protectedIds }
                .map { it.copy(needsSync = false) },
-            deleteIds = local
-                .map { it.id }
-                .filterNot { it in serverIds || it in protectedIds }
+            deleteIds = emptyList() // هرگز رکوردهای محلی را به خاطر غیبت در سرور حذف نمی‌کنیم
        )
    }
 }
@@ -1,5 +1,6 @@
 package com.oqba26.monthlypaymentapp.ui.screens

+import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
@@ -38,12 +39,13 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.window.Dialog
+import androidx.navigation.NavController
 import com.oqba26.monthlypaymentapp.viewmodel.PersonScreenEvent
 import com.oqba26.monthlypaymentapp.viewmodel.PersonUiModel
 import com.oqba26.monthlypaymentapp.viewmodel.PersonViewModel

@Composable
-fun ArchiveScreen(viewModel: PersonViewModel) {
+fun ArchiveScreen(viewModel: PersonViewModel, navController: NavController) {
    val uiState by viewModel.uiState.collectAsState()
    var personToDelete by remember { mutableStateOf<PersonUiModel?>(null) }
    var personToRestore by remember { mutableStateOf<PersonUiModel?>(null) }
@@ -63,6 +65,9 @@ fun ArchiveScreen(viewModel: PersonViewModel) {
            items(uiState.archivedPersons, key = { it.id }) { person ->
                ArchivedPersonListItem(
                    person = person,
+                    onPersonClick = {
+                        navController.navigate("person_detail/${person.id}")
+                    },
                    onRestore = {
                        personToRestore = person
                    },
@@ -148,12 +153,14 @@ fun ArchiveScreen(viewModel: PersonViewModel) {
@Composable
 fun ArchivedPersonListItem(
    person: PersonUiModel,
+    onPersonClick: () -> Unit,
    onRestore: () -> Unit,
    onDelete: () -> Unit
 ) {
    Row(
        modifier = Modifier
            .fillMaxWidth()
+            .clickable(onClick = onPersonClick)
            .padding(horizontal = 16.dp, vertical = 12.dp),
        verticalAlignment = Alignment.CenterVertically,
        horizontalArrangement = Arrangement.SpaceBetween
@@ -25,6 +25,7 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.ArrowBack
 import androidx.compose.material.icons.filled.ChevronLeft
 import androidx.compose.material.icons.filled.ChevronRight
+import androidx.compose.material.icons.filled.Delete
 import androidx.compose.material.icons.filled.Edit
 import androidx.compose.material.icons.filled.Search
 import androidx.compose.material3.Button
@@ -43,7 +44,6 @@ import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.RadioButton
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
@@ -128,7 +128,6 @@ fun PersonDetailScreen(
                items(detailState.monthStates) { monthModel ->
                    MonthListItem(
                        month = monthModel,
-                        personName = detailState.person?.name ?: "",
                        startMonth = detailState.person?.startMonth ?: 1,
                        onHeaderClick = {
                            expandedMonth = if (expandedMonth == monthModel.month) null else monthModel.month
@@ -207,12 +206,18 @@ fun PersonDetailScreen(
            initialPhone = detailState.person?.phoneNumber,
            initialCommitment = detailState.person?.monthlyCommitment ?: 0.0,
            initialStartMonth = detailState.person?.startMonth ?: 1,
-            initialStartYear = detailState.person?.startYear ?: com.oqba26.monthlypaymentapp.utils.getCurrentShamsiYear(),
+            initialStartYear = detailState.person?.startYear ?: getCurrentShamsiYear(),
+            initialIsAnonymous = detailState.person?.isAnonymous ?: false,
            isMosqueCategory = currentCategory == "mosque",
-            onConfirm = { name, phone, commitment, month, year ->
-                viewModel.onEvent(PersonScreenEvent.UpdatePerson(personId, name, phone, commitment, month, year))
+            onConfirm = { name, phone, commitment, month, year, isAnon ->
+                viewModel.onEvent(PersonScreenEvent.UpdatePerson(personId, name, phone, commitment, month, year, isAnon))
                editingPerson = false
            },
+            onDelete = {
+                viewModel.onEvent(PersonScreenEvent.DeletePerson(personId))
+                editingPerson = false
+                navController.popBackStack()
+            },
            onDismiss = { editingPerson = false },
            onSearchContact = { name ->
                contactViewModel.findSimilarContacts(name)
@@ -256,16 +261,20 @@ fun UpdatePersonDialog(
    initialCommitment: Double = 0.0,
    initialStartMonth: Int = 1,
    initialStartYear: Int = 1403,
+    initialIsAnonymous: Boolean = false,
    isMosqueCategory: Boolean = false,
-    onConfirm: (String, String, Double, Int, Int) -> Unit,
+    onConfirm: (String, String, Double, Int, Int, Boolean) -> Unit,
+    onDelete: () -> Unit,
    onDismiss: () -> Unit,
    onSearchContact: (String) -> List<ContactMatch>,
 ) {
    var name by remember { mutableStateOf(initialName) }
    var phoneNumber by remember { mutableStateOf(initialPhone ?: "") }
    var monthlyCommitment by remember { mutableStateOf(if (initialCommitment > 0) initialCommitment.toInt().toString() else "") }
+    var isAnonymous by remember { mutableStateOf(initialIsAnonymous) }
+    var showDeleteConfirm by remember { mutableStateOf(false) }
    
-    val currentShamsiYear = com.oqba26.monthlypaymentapp.utils.getCurrentShamsiYear()
+    val currentShamsiYear = getCurrentShamsiYear()
    var startMonth by remember { mutableIntStateOf(initialStartMonth) }
    var startYear by remember { mutableIntStateOf(initialStartYear) }
    
@@ -307,6 +316,20 @@ fun UpdatePersonDialog(
                        fontWeight = FontWeight.Bold
                    )

+                    Row(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .clickable { isAnonymous = !isAnonymous },
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
+                        Checkbox(
+                            checked = isAnonymous,
+                            onCheckedChange = { isAnonymous = it }
+                        )
+                        Spacer(modifier = Modifier.width(8.dp))
+                        Text("ثبت به صورت خیر ناشناس")
+                    }
+
                    OutlinedTextField(
                        value = name,
                        onValueChange = { name = it },
@@ -458,12 +481,12 @@ fun UpdatePersonDialog(
                                    onClick = { expandedMonth = true },
                                    modifier = Modifier.fillMaxWidth()
                                ) {
-                                    Text(com.oqba26.monthlypaymentapp.utils.getPersianMonthName(startMonth))
+                                    Text(getPersianMonthName(startMonth))
                                }
                                DropdownMenu(expanded = expandedMonth, onDismissRequest = { expandedMonth = false }) {
                                    (1..12).forEach { m ->
                                        DropdownMenuItem(
-                                            text = { Text(com.oqba26.monthlypaymentapp.utils.getPersianMonthName(m)) },
+                                            text = { Text(getPersianMonthName(m)) },
                                            onClick = { startMonth = m; expandedMonth = false }
                                        )
                                    }
@@ -481,7 +504,7 @@ fun UpdatePersonDialog(
                            onClick = {
                                if (name.isNotBlank()) {
                                    val commitment = monthlyCommitment.toDoubleOrNull() ?: 0.0
-                                    onConfirm(name, phoneNumber, commitment, startMonth, startYear)
+                                    onConfirm(name, phoneNumber, commitment, startMonth, startYear, isAnonymous)
                                }
                            },
                            enabled = name.isNotBlank()
@@ -498,6 +521,47 @@ fun UpdatePersonDialog(
                            Text("لغو")
                        }
                    }
+
+                    Button(
+                        onClick = { showDeleteConfirm = true },
+                        modifier = Modifier.fillMaxWidth(),
+                        colors = ButtonDefaults.buttonColors(
+                            containerColor = MaterialTheme.colorScheme.errorContainer,
+                            contentColor = MaterialTheme.colorScheme.error
+                        )
+                    ) {
+                        Icon(Icons.Default.Delete, contentDescription = null)
+                        Spacer(Modifier.width(4.dp))
+                        Text("حذف این شخص")
+                    }
+
+                    if (showDeleteConfirm) {
+                        Dialog(onDismissRequest = { showDeleteConfirm = false }) {
+                            CompositionLocalProvider(LocalLayoutDirection provides LayoutDirection.Rtl) {
+                                Card(
+                                    modifier = Modifier.fillMaxWidth(),
+                                    shape = RoundedCornerShape(24.dp)
+                                ) {
+                                    Column(modifier = Modifier.padding(20.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
+                                        Text(text = "حذف شخص", style = MaterialTheme.typography.headlineSmall, fontWeight = FontWeight.Bold)
+                                        Text(text = "آیا از حذف این شخص و تمام پرداخت‌های او مطمئن هستید؟", style = MaterialTheme.typography.bodyMedium)
+                                        Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.CenterVertically) {
+                                            Button(onClick = { showDeleteConfirm = false }) { Text("لغو") }
+                                            Button(
+                                                onClick = {
+                                                    showDeleteConfirm = false
+                                                    onDelete()
+                                                },
+                                                colors = ButtonDefaults.buttonColors(containerColor = MaterialTheme.colorScheme.error)
+                                            ) {
+                                                Text("حذف")
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
                }
            }
        }
@@ -535,7 +599,6 @@ fun YearSelector(year: Int, onYearChange: (Int) -> Unit) {
@Composable
 fun MonthListItem(
    month: MonthUiModel,
-    personName: String,
    startMonth: Int,
    onHeaderClick: () -> Unit,
    onEditClick: () -> Unit
@@ -201,10 +201,10 @@ fun PersonScreen(
                if (currentCategory == "mosque" && uiState.unpaidPersons.isNotEmpty()) {
                    item {
                        Text(
-                            text = "لیست خیرین (بدهکار)",
+                            text = "لیست خیرین",
                            modifier = Modifier.padding(16.dp),
                            style = MaterialTheme.typography.titleMedium,
-                            color = MaterialTheme.colorScheme.error
+                            color = MaterialTheme.colorScheme.primary
                        )
                    }
                }
@@ -303,14 +303,12 @@ fun PersonScreen(
    personForPaymentDialog?.let { person ->
        val currentDay = getCurrentShamsiDay()
        val currentMonth = getCurrentShamsiMonth()
-        val currentYear = getCurrentShamsiYear()
        val targetMonth = if (currentDay >= 20) currentMonth else if (currentMonth == 1) 12 else currentMonth - 1
-        val targetYear = if (currentDay < 20 && currentMonth == 1) currentYear - 1 else currentYear

        val monthName = getPersianMonthName(targetMonth)
        val currentDateTime = formatTimestampToPersianDateTime(System.currentTimeMillis())
        
-        val isCurrentMonth = (targetMonth == currentMonth) && (targetYear == currentYear)
+        val isCurrentMonth = targetMonth == currentMonth
        val initialDesc = if (isCurrentMonth) {
            "پرداخت برای ماه جاری در تاریخ $currentDateTime ثبت شد."
        } else {
@@ -1,34 +1,32 @@
-@file:OptIn(kotlinx.serialization.InternalSerializationApi::class)
+@file:OptIn(InternalSerializationApi::class)
 package com.oqba26.monthlypaymentapp.utils

 import android.app.DownloadManager
-import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
-import android.content.IntentFilter
 import android.net.ConnectivityManager
 import android.net.NetworkCapabilities
 import android.os.Build
 import android.os.Environment
 import android.widget.Toast
-import androidx.core.content.ContextCompat
 import androidx.core.content.FileProvider
 import androidx.core.net.toUri
 import io.ktor.client.*
-import io.ktor.client.statement.bodyAsText
 import io.ktor.client.plugins.contentnegotiation.*
 import io.ktor.client.request.*
+import io.ktor.client.statement.*
+import io.ktor.http.*
 import io.ktor.serialization.kotlinx.json.*
+import io.ktor.utils.io.*
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.withContext
+import kotlinx.serialization.InternalSerializationApi
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
 import java.io.File
-import kotlin.time.Duration.Companion.milliseconds

@Serializable
 data class UpdateInfo(
@@ -39,6 +37,12 @@ data class UpdateInfo(
    val isForceUpdate: Boolean = false,
 )

+sealed class DownloadState {
+    data class Progress(val progress: Float) : DownloadState()
+    data class Success(val file: File) : DownloadState()
+    data class Error(val message: String) : DownloadState()
+}
+
 class UpdateManager(private val context: Context) {

    private val updateUrl = "https://raw.githubusercontent.com/oqba26/MonthlyPaymentApp/main/update.json"
@@ -55,6 +59,7 @@ class UpdateManager(private val context: Context) {
    }

    suspend fun checkForUpdate(): UpdateInfo? = withContext(Dispatchers.IO) {
+        cancelPendingSystemDownloads()
        if (!isNetworkAvailable()) return@withContext null

        try {
@@ -81,90 +86,53 @@ class UpdateManager(private val context: Context) {
        null
    }

-    fun downloadAndInstall(url: String, fileName: String): Long {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            if (!context.packageManager.canRequestPackageInstalls()) {
-                Toast.makeText(context, "لطفاً اجازه نصب برنامه‌های ناشناخته را بدهید", Toast.LENGTH_LONG).show()
-                val intent = Intent(android.provider.Settings.ACTION_MANAGE_UNKNOWN_APP_SOURCES).apply {
-                    data = "package:${context.packageName}".toUri()
-                    flags = Intent.FLAG_ACTIVITY_NEW_TASK
-                }
-                context.startActivity(intent)
-                return -1L
-            }
-        }
-
-        val downloadManager = context.getSystemService(Context.DOWNLOAD_SERVICE) as DownloadManager
-        val uri = url.toUri()
-        
-        val oldFile = File(context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS), fileName)
-        if (oldFile.exists()) oldFile.delete()
-
-        val request = DownloadManager.Request(uri)
-            .setTitle("دریافت به‌روزرسانی")
-            .setDescription("نسخه جدید در حال دانلود است...")
-            .setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED)
-            .setDestinationInExternalFilesDir(context, Environment.DIRECTORY_DOWNLOADS, fileName)
-            .setAllowedOverMetered(true)
-            .setAllowedOverRoaming(true)
-
-        val downloadId = downloadManager.enqueue(request)
-
-        val onComplete = object : BroadcastReceiver() {
-            override fun onReceive(receiverContext: Context, intent: Intent) {
-                val id = intent.getLongExtra(DownloadManager.EXTRA_DOWNLOAD_ID, -1L)
-                if (id == downloadId) {
-                    installApk(fileName)
+    fun downloadApk(url: String, fileName: String): Flow<DownloadState> = flow {
        try {
-                        receiverContext.unregisterReceiver(this)
-                    } catch (e: Exception) {
-                        e.printStackTrace()
-                    }
-                }
-            }
+            val destinationFile = File(
+                context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS),
+                fileName
+            )
+            if (destinationFile.exists()) {
+                destinationFile.delete()
            }

-        val filter = IntentFilter(DownloadManager.ACTION_DOWNLOAD_COMPLETE)
-        ContextCompat.registerReceiver(context, onComplete, filter, ContextCompat.RECEIVER_EXPORTED)
-        
-        return downloadId
+            client.prepareGet(url) {
+                header(HttpHeaders.UserAgent, "Mozilla/5.0 (Linux; Android 10; Mobile) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36")
+            }.execute { response ->
+                if (!response.status.isSuccess()) {
+                    emit(DownloadState.Error("خطا در دانلود فایل (کد ${response.status.value})"))
+                    return@execute
                }

-    fun getDownloadProgress(downloadId: Long): Flow<Float> = flow {
-        val downloadManager = context.getSystemService(Context.DOWNLOAD_SERVICE) as DownloadManager
-        var isDownloading = true
-        while (isDownloading) {
-            val query = DownloadManager.Query().setFilterById(downloadId)
-            val cursor = downloadManager.query(query)
-            if (cursor != null && cursor.moveToFirst()) {
-                val bytesDownloadedIndex = cursor.getColumnIndex(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR)
-                val bytesTotalIndex = cursor.getColumnIndex(DownloadManager.COLUMN_TOTAL_SIZE_BYTES)
-                val statusIndex = cursor.getColumnIndex(DownloadManager.COLUMN_STATUS)
+                val channel: ByteReadChannel = response.bodyAsChannel()
+                val contentLength = response.contentLength() ?: -1L

-                if (bytesDownloadedIndex != -1 && bytesTotalIndex != -1 && statusIndex != -1) {
-                    val bytesDownloaded = cursor.getInt(bytesDownloadedIndex)
-                    val bytesTotal = cursor.getInt(bytesTotalIndex)
-                    val status = cursor.getInt(statusIndex)
+                destinationFile.outputStream().use { output ->
+                    val buffer = ByteArray(16384)
+                    var bytesCopied = 0L
+                    while (!channel.isClosedForRead) {
+                        val read = channel.readAvailable(buffer, 0, buffer.size)
+                        if (read <= 0) break
+                        output.write(buffer, 0, read)
+                        bytesCopied += read

-                    if (status == DownloadManager.STATUS_SUCCESSFUL || status == DownloadManager.STATUS_FAILED) {
-                        isDownloading = false
-                    }
-
-                    if (bytesTotal > 0) {
-                        emit(bytesDownloaded.toFloat() / bytesTotal.toFloat())
-                    }
-                }
-                cursor.close()
+                        if (contentLength > 0) {
+                            val progress = bytesCopied.toFloat() / contentLength.toFloat()
+                            emit(DownloadState.Progress(progress.coerceIn(0f, 1f)))
                        } else {
-                isDownloading = false
-                cursor?.close()
+                            emit(DownloadState.Progress(0f))
                        }
-            if (isDownloading) delay(500.milliseconds)
+                    }
+                }
+                emit(DownloadState.Progress(1f))
+                emit(DownloadState.Success(destinationFile))
+            }
+        } catch (e: Exception) {
+            emit(DownloadState.Error(e.localizedMessage ?: "خطای ارتباط با سرور"))
        }
    }.flowOn(Dispatchers.IO)

-    private fun installApk(fileName: String) {
-        val apkFile = File(context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS), fileName)
+    fun installApk(apkFile: File) {
        if (!apkFile.exists()) return

        try {
@@ -179,6 +147,44 @@ class UpdateManager(private val context: Context) {
                flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_GRANT_READ_URI_PERMISSION
            }
            context.startActivity(intent)
+        } catch (e: Exception) {
+            e.printStackTrace()
+            Toast.makeText(context, "خطا در اجرای فایل نصب: ${e.message}", Toast.LENGTH_LONG).show()
+        }
+    }
+
+    fun openInBrowser(url: String) {
+        try {
+            val intent = Intent(Intent.ACTION_VIEW, url.toUri()).apply {
+                flags = Intent.FLAG_ACTIVITY_NEW_TASK
+            }
+            context.startActivity(intent)
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    fun cancelPendingSystemDownloads() {
+        try {
+            val downloadManager = context.getSystemService(Context.DOWNLOAD_SERVICE) as? DownloadManager ?: return
+            val query = DownloadManager.Query()
+            val cursor = downloadManager.query(query)
+            if (cursor != null) {
+                val idIndex = cursor.getColumnIndex(DownloadManager.COLUMN_ID)
+                val titleIndex = cursor.getColumnIndex(DownloadManager.COLUMN_TITLE)
+                val statusIndex = cursor.getColumnIndex(DownloadManager.COLUMN_STATUS)
+                while (cursor.moveToNext()) {
+                    if (idIndex != -1) {
+                        val id = cursor.getLong(idIndex)
+                        val title = if (titleIndex != -1) cursor.getString(titleIndex) ?: "" else ""
+                        val status = if (statusIndex != -1) cursor.getInt(statusIndex) else -1
+                        if (title.contains("به‌روزرسانی") || title.contains("MonthlyPaymentApp") || status == DownloadManager.STATUS_FAILED) {
+                            downloadManager.remove(id)
+                        }
+                    }
+                }
+                cursor.close()
+            }
        } catch (e: Exception) {
            e.printStackTrace()
        }
@@ -132,12 +132,8 @@ class PersonViewModel @Inject constructor(
            settingsRepository.authTokenFlow.collectLatest { token ->
                if (token != null) {
                    networkRepository.observeRealtimeChanges()
-                    networkRepository.refresh()

-                    // شرط قبلی `persons.isNotEmpty()` بود که دو مشکل داشت: هم لیست خالیِ
-                    // معتبر سرور را نادیده می‌گرفت، و هم اگر واکشی شکست می‌خورد (چون refresh
-                    // خطا را می‌بلعید) روی داده‌ی قدیمی/ناقص merge می‌کرد.
-                    // حالا فقط بعد از یک refresh موفق merge می‌کنیم و خودِ merge هم غیرمخرب است.
+                    launch {
                        combine(
                            networkRepository.getPersonsFlow(),
                            networkRepository.getPaymentsFlow(),
@@ -160,6 +156,9 @@ class PersonViewModel @Inject constructor(
                            }
                        }
                    }
+
+                    networkRepository.refresh()
+                }
            }
        }

@@ -189,18 +188,8 @@ class PersonViewModel @Inject constructor(
                val uiModels = activePersons.map { person ->
                    val hasPaid = relevantPayments.any { it.personId == person.id }
                    
-                    val unpaidResult = if (category == "mosque") {
-                        if (person.monthlyCommitment > 0) {
-                            val debtEndMonth = if (currentDay >= 20) currentMonth else currentMonth - 1
-                            val debtStartMonth = if (person.startYear == currentYear) person.startMonth else 1
-                            
-                            val unpaid = (debtStartMonth..debtEndMonth).filter { m ->
-                                allPayments.none { it.personId == person.id && it.shamsiYear == currentYear && it.shamsiMonth == m && it.category == category }
-                            }
-                            Triple(unpaid.size, unpaid.size * person.monthlyCommitment, unpaid.map { getPersianMonthName(it) } to unpaid)
-                        } else {
-                            Triple(0, 0.0, emptyList<String>() to emptyList<Int>())
-                        }
+                    val unpaidResult = if (category == "mosque" || person.isAnonymous) {
+                        Triple(0, 0.0, emptyList<String>() to emptyList())
                    } else {
                        // Salary logic
                        val debtEndMonth = if (currentDay >= 20) currentMonth else currentMonth - 1
@@ -374,7 +363,8 @@ class PersonViewModel @Inject constructor(

                is PersonScreenEvent.UpdatePerson -> {
                    val persons = localPersonRepository.getAllPersonsFlow().first()
-                    val isDuplicate = persons.any { it.id != event.personId && it.category == _currentCategory.value && it.name.trim().equals(event.name.trim(), ignoreCase = true) }
+                    val finalName = if (event.isAnonymous && event.name.isBlank()) "ناشناس" else event.name
+                    val isDuplicate = !event.isAnonymous && persons.any { it.id != event.personId && it.category == _currentCategory.value && it.name.trim().equals(finalName.trim(), ignoreCase = true) }
                    
                    if (isDuplicate) {
                        _toastMessage.emit("خطا: این نام از قبل وجود دارد.")
@@ -382,13 +372,15 @@ class PersonViewModel @Inject constructor(
                        val currentPerson = persons.find { it.id == event.personId }
                        if (currentPerson != null) {
                            val updatedPerson = currentPerson.copy(
-                                name = event.name,
+                                name = finalName,
                                phoneNumber = event.phoneNumber,
-                                monthlyCommitment = event.monthlyCommitment,
+                                monthlyCommitment = if (event.isAnonymous) 0.0 else event.monthlyCommitment,
                                startMonth = event.startMonth,
-                                startYear = event.startYear
+                                startYear = event.startYear,
+                                isAnonymous = event.isAnonymous
                            )
                            localPersonRepository.updatePersonLocally(updatedPerson)
+                            _toastMessage.emit("اطلاعات شخص با موفقیت بروز شد.")
                        }
                    }
                }
@@ -498,7 +490,15 @@ class PersonViewModel @Inject constructor(

                PersonScreenEvent.RefreshData -> {
                    _isRefreshing.value = true
-                    networkRepository.refresh()
+                    val success = networkRepository.refresh()
+                    if (success) {
+                        val persons = networkRepository.getPersonsFlow().first()
+                        val payments = networkRepository.getPaymentsFlow().first()
+                        localPersonRepository.mergeFromServer(persons, payments)
+                        _toastMessage.emit("اطلاعات با سرور با موفقیت همگام‌سازی شد")
+                    } else {
+                        _toastMessage.emit("خطا در همگام‌سازی با سرور")
+                    }
                    _isRefreshing.value = false
                }
                else -> {}
@@ -84,7 +84,8 @@ sealed class PersonScreenEvent {
        val phoneNumber: String?,
        val monthlyCommitment: Double = 0.0,
        val startMonth: Int = 1,
-        val startYear: Int = 1403
+        val startYear: Int = 1403,
+        val isAnonymous: Boolean = false
    ) : PersonScreenEvent()
    data class DeletePerson(val personId: String) : PersonScreenEvent()
    data class ArchivePerson(val personId: String) : PersonScreenEvent()
@@ -1,6 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
 <network-security-config>
+    <base-config cleartextTrafficPermitted="true" />
    <domain-config cleartextTrafficPermitted="true">
+        <domain includeSubdomains="true">194.146.68.50</domain>
        <domain includeSubdomains="true">167.235.136.65</domain>
    </domain-config>
 </network-security-config>
@@ -70,17 +70,17 @@ class SyncMergerTest {
    }

    @Test
-    fun `شخص محلی غیر pending که در سرور نیست حذف می شود`() {
+    fun `شخص محلی غیر pending که در سرور نیست حذف نمی شود`() {
        val local = listOf(person("a"), person("b"))
        val server = listOf(person("a"))

        val plan = SyncMerger.planPersons(local, server, pendingIds = emptySet())

-        assertEquals(listOf("b"), plan.deleteIds)
+        assertEquals(emptyList<String>(), plan.deleteIds)
    }

    @Test
-    fun `سرور خالی هیچ رکورد محافظت شده ای را پاک نمی کند`() {
+    fun `سرور خالی هیچ رکوردی را پاک نمی کند`() {
        val local = listOf(
            person("a", needsSync = true),
            person("b"),
@@ -89,8 +89,7 @@ class SyncMergerTest {

        val plan = SyncMerger.planPersons(local, server = emptyList(), pendingIds = setOf("b"))

-        // a با needsSync و b از طریق صف محافظت شده‌اند؛ فقط c حذف می‌شود.
-        assertEquals(listOf("c"), plan.deleteIds)
+        assertEquals(emptyList<String>(), plan.deleteIds)
        assertTrue(plan.upserts.isEmpty())
    }

@@ -170,17 +169,17 @@ class SyncMergerTest {
    }

    @Test
-    fun `پرداخت حذف شده در سرور از گوشی هم حذف می شود`() {
+    fun `پرداخت غایب در سرور حذف نمی شود`() {
        val local = listOf(payment("x"), payment("y"))
        val server = listOf(payment("x"))

        val plan = SyncMerger.planPayments(local, server, pendingIds = emptySet())

-        assertEquals(listOf("y"), plan.deleteIds)
+        assertEquals(emptyList<String>(), plan.deleteIds)
    }

    @Test
-    fun `سرور خالی پرداخت های در صف را نگه می دارد`() {
+    fun `سرور خالی پرداخت ها را حذف نمی کند`() {
        val local = listOf(
            payment("pending", needsSync = true),
            payment("synced")
@@ -188,7 +187,7 @@ class SyncMergerTest {

        val plan = SyncMerger.planPayments(local, server = emptyList(), pendingIds = emptySet())

-        assertEquals(listOf("synced"), plan.deleteIds)
+        assertEquals(emptyList<String>(), plan.deleteIds)
    }

    @Test
@@ -31,8 +31,7 @@ junit = "4.13.2"
 junitExt = "1.1.5"
 espressoCore = "3.5.1"

-# Supabase & Ktor
-supabase = "2.5.0"
+# Ktor
 ktor = "2.3.12"

 [libraries]
@@ -75,10 +74,7 @@ google-material = { group = "com.google.android.material", name = "material", ve

 kotlin-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "serialization" }

-# Supabase Libraries
-supabase-postgrest = { group = "io.github.jan-tennert.supabase", name = "postgrest-kt", version.ref = "supabase" }
-supabase-auth = { group = "io.github.jan-tennert.supabase", name = "gotrue-kt", version.ref = "supabase" }
-supabase-realtime = { group = "io.github.jan-tennert.supabase", name = "realtime-kt", version.ref = "supabase" }
+# Ktor Libraries
 ktor-client-okhttp = { group = "io.ktor", name = "ktor-client-okhttp", version.ref = "ktor" }
 ktor-client-content-negotiation = { group = "io.ktor", name = "ktor-client-content-negotiation", version.ref = "ktor" }
 ktor-serialization-kotlinx-json = { group = "io.ktor", name = "ktor-serialization-kotlinx-json", version.ref = "ktor" }
@@ -1,7 +1,7 @@
 {
-  "versionCode": 6,
-  "versionName": "1.0.5",
-  "url": "https://github.com/oqba26/MonthlyPaymentApp/releases/download/v1.0.5/MonthlyPaymentApp-v1.0.5.apk",
-  "releaseNotes": "اصلاح چیدمان دکمه‌های دیالوگ آپدیت و تغییر متن دکمه تایید",
+  "versionCode": 8,
+  "versionName": "1.0.7",
+  "url": "https://github.com/oqba26/MonthlyPaymentApp/releases/download/v1.0.7/MonthlyPaymentApp-v1.0.7.apk",
+  "releaseNotes": "مهاجرت به PocketBase، رفع خطاهای بیلد و بهبود پایداری همگام‌سازی",
  "isForceUpdate": false
 }
Author	SHA1	Message	Date
Oqba	fe891b2765	پاکسازی درخواست‌های مانده در سیستم DownloadManager هنگام اجرای برنامه Android Release / build (push) Canceled after 0s Details	2026-09-21 18:57:32 +03:30
Oqba	07c670c1b1	مجوز ارتباط Cleartext HTTP به آی‌پی جدید PocketBase در network_security_config	2026-09-21 18:31:32 +03:30
Oqba	ebf9798c16	اصلاح سیستم دانلود به‌روزرسانی با Ktor و حل مشکل گیر کردن در ۰٪	2026-09-21 18:08:35 +03:30
Oqba	ed1d3cecbb	مهاجرت به PocketBase، رفع خطای بیلد و ارتقای نسخه به 1.0.7 (نسخه 8)	2026-09-21 17:50:52 +03:30
Oqba	a3a8448ee5	Fix Supabase column serialization mapping (snake_case) for Person and PaymentRecord models to prevent resetting archived status during sync Android Release / build (push) Canceled after 14s Details	2026-09-11 16:45:51 +03:30
Oqba	b05c7c7521	Update version to 1.0.6, fix compiler warnings in PersonScreen and PersonDetailScreen, and update release notes	2026-09-11 15:24:21 +03:30