content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package com.example.valorantcomposeapp.presentation.maps.all_maps
import android.os.Build
import androidx.annotation.RequiresExtension
import androidx.compose.runtime.State
import androidx.compose.runtime.mutableStateOf
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.valorantcomposeapp.common.Resource
import com.example.valorantcomposeapp.domain.use_case.maps.GetMapsUseCase
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.onEach
import javax.inject.Inject
@RequiresExtension(extension = Build.VERSION_CODES.S, version = 7)
@HiltViewModel
class MapsViewModel @Inject constructor(
private val getMapsUseCase: GetMapsUseCase
) : ViewModel() {
private val _mapsState = mutableStateOf(MapsState())
val mapsState : State<MapsState> = _mapsState
init {
getMaps()
}
private fun getMaps() {
getMapsUseCase().onEach { result ->
when(result) {
is Resource.Success -> {
result.data?.let {
_mapsState.value = _mapsState.value.copy(maps = it)
}
}
is Resource.Loading -> {
_mapsState.value = _mapsState.value.copy(isLoading = true)
}
is Resource.Error -> {
_mapsState.value = _mapsState.value.copy(error = result.errorMessage ?: "")
}
}
}.launchIn(viewModelScope)
}
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/maps/all_maps/MapsViewModel.kt | 2964109648 |
package com.example.valorantcomposeapp.presentation.maps.map_detail
import android.os.Build
import androidx.annotation.RequiresExtension
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
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.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.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.graphics.ColorFilter
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.platform.ComposeView
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.hilt.navigation.compose.hiltViewModel
import coil.compose.AsyncImage
import com.example.valorantcomposeapp.common.LoadingBar
import com.example.valorantcomposeapp.common.TextError
import com.example.valorantcomposeapp.presentation.ui.theme.azul
import com.example.valorantcomposeapp.presentation.ui.theme.cupidEye
import com.example.valorantcomposeapp.presentation.ui.theme.radiant
import com.example.valorantcomposeapp.presentation.ui.theme.valoTertiary
import com.example.valorantcomposeapp.presentation.ui.theme.wildApothecary
@RequiresExtension(extension = Build.VERSION_CODES.S, version = 7)
@Composable
fun MapDetailScreen(
viewModel: MapDetailViewModel = hiltViewModel()
) {
val state = viewModel.mapDetailState.value
Column(modifier = Modifier
.fillMaxSize()
.background(cupidEye)
.verticalScroll(rememberScrollState()),
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
) {
state.mapDetail?.let { map ->
Text(
text = map.displayName, style = TextStyle(
color = azul,
fontSize = 28.sp,
fontWeight = FontWeight.SemiBold
),
modifier = Modifier.padding(bottom = 10.dp)
)
Text(text = map.mapSites, style = TextStyle(
color = azul,
fontSize = 18.sp,
fontWeight = FontWeight.SemiBold
))
Text(
text = map.description, style = TextStyle(
color = azul,
fontSize = 16.sp,
fontWeight = FontWeight.W400,
textAlign = TextAlign.Center
),
modifier = Modifier.padding(10.dp)
)
AsyncImage(
model = map.displayMap,
contentDescription = map.description,
modifier = Modifier
.size(400.dp),
contentScale = ContentScale.Crop,
alignment = Alignment.Center,
colorFilter = ColorFilter.lighting(cupidEye, valoTertiary)
)
Text(
text = map.coordinates, style = TextStyle(
color = azul,
fontSize = 18.sp,
fontWeight = FontWeight.W500,
textAlign = TextAlign.Center
)
)
}
if (state.error.isNotBlank()) {
TextError(error = state.error)
}
if (state.isLoading) {
LoadingBar()
}
}
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/maps/map_detail/MapDetailScreen.kt | 2388548604 |
package com.example.valorantcomposeapp.presentation.maps.map_detail
import com.example.valorantcomposeapp.domain.model.Map
data class MapDetailState(
val isLoading : Boolean = false,
val mapDetail : Map? = null,
val error : String = ""
)
| ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/maps/map_detail/MapDetailState.kt | 2644999888 |
package com.example.valorantcomposeapp.presentation.maps.map_detail
import android.os.Build
import androidx.annotation.RequiresExtension
import androidx.compose.runtime.State
import androidx.compose.runtime.mutableStateOf
import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.valorantcomposeapp.common.Params
import com.example.valorantcomposeapp.common.Resource
import com.example.valorantcomposeapp.domain.use_case.maps.GetMapUseCase
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.onEach
import javax.inject.Inject
@RequiresExtension(extension = Build.VERSION_CODES.S, version = 7)
@HiltViewModel
class MapDetailViewModel @Inject constructor(
private val getMapUseCase : GetMapUseCase,
stateHandle: SavedStateHandle
) : ViewModel() {
private val _mapDetailState = mutableStateOf(MapDetailState())
val mapDetailState : State<MapDetailState> = _mapDetailState
init {
stateHandle.get<String>(Params.PARAM_MAP_ID)?.let { mapId ->
loadMap(mapId)
}
}
private fun loadMap(uuid : String) {
getMapUseCase(uuid).onEach { result ->
when(result) {
is Resource.Loading -> {
_mapDetailState.value = _mapDetailState.value.copy(isLoading = true)
}
is Resource.Success -> {
result.data?.let {
_mapDetailState.value = _mapDetailState.value.copy(mapDetail = it)
}
}
is Resource.Error -> {
_mapDetailState.value = _mapDetailState.value.copy(error = result.errorMessage ?: "")
}
}
}.launchIn(viewModelScope)
}
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/maps/map_detail/MapDetailViewModel.kt | 3781740284 |
package com.example.valorantcomposeapp.presentation.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)
val wildApothecary = Color(0xfffd4556)
val azul = Color(0xffbd3944)
val valoTertiary = Color(0xff53212b)
val cupidEye = Color(0xfffffbf5)
val radiant = Color(0xff000000) | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/ui/theme/Color.kt | 3962839284 |
package com.example.valorantcomposeapp.presentation.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.Color
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 = wildApothecary,
secondary = cupidEye,
tertiary = valoTertiary,
background = cupidEye,
surface = cupidEye,
onPrimary = cupidEye,
onSecondary = radiant,
onTertiary = valoTertiary,
onBackground = radiant,
onSurface = azul,
)
private val LightColorScheme = lightColorScheme(
primary = wildApothecary,
secondary = cupidEye,
tertiary = valoTertiary,
background = cupidEye,
surface = cupidEye,
onPrimary = cupidEye,
onSecondary = radiant,
onTertiary = valoTertiary,
onBackground = radiant,
onSurface = azul,
)
@Composable
fun ValorantComposeAppTheme(
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
)
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/ui/theme/Theme.kt | 4031358390 |
package com.example.valorantcomposeapp.presentation.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
)
*/
) | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/ui/theme/Type.kt | 4001181655 |
package com.example.valorantcomposeapp.presentation.splash
import androidx.compose.animation.core.animateFloatAsState
import androidx.compose.animation.core.tween
import androidx.compose.runtime.Composable
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.*
import kotlinx.coroutines.delay
@Composable
fun SplashScreen(
navigateToAgents: () -> Unit
) {
var startAnimation by remember { mutableStateOf(false) }
val alphaAnimation =
animateFloatAsState(
targetValue = if (startAnimation) 1f else 0f,
animationSpec = tween(durationMillis = 2000),
label = "Splash Screen Animation"
)
LaunchedEffect(key1 = true) {
startAnimation = true
delay(2000)
navigateToAgents()
}
SplashDesign(alpha = alphaAnimation.value)
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/splash/SplashScreen.kt | 660927022 |
package com.example.valorantcomposeapp.presentation.splash
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.size
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.alpha
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.unit.dp
import com.example.valorantcomposeapp.R
@Composable
fun SplashDesign(
alpha: Float
) {
Column(
modifier = Modifier.fillMaxSize(),
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
) {
Image(
modifier = Modifier
.size(200.dp)
.alpha(alpha),
painter = painterResource(id = R.drawable.splash_valo),
contentDescription = "Splash Valo Logo"
)
}
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/splash/SplashDesign.kt | 2222334586 |
package com.example.valorantcomposeapp.presentation
import android.os.Build
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.annotation.RequiresExtension
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import com.example.valorantcomposeapp.presentation.ui.theme.ValorantComposeAppTheme
import dagger.hilt.android.AndroidEntryPoint
@RequiresExtension(extension = Build.VERSION_CODES.S, version = 7)
@AndroidEntryPoint
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
ValorantComposeAppTheme {
ValorantApp()
}
}
}
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/MainActivity.kt | 1816218442 |
package com.example.valorantcomposeapp.presentation.agents.all_agents
import android.os.Build
import androidx.annotation.RequiresExtension
import androidx.compose.runtime.State
import androidx.compose.runtime.mutableStateOf
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.valorantcomposeapp.common.Resource
import com.example.valorantcomposeapp.domain.use_case.agents.GetAgentsUseCase
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.onEach
import javax.inject.Inject
@RequiresExtension(extension = Build.VERSION_CODES.S, version = 7)
@HiltViewModel
class AgentsViewModel @Inject constructor(
private val getAgentsUseCase: GetAgentsUseCase
) : ViewModel() {
private val _state = mutableStateOf(AgentsState())
val state: State<AgentsState> = _state
init {
loadAgents()
}
private fun loadAgents() {
getAgentsUseCase().onEach { result ->
when (result) {
is Resource.Loading -> {
_state.value = _state.value.copy(isLoading = true)
}
is Resource.Success -> {
result.data?.let {
_state.value = _state.value.copy(agents = it)
}
}
is Resource.Error -> {
_state.value = _state.value.copy(error = result.errorMessage ?: "")
}
}
}.launchIn(viewModelScope)
}
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/agents/all_agents/AgentsViewModel.kt | 411541941 |
package com.example.valorantcomposeapp.presentation.agents.all_agents.components
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.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import coil.compose.AsyncImage
import com.example.valorantcomposeapp.domain.model.Agent
@Composable
fun AgentItem(
agent: Agent,
navigate: (String) -> Unit
) {
Card(
modifier = Modifier
.clickable { navigate(agent.uuid) }
.padding(12.dp),
colors = CardDefaults.cardColors(containerColor = Color.LightGray)
) {
Box {
AsyncImage(
model = agent.displayIcon,
contentDescription = agent.description,
contentScale = ContentScale.Crop,
modifier = Modifier.size(130.dp)
)
Text(
text = agent.displayName,
style = MaterialTheme.typography.bodyLarge,
color = Color.White,
fontWeight = FontWeight.SemiBold,
overflow = TextOverflow.Ellipsis,
textAlign = TextAlign.Center,
modifier = Modifier
.align(Alignment.BottomCenter)
.background(
brush = Brush.verticalGradient(
listOf(
Color.Transparent,
Color.Gray
)
)
)
.padding(4.dp)
.fillMaxWidth()
)
}
}
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/agents/all_agents/components/AgentItem.kt | 672706167 |
package com.example.valorantcomposeapp.presentation.agents.all_agents
import android.os.Build
import androidx.annotation.RequiresExtension
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.grid.GridCells
import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
import androidx.compose.foundation.lazy.grid.items
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import com.example.valorantcomposeapp.common.LoadingBar
import com.example.valorantcomposeapp.common.TextError
import com.example.valorantcomposeapp.presentation.agents.all_agents.components.AgentItem
import com.example.valorantcomposeapp.presentation.ui.theme.cupidEye
@RequiresExtension(extension = Build.VERSION_CODES.S, version = 7)
@Composable
fun AgentsScreen(
viewmodel: AgentsViewModel = hiltViewModel(),
navigateToAgentDetail: (String) -> Unit
) {
val state = viewmodel.state.value
Box {
Column(
modifier = Modifier
.fillMaxSize()
.padding(top = 12.dp)
.background(cupidEye)
) {
LazyVerticalGrid(
columns = GridCells.Fixed(3),
contentPadding = PaddingValues(12.dp)
) {
items(state.agents) { agentItem ->
AgentItem(
agent = agentItem,
navigate = { navigateToAgentDetail.invoke(it) }
)
}
}
}
if (state.error.isNotBlank()) {
TextError(error = state.error)
}
if (state.isLoading) {
LoadingBar()
}
}
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/agents/all_agents/AgentsScreen.kt | 2603657972 |
package com.example.valorantcomposeapp.presentation.agents.all_agents
import com.example.valorantcomposeapp.domain.model.Agent
data class AgentsState(
val isLoading : Boolean = false,
val agents : List<Agent> = emptyList(),
val error : String = ""
)
| ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/agents/all_agents/AgentsState.kt | 3287726325 |
package com.example.valorantcomposeapp.presentation.agents.agentDetail
import android.os.Build
import androidx.annotation.RequiresExtension
import androidx.compose.runtime.State
import androidx.compose.runtime.mutableStateOf
import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.valorantcomposeapp.common.Params
import com.example.valorantcomposeapp.common.Resource
import com.example.valorantcomposeapp.domain.use_case.agents.GetAgentDetailUseCase
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.onEach
import javax.inject.Inject
@RequiresExtension(extension = Build.VERSION_CODES.S, version = 7)
@HiltViewModel
class AgentDetailViewModel @Inject constructor(
private val getAgentDetailUseCase: GetAgentDetailUseCase,
savedStateHandle: SavedStateHandle
) : ViewModel() {
private val _agentState = mutableStateOf(AgentDetailState())
val agentState : State<AgentDetailState> = _agentState
init {
savedStateHandle.get<String>(Params.PARAM_AGENT_ID)?.let { agentId ->
getAgentDetail(agentId)
}
}
private fun getAgentDetail(uuid : String) {
getAgentDetailUseCase.invoke(uuid).onEach { result ->
when (result) {
is Resource.Loading -> {
_agentState.value = _agentState.value.copy(isLoading = true)
}
is Resource.Success -> {
_agentState.value = _agentState.value.copy(agent = result.data)
}
is Resource.Error -> {
_agentState.value = _agentState.value.copy(error = result.errorMessage?: "")
}
}
}.launchIn(viewModelScope)
}
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/agents/agentDetail/AgentDetailViewModel.kt | 5120115 |
package com.example.valorantcomposeapp.presentation.agents.agentDetail
import android.os.Build
import androidx.annotation.RequiresExtension
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
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.rememberScrollState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.hilt.navigation.compose.hiltViewModel
import coil.compose.AsyncImage
import com.example.valorantcomposeapp.presentation.agents.agentDetail.components.AgentAbilityItem
import com.example.valorantcomposeapp.presentation.ui.theme.cupidEye
import com.example.valorantcomposeapp.presentation.ui.theme.radiant
import com.example.valorantcomposeapp.presentation.ui.theme.wildApothecary
@RequiresExtension(extension = Build.VERSION_CODES.S, version = 7)
@Composable
fun AgentDetailScreen(
viewModel: AgentDetailViewModel = hiltViewModel(),
) {
val state = viewModel.agentState.value
Column(
modifier = Modifier
.fillMaxSize()
.background(cupidEye)
.verticalScroll(rememberScrollState()),
horizontalAlignment = Alignment.CenterHorizontally
) {
state.agent?.let { agent ->
Box(
modifier = Modifier
.background(
color = wildApothecary,
shape = RoundedCornerShape(
bottomStart = 32.dp,
bottomEnd = 32.dp
)
)
.padding(24.dp)
.fillMaxWidth(),
contentAlignment = Alignment.Center
) {
AsyncImage(
modifier = Modifier.size(400.dp),
model = agent.role?.displayIcon,
contentDescription = agent.description,
alpha = 0.2f,
)
Column(
horizontalAlignment = Alignment.CenterHorizontally
) {
AsyncImage(
model = agent.portrait,
contentDescription = agent.description,
modifier = Modifier.size(300.dp)
)
Spacer(modifier = Modifier.size(24.dp))
Text(
text = agent.displayName,
style = MaterialTheme.typography.headlineMedium,
color = cupidEye
)
Spacer(modifier = Modifier.size(12.dp))
Text(
text = agent.role?.displayName.orEmpty(),
style = MaterialTheme.typography.headlineSmall,
color = cupidEye
)
Spacer(modifier = Modifier.size(15.dp))
}
}
Spacer(modifier = Modifier.size(24.dp))
Text(
text = "Description",
style = MaterialTheme.typography.headlineMedium,
color = radiant
)
Spacer(modifier = Modifier.size(8.dp))
Text(
text = agent.description,
style = TextStyle(
textAlign = TextAlign.Center,
color = wildApothecary,
fontSize = 16.5.sp,
fontWeight = FontWeight.W500
),
modifier = Modifier.padding(start = 24.dp, end = 24.dp)
)
Spacer(modifier = Modifier.size(24.dp))
Text(text = "Abilities", style = MaterialTheme.typography.headlineMedium)
Spacer(modifier = Modifier.size(10.dp))
AgentAbilityItem(abilities = agent.abilities)
}
}
}
| ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/agents/agentDetail/AgentDetailScreen.kt | 2528617851 |
package com.example.valorantcomposeapp.presentation.agents.agentDetail.components
import androidx.compose.animation.Animatable
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.Tab
import androidx.compose.material3.TabRow
import androidx.compose.material3.TabRowDefaults
import androidx.compose.material3.TabRowDefaults.tabIndicatorOffset
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
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.ColorFilter
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import coil.compose.AsyncImage
import com.example.valorantcomposeapp.data.dto.agents.Ability
import com.example.valorantcomposeapp.presentation.ui.theme.azul
import com.example.valorantcomposeapp.presentation.ui.theme.cupidEye
import com.example.valorantcomposeapp.presentation.ui.theme.radiant
import com.example.valorantcomposeapp.presentation.ui.theme.valoTertiary
import com.example.valorantcomposeapp.presentation.ui.theme.wildApothecary
import com.google.accompanist.pager.ExperimentalPagerApi
import com.google.accompanist.pager.HorizontalPager
import com.google.accompanist.pager.rememberPagerState
import kotlinx.coroutines.launch
@OptIn(ExperimentalPagerApi::class)
@Composable
fun AgentAbilityItem(
abilities: List<Ability>
) {
val pagerState = rememberPagerState()
val coroutineScope = rememberCoroutineScope()
Card(
colors = CardDefaults.cardColors(
containerColor = cupidEye
),
modifier = Modifier
.clip(RoundedCornerShape(20.dp))
.padding(start = 24.dp, end = 24.dp, bottom = 24.dp)
) {
Column {
TabRow(selectedTabIndex = pagerState.currentPage,
containerColor = cupidEye,
indicator = { tabPositions ->
TabRowDefaults.Indicator(
Modifier
.tabIndicatorOffset(
tabPositions[pagerState.currentPage]
)
.width(0.dp)
.height(0.dp)
)
}
) {
abilities.forEachIndexed { index, ability ->
val color = remember {
Animatable(wildApothecary)
}
LaunchedEffect(key1 = pagerState.currentPage == index) {
color.animateTo(if (pagerState.currentPage == index) wildApothecary else cupidEye)
}
Tab(
icon = {
AsyncImage(
model = ability.displayIcon,
contentDescription = ability.description,
contentScale = ContentScale.Fit,
colorFilter = if (pagerState.currentPage == index) ColorFilter.tint(
cupidEye
) else ColorFilter.tint(valoTertiary),
modifier = Modifier.size(32.dp)
)
},
selected = pagerState.currentPage == index,
modifier = Modifier
.background(color = color.value),
onClick = {
coroutineScope.launch {
pagerState.animateScrollToPage(index)
}
}
)
}
}
}
Spacer(modifier = Modifier.size(12.dp))
HorizontalPager(count = abilities.size, state = pagerState) { page ->
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center
) {
Text(
text = abilities[page].displayName.orEmpty(), style = TextStyle(
fontSize = 20.sp
)
)
Text(
modifier = Modifier.padding(8.dp),
text = abilities[page].description.orEmpty(), style = TextStyle(
textAlign = TextAlign.Center,
fontSize = 16.sp
)
)
}
}
}
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/agents/agentDetail/components/AgentAbilityItem.kt | 3190118071 |
package com.example.valorantcomposeapp.presentation.agents.agentDetail
import com.example.valorantcomposeapp.domain.model.Agent
data class AgentDetailState(
val isLoading: Boolean = false,
val agent: Agent? = null,
val error: String = ""
)
| ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/agents/agentDetail/AgentDetailState.kt | 3357827263 |
package com.example.valorantcomposeapp.presentation.weapons.all_weapons
import android.os.Build
import androidx.annotation.RequiresExtension
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
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.grid.GridCells
import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
import androidx.compose.foundation.lazy.grid.items
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.hilt.navigation.compose.hiltViewModel
import com.example.valorantcomposeapp.common.LoadingBar
import com.example.valorantcomposeapp.common.TextError
import com.example.valorantcomposeapp.presentation.ui.theme.azul
import com.example.valorantcomposeapp.presentation.ui.theme.cupidEye
import com.example.valorantcomposeapp.presentation.ui.theme.valoTertiary
import com.example.valorantcomposeapp.presentation.weapons.all_weapons.components.WeaponItem
@RequiresExtension(extension = Build.VERSION_CODES.S, version = 7)
@Composable
fun WeaponsScreen(
viewModel: WeaponsViewModel = hiltViewModel(),
navigateToWeaponDetail: (String) -> Unit
) {
val state = viewModel.weaponState.value
Box(
modifier = Modifier
.fillMaxSize()
.background(cupidEye)
) {
Box {
LazyVerticalGrid(columns = GridCells.Fixed(2)) {
items(state.weapons) { weapon ->
WeaponItem(weapon = weapon) {
navigateToWeaponDetail(it)
}
}
}
if (state.isLoading) {
LoadingBar()
}
if (state.error.isNotBlank()) {
TextError(error = state.error)
}
}
}
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/weapons/all_weapons/WeaponsScreen.kt | 2778537481 |
package com.example.valorantcomposeapp.presentation.weapons.all_weapons
import com.example.valorantcomposeapp.domain.model.weapon.Weapon
data class WeaponsState(
val isLoading: Boolean = false,
val weapons : List<Weapon> = emptyList(),
val error: String = ""
)
| ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/weapons/all_weapons/WeaponsState.kt | 2089257848 |
package com.example.valorantcomposeapp.presentation.weapons.all_weapons.components
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import coil.compose.AsyncImage
import com.example.valorantcomposeapp.domain.model.weapon.Weapon
import com.example.valorantcomposeapp.presentation.ui.theme.azul
import com.example.valorantcomposeapp.presentation.ui.theme.cupidEye
import com.example.valorantcomposeapp.presentation.ui.theme.wildApothecary
@Composable
fun WeaponItem(
weapon: Weapon,
onItemClick: (String) -> Unit
) {
Card(
elevation = CardDefaults.cardElevation(
defaultElevation = 8.dp
),
colors = CardDefaults.cardColors(
containerColor = wildApothecary,
contentColor = azul
),
modifier = Modifier
.padding(8.dp)
.clickable {
onItemClick(weapon.weaponUuid.orEmpty())
},
shape = RoundedCornerShape(10.dp)
) {
AsyncImage(
model = weapon.displayIcon,
contentDescription = weapon.displayName,
contentScale = ContentScale.Fit,
modifier = Modifier.size(200.dp),
alignment = Alignment.Center
)
Text(
text = weapon.displayName.orEmpty(),
style = TextStyle(
fontSize = 20.sp,
fontWeight = FontWeight.W500,
textAlign = TextAlign.Center,
color = cupidEye
),
overflow = TextOverflow.Ellipsis,
modifier = Modifier
.fillMaxWidth()
.padding(bottom = 10.dp)
)
}
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/weapons/all_weapons/components/WeaponItem.kt | 3050140959 |
package com.example.valorantcomposeapp.presentation.weapons.all_weapons
import android.os.Build
import androidx.annotation.RequiresExtension
import androidx.compose.runtime.State
import androidx.compose.runtime.mutableStateOf
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.valorantcomposeapp.common.Resource
import com.example.valorantcomposeapp.domain.use_case.weapons.GetAllWeaponsUseCase
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.onEach
import javax.inject.Inject
@RequiresExtension(extension = Build.VERSION_CODES.S, version = 7)
@HiltViewModel
class WeaponsViewModel @Inject constructor(
private val getAllWeaponsUseCase : GetAllWeaponsUseCase
) : ViewModel() {
private val _weaponState = mutableStateOf(WeaponsState())
val weaponState : State<WeaponsState> = _weaponState
init {
loadWeapons()
}
private fun loadWeapons() {
getAllWeaponsUseCase().onEach { resource ->
when (resource) {
is Resource.Success -> {
_weaponState.value = _weaponState.value.copy(
weapons = resource.data ?: emptyList(),
isLoading = false
)
}
is Resource.Loading -> {
_weaponState.value = _weaponState.value.copy(
isLoading = true
)
}
is Resource.Error -> {
_weaponState.value = _weaponState.value.copy(
isLoading = false,
error = "Not found weapons!"
)
}
}
}.launchIn(viewModelScope)
}
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/weapons/all_weapons/WeaponsViewModel.kt | 3024358033 |
package com.example.valorantcomposeapp.presentation.weapons.weaponDetail
import com.example.valorantcomposeapp.domain.model.weapon.Weapon
data class WeaponDetailState(
val isLoading : Boolean = false,
val weapon : Weapon? = null,
val error : String = ""
)
| ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/weapons/weaponDetail/WeaponDetailState.kt | 2024729440 |
package com.example.valorantcomposeapp.presentation.weapons.weaponDetail
import android.os.Build
import androidx.annotation.RequiresExtension
import androidx.compose.runtime.State
import androidx.compose.runtime.mutableStateOf
import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.valorantcomposeapp.common.Params
import com.example.valorantcomposeapp.common.Resource
import com.example.valorantcomposeapp.domain.use_case.weapons.GetWeaponByIdUseCase
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.onEach
import javax.inject.Inject
@RequiresExtension(extension = Build.VERSION_CODES.S, version = 7)
@HiltViewModel
class WeaponDetailViewModel @Inject constructor(
private val getWeaponByIdUseCase: GetWeaponByIdUseCase,
savedStateHandle: SavedStateHandle
) : ViewModel() {
private val _weaponState = mutableStateOf(WeaponDetailState())
val weaponState : State<WeaponDetailState> = _weaponState
init {
savedStateHandle.get<String>(Params.PARAM_WEAPON_ID)?.let {
loadWeaponDetail(it)
}
}
private fun loadWeaponDetail(weaponUuid : String) {
getWeaponByIdUseCase(weaponUuid).onEach { result ->
when (result) {
is Resource.Loading -> {
_weaponState.value = _weaponState.value.copy(
isLoading = true
)
}
is Resource.Success -> {
_weaponState.value = _weaponState.value.copy(
isLoading = false,
weapon = result.data
)
}
is Resource.Error -> {
_weaponState.value = _weaponState.value.copy(
isLoading = false,
error = result.errorMessage ?: "Not found Weapon Detail!"
)
}
}
}.launchIn(viewModelScope)
}
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/weapons/weaponDetail/WeaponDetailViewModel.kt | 1081189342 |
package com.example.valorantcomposeapp.presentation.weapons.weaponDetail.components
import androidx.compose.animation.Animatable
import androidx.compose.foundation.background
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.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.ScrollableTabRow
import androidx.compose.material3.Tab
import androidx.compose.material3.TabRowDefaults
import androidx.compose.material3.TabRowDefaults.tabIndicatorOffset
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import coil.compose.AsyncImage
import com.example.valorantcomposeapp.data.dto.weapons.Skin
import com.example.valorantcomposeapp.presentation.ui.theme.azul
import com.example.valorantcomposeapp.presentation.ui.theme.cupidEye
import com.example.valorantcomposeapp.presentation.ui.theme.valoTertiary
import com.example.valorantcomposeapp.presentation.ui.theme.wildApothecary
import com.google.accompanist.pager.ExperimentalPagerApi
import com.google.accompanist.pager.HorizontalPager
import com.google.accompanist.pager.rememberPagerState
import kotlinx.coroutines.launch
@OptIn(ExperimentalPagerApi::class)
@Composable
fun SkinBox(
skins: List<Skin>
) {
val pagerState = rememberPagerState()
val coroutineScope = rememberCoroutineScope()
Card(
colors = CardDefaults.cardColors(
containerColor = cupidEye
),
modifier = Modifier
.clip(shape = RoundedCornerShape(10.dp))
.padding(start = 24.dp, end = 24.dp, bottom = 24.dp)
) {
Column {
ScrollableTabRow(
selectedTabIndex = pagerState.currentPage,
indicator = { tabPositions ->
TabRowDefaults.Indicator(
modifier = Modifier
.tabIndicatorOffset(
tabPositions[pagerState.currentPage]
)
.width(0.dp)
.height(3.dp),
color = azul
)
},
containerColor = cupidEye
) {
skins.forEachIndexed { index, skin ->
val color = remember {
Animatable(wildApothecary)
}
LaunchedEffect(key1 = pagerState.currentPage == index) {
color.animateTo(if (pagerState.currentPage == index) wildApothecary else cupidEye)
}
Tab(
selected = pagerState.currentPage == index,
onClick = {
coroutineScope.launch {
pagerState.animateScrollToPage(index)
}
},
icon = {
AsyncImage(
model = skin.displayIcon,
contentDescription = skin.displayName,
contentScale = ContentScale.Fit,
modifier = Modifier.size(80.dp)
)
},
modifier = Modifier.background(color.value)
)
}
}
}
Spacer(modifier = Modifier.size(12.dp))
HorizontalPager(count = skins.size, state = pagerState) { page ->
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center,
modifier = Modifier.background(cupidEye)
) {
AsyncImage(
model = skins[page].displayIcon,
contentDescription = skins[page].displayName,
contentScale = ContentScale.Fit,
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 32.dp, vertical = 16.dp)
)
Text(
text = skins[page].displayName.orEmpty(),
style = MaterialTheme.typography.headlineSmall,
textAlign = TextAlign.Center,
color = wildApothecary,
modifier = Modifier.padding(16.dp)
)
}
}
}
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/weapons/weaponDetail/components/SkinBox.kt | 3861247230 |
package com.example.valorantcomposeapp.presentation.weapons.weaponDetail
import android.os.Build
import androidx.annotation.RequiresExtension
import androidx.compose.foundation.background
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.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.layout.width
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Card
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.draw.shadow
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.hilt.navigation.compose.hiltViewModel
import coil.compose.AsyncImage
import com.example.valorantcomposeapp.common.StatsBar
import com.example.valorantcomposeapp.presentation.ui.theme.azul
import com.example.valorantcomposeapp.presentation.ui.theme.cupidEye
import com.example.valorantcomposeapp.presentation.ui.theme.radiant
import com.example.valorantcomposeapp.presentation.ui.theme.wildApothecary
import com.example.valorantcomposeapp.presentation.weapons.weaponDetail.components.SkinBox
@RequiresExtension(extension = Build.VERSION_CODES.S, version = 7)
@Composable
fun WeaponDetailScreen(
viewModel: WeaponDetailViewModel = hiltViewModel()
) {
val state = viewModel.weaponState.value
Column(
modifier = Modifier
.fillMaxSize()
.background(cupidEye)
.verticalScroll(rememberScrollState()),
horizontalAlignment = Alignment.CenterHorizontally
) {
state.weapon?.let { weapon ->
Box(
modifier = Modifier
.fillMaxWidth()
.background(
color = wildApothecary, shape = RoundedCornerShape(
bottomStart = 32.dp, bottomEnd = 32.dp
)
), contentAlignment = Alignment.Center
) {
Column(
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
) {
AsyncImage(
model = weapon.displayIcon,
contentDescription = weapon.displayName,
modifier = Modifier.size(300.dp),
alignment = Alignment.Center
)
Row(
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically,
modifier = Modifier
.fillMaxWidth()
.padding(start = 20.dp, end = 20.dp)
) {
Column {
Text(
text = weapon.displayName.orEmpty(),
style = MaterialTheme.typography.headlineLarge,
color = cupidEye
)
Spacer(modifier = Modifier.height(12.dp))
Text(
text = weapon.category.orEmpty()
.replace("EEquippableCategory::", ""),
style = MaterialTheme.typography.headlineSmall,
color = cupidEye
)
}
Column(
horizontalAlignment = Alignment.CenterHorizontally
) {
Text(
text = "Cost", style = MaterialTheme.typography.headlineLarge,
color = cupidEye
)
Spacer(modifier = Modifier.height(12.dp))
Text(
text = "${weapon.weaponMarket?.cost.toString()}$",
style = MaterialTheme.typography.headlineSmall,
color = cupidEye
)
}
}
Spacer(modifier = Modifier.height(16.dp))
}
}
Spacer(modifier = Modifier.size(24.dp))
Text(
text = "Weapon Stats",
style = MaterialTheme.typography.headlineLarge,
color = azul
)
Spacer(modifier = Modifier.size(16.dp))
weapon.weaponStats?.damageRanges?.getOrNull(0)?.let { damageRange ->
Column(
modifier = Modifier.padding(start = 24.dp, end = 24.dp)
) {
damageRange.headDamage?.div(200)?.let { d ->
StatsBar(
title = "Head Damage",
progress = d.toFloat(),
progressName = damageRange.bodyDamage.toString()
)
}
damageRange.bodyDamage?.toFloat()?.div(200)?.let { d ->
StatsBar(
title = "Body Damage",
progress = d,
progressName = damageRange.bodyDamage.toString()
)
}
damageRange.legDamage?.div(200)?.let { d ->
StatsBar(
title = "Leg Damage",
progress = d.toFloat(),
progressName = damageRange.legDamage.toString()
)
}
}
}
Spacer(modifier = Modifier.size(16.dp))
Text(text = "Skins", style = MaterialTheme.typography.headlineLarge, color = azul)
Spacer(modifier = Modifier.size(16.dp))
SkinBox(weapon.skins.orEmpty())
}
}
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/weapons/weaponDetail/WeaponDetailScreen.kt | 716985427 |
package com.example.valorantcomposeapp.presentation
import android.os.Build
import androidx.annotation.RequiresExtension
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Scaffold
import androidx.compose.runtime.Composable
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.ui.Modifier
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.rememberNavController
import com.example.valorantcomposeapp.common.Routes
import com.example.valorantcomposeapp.presentation.agents.all_agents.AgentsScreen
import com.example.valorantcomposeapp.navigation.MainNavigationBar
import com.example.valorantcomposeapp.navigation.NavGraphComponent
@RequiresExtension(extension = Build.VERSION_CODES.S, version = 7)
@Composable
fun ValorantApp() {
val navController = rememberNavController()
val bottomBarState = rememberSaveable { mutableStateOf(true) }
Scaffold(
bottomBar = {
MainNavigationBar(navController, bottomBarState)
}
) { paddingValues ->
NavGraphComponent(navController = navController, paddingValues)
}
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/ValorantApp.kt | 1806952523 |
package com.example.valorantcomposeapp.presentation.tiers
import android.os.Build
import androidx.annotation.RequiresExtension
import androidx.compose.runtime.State
import androidx.compose.runtime.mutableStateOf
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.valorantcomposeapp.common.Resource
import com.example.valorantcomposeapp.domain.use_case.tiers.AllTiersUseCase
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.onEach
import javax.inject.Inject
@RequiresExtension(extension = Build.VERSION_CODES.S, version = 7)
@HiltViewModel
class AllTiersViewModel @Inject constructor(
private val allTiersUseCase: AllTiersUseCase
) : ViewModel() {
private val _tiersState = mutableStateOf(TierState())
val tierState: State<TierState> = _tiersState
init {
loadAllTiers()
}
private fun loadAllTiers() {
allTiersUseCase().onEach { resource ->
when (resource) {
is Resource.Loading -> {
_tiersState.value = _tiersState.value.copy(isLoading = true)
}
is Resource.Success -> {
_tiersState.value = _tiersState.value.copy(tiers = resource.data ?: emptyList())
}
is Resource.Error -> {
_tiersState.value =
_tiersState.value.copy(error = resource.errorMessage ?: "Not Found Tiers!")
}
}
}.launchIn(viewModelScope)
}
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/tiers/AllTiersViewModel.kt | 4256067549 |
package com.example.valorantcomposeapp.presentation.tiers
import android.os.Build
import androidx.annotation.RequiresExtension
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
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.grid.GridCells
import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
import androidx.compose.foundation.lazy.grid.items
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.hilt.navigation.compose.hiltViewModel
import coil.compose.AsyncImage
import com.example.valorantcomposeapp.common.LoadingBar
import com.example.valorantcomposeapp.common.TextError
import com.example.valorantcomposeapp.domain.model.Tier
import com.example.valorantcomposeapp.presentation.tiers.components.TierItem
import com.example.valorantcomposeapp.presentation.ui.theme.azul
import com.example.valorantcomposeapp.presentation.ui.theme.cupidEye
import com.example.valorantcomposeapp.presentation.ui.theme.valoTertiary
import com.example.valorantcomposeapp.presentation.ui.theme.wildApothecary
@RequiresExtension(extension = Build.VERSION_CODES.S, version = 7)
@Composable
fun TiersScreen(
viewModel: AllTiersViewModel = hiltViewModel()
) {
val state = viewModel.tierState.value
Box(
modifier = Modifier
.fillMaxSize()
.background(cupidEye)
) {
LazyVerticalGrid(columns = GridCells.Fixed(3)) {
items(state.tiers) { tier ->
TierItem(tier)
}
}
if (state.isLoading) {
LoadingBar()
}
if (state.error.isNotBlank()) {
TextError(error = state.error)
}
}
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/tiers/TiersScreen.kt | 3261425011 |
package com.example.valorantcomposeapp.presentation.tiers.components
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import coil.compose.AsyncImage
import com.example.valorantcomposeapp.domain.model.Tier
import com.example.valorantcomposeapp.presentation.ui.theme.cupidEye
import com.example.valorantcomposeapp.presentation.ui.theme.wildApothecary
@Composable
fun TierItem(
tier: Tier
) {
Card(
modifier = Modifier
.padding(12.dp),
colors = CardDefaults.cardColors(
containerColor = wildApothecary
)
) {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center
) {
AsyncImage(
model = tier.tierIcon,
contentDescription = tier.tierName,
contentScale = ContentScale.Crop,
modifier = Modifier
.size(80.dp)
.padding(8.dp)
)
Text(
text = tier.tierName.orEmpty(),
style = TextStyle(
color = cupidEye,
fontSize = 14.sp,
fontWeight = FontWeight.W500,
textAlign = TextAlign.Center
),
overflow = TextOverflow.Ellipsis,
modifier = Modifier
.padding(5.dp)
.fillMaxWidth()
)
}
}
} | ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/tiers/components/TierItem.kt | 3908757551 |
package com.example.valorantcomposeapp.presentation.tiers
import com.example.valorantcomposeapp.domain.model.Tier
data class TierState(
val isLoading : Boolean = false,
val tiers : List<Tier> = emptyList(),
val error : String = ""
)
| ValorantComposeApp/app/src/main/java/com/example/valorantcomposeapp/presentation/tiers/TierState.kt | 1856242097 |
package tacos.web
import org.springframework.core.convert.converter.Converter
import org.springframework.stereotype.Component
import tacos.Ingredient
import tacos.data.IngredientRepository
@Component
class IngredientByIdConverter(
private val ingredientRepository: IngredientRepository
) : Converter<String, Ingredient> {
override fun convert(id: String): Ingredient? {
return ingredientRepository.findById(id).let { if(it.isEmpty) null else it.get() }
}
} | SpringInAction5/tacocloud-web/src/main/kotlin/tacos/web/IngredientByIdConverter.kt | 879225802 |
package tacos.web
import org.springframework.context.annotation.Configuration
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer
@Configuration
class WebConfig: WebMvcConfigurer {
override fun addViewControllers(registry: ViewControllerRegistry) {
registry.addViewController("/").setViewName("home")
}
} | SpringInAction5/tacocloud-web/src/main/kotlin/tacos/web/WebConfig.kt | 2802779026 |
package tacos.web
import jakarta.validation.Valid
import org.springframework.security.core.userdetails.UsernameNotFoundException
import org.springframework.stereotype.Controller
import org.springframework.ui.Model
import org.springframework.validation.Errors
import org.springframework.web.bind.annotation.*
import tacos.Ingredient
import tacos.Ingredient.Type
import tacos.Order
import tacos.Taco
import tacos.data.IngredientRepository
import tacos.data.TacoRepository
import tacos.data.UserRepository
import java.security.Principal
@Controller
@RequestMapping("/design")
@SessionAttributes("order")
class DesignTacoController(
private val ingredientRepository: IngredientRepository,
private val tacoRepository: TacoRepository,
private val userRepository: UserRepository,
){
@GetMapping
fun showDesignForm(model: Model, principal: Principal): String {
val ingredients = ingredientRepository.findAll().toList()
Type.entries.forEach {
model.addAttribute(it.toString().lowercase(), filterByType(ingredients, it))
}
val username = principal.name
val user = userRepository.findByUsername(username).orElseThrow { UsernameNotFoundException("User not found") }
model.addAttribute("user", user)
model.addAttribute("taco", Taco())
return "design"
}
@PostMapping
fun processDesign(@Valid design: Taco, errors: Errors,
@ModelAttribute order: Order
): String {
if(errors.hasErrors()) return "design"
val saved = tacoRepository.save(design)
order.addDesign(saved)
return "redirect:/orders/current"
}
private fun filterByType(ingredients: List<Ingredient>, type: Type): List<Ingredient> {
return ingredients.filter { it.type == type }
.toList()
}
@ModelAttribute(name = "order")
fun order() = Order()
@ModelAttribute(name = "taco")
fun taco() = Taco()
}
| SpringInAction5/tacocloud-web/src/main/kotlin/tacos/web/DesignTacoController.kt | 2292625764 |
package tacos.web
import jakarta.validation.constraints.Max
import jakarta.validation.constraints.Min
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.stereotype.Component
import org.springframework.validation.annotation.Validated
@Component
@ConfigurationProperties(prefix = "taco.orders")
@Validated
data class OrderProps(
@field:Min(value = 5, message = "must be between 5 and 25")
@field:Max(value = 25, message = "must be between 5 and 25")
var pageSize: Int = 10
) | SpringInAction5/tacocloud-web/src/main/kotlin/tacos/web/OrderProps.kt | 1506337575 |
package tacos.web
import jakarta.validation.Valid
import org.springframework.data.domain.PageRequest
import org.springframework.security.core.annotation.AuthenticationPrincipal
import org.springframework.stereotype.Controller
import org.springframework.ui.Model
import org.springframework.validation.Errors
import org.springframework.web.bind.annotation.*
import org.springframework.web.bind.support.SessionStatus
import tacos.Order
import tacos.Users
import tacos.data.OrderRepository
@Controller
@RequestMapping("/orders")
@SessionAttributes("order")
class OrderController(
private val orderRepository: OrderRepository,
private val orderProps: OrderProps,
) {
@GetMapping("/current")
fun orderForm(@AuthenticationPrincipal users: Users,
@ModelAttribute order: Order
): String {
if(order.deliveryName == null) order.deliveryName = users.fullName
if(order.deliveryStreet == null) order.deliveryStreet = users.street
if(order.deliveryCity == null) order.deliveryCity = users.city
if(order.deliveryState == null) order.deliveryState = users.state
if(order.deliveryZip == null) order.deliveryZip = users.zip
return "orderForm"
}
@PostMapping
fun processOrder(@Valid order: Order, errors: Errors, sessionStatus: SessionStatus,
@AuthenticationPrincipal users: Users): String {
if(errors.hasErrors()) return "orderForm"
order.users = users
orderRepository.save(order)
sessionStatus.setComplete()
return "redirect:/"
}
@GetMapping
fun ordersForUser(@AuthenticationPrincipal users: Users, model: Model): String {
val pageable = PageRequest.of(0, orderProps.pageSize)
model.addAttribute("orders", orderRepository.findByUsersOrderByPlacedAtDesc(users, pageable))
return "orderList"
}
} | SpringInAction5/tacocloud-web/src/main/kotlin/tacos/web/OrderController.kt | 1817752648 |
package tacos.messaging
import tacos.Order
interface OrderMessagingService {
fun sendOrder(order: Order)
}
| SpringInAction5/tacocloud-messaging-rabbitmq/src/main/kotlin/tacos/messaging/OrderMessagingService.kt | 1313104986 |
package tacos.messaging
import org.springframework.amqp.rabbit.core.RabbitTemplate
import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.context.annotation.Primary
import org.springframework.stereotype.Service
import tacos.Order
@Service
@Qualifier
class RabbitOrderMessagingService(
private val rabbitTemplate: RabbitTemplate,
) : OrderMessagingService {
// override fun sendOrder(order: Order) {
// val message = rabbitTemplate.messageConverter
// .toMessage(order, MessageProperties())
// rabbitTemplate.send("tacocloud.order", message)
// }
override fun sendOrder(order: Order) {
println("Sending order $order")
rabbitTemplate.convertAndSend("tacocloud.order", "kitchens.central.#", order)
}
// override fun sendOrder(order: Order) {
// val messageConverter = rabbitTemplate.messageConverter
// val props = MessageProperties().apply {
// setHeader("X_ORDER_SOURCE", "WEB")
// }
// val message = messageConverter.toMessage(order, props)
// rabbitTemplate.send("tacocloud.order", message)
// }
// override fun sendOrder(order: Order) {
// rabbitTemplate.convertAndSend("tacocloud.order", order) { message ->
// message.messageProperties.setHeader("X_ORDER_SOURCE", "WEB")
// message
// }
// }
} | SpringInAction5/tacocloud-messaging-rabbitmq/src/main/kotlin/tacos/messaging/RabbitOrderMessagingService.kt | 2416059278 |
package tacos.messaging
import org.springframework.amqp.core.Binding
import org.springframework.amqp.core.BindingBuilder
import org.springframework.amqp.core.Queue
import org.springframework.amqp.core.TopicExchange
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
@Configuration
class RabbitMessagingConfig{
@Bean
fun messageConverter() = Jackson2JsonMessageConverter()
@Bean
fun queue(): Queue {
return Queue("tacocloud.order.queue", false)
}
@Bean
fun exchange(): TopicExchange {
return TopicExchange("tacocloud.order")
}
@Bean
fun binding(queue: Queue?, exchange: TopicExchange?): Binding {
return BindingBuilder.bind(queue).to(exchange).with("kitchens.central.#")
}
} | SpringInAction5/tacocloud-messaging-rabbitmq/src/main/kotlin/tacos/messaging/RabbitMessagingConfig.kt | 1060856265 |
package tacos.mongodb
import jakarta.validation.constraints.NotNull
import jakarta.validation.constraints.Size
import org.springframework.data.annotation.Id
import org.springframework.data.mongodb.core.mapping.Document
import org.springframework.data.rest.core.annotation.RestResource
import java.util.*
@RestResource(rel = "tacos", path = "tacos")
@Document
data class Taco(
@field:Id
var id: Long? = null,
@field:NotNull
@field:Size(min = 5, message = "Name must be at least 5 characters long")
var name: String? = null,
@field:Size(min = 1, message = "You must choose at least 1 ingredient")
var ingredients: MutableList<Ingredient>? = mutableListOf(),
var createdAt: Date? = Date(),
) {
constructor(name: String): this() {
this.name = name
}
// @PrePersist
// fun createdAt() {
// this.createdAt = Date()
// }
} | SpringInAction5/tacocloud-domain-mongodb/src/main/kotlin/tacos/mongodb/Taco.kt | 1595753699 |
package tacos.mongodb
import org.springframework.data.mongodb.core.mapping.Document
import org.springframework.security.core.GrantedAuthority
import org.springframework.security.core.authority.SimpleGrantedAuthority
import org.springframework.security.core.userdetails.UserDetails
import java.io.Serializable
@Document
class Users(
@field:org.springframework.data.annotation.Id
var id: Long? = null,
private val username: String = "",
private val password: String = "",
var fullName: String? = null,
var street: String? = null,
var city: String? = null,
var state: String? = null,
var zip: String? = null,
var phoneNumber: String? = null,
): Serializable, UserDetails {
private val serialVersionUID: Long = 1L
override fun getAuthorities(): MutableCollection<out GrantedAuthority> {
return mutableListOf(SimpleGrantedAuthority("ROLE_USER"))
}
override fun getPassword(): String = password
override fun getUsername(): String = username
override fun isAccountNonExpired(): Boolean = true
override fun isAccountNonLocked(): Boolean = true
override fun isCredentialsNonExpired(): Boolean = true
override fun isEnabled(): Boolean = true
} | SpringInAction5/tacocloud-domain-mongodb/src/main/kotlin/tacos/mongodb/Users.kt | 3711219509 |
package tacos.mongodb
import org.springframework.data.annotation.Id
import org.springframework.data.mongodb.core.mapping.Document
@Document(collection = "ingredients")
class Ingredient(
@field:Id
var id: String,
var name: String,
var type: Type,
) {
enum class Type {
WRAP, PROTEIN, VEGGIES, CHEESE, SAUCE
}
} | SpringInAction5/tacocloud-domain-mongodb/src/main/kotlin/tacos/mongodb/Ingredient.kt | 3917315283 |
package tacos.mongodb
import jakarta.validation.constraints.Digits
import jakarta.validation.constraints.NotBlank
import jakarta.validation.constraints.Pattern
import org.hibernate.validator.constraints.CreditCardNumber
import org.springframework.data.annotation.Id
import org.springframework.data.mongodb.core.mapping.Document
import java.io.Serializable
import java.util.*
@Document
class Order (
@field:Id
var id: Long? = null,
@field:NotBlank(message = "Name is required")
var deliveryName: String? = String(),
@field:NotBlank(message = "Street is required")
var deliveryStreet: String? = String(),
@field:NotBlank(message = "City is required")
var deliveryCity: String? = String(),
@field:NotBlank(message = "State is required")
var deliveryState: String? = String(),
@field:NotBlank(message = "Zip code is required")
var deliveryZip: String? = String(),
@field:CreditCardNumber(message = "Not a valid credit card number")
var ccNumber: String? = String(),
@field:Pattern(regexp = "^(0[1-9]|1[0-2])(/)([1-9][0-9])$", message = "Must be formatted MM/YY")
var ccExpiration: String? = String(),
@field:Digits(integer = 3, fraction = 0, message = "Invalid CVV")
var ccCVV: String? = String(),
var placedAt: Date? = null,
val tacos: MutableList<Taco> = mutableListOf(),
var users: Users? = null
): Serializable {
constructor(email: String): this() {
this.deliveryName = email
}
private val serialVersionUID: Long = 1L
fun addDesign(design: Taco) {
this.tacos.add(design)
}
// @PrePersist
// fun placedAt() {
// this.placedAt = Date()
// }
} | SpringInAction5/tacocloud-domain-mongodb/src/main/kotlin/tacos/mongodb/Order.kt | 272007354 |
package tacos.restclient
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.hateoas.MediaTypes
import org.springframework.hateoas.client.Traverson
import org.springframework.web.client.RestTemplate
import java.net.URI
@Configuration
class RestConfig {
@Bean
fun restTemplate(): RestTemplate = RestTemplate()
@Bean
fun traverson(): Traverson = Traverson(
URI.create("http://localhost:8080/api"),
MediaTypes.HAL_JSON
)
} | SpringInAction5/tacocloud-restclient/src/main/kotlin/tacos/restclient/RestConfig.kt | 2125988285 |
package tacos.restclient
import org.springframework.hateoas.client.Traverson
import org.springframework.stereotype.Service
import org.springframework.web.client.RestTemplate
import tacos.Ingredient
@Service
class TacoCloudClient(
private val restTemplate: RestTemplate,
private val traverson: Traverson,
) {
fun getIngredientById(ingredientId: String): Ingredient? {
return restTemplate.getForObject("http://localhost:8080/ingredients/{id}", Ingredient::class.java, ingredientId)
}
// fun getIngredientById(ingredientId: String): Ingredient? {
// val urlVariables = HashMap<String, Any>()
// urlVariables["id"] = ingredientId
// return restTemplate.getForObject("http://localhost:8080/ingredients/{id}", Ingredient::class.java, urlVariables)
// }
// fun getIngredientById(ingredientId: String): Ingredient? {
// val urlVariables = HashMap<String, Any>()
// urlVariables["id"] = ingredientId
// val url = UriComponentsBuilder.fromHttpUrl("http://localhost:8080/ingredients/{id}")
// .build(urlVariables)
// return restTemplate.getForObject(url.toString(), Ingredient::class.java)
// }
// fun getIngredientById(ingredientId: String): Ingredient? {
// val responseEntity =
// restTemplate.getForEntity("http://localhost:8080/ingredients/{id}", Ingredient::class.java, ingredientId)
// return responseEntity.body
// }
fun updateIngredient(ingredient: Ingredient) {
restTemplate.put("http://localhost:8080/ingredients/{id}", ingredient, ingredient.id)
}
fun deleteIngredient(ingredient: Ingredient) {
restTemplate.delete("http://localhost:8080/ingredients/{id}", ingredient.id)
}
fun createIngredient(ingredient: Ingredient): Ingredient? {
return restTemplate.postForObject("http://localhost:8080/ingredients", ingredient, Ingredient::class.java)
}
// fun createIngredient(ingredient: Ingredient): URI? {
// return restTemplate.postForLocation("http://localhost:8080/ingredients", ingredient)
// }
// fun createIngredient(ingredient: Ingredient): Ingredient? {
// val responseEntity =
// restTemplate.postForEntity("http://localhost:8080/ingredients", ingredient, Ingredient::class.java)
// return responseEntity.body
// }
} | SpringInAction5/tacocloud-restclient/src/main/kotlin/tacos/restclient/TacoCloudClient.kt | 928451520 |
package tacos
import jakarta.persistence.*
import jakarta.validation.constraints.NotNull
import jakarta.validation.constraints.Size
import org.springframework.data.rest.core.annotation.RestResource
import java.util.Date
//@Entity
@RestResource(rel = "tacos", path = "tacos")
data class Taco(
@field:Id
@field:GeneratedValue(strategy = GenerationType.AUTO)
var id: Long? = null,
@field:NotNull
@field:Size(min = 5, message = "Name must be at least 5 characters long")
var name: String? = null,
@field:ManyToMany(targetEntity = Ingredient::class)
@field:Size(min = 1, message = "You must choose at least 1 ingredient")
var ingredients: MutableList<Ingredient>? = mutableListOf(),
var createdAt: Date? = Date(),
) {
constructor(name: String): this() {
this.name = name
}
@PrePersist
fun createdAt() {
this.createdAt = Date()
}
} | SpringInAction5/tacocloud-domain/src/main/kotlin/tacos/Taco.kt | 1659799044 |
package tacos
import jakarta.persistence.Entity
import jakarta.persistence.GeneratedValue
import jakarta.persistence.GenerationType
import jakarta.persistence.Id
import org.springframework.security.core.GrantedAuthority
import org.springframework.security.core.authority.SimpleGrantedAuthority
import org.springframework.security.core.userdetails.UserDetails
import java.io.Serializable
@Entity
class Users(
@field:Id
@field:GeneratedValue(strategy = GenerationType.AUTO)
var id: Long? = null,
private val username: String = "",
private val password: String = "",
var fullName: String? = null,
var street: String? = null,
var city: String? = null,
var state: String? = null,
var zip: String? = null,
var phoneNumber: String? = null,
): Serializable, UserDetails {
private val serialVersionUID: Long = 1L
override fun getAuthorities(): MutableCollection<out GrantedAuthority> {
return mutableListOf(SimpleGrantedAuthority("ROLE_USER"))
}
override fun getPassword(): String = password
override fun getUsername(): String = username
override fun isAccountNonExpired(): Boolean = true
override fun isAccountNonLocked(): Boolean = true
override fun isCredentialsNonExpired(): Boolean = true
override fun isEnabled(): Boolean = true
} | SpringInAction5/tacocloud-domain/src/main/kotlin/tacos/Users.kt | 396401740 |
package tacos
import jakarta.persistence.Entity
import jakarta.persistence.EnumType
import jakarta.persistence.Enumerated
import jakarta.persistence.Id
//@Entity
data class Ingredient(
@field:Id
var id: String,
var name: String,
@field:Enumerated(EnumType.STRING)
var type: Type,
) {
enum class Type {
WRAP, PROTEIN, VEGGIES, CHEESE, SAUCE
}
} | SpringInAction5/tacocloud-domain/src/main/kotlin/tacos/Ingredient.kt | 1789310656 |
package tacos
import jakarta.persistence.*
import jakarta.validation.constraints.Digits
import jakarta.validation.constraints.NotBlank
import jakarta.validation.constraints.Pattern
import org.hibernate.validator.constraints.CreditCardNumber
import java.io.Serializable
import java.util.Date
@Entity
@Table(name="`Order`")
class Order (
@field:Id
@field:GeneratedValue(strategy = GenerationType.AUTO)
var id: Long? = null,
@field:NotBlank(message = "Name is required")
var deliveryName: String? = String(),
@field:NotBlank(message = "Street is required")
var deliveryStreet: String? = String(),
@field:NotBlank(message = "City is required")
var deliveryCity: String? = String(),
@field:NotBlank(message = "State is required")
var deliveryState: String? = String(),
@field:NotBlank(message = "Zip code is required")
var deliveryZip: String? = String(),
@field:CreditCardNumber(message = "Not a valid credit card number")
var ccNumber: String? = String(),
@field:Pattern(regexp = "^(0[1-9]|1[0-2])(/)([1-9][0-9])$", message = "Must be formatted MM/YY")
var ccExpiration: String? = String(),
@field:Digits(integer = 3, fraction = 0, message = "Invalid CVV")
var ccCVV: String? = String(),
var placedAt: Date? = null,
@field:ManyToMany(targetEntity = Taco::class)
var tacos: MutableList<Taco> = mutableListOf(),
@field:ManyToOne
var users: Users? = null
): Serializable {
constructor(email: String): this() {
this.deliveryName = email
}
private val serialVersionUID: Long = 1L
fun addDesign(design: Taco) {
this.tacos.add(design)
}
@PrePersist
fun placedAt() {
this.placedAt = Date()
}
} | SpringInAction5/tacocloud-domain/src/main/kotlin/tacos/Order.kt | 871458768 |
package tacos.security
import org.springframework.security.core.userdetails.UserDetails
import org.springframework.security.core.userdetails.UserDetailsService
import org.springframework.security.core.userdetails.UsernameNotFoundException
import org.springframework.stereotype.Service
import tacos.data.UserRepository
@Service
class UserRepositoryUSerDetailsService(
private val userRepository: UserRepository
): UserDetailsService {
override fun loadUserByUsername(username: String): UserDetails {
return userRepository.findByUsername(username).orElseThrow {
UsernameNotFoundException("User '$username' not found")
}
}
} | SpringInAction5/tacocloud-security/src/main/kotlin/tacos/security/UserRepositoryUSerDetailsService.kt | 4114293973 |
package tacos.security
import org.springframework.security.crypto.password.PasswordEncoder
import org.springframework.stereotype.Controller
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.RequestMapping
import tacos.data.UserRepository
@Controller
@RequestMapping("/register")
class RegistrationController(
private val userRepository: UserRepository,
private val passwordEncoder: PasswordEncoder
) {
@GetMapping
fun registerForm() = "registration"
@PostMapping
fun processRegistration(registrationForm: RegistrationForm): String {
userRepository.save(registrationForm.toUser(passwordEncoder))
return "redirect:/login"
}
} | SpringInAction5/tacocloud-security/src/main/kotlin/tacos/security/RegistrationController.kt | 3127190933 |
package tacos.security
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.http.HttpMethod
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder
import org.springframework.security.config.annotation.authentication.configurers.provisioning.UserDetailsManagerConfigurer.UserDetailsBuilder
import org.springframework.security.config.annotation.web.builders.HttpSecurity
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity
import org.springframework.security.config.annotation.web.reactive.EnableWebFluxSecurity
import org.springframework.security.config.web.server.ServerHttpSecurity
import org.springframework.security.core.userdetails.ReactiveUserDetailsService
import org.springframework.security.core.userdetails.UserDetailsService
import org.springframework.security.crypto.factory.PasswordEncoderFactories
import org.springframework.security.crypto.password.PasswordEncoder
import org.springframework.security.web.SecurityFilterChain
import org.springframework.security.web.server.SecurityWebFilterChain
import org.springframework.security.web.servlet.util.matcher.MvcRequestMatcher
import org.springframework.security.web.util.matcher.AntPathRequestMatcher
import org.springframework.stereotype.Service
import org.springframework.web.servlet.handler.HandlerMappingIntrospector
import reactor.core.publisher.Mono
import tacos.data.UserReactiveRepository
import tacos.data.UserRepository
@Configuration
//@EnableWebSecurity
@EnableWebFluxSecurity
class SecurityConfig {
@Bean
fun passwordEncoder(): PasswordEncoder? = PasswordEncoderFactories.createDelegatingPasswordEncoder()
// @Bean
// fun securityFilterChain(http: HttpSecurity, inspector: HandlerMappingIntrospector): SecurityFilterChain {
// val matcherBuilder = MvcRequestMatcher.Builder(inspector)
//
// return http
// .authorizeHttpRequests {
// it
// .requestMatchers(HttpMethod.OPTIONS).permitAll()
// .requestMatchers(
// matcherBuilder.pattern("/design"),
// matcherBuilder.pattern("/orders/**")
// ).permitAll()
//// ).hasRole("USER")
// .requestMatchers(HttpMethod.PUT, "/ingredients").permitAll()
// .requestMatchers(
// matcherBuilder.pattern("/"),
// matcherBuilder.pattern("/**"),
// AntPathRequestMatcher("/h2-console/**")
// ).permitAll()
// }
// .httpBasic {
// it.realmName("Taco Cloud")
// }
// .formLogin {
// it.loginPage("/login")
// .defaultSuccessUrl("/design", true)
// }
// .logout {
// it.logoutSuccessUrl("/")
// }
// .csrf { it.ignoringRequestMatchers(AntPathRequestMatcher("/h2-console/**"))
// .ignoringRequestMatchers("/ingredients/**", "/design", "/orders/**")
// }
// .headers { it.frameOptions { option -> option.sameOrigin() } }
// .build()
// }
/*
Webflux λ²μ
Ant λ°©μμΈ **λ₯Ό μ¬μ©νμ§ μμλ λλ€
*/
@Bean
fun securityFilterChain(http: ServerHttpSecurity): SecurityWebFilterChain {
return http
.authorizeExchange {
ex -> ex.pathMatchers("/design", "orders").hasAuthority("USER")
.anyExchange().permitAll()
}
.build()
}
@Bean
fun userDetailsService(userRepository: UserReactiveRepository): ReactiveUserDetailsService {
return ReactiveUserDetailsService {
username -> userRepository.findByUsername(username)
.map { it }
}
}
} | SpringInAction5/tacocloud-security/src/main/kotlin/tacos/security/SecurityConfig.kt | 471384910 |
package tacos.security
import org.springframework.security.crypto.password.PasswordEncoder
import tacos.Users
data class RegistrationForm(
val username: String,
val password: String,
val fullName: String,
val street: String,
val city: String,
val state: String,
val zip: String,
val phone: String
) {
fun toUser(passwordEncoder: PasswordEncoder) = Users(
null,
username,
passwordEncoder.encode(password),
fullName,
street,
city,
state,
zip,
phone
)
}
| SpringInAction5/tacocloud-security/src/main/kotlin/tacos/security/RegistrationForm.kt | 2495917764 |
package tacos.kitchen
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
@SpringBootApplication
class TacoKitchenApplication
fun main(args: Array<String>) {
runApplication<TacoKitchenApplication>(*args)
} | SpringInAction5/tacocloud-kitchen/src/main/kotlin/tacos/kitchen/TacoKitchenApplication.kt | 2804264194 |
package tacos.kitchen
import tacos.Order
interface OrderReceiver {
fun receiveOrder(): Order?
}
| SpringInAction5/tacocloud-kitchen/src/main/kotlin/tacos/kitchen/OrderReceiver.kt | 1104293924 |
package tacos.kitchen.kafka.listener
import org.springframework.kafka.annotation.KafkaListener
import org.springframework.stereotype.Component
import tacos.Order
@Component
class KafkaOrderListener {
@KafkaListener(topics = ["tacocloud.orders.topic"])
fun handle(order: Order) {
println("Received from topics: $order")
}
} | SpringInAction5/tacocloud-kitchen/src/main/kotlin/tacos/kitchen/kafka/listener/KafkaOrderListener.kt | 1495639974 |
package tacos.kitchen.rabbit.listener
import org.springframework.amqp.rabbit.annotation.RabbitListener
import org.springframework.context.annotation.Profile
import org.springframework.stereotype.Component
import tacos.Order
@Profile("rabbitmq-listener")
@Component
class RabbitOrderListener {
@RabbitListener(queues = ["tacocloud.order.queue"])
fun receiveOrder(order: Order) {
println("Received from queue: $order")
}
} | SpringInAction5/tacocloud-kitchen/src/main/kotlin/tacos/kitchen/rabbit/listener/RabbitOrderListener.kt | 3691773804 |
package tacos.kitchen.rabbit
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
@Configuration
class RabbitMessagingConfig {
@Bean
fun messageConverter() = Jackson2JsonMessageConverter()
} | SpringInAction5/tacocloud-kitchen/src/main/kotlin/tacos/kitchen/rabbit/RabbitMessagingConfig.kt | 694848908 |
package tacos.kitchen.rabbit
import org.springframework.amqp.rabbit.core.RabbitTemplate
import org.springframework.context.annotation.Profile
import org.springframework.core.ParameterizedTypeReference
import org.springframework.stereotype.Component
import tacos.Order
import tacos.kitchen.OrderReceiver
@Profile("rabbitmq-template")
@Component("templateOrderReceiver")
class RabbitOrderReceiver(
private val rabbitTemplate: RabbitTemplate,
): OrderReceiver {
override fun receiveOrder(): Order? {
return rabbitTemplate.receiveAndConvert("tacocloud.order.queue", object: ParameterizedTypeReference<Order>() {})
}
} | SpringInAction5/tacocloud-kitchen/src/main/kotlin/tacos/kitchen/rabbit/RabbitOrderReceiver.kt | 3324927514 |
package tacos.email
import org.springframework.integration.core.GenericHandler
import org.springframework.messaging.MessageHeaders
import org.springframework.stereotype.Component
import org.springframework.web.client.RestTemplate
@Component
class OrderSubmitMessageHandler(
private val apiProperties: ApiProperties,
private val restTemplate: RestTemplate,
): GenericHandler<Order> {
override fun handle(payload: Order?, headers: MessageHeaders?): Any? {
restTemplate.postForObject(apiProperties.url!!, payload, String::class.java)
return null
}
}
| SpringInAction5/tacocloud-email/src/main/kotlin/tacos/email/OrderSubmitMessageHandler.kt | 2333734212 |
package tacos.email
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.integration.dsl.IntegrationFlow
import org.springframework.integration.dsl.Pollers
import org.springframework.integration.mail.dsl.Mail
@Configuration
class TacoOrderEmailIntegrationConfig {
@Bean
fun tacoOrderEmailFlow(
emailProperties: EmailProperties,
emailToOrderTransformer: EmailToOrderTransformer,
orderSubmitHandler: OrderSubmitMessageHandler
): IntegrationFlow {
return IntegrationFlow
.from(Mail.imapInboundAdapter(emailProperties.imapUrl))
{ e -> e.poller(Pollers.fixedDelay(emailProperties.pollRate)) }
.transform(emailToOrderTransformer)
.handle(orderSubmitHandler)
.get()
}
} | SpringInAction5/tacocloud-email/src/main/kotlin/tacos/email/TacoOrderEmailIntegrationConfig.kt | 3955292571 |
package tacos.email
class Taco(
val name: String,
var ingredients: MutableList<String> = mutableListOf()
) | SpringInAction5/tacocloud-email/src/main/kotlin/tacos/email/Taco.kt | 3056959823 |
package tacos.email
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.stereotype.Component
@Component
@ConfigurationProperties(prefix = "tacocloud.email")
class EmailProperties(
val username: String? = null,
val password: String? = null,
val host: String? = null,
val mailbox: String? = null,
val pollRate: Long = 30000,
) {
val imapUrl: String
get() = String.format("imaps://%s:%s@%s/%s", username, password, host, mailbox)
} | SpringInAction5/tacocloud-email/src/main/kotlin/tacos/email/EmailProperties.kt | 2269523373 |
package tacos.email
import jakarta.mail.Message
import jakarta.mail.internet.InternetAddress
import org.apache.commons.text.similarity.LevenshteinDistance
import org.springframework.integration.mail.transformer.AbstractMailMessageTransformer
import org.springframework.integration.support.AbstractIntegrationMessageBuilder
import org.springframework.integration.support.MessageBuilder
import org.springframework.stereotype.Component
import java.util.*
import java.util.logging.Logger
@Component
class EmailToOrderTransformer: AbstractMailMessageTransformer<Order>() {
override fun doTransform(mailMessage: Message): AbstractIntegrationMessageBuilder<Order> {
val tacoOrder = processPayload(mailMessage)
return MessageBuilder.withPayload(tacoOrder!!)
}
private fun processPayload(mailMessage: Message): Order? {
try {
val subject = mailMessage.subject
if (subject.uppercase(Locale.getDefault()).contains("TACO ORDER")) {
val email = (mailMessage.from[0] as InternetAddress).address
val content = mailMessage.content.toString()
return parseEmailToOrder(email, content)
}
} catch (e: Exception) {
logger.info(e.message)
}
return null
}
private fun parseEmailToOrder(email: String, content: String): Order {
val order = Order(email)
val lines = content.split("\\r?\\n".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
for (line in lines) {
if (line.trim { it <= ' ' }.isNotEmpty() && line.contains(":")) {
val lineSplit = line.split(":".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
val tacoName = lineSplit[0].trim { it <= ' ' }
val ingredients = lineSplit[1].trim { it <= ' ' }
val ingredientsSplit = ingredients.split(",".toRegex()).dropLastWhile { it.isEmpty() }
.toTypedArray()
val ingredientCodes: MutableList<String> = ArrayList()
for (ingredientName in ingredientsSplit) {
val code = lookupIngredientCode(ingredientName.trim { it <= ' ' })
if (code != null) {
ingredientCodes.add(code)
}
}
val taco = Taco(tacoName)
taco.ingredients = ingredientCodes
order.addTaco(taco)
}
}
return order
}
private fun lookupIngredientCode(ingredientName: String): String? {
for (ingredient in ALL_INGREDIENTS) {
val ucIngredientName = ingredientName.uppercase(Locale.getDefault())
if (LevenshteinDistance.getDefaultInstance().apply(ucIngredientName, ingredient.name) < 3 ||
ucIngredientName.contains(ingredient.name) ||
ingredient.name.contains(ucIngredientName)
) {
return ingredient.code
}
}
return null
}
companion object {
private val logger = Logger.getLogger(EmailToOrderTransformer::class.java.name)
private val ALL_INGREDIENTS = arrayOf(
Ingredient("FLTO", "FLOUR TORTILLA"),
Ingredient("COTO", "CORN TORTILLA"),
Ingredient("GRBF", "GROUND BEEF"),
Ingredient("CARN", "CARNITAS"),
Ingredient("TMTO", "TOMATOES"),
Ingredient("LETC", "LETTUCE"),
Ingredient("CHED", "CHEDDAR"),
Ingredient("JACK", "MONTERREY JACK"),
Ingredient("SLSA", "SALSA"),
Ingredient("SRCR", "SOUR CREAM")
)
}
}
| SpringInAction5/tacocloud-email/src/main/kotlin/tacos/email/EmailToOrderTransformer.kt | 2416651500 |
package tacos.email
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.stereotype.Component
@Component
@ConfigurationProperties(prefix = "tacocloud.api")
class ApiProperties(
val url: String? = null
) | SpringInAction5/tacocloud-email/src/main/kotlin/tacos/email/ApiProperties.kt | 699136135 |
package tacos.email
class Ingredient(
val code: String,
val name: String
) | SpringInAction5/tacocloud-email/src/main/kotlin/tacos/email/Ingredient.kt | 222530323 |
package tacos.email
class Order(
val email: String,
val tacos: MutableList<Taco> = mutableListOf()
) {
fun addTaco(taco: Taco) {
this.tacos.add(taco)
}
} | SpringInAction5/tacocloud-email/src/main/kotlin/tacos/email/Order.kt | 3041493846 |
package tacos.email
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.context.annotation.Bean
import org.springframework.web.client.RestTemplate
@SpringBootApplication
class TacoEmailApplication {
@Bean
fun restTemplate(): RestTemplate {
return RestTemplate()
}
}
fun main(args: Array<String>) {
runApplication<TacoEmailApplication>(*args)
} | SpringInAction5/tacocloud-email/src/main/kotlin/tacos/email/TacoEmailApplication.kt | 1724384265 |
package tacos.messaging
import tacos.Order
interface OrderMessagingService {
fun sendOrder(order: Order)
}
| SpringInAction5/tacocloud-messaging-kafka/src/main/kotlin/tacos/messaging/OrderMessagingService.kt | 1313104986 |
package tacos.messaging
import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.kafka.core.KafkaTemplate
import org.springframework.stereotype.Service
import tacos.Order
@Service
@Qualifier
class KafkaOrderMessagingService(
private val kafkaTemplate: KafkaTemplate<String, Order>,
): OrderMessagingService {
override fun sendOrder(order: Order) {
kafkaTemplate.send("tacocloud.orders.topic", order)
}
} | SpringInAction5/tacocloud-messaging-kafka/src/main/kotlin/tacos/messaging/KafkaOrderMessagingService.kt | 429009689 |
package tacos.messaging
import org.apache.kafka.clients.admin.AdminClientConfig
import org.apache.kafka.clients.admin.NewTopic
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.kafka.core.KafkaAdmin
@Configuration
class KafkaMessagingConfig{
@Bean
fun kafkaAdmin(): KafkaAdmin {
val configs: MutableMap<String, Any> = HashMap()
configs[AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG] = "localhost:9092"
return KafkaAdmin(configs)
}
@Bean
fun newTopic() = NewTopic("tacocloud.orders.topic", 10, 1)
} | SpringInAction5/tacocloud-messaging-kafka/src/main/kotlin/tacos/messaging/KafkaMessagingConfig.kt | 3342106468 |
package tacos
import org.springframework.boot.CommandLineRunner
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.Profile
import org.springframework.security.crypto.password.PasswordEncoder
import tacos.Ingredient.Type
import tacos.data.IngredientRepository
import tacos.data.OrderRepository
import tacos.data.TacoRepository
import tacos.data.UserRepository
@Profile("!prod")
@Configuration
class DevelopmentConfig {
@Bean
fun dataLoader(
ingredientRepository: IngredientRepository,
userRepository: UserRepository,
tacoRepository: TacoRepository,
orderRepository: OrderRepository,
encoder: PasswordEncoder
): CommandLineRunner {
return CommandLineRunner {
val flourTortilla = Ingredient("FLTO", "Flour Tortilla", Type.WRAP)
val cornTortilla = Ingredient("COTO", "Corn Tortilla", Type.WRAP)
val groundBeef = Ingredient("GRBF", "Ground Beef", Type.PROTEIN)
val carnitas = Ingredient("CARN", "Carnitas", Type.PROTEIN)
val tomatoes = Ingredient("TMTO", "Diced Tomatoes", Type.VEGGIES)
val lettuce = Ingredient("LETC", "Lettuce", Type.VEGGIES)
val cheddar = Ingredient("CHED", "Cheddar", Type.CHEESE)
val jack = Ingredient("JACK", "Monterrey Jack", Type.CHEESE)
val salsa = Ingredient("SLSA", "Salsa", Type.SAUCE)
val sourCream = Ingredient("SRCR", "Sour Cream", Type.SAUCE)
ingredientRepository.save(flourTortilla)
ingredientRepository.save(cornTortilla)
ingredientRepository.save(groundBeef)
ingredientRepository.save(carnitas)
ingredientRepository.save(tomatoes)
ingredientRepository.save(lettuce)
ingredientRepository.save(cheddar)
ingredientRepository.save(jack)
ingredientRepository.save(salsa)
ingredientRepository.save(sourCream)
userRepository.save(
Users(
username = "habuma",
password = encoder.encode("password"),
fullName = "Craig Walls",
street = "123 North Street",
city = "Cross Roads",
state = "TX",
zip = "76227",
phoneNumber = "123-123-1234"
)
)
val taco1 = Taco()
taco1.name = "Carnivore"
taco1.ingredients = mutableListOf(flourTortilla, groundBeef, carnitas, sourCream, salsa, cheddar)
tacoRepository.save(taco1)
val taco2 = Taco()
taco2.name = "Bovine Bounty"
taco2.ingredients = mutableListOf(cornTortilla, groundBeef, cheddar, jack, sourCream)
tacoRepository.save(taco2)
val taco3 = Taco()
taco3.name = "Veg-Out"
taco3.ingredients = mutableListOf(flourTortilla, cornTortilla, tomatoes, lettuce, salsa)
tacoRepository.save(taco3)
val order = Order()
order.deliveryName = "John Doe"
order.deliveryStreet = "1234 Culinary Blvd."
order.deliveryCity = "Foodsville"
order.deliveryState = "CO"
order.deliveryZip = "81019"
order.ccNumber = "4111111111111111"
order.ccExpiration = "10/19"
order.ccCVV = "123"
order.tacos = mutableListOf(taco1, taco2)
orderRepository.save(order)
}
}
} | SpringInAction5/tacos/src/main/kotlin/tacos/DevelopmentConfig.kt | 4083739551 |
package tacos
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
@SpringBootApplication
class TacoCloudApplication
fun main(args: Array<String>) {
runApplication<TacoCloudApplication>(*args)
} | SpringInAction5/tacos/src/main/kotlin/tacos/TacoCloudApplication.kt | 3354961936 |
package tacos
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
@SpringBootTest
class TacocloudDataApplicationTests {
@Test
fun contextLoads() {
}
}
| SpringInAction5/tacocloud-data/src/test/kotlin/tacos/TacocloudDataApplicationTests.kt | 2363567344 |
package tacos.data
import org.springframework.data.domain.Pageable
import org.springframework.data.repository.CrudRepository
import tacos.Order
import tacos.Users
import java.util.*
interface OrderRepository: CrudRepository<Order, Long> {
fun readOrdersByDeliveryZipAndPlacedAtBetween(deliveryZip: String, startDate: Date, endDate: Date): List<Order>
fun findByUsersOrderByPlacedAtDesc(users: Users, pageable: Pageable): List<Order>
} | SpringInAction5/tacocloud-data/src/main/kotlin/tacos/data/OrderRepository.kt | 1561289688 |
package tacos.data
import org.springframework.data.repository.CrudRepository
import tacos.Users
import java.util.*
interface UserRepository: CrudRepository<Users, Long> {
fun findByUsername(username: String): Optional<Users>
} | SpringInAction5/tacocloud-data/src/main/kotlin/tacos/data/UserRepository.kt | 1348628442 |
package tacos.data
import org.springframework.data.repository.reactive.ReactiveCrudRepository
import reactor.core.publisher.Mono
import tacos.Users
interface UserReactiveRepository: ReactiveCrudRepository<Users, Long> {
fun findByUsername(username: String): Mono<Users>
} | SpringInAction5/tacocloud-data/src/main/kotlin/tacos/data/UserReactiveRepository.kt | 1112910433 |
package tacos.data
import org.springframework.data.jpa.repository.JpaRepository
import tacos.Taco
interface TacoRepository: JpaRepository<Taco, Long> | SpringInAction5/tacocloud-data/src/main/kotlin/tacos/data/TacoRepository.kt | 2278734590 |
package tacos.data
import org.springframework.data.repository.CrudRepository
import tacos.Ingredient
interface IngredientRepository: CrudRepository<Ingredient, String> | SpringInAction5/tacocloud-data/src/main/kotlin/tacos/data/IngredientRepository.kt | 1797807473 |
package tacos.data.mongodb
import org.springframework.data.mongodb.repository.ReactiveMongoRepository
import tacos.mongodb.Order
interface OrderRepository: ReactiveMongoRepository<Order, Long> | SpringInAction5/tacocloud-data-mongodb/src/main/kotlin/tacos/data/mongodb/OrderRepository.kt | 3060301221 |
package tacos.data.mongodb
import org.springframework.boot.autoconfigure.security.SecurityProperties.User
import org.springframework.data.mongodb.repository.ReactiveMongoRepository
import reactor.core.publisher.Mono
import tacos.mongodb.Users
interface UserRepository: ReactiveMongoRepository<Users, Long> {
fun findByUsername(username: String): Mono<User>
fun findByEmail(email: String): Mono<User>
} | SpringInAction5/tacocloud-data-mongodb/src/main/kotlin/tacos/data/mongodb/UserRepository.kt | 1224824919 |
package tacos.data.mongodb
import org.springframework.data.mongodb.repository.ReactiveMongoRepository
import reactor.core.publisher.Flux
import tacos.mongodb.Taco
interface TacoRepository: ReactiveMongoRepository<Taco, Long> {
/*
ReactiveMongoRepository λ€λ₯Έ λ°μ΄ν°λ² μ΄μ€μλ μ¬μ©ν μ μμ, MongoDB νΉν
μ΅μ νλ insert() λ©μλκ° μ μ©ν¨
*/
fun findByOrderByCreatedAtDesc(): Flux<Taco>
} | SpringInAction5/tacocloud-data-mongodb/src/main/kotlin/tacos/data/mongodb/TacoRepository.kt | 2494709494 |
package tacos.data.mongodb
import org.springframework.data.repository.reactive.ReactiveCrudRepository
import org.springframework.web.bind.annotation.CrossOrigin
import tacos.mongodb.Ingredient
@CrossOrigin("*")
interface IngredientRepository: ReactiveCrudRepository<Ingredient, String> | SpringInAction5/tacocloud-data-mongodb/src/main/kotlin/tacos/data/mongodb/IngredientRepository.kt | 1068331169 |
package tacos.web.api
import org.junit.jupiter.api.Assertions.*
import org.junit.jupiter.api.Disabled
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.ExtendWith
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.http.MediaType
import org.springframework.test.context.junit.jupiter.SpringExtension
import org.springframework.test.web.reactive.server.WebTestClient
import org.springframework.test.web.reactive.server.expectBody
@ExtendWith(SpringExtension::class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class DesignTacoControllerWebTest @Autowired constructor(private val testClient: WebTestClient) {
@Test
@Disabled
@DisplayName("Not Test")
fun shouldReturnRecentTacos() {
testClient.get().uri("/design/recent")
.accept(MediaType.APPLICATION_JSON).exchange()
.expectStatus().isOk
.expectBody()
.jsonPath("$[?(@.id == 'TACO1')].name")
.isEqualTo("Canivore")
.jsonPath("$[?(@.id == 'TACO2')].name")
.isEqualTo("Bovine Bounty")
.jsonPath("$[?(@.id == 'TACO3')].name")
.isEqualTo("Veg-Out")
}
} | SpringInAction5/tacocloud-api/src/test/kotlin/tacos/web/api/DesignTacoControllerWebTest.kt | 1919003132 |
package tacos.web.api
import org.junit.jupiter.api.Test
import org.mockito.ArgumentMatchers.any
import org.mockito.BDDMockito.given
import org.mockito.Mockito
import org.springframework.core.ParameterizedTypeReference
import org.springframework.http.MediaType
import org.springframework.test.web.reactive.server.WebTestClient
import org.springframework.test.web.reactive.server.expectBody
import reactor.core.publisher.Flux
import reactor.core.publisher.Mono
import tacos.Ingredient
import tacos.Taco
import tacos.data.TacoRepository
class DesignTacoControllerTest {
@Test
fun shouldReturnRecentTacos() {
val tacos = arrayOf(
testTaco(1),
testTaco(2),
)
val tacoFlux = Flux.fromArray(tacos)
val tacoRepository: TacoRepository = Mockito.mock(TacoRepository::class.java)
given(tacoRepository.findAll()).willReturn(tacoFlux)
val testClient = WebTestClient.bindToController(DesignTacoController(tacoRepository)).build()
testClient.get().uri("/design/recent")
.exchange()
.expectStatus().isOk
.expectBody()
.jsonPath("$").isArray
.jsonPath("$").isNotEmpty
.jsonPath("$[0].id").isEqualTo(tacos[0].id.toString())
.jsonPath("$[0].name").isEqualTo(tacos[0].name.toString())
.jsonPath("$[1].id").isEqualTo(tacos[1].id.toString())
.jsonPath("$[1].name").isEqualTo(tacos[1].name.toString())
.jsonPath("$[3]").doesNotExist()
}
@Test
fun shouldSaveATaco() {
val tacoRepository = Mockito.mock(TacoRepository::class.java)
val unsavedTacoMono = Mono.just(testTaco(null))
val savedTaco = testTaco(null)
savedTaco.id = 1L
val savedTacoMono = Mono.just(savedTaco)
given(tacoRepository.save(any())).willReturn(savedTacoMono)
val testClient: WebTestClient = WebTestClient.bindToController(DesignTacoController(tacoRepository)).build()
testClient.post()
.uri("/design")
.contentType(MediaType.APPLICATION_JSON)
.body(unsavedTacoMono, Taco::class.java)
.exchange()
.expectStatus().isCreated
.expectBody(Taco::class.java)
.isEqualTo(savedTaco)
}
private fun testTaco(number: Long?): Taco {
val taco = Taco()
taco.id = number
taco.name = "Taco $number"
val ingredients = arrayListOf(
Ingredient("INGA", "Ingredient A", Ingredient.Type.WRAP),
Ingredient("INGB", "Ingredient B", Ingredient.Type.PROTEIN),
)
taco.ingredients = ingredients
return taco
}
} | SpringInAction5/tacocloud-api/src/test/kotlin/tacos/web/api/DesignTacoControllerTest.kt | 1772818189 |
package tacos
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
@SpringBootTest
class TacocloudApiApplicationTests {
@Test
fun contextLoads() {
}
}
| SpringInAction5/tacocloud-api/src/test/kotlin/tacos/TacocloudApiApplicationTests.kt | 3930445552 |
package tacos.web.api
import org.springframework.web.bind.annotation.CrossOrigin
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RestController
import tacos.data.IngredientRepository
@RestController
@RequestMapping(path = ["/ingredients"], produces = ["application/json"])
@CrossOrigin("*")
class IngredientController(
private val ingredientRepository: IngredientRepository
) {
@GetMapping
fun allIngredients() = ingredientRepository.findAll().toList()
} | SpringInAction5/tacocloud-api/src/main/kotlin/tacos/web/api/IngredientController.kt | 2246920922 |
package tacos.web.api
import org.springframework.hateoas.server.RepresentationModelAssembler
import tacos.Ingredient
class IngredientRepresentationModelAssembler: RepresentationModelAssembler<Ingredient, IngredientEntityModel> {
override fun toModel(entity: Ingredient): IngredientEntityModel {
return IngredientEntityModel(entity)
}
} | SpringInAction5/tacocloud-api/src/main/kotlin/tacos/web/api/IngredientRepresentationModelAssembler.kt | 4272524097 |
package tacos.web.api
import org.springframework.hateoas.CollectionModel
import org.springframework.hateoas.server.RepresentationModelAssembler
import org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.linkTo
import org.springframework.hateoas.server.mvc.WebMvcLinkBuilder.methodOn
import org.springframework.stereotype.Component
import tacos.Taco
@Component
class TacoRepresentationModelAssembler: RepresentationModelAssembler<Taco, TacoEntityModel> {
override fun toModel(entity: Taco): TacoEntityModel {
return TacoEntityModel(entity)
}
// override fun toCollectionModel(entities: MutableIterable<Taco>): CollectionModel<TacoEntityModel> {
// return super.toCollectionModel(entities )
// .add(linkTo(methodOn(RecentTacosController::class.java).recentTacos()).withSelfRel())
// }
} | SpringInAction5/tacocloud-api/src/main/kotlin/tacos/web/api/TacoRepresentationModelAssembler.kt | 32998089 |
package tacos.web.api
import org.springframework.hateoas.RepresentationModel
import tacos.Ingredient
class IngredientEntityModel(
ingredient: Ingredient,
): RepresentationModel<IngredientEntityModel>() {
val name: String = ingredient.name
val type: Ingredient.Type = ingredient.type
} | SpringInAction5/tacocloud-api/src/main/kotlin/tacos/web/api/IngredientEntityModel.kt | 3771423182 |
package tacos.web.api
import org.springframework.data.domain.PageRequest
import org.springframework.data.domain.Sort
import org.springframework.data.rest.webmvc.RepositoryRestController
import org.springframework.data.web.PagedResourcesAssembler
import org.springframework.hateoas.CollectionModel
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.GetMapping
import tacos.Taco
import tacos.data.TacoRepository
@RepositoryRestController
class RecentTacosController(
private val tacoRepository: TacoRepository,
private val pagedModelAssembler: PagedResourcesAssembler<Taco>,
private val tacoRepresentationModelAssembler: TacoRepresentationModelAssembler,
) {
// @GetMapping(path = ["/tacos/recent"], produces = ["application/hal+json"])
// fun recentTacos(): ResponseEntity<CollectionModel<TacoEntityModel>> {
// val page = PageRequest.of(0, 12, Sort.by("createdAt").descending())
//
//
// val tacosPage = tacoRepository.findAll(page)
// val pagedModel = pagedModelAssembler.toModel(tacosPage, tacoRepresentationModelAssembler)
//
// return ResponseEntity.ok(pagedModel)
// }
} | SpringInAction5/tacocloud-api/src/main/kotlin/tacos/web/api/RecentTacosController.kt | 28685281 |
package tacos.web.api
import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.dao.EmptyResultDataAccessException
import org.springframework.http.HttpStatus
import org.springframework.web.bind.annotation.*
import tacos.Order
import tacos.data.OrderRepository
import tacos.messaging.OrderMessagingService
@RestController
@RequestMapping(path = ["/orders"], produces = ["application/json"])
@CrossOrigin(origins = ["*"])
class OrderApiController(
private val orderRepository: OrderRepository,
@Qualifier("rabbitOrderMessagingService")
private val rabbitOrderMessage: OrderMessagingService,
@Qualifier("kafkaOrderMessagingService")
private val kafkaOrderMessage: OrderMessagingService,
) {
@GetMapping(produces = ["application/json"])
fun allOrders() = orderRepository.findAll().toList()
@PostMapping(produces = ["application/json"])
@ResponseStatus(HttpStatus.CREATED)
fun postOrder(@RequestBody order: Order) {
// rabbitOrderMessage.sendOrder(order)
kafkaOrderMessage.sendOrder(order)
orderRepository.save(order)
}
@PutMapping(path = ["/{orderId}"], produces = ["application/json"])
fun pathOrder(@PathVariable orderId: Long,
@RequestBody patch: Order): Order {
val order = orderRepository.findById(orderId).get()
patch.apply {
if(deliveryName != null) order.deliveryName = deliveryName
if(deliveryStreet != null) order.deliveryStreet = deliveryStreet
if(deliveryCity != null) order.deliveryCity = deliveryCity
if(deliveryState != null) order.deliveryState = deliveryState
if(deliveryZip != null) order.deliveryZip = deliveryZip
if(ccNumber != null) order.ccNumber = ccNumber
if(ccExpiration != null) order.ccExpiration = ccExpiration
if(ccCVV != null) order.ccCVV = ccCVV
}
return orderRepository.save(order)
}
@DeleteMapping(path = ["/{orderId}"])
fun deleteOrder(@PathVariable orderId: Long) {
try {
orderRepository.deleteById(orderId)
} catch (_: EmptyResultDataAccessException) { }
}
} | SpringInAction5/tacocloud-api/src/main/kotlin/tacos/web/api/OrderApiController.kt | 4214045487 |
package tacos.web.api
import org.springframework.data.domain.PageRequest
import org.springframework.data.domain.Sort
import org.springframework.http.HttpStatus
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.*
import tacos.Taco
import tacos.data.TacoRepository
@RestController
@RequestMapping(path = ["/design"], produces = ["application/json"])
@CrossOrigin(origins = ["*"])
class DesignTacoController(
private val tacoRepository: TacoRepository,
) {
@GetMapping("/recent")
fun recentTacos(): MutableList<Taco> {
val page = PageRequest.of(0, 12, Sort.by("createdAt").descending())
return tacoRepository.findAll(page).content
}
@GetMapping("/{id}")
fun tacoById(@PathVariable id: Long): ResponseEntity<Taco>? {
val tacoOptional = tacoRepository.findById(id)
return if (tacoOptional.isEmpty) ResponseEntity(HttpStatus.NOT_FOUND)
else ResponseEntity.ok(tacoOptional.get())
}
@PostMapping(consumes = ["application/json"])
@ResponseStatus(HttpStatus.CREATED)
fun postTaco(@RequestBody taco: Taco): Taco {
return tacoRepository.save(taco)
}
} | SpringInAction5/tacocloud-api/src/main/kotlin/tacos/web/api/DesignTacoController.kt | 3673255178 |
package tacos.web.api
import org.springframework.hateoas.RepresentationModel
import org.springframework.hateoas.server.core.Relation
import tacos.Taco
import java.util.*
@Relation(value = "taco", collectionRelation = "tacos")
class TacoEntityModel(
taco: Taco,
): RepresentationModel<TacoEntityModel>() {
private val ingredientAssembler = IngredientRepresentationModelAssembler()
val name: String = taco.name!!
val createdAt: Date = taco.createdAt!!
val ingredients: List<IngredientEntityModel> = ingredientAssembler.toCollectionModel(taco.ingredients!!).content.toList()
} | SpringInAction5/tacocloud-api/src/main/kotlin/tacos/web/api/TacoEntityModel.kt | 2133183130 |
package tacos.web.react
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.web.reactive.function.client.WebClient
@Configuration
class ReactWebConfig {
@Bean
fun webClient(): WebClient {
return WebClient.create("http://localhost:8080")
}
} | SpringInAction5/tacocloud-api/src/main/kotlin/tacos/web/react/ReactWebConfig.kt | 942290492 |
package tacos.web.react
import org.springframework.http.HttpStatus
import org.springframework.web.bind.annotation.*
import reactor.core.publisher.Flux
import reactor.core.publisher.Mono
import tacos.data.mongodb.TacoRepository
import tacos.mongodb.Taco
@RestController
@RequestMapping(path = ["/design"], produces = ["application/json"])
@CrossOrigin(origins = ["*"])
class ReactiveDesignTacoController(
private val tacoRepository: TacoRepository,
) {
@GetMapping("/recent")
fun recentTacos(): Flux<Taco> {
return tacoRepository.findByOrderByCreatedAtDesc().take(12)
}
@GetMapping("/{id}")
fun tacoById(@PathVariable id: Long): Mono<Taco> {
return tacoRepository.findById(id)
}
@PostMapping(consumes = ["application/json"])
@ResponseStatus(HttpStatus.CREATED)
fun postTaco(@RequestBody taco: Taco): Mono<Taco> {
return tacoRepository.save(taco)
}
} | SpringInAction5/tacocloud-api/src/main/kotlin/tacos/web/react/ReactiveDesignTacoController.kt | 3743124841 |
package tacos.web.react
import org.springframework.http.HttpStatus
import org.springframework.stereotype.Service
import org.springframework.web.reactive.function.client.WebClient
import org.springframework.web.reactive.function.client.bodyToMono
import reactor.core.Disposable
import reactor.core.publisher.Mono
import tacos.Ingredient
import java.time.Duration
@Service
class WebClientService(
private val webClient: WebClient
) {
/*
.retrieve() -> ResponseSpec νμ
κ°μ²΄ λ°ν, μλ΅μ ν€λλ μΏ ν€ κ°μ μ¬μ©ν μ μλ€
*/
fun getIngredientById(ingredientId: String) {
val ingredientMono = webClient.get().uri("/ingredients/{id}", ingredientId)
.retrieve()
.bodyToMono(Ingredient::class.java)
ingredientMono.subscribe {
ingredient -> println(ingredient.name)
}
}
fun getIngredients() {
val ingredients = WebClient.create()
.get()
.uri("http://localhost:8080/ingredients")
.retrieve()
.bodyToFlux(Ingredient::class.java)
ingredients.timeout(Duration.ofSeconds(1))
.subscribe (
{
ingredient -> println(ingredient.id)
},
{
error -> println(error.message)
}
)
}
fun postIngredientMono(ingredientMono: Mono<Ingredient>) {
val result = webClient.post()
.uri("/ingredients")
.body(ingredientMono, Ingredient::class.java)
.retrieve()
.bodyToMono(Ingredient::class.java)
result.subscribe {
ingredient -> println(ingredient.id)
}
}
fun postIngredient(ingredient: Ingredient) {
val result = webClient.post()
.uri("/ingredients")
.bodyValue(ingredient)// syncBody -> bodyValue since 5.2
.retrieve()
.bodyToMono(Ingredient::class.java)
result.subscribe {
i -> println(i.id)
}
}
fun deleteIngredient(ingredientId: Long) {
val result: Disposable = webClient.delete()
.uri("/ingredients/{id}", ingredientId)
.retrieve()
.bodyToMono(Void::class.java)
.subscribe()
}
fun handleError(ingredientId: Long) {
val ingredientMono = webClient.get().uri("/ingredients/{id}", ingredientId)
.retrieve()
.onStatus(
{status -> status == HttpStatus.NOT_FOUND},
{ _ -> Mono.just(RuntimeException("4xx"))}
)
.bodyToMono(Ingredient::class.java)
ingredientMono.subscribe (
{ ingredient -> println(ingredient.name) },
{ error -> println(error.message) } // WebClientResponseException μμΈ λ°μ
)
}
/*
Mono<ClientResponse> λ₯Ό μ΄μ©νμ¬ μΆκ°μ μΈ μμ
μ ν λ
*/
fun exchange(ingredientId: Long) {
webClient.get()
.uri("http://localhost:8080/ingredients/{id}", ingredientId)
.exchangeToMono { response ->
if (response.headers().header("X_UNAVAILABLE").contains("true")) {
Mono.empty<Void>()
}
Mono.just(response)
}
.flatMap { response -> response.bodyToMono(Ingredient::class.java) }
}
} | SpringInAction5/tacocloud-api/src/main/kotlin/tacos/web/react/WebClientService.kt | 1983858269 |
import org.assertj.core.groups.Tuple
import org.junit.jupiter.api.Test
import reactor.core.publisher.Flux
import reactor.test.StepVerifier
import reactor.util.function.Tuple2
import java.time.Duration
class FluxMergingTest {
@Test
fun mergeFluxes() {
val characterFlux = Flux.just("Garfield", "Kojak", "Barbossa")
.delayElements(Duration.ofMillis(500))
val foodFlux = Flux.just("Lasagna", "Lollipops", "Apples")
.delaySubscription(Duration.ofMillis(250))
.delayElements(Duration.ofMillis(500))
val mergedFlux = characterFlux.mergeWith(foodFlux)
StepVerifier.create(mergedFlux)
.expectNext("Garfield")
.expectNext("Lasagna")
.expectNext("Kojak")
.expectNext("Lollipops")
.expectNext("Barbossa")
.expectNext("Apples")
.verifyComplete()
}
@Test
fun zipFluxes() {
val characterFlux = Flux.just("Garfield", "Kojak", "Barbossa")
val foodFlux = Flux.just("Lasagna", "Lollipops", "Apples")
val zippedFlux: Flux<Tuple2<String, String>> = Flux.zip(characterFlux, foodFlux)
StepVerifier.create(zippedFlux)
.expectNextMatches{ t: Tuple2<String, String> -> t.t1 == "Garfield" && t.t2 == "Lasagna" }
.expectNextMatches{ t: Tuple2<String, String> -> t.t1 == "Kojak" && t.t2 == "Lollipops" }
.expectNextMatches{ t: Tuple2<String, String> -> t.t1 == "Barbossa" && t.t2 == "Apples" }
.verifyComplete()
}
@Test
fun zipFluxesToObject() {
val characterFlux = Flux.just("Garfield", "Kojak", "Barbossa")
val foodFlux = Flux.just("Lasagna", "Lollipops", "Apples")
val zippedFlux = Flux.zip(characterFlux, foodFlux) { c, f -> "$c eats $f" }
StepVerifier.create(zippedFlux)
.expectNext("Garfield eats Lasagna")
.expectNext("Kojak eats Lollipops")
.expectNext("Barbossa eats Apples")
.verifyComplete()
}
@Test
fun firstFlux() {
val slowFlux = Flux.just("tortoise", "snail", "sloth")
.delaySubscription(Duration.ofMillis(100))
val fastFlux = Flux.just("hare", "cheetah", "squirrel")
val firstFlux = Flux.firstWithSignal(slowFlux, fastFlux)
StepVerifier.create(firstFlux)
.expectNext("hare")
.expectNext("cheetah")
.expectNext("squirrel")
.verifyComplete()
}
} | SpringInAction5/reactor/src/test/kotlin/FluxMergingTest.kt | 3188904025 |
import org.junit.jupiter.api.Test
import reactor.core.publisher.Flux
import reactor.core.publisher.Mono
import reactor.core.scheduler.Schedulers
import reactor.test.StepVerifier
class FluxBufferingTest {
@Test
fun buffer() {
val fruitFlux = Flux.just("apple", "orange", "banana", "kiwi", "strawberry")
val bufferedFlux: Flux<List<String>> = fruitFlux.buffer(3)
StepVerifier.create(bufferedFlux)
.expectNext(listOf("apple", "orange", "banana"))
.expectNext(listOf("kiwi", "strawberry"))
.verifyComplete()
}
@Test
fun bufferToList() {
Flux.just("apple", "orange", "banana", "kiwi", "strawberry")
.buffer(3)
.flatMap { x ->
Flux.fromIterable(x)
.map { y -> y.uppercase() }
.subscribeOn(Schedulers.parallel())
.log()
}
.subscribe()
}
@Test
fun collectionList() {
val fruitFlux = Flux.just("apple", "orange", "banana", "kiwi", "strawberry")
val fruitListMono: Mono<List<String>> = fruitFlux.collectList()
StepVerifier.create(fruitListMono)
.expectNext(listOf("apple", "orange", "banana", "kiwi", "strawberry"))
.verifyComplete()
}
@Test
fun collectMap() {
val animalFlux = Flux.just("aardvark", "elephant", "koala", "eagle", "kangaroo")
val animalMapMono: Mono<Map<Char, String>> = animalFlux.collectMap { a -> a[0] }
StepVerifier.create(animalMapMono)
.expectNextMatches { m ->
m.size == 3 &&
m['a'] == "aardvark" &&
m['e'] == "eagle" && // elephant -> eagle
m['k'] == "kangaroo" // koala -> kangaroo
}
.verifyComplete()
}
@Test
fun all() {
// λͺ¨λ λ¨μ΄μμ ν¬ν¨μ¬λΆ
val animalFlux = Flux.just("aardvark", "elephant", "koala", "eagle", "kangaroo")
val hasAMono: Mono<Boolean> = animalFlux.all { a -> a.contains("a") }
StepVerifier.create(hasAMono)
.expectNext(true)
.verifyComplete()
val hasKMono: Mono<Boolean> = animalFlux.all { a -> a.contains("k") }
StepVerifier.create(hasKMono)
.expectNext(false)
.verifyComplete()
}
@Test
fun any() {
// μ μ΄λ νλμ λ¨μ΄μμ ν¬ν¨μ¬λΆ
val animalFlux = Flux.just("aardvark", "elephant", "koala", "eagle", "kangaroo")
val hasTMono = animalFlux.any { a -> a.contains("t") }
StepVerifier.create(hasTMono)
.expectNext(true)
.verifyComplete()
val hasZMono = animalFlux.any { a -> a.contains("z") }
StepVerifier.create(hasZMono)
.expectNext(false)
.verifyComplete()
}
} | SpringInAction5/reactor/src/test/kotlin/FluxBufferingTest.kt | 3932972164 |
import org.junit.jupiter.api.Test
import reactor.core.publisher.Flux
import reactor.test.StepVerifier
import java.time.Duration
import java.util.stream.Stream
class FluxCreationTest {
@Test
fun createAFlux_just() {
val fruitFlux: Flux<String> = Flux.just("Apple", "Orange", "Grape", "Banana", "Strawberry")
fruitFlux.subscribe {
println("Here's some fruit: $it")
}
StepVerifier.create(fruitFlux)
.expectNext("Apple")
.expectNext("Orange")
.expectNext("Grape")
.expectNext("Banana")
.expectNext("Strawberry")
.verifyComplete()
}
@Test
fun createAFlux_fromArray() {
val fruits = arrayOf("Apple", "Orange", "Grape", "Banana", "Strawberry")
val fruitFlux: Flux<String> = Flux.fromArray(fruits)
StepVerifier.create(fruitFlux)
.expectNext("Apple")
.expectNext("Orange")
.expectNext("Grape")
.expectNext("Banana")
.expectNext("Strawberry")
.verifyComplete()
}
@Test
fun createAFlux_fromIterable() {
val fruitList = arrayListOf("Apple", "Orange", "Grape", "Banana", "Strawberry")
val fruitFlux = Flux.fromIterable(fruitList)
StepVerifier.create(fruitFlux)
.expectNext("Apple")
.expectNext("Orange")
.expectNext("Grape")
.expectNext("Banana")
.expectNext("Strawberry")
.verifyComplete()
}
@Test
fun createAFlux_fromStream() {
val fruitStream = Stream.of("Apple", "Orange", "Grape", "Banana", "Strawberry")
val fruitFlux = Flux.fromStream(fruitStream)
StepVerifier.create(fruitFlux)
.expectNext("Apple")
.expectNext("Orange")
.expectNext("Grape")
.expectNext("Banana")
.expectNext("Strawberry")
.verifyComplete()
}
@Test
fun createAFlux_range() {
val intervalFlux = Flux.range(1, 5)
StepVerifier.create(intervalFlux)
.expectNext(1)
.expectNext(2)
.expectNext(3)
.expectNext(4)
.expectNext(5)
.verifyComplete()
}
@Test
fun createAFlux_interval() {
// 0λΆν° μμ, μ΅λκ°μ΄ μ€μ λμ§ μμΌλ©΄ 무νμ μΌλ‘ μ¦κ°
val intervalFlux = Flux.interval(Duration.ofSeconds(1)).take(5)
StepVerifier.create(intervalFlux)
.expectNext(0L)
.expectNext(1L)
.expectNext(2L)
.expectNext(3L)
.expectNext(4L)
.verifyComplete()
}
} | SpringInAction5/reactor/src/test/kotlin/FluxCreationTest.kt | 4215446057 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.