Fill with more functionality

core/design/src/main/kotlin/edu/stanford/spezi/core/design/views/personalInfo/PersonNameComponents.kt

@@ -33,4 +33,15 @@ data class PersonNameComponents(
                 .filter { it.isUpperCase() }
         }
     }
+
+    companion object {
+        operator fun invoke(string: String): PersonNameComponents {
+            val components = string.split(" ")
+            // TODO: Vastly improve this implementation!
+            return PersonNameComponents(
+                givenName = components.firstOrNull(),
+                familyName = components.drop(1).joinToString(" ")
+            )
+        }
+    }
 }

core/design/src/main/kotlin/edu/stanford/spezi/core/design/views/validation/views/VerifiableTextField.kt

@@ -14,6 +14,7 @@ import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.text.input.KeyboardType
 import androidx.compose.ui.text.input.PasswordVisualTransformation
+import androidx.compose.ui.text.input.TextFieldValue
 import edu.stanford.spezi.core.design.component.StringResource
 import edu.stanford.spezi.core.design.theme.SpeziTheme
 import edu.stanford.spezi.core.design.theme.ThemePreviews

modules/account/src/main/kotlin/edu/stanford/spezi/module/account/account/Account.kt

@@ -13,8 +13,8 @@ import kotlinx.coroutines.runBlocking
 import javax.inject.Inject
 
 class Account(
-    val configuration: AccountValueConfiguration = AccountValueConfiguration.default,
     service: AccountService,
+    val configuration: AccountValueConfiguration = AccountValueConfiguration.default,
     details: AccountDetails? = null,
 ) {
     val logger by speziLogger()

modules/account/src/main/kotlin/edu/stanford/spezi/module/account/account/AccountConfiguration.kt

@@ -6,21 +6,29 @@ import edu.stanford.spezi.module.account.account.service.configuration.Supported
 import edu.stanford.spezi.module.account.account.service.configuration.supportedAccountKeys
 import edu.stanford.spezi.module.account.account.service.configuration.unsupportedAccountKeys
 import edu.stanford.spezi.module.account.account.value.AccountKeys
+import edu.stanford.spezi.module.account.account.value.collections.AccountDetails
 import edu.stanford.spezi.module.account.account.value.configuration.AccountValueConfiguration
 import edu.stanford.spezi.module.account.account.value.keys.accountId
 import javax.inject.Inject
 import kotlin.system.exitProcess
 
-class AccountConfiguration<Service : AccountService> {
-    private val logger by speziLogger()
-
-    @Inject lateinit var account: Account
+interface Standard
 
-    @Inject internal lateinit var externalStorage: ExternalAccountStorage
-
-    @Inject internal lateinit var accountService: Service
+// TODO: Expose those properties!!!!
+class AccountConfiguration<Service : AccountService>(
+    private val accountService: Service,
+    private val storageProvider: AccountStorageProvider? = null,
+    configuration: AccountValueConfiguration = AccountValueConfiguration.default,
+    defaultActiveDetails: AccountDetails? = null,
+) {
+    private val logger by speziLogger()
 
-    @Inject internal lateinit var storageProvider: List<Module> // TODO: This is never going to work
+    val account = Account(
+        accountService,
+        configuration,
+        defaultActiveDetails
+    )
+    val externalStorage = ExternalAccountStorage(storageProvider)
 
     @Inject internal lateinit var standard: Standard
 
@@ -44,7 +52,7 @@ class AccountConfiguration<Service : AccountService> {
 
         if (unmappedAccountKeys.isEmpty()) return // we are fine, nothing unsupported
 
-        storageProvider.firstOrNull()?.let {
+        storageProvider?.let {
             logger.w {
                 """
                     The storage provider $it is used to store the following account values that

modules/account/src/main/kotlin/edu/stanford/spezi/module/account/account/ExternalAccountStorage.kt

@@ -11,14 +11,15 @@ import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.onCompletion
 import java.util.UUID
 
-class ExternalAccountStorage {
+class ExternalAccountStorage internal constructor(
+    private var storageProvider: AccountStorageProvider?
+) {
     data class ExternallyStoredDetails internal constructor(
         val accountId: String,
         val details: AccountDetails,
     )
 
     private var subscriptions = mutableMapOf<UUID, FlowCollector<ExternallyStoredDetails>>()
-    private var storageProvider: AccountStorageProvider? = null
 
     val updatedDetails: Flow<ExternallyStoredDetails>
         get() = UUID().let { id ->

modules/account/src/main/kotlin/edu/stanford/spezi/module/account/account/compositionLocal/AccountServiceConfiguration.kt

@@ -0,0 +1,9 @@
+package edu.stanford.spezi.module.account.account.compositionLocal
+
+import androidx.compose.runtime.compositionLocalOf
+import edu.stanford.spezi.module.account.account.service.configuration.AccountServiceConfiguration
+import edu.stanford.spezi.module.account.account.service.configuration.SupportedAccountKeys
+
+val LocalAccountServiceConfiguration = compositionLocalOf {
+    AccountServiceConfiguration(SupportedAccountKeys.Arbitrary)
+}

modules/account/src/main/kotlin/edu/stanford/spezi/module/account/account/compositionLocal/AccountViewType.kt

@@ -0,0 +1,14 @@
+package edu.stanford.spezi.module.account.account.compositionLocal
+
+import androidx.compose.runtime.compositionLocalOf
+
+sealed interface AccountViewType {
+    data object Signup : AccountViewType
+    data class Overview(val mode: OverviewEntryMode) : AccountViewType
+
+    enum class OverviewEntryMode {
+        NEW, EXISTING, DISPLAY
+    }
+}
+
+val LocalAccountViewType = compositionLocalOf<AccountViewType?> { null }

modules/account/src/main/kotlin/edu/stanford/spezi/module/account/account/compositionLocal/PasswordFieldType.kt

@@ -0,0 +1,24 @@
+package edu.stanford.spezi.module.account.account.compositionLocal
+
+import androidx.compose.runtime.compositionLocalOf
+import edu.stanford.spezi.core.design.component.StringResource
+import edu.stanford.spezi.module.account.account.value.AccountKeys
+import edu.stanford.spezi.module.account.account.value.keys.password
+
+enum class PasswordFieldType {
+    PASSWORD, NEW, REPEAT;
+
+    val text: StringResource get() = when (this) {
+        PASSWORD -> AccountKeys.password.name
+        NEW -> StringResource("NEW_PASSWORD")
+        REPEAT -> StringResource("REPEAT_PASSWORD")
+    }
+
+    val prompt: StringResource get() = when (this) {
+        PASSWORD -> AccountKeys.password.name
+        NEW -> StringResource("NEW_PASSWORD_PROMPT")
+        REPEAT -> StringResource("REPEAT_PASSWORD_PROMPT")
+    }
+}
+
+val LocalPasswordFieldType = compositionLocalOf { PasswordFieldType.PASSWORD }

modules/account/src/main/kotlin/edu/stanford/spezi/module/account/account/compositionLocal/SignUpProviderCompliance.kt

@@ -1,5 +1,10 @@
 package edu.stanford.spezi.module.account.account.compositionLocal
 
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.compositionLocalOf
+import androidx.compose.runtime.remember
 import edu.stanford.spezi.module.account.account.value.AccountKey
 import java.util.Date
 
@@ -21,4 +26,43 @@ data class SignUpProviderCompliance internal constructor(
     }
 }
 
-// TODO: Find equivalent to SwiftUI preferences and implement inject functionality
+private data class SignupProviderComplianceReader(
+    var entry: Entry? = null,
+) {
+    data class Entry(
+        val compliance: SignUpProviderCompliance,
+        val date: Date = Date(),
+    )
+}
+
+private val LocalSignupProviderComplianceReaders = compositionLocalOf { emptyList<SignupProviderComplianceReader>() }
+
+@Composable
+fun ReportSignupProviderCompliance(compliance: SignUpProviderCompliance?) {
+    compliance?.let {
+        val newEntry = SignupProviderComplianceReader.Entry(it)
+        LocalSignupProviderComplianceReaders.current.forEach { reader ->
+            val oldEntry = reader.entry
+            if (oldEntry == null || oldEntry.date > newEntry.date) {
+                reader.entry = newEntry
+            }
+        }
+    }
+}
+
+@Composable
+internal fun ReceiveSignupProviderCompliance(
+    action: (SignUpProviderCompliance?) -> Unit,
+    content: @Composable () -> Unit
+) {
+    val newReader = remember { SignupProviderComplianceReader() }
+    val existingReaders = LocalSignupProviderComplianceReaders.current
+    CompositionLocalProvider(
+        LocalSignupProviderComplianceReaders provides (existingReaders + newReader)
+    ) {
+        content()
+    }
+    LaunchedEffect(newReader.entry) {
+        action(newReader.entry?.compliance)
+    }
+}