Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f2ad196d authored by Fahim M. Choudhury's avatar Fahim M. Choudhury
Browse files

Merge branch 'origin-main-to-upstream-6.712-#2-42a93bcf' into 'main-6.711-to-upstream-6.712'

MR 2: Merge upstream v6.712 changes

See merge request !165
parents edb44ed3 10f1dc64
Loading
Loading
Loading
Loading
Loading
+1 −1
Original line number Original line Diff line number Diff line
@@ -27,7 +27,7 @@ val accountModule: Module = module {
            arrayOf(
            arrayOf(
                AccountCommonExternalContract.AccountStateLoader::class,
                AccountCommonExternalContract.AccountStateLoader::class,
                AccountSetupExternalContract.AccountCreator::class,
                AccountSetupExternalContract.AccountCreator::class,
                AccountEditExternalContract.AccountUpdater::class,
                AccountEditExternalContract.AccountServerSettingsUpdater::class,
            ),
            ),
        )
        )
    factory<AccountSetupExternalContract.AccountOwnerNameProvider> { AccountOwnerNameProvider() }
    factory<AccountSetupExternalContract.AccountOwnerNameProvider> { AccountOwnerNameProvider() }
+19 −7
Original line number Original line Diff line number Diff line
@@ -4,14 +4,16 @@ import app.k9mail.feature.account.common.AccountCommonExternalContract.AccountSt
import app.k9mail.feature.account.common.domain.entity.Account
import app.k9mail.feature.account.common.domain.entity.Account
import app.k9mail.feature.account.common.domain.entity.AccountState
import app.k9mail.feature.account.common.domain.entity.AccountState
import app.k9mail.feature.account.common.domain.entity.AuthorizationState
import app.k9mail.feature.account.common.domain.entity.AuthorizationState
import app.k9mail.feature.account.edit.AccountEditExternalContract.AccountUpdater
import app.k9mail.feature.account.edit.AccountEditExternalContract.AccountServerSettingsUpdater
import app.k9mail.feature.account.edit.AccountEditExternalContract.AccountUpdater.AccountUpdaterResult
import app.k9mail.feature.account.edit.AccountEditExternalContract.AccountUpdaterFailure
import app.k9mail.feature.account.edit.AccountEditExternalContract.AccountUpdaterResult
import app.k9mail.feature.account.setup.AccountSetupExternalContract.AccountCreator
import app.k9mail.feature.account.setup.AccountSetupExternalContract.AccountCreator
import app.k9mail.feature.account.setup.AccountSetupExternalContract.AccountCreator.AccountCreatorResult
import app.k9mail.feature.account.setup.AccountSetupExternalContract.AccountCreator.AccountCreatorResult
import com.fsck.k9.mail.ServerSettings


class InMemoryAccountStore(
class InMemoryAccountStore(
    private val accountMap: MutableMap<String, Account> = mutableMapOf(),
    private val accountMap: MutableMap<String, Account> = mutableMapOf(),
) : AccountCreator, AccountUpdater, AccountStateLoader {
) : AccountCreator, AccountServerSettingsUpdater, AccountStateLoader {


    suspend fun load(accountUuid: String): Account? {
    suspend fun load(accountUuid: String): Account? {
        return accountMap[accountUuid]
        return accountMap[accountUuid]
@@ -27,11 +29,21 @@ class InMemoryAccountStore(
        return AccountCreatorResult.Success(account.uuid)
        return AccountCreatorResult.Success(account.uuid)
    }
    }


    override suspend fun updateAccount(account: Account): AccountUpdaterResult {
    override suspend fun updateServerSettings(
        return if (!accountMap.containsKey(account.uuid)) {
        accountUuid: String,
            AccountUpdaterResult.Error("Account not found")
        isIncoming: Boolean,
        serverSettings: ServerSettings,
    ): AccountUpdaterResult {
        return if (!accountMap.containsKey(accountUuid)) {
            AccountUpdaterResult.Failure(AccountUpdaterFailure.AccountNotFound(accountUuid))
        } else {
        } else {
            accountMap[account.uuid] = account
            val account = accountMap[accountUuid]!!

            accountMap[account.uuid] = if (isIncoming) {
                account.copy(incomingServerSettings = serverSettings)
            } else {
                account.copy(outgoingServerSettings = serverSettings)
            }


            AccountUpdaterResult.Success(account.uuid)
            AccountUpdaterResult.Success(account.uuid)
        }
        }
+3 −3
Original line number Original line Diff line number Diff line
@@ -28,9 +28,9 @@ val newAccountModule = module {
        )
        )
    }
    }


    factory<AccountEditExternalContract.AccountUpdater> {
    factory<AccountEditExternalContract.AccountServerSettingsUpdater> {
        AccountUpdater(
        AccountServerSettingsUpdater(
            preferences = get(),
            accountManager = get(),
        )
        )
    }
    }
}
}
+54 −0
Original line number Original line Diff line number Diff line
package com.fsck.k9.account

import app.k9mail.feature.account.edit.AccountEditExternalContract
import app.k9mail.feature.account.edit.AccountEditExternalContract.AccountUpdaterFailure
import app.k9mail.feature.account.edit.AccountEditExternalContract.AccountUpdaterResult
import com.fsck.k9.logging.Timber
import com.fsck.k9.mail.ServerSettings
import com.fsck.k9.preferences.AccountManager
import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

class AccountServerSettingsUpdater(
    private val accountManager: AccountManager,
    private val coroutineDispatcher: CoroutineDispatcher = Dispatchers.IO,
) : AccountEditExternalContract.AccountServerSettingsUpdater {

    @Suppress("TooGenericExceptionCaught")
    override suspend fun updateServerSettings(
        accountUuid: String,
        isIncoming: Boolean,
        serverSettings: ServerSettings,
    ): AccountUpdaterResult {
        return try {
            withContext(coroutineDispatcher) {
                updateSettings(accountUuid, isIncoming, serverSettings)
            }
        } catch (error: Exception) {
            Timber.e(error, "Error while updating account server settings with UUID %s", accountUuid)

            AccountUpdaterResult.Failure(AccountUpdaterFailure.UnknownError(error))
        }
    }

    private fun updateSettings(
        accountUuid: String,
        isIncoming: Boolean,
        serverSettings: ServerSettings,
    ): AccountUpdaterResult {
        val account = accountManager.getAccount(accountUuid = accountUuid) ?: return AccountUpdaterResult.Failure(
            AccountUpdaterFailure.AccountNotFound(accountUuid),
        )

        if (isIncoming) {
            account.incomingServerSettings = serverSettings
        } else {
            account.outgoingServerSettings = serverSettings
        }

        accountManager.saveAccount(account)

        return AccountUpdaterResult.Success(accountUuid)
    }
}
+0 −44
Original line number Original line Diff line number Diff line
package com.fsck.k9.account

import app.k9mail.feature.account.common.domain.entity.Account
import app.k9mail.feature.account.edit.AccountEditExternalContract
import app.k9mail.feature.account.edit.AccountEditExternalContract.AccountUpdater.AccountUpdaterResult
import com.fsck.k9.Preferences
import com.fsck.k9.logging.Timber
import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

class AccountUpdater(
    private val preferences: Preferences,
    private val coroutineDispatcher: CoroutineDispatcher = Dispatchers.IO,
) : AccountEditExternalContract.AccountUpdater {

    @Suppress("TooGenericExceptionCaught")
    override suspend fun updateAccount(account: Account): AccountUpdaterResult {
        return try {
            withContext(coroutineDispatcher) {
                AccountUpdaterResult.Success(update(account))
            }
        } catch (e: Exception) {
            Timber.e(e, "Error while updating account")

            AccountUpdaterResult.Error(e.message ?: "Unknown update account error")
        }
    }

    private fun update(account: Account): String {
        val uuid = account.uuid
        require(uuid.isNotEmpty()) { "Can't update account without uuid" }

        val existingAccount = preferences.getAccount(uuid)
        require(existingAccount != null) { "Can't update non-existing account" }

        existingAccount.incomingServerSettings = account.incomingServerSettings
        existingAccount.outgoingServerSettings = account.outgoingServerSettings

        preferences.saveAccount(existingAccount)

        return uuid
    }
}
Loading