content
stringlengths 0
13M
| path
stringlengths 4
263
| contentHash
stringlengths 1
10
|
|---|---|---|
package com.jolufeja.authentication
class TestAuthenticationStore : AuthenticationStore {
companion object {
const val TokenKey = "authToken"
}
private val prefs: MutableMap<String, String> = mutableMapOf()
override suspend fun retrieve(): AuthenticationInfo? =
prefs[TokenKey]?.let { AuthenticationInfo(it) }
override suspend fun store(authInfo: AuthenticationInfo) {
prefs[TokenKey] = authInfo.token
}
override suspend fun clear() {
prefs.clear()
}
} | tudas-app/tudas-app/lib/authentication/src/test/java/com/jolufeja/authentication/TestAuthenticationStore.kt | 4272208726 |
package com.jolufeja.authentication
import com.jolufeja.authentication.registration.DefaultRegistrationService
import com.jolufeja.authentication.registration.RegistrationService
import com.jolufeja.httpclient.HttpClientModule
import org.koin.core.context.startKoin
import org.koin.dsl.module
object AuthenticationTestModule {
/**
* Noop method to force the one-off call to the init block of this object.
*/
internal fun init() {}
private val module = module {
single<RegistrationService> { DefaultRegistrationService(get(), get()) }
single<AuthenticationStore> { TestAuthenticationStore() }
single<UserAuthenticationService> { DefaultUserAuthenticationService(get(), get()) }
}
val withDependencies = setOf(module) + HttpClientModule.withDependencies
init {
startKoin { modules(withDependencies.toList()) }
}
} | tudas-app/tudas-app/lib/authentication/src/test/java/com/jolufeja/authentication/AuthenticationTestModule.kt | 2219896493 |
package com.jolufeja.authentication.registration
sealed interface RegistrationError {
data class RegistrationFailed(val reason: String) : RegistrationError
} | tudas-app/tudas-app/lib/authentication/src/main/java/com/jolufeja/authentication/registration/RegistrationError.kt | 2640666853 |
package com.jolufeja.authentication.registration
import org.koin.dsl.module
object RegistrationModule {
private val module = module {
single<RegistrationService> { DefaultRegistrationService(get(), get()) }
}
val withDependencies get() = setOf(module)
} | tudas-app/tudas-app/lib/authentication/src/main/java/com/jolufeja/authentication/registration/RegistrationModule.kt | 4171388416 |
package com.jolufeja.authentication.registration
import arrow.core.Either
import arrow.core.computations.either
import com.jolufeja.authentication.AuthenticationInfo
import com.jolufeja.authentication.AuthenticationStore
import com.jolufeja.httpclient.HttpClient
import com.jolufeja.httpclient.error.awaitJsonBody
import com.jolufeja.httpclient.error.tryExecute
fun interface RegistrationService {
suspend fun registerUser(
credentials: RegistrationCredentials
): Either<RegistrationError.RegistrationFailed, Unit>
}
class DefaultRegistrationService(
private val httpClient: HttpClient,
private val authStore: AuthenticationStore
) : RegistrationService {
companion object {
private const val RegistrationUrl: String = "auth/register"
}
override suspend fun registerUser(
credentials: RegistrationCredentials
): Either<RegistrationError.RegistrationFailed, Unit> = either {
val authInfo = httpClient
.registrationRequest(credentials)
.bind()
authStore.store(authInfo)
}
private suspend fun HttpClient.registrationRequest(
credentials: RegistrationCredentials
): Either<RegistrationError.RegistrationFailed, AuthenticationInfo> =
post(RegistrationUrl)
.jsonBody(credentials)
.tryExecute()
.awaitJsonBody<AuthenticationInfo>()
.mapLeft { RegistrationError.RegistrationFailed(it.message) }
}
| tudas-app/tudas-app/lib/authentication/src/main/java/com/jolufeja/authentication/registration/RegistrationService.kt | 1026780622 |
package com.jolufeja.authentication.registration
data class RegistrationCredentials(
val name: String,
val password: String,
val email: String,
) | tudas-app/tudas-app/lib/authentication/src/main/java/com/jolufeja/authentication/registration/RegistrationCredentials.kt | 4175249197 |
package com.jolufeja.authentication
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.collect
import java.time.Duration
import java.util.concurrent.locks.Lock
import java.util.concurrent.locks.ReentrantLock
import kotlin.concurrent.withLock
import kotlin.reflect.KProperty
enum class CacheState { Active, Cancelled }
interface CachedValue<T> {
fun getAsync(): Deferred<T>
fun getIfPresentAsync(): Deferred<T>?
suspend fun await(): T = getAsync().await()
}
private class DefaultCachedValue<T>(
val supplier: suspend () -> T,
val ttlForValue: (T) -> Duration,
val ttlForError: (Throwable) -> Duration = { Duration.ZERO },
state: StateFlow<CacheState>?
) : CachedValue<T> {
private var currentJob: Job? = null
@Volatile
private var deferred: CompletableDeferred<T>? = null
private val lock: Lock = ReentrantLock()
init {
state?.let { stateFlow ->
CoroutineScope(Dispatchers.Default).launch {
stateFlow.collect {
when (it) {
CacheState.Cancelled -> resetCache()
else -> {
}
}
}
}
}
}
private fun resetCache() {
deferred?.cancel()
currentJob?.cancel()
deferred = null
currentJob = null
}
override fun getAsync(): Deferred<T> =
deferred
?: lock.withLock {
deferred
?: run {
CompletableDeferred<T>().also { d ->
deferred = d
currentJob = CoroutineScope(Dispatchers.Default).launch {
val ttl = try {
val value = supplier()
d.complete(value)
ttlForValue(value)
} catch (err: Throwable) {
d.completeExceptionally(err)
ttlForError(err)
}
delay(ttl.toMillis())
deferred = null
}
}
}
}
override fun getIfPresentAsync(): Deferred<T>? = deferred
}
@Suppress("NOTHING_TO_INLINE", "DeferredIsResult")
inline operator fun <T> CachedValue<T>.getValue(thisRef: Any?, property: KProperty<*>): Deferred<T> =
getAsync()
fun <T> cached(
ttlForValue: (T) -> Duration = { Duration.ZERO },
ttlForError: (Throwable) -> Duration = { Duration.ZERO },
cancellation: StateFlow<CacheState>? = null,
supplier: suspend () -> T
): CachedValue<T> = DefaultCachedValue(supplier, ttlForValue, ttlForError, cancellation) | tudas-app/tudas-app/lib/authentication/src/main/java/com/jolufeja/authentication/CachedValue.kt | 2061486984 |
package com.jolufeja.authentication
import com.jolufeja.httpclient.HttpClientRequest
import com.jolufeja.httpclient.HttpClientResponse
import com.jolufeja.httpclient.HttpInterceptor
class AuthenticationHttpInterceptor(private val authService: UserAuthenticationService) : HttpInterceptor {
override suspend fun intercept(request: HttpClientRequest, chain: HttpInterceptor.Chain): HttpClientResponse =
authService.authentication.await().let { authInfo ->
val newRequest = request.cloneWith {
headers { headers ->
headers.add("x-auth-token", authInfo.token)
}
}
chain.proceed(newRequest)
}
} | tudas-app/tudas-app/lib/authentication/src/main/java/com/jolufeja/authentication/AuthenticationHttpInterceptor.kt | 2504424840 |
package com.jolufeja.authentication
| tudas-app/tudas-app/lib/authentication/src/main/java/com/jolufeja/authentication/UserInfo.kt | 735119143 |
package com.jolufeja.authentication
import com.fasterxml.jackson.annotation.JsonIgnoreProperties
@JsonIgnoreProperties(ignoreUnknown = true)
data class AuthenticationInfo(
val token: String,
val user: UserInfo
) | tudas-app/tudas-app/lib/authentication/src/main/java/com/jolufeja/authentication/AuthenticationInfo.kt | 1882990918 |
package com.jolufeja.authentication
/**
* Authentication qualifiers intended to be used later on to distinguish http-clients that
* provide JWT-based authentication, or not. We can use koin qualifiers to specifically request a
* http-client *with* [WithUserAuthentication] or *without* [None] (omitting qualifiers) authentication.
*/
enum class AuthenticationQualifiers {
None,
WithUserAuthentication
} | tudas-app/tudas-app/lib/authentication/src/main/java/com/jolufeja/authentication/AuthenticationQualifiers.kt | 466559737 |
package com.jolufeja.authentication
import android.content.Context
import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.core.edit
import androidx.datastore.preferences.core.stringPreferencesKey
import androidx.datastore.preferences.preferencesDataStore
import arrow.core.computations.nullable
import com.fasterxml.jackson.annotation.JsonIgnoreProperties
import kotlinx.coroutines.flow.firstOrNull
import kotlinx.coroutines.flow.map
@JsonIgnoreProperties(ignoreUnknown = true)
data class FeedEntry(val message: String, val new: Boolean)
@JsonIgnoreProperties(ignoreUnknown = true)
data class UserInfo(val id: String, val name: String, val email: String, val feed: List<FeedEntry> = listOf())
private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(
SharedPreferencesAuthenticationStore.SharedPreferencesName
)
class SharedPreferencesAuthenticationStore(context: Context) : AuthenticationStore {
companion object {
const val SharedPreferencesName = "com.jolufeja.authentication"
val TokenKey = stringPreferencesKey("authToken")
val UserNameKey = stringPreferencesKey("userName")
val UserIdKey = stringPreferencesKey("userId")
val EmailKey = stringPreferencesKey("emailAddress")
}
private val dataStore by lazy { context.dataStore }
override suspend fun retrieve(): AuthenticationInfo? = dataStore.data
.map { store ->
nullable {
AuthenticationInfo(
token = store[TokenKey].bind(),
user = UserInfo(
id = store[UserIdKey].bind(),
name = store[UserNameKey].bind(),
email = store[EmailKey].bind(),
feed = listOf()
)
)
}
}.firstOrNull()
override suspend fun store(authInfo: AuthenticationInfo) {
dataStore
.edit {
it.clear()
it[TokenKey] = authInfo.token
it[UserIdKey] = authInfo.user.id
it[UserNameKey] = authInfo.user.name
it[EmailKey] = authInfo.user.email
}
}
override suspend fun clear() {
dataStore.edit { it.clear() }
}
} | tudas-app/tudas-app/lib/authentication/src/main/java/com/jolufeja/authentication/SharedPreferencesAuthenticationStore.kt | 2872247115 |
package com.jolufeja.authentication
data class UserCredentials(
val name: String,
val password: String
) | tudas-app/tudas-app/lib/authentication/src/main/java/com/jolufeja/authentication/UserCredentials.kt | 2362696672 |
package com.jolufeja.authentication
sealed interface AuthenticationError {
data class LoginFailed(val reason: String) : AuthenticationError
}
| tudas-app/tudas-app/lib/authentication/src/main/java/com/jolufeja/authentication/AuthenticationError.kt | 950111612 |
package com.jolufeja.authentication
import com.jolufeja.authentication.registration.RegistrationModule
import com.jolufeja.httpclient.HttpClient
import org.koin.core.qualifier.qualifier
import org.koin.dsl.module
object AuthenticationModule {
private val module = module {
single<UserAuthenticationService> {
DefaultUserAuthenticationService(get(), get())
}
single<AuthenticationStore> {
SharedPreferencesAuthenticationStore(get())
}
single(qualifier(AuthenticationQualifiers.WithUserAuthentication)) {
get<HttpClient.Builder>()
.addInterceptor(AuthenticationHttpInterceptor(get()))
.build()
}
}
val withDependencies get() = setOf(module) + RegistrationModule.withDependencies
} | tudas-app/tudas-app/lib/authentication/src/main/java/com/jolufeja/authentication/AuthenticationModule.kt | 2087098406 |
package com.jolufeja.authentication
interface AuthenticationStore {
suspend fun retrieve(): AuthenticationInfo?
suspend fun store(authInfo: AuthenticationInfo)
suspend fun clear()
}
| tudas-app/tudas-app/lib/authentication/src/main/java/com/jolufeja/authentication/AuthenticationStore.kt | 1532170865 |
package com.jolufeja.authentication
import arrow.core.Either
import arrow.core.computations.either
import com.jolufeja.httpclient.HttpClient
import com.jolufeja.httpclient.error.awaitJsonBody
import com.jolufeja.httpclient.error.tryExecute
import kotlinx.coroutines.Deferred
import kotlinx.coroutines.flow.MutableStateFlow
import java.time.Duration
interface UserAuthenticationService {
suspend fun login(credentials: UserCredentials): Either<AuthenticationError.LoginFailed, Unit>
suspend fun logout()
val authentication: Deferred<AuthenticationInfo>
}
class DefaultUserAuthenticationService(
private val httpClient: HttpClient,
private val authStore: AuthenticationStore
) : UserAuthenticationService {
companion object {
private object EmptyAuthStoreException : Throwable("Authentication store is empty.")
private const val LoginUrl = "auth/login"
}
private val authCancellable: MutableStateFlow<CacheState> = MutableStateFlow(CacheState.Active)
override suspend fun login(
credentials: UserCredentials
): Either<AuthenticationError.LoginFailed, Unit> = either {
val authInfo = httpClient
.loginCredentialRequest(credentials)
.bind()
authStore.store(authInfo)
authCancellable.value = CacheState.Active
}
override suspend fun logout() {
authStore.clear()
authCancellable.value = CacheState.Cancelled
}
/**
* This may become relevant if we decide to include expiration dates for JWT auth tokens. In that case,
* the [cached] delegate can automatically try to refresh or revalidate the token through the backend
*/
override val authentication: Deferred<AuthenticationInfo> by cached(
ttlForValue = { Duration.ofMinutes(300) },
ttlForError = { Duration.ofMinutes(5) },
cancellation = authCancellable
) { authStore.retrieve() ?: throw EmptyAuthStoreException }
private suspend fun HttpClient.loginCredentialRequest(
credentials: UserCredentials
): Either<AuthenticationError.LoginFailed, AuthenticationInfo> =
post(LoginUrl)
.jsonBody(credentials)
.tryExecute()
.awaitJsonBody<AuthenticationInfo>()
.mapLeft { AuthenticationError.LoginFailed(it.message) }
}
| tudas-app/tudas-app/lib/authentication/src/main/java/com/jolufeja/authentication/UserAuthenticationService.kt | 3158643349 |
package com.jolufeja.presentation
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.jolufeja.presentation.test", appContext.packageName)
}
} | tudas-app/tudas-app/lib/presentation/src/androidTest/java/com/jolufeja/presentation/ExampleInstrumentedTest.kt | 2838842996 |
package com.jolufeja.presentation
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} | tudas-app/tudas-app/lib/presentation/src/test/java/com/jolufeja/presentation/ExampleUnitTest.kt | 3451118224 |
package com.jolufeja.presentation.viewmodel
import com.jolufeja.httpclient.error.ErrorHandler
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.stateIn
interface DataSource<E, V> {
val status: StateFlow<State<E, V>>
fun refresh()
sealed interface State<out E, out V> {
object Empty : State<Nothing, Nothing>
object Loading : State<Nothing, Nothing>
data class Success<out V>(val data: V) : State<Nothing, V>
data class Error<out E>(val error: E) : State<E, Nothing>
}
}
private class DefaultDataSource<E, V>(
override val status: StateFlow<DataSource.State<E, V>>,
private inline val refresher: () -> Unit
) : DataSource<E, V> {
override fun refresh() = refresher()
}
@Suppress("FunctionName")
fun <E, V> DataSource(
fetcher: suspend () -> V,
errorHandler: ErrorHandler<E>,
scope: CoroutineScope,
autoLoad: Boolean = true
): DataSource<E, V> {
val refreshSignal = Channel<Unit>()
val status = flow {
if (!autoLoad) {
refreshSignal.receive()
}
while (true) {
emit(DataSource.State.Loading)
val data = try {
DataSource.State.Success(fetcher())
} catch (err: Throwable) {
DataSource.State.Error(errorHandler(err))
}
emit(data)
refreshSignal.receive()
}
}.stateIn(scope, SharingStarted.Eagerly, DataSource.State.Empty)
return DefaultDataSource(status) { refreshSignal.trySend(Unit) }
}
| tudas-app/tudas-app/lib/presentation/src/main/java/com/jolufeja/presentation/viewmodel/DataSource.kt | 3789043444 |
package com.jolufeja.presentation.viewmodel
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.jolufeja.httpclient.error.ErrorHandler
import kotlinx.coroutines.flow.*
abstract class FetcherViewModel<E, V>(errorHandler: ErrorHandler<E>, autoLoad: Boolean = true) : ViewModel() {
protected val dataSource: DataSource<E, V> =
DataSource(::fetchData, errorHandler, viewModelScope, autoLoad = autoLoad)
protected abstract suspend fun fetchData(): V
val fetchStatus: StateFlow<DataSource.State<E, V>> =
dataSource.status
val data: StateFlow<V?> = fetchStatus
.filterIsInstance<DataSource.State.Success<V>>()
.map { it.data }
.stateIn(viewModelScope, SharingStarted.Lazily, null)
val hasError: StateFlow<Boolean> = fetchStatus
.filterIsInstance<DataSource.State.Error<E>>()
.map { true }
.stateIn(viewModelScope, SharingStarted.Lazily, false)
fun refresh() = dataSource.refresh()
}
| tudas-app/tudas-app/lib/presentation/src/main/java/com/jolufeja/presentation/viewmodel/FetcherViewModel.kt | 2990131163 |
package com.jolufeja.presentation
import androidx.fragment.app.Fragment
import kotlinx.coroutines.InternalCoroutinesApi
import kotlinx.coroutines.flow.Flow
@InternalCoroutinesApi
class FragmentObserver<T>(
fragment: Fragment,
private val flow: Flow<T>,
private val collector: suspend (T) -> Unit
) {
init {
fragment.viewLifecycleOwnerLiveData.observe(fragment) { viewLifecycleOwner ->
FlowObserver(viewLifecycleOwner, flow, collector)
}
}
}
@InternalCoroutinesApi
inline fun <reified T> Flow<T>.observe(
fragment: Fragment,
noinline collector: suspend (T) -> Unit
) = FragmentObserver(fragment, this, collector)
@InternalCoroutinesApi
inline fun <reified T> Flow<T>.observeIn(
fragment: Fragment
) = FragmentObserver(fragment, this) {}
| tudas-app/tudas-app/lib/presentation/src/main/java/com/jolufeja/presentation/FragmentObserver.kt | 2479998799 |
package com.jolufeja.presentation
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.InternalCoroutinesApi
import kotlinx.coroutines.Job
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.FlowCollector
import kotlinx.coroutines.launch
@InternalCoroutinesApi
class FlowObserver<T>(
lifecycleOwner: LifecycleOwner,
private val flow: Flow<T>,
private val collector: suspend (T) -> Unit
) {
private var job: Job? = null
init {
lifecycleOwner.lifecycle.addObserver(LifecycleEventObserver { source: LifecycleOwner, event: Lifecycle.Event ->
when (event) {
Lifecycle.Event.ON_START -> {
job = source.lifecycleScope.launch {
flow.collect(
object : FlowCollector<T> {
override suspend fun emit(value: T) = collector(value)
}
)
}
}
Lifecycle.Event.ON_STOP -> {
job?.cancel()
job = null
}
else -> {}
}
})
}
}
@InternalCoroutinesApi
inline fun <reified T> Flow<T>.observeOnLifecycle(
lifecycleOwner: LifecycleOwner,
noinline collector: suspend (T) -> Unit
) = FlowObserver(lifecycleOwner, this, collector)
@InternalCoroutinesApi
inline fun <reified T> Flow<T>.observeInLifecycle(
lifecycleOwner: LifecycleOwner
) = FlowObserver(lifecycleOwner, this) {} | tudas-app/tudas-app/lib/presentation/src/main/java/com/jolufeja/presentation/FlowObserver.kt | 1263813487 |
package com.jolufeja.presentation.fragment
import android.os.Bundle
import android.view.View
import androidx.annotation.LayoutRes
import androidx.databinding.ViewDataBinding
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModel
import org.koin.androidx.viewmodel.ext.android.viewModel
import kotlin.reflect.KClass
/**
* Data bound fragment.
* See also [View binding](https://developer.android.com/topic/libraries/view-binding)
*
* @param VM
* @param B
* @property viewModelPropertyId
* @constructor
*
* @param layoutId
* @param viewModelClass
*/
abstract class DataBoundFragment<VM : ViewModel, B : ViewDataBinding>(
@LayoutRes layoutId: Int,
viewModelClass: KClass<VM>,
private val viewModelPropertyId: Int
) : Fragment(layoutId) {
open val viewModel: VM by viewModel(clazz = viewModelClass)
final override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
val binding = createBinding(view)
binding.lifecycleOwner = this
binding.setVariable(viewModelPropertyId, viewModel)
binding.setBindingVariables()
onViewAndBindingCreated(view, binding, savedInstanceState)
}
protected abstract fun createBinding(view: View): B
protected open fun B.setBindingVariables() {}
protected open fun onViewAndBindingCreated(view: View, binding: B, savedInstanceState: Bundle?) {}
} | tudas-app/tudas-app/lib/presentation/src/main/java/com/jolufeja/presentation/fragment/DataBoundFragment.kt | 4123416472 |
package com.example.smunsia1
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.example.smunsia1", appContext.packageName)
}
} | smunsia/app/src/androidTest/java/com/example/smunsia1/ExampleInstrumentedTest.kt | 1086309840 |
package com.example.smunsia1
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} | smunsia/app/src/test/java/com/example/smunsia1/ExampleUnitTest.kt | 4133980410 |
package com.example.smunsia1
import android.annotation.SuppressLint
import androidx.annotation.DrawableRes
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.wrapContentWidth
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.Scaffold
import androidx.compose.material.Text
import androidx.compose.material.TopAppBar
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.ArrowBack
import androidx.compose.material3.Button
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.TextField
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.livedata.observeAsState
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.navigation.NavController
import com.example.smunsia1.ui.EditProfileViewModel
@OptIn(ExperimentalMaterial3Api::class)
@SuppressLint("UnusedMaterialScaffoldPaddingParameter")
@Composable
fun ScreenEditProfile(navController: NavController, editProfileViewModel: EditProfileViewModel, username: String) {
// Ambil data pengguna dari ViewModel
val users by editProfileViewModel.users.observeAsState()
// Filter data pengguna berdasarkan username
val filteredUsers = users?.filter { it.username == username } ?: emptyList()
// Ambil data pengguna pertama dari daftar yang difilter
val user = filteredUsers.firstOrNull()
// State untuk menyimpan nilai username dan email yang diubah oleh pengguna
var editedUsername by remember { mutableStateOf(user?.username ?: "") }
var editedEmail by remember { mutableStateOf(user?.email ?: "") }
Scaffold(
topBar = {
TopAppBar(
backgroundColor = Color.LightGray,
elevation = 4.dp,
modifier = Modifier
.fillMaxWidth()
.height(56.dp)
) {
val density = LocalDensity.current.density
Row(
modifier = Modifier
.fillMaxSize()
.padding(start = 16.dp, end = 16.dp),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
IconButton(onClick = { navController.popBackStack() }) {
Icon(Icons.Default.ArrowBack, contentDescription = "Back")
}
Text(
text = "Edit Profile",
style = MaterialTheme.typography.bodyMedium,
fontWeight = FontWeight.Bold,
modifier = Modifier
.weight(1f)
.wrapContentWidth(Alignment.CenterHorizontally)
)
}
}
}
) {
LazyColumn {
items(filteredUsers) { user ->
// Tampilkan informasi pengguna (username dan email) di TextField
TextField(
value = editedUsername,
onValueChange = { editedUsername = it },
label = { Text("Username") },
modifier = Modifier
.fillMaxWidth()
.padding(16.dp)
)
TextField(
value = editedEmail,
onValueChange = { editedEmail = it },
label = { Text("Email") },
modifier = Modifier
.fillMaxWidth()
.padding(16.dp)
)
Button(
onClick = {
// Panggil fungsi untuk memperbarui profil pengguna
editProfileViewModel.updateProfile(username, editedUsername, editedEmail)
// Navigasi kembali ke halaman sebelumnya
navController.popBackStack()
},
modifier = Modifier
.fillMaxWidth()
.padding(16.dp)
) {
Text("Simpan Perubahan")
}
}
}
}
}
data class Profile(
@DrawableRes val imageId: Int,
)
| smunsia/app/src/main/java/com/example/smunsia1/EditProfile.kt | 4139187940 |
package com.example.smunsia1.ui.home
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
class HomeViewModel : ViewModel() {
private val _text = MutableLiveData<String>().apply {
value = "This is home Fragment"
}
val text: LiveData<String> = _text
} | smunsia/app/src/main/java/com/example/smunsia1/ui/home/HomeViewModel.kt | 2546656237 |
package com.example.smunsia1.ui.home
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModelProvider
import com.example.smunsia1.databinding.FragmentHomeBinding
class HomeFragment : Fragment() {
private var _binding: FragmentHomeBinding? = null
// This property is only valid between onCreateView and
// onDestroyView.
private val binding get() = _binding!!
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
val homeViewModel =
ViewModelProvider(this).get(HomeViewModel::class.java)
_binding = FragmentHomeBinding.inflate(inflater, container, false)
val root: View = binding.root
val textView: TextView = binding.textHome
homeViewModel.text.observe(viewLifecycleOwner) {
textView.text = it
}
return root
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | smunsia/app/src/main/java/com/example/smunsia1/ui/home/HomeFragment.kt | 2114692490 |
package com.example.smunsia1.ui
import android.net.Uri
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import com.example.smunsia1.Postingan
import com.example.smunsia1.PostinganRepository
import com.example.smunsia1.UserRepository
import com.google.firebase.database.DataSnapshot
import com.google.firebase.database.DatabaseError
import com.google.firebase.database.DatabaseReference
import com.google.firebase.database.FirebaseDatabase
import com.google.firebase.database.ValueEventListener
class AuthViewModel : ViewModel() {
private val _username = MutableLiveData<String>()
val username: LiveData<String>
get() = _username
fun setLoggedInUser(username: String) {
_username.value = username
}
private val _selectedImageUri = MutableLiveData<Uri?>()
val selectedImageUri: LiveData<Uri?> get() = _selectedImageUri
fun setSelectedImageUri(uri: Uri?) {
_selectedImageUri.value = uri
}
}
class PostinganViewModel : ViewModel() {
private val repository = PostinganRepository()
val postingans = repository.postingans
fun getPostingansByUsername(username: String): LiveData<List<Postingan>> {
return repository.getPostingansByUsername(username)
}
}
class GroupListViewModel : ViewModel() {
private val _groups = MutableLiveData<List<Group>>()
val groups: LiveData<List<Group>> get() = _groups
private val database: DatabaseReference = FirebaseDatabase.getInstance().reference.child("groups")
init {
// Panggil fungsi ini untuk mengambil daftar grup saat ViewModel diinisialisasi
fetchGroups()
}
// Fungsi ini akan dipanggil untuk mengambil daftar grup dari Firebase Realtime Database
fun fetchGroups() {
val groupsList = mutableListOf<Group>()
database.addValueEventListener(object : ValueEventListener {
override fun onDataChange(snapshot: DataSnapshot) {
for (groupSnapshot in snapshot.children) {
val groupId = groupSnapshot.key ?: ""
val groupName = groupSnapshot.child("groupName").getValue(String::class.java) ?: ""
val description = groupSnapshot.child("description").getValue(String::class.java) ?: ""
val group = Group(groupId, groupName, description)
groupsList.add(group)
}
_groups.value = groupsList
}
override fun onCancelled(error: DatabaseError) {
// Handle error, misalnya log atau tampilkan pesan ke pengguna
error.toException().printStackTrace()
}
})
}
}
data class Group(
val groupId: String,
val groupName: String,
val description: String
)
class UserViewModel : ViewModel() {
private val repository = UserRepository()
val users = repository.users
}
| smunsia/app/src/main/java/com/example/smunsia1/ui/ViewModel.kt | 4205176407 |
package com.example.smunsia1.ui.gallery
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
class GalleryViewModel : ViewModel() {
private val _text = MutableLiveData<String>().apply {
value = "This is gallery Fragment"
}
val text: LiveData<String> = _text
} | smunsia/app/src/main/java/com/example/smunsia1/ui/gallery/GalleryViewModel.kt | 879548212 |
package com.example.smunsia1.ui.gallery
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModelProvider
import com.example.smunsia1.databinding.FragmentGalleryBinding
class GalleryFragment : Fragment() {
private var _binding: FragmentGalleryBinding? = null
// This property is only valid between onCreateView and
// onDestroyView.
private val binding get() = _binding!!
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
val galleryViewModel =
ViewModelProvider(this).get(GalleryViewModel::class.java)
_binding = FragmentGalleryBinding.inflate(inflater, container, false)
val root: View = binding.root
val textView: TextView = binding.textGallery
galleryViewModel.text.observe(viewLifecycleOwner) {
textView.text = it
}
return root
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | smunsia/app/src/main/java/com/example/smunsia1/ui/gallery/GalleryFragment.kt | 3248881582 |
package com.example.smunsia1.ui.theme
import androidx.compose.ui.graphics.Color
val Purple80 = Color(0xFFD0BCFF)
val PurpleGrey80 = Color(0xFFCCC2DC)
val Pink80 = Color(0xFFEFB8C8)
val Purple40 = Color(0xFF6650a4)
val PurpleGrey40 = Color(0xFF625b71)
val Pink40 = Color(0xFF7D5260) | smunsia/app/src/main/java/com/example/smunsia1/ui/theme/Color.kt | 3307844711 |
package com.example.smunsia1.ui.theme
import android.app.Activity
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.SideEffect
import androidx.compose.ui.graphics.toArgb
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalView
import androidx.core.view.WindowCompat
private val DarkColorScheme = darkColorScheme(
primary = Purple80,
secondary = PurpleGrey80,
tertiary = Pink80
)
private val LightColorScheme = lightColorScheme(
primary = Purple40,
secondary = PurpleGrey40,
tertiary = Pink40
/* Other default colors to override
background = Color(0xFFFFFBFE),
surface = Color(0xFFFFFBFE),
onPrimary = Color.White,
onSecondary = Color.White,
onTertiary = Color.White,
onBackground = Color(0xFF1C1B1F),
onSurface = Color(0xFF1C1B1F),
*/
)
@Composable
fun Smunsia1Theme(
darkTheme: Boolean = isSystemInDarkTheme(),
// Dynamic color is available on Android 12+
dynamicColor: Boolean = true,
content: @Composable () -> Unit
) {
val colorScheme = when {
dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
val context = LocalContext.current
if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
}
darkTheme -> DarkColorScheme
else -> LightColorScheme
}
val view = LocalView.current
if (!view.isInEditMode) {
SideEffect {
val window = (view.context as Activity).window
window.statusBarColor = colorScheme.primary.toArgb()
WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = darkTheme
}
}
MaterialTheme(
colorScheme = colorScheme,
typography = Typography,
content = content
)
} | smunsia/app/src/main/java/com/example/smunsia1/ui/theme/Theme.kt | 4274962152 |
package com.example.smunsia1.ui.theme
import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
// Set of Material typography styles to start with
val Typography = Typography(
bodyLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 16.sp,
lineHeight = 24.sp,
letterSpacing = 0.5.sp
)
/* Other default text styles to override
titleLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 22.sp,
lineHeight = 28.sp,
letterSpacing = 0.sp
),
labelSmall = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Medium,
fontSize = 11.sp,
lineHeight = 16.sp,
letterSpacing = 0.5.sp
)
*/
) | smunsia/app/src/main/java/com/example/smunsia1/ui/theme/Type.kt | 840915999 |
package com.example.smunsia1.ui.slideshow
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
class SlideshowViewModel : ViewModel() {
private val _text = MutableLiveData<String>().apply {
value = "This is slideshow Fragment"
}
val text: LiveData<String> = _text
} | smunsia/app/src/main/java/com/example/smunsia1/ui/slideshow/SlideshowViewModel.kt | 218037708 |
package com.example.smunsia1.ui.slideshow
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModelProvider
import com.example.smunsia1.databinding.FragmentSlideshowBinding
class SlideshowFragment : Fragment() {
private var _binding: FragmentSlideshowBinding? = null
// This property is only valid between onCreateView and
// onDestroyView.
private val binding get() = _binding!!
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
val slideshowViewModel =
ViewModelProvider(this).get(SlideshowViewModel::class.java)
_binding = FragmentSlideshowBinding.inflate(inflater, container, false)
val root: View = binding.root
val textView: TextView = binding.textSlideshow
slideshowViewModel.text.observe(viewLifecycleOwner) {
textView.text = it
}
return root
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | smunsia/app/src/main/java/com/example/smunsia1/ui/slideshow/SlideshowFragment.kt | 227447390 |
package com.example.smunsia1
import android.app.Application
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import com.example.smunsia1.ui.theme.Smunsia1Theme
import com.google.firebase.FirebaseApp
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
Smunsia1Theme {
Nav()
}
}
}
}
class MyApplication : Application() {
override fun onCreate() {
super.onCreate()
FirebaseApp.initializeApp(this)
}
}
| smunsia/app/src/main/java/com/example/smunsia1/MainActivity.kt | 774481703 |
package com.example.smunsia1
data class Postingan(
val username: String = "",
val caption: String = "",
val imageUrl: String = "",
val timestamp: Long = 0
) | smunsia/app/src/main/java/com/example/smunsia1/Postingan.kt | 3493287761 |
package com.example.smunsia1
import android.net.Uri
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.result.contract.ActivityResultContracts
import androidx.annotation.DrawableRes
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.MaterialTheme
import androidx.compose.material.Scaffold
import androidx.compose.material.Text
import androidx.compose.material.TextField
import androidx.compose.material.TopAppBar
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.AddCircle
import androidx.compose.material.icons.filled.ArrowBack
import androidx.compose.material3.Button
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.painter.Painter
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.navigation.NavController
import coil.compose.rememberImagePainter
import com.example.smunsia1.ui.AuthViewModel
import com.google.firebase.database.DatabaseReference
import com.google.firebase.database.ktx.database
import com.google.firebase.ktx.Firebase
import com.google.firebase.storage.ktx.storage
import java.util.UUID
@Composable
fun PostPage(navController: NavController, authViewModel: AuthViewModel, username: String) {
var username = username
var descriptionText by remember { mutableStateOf("") }
var selectedImageUri by remember { mutableStateOf<Uri?>(null) }
val pickImageLauncher = rememberLauncherForActivityResult(contract = ActivityResultContracts.GetContent()) { uri: Uri? ->
selectedImageUri = uri
}
Scaffold(
topBar = {
TopAppBar(
title = { Text("Buat postingan") },
backgroundColor = Color.LightGray,
navigationIcon = {
IconButton(onClick = { navController.popBackStack() }) {
Icon(Icons.Default.ArrowBack, contentDescription = "Back")
}
}
)
}
) {
LazyColumn(
modifier = Modifier.fillMaxSize(),
content = {
items(
items = listOf(
Post(
imageId = R.drawable.image1,
title = "Caption :",
description = descriptionText,
),
)
) { post ->
PostItem(
post = post,
username = username,
onDescriptionChanged = { descriptionText = it },
onImageClick = { pickImageLauncher.launch("image/*") },
selectedImageUri = selectedImageUri,
onImageSelected = { uri -> selectedImageUri = uri },
navController = navController
)
selectedImageUri?.let { uri ->
Image(
painter = rememberImagePainter(uri),
contentDescription = null,
modifier = Modifier.fillMaxWidth().size(200.dp)
)
}
}
}
)
}
}
@Composable
fun PostItem(
post: Post,
username: String,
onDescriptionChanged: (String) -> Unit,
onImageClick: () -> Unit,
selectedImageUri: Uri?,
onImageSelected: (Uri?) -> Unit,
navController: NavController
) {
val painter: Painter = painterResource(id = post.imageId)
Column(
modifier = Modifier.fillMaxWidth()
) {
Column(
modifier = Modifier.fillMaxWidth(),
horizontalAlignment = Alignment.CenterHorizontally
) {
IconButton(
onClick = { onImageClick(); onImageSelected(selectedImageUri) },
modifier = Modifier
.padding(top = 8.dp)
.size(40.dp)
) {
Icon(imageVector = Icons.Default.AddCircle, contentDescription = "Add")
}
}
Column(
modifier = Modifier.padding(16.dp),
) {
Text(
text = post.title,
style = MaterialTheme.typography.h6,
textAlign = TextAlign.Start,
)
TextField(
value = post.description,
onValueChange = { onDescriptionChanged(it) },
modifier = Modifier
.fillMaxWidth()
.padding(top = 8.dp),
textStyle = MaterialTheme.typography.body1,
keyboardOptions = KeyboardOptions.Default.copy(
imeAction = ImeAction.Done
),
singleLine = false,
)
Button(
onClick = {
onImageSelected(selectedImageUri)
selectedImageUri?.let { uri ->
// Upload gambar ke Firebase Storage
val imageUrl = uploadGambarKeFirebaseStorage(uri)
// Simpan data ke Firebase Realtime Database
simpanDataKeDatabase(username, post.description, imageUrl, navController)
}
},
modifier = Modifier
.padding(top = 8.dp)
.fillMaxWidth()
) {
Text(text = "Bagikan")
}
}
}
}
data class Post(
@DrawableRes val imageId: Int,
val title: String,
val description: String,
)
fun simpanDataKeDatabase(username: String, caption: String, imageUrl: String, navController: NavController) {
val database = Firebase.database
val postinganRef: DatabaseReference = database.getReference("postingan")
// Buat objek Postingan
val postingan = Postingan(username, caption, imageUrl, timestamp = System.currentTimeMillis())
// Simpan data ke Firebase Realtime Database
val postinganId = postinganRef.push().key
postinganId?.let {
postinganRef.child(it).setValue(postingan)
}
navController.navigate("Posting")
}
fun uploadGambarKeFirebaseStorage(uri: Uri): String {
val storage = Firebase.storage
val storageRef = storage.reference
val imageRef = storageRef.child("images/${UUID.randomUUID()}.jpg")
// Upload file ke Firebase Storage
imageRef.putFile(uri)
.addOnSuccessListener {
imageRef.downloadUrl
.addOnSuccessListener { downloadUri ->
val imageUrl = downloadUri.toString()
}
.addOnFailureListener {
}
}
.addOnFailureListener {
}
return ""
}
| smunsia/app/src/main/java/com/example/smunsia1/NewPost.kt | 3575858052 |
package com.example.smunsia1
import android.annotation.SuppressLint
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.ArrowBack
import androidx.compose.material3.Card
import androidx.compose.material3.Divider
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.livedata.observeAsState
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.tooling.data.UiToolingDataApi
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
import androidx.navigation.NavController
import com.example.smunsia1.ui.AuthViewModel
import com.example.smunsia1.ui.Group
import com.example.smunsia1.ui.GroupListViewModel
@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
@OptIn(UiToolingDataApi::class, ExperimentalMaterial3Api::class)
@Composable
fun GroupList(navController: NavController, authViewModel: AuthViewModel, username: String) {
val groupListViewModel: GroupListViewModel = viewModel()
val groups by groupListViewModel.groups.observeAsState(emptyList())
Scaffold(
topBar = {
androidx.compose.material.TopAppBar(
title = { androidx.compose.material.Text("Daftar Group") },
backgroundColor = Color.LightGray,
navigationIcon = {
IconButton(onClick = { navController.popBackStack() }) {
Icon(Icons.Default.ArrowBack, contentDescription = "Back")
}
}
)
}
) {
Column {
Column {
LazyColumn(
modifier = Modifier
.fillMaxSize()
.padding(top = 60.dp)
) {
items(groups) { group ->
GroupListItem(group = group, navController = navController)
Divider()
}
}
}
}
}
}
@Composable
fun GroupListItem(group: Group, navController: NavController) {
// Implement the UI for each group item
Card(
modifier = Modifier
.fillMaxWidth()
.padding(8.dp)
.clickable { /* Handle group item click, navigate to group details, etc. */ }
) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp)
) {
Text(text = group.groupName, fontWeight = FontWeight.Bold)
Text(text = group.description)
// Add other group details as needed
}
}
}
| smunsia/app/src/main/java/com/example/smunsia1/GroupList.kt | 3237317198 |
package com.example.smunsia1
import android.content.res.Configuration
import androidx.compose.foundation.Image
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.ClickableText
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Email
import androidx.compose.material.icons.filled.Lock
import androidx.compose.material3.Button
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Snackbar
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalConfiguration
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.TextFieldValue
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.navigation.NavHostController
import com.example.smunsia1.ui.AuthViewModel
import com.google.firebase.auth.FirebaseAuth
import com.google.firebase.database.DataSnapshot
import com.google.firebase.database.DatabaseError
import com.google.firebase.database.FirebaseDatabase
import com.google.firebase.database.ValueEventListener
import kotlinx.coroutines.delay
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun ScreenLogin(navController: NavHostController, authViewModel: AuthViewModel) {
var email by remember { mutableStateOf(TextFieldValue("")) }
var password by remember { mutableStateOf(TextFieldValue("")) }
var showMessage by remember { mutableStateOf(false) }
var message by remember { mutableStateOf("") }
val isLandscape = LocalConfiguration.current.orientation == Configuration.ORIENTATION_LANDSCAPE
Column(
modifier = Modifier.fillMaxSize(),
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
) {
if (isLandscape) {
Row(
modifier = Modifier.fillMaxSize(),
horizontalArrangement = Arrangement.SpaceEvenly,
verticalAlignment = Alignment.CenterVertically
) {
// content for landscape mode
Logo1()
Column(
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
) {
HeaderText(text = "Login")
Spacer(modifier = Modifier.height(16.dp))
OutlinedTextField(
value = email,
onValueChange = { email = it },
label = { Text(text = stringResource(id = R.string.label_email_address)) },
placeholder = { Text(text = "") },
shape = RoundedCornerShape(8.dp),
leadingIcon = {
Icon(
imageVector = Icons.Default.Email,
contentDescription = "Email Icon"
)
}
)
Spacer(modifier = Modifier.height(10.dp))
OutlinedTextField(
value = password,
onValueChange = { password = it },
label = { Text(text = stringResource(id = R.string.label_password)) },
placeholder = { Text(text = stringResource(id = R.string.hint_enter_password)) },
shape = RoundedCornerShape(8.dp),
leadingIcon = {
Icon(
imageVector = Icons.Default.Lock,
contentDescription = "Email Icon"
)
}
)
Spacer(modifier = Modifier.height(15.dp))
Button(onClick = {
navController.navigate("Posting")
}) {
Text(text = "Login", fontSize = 20.sp)
}
}
}
} else {
// content for portrait mode
Logo1()
Spacer(modifier = Modifier.height(8.dp))
HeaderText(text = "Login")
Spacer(modifier = Modifier.height(16.dp))
OutlinedTextField(
value = email,
onValueChange = { email = it },
label = { Text(text = stringResource(id = R.string.label_email_address)) },
placeholder = { Text(text = "") },
shape = RoundedCornerShape(8.dp),
leadingIcon = {
Icon(
imageVector = Icons.Default.Email,
contentDescription = "Email Icon"
)
}
)
Spacer(modifier = Modifier.height(10.dp))
OutlinedTextField(
value = password,
onValueChange = { password = it },
label = { Text(text = stringResource(id = R.string.label_password)) },
placeholder = { Text(text = stringResource(id = R.string.hint_enter_password)) },
shape = RoundedCornerShape(8.dp),
leadingIcon = {
Icon(
imageVector = Icons.Default.Lock,
contentDescription = "Email Icon"
)
}
)
Spacer(modifier = Modifier.height(15.dp))
Button(onClick = {
// Validasi data pengguna sebelum menyimpan ke database
if (email.text.isNotEmpty() && password.text.isNotEmpty()) {
// Menggunakan Firebase Authentication untuk otentikasi
FirebaseAuth.getInstance().signInWithEmailAndPassword(
email.text, password.text
).addOnCompleteListener { task ->
if (task.isSuccessful) {
val user = task.result?.user
val userUid = user?.uid
// Ambil data dari Realtime Database
if (userUid != null) {
val databaseReference = FirebaseDatabase.getInstance().getReference("users")
databaseReference.child(userUid).addListenerForSingleValueEvent(object :
ValueEventListener {
override fun onDataChange(dataSnapshot: DataSnapshot) {
val username = dataSnapshot.child("username").getValue(String::class.java)
authViewModel.setLoggedInUser(username ?: "")
}
override fun onCancelled(databaseError: DatabaseError) {
}
})
}
// Lanjutkan navigasi
navController.navigate("Posting")
} else {
// Jika otentikasi gagal, tampilkan pesan kesalahan
showMessage = true
message = "Email atau password salah"
}
}
} else {
// Menampilkan pesan kesalahan jika data tidak lengkap
showMessage = true
message = "Harap isi semua kolom dengan benar"
}
}) {
Text(text = "Login", fontSize = 20.sp)
}
}
if (showMessage) {
LaunchedEffect(showMessage) {
delay(2000L)
showMessage = false
}
Snackbar(
modifier = Modifier.padding(8.dp),
action = {
TextButton(onClick = { showMessage = false }) {
Text("")
}
}
) {
Text(message)
}
}
Spacer(modifier = Modifier.height(15.dp))
Row(
modifier = Modifier
.padding(vertical = 8.dp)
.clickable {
navController.navigate("Register")
}
) {
val annotatedString = buildAnnotatedString {
append("Belum memiliki akun? ")
withStyle(style = SpanStyle(color = Color.Green)) {
append("Register")
}
}
ClickableText(
text = annotatedString,
onClick = {
navController.navigate("Register")
},
modifier = Modifier.padding(vertical = 8.dp)
)
}
Spacer(modifier = Modifier.height(15.dp))
Row(
verticalAlignment = Alignment.CenterVertically,
modifier = Modifier.padding(8.dp)
) {
Text(text = "Powered by", fontSize = 20.sp, modifier = Modifier.padding(end = 8.dp))
Logo2()
}
}
}
@Composable
fun Logo1() {
val logoModifier = Modifier
.size(150.dp)
.padding(8.dp)
Image(
painter = painterResource(id = R.drawable.logo),
contentDescription = null,
modifier = logoModifier
)
}
@Composable
fun Logo2() {
val logoModifier = Modifier
.size(100.dp)
Image(
painter = painterResource(id = R.drawable.unsia),
contentDescription = null,
modifier = logoModifier
)
}
@Composable
fun HeaderText(text: String) {
Text(
text = text,
fontSize = 24.sp,
fontWeight = FontWeight.Bold
)
}
| smunsia/app/src/main/java/com/example/smunsia1/Login.kt | 4137458036 |
package com.example.smunsia1
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import com.google.firebase.database.DataSnapshot
import com.google.firebase.database.DatabaseError
import com.google.firebase.database.FirebaseDatabase
import com.google.firebase.database.ValueEventListener
class UserRepository {
private val database = FirebaseDatabase.getInstance()
private val userRef = database.getReference("users")
private val _users = MutableLiveData<List<User>>()
val users: LiveData<List<User>> get() = _users
init {
fetchUsers()
}
private fun fetchUsers() {
userRef.addValueEventListener(object : ValueEventListener {
override fun onDataChange(snapshot: DataSnapshot) {
val usersList = mutableListOf<User>()
for (postSnapshot in snapshot.children) {
val user = postSnapshot.getValue(User::class.java)
user?.let {
usersList.add(it)
}
}
_users.value = usersList
}
override fun onCancelled(error: DatabaseError) {
// Handle error if needed
}
})
}
fun updateUserProfile(username: String, newUsername: String, newEmail: String) {
// Cari data pengguna berdasarkan username
userRef.orderByChild("username").equalTo(username).addListenerForSingleValueEvent(object : ValueEventListener {
override fun onDataChange(snapshot: DataSnapshot) {
for (userSnapshot in snapshot.children) {
// Dapatkan ID pengguna
val userId = userSnapshot.key ?: ""
// Buat objek User dan update nilai username dan email
val updatedUser = User(newUsername, newEmail)
userRef.child(userId).setValue(updatedUser)
}
}
override fun onCancelled(error: DatabaseError) {
// Handle error
}
})
}
}
| smunsia/app/src/main/java/com/example/smunsia1/UserRepository.kt | 2045480519 |
package com.example.smunsia1
import android.annotation.SuppressLint
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.Checkbox
import androidx.compose.material.MaterialTheme
import androidx.compose.material.Scaffold
import androidx.compose.material.Text
import androidx.compose.material.TextField
import androidx.compose.material.TopAppBar
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.ArrowBack
import androidx.compose.material3.Button
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateListOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.painter.Painter
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
import androidx.navigation.NavController
import com.example.smunsia1.ui.AuthViewModel
import com.example.smunsia1.ui.PostinganViewModel
import com.google.firebase.database.ktx.database
import com.google.firebase.ktx.Firebase
data class Contact(val id: Int, val name: String, val avatar: Painter)
@SuppressLint("UnusedMaterialScaffoldPaddingParameter")
@Composable
fun ScreenGroup(navController: NavController, authViewModel: AuthViewModel, username: String, postinganViewModel: PostinganViewModel = viewModel()) {
var nameText by remember { mutableStateOf("Nama Group") }
var descriptionText by remember { mutableStateOf("Deskripsi Group") }
val postingans = postinganViewModel.postingans.value ?: emptyList()
val uniqueUsernames = postingans.map { it.username }.distinct()
val selectedUsernames = remember { mutableStateListOf<String>() }
val firebaseRepository = FirebaseRepository()
Scaffold(
topBar = {
TopAppBar(
title = { Text("Buat Group baru") },
backgroundColor = Color.LightGray,
navigationIcon = {
IconButton(onClick = { navController.popBackStack() }) {
Icon(Icons.Default.ArrowBack, contentDescription = "Back")
}
}
)
}
) {
Column {
Column {
TextField(
value = nameText,
onValueChange = { nameText = it },
modifier = Modifier
.fillMaxWidth()
.padding(top = 8.dp)
.padding(bottom = 8.dp)
.padding(start = 8.dp)
.padding(end = 8.dp),
textStyle = MaterialTheme.typography.body1,
keyboardOptions = KeyboardOptions.Default.copy(
imeAction = ImeAction.Done
),
singleLine = true,
)
TextField(
value = descriptionText,
onValueChange = { descriptionText = it },
modifier = Modifier
.fillMaxWidth()
.padding(top = 8.dp)
.padding(bottom = 8.dp)
.padding(start = 8.dp)
.padding(end = 8.dp),
textStyle = MaterialTheme.typography.body1,
keyboardOptions = KeyboardOptions.Default.copy(
imeAction = ImeAction.Done
),
singleLine = true,
)
}
Text(
text = "Pilih kontak ",
style = MaterialTheme.typography.h6,
textAlign = TextAlign.Start,
)
LazyColumn(
modifier = Modifier
) {
items(uniqueUsernames) { uniqueUsername ->
Row(
modifier = Modifier
.fillMaxWidth()
.padding(8.dp),
verticalAlignment = Alignment.CenterVertically
) {
Checkbox(
checked = selectedUsernames.contains(uniqueUsername),
onCheckedChange = { isChecked ->
if (isChecked) {
selectedUsernames.add(uniqueUsername)
} else {
selectedUsernames.remove(uniqueUsername)
}
},
modifier = Modifier.padding(end = 8.dp)
)
Text(text = uniqueUsername, modifier = Modifier.weight(1f))
}
}
}
Button(
onClick = {
firebaseRepository.createGroup(nameText, descriptionText, selectedUsernames)
navController.navigate("GroupList")
},
modifier = Modifier
.fillMaxWidth()
.padding(top = 8.dp)
) {
Text(text = "Buat Group")
}
}
}
}
data class Group(
val groupId: String,
val groupName: String,
val description: String
)
data class GroupMember(
val groupId: String,
val userId: String
)
class FirebaseRepository {
private val groupsRef = Firebase.database.reference.child("groups")
private val groupMembersRef = Firebase.database.reference.child("groupMembers")
fun createGroup(groupName: String, description: String, memberUserIds: List<String>) {
val groupId = groupsRef.push().key // Generate a unique key for the group
val group = Group(groupId!!, groupName, description)
groupsRef.child(groupId).setValue(group)
// Add group members
memberUserIds.forEach { userId ->
val groupMember = GroupMember(groupId, userId)
groupMembersRef.child(groupId).child(userId).setValue(groupMember)
}
}
}
//@Composable
//fun CreateGroup(postingan: Postingan, navController: NavController) {
// Text(
// text = "${postingan.username}",
// fontWeight = FontWeight.Bold,
// modifier = Modifier
// .fillMaxWidth()
// .padding(8.dp) // Adjust the padding as needed
// )
//}
| smunsia/app/src/main/java/com/example/smunsia1/NewGroup.kt | 1023491903 |
package com.example.smunsia1
import androidx.compose.runtime.Composable
import androidx.compose.runtime.livedata.observeAsState
import androidx.lifecycle.viewmodel.compose.viewModel
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.rememberNavController
import com.example.smunsia1.ui.AuthViewModel
import com.example.smunsia1.ui.EditProfileViewModel
import com.example.smunsia1.ui.PostinganViewModel
@Composable
fun Nav(){
val navController = rememberNavController()
val authViewModel: AuthViewModel = viewModel()
val editProfileViewModel : EditProfileViewModel = viewModel()
val postinganViewModel: PostinganViewModel = PostinganViewModel()
NavHost(navController = navController, startDestination = "Login"){
composable(route = "Login") { backStackEntry ->
val usernameState = authViewModel.username.observeAsState(initial = "")
val username = usernameState.value
ScreenLogin(navController, authViewModel)
}
composable(route = "Register"){
ScreenRegister(navController)
}
composable(route = "Profile/{username}") { backStackEntry ->
val username = backStackEntry.arguments?.getString("username")
if (username != null) {
ScreenProfile(navController, username)
}
}
composable(route = "Posting") {
ScreenPosting(navController, authViewModel, postinganViewModel)
}
composable(route = "Message"){
ScreenMessage(navController)
}
composable(route = "NewPost/{username}") { backStackEntry ->
val usernameState = authViewModel.username.observeAsState(initial = "")
val username = usernameState.value
PostPage(navController, authViewModel, username)
}
composable(route = "NewGroup/{username}") { backStackEntry ->
val usernameState = authViewModel.username.observeAsState(initial = "")
val username = usernameState.value
ScreenGroup(navController, authViewModel, username)
}
composable(route = "GroupList/{username}") { backStackEntry ->
val usernameState = authViewModel.username.observeAsState(initial = "")
val username = usernameState.value
GroupList(navController, authViewModel, username)
}
composable(route = "EditProfile/{username}") { backStackEntry ->
val usernameState = editProfileViewModel.users.observeAsState(initial = "")
val username = backStackEntry.arguments?.getString("username") ?: ""
ScreenEditProfile(navController, editProfileViewModel, username)
}
}
}
| smunsia/app/src/main/java/com/example/smunsia1/NavGraph.kt | 2522847646 |
package com.example.smunsia1
import android.content.res.Configuration
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.ClickableText
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Email
import androidx.compose.material.icons.filled.Lock
import androidx.compose.material.icons.filled.Person
import androidx.compose.material3.Button
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Snackbar
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalConfiguration
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.input.TextFieldValue
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.navigation.NavHostController
import com.google.firebase.auth.FirebaseAuth
import com.google.firebase.database.FirebaseDatabase
import kotlinx.coroutines.delay
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun ScreenRegister(navController: NavHostController) {
var username by remember { mutableStateOf(TextFieldValue("")) }
var email by remember { mutableStateOf(TextFieldValue("")) }
var password1 by remember { mutableStateOf(TextFieldValue("")) }
var password2 by remember { mutableStateOf(TextFieldValue("")) }
var showMessage by remember { mutableStateOf(false) }
var message by remember { mutableStateOf("") }
val isLandscape = LocalConfiguration.current.orientation == Configuration.ORIENTATION_LANDSCAPE
Column(
modifier = Modifier.fillMaxSize(),
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
) {
Logo1()
Spacer(modifier = Modifier.height(8.dp))
HeaderText(text = "Register")
if (isLandscape) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 16.dp),
horizontalArrangement = Arrangement.SpaceBetween
) {
Column {
OutlinedTextField(
value = username,
onValueChange = { username = it },
label = { Text(text = stringResource(id = R.string.label_username)) },
placeholder = { Text(text = "") },
shape = RoundedCornerShape(8.dp),
leadingIcon = {
Icon(
imageVector = Icons.Default.Person,
contentDescription = "Person Icon"
)
}
)
OutlinedTextField(
value = email,
onValueChange = { email = it },
label = { Text(text = stringResource(id = R.string.label_email_address)) },
placeholder = { Text(text = "") },
shape = RoundedCornerShape(8.dp),
leadingIcon = {
Icon(
imageVector = Icons.Default.Email,
contentDescription = "Email Icon"
)
}
)
}
Column {
OutlinedTextField(
value = password1,
onValueChange = { password1 = it },
label = { Text(text = stringResource(id = R.string.label_password)) },
placeholder = { Text(text = stringResource(id = R.string.hint_enter_password)) },
shape = RoundedCornerShape(8.dp),
leadingIcon = {
Icon(
imageVector = Icons.Default.Lock,
contentDescription = "Lock Icon"
)
}
)
OutlinedTextField(
value = password2,
onValueChange = { password2 = it },
label = { Text(text = stringResource(id = R.string.label_password)) },
placeholder = { Text(text = stringResource(id = R.string.hint_enter_password)) },
shape = RoundedCornerShape(8.dp),
leadingIcon = {
Icon(
imageVector = Icons.Default.Lock,
contentDescription = "Lock Icon"
)
}
)
}
}
} else {
OutlinedTextField(
value = username,
onValueChange = { username = it },
label = { Text(text = stringResource(id = R.string.label_username)) },
placeholder = { Text(text = "") },
shape = RoundedCornerShape(8.dp),
leadingIcon = {
Icon(
imageVector = Icons.Default.Person,
contentDescription = "Person Icon"
)
}
)
OutlinedTextField(
value = email,
onValueChange = { email = it },
label = { Text(text = stringResource(id = R.string.label_email_address)) },
placeholder = { Text(text = "") },
shape = RoundedCornerShape(8.dp),
leadingIcon = {
Icon(
imageVector = Icons.Default.Email,
contentDescription = "Email Icon"
)
}
)
OutlinedTextField(
value = password1,
onValueChange = { password1 = it },
label = { Text(text = stringResource(id = R.string.label_password)) },
placeholder = { Text(text = stringResource(id = R.string.hint_enter_password)) },
shape = RoundedCornerShape(8.dp),
leadingIcon = {
Icon(
imageVector = Icons.Default.Lock,
contentDescription = "Lock Icon"
)
}
)
OutlinedTextField(
value = password2,
onValueChange = { password2 = it },
label = { Text(text = stringResource(id = R.string.label_password)) },
placeholder = { Text(text = stringResource(id = R.string.hint_enter_password)) },
shape = RoundedCornerShape(8.dp),
leadingIcon = {
Icon(
imageVector = Icons.Default.Lock,
contentDescription = "Lock Icon"
)
}
)
}
Row(
verticalAlignment = Alignment.CenterVertically,
modifier = Modifier.padding(8.dp)
) {
Text(text = "*) password minimal 6 karakter", fontSize = 12.sp, modifier = Modifier.padding(end = 8.dp))
}
Spacer(modifier = Modifier.height(25.dp))
Button(onClick = {
// Validasi data pengguna sebelum menyimpan ke database
if (username.text.isNotEmpty() && email.text.isNotEmpty() && password1.text.isNotEmpty() && password1.text == password2.text) {
// Menggunakan Firebase Authentication untuk registrasi
FirebaseAuth.getInstance().createUserWithEmailAndPassword(
email.text.toString(),
password1.text.toString()
).addOnCompleteListener { task ->
if (task.isSuccessful) {
// Registrasi berhasil
val userUid = FirebaseAuth.getInstance().currentUser?.uid
saveUserDataToDatabase(userUid, User(username = username.text, email = email.text))
showMessage = true
message = "Registrasi berhasil"
username = TextFieldValue("")
email = TextFieldValue("")
password1 = TextFieldValue("")
password2 = TextFieldValue("")
} else {
// Registrasi gagal, tampilkan pesan kesalahan
showMessage = true
message = "Registrasi gagal: ${task.exception?.message}"
}
}
} else {
// Tampilkan pesan kesalahan jika data tidak lengkap
showMessage = true
message = "Harap isi semua kolom dengan benar"
}
}) {
Text(text = "Register", fontSize = 20.sp)
}
if (showMessage) {
LaunchedEffect(showMessage) {
delay(3000L)
showMessage = false
}
Snackbar(
modifier = Modifier.padding(8.dp),
action = {
TextButton(onClick = { showMessage = false }) {
Text("")
}
}
) {
Text(message)
}
}
Spacer(modifier = Modifier.height(25.dp))
Row(
) {
val annotatedString = buildAnnotatedString {
append("Sudah memiliki akun? ")
withStyle(style = SpanStyle(color = Color.Green)) {
append("Login")
}
}
ClickableText(
text = annotatedString,
onClick = {
navController.navigate("Login")
},
modifier = Modifier.padding(vertical = 8.dp)
)
}
Spacer(modifier = Modifier.height(15.dp))
Row(
verticalAlignment = Alignment.CenterVertically,
modifier = Modifier.padding(8.dp)
) {
Text(text = "Powered by", fontSize = 20.sp, modifier = Modifier.padding(end = 8.dp))
Logo2()
}
}
}
data class User(
val username: String = "",
val email: String = "",
val password: String = ""
)
private fun saveUserDataToDatabase(userUid: String?, user: User) {
if (userUid != null) {
val databaseReference = FirebaseDatabase.getInstance().getReference("users")
databaseReference.child(userUid).setValue(
mapOf(
"username" to user.username,
"email" to user.email
)
)
}
}
| smunsia/app/src/main/java/com/example/smunsia1/Register.kt | 17105352 |
package com.example.smunsia1
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import com.google.firebase.database.DataSnapshot
import com.google.firebase.database.DatabaseError
import com.google.firebase.database.FirebaseDatabase
import com.google.firebase.database.ValueEventListener
class PostinganRepository {
private val database = FirebaseDatabase.getInstance()
private val postinganRef = database.getReference("postingan")
private val _postingans = MutableLiveData<List<Postingan>>()
val postingans: LiveData<List<Postingan>> get() = _postingans
init {
fetchPostingans()
}
private fun fetchPostingans() {
postinganRef.addValueEventListener(object : ValueEventListener {
override fun onDataChange(snapshot: DataSnapshot) {
val postingansList: MutableList<Postingan> = mutableListOf()
for (postSnapshot in snapshot.children) {
val postingan = postSnapshot.getValue(Postingan::class.java)
postingan?.let {
postingansList.add(it)
}
}
val sortedPostingans = postingansList.sortedByDescending { it.timestamp }
_postingans.value = sortedPostingans
}
override fun onCancelled(error: DatabaseError) {
}
})
}
fun getPostingansByUsername(username: String): LiveData<List<Postingan>> {
val postingansLiveData = MutableLiveData<List<Postingan>>()
postinganRef.orderByChild("username").equalTo(username)
.addValueEventListener(object : ValueEventListener {
override fun onDataChange(snapshot: DataSnapshot) {
val postingansList: MutableList<Postingan> = mutableListOf()
for (postSnapshot in snapshot.children) {
val postingan = postSnapshot.getValue(Postingan::class.java)
postingan?.let {
postingansList.add(it)
}
}
postingansLiveData.value = postingansList
}
override fun onCancelled(error: DatabaseError) {
}
})
return postingansLiveData
}
} | smunsia/app/src/main/java/com/example/smunsia1/PostinganRepository.kt | 2427161773 |
package com.example.smunsia1
import android.annotation.SuppressLint
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.BasicTextField
import androidx.compose.foundation.text.KeyboardActions
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.ArrowBack
import androidx.compose.material.icons.filled.Send
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.ExperimentalComposeUiApi
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.platform.LocalFocusManager
import androidx.compose.ui.platform.LocalSoftwareKeyboardController
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.navigation.NavHostController
data class Message(val sender: String, val content: String)
private val Any.content: Any
get() {
TODO("Not yet implemented")
}
private val Any.sender: Any
get() {
TODO("Not yet implemented")
}
@Composable
fun ScreenMessage(navController: NavHostController) {
Column(
modifier = Modifier.fillMaxSize(),
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
) {
DirectMessageScreen(navController = navController, messages = getDummyMessages())
}
}
@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun DirectMessageScreen(navController: NavHostController, messages: List<Message>) {
Scaffold(
topBar = {
TopAppBar(
title = { Text("Irmayanti Juliana") },
navigationIcon = {
IconButton(
onClick = {
// Navigate back
navController.popBackStack()
}
) {
Icon(imageVector = Icons.Default.ArrowBack, contentDescription = null)
}
}
)
},
content = {
Column(
modifier = Modifier
.fillMaxSize()
.padding(16.dp)
) {
LazyColumn(
modifier = Modifier
.weight(1f),
contentPadding = PaddingValues(vertical = 40.dp)
) {
items(messages) { message ->
DirectMessageItem(message = message)
}
}
ComposeMessageSection(
onMessageSent = { newMessage ->
}
)
}
}
)
}
@OptIn(ExperimentalComposeUiApi::class)
@Composable
fun ComposeMessageSection(onMessageSent: (String) -> Unit) {
val focusManager = LocalFocusManager.current
val keyboardController = LocalSoftwareKeyboardController.current
// Input text state
var messageText by remember { mutableStateOf("") }
// Send button click handler
val onSendClick: () -> Unit = {
if (messageText.isNotEmpty()) {
onMessageSent(messageText)
messageText = ""
focusManager.clearFocus()
}
}
// Message input section
Row(
modifier = Modifier
.fillMaxWidth()
.padding(vertical = 8.dp),
verticalAlignment = Alignment.CenterVertically
) {
// Message input field
BasicTextField(
value = messageText,
onValueChange = { messageText = it },
keyboardOptions = KeyboardOptions.Default.copy(
imeAction = androidx.compose.ui.text.input.ImeAction.Send
),
keyboardActions = KeyboardActions(
onSend = {
onSendClick()
keyboardController?.hide()
}
),
modifier = Modifier
.weight(1f)
.padding(horizontal = 8.dp)
)
// Send button
IconButton(
onClick = onSendClick,
modifier = Modifier
.size(40.dp)
.background(MaterialTheme.colorScheme.primary)
.clip(CircleShape)
) {
Icon(imageVector = Icons.Default.Send, contentDescription = "Back")
}
}
}
@Composable
fun DirectMessageItem(message: Message) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(vertical = 8.dp),
horizontalArrangement = Arrangement.Start
) {
if (message.sender == "Irmayanti Juliana") {
Image(
painter = painterResource(id = R.drawable.ava2),
contentDescription = null,
modifier = Modifier
.size(40.dp)
.clip(CircleShape)
.background(MaterialTheme.colorScheme.primary)
)
Column(
modifier = Modifier
.padding(start = 8.dp)
.background(MaterialTheme.colorScheme.background)
.clip(RoundedCornerShape(10.dp))
.clickable {
// Handle clicking on a message (optional)
}
.fillMaxWidth()
) {
Text(text = message.sender, textAlign = TextAlign.Start, fontWeight = FontWeight.Bold)
Spacer(modifier = Modifier.height(4.dp))
Text(text = message.content, textAlign = TextAlign.Start)
}
} else {
Image(
painter = painterResource(id = R.drawable.ava1),
contentDescription = null,
modifier = Modifier
.size(40.dp)
.clip(CircleShape)
.background(MaterialTheme.colorScheme.primary)
)
// Isi pesan pengirim
Column(
modifier = Modifier
.padding(start = 8.dp)
.background(MaterialTheme.colorScheme.background)
.clip(RoundedCornerShape(10.dp))
.fillMaxWidth()
) {
Text(text = "You", textAlign = TextAlign.End, fontWeight = FontWeight.Bold)
Spacer(modifier = Modifier.height(4.dp))
Text(text = message.content, textAlign = TextAlign.End)
}
}
}
}
@Composable
fun getDummyMessages(): List<Message> {
// Replace this function with actual data retrieval logic
return listOf(
Message(sender = "You", content = "Pagi"),
Message(sender = "Irmayanti Juliana", content = "Pagi juga..."),
Message(sender = "You", content = "Gimana progres tugas?"),
Message(sender = "Irmayanti Juliana", content = "Aman...")
)
}
| smunsia/app/src/main/java/com/example/smunsia1/Message.kt | 635012998 |
package com.example.smunsia1
import android.icu.text.SimpleDateFormat
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.aspectRatio
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.layout.wrapContentWidth
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.text.ClickableText
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.Home
import androidx.compose.material.icons.filled.Menu
import androidx.compose.material.icons.filled.Person
import androidx.compose.material.icons.filled.Send
import androidx.compose.material.icons.filled.Settings
import androidx.compose.material.icons.filled.ThumbUp
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.Divider
import androidx.compose.material3.FloatingActionButton
import androidx.compose.material3.Icon
import androidx.compose.material3.LocalContentColor
import androidx.compose.material3.MaterialTheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.livedata.observeAsState
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.compose.ui.zIndex
import androidx.lifecycle.viewmodel.compose.viewModel
import androidx.navigation.NavController
import com.example.smunsia1.ui.AuthViewModel
import com.example.smunsia1.ui.PostinganViewModel
import com.google.firebase.database.ktx.database
import com.google.firebase.ktx.Firebase
import kotlin.random.Random
import androidx.compose.material3.Text as Text1
data class MenuOption(val text: String, val icon: ImageVector, val onClick: (NavController, String) -> Unit)
val database = Firebase.database
val postinganRef = database.getReference("postingan")
val menuOptions = listOf(
MenuOption("New Post", Icons.Filled.Add) { navController, username -> navController.navigate("NewPost/$username") },
MenuOption("New Group", Icons.Filled.Person) { navController, username -> navController.navigate("NewGroup/$username") },
MenuOption("Group", Icons.Filled.Person) { navController, username -> navController.navigate("GroupList/$username") },
MenuOption("Profil", Icons.Filled.Settings) { navController, username -> navController.navigate("EditProfile/$username") },
MenuOption("Logout", Icons.Filled.Home) { navController, username -> navController.navigate("Login") },
)
@Composable
fun ScreenPosting(
navController: NavController,
authViewModel: AuthViewModel,
postinganViewModel: PostinganViewModel = viewModel()
) {
val postingans = postinganViewModel.postingans.value ?: emptyList()
var isMenuExpanded = false
FloatingMenu(
navController = navController,
authViewModel = authViewModel
) { isMenuExpanded = true }
Column(
modifier = Modifier
.fillMaxSize()
.padding(16.dp)
) {
// Header
Row(
modifier = Modifier
.fillMaxWidth()
.weight(1f)
) {
Spacer(modifier = Modifier.width(8.dp))
Text1(
text = "Postingan terbaru",
fontSize = 20.sp,
fontWeight = FontWeight.Bold,
textAlign = TextAlign.Center,
modifier = Modifier
.fillMaxWidth()
.padding(top = 8.dp)
)
}
Spacer(modifier = Modifier.width(8.dp))
Divider(
modifier = Modifier
.fillMaxWidth()
.padding(top = 8.dp, bottom = 8.dp),
color = Color.Gray,
thickness = 1.dp
)
// Content
LazyColumn(
modifier = Modifier
.fillMaxSize()
.weight(10f),
content = {
items(postingans) { postingan ->
PostingItem(postingan = postingan, navController = navController)
}
}
)
}
}
@Composable
fun PostingItem(postingan: Postingan, navController: NavController) {
Card(
modifier = Modifier
.fillMaxWidth()
.padding(8.dp)
) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp)
) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(8.dp),
verticalAlignment = Alignment.CenterVertically
) {
// Avatar
Avatar()
Spacer(modifier = Modifier.width(8.dp))
// User Info (Username and Timestamp)
Column {
ClickableText(
text = buildAnnotatedString {
withStyle(style = SpanStyle(
color = LocalContentColor.current,
fontWeight = FontWeight.Bold,
fontSize = 18.sp
)
) {
append(postingan.username)
}
},
onClick = {
navController.navigate("Profile/${postingan.username}")
},
modifier = Modifier.clickable { }
)
val formattedTimestamp = formatDate(postingan.timestamp)
Text1(
text = "$formattedTimestamp",
fontSize = 14.sp,
color = Color.Gray
)
}
}
// Caption
Text1(text = "${postingan.caption}")
Box(
modifier = Modifier
.fillMaxWidth()
.padding(vertical = 8.dp)
) {
Column {
ImagePost()
}
}
Row(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 20.dp, vertical = 8.dp),
verticalAlignment = Alignment.CenterVertically
) {
CommentColumn()
Spacer(modifier = Modifier.width(120.dp))
LikeColumn()
}
}
}
}
@Composable
fun Avatar() {
val randomAvaIndex = remember { mutableStateOf(Random.nextInt(1, 6)) }
val avatarResourceId = when (randomAvaIndex.value) {
1 -> R.drawable.ava1
2 -> R.drawable.ava2
3 -> R.drawable.ava3
4 -> R.drawable.ava4
5 -> R.drawable.ava5
else -> R.drawable.ava1
}
Image(
painter = painterResource(id = avatarResourceId),
contentDescription = null,
modifier = Modifier
.size(40.dp)
.clip(CircleShape)
.background(MaterialTheme.colorScheme.background)
)
}
@Composable
fun LikeColumn() {
Icon(
imageVector = Icons.Default.ThumbUp,
contentDescription = null,
tint = MaterialTheme.colorScheme.primary,
modifier = Modifier.size(20.dp)
)
Spacer(modifier = Modifier.width(8.dp))
// Teks "likes"
Text1(
text = "21",
fontSize = 14.sp,
fontWeight = FontWeight.Bold,
color = Color.Gray
)
}
@Composable
fun CommentColumn() {
Icon(
imageVector = Icons.Default.Send,
contentDescription = null,
tint = MaterialTheme.colorScheme.primary,
modifier = Modifier.size(24.dp)
)
Spacer(modifier = Modifier.width(8.dp))
Text1(
text = "Komentar",
fontSize = 14.sp,
fontWeight = FontWeight.Bold,
color = Color.Gray
)
}
fun formatDate(timestamp: Long): String {
val date = java.util.Date(timestamp)
val format = SimpleDateFormat("dd-MM-yyyy HH:mm")
return format.format(date)
}
@Composable
fun FloatingMenu(navController: NavController, authViewModel: AuthViewModel, onClickFab: () -> Unit) {
var isMenuOpen by remember { mutableStateOf(false) }
val username by authViewModel.username.observeAsState("")
FloatingActionButton(
onClick = { isMenuOpen = !isMenuOpen },
modifier = Modifier
.padding(8.dp)
) {
Icon(imageVector = Icons.Default.Menu, contentDescription = null)
}
if (isMenuOpen) {
Column(
modifier = Modifier
.background(Color.Transparent.copy(alpha = 0.5f))
.fillMaxSize()
.clickable { isMenuOpen = false }
.padding(16.dp)
.zIndex(4f)
) {
Text1(text = "", fontSize = 12.sp)
Divider(modifier = Modifier.padding(top = 8.dp, bottom = 8.dp))
menuOptions.forEach { option ->
Button(
onClick = {
isMenuOpen = false
option.onClick.invoke(navController, username ?: "")
},
modifier = Modifier
.fillMaxWidth()
.wrapContentWidth(Alignment.Start)
.padding(bottom = 8.dp)
) {
Row(
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(8.dp)
) {
Icon(imageVector = option.icon, contentDescription = null, modifier = Modifier.size(24.dp))
Text1(text = option.text)
}
}
}
}
}
}
@Composable
fun ImagePost() {
val randomImageIndex = remember { mutableStateOf(Random.nextInt(1, 11)) }
val imagePostResourceId = when (randomImageIndex.value) {
1 -> R.drawable.post1
2 -> R.drawable.post2
3 -> R.drawable.post3
4 -> R.drawable.post4
5 -> R.drawable.post5
6 -> R.drawable.post6
7 -> R.drawable.post7
8 -> R.drawable.post8
9 -> R.drawable.post9
10 -> R.drawable.post10
else -> R.drawable.post1
}
Image(
painter = painterResource(id = imagePostResourceId),
contentDescription = null,
modifier = Modifier
.fillMaxWidth()
.aspectRatio(14f / 9f)
)
}
| smunsia/app/src/main/java/com/example/smunsia1/Posting.kt | 3340646052 |
package com.example.smunsia1
import android.content.res.Configuration
import androidx.compose.foundation.BorderStroke
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.AddCircle
import androidx.compose.material.icons.filled.ArrowBack
import androidx.compose.material.icons.filled.Check
import androidx.compose.material.icons.filled.Create
import androidx.compose.material.icons.filled.MailOutline
import androidx.compose.material.icons.filled.Person
import androidx.compose.material3.Divider
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.LocalContentColor
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.livedata.observeAsState
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.platform.LocalConfiguration
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.lifecycle.viewmodel.compose.viewModel
import androidx.navigation.NavHostController
import com.example.smunsia1.ui.PostinganViewModel
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun ScreenProfile(navController: NavHostController, username: String, postinganViewModel: PostinganViewModel = viewModel()) {
val annotatedString = buildAnnotatedString {
withStyle(style = SpanStyle(
color = LocalContentColor.current,
fontWeight = FontWeight.Bold,
fontSize = 18.sp
)
) {
append(username)
}
}
val postingans by postinganViewModel.postingans.observeAsState(emptyList())
val isLandscape = LocalConfiguration.current.orientation == Configuration.ORIENTATION_LANDSCAPE
Column(modifier = Modifier.fillMaxSize(),
verticalArrangement = Arrangement.Top,
horizontalAlignment = Alignment.CenterHorizontally
) {
TopAppBar(
title = {
},
navigationIcon = {
IconButton(
onClick = {
// Navigate back to "Posting" route
navController.popBackStack()
}
) {
Icon(imageVector = Icons.Default.ArrowBack, contentDescription = null)
}
}
)
Surface(
modifier = Modifier
.size(120.dp)
.clip(CircleShape)
.background(MaterialTheme.colorScheme.primary)
) {
// Use painterResource for image from res/drawable
Avatar()
}
Text(text = "$username", fontSize = 20.sp, fontWeight = FontWeight.Bold)
Spacer(modifier = Modifier.height(25.dp))
Row(
modifier = Modifier
.fillMaxWidth()
.padding(top = 8.dp),
horizontalArrangement = Arrangement.SpaceEvenly
) {
UserStat(icon = Icons.Default.Create, count = 1, label = "Posts")
UserStat(icon = Icons.Default.Person, count = 1, label = "Followers")
UserStat(icon = Icons.Default.Person, count = 0, label = "Following")
}
Row(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp),
horizontalArrangement = Arrangement.SpaceBetween
) {
FollowButton()
// Button Pesan
OutlinedButton(
onClick = { navController.navigate("Message") },
border = BorderStroke(1.dp, Color.DarkGray),
modifier = Modifier.padding(8.dp),
shape = MaterialTheme.shapes.small
) {
Icon(
imageVector = Icons.Default.MailOutline,
contentDescription = null,
modifier = Modifier.padding(end = 6.dp)
)
Text(text = "Pesan")
}
}
Column(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 10.dp)
) {
Divider(
modifier = Modifier
.fillMaxWidth()
.padding(top = 8.dp, bottom = 8.dp),
color = Color.Gray,
thickness = 1.dp
)
val filteredPostingans = postingans.filter { it.username == username }
LazyColumn(
modifier = Modifier.fillMaxSize(),
content = {
items(filteredPostingans) { postingan ->
PostingItem(postingan = postingan, navController = navController)
}
}
)
}
}
}
@Composable
fun UserStat(icon: ImageVector, count: Int, label: String) {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
modifier = Modifier.clickable {
// Handle click on stats
}
) {
Icon(imageVector = icon, contentDescription = null)
Spacer(modifier = Modifier.height(4.dp))
Text(text = count.toString(), fontWeight = FontWeight.Bold)
Text(text = label, fontSize = 12.sp)
}
}
@Composable
fun FollowButton() {
var isFollowing by remember { mutableStateOf(false) }
OutlinedButton(
onClick = {
isFollowing = !isFollowing
},
border = BorderStroke(1.dp, if (isFollowing) Color.DarkGray else Color.Blue),
modifier = Modifier.padding(8.dp),
shape = MaterialTheme.shapes.small
) {
if (isFollowing) {
Icon(
imageVector = Icons.Default.AddCircle,
contentDescription = null,
modifier = Modifier.padding(end = 6.dp)
)
Text(text = "Ikuti")
} else {
Icon(
imageVector = Icons.Default.Check,
contentDescription = null,
modifier = Modifier.padding(end = 6.dp)
)
Text(text = "Mengikuti")
}
}
}
@Composable
fun Centang() {
Icon(
imageVector = Icons.Default.Check,
contentDescription = null,
tint = androidx.compose.material3.MaterialTheme.colorScheme.primary,
modifier = Modifier.size(24.dp)
)
}
| smunsia/app/src/main/java/com/example/smunsia1/Profile.kt | 1142469126 |
package jahni.sandbox
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
@SpringBootTest
class SandboxApplicationTests {
@Test
fun contextLoads() {
}
}
| spring-sandbox/src/test/kotlin/jahni/sandbox/SandboxApplicationTests.kt | 2415383063 |
package jahni.sandbox.api.controller.member
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.http.MediaType
import org.springframework.test.web.servlet.MockMvc
import org.springframework.test.web.servlet.get
import org.springframework.test.web.servlet.patch
import org.springframework.test.web.servlet.post
@SpringBootTest
@AutoConfigureMockMvc
class MemberControllerTest {
@Autowired
private lateinit var mockMvc: MockMvc
@Test
fun νμκ°μ
() {
mockMvc.post("/member") {
contentType = MediaType.APPLICATION_JSON
content = """
{
"loginId": "test",
"password": "test"
}
"""
}.andExpectAll {
status { isOk() }
jsonPath("$.result") { value("νμκ°μ
μ΄ μλ£λμμ΅λλ€.") }
}
}
} | spring-sandbox/src/test/kotlin/jahni/sandbox/api/controller/member/MemberControllerTest.kt | 3407089237 |
package jahni.sandbox.infra.database
import jahni.sandbox.application.domain.Member.Member
import org.springframework.data.jpa.repository.JpaRepository
interface MemberJpaRepository : JpaRepository<Member, Long> {
fun findByLoginId(loginId: String): Member?
fun findByIdIn(ids: List<Long>): List<Member>
} | spring-sandbox/src/main/kotlin/jahni/sandbox/infra/database/MemberJpaRepository.kt | 2303256903 |
package jahni.sandbox.infra.database
import jahni.sandbox.application.domain.comment.Comment
import org.springframework.data.jpa.repository.JpaRepository
interface CommentJpaRepository : JpaRepository<Comment, Long> {
fun findByPostId(postId: Long): List<Comment>
} | spring-sandbox/src/main/kotlin/jahni/sandbox/infra/database/CommentJpaRepository.kt | 2929673391 |
package jahni.sandbox.infra.database
import jahni.sandbox.application.domain.post.Post
import org.springframework.data.jpa.repository.JpaRepository
interface PostJpaRepository : JpaRepository<Post, Long> {
} | spring-sandbox/src/main/kotlin/jahni/sandbox/infra/database/PostJpaRepository.kt | 879990019 |
package jahni.sandbox
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.data.jpa.repository.config.EnableJpaAuditing
@EnableJpaAuditing // JPA Auditing νμ±ν
@SpringBootApplication
class SandboxApplication
fun main(args: Array<String>) {
runApplication<SandboxApplication>(*args)
}
| spring-sandbox/src/main/kotlin/jahni/sandbox/SandboxApplication.kt | 735751079 |
package jahni.sandbox.api.configuration
@Target(AnnotationTarget.VALUE_PARAMETER)
@Retention(AnnotationRetention.RUNTIME)
annotation class LoginMember
| spring-sandbox/src/main/kotlin/jahni/sandbox/api/configuration/LoginMember.kt | 2639850181 |
package jahni.sandbox.api.configuration
import jakarta.servlet.http.HttpServletRequest
import jakarta.servlet.http.HttpServletResponse
import org.slf4j.LoggerFactory
import org.springframework.web.servlet.HandlerInterceptor
class LogInterceptor : HandlerInterceptor {
private val logger = LoggerFactory.getLogger(this.javaClass)
override fun preHandle(request: HttpServletRequest, response: HttpServletResponse, handler: Any): Boolean {
logger.info("Request URL: ${request.requestURI}")
return true
}
} | spring-sandbox/src/main/kotlin/jahni/sandbox/api/configuration/LogInterceptor.kt | 3705115778 |
package jahni.sandbox.api.configuration
import jahni.sandbox.api.util.ApiResponse
import jahni.sandbox.application.exception.ErrorMessage
import jahni.sandbox.application.exception.JahniCustomException
import org.springframework.http.HttpStatus
import org.springframework.web.bind.annotation.ExceptionHandler
import org.springframework.web.bind.annotation.ResponseStatus
import org.springframework.web.bind.annotation.RestControllerAdvice
@RestControllerAdvice
class ControllerAdvice {
@ResponseStatus(HttpStatus.OK)
@ExceptionHandler(Exception::class)
fun handleException(e: Exception): ApiResponse<String> {
val errorMessage = ErrorMessage("Internal Server Error")
// TODO: μ¬λμ μλ¬ λ‘κ·Έ μ μ‘
return ApiResponse.fail(errorMessage)
}
@ResponseStatus(HttpStatus.OK)
@ExceptionHandler(JahniCustomException::class)
fun handleException(e: JahniCustomException): ApiResponse<String> {
return ApiResponse.fail(ErrorMessage(e.message ?: "μ μ μλ μλ¬μ
λλ€."))
}
} | spring-sandbox/src/main/kotlin/jahni/sandbox/api/configuration/ControllerAdvice.kt | 3113160887 |
package jahni.sandbox.api.configuration
import org.springframework.context.annotation.Configuration
import org.springframework.web.method.support.HandlerMethodArgumentResolver
import org.springframework.web.servlet.config.annotation.InterceptorRegistry
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer
@Configuration
class WebConfiguration : WebMvcConfigurer {
override fun addInterceptors(registry: InterceptorRegistry) {
registry.addInterceptor(LogInterceptor())
.addPathPatterns("/**")
}
override fun addArgumentResolvers(resolvers: MutableList<HandlerMethodArgumentResolver>) {
resolvers.add(LoginMemberArgumentResolver())
}
} | spring-sandbox/src/main/kotlin/jahni/sandbox/api/configuration/WebConfiguration.kt | 4283827001 |
package jahni.sandbox.api.configuration
import jahni.sandbox.application.domain.Member.Member
import jahni.sandbox.application.exception.JahniCustomException
import jakarta.servlet.http.HttpServletRequest
import org.springframework.core.MethodParameter
import org.springframework.web.bind.support.WebDataBinderFactory
import org.springframework.web.context.request.NativeWebRequest
import org.springframework.web.method.support.HandlerMethodArgumentResolver
import org.springframework.web.method.support.ModelAndViewContainer
class LoginMemberArgumentResolver : HandlerMethodArgumentResolver {
override fun supportsParameter(parameter: MethodParameter): Boolean {
val hasLoginAnnotation = parameter.hasParameterAnnotation(LoginMember::class.java)
val hasMemberType = Member::class.java.isAssignableFrom(parameter.parameterType)
return hasLoginAnnotation && hasMemberType
}
override fun resolveArgument(
parameter: MethodParameter,
mavContainer: ModelAndViewContainer?,
webRequest: NativeWebRequest,
binderFactory: WebDataBinderFactory?
): Any {
val request = webRequest.nativeRequest as HttpServletRequest
return request.getSession(false)?.getAttribute("LOGIN_MEMBER")
?: throw JahniCustomException("λ‘κ·ΈμΈμ΄ νμν©λλ€.")
}
} | spring-sandbox/src/main/kotlin/jahni/sandbox/api/configuration/LoginMemberArgumentResolver.kt | 1065944982 |
package jahni.sandbox.api.util
enum class ResultType {
SUCCESS,
FAIL,
ERROR
} | spring-sandbox/src/main/kotlin/jahni/sandbox/api/util/ResultType.kt | 1077060496 |
package jahni.sandbox.api.util
import jahni.sandbox.application.exception.ErrorMessage
class ApiResponse<T> {
val resultType: ResultType
val result: T?
val errorMessage: ErrorMessage?
companion object {
fun <T> success(result: T): ApiResponse<T> {
return ApiResponse(result)
}
fun <T> fail(errorMessage: ErrorMessage): ApiResponse<T> {
return ApiResponse(errorMessage)
}
}
private constructor(result: T) {
this.resultType = ResultType.SUCCESS
this.result = result
this.errorMessage = null
}
private constructor(errorMessage: ErrorMessage) {
this.resultType = ResultType.FAIL
this.result = null
this.errorMessage = errorMessage
}
} | spring-sandbox/src/main/kotlin/jahni/sandbox/api/util/ApiResponse.kt | 1212242927 |
package jahni.sandbox.api.controller.post.response
import jahni.sandbox.application.domain.Member.Member
import jahni.sandbox.application.domain.comment.Comment
import jahni.sandbox.application.domain.post.PostDetailOutput
import java.time.LocalDateTime
data class PostDetailResponse(
val id: Long,
val author: AuthorInfo,
val title: String,
val content: String,
val createdAt: LocalDateTime,
val updatedAt: LocalDateTime,
val comments: List<CommentInfo>,
) {
data class AuthorInfo(
val id: Long,
val loginId: String,
) {
companion object {
fun from(author: Member): AuthorInfo {
return AuthorInfo(
id = author.id,
loginId = author.loginId,
)
}
}
}
data class CommentInfo(
val id: Long,
val author: AuthorInfo,
val content: String,
val createdAt: LocalDateTime,
val updatedAt: LocalDateTime,
) {
companion object {
fun of(comment: Comment, commentAuthors: Map<Long, Member>): CommentInfo {
return CommentInfo(
id = comment.id,
author = AuthorInfo.from(commentAuthors[comment.authorId]!!),
content = comment.content,
createdAt = comment.createdAt,
updatedAt = comment.updatedAt,
)
}
}
}
companion object {
fun from(postDetailOutput: PostDetailOutput): PostDetailResponse {
return PostDetailResponse(
id = postDetailOutput.post.id,
author = AuthorInfo.from(postDetailOutput.postAuthor),
title = postDetailOutput.post.title,
content = postDetailOutput.post.content,
createdAt = postDetailOutput.post.createdAt,
updatedAt = postDetailOutput.post.updatedAt,
comments = postDetailOutput.comments.map { CommentInfo.of(it, postDetailOutput.commentAuthors) }
)
}
}
}
| spring-sandbox/src/main/kotlin/jahni/sandbox/api/controller/post/response/PostDetailResponse.kt | 2548590384 |
package jahni.sandbox.api.controller.post.response
import jahni.sandbox.application.domain.post.Post
import java.time.LocalDateTime
data class PostResponse(
val id: Long,
val authorId: Long,
// μμ±μ μ 보 μΆκ°νκΈ°
val title: String,
val content: String,
val createdAt: LocalDateTime,
val updatedAt: LocalDateTime,
) {
companion object {
fun from(post: Post): PostResponse {
return PostResponse(
id = post.id,
authorId = post.authorId,
title = post.title,
content = post.content,
createdAt = post.createdAt,
updatedAt = post.updatedAt,
)
}
}
} | spring-sandbox/src/main/kotlin/jahni/sandbox/api/controller/post/response/PostResponse.kt | 701026946 |
package jahni.sandbox.api.controller.post
import jahni.sandbox.api.configuration.LoginMember
import jahni.sandbox.api.controller.post.request.CreatePostRequest
import jahni.sandbox.api.controller.post.request.UpdatePostRequest
import jahni.sandbox.api.controller.post.response.PostDetailResponse
import jahni.sandbox.api.controller.post.response.PostResponse
import jahni.sandbox.api.util.ApiResponse
import jahni.sandbox.application.domain.Member.Member
import jahni.sandbox.application.domain.post.PostService
import org.springframework.web.bind.annotation.*
@RestController
class PostController(
private val postService: PostService
) {
// κΈ λ±λ‘
@PostMapping("/post")
fun createPost(
@LoginMember member: Member,
@RequestBody request: CreatePostRequest,
) : ApiResponse<String> {
postService.createPost(request.toCommand(member))
return ApiResponse.success("κΈμ΄ λ±λ‘λμμ΅λλ€.")
}
// κΈ μ‘°ν + λκΈκΉμ§
@GetMapping("/post/{postId}")
fun getPost(
@PathVariable postId: Long,
): ApiResponse<PostDetailResponse> {
val postDetailOutput = postService.getPost(postId)
val response = PostDetailResponse.from(postDetailOutput)
return ApiResponse.success(response)
}
// κΈ μμ
@PutMapping("/post")
fun updatePost(
@LoginMember member: Member,
@RequestBody request: UpdatePostRequest,
): ApiResponse<String> {
val command = request.toCommand(member)
postService.updatePost(command)
return ApiResponse.success("κΈμ΄ μμ λμμ΅λλ€.")
}
// κΈ μμ
@DeleteMapping("/post/{postId}")
fun deletePost(
@LoginMember member: Member,
@PathVariable postId: Long,
): ApiResponse<String> {
postService.deletePost(member, postId)
return ApiResponse.success("κΈμ΄ μμ λμμ΅λλ€.")
}
// κΈ μ λΆ μ‘°ν + λκΈ μ μΈ
// νμ΄μ§ μ²λ¦¬
@GetMapping("/posts")
fun getPosts(): ApiResponse<List<PostResponse>> {
val posts = postService.getAllPost()
val response = posts.map { PostResponse.from(it) }
return ApiResponse.success(response)
}
} | spring-sandbox/src/main/kotlin/jahni/sandbox/api/controller/post/PostController.kt | 3474666719 |
package jahni.sandbox.api.controller.post.request
import jahni.sandbox.application.domain.Member.Member
import jahni.sandbox.application.domain.post.UpdatePostCommand
data class UpdatePostRequest(
val postId: Long,
val newTitle: String,
val newContent: String,
) {
fun toCommand(member: Member): UpdatePostCommand {
return UpdatePostCommand(
memberId = member.id,
postId = postId,
newTitle = newTitle,
newContent = newContent,
)
}
}
| spring-sandbox/src/main/kotlin/jahni/sandbox/api/controller/post/request/UpdatePostRequest.kt | 926282061 |
package jahni.sandbox.api.controller.post.request
import jahni.sandbox.application.domain.Member.Member
import jahni.sandbox.application.domain.post.CreatePostCommand
data class CreatePostRequest(
val title: String,
val content: String,
) {
fun toCommand(member: Member): CreatePostCommand {
return CreatePostCommand(
authorId = member.id,
title = title,
content = content,
)
}
}
| spring-sandbox/src/main/kotlin/jahni/sandbox/api/controller/post/request/CreatePostRequest.kt | 2154649200 |
package jahni.sandbox.api.controller.comment.request
import jahni.sandbox.application.domain.Member.Member
import jahni.sandbox.application.domain.comment.CreateCommentCommand
data class CreateCommentRequest(
val postId: Long,
val content: String,
) {
fun toCommand(member: Member): CreateCommentCommand {
return CreateCommentCommand(
authorId = member.id,
postId = postId,
content = content,
)
}
}
| spring-sandbox/src/main/kotlin/jahni/sandbox/api/controller/comment/request/CreateCommentRequest.kt | 1432864635 |
package jahni.sandbox.api.controller.comment.request
data class UpdateCommentRequest(
val content: String,
)
| spring-sandbox/src/main/kotlin/jahni/sandbox/api/controller/comment/request/UpdateCommentRequest.kt | 1828739421 |
package jahni.sandbox.api.controller.comment
import jahni.sandbox.api.configuration.LoginMember
import jahni.sandbox.api.controller.comment.request.CreateCommentRequest
import jahni.sandbox.api.controller.comment.request.UpdateCommentRequest
import jahni.sandbox.api.util.ApiResponse
import jahni.sandbox.application.domain.Member.Member
import jahni.sandbox.application.domain.comment.CommentService
import jahni.sandbox.application.domain.comment.UpdateCommentCommand
import org.springframework.web.bind.annotation.DeleteMapping
import org.springframework.web.bind.annotation.PathVariable
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.PutMapping
import org.springframework.web.bind.annotation.RequestBody
import org.springframework.web.bind.annotation.RestController
@RestController
class CommentController(
private val commentService: CommentService,
) {
// λκΈ λ±λ‘
@PostMapping("/comment")
fun createComment(
@LoginMember member: Member,
@RequestBody request: CreateCommentRequest
) : ApiResponse<String> {
commentService.createComment(request.toCommand(member))
return ApiResponse.success("λκΈμ΄ λ±λ‘λμμ΅λλ€.")
}
// λκΈ μμ
@DeleteMapping("/comment/{commentId}")
fun deleteComment(
@LoginMember member: Member,
@PathVariable commentId: Long
) : ApiResponse<String> {
commentService.deleteComment(member.id, commentId)
return ApiResponse.success("λκΈμ΄ μμ λμμ΅λλ€.")
}
// λκΈ μμ
@PutMapping("/comment/{commentId}")
fun updateComment(
@LoginMember member: Member,
@PathVariable commentId: Long,
@RequestBody request: UpdateCommentRequest
) : ApiResponse<String> {
val command = UpdateCommentCommand(member.id, commentId, request.content)
commentService.updateComment(command)
return ApiResponse.success("λκΈμ΄ μμ λμμ΅λλ€.")
}
} | spring-sandbox/src/main/kotlin/jahni/sandbox/api/controller/comment/CommentController.kt | 562667981 |
package jahni.sandbox.api.controller.member
import jahni.sandbox.api.controller.member.request.LoginMemberRequest
import jahni.sandbox.api.util.ApiResponse
import jahni.sandbox.application.domain.Member.LoginService
import jakarta.servlet.http.HttpServletRequest
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.RequestBody
import org.springframework.web.bind.annotation.RestController
@RestController
class LoginController(
private val loginService: LoginService,
) {
@PostMapping("/login")
fun login(
httpRequest: HttpServletRequest,
@RequestBody request: LoginMemberRequest,
): ApiResponse<String> {
loginService.login(request.toCommand(httpRequest))
return ApiResponse.success("λ‘κ·ΈμΈμ΄ μλ£λμμ΅λλ€.")
}
} | spring-sandbox/src/main/kotlin/jahni/sandbox/api/controller/member/LoginController.kt | 1420316361 |
package jahni.sandbox.api.controller.member.response
data class MemberResponse(
val id: Long,
val loginId: String,
val password: String,
)
| spring-sandbox/src/main/kotlin/jahni/sandbox/api/controller/member/response/MemberResponse.kt | 1079954212 |
package jahni.sandbox.api.controller.member
import jahni.sandbox.api.configuration.LoginMember
import jahni.sandbox.api.controller.member.request.RegisterMemberRequest
import jahni.sandbox.api.controller.member.request.UpdatePasswordRequest
import jahni.sandbox.api.controller.member.response.MemberResponse
import jahni.sandbox.api.util.ApiResponse
import jahni.sandbox.application.domain.Member.Member
import jahni.sandbox.application.domain.Member.MemberService
import org.springframework.web.bind.annotation.*
@RestController
class MemberController(
private val memberService: MemberService,
) {
@PostMapping("/member")
fun register(@RequestBody request: RegisterMemberRequest): ApiResponse<String> {
memberService.register(request.toDomain())
return ApiResponse.success("νμκ°μ
μ΄ μλ£λμμ΅λλ€.")
}
@GetMapping("/member/{id}")
fun getMember(
@PathVariable id: Long,
@LoginMember member: Member,
): ApiResponse<MemberResponse> {
val findMember = memberService.getMember(member.id, id)
val response = MemberResponse(
id = findMember.id,
loginId = findMember.loginId,
password = findMember.password,
)
return ApiResponse.success(response)
}
@PatchMapping("/member/password")
fun updatePassword(
@LoginMember member: Member,
@RequestBody request: UpdatePasswordRequest,
): ApiResponse<String> {
memberService.update(request.toDomain(member))
return ApiResponse.success("λΉλ°λ²νΈκ° λ³κ²½λμμ΅λλ€.")
}
} | spring-sandbox/src/main/kotlin/jahni/sandbox/api/controller/member/MemberController.kt | 571457023 |
package jahni.sandbox.api.controller.member.request
import jahni.sandbox.application.domain.Member.LoginCommand
import jakarta.servlet.http.HttpServletRequest
data class LoginMemberRequest(
val loginId: String,
val password: String,
) {
fun toCommand(httpRequest: HttpServletRequest): LoginCommand {
return LoginCommand(
loginId = loginId,
password = password,
httpRequest = httpRequest,
)
}
} | spring-sandbox/src/main/kotlin/jahni/sandbox/api/controller/member/request/LoginMemberRequest.kt | 3137127013 |
package jahni.sandbox.api.controller.member.request
import jahni.sandbox.application.domain.Member.Member
data class RegisterMemberRequest(
val loginId: String,
val password: String,
) {
fun toDomain(): Member {
return Member(
loginId = loginId,
password = password,
)
}
}
| spring-sandbox/src/main/kotlin/jahni/sandbox/api/controller/member/request/RegisterMemberRequest.kt | 1575887513 |
package jahni.sandbox.api.controller.member.request
import jahni.sandbox.application.domain.Member.Member
data class UpdatePasswordRequest(
val newPassword: String,
) {
fun toDomain(oldMember: Member): Member {
return Member(
id = oldMember.id,
loginId = oldMember.loginId,
password = newPassword,
)
}
}
| spring-sandbox/src/main/kotlin/jahni/sandbox/api/controller/member/request/UpdatePasswordRequest.kt | 1344498331 |
package jahni.sandbox.application.domain.post
import jahni.sandbox.application.domain.Member.Member
import jahni.sandbox.application.exception.JahniCustomException
import jahni.sandbox.infra.database.CommentJpaRepository
import jahni.sandbox.infra.database.MemberJpaRepository
import jahni.sandbox.infra.database.PostJpaRepository
import org.springframework.data.repository.findByIdOrNull
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
@Service
class PostService(
private val memberRepository: MemberJpaRepository,
private val postRepository: PostJpaRepository,
private val commentRepository: CommentJpaRepository,
) {
fun createPost(command: CreatePostCommand) {
postRepository.save(command.toEntity())
}
@Transactional(readOnly = true)
fun getPost(postId: Long): PostDetailOutput {
val post = postRepository.findByIdOrNull(postId) ?: throw JahniCustomException("μ‘΄μ¬νμ§ μλ κΈμ
λλ€.")
val comments = commentRepository.findByPostId(post.id)
val postAuthor = memberRepository.findByIdOrNull(post.authorId) ?: throw JahniCustomException("μ‘΄μ¬νμ§ μλ μμ±μμ
λλ€.")
val commentAuthorIds = comments.map { it.authorId }
val commentAuthors = memberRepository.findByIdIn(commentAuthorIds)
val commentAuthorMap = commentAuthors.associateBy { it.id }
return PostDetailOutput(post, postAuthor, comments, commentAuthorMap)
}
@Transactional
fun updatePost(command: UpdatePostCommand) {
val post = postRepository.findByIdOrNull(command.postId) ?: throw JahniCustomException("μ‘΄μ¬νμ§ μλ κΈμ
λλ€.")
if (command.memberId != post.authorId) {
throw JahniCustomException("κΈ μμ±μλ§ μμ ν μ μμ΅λλ€.")
}
post.update(command.newTitle, command.newContent)
}
fun getAllPost(): List<Post> {
return postRepository.findAll()
}
@Transactional
fun deletePost(member: Member, postId: Long) {
val post = postRepository.findByIdOrNull(postId) ?: throw JahniCustomException("μ‘΄μ¬νμ§ μλ κΈμ
λλ€.")
if (member.id != post.authorId) {
throw JahniCustomException("κΈ μμ±μλ§ μμ ν μ μμ΅λλ€.")
}
postRepository.delete(post)
}
}
| spring-sandbox/src/main/kotlin/jahni/sandbox/application/domain/post/PostService.kt | 649289328 |
package jahni.sandbox.application.domain.post
import jahni.sandbox.application.domain.Member.Member
import jahni.sandbox.application.domain.comment.Comment
data class PostDetailOutput(
val post: Post,
val postAuthor: Member,
val comments: List<Comment>,
val commentAuthors: Map<Long, Member>,
) | spring-sandbox/src/main/kotlin/jahni/sandbox/application/domain/post/PostDetailOutput.kt | 528139049 |
package jahni.sandbox.application.domain.post
data class UpdatePostCommand(
val memberId: Long,
val postId: Long,
val newTitle: String,
val newContent: String,
)
| spring-sandbox/src/main/kotlin/jahni/sandbox/application/domain/post/UpdatePostCommand.kt | 2424840620 |
package jahni.sandbox.application.domain.post
data class CreatePostCommand(
private val authorId: Long,
private val title: String,
private val content: String,
) {
fun toEntity(): Post {
return Post(
authorId = authorId,
title = title,
content = content,
)
}
}
| spring-sandbox/src/main/kotlin/jahni/sandbox/application/domain/post/CreatePostCommand.kt | 23094136 |
package jahni.sandbox.application.domain.post
import jahni.sandbox.application.domain.BaseTimeEntity
import jakarta.persistence.*
@Entity
@Table(name = "post")
class Post(
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
val id: Long = 0L,
val authorId: Long,
var title: String,
var content: String,
var isDeleted: Boolean = false,
) : BaseTimeEntity() {
fun update(newTitle: String, newContent: String) {
this.title = newTitle
this.content = newContent
}
} | spring-sandbox/src/main/kotlin/jahni/sandbox/application/domain/post/Post.kt | 2296246541 |
package jahni.sandbox.application.domain
import jakarta.persistence.Column
import jakarta.persistence.EntityListeners
import jakarta.persistence.MappedSuperclass
import org.springframework.data.annotation.CreatedDate
import org.springframework.data.annotation.LastModifiedDate
import org.springframework.data.jpa.domain.support.AuditingEntityListener
import java.time.LocalDateTime
@MappedSuperclass
@EntityListeners(AuditingEntityListener::class)
abstract class BaseTimeEntity {
@CreatedDate
@Column(updatable = false)
var createdAt: LocalDateTime = LocalDateTime.now()
@LastModifiedDate
var updatedAt: LocalDateTime = LocalDateTime.now()
} | spring-sandbox/src/main/kotlin/jahni/sandbox/application/domain/BaseTimeEntity.kt | 4012607513 |
package jahni.sandbox.application.domain.comment
data class UpdateCommentCommand(
val updaterId: Long,
val commentId: Long,
val newContent: String
)
| spring-sandbox/src/main/kotlin/jahni/sandbox/application/domain/comment/UpdateCommentCommand.kt | 3683205300 |
package jahni.sandbox.application.domain.comment
data class CreateCommentCommand(
val authorId: Long,
val postId: Long,
val content: String,
) {
fun toEntity(): Comment {
return Comment(
authorId = authorId,
postId = postId,
content = content,
)
}
}
| spring-sandbox/src/main/kotlin/jahni/sandbox/application/domain/comment/CreateCommentCommand.kt | 1811246715 |
package jahni.sandbox.application.domain.comment
import jahni.sandbox.application.exception.JahniCustomException
import jahni.sandbox.infra.database.CommentJpaRepository
import org.springframework.data.repository.findByIdOrNull
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
@Service
class CommentService(
private val commentRepository: CommentJpaRepository,
) {
fun createComment(command: CreateCommentCommand) {
val comment = command.toEntity()
commentRepository.save(comment)
}
@Transactional
fun deleteComment(memberId: Long, commentId: Long) {
val comment = commentRepository.findByIdOrNull(commentId) ?: throw JahniCustomException("μ‘΄μ¬νμ§ μλ λκΈμ
λλ€.")
if (memberId != comment.authorId)
throw JahniCustomException("λκΈ μμ±μλ§ μμ ν μ μμ΅λλ€.")
commentRepository.delete(comment)
}
@Transactional
fun updateComment(command: UpdateCommentCommand) {
val (updaterId, commentId, newContent) = command
val comment = commentRepository.findByIdOrNull(commentId) ?: throw JahniCustomException("μ‘΄μ¬νμ§ μλ λκΈμ
λλ€.")
if (updaterId != comment.authorId)
throw JahniCustomException("λκΈ μμ±μλ§ μμ ν μ μμ΅λλ€.")
comment.updateContent(newContent)
}
}
| spring-sandbox/src/main/kotlin/jahni/sandbox/application/domain/comment/CommentService.kt | 1704195627 |
package jahni.sandbox.application.domain.comment
import jahni.sandbox.application.domain.BaseTimeEntity
import jakarta.persistence.*
@Entity
@Table(name = "comment")
class Comment(
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
val id: Long = 0L,
val authorId: Long,
val postId: Long,
var content: String,
) : BaseTimeEntity() {
fun updateContent(newContent: String) {
this.content = newContent
}
} | spring-sandbox/src/main/kotlin/jahni/sandbox/application/domain/comment/Comment.kt | 2024896967 |
package jahni.sandbox.application.domain.Member
import jahni.sandbox.application.exception.JahniCustomException
import jahni.sandbox.infra.database.MemberJpaRepository
import org.springframework.stereotype.Service
@Service
class MemberService(
private val memberRepository: MemberJpaRepository
) {
fun register(member: Member) {
memberRepository.findByLoginId(member.loginId)
?.let { throw JahniCustomException("μ΄λ―Έ μ‘΄μ¬νλ νμμ
λλ€.") }
memberRepository.save(member)
}
fun getMember(memberId: Long, targetMemberId: Long): Member {
if (memberId != targetMemberId) throw JahniCustomException("λ³ΈμΈλ§ μ‘°νν μ μμ΅λλ€.")
return memberRepository.findById(targetMemberId).orElseThrow { JahniCustomException("μ‘΄μ¬νμ§ μλ νμμ
λλ€.") }
}
fun update(newMember: Member) {
memberRepository.save(newMember)
}
} | spring-sandbox/src/main/kotlin/jahni/sandbox/application/domain/Member/MemberService.kt | 2732307531 |
package jahni.sandbox.application.domain.Member
import jakarta.servlet.http.HttpServletRequest
class LoginCommand(
val loginId: String,
val password: String,
val httpRequest: HttpServletRequest,
) | spring-sandbox/src/main/kotlin/jahni/sandbox/application/domain/Member/LoginCommand.kt | 1259588244 |
package jahni.sandbox.application.domain.Member
import jahni.sandbox.application.domain.BaseTimeEntity
import jakarta.persistence.*
@Entity
@Table(name = "member")
class Member(
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
val id: Long = 0L,
val loginId: String,
var password: String,
) : BaseTimeEntity() | spring-sandbox/src/main/kotlin/jahni/sandbox/application/domain/Member/Member.kt | 1641336738 |
package jahni.sandbox.application.domain.Member
import jahni.sandbox.application.exception.JahniCustomException
import jahni.sandbox.infra.database.MemberJpaRepository
import org.springframework.stereotype.Service
@Service
class LoginService(
private val memberJpaRepository: MemberJpaRepository,
) {
/**
* JSESSIONIDλ₯Ό ν΅ν΄ νμ μ 보λ₯Ό κ°μ Έμ€λ λ°©μμ μλμ κ°μ κ΅¬μ‘°λ‘ μ΄ν΄νλ©΄ λλ€.
* getSession -> SessionStore[JSESSIONID] -> Session
* Session -> Session[LOGIN_MEMBER] -> Member μ 보
* */
fun login(command: LoginCommand) {
val member = memberJpaRepository.findByLoginId(command.loginId)
?: throw JahniCustomException("μ‘΄μ¬νμ§ μλ νμμ
λλ€.")
checkPassword(member, command)
val session = command.httpRequest.getSession(true) // μΈμ
μ΄ μλ€λ©΄ κΈ°μ‘΄κ²μ, μλ€λ©΄ μ κ· μμ±
session.setAttribute("LOGIN_MEMBER", member) // μΈμ
μ λ‘κ·ΈμΈ νμ μ 보 μ μ₯ (Map ννλ‘ μ μ₯λ¨)
}
private fun checkPassword(member: Member, command: LoginCommand) {
if (member.password != command.password)
throw JahniCustomException("λΉλ°λ²νΈκ° μΌμΉνμ§ μμ΅λλ€.")
}
}
| spring-sandbox/src/main/kotlin/jahni/sandbox/application/domain/Member/LoginService.kt | 1506630707 |
package jahni.sandbox.application.exception
class ErrorMessage(val reason: String) | spring-sandbox/src/main/kotlin/jahni/sandbox/application/exception/ErrorMessage.kt | 577848827 |
package jahni.sandbox.application.exception
class JahniCustomException(override val message: String) : RuntimeException(message) | spring-sandbox/src/main/kotlin/jahni/sandbox/application/exception/JahniCustomException.kt | 1154078215 |
package com.example.teste_tabs
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.example.teste_tabs", appContext.packageName)
}
} | teste-tabs/app/src/androidTest/java/com/example/teste_tabs/ExampleInstrumentedTest.kt | 3125547974 |
package com.example.teste_tabs
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} | teste-tabs/app/src/test/java/com/example/teste_tabs/ExampleUnitTest.kt | 1762451 |
package com.example.teste_tabs.ui
import android.os.Bundle
import android.os.Handler
import android.os.Looper
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.navigation.fragment.findNavController
import com.example.teste_tabs.R
import com.example.teste_tabs.databinding.FragmentSplashBinding
class SplashFragment : Fragment() {
private var _binding: FragmentSplashBinding? = null
private val binding get() = _binding!!
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View {
_binding = FragmentSplashBinding.inflate(layoutInflater,container,false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
Handler(Looper.getMainLooper()).postDelayed(this::initApp,3000)
}
private fun initApp() {
findNavController().navigate(R.id.action_splashFragment_to_mainFragment2)
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | teste-tabs/app/src/main/java/com/example/teste_tabs/ui/SplashFragment.kt | 3905315310 |
package com.example.teste_tabs.ui
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import com.example.teste_tabs.R
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private const val ARG_PARAM1 = "param1"
private const val ARG_PARAM2 = "param2"
/**
* A simple [Fragment] subclass.
* Use the [LoginFragment.newInstance] factory method to
* create an instance of this fragment.
*/
class LoginFragment : Fragment() {
// TODO: Rename and change types of parameters
private var param1: String? = null
private var param2: String? = null
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
arguments?.let {
param1 = it.getString(ARG_PARAM1)
param2 = it.getString(ARG_PARAM2)
}
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_login, container, false)
}
companion object {
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment LoginFragment.
*/
// TODO: Rename and change types and number of parameters
@JvmStatic
fun newInstance(param1: String, param2: String) =
LoginFragment().apply {
arguments = Bundle().apply {
putString(ARG_PARAM1, param1)
putString(ARG_PARAM2, param2)
}
}
}
} | teste-tabs/app/src/main/java/com/example/teste_tabs/ui/LoginFragment.kt | 2881695351 |
package com.example.teste_tabs.ui
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import com.example.teste_tabs.R
import com.example.teste_tabs.adapter.ViewPagerAdapter
import com.example.teste_tabs.databinding.FragmentMainBinding
import com.example.teste_tabs.databinding.FragmentSplashBinding
import com.google.android.material.tabs.TabLayoutMediator
class MainFragment : Fragment() {
private var _binding: FragmentMainBinding? = null
private val binding get() = _binding!!
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View {
_binding = FragmentMainBinding.inflate(layoutInflater,container,false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
initTab()
}
private fun initTab() {
val viewpagerAdapter = ViewPagerAdapter(requireActivity())
viewpagerAdapter.addFragment(LoginFragment(),R.string.tab_login)
viewpagerAdapter.addFragment(CriarContaFragment(),R.string.tab_create)
with(binding.viewpager){
adapter = viewpagerAdapter
offscreenPageLimit = viewpagerAdapter.itemCount
}
TabLayoutMediator(binding.tablayout,binding.viewpager){ tab,position ->
tab.text = getText(viewpagerAdapter.getTitle(position))
}.attach()
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | teste-tabs/app/src/main/java/com/example/teste_tabs/ui/MainFragment.kt | 1548082981 |
package com.example.teste_tabs.ui
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import com.example.teste_tabs.R
// TODO: Rename parameter arguments, choose names that match
// the fragment initialization parameters, e.g. ARG_ITEM_NUMBER
private const val ARG_PARAM1 = "param1"
private const val ARG_PARAM2 = "param2"
/**
* A simple [Fragment] subclass.
* Use the [CriarContaFragment.newInstance] factory method to
* create an instance of this fragment.
*/
class CriarContaFragment : Fragment() {
// TODO: Rename and change types of parameters
private var param1: String? = null
private var param2: String? = null
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
arguments?.let {
param1 = it.getString(ARG_PARAM1)
param2 = it.getString(ARG_PARAM2)
}
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
return inflater.inflate(R.layout.fragment_criar_conta, container, false)
}
companion object {
/**
* Use this factory method to create a new instance of
* this fragment using the provided parameters.
*
* @param param1 Parameter 1.
* @param param2 Parameter 2.
* @return A new instance of fragment CriarContaFragment.
*/
// TODO: Rename and change types and number of parameters
@JvmStatic
fun newInstance(param1: String, param2: String) =
CriarContaFragment().apply {
arguments = Bundle().apply {
putString(ARG_PARAM1, param1)
putString(ARG_PARAM2, param2)
}
}
}
} | teste-tabs/app/src/main/java/com/example/teste_tabs/ui/CriarContaFragment.kt | 1943745727 |
package com.example.teste_tabs
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
}
} | teste-tabs/app/src/main/java/com/example/teste_tabs/MainActivity.kt | 1646093698 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.