content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package com.fsacchi.hilt_mvvm_compose_pokedex
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.platform.app.InstrumentationRegistry
import org.junit.Assert.*
import org.junit.Test
import org.junit.runner.RunWith
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.fsacchi.hilt_mvvm_compose_pokedex", appContext.packageName)
}
} | Hilt-MVVM-Compose-Pokedex/app/src/androidTest/java/com/fsacchi/hilt_mvvm_compose_pokedex/ExampleInstrumentedTest.kt | 2181829335 |
package com.fsacchi.hilt_mvvm_compose_pokedex
import org.junit.Assert.assertEquals
import org.junit.Test
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} | Hilt-MVVM-Compose-Pokedex/app/src/test/java/com/fsacchi/hilt_mvvm_compose_pokedex/ExampleUnitTest.kt | 2077403793 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.component.appbar
import androidx.compose.material.Icon
import androidx.compose.material.IconButton
import androidx.compose.material.MaterialTheme
import androidx.compose.material.Text
import androidx.compose.material.TopAppBar
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Menu
import androidx.compose.runtime.Composable
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.theme.PokedexColor
@Composable
fun HomeAppBar(title: String, openDrawer: () -> Unit, openFilters: () -> Unit) {
TopAppBar(
backgroundColor = PokedexColor,
title = {
Text(
text = title,
style = MaterialTheme.typography.h6,
)
},
navigationIcon = {
IconButton(onClick = {
openDrawer()
}) {
Icon(Icons.Default.Menu, "Menu")
}
},
)
}
| Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/component/appbar/HomeAppBar.kt | 1102812518 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.component.appbar
import androidx.compose.foundation.Image
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.material.MaterialTheme
import androidx.compose.material.Text
import androidx.compose.material.TopAppBar
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.ArrowBack
import androidx.compose.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.unit.dp
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.theme.PokedexColor
@Composable
fun AppBarWithArrow(
title: String?,
pressOnBack: () -> Unit
) {
TopAppBar(
elevation = 6.dp,
backgroundColor = PokedexColor,
modifier = Modifier.height(58.dp)
) {
Row {
Spacer(modifier = Modifier.width(10.dp))
Image(
imageVector = Icons.Filled.ArrowBack,
colorFilter = ColorFilter.tint(Color.White),
contentDescription = null,
modifier = Modifier
.align(Alignment.CenterVertically)
.clickable {
pressOnBack()
}
)
Spacer(modifier = Modifier.width(12.dp))
Text(
modifier = Modifier
.padding(8.dp)
.align(Alignment.CenterVertically),
text = title ?: "",
style = MaterialTheme.typography.h6,
color = Color.White
)
}
}
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/component/appbar/AppBarWithArrow.kt | 1062535142 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.component
import android.app.Activity
import androidx.activity.compose.BackHandler
import androidx.compose.animation.animateColorAsState
import androidx.compose.animation.core.LinearOutSlowInEasing
import androidx.compose.animation.core.tween
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.interaction.MutableInteractionSource
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
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.widthIn
import androidx.compose.foundation.lazy.LazyRow
import androidx.compose.foundation.lazy.grid.GridCells
import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
import androidx.compose.foundation.lazy.grid.rememberLazyGridState
import androidx.compose.foundation.lazy.items
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.snapshotFlow
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.shadow
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.platform.LocalContext
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.navigation.NavController
import androidx.paging.LoadState
import androidx.paging.PagingData
import androidx.paging.compose.LazyPagingItems
import androidx.paging.compose.collectAsLazyPagingItems
import coil.compose.AsyncImagePainter
import coil.compose.rememberAsyncImagePainter
import coil.decode.SvgDecoder
import coil.request.ImageRequest
import com.fsacchi.hilt_mvvm_compose_pokedex.data.datasource.remote.ApiURL
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.ResultItem
import com.fsacchi.hilt_mvvm_compose_pokedex.navigation.Screen
import com.fsacchi.hilt_mvvm_compose_pokedex.navigation.currentRoute
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.theme.DefaultBackgroundColor
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.theme.PokedexColor
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.theme.PokedexLight
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.theme.cornerRadius
import com.fsacchi.hilt_mvvm_compose_pokedex.utils.conditional
import com.fsacchi.hilt_mvvm_compose_pokedex.utils.items
import com.fsacchi.hilt_mvvm_compose_pokedex.utils.pagingLoadingState
import kotlinx.coroutines.flow.Flow
@Composable
fun PokemonItemList(
navController: NavController,
pokemons: Flow<PagingData<ResultItem>>,
types: ArrayList<ResultItem>? = null,
selectedName: ResultItem?,
onclick: (genreId: ResultItem?) -> Unit
) {
val activity = (LocalContext.current as? Activity)
val progressBar = remember { mutableStateOf(false) }
val openDialog = remember { mutableStateOf(false) }
val pokemonItems: LazyPagingItems<ResultItem> = pokemons.collectAsLazyPagingItems()
val lazyGridState = rememberLazyGridState()
BackHandler(enabled = (currentRoute(navController) == Screen.Home.route)) {
openDialog.value = true
}
LaunchedEffect(pokemonItems) {
snapshotFlow { pokemonItems.loadState.refresh }
.collect { loadState ->
if (loadState is LoadState.NotLoading) {
lazyGridState.scrollToItem(index = 0)
}
}
}
Column(modifier = Modifier.background(DefaultBackgroundColor)) {
types?.let {
LazyRow(
modifier = Modifier
.padding(top = 8.dp, bottom = 8.dp, start = 9.dp, end = 9.dp)
.fillMaxWidth()
) {
items(types) { item ->
SelectableGenreChip(
selected = item.name === selectedName?.name,
genre = item.name,
onclick = {
onclick(item)
}
)
}
}
}
CircularIndeterminateProgressBar(isDisplayed = progressBar.value, 0.4f)
LazyVerticalGrid(columns = GridCells.Fixed(3),
modifier = Modifier
.padding(start = 5.dp, end = 5.dp)
.conditional(types == null) {
padding(top = 8.dp)
},
content = {
items(pokemonItems) { item ->
item?.let {
PokemonItemView(it, navController)
}
}
},
state = lazyGridState)
}
if (openDialog.value) {
ExitAlertDialog(navController, {
openDialog.value = it
}, {
activity?.finish()
})
}
pokemonItems.pagingLoadingState {
progressBar.value = it
}
}
@Composable
fun PokemonItemView(item: ResultItem, navController: NavController) {
Box(modifier = Modifier.padding(start = 5.dp, end = 5.dp, top = 0.dp, bottom = 10.dp)) {
val painter = rememberAsyncImagePainter(
model = ImageRequest.Builder(LocalContext.current)
.decoderFactory(SvgDecoder.Factory())
.data(ApiURL.IMAGE_URL.plus(item.getNameImage()) )
.build()
)
Image(
modifier = Modifier
.size(150.dp)
.cornerRadius(10)
.shadow(8.dp)
.background(color = Color.White)
.clickable {
navController.navigate(Screen.PokemonDetail.route.plus("/${item.getNameItem()}"))
},
painter = painter,
contentDescription = null,
contentScale = ContentScale.Fit,
alignment = Alignment.Center,
)
when (painter.state) {
is AsyncImagePainter.State.Loading -> {
CircularIndeterminateProgressBar(isDisplayed = true, 0.6f)
}
else -> {}
}
Text(
text = item.name.replaceFirstChar { it.uppercase() },
modifier = Modifier
.fillMaxWidth()
.padding(top = 150.dp),
fontWeight = FontWeight.Bold,
textAlign = TextAlign.Center
)
}
}
@Composable
fun SelectableGenreChip(
selected: Boolean,
genre: String,
onclick: () -> Unit
) {
val animateChipBackgroundColor by animateColorAsState(
targetValue = if (selected) PokedexColor else PokedexLight,
animationSpec = tween(
durationMillis = 50,
delayMillis = 0,
easing = LinearOutSlowInEasing
), label = ""
)
Box(
modifier = Modifier
.padding(end = 8.dp)
.cornerRadius(16)
.background(
color = animateChipBackgroundColor
)
.height(32.dp)
.widthIn(min = 80.dp)
.padding(horizontal = 8.dp)
.clickable(
interactionSource = remember { MutableInteractionSource() },
indication = null
) {
onclick()
}
) {
Text(
text = genre,
fontSize = 14.sp,
fontWeight = FontWeight.Light,
textAlign = TextAlign.Center,
modifier = Modifier.align(Alignment.Center),
color = Color.White.copy(alpha = 0.80F)
)
}
}
| Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/component/PokemonItemList.kt | 3686445697 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.component
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material.CircularProgressIndicator
import androidx.compose.material.MaterialTheme
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.constraintlayout.compose.ConstraintLayout
@Composable
fun CircularIndeterminateProgressBar(isDisplayed: Boolean, verticalBias: Float) {
if (isDisplayed) {
ConstraintLayout(
modifier = Modifier.fillMaxSize()//.background(Color.Black.copy(alpha = 0.5f)),
) {
val (progressBar) = createRefs()
val topBias = createGuidelineFromTop(verticalBias)
CircularProgressIndicator(
modifier = Modifier.constrainAs(progressBar)
{
top.linkTo(topBias)
end.linkTo(parent.end)
start.linkTo(parent.start)
},
color = MaterialTheme.colors.primary
)
}
}
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/component/ProgressBar.kt | 1600787196 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.component
import androidx.compose.material.AlertDialog
import androidx.compose.material.Text
import androidx.compose.material.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
import androidx.navigation.NavController
import com.fsacchi.hilt_mvvm_compose_pokedex.R
import com.fsacchi.hilt_mvvm_compose_pokedex.navigation.Screen
import com.fsacchi.hilt_mvvm_compose_pokedex.navigation.currentRoute
@Composable
fun ExitAlertDialog(navController: NavController, cancel: (isOpen: Boolean) -> Unit, ok: () -> Unit) {
val openDialog = remember { mutableStateOf(true) }
if (currentRoute(navController = navController) == Screen.Home.route && openDialog.value) {
AlertDialog(
onDismissRequest = {
},
// below line is use to display title of our dialog
// box and we are setting text color to white.
title = {
Text(
text = stringResource(R.string.close_the_app),
fontWeight = FontWeight.Bold,
fontSize = 18.sp
)
},
text = {
Text(text = stringResource(R.string.do_you_want_to_exit_the_app), fontSize = 16.sp)
},
confirmButton = {
TextButton(
onClick = {
openDialog.value = false
ok()
}) {
Text(
stringResource(R.string.yes),
fontWeight = FontWeight.Bold,
style = TextStyle(color = Color.Black)
)
}
},
dismissButton = {
TextButton(
onClick = {
openDialog.value = false
cancel(false)
}) {
Text(
stringResource(R.string.no),
fontWeight = FontWeight.Bold,
style = TextStyle(color = Color.Black)
)
}
},
)
}
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/component/ExistAlertDiaglog.kt | 97284256 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.component.text
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.theme.subTitlePrimary
@Composable
fun SubtitlePrimary(text: String) {
Text(
text = text,
style = subTitlePrimary
)
}
| Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/component/text/SubtitlePrimary.kt | 2813304721 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.component.text
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.theme.subTitleSecondary
@Composable
fun SubtitleSecondary(text:String) {
Text(
text = text,
style = subTitleSecondary
)
}
| Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/component/text/SubtitleSecondary.kt | 2791869266 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.screens.drawer
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxHeight
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.Icon
import androidx.compose.material.Text
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.outlined.CatchingPokemon
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.navigation.NavController
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.ResultItem
import com.fsacchi.hilt_mvvm_compose_pokedex.navigation.Screen
import com.fsacchi.hilt_mvvm_compose_pokedex.utils.AppConstant
@Composable
fun DrawerUI(
navController: NavController,
types: List<ResultItem>,
closeDrawer: (typeName: String) -> Unit
) {
LazyColumn(
modifier = Modifier
.fillMaxHeight()
) {
items(items = types, itemContent = { item ->
DrawerItem(
item = item
) {
if (it.name == AppConstant.DEFAULT_TYPE_ITEM) {
navController.navigate(Screen.Home.route)
} else {
navController.navigate(Screen.NavigationDrawer.route.plus("/${it.name}")) {
launchSingleTop = true
}
}
// Close drawer
closeDrawer(it.name)
}
})
}
}
@Composable
fun DrawerItem(item: ResultItem, onItemClick: (ResultItem) -> Unit) {
Row(
verticalAlignment = Alignment.CenterVertically,
modifier = Modifier
.fillMaxWidth()
.clickable(onClick = { onItemClick(item) })
.height(45.dp)
.padding(start = 10.dp)
) {
Icon(
Icons.Outlined.CatchingPokemon, "", modifier = Modifier
.height(24.dp)
.width(24.dp)
)
Spacer(modifier = Modifier.width(7.dp))
Text(
text = item.name,
fontSize = 18.sp
)
}
}
| Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/screens/drawer/NavigationDrawer.kt | 3418974707 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.screens.mainscreen
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.mutableStateOf
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.TypesPokemon
import com.fsacchi.hilt_mvvm_compose_pokedex.data.repository.PokemonRepository
import com.fsacchi.hilt_mvvm_compose_pokedex.utils.network.DataState
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.onEach
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class MainViewModel @Inject constructor(private val repo: PokemonRepository) : ViewModel() {
val types: MutableState<DataState<TypesPokemon>?> = mutableStateOf(null)
fun typeList() {
viewModelScope.launch {
repo.typesList().onEach {
types.value = it
}.launchIn(viewModelScope)
}
}
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/screens/mainscreen/MainViewModel.kt | 2410373068 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.screens.mainscreen
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material.Scaffold
import androidx.compose.material.Snackbar
import androidx.compose.material.Text
import androidx.compose.material.rememberScaffoldState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.navigation.compose.rememberNavController
import com.fsacchi.hilt_mvvm_compose_pokedex.R
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.ResultItem
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.TypesPokemon
import com.fsacchi.hilt_mvvm_compose_pokedex.navigation.Navigation
import com.fsacchi.hilt_mvvm_compose_pokedex.navigation.Screen
import com.fsacchi.hilt_mvvm_compose_pokedex.navigation.currentRoute
import com.fsacchi.hilt_mvvm_compose_pokedex.navigation.navigationTitle
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.component.appbar.AppBarWithArrow
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.component.appbar.HomeAppBar
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.screens.drawer.DrawerUI
import com.fsacchi.hilt_mvvm_compose_pokedex.utils.AppConstant
import com.fsacchi.hilt_mvvm_compose_pokedex.utils.network.DataState
import com.fsacchi.hilt_mvvm_compose_pokedex.utils.networkconnection.ConnectionState
import com.fsacchi.hilt_mvvm_compose_pokedex.utils.networkconnection.connectivityState
import kotlinx.coroutines.launch
@Composable
fun MainScreen() {
val mainViewModel = hiltViewModel<MainViewModel>()
val navController = rememberNavController()
val scaffoldState = rememberScaffoldState()
val scope = rememberCoroutineScope()
val isAppBarVisible = remember { mutableStateOf(true) }
val searchProgressBar = remember { mutableStateOf(false) }
val genreName = remember { mutableStateOf("") }
val typesList = remember { mutableStateOf(arrayListOf<ResultItem>()) }
// internet connection
val connection by connectivityState()
val isConnected = connection === ConnectionState.Available
// faz chamar o endpoint de tipos ao criar a tela
LaunchedEffect(key1 = 0) {
mainViewModel.typeList()
}
if (mainViewModel.types.value is DataState.Success<TypesPokemon>) {
typesList.value =
(mainViewModel.types.value as DataState.Success<TypesPokemon>).data.types as ArrayList
// All first value as all
if (typesList.value.first().name != AppConstant.DEFAULT_TYPE_ITEM)
typesList.value.add(0, ResultItem(AppConstant.DEFAULT_TYPE_ITEM, ""))
}
Scaffold(scaffoldState = scaffoldState, topBar = {
when (currentRoute(navController)) {
Screen.Home.route, Screen.NavigationDrawer.route -> {
if (isAppBarVisible.value) {
val appTitle: String =
if (currentRoute(navController) == Screen.NavigationDrawer.route) genreName.value
else stringResource(R.string.app_title)
HomeAppBar(title = appTitle, openDrawer = {
scope.launch {
scaffoldState.drawerState.apply {
if (isClosed) open() else close()
}
}
}, openFilters = {
isAppBarVisible.value = false
})
}
}
else -> {
AppBarWithArrow(navigationTitle(navController)) {
navController.popBackStack()
}
}
}
}, drawerContent = {
// Drawer content
DrawerUI(navController, typesList.value as List<ResultItem>) {
genreName.value = it
scope.launch {
scaffoldState.drawerState.close()
}
}
}, snackbarHost = {
if (isConnected.not()) {
Snackbar(
action = {}, modifier = Modifier.padding(8.dp)
) {
Text(text = stringResource(R.string.there_is_no_internet))
}
}
}) {
Box(
modifier = Modifier.fillMaxWidth()
) {
Navigation(navController, Modifier.padding(it), typesList.value)
}
}
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/screens/mainscreen/MainScreen.kt | 3229638900 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.screens.types
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import androidx.paging.cachedIn
import com.fsacchi.hilt_mvvm_compose_pokedex.data.repository.PokemonRepository
import dagger.hilt.android.lifecycle.HiltViewModel
import javax.inject.Inject
@HiltViewModel
class TypePokemonsViewModel @Inject constructor(private val repo: PokemonRepository) : ViewModel() {
fun pokemonsByType(pokemonType: String) =
repo.pokemonPagingDataSource(pokemonType).cachedIn(viewModelScope)
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/screens/types/TypePokemonsViewModel.kt | 1508035545 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.screens.types
import androidx.compose.runtime.Composable
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.navigation.NavController
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.component.PokemonItemList
@Composable
fun TypePokemonScreen(
navController: NavController,
pokemonType: String
) {
val typePokemonsViewModel = hiltViewModel<TypePokemonsViewModel>()
PokemonItemList(
navController = navController,
pokemons = typePokemonsViewModel.pokemonsByType(pokemonType),
null,
null
){
}
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/screens/types/TypePokemonScreen.kt | 2821582405 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.screens.activity
import android.os.Bundle
import androidx.activity.compose.setContent
import androidx.activity.viewModels
import androidx.appcompat.app.AppCompatActivity
import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.screens.mainscreen.MainScreen
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.theme.HiltMVVMComposePokedexTheme
import dagger.hilt.android.AndroidEntryPoint
@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
private val splashViewModel: MainActivityViewModel by viewModels()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
installSplashScreen().apply {
setKeepOnScreenCondition { splashViewModel.isLoading.value }
}
setContent {
HiltMVVMComposePokedexTheme {
MainScreen()
}
}
}
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/screens/activity/MainActivity.kt | 1413012624 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.screens.activity
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class MainActivityViewModel @Inject constructor() : ViewModel() {
private val _isLoading = MutableStateFlow(true)
val isLoading get() = _isLoading.asStateFlow()
init {
viewModelScope.launch {
delay(500)
_isLoading.value = false
}
}
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/screens/activity/MainActivityViewModel.kt | 1883495374 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.screens.detail
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
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.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.hilt.navigation.compose.hiltViewModel
import coil.compose.AsyncImagePainter
import coil.compose.rememberAsyncImagePainter
import coil.decode.SvgDecoder
import coil.request.ImageRequest
import com.fsacchi.hilt_mvvm_compose_pokedex.R
import com.fsacchi.hilt_mvvm_compose_pokedex.data.datasource.remote.ApiURL
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.pokemondetail.PokemonDetail
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.pokemondetail.TypesPokemon
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.component.CircularIndeterminateProgressBar
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.component.text.SubtitlePrimary
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.component.text.SubtitleSecondary
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.theme.DefaultBackgroundColor
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.theme.FontColor
import com.fsacchi.hilt_mvvm_compose_pokedex.utils.network.DataState
import com.fsacchi.hilt_mvvm_compose_pokedex.utils.pagingLoadingState
import com.skydoves.landscapist.ImageOptions
import com.skydoves.landscapist.coil.CoilImage
@Composable
fun PokemonDetail(pokemonId: Int) {
val pokemonDetailViewModel = hiltViewModel<PokemonDetailViewModel>()
val progressBar = remember { mutableStateOf(false) }
val pokemonDetail = pokemonDetailViewModel.pokemonDetail
LaunchedEffect(true) {
pokemonDetailViewModel.pokemonDetailApi(pokemonId)
}
Column(
modifier = Modifier
.fillMaxSize()
.background(
DefaultBackgroundColor
)
) {
CircularIndeterminateProgressBar(isDisplayed = progressBar.value, 0.4f)
pokemonDetail.value?.let {
if (it is DataState.Success<PokemonDetail>) {
LazyColumn(
modifier = Modifier
.fillMaxSize()
) {
// Image Pokemon
item {
val painter = rememberAsyncImagePainter(
model = ImageRequest.Builder(LocalContext.current)
.decoderFactory(SvgDecoder.Factory())
.data(ApiURL.IMAGE_URL.plus(it.data.getNameImage()) )
.build()
)
Image(
modifier = Modifier
.fillMaxWidth()
.height(300.dp),
painter = painter,
contentDescription = null,
contentScale = ContentScale.Crop,
alignment = Alignment.Center,
)
when (painter.state) {
is AsyncImagePainter.State.Loading -> {
CircularIndeterminateProgressBar(isDisplayed = true, 0.6f)
}
else -> {}
}
}
// Stats Pokemon
item {
Column(
modifier = Modifier
.fillMaxSize()
.padding(start = 10.dp, end = 10.dp)
) {
Text(
text = it.data.name.replaceFirstChar { it.uppercase() },
modifier = Modifier.padding(top = 10.dp),
color = FontColor,
fontSize = 30.sp,
fontWeight = FontWeight.W700,
maxLines = 1,
overflow = TextOverflow.Ellipsis
)
Row(
modifier = Modifier
.fillMaxWidth()
.padding(bottom = 10.dp, top = 10.dp)
) {
Column(Modifier.weight(1f)) {
SubtitlePrimary(
text = "#${it.data.order}",
)
SubtitleSecondary(
text = stringResource(R.string.number)
)
}
Column(Modifier.weight(1f)) {
SubtitlePrimary(
text = "${it.data.baseExperience}",
)
SubtitleSecondary(
text = stringResource(R.string.base_experience)
)
}
Column(Modifier.weight(1f)) {
SubtitlePrimary(
text = it.data.getHeightFormatted(),
)
SubtitleSecondary(
text = stringResource(R.string.height)
)
}
Column(Modifier.weight(1f)) {
SubtitlePrimary(
text = it.data.getWeightFormatted(),
)
SubtitleSecondary(
text = stringResource(R.string.weight)
)
}
}
}
}
// Types Pokemon
item {
Text(
text = stringResource(R.string.types),
color = FontColor,
fontSize = 17.sp,
fontWeight = FontWeight.SemiBold,
modifier = Modifier.padding(top = 16.dp, start = 16.dp)
)
}
items(items = it.data.types) { type ->
PokemonType(type = type)
}
// Sprites
item {
Text(
text = stringResource(R.string.sprites),
color = FontColor,
fontSize = 17.sp,
fontWeight = FontWeight.SemiBold,
modifier = Modifier.padding(top = 16.dp, start = 16.dp)
)
it.data.sprites.apply {
PokemonSprite(urlFront = frontDefault, urlBack = backDefault)
PokemonSprite(urlFront = frontShiny, urlBack = frontShiny)
}
}
}
}
}
pokemonDetail.pagingLoadingState {
progressBar.value = it
}
}
}
@Preview(name = "PokemonDetail", showBackground = true)
@Composable
fun Preview() {
PokemonDetail(1)
}
@Composable
fun PokemonType(type: TypesPokemon) {
Row(modifier = Modifier.padding(top = 16.dp, start = 16.dp)) {
CoilImage(
modifier = Modifier
.height(30.dp)
.width(30.dp),
imageModel = { ApiURL.IMAGE_URL_TYPE.plus("${type.type.name}.png") },
imageOptions = ImageOptions(
contentScale = ContentScale.Fit,
alignment = Alignment.Center,
contentDescription = "",
colorFilter = null,
)
)
Text(
text = type.type.name.replaceFirstChar { firstChar -> firstChar.uppercase() },
color = FontColor,
fontSize = 14.sp,
fontWeight = FontWeight.Normal,
modifier = Modifier.padding(8.dp)
)
}
}
@Composable
fun PokemonSprite(urlFront: String, urlBack: String) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(bottom = 20.dp, top = 10.dp)
) {
Column(modifier = Modifier.weight(1f)) {
PokemonSpriteImage(urlFront)
}
Column(modifier = Modifier.weight(1f)) {
PokemonSpriteImage(urlBack)
}
}
}
@Composable
fun PokemonSpriteImage(url: String) {
val painterSprite = rememberAsyncImagePainter(
model = ImageRequest.Builder(LocalContext.current)
.data(url)
.build()
)
Image(
modifier = Modifier
.fillMaxWidth()
.height(150.dp),
painter = painterSprite,
contentDescription = null,
contentScale = ContentScale.Fit,
alignment = Alignment.Center,
)
when (painterSprite.state) {
is AsyncImagePainter.State.Loading -> {
CircularIndeterminateProgressBar(isDisplayed = true, 0.6f)
}
else -> {}
}
}
| Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/screens/detail/PokemonDetail.kt | 1546142663 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.screens.detail
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.mutableStateOf
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.pokemondetail.PokemonDetail
import com.fsacchi.hilt_mvvm_compose_pokedex.data.repository.PokemonRepository
import com.fsacchi.hilt_mvvm_compose_pokedex.utils.network.DataState
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.onEach
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class PokemonDetailViewModel @Inject constructor(private val repo: PokemonRepository) : ViewModel() {
val pokemonDetail: MutableState<DataState<PokemonDetail>?> = mutableStateOf(null)
fun pokemonDetailApi(pokemonId: Int) {
viewModelScope.launch {
repo.pokemonDetail(pokemonId).onEach {
pokemonDetail.value = it
}.launchIn(viewModelScope)
}
}
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/screens/detail/PokemonDetailViewModel.kt | 3864228508 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.screens.bottomnavigation.pokemon
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.mutableStateOf
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import androidx.paging.cachedIn
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.ResultItem
import com.fsacchi.hilt_mvvm_compose_pokedex.data.repository.PokemonRepository
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.flatMapLatest
import javax.inject.Inject
@HiltViewModel
class AllPokemonViewModel @Inject constructor(val repo: PokemonRepository) : ViewModel() {
var selectedType: MutableState<ResultItem> =
mutableStateOf(ResultItem("", ""))
val filterData = MutableStateFlow<String?>(null)
@OptIn(ExperimentalCoroutinesApi::class)
val allPokemons = filterData.flatMapLatest {
repo.pokemonPagingDataSource(it)
}.cachedIn(viewModelScope)
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/screens/bottomnavigation/pokemon/AllPokemonViewModel.kt | 3574455829 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.screens.bottomnavigation.pokemon
import androidx.compose.runtime.Composable
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.navigation.NavController
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.ResultItem
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.component.PokemonItemList
@Composable
fun AllPokemon(
navController: NavController,
types: ArrayList<ResultItem>? = null,
) {
val allPokemonViewModel = hiltViewModel<AllPokemonViewModel>()
PokemonItemList(
navController = navController,
pokemons = allPokemonViewModel.allPokemons,
types = types,
selectedName = allPokemonViewModel.selectedType.value
){
allPokemonViewModel.filterData.value = it?.name
it?.let {
allPokemonViewModel.selectedType.value = it
}
}
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/screens/bottomnavigation/pokemon/AllPokemon.kt | 2927897175 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.theme
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.Shapes
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.unit.dp
val Shapes = Shapes(
small = RoundedCornerShape(4.dp),
medium = RoundedCornerShape(4.dp),
large = RoundedCornerShape(0.dp)
)
fun Modifier.cornerRadius(radius: Int) =
graphicsLayer(shape = RoundedCornerShape(radius.dp), clip = true) | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/theme/Shape.kt | 3041517742 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.theme
import androidx.compose.ui.graphics.Color
val Teal200 = Color(0xffA5BCF3)
val FontColor = Color(0xFF212121)
val SecondaryFontColor = Color(0xFF757575)
val DefaultBackgroundColor = Color(0xFFFAFAFA)
val LinkColor = Color(0xff64B5F6)
val PokedexColor = Color(0xfff91f1f)
val PokedexVariantColor = Color(0xfffe4d4d)
val PokedexLight = Color(0xffffb3b3) | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/theme/Color.kt | 1308654534 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.theme
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material.MaterialTheme
import androidx.compose.material.darkColors
import androidx.compose.material.lightColors
import androidx.compose.runtime.Composable
private val DarkColorPalette = darkColors(
primary = PokedexColor,
primaryVariant = PokedexVariantColor,
secondary = Teal200
)
private val LightColorPalette = lightColors(
primary = PokedexColor,
primaryVariant = PokedexVariantColor,
secondary = Teal200
/* Other default colors to override
background = Color.White,
surface = Color.White,
onPrimary = Color.White,
onSecondary = Color.Black,
onBackground = Color.Black,
onSurface = Color.Black,
*/
)
@Composable
fun HiltMVVMComposePokedexTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
content: @Composable() () -> Unit
) {
val colors = if (darkTheme) {
DarkColorPalette
} else {
LightColorPalette
}
MaterialTheme(
colors = colors,
typography = Typography,
shapes = Shapes,
content = content
)
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/theme/Theme.kt | 2704755707 |
package com.fsacchi.hilt_mvvm_compose_pokedex.ui.theme
import androidx.compose.material.Typography
import androidx.compose.runtime.Composable
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(
body1 = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 16.sp
),
button = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.W500,
fontSize = 14.sp
),
caption = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 12.sp
)
)
val subTitlePrimary: TextStyle
@Composable
get() {
return TextStyle(
fontFamily = FontFamily.Default,
color = FontColor,
fontSize = 14.sp,
fontWeight = FontWeight.Medium
)
}
val subTitleSecondary: TextStyle
@Composable
get() {
return TextStyle(
fontFamily = FontFamily.Default,
color = SecondaryFontColor,
fontSize = 12.sp,
)
}
val Typography.bioGrapyText: TextStyle
@Composable
get() {
return TextStyle(
fontFamily = FontFamily.Default,
color = SecondaryFontColor,
fontSize = 14.sp,
)
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/ui/theme/Type.kt | 1534336979 |
package com.fsacchi.hilt_mvvm_compose_pokedex.di
import com.fsacchi.hilt_mvvm_compose_pokedex.data.datasource.remote.ApiService
import com.fsacchi.hilt_mvvm_compose_pokedex.data.datasource.remote.ApiURL
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Converter
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import java.util.concurrent.TimeUnit
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {
/**
* Provides BaseUrl as string
*/
@Singleton
@Provides
fun provideBaseURL(): String {
return ApiURL.BASE_URL
}
/**
* Provides LoggingInterceptor for api information
*/
@Singleton
@Provides
fun provideLoggingInterceptor(): HttpLoggingInterceptor {
return HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY)
}
/**
* Provides custom OkkHttp
*/
@Singleton
@Provides
fun provideOkHttpClient(loggingInterceptor: HttpLoggingInterceptor): OkHttpClient {
val okHttpClient = OkHttpClient().newBuilder()
okHttpClient.callTimeout(40, TimeUnit.SECONDS)
okHttpClient.connectTimeout(40, TimeUnit.SECONDS)
okHttpClient.readTimeout(40, TimeUnit.SECONDS)
okHttpClient.writeTimeout(40, TimeUnit.SECONDS)
okHttpClient.addInterceptor(loggingInterceptor)
okHttpClient.build()
return okHttpClient.build()
}
/**
* Provides converter factory for retrofit
*/
@Singleton
@Provides
fun provideConverterFactory(): Converter.Factory {
return GsonConverterFactory.create()
}
/**
* Provides ApiServices client for Retrofit
*/
@Singleton
@Provides
fun provideRetrofitClient(
baseUrl: String,
okHttpClient: OkHttpClient,
converterFactory: Converter.Factory
): Retrofit {
return Retrofit.Builder()
.baseUrl(baseUrl)
.client(okHttpClient)
.addConverterFactory(converterFactory)
.build()
}
/**
* Provides Api Service using retrofit
*/
@Singleton
@Provides
fun provideRestApiService(retrofit: Retrofit): ApiService {
return retrofit.create(ApiService::class.java)
}
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/di/NetworkModule.kt | 576755238 |
package com.fsacchi.hilt_mvvm_compose_pokedex.di
import com.fsacchi.hilt_mvvm_compose_pokedex.data.datasource.remote.ApiService
import com.fsacchi.hilt_mvvm_compose_pokedex.data.repository.PokemonRepository
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
object RepositoryModule {
/**
* Provides RemoteDataRepository for access api service method
*/
@Singleton
@Provides
fun providePokemonRepository(
apiService: ApiService,
): PokemonRepository {
return PokemonRepository(
apiService
)
}
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/di/RepositoryModule.kt | 437464584 |
package com.fsacchi.hilt_mvvm_compose_pokedex
import androidx.multidex.MultiDexApplication
import dagger.hilt.android.HiltAndroidApp
import timber.log.Timber
@HiltAndroidApp
class HiltApplication : MultiDexApplication() {
override fun onCreate() {
super.onCreate()
if (BuildConfig.DEBUG) {
Timber.plant(Timber.DebugTree())
}
}
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/HiltApplication.kt | 2679666372 |
package com.fsacchi.hilt_mvvm_compose_pokedex.navigation
sealed class Screen(
val route: String,
val objectName: String = "",
val objectPath: String = ""
) {
object Home : Screen("home_screen")
object NavigationDrawer :
Screen("navigation_drawer", objectName = "typeId", objectPath = "/{typeId}")
object PokemonDetail :
Screen("pokemon_detail_screen", objectName = "pokemonItem", objectPath = "/{pokemonItem}")
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/navigation/NavigationScreen.kt | 3253850590 |
package com.fsacchi.hilt_mvvm_compose_pokedex.navigation
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import androidx.navigation.NavController
import androidx.navigation.NavHostController
import androidx.navigation.NavType
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.currentBackStackEntryAsState
import androidx.navigation.navArgument
import com.fsacchi.hilt_mvvm_compose_pokedex.R
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.ResultItem
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.screens.bottomnavigation.pokemon.AllPokemon
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.screens.detail.PokemonDetail
import com.fsacchi.hilt_mvvm_compose_pokedex.ui.screens.types.TypePokemonScreen
@Composable
fun Navigation(
navController: NavHostController, modifier: Modifier, types: ArrayList<ResultItem>? = null,
) {
NavHost(navController, startDestination = Screen.Home.route, modifier) {
composable(Screen.Home.route) {
AllPokemon(
navController = navController,
types
)
}
composable(
Screen.NavigationDrawer.route.plus(Screen.NavigationDrawer.objectPath),
arguments = listOf(navArgument(Screen.NavigationDrawer.objectName) {
type = NavType.StringType
})
) { backStack ->
val typeId = backStack.arguments?.getString(Screen.NavigationDrawer.objectName)
typeId?.let {
TypePokemonScreen(
navController = navController, typeId
)
}
}
composable(
Screen.PokemonDetail.route.plus(Screen.PokemonDetail.objectPath),
arguments = listOf(navArgument(Screen.PokemonDetail.objectName) {
type = NavType.IntType
})
) {
label = stringResource(R.string.pokemon_detail)
val pokemonId = it.arguments?.getInt(Screen.PokemonDetail.objectName)
pokemonId?.let {
PokemonDetail(pokemonId)
}
}
}
}
@Composable
fun navigationTitle(navController: NavController): String {
return when (currentRoute(navController)) {
Screen.PokemonDetail.route -> stringResource(id = R.string.pokemon_detail)
else -> {
""
}
}
}
@Composable
fun currentRoute(navController: NavController): String? {
val navBackStackEntry by navController.currentBackStackEntryAsState()
return navBackStackEntry?.destination?.route?.substringBeforeLast("/")
}
| Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/navigation/NavGraph.kt | 307213135 |
package com.fsacchi.hilt_mvvm_compose_pokedex.utils
object AppConstant {
const val MINIMIZED_MAX_LINES = 2
const val DEFAULT_TYPE_ITEM = "All"
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/utils/AppConstant.kt | 1545205954 |
package com.fsacchi.hilt_mvvm_compose_pokedex.utils.network
/**
* Data state for processing api response Loading, Success and Error
*/
sealed class DataState<out R> {
data class Success<out T>(val data: T) : DataState<T>()
data class Error(val exception: Exception) : DataState<Nothing>()
object Loading : DataState<Nothing>()
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/utils/network/DataState.kt | 686098713 |
package com.fsacchi.hilt_mvvm_compose_pokedex.utils.networkconnection
import android.content.Context
import android.net.ConnectivityManager
import android.net.Network
import android.net.NetworkCapabilities
import android.net.NetworkRequest
import androidx.compose.runtime.Composable
import androidx.compose.runtime.State
import androidx.compose.runtime.produceState
import androidx.compose.ui.platform.LocalContext
import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.flow.callbackFlow
/**
* Network utility to get current state of internet connection
*/
val Context.currentConnectivityState: ConnectionState
get() {
val connectivityManager =
getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
return getCurrentConnectivityState(connectivityManager)
}
private fun getCurrentConnectivityState(
connectivityManager: ConnectivityManager
): ConnectionState {
val connected = connectivityManager.allNetworks.any { network ->
connectivityManager.getNetworkCapabilities(network)
?.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
?: false
}
return if (connected) ConnectionState.Available else ConnectionState.Unavailable
}
fun Context.observeConnectivityAsFlow() = callbackFlow {
val connectivityManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
val callback = networkCallback { connectionState -> trySend(connectionState) }
val networkRequest = NetworkRequest.Builder()
.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
.build()
connectivityManager.registerNetworkCallback(networkRequest, callback)
// Set current state
val currentState = getCurrentConnectivityState(connectivityManager)
trySend(currentState)
// Remove callback when not used
awaitClose {
// Remove listeners
connectivityManager.unregisterNetworkCallback(callback)
}
}
fun networkCallback(callback: (ConnectionState) -> Unit): ConnectivityManager.NetworkCallback {
return object : ConnectivityManager.NetworkCallback() {
override fun onAvailable(network: Network) {
callback(ConnectionState.Available)
}
override fun onLost(network: Network) {
callback(ConnectionState.Unavailable)
}
}
}
@Composable
fun connectivityState(): State<ConnectionState> {
val context = LocalContext.current
// Creates a State<ConnectionState> with current connectivity state as initial value
return produceState(initialValue = context.currentConnectivityState) {
// In a coroutine, can make suspend calls
context.observeConnectivityAsFlow().collect {
value = it
}
}
}
/*
@Composable
fun ConnectivityStatus() {
// This will cause re-composition on every network state change
val connection by connectivityState()
val isConnected = connection === ConnectionState.Available
if (isConnected) {
// Show UI when connectivity is available
} else {
// Show UI for No Internet Connectivity
}
}*/
| Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/utils/networkconnection/NetworkConnection.kt | 1287811820 |
package com.fsacchi.hilt_mvvm_compose_pokedex.utils.networkconnection
sealed class ConnectionState {
object Available : ConnectionState()
object Unavailable : ConnectionState()
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/utils/networkconnection/ConnectionState.kt | 442717426 |
package com.fsacchi.hilt_mvvm_compose_pokedex.utils
import androidx.compose.foundation.lazy.grid.LazyGridItemScope
import androidx.compose.foundation.lazy.grid.LazyGridScope
import androidx.compose.runtime.Composable
import androidx.compose.runtime.MutableState
import androidx.compose.ui.Modifier
import androidx.paging.LoadState
import androidx.paging.compose.LazyPagingItems
import com.fsacchi.hilt_mvvm_compose_pokedex.utils.network.DataState
fun <T : Any> LazyGridScope.items(
lazyPagingItems: LazyPagingItems<T>,
itemContent: @Composable LazyGridItemScope.(value: T?) -> Unit
) {
items(lazyPagingItems.itemCount) { index ->
itemContent(lazyPagingItems[index])
}
}
@Composable
fun <T : Any> LazyPagingItems<T>.pagingLoadingState(
isLoaded: (pagingState: Boolean) -> Unit,
) {
this.apply {
when {
// data is loading for first time
loadState.refresh is LoadState.Loading -> {
isLoaded(true)
}
// data is loading for second time or pagination
loadState.append is LoadState.Loading -> {
isLoaded(true)
}
loadState.refresh is LoadState.NotLoading -> {
isLoaded(false)
}
loadState.append is LoadState.NotLoading -> {
isLoaded(false)
}
}
}
}
fun <T : Any> MutableState<DataState<T>?>.pagingLoadingState(isLoaded: (pagingState: Boolean) -> Unit) {
when (this.value) {
is DataState.Success<T> -> {
isLoaded(false)
}
is DataState.Loading -> {
isLoaded(true)
}
is DataState.Error -> {
isLoaded(false)
}
else -> {
}
}
}
fun Modifier.conditional(condition : Boolean, modifier : Modifier.() -> Modifier) : Modifier {
return if (condition) {
then(modifier(Modifier))
} else {
this
}
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/utils/ComposableExtension.kt | 411962526 |
package com.fsacchi.hilt_mvvm_compose_pokedex.data.datasource.remote
object ApiURL {
const val BASE_URL = "https://pokeapi.co/api/v2/"
const val IMAGE_URL = "https://unpkg.com/[email protected]/sprites/pokemon/other/dream-world/"
const val IMAGE_URL_TYPE = "https://raw.githubusercontent.com/msikma/pokesprite/master/misc/types/masters/"
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/data/datasource/remote/ApiURL.kt | 1537956240 |
package com.fsacchi.hilt_mvvm_compose_pokedex.data.datasource.remote.paging
import androidx.paging.PagingSource
import androidx.paging.PagingState
import com.fsacchi.hilt_mvvm_compose_pokedex.data.datasource.remote.ApiService
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.ResultItem
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.toResultModel
import com.fsacchi.hilt_mvvm_compose_pokedex.utils.AppConstant
import retrofit2.HttpException
import timber.log.Timber
import java.io.IOException
import javax.inject.Inject
class PokemonsPagingDataSource @Inject constructor(private val apiService: ApiService, private val typePokemon:String?) :
PagingSource<Int, ResultItem>() {
override fun getRefreshKey(state: PagingState<Int, ResultItem>): Int? {
return state.anchorPosition
}
override suspend fun load(params: LoadParams<Int>): LoadResult<Int, ResultItem> {
return try {
// Pesquisa global
if (typePokemon.isNullOrBlank() || typePokemon == AppConstant.DEFAULT_TYPE_ITEM) {
val nextPage = params.key ?: 1
val offset = if (nextPage > 1) nextPage else 0
val pokemonList = apiService.pokemons(offset = (offset * 20))
LoadResult.Page(
data = pokemonList.results,
prevKey = if (nextPage == 1) null else nextPage - 1,
nextKey = if (pokemonList.results.isNotEmpty()) nextPage + 1 else null
)
} else {
//Pesquisa por Tipo
val pokemonList = apiService.pokemonsByType(typePokemon)
LoadResult.Page(
data = pokemonList.toResultModel(),
prevKey = null,
nextKey = null
)
}
} catch (exception: IOException) {
Timber.e("exception ${exception.message}")
return LoadResult.Error(exception)
} catch (httpException: HttpException) {
Timber.e("httpException ${httpException.message}")
return LoadResult.Error(httpException)
}
}
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/data/datasource/remote/paging/PokemonsPagingDataSource.kt | 880275389 |
package com.fsacchi.hilt_mvvm_compose_pokedex.data.datasource.remote
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.PokemonsByTypeModel
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.ResultModel
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.pokemondetail.PokemonDetail
import retrofit2.http.GET
import retrofit2.http.Path
import retrofit2.http.Query
interface ApiService {
@GET("pokemon")
suspend fun pokemons(
@Query("limit") limit: Int = 20,
@Query("offset") offset: Int
): ResultModel
@GET("type")
suspend fun typeList(): ResultModel
@GET("type/{idType}")
suspend fun pokemonsByType(
@Path("idType") idType: String
): PokemonsByTypeModel
@GET("pokemon/{pokemonId}")
suspend fun pokemonDetail(
@Path("pokemonId") pokemonId: Int
): PokemonDetail
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/data/datasource/remote/ApiService.kt | 133419856 |
package com.fsacchi.hilt_mvvm_compose_pokedex.data.repository
import androidx.paging.PagingData
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.ResultItem
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.TypesPokemon
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.pokemondetail.PokemonDetail
import com.fsacchi.hilt_mvvm_compose_pokedex.utils.network.DataState
import kotlinx.coroutines.flow.Flow
interface PokemonRepositoryInterface {
suspend fun pokemonDetail(pokemonId: Int): Flow<DataState<PokemonDetail>>
suspend fun typesList(): Flow<DataState<TypesPokemon>>
fun pokemonPagingDataSource(typesPokemon: String?): Flow<PagingData<ResultItem>>
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/data/repository/PokemonRepositoryInterface.kt | 2266564624 |
package com.fsacchi.hilt_mvvm_compose_pokedex.data.repository
import androidx.paging.Pager
import androidx.paging.PagingConfig
import androidx.paging.PagingData
import com.fsacchi.hilt_mvvm_compose_pokedex.data.datasource.remote.ApiService
import com.fsacchi.hilt_mvvm_compose_pokedex.data.datasource.remote.paging.PokemonsPagingDataSource
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.ResultItem
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.TypesPokemon
import com.fsacchi.hilt_mvvm_compose_pokedex.data.model.pokemondetail.PokemonDetail
import com.fsacchi.hilt_mvvm_compose_pokedex.utils.network.DataState
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import javax.inject.Inject
class PokemonRepository @Inject constructor(
private val apiService: ApiService
) : PokemonRepositoryInterface {
override suspend fun pokemonDetail(pokemonId: Int): Flow<DataState<PokemonDetail>> = flow {
emit(DataState.Loading)
try {
val searchResult = apiService.pokemonDetail(pokemonId)
emit(DataState.Success(searchResult))
} catch (e: Exception) {
emit(DataState.Error(e))
}
}
override suspend fun typesList(): Flow<DataState<TypesPokemon>> = flow {
emit(DataState.Loading)
try {
val genreResult = apiService.typeList()
emit(DataState.Success(TypesPokemon(genreResult.results)))
} catch (e: Exception) {
emit(DataState.Error(e))
}
}
override fun pokemonPagingDataSource(typesPokemon: String?): Flow<PagingData<ResultItem>> = Pager(
pagingSourceFactory = { PokemonsPagingDataSource(apiService, typesPokemon) },
config = PagingConfig(pageSize = 1)
).flow
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/data/repository/PokemonRepository.kt | 1468234028 |
package com.fsacchi.hilt_mvvm_compose_pokedex.data.model
import com.google.gson.annotations.SerializedName
data class PokemonsByTypeModel(
@SerializedName("pokemon")
val pokemon: List<PokemonsType>
)
fun PokemonsByTypeModel.toResultModel(): List<ResultItem> {
val listResults = mutableListOf<ResultItem>()
pokemon.forEach {
listResults.add(ResultItem(
name = it.pokemon.name,
url = it.pokemon.url
))
}
return listResults
}
data class PokemonsType(
val pokemon: Pokemon
)
data class Pokemon(
@SerializedName("name")
val name: String,
@SerializedName("url")
val url: String
)
| Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/data/model/PokemonsByTypeModel.kt | 521389250 |
package com.fsacchi.hilt_mvvm_compose_pokedex.data.model
import com.google.gson.annotations.SerializedName
data class ResultModel(
@SerializedName("count")
val count: Int,
@SerializedName("results")
val results: List<ResultItem>
)
| Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/data/model/ResultModel.kt | 1105205684 |
package com.fsacchi.hilt_mvvm_compose_pokedex.data.model
data class TypesPokemon(val types: List<ResultItem>) | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/data/model/TypesPokemon.kt | 3633237409 |
package com.fsacchi.hilt_mvvm_compose_pokedex.data.model.pokemondetail
import com.google.gson.annotations.SerializedName
data class PokemonDetail(
val id: Int,
val name: String,
val order: Int,
@SerializedName("base_experience")
val baseExperience: Int,
val weight: Int,
val height: Int,
val types: List<TypesPokemon>,
val sprites: SpritesPokemon
) {
fun getNameImage(): String = "${id}.svg"
fun getHeightFormatted() = "${height / 10},${height % 10} m"
fun getWeightFormatted() = "${weight / 10},${weight % 10} kg"
}
data class TypesPokemon(
val slot: Int,
val type: TypePokemon
)
data class TypePokemon(
val name: String
)
data class SpritesPokemon(
@SerializedName("front_default")
val frontDefault: String,
@SerializedName("back_default")
val backDefault: String,
@SerializedName("front_shiny")
val frontShiny: String,
@SerializedName("back_shiny")
val backShiny: String,
) | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/data/model/pokemondetail/PokemonDetail.kt | 3024434030 |
package com.fsacchi.hilt_mvvm_compose_pokedex.data.model
import com.google.gson.annotations.SerializedName
data class ResultItem(
@SerializedName("name")
val name: String,
@SerializedName("url")
val url: String
) {
fun getNameItem(): String {
val splits = url.split("/").filter { it.isNotEmpty() }
return splits.last()
}
fun getNameImage(): String = "${getNameItem()}.svg"
} | Hilt-MVVM-Compose-Pokedex/app/src/main/java/com/fsacchi/hilt_mvvm_compose_pokedex/data/model/ResultItem.kt | 1505857842 |
package com.orangeink.taskstodocompose
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.orangeink.taskstodocompose", appContext.packageName)
}
} | tasks-todo-compose/app/src/androidTest/java/com/orangeink/taskstodocompose/ExampleInstrumentedTest.kt | 3149383497 |
package com.orangeink.taskstodocompose
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} | tasks-todo-compose/app/src/test/java/com/orangeink/taskstodocompose/ExampleUnitTest.kt | 1023360459 |
package com.orangeink.taskstodocompose.ui.tasks
import com.orangeink.taskstodocompose.data.db.entity.Task
data class TasksState(
val tasks: List<Task> = emptyList(),
val sortType: SortType = SortType.Date
)
enum class SortType {
Date, Completion
}
| tasks-todo-compose/app/src/main/java/com/orangeink/taskstodocompose/ui/tasks/TaskState.kt | 2811509902 |
package com.orangeink.taskstodocompose.ui.tasks
import androidx.compose.animation.animateContentSize
import androidx.compose.foundation.ExperimentalFoundationApi
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.rememberLazyListState
import androidx.compose.material3.Checkbox
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.FloatingActionButton
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.LocalMinimumInteractiveComponentEnforcement
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.orangeink.taskstodocompose.R
import com.orangeink.taskstodocompose.data.db.entity.Task
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Locale
@OptIn(ExperimentalFoundationApi::class)
@Composable
fun TasksScreen(
tasksState: TasksState,
onSortClick: (() -> Unit)? = null,
onSaveTask: ((Task) -> Unit)? = null,
onUpdateTask: ((Task) -> Unit)? = null,
onDeleteCompletedTasks: (() -> Unit)? = null
) {
val lazyColumnState = rememberLazyListState()
var showSheet by remember { mutableStateOf(false) }
var selectedTask by remember { mutableStateOf<Task?>(null) }
Scaffold(
topBar = {
Row(
modifier = Modifier.padding(start = 16.dp, top = 32.dp, bottom = 12.dp),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Text(
text = "Tasks",
fontSize = 30.sp,
fontWeight = FontWeight.Medium,
modifier = Modifier.weight(1f)
)
IconButton(onClick = { onSortClick?.invoke() }) {
Icon(
painter = painterResource(
id = when (tasksState.sortType) {
SortType.Date -> R.drawable.round_calendar_month_24
SortType.Completion -> R.drawable.round_check_circle_24
}
),
contentDescription = "sort-tasks"
)
}
if (tasksState.tasks.any { it.completed }) {
IconButton(onClick = { onDeleteCompletedTasks?.invoke() }) {
Icon(
painter = painterResource(
id = R.drawable.round_delete_outline_24
),
tint = MaterialTheme.colorScheme.error,
contentDescription = "sort-tasks"
)
}
}
}
},
floatingActionButton = {
FloatingActionButton(onClick = { showSheet = true }) {
Icon(
painter = painterResource(R.drawable.round_add_24),
contentDescription = "add-task"
)
}
}
) {
if (showSheet) {
TaskBottomSheet(
selectedTask,
onDismiss = {
showSheet = false
selectedTask = null
},
onSaveTask = onSaveTask,
onUpdateTask = onUpdateTask
)
}
LazyColumn(
modifier = Modifier.padding(it),
contentPadding = PaddingValues(vertical = 8.dp),
state = lazyColumnState,
) {
items(
count = tasksState.tasks.size,
key = { index ->
tasksState.tasks[index]
}
) { index ->
TaskItem(
modifier = Modifier
.animateItemPlacement()
.animateContentSize(),
task = tasksState.tasks[index],
onTaskCompleted = onUpdateTask
) { task ->
selectedTask = task
showSheet = true
}
}
}
}
}
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun TaskItem(
modifier: Modifier = Modifier,
task: Task,
onTaskCompleted: ((Task) -> Unit)? = null,
onTaskUpdate: ((Task) -> Unit)? = null
) {
var completed by remember { mutableStateOf(task.completed) }
Row(
modifier = modifier
.clickable { onTaskUpdate?.invoke(task) }
.fillMaxWidth()
.padding(horizontal = 16.dp, vertical = 8.dp)
) {
CompositionLocalProvider(LocalMinimumInteractiveComponentEnforcement provides false) {
Checkbox(checked = completed, onCheckedChange = {
completed = it
onTaskCompleted?.invoke(task.copy(completed = it))
})
}
Spacer(modifier = Modifier.width(8.dp))
Column(
verticalArrangement = Arrangement.Center,
) {
Text(
text = task.title,
fontSize = 18.sp,
maxLines = 3,
overflow = TextOverflow.Ellipsis
)
task.dueDate?.let { date ->
Spacer(modifier = Modifier.height(2.dp))
Text(
text = SimpleDateFormat("dd/MM/yyyy", Locale.getDefault())
.format(date)
.uppercase(),
fontSize = 14.sp,
color = Color.Gray
)
}
}
}
}
@Preview(showBackground = true)
@Composable
fun TasksScreenPreview() {
TasksScreen(
TasksState(
listOf(
Task("Pay all the electric bills", Date(), id = 0),
Task("Complete all college assignments", id = 1),
Task("Bake Bread", id = 2),
Task("Give Clothes to charity", id = 3),
Task("Watch movies", Date(), id = 4)
)
)
)
}
@Preview(showBackground = true)
@Composable
fun TaskItemPreview() {
TaskItem(task = Task("Pay all the electric bills", Date()))
} | tasks-todo-compose/app/src/main/java/com/orangeink/taskstodocompose/ui/tasks/TasksScreen.kt | 1644274573 |
package com.orangeink.taskstodocompose.ui.tasks
import androidx.compose.foundation.ExperimentalFoundationApi
import androidx.compose.foundation.border
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.WindowInsets
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.ime
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text2.BasicTextField2
import androidx.compose.foundation.text2.input.rememberTextFieldState
import androidx.compose.material3.Checkbox
import androidx.compose.material3.DatePicker
import androidx.compose.material3.DatePickerDialog
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.LocalMinimumInteractiveComponentEnforcement
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.ModalBottomSheet
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.material3.rememberDatePickerState
import androidx.compose.material3.rememberModalBottomSheetState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.focus.FocusRequester
import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.SolidColor
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.orangeink.taskstodocompose.R
import com.orangeink.taskstodocompose.data.db.entity.Task
import kotlinx.coroutines.launch
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Locale
@OptIn(ExperimentalMaterial3Api::class, ExperimentalFoundationApi::class)
@Composable
fun TaskBottomSheet(
task: Task? = null,
onDismiss: () -> Unit,
onSaveTask: ((Task) -> Unit)? = null,
onUpdateTask: ((Task) -> Unit)? = null
) {
val scope = rememberCoroutineScope()
val modalBottomSheetState = rememberModalBottomSheetState()
val focusRequester = remember { FocusRequester() }
val textFieldState = rememberTextFieldState(initialText = task?.title ?: "")
var openDatePicker by remember { mutableStateOf(false) }
var dueDate by remember { mutableStateOf(task?.dueDate) }
ModalBottomSheet(
onDismissRequest = onDismiss,
sheetState = modalBottomSheetState,
shape = RoundedCornerShape(topStart = 10.dp, topEnd = 10.dp),
dragHandle = null,
contentColor = MaterialTheme.colorScheme.onSurface,
windowInsets = WindowInsets.ime
) {
var completed by remember { mutableStateOf(task?.completed ?: false) }
Row(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 16.dp)
.padding(top = 24.dp)
) {
CompositionLocalProvider(LocalMinimumInteractiveComponentEnforcement provides false) {
Checkbox(checked = completed, onCheckedChange = {
completed = it
})
}
Spacer(modifier = Modifier.width(8.dp))
Column(verticalArrangement = Arrangement.Center) {
BasicTextField2(
state = textFieldState,
modifier = Modifier
.fillMaxWidth()
.focusRequester(focusRequester),
textStyle = TextStyle(
color = MaterialTheme.colorScheme.onSurface,
fontSize = 18.sp
),
cursorBrush = SolidColor(MaterialTheme.colorScheme.onSurface),
decorator = { innerTextField ->
Row(
modifier = Modifier.fillMaxWidth(),
verticalAlignment = Alignment.CenterVertically
) {
if (textFieldState.text.isEmpty()) {
Text(
text = "Eg. pay all bills",
color = Color.Gray,
fontSize = 18.sp
)
}
}
innerTextField()
}
)
}
}
HorizontalDivider(
thickness = Dp.Hairline,
color = Color.Gray,
modifier = Modifier.padding(top = 16.dp)
)
Row(
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically,
modifier = Modifier.padding(start = 16.dp)
) {
Text(
text = dueDate?.let {
SimpleDateFormat(
"dd/MM/yyyy",
Locale.getDefault()
).format(it)
} ?: "Due",
color = Color.Gray,
fontSize = 12.sp,
modifier = Modifier
.border(
width = 0.8.dp,
shape = RoundedCornerShape(6.dp),
color = Color.Gray
)
.clickable { openDatePicker = true }
.padding(horizontal = 8.dp)
)
Spacer(modifier = Modifier.weight(1f))
IconButton(
onClick = {
task?.let {
onUpdateTask?.invoke(
Task(
textFieldState.text.toString(),
dueDate,
completed,
id = it.id
)
)
} ?: onSaveTask?.invoke(
Task(
textFieldState.text.toString(),
dueDate,
completed
)
)
scope.launch { modalBottomSheetState.hide() }.invokeOnCompletion {
if (!modalBottomSheetState.isVisible) {
onDismiss.invoke()
}
}
},
enabled = textFieldState.text.isNotEmpty()
) {
Icon(
painter = painterResource(id = task?.let { R.drawable.round_save_24 }
?: R.drawable.round_add_circle_24),
contentDescription = "save-task"
)
}
}
}
DueDatePicker(openDatePicker = openDatePicker) { selectedDate ->
dueDate = selectedDate?.let { Date(it) }
openDatePicker = false
}
LaunchedEffect(modalBottomSheetState.isVisible) {
focusRequester.requestFocus()
}
}
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun DueDatePicker(openDatePicker: Boolean = false, onDismiss: (selectedDate: Long?) -> Unit) {
val datePickerState = rememberDatePickerState()
if (openDatePicker) {
DatePickerDialog(
onDismissRequest = { onDismiss(datePickerState.selectedDateMillis) },
confirmButton = {
TextButton(onClick = { onDismiss(datePickerState.selectedDateMillis) }) {
Text("OK")
}
},
dismissButton = {
TextButton(onClick = { onDismiss(datePickerState.selectedDateMillis) }) {
Text("CANCEL")
}
}
) {
DatePicker(
state = datePickerState
)
}
}
} | tasks-todo-compose/app/src/main/java/com/orangeink/taskstodocompose/ui/tasks/TaskBottomSheet.kt | 1119950688 |
package com.orangeink.taskstodocompose.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) | tasks-todo-compose/app/src/main/java/com/orangeink/taskstodocompose/ui/theme/Color.kt | 635443285 |
package com.orangeink.taskstodocompose.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.platform.LocalContext
import androidx.compose.ui.platform.LocalView
import androidx.core.view.WindowCompat
private val DarkColorScheme = darkColorScheme(
primary = Purple80,
secondary = PurpleGrey80,
tertiary = Pink80
)
private val LightColorScheme = lightColorScheme(
primary = Purple40,
secondary = PurpleGrey40,
tertiary = Pink40,
)
@Composable
fun TasksToDoComposeTheme(
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
WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = darkTheme.not()
}
}
MaterialTheme(
colorScheme = colorScheme,
content = content
)
} | tasks-todo-compose/app/src/main/java/com/orangeink/taskstodocompose/ui/theme/Theme.kt | 2326874008 |
package com.orangeink.taskstodocompose.di
import com.orangeink.taskstodocompose.data.TasksRepositoryImpl
import com.orangeink.taskstodocompose.domain.TasksRepository
import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
@Module
@InstallIn(SingletonComponent::class)
abstract class RepositoryModule {
@Binds
abstract fun bindTasksRepository(impl: TasksRepositoryImpl): TasksRepository
} | tasks-todo-compose/app/src/main/java/com/orangeink/taskstodocompose/di/RepositoryModule.kt | 3925123478 |
package com.orangeink.taskstodocompose.di
import android.app.Application
import androidx.room.Room
import com.orangeink.taskstodocompose.data.db.TaskDatabase
import com.orangeink.taskstodocompose.data.db.dao.TaskDao
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
object DatabaseModule {
@Provides
@Singleton
fun provideUserDatabase(
application: Application
): TaskDatabase {
return Room.databaseBuilder(application, TaskDatabase::class.java, "task_database")
.fallbackToDestructiveMigration()
.build()
}
@Provides
fun provideTaskDao(db: TaskDatabase): TaskDao {
return db.getTaskDao()
}
} | tasks-todo-compose/app/src/main/java/com/orangeink/taskstodocompose/di/DatabaseModule.kt | 2832100541 |
package com.orangeink.taskstodocompose
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.orangeink.taskstodocompose.data.db.entity.Task
import com.orangeink.taskstodocompose.domain.TasksRepository
import com.orangeink.taskstodocompose.ui.tasks.SortType
import com.orangeink.taskstodocompose.ui.tasks.TasksState
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.cancellable
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.onEach
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class TasksViewModel @Inject constructor(
private val tasksRepository: TasksRepository
) : ViewModel() {
private val _allTasks = MutableStateFlow(TasksState())
val allTasks = _allTasks.asStateFlow()
private var sortType: SortType = SortType.Date
private var dataJob: Job? = null
init {
getData(isInitialCall = true)
}
fun addTask(task: Task) {
viewModelScope.launch(Dispatchers.IO) {
tasksRepository.addTask(task)
}
}
fun updateTask(task: Task) {
viewModelScope.launch(Dispatchers.IO) {
tasksRepository.updateTask(task)
}
}
fun deleteCompletedTasks() {
viewModelScope.launch(Dispatchers.IO) {
tasksRepository.deleteCompletedTasks()
}
}
fun getData(isInitialCall: Boolean = false) {
viewModelScope.launch {
if (isInitialCall.not()) {
val index = SortType.entries.indexOf(sortType)
val nextIndex = (index + 1) % SortType.entries.size
sortType = SortType.entries[nextIndex]
dataJob?.cancel()
}
when (sortType) {
SortType.Date -> dataJob = tasksRepository.getAllTaskByDate().cancellable()
.onEach { allTasks ->
_allTasks.update {
it.copy(
tasks = allTasks,
sortType = sortType
)
}
}.launchIn(this)
SortType.Completion -> dataJob =
tasksRepository.getAllTaskByCompletion().cancellable()
.onEach { allTasks ->
_allTasks.update {
it.copy(
tasks = allTasks,
sortType = sortType
)
}
}.launchIn(this)
}
}
}
} | tasks-todo-compose/app/src/main/java/com/orangeink/taskstodocompose/TasksViewModel.kt | 4196990288 |
package com.orangeink.taskstodocompose
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.ui.Modifier
import androidx.hilt.navigation.compose.hiltViewModel
import com.orangeink.taskstodocompose.ui.tasks.TasksScreen
import com.orangeink.taskstodocompose.ui.theme.TasksToDoComposeTheme
import dagger.hilt.android.AndroidEntryPoint
@AndroidEntryPoint
class TasksActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
enableEdgeToEdge()
super.onCreate(savedInstanceState)
setContent {
TasksToDoComposeTheme {
val taskViewModel: TasksViewModel = hiltViewModel()
val allTasks by taskViewModel.allTasks.collectAsState()
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
TasksScreen(
allTasks,
onSortClick = taskViewModel::getData,
onSaveTask = taskViewModel::addTask,
onUpdateTask = taskViewModel::updateTask,
onDeleteCompletedTasks = taskViewModel::deleteCompletedTasks
)
}
}
}
}
} | tasks-todo-compose/app/src/main/java/com/orangeink/taskstodocompose/TasksActivity.kt | 4034202444 |
package com.orangeink.taskstodocompose
import android.app.Application
import dagger.hilt.android.HiltAndroidApp
@HiltAndroidApp
class TasksApp: Application() | tasks-todo-compose/app/src/main/java/com/orangeink/taskstodocompose/TasksApp.kt | 3566802082 |
package com.orangeink.taskstodocompose.data
import com.orangeink.taskstodocompose.data.db.dao.TaskDao
import com.orangeink.taskstodocompose.data.db.entity.Task
import com.orangeink.taskstodocompose.domain.TasksRepository
import kotlinx.coroutines.flow.Flow
import javax.inject.Inject
class TasksRepositoryImpl @Inject constructor(
private val taskDao: TaskDao
) : TasksRepository {
override suspend fun addTask(task: Task) {
taskDao.addTask(task)
}
override suspend fun updateTask(task: Task) {
taskDao.updateTask(task)
}
override suspend fun deleteCompletedTasks() = taskDao.deleteCompletedTasks()
override suspend fun getAllTasks(): Flow<List<Task>> = taskDao.getTasks()
override suspend fun getAllTaskByDate(): Flow<List<Task>> = taskDao.getTasksByDate()
override suspend fun getAllTaskByCompletion(): Flow<List<Task>> = taskDao.getTasksByCompletion()
} | tasks-todo-compose/app/src/main/java/com/orangeink/taskstodocompose/data/TasksRepositoryImpl.kt | 3104175176 |
package com.orangeink.taskstodocompose.data.db.converter
import androidx.room.TypeConverter
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Locale
class Converters {
@TypeConverter
fun fromTimestamp(value: String?): Date? {
return value?.let {
SimpleDateFormat(
"yyyy-MM-dd",
Locale.getDefault()
).parse(it)
}
}
@TypeConverter
fun dateToTimestamp(date: Date?): String? {
return date?.let {
SimpleDateFormat(
"yyyy-MM-dd",
Locale.getDefault()
).format(it)
}
}
} | tasks-todo-compose/app/src/main/java/com/orangeink/taskstodocompose/data/db/converter/Converters.kt | 3646008100 |
package com.orangeink.taskstodocompose.data.db.entity
import android.os.Parcelable
import androidx.room.Entity
import androidx.room.PrimaryKey
import kotlinx.parcelize.Parcelize
import java.util.Date
@Entity(tableName = "tasks")
@Parcelize
data class Task(
val title: String,
val dueDate: Date? = null,
val completed: Boolean = false,
@PrimaryKey(autoGenerate = true) val id: Int = 0
): Parcelable
| tasks-todo-compose/app/src/main/java/com/orangeink/taskstodocompose/data/db/entity/Task.kt | 3908336050 |
package com.orangeink.taskstodocompose.data.db.dao
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import androidx.room.Update
import com.orangeink.taskstodocompose.data.db.entity.Task
import kotlinx.coroutines.flow.Flow
@Dao
interface TaskDao {
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun addTask(task: Task)
@Update
suspend fun updateTask(task: Task)
@Query("SELECT * FROM tasks")
fun getTasks(): Flow<List<Task>>
@Query("SELECT * FROM tasks ORDER BY dueDate DESC")
fun getTasksByDate(): Flow<List<Task>>
@Query("SELECT * FROM tasks ORDER BY completed DESC")
fun getTasksByCompletion(): Flow<List<Task>>
@Query("DELETE FROM tasks WHERE completed")
suspend fun deleteCompletedTasks()
} | tasks-todo-compose/app/src/main/java/com/orangeink/taskstodocompose/data/db/dao/TaskDao.kt | 2903248975 |
package com.orangeink.taskstodocompose.data.db
import androidx.room.Database
import androidx.room.RoomDatabase
import androidx.room.TypeConverters
import com.orangeink.taskstodocompose.data.db.converter.Converters
import com.orangeink.taskstodocompose.data.db.dao.TaskDao
import com.orangeink.taskstodocompose.data.db.entity.Task
@Database(entities = [Task::class], version = 1, exportSchema = false)
@TypeConverters(Converters::class)
abstract class TaskDatabase : RoomDatabase() {
abstract fun getTaskDao(): TaskDao
} | tasks-todo-compose/app/src/main/java/com/orangeink/taskstodocompose/data/db/TaskDatabase.kt | 854910886 |
package com.orangeink.taskstodocompose.domain
import com.orangeink.taskstodocompose.data.db.entity.Task
import kotlinx.coroutines.flow.Flow
interface TasksRepository {
suspend fun addTask(task:Task)
suspend fun updateTask(task: Task)
suspend fun deleteCompletedTasks()
suspend fun getAllTasks(): Flow<List<Task>>
suspend fun getAllTaskByDate(): Flow<List<Task>>
suspend fun getAllTaskByCompletion(): Flow<List<Task>>
} | tasks-todo-compose/app/src/main/java/com/orangeink/taskstodocompose/domain/TasksRepository.kt | 2536513287 |
package uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.integration
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.beans.factory.annotation.Value
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment.RANDOM_PORT
import org.springframework.http.HttpHeaders
import org.springframework.test.context.ActiveProfiles
import org.springframework.test.web.reactive.server.WebTestClient
@SpringBootTest(webEnvironment = RANDOM_PORT)
@ActiveProfiles("test")
abstract class IntegrationTestBase {
@Value("\${dpr.lib.user.role}")
lateinit var authorisedRole: String
@Autowired
lateinit var webTestClient: WebTestClient
@Autowired
lateinit var jwtAuthHelper: JwtAuthHelper
internal fun setAuthorisation(
user: String = "AUTH_ADM",
roles: List<String> = listOf(),
scopes: List<String> = listOf(),
): (HttpHeaders) -> Unit = jwtAuthHelper.setAuthorisation(user, roles, scopes)
}
| hmpps-dpr-tools-api/src/test/kotlin/uk/gov/justice/digital/hmpps/digitalprisonreportingtoolsapi/integration/IntegrationTestBase.kt | 2783927150 |
package uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.integration.security
import org.springframework.security.oauth2.jwt.Jwt
import org.springframework.stereotype.Component
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.security.CaseloadProvider
@Component
class FakeCaseloadProvider : CaseloadProvider {
override fun getActiveCaseloadIds(jwt: Jwt): List<String> {
return listOf("LWSTMC")
}
}
| hmpps-dpr-tools-api/src/test/kotlin/uk/gov/justice/digital/hmpps/digitalprisonreportingtoolsapi/integration/security/FakeCaseloadProvider.kt | 3674790234 |
package uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.integration
import io.jsonwebtoken.Jwts
import io.jsonwebtoken.SignatureAlgorithm
import org.springframework.context.annotation.Bean
import org.springframework.http.HttpHeaders
import org.springframework.security.oauth2.jwt.JwtDecoder
import org.springframework.security.oauth2.jwt.NimbusJwtDecoder
import org.springframework.stereotype.Component
import java.security.KeyPair
import java.security.KeyPairGenerator
import java.security.interfaces.RSAPublicKey
import java.time.Duration
import java.util.Date
import java.util.UUID
@Component
class JwtAuthHelper {
private val keyPair: KeyPair
init {
val gen = KeyPairGenerator.getInstance("RSA")
gen.initialize(2048)
keyPair = gen.generateKeyPair()
}
@Bean
fun jwtDecoder(): JwtDecoder = NimbusJwtDecoder.withPublicKey(keyPair.public as RSAPublicKey).build()
fun setAuthorisation(
user: String = "prison-reporting-mi-client",
roles: List<String> = listOf(),
scopes: List<String> = listOf(),
): (HttpHeaders) -> Unit {
val token = createJwt(
subject = user,
scope = scopes,
expiryTime = Duration.ofHours(1L),
roles = roles,
)
return { it.set(HttpHeaders.AUTHORIZATION, "Bearer $token") }
}
internal fun createJwt(
subject: String,
scope: List<String> = listOf(),
roles: List<String> = listOf(),
expiryTime: Duration = Duration.ofHours(1),
jwtId: String = UUID.randomUUID().toString(),
): String =
mapOf(
"user_name" to subject,
"client_id" to "prison-reporting-mi-client",
"authorities" to roles,
"scope" to scope,
)
.let {
Jwts.builder()
.setId(jwtId)
.setSubject(subject)
.addClaims(it.toMap())
.setExpiration(Date(System.currentTimeMillis() + expiryTime.toMillis()))
.signWith(SignatureAlgorithm.RS256, keyPair.private)
.compact()
}
}
| hmpps-dpr-tools-api/src/test/kotlin/uk/gov/justice/digital/hmpps/digitalprisonreportingtoolsapi/integration/JwtAuthHelper.kt | 4243224750 |
package uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.integration
import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.Test
import org.springframework.http.MediaType
import org.springframework.test.web.reactive.server.expectBodyList
import org.springframework.test.web.reactive.server.returnResult
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.controller.model.FieldType
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.controller.model.FilterType
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.controller.model.ReportDefinition
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.controller.model.ReportDefinitionSummary
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.controller.model.SingleVariantReportDefinition
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.controller.model.VariantDefinition
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.controller.model.WordWrap
import uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.config.ErrorResponse
class ReportDefinitionIntegrationTest : IntegrationTestBase() {
val productDefinition =
"""
{
"id": "1",
"name": "2",
"description": "3",
"metadata": {
"author": "4",
"version": "5",
"owner": "6",
"purpose": "7",
"profile": "8",
"dqri": "9"
},
"datasource": [
{
"id": "10",
"name": "11"
}
],
"dataset": [
{
"id": "20",
"name": "21",
"query": "SELECT '70' AS F30",
"schema": {
"field": [
{
"name": "F30",
"type": "string"
}
]
}
}
],
"report": [
{
"id": "40",
"name": "41",
"description": "42",
"created": "2023-12-07T09:21:00",
"version": "43",
"dataset": "20",
"render": "HTML",
"specification": {
"template": "list",
"field": [
{
"name": "${'$'}ref:F30",
"display": "51",
"wordWrap": "None",
"filter": {
"type": "Radio",
"dynamicoptions": {
"minimumLength": 2,
"returnAsStaticOptions": true
}
},
"sortable": true,
"defaultsort": false,
"visible": "true"
}
]
},
"destination": []
}
],
"policy": [
{
"id": "60",
"type": "row-level",
"action": ["TRUE"],
"rule": []
}
]
}
""".trimIndent()
@Test
fun `Valid definition is saved and is presented by list endpoint`() {
webTestClient.put()
.uri("/definitions/1")
.headers(setAuthorisation(roles = listOf(authorisedRole)))
.contentType(MediaType.APPLICATION_JSON)
.bodyValue(productDefinition)
.exchange()
.expectStatus()
.isOk
val result = webTestClient.get()
.uri("/definitions")
.headers(setAuthorisation(roles = listOf(authorisedRole)))
.exchange()
.expectStatus()
.isOk
.expectBodyList<ReportDefinitionSummary>()
.returnResult()
.responseBody!!
assertThat(result).hasSizeGreaterThan(0)
val definition = result.findLast { it.id == "1" }!!
assertThat(definition.name).isEqualTo("2")
assertThat(definition.description).isEqualTo("3")
assertThat(definition.variants).hasSize(1)
assertThat(definition.variants[0]).isNotNull
assertThat(definition.variants[0].id).isEqualTo("40")
assertThat(definition.variants[0].name).isEqualTo("41")
assertThat(definition.variants[0].description).isEqualTo("42")
}
@Test
fun `Valid definition is saved and is presented by definition endpoint`() {
webTestClient.put()
.uri("/definitions/1")
.headers(setAuthorisation(roles = listOf(authorisedRole)))
.contentType(MediaType.APPLICATION_JSON)
.bodyValue(productDefinition)
.exchange()
.expectStatus()
.isOk
.expectBodyList<ReportDefinition>()
.returnResult()
val result = webTestClient.get()
.uri("/definitions/1/40")
.headers(setAuthorisation(roles = listOf(authorisedRole)))
.exchange()
.expectStatus()
.isOk
.expectBody(SingleVariantReportDefinition::class.java)
.returnResult()
.responseBody!!
assertThat(result.name).isEqualTo("2")
assertThat(result.description).isEqualTo("3")
assertThat(result.variant).isNotNull
assertVariant(result.variant)
}
private fun assertVariant(variant: VariantDefinition) {
assertThat(variant.id).isEqualTo("40")
assertThat(variant.resourceName).isEqualTo("reports/1/40")
assertThat(variant.name).isEqualTo("41")
assertThat(variant.description).isEqualTo("42")
assertThat(variant.specification).isNotNull
assertThat(variant.specification?.fields).hasSize(1)
val field = variant.specification!!.fields[0]
assertThat(field.name).isEqualTo("F30")
assertThat(field.display).isEqualTo("51")
assertThat(field.sortable).isEqualTo(true)
assertThat(field.defaultsort).isEqualTo(false)
assertThat(field.type).isEqualTo(FieldType.String)
assertThat(field.wordWrap).isEqualTo(WordWrap.None)
assertThat(field.filter).isNotNull()
assertThat(field.filter!!.type).isEqualTo(FilterType.Radio)
assertThat(field.filter!!.staticOptions).hasSize(1)
}
@Test
fun `Empty definition is rejected`() {
webTestClient.put()
.uri("/definitions/1")
.headers(setAuthorisation(roles = listOf(authorisedRole)))
.contentType(MediaType.APPLICATION_JSON)
.bodyValue("{}")
.exchange()
.expectStatus()
.isBadRequest
}
@Test
fun `Definition with invalid dataset reference is rejected`() {
webTestClient.put()
.uri("/definitions/people")
.headers(setAuthorisation(roles = listOf(authorisedRole)))
.contentType(MediaType.APPLICATION_JSON)
.bodyValue(
"""
{
"id": "people",
"name": "People",
"description": "Reports about people",
"metadata": {
"author": "Stu",
"owner": "Stu",
"version": "1.0.0"
},
"datasource": [
{
"id": "redshift",
"name": "redshift"
}
],
"dataset": [
{
"id": "people",
"name": "All",
"datasource": "redshift",
"query": "SELECT prisoners.number AS prisonNumber, prisoners.lastname, prisoners.firstname FROM datamart.domain.prisoner_prisoner AS prisoners",
"schema": {
"field": []
}
}
],
"policy": [
{
"id": "60",
"type": "row-level",
"action": ["TRUE"],
"rule": []
}
],
"report": [
{
"id": "everyone",
"name": "Everyone",
"description": "EVERYONE",
"created": "2023-12-04T14:41:00",
"classification": "OFFICIAL",
"version": "1.2.3",
"render": "HTML",
"dataset": "invalid",
"specification": {
"template": "list",
"field": []
}
}
]
}
""".trimIndent(),
)
.exchange()
.expectStatus()
.isBadRequest
}
@Test
fun `Definition with invalid field reference is rejected`() {
webTestClient.put()
.uri("/definitions/people")
.headers(setAuthorisation(roles = listOf(authorisedRole)))
.contentType(MediaType.APPLICATION_JSON)
.bodyValue(
"""
{
"id": "people",
"name": "People",
"description": "Reports about people",
"metadata": {
"author": "Stu",
"owner": "Stu",
"version": "1.0.0"
},
"datasource": [
{
"id": "redshift",
"name": "redshift"
}
],
"dataset": [
{
"id": "people",
"name": "All",
"datasource": "redshift",
"query": "SELECT prisoners.number AS prisonNumber, prisoners.lastname, prisoners.firstname FROM datamart.domain.prisoner_prisoner AS prisoners",
"schema": {
"field": []
}
}
],
"policy": [
{
"id": "60",
"type": "row-level",
"action": ["TRUE"],
"rule": []
}
],
"report": [
{
"id": "everyone",
"name": "Everyone",
"description": "EVERYONE",
"created": "2023-12-04T14:41:00",
"classification": "OFFICIAL",
"version": "1.2.3",
"render": "HTML",
"dataset": "people",
"specification": {
"template": "list",
"field": [
{
"name": "prisonNumber",
"display": "Prison Number",
"formula": "",
"visible": "true",
"sortable": true,
"defaultsort": true
}
]
}
}
]
}
""".trimIndent(),
)
.exchange()
.expectStatus()
.isBadRequest
}
@Test
fun `Definition with invalid SQL query is rejected`() {
val result = webTestClient.put()
.uri("/definitions/people")
.headers(setAuthorisation(roles = listOf(authorisedRole)))
.contentType(MediaType.APPLICATION_JSON)
.bodyValue(
"""
{
"id": "people",
"name": "People",
"description": "Reports about people",
"metadata": {
"author": "Stu",
"owner": "Stu",
"version": "1.0.0"
},
"datasource": [
{
"id": "redshift",
"name": "redshift"
}
],
"dataset": [
{
"id": "people",
"name": "All",
"datasource": "redshift",
"query": "SELECT cheese, FROM tables",
"schema": {
"field": [
{
"name": "prisonNumber",
"type": "string",
"display": ""
}
]
}
}
],
"policy": [
{
"id": "60",
"type": "row-level",
"action": ["TRUE"],
"rule": []
}
],
"report": [
{
"id": "everyone",
"name": "Everyone",
"description": "EVERYONE",
"created": "2023-12-04T14:41:00",
"classification": "OFFICIAL",
"version": "1.2.3",
"render": "HTML",
"dataset": "people",
"specification": {
"template": "list",
"field": [
{
"name": "prisonNumber",
"display": "Prison Number",
"formula": "",
"visible": "true",
"sortable": true,
"defaultsort": true
}
]
}
}
]
}
""".trimIndent(),
)
.exchange()
.expectStatus()
.isBadRequest
.returnResult<ErrorResponse>()
.responseBody
.blockFirst()
assertThat(result!!.developerMessage).contains("bad SQL grammar")
}
@Test
fun `Definition with date range filter is returned correctly`() {
webTestClient.put()
.uri("/definitions/people")
.headers(setAuthorisation(roles = listOf(authorisedRole)))
.contentType(MediaType.APPLICATION_JSON)
.bodyValue(
"""
{
"id": "people",
"name": "People",
"description": "Reports about people",
"metadata": {
"author": "Stu",
"owner": "Stu",
"version": "1.0.0"
},
"datasource": [
{
"id": "redshift",
"name": "redshift"
}
],
"dataset": [
{
"id": "people",
"name": "All",
"datasource": "redshift",
"query": "SELECT 1",
"schema": {
"field": [
{
"name": "date",
"type": "date",
"display": ""
}
]
}
}
],
"policy": [
{
"id": "60",
"type": "row-level",
"action": ["TRUE"],
"rule": []
}
],
"report": [
{
"id": "everyone",
"name": "Everyone",
"description": "EVERYONE",
"created": "2023-12-04T14:41:00",
"classification": "OFFICIAL",
"version": "1.2.3",
"render": "HTML",
"dataset": "people",
"specification": {
"template": "list",
"field": [
{
"name": "date",
"display": "Date",
"formula": "",
"visible": "true",
"sortable": true,
"defaultsort": true,
"filter" : {
"type": "daterange"
}
}
]
}
}
]
}
""".trimIndent(),
)
.exchange()
.expectStatus()
.isOk
val body = webTestClient.get()
.uri("/definitions/people/everyone")
.headers(setAuthorisation(roles = listOf(authorisedRole)))
.exchange()
.expectStatus()
.isOk
.expectBody(String::class.java)
.returnResult()
.responseBody
assertThat(body).contains("\"type\":\"date\"")
assertThat(body).contains("\"type\":\"daterange\"")
}
@Test
fun `Property with GSON deserialisation annotations is deserialised correctly`() {
webTestClient.put()
.uri("/definitions/1")
.headers(setAuthorisation(roles = listOf(authorisedRole)))
.contentType(MediaType.APPLICATION_JSON)
.bodyValue(productDefinition)
.exchange()
.expectStatus()
.isOk
val result = webTestClient.get()
.uri("/definitions/1/40")
.headers(setAuthorisation(roles = listOf(authorisedRole)))
.exchange()
.expectStatus()
.isOk
.expectBody(SingleVariantReportDefinition::class.java)
.returnResult()
.responseBody
val field = result!!.variant.specification!!.fields[0]
assertThat(field.defaultsort).isFalse()
assertThat(field.filter).isNotNull()
assertThat(field.filter!!.dynamicOptions!!.returnAsStaticOptions).isTrue()
assertThat(field.filter!!.staticOptions!![0].name).isEqualTo("70")
}
@Test
fun `Definition is deleted`() {
webTestClient.put()
.uri("/definitions/1")
.headers(setAuthorisation(roles = listOf(authorisedRole)))
.contentType(MediaType.APPLICATION_JSON)
.bodyValue(productDefinition)
.exchange()
.expectStatus()
.isOk
webTestClient.delete()
.uri("/definitions/1")
.headers(setAuthorisation(roles = listOf(authorisedRole)))
.exchange()
.expectStatus()
.isOk
webTestClient.get()
.uri("/definitions/1/40")
.headers(setAuthorisation(roles = listOf(authorisedRole)))
.exchange()
.expectStatus()
.isNotFound
}
@Test
fun `Definition is fetched`() {
webTestClient.put()
.uri("/definitions/1")
.headers(setAuthorisation(roles = listOf(authorisedRole)))
.contentType(MediaType.APPLICATION_JSON)
.bodyValue(productDefinition)
.exchange()
.expectStatus()
.isOk
val savedDefinition = webTestClient.get()
.uri("/definitions/original/1")
.headers(setAuthorisation(roles = listOf(authorisedRole)))
.exchange()
.expectStatus()
.isOk
.expectBody(String::class.java)
.returnResult()
.responseBody
assertThat(savedDefinition).isEqualTo(productDefinition)
}
}
| hmpps-dpr-tools-api/src/test/kotlin/uk/gov/justice/digital/hmpps/digitalprisonreportingtoolsapi/integration/ReportDefinitionIntegrationTest.kt | 1988629516 |
package uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.config
import com.fasterxml.jackson.databind.exc.MismatchedInputException
import org.slf4j.LoggerFactory
import org.springframework.http.HttpStatus
import org.springframework.http.HttpStatus.BAD_REQUEST
import org.springframework.http.HttpStatus.NOT_FOUND
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.ExceptionHandler
import org.springframework.web.bind.annotation.ResponseStatus
import org.springframework.web.bind.annotation.RestControllerAdvice
import uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.exception.DefinitionNotFoundException
import uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.exception.InvalidDefinitionException
@RestControllerAdvice
class ToolsApiExceptionHandler {
@ExceptionHandler(MismatchedInputException::class)
@ResponseStatus(BAD_REQUEST)
fun handleValidationException(e: Exception): ResponseEntity<ErrorResponse> {
return respondWithBadRequest(e)
}
@ExceptionHandler(InvalidDefinitionException::class)
@ResponseStatus(BAD_REQUEST)
fun handleInvalidDefinitionException(e: Exception): ResponseEntity<ErrorResponse> {
return respondWithBadRequest(e)
}
@ExceptionHandler(DefinitionNotFoundException::class)
@ResponseStatus(NOT_FOUND)
fun handleDefinitionNotFoundException(e: Exception): ResponseEntity<ErrorResponse> {
return ResponseEntity
.status(NOT_FOUND)
.body(
ErrorResponse(
status = NOT_FOUND,
userMessage = e.message,
developerMessage = e.message,
),
)
}
private fun respondWithBadRequest(e: Exception): ResponseEntity<ErrorResponse> {
log.info("Validation exception: {}", e.message)
log.info("Cause: {}", e.cause?.message)
return ResponseEntity
.status(BAD_REQUEST)
.body(
ErrorResponse(
status = BAD_REQUEST,
userMessage = "Validation failure: ${e.message}",
developerMessage = e.message,
),
)
}
companion object {
private val log = LoggerFactory.getLogger(this::class.java)
}
}
data class ErrorResponse(
val status: Int,
val errorCode: Int? = null,
val userMessage: String? = null,
val developerMessage: String? = null,
val moreInfo: String? = null,
) {
constructor(
status: HttpStatus,
errorCode: Int? = null,
userMessage: String? = null,
developerMessage: String? = null,
moreInfo: String? = null,
) :
this(status.value(), errorCode, userMessage, developerMessage, moreInfo)
}
| hmpps-dpr-tools-api/src/main/kotlin/uk/gov/justice/digital/hmpps/digitalprisonreportingtoolsapi/config/ToolsApiExceptionHandler.kt | 3403803651 |
package uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.config
import org.springframework.beans.factory.annotation.Value
import org.springframework.boot.jdbc.DataSourceBuilder
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.Primary
import java.util.*
import javax.sql.DataSource
@Configuration
class RedshiftDataSourceConfiguration(
@Value("\${customdatasource.redshift.url}") val url: String,
@Value("\${customdatasource.redshift.username}") val username: String,
@Value("\${customdatasource.redshift.password}") val password: String,
@Value("\${customdatasource.redshift.driver}") val driver: String,
) {
@Bean("redshift")
@Primary
fun createRedshiftDataSource(): DataSource {
return DataSourceBuilder.create()
.url(url)
.username(username)
.password(password)
.driverClassName(driver)
.build()
}
}
| hmpps-dpr-tools-api/src/main/kotlin/uk/gov/justice/digital/hmpps/digitalprisonreportingtoolsapi/config/RedshiftDataSourceConfiguration.kt | 4065128276 |
package uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.config
import org.springframework.beans.factory.annotation.Value
import org.springframework.boot.jdbc.DataSourceBuilder
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import java.util.*
import javax.sql.DataSource
@Configuration
class ActivitiesDataSourceConfiguration(
@Value("\${customdatasource.activities.url}") val url: String,
@Value("\${customdatasource.activities.username}") val username: String,
@Value("\${customdatasource.activities.password}") val password: String,
@Value("\${customdatasource.activities.driver}") val driver: String,
) {
@Bean("activities")
fun createCustomDataSource(): DataSource {
return DataSourceBuilder.create()
.url(url)
.username(username)
.password(password)
.driverClassName(driver)
.build()
}
}
| hmpps-dpr-tools-api/src/main/kotlin/uk/gov/justice/digital/hmpps/digitalprisonreportingtoolsapi/config/ActivitiesDataSourceConfiguration.kt | 1547051962 |
package uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.health
import org.springframework.boot.actuate.health.Health
import org.springframework.boot.actuate.health.HealthIndicator
import org.springframework.boot.info.BuildProperties
import org.springframework.stereotype.Component
/**
* Adds version data to the /health endpoint. This is called by the UI to display API details
*/
@Component
class HealthInfo(buildProperties: BuildProperties) : HealthIndicator {
private val version: String = buildProperties.version
override fun health(): Health = Health.up().withDetail("version", version).build()
}
| hmpps-dpr-tools-api/src/main/kotlin/uk/gov/justice/digital/hmpps/digitalprisonreportingtoolsapi/health/HealthInfo.kt | 481259469 |
package uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.health
import org.slf4j.LoggerFactory
import org.springframework.boot.context.event.ApplicationReadyEvent
import org.springframework.boot.info.BuildProperties
import org.springframework.context.annotation.Configuration
import org.springframework.context.event.EventListener
@Configuration
class VersionOutputter(buildProperties: BuildProperties) {
private val version = buildProperties.version
@EventListener(ApplicationReadyEvent::class)
fun logVersionOnStartup() {
log.info("Version {} started", version)
}
companion object {
private val log = LoggerFactory.getLogger(this::class.java)
}
}
| hmpps-dpr-tools-api/src/main/kotlin/uk/gov/justice/digital/hmpps/digitalprisonreportingtoolsapi/health/VersionOutputter.kt | 2466035511 |
package uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.controller
import com.google.gson.Gson
import io.swagger.v3.oas.annotations.Operation
import io.swagger.v3.oas.annotations.security.SecurityRequirement
import io.swagger.v3.oas.annotations.tags.Tag
import org.springframework.web.bind.annotation.DeleteMapping
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PathVariable
import org.springframework.web.bind.annotation.PutMapping
import org.springframework.web.bind.annotation.RequestBody
import org.springframework.web.bind.annotation.RestController
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.data.model.ProductDefinition
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.security.DprAuthAwareAuthenticationToken
import uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.service.DefinitionService
@RestController
@Tag(name = "Report Definition API")
class DefinitionController(
val definitionService: DefinitionService,
val dprDefinitionGson: Gson,
) {
@Operation(
description = "Saves a definition",
security = [SecurityRequirement(name = "bearer-jwt")],
)
@PutMapping("/definitions/{definitionId}")
fun putDefinition(
@RequestBody
body: String,
@PathVariable definitionId: String,
authentication: DprAuthAwareAuthenticationToken,
) {
val definition = dprDefinitionGson.fromJson(body, ProductDefinition::class.java)
definitionService.validateAndSave(definition, authentication, body)
}
@Operation(
description = "Deletes a definition",
security = [ SecurityRequirement(name = "bearer-jwt") ],
)
@DeleteMapping("/definitions/{definitionId}")
fun deleteDefinition(@PathVariable definitionId: String) {
definitionService.deleteById(definitionId)
}
@Operation(
description = "Get the original definition",
security = [ SecurityRequirement(name = "bearer-jwt") ],
)
@GetMapping("/definitions/original/{definitionId}")
fun getOriginalDefinition(@PathVariable definitionId: String) = definitionService.getOriginalBody(definitionId)
}
| hmpps-dpr-tools-api/src/main/kotlin/uk/gov/justice/digital/hmpps/digitalprisonreportingtoolsapi/controller/DefinitionController.kt | 2327781322 |
package uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
@SpringBootApplication
class DigitalPrisonReportingToolsApi
fun main(args: Array<String>) {
runApplication<DigitalPrisonReportingToolsApi>(*args)
}
| hmpps-dpr-tools-api/src/main/kotlin/uk/gov/justice/digital/hmpps/digitalprisonreportingtoolsapi/DigitalPrisonReportingToolsApi.kt | 2476038172 |
package uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.service
import org.springframework.stereotype.Service
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.controller.model.RenderMethod
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.data.ConfiguredApiRepository
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.data.model.ProductDefinition
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.security.DprAuthAwareAuthenticationToken
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.service.ReportDefinitionMapper
import uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.data.InMemoryProductDefinitionRepository
import uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.exception.InvalidDefinitionException
@Service
class DefinitionService(
private val repository: InMemoryProductDefinitionRepository,
private val dataRepository: ConfiguredApiRepository,
) {
val mapper: ReportDefinitionMapper = ReportDefinitionMapper(FakeConfiguredApiService(repository, dataRepository))
fun validateAndSave(
definition: ProductDefinition,
authenticationToken: DprAuthAwareAuthenticationToken,
originalBody: String,
) {
try {
// Attempt mapping to assert references are correct
mapper.map(definition, RenderMethod.HTML, authenticationToken)
// Check each query executes successfully
definition.dataset.forEach { dataset ->
dataRepository.count(
reportId = definition.id,
filters = emptyList(),
query = dataset.query,
policyEngineResult = "FALSE",
dataSourceName = definition.datasource.first().name,
)
}
} catch (e: Exception) {
throw InvalidDefinitionException(e)
}
repository.save(definition, originalBody)
}
fun deleteById(definitionId: String) {
repository.deleteById(definitionId)
}
fun getOriginalBody(definitionId: String) = repository.getOriginalBody(definitionId)
}
| hmpps-dpr-tools-api/src/main/kotlin/uk/gov/justice/digital/hmpps/digitalprisonreportingtoolsapi/service/DefinitionService.kt | 4220662750 |
package uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.service
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.data.ConfiguredApiRepository
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.data.ProductDefinitionRepository
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.security.DprAuthAwareAuthenticationToken
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.service.ConfiguredApiService
class FakeConfiguredApiService(
override val productDefinitionRepository: ProductDefinitionRepository,
override val configuredApiRepository: ConfiguredApiRepository,
) : ConfiguredApiService(productDefinitionRepository, configuredApiRepository) {
override fun validateAndFetchData(
reportId: String,
reportVariantId: String,
filters: Map<String, String>,
selectedPage: Long,
pageSize: Long,
sortColumn: String?,
sortedAsc: Boolean,
userToken: DprAuthAwareAuthenticationToken?,
reportFieldId: String?,
prefix: String?,
dataProductDefinitionsPath: String?,
): List<Map<String, Any>> {
return emptyList()
}
}
| hmpps-dpr-tools-api/src/main/kotlin/uk/gov/justice/digital/hmpps/digitalprisonreportingtoolsapi/service/FakeConfiguredApiService.kt | 2323520033 |
package uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.data
import jakarta.validation.ValidationException
import org.springframework.stereotype.Service
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.data.AbstractProductDefinitionRepository
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.data.model.ProductDefinition
import uk.gov.justice.digital.hmpps.digitalprisonreportinglib.data.model.SingleReportProductDefinition
import uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.exception.DefinitionNotFoundException
import java.util.concurrent.ConcurrentHashMap
@Service
class InMemoryProductDefinitionRepository : AbstractProductDefinitionRepository() {
private val definitions: ConcurrentHashMap<String, Pair<ProductDefinition, String>> = ConcurrentHashMap()
override fun getProductDefinitions(path: String?): List<ProductDefinition> {
return definitions.values.map { it.first }.toList()
}
override fun getProductDefinition(definitionId: String, dataProductDefinitionsPath: String?): ProductDefinition =
definitions.getOrElse(definitionId) { throw DefinitionNotFoundException("Invalid report id provided: $definitionId") }.first
override fun getSingleReportProductDefinition(definitionId: String, reportId: String, dataProductDefinitionsPath: String?): SingleReportProductDefinition {
try {
return super.getSingleReportProductDefinition(definitionId, reportId, null)
} catch (e: ValidationException) {
throw DefinitionNotFoundException(e.message)
}
}
fun save(definition: ProductDefinition, originalBody: String) {
definitions[definition.id] = Pair(definition, originalBody)
}
fun deleteById(definitionId: String) {
definitions.remove(definitionId)
}
fun getOriginalBody(definitionId: String) = definitions[definitionId]?.second
}
| hmpps-dpr-tools-api/src/main/kotlin/uk/gov/justice/digital/hmpps/digitalprisonreportingtoolsapi/data/InMemoryProductDefinitionRepository.kt | 1374971623 |
package uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.exception
class DefinitionNotFoundException(message: String?) : RuntimeException(message)
| hmpps-dpr-tools-api/src/main/kotlin/uk/gov/justice/digital/hmpps/digitalprisonreportingtoolsapi/exception/DefinitionNotFoundException.kt | 146975133 |
package uk.gov.justice.digital.hmpps.digitalprisonreportingtoolsapi.exception
import java.lang.Exception
class InvalidDefinitionException(innerException: Exception) : RuntimeException(innerException)
| hmpps-dpr-tools-api/src/main/kotlin/uk/gov/justice/digital/hmpps/digitalprisonreportingtoolsapi/exception/InvalidDefinitionException.kt | 129660296 |
package ru.netology
fun calculateCommission(cardType: String, amount: Int): Int {
return when (cardType) {
"Mastercard", "Maestro" -> if (amount in 300..75000) {
0
} else {
(amount * 0.006 + 20).toInt()
}
"Visa", "Мир" -> (amount * 0.0075 + 35).toInt()
else -> 0
}
}
fun isWithinLimits(cardType: String, amount: Int): Boolean {
return when (cardType) {
"Mastercard", "Maestro" -> amount <= 150000
"Visa", "Мир" -> amount <= 150000
"VK Pay" -> amount <= 15000
else -> false
}
}
fun main() {
val cardType = "Mastercard"
val amount = 5000
val commission = calculateCommission(cardType, amount)
val isWithinLimits = isWithinLimits(cardType, amount)
println("Commission: $commission")
println("Within Limits: $isWithinLimits")
}
| Money-Transfers/src/main/kotlin/transfer.kt | 3677455570 |
package com.example.my_notes
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.example.my_notes", appContext.packageName)
}
} | My-Notes-App/app/src/androidTest/java/com/example/my_notes/ExampleInstrumentedTest.kt | 2741479318 |
package com.example.my_notes
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} | My-Notes-App/app/src/test/java/com/example/my_notes/ExampleUnitTest.kt | 751555731 |
package com.example.my_notes.viewmodel
import android.app.Application
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.viewModelScope
import com.example.my_notes.model.NoteData
import com.example.my_notes.repo.NoteRepo
import kotlinx.coroutines.launch
//Bu sınıfın temel amacı, kullanıcı arayüzünden gelen istekleri almak,
// bu istekleri NoteRepo sınıfı aracılığı ile veritabanı işlemlerine çevirmek ve sonuçları kullanıcı arayüzüne geri iletmektir.
// Aynı zamanda, yaşam döngüsü bilinci (lifecycle awareness) sağlar, bu da özellikle Android uygulamalarında uygundur.
// Bu sayede, UI'nin bağımsızlığı artar ve uygulamanın yapılandırılmasını kolaylaştırır.
class NoteViewModel(app:Application, private val noteRepo:NoteRepo):AndroidViewModel(app) {
fun addNote(note:NoteData)=
viewModelScope.launch {
noteRepo.insertNote(note)
}
fun deleteNote(note:NoteData)=
viewModelScope.launch {
noteRepo.deleteNote(note)
}
fun updateNote(note:NoteData)=
viewModelScope.launch {
noteRepo.updateNote(note)
}
fun getAllNotes() = noteRepo.getAllNotes()
fun searchNote(query:String?) =
noteRepo.searchNote(query)
} | My-Notes-App/app/src/main/java/com/example/my_notes/viewmodel/NoteViewModel.kt | 4023702658 |
package com.example.my_notes.viewmodel
import android.app.Application
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import com.example.my_notes.repo.NoteRepo
class NoteViewModelFactory(val app:Application,private val noteRepo: NoteRepo)
:ViewModelProvider.Factory {
override fun <T : ViewModel> create(modelClass: Class<T>): T {
@Suppress("UNCHECKED_CAST")
return NoteViewModel(app, noteRepo) as T
}
} | My-Notes-App/app/src/main/java/com/example/my_notes/viewmodel/NoteViewModelFactory.kt | 2001198212 |
package com.example.my_notes.database
import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
import com.example.my_notes.model.NoteData
@Database(entities = [NoteData::class], version = 1)
abstract class NoteDatabase:RoomDatabase() {
abstract fun getNoteDAO():NoteDAO
companion object{
@Volatile
private var instance : NoteDatabase?=null
private val LOCK = Any()
operator fun invoke(context: Context)= instance ?:
synchronized(LOCK){
instance ?:
createDatabase(context).also{
instance = it
}
}
private fun createDatabase(context: Context)=
Room.databaseBuilder(
context.applicationContext,
NoteDatabase::class.java,
"note_db"
).build()
}
} | My-Notes-App/app/src/main/java/com/example/my_notes/database/NoteDatabase.kt | 3792739688 |
package com.example.my_notes.database
import androidx.lifecycle.LiveData
import androidx.room.Dao
import androidx.room.Delete
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import androidx.room.Update
import com.example.my_notes.model.NoteData
@Dao
interface NoteDAO {
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun insertNote(note: NoteData)
@Update
suspend fun updateNote(note: NoteData)
@Delete
suspend fun deleteNote(note: NoteData)
// Read descending order
@Query("SELECT * FROM NOTES ORDER BY id DESC")
fun getAllNotes():LiveData<List<NoteData>>
@Query("SELECT * FROM NOTES WHERE noteTitle LIKE :query OR noteDesc LIKE:query")
fun searchNote(query: String?):LiveData<List<NoteData>>
} | My-Notes-App/app/src/main/java/com/example/my_notes/database/NoteDAO.kt | 2228316926 |
package com.example.my_notes
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.lifecycle.ViewModelProvider
import com.example.my_notes.database.NoteDatabase
import com.example.my_notes.repo.NoteRepo
import com.example.my_notes.viewmodel.NoteViewModel
import com.example.my_notes.viewmodel.NoteViewModelFactory
class MainActivity : AppCompatActivity() {
lateinit var noteViewModel: NoteViewModel
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
setupViewModel()
}
private fun setupViewModel(){
val noteRepo = NoteRepo(NoteDatabase(this))
val viewmodelfactory = NoteViewModelFactory(application,noteRepo)
noteViewModel = ViewModelProvider(this,viewmodelfactory)[NoteViewModel::class.java]
}
} | My-Notes-App/app/src/main/java/com/example/my_notes/MainActivity.kt | 464850912 |
package com.example.my_notes.fragments
import android.app.AlertDialog
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.Menu
import android.view.MenuInflater
import android.view.MenuItem
import android.view.View
import android.view.ViewGroup
import android.widget.Toast
import androidx.core.view.MenuHost
import androidx.core.view.MenuProvider
import androidx.lifecycle.Lifecycle
import androidx.navigation.findNavController
import androidx.navigation.fragment.navArgs
import com.example.my_notes.MainActivity
import com.example.my_notes.R
import com.example.my_notes.databinding.FragmentAddBinding
import com.example.my_notes.databinding.FragmentEditBinding
import com.example.my_notes.model.NoteData
import com.example.my_notes.viewmodel.NoteViewModel
class EditFragment : Fragment(R.layout.fragment_edit), MenuProvider {
private var editBinding : FragmentEditBinding?=null
private val binding get() = editBinding!!
private lateinit var notesViewModel: NoteViewModel
private lateinit var currentNote:NoteData
private val args: EditFragmentArgs by navArgs()
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
editBinding=FragmentEditBinding.inflate(inflater,container,false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
val menuHost: MenuHost =requireActivity()
menuHost.addMenuProvider(this,viewLifecycleOwner, Lifecycle.State.RESUMED)
notesViewModel=(activity as MainActivity).noteViewModel
currentNote = args.note!!
binding.editNoteTitle.setText(currentNote.noteTitle)
binding.editNoteDesc.setText(currentNote.noteDesc)
binding.editNoteFab.setOnClickListener{
val notetitle = binding.editNoteTitle.text.toString().trim()
val notedesc = binding.editNoteDesc.text.toString().trim()
if(notetitle.isNotEmpty()){
val note = NoteData(currentNote.id,notetitle,notedesc)
notesViewModel.updateNote(note)
view.findNavController().popBackStack(R.id.homeFragment,false)
} else{
Toast.makeText(context,"PLease enter note title",Toast.LENGTH_SHORT).show()
}
}
}
private fun deletNote(){
AlertDialog.Builder(activity).apply {
setTitle("Delete Note")
setMessage("Are you sure delete this note ?")
setPositiveButton("Delete"){_,_ ->
notesViewModel.deleteNote(currentNote)
Toast.makeText(context,"Note Deleted",Toast.LENGTH_SHORT).show()
view?.findNavController()?.popBackStack(R.id.homeFragment,false)
}
setNegativeButton("Cancel",null)
}.create().show()
}
override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
menu.clear()
menuInflater.inflate(R.menu.edit_note,menu)
}
override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
return when(menuItem.itemId){
R.id.deletemenu->{
deletNote()
true
}else->false
}
}
override fun onDestroy() {
super.onDestroy()
editBinding=null
}
} | My-Notes-App/app/src/main/java/com/example/my_notes/fragments/EditFragment.kt | 3140735284 |
package com.example.my_notes.fragments
import android.os.Binder
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.Menu
import android.view.MenuInflater
import android.view.MenuItem
import android.view.View
import android.view.ViewGroup
import androidx.appcompat.widget.SearchView
import androidx.core.view.MenuHost
import androidx.core.view.MenuProvider
import androidx.lifecycle.Lifecycle
import androidx.navigation.findNavController
import androidx.recyclerview.widget.StaggeredGridLayoutManager
import com.example.my_notes.MainActivity
import com.example.my_notes.R
import com.example.my_notes.adapter.NoteAdapter
import com.example.my_notes.databinding.FragmentHomeBinding
import com.example.my_notes.model.NoteData
import com.example.my_notes.viewmodel.NoteViewModel
class HomeFragment : Fragment(R.layout.fragment_home), SearchView.OnQueryTextListener,MenuProvider {
private var homeBinding : FragmentHomeBinding?=null
private val binding get() = homeBinding!!
private lateinit var notesViewModel: NoteViewModel
private lateinit var noteAdapter: NoteAdapter
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
homeBinding = FragmentHomeBinding.inflate(inflater,container,false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
val menuHost:MenuHost=requireActivity()
menuHost.addMenuProvider(this,viewLifecycleOwner,Lifecycle.State.RESUMED)
notesViewModel=(activity as MainActivity).noteViewModel
setuphomeRv()
binding.addNote.setOnClickListener{
it.findNavController().navigate(R.id.action_homeFragment_to_addFragment)
}
}
private fun updateUI(note:List<NoteData>?){
if(note !=null){
if (note.isNotEmpty()){
binding.emptyNotesImage.visibility = View.GONE
binding.homeRecyclerView.visibility =View.VISIBLE
}
else{
binding.emptyNotesImage.visibility = View.VISIBLE
binding.homeRecyclerView.visibility =View.GONE
}
}
}
//recyclerView
private fun setuphomeRv(){
noteAdapter= NoteAdapter()
binding.homeRecyclerView.apply {
//notlar gösterilirken ekranda en fazla yanyana 2 not view durabilir
//ve grid bir göreünüm olacak
layoutManager= StaggeredGridLayoutManager(2,StaggeredGridLayoutManager.VERTICAL)
setHasFixedSize(true)
adapter=noteAdapter
}
activity?.let {
notesViewModel.getAllNotes().observe(viewLifecycleOwner){note->
noteAdapter.differ.submitList(note)
updateUI(note)
}
}
}
private fun searchNote(query: String?){
val searchQuery = "%$query"
notesViewModel.searchNote(searchQuery).observe(this){
list->
noteAdapter.differ.submitList(list)
}
}
//arama kısmına yazdığımız anda sonuçlar listelenmeye başlıcak
override fun onQueryTextChange(newText: String?): Boolean {
if(newText != null){
searchNote(newText)
}
return true
}
override fun onQueryTextSubmit(query: String?): Boolean {
return false
}
override fun onDestroy() {
super.onDestroy()
homeBinding= null
}
override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
menu.clear()
menuInflater.inflate(R.menu.home_menu,menu)
val menuSearch = menu.findItem(R.id.searchmenu).actionView as SearchView
menuSearch.isSubmitButtonEnabled = false
menuSearch.setOnQueryTextListener(this)
}
override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
return false
}
} | My-Notes-App/app/src/main/java/com/example/my_notes/fragments/HomeFragment.kt | 3909857878 |
package com.example.my_notes.fragments
import android.os.Bundle
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.Menu
import android.view.MenuInflater
import android.view.MenuItem
import android.view.View
import android.view.ViewGroup
import android.widget.Toast
import androidx.core.view.MenuHost
import androidx.core.view.MenuProvider
import androidx.lifecycle.Lifecycle
import androidx.navigation.findNavController
import com.example.my_notes.MainActivity
import com.example.my_notes.R
import com.example.my_notes.databinding.FragmentAddBinding
import com.example.my_notes.model.NoteData
import com.example.my_notes.viewmodel.NoteViewModel
class AddFragment : Fragment(R.layout.fragment_add),MenuProvider {
private var addFragmentAddBinding : FragmentAddBinding?=null
private val binding get() = addFragmentAddBinding!!
private lateinit var notesViewModel: NoteViewModel
private lateinit var addNoteView:View
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
// Inflate the layout for this fragment
addFragmentAddBinding=FragmentAddBinding.inflate(inflater,container,false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
val menuHost: MenuHost =requireActivity()
menuHost.addMenuProvider(this,viewLifecycleOwner, Lifecycle.State.RESUMED)
notesViewModel=(activity as MainActivity).noteViewModel
addNoteView = view
}
private fun saveNote(view: View){
val noteTitle = binding.addNoteTitle.text.toString().trim()
val noteDesc= binding.addNoteDesc.text.toString().trim()
if(noteTitle.isNotEmpty()){
val note = NoteData(0,noteTitle,noteDesc)
notesViewModel.addNote(note)
Toast.makeText(addNoteView.context,"Note Added Successfully",Toast.LENGTH_SHORT).show()
view.findNavController().popBackStack(R.id.homeFragment,false)
}else{
Toast.makeText(addNoteView.context,"Please enter note title",Toast.LENGTH_SHORT).show()
}
}
override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
menu.clear()
menuInflater.inflate(R.menu.add_note,menu)
}
override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
return when(menuItem.itemId){
R.id.saveMenu->{
saveNote(addNoteView)
true
}
else-> false
}
}
override fun onDestroy() {
super.onDestroy()
addFragmentAddBinding = null
}
} | My-Notes-App/app/src/main/java/com/example/my_notes/fragments/AddFragment.kt | 2678315952 |
package com.example.my_notes.adapter
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.navigation.findNavController
import androidx.recyclerview.widget.AsyncListDiffer
import androidx.recyclerview.widget.DiffUtil
import androidx.recyclerview.widget.RecyclerView
import com.example.my_notes.databinding.NoteItemBinding
import com.example.my_notes.fragments.HomeFragmentDirections
import com.example.my_notes.model.NoteData
class NoteAdapter: RecyclerView.Adapter<NoteAdapter.NoteViewHolder>() {
class NoteViewHolder(val itemBinding: NoteItemBinding):RecyclerView.ViewHolder(itemBinding.root)
// güncelleme durumlarında çalışır
private val differCallback= object :DiffUtil.ItemCallback<NoteData>(){
override fun areItemsTheSame(oldItem: NoteData, newItem: NoteData): Boolean {
return oldItem.id == newItem.id
&&
oldItem.noteDesc == newItem.noteDesc
&&
oldItem.noteTitle == newItem.noteTitle
}
override fun areContentsTheSame(oldItem: NoteData, newItem: NoteData): Boolean {
return oldItem == newItem
}
}
val differ = AsyncListDiffer(this,differCallback)
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): NoteViewHolder {
return NoteViewHolder(
NoteItemBinding.inflate(LayoutInflater.from(parent.context),parent,false)
)
}
override fun getItemCount(): Int {
return differ.currentList.size
}
override fun onBindViewHolder(holder: NoteViewHolder, position: Int) {
// Belirli pozisyondaki notu al
val currentNote = differ.currentList[position]
// ViewHolder'ın içindeki görünümlere notun başlık ve açıklama bilgilerini yerleştir
holder.itemBinding.noteTitle.text=currentNote.noteTitle
holder.itemBinding.noteDesc.text=currentNote.noteDesc
// note a tıklaynca edit note sayfasına yönlendiriyor
// note objesini intent ile başka sayfaya yönlendiriyo gibi düşün.
holder.itemView.setOnClickListener {
val direction = HomeFragmentDirections.actionHomeFragmentToEditFragment(currentNote)
it.findNavController().navigate(direction)
}
}
} | My-Notes-App/app/src/main/java/com/example/my_notes/adapter/NoteAdapter.kt | 2701483823 |
package com.example.my_notes.model
import android.os.Parcelable
import androidx.room.Entity
import androidx.room.PrimaryKey
import kotlinx.parcelize.Parcelize
@Entity(tableName = "notes")
@Parcelize
data class NoteData(
@PrimaryKey(autoGenerate = true)
val id :Int,
val noteTitle : String,
val noteDesc : String
):Parcelable
| My-Notes-App/app/src/main/java/com/example/my_notes/model/NoteData.kt | 1688922023 |
package com.example.my_notes.repo
import androidx.room.Query
import com.example.my_notes.database.NoteDatabase
import com.example.my_notes.model.NoteData
// Bu NoteRepo (Repository) sınıfı,
// veritabanı işlemlerini yöneten ve veritabanı ile arayüz sağlayan bir ara katman (repository) sınıfıdır.
// Bu tür bir sınıf, uygulama katmanları arasında bir bağlantı görevi görerek veritabanı işlemlerini soyutlar
// ve diğer katmanlara daha kolay erişim sağlar.
class NoteRepo(private val db:NoteDatabase){
suspend fun insertNote(note:NoteData) = db.getNoteDAO().insertNote(note)
suspend fun deleteNote(note: NoteData) = db.getNoteDAO().deleteNote(note)
suspend fun updateNote(note: NoteData) = db.getNoteDAO().updateNote(note)
fun getAllNotes() = db.getNoteDAO().getAllNotes()
fun searchNote(query: String?) = db.getNoteDAO().searchNote(query)
} | My-Notes-App/app/src/main/java/com/example/my_notes/repo/NoteRepo.kt | 2899866210 |
package com.sowon.a1_fruite_study
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.sowon.a1_fruite_study", appContext.packageName)
}
} | AMPMAndroidStudy2024/app/src/androidTest/java/com/sowon/a1_fruite_study/ExampleInstrumentedTest.kt | 396067508 |
package com.sowon.a1_fruite_study
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} | AMPMAndroidStudy2024/app/src/test/java/com/sowon/a1_fruite_study/ExampleUnitTest.kt | 1678296682 |
package com.sowon.a1_fruite_study
import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.ImageView
import android.widget.Toast
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
// 1. 프로그램이 화면이 클릭 된 것을 알게 함
val image1 = findViewById<ImageView>(R.id.fruit_image_1)
image1.setOnClickListener {
Toast.makeText(this, "1번 사진 클릭", Toast.LENGTH_LONG).show()
// 2. 화면이 클릭되면 다른 화면으로 넘어감 - Activity 화면 전환
var intent = Intent(this, Fruit1Activity::class.java)
startActivity(intent)
}
}
}
| AMPMAndroidStudy2024/app/src/main/java/com/sowon/a1_fruite_study/MainActivity.kt | 2290773342 |
package com.sowon.a1_fruite_study
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
class Fruit1Activity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_fruit1)
}
} | AMPMAndroidStudy2024/app/src/main/java/com/sowon/a1_fruite_study/Fruit1Activity.kt | 1299053444 |
package com.yonatankarp.drools
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
@SpringBootTest
class DroolsApplicationTests {
@Test
fun contextLoads() {
}
}
| drools-rule-engine/src/test/kotlin/com/yonatankarp/drools/DroolsApplicationTests.kt | 180863862 |
package com.yonatankarp.drools.config
import com.yonatankarp.drools.rules.Rule
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
@Configuration
class RulesConfig {
@Bean(name = ["rulesByName"])
fun rulesMap(rules: List<Rule>): Map<String, Rule> = rules.associateBy { it::class.simpleName.lowercaseOrEmpty() }
private fun String?.lowercaseOrEmpty() = this?.lowercase() ?: ""
}
| drools-rule-engine/src/main/kotlin/com/yonatankarp/drools/config/RulesConfig.kt | 4068507294 |
package com.yonatankarp.drools.config
import org.kie.api.KieServices
import org.kie.api.runtime.KieContainer
import org.kie.internal.io.ResourceFactory
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
@Configuration
class DroolsConfig {
companion object {
private const val RULES_CUSTOMER_RULES_DRL = "rules/risk-rules.drl"
private val kieServices = KieServices.Factory.get()
}
@Bean
fun kieContainer(): KieContainer {
val kieFileSystem =
kieServices.newKieFileSystem()
.apply {
write(ResourceFactory.newClassPathResource(RULES_CUSTOMER_RULES_DRL))
}
val kb =
kieServices.newKieBuilder(kieFileSystem)
.apply {
buildAll()
}
return kieServices.newKieContainer(kb.kieModule.releaseId)
}
}
| drools-rule-engine/src/main/kotlin/com/yonatankarp/drools/config/DroolsConfig.kt | 3819758384 |
package com.yonatankarp.drools.controller
import com.yonatankarp.drools.model.RiskRequest
import com.yonatankarp.drools.model.RiskResponse
import com.yonatankarp.drools.service.RiskService
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.RequestBody
import org.springframework.web.bind.annotation.RestController
@RestController
class RiskController(private val riskService: RiskService) {
@PostMapping("/risk")
suspend fun runRules(
@RequestBody riskRequest: RiskRequest,
): ResponseEntity<RiskResponse> =
riskService.runRules(riskRequest)
.let { ResponseEntity.ok(it.toResponse()) }
private suspend fun Boolean.toResponse() = RiskResponse(isRuleApplied = this)
}
| drools-rule-engine/src/main/kotlin/com/yonatankarp/drools/controller/RiskController.kt | 2291410059 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.