content
stringlengths 0
13M
| path
stringlengths 4
263
| contentHash
stringlengths 1
10
|
|---|---|---|
package be.helmo.planivacances.factory
import be.helmo.planivacances.presenter.*
import be.helmo.planivacances.presenter.interfaces.*
import be.helmo.planivacances.view.interfaces.*
/**
* Factory de singleton + stockage du token
*/
class AppSingletonFactory() {
val authPresenter: AuthPresenter = AuthPresenter()
val groupPresenter: GroupPresenter = GroupPresenter()
val weatherPresenter: WeatherPresenter = WeatherPresenter(groupPresenter)
val tchatPresenter : TchatPresenter = TchatPresenter(groupPresenter, authPresenter)
val activityPresenter : ActivityPresenter = ActivityPresenter(groupPresenter)
fun getAuthPresenter(authView: IAuthView): IAuthPresenter {
authPresenter.setIAuthView(authView)
return authPresenter
}
//group presenter
fun getGroupPresenter(groupView:IGroupView): IGroupPresenter {
groupPresenter.setIGroupView(groupView)
return groupPresenter
}
fun getGroupPresenter(createGroupView:ICreateGroupView): IGroupPresenter {
groupPresenter.setICreateGroupView(createGroupView)
return groupPresenter
}
fun getGroupPresenter(homeView:IHomeView): IGroupPresenter {
groupPresenter.setIHomeView(homeView)
return groupPresenter
}
fun getGroupPresenter(updateGroupView: IUpdateGroupView) : IGroupPresenter {
groupPresenter.setIUpdateGroupView(updateGroupView)
return groupPresenter
}
//weather presenter
fun getWeatherPresenter(weatherView: IWeatherView): IWeatherPresenter {
weatherPresenter.setIWeatherView(weatherView)
return weatherPresenter
}
fun getTchatPresenter(tchatView : ITchatView) : ITchatPresenter {
tchatPresenter.setITchatView(tchatView)
return tchatPresenter
}
fun getCalendarPresenter(calendarView: ICalendarView) : IActivityPresenter {
activityPresenter.setICalendarView(calendarView)
return activityPresenter
}
fun getActivityPresenter(activityView: IActivityView) : IActivityPresenter {
activityPresenter.setIActivityView(activityView)
return activityPresenter
}
fun getActivityPresenter(createActivityView: ICreateActivityView) : IActivityPresenter {
activityPresenter.setICreateActivityView(createActivityView)
return activityPresenter
}
fun getActivityPresenter(updateActivityView: IUpdateActivityView) : IActivityPresenter {
activityPresenter.setIUpdateActivityView(updateActivityView)
return activityPresenter
}
companion object {
var instance: AppSingletonFactory? = null
get() {
if (field == null) field = AppSingletonFactory()
return field
}
}
} | mobile-planivacances/app/src/main/java/be/helmo/planivacances/factory/AppSingletonFactory.kt | 1031874804 |
package com.example.amangeldi_abdibaitov_mo5_hw_1
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.amangeldi_abdibaitov_mo5_hw_1", appContext.packageName)
}
} | Amangeldi_Abdibaitov_mo5_hw_1/app/src/androidTest/java/com/example/amangeldi_abdibaitov_mo5_hw_1/ExampleInstrumentedTest.kt | 1227945962 |
package com.example.amangeldi_abdibaitov_mo5_hw_1
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)
}
} | Amangeldi_Abdibaitov_mo5_hw_1/app/src/test/java/com/example/amangeldi_abdibaitov_mo5_hw_1/ExampleUnitTest.kt | 650686106 |
package com.example.amangeldi_abdibaitov_mo5_hw_1.mvp
import android.os.Bundle
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.view.isVisible
import com.example.amangeldi_abdibaitov_mo5_hw_1.databinding.ActivityMainBinding
class MainActivity : AppCompatActivity(), CounterView {
private lateinit var binding: ActivityMainBinding
private val presenter = Injector.getPresenter()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
presenter.attachView(this)
initListener()
}
private fun initListener() {
with(binding) {
incBtn.setOnClickListener {
presenter.increment()
presenter.checkNumber()
}
decBtn.setOnClickListener {
presenter.decrement()
presenter.checkNumber()
}
visibilityChangeBtn.setOnClickListener {
presenter.changeVisible()
}
clearBtn.setOnClickListener {
presenter.clear()
}
}
}
override fun showCount(count: Int) {
binding.resultTv.text = count.toString()
}
override fun changedVisible(isVisible: Boolean) {
binding.resultTv.isVisible = isVisible
}
override fun showToast(message: String) {
Toast.makeText(this, message, Toast.LENGTH_SHORT).show()
}
override fun changeTextColor() {
binding.resultTv.setTextColor(resources.getColor(android.R.color.holo_green_dark))
}
} | Amangeldi_Abdibaitov_mo5_hw_1/app/src/main/java/com/example/amangeldi_abdibaitov_mo5_hw_1/mvp/MainActivity.kt | 940858306 |
package com.example.amangeldi_abdibaitov_mo5_hw_1.mvp
interface CounterView {
fun showCount(count: Int)
fun changedVisible(isVisible: Boolean)
fun showToast(message: String)
fun changeTextColor()
} | Amangeldi_Abdibaitov_mo5_hw_1/app/src/main/java/com/example/amangeldi_abdibaitov_mo5_hw_1/mvp/CounterView.kt | 1956453293 |
package com.example.amangeldi_abdibaitov_mo5_hw_1.mvp
class CounterModel {
var count = 0
var isVisible = true
fun inc() {
count++
}
fun dec() {
count--
}
fun clear() {
count = 0
}
fun changeVisibility(isVisible: Boolean) {
this.isVisible = isVisible
}
} | Amangeldi_Abdibaitov_mo5_hw_1/app/src/main/java/com/example/amangeldi_abdibaitov_mo5_hw_1/mvp/CounterModel.kt | 1646624222 |
package com.example.amangeldi_abdibaitov_mo5_hw_1.mvp
class Presenter {
private var model = Injector.getModel()
private lateinit var view: CounterView
fun increment() {
model.inc()
view.showCount(model.count)
}
fun checkNumber() {
if (model.count == 10) {
view.showToast("ะะพะทะดัะฐะฒะปัะตะผ")
} else if (model.count == 15) {
view.changeTextColor()
}
}
fun decrement() {
model.dec()
view.showCount(model.count)
}
fun changeVisible() {
if (model.isVisible) {
model.changeVisibility(false)
} else model.changeVisibility(true)
view.changedVisible(model.isVisible)
}
fun clear() {
model.clear()
view.showCount(model.count)
}
fun attachView(view: CounterView) {
this.view = view
}
} | Amangeldi_Abdibaitov_mo5_hw_1/app/src/main/java/com/example/amangeldi_abdibaitov_mo5_hw_1/mvp/Presenter.kt | 892313900 |
package com.example.amangeldi_abdibaitov_mo5_hw_1.mvp
class Injector {
companion object {
fun getPresenter() = Presenter()
fun getModel() = CounterModel()
}
} | Amangeldi_Abdibaitov_mo5_hw_1/app/src/main/java/com/example/amangeldi_abdibaitov_mo5_hw_1/mvp/Injector.kt | 902702587 |
package com.sunueric.tableauapp.ui.viewmodels
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.viewModelScope
import com.sunueric.tableauapp.network.AuthService
import kotlinx.coroutines.launch
class AuthViewModel(private val authService: AuthService) : ViewModel() {
val accessToken = MutableLiveData("")
val isAuthenticated = MutableLiveData(false)
init {
isAuthenticated.value = false // Not authenticated by default
}
fun authenticateIfNeeded(url: String) {
if (requiresAuthentication(url)) {
if (accessToken.value.isNullOrEmpty()) {
signInAutomatically()
}
} else {
isAuthenticated.value = true // No authentication needed for public URLs
}
}
private fun requiresAuthentication(url: String): Boolean {
return url.contains("/private/") // placeholder condition
}
private fun signInAutomatically() {
viewModelScope.launch {
val response = authService.signIn("[email protected]", "password").execute()
if (response.isSuccessful && response.body() != null) {
accessToken.value = response.body()!!.accessToken
isAuthenticated.value = true
} else {
isAuthenticated.value = false
}
}
}
}
class AuthViewModelFactory(private val authService: AuthService) : ViewModelProvider.Factory {
override fun <T : ViewModel> create(modelClass: Class<T>): T {
if (modelClass.isAssignableFrom(AuthViewModel::class.java)) {
@Suppress("UNCHECKED_CAST")
return AuthViewModel(authService) as T
}
throw IllegalArgumentException("Unknown ViewModel class")
}
}
| TableauApp/app/src/main/java/com/sunueric/tableauapp/ui/viewmodels/AuthViewModel.kt | 3382012860 |
package com.sunueric.tableauapp.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) | TableauApp/app/src/main/java/com/sunueric/tableauapp/ui/theme/Color.kt | 1442824813 |
package com.sunueric.tableauapp.ui.theme
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.runtime.Composable
import androidx.tv.material3.ExperimentalTvMaterial3Api
import androidx.tv.material3.MaterialTheme
import androidx.tv.material3.darkColorScheme
import androidx.tv.material3.lightColorScheme
@OptIn(ExperimentalTvMaterial3Api::class)
@Composable
fun TableauAppTheme(
isInDarkTheme: Boolean = isSystemInDarkTheme(),
content: @Composable () -> Unit,
) {
val colorScheme = if (isInDarkTheme) {
darkColorScheme(
primary = Purple80,
secondary = PurpleGrey80,
tertiary = Pink80
)
} else {
lightColorScheme(
primary = Purple40,
secondary = PurpleGrey40,
tertiary = Pink40
)
}
MaterialTheme(
colorScheme = colorScheme,
typography = Typography,
content = content
)
} | TableauApp/app/src/main/java/com/sunueric/tableauapp/ui/theme/Theme.kt | 3450113258 |
package com.sunueric.tableauapp.ui.theme
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
import androidx.tv.material3.ExperimentalTvMaterial3Api
import androidx.tv.material3.Typography
// Set of Material typography styles to start with
@OptIn(ExperimentalTvMaterial3Api::class)
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
)
*/
) | TableauApp/app/src/main/java/com/sunueric/tableauapp/ui/theme/Type.kt | 68522891 |
package com.sunueric.tableauapp
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.viewModels
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.RectangleShape
import androidx.compose.ui.tooling.preview.Preview
import androidx.tv.material3.ExperimentalTvMaterial3Api
import androidx.tv.material3.Surface
import androidx.tv.material3.Text
import com.sunueric.tableauapp.network.provideAuthService
import com.sunueric.tableauapp.ui.theme.TableauAppTheme
import com.sunueric.tableauapp.ui.viewmodels.AuthViewModel
import com.sunueric.tableauapp.ui.viewmodels.AuthViewModelFactory
class MainActivity : ComponentActivity() {
@OptIn(ExperimentalTvMaterial3Api::class)
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
val authService = provideAuthService()
val authViewModel: AuthViewModel by viewModels { AuthViewModelFactory(authService) }
TableauAppTheme {
Surface(
modifier = Modifier.fillMaxSize(),
shape = RectangleShape
) {
TableauReportView(authViewModel)
}
}
}
}
}
@OptIn(ExperimentalTvMaterial3Api::class)
@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
Text(
text = "Hello $name!",
modifier = modifier
)
}
@Preview(showBackground = true)
@Composable
fun GreetingPreview() {
TableauAppTheme {
Greeting("Android")
}
} | TableauApp/app/src/main/java/com/sunueric/tableauapp/MainActivity.kt | 581588108 |
package com.sunueric.tableauapp.network
import okhttp3.OkHttpClient
import retrofit2.Call
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import retrofit2.http.POST
import retrofit2.http.Field
import retrofit2.http.FormUrlEncoded
interface AuthService {
@POST("/api/authenticate")
@FormUrlEncoded
fun signIn(@Field("email") email: String, @Field("password") password: String): Call<AuthResponse>
}
data class AuthResponse(val accessToken: String)
object RetrofitClient {
private const val BASE_URL = "https://your.api.base.url/" // Change this to your actual base URL
private fun provideOkHttpClient(): OkHttpClient {
return OkHttpClient.Builder()
.build()
}
val retrofit: Retrofit = Retrofit.Builder()
.baseUrl(BASE_URL)
.client(provideOkHttpClient())
.addConverterFactory(GsonConverterFactory.create())
.build()
}
fun provideAuthService(): AuthService {
return RetrofitClient.retrofit.create(AuthService::class.java)
} | TableauApp/app/src/main/java/com/sunueric/tableauapp/network/AuthService.kt | 3657168732 |
package com.sunueric.tableauapp.utils
import android.content.Context
import androidx.security.crypto.EncryptedSharedPreferences
import androidx.security.crypto.MasterKey
fun saveCredentials(email: String, password: String, context: Context) {
val sharedPreferences = EncryptedSharedPreferences.create(
context,
"SecurePreferences",
MasterKey.Builder(context).setKeyScheme(MasterKey.KeyScheme.AES256_GCM).build(),
EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
)
with(sharedPreferences.edit()) {
putString("email", email)
putString("password", password)
apply()
}
}
| TableauApp/app/src/main/java/com/sunueric/tableauapp/utils/SecureCredentials.kt | 2125208199 |
package com.sunueric.tableauapp
import android.view.ViewGroup
import android.webkit.WebView
import android.webkit.WebViewClient
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.unit.dp
import androidx.compose.ui.viewinterop.AndroidView
import com.sunueric.tableauapp.ui.viewmodels.AuthViewModel
import kotlinx.coroutines.delay
@Composable
fun TableauReportView(authViewModel: AuthViewModel) {
val density = LocalDensity.current
val desiredWidthPx = remember(density) {
density.run { 1280.dp.toPx() }
}
val desiredHeightPx = remember(density) {
density.run { 720.dp.toPx() }
}
val webViewUrl = "https://public.tableau.com/views/TestBook_17133560147830/ExecutiveSummary?:embed=y&:tooltip=n&:toolbar=n&:showVizHome=no&:mobile=y&:showAppBanner=n"
val reloadTrigger = remember { mutableStateOf(false) }
val isAuthenticated = authViewModel.isAuthenticated.value
val accessToken = authViewModel.accessToken.value
// Example URL that needs to be dynamically set based on context
//val webViewUrl = "https://public.tableau.com/views/publicViz"
val urlToLoad = remember(isAuthenticated, accessToken) {
if (isAuthenticated == true && !accessToken.isNullOrEmpty()) {
"$webViewUrl?token=$accessToken" // Append the token for authenticated access
} else {
webViewUrl
}
}
AndroidView(
modifier = Modifier.fillMaxSize(),
factory = { context ->
WebView(context).apply {
layoutParams = ViewGroup.LayoutParams(
desiredWidthPx.toInt(),
desiredHeightPx.toInt()
)
webViewClient = object : WebViewClient() {
@Deprecated("Deprecated in Java")
override fun shouldOverrideUrlLoading(view: WebView?, url: String?): Boolean {
view?.loadUrl(url ?: "")
return true
}
}
@Suppress("SetJavaScriptEnabled") // This is safe because the URL is a known constant...
settings.apply {
javaScriptEnabled = true
loadWithOverviewMode = true
useWideViewPort = true
builtInZoomControls = true
displayZoomControls = false
}
loadUrl(webViewUrl)
}
},
update = { webView ->
webView.apply {
layoutParams = ViewGroup.LayoutParams(
desiredWidthPx.toInt(),
desiredHeightPx.toInt()
)
if (reloadTrigger.value) {
webView.loadUrl(webViewUrl)
reloadTrigger.value = false
}
}
}
)
// Periodically reload the WebView
LaunchedEffect(key1 = Unit, urlToLoad) {
authViewModel.authenticateIfNeeded(webViewUrl)
while (true) {
delay(1800000) // wait for 30mins and reload
// Reload the WebView in a UI thread
reloadTrigger.value = true
}
}
}
| TableauApp/app/src/main/java/com/sunueric/tableauapp/ReportWebView.kt | 1814813893 |
package com.rarible.protocol.e2e.mint
import com.rarible.core.test.wait.Wait
import com.rarible.protocol.e2e.test.AbstractTest
import com.rarible.protocol.e2e.test.E2eTest
import kotlinx.coroutines.runBlocking
import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.DynamicTest.dynamicTest
import org.junit.jupiter.api.TestFactory
import java.time.Duration
@E2eTest
class ItemMintTest : AbstractTest() {
@TestFactory
fun `mint item`() = properties.blockchains.map { blockchain ->
dynamicTest("mint item in $blockchain") {
runBlocking {
val content = contentPreparer.preparerImageContent()
val mintMeta = metaPreparer.prepare(blockchain, content)
val itemId = mintService.mintItem(blockchain, mintMeta)
Wait.waitAssert(Duration.ofSeconds(20)) {
val item = unionService.getItemById(itemId)
assertThat(item).isNotNull
}
}
}
}
}
| protocol-e2e/src/test/kotlin/com/rarible/protocol/e2e/mint/ItemMintTest.kt | 2643044775 |
package com.rarible.protocol.e2e.test
import com.rarible.protocol.e2e.configuration.E2eProperties
import com.rarible.protocol.e2e.service.api.UnionService
import com.rarible.protocol.e2e.service.content.ContentPreparer
import com.rarible.protocol.e2e.service.mint.CompositeMetaPreparer
import com.rarible.protocol.e2e.service.mint.CompositeMintService
import com.rarible.protocol.union.api.client.ItemControllerApi
import org.springframework.beans.factory.annotation.Autowired
abstract class AbstractTest {
@Autowired
protected lateinit var unionItemControllerApi: ItemControllerApi
@Autowired
protected lateinit var unionService: UnionService
@Autowired
protected lateinit var mintService: CompositeMintService
@Autowired
protected lateinit var metaPreparer: CompositeMetaPreparer
@Autowired
protected lateinit var contentPreparer: ContentPreparer
@Autowired
protected lateinit var properties: E2eProperties
}
| protocol-e2e/src/test/kotlin/com/rarible/protocol/e2e/test/AbstractTest.kt | 2475930466 |
package com.rarible.protocol.e2e.test
import org.springframework.boot.test.context.SpringBootTest
@SpringBootTest(
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
properties = [
"logging.logstash.tcp-socket.enabled = false",
"logging.logjson.enabled = false",
]
)
annotation class E2eTest
| protocol-e2e/src/test/kotlin/com/rarible/protocol/e2e/test/E2eTest.kt | 1748450099 |
package com.rarible.protocol.e2e
import com.rarible.protocol.e2e.test.AbstractTest
import com.rarible.protocol.e2e.test.E2eTest
import com.rarible.protocol.union.dto.BlockchainDto
import com.rarible.protocol.union.dto.SearchEngineDto
import kotlinx.coroutines.reactor.awaitSingle
import kotlinx.coroutines.runBlocking
import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.EnumSource
@E2eTest
class BasicTest : AbstractTest() {
@ParameterizedTest
@EnumSource(SearchEngineDto::class)
fun `fetch protocol items from union`(searchEngine: SearchEngineDto) = runBlocking<Unit> {
val blockchains = properties.blockchains
val continuation: String? = null
val size = 10
val showDeleted = false
val lastUpdatedFrom: Long? = null
val lastUpdatedTo: Long? = null
val items = unionItemControllerApi.getAllItems(
blockchains,
continuation,
size,
showDeleted,
lastUpdatedFrom,
lastUpdatedTo,
searchEngine
).awaitSingle()
assertThat(items.items).isNotEmpty
}
}
| protocol-e2e/src/test/kotlin/com/rarible/protocol/e2e/BasicTest.kt | 1121528110 |
package com.rarible.protocol.e2e.misc
import com.rarible.contracts.test.erc721.TestERC721
import kotlinx.coroutines.reactive.awaitFirst
import scalether.transaction.MonoSigningTransactionSender
import scalether.transaction.MonoTransactionPoller
object EthereumContractFactory {
suspend fun deployToken(
sender: MonoSigningTransactionSender,
poller: MonoTransactionPoller,
name: String = "Test",
symbol: String = "TST"
): TestERC721 {
return TestERC721.deployAndWait(sender, poller, name, symbol).awaitFirst()
}
}
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/misc/EthereumContractFactory.kt | 2581453237 |
package com.rarible.protocol.e2e.misc
import io.daonomic.rpc.domain.Request
import io.daonomic.rpc.domain.Response
import io.netty.channel.ChannelException
import io.daonomic.rpc.mono.WebClientTransport
import org.springframework.web.reactive.function.client.WebClientException
import reactor.core.publisher.Mono
import reactor.util.retry.Retry
import scala.reflect.Manifest
import scalether.core.MonoEthereum
import scalether.transaction.MonoSigningTransactionSender
import scalether.transaction.MonoSimpleNonceProvider
import scalether.transaction.MonoTransactionPoller
import java.io.IOException
import java.math.BigInteger
import java.net.URL
import java.time.Duration
object EthereumProvider {
fun createEthereum(ethereumUri: URL): MonoEthereum {
val requestTimeoutMs = 10000
val readWriteTimeoutMs = 10000
val maxFrameSize = 1024 * 1024
val retryMaxAttempts = 5L
val retryBackoffDelay = 100L
val retry = Retry.backoff(retryMaxAttempts, Duration.ofMillis(retryBackoffDelay))
.filter { it is WebClientException || it is IOException || it is ChannelException }
val transport = object : WebClientTransport(
ethereumUri.toString(),
MonoEthereum.mapper(),
requestTimeoutMs,
readWriteTimeoutMs
) {
override fun maxInMemorySize(): Int = maxFrameSize
override fun <T : Any?> get(url: String?, manifest: Manifest<T>?): Mono<T> =
super.get(url, manifest).retryWhen(retry)
override fun <T : Any?> send(request: Request?, manifest: Manifest<T>?): Mono<Response<T>> {
return super.send(request, manifest).retryWhen(retry)
}
}
return MonoEthereum(transport)
}
fun createTransactionPoller(ethereum: MonoEthereum): MonoTransactionPoller {
return MonoTransactionPoller(ethereum)
}
fun createUserSender(
privateKey: BigInteger,
ethereum: MonoEthereum
): MonoSigningTransactionSender {
return MonoSigningTransactionSender(
ethereum,
MonoSimpleNonceProvider(ethereum),
privateKey,
BigInteger.valueOf(8000000)
) { Mono.just(BigInteger.valueOf(800000)) }
}
}
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/misc/EthereumProvider.kt | 2402287204 |
package com.rarible.protocol.e2e.misc
import io.netty.channel.ChannelOption
import io.netty.channel.epoll.EpollChannelOption
import org.springframework.http.client.reactive.ClientHttpConnector
import org.springframework.http.client.reactive.ReactorClientHttpConnector
import org.springframework.web.reactive.function.client.WebClient
import reactor.netty.http.client.HttpClient
import reactor.netty.resources.ConnectionProvider
object WebClientProvider {
fun initTransport(): WebClient {
return WebClient.builder().run {
clientConnector(clientConnector())
build()
}
}
private fun clientConnector(): ClientHttpConnector {
val provider = ConnectionProvider.builder("webclient-connection-provider")
.maxConnections(1000)
.pendingAcquireMaxCount(-1)
.lifo()
.build()
val client = HttpClient.create(provider)
.option(ChannelOption.SO_KEEPALIVE, true)
.option(EpollChannelOption.TCP_KEEPIDLE, 300)
.option(EpollChannelOption.TCP_KEEPINTVL, 60)
.option(EpollChannelOption.TCP_KEEPCNT, 8)
return ReactorClientHttpConnector(client)
}
}
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/misc/WebClientProvider.kt | 4091722024 |
package com.rarible.protocol.e2e.misc
import com.fasterxml.jackson.databind.DeserializationFeature
import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.databind.SerializationFeature
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule
import com.fasterxml.jackson.module.kotlin.KotlinModule
import com.rarible.protocol.union.api.ApiClient
object Mapper {
val mapper = ObjectMapper().also {
it.setDateFormat(ApiClient.createDefaultDateFormat())
it.registerModule(JavaTimeModule())
it.registerModule(KotlinModule())
it.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
it.enable(SerializationFeature.INDENT_OUTPUT)
}
}
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/misc/Mapper.kt | 1333486517 |
package com.rarible.protocol.e2e.configuration
import com.rarible.protocol.e2e.service.provide.WebClientCustomizerFactory
import com.rarible.protocol.erc20.api.client.Erc20IndexerApiClientFactory
import com.rarible.protocol.erc20.api.client.Erc20IndexerApiServiceUriProvider
import com.rarible.protocol.erc20.api.client.FixedErc20IndexerApiServiceUriProvider
import com.rarible.protocol.nft.api.client.FixedNftIndexerApiServiceUriProvider
import com.rarible.protocol.nft.api.client.NftIndexerApiClientFactory
import com.rarible.protocol.nft.api.client.NftIndexerApiServiceUriProvider
import com.rarible.protocol.order.api.client.FixedOrderIndexerApiServiceUriProvider
import com.rarible.protocol.order.api.client.OrderIndexerApiServiceUriProvider
import org.springframework.boot.context.properties.EnableConfigurationProperties
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
@Configuration
@EnableConfigurationProperties(E2eProperties::class)
class ProtocolIndexerApiClientsConfiguration(
private val e2eProperties: E2eProperties,
webClientCustomizerFactory: WebClientCustomizerFactory
) {
private val customizer = webClientCustomizerFactory.create(e2eProperties.protocol.getApiKey())
@Bean
fun nftIndexerApiServiceUriProvider(): NftIndexerApiServiceUriProvider {
return FixedNftIndexerApiServiceUriProvider(e2eProperties.protocol.indexerEndpoint)
}
@Bean
fun orderIndexerApiServiceUriProvider(): OrderIndexerApiServiceUriProvider {
return FixedOrderIndexerApiServiceUriProvider(e2eProperties.protocol.indexerEndpoint)
}
@Bean
fun erc20IndexerApiServiceUriProvider(): Erc20IndexerApiServiceUriProvider {
return FixedErc20IndexerApiServiceUriProvider(e2eProperties.protocol.indexerEndpoint)
}
@Bean
fun nftIndexerApiClientFactory(
nftIndexerApiServiceUriProvider: NftIndexerApiServiceUriProvider
): NftIndexerApiClientFactory {
return NftIndexerApiClientFactory(nftIndexerApiServiceUriProvider, customizer)
}
@Bean
fun orderIndexerApiClientFactory(
orderIndexerApiServiceUriProvider: OrderIndexerApiServiceUriProvider
): NftIndexerApiClientFactory {
return NftIndexerApiClientFactory(orderIndexerApiServiceUriProvider, customizer)
}
@Bean
fun erc20IndexerApiClientFactory(
erc20IndexerApiServiceUriProvider: Erc20IndexerApiServiceUriProvider
): Erc20IndexerApiClientFactory {
return Erc20IndexerApiClientFactory(erc20IndexerApiServiceUriProvider, customizer)
}
}
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/configuration/ProtocolIndexerApiClientsConfiguration.kt | 1252221991 |
package com.rarible.protocol.e2e.configuration
import com.rarible.protocol.e2e.model.ApiKey
import com.rarible.protocol.union.dto.BlockchainDto
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.boot.context.properties.ConstructorBinding
import org.springframework.boot.context.properties.NestedConfigurationProperty
import scalether.domain.Address
import java.math.BigInteger
import java.net.URI
import java.net.URL
import java.util.UUID
internal const val RARIBLE_E2E = "e2e"
@ConstructorBinding
@ConfigurationProperties(RARIBLE_E2E)
data class E2eProperties(
val environment: String,
val blockchains: List<BlockchainDto>,
@NestedConfigurationProperty
val protocol: ProtocolClientProperties,
@NestedConfigurationProperty
val contentStorage: ContentStorageProperties,
@NestedConfigurationProperty
val nodes: ChainNodeProperties,
@NestedConfigurationProperty
val account: AccountProperties,
)
data class AccountProperties(
val evm: EvmAccountProperties
)
data class EvmAccountProperties(
val privateKey: BigInteger
)
data class ChainNodeProperties(
@NestedConfigurationProperty
val evm: Map<BlockchainDto, URL>
)
data class ProtocolClientProperties(
val unionEndpoint: URI,
val indexerEndpoint: URI,
val apiKey: String = UUID.randomUUID().toString()
) {
fun getApiKey(): ApiKey {
return ApiKey.protocolApiKey(apiKey)
}
}
data class ContentStorageProperties(
val endpoint: URI,
)
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/configuration/E2eProperties.kt | 2028920296 |
package com.rarible.protocol.e2e.configuration
import com.rarible.protocol.e2e.service.provide.WebClientCustomizerFactory
import com.rarible.protocol.union.api.client.FixedUnionApiServiceUriProvider
import com.rarible.protocol.union.api.client.ItemControllerApi
import com.rarible.protocol.union.api.client.UnionApiClientFactory
import com.rarible.protocol.union.api.client.UnionApiServiceUriProvider
import org.springframework.boot.context.properties.EnableConfigurationProperties
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
@Configuration
@EnableConfigurationProperties(E2eProperties::class)
class ProtocolUnionApiClientsConfiguration(
private val e2eProperties: E2eProperties,
webClientCustomizerFactory: WebClientCustomizerFactory
) {
private val customizer = webClientCustomizerFactory.create(e2eProperties.protocol.getApiKey())
@Bean
fun unionApiServiceUriProvider(): UnionApiServiceUriProvider {
return FixedUnionApiServiceUriProvider(e2eProperties.protocol.unionEndpoint)
}
@Bean
fun unionApiClientFactory(
unionApiServiceUriProvider: UnionApiServiceUriProvider
): UnionApiClientFactory {
return UnionApiClientFactory(unionApiServiceUriProvider, customizer)
}
@Bean
fun unionItemControllerApi(
unionApiClientFactory: UnionApiClientFactory
): ItemControllerApi {
return unionApiClientFactory.createItemApiClient()
}
}
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/configuration/ProtocolUnionApiClientsConfiguration.kt | 2119074601 |
package com.rarible.protocol.e2e.model
@Suppress("ArrayInDataClass")
data class Content(val payload: ByteArray) {
constructor(payload: String) : this(payload.toByteArray())
}
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/model/Content.kt | 1915957708 |
package com.rarible.protocol.e2e.model
data class ApiKey(
val header: String,
val apiKey: String
) {
companion object {
fun protocolApiKey(apiKey: String): ApiKey {
return ApiKey("x-api-key", apiKey)
}
}
}
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/model/ApiKey.kt | 2735952617 |
package com.rarible.protocol.e2e.model
import java.net.URL
class UploadedContent(
val name: String,
val url: URL
)
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/model/UploadedContent.kt | 4238659958 |
package com.rarible.protocol.e2e.model
import java.net.URL
data class MintMeta(
val raw: String,
val content: ContentMeta,
val attributes: List<Attribute>
)
data class Attribute(
val key: String,
val value: String
)
data class ContentMeta(
val content: URL,
val mimeType: String,
val width: Int?,
val height: Int?,
)
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/model/MintMeta.kt | 3368742157 |
package com.rarible.protocol.e2e.service.mint
import com.rarible.protocol.e2e.model.ContentMeta
import com.rarible.protocol.e2e.model.MintMeta
import com.rarible.protocol.e2e.service.mint.blockchain.MetaPreparer
import com.rarible.protocol.union.dto.BlockchainDto
import org.springframework.stereotype.Component
@Component
class CompositeMetaPreparer(
metaPreparers: List<MetaPreparer>
) {
private val preparers = metaPreparers
.flatMap { minter -> minter.supportedBlockchain.map { it to minter } }
.toMap()
suspend fun prepare(blockchain: BlockchainDto, content: ContentMeta): MintMeta {
return getMinter(blockchain).prepare(blockchain, content)
}
private fun getMinter(blockchain: BlockchainDto): MetaPreparer {
return preparers[blockchain] ?: throw IllegalArgumentException("Unsupported blockchain: $blockchain")
}
}
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/service/mint/CompositeMetaPreparer.kt | 4155543328 |
package com.rarible.protocol.e2e.service.mint.blockchain
import com.rarible.protocol.e2e.model.ContentMeta
import com.rarible.protocol.e2e.model.MintMeta
import com.rarible.protocol.union.dto.BlockchainDto
interface MetaPreparer {
val supportedBlockchain: List<BlockchainDto>
suspend fun prepare(blockchain: BlockchainDto, content: ContentMeta): MintMeta
}
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/service/mint/blockchain/MetaPreparer.kt | 2284661511 |
package com.rarible.protocol.e2e.service.mint.blockchain
import com.rarible.protocol.e2e.model.MintMeta
import com.rarible.protocol.union.dto.BlockchainDto
import com.rarible.protocol.union.dto.ItemIdDto
interface MintService {
val supportedBlockchain: List<BlockchainDto>
suspend fun mintItem(blockchain: BlockchainDto, mintMeta: MintMeta): ItemIdDto
}
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/service/mint/blockchain/MintService.kt | 2358140865 |
package com.rarible.protocol.e2e.service.mint.blockchain
import com.rarible.protocol.e2e.misc.Mapper
import com.rarible.protocol.e2e.model.Attribute
import com.rarible.protocol.e2e.model.Content
import com.rarible.protocol.e2e.model.ContentMeta
import com.rarible.protocol.e2e.model.MintMeta
import com.rarible.protocol.e2e.service.content.ContentUploader
import com.rarible.protocol.union.dto.BlockchainDto
import com.rarible.protocol.union.dto.BlockchainGroupDto
import com.rarible.protocol.union.dto.subchains
import org.springframework.stereotype.Component
import java.util.UUID
@Component
class EvmMetaPreparer(
private val uploader: ContentUploader,
) : MetaPreparer {
override val supportedBlockchain = BlockchainGroupDto.ETHEREUM.subchains()
override suspend fun prepare(
blockchain: BlockchainDto,
content: ContentMeta
): MintMeta {
val evmMeta = EvmMeta(
name = "name-${UUID.randomUUID()}",
description = "description-${UUID.randomUUID()}",
image = content.content.toString(),
attributes = (1..10).map {
Attribute(
key = "key-${UUID.randomUUID()}",
value = "value-${UUID.randomUUID()}"
)
}
)
val raw = Mapper.mapper.writeValueAsString(evmMeta)
val tokenUrl = uploader.uploadContent(Content(raw)).url
return MintMeta(
raw = tokenUrl.toString(),
content = content,
attributes = evmMeta.attributes
)
}
private data class EvmMeta(
val name: String,
val description: String,
val image: String,
val attributes: List<Attribute>
)
}
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/service/mint/blockchain/EvmMetaPreparer.kt | 27758808 |
package com.rarible.protocol.e2e.service.mint.blockchain
import com.rarible.protocol.e2e.configuration.E2eProperties
import com.rarible.protocol.e2e.misc.EthereumContractFactory
import com.rarible.protocol.e2e.misc.EthereumProvider
import com.rarible.protocol.e2e.model.MintMeta
import com.rarible.protocol.union.dto.BlockchainDto
import com.rarible.protocol.union.dto.BlockchainGroupDto
import com.rarible.protocol.union.dto.ItemIdDto
import com.rarible.protocol.union.dto.subchains
import kotlinx.coroutines.reactive.awaitFirst
import org.springframework.stereotype.Component
import kotlin.random.Random
@Component
class EvmMintService(
properties: E2eProperties
) : MintService {
private val nodes = properties.nodes.evm
private val account = properties.account.evm
override val supportedBlockchain = BlockchainGroupDto.ETHEREUM.subchains()
override suspend fun mintItem(blockchain: BlockchainDto, mintMeta: MintMeta): ItemIdDto {
require(blockchain in supportedBlockchain) { "Unsupported blockchain: $blockchain" }
val node = nodes[blockchain] ?: throw IllegalArgumentException("Can't find node for blockchain: $blockchain")
val ethereum = EthereumProvider.createEthereum(node)
val sender = EthereumProvider.createUserSender(account.privateKey, ethereum)
val poller = EthereumProvider.createTransactionPoller(ethereum)
val token = EthereumContractFactory.deployToken(sender, poller)
val tokenId = Random.nextInt(1, 1000).toBigInteger()
token.mint(sender.from(), tokenId).execute().awaitFirst()
return ItemIdDto(blockchain = blockchain, value = "${token.address().prefixed()}:$tokenId")
}
}
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/service/mint/blockchain/EvmMintService.kt | 3178162226 |
package com.rarible.protocol.e2e.service.mint
import com.rarible.protocol.e2e.model.MintMeta
import com.rarible.protocol.e2e.service.mint.blockchain.MintService
import com.rarible.protocol.union.dto.BlockchainDto
import com.rarible.protocol.union.dto.ItemIdDto
import org.springframework.stereotype.Component
@Component
class CompositeMintService(
minters: List<MintService>
) {
private val minters = minters
.flatMap { minter -> minter.supportedBlockchain.map { it to minter } }
.toMap()
suspend fun mintItem(blockchain: BlockchainDto, mintMeta: MintMeta): ItemIdDto {
return getMinter(blockchain).mintItem(blockchain, mintMeta)
}
private fun getMinter(blockchain: BlockchainDto): MintService {
return minters[blockchain] ?: throw IllegalArgumentException("Unsupported blockchain: $blockchain")
}
}
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/service/mint/CompositeMintService.kt | 263677192 |
package com.rarible.protocol.e2e.service.content
import com.rarible.protocol.e2e.configuration.E2eProperties
import com.rarible.protocol.e2e.misc.WebClientProvider
import com.rarible.protocol.e2e.model.Content
import com.rarible.protocol.e2e.model.UploadedContent
import org.slf4j.LoggerFactory
import org.springframework.stereotype.Component
import org.springframework.web.reactive.function.client.awaitBodilessEntity
import java.net.URL
import java.util.UUID
@Component
class ContentUploader(e2eProperties: E2eProperties) {
private val properties = e2eProperties.contentStorage
private val transport = WebClientProvider.initTransport()
suspend fun uploadContent(content: Content): UploadedContent {
val name = UUID.randomUUID().toString()
val url = "${properties.endpoint}/$name"
transport.put().uri(url).bodyValue(content.payload).retrieve().awaitBodilessEntity()
val upload = UploadedContent(name = name, url = URL(url))
logger.info("Uploaded content: {}", upload)
return upload
}
private companion object {
private val logger = LoggerFactory.getLogger(ContentUploader::class.java)
}
}
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/service/content/ContentUploader.kt | 2731518908 |
package com.rarible.protocol.e2e.service.content
import com.rarible.core.meta.resource.detector.ContentDetector
import com.rarible.core.meta.resource.model.ContentData
import com.rarible.protocol.e2e.model.Content
import com.rarible.protocol.e2e.model.ContentMeta
import org.springframework.core.io.ClassPathResource
import org.springframework.stereotype.Component
@Component
class ContentPreparer(
private val contentUploader: ContentUploader
) {
private val contentDetector = ContentDetector()
suspend fun preparerImageContent(): ContentMeta {
val image = ClassPathResource("content/image/sample1.png").inputStream.use { it.readAllBytes() }
val uploaded = contentUploader.uploadContent(Content(image))
val meta = contentDetector.detect(ContentData(image), uploaded.name) ?: throw IllegalStateException("Can't detect image meta")
return ContentMeta(
content = uploaded.url,
mimeType = meta.mimeType,
width = meta.width,
height = meta.height,
)
}
}
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/service/content/ContentPreparer.kt | 1639398917 |
package com.rarible.protocol.e2e.service.api
import com.rarible.protocol.union.api.client.ItemControllerApi
import com.rarible.protocol.union.dto.ItemDto
import com.rarible.protocol.union.dto.ItemIdDto
import kotlinx.coroutines.reactive.awaitFirstOrNull
import org.springframework.stereotype.Component
@Component
class UnionService(
protected val itemControllerApi: ItemControllerApi
) : AbstractApiService() {
suspend fun getItemById(itemIdDto: ItemIdDto): ItemDto? {
return clientRequest {
itemControllerApi.getItemById(itemIdDto.fullId()).awaitFirstOrNull()
}
}
} | protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/service/api/UnionService.kt | 1670109748 |
package com.rarible.protocol.e2e.service.api
import org.springframework.http.HttpStatus
import org.springframework.web.reactive.function.client.WebClientResponseException
abstract class AbstractApiService {
protected suspend fun <T> clientRequest(body: suspend () -> T): T? {
return try {
body()
} catch (ex: WebClientResponseException) {
if (ex.statusCode == HttpStatus.NOT_FOUND) {
null
} else {
throw ex
}
}
}
}
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/service/api/AbstractApiService.kt | 3524318914 |
package com.rarible.protocol.e2e.service.provide
import com.rarible.protocol.client.CompositeWebClientCustomizer
import com.rarible.protocol.client.DefaultProtocolWebClientCustomizer
import com.rarible.protocol.e2e.model.ApiKey
import org.springframework.boot.web.reactive.function.client.WebClientCustomizer
import org.springframework.stereotype.Component
@Component
class WebClientCustomizerFactory {
fun create(
apiKey: ApiKey? = null
): WebClientCustomizer {
val customizers = listOfNotNull(
DefaultProtocolWebClientCustomizer("protocol-e2e"),
apiKey?.let { createApiKeyWebClientCustomizer(it) }
)
return CompositeWebClientCustomizer(customizers)
}
private fun createApiKeyWebClientCustomizer(apiKey: ApiKey): WebClientCustomizer {
return WebClientCustomizer { builder ->
builder.defaultHeaders { headers ->
headers.set(apiKey.header, apiKey.apiKey)
}
}
}
}
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/service/provide/WebClientCustomizerFactory.kt | 2435568172 |
package com.rarible.protocol.e2e
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
@SpringBootApplication
class ProtocolE2eApplication
fun main(args: Array<String>) {
runApplication<ProtocolE2eApplication>(*args)
}
| protocol-e2e/src/main/kotlin/com/rarible/protocol/e2e/ProtocolE2eApplication.kt | 2877208447 |
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.getValue
import androidx.compose.runtime.setValue
import kotlinx.coroutines.*
import java.time.Instant
import java.time.LocalDateTime
import java.time.ZoneId
import java.time.format.DateTimeFormatter
import java.util.*
class StopWatch {
var formattedTime by mutableStateOf("00:00:000")
private var coroutineScopt = CoroutineScope(Dispatchers.Default)
private var isActive = false
private var timeMillis = 0L
private var lastTimestamp = 0L
fun start() {
if (isActive) return
coroutineScopt.launch {
lastTimestamp = System.currentTimeMillis()
[email protected] = true
while ([email protected]) {
delay(10L)
timeMillis += System.currentTimeMillis() - lastTimestamp
lastTimestamp = System.currentTimeMillis()
formattedTime = formatTime(timeMillis)
}
}
}
fun pause() {
isActive = false
}
fun reset() {
coroutineScopt.cancel()
coroutineScopt = CoroutineScope(Dispatchers.Default)
timeMillis = 0L
lastTimestamp = 0L
formattedTime = ("00:00:000")
isActive = false
}
private fun formatTime(timeMillis: Long): String {
val localDataTime = LocalDateTime.ofInstant(
Instant.ofEpochMilli(timeMillis),
ZoneId.systemDefault()
)
val formatter = DateTimeFormatter.ofPattern(
"mm:ss:SSS",
Locale.getDefault()
)
return localDataTime.format(formatter)
}
} | kotlin_learning-stopWatchDemo/src/main/kotlin/StopWatch.kt | 2554739301 |
import androidx.compose.foundation.layout.*
import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
import androidx.compose.ui.unit.dp
@Composable
fun StopWatchDisplay(
formattedTime: String,
onStartClick: () -> Unit,
onPauseClick: () -> Unit,
onResetClick: () -> Unit,
modifier: Modifier = Modifier
) {
Column(
modifier = modifier,
horizontalAlignment = Alignment.CenterHorizontally
) {
Text(
text = "็ฎๆ่ฎกๆถๅจ",
fontWeight = FontWeight.Bold,
fontSize = 15.sp,
color = Color.Gray,
)
Spacer(Modifier.height(16.dp))
Text(
text = formattedTime,
fontWeight = FontWeight.Bold,
fontSize = 30.sp,
color = Color.Black,
)
Spacer(Modifier.height(16.dp))
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.Center,
verticalAlignment = Alignment.CenterVertically,
) {
// show ๅผๅง button when not active
Button(onStartClick) {
Text("ๅผๅง")
}
Spacer(Modifier.width(16.dp))
Button(onPauseClick) {
Text("ๆๅ")
}
Spacer(Modifier.width(16.dp))
Button(onResetClick) {
Text("้็ฝฎ")
}
}
}
} | kotlin_learning-stopWatchDemo/src/main/kotlin/StopWatchDisplay.kt | 1659998809 |
import androidx.compose.desktop.ui.tooling.preview.Preview
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material.Button
import androidx.compose.material.MaterialTheme
import androidx.compose.material.Text
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.window.Window
import androidx.compose.ui.window.application
@Composable
@Preview
fun App() {
MaterialTheme {
Box(
contentAlignment = Alignment.Center,
modifier = Modifier.fillMaxSize()
) {
val stopWatch = remember { StopWatch() }
StopWatchDisplay(
formattedTime = stopWatch.formattedTime,
onStartClick = stopWatch::start,
onPauseClick = stopWatch::pause,
onResetClick = stopWatch::reset,
)
}
}
}
fun main() = application {
Window(onCloseRequest = ::exitApplication) {
App()
}
}
| kotlin_learning-stopWatchDemo/src/main/kotlin/Main.kt | 3304208759 |
package Clases
import kotlin.concurrent.schedule
import java.util.*
class Mario(var vidas: Int = 3) { //Setear el numero de vidas por defecto en el contructor
init {
println("It's a me! Mario!")
}
private var state = "small"
set(value){
val before = field
field = value
println("Tu estado ahora es $field")
if(value=="Star"){
Timer("SettingUp", false).schedule(10000){
field = before
println("tu estado ahora es $field")
}
}
}
private var lives = 3
set(value){
if(field == 1){
field = 0
gameOver()
}
else if (field == 0){
println("Necesitas volver a jugar")
}
else{
field = value
}
}
val isAlive: Boolean
get(){
return lives >=1
}
/*private fun die(){
lives--
println("Has perdido una vida!")
}*/
fun collision(collisionObj: String){
when (collisionObj){
"Goomba" -> lives--
"Super Mushroom" -> state = "Super Mario"
"Fire flower" -> state = "Fire Mario"
"Star" -> state = "Star"
else -> println("Objeto desconocido, ยกNo pasa nada!")
}
}
fun getLives(): String{
return "$lives vidas"
}
private fun gameOver(){
println("Juego Terminado")
}
} | 2do_Dep_Juego_Mario/Mario.kt | 1043662697 |
package Clases
open class Enemy (val name: String, val strength:Int){
init {
println("Iniciando superclase")
}
protected var direction: String = "Left"
protected fun changeDirection(){
direction = if (direction=="Right") "Left" else "Right"
println("$name va en direcciรณn $direction")
}
protected fun die(){
println("$name ha muerto")
}
open fun collision(collider: String){
when (collider){
"Weapon" -> die()
"Enemy" -> changeDirection()
}
}
}
| 2do_Dep_Juego_Mario/Enemy.kt | 3902848016 |
package Clases
class Goomba: Enemy("Goomba", 1){
//(name: String, strength: Int):
//Enemy(name,strength) {
//Enemy("Goomba",1) {
init {
println("Iniciando subclase de $name")
}
} | 2do_Dep_Juego_Mario/Goomba.kt | 2979133946 |
import Clases.Goomba
import Clases.Koopa
import Clases.Mario
/*fun main(){
//Clase Telefono
val myPhone = Phone()
myPhone.getTurn()
myPhone.turnOn()
myPhone.getTurn()
//Clase Vehiculo
val miVehiculo = Vehiculos("Ford","2020","Verde")
miVehiculo.placas = "NNT3047"
println("El coche estรก encendido? ${miVehiculo.encendido}")
miVehiculo.encender()
println("El coche encendio? ${miVehiculo.encendido}")
println("El tanque tiene ${miVehiculo.gasolina}")
miVehiculo.recargar(20.07f)
println("El tanque ahora tiene ${miVehiculo.gasolina}")
val golNegro = Vehiculos("Volkswagen", "Gol")
val sonicAzul = Vehiculos(
marca = "Ford",
modelo = "Sonic",
color = "Azul",
placas = "ALS9763"
)
println(golNegro)
println(sonicAzul)
}*/
fun main(){
var mario = Mario()
/*for (i in 1..5){
if(mario.isAlive){
mario.collision("Goomba")
println("Te quedan ${mario.getLives()}")
}
println("Te quedan ${mario.getLives()}")
}*/
mario.collision("star")
/*val enemy = Enemy("Un enemigo",2)
enemy.collision("Enemy")
enemy.collision("Weapon")*/
val enemy = Goomba()
enemy.collision("Enemy")
enemy.collision("Weapon")
val koopa = Koopa()
koopa.collision("Weapon")
}
| 2do_Dep_Juego_Mario/Main.kt | 1485804590 |
package Clases
class Person (val Nombre: String, val Apellidos: String, val Sexo: String, val Altura: String){
} | 2do_Dep_Juego_Mario/Person.kt | 1641046203 |
package Clases
class Phone {
//atributos
var isOn= false
lateinit var model:String
//metodos
fun turnOn(){
isOn = true
}
fun turnOff(){
isOn = true
}
fun getTurn(){
val turnMode = if(isOn) "Encedido" else "Apagado"
println("El telรฉfono esta $turnMode")
}
} | 2do_Dep_Juego_Mario/Phone.kt | 2769991600 |
package Clases
class Koopa:
Enemy("Koopa", 2){
override fun collision(collider: String) {
//super.collision(collider)
when(collider){
"Weapon" -> {
var state = "Shell"
println("El estado ahora es $state")
}
"Enemy" -> changeDirection()
}
println("Usando la colisiรณn de la clase Enemy")
}
}
| 2do_Dep_Juego_Mario/Koopa.kt | 2908339922 |
package Clases
class Vehiculos (val marca: String, val modelo: String, var color: String = "Negro"){
init {
println("""Los datos del coche son:
marca: $marca
modelo: $modelo
color: $color""")
}
constructor(marca: String, modelo: String, color: String, placas: String): this(marca,modelo,color){
this.placas = placas
println("Las placas son: ${this.placas}")
}
//atributos
var placas = ""
var gasolina = 0f
var encendido = false
//metodos
fun encender(){
encendido = true
}
fun apagar(){
encendido = false
}
fun recargar(litros:Float){
gasolina+=litros
}
}
| 2do_Dep_Juego_Mario/Vehiculos.kt | 3771331790 |
package kr.co.anna.lib.config
import kr.co.anna.lib.utils.MessageUtil
import org.springframework.context.MessageSource
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.context.support.MessageSourceAccessor
import org.springframework.context.support.ReloadableResourceBundleMessageSource
import org.springframework.web.servlet.LocaleResolver
import org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver
import java.util.*
@Configuration
class MessageConfig {
@Bean
fun localeResolver(): LocaleResolver {
val localeResolver = AcceptHeaderLocaleResolver()
localeResolver.defaultLocale = Locale.KOREA //์ธ์ด&๊ตญ๊ฐ์ ๋ณด๊ฐ ์๋ ๊ฒฝ์ฐ ํ๊ตญ์ผ๋ก ์ธ์
return localeResolver
}
@Bean
fun messageSource(): MessageSource {
val messageSource = ReloadableResourceBundleMessageSource()
messageSource.setBasenames("classpath:/messages/message")
messageSource.setDefaultEncoding("utf-8")
messageSource.setCacheSeconds(180) // ๋ฆฌ๋ก๋ฉ ๊ฐ๊ฒฉ
Locale.setDefault(Locale.KOREA) // ์ ๊ณตํ์ง ์๋ ์ธ์ด๋ก ์์ฒญ์ด ๋ค์ด์์ ๋ MessageSource์์ ์ฌ์ฉํ ๊ธฐ๋ณธ ์ธ์ด์ ๋ณด.
return messageSource
}
@Bean
fun messageSourceAccessor(): MessageSourceAccessor {
return MessageSourceAccessor(messageSource()!!)
}
@Bean
fun messageUtils() {
MessageUtil.messageSourceAccessor = messageSourceAccessor()!!
}
}
| kopring_graphql_querydsl/common/lib/src/main/kotlin/kr/co/anna/lib/config/MessageConfig.kt | 1848389810 |
package kr.co.anna.lib.security.jwt
import io.jsonwebtoken.Claims
import io.jsonwebtoken.Jws
import io.jsonwebtoken.Jwts
import io.jsonwebtoken.io.Decoders
import io.jsonwebtoken.security.Keys
import kr.co.anna.lib.error.JwtUnauthenticatedAccessException
import kr.co.anna.lib.security.AuthUser
import kr.co.anna.lib.security.SignInUser
import kr.co.anna.lib.security.UserDetailsServiceImpl
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken
import org.springframework.stereotype.Component
/**
* JWT ๋ฌธ์์ด์ ์ฒ๋ฆฌํ๋ ์ฑ
์์ ๊ฐ์ง ๊ฐ์ฒด
* JWT ํ ํฐ์์ ์ธ์ฆ ์ ๋ณด ์กฐํ
*/
@Component
class JwtProcessor(
private val jwtProperties: JwtProperties,
private val userDetailsServiceImpl: UserDetailsServiceImpl
) {
/**
* jwt ๋ฌธ์์ด์ ํ์ฑํ๊ณ ์ฌ์ฉ์ ์ ๋ณด๋ฅผ UsernamePasswordAuthenticationToken ์ ๋ด์ ๋ฐํ
* UsernamePasswordAuthenticationToken ๋ JwtFilter๋ฅผ ํตํด Spring Security Context ์ ์ ์ฅ๋๊ณ ,
* SecurityContextHolder.getContext().authentication ๋ก ๊บผ๋ด์ ์ฌ์ฉ ๊ฐ๋ฅ
*/
fun extractAuthentication(jwt: String): UsernamePasswordAuthenticationToken {
val jws = parse(jwt)
val body = jws.body
val userId = body[JwtKeys.UID.keyName].toString()
val userOid = (body[JwtKeys.USER_OID.keyName] as Int).toLong()
val userDetails = userDetailsServiceImpl.loadUserByUsername(userId) as SignInUser //db์์ idํ์ธ
if (userDetails.userOid() != userOid) throw JwtUnauthenticatedAccessException()
return UsernamePasswordAuthenticationToken(AuthUser(userDetails), jws, userDetails.authorities)
}
private fun parse(token: String): Jws<Claims> {
return Jwts.parserBuilder()
.setSigningKey(Keys.hmacShaKeyFor(Decoders.BASE64.decode(jwtProperties.base64EncodedSecret)))
.build()
.parseClaimsJws(token)
}
}
| kopring_graphql_querydsl/common/lib/src/main/kotlin/kr/co/anna/lib/security/jwt/JwtProcessor.kt | 3808581028 |
package kr.co.anna.lib.security.jwt
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.boot.context.properties.ConstructorBinding
@ConfigurationProperties(prefix = "jwt")
@ConstructorBinding
data class JwtProperties (
val base64EncodedSecret: String, // JWT ์์ฑ/ํ์ฑ์ ์ฌ์ฉํ๋ ๋น๋ฐํค
val tokenDurationHr: Int? = 24, // ์ฌ์ฉ์ ํ ํฐ ์ ํจ ์๊ฐ
val swaggerTokenDurationHr: Int? = 120, // ์ค์จ๊ฑฐ ํ ํฐ ์ ํจ ์๊ฐ
val generatorEnabled: Boolean = false, // ์ค์จ๊ฑฐ์ ํ ํฐ ์์ฑ๊ธฐ ํฌํจ ์ฌ๋ถ
)
| kopring_graphql_querydsl/common/lib/src/main/kotlin/kr/co/anna/lib/security/jwt/JwtProperties.kt | 1263105240 |
package kr.co.anna.lib.security.jwt
import org.springframework.security.core.context.SecurityContextHolder
import org.springframework.web.filter.OncePerRequestFilter
import javax.servlet.FilterChain
import javax.servlet.http.HttpServletRequest
import javax.servlet.http.HttpServletResponse
class JwtAuthFilter(private val jwtProcessor: JwtProcessor) :
OncePerRequestFilter() {
override fun doFilterInternal(
request: HttpServletRequest,
response: HttpServletResponse,
filterChain: FilterChain
) {
val jwtFromRequest = getJwtFromRequest(request)
try {
if (!jwtFromRequest.isNullOrBlank()) {
SecurityContextHolder.getContext().authentication =
jwtProcessor.extractAuthentication(jwtFromRequest) // SecurityContext ์ Authentication ๊ฐ์ฒด๋ฅผ ์ ์ฅํฉ๋๋ค.
}
} catch (e: Exception) {
SecurityContextHolder.clearContext()
}
filterChain.doFilter(request, response)
}
private val BEARER_PREFIX = "Bearer "
private fun getJwtFromRequest(request: HttpServletRequest): String? {
val bearerToken = request.getHeader("Authorization")
return if (!bearerToken.isNullOrBlank() && bearerToken.startsWith(BEARER_PREFIX, true)) {
bearerToken.substring(BEARER_PREFIX.length)
} else null
}
}
| kopring_graphql_querydsl/common/lib/src/main/kotlin/kr/co/anna/lib/security/jwt/JwtAuthFilter.kt | 2888317905 |
package kr.co.anna.lib.security.jwt
enum class JwtKeys(val keyName: String) {
UID("uid"),
USER_OID("userOid")
}
| kopring_graphql_querydsl/common/lib/src/main/kotlin/kr/co/anna/lib/security/jwt/JwtKeys.kt | 2269066340 |
package kr.co.anna.lib.security.jwt
import io.jsonwebtoken.Jwts
import io.jsonwebtoken.SignatureAlgorithm
import io.jsonwebtoken.io.Decoders
import io.jsonwebtoken.security.Keys
import kr.co.anna.domain.model.Role
import kr.co.anna.lib.security.SignInUser
import org.slf4j.LoggerFactory
import org.springframework.stereotype.Component
import java.util.*
import javax.crypto.SecretKey
/**
* JWT(JSON Web Token)๋ฅผ ์์ฑํ๋ ์ฑ
์์ ๊ฐ์ง ๊ฐ์ฒด
*/
@Component
class JwtGenerator(
private val jwtProperties: JwtProperties,
) {
private val key: SecretKey = Keys.hmacShaKeyFor(Decoders.BASE64.decode(jwtProperties.base64EncodedSecret))
fun generateUserToken(signInUser: SignInUser): String {
return Jwts.builder()
.setSubject("kopring_graphql_querydsl")
.claim(JwtKeys.UID.keyName, signInUser.username)
.claim(JwtKeys.USER_OID.keyName, signInUser.userOid())
.signWith(key, SignatureAlgorithm.HS512)
.setExpiration(expiration(jwtProperties.swaggerTokenDurationHr))
.compact()
}
private fun expiration(hour: Int?): Date = Date(Date().time + (1000 * 60 * 60 * hour!!.toInt()))
}
| kopring_graphql_querydsl/common/lib/src/main/kotlin/kr/co/anna/lib/security/jwt/JwtGenerator.kt | 4018073854 |
package kr.co.anna.lib.security
import kr.co.anna.domain.model.user.User
import org.springframework.security.core.GrantedAuthority
import org.springframework.security.core.authority.SimpleGrantedAuthority
import org.springframework.security.core.userdetails.UserDetails
class SignInUser(
val user: User,
) : UserDetails {
override fun getAuthorities(): MutableCollection<out GrantedAuthority> {
return user.role().map { SimpleGrantedAuthority(it.getCode()) }.toMutableSet()
}
override fun getPassword(): String {
return user.password()
}
override fun getUsername(): String {
return user.userId()
}
override fun isAccountNonExpired(): Boolean {
return true
}
override fun isAccountNonLocked(): Boolean {
return true
}
override fun isCredentialsNonExpired(): Boolean {
return true
}
override fun isEnabled(): Boolean {
return user.checkActiveUser()
}
fun name() = user.name()
fun email() = user.email()
fun userOid() = user.oid
fun roles() = user.role()
}
| kopring_graphql_querydsl/common/lib/src/main/kotlin/kr/co/anna/lib/security/SignInUser.kt | 1144070753 |
package kr.co.anna.lib.security
import kr.co.anna.domain.model.Role
import org.springframework.security.core.GrantedAuthority
/**
* ๋ก๊ทธ์ธ ํ ์ฌ์ฉ์์ ์ ๋ณด๋ฅผ ๋ด๋ ๊ฐ์ฒด
* ์ด ๊ฐ์ฒด๋ Spring Security Context ์ ์ ์ฅ๋๊ณ ,
* ํ์ํ ๋ SecurityContextHolder.getContext().authentication.principal as? AuthUser ๋ฅผ ํธ์ถํด์ ์ป๋ค ์ ์๋ค.
*/
data class AuthUser(
val userId: String,
val userOid: Long,
val authorities: Collection<GrantedAuthority>,
val roles: List<Role>
) {
constructor(signInUser: SignInUser) : this(
signInUser.username,
signInUser.userOid()!!,
signInUser.authorities,
signInUser.roles()
)
fun isFreePass(): Boolean {
return authorities.map { it.authority }.contains(Role.ROLE_SYS_ADMIN.getCode())
}
}
| kopring_graphql_querydsl/common/lib/src/main/kotlin/kr/co/anna/lib/security/AuthUser.kt | 1635774426 |
package kr.co.anna.lib.security
import kr.co.anna.domain.repository.user.UserRepository
import org.springframework.security.core.userdetails.UserDetails
import org.springframework.security.core.userdetails.UserDetailsService
import org.springframework.stereotype.Service
@Service
class UserDetailsServiceImpl(
private val userRepository: UserRepository,
) : UserDetailsService {
override fun loadUserByUsername(userId: String?): UserDetails {
if (userId.isNullOrEmpty()) throw IllegalArgumentException("๋ก๊ทธ์ธ ์์ด๋๊ฐ ๋น์ด์์ต๋๋ค.")
val user = userRepository.getByUserId(userId)
return SignInUser(user)
}
}
| kopring_graphql_querydsl/common/lib/src/main/kotlin/kr/co/anna/lib/security/UserDetailsServiceImpl.kt | 2770490313 |
package kr.co.anna.lib.security
import kr.co.anna.domain.model.Role
import kr.co.anna.lib.utils.MessageUtil
import org.springframework.security.access.AccessDeniedException
import org.springframework.security.core.context.SecurityContextHolder
object SecurityUtil {
private fun authUser(): AuthUser {
val authUser = SecurityContextHolder.getContext().authentication.principal as? AuthUser
?: throw RuntimeException(MessageUtil.getMessage("UNAUTHENTICATED_USER"))
return authUser
}
fun checkUserOid(userOid: Long) {
val authUser = authUser()
if (authUser.isFreePass()) return
if (authUser.userOid != userOid) {
throw AccessDeniedException(MessageUtil.getMessage("UNAUTHORIZED_ACCESS"))
}
}
fun checkUserId(userId: String) {
val authUser = authUser()
if (authUser.isFreePass()) return
if (authUser.userId != userId) {
throw AccessDeniedException(MessageUtil.getMessage("UNAUTHORIZED_ACCESS"))
}
}
fun checkManagerRole() {
val authUser = authUser()
if (authUser.isFreePass()) return
if (!authUser.roles.any { it.getCode().equals(Role.ROLE_MANAGER.getCode()) }) {
throw AccessDeniedException(MessageUtil.getMessage("ROLE_NOT_FOUND"))
}
}
}
| kopring_graphql_querydsl/common/lib/src/main/kotlin/kr/co/anna/lib/security/SecurityUtil.kt | 1713036318 |
package kr.co.anna.lib.utils
import org.springframework.context.support.MessageSourceAccessor
object MessageUtil {
var messageSourceAccessor: MessageSourceAccessor? = null
fun getMessage(key: String?): String {
return messageSourceAccessor!!.getMessage(key!!)
}
}
| kopring_graphql_querydsl/common/lib/src/main/kotlin/kr/co/anna/lib/utils/MessageUtil.kt | 511224098 |
package kr.co.anna.lib.error
import com.fasterxml.jackson.annotation.JsonInclude
import org.springframework.validation.BindingResult
import java.time.ZoneId
import java.time.ZonedDateTime
class ErrorBody(
val message: String,
@JsonInclude(JsonInclude.Include.NON_NULL)
val requestUrl: String? = null,
val timestamp: ZonedDateTime,
@JsonInclude(JsonInclude.Include.NON_NULL)
val exceptionName: String? = null,
@JsonInclude(JsonInclude.Include.NON_EMPTY)
val errors: List<FieldErr>? = null,
) {
constructor(message: String, requestUrl: String?, exceptionName: String?) :
this(message, requestUrl, ZonedDateTime.now(ZoneId.of("Z")), exceptionName)
constructor(message: String, requestUrl: String?, exceptionName: String?, errors: BindingResult) :
this(message, requestUrl, ZonedDateTime.now(ZoneId.of("Z")), exceptionName, FieldErr.from(errors))
}
| kopring_graphql_querydsl/common/lib/src/main/kotlin/kr/co/anna/lib/error/ErrorBody.kt | 4263947623 |
package kr.co.anna.lib.error
import org.springframework.validation.BindingResult
class FieldErr(
val field: String,
val value: String?,
val reason: String?) {
companion object {
internal fun from(bindingResult: BindingResult): List<FieldErr> {
return bindingResult.fieldErrors
.map { FieldErr(
it.field,
it.rejectedValue?.toString(),
it.defaultMessage
) }
}
}
}
| kopring_graphql_querydsl/common/lib/src/main/kotlin/kr/co/anna/lib/error/FieldErr.kt | 3746848449 |
package kr.co.anna.lib.error
import kr.co.anna.lib.utils.MessageUtil
class UnauthenticatedAccessException
: RuntimeException(MessageUtil.getMessage("UNAUTHORIZED_ACCESS")) {
}
| kopring_graphql_querydsl/common/lib/src/main/kotlin/kr/co/anna/lib/error/UnauthenticatedAccessException.kt | 2612694833 |
package kr.co.anna.lib.error
import org.slf4j.LoggerFactory
import org.springframework.web.filter.OncePerRequestFilter
import org.springframework.web.servlet.HandlerExceptionResolver
import javax.servlet.FilterChain
import javax.servlet.http.HttpServletRequest
import javax.servlet.http.HttpServletResponse
/**
* Filter Chain ์์์ ๋ฐ์ํ ์์ธ๋ฅผ GlobalExceptionHandler ์์ ์ฒ๋ฆฌํ ์ ์๊ฒ ํด์ฃผ๋ ํํฐ
* Security Config ์ ์ถ๊ฐํ ๋ ํํฐ ์ฒด์ธ ์์ชฝ์ ๋์์ผ ๋ ๋์ ๋ฒ์์ ํํฐ ์ฒด์ธ ์ปค๋ฒ ๊ฐ๋ฅ
* ํํฐ ์ฒด์ธ ๋ชฉ๋ก: https://docs.spring.io/spring-security/site/docs/current/reference/html5/#filter-stack
*/
class ErrorResolvingFilter(
private val handlerExceptionResolver: HandlerExceptionResolver
): OncePerRequestFilter() {
private val log = LoggerFactory.getLogger(javaClass)
override fun doFilterInternal(
request: HttpServletRequest,
response: HttpServletResponse,
filterChain: FilterChain
) {
try {
filterChain.doFilter(request, response)
} catch (e: Exception) {
log.error("Exception in Filter Chain:", e)
handlerExceptionResolver.resolveException(request, response, null, e)
}
}
}
| kopring_graphql_querydsl/common/lib/src/main/kotlin/kr/co/anna/lib/error/ErrorResolvingFilter.kt | 719353058 |
package kr.co.anna.lib.error
import org.springframework.validation.BindingResult
/**
* ๋ฐธ๋ฆฌ๋ฐ์ด์
์๋ฌ์ฒ๋ฆฌ
*/
class InvalidException(
message: String? = null,
val errors: BindingResult,
) : RuntimeException(
message
) {
}
| kopring_graphql_querydsl/common/lib/src/main/kotlin/kr/co/anna/lib/error/InvalidException.kt | 1222424123 |
package kr.co.anna.lib.error
import kr.co.anna.lib.utils.MessageUtil
class JwtUnauthenticatedAccessException
: RuntimeException(MessageUtil.getMessage("UNAUTHORIZED_ACCESS")) {
}
| kopring_graphql_querydsl/common/lib/src/main/kotlin/kr/co/anna/lib/error/JwtUnauthenticatedAccessException.kt | 3047460724 |
package kr.co.anna.lib.error
import kr.co.anna.domain.exception.DomainEntityNotFoundException
import kr.co.anna.domain.exception.NotAllowedException
import kr.co.anna.lib.security.AuthUser
import org.slf4j.LoggerFactory
import org.slf4j.MDC
import org.springframework.core.NestedRuntimeException
import org.springframework.http.HttpStatus
import org.springframework.http.ResponseEntity
import org.springframework.security.access.AccessDeniedException
import org.springframework.security.authentication.BadCredentialsException
import org.springframework.security.core.context.SecurityContextHolder
import org.springframework.web.bind.annotation.ExceptionHandler
import org.springframework.web.bind.annotation.RestControllerAdvice
import org.springframework.web.servlet.support.ServletUriComponentsBuilder
import java.security.InvalidParameterException
@RestControllerAdvice
class GlobalExceptionHandler(
) {
@ExceptionHandler(IllegalArgumentException::class)
fun handleIllegalArgumentException(e: IllegalArgumentException): ResponseEntity<ErrorBody> {
log(e,e.javaClass.simpleName)
val errorBody =
ErrorBody(
message = e.message ?: "๋ฉ์์ง ์๋ IllegalArgumentException ์ด ๋ฐ์ํ์ต๋๋ค.",
requestUrl = ServletUriComponentsBuilder.fromCurrentRequestUri().toUriString()
,e.javaClass.simpleName
)
return ResponseEntity(errorBody, HttpStatus.BAD_REQUEST)
}
/**
* ์ธ๊ฐ์ฒ๋ฆฌ
*/
@ExceptionHandler(AccessDeniedException::class)
fun handleAccessDeniedException(
e: AccessDeniedException
): ResponseEntity<ErrorBody> {
log(e,e.javaClass.simpleName)
val errorBody =
ErrorBody(
message = e.message ?: "ํ๊ฐ๋์ง ์์ ์ ๊ทผ์
๋๋ค.",
requestUrl = ServletUriComponentsBuilder.fromCurrentRequestUri().toUriString()
,e.javaClass.simpleName
)
return ResponseEntity(errorBody, HttpStatus.FORBIDDEN)
}
/**
* ์ธ์ฆ์ฒ๋ฆฌ
*/
@ExceptionHandler(
JwtUnauthenticatedAccessException::class,
UnauthenticatedAccessException::class,
BadCredentialsException::class
)
fun handleBadCredentialsException(
e: RuntimeException
): ResponseEntity<ErrorBody> {
log(e,e.javaClass.simpleName)
val errorBody =
ErrorBody(
message = e.message ?: "๋ก๊ทธ์ธ ์ ๋ณด๊ฐ ์ฌ๋ฐ๋ฅด์ง ์์ต๋๋ค.",
requestUrl = ServletUriComponentsBuilder.fromCurrentRequestUri().toUriString()
,e.javaClass.simpleName
)
return ResponseEntity(errorBody, HttpStatus.UNAUTHORIZED)
}
/**
* ๋น์ฆ๋์ค ์ ์ ์ต์
์
* ๊ธฐ๋ฅ์ ํ
*/
@ExceptionHandler(NotAllowedException::class)
fun handleNotAllowedException(
e: NotAllowedException
): ResponseEntity<ErrorBody> {
log(e,e.javaClass.simpleName)
val errorBody =
ErrorBody(
message = e.message ?: "ํ์ฉ๋์ง ์๋ ๊ธฐ๋ฅ์
๋๋ค.",
requestUrl = ServletUriComponentsBuilder.fromCurrentRequestUri().toUriString()
,e.javaClass.simpleName
)
return ResponseEntity(errorBody, HttpStatus.FORBIDDEN)
}
/**
* ๋๋ฉ์ธ ์ต์
์
*/
@ExceptionHandler(DomainEntityNotFoundException::class)
fun handleDomainEntityNotFoundException(
e: DomainEntityNotFoundException
): ResponseEntity<ErrorBody> {
log(e,e.entityClazz.simpleName)
val errorBody =
ErrorBody(
message = e.message ?: "ํด๋น์ ๋ณด๋ฅผ ์ฐพ์ ์ ์์ต๋๋ค.",
requestUrl = ServletUriComponentsBuilder.fromCurrentRequestUri().toUriString()
,e.entityClazz.simpleName
)
return ResponseEntity(errorBody, HttpStatus.NOT_FOUND)
}
@ExceptionHandler(NestedRuntimeException::class)
fun handleNestedRuntimeException(e: NestedRuntimeException): ResponseEntity<ErrorBody> {
log(e,e.javaClass.simpleName)
val errorBody =
ErrorBody(
message = e.rootCause?.message ?: e.message ?: "๋ฉ์์ง ์๋ NestedRuntimeException ์ด ๋ฐ์ํ์ต๋๋ค.",
requestUrl = ServletUriComponentsBuilder.fromCurrentRequestUri().toUriString()
,e.javaClass.simpleName
)
return ResponseEntity(errorBody, HttpStatus.INTERNAL_SERVER_ERROR)
}
/**
* ๋ฐธ๋ฆฌ๋ฐ์ด์
๊ฐ ๊ฒ์ฆ ์๋ฌ
*/
@ExceptionHandler(InvalidException::class, InvalidParameterException::class)
fun handleInvaliduserException(e: InvalidException): ResponseEntity<ErrorBody> {
log(e,e.javaClass.simpleName)
val errorBody =
ErrorBody(
message = e.message ?: "๋ฉ์์ง ์๋ InvalidException ์ด ๋ฐ์ํ์ต๋๋ค.",
requestUrl = ServletUriComponentsBuilder.fromCurrentRequestUri().toUriString(),
e.javaClass.simpleName,
errors = e.errors,
)
return ResponseEntity(errorBody, HttpStatus.BAD_REQUEST)
}
@ExceptionHandler(Exception::class)
fun handleException(e: Exception): ResponseEntity<ErrorBody> {
log(e,e.javaClass.simpleName)
val errorBody =
ErrorBody(
message = e.message ?: "๋ฉ์์ง ์๋ Exception ์ด ๋ฐ์ํ์ต๋๋ค.",
requestUrl = ServletUriComponentsBuilder.fromCurrentRequestUri().toUriString()
,e.javaClass.simpleName
)
return ResponseEntity(errorBody, HttpStatus.INTERNAL_SERVER_ERROR)
}
private fun setUserId() {
val authUser = SecurityContextHolder.getContext().authentication.principal as? AuthUser
MDC.put("userId", authUser?.userId)
}
private fun log(
e: Exception,
className : String?
) {
setUserId()
log.error("$className | $e")
MDC.clear()
}
private val log = LoggerFactory.getLogger(javaClass)
}
| kopring_graphql_querydsl/common/lib/src/main/kotlin/kr/co/anna/lib/error/GlobalExceptionHandler.kt | 4211151565 |
package kr.co.anna.domain.repository.user
import kr.co.anna.domain.model.user.User
import org.springframework.data.jpa.repository.JpaRepository
interface UserRepository : JpaRepository<User, Long>, UserRepositoryCustom
| kopring_graphql_querydsl/common/domain/src/main/kotlin/kr/co/anna/domain/repository/user/UserRepository.kt | 1162546284 |
package kr.co.anna.domain.repository.user
import kr.co.anna.domain.model.user.User
import org.springframework.data.domain.Page
import org.springframework.data.domain.Pageable
import java.util.*
interface UserRepositoryCustom {
fun getByOid(oid: Long): User
fun getByUserId(userId: String) : User
}
| kopring_graphql_querydsl/common/domain/src/main/kotlin/kr/co/anna/domain/repository/user/UserRepositoryCustom.kt | 3336776088 |
package kr.co.anna.domain.repository.user
import com.querydsl.core.types.dsl.BooleanExpression
import kr.co.anna.domain._common.DomainMessageUtil
import kr.co.anna.domain.exception.DomainEntityNotFoundException
import kr.co.anna.domain.model.user.QUser
import kr.co.anna.domain.model.user.User
import org.springframework.data.jpa.repository.support.QuerydslRepositorySupport
class UserRepositoryImpl : QuerydslRepositorySupport(User::class.java), UserRepositoryCustom {
private val qUser = QUser.user
override fun getByOid(oid: Long): User {
return from(qUser)
.where(
isActive(),
qUser.oid.eq(oid)
)
.fetchOne() ?: throw DomainEntityNotFoundException(oid, User::class, DomainMessageUtil.getMessage("USER_NOT_FOUND"))
}
override fun getByUserId(userId: String): User {
return from(qUser)
.where(
isActive(),
qUser.userId.eq(userId)
)
.fetchOne() ?: throw DomainEntityNotFoundException(userId, User::class, DomainMessageUtil.getMessage("USER_NOT_FOUND"))
}
private fun isActive(): BooleanExpression? {
return qUser.status.eq(User.Status.ACTIVE)
}
}
| kopring_graphql_querydsl/common/domain/src/main/kotlin/kr/co/anna/domain/repository/user/UserRepositoryImpl.kt | 3325335043 |
package kr.co.anna.domain.converter
import kr.co.anna.domain._common.EnumModel
import kr.co.anna.domain.model.Role
import javax.persistence.Convert
/**
* role list num ๋ณํ
*/
@Convert
class RoleEnumToListConvert(private val targetEnumClass: Class<out EnumModel> = Role::class.java) :
EnumToListConverter(targetEnumClass) {
}
| kopring_graphql_querydsl/common/domain/src/main/kotlin/kr/co/anna/domain/converter/RoleEnumToListConvert.kt | 55877664 |
package kr.co.anna.domain.converter
import javax.persistence.AttributeConverter
import javax.persistence.Converter
/**
* DB data 'Y/N' ๊ณผ ๊ฐ์ฒด boolean ์ปจ๋ฒํฐ
* ๊ธ๋ก๋ฒ ์ค์
*/
@Converter(autoApply = true)
class BooleanToYNConverter: AttributeConverter<Boolean, String> {
override fun convertToDatabaseColumn(attribute: Boolean?): String {
if (attribute == null) return "N"
return if (attribute) "Y" else "N"
}
override fun convertToEntityAttribute(yn: String?): Boolean {
return "Y".equals(yn, true)
}
}
| kopring_graphql_querydsl/common/domain/src/main/kotlin/kr/co/anna/domain/converter/BooleanToYNConverter.kt | 3130778124 |
package kr.co.anna.domain.converter
import kr.co.anna.domain._common.EnumModel
import javax.persistence.AttributeConverter
/**
* ์ฝค๋ง๋ก ๊ตฌ๋ถ๋ ๋ฐ์ดํฐ๋ค์ ๊ฐ์ฒด์์ ์ปฌ๋ ์
์ผ๋ก ๋ณํ
*/
open class EnumToListConverter(private var targetEnumClass: Class<out EnumModel>) :
AttributeConverter<List<EnumModel>, String> {
override fun convertToDatabaseColumn(attribute: List<EnumModel>?): String {
if (attribute != null) {
return attribute.joinToString(COMMA) { it.getCode() }
}
return ""
}
override fun convertToEntityAttribute(dbData: String?): List<EnumModel>? {
if (!dbData.isNullOrBlank()) {
return dbData.split(COMMA).toTypedArray()
.map { att -> targetEnumClass.enumConstants.find { att == it.getCode() }!! }
}
return emptyList()
}
companion object {
private const val COMMA: String = ","
}
}
| kopring_graphql_querydsl/common/domain/src/main/kotlin/kr/co/anna/domain/converter/EnumToListConverter.kt | 3993624570 |
package kr.co.anna.domain.converter
import org.springframework.data.domain.Page
import org.springframework.data.domain.PageImpl
import org.springframework.data.domain.Pageable
class ListToPageConverter {
companion object {
fun <E> pageFromListAndPageable(
list: List<E>,
pageable: Pageable,
): Page<E> {
val start = pageable.offset.toInt()
val end = (start + pageable.pageSize).coerceAtMost(list.size)
return PageImpl(list.subList(start, end), pageable, list.size.toLong())
}
}
}
| kopring_graphql_querydsl/common/domain/src/main/kotlin/kr/co/anna/domain/converter/ListToPageConverter.kt | 2971603361 |
package kr.co.anna.domain.converter
import javax.persistence.AttributeConverter
import javax.persistence.Converter
@Converter
class StringToListConverter : AttributeConverter<List<String>, String> {
override fun convertToDatabaseColumn(recipients: List<String>): String {
return recipients.joinToString(COMMA)
}
override fun convertToEntityAttribute(dbData: String): List<String> {
return dbData.split(COMMA)
}
companion object {
private const val COMMA: String = ","
}
}
| kopring_graphql_querydsl/common/domain/src/main/kotlin/kr/co/anna/domain/converter/StringToListConverter.kt | 1887609633 |
package kr.co.anna.domain.config
import com.p6spy.engine.logging.Category
import com.p6spy.engine.spy.appender.MessageFormattingStrategy
import org.hibernate.engine.jdbc.internal.FormatStyle
import java.util.*
/**
* JPA ๊ฐ ์คํํ๋ ์ฟผ๋ฆฌ์ ํ๋ผ๋ฏธํฐ๋ฅผ ๋ณผ ์ ์๊ฒ ํด์ฃผ๋ P6Spy ์ค์
*/
class P6SpyLogger : MessageFormattingStrategy {
override fun formatMessage(
connectionId: Int,
now: String?,
elapsed: Long,
category: String,
prepared: String?,
sql: String,
url: String?
): String {
val callStack = Stack<String>()
val stackTrace = Throwable().stackTrace
for (i in stackTrace.indices) {
val trace = stackTrace[i].toString()
if (trace.startsWith("kr.co.anna") && !trace.contains("P6SpyLogger") && !trace.contains("$$")) {
callStack.push(trace)
}
}
val callStackBuilder = StringBuilder()
var order = 1
while (callStack.size != 0) {
callStackBuilder.append(
"""
${order++}. ${callStack.pop()}"""
)
}
val message = StringBuilder()
.append("\n\tExecution Time: ").append(elapsed).append(" ms\n")
.append("\n----------------------------------------------------------------------------------------------------")
.toString()
return sqlFormat(sql, category, message)
}
private fun sqlFormat(sql: String, category: String, message: String): String {
var sql = sql
if (sql.trim { it <= ' ' }.isEmpty()) {
return ""
}
if (Category.STATEMENT.getName().equals(category)) {
val s = sql.trim { it <= ' ' }.toLowerCase(Locale.ROOT)
sql = if (s.startsWith("create") || s.startsWith("alter") || s.startsWith("comment")) {
FormatStyle.DDL
.formatter
.format(sql)
} else {
FormatStyle.BASIC
.formatter
.format(sql)
}
}
return StringBuilder().append("\n")
.append(sql)
.append(message)
.toString()
}
}
| kopring_graphql_querydsl/common/domain/src/main/kotlin/kr/co/anna/domain/config/P6SpyLogger.kt | 2514191508 |
package kr.co.anna.domain.config
import kr.co.anna.domain._common.DomainMessageUtil
import org.springframework.context.MessageSource
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.context.support.MessageSourceAccessor
import org.springframework.context.support.ReloadableResourceBundleMessageSource
import org.springframework.web.servlet.LocaleResolver
import org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver
import java.util.*
@Configuration
class DomainMessageConfig {
@Bean
fun localeResolverDomain(): LocaleResolver? {
val localeResolver = AcceptHeaderLocaleResolver()
localeResolver.defaultLocale = Locale.KOREA //์ธ์ด&๊ตญ๊ฐ์ ๋ณด๊ฐ ์๋ ๊ฒฝ์ฐ ํ๊ตญ์ผ๋ก ์ธ์
return localeResolver
}
@Bean
fun messageSourceDomain(): MessageSource? {
val messageSource = ReloadableResourceBundleMessageSource()
messageSource.setBasenames("classpath:/domain-messages/message")
messageSource.setDefaultEncoding("utf-8")
messageSource.setCacheSeconds(180) // ๋ฆฌ๋ก๋ฉ ๊ฐ๊ฒฉ
Locale.setDefault(Locale.KOREA) // ์ ๊ณตํ์ง ์๋ ์ธ์ด๋ก ์์ฒญ์ด ๋ค์ด์์ ๋ MessageSource์์ ์ฌ์ฉํ ๊ธฐ๋ณธ ์ธ์ด์ ๋ณด.
return messageSource
}
@Bean
fun messageSourceAccessorDomain(): MessageSourceAccessor {
return MessageSourceAccessor(messageSourceDomain()!!)
}
@Bean
fun messageUtilsDomain() {
DomainMessageUtil.messageSourceAccessorDomain = messageSourceAccessorDomain()!!
}
}
| kopring_graphql_querydsl/common/domain/src/main/kotlin/kr/co/anna/domain/config/DomainMessageConfig.kt | 2012719185 |
package kr.co.anna.domain._common
import org.springframework.context.support.MessageSourceAccessor
object DomainMessageUtil {
var messageSourceAccessorDomain: MessageSourceAccessor? = null
fun getMessage(key: String?): String {
println(messageSourceAccessorDomain)
return messageSourceAccessorDomain!!.getMessage(key!!)
}
fun getMessage(key: String?, objs: Array<Any?>?): String {
return messageSourceAccessorDomain!!.getMessage(key!!, objs)
}
}
| kopring_graphql_querydsl/common/domain/src/main/kotlin/kr/co/anna/domain/_common/DomainMessageUtil.kt | 1375336538 |
package kr.co.anna.domain._common
interface EnumModel {
fun getCode(): String
fun getKorName(): String
fun getEngName(): String
}
| kopring_graphql_querydsl/common/domain/src/main/kotlin/kr/co/anna/domain/_common/EnumModel.kt | 2074747176 |
package kr.co.anna.domain._common
import org.springframework.data.annotation.CreatedBy
import org.springframework.data.annotation.CreatedDate
import org.springframework.data.annotation.LastModifiedBy
import org.springframework.data.annotation.LastModifiedDate
import org.springframework.data.jpa.domain.support.AuditingEntityListener
import java.time.LocalDateTime
import javax.persistence.*
@MappedSuperclass
@EntityListeners(AuditingEntityListener::class)
abstract class AbstractEntity(
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "OID")
val oid: Long?
) {
@CreatedDate
@Column(name = "CREATED_DATE", updatable = false, columnDefinition = "DATETIME")
protected lateinit var createdTime: LocalDateTime
@Column(name = "CREATED_BY", updatable = false)
@CreatedBy
protected var createdBy: String? = null
@LastModifiedDate
@Column(name = "LAST_MODIFIED_DATE",columnDefinition = "DATETIME")
protected lateinit var lastModifiedTime: LocalDateTime
@Column(name = "LAST_MODIFIED_BY", updatable = true)
@LastModifiedBy
protected var lastModifiedBy: String? = null
override fun equals(other: Any?): Boolean {
if (this === other) return true
if (javaClass != other?.javaClass) return false
other as AbstractEntity
if (oid != other.oid) return false
return true
}
override fun hashCode(): Int {
return oid?.hashCode() ?: 0
}
}
| kopring_graphql_querydsl/common/domain/src/main/kotlin/kr/co/anna/domain/_common/AbstractEntity.kt | 12225837 |
package kr.co.anna.domain._common
class EnumMapper {
private val factory: MutableMap<String, List<EnumValue>> = HashMap<String, List<EnumValue>>()
private fun toEnumValues(e: Class<out EnumModel>): List<EnumValue> {
return e.enumConstants.map { EnumValue(it) }
}
fun put(key: String, e: Class<out EnumModel>) {
factory[key] = toEnumValues(e)
}
operator fun get(keys: String): Map<String, List<EnumValue>?> {
return keys.split(",").toTypedArray().associateWith { key: String -> factory[key] }
}
}
| kopring_graphql_querydsl/common/domain/src/main/kotlin/kr/co/anna/domain/_common/EnumMapper.kt | 2885664500 |
package kr.co.anna.domain._common
data class EnumValue(val code: String, val korName: String, val engName: String) {
constructor(enumModel: EnumModel) : this(
enumModel.getCode(), enumModel.getKorName(), enumModel.getEngName()
)
}
| kopring_graphql_querydsl/common/domain/src/main/kotlin/kr/co/anna/domain/_common/EnumValue.kt | 2978858657 |
package kr.co.anna.domain.model.user
import kr.co.anna.domain._common.AbstractEntity
import kr.co.anna.domain._common.EnumModel
import kr.co.anna.domain.converter.RoleEnumToListConvert
import kr.co.anna.domain.model.Role
import javax.persistence.*
/**
* ํ์
*/
@Entity
@Table(
name = "USER",
indexes = [
Index(name = "IDX_USER__USER_ID", columnList = "USER_ID", unique = true),
Index(name = "IDX_USER__EMAIL", columnList = "EMAIL", unique = true),
]
)
class User(
oid: Long? = null, //pk
@Column(name = "USER_ID")
private val userId: String,
@Column(name = "NAME")
private var name: String,
@Column(name = "EMAIL")
private var email: String,
@Column(name = "PASSWORD")
private var password: String,
@Column(name = "ROLES")
@Convert(converter = RoleEnumToListConvert::class)
private var roles: List<Role>,
@Enumerated(EnumType.STRING)
@Column(name = "STATUS")
private var status: Status = Status.ACTIVE, // ์ฌ์ฉ์ ์ํ ์ฝ๋
) : kr.co.anna.domain._common.AbstractEntity(oid) {
fun name() = name
fun email() = email
fun password() = password
fun status() = status
fun role() = roles
fun userId() = userId
enum class Status(private val korName: String, private val engName: String) : EnumModel {
ACTIVE("ํ์ฑ", "ACTIVE"),
WITHDRAW("ํํด", "WITHDRAW"),
INACTIVE("๋นํ์ฑ", "INACTIVE");
override fun getKorName(): String {
return korName
}
override fun getEngName(): String {
return engName
}
override fun getCode(): String {
return name
}
}
data class NewValue(
val name: String?,
val email: String?
)
fun updateWith(n: NewValue) {
if (!n.name.isNullOrBlank()) this.name = n.name
if (!n.email.isNullOrBlank()) this.email = n.email
}
fun checkActiveUser(): Boolean {
return status().equals(Status.ACTIVE)
}
}
| kopring_graphql_querydsl/common/domain/src/main/kotlin/kr/co/anna/domain/model/user/User.kt | 1934470915 |
package kr.co.anna.domain.model
import kr.co.anna.domain._common.EnumModel
enum class Role(private val korName: String, private val engName: String) : EnumModel {
ROLE_USER("์ฌ์ฉ์", "user"),
ROLE_MANAGER("๋งค๋์ ", "MANAGER"),
ROLE_SYS_ADMIN("์์คํ
๊ด๋ฆฌ์", "systemAdmin");
override fun getKorName(): String {
return korName
}
override fun getEngName(): String {
return engName
}
override fun getCode(): String {
return name
}
}
| kopring_graphql_querydsl/common/domain/src/main/kotlin/kr/co/anna/domain/model/Code.kt | 3048380391 |
package kr.co.anna.domain.exception
import kr.co.anna.domain._common.AbstractEntity
import kotlin.reflect.KClass
class DomainEntityNotFoundException(
val id: Any,
val entityClazz: KClass<out kr.co.anna.domain._common.AbstractEntity>,
msg: String,
) : RuntimeException(msg) {
}
| kopring_graphql_querydsl/common/domain/src/main/kotlin/kr/co/anna/domain/exception/DomainEntityNotFoundException.kt | 576488397 |
package kr.co.anna.domain.exception
class NotAllowedException(
msg: String,
) : RuntimeException(msg) {
}
| kopring_graphql_querydsl/common/domain/src/main/kotlin/kr/co/anna/domain/exception/NotAllowedException.kt | 580457907 |
package kr.co.anna.api.dto.user
import kr.co.anna.domain._common.EnumValue
import kr.co.anna.lib.security.SignInUser
data class SignInOut(
val userId: String,
val accessToken: String,
val roles: List<EnumValue>,
val customInfo: CustomInfo,
) {
data class CustomInfo(
val userName: String?,
val email: String?,
val userOid: Long?
)
companion object {
fun from(signInUser: SignInUser, accessToken: String): SignInOut {
return SignInOut(
userId = signInUser.username,
accessToken = accessToken,
roles = signInUser.roles().map { EnumValue(it) },
customInfo = CustomInfo(
userName = signInUser.name(),
email = signInUser.email(),
userOid = signInUser.userOid()
)
)
}
}
}
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/dto/user/SignInOut.kt | 2977583046 |
package kr.co.anna.api.dto.user
import javax.validation.constraints.NotEmpty
data class SignInIn(
@field:NotEmpty
val userId : String,
@field:NotEmpty
val password : String,
)
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/dto/user/SignInIn.kt | 2553840361 |
package kr.co.anna.api.dto.user
import kr.co.anna.domain.model.Role
import kr.co.anna.domain.model.user.User
import org.springframework.security.crypto.password.PasswordEncoder
data class SignUpIn(
val userId: String,
val name: String,
val email: String,
val password: String,
) {
fun toEntity(passwordEncoder: PasswordEncoder): User {
return User(
userId = userId,
name = name,
email = email,
roles = listOf(Role.ROLE_USER),
password = passwordEncoder.encode(password),
)
}
}
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/dto/user/SignUpIn.kt | 3234345290 |
package kr.co.anna.api.dto.user
data class UserUpdateIn(
val name: String,
val email: String
)
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/dto/user/UserUpdateIn.kt | 2612062062 |
package kr.co.anna.api.dto.user
import kr.co.anna.domain.model.user.User
data class UserOut(
val oid: Long,
val userId: String,
val name: String,
val email: String,
) {
companion object {
fun fromEntity(e: User): UserOut {
return UserOut(
oid = e.oid!!,
userId = e.userId(),
name = e.name(),
email = e.email(),
)
}
}
}
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/dto/user/UserOut.kt | 3495945110 |
package kr.co.anna.api
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.context.properties.ConfigurationPropertiesScan
import org.springframework.boot.runApplication
@SpringBootApplication
class ApiApplication
fun main(args: Array<String>) {
runApplication<ApiApplication>(*args)
}
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/ApiApplication.kt | 2260778417 |
package kr.co.anna.api.config
import org.springframework.context.annotation.ComponentScan
import org.springframework.context.annotation.Configuration
/**
* basePackages์ ์ง์ ํ ํจํค์ง ์์ @Component ๊ฐ ๋ถ์ด์๋ ํด๋์ค๋ฅผ ์คํ๋ง ๋น์ผ๋ก ์ฝ์ด์ฌ ์ ์๋๋ก ์ค์
*/
@Configuration
@ComponentScan(basePackages = ["kr.co.anna.lib"])
class CommonLibConfig {
}
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/config/CommonLibConfig.kt | 3195739139 |
package kr.co.anna.api.config
import org.springframework.context.annotation.Configuration
import org.springframework.web.servlet.config.annotation.InterceptorRegistry
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer
/**
* ์คํ๋ง MVC ์ค์
*
* ํ์ฌ๋ interceptor ์ค์ ๋ง ์์ผ๋ ์ด ์ธ์๋ ์ฌ๋ฌ๊ฐ์ง ์ค์ ๊ฐ๋ฅ
*/
@Configuration
class WebMvcConfig() : WebMvcConfigurer {
override fun addInterceptors(registry: InterceptorRegistry) {
}
}
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/config/WebMvcConfig.kt | 992544908 |
package kr.co.anna.api.config
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.context.support.ReloadableResourceBundleMessageSource
/**
* api ๋ค๊ตญ์ด ๋ฉ์ธ์ง ์ค์
*/
@Configuration
class ApiMessageConfig {
@Autowired
var messageSource: ReloadableResourceBundleMessageSource? = null
@Bean
fun addMessageBaseName() {
messageSource!!.addBasenames("classpath:/api-messages/message")
}
}
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/config/ApiMessageConfig.kt | 901575569 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.