content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package com.example.planit_mobile.ui.screens.common
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.OutlinedTextFieldDefaults
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.scale
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.text.input.VisualTransformation
import androidx.compose.ui.unit.Dp
@Composable
fun TextField(
text: String,
onTextChange: (String) -> Unit,
label: String,
leadingIcon: ImageVector,
singleLine: Boolean = true,
error: Boolean = false,
visualTransformation: VisualTransformation = VisualTransformation.None,
maxLength: Int,
padding: Dp
) {
val textLimitExceeded = text.length > maxLength
val limitedText = if (textLimitExceeded) text.substring(0, maxLength) else text
return OutlinedTextField(
value = limitedText,
leadingIcon = { Icon(imageVector = leadingIcon, contentDescription = "Icon", tint = Color.White) },
onValueChange = {
var newText = it
if (it.contains("\n")) {
newText = it.replace("\n", "")
}
onTextChange(newText)
},
label = { Text(text = label, color = Color.White) },
singleLine = singleLine,
isError = error,
visualTransformation = visualTransformation,
colors = OutlinedTextFieldDefaults.colors(
cursorColor = Color.White,
focusedBorderColor = Color.White,
unfocusedBorderColor = Color(0xFF1EABBD),
focusedTextColor = Color.White,
unfocusedTextColor = Color.White,
),
modifier = Modifier
.scale(0.8f)
.padding(top = padding)
)
} | planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/common/TextField.kt | 1603678947 |
package com.example.planit_mobile.ui.screens.common
open class LoadState<out T>
data class Error(val message: String): LoadState<String>()
object Idle : LoadState<Nothing>()
object Loading : LoadState<Nothing>()
data class Loaded<T>(val value: T) : LoadState<T>()
fun errorMessage(message: String): Error = Error(message)
fun idle(): Idle = Idle
fun loading(): Loading = Loading
fun <T> loaded(value: T): Loaded<T> = Loaded(value)
fun <T> LoadState<T>.getOrNull(): T? = when (this) {
is Loaded -> value
else -> null
}
fun <T> LoadState<T>.getOrThrow(): T = when (this) {
is Loaded -> value
else -> throw IllegalStateException("No value available")
}
| planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/common/LoadState.kt | 2004741583 |
package com.example.planit_mobile.ui.screens.common
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Button
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
@Composable
fun ErrorPopup(showDialog: Boolean, errorMessage: String, onDialogDismiss: () -> Unit) {
if (showDialog) {
AlertDialog(
onDismissRequest = {
onDialogDismiss()
},
title = {
Text(text = "Error")
},
text = {
Text(text = errorMessage)
},
confirmButton = {
Button(onClick = {
onDialogDismiss()
}) {
Text("OK")
}
}
)
}
} | planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/common/ErrorPopup.kt | 2376573173 |
package com.example.planit_mobile.ui.screens.common
data class NavigationHandlers(
val onInfoRequested: (() -> Unit)? = null,
val onProfileRequested: (() -> Unit)? = null,
val onHomeRequested: (() -> Unit)? = null,
val onEventsRequested: (() -> Unit)? = null
) | planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/common/NavigationHandlers.kt | 490966717 |
package com.example.planit_mobile.ui.screens.profile
import android.app.Activity
import android.content.Intent
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.viewModels
import androidx.compose.runtime.collectAsState
import androidx.lifecycle.lifecycleScope
import com.example.planit_mobile.PlanItDependencyProvider
import com.example.planit_mobile.ui.screens.common.Error
import com.example.planit_mobile.ui.screens.common.ErrorPopup
import com.example.planit_mobile.ui.screens.common.Idle
import com.example.planit_mobile.ui.screens.common.getOrNull
import com.example.planit_mobile.ui.screens.common.idle
import com.example.planit_mobile.ui.screens.home.HomeActivity
import com.example.planit_mobile.ui.screens.searchEvent.SearchEventActivity
import kotlinx.coroutines.launch
class UserProfileActivity : ComponentActivity() {
private val dependencies by lazy { application as PlanItDependencyProvider }
private val viewModel by viewModels<UserProfileViewModel> {
UserProfileViewModel.factory(dependencies.userService, dependencies.sessionStorage)
}
companion object {
fun navigateTo(origin: Activity, userID: Int? = null) {
val intent = Intent(origin, UserProfileActivity::class.java).apply {
putExtra("userID", userID)
}
origin.startActivity(intent)
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val userID = intent.getIntExtra("userID", 0)
lifecycleScope.launch {
viewModel.loadState.collect {
if (it is Idle) {
if(userID != 0) {
viewModel.fetchUser(userID)
}else {
viewModel.fetchUser()
}
}
}
}
setContent {
val state = viewModel.loadState.collectAsState(initial = idle()).value.getOrNull()
val errorMessage = viewModel.errorState.collectAsState(initial = Error("")).value.message
if (state != null) {
UserProfileScreen(
userInfo = state,
onBackRequested = { finish() },
onProfileRequested = { navigateTo(this) },
onHomeRequested = { HomeActivity.navigateTo(this) },
onEventsRequested = { SearchEventActivity.navigateTo(this) }
)
ErrorPopup(
showDialog = errorMessage != "",
errorMessage = errorMessage) {
viewModel.dismissError()
}
}
}
}
}
| planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/profile/UserProfileActivity.kt | 2479039704 |
package com.example.planit_mobile.ui.screens.profile
import android.util.Log
import androidx.compose.foundation.Canvas
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
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.size
import androidx.compose.foundation.layout.width
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.shadow
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import com.example.planit_mobile.domain.User
import com.example.planit_mobile.ui.screens.common.BotBar
import com.example.planit_mobile.ui.screens.common.NavigationHandlers
@Composable
fun UserProfileScreen(
userInfo: User,
onBackRequested: () -> Unit,
onProfileRequested: () -> Unit,
onHomeRequested: () -> Unit,
onEventsRequested: () -> Unit,
) {
Scaffold(
modifier = Modifier
.fillMaxSize(),
bottomBar = {
BotBar(navigation =
NavigationHandlers(
onProfileRequested = onProfileRequested,
onHomeRequested = onHomeRequested,
onEventsRequested = onEventsRequested
)
)
},
) {
UpperHalf(padding = it, userInfo = userInfo)
MiddleSection(userInfo = userInfo)
LowerHalf(userInfo = userInfo)
}
}
@Composable
fun UpperHalf(padding: PaddingValues, userInfo: User){
Box(
modifier = Modifier
.padding(padding)
.height(275.dp)
.background(color = Color(28, 155, 139, 255))
) {
Column(
modifier = Modifier
.fillMaxSize()
.padding(16.dp),
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
) {
Canvas(
modifier = Modifier.size(150.dp)
) {
drawCircle(
color = Color.White
)
}
Text(
text = userInfo.name,
style = androidx.compose.ui.text.TextStyle(color = Color.White),
fontSize = 24.sp,
modifier = Modifier.padding(10.dp)
)
}
}
}
@Composable
fun MiddleSection(userInfo: User){
Box(
modifier = Modifier
.padding(horizontal = 30.dp, vertical = 235.dp)
.height(95.dp)
.width(500.dp)
.background(Color.White)
.shadow(2.dp)
) {
Column(
modifier = Modifier
.fillMaxSize()
.padding(16.dp),
verticalArrangement = Arrangement.Center,
horizontalAlignment = Alignment.CenterHorizontally
) {
Text(
text = "@" + userInfo.username,
style = androidx.compose.ui.text.TextStyle(color = Color.Black),
fontSize = 16.sp
)
Text(
text = userInfo.email,
style = androidx.compose.ui.text.TextStyle(color = Color.Black),
fontSize = 13.sp
)
}
}
}
@Composable
fun LowerHalf(userInfo: User){
Box(modifier = Modifier.padding(0.dp, 340.dp, 0.dp, 0.dp)) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(0.dp, 10.dp, 0.dp, 0.dp),
verticalArrangement = Arrangement.Top,
) {
Text(
text = "Interests:",
modifier = Modifier.padding(20.dp),
style = androidx.compose.ui.text.TextStyle(color = Color.Black),
fontSize = 20.sp
)
val chunkedInterests = userInfo.interests.chunked(3)
Row(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 20.dp),
horizontalArrangement = Arrangement.SpaceEvenly
) {
for (interestsColumn in chunkedInterests) {
Column(
modifier = Modifier.weight(1f),
verticalArrangement = Arrangement.Top,
) {
for (interest in interestsColumn) {
Text(
text = "• $interest",
style = androidx.compose.ui.text.TextStyle(color = Color.Black),
fontSize = 16.sp
)
}
}
}
}
Text(
text = "Description:",
modifier = Modifier.padding(20.dp),
style = androidx.compose.ui.text.TextStyle(color = Color.Black),
fontSize = 20.sp
)
Text(
text = userInfo.description,
modifier = Modifier.padding(horizontal = 20.dp),
style = androidx.compose.ui.text.TextStyle(color = Color.Black),
fontSize = 16.sp
)
}
}
}
@Preview
@Composable
fun PreviewUserProfileScreen() {
UserProfileScreen(
userInfo = User(
1,
"Daniel",
"Daniel2003",
"Im nice",
"[email protected]",
listOf("Sports and Outdoor", "Culture", "Education", "Entertainment", /*"Volunteering"*/)),
onBackRequested = {},
onProfileRequested = {},
onHomeRequested = {},
onEventsRequested = {}
)
} | planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/profile/UserProfileScreen.kt | 368371226 |
package com.example.planit_mobile.ui.screens.profile
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewmodel.initializer
import androidx.lifecycle.viewmodel.viewModelFactory
import com.example.myapplication.sessionStorage.SessionDataStore
import com.example.planit_mobile.domain.User
import com.example.planit_mobile.services.UserService
import com.example.planit_mobile.services.utils.executeRequest
import com.example.planit_mobile.services.utils.launchAndAuthenticateRequest
import com.example.planit_mobile.services.utils.launchAndRequest
import com.example.planit_mobile.ui.screens.common.Error
import com.example.planit_mobile.ui.screens.common.LoadState
import com.example.planit_mobile.ui.screens.common.errorMessage
import com.example.planit_mobile.ui.screens.common.idle
import com.example.planit_mobile.ui.screens.common.loaded
import com.example.planit_mobile.ui.screens.common.loading
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
class UserProfileViewModel(
private val service: UserService,
private val sessionStorage: SessionDataStore
) : ViewModel() {
companion object {
fun factory(service: UserService, sessionStorage: SessionDataStore) = viewModelFactory {
initializer { UserProfileViewModel(service, sessionStorage) }
}
}
private val loadStateFlow : MutableStateFlow<LoadState<User>> = MutableStateFlow(idle())
private val errorStateFlow: MutableStateFlow<Error> = MutableStateFlow(Error(""))
val loadState: Flow<LoadState<User>>
get() = loadStateFlow.asStateFlow()
val errorState: Flow<Error>
get() = errorStateFlow.asStateFlow()
suspend fun fetchUser(id: Int? = null) {
loadStateFlow.value = loading()
val userId = sessionStorage.getUserID() ?: return
launchAndRequest(
request = {
service.fetchUserInfo(id ?: userId)
},
onSuccess = { res ->
loadStateFlow.value = loaded(res)
},
onFailure = {errorStateFlow.value = errorMessage(it.message.toString()) }
)
}
fun dismissError() {
errorStateFlow.value = Error("")
}
} | planit-mobile/app/src/main/java/com/example/planit_mobile/ui/screens/profile/UserProfileViewModel.kt | 1688184778 |
package com.example.planit_mobile.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) | planit-mobile/app/src/main/java/com/example/planit_mobile/ui/theme/Color.kt | 4152555474 |
package com.example.planit_mobile.ui.theme
import android.app.Activity
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.SideEffect
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.toArgb
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalView
import androidx.core.view.WindowCompat
private val DarkColorScheme = darkColorScheme(
primary = Color(57, 99, 119, 255),
secondary = Color.White,
tertiary = Pink80,
background = Color(27,42,49,255)
)
private val LightColorScheme = lightColorScheme(
primary = Color(68, 122, 148, 255),
secondary = Color.White,
tertiary = Pink40,
background = Color(27,42,49,255)
/* Other default colors to override
background = Color(0xFFFFFBFE),
surface = Color(0xFFFFFBFE),
onPrimary = Color.White,
onSecondary = Color.White,
onTertiary = Color.White,
onBackground = Color(0xFF1C1B1F),
onSurface = Color(0xFF1C1B1F),
*/
)
@Composable
fun PlanitMobileTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
// Dynamic color is available on Android 12+
dynamicColor: Boolean = true,
content: @Composable () -> Unit
) {
val colorScheme = when {
darkTheme -> DarkColorScheme
else -> LightColorScheme
}
val view = LocalView.current
if (!view.isInEditMode) {
SideEffect {
val window = (view.context as Activity).window
window.statusBarColor = colorScheme.primary.toArgb()
WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = darkTheme
}
}
MaterialTheme(
colorScheme = colorScheme,
typography = Typography,
content = content
)
} | planit-mobile/app/src/main/java/com/example/planit_mobile/ui/theme/Theme.kt | 1545543612 |
package com.example.planit_mobile.ui.theme
import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
// Set of Material typography styles to start with
val Typography = Typography(
bodyLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 16.sp,
lineHeight = 24.sp,
letterSpacing = 0.5.sp
)
/* Other default text styles to override
titleLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 22.sp,
lineHeight = 28.sp,
letterSpacing = 0.sp
),
labelSmall = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Medium,
fontSize = 11.sp,
lineHeight = 16.sp,
letterSpacing = 0.5.sp
)
*/
) | planit-mobile/app/src/main/java/com/example/planit_mobile/ui/theme/Type.kt | 1802291414 |
package com.example.myapplication.sessionStorage
import androidx.datastore.core.DataStore
import androidx.datastore.preferences.core.Preferences
import androidx.datastore.preferences.core.edit
import androidx.datastore.preferences.core.intPreferencesKey
import androidx.datastore.preferences.core.stringPreferencesKey
import kotlinx.coroutines.flow.first
/**
* DataStore implementation for storing and retrieving session-related data, such as access tokens,
* refresh tokens, and user IDs.
*
* @property store The DataStore instance for storing session data.
*/
class SessionDataStore(private val store: DataStore<Preferences>) {
private val accessToken = stringPreferencesKey("access_token")
private val refreshToken = stringPreferencesKey("refresh_token")
private val userID = intPreferencesKey("user_id")
/**
* Retrieves the stored access token from the session data.
*
* @return The stored access token, or null if not present.
*/
suspend fun getSessionAccessToken(): String? {
val token = store.data.first()
val accessToken = token[accessToken]
return if (accessToken.isNullOrEmpty()) null else accessToken
}
/**
* Retrieves the stored refresh token from the session data.
*
* @return The stored refresh token, or null if not present.
*/
suspend fun getSessionRefreshToken(): String? {
val token = store.data.first()
val refreshToken = token[refreshToken]
return if (refreshToken.isNullOrEmpty()) null else refreshToken
}
/**
* Retrieves the stored user ID from the session data.
*
* @return The stored user ID, or null if not present.
*/
suspend fun getUserID(): Int? {
val id = store.data.first()
return id[this.userID]
}
/**
* Checks if a user is logged in by verifying the presence of an access token.
*
* @return True if a user is logged in; false otherwise.
*/
suspend fun isLogged(): Boolean {
val token = store.data.first()
val accessToken = token[accessToken]
return !accessToken.isNullOrEmpty()
}
/**
* Clears the session data, effectively logging out the user.
*/
suspend fun clearSession() {
store.edit {
it.clear()
}
}
/**
* Sets the session data with the provided access token, refresh token, and user ID.
*
* @param accessToken The access token to be stored.
* @param refreshToken The refresh token to be stored.
* @param userID The user ID to be stored.
*/
suspend fun setSession(accessToken: String, refreshToken: String, userID: Int) {
store.edit {
it[this.accessToken] = accessToken
it[this.refreshToken] = refreshToken
it[this.userID] = userID
}
}
}
| planit-mobile/app/src/main/java/com/example/planit_mobile/sessionStorage/SessionDataStore.kt | 142994507 |
package com.example.planit_mobile
import com.example.myapplication.sessionStorage.SessionDataStore
import com.example.planit_mobile.services.EventService
import com.example.planit_mobile.services.UserService
import com.google.gson.Gson
import okhttp3.OkHttpClient
/**
* The contract to be supported by the application's class used to resolve dependencies.
*/
interface PlanItDependencyProvider {
/**
* The HTTP client used to perform HTTP requests
*/
val httpClient: OkHttpClient
/**
* The JSON serializer/deserializer used to convert JSON into DTOs
*/
val gson: Gson
/**
* The service used to fetch user related info
*/
val userService: UserService
/**
* The service used to fetch event related info
*/
val eventService: EventService
/**
* The storage used to persist the user session
*/
val sessionStorage: SessionDataStore
}
| planit-mobile/app/src/main/java/com/example/planit_mobile/PlanItDependencyProvider.kt | 338416555 |
package com.example.planit_mobile
import android.app.Application
import androidx.datastore.core.DataStore
import androidx.datastore.preferences.preferencesDataStore
import com.google.gson.Gson
import okhttp3.OkHttpClient
import androidx.datastore.preferences.core.Preferences
import com.example.myapplication.sessionStorage.SessionDataStore
import com.example.planit_mobile.services.EventService
import com.example.planit_mobile.services.UserService
import com.example.planit_mobile.services.providers.EventProvider
import com.example.planit_mobile.services.providers.UserProvider
/**
* The contract to be supported by the application's class used to resolve dependencies.
*/
class PlanItApplication : Application(), PlanItDependencyProvider {
private val dataStore: DataStore<Preferences> by preferencesDataStore(name = "authentication")
/**
* The HTTP client used to perform HTTP requests
*/
override val httpClient: OkHttpClient =
OkHttpClient.Builder()
.callTimeout(10, java.util.concurrent.TimeUnit.SECONDS)
.build()
/**
* The JSON serializer/deserializer used to convert JSON into DTOs
*/
override val gson: Gson = Gson()
/**
* The service used to fetch user related info
*/
override val userService: UserService = UserProvider(httpClient, gson)
/**
* The service used to fetch event related info
*/
override val eventService: EventService = EventProvider(httpClient, gson)
/**
* The storage used to persist the user session
*/
override val sessionStorage: SessionDataStore
get() = SessionDataStore(dataStore)
}
| planit-mobile/app/src/main/java/com/example/planit_mobile/PlanItApplication.kt | 3684546933 |
package com.example.planit_mobile.domain
/**
* Represents an event.
* @property id The unique identifier of the event.
* @property title The title of the event.
* @property description The description of the event.
* @property date The date of the event.
* @property category The category of the event.
* @property subCategory The subcategory of the event.
* @property location The location of the event.
* @property visibility The visibility of the event.
* @property price The price of the event.
*/
data class Event(
val id: Int,
val title: String,
val description: String,
val date: String,
val category: String,
val subCategory: String,
val location: String,
val visibility: String,
val price: Double
) | planit-mobile/app/src/main/java/com/example/planit_mobile/domain/Event.kt | 592166563 |
package com.example.planit_mobile.domain
/**
* Represents a user in the PlanIt application.
*
* @property id The unique identifier for the user.
* @property name The name of the user.
* @property username The username of the user.
* @property description The description of the user.
* @property email The email address of the user.
* @property interests The list of interests associated with the user.
*/
data class User(
val id: Int,
val name: String,
val username: String,
val description: String,
val email: String,
val interests: List<String>
)
| planit-mobile/app/src/main/java/com/example/planit_mobile/domain/User.kt | 1085390858 |
package com.example.planit_mobile.domain
/**
* Represents a pair of access and refresh tokens used for authentication.
*
* @property accessToken The access token for authentication.
* @property refreshToken The refresh token for obtaining a new access token.
*/
data class Tokens(
val accessToken: String,
val refreshToken: String,
)
| planit-mobile/app/src/main/java/com/example/planit_mobile/domain/Tokens.kt | 4164427500 |
package com.example.planit_mobile.services
data class ErrorResponse(
val error: String
)
| planit-mobile/app/src/main/java/com/example/planit_mobile/services/ErrorResponse.kt | 2995735035 |
package com.example.planit_mobile.services.providers
import com.example.planit_mobile.domain.User
import com.example.planit_mobile.services.UserService
import com.example.planit_mobile.services.models.AuthOutputModel
import com.example.planit_mobile.services.models.EditUserInputModel
import com.example.planit_mobile.services.utils.ApiRequests
import com.example.planit_mobile.services.utils.PathTemplates.LOGIN_URL
import com.example.planit_mobile.services.utils.PathTemplates.LOGOUT_URL
import com.example.planit_mobile.services.utils.PathTemplates.REGISTER_URL
import com.example.planit_mobile.services.utils.PathTemplates.USER_URL
import com.google.gson.Gson
import okhttp3.OkHttpClient
/**
* Provider that fetches user information from the PlanIt API.
*
* @param client The HTTP client used to perform the requests.
* @param gson The JSON serializer/deserializer used to convert JSON into DTOs.
*/
class UserProvider(
private val client: OkHttpClient,
private val gson: Gson,
) : UserService {
override suspend fun register(
username: String,
name: String,
email: String,
password: String
): AuthOutputModel =
ApiRequests(client, gson).postRequest(
REGISTER_URL,
"{\"username\":\"$username\"," +
"\"name\":\"$name\"," +
"\"email\":\"$email\"," +
"\"password\":\"$password\"}"
)
override suspend fun login(emailOrName: String, password: String): AuthOutputModel =
ApiRequests(client, gson).postRequest(
LOGIN_URL,
"{\"emailOrName\":\"$emailOrName\",\"password\":\"$password\"}"
)
override suspend fun logout(accessToken: String, refreshToken: String): Unit =
ApiRequests(client, gson).postRequest(
LOGOUT_URL,
"{}",
accessToken = accessToken,
refreshToken = refreshToken,
)
override suspend fun fetchUserInfo(uID: Int): User =
ApiRequests(client, gson).getRequest(
"$USER_URL/$uID"
)
override suspend fun editUser(uID: Int, name: String, interests: List<String>, description: String) {
val userData = EditUserInputModel(name, interests, description)
return ApiRequests(client, gson).putRequest(
"$USER_URL/$uID/edit",
gson.toJson(userData).toString()
)
}
}
| planit-mobile/app/src/main/java/com/example/planit_mobile/services/providers/UserProvider.kt | 3063211873 |
package com.example.planit_mobile.services.providers
import com.example.planit_mobile.services.EventService
import com.google.gson.Gson
import okhttp3.OkHttpClient
class EventProvider(
private val client: OkHttpClient,
private val gson: Gson,
): EventService {
override suspend fun createEvent(
title: String,
description: String?,
category: String,
subcategory: String?,
location: String?,
visibility: String?,
date: String?,
endDate: String?,
price: String?,
userID: Int
) {}
override suspend fun fetchEventInfo(eventID: Int) {}
override suspend fun getUsersInEvent(eventID: Int) {}
} | planit-mobile/app/src/main/java/com/example/planit_mobile/services/providers/EventProvider.kt | 2411662221 |
package com.example.planit_mobile.services.utils
object PathTemplates {
const val PLANIT_API_URL = "http://10.0.2.2:1904/api-planit"
/**
* User paths
*/
const val REGISTER_URL = "${PLANIT_API_URL}/register"
const val LOGIN_URL = "${PLANIT_API_URL}/login"
const val LOGOUT_URL = "${PLANIT_API_URL}/logout"
const val USER_URL = "${PLANIT_API_URL}/user"
/**
* Event paths
*/
const val CREATE_EVENT = "${PLANIT_API_URL}/event"
const val GET_EVENT = "${PLANIT_API_URL}/event/{id}"
const val USERS_IN_EVENT = "${PLANIT_API_URL}/event/{id}/users"
}
| planit-mobile/app/src/main/java/com/example/planit_mobile/services/utils/PathTemplates.kt | 1338775058 |
package com.example.planit_mobile.services.utils
import android.util.Log
import com.example.planit_mobile.services.ErrorResponse
import com.google.gson.Gson
import kotlinx.coroutines.suspendCancellableCoroutine
import okhttp3.Call
import okhttp3.Callback
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import okhttp3.Response
import java.io.IOException
import kotlin.coroutines.resumeWithException
class ApiRequests(val client: OkHttpClient, val gson: Gson) {
val setCookie = "Cookie"
suspend inline fun <reified R> postRequest(
url: String,
data: String? = null,
accessToken: String? = null,
refreshToken: String? = null
): R {
val req = Request.Builder().url(url)
.addHeader("accept", "application/json")
.addHeader(setCookie, "access_token=$accessToken")
.addHeader(setCookie, "refresh_token=$refreshToken")
if (data != null) {
req.post(data.toRequestBody("application/json; charset=utf-8".toMediaType()))
}
return callApi(req.build())
}
suspend inline fun <reified R> putRequest(
url: String,
data: String,
accessToken: String? = null,
refreshToken: String? = null
): R {
val req = Request.Builder().url(url)
.addHeader("accept", "application/json")
.addHeader(setCookie, "access_token=$accessToken")
.addHeader(setCookie, "refresh_token=$refreshToken")
.put(data.toRequestBody("application/json; charset=utf-8".toMediaType()))
return callApi(req.build())
}
suspend inline fun <reified R> getRequest(
url: String,
accessToken: String? = null,
refreshToken: String? = null,
): R {
val req = Request.Builder().url(url).addHeader("accept", "application/json")
.addHeader(setCookie, "access_token=$accessToken")
.addHeader(setCookie, "refresh_token=$refreshToken")
.build()
return callApi(req)
}
suspend inline fun <reified R> callApi(
request: Request
): R = suspendCancellableCoroutine {
val call = client.newCall(request)
call.enqueue(object : Callback {
override fun onFailure(call: Call, e: IOException) {
it.resumeWithException(Exception("Failure", e))
}
override fun onResponse(call: Call, response: Response) {
val bodyRes = response.body
if (!response.isSuccessful || bodyRes == null) {
val errorResponse = gson.fromJson(bodyRes?.string(), ErrorResponse::class.java)
it.resumeWithException(Exception(" ${errorResponse.error}."))
} else {
it.resumeWith(
Result.success(
gson.fromJson(
bodyRes.string(),
R::class.java,
),
),
)
}
}
})
it.invokeOnCancellation { call.cancel() }
}
} | planit-mobile/app/src/main/java/com/example/planit_mobile/services/utils/ApiCallsUtils.kt | 1711129894 |
package com.example.planit_mobile.services.utils
import android.util.Log
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.myapplication.sessionStorage.SessionDataStore
import kotlinx.coroutines.launch
suspend fun <T> executeRequest(
request: suspend () -> T,
onSuccess: suspend (T) -> Unit,
onFailure: suspend (Throwable) -> Unit
){
val response = runCatching { request() }
if (response.isSuccess) {
response.getOrNull()?.let { onSuccess(it) }
}
if(response.isFailure){
onFailure(response.exceptionOrNull()!!)
}
}
fun <T> ViewModel.launchAndRequest(
request: suspend () -> T,
onSuccess: suspend (T) -> Unit,
onFailure: suspend (Throwable) -> Unit
) {
viewModelScope.launch {
executeRequest(request, onSuccess, onFailure)
}
}
fun <T> ViewModel.launchAndAuthenticateRequest(
request: suspend (accessToken: String, refreshToken: String, userId: Int) -> T,
onSuccess: suspend (T, accessToken: String, refreshToken: String, userID: Int) -> Unit = { _, _, _, _ -> },
onFailure: suspend (Throwable) -> Unit,
sessionStorage: SessionDataStore
) {
viewModelScope.launch {
val userAccessToken = sessionStorage.getSessionAccessToken()
val userRefreshToken = sessionStorage.getSessionRefreshToken()
val userID = sessionStorage.getUserID()
if (userAccessToken == null || userRefreshToken == null || userID == null) {
return@launch
}
val result = request(userAccessToken, userRefreshToken, userID)
executeRequest(
request = { result },
onSuccess = { onSuccess(result, userAccessToken, userRefreshToken, userID) },
onFailure = onFailure
)
}
}
| planit-mobile/app/src/main/java/com/example/planit_mobile/services/utils/RequestUtils.kt | 3811666274 |
package com.example.planit_mobile.services.models
data class AuthOutputModel(
val id: Int,
val accessToken: String,
val refreshToken: String
) | planit-mobile/app/src/main/java/com/example/planit_mobile/services/models/AuthOutputModel.kt | 2551465010 |
package com.example.planit_mobile.services.models
/**
* Represents the input model for editing a user.
* @param name The name of the user.
* @param interests The interests of the user.
* @param description The description of the user.
*/
data class EditUserInputModel (
val name: String,
val interests: List<String>,
val description: String
) | planit-mobile/app/src/main/java/com/example/planit_mobile/services/models/EditUserInputModel.kt | 810881196 |
package com.example.planit_mobile.services
interface EventService {
/**
* Creates a new event with the provided information.
* @param title The title of the new event.
* @param description The description of the new event.
* @param category The category of the new event.
* @param subcategory The subcategory of the new event.
* @param location The location of the new event.
* @param visibility The visibility of the new event.
* @param date The date of the new event.
* @param endDate The end date of the new event.
* @param price The price of the new event.
* @param userID The ID of the user creating the event.
* @return containing the ID of the newly created event, its title and a status message.
*/
suspend fun createEvent(
title: String,
description: String?,
category: String,
subcategory: String?,
location: String?,
visibility: String?,
date: String?,
endDate: String?,
price: String?,
userID: Int
)
/**
* Retrieves the event associated with the given ID.
* @param eventID The ID of the event to retrieve.
* @return The event associated with the ID.
*/
suspend fun fetchEventInfo(eventID: Int)
/**
* Retrieves the users in the event associated with the given ID.
* @param eventID The ID of the event to retrieve the users from.
* @return The users in the event associated with the ID.
*/
suspend fun getUsersInEvent(eventID: Int)
} | planit-mobile/app/src/main/java/com/example/planit_mobile/services/EventService.kt | 2802529909 |
package com.example.planit_mobile.services
import com.example.planit_mobile.domain.User
import com.example.planit_mobile.services.models.AuthOutputModel
/**
* Interface for interacting with user-related operations in the PlanIt application.
*/
interface UserService {
/**
* Registers a new user in the PlanIt application.
*
* @param username The username of the user.
* @param name The name of the user.
* @param email The email address of the user.
* @param password The password for the user account.
* @return The authentication tokens for the newly registered user.
*/
suspend fun register(
username: String,
name: String,
email: String,
password: String
): AuthOutputModel
/**
* Logs in a user with the provided email and password.
*
* @param emailOrName The email address or the name of the user.
* @param password The password for the user account.
* @return The authentication tokens for the logged-in user.
*/
suspend fun login(emailOrName: String, password: String): AuthOutputModel
/**
* Logs out the user with the specified access and refresh tokens.
*
* @param accessToken The access token for authentication.
* @param refreshToken The refresh token for obtaining a new access token.
*/
suspend fun logout(accessToken: String, refreshToken: String)
/**
* Fetches information about a specific user.
*
* @param uID The unique identifier of the user.
* @return The details of the requested user.
*/
suspend fun fetchUserInfo(uID: Int): User
/**
* Edits the interests and description of a user.
*
* @param uID The unique identifier of the user.
* @param name The name of the user.
* @param interests The interests of the user.
* @param description The description of the user.
*/
suspend fun editUser(uID: Int, name: String, interests: List<String>, description: String)
}
| planit-mobile/app/src/main/java/com/example/planit_mobile/services/UserService.kt | 1137007297 |
package dev.kata.stringcalculator
import org.assertj.core.api.Assertions.*
import org.junit.jupiter.api.Test
internal class EmployeeReportShould {
@Test
fun `obtainAdultsEmployees`() {
val employee1 = Employee("Marcos", 30)
val employee2 = Employee("Ismael", 15)
val employee3 = Employee("Kika", 34)
val employee4 = Employee("Anabel", 27)
val employee5 = Employee("Sonia", 17)
var report = Report()
report.addEmployee(employee1)
report.addEmployee(employee2)
report.addEmployee(employee3)
report.addEmployee(employee4)
report.addEmployee(employee5)
var listAdults: MutableList<Employee> = arrayListOf()
for (employee in report.getList()) {
if (employee.age >= 18) {
listAdults.add(employee)
}
}
val result = listAdults.count()
assertThat(result).isEqualTo(3)
}
@Test
fun `obtainEmployeesSorted`() {
val employee1 = Employee("Marcos", 30)
val employee2 = Employee("Ismael", 15)
val employee3 = Employee("Kika", 34)
val employee4 = Employee("Anabel", 27)
val employee5 = Employee("Sonia", 17)
var report = Report()
report.addEmployee(employee1)
report.addEmployee(employee2)
report.addEmployee(employee3)
report.addEmployee(employee4)
report.addEmployee(employee5)
assertThat(report.sortEmployees()[0].name).isEqualTo("Anabel")
for (employee in report.sortEmployees()) {
println(employee.name + " " + employee.age)
}
}
@Test
fun `getCapitalizedList`() {
val employee1 = Employee("Marcos", 30)
val employee2 = Employee("Ismael", 15)
val employee3 = Employee("Kika", 34)
val employee4 = Employee("Anabel", 27)
val employee5 = Employee("Sonia", 17)
var report = Report()
report.addEmployee(employee1)
report.addEmployee(employee2)
report.addEmployee(employee3)
report.addEmployee(employee4)
report.addEmployee(employee5)
assertThat(report.capitalizedLetters()[0].name).isEqualTo("MARCOS")
for (employee in report.capitalizedLetters()) {
println(employee.name + " " + employee.age)
}
}
@Test
fun `descendingOrder`() {
val employee1 = Employee("Marcos", 30)
val employee2 = Employee("Ismael", 15)
val employee3 = Employee("Kika", 34)
val employee4 = Employee("Anabel", 27)
val employee5 = Employee("Sonia", 17)
var report = Report()
report.addEmployee(employee1)
report.addEmployee(employee2)
report.addEmployee(employee3)
report.addEmployee(employee4)
report.addEmployee(employee5)
for (employee in report.descendingOrder()) {
println(employee.name + " " + employee.age)
}
}
}
| kataEmployeeReport/src/test/kotlin/dev/kata/stringcalculator/EmployeeReportShould.kt | 227254780 |
package dev.kata.stringcalculator
class Employee {
var name : String
var age: Int
constructor(name: String, age: Int) {
this.name = name
this.age = age
}
}
| kataEmployeeReport/src/main/kotlin/dev/kata/stringcalculator/Employee.kt | 2785213412 |
package dev.kata.stringcalculator
class Report {
var employees: MutableList<Employee>
constructor() {
this.employees = arrayListOf()
}
fun getList(): MutableList<Employee> {
return this.employees
}
fun addEmployee(employee: Employee) {
this.employees.add(employee)
}
fun removeEmployee(employee: Employee) {
this.employees.remove(employee)
}
fun sortEmployees(): List<Employee> {
return this.employees.sortedBy { it.name }
}
fun capitalizedLetters(): MutableList<Employee> {
for (employee in this.employees) {
employee.name = employee.name.uppercase()
}
return this.employees
}
fun descendingOrder(): List<Employee> {
return this.employees.sortedBy { it.name }.reversed()
}
} | kataEmployeeReport/src/main/kotlin/dev/kata/stringcalculator/Report.kt | 12345843 |
package dev.kata.stringcalculator
fun main() {
} | kataEmployeeReport/src/main/kotlin/dev/kata/stringcalculator/Main.kt | 1147648471 |
package com.example.starnetvoyager
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.starnetvoyager", appContext.packageName)
}
} | star-net-voyager-android-swapi/app/src/androidTest/java/com/example/starnetvoyager/ExampleInstrumentedTest.kt | 1273037873 |
package com.example.starnetvoyager
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)
}
} | star-net-voyager-android-swapi/app/src/test/java/com/example/starnetvoyager/ExampleUnitTest.kt | 4171346273 |
package com.example.starnetvoyager.ui.home
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import androidx.paging.cachedIn
import androidx.paging.filter
import com.example.starnetvoyager.domain.repository.StarWarsRepository
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.distinctUntilChangedBy
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.mapLatest
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.flow.update
import javax.inject.Inject
@HiltViewModel
class HomeViewModel @Inject constructor(
repository: StarWarsRepository,
) : ViewModel() {
private val _state = MutableStateFlow(HomeUIState.EmptyState)
@OptIn(ExperimentalCoroutinesApi::class)
private val characters =
_state.distinctUntilChangedBy { it.filters.searchQuery }
.mapLatest {
repository.getCharacters(it.filters.searchQuery).cachedIn(viewModelScope)
}
private val filteredCharacters = characters
.combine(_state.distinctUntilChangedBy { it.filters.selectedGender }) { data, state ->
val selectedGender = state.filters.selectedGender
data.map {
it.filter { character ->
when (selectedGender) {
CharacterFilters.Gender.MALE, CharacterFilters.Gender.FEMALE -> {
character.gender.equals(selectedGender.name, true)
}
CharacterFilters.Gender.OTHER -> {
!character.gender.equals(CharacterFilters.Gender.MALE.name, true) &&
!character.gender.equals(
CharacterFilters.Gender.FEMALE.name,
true
)
}
CharacterFilters.Gender.ALL -> true
}
}
}
}
val state = _state.combine(filteredCharacters) { state, characters ->
state.copy(
characters = characters,
filters = state.filters
)
}.stateIn(
viewModelScope,
SharingStarted.WhileSubscribed(5_000),
HomeUIState.EmptyState
)
fun setFilter(filter: CharacterFilters) {
_state.update {
it.copy(
filters = filter
)
}
}
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/ui/home/HomeViewModel.kt | 452443200 |
package com.example.starnetvoyager.ui.home
import androidx.paging.PagingData
import com.example.starnetvoyager.domain.entity.StarWarsCharacter
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.emptyFlow
data class HomeUIState(
val characters: Flow<PagingData<StarWarsCharacter>> = emptyFlow(),
val filters: CharacterFilters = CharacterFilters()
) {
companion object {
val EmptyState = HomeUIState()
}
}
data class CharacterFilters(
val searchQuery: String = "",
val selectedGender: Gender = Gender.ALL
) {
enum class Gender {
MALE,
FEMALE,
OTHER,
ALL
}
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/ui/home/HomeUIState.kt | 3170147919 |
package com.example.starnetvoyager.ui.home.dialog
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.AdapterView
import android.widget.AdapterView.OnItemSelectedListener
import android.widget.ArrayAdapter
import androidx.fragment.app.viewModels
import androidx.lifecycle.flowWithLifecycle
import androidx.lifecycle.lifecycleScope
import com.example.starnetvoyager.R
import com.example.starnetvoyager.databinding.FragmentHomeCharacterFilterBinding
import com.example.starnetvoyager.ui.home.CharacterFilters
import com.example.starnetvoyager.ui.home.HomeViewModel
import com.google.android.material.bottomsheet.BottomSheetDialogFragment
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.launch
class CharacterFilterBottomSheet : BottomSheetDialogFragment() {
private var binding: FragmentHomeCharacterFilterBinding? = null
private val viewModel: HomeViewModel by viewModels({ requireParentFragment() })
private var userSelectedGender: CharacterFilters.Gender? = null
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
return FragmentHomeCharacterFilterBinding
.inflate(
inflater,
container,
false
).also {
binding = it
}.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) = binding?.run {
val items = CharacterFilters.Gender.entries
.map { it.name }
.toTypedArray()
selectGender.adapter = ArrayAdapter(
requireContext(),
R.layout.simple_spinner_item,
items
)
selectGender.onItemSelectedListener =
object : OnItemSelectedListener {
override fun onItemSelected(
parent: AdapterView<*>?,
view: View?,
position: Int,
id: Long
) {
userSelectedGender = CharacterFilters.Gender.entries[position]
}
override fun onNothingSelected(parent: AdapterView<*>?) {}
}
applyFilterBtn.setOnClickListener {
viewModel.setFilter(
CharacterFilters(
searchQuery = characterSearch.text.toString(),
selectedGender = userSelectedGender ?: CharacterFilters.Gender.ALL
)
)
dismiss()
}
viewLifecycleOwner.lifecycleScope.launch {
viewModel.state
.flowWithLifecycle(viewLifecycleOwner.lifecycle)
.collectLatest {
characterSearch.setText(it.filters.searchQuery)
selectGender.setSelection(it.filters.selectedGender.ordinal)
userSelectedGender = it.filters.selectedGender
}
}
return@run
} ?: Unit
override fun onDestroy() {
super.onDestroy()
binding = null
}
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/ui/home/dialog/CharacterFilterBottomSheet.kt | 1369407991 |
package com.example.starnetvoyager.ui.home
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.core.view.isVisible
import androidx.fragment.app.Fragment
import androidx.fragment.app.viewModels
import androidx.lifecycle.flowWithLifecycle
import androidx.lifecycle.lifecycleScope
import androidx.navigation.fragment.findNavController
import androidx.paging.LoadState
import androidx.paging.PagingData
import androidx.recyclerview.widget.GridLayoutManager
import com.example.starnetvoyager.R
import com.example.starnetvoyager.databinding.FragmentHomeBinding
import com.example.starnetvoyager.domain.entity.StarWarsCharacter
import com.example.starnetvoyager.ui.home.dialog.CharacterFilterBottomSheet
import dagger.hilt.android.AndroidEntryPoint
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.flow.distinctUntilChangedBy
import kotlinx.coroutines.launch
@AndroidEntryPoint
class HomeFragment : Fragment() {
private var binding: FragmentHomeBinding? = null
private val viewModel: HomeViewModel by viewModels()
private val charactersAdapter: CharactersAdapter by lazy {
CharactersAdapter {
findNavController().navigate(
HomeFragmentDirections
.actionHomeFragmentToMovieFragment(
it.id,
it.name
)
)
}
}
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View {
return FragmentHomeBinding.inflate(
inflater,
container,
false
).also {
binding = it
}.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) = binding?.run {
setUpAdapter()
setUpObserver()
characterToolbar.setOnMenuItemClickListener {
return@setOnMenuItemClickListener when (it.itemId) {
R.id.character_filter -> {
CharacterFilterBottomSheet().show(childFragmentManager, null)
true
}
else -> false
}
}
return@run
} ?: Unit
private fun setUpObserver() {
viewLifecycleOwner.lifecycleScope.launch {
viewModel.state
.flowWithLifecycle(viewLifecycleOwner.lifecycle)
.distinctUntilChangedBy { it.characters }
.collectLatest {
observePagingData(it.characters)
}
}
}
private fun observePagingData(flow: Flow<PagingData<StarWarsCharacter>>) {
viewLifecycleOwner.lifecycleScope.launch {
flow
.flowWithLifecycle(viewLifecycleOwner.lifecycle)
.collectLatest {
charactersAdapter.submitData(lifecycle, it)
}
}
}
private fun setUpAdapter() = binding?.run {
charactersRecyclerview.apply {
adapter = charactersAdapter
layoutManager = GridLayoutManager(context, 2)
}
charactersAdapter.addLoadStateListener { loadState ->
when (loadState.refresh) {
is LoadState.Loading -> showProgressbar()
is LoadState.NotLoading -> showList()
is LoadState.Error -> {
if (charactersAdapter.snapshot().isEmpty()) {
showErrorMsg(loadState.refresh as LoadState.Error)
} else {
showList()
}
}
}
}
}
private fun showErrorMsg(errorLoadState: LoadState.Error?) = binding?.run {
charactersProgressBar.isVisible = false
charactersRecyclerview.isVisible = false
textViewError.isVisible = true
textViewError.setText(R.string.network_error_msg)
}
private fun showProgressbar() = binding?.run {
charactersProgressBar.isVisible = true
textViewError.isVisible = false
charactersRecyclerview.isVisible = false
}
private fun showList() = binding?.run {
charactersRecyclerview.isVisible = true
textViewError.isVisible = false
charactersProgressBar.isVisible = false
}
override fun onDestroyView() {
super.onDestroyView()
binding = null
}
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/ui/home/HomeFragment.kt | 872800476 |
package com.example.starnetvoyager.ui.home
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.paging.PagingDataAdapter
import androidx.recyclerview.widget.DiffUtil
import androidx.recyclerview.widget.RecyclerView
import com.example.starnetvoyager.databinding.RvItemCharacterBinding
import com.example.starnetvoyager.domain.entity.StarWarsCharacter
class CharactersAdapter(
private val onClickListener: (StarWarsCharacter) -> Unit,
) : PagingDataAdapter<StarWarsCharacter, CharactersAdapter.MyViewHolder>(CHARACTER_COMPARATOR) {
inner class MyViewHolder(private val binding: RvItemCharacterBinding) :
RecyclerView.ViewHolder(binding.root) {
fun bind(character: StarWarsCharacter?) {
binding.character = character
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): MyViewHolder {
return MyViewHolder(
RvItemCharacterBinding.inflate(
LayoutInflater.from(parent.context),
parent,
false
)
)
}
override fun onBindViewHolder(holder: MyViewHolder, position: Int) {
getItem(position)?.let {
holder.bind(it)
holder.itemView.setOnClickListener { _ ->
onClickListener(it)
}
}
}
companion object {
private val CHARACTER_COMPARATOR = object : DiffUtil.ItemCallback<StarWarsCharacter>() {
override fun areItemsTheSame(
oldItem: StarWarsCharacter,
newItem: StarWarsCharacter
): Boolean {
return oldItem.id == newItem.id
}
override fun areContentsTheSame(
oldItem: StarWarsCharacter,
newItem: StarWarsCharacter
): Boolean {
return oldItem == newItem
}
}
}
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/ui/home/CharactersAdapter.kt | 3897561019 |
package com.example.starnetvoyager.ui.movie
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.core.view.isVisible
import androidx.fragment.app.Fragment
import androidx.fragment.app.viewModels
import androidx.lifecycle.flowWithLifecycle
import androidx.lifecycle.lifecycleScope
import androidx.navigation.fragment.findNavController
import androidx.navigation.fragment.navArgs
import androidx.paging.LoadState
import androidx.recyclerview.widget.GridLayoutManager
import com.example.starnetvoyager.R
import com.example.starnetvoyager.databinding.FragmentMovieBinding
import dagger.hilt.android.AndroidEntryPoint
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.launch
@AndroidEntryPoint
class MovieFragment : Fragment() {
private var binding: FragmentMovieBinding? = null
private val viewModel: MovieViewModel by viewModels()
private val args by navArgs<MovieFragmentArgs>()
private val movieAdapter = MovieAdapter()
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View {
return FragmentMovieBinding.inflate(
inflater,
container,
false
).also {
binding = it
}.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) = binding?.run {
topAppBar.setNavigationOnClickListener {
findNavController().navigateUp()
}
topAppBar.title = "Movies of ${args.characterName}"
setUpAdapter()
setUpObserver()
} ?: Unit
private fun setUpObserver() {
viewLifecycleOwner.lifecycleScope.launch {
viewModel.movies
.flowWithLifecycle(viewLifecycleOwner.lifecycle)
.collectLatest {
movieAdapter.submitData(lifecycle, it)
}
}
}
private fun setUpAdapter() = binding?.run {
moviesRecyclerView.apply {
adapter = movieAdapter
layoutManager = GridLayoutManager(context, 2)
}
movieAdapter.addLoadStateListener { loadState ->
when (loadState.refresh) {
is LoadState.Loading -> showProgressbar()
is LoadState.NotLoading -> showList()
is LoadState.Error -> {
if (movieAdapter.snapshot().isEmpty()) {
showErrorMsg(loadState.refresh as LoadState.Error)
} else {
showList()
}
}
}
}
}
private fun showErrorMsg(errorLoadState: LoadState.Error?) = binding?.run {
moviesProgressBar.isVisible = false
moviesProgressBar.isVisible = false
textViewError.isVisible = true
textViewError.setText(R.string.network_error_msg)
}
private fun showProgressbar() = binding?.run {
moviesProgressBar.isVisible = true
textViewError.isVisible = false
moviesRecyclerView.isVisible = false
}
private fun showList() = binding?.run {
moviesRecyclerView.isVisible = true
textViewError.isVisible = false
moviesProgressBar.isVisible = false
}
override fun onDestroyView() {
super.onDestroyView()
binding = null
}
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/ui/movie/MovieFragment.kt | 1884827102 |
package com.example.starnetvoyager.ui.movie
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.paging.PagingDataAdapter
import androidx.recyclerview.widget.DiffUtil
import androidx.recyclerview.widget.RecyclerView
import com.example.starnetvoyager.databinding.RvItemMovieBinding
import com.example.starnetvoyager.domain.entity.StarWarsMovie
class MovieAdapter :
PagingDataAdapter<StarWarsMovie, MovieAdapter.MovieItemViewHolder>(CHARACTER_COMPARATOR) {
inner class MovieItemViewHolder(private val binding: RvItemMovieBinding) :
RecyclerView.ViewHolder(binding.root) {
fun bind(film: StarWarsMovie?) {
binding.film = film
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): MovieItemViewHolder {
return MovieItemViewHolder(
RvItemMovieBinding.inflate(
LayoutInflater.from(parent.context),
parent,
false
)
)
}
override fun onBindViewHolder(holder: MovieItemViewHolder, position: Int) {
getItem(position)?.let {
holder.bind(it)
}
}
companion object {
private val CHARACTER_COMPARATOR = object : DiffUtil.ItemCallback<StarWarsMovie>() {
override fun areItemsTheSame(oldItem: StarWarsMovie, newItem: StarWarsMovie): Boolean {
return oldItem.id == newItem.id
}
override fun areContentsTheSame(
oldItem: StarWarsMovie,
newItem: StarWarsMovie
): Boolean {
return oldItem == newItem
}
}
}
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/ui/movie/MovieAdapter.kt | 2970292702 |
package com.example.starnetvoyager.ui.movie
import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import androidx.paging.cachedIn
import com.example.starnetvoyager.domain.repository.StarWarsRepository
import dagger.hilt.android.lifecycle.HiltViewModel
import javax.inject.Inject
@HiltViewModel
class MovieViewModel @Inject constructor(
repository: StarWarsRepository,
savedStateHandle: SavedStateHandle,
) : ViewModel() {
val movies = repository
.getMovies(MovieFragmentArgs.fromSavedStateHandle(savedStateHandle).charcterId)
.cachedIn(viewModelScope)
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/ui/movie/MovieViewModel.kt | 4250805158 |
package com.example.starnetvoyager.ui
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import com.example.starnetvoyager.R
import dagger.hilt.android.AndroidEntryPoint
@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
}
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/ui/MainActivity.kt | 1879009864 |
package com.example.starnetvoyager.di
import android.content.Context
import com.example.starnetvoyager.data.local.StarWarsDataStore
import com.example.starnetvoyager.data.network.StarWarsDataSource
import com.example.starnetvoyager.data.repository.StarWarsRepositoryImpl
import com.example.starnetvoyager.domain.repository.StarWarsRepository
import dagger.Binds
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.qualifiers.ApplicationContext
import dagger.hilt.components.SingletonComponent
import okhttp3.OkHttpClient
import retrofit2.Converter
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import java.util.concurrent.TimeUnit
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
abstract class AppModule {
companion object {
@Singleton
@Provides
fun providesBaseUrl(): String {
return "https://swapi.dev/api/"
}
@Singleton
@Provides
fun providesConverterFactory(): Converter.Factory {
return GsonConverterFactory.create()
}
@Singleton
@Provides
fun providesOkHttpClient(): OkHttpClient = OkHttpClient.Builder()
.connectTimeout(10, TimeUnit.SECONDS)
.writeTimeout(10, TimeUnit.SECONDS)
.readTimeout(10, TimeUnit.SECONDS)
.build();
@Singleton
@Provides
fun providesRetrofit(
baseUrl: String,
converterFactory: Converter.Factory,
okHttpClient: OkHttpClient
): Retrofit {
val retrofit = Retrofit.Builder()
.baseUrl(baseUrl)
.client(okHttpClient)
.addConverterFactory(converterFactory)
return retrofit.build()
}
@Singleton
@Provides
fun providesStarWarsDataSource(retrofit: Retrofit): StarWarsDataSource =
retrofit.create(StarWarsDataSource::class.java)
@Singleton
@Provides
fun providesStarWarsDataStore(@ApplicationContext context: Context) =
StarWarsDataStore.createDatabase(context)
}
@Singleton
@Binds
abstract fun providesStarWarsRepository(repositoryImpl: StarWarsRepositoryImpl):
StarWarsRepository
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/di/AppModule.kt | 116022643 |
package com.example.starnetvoyager
import android.app.Application
import dagger.hilt.android.HiltAndroidApp
@HiltAndroidApp
class StarNetVoyagerApp: Application() | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/StarNetVoyagerApp.kt | 1476539177 |
package com.example.starnetvoyager.data.repository
import androidx.paging.ExperimentalPagingApi
import androidx.paging.Pager
import androidx.paging.PagingConfig
import androidx.paging.PagingData
import androidx.paging.map
import com.example.starnetvoyager.data.local.StarWarsDataStore
import com.example.starnetvoyager.data.local.entity.toDomain
import com.example.starnetvoyager.data.network.StarWarsDataSource
import com.example.starnetvoyager.data.repository.paging.CharacterRemoteMediator
import com.example.starnetvoyager.data.repository.paging.FilmRemoteMediator
import com.example.starnetvoyager.domain.entity.StarWarsCharacter
import com.example.starnetvoyager.domain.entity.StarWarsMovie
import com.example.starnetvoyager.domain.repository.StarWarsRepository
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map
import javax.inject.Inject
class StarWarsRepositoryImpl @Inject constructor(
private val starWarsDataSource: StarWarsDataSource,
private val starWarsDataStore: StarWarsDataStore
) : StarWarsRepository {
@OptIn(ExperimentalPagingApi::class)
override fun getCharacters(searchQuery: String?): Flow<PagingData<StarWarsCharacter>> = Pager(
config = PagingConfig(
pageSize = 10,
maxSize = 100,
),
remoteMediator = CharacterRemoteMediator(
searchQuery,
starWarsDataStore,
starWarsDataSource
),
pagingSourceFactory = { starWarsDataStore.characterDao().getCharacters(searchQuery) }
).flow
.map { it.map { character -> character.toDomain() } }
@OptIn(ExperimentalPagingApi::class)
override fun getMovies(characterId: Int): Flow<PagingData<StarWarsMovie>> = Pager(
config = PagingConfig(
pageSize = 10,
maxSize = 100,
),
remoteMediator = FilmRemoteMediator(
starWarsDataStore,
starWarsDataSource,
characterId
),
pagingSourceFactory = { starWarsDataStore.filmDao().getFilmsOfCharacter(characterId) }
).flow
.map { it.map { movie -> movie.toDomain() } }
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/data/repository/StarWarsRepositoryImpl.kt | 3262745525 |
package com.example.starnetvoyager.data.repository.paging
import androidx.core.net.toUri
import androidx.paging.ExperimentalPagingApi
import androidx.paging.LoadType
import androidx.paging.PagingState
import androidx.paging.RemoteMediator
import androidx.room.withTransaction
import com.example.starnetvoyager.data.local.StarWarsDataStore
import com.example.starnetvoyager.data.local.entity.Film
import com.example.starnetvoyager.data.local.entity.Film.Companion.toFilm
import com.example.starnetvoyager.data.local.entity.FilmCharacterRelation
import com.example.starnetvoyager.data.network.StarWarsDataSource
import kotlinx.coroutines.async
import kotlinx.coroutines.awaitAll
import kotlinx.coroutines.coroutineScope
import kotlin.math.ceil
import kotlin.math.min
@ExperimentalPagingApi
class FilmRemoteMediator(
private val starWarsDataStore: StarWarsDataStore,
private val starWarDataSource: StarWarsDataSource,
private val characterId: Int
) : RemoteMediator<Int, Film>() {
private val filmDao = starWarsDataStore.filmDao()
private val filmCharacterDao = starWarsDataStore.filmCharacterDao()
private var filmIds = emptyList<Int>()
override suspend fun load(
loadType: LoadType,
state: PagingState<Int, Film>
): MediatorResult {
return try {
val currentPage = when (loadType) {
LoadType.REFRESH -> {
fetchFilmsId(characterId)
val page = getPageClosestToCurrentPosition(state)
page?.value ?: 1
}
LoadType.PREPEND -> {
val page = getFirstPage(state)
val prevPage = page?.value?.minus(1)
?: return MediatorResult.Success(
endOfPaginationReached = page != null
)
prevPage
}
LoadType.APPEND -> {
val page = getLastPage(state)
val nextPage = page?.value?.plus(1)
?: return MediatorResult.Success(
endOfPaginationReached = page != null
)
nextPage
}
}
val response = fetchFilms(
filmIds.subList(
(currentPage - 1) * state.config.pageSize,
min(currentPage * state.config.pageSize, filmIds.size)
)
)
val endOfPaginationReached = currentPage * state.config.pageSize >= filmIds.size
starWarsDataStore.withTransaction {
if (loadType == LoadType.REFRESH) {
filmCharacterDao.deleteFilmRelationOfCharacter(characterId)
}
val ids = filmDao.insertFilms(response.map { it.toFilm() })
val relations = List(response.size) { i ->
FilmCharacterRelation(
filmId = ids[i].toInt(),
characterId = characterId
)
}
filmCharacterDao.insertFilmCharacterRelations(relations)
}
MediatorResult.Success(endOfPaginationReached)
} catch (e: Exception) {
MediatorResult.Error(e)
}
}
private suspend fun fetchFilmsId(characterId: Int) {
val characterResponse = starWarDataSource.getCharacterFilm(characterId)
filmIds = characterResponse.films.map {
it.toUri().lastPathSegment?.toIntOrNull() ?: 0
}
}
private suspend fun fetchFilms(filmIds: List<Int>) = coroutineScope {
filmIds
.map { async { starWarDataSource.getFilm(it) } }
.awaitAll()
}
private fun getPageClosestToCurrentPosition(
state: PagingState<Int, Film>
): PageNum? {
return state.anchorPosition?.let { position ->
state.closestItemToPosition(position)?.id?.let { id ->
val filmIndex = filmIds.indexOfFirst { it == id } + 1
val num = ceil(filmIndex.toFloat() / state.config.pageSize).toInt()
PageNum(num)
}
}
}
private fun getFirstPage(
state: PagingState<Int, Film>
): PageNum? {
return state.pages.firstOrNull { it.data.isNotEmpty() }?.data?.firstOrNull()
?.let { film ->
val filmIndex = filmIds.indexOfFirst { it == film.id } + 1
val num = if (filmIndex == 1)
null
else
ceil(filmIndex.toFloat() / state.config.pageSize).toInt()
return PageNum(num)
}
}
private fun getLastPage(
state: PagingState<Int, Film>
): PageNum? {
return state.pages.lastOrNull { it.data.isNotEmpty() }?.data?.lastOrNull()
?.let { film ->
val filmIndex = filmIds.indexOfFirst { it == film.id } + 1
val num = if (filmIndex == filmIds.size)
null
else
ceil(filmIndex.toFloat() / state.config.pageSize).toInt()
return PageNum(num)
}
}
}
private data class PageNum(val value: Int?) | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/data/repository/paging/FilmRemoteMediator.kt | 2842754025 |
package com.example.starnetvoyager.data.repository.paging
import androidx.paging.ExperimentalPagingApi
import androidx.paging.LoadType
import androidx.paging.PagingState
import androidx.paging.RemoteMediator
import androidx.room.withTransaction
import com.example.starnetvoyager.data.local.StarWarsDataStore
import com.example.starnetvoyager.data.local.entity.Character
import com.example.starnetvoyager.data.local.entity.Character.Companion.toCharacter
import com.example.starnetvoyager.data.local.entity.CharacterRemoteKey
import com.example.starnetvoyager.data.network.StarWarsDataSource
@ExperimentalPagingApi
class CharacterRemoteMediator(
private val searchQuery: String?,
private val starWarsDataStore: StarWarsDataStore,
private val starWarsDataSource: StarWarsDataSource
) : RemoteMediator<Int, Character>() {
private val characterDao = starWarsDataStore.characterDao()
private val characterRemoteKeyDao = starWarsDataStore.characterRemoteKeyDao()
override suspend fun load(
loadType: LoadType,
state: PagingState<Int, Character>
): MediatorResult {
return try {
val currentPage = when (loadType) {
LoadType.REFRESH -> {
val remoteKeys = getRemoteKeyClosestToCurrentPosition(state)
remoteKeys?.nextPage?.minus(1) ?: 1
}
LoadType.PREPEND -> {
val remoteKeys = getRemoteKeyForFirstItem(state)
val prevPage = remoteKeys?.prevPage
?: return MediatorResult.Success(
endOfPaginationReached = remoteKeys != null
)
prevPage
}
LoadType.APPEND -> {
val remoteKeys = getRemoteKeyForLastItem(state)
val nextPage = remoteKeys?.nextPage
?: return MediatorResult.Success(
endOfPaginationReached = remoteKeys != null
)
nextPage
}
}
val response = starWarsDataSource.getCharacters(searchQuery.orEmpty(), currentPage)
val endOfPaginationReached = response.nextPageUrl == null
val prevPage = if (currentPage == 1) null else currentPage - 1
val nextPage = if (endOfPaginationReached) null else currentPage + 1
starWarsDataStore.withTransaction {
if (loadType == LoadType.REFRESH) {
characterRemoteKeyDao.deleteAllRemoteKeys()
if (searchQuery.isNullOrBlank()) {
characterDao.deleteCharacters()
}
}
val ids = characterDao.insertCharacters(response.results.map { it.toCharacter() })
val keys = List(response.results.size) { i ->
CharacterRemoteKey(
id = ids[i].toInt(),
prevPage = prevPage,
nextPage = nextPage
)
}
characterRemoteKeyDao.addAllRemoteKeys(keys)
}
MediatorResult.Success(endOfPaginationReached)
} catch (e: Exception) {
MediatorResult.Error(e)
}
}
private suspend fun getRemoteKeyClosestToCurrentPosition(
state: PagingState<Int, Character>
): CharacterRemoteKey? {
return state.anchorPosition?.let { position ->
state.closestItemToPosition(position)?.id?.let { id ->
characterRemoteKeyDao.getRemoteKeys(id = id)
}
}
}
private suspend fun getRemoteKeyForFirstItem(
state: PagingState<Int, Character>
): CharacterRemoteKey? {
return state.pages.firstOrNull { it.data.isNotEmpty() }?.data?.firstOrNull()
?.let { character ->
characterRemoteKeyDao.getRemoteKeys(id = character.id)
}
}
private suspend fun getRemoteKeyForLastItem(
state: PagingState<Int, Character>
): CharacterRemoteKey? {
return state.pages.lastOrNull { it.data.isNotEmpty() }?.data?.lastOrNull()
?.let { character ->
characterRemoteKeyDao.getRemoteKeys(id = character.id)
}
}
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/data/repository/paging/CharacterRemoteMediator.kt | 599963057 |
package com.example.starnetvoyager.data.network
import com.example.starnetvoyager.data.network.model.CharacterFilms
import com.example.starnetvoyager.data.network.model.FilmResponse
import com.example.starnetvoyager.data.network.model.PeopleResponse
import retrofit2.http.GET
import retrofit2.http.Path
import retrofit2.http.Query
import retrofit2.http.Url
interface StarWarsDataSource {
@GET("people")
suspend fun getCharacters(@Query("page") page: Int): PeopleResponse
@GET
suspend fun getFilm(@Url url: String): FilmResponse
@GET("films/{id}")
suspend fun getFilm(@Path("id") id: Int): FilmResponse
@GET("people/{id}")
suspend fun getCharacterFilm(@Path("id") id: Int): CharacterFilms
@GET("people")
suspend fun getCharacters(
@Query("search") query: String,
@Query("page") page: Int
): PeopleResponse
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/data/network/StarWarsDataSource.kt | 2474498499 |
package com.example.starnetvoyager.data.network.model
import com.google.gson.annotations.SerializedName
data class PeopleResponse(
@SerializedName("count")
val count: Int,
@SerializedName("next")
val nextPageUrl: String?,
@SerializedName("previous")
val previousPageUrl: String?,
@SerializedName("results")
val results: List<CharacterResponse>
) | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/data/network/model/PeopleResponse.kt | 3777534370 |
package com.example.starnetvoyager.data.network.model
import androidx.core.net.toUri
import com.google.gson.annotations.SerializedName
data class CharacterResponse(
@SerializedName("birth_year")
val birthYear: String,
@SerializedName("eye_color")
val eyeColor: String,
@SerializedName("films")
val films: List<String>,
@SerializedName("gender")
val gender: String,
@SerializedName("hair_color")
val hairColor: String,
@SerializedName("height")
val height: String,
@SerializedName("homeworld")
val homeworld: String,
@SerializedName("mass")
val mass: String,
@SerializedName("name")
val name: String,
@SerializedName("skin_color")
val skinColor: String,
@SerializedName("url")
val url: String
) {
val id: Int
get() = url
.toUri()
.lastPathSegment
?.toInt() ?: 0
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/data/network/model/CharacterResponse.kt | 454003848 |
package com.example.starnetvoyager.data.network.model
import com.google.gson.annotations.SerializedName
data class CharacterFilms(
@SerializedName("films")
val films: List<String>,
) | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/data/network/model/CharacterFilms.kt | 1353564491 |
package com.example.starnetvoyager.data.network.model
import androidx.core.net.toUri
import com.google.gson.annotations.SerializedName
data class FilmResponse(
@SerializedName("opening_crawl")
val openingCrawl: String,
@SerializedName("title")
val title: String,
@SerializedName("url")
val url: String
) {
val id: Int
get() = url
.toUri()
.lastPathSegment
?.toInt() ?: 0
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/data/network/model/FilmResponse.kt | 3963325726 |
package com.example.starnetvoyager.data.local
import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
import com.example.starnetvoyager.data.local.dao.CharacterDao
import com.example.starnetvoyager.data.local.dao.CharacterRemoteKeyDao
import com.example.starnetvoyager.data.local.dao.FilmCharacterDao
import com.example.starnetvoyager.data.local.dao.FilmDao
import com.example.starnetvoyager.data.local.entity.Character
import com.example.starnetvoyager.data.local.entity.CharacterRemoteKey
import com.example.starnetvoyager.data.local.entity.Film
import com.example.starnetvoyager.data.local.entity.FilmCharacterRelation
@Database(
entities = [
Character::class,
CharacterRemoteKey::class,
Film::class,
FilmCharacterRelation::class
],
version = 1
)
abstract class StarWarsDataStore : RoomDatabase() {
abstract fun characterDao(): CharacterDao
abstract fun characterRemoteKeyDao(): CharacterRemoteKeyDao
abstract fun filmDao(): FilmDao
abstract fun filmCharacterDao(): FilmCharacterDao
companion object {
private const val DATABASE_NAME = "star_net_voyager_database"
fun createDatabase(context: Context) =
Room
.databaseBuilder(
context,
StarWarsDataStore::class.java,
DATABASE_NAME
)
.build()
}
}
| star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/data/local/StarWarsDataStore.kt | 111024131 |
package com.example.starnetvoyager.data.local.entity
import androidx.room.ColumnInfo
import androidx.room.Entity
import androidx.room.PrimaryKey
import com.example.starnetvoyager.data.network.model.CharacterResponse
import com.example.starnetvoyager.domain.entity.StarWarsCharacter
@Entity(tableName = "character")
data class Character(
@PrimaryKey(autoGenerate = false)
@ColumnInfo(TableInfo.ID_COLUMN_NAME)
val id: Int,
@ColumnInfo(name = TableInfo.NAME_COLUMN_NAME)
val name: String,
@ColumnInfo(name = TableInfo.GENDER_COLUMN_NAME)
val gender: String,
@ColumnInfo(name = TableInfo.HEIGHT_COLUMN_NAME)
val height: String,
@ColumnInfo(name = TableInfo.BIRTH_YEAR_COLUMN_NAME)
val birthYear: String,
) {
object TableInfo {
const val ID_COLUMN_NAME = "id"
const val NAME_COLUMN_NAME = "name"
const val GENDER_COLUMN_NAME = "gender"
const val HEIGHT_COLUMN_NAME = "height"
const val BIRTH_YEAR_COLUMN_NAME = "birth_year"
}
companion object {
fun CharacterResponse.toCharacter() = Character(
name = name,
gender = gender,
height = height,
birthYear = birthYear,
id = id
)
}
}
fun Character.toDomain() = StarWarsCharacter(
id = id,
name = name,
gender = gender,
height = height,
birthYear = birthYear
)
| star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/data/local/entity/Character.kt | 520870415 |
package com.example.starnetvoyager.data.local.entity
import androidx.room.ColumnInfo
import androidx.room.Entity
@Entity(
tableName = "film_character",
primaryKeys = [
FilmCharacterRelation.TableInfo.FILM_ID_COLUMN_NAME,
FilmCharacterRelation.TableInfo.CHARACTER_ID_COLUMN_NAME
],
)
data class FilmCharacterRelation(
@ColumnInfo(TableInfo.FILM_ID_COLUMN_NAME)
val filmId: Int,
@ColumnInfo(TableInfo.CHARACTER_ID_COLUMN_NAME)
val characterId: Int,
) {
object TableInfo {
const val FILM_ID_COLUMN_NAME = "film_id"
const val CHARACTER_ID_COLUMN_NAME = "character_id"
}
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/data/local/entity/FilmCharacterRelation.kt | 3039589893 |
package com.example.starnetvoyager.data.local.entity
import androidx.room.ColumnInfo
import androidx.room.Entity
import androidx.room.PrimaryKey
@Entity(tableName = "character_remote_key")
data class CharacterRemoteKey(
@PrimaryKey(autoGenerate = false)
val id: Int = 0,
@ColumnInfo(name = "prev_page")
val prevPage: Int? = null,
@ColumnInfo(name = "next_page")
val nextPage: Int? = null
) | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/data/local/entity/CharacterRemoteKey.kt | 1998728104 |
package com.example.starnetvoyager.data.local.entity
import androidx.room.ColumnInfo
import androidx.room.Entity
import androidx.room.PrimaryKey
import com.example.starnetvoyager.data.network.model.FilmResponse
import com.example.starnetvoyager.domain.entity.StarWarsMovie
@Entity
data class Film(
@PrimaryKey(autoGenerate = false)
@ColumnInfo(TableInfo.ID_COLUMN_NAME)
val id: Int,
@ColumnInfo(TableInfo.OPENING_CRAWL_COLUMN_NAME)
val openingCrawl: String,
@ColumnInfo(TableInfo.TITLE_COLUMN_NAME)
val title: String
) {
object TableInfo {
const val ID_COLUMN_NAME = "id"
const val OPENING_CRAWL_COLUMN_NAME = "opening_crawl"
const val TITLE_COLUMN_NAME = "title"
}
companion object {
fun FilmResponse.toFilm() = Film(
id = id,
openingCrawl = openingCrawl,
title = title
)
}
}
fun Film.toDomain() = StarWarsMovie(
id = id,
openingCrawl = openingCrawl,
title = title
)
| star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/data/local/entity/Film.kt | 359683112 |
package com.example.starnetvoyager.data.local.dao
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import com.example.starnetvoyager.data.local.entity.CharacterRemoteKey
@Dao
interface CharacterRemoteKeyDao {
@Query("SELECT * FROM character_remote_key WHERE id =:id")
suspend fun getRemoteKeys(id: Int): CharacterRemoteKey
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun addAllRemoteKeys(remoteKeys: List<CharacterRemoteKey>): List<Long>
@Query("DELETE FROM character_remote_key")
suspend fun deleteAllRemoteKeys()
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/data/local/dao/CharacterRemoteKeyDao.kt | 2760445228 |
package com.example.starnetvoyager.data.local.dao
import androidx.paging.PagingSource
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import com.example.starnetvoyager.data.local.entity.Film
@Dao
interface FilmDao {
@Query(
"SELECT * FROM film " +
"INNER JOIN film_character fc on film_id == film.id " +
"WHERE fc.character_id = :characterId"
)
fun getFilmsOfCharacter(characterId: Int): PagingSource<Int, Film>
@Query(
"DELETE FROM film " +
"WHERE id in (SELECT film_id FROM film_character fc WHERE fc.character_id = :characterId)"
)
fun deleteFilmsOfCharacter(characterId: Int)
@Insert(onConflict = OnConflictStrategy.REPLACE)
fun insertFilms(films: List<Film>): List<Long>
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/data/local/dao/FilmDao.kt | 3475407161 |
package com.example.starnetvoyager.data.local.dao
import androidx.paging.PagingSource
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import com.example.starnetvoyager.data.local.entity.Character
@Dao
interface CharacterDao {
@Query("SELECT * FROM character")
fun getCharacters(): PagingSource<Int, Character>
@Query(
"SELECT * FROM character " +
"WHERE (" +
" :searchQuery is null or " +
" LENGTH(:searchQuery) = 0 or " +
" character.name LIKE '%' || :searchQuery || '%'" +
" )"
)
fun getCharacters(searchQuery: String?): PagingSource<Int, Character>
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun insertCharacters(characters: List<Character>): List<Long>
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun insertCharacter(character: Character): Long
@Query("DELETE FROM character")
suspend fun deleteCharacters()
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/data/local/dao/CharacterDao.kt | 327022230 |
package com.example.starnetvoyager.data.local.dao
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.Query
import com.example.starnetvoyager.data.local.entity.FilmCharacterRelation
@Dao
interface FilmCharacterDao {
@Insert
fun insertFilmCharacterRelations(relations: List<FilmCharacterRelation>): List<Long>
@Query(
"DELETE FROM film_character WHERE character_id = :characterId"
)
fun deleteFilmRelationOfCharacter(characterId: Int)
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/data/local/dao/FilmCharacterDao.kt | 829252901 |
package com.example.starnetvoyager.domain.repository
import androidx.paging.PagingData
import com.example.starnetvoyager.domain.entity.StarWarsCharacter
import com.example.starnetvoyager.domain.entity.StarWarsMovie
import kotlinx.coroutines.flow.Flow
interface StarWarsRepository {
fun getCharacters(searchQuery: String? = null): Flow<PagingData<StarWarsCharacter>>
fun getMovies(characterId: Int): Flow<PagingData<StarWarsMovie>>
} | star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/domain/repository/StarWarsRepository.kt | 3131811322 |
package com.example.starnetvoyager.domain.entity
data class StarWarsMovie(
val id: Int,
val openingCrawl: String,
val title: String
)
| star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/domain/entity/StarWarsMovie.kt | 3785003059 |
package com.example.starnetvoyager.domain.entity
data class StarWarsCharacter(
val id: Int,
val name: String,
val gender: String,
val height: String,
val birthYear: String,
)
| star-net-voyager-android-swapi/app/src/main/java/com/example/starnetvoyager/domain/entity/StarWarsCharacter.kt | 1314190478 |
mychess/src/test/kotlin/edu/austral/dissis/chess/engine/MessageProviderKtTest.kt | 0 |
|
package edu.austral.dissis.chess.engine
import edu.austral.dissis.chess.engine.game.ChessGame
import edu.austral.dissis.chess.engine.game.ChessGameTypes
import edu.austral.dissis.chess.engine.game.moves.ClassicMove
import edu.austral.dissis.chess.engine.position.Position
import org.junit.jupiter.api.Test
class SetBoardTest {
@Test
fun moveTest() {
val chessGame = ChessGame(ChessGameTypes.CLASSIC.setUpBoard(8, 8), ChessGameTypes.CLASSIC)
val n: Int = chessGame.getNumberOfPlayers()
val players = chessGame.setUpPlayers()
// gameType.getNumberOfPlayers() // chessGame.getPlayers()
val currentPlayersTurn = chessGame.whoseTurnIsIt()
val move = currentPlayersTurn.proposeMove("1,2", "1,4", "PAWN", "WHITE") // Piece, from, to
val canMove = chessGame.canMove(currentPlayersTurn, move)
if (canMove) {
chessGame.move(move)
}
print("First move")
print("\n")
chessGame.printBoard()
print("Second move")
print("\n")
val move1 = currentPlayersTurn.proposeMove("1,7", "1,5", "PAWN", "BLACK") // Piece, from, to
val canMove1 = chessGame.canMove(currentPlayersTurn, move)
if (canMove1) {
chessGame.move(move1)
}
chessGame.printBoard()
print("Third move")
print("\n")
val move2 = currentPlayersTurn.proposeMove("1,4", "1,5", "PAWN", "WHITE") // Piece, from, to
val canMove2 = chessGame.canMove(currentPlayersTurn, move)
if (canMove2) {
chessGame.move(move2)
}
chessGame.printBoard()
}
// val currentPlayersTurn = chessGame.whoseTurnIsIt()
// val move = currentPlayer.proposeMove() // Piece, from, to
// chessGame.canMove(currentPlayersTurn, move)
// if(canMove) { chessGame.move() } else { proposeMove() }
// printBoard()
// checkEndConditions()
/// loop
// move1.validate() // rules [].filter(rule -> rule.doesBreakRule(move, board)).isEmpty()
// enforceGameRules() // game.getMovementRules()
// for(rule in rules) { if (rule.doesBreakRule(move, board)) throw Exception("Invalid move") }
}
| mychess/src/test/kotlin/edu/austral/dissis/chess/engine/SetBoardTest.kt | 2402340706 |
package edu.austral.dissis.chess.engine.board;
import edu.austral.dissis.chess.engine.game.moves.ClassicMove
import edu.austral.dissis.chess.engine.pieces.Piece
import edu.austral.dissis.chess.engine.position.Position
class ChessBoard(private val maxRow: Int, private val maxCol: Int, private var currentBoard: Map<Position, Piece> = emptyMap<Position,Piece>()){
private val moves = mutableListOf<ClassicMove>()
fun putPieceAt(position: Position, piece: Piece) {
currentBoard = currentBoard.plus(position to piece)
}
fun removePieceAt(position: Position) {
currentBoard = currentBoard.minus(position)
}
fun movePiece(move: ClassicMove) {
currentBoard = currentBoard.minus(move.from).plus(move.to to currentBoard[move.from]!!)
moves.add(move)
}
fun getBoard(): Map<Position, Piece> {
return currentBoard
}
fun getPieceAt(position: Position): Piece? {
return currentBoard[position]
}
fun getLastMove(): ClassicMove? {
return moves.lastOrNull()
}
fun containsPiece(from: Position): Boolean {
return currentBoard.containsKey(from)
}
fun getPositionOf(piece: Piece): Position {
return currentBoard.filterValues { it == piece }.keys.first()
}
fun capture(piece: Piece, to: Position) {
currentBoard = currentBoard.minus(getPositionOf(piece)).minus(to).plus(to to piece)
}
}
// | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/board/ChessBoard.kt | 1023287748 |
package edu.austral.dissis.chess.engine
interface engine {
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/engine.kt | 1055545562 |
package edu.austral.dissis.chess.engine.position
data class Position(private val x: Int, private val y: Int) {
fun getX(): Int {
return x
}
fun getY(): Int {
return y
}
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/position/Position.kt | 3261102229 |
package edu.austral.dissis.chess.engine.pieces.types
import edu.austral.dissis.chess.engine.pieces.Color
import edu.austral.dissis.chess.engine.position.Position
class Knight(color: Color) {
companion object {
fun canMove(from: Position, to: Position): Boolean {
return (Math.abs(from.getX() - to.getX()) == 2 && Math.abs(from.getY() - to.getY()) == 1) ||
(Math.abs(from.getX() - to.getX()) == 1 && Math.abs(from.getY() - to.getY()) == 2)
}
}
}
| mychess/src/main/kotlin/edu/austral/dissis/chess/engine/pieces/types/Knight.kt | 259646601 |
package edu.austral.dissis.chess.engine.pieces.types
import edu.austral.dissis.chess.engine.pieces.Color
import edu.austral.dissis.chess.engine.position.Position
class Bishop(color: Color) {
companion object {
fun canMoveDiagonal(from: Position, to: Position): Boolean {
return Math.abs(from.getX() - to.getX()) == Math.abs(from.getY() - to.getY())
}
}
}
| mychess/src/main/kotlin/edu/austral/dissis/chess/engine/pieces/types/Bishop.kt | 4043672807 |
package edu.austral.dissis.chess.engine.pieces.types
import edu.austral.dissis.chess.engine.pieces.Color
import edu.austral.dissis.chess.engine.position.Position
class King(color: Color) {
companion object {
fun canMove(from: Position, to: Position): Boolean {
return Math.abs(from.getX() - to.getX()) <= 1 && Math.abs(from.getY() - to.getY()) <= 1
}
}
}
| mychess/src/main/kotlin/edu/austral/dissis/chess/engine/pieces/types/King.kt | 3723135550 |
package edu.austral.dissis.chess.engine.pieces.types
enum class PieceType {
PAWN,
ROOK,
KNIGHT,
BISHOP,
QUEEN,
KING
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/pieces/types/PieceType.kt | 3298427464 |
package edu.austral.dissis.chess.engine.pieces.types
import edu.austral.dissis.chess.engine.board.ChessBoard
import edu.austral.dissis.chess.engine.pieces.Color
import edu.austral.dissis.chess.engine.pieces.validator.VerticalValidator
import edu.austral.dissis.chess.engine.position.Position
class Pawn(color: Color, val firstMove: Boolean = true) {
}
| mychess/src/main/kotlin/edu/austral/dissis/chess/engine/pieces/types/Pawn.kt | 1174179226 |
package edu.austral.dissis.chess.engine.pieces.types
import edu.austral.dissis.chess.engine.pieces.Color
import edu.austral.dissis.chess.engine.position.Position
class Rook(color: Color) {
}
| mychess/src/main/kotlin/edu/austral/dissis/chess/engine/pieces/types/Rook.kt | 2044323582 |
package edu.austral.dissis.chess.engine.pieces.types
import edu.austral.dissis.chess.engine.pieces.Color
import edu.austral.dissis.chess.engine.position.Position
class Queen(color: Color) {
}
| mychess/src/main/kotlin/edu/austral/dissis/chess/engine/pieces/types/Queen.kt | 809565017 |
package edu.austral.dissis.chess.engine.pieces.validator
import edu.austral.dissis.chess.engine.board.ChessBoard
import edu.austral.dissis.chess.engine.position.Position
import kotlin.math.abs
class LShapeValidator(): Validator{
override fun validate(from: Position, to: Position,board: ChessBoard): Boolean {
if(!((abs(from.getX() - to.getX()) == 2 && abs(from.getY() - to.getY()) == 1)
|| (abs(from.getX() - to.getX()) == 1
&& abs(from.getY() - to.getY()) == 2))) throw RuntimeException("Invalid move")
return clearPath(from, to,board)
}
override fun clearPath(from: Position, to: Position,board: ChessBoard): Boolean {
return board.getPieceAt(from)!!.color != board.getPieceAt(to)?.color
}
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/pieces/validator/LShapeValidator.kt | 3566978305 |
package edu.austral.dissis.chess.engine.pieces.validator
import edu.austral.dissis.chess.engine.board.ChessBoard
import edu.austral.dissis.chess.engine.position.Position
interface Validator {
fun validate(from: Position, to: Position,board: ChessBoard): Boolean
fun clearPath(from: Position, to: Position,board: ChessBoard): Boolean
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/pieces/validator/Validator.kt | 400292241 |
package edu.austral.dissis.chess.engine.pieces.validator
import edu.austral.dissis.chess.engine.board.ChessBoard
import edu.austral.dissis.chess.engine.position.Position
class VerticalValidator(): Validator{
override fun validate(from: Position, to: Position, board: ChessBoard): Boolean {
return clearPath(from, to, board)
}
override fun clearPath(from: Position, to: Position, board: ChessBoard): Boolean {
for (i in 1 until Math.abs(from.getY() - to.getY())) {
val pathPos = if(from.getY() < to.getY()) Position(from.getX(), from.getY() + i)
else Position(from.getX(), from.getY() - i)
if(pathPos != to && board.getPieceAt(pathPos) != null) return false
if(pathPos == to )
if(board.getPieceAt(to) != null && board.getPieceAt(to)!!.color != board.getPieceAt(from)!!.color)
return board.getPieceAt(from)!!.canCapture(board.getPieceAt(from)!!,to,board)
}
return true
}
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/pieces/validator/VerticalValidator.kt | 1163294233 |
package edu.austral.dissis.chess.engine.pieces.validator
import edu.austral.dissis.chess.engine.board.ChessBoard
import edu.austral.dissis.chess.engine.position.Position
class HorizontalValidator() : Validator {
override fun validate(from: Position, to: Position,board: ChessBoard): Boolean {
return clearPath(from, to,board)
}
override fun clearPath(from:Position, to:Position,board: ChessBoard): Boolean {
for(i in 1 until Math.abs(from.getX() - to.getX())) {
val pathPos: Position = if(from.getX() < to.getX()) Position(from.getX() + i, from.getY())
else Position(from.getX() - i, from.getY())
if(pathPos != to && board.getPieceAt(pathPos) != null) return false
if(pathPos == to && board.getPieceAt(to)!!.color != board.getPieceAt(from)!!.color ) return board.getPieceAt(from)!!.canCapture(
board.getPieceAt(from)!!, to, board)
}
return true
}
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/pieces/validator/HorizontalValidator.kt | 1324846780 |
package edu.austral.dissis.chess.engine.pieces.validator
import edu.austral.dissis.chess.engine.board.ChessBoard
import edu.austral.dissis.chess.engine.position.Position
import kotlin.math.abs
class DiagonalValidator() : Validator{
override fun validate(from: Position, to: Position,board: ChessBoard): Boolean {
return clearPath(from, to,board)
}
override fun clearPath(from: Position, to: Position,board: ChessBoard): Boolean {
for (i in 1 until abs(from.getX() - to.getX())) {
if (from.getX() < to.getX() && from.getY() < to.getY()) {
val pathPos = Position(from.getX() + i, from.getY() + i)
if(pathPos != to && board.getPieceAt(pathPos) != null) return false
if(pathPos == to && board.getPieceAt(to) != null && board.getPieceAt(to)!!.color != board.getPieceAt(from)!!.color)
return board.getPieceAt(from)!!.canCapture(board.getPieceAt(from)!!, to, board)
}
else if (from.getX() < to.getX() && from.getY() > to.getY()) {
val pathPos = Position(from.getX() + i, from.getY() - i)
if(pathPos != to && board.getPieceAt(pathPos) != null) return false
if(pathPos == to && board.getPieceAt(to) != null && board.getPieceAt(to)!!.color != board.getPieceAt(from)!!.color)
return board.getPieceAt(from)!!.canCapture(board.getPieceAt(from)!!, to, board)
}
else if (from.getX() > to.getX() && from.getY() < to.getY()) {
val pathPos = Position(from.getX() - i, from.getY() + i)
if(pathPos != to && board.getPieceAt(pathPos) != null) return false
if(pathPos == to && board.getPieceAt(to) != null && board.getPieceAt(to)!!.color != board.getPieceAt(from)!!.color)
return board.getPieceAt(from)!!.canCapture(board.getPieceAt(from)!!, to, board)
}
if (from.getX() > to.getX() && from.getY() > to.getY()) {
val pathPos = Position(from.getX() - i, from.getY() - i)
if(pathPos != to && board.getPieceAt(pathPos) != null) return false
if(pathPos == to && board.getPieceAt(to) != null && board.getPieceAt(to)!!.color != board.getPieceAt(from)!!.color)
return board.getPieceAt(from)!!.canCapture(board.getPieceAt(from)!!, to, board)
}
}
return board.getPieceAt(from)!!.color != board.getPieceAt(to)?.color
}
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/pieces/validator/DiagonalValidator.kt | 1343454073 |
package edu.austral.dissis.chess.engine.pieces
import edu.austral.dissis.chess.engine.game.moves.ClassicMove
import edu.austral.dissis.chess.engine.pieces.types.PieceType
import edu.austral.dissis.chess.engine.position.Position
class Piece(val color: Color, val pieceType : PieceType) {
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/pieces/Piece.kt | 2283806744 |
package edu.austral.dissis.chess.engine.pieces
class Color {
companion object {
fun valueOf(colorInput: String): Color {
return when (colorInput) {
"WHITE" -> WHITE
"BLACK" -> BLACK
else -> throw IllegalArgumentException("Invalid color")
}
}
val WHITE = Color()
val BLACK = Color()
}
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/pieces/Color.kt | 1587851745 |
package edu.austral.dissis.chess.engine.pieces.specialMoves
import edu.austral.dissis.chess.engine.board.ChessBoard
import edu.austral.dissis.chess.engine.position.Position
class Castle():
PieceMoves {
override fun isMove(from: Position, to: Position, board: ChessBoard): Boolean {
return canCastle(from, to,board) || canLongCastle(from, to, board)
}
private fun canLongCastle(from: Position, to: Position, board: ChessBoard): Boolean {
val moves = board.moves
for(move in moves){
if(board.getPieceAt(from) == move.board.getPieceAt(move.from)){
return false
}
if(move.from == Position(1,1) || move.from == Position(1,8)){
return false
}
}
if((from.getX() == 5 && from.getY() == 1 && to.getX() == 3 && to.getY() == 1)||(from.getX() == 5 && from.getY() == 8 && to.getX() == 3 && to.getY() == 8)){
return true
}
return false
}
private fun canCastle(from: Position, to: Position, board: ChessBoard): Boolean {
val moves = board.moves
for(move in moves){
if(board.getPieceAt(from) == move.board.getPieceAt(move.from)){
return false
}
if(move.from == Position(8,1) || move.from == Position(8,8)){
return false
}
}
if((from.getX() == 5 && from.getY() == 1 && to.getX() == 7 && to.getY() == 1)||(from.getX() == 5 && from.getY() == 8 && to.getX() == 7 && to.getY() == 8)){
return true
}
return false
}
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/pieces/specialMoves/Castle.kt | 3424925556 |
package edu.austral.dissis.chess.engine.pieces.specialMoves
import edu.austral.dissis.chess.engine.board.ChessBoard
import edu.austral.dissis.chess.engine.position.Position
interface PieceMoves {
fun isMove(from: Position, to: Position,board: ChessBoard): Boolean
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/pieces/specialMoves/PieceMoves.kt | 213364772 |
package edu.austral.dissis.chess.engine.pieces.specialMoves
import edu.austral.dissis.chess.engine.board.ChessBoard
import edu.austral.dissis.chess.engine.pieces.types.PieceType
import edu.austral.dissis.chess.engine.position.Position
import kotlin.math.abs
class PawnMoves(): PieceMoves {
override fun isMove(from: Position, to: Position,board: ChessBoard): Boolean {
if((from.getY() == 2 && to.getY() == 4)||(from.getY() == 7 && to.getY() == 5)) return canDoubleMove(from, to,board)
if(canCapture(from, to,board) || canCaptureEnPassant(from, to,board)) return true
if(kotlin.math.abs(from.getY() - to.getY()) != 1) return false
if((from.getY() == 2 && to.getY() == 1)||(from.getY() == 7 && to.getY() == 8) ) return isPromotion(from, to,board)
return true
}
private fun isPromotion(from: Position, to: Position, board: ChessBoard): Boolean {
return true
}
private fun canDoubleMove(from: Position, to: Position, board: ChessBoard): Boolean {
return true
}
private fun canCapture(from: Position, to: Position, board: ChessBoard): Boolean {
if (abs(from.getX() - to.getX()) == 1 && abs(from.getY() - to.getY()) == 1 && board.getPieceAt(to) != null) return true
return false
}
private fun canCaptureEnPassant(from: Position, to: Position, board: ChessBoard): Boolean {
if(abs(from.getX() - to.getX()) == 1 && abs(from.getY() - to.getY()) == 1 && board.getPieceAt(to) == null){
val lastMove = board.getLastMove()
if(lastMove != null && lastMove.from.getY() == 7 && lastMove.to.getY() == 5 && lastMove.to.getX() == to.getX() &&
lastMove.board.getPieceAt(lastMove.to)!!.type == PieceType.PAWN &&
lastMove.board.getPieceAt(lastMove.to)!!.color != board.getPieceAt(from)!!.color)
return true
if(lastMove != null && lastMove.from.getY() == 2 && lastMove.to.getY() == 4 &&
lastMove.to.getX() == to.getX()&& lastMove.board.getPieceAt(lastMove.to)!!.type == PieceType.PAWN &&
lastMove.board.getPieceAt(lastMove.to)!!.color != board.getPieceAt(from)!!.color)
return true
}
return false
}
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/pieces/specialMoves/PawnMoves.kt | 2687361117 |
package edu.austral.dissis.chess.engine.game.moves
import edu.austral.dissis.chess.engine.pieces.Piece
import edu.austral.dissis.chess.engine.position.Position
class ClassicMove(val from: Position, val to: Position, val piece: Piece) {
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/game/moves/ClassicMove.kt | 3272844116 |
package edu.austral.dissis.chess.engine.game
import edu.austral.dissis.chess.engine.game.moves.ClassicMove
import edu.austral.dissis.chess.engine.pieces.Color
import edu.austral.dissis.chess.engine.pieces.Piece
import edu.austral.dissis.chess.engine.pieces.types.PieceType
import edu.austral.dissis.chess.engine.position.Position
class Player(color: Color) {
fun proposeMove(fromInput: String, toInput: String, pieceTypeInput: String, colorInput: String): ClassicMove {
val fromCoordinates = fromInput.split(",").map { it.trim().toInt() }
val fromPosition = Position(fromCoordinates[0], fromCoordinates[1])
val toCoordinates = toInput.split(",").map { it.trim().toInt() }
val toPosition = Position(toCoordinates[0], toCoordinates[1])
val piece = Piece(Color.valueOf(colorInput), PieceType.valueOf(pieceTypeInput))
return ClassicMove(fromPosition, toPosition, piece)
}
}
| mychess/src/main/kotlin/edu/austral/dissis/chess/engine/game/Player.kt | 2710602066 |
package edu.austral.dissis.chess.engine.game
import edu.austral.dissis.chess.engine.board.ChessBoard
import edu.austral.dissis.chess.engine.game.moves.ClassicMove
import edu.austral.dissis.chess.engine.pieces.Color
import edu.austral.dissis.chess.engine.pieces.Color.Companion.WHITE
import edu.austral.dissis.chess.engine.position.Position
class ChessGame(val board : ChessBoard, private val gameType: ChessGameTypes){
var currentPlayer = gameType.setUpPlayers()[0]
var player1 = gameType.setUpPlayers()[0]
var player2 = gameType.setUpPlayers()[1]
fun setUpBoard(): ChessBoard {
return gameType.setUpBoard(8, 8)
}
fun whoseTurnIsIt(): Player {
currentPlayer = if (currentPlayer == player1) player2
else player1
return currentPlayer
}
fun move(move: ClassicMove): ChessBoard {
board.movePiece(move)
currentPlayer = whoseTurnIsIt()
return board
}
fun printBoard() {
for (j in 1..8) {
for (i in 1..8) {
if (board.containsPiece(Position(i, j))) {
if(board.getPieceAt(Position(i, j))!!.color == WHITE){
print("| W" + board.getPieceAt(Position(i, j))!!.pieceType.toString() + " |")}
if (board.getPieceAt(Position(i, j))!!.color == Color.BLACK){
print("| B" + board.getPieceAt(Position(i, j))!!.pieceType.toString() + " |")
}
} else {
print("| null |")
}
}
println()
}
}
fun getNumberOfPlayers(): Int {
return gameType.getNumberOfPlayers()
}
fun setUpPlayers(): Array<Player> {
return gameType.setUpPlayers()
}
fun canMove(currentPlayersTurn: Player, move: ClassicMove): Boolean {
return gameType.isValidMove(this, move)
}
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/game/ChessGame.kt | 4162672633 |
mychess/src/main/kotlin/edu/austral/dissis/chess/engine/game/Main.kt | 0 |
|
package edu.austral.dissis.chess.engine.game.gameTypes.classic
import edu.austral.dissis.chess.engine.board.ChessBoard
import edu.austral.dissis.chess.engine.game.rules.DrawCondition
class ClassicDrawCondition: DrawCondition {
override fun DrawCondition(thisBoard: ChessBoard): Boolean {
return true
}
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/game/gameTypes/classic/ClassicDrawCondition.kt | 117830700 |
package edu.austral.dissis.chess.engine.game.gameTypes.classic
import edu.austral.dissis.chess.engine.board.ChessBoard
import edu.austral.dissis.chess.engine.game.ChessGame
import edu.austral.dissis.chess.engine.game.Player
import edu.austral.dissis.chess.engine.game.moves.ClassicMove
import edu.austral.dissis.chess.engine.pieces.Color
import edu.austral.dissis.chess.engine.pieces.Piece
import edu.austral.dissis.chess.engine.pieces.types.PieceType
import edu.austral.dissis.chess.engine.position.Position
import kotlin.math.abs
class ClassicChess {
fun setUpPlayers(): Array<Player> {
val player1 = Player(Color.WHITE)
val player2 = Player(Color.BLACK)
return arrayOf(player1, player2)
}
fun setUpBoard(maxRow: Int, maxCol: Int ): ChessBoard {
var board = ChessBoard(maxRow, maxCol)
for (i in 1..maxCol) {
board.putPieceAt(Position(i, 2), Piece(Color.WHITE, PieceType.PAWN))
board.putPieceAt(Position(i, maxRow - 1), Piece(Color.BLACK, PieceType.PAWN))
}
return board
}
fun getNumberOfPlayers(): Int {
return 2
}
companion object{
fun whoseTurnIsIt(chessGame: ChessGame): Player {
val currentPlayer: Player = chessGame.currentPlayer
if (chessGame.currentPlayer == chessGame.player1) chessGame.currentPlayer = chessGame.player2
else chessGame.currentPlayer = chessGame.player1
return currentPlayer
}
fun checkEndConditions(chessGame: ChessGame): Boolean {
return checkDraw(chessGame) || checkWin(chessGame)
}
private fun checkDraw(chessGame: ChessGame): Boolean {
return true
}
private fun checkWin(chessGame: ChessGame): Boolean {
return true
}
public fun isValidMove(chessGame: ChessGame, move: ClassicMove): Boolean {
return verifyMoveRules(chessGame.board, move)
}
private fun verifyMoveRules(board: ChessBoard, move: ClassicMove): Boolean {
if(move.piece.pieceType == PieceType.PAWN) {
if(verifyPawnCapture(board, move)) {
board.capture(move.piece, move.to)
return true
}
return verifyPawnMove(board, move)
}
if(move.piece.pieceType == PieceType.KNIGHT) {
if (verifyKnightCapture(board, move)) {
board.capture(move.piece, move.to)
return true
}
return verifyKnightMove(board,move)
}
if(move.piece.pieceType == PieceType.BISHOP) {
return verifyBishopMove(board,move)
}
if(move.piece.pieceType == PieceType.ROOK) {
return verifyRookMove(board,move)
}
if(move.piece.pieceType == PieceType.QUEEN) {
return verifyBishopMove(board,move) || verifyRookMove(board,move)
}
if(move.piece.pieceType == PieceType.KING) {
return verifyKingMove(board,move)
}
return false
}
private fun verifyKnightCapture(board: ChessBoard, move: ClassicMove): Boolean {
if(((abs(move.from.getX() - move.to.getX()) == 2 && abs(move.from.getY() - move.to.getY()) == 1) ||
(abs(move.from.getX() - move.to.getX()) == 1 && abs(move.from.getY() - move.to.getY()) == 2))
&& board.getPieceAt(move.to) != null && board.getPieceAt(move.to)!!.color != move.piece.color) return true
return false
}
private fun verifyPawnCapture(board: ChessBoard, move: ClassicMove): Boolean {
if((move.from.getX() == move.to.getX() + 1) && (move.from.getY() == move.to.getY() + 1)||
(move.from.getX() == move.to.getX() - 1) && (move.from.getY() == move.to.getY() + 1)){
if(move.piece.color == Color.BLACK)
return board.getPieceAt(move.to) != null && board.getPieceAt(move.to)!!.color != board.getPieceAt(move.from)!!.color
}
if((move.from.getX() == move.to.getX() + 1) && (move.from.getY() == move.to.getY() - 1)||
(move.from.getX() == move.to.getX() - 1) && (move.from.getY() == move.to.getY() - 1)){
if(move.piece.color == Color.WHITE)
return board.getPieceAt(move.to) != null && board.getPieceAt(move.to)!!.color != board.getPieceAt(move.from)!!.color
}
return false
}
private fun verifyKingMove(board: ChessBoard, move: ClassicMove): Boolean {
if(abs(move.from.getX() - move.to.getX()) <= 1 && abs(move.from.getY() - move.to.getY()) <= 1){
if(board.getPieceAt(move.to) == null) return true
if(board.getPieceAt(move.to) != null && board.getPieceAt(move.to)!!.color != board.getPieceAt(move.from)!!.color)
return capture(board, move)
}
return false
}
private fun verifyRookMove(board: ChessBoard, move: ClassicMove): Boolean {
if(((move.from.getX() == move.to.getX()) xor (move.from.getY() == move.to.getY()) )&& clearStraightPath(board,move)) return true
return false
}
private fun verifyBishopMove(board: ChessBoard, move: ClassicMove): Boolean {
if(abs(move.from.getX() - move.to.getX()) == abs(move.from.getY() - move.to.getY())
&& clearDiagonal(board,move)) return true
return false
}
private fun verifyKnightMove(board: ChessBoard, move: ClassicMove): Boolean {
if(((abs(move.from.getX() - move.to.getX()) == 2 && abs(move.from.getY() - move.to.getY()) == 1) ||
(abs(move.from.getX() - move.to.getX()) == 1 && abs(move.from.getY() - move.to.getY()) == 2))
&& board.getPieceAt(move.to) == null) return true
return false
}
private fun verifyPawnMove(board: ChessBoard, move: ClassicMove): Boolean {
if(move.from.getX() != move.to.getX()) return false
if((move.from.getY() == 2 && move.to.getY() == 4 || move.from.getY() == 7 && move.to.getY() == 5 )
&& clearStraightPath(board,move)) return true
if (move.from.getY() == move.to.getY() + 1 && board.getPieceAt(move.to) == null) return true
if(move.from.getY() == move.to.getY() - 1 && board.getPieceAt(move.to) == null) return true
return false
}
private fun clearStraightPath(board: ChessBoard, move: ClassicMove): Boolean {
if(move.from.getX() == move.to.getX()){
for (i in 1 until abs(move.from.getY() - move.to.getY())) {
val pathPos = if(move.from.getY() < move.to.getY()) Position(move.from.getX(), move.from.getY() + i+1)
else Position(move.from.getX(), move.from.getY() - i -1)
if(pathPos != move.to && board.getPieceAt(pathPos) != null) return false
if(pathPos.getY() == move.to.getY() ){
if(board.getPieceAt(move.to) != null && board.getPieceAt(move.to)!!.color != board.getPieceAt(move.from)!!.color) {
if(move.piece.pieceType != PieceType.PAWN) return capture(board, move)
}
else if(board.getPieceAt(move.to) == null) return true
}
}
}
if(move.from.getY() == move.to.getY()){
for (i in 1 until abs(move.from.getX() - move.to.getX())) {
val pathPos = if(move.from.getX() < move.to.getX()) Position(move.from.getX() + i, move.from.getY())
else Position(move.from.getX() - i, move.from.getY())
if(pathPos != move.to && board.getPieceAt(pathPos) != null) return false
if(pathPos == move.to ) {
if (board.getPieceAt(move.to) != null && board.getPieceAt(move.to)!!.color != board.getPieceAt(move.from)!!.color)
if (move.piece.pieceType != PieceType.PAWN) return capture(board, move)
else if(board.getPieceAt(move.to) == null) return true
}
}
}
return false
}
private fun clearDiagonal(board: ChessBoard, move: ClassicMove): Boolean {
for (i in 1 until abs(move.from.getX() - move.to.getX())) {
if (move.from.getX() < move.to.getX() && move.from.getY() < move.to.getY()) {
val pathPos = Position(move.from.getX() + i, move.from.getY() + i)
if(pathPos != move.to && board.getPieceAt(pathPos) != null) return false
if(pathPos == move.to && board.getPieceAt(move.to) != null && board.getPieceAt(move.to)!!.color != board.getPieceAt(move.from)!!.color)
return capture(board, move)
}
else if (move.from.getX() < move.to.getX() && move.from.getY() > move.to.getY()) {
val pathPos = Position(move.from.getX() + i, move.from.getY() - i)
if(pathPos != move.to && board.getPieceAt(pathPos) != null) return false
if(pathPos == move.to && board.getPieceAt(move.to) != null && board.getPieceAt(move.to)!!.color != board.getPieceAt(move.from)!!.color)
return capture(board, move)
}
else if (move.from.getX() > move.to.getX() && move.from.getY() < move.to.getY()) {
val pathPos = Position(move.from.getX() - i, move.from.getY() + i)
if(pathPos != move.to && board.getPieceAt(pathPos) != null) return false
if(pathPos == move.to && board.getPieceAt(move.to) != null && board.getPieceAt(move.to)!!.color != board.getPieceAt(move.from)!!.color)
return capture(board, move)
}
if (move.from.getX() > move.to.getX() && move.from.getY() > move.to.getY()) {
val pathPos = Position(move.from.getX() - i, move.from.getY() - i)
if(pathPos != move.to && board.getPieceAt(pathPos) != null) return false
if(pathPos == move.to && board.getPieceAt(move.to) != null && board.getPieceAt(move.to)!!.color != board.getPieceAt(move.from)!!.color)
return capture(board, move)
}
}
return board.getPieceAt(move.from)!!.color != board.getPieceAt(move.to)?.color
}
private fun capture(board: ChessBoard, move: ClassicMove): Boolean {
board.capture(move.piece, move.to)
return true
}
}
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/game/gameTypes/classic/ClassicChess.kt | 2219395175 |
package edu.austral.dissis.chess.engine.game.gameTypes.classic
import edu.austral.dissis.chess.engine.board.ChessBoard
import edu.austral.dissis.chess.engine.game.rules.WinCondition
class ClassicWinCondition: WinCondition {
override fun winCondition(thisBoard: ChessBoard): Boolean {
return true
}
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/game/gameTypes/classic/ClassicWinCondition.kt | 3156409789 |
package edu.austral.dissis.chess.engine.game.gameTypes.classic
import edu.austral.dissis.chess.engine.game.ChessGame
import edu.austral.dissis.chess.engine.game.Player
import edu.austral.dissis.chess.engine.game.rules.ChangeTurn
class ClassicTurns: ChangeTurn {
override fun changeTurn(chessGame: ChessGame): Player {
var currentPlayer: Player = chessGame.currentPlayer
if (chessGame.currentPlayer == chessGame.player1) chessGame.currentPlayer = chessGame.player2
else chessGame.currentPlayer = chessGame.player1
return currentPlayer
}
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/game/gameTypes/classic/ClassicTurns.kt | 3330747983 |
package edu.austral.dissis.chess.engine.game.gameTypes.classic
import edu.austral.dissis.chess.engine.board.ChessBoard
import edu.austral.dissis.chess.engine.game.rules.PieceSet
import edu.austral.dissis.chess.engine.pieces.Color.Companion.BLACK
import edu.austral.dissis.chess.engine.pieces.Color.Companion.WHITE
import edu.austral.dissis.chess.engine.pieces.Piece
import edu.austral.dissis.chess.engine.pieces.specialMoves.PawnMoves
import edu.austral.dissis.chess.engine.pieces.types.PieceType
import edu.austral.dissis.chess.engine.position.Position
class ClassicPieceSet: PieceSet {
override fun piecePosition(): ChessBoard {
TODO("Not yet implemented")
}
companion object {
fun setPieces(): ChessBoard {
val board = ChessBoard(8, 8)
val board1 = board.putPieceAt(Position(1, 2), Piece(WHITE, PawnMoves(), PieceType.PAWN))
val board2 = board1.putPieceAt(Position(2, 2), Piece(WHITE,PawnMoves(), PieceType.PAWN))
val board3 = board2.putPieceAt(Position(3, 2), Piece(WHITE,PawnMoves(), PieceType.PAWN))
val board4 = board3.putPieceAt(Position(4, 2), Piece(WHITE,PawnMoves(), PieceType.PAWN))
val board5 = board4.putPieceAt(Position(5, 2), Piece(WHITE,PawnMoves(), PieceType.PAWN))
val board6 = board5.putPieceAt(Position(6, 2), Piece(WHITE,PawnMoves(), PieceType.PAWN))
val board7 = board6.putPieceAt(Position(7, 2), Piece(WHITE,PawnMoves(), PieceType.PAWN))
val board8 = board7.putPieceAt(Position(8, 2), Piece(WHITE,PawnMoves(), PieceType.PAWN))
val board9 = board8.putPieceAt(Position(1, 7), Piece(BLACK,PawnMoves(), PieceType.PAWN))
val board10 = board9.putPieceAt(Position(2, 7), Piece(BLACK,PawnMoves(), PieceType.PAWN))
val board11 = board10.putPieceAt(Position(3, 7), Piece(BLACK,PawnMoves(), PieceType.PAWN))
val board12 = board11.putPieceAt(Position(4, 7), Piece(BLACK,PawnMoves(), PieceType.PAWN))
val board13 = board12.putPieceAt(Position(5, 7), Piece(BLACK,PawnMoves(), PieceType.PAWN))
val board14 = board13.putPieceAt(Position(6, 7), Piece(BLACK,PawnMoves(), PieceType.PAWN))
val board15 = board14.putPieceAt(Position(7, 7), Piece(BLACK,PawnMoves(), PieceType.PAWN))
return board15.putPieceAt(Position(8, 7), Piece(BLACK,PawnMoves(), PieceType.PAWN))
}
}
}
| mychess/src/main/kotlin/edu/austral/dissis/chess/engine/game/gameTypes/classic/ClassicPieceSet.kt | 823999682 |
package edu.austral.dissis.chess.engine.game.rules
import edu.austral.dissis.chess.engine.board.ChessBoard
interface WinCondition {
fun winCondition(thisBoard: ChessBoard): Boolean
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/game/rules/WinCondition.kt | 3068701906 |
package edu.austral.dissis.chess.engine.game.rules
import edu.austral.dissis.chess.engine.board.ChessBoard
interface DrawCondition {
fun DrawCondition(thisBoard: ChessBoard): Boolean
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/game/rules/DrawCondition.kt | 3589968104 |
package edu.austral.dissis.chess.engine.game.rules
import edu.austral.dissis.chess.engine.board.ChessBoard
interface PieceSet {
fun piecePosition(): ChessBoard
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/game/rules/PieceSet.kt | 4029772559 |
package edu.austral.dissis.chess.engine.game.rules
import edu.austral.dissis.chess.engine.game.ChessGame
import edu.austral.dissis.chess.engine.game.Player
interface ChangeTurn {
fun changeTurn(chessGame: ChessGame): Player
} | mychess/src/main/kotlin/edu/austral/dissis/chess/engine/game/rules/ChangeTurn.kt | 359029100 |
package edu.austral.dissis.chess.engine.game
import edu.austral.dissis.chess.engine.board.ChessBoard
import edu.austral.dissis.chess.engine.game.gameTypes.classic.ClassicChess
import edu.austral.dissis.chess.engine.game.moves.ClassicMove
enum class ChessGameTypes {
CLASSIC;
fun setUpPlayers(): Array<Player> {
return when (this) {
CLASSIC -> ClassicChess().setUpPlayers()
}
}
fun setUpBoard(maxRow: Int, maxCol: Int): ChessBoard {
return when (this) {
CLASSIC -> ClassicChess().setUpBoard(maxRow, maxCol)
}
}
fun whoseTurnIsIt(chessGame: ChessGame): Player {
return when (this) {
CLASSIC -> ClassicChess.whoseTurnIsIt(chessGame)
}
}
fun checkEndConditions(chessGame: ChessGame): Boolean {
return when (this) {
CLASSIC -> ClassicChess.checkEndConditions(chessGame)
}
}
fun isValidMove(chessGame: ChessGame, move: ClassicMove): Boolean {
return when (this) {
CLASSIC -> ClassicChess.isValidMove(chessGame, move)
}
}
fun getNumberOfPlayers(): Int {
return when (this) {
CLASSIC -> ClassicChess().getNumberOfPlayers()
}
}
}
| mychess/src/main/kotlin/edu/austral/dissis/chess/engine/game/ChessGameTypes.kt | 748725193 |
package com.example.wheatherapp
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.wheatherapp", appContext.packageName)
}
} | WeatherForecastApp/app/src/androidTest/java/com/example/wheatherapp/ExampleInstrumentedTest.kt | 1611227550 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.