content
stringlengths 0
13M
| path
stringlengths 4
263
| contentHash
stringlengths 1
10
|
|---|---|---|
package kr.co.anna.api.config
import io.swagger.v3.oas.annotations.OpenAPIDefinition
import io.swagger.v3.oas.annotations.enums.SecuritySchemeType
import io.swagger.v3.oas.annotations.security.SecurityRequirement
import io.swagger.v3.oas.annotations.security.SecurityScheme
import io.swagger.v3.oas.annotations.security.SecuritySchemes
import org.springframework.context.annotation.Configuration
/**
* Open API (Swagger) ์ค์
*/
@Configuration
@OpenAPIDefinition(
security = [
SecurityRequirement(name = "JWT"),
]
)
@SecuritySchemes(
SecurityScheme(
type = SecuritySchemeType.HTTP,
name = "JWT",
description = "JWT Bearer Token ์
๋ ฅ",
scheme = "bearer",
bearerFormat = "JWT"
),
)
class OpenApiConfig
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/config/OpenApiConfig.kt | 1407749512 |
package kr.co.anna.api.config
import kr.co.anna.domain.repository.user.UserRepository
import kr.co.anna.lib.security.jwt.JwtAuthFilter
import kr.co.anna.lib.security.jwt.JwtProcessor
import kr.co.anna.lib.security.jwt.JwtProperties
import kr.co.anna.lib.utils.MessageUtil
import org.springframework.boot.context.properties.EnableConfigurationProperties
import org.springframework.context.annotation.Bean
import org.springframework.http.HttpMethod
import org.springframework.security.access.AccessDeniedException
import org.springframework.security.authentication.AuthenticationManager
import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration
import org.springframework.security.config.annotation.web.builders.HttpSecurity
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity
import org.springframework.security.core.AuthenticationException
import org.springframework.security.crypto.factory.PasswordEncoderFactories
import org.springframework.security.crypto.password.PasswordEncoder
import org.springframework.security.web.AuthenticationEntryPoint
import org.springframework.security.web.SecurityFilterChain
import org.springframework.security.web.access.AccessDeniedHandler
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter
import org.springframework.security.web.header.writers.frameoptions.XFrameOptionsHeaderWriter
import org.springframework.web.cors.CorsConfiguration
import org.springframework.web.cors.CorsConfigurationSource
import org.springframework.web.cors.CorsUtils
import org.springframework.web.cors.UrlBasedCorsConfigurationSource
import javax.servlet.http.HttpServletRequest
import javax.servlet.http.HttpServletResponse
/**
* ์คํ๋ง ์ํ๋ฆฌํฐ ์ค์
*/
@EnableWebSecurity
@EnableConfigurationProperties(JwtProperties::class)
class SecurityConfig(
private val jwtProcessor: JwtProcessor
) {
@Bean
fun filterChain(http: HttpSecurity) : SecurityFilterChain {
http
.cors().configurationSource(corsConfigurationSource())
.and()
.csrf()
.disable()
.addFilterBefore(JwtAuthFilter(jwtProcessor), UsernamePasswordAuthenticationFilter::class.java)
.exceptionHandling()
.authenticationEntryPoint(JwtAuthenticationEntryPoint())
.accessDeniedHandler(CustomAccessDeniedHandler())
.and()
.authorizeRequests()
.requestMatchers(CorsUtils::isPreFlightRequest).permitAll()
.antMatchers(HttpMethod.GET, "/").permitAll()
.antMatchers(*swaggerAllowedList()).permitAll()
.antMatchers(*actuatorAllowedList()).permitAll()
.antMatchers(*devAllowedList()).permitAll()
.antMatchers(HttpMethod.GET, *signAllowedList()).permitAll()
.antMatchers(HttpMethod.POST, *signAllowedList()).permitAll()
.antMatchers(HttpMethod.PUT, *signAllowedList()).permitAll()
.antMatchers(HttpMethod.GET, *commCodeAllowedList()).permitAll()
.antMatchers(*sysAdminAllowedList()).hasAnyRole("SYS_ADMIN")
.anyRequest().authenticated()
.and()
.headers()
.addHeaderWriter(XFrameOptionsHeaderWriter(XFrameOptionsHeaderWriter.XFrameOptionsMode.SAMEORIGIN))
return http.build()
}
class JwtAuthenticationEntryPoint() : AuthenticationEntryPoint {
override fun commence(
request: HttpServletRequest?,
response: HttpServletResponse?,
authException: AuthenticationException?
) {
response?.sendError(HttpServletResponse.SC_UNAUTHORIZED, MessageUtil.getMessage("UNAUTHENTICATED_USER"))
}
}
/**
* ์ํ๋ฆฌํฐ ์ธ๊ฐ
*/
class CustomAccessDeniedHandler() : AccessDeniedHandler {
override fun handle(
request: HttpServletRequest?,
response: HttpServletResponse?,
accessDeniedException: AccessDeniedException?
) {
response?.sendError(HttpServletResponse.SC_FORBIDDEN,MessageUtil.getMessage("UNAUTHORIZED_ACCESS"))
}
}
@Bean
fun passwordEncoder(): PasswordEncoder = PasswordEncoderFactories.createDelegatingPasswordEncoder()
@Bean
fun corsConfigurationSource(): CorsConfigurationSource? {
val configuration = CorsConfiguration()
configuration.addAllowedOriginPattern("http://localhost:3040")
configuration.addAllowedMethod("*")
configuration.addAllowedHeader("*")
configuration.allowCredentials = true
configuration.maxAge = 3600L
configuration.exposedHeaders = listOf("Content-Disposition")
val source = UrlBasedCorsConfigurationSource()
source.registerCorsConfiguration("/**", configuration)
return source
}
@Bean
fun authenticationManager(
authenticationConfiguration: AuthenticationConfiguration
): AuthenticationManager? {
return authenticationConfiguration.authenticationManager
}
private fun commCodeAllowedList(): Array<String> {
return arrayOf(
"/api/api/common-code/**"
)
}
private fun signAllowedList(): Array<String> {
return arrayOf(
"/api/sign-up",
"/api/sign-in"
)
}
private fun swaggerAllowedList(): Array<String> {
return arrayOf(
"/v3/api-docs/**",
"/v3/api-docs.yaml",
"/swagger-ui/**",
"/swagger-ui.html"
)
}
private fun actuatorAllowedList(): Array<String> {
return arrayOf(
"/management/health",
"/management/info",
)
}
private fun devAllowedList(): Array<String> {
return arrayOf(
"/h2-console/**"
)
}
private fun sysAdminAllowedList(): Array<String> {
return arrayOf(
"/api/admin/**",
)
}
}
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/config/SecurityConfig.kt | 526675144 |
package kr.co.anna.api.config
import org.ehcache.event.CacheEvent
import org.ehcache.event.CacheEventListener
import org.slf4j.LoggerFactory
import org.springframework.cache.annotation.EnableCaching
import org.springframework.context.annotation.Configuration
/**
* ์บ์ ์ค์ ํด๋์ค
* ์คํ๋ง ๋ถํธ ๊ธฐ๋ณธ์ธ EhCache ์บ์ ์ค์
*/
@Configuration
@EnableCaching
class CacheLogger : CacheEventListener<Any, Any> {
private val log = LoggerFactory.getLogger(javaClass)
override fun onEvent(cacheEvent: CacheEvent<out Any, out Any>) {
log.info("Key: [${cacheEvent.key}] | EventType: [${cacheEvent.type}] | Old value: [${cacheEvent.oldValue}] | New value: [${cacheEvent.newValue}]")
}
}
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/config/CacheLogger.kt | 836296400 |
package kr.co.anna.api.config
import kr.co.anna.domain._common.EnumMapper
import kr.co.anna.domain.model.Role
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
/**
* enum ๋ชฉ๋ก ์กฐํ์ ์ฌ์ฉํ enum๋ฑ๋ก
*/
@Configuration
class EnumMapperConfig {
@Bean
fun enumMapper(): EnumMapper {
val enumMapper = EnumMapper()
enumMapper.put("ROLE", Role::class.java)
return enumMapper
}
}
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/config/EnumMapperConfig.kt | 883898207 |
package kr.co.anna.api.config
import kr.co.anna.lib.security.AuthUser
import org.springframework.boot.autoconfigure.domain.EntityScan
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.data.auditing.DateTimeProvider
import org.springframework.data.domain.AuditorAware
import org.springframework.data.jpa.repository.config.EnableJpaAuditing
import org.springframework.data.jpa.repository.config.EnableJpaRepositories
import org.springframework.security.core.context.SecurityContextHolder
import java.time.LocalDateTime
import java.util.*
/**
* JPA ์ค์ ํด๋์ค
* 2๊ฐ์ ๋น์ ๋๋น ํ
์ด๋ธ์ createdAt, createdBy ๋ฑ audit ์ ๋ณด๋ฅผ ์๋์ผ๋ก ์ ์ฅํ๋๋ฐ ์ฌ์ฉ
*/
@Configuration
@EntityScan(basePackages = ["kr.co.anna.domain"])
@EnableJpaRepositories(basePackages = ["kr.co.anna.domain"])
@EnableJpaAuditing(dateTimeProviderRef = "auditingDateTimeProvider")
class JpaConfig {
@Bean
fun auditingDateTimeProvider() = DateTimeProvider {
Optional.of(LocalDateTime.now())
}
@Bean
fun auditorAwareProvider() = AuditorAware {
val authentication = SecurityContextHolder.getContext().authentication
if (authentication == null) {
Optional.empty()
} else when (val principal: Any = authentication.principal) {
is String -> Optional.of(principal)
is AuthUser -> Optional.of(principal.userId)
else -> Optional.empty()
}
}
}
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/config/JpaConfig.kt | 1290757598 |
package kr.co.anna.api.controller
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RestController
@RestController
class HomeController(
) {
@GetMapping("/")
fun index(): ResponseEntity<String> {
return ResponseEntity.ok("Hello World!")
}
}
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/controller/HomeController.kt | 837595826 |
package kr.co.anna.api.controller.restapi.commcode
import io.swagger.v3.oas.annotations.Operation
import io.swagger.v3.oas.annotations.tags.Tag
import kr.co.anna.domain._common.EnumMapper
import kr.co.anna.domain._common.EnumValue
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PathVariable
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RestController
@Tag(name = "commonCode-controller", description = "๊ณตํต ์ฝ๋์ฑ ์กฐํ ์ปจํธ๋กค๋ฌ ")
@RequestMapping("/api/common-code")
@RestController
class CommCodeController(
private val enumMapper: EnumMapper,
) {
@Operation(summary = "enumMapper์ ๋ฑ๋ก๋ enum ๋ชฉ๋ก ์กฐํ")
@GetMapping("/enums/{names}")
fun findByEnums(@PathVariable("names") names: String): ResponseEntity<Map<String, List<EnumValue>?>> {
return ResponseEntity.ok(enumMapper[names])
}
}
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/controller/restapi/commcode/CommCodeController.kt | 3468934661 |
package kr.co.anna.api.controller.restapi.user
import io.swagger.v3.oas.annotations.Operation
import io.swagger.v3.oas.annotations.tags.Tag
import kr.co.anna.api.dto.user.*
import kr.co.anna.api.service.command.user.UserCommandService
import kr.co.anna.api.service.command.user.UserLoginService
import kr.co.anna.domain._common.EnumMapper
import kr.co.anna.domain._common.EnumValue
import kr.co.anna.lib.error.InvalidException
import kr.co.anna.lib.security.SecurityUtil
import kr.co.anna.lib.utils.MessageUtil
import org.springframework.http.ResponseEntity
import org.springframework.validation.BindingResult
import org.springframework.web.bind.annotation.*
import javax.validation.Valid
@Tag(name = "ํ์ ๊ด๋ฆฌ API")
@RequestMapping("/api")
@RestController
class SignController(
private val userCommandService: UserCommandService,
private val userLoginService: UserLoginService,
private val enumMapper: EnumMapper,
) {
@Operation(summary = "ํ์ ๊ฐ์
")
@PostMapping("/sign-up")
fun createUser(@RequestBody signUpIn: SignUpIn): ResponseEntity<UserOut> {
val userOut = userCommandService.createUser(signUpIn)
return ResponseEntity.ok(userOut)
}
@Operation(summary = "๋ก๊ทธ์ธ")
@PostMapping("/sign-in")
fun login(@Valid @RequestBody signIn: SignInIn, bindingResult: BindingResult): ResponseEntity<SignInOut> {
if (bindingResult.hasErrors()) throw InvalidException(MessageUtil.getMessage("INVALID_USER_INFO"), bindingResult)
return ResponseEntity.ok(userLoginService.login(signIn))
}
}
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/controller/restapi/user/SignController.kt | 3899349757 |
package kr.co.anna.api.controller.graphql.user
import graphql.kickstart.tools.GraphQLMutationResolver
import graphql.kickstart.tools.GraphQLQueryResolver
import kr.co.anna.api.dto.user.SignUpIn
import kr.co.anna.api.dto.user.UserUpdateIn
import kr.co.anna.domain.model.user.User
import kr.co.anna.domain.repository.user.UserRepository
import org.springframework.security.crypto.password.PasswordEncoder
import org.springframework.stereotype.Controller
import org.springframework.transaction.annotation.Transactional
import org.springframework.web.bind.annotation.RequestBody
import org.springframework.web.bind.annotation.RequestParam
/**
* Url: http://localhost:8080/graphql
* Https Method: POST
* Header: 'Content-Type : application/json'
* **/
@Controller
@Transactional
class UserGraphController (
private val userRepository: UserRepository,
private val passwordEncoder: PasswordEncoder
) : GraphQLQueryResolver, GraphQLMutationResolver {
/**
{
"query": "{ findAllUsers { oid userId name email } }"
}
**/
fun findAllUsers(): List<User> = userRepository.findAll()
/**
{
"query": "query ($userId: String!) { getByUserId(userId: $userId) { oid, userId, name, email } }",
"variables": {
"userId": "userId"
}
}
**/
fun getByUserId(
@RequestParam userId: String
) = userRepository.getByUserId(userId)
/**
{
"query": "mutation ($signUpIn: SignUpIn!) { createUser(signUpIn: $signUpIn) { oid, userId, name, email } }",
"variables": {
"signUpIn": {
"userId": "newUserID",
"name": "New User",
"email": "[email protected]",
"password": "NewPassword"
}
}
}
**/
fun createUser(
@RequestBody signUpIn: SignUpIn
) = userRepository.save(signUpIn.toEntity(passwordEncoder))
/**
{
"query": "mutation ($userOid: ID!) { deleteUserByUserOid(userOid: $userOid) }",
"variables": {
"userOid": "Some UserOid"
}
}
**/
fun deleteUserByUserOid(
@RequestParam userOid: Long
) = userRepository.delete(userRepository.getByOid(userOid))
/**
{
"query": "mutation updateUserByUserOid($userOid: ID!, $userUpdateIn: UserUpdateIn!) { updateUserByUserOid(userOid: $userOid, userUpdateIn: $userUpdateIn) { oid, userId, name, email } }",
"variables": {
"userOid": "1",
"userUpdateIn": {
"name": "NewName",
"email": "[email protected]"
}
}
}
**/
fun updateUserByUserOid(
@RequestParam userOid: Long,
@RequestBody userUpdateIn: UserUpdateIn
) {
val user = userRepository.getByOid(userOid)
user.updateWith(User.NewValue(
name = userUpdateIn.name,
email = userUpdateIn.email
))
}
}
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/controller/graphql/user/UserGraphController.kt | 1381181072 |
package kr.co.anna.api.filter
import org.springframework.stereotype.Component
import org.springframework.web.filter.OncePerRequestFilter
import org.springframework.web.util.ContentCachingRequestWrapper
import org.springframework.web.util.ContentCachingResponseWrapper
import javax.servlet.FilterChain
import javax.servlet.http.HttpServletRequest
import javax.servlet.http.HttpServletResponse
/**
* http req, res ๋ฅผ ์ฌ๋ฌ๋ฒ ์ฝ์ ์ ์๋๋ก ContentCaching Wrapper ์ฌ์
*
* ์ฐธ๊ณ : https://hirlawldo.tistory.com/44
*/
@Component
class CustomServletWrapperFilter : OncePerRequestFilter() {
override fun doFilterInternal(
request: HttpServletRequest,
response: HttpServletResponse,
filterChain: FilterChain
) {
val wrappingRequest = ContentCachingRequestWrapper(request)
val wrappingResponse = ContentCachingResponseWrapper(response)
filterChain.doFilter(wrappingRequest, wrappingResponse)
wrappingResponse.copyBodyToResponse();
}
}
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/filter/CustomServletWrapperFilter.kt | 2436623004 |
package kr.co.anna.api.service.command.user
import kr.co.anna.api.dto.user.*
import kr.co.anna.domain.model.user.User
import kr.co.anna.domain.repository.user.UserRepository
import kr.co.anna.lib.security.jwt.JwtGenerator
import org.springframework.dao.DataIntegrityViolationException
import org.springframework.security.crypto.password.PasswordEncoder
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
import java.time.LocalDateTime
import java.time.format.DateTimeFormatter
@Service
@Transactional
class UserCommandService(
private val userRepository: UserRepository,
private val passwordEncoder: PasswordEncoder,
) {
fun createUser(signUpIn: SignUpIn): UserOut {
val user: User = try {
userRepository.save(signUpIn.toEntity(passwordEncoder))
} catch (e: DataIntegrityViolationException) {
// index ์ด๋ฆ ๋ฐ DataIntegrityViolationException ๊ตฌํ์ ์์กดํ๋ฏ๋ก ์ข์ ๋ฐฉ์์ ์๋์ง๋ง,
// userId, email ๊ฐ๊ฐ์ ๋ํด ์ฟผ๋ฆฌ๋ฅผ 2๋ฒ ๋ ๋ฆด ํ์๊ฐ ์๋ ์ฅ์ ์ด ์๊ณ , ํต์ฌ ๋น์ฆ ๋ก์ง๋ ์๋๋ฏ๋ก ํธ๋ฆฌํ๊ฒ ์ ์ฉ
val defaultMsg = "๊ณ์ ์ ์์ฑํ ์ ์์ต๋๋ค. ๊ด๋ฆฌ์์๊ฒ ๋ฌธ์ํด์ฃผ์ธ์."
val msg = e.message ?: throw RuntimeException(defaultMsg)
when {
msg.contains("USER_ID") -> throw IllegalArgumentException("์ด๋ฏธ ์ฌ์ฉ ์ค์ธ ์ฌ์ฉ์ ์์ด๋ ์
๋๋ค.")
msg.contains("EMAIL") -> throw IllegalArgumentException("์ด๋ฏธ ์ฌ์ฉ ์ค์ธ ์ด๋ฉ์ผ ์
๋๋ค.")
else -> throw RuntimeException(defaultMsg)
}
}
return UserOut.fromEntity(user)
}
}
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/service/command/user/UserCommandService.kt | 3096603837 |
package kr.co.anna.api.service.command.user
import kr.co.anna.api.dto.user.SignInIn
import kr.co.anna.api.dto.user.SignInOut
import kr.co.anna.domain.model.user.User
import kr.co.anna.domain.repository.user.UserRepository
import kr.co.anna.lib.error.UnauthenticatedAccessException
import kr.co.anna.lib.security.SignInUser
import kr.co.anna.lib.security.jwt.JwtGenerator
import kr.co.anna.lib.utils.MessageUtil
import org.springframework.beans.factory.annotation.Value
import org.springframework.security.authentication.*
import org.springframework.security.core.Authentication
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
@Service
@Transactional
class UserLoginService(
private val authManager: AuthenticationManager,
private val jwtGenerator: JwtGenerator
) {
@Transactional(noRollbackFor = [BadCredentialsException::class])
fun login(signIn: SignInIn): SignInOut {
val authenticate: Authentication = try {
authManager.authenticate(UsernamePasswordAuthenticationToken(signIn.userId, signIn.password))
} catch (e: InternalAuthenticationServiceException) { // ์กด์ฌํ์ง ์๋ ์ฌ์ฉ์
throw InternalAuthenticationServiceException(MessageUtil.getMessage("USER_NOT_FOUND"))
} catch (e: DisabledException) { // ์ ํจํ ํ์์ด ์๋
throw DisabledException(MessageUtil.getMessage("LOGIN_FAIL"))
} catch (e: UnauthenticatedAccessException) {
throw UnauthenticatedAccessException()
}
val signInUser = authenticate.principal as SignInUser
return SignInOut.from(signInUser, jwtGenerator.generateUserToken(signInUser))
}
}
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/service/command/user/UserLoginService.kt | 1563520182 |
package kr.co.anna.api.interceptor
import org.springframework.web.servlet.HandlerInterceptor
import org.springframework.web.servlet.ModelAndView
import javax.servlet.http.HttpServletRequest
import javax.servlet.http.HttpServletResponse
/**
* Spring Intercepter
*/
class PersonalInfoLoggingInterceptor() : HandlerInterceptor {
override fun postHandle(
request: HttpServletRequest,
response: HttpServletResponse,
handler: Any,
modelAndView: ModelAndView?
) {
}
}
| kopring_graphql_querydsl/api/src/main/kotlin/kr/co/anna/api/interceptor/PersonalInfoLoggingInterceptor.kt | 2077290698 |
package com.studentschedulleapp.androidclient
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.studentschedulleapp.androidclient", appContext.packageName)
}
} | AndroidClient/app/src/androidTest/java/com/studentschedulleapp/androidclient/ExampleInstrumentedTest.kt | 3609032693 |
package com.studentschedulleapp.androidclient
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)
}
} | AndroidClient/app/src/test/java/com/studentschedulleapp/androidclient/ExampleUnitTest.kt | 835523166 |
package com.studentschedulleapp.androidclient.presentation.ui.theme
import androidx.compose.ui.graphics.Color
val Purple80 = Color(0xFFD0BCFF)
val PurpleGrey80 = Color(0xFFCCC2DC)
val Pink80 = Color(0xFFEFB8C8)
val Purple40 = Color(0xFF6650a4)
val PurpleGrey40 = Color(0xFF625b71)
val Pink40 = Color(0xFF7D5260) | AndroidClient/app/src/main/java/com/studentschedulleapp/androidclient/presentation/ui/theme/Color.kt | 4178949136 |
package com.studentschedulleapp.androidclient.presentation.ui.theme
import android.app.Activity
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.SideEffect
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.toArgb
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalView
import androidx.core.view.WindowCompat
private val DarkColorScheme = darkColorScheme(
primary = Purple80,
secondary = PurpleGrey80,
tertiary = Pink80
)
private val LightColorScheme = lightColorScheme(
primary = Color(0xFF2980B9),
secondary = Color(0xFF1ABC9C),
primaryContainer = Color(0xFF376D8F),
surfaceVariant = Color(0xFF15425F),
surface = Color(0xFFE9E9E9),
)
@Composable
fun AndroidClientTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
// Dynamic color is available on Android 12+
dynamicColor: Boolean = true,
content: @Composable () -> Unit
) {
val colorScheme = when {
dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
val context = LocalContext.current
if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
}
darkTheme -> DarkColorScheme
else -> LightColorScheme
}
val view = LocalView.current
if (!view.isInEditMode) {
SideEffect {
val window = (view.context as Activity).window
window.statusBarColor = colorScheme.primary.toArgb()
WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = darkTheme
}
}
MaterialTheme(
colorScheme = colorScheme,
typography = Typography,
content = content
)
} | AndroidClient/app/src/main/java/com/studentschedulleapp/androidclient/presentation/ui/theme/Theme.kt | 1493520199 |
package com.studentschedulleapp.androidclient.presentation.ui.theme
import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
// Set of Material typography styles to start with
val Typography = Typography(
bodyLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 16.sp,
lineHeight = 24.sp,
letterSpacing = 0.5.sp
)
/* Other default text styles to override
titleLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 22.sp,
lineHeight = 28.sp,
letterSpacing = 0.sp
),
labelSmall = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Medium,
fontSize = 11.sp,
lineHeight = 16.sp,
letterSpacing = 0.5.sp
)
*/
) | AndroidClient/app/src/main/java/com/studentschedulleapp/androidclient/presentation/ui/theme/Type.kt | 2327160446 |
package com.studentschedulleapp.androidclient.presentation
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import com.studentschedulleapp.androidclient.presentation.ui.theme.AndroidClientTheme
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
AndroidClientTheme {
// A surface container using the 'background' color from the theme
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
Greeting("Android")
}
}
}
}
}
@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
Text(
text = "Hello $name!",
modifier = modifier
)
}
@Preview(showBackground = true)
@Composable
fun GreetingPreview() {
AndroidClientTheme {
Greeting("Android")
}
} | AndroidClient/app/src/main/java/com/studentschedulleapp/androidclient/presentation/MainActivity.kt | 3631648561 |
package com.studentschedulleapp.androidclient
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.studentschedulleapp.androidclient.test", appContext.packageName)
}
} | AndroidClient/data/src/androidTest/java/com/studentschedulleapp/androidclient/ExampleInstrumentedTest.kt | 3924849889 |
package com.studentschedulleapp.androidclient
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)
}
} | AndroidClient/data/src/test/java/com/studentschedulleapp/androidclient/ExampleUnitTest.kt | 835523166 |
package com.studentschedulleapp.androidclient
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.studentschedulleapp.androidclient.test", appContext.packageName)
}
} | AndroidClient/domain/src/androidTest/java/com/studentschedulleapp/androidclient/ExampleInstrumentedTest.kt | 3924849889 |
package com.studentschedulleapp.androidclient
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)
}
} | AndroidClient/domain/src/test/java/com/studentschedulleapp/androidclient/ExampleUnitTest.kt | 835523166 |
package rs.ac.metropolitan.cs330_dz06_anteaprimorac5157
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("rs.ac.metropolitan.cs330_dz06_anteaprimorac5157", appContext.packageName)
}
} | CS330-DZ06-Zadatak3-AnteaPrimorac/app/src/androidTest/java/rs/ac/metropolitan/cs330_dz06_anteaprimorac5157/ExampleInstrumentedTest.kt | 2964406475 |
package rs.ac.metropolitan.cs330_dz06_anteaprimorac5157
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)
}
} | CS330-DZ06-Zadatak3-AnteaPrimorac/app/src/test/java/rs/ac/metropolitan/cs330_dz06_anteaprimorac5157/ExampleUnitTest.kt | 73693298 |
package rs.ac.metropolitan.cs330_dz06_anteaprimorac5157
import android.app.Activity
import android.content.res.Configuration
import android.os.Bundle
import android.util.Log
import android.widget.ArrayAdapter
import android.widget.ImageView
import android.widget.ListView
import android.widget.Toast
import android.content.Intent
import kotlin.random.Random
class MyActivity : Activity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val moleImageView: ImageView = findViewById(R.id.moleImageView)
val moleListView: ListView = findViewById(R.id.moleListView)
// Elementi poprimaju vrijednosti iz strings.xml.
val moleNames = resources.getStringArray(R.array.mole_names)
// Podeลกavanje ArrayAdapter objekta za ListView
val adapter = ArrayAdapter(this, android.R.layout.simple_list_item_1, moleNames)
moleListView.adapter = adapter
moleListView.setOnItemClickListener { _, _, position, _ ->
val drawableId = when (position) {
0 -> R.drawable.sprout_mole
1 -> R.drawable.box_mole
2 -> R.drawable.warden_mole
else -> {
Log.e("MyActivity", "No image available for this position.")
0
}
}
if (drawableId != 0) {
moleImageView.setImageResource(drawableId)
if (Random.nextInt(10) == 1) { // 10% ลกanse za trigger intenta
Toast.makeText(this, getString(R.string.lucky), Toast.LENGTH_SHORT).show()
val emailIntent = Intent(Intent.ACTION_SEND).apply {
type = "message/rfc822"
putExtra(
Intent.EXTRA_SUBJECT,
getString(R.string.email_subject)
)
putExtra(Intent.EXTRA_TEXT, getString(R.string.email_body))
}
if (emailIntent.resolveActivity(packageManager) != null) {
startActivity(Intent.createChooser(emailIntent, "Send email..."))
} else {
Toast.makeText(this, "No email client installed.", Toast.LENGTH_SHORT)
.show()
}
}
}
}
}
override fun onConfigurationChanged(newConfig: Configuration) {
super.onConfigurationChanged(newConfig)
val message = when (newConfig.orientation) {
Configuration.ORIENTATION_LANDSCAPE -> getString(R.string.landscape_toast)
Configuration.ORIENTATION_PORTRAIT -> getString(R.string.portrait_toast)
else -> ""
}
if (message.isNotEmpty()) {
Toast.makeText(this, message, Toast.LENGTH_SHORT).show()
}
}
}
| CS330-DZ06-Zadatak3-AnteaPrimorac/app/src/main/java/rs/ac/metropolitan/cs330_dz06_anteaprimorac5157/MyActivity.kt | 3130976229 |
package com.example.core
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.core.test", appContext.packageName)
}
} | JetBlogCleanArchitecture/core/src/androidTest/java/com/example/core/ExampleInstrumentedTest.kt | 3393852045 |
package com.example.core
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)
}
} | JetBlogCleanArchitecture/core/src/test/java/com/example/core/ExampleUnitTest.kt | 2303082555 |
package com.example.core.di
import com.example.core.Utils.Constant
import com.example.core.data.network.api.ApiService
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import okhttp3.CertificatePinner
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import java.util.concurrent.TimeUnit
@InstallIn(SingletonComponent::class)
@Module
object DataModule {
@Provides
fun provideApiService(): ApiService {
val hostname = "dummyapi.io"
val certificatePinner = CertificatePinner.Builder()
.add(hostname, "sha256/F6jTih9VkkYZS8yuYqeU/4DUGehJ+niBGkkQ1yg8H3U=")
.add(hostname, "sha256/cXjPgKdVe6iojP8s0YQJ3rtmDFHTnYZxcYvmYGFiYME=")
.add(hostname, "sha256/hxqRlPTu1bMS/0DITB1SSu0vd4u/8l8TjPgfaAp63Gc=")
.add(hostname, "sha256/K87oWBWM9UZfyddvDfoxL+8lpNyoUB2ptGtn0fv6G2Q=")
.build()
val loggingInterceptor =
HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY)
val client = OkHttpClient.Builder()
.addInterceptor(loggingInterceptor)
.connectTimeout(120, TimeUnit.SECONDS)
.readTimeout(120, TimeUnit.SECONDS)
.certificatePinner(certificatePinner)
.build()
val retrofit = Retrofit.Builder()
.baseUrl(Constant.BASE_URL)
.addConverterFactory(GsonConverterFactory.create())
.client(client)
.build()
return retrofit.create(ApiService::class.java)
}
// @Provides
// fun provideRemoteDataSource(apiService: ApiService) : RemoteDataSource =
// RemoteDataSource(apiService)
//
// @Provides
// fun provideLocalDataSource() : LocalDataSource =
// LocalDataSource()
// @Provides
// fun provideBlogRepositoryImpl(remoteDataSource: RemoteDataSource, localDataSource: LocalDataSource, ): BlogRepository =
// BlogRepositoryImpl()
} | JetBlogCleanArchitecture/core/src/main/java/com/example/core/di/DataModule.kt | 3042090439 |
package com.example.core.di
import com.example.core.data.source.BlogRepositoryImpl
import com.example.core.domain.repository.BlogRepository
import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
@Module(includes = [DatabaseModule::class, DataModule::class])
@InstallIn(SingletonComponent::class)
abstract class RepositoryModule {
@Binds
abstract fun provideRepository(blogRepository: BlogRepositoryImpl) : BlogRepository
} | JetBlogCleanArchitecture/core/src/main/java/com/example/core/di/RepositoryModule.kt | 1717490526 |
package com.example.core.di
import android.content.Context
import androidx.room.Room
import com.example.core.data.local.db.BlogDao
import com.example.core.data.local.db.BlogDatabase
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.qualifiers.ApplicationContext
import dagger.hilt.components.SingletonComponent
import net.sqlcipher.database.SupportFactory
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
class DatabaseModule {
@Singleton
@Provides
fun provideDatabase(@ApplicationContext context: Context): BlogDatabase {
val passphrase: ByteArray = net.sqlcipher.database.SQLiteDatabase.getBytes("satrio".toCharArray())
val factory = SupportFactory(passphrase)
return Room.databaseBuilder(
context,
BlogDatabase::class.java, "Blog.db"
).fallbackToDestructiveMigration()
.openHelperFactory(factory)
.build()
}
@Provides
fun provideMovieDao(database: BlogDatabase): BlogDao = database.blogDao()
} | JetBlogCleanArchitecture/core/src/main/java/com/example/core/di/DatabaseModule.kt | 2178037401 |
package com.example.core.Utils
object Constant {
const val BASE_URL = "https://dummyapi.io/data/v1/"
const val APP_ID = "653c562ca291fa2ca39149ce"
} | JetBlogCleanArchitecture/core/src/main/java/com/example/core/Utils/Constant.kt | 2211525159 |
package com.example.core.Utils
import com.example.core.data.local.entity.BlogEntity
import com.example.core.data.local.entity.OwnerEntity
import com.example.core.data.network.model.BlogDTO
import com.example.core.data.network.model.OwnerDTO
import com.example.core.domain.model.Blog
import com.example.core.domain.model.Owner
fun List<BlogDTO>.toDomain(): List<Blog> {
return map {
Blog(
id = it.id ?: "",
image = it.image ?: "",
likes = it.likes ?: 0,
owner = it.owner?.toDomain() ?: Owner("", "", "", "", ""),
publishDate = it.publishDate ?: "",
tags = it.tags ?: emptyList(),
text = it.text ?: "",
isFavorite = false
)
}
}
fun List<BlogDTO>.toEntity(): List<BlogEntity> {
return map {
BlogEntity(
id = it.id ?: "",
image = it.image ?: "",
likes = it.likes ?: 0,
owner = it.owner?.toEntity() ?: OwnerEntity("", "", "", "", ""),
publishDate = it.publishDate ?: "",
tags = it.tags ?: emptyList(),
text = it.text ?: ""
)
}
}
fun OwnerDTO.toEntity(): OwnerEntity {
return OwnerEntity(
firstName ?: "",
id ?: "",
lastName ?: "",
picture ?: "",
title ?: ""
)
}
fun OwnerEntity.toDomain(): Owner {
return Owner(
firstName,
id,
lastName,
picture,
title
)
}
fun OwnerDTO.toDomain(): Owner {
return Owner(
firstName ?: "",
id ?: "",
lastName ?: "",
picture ?: "",
title ?: ""
)
}
fun Owner.toEntity(): OwnerEntity {
return OwnerEntity(
firstName,
id,
lastName,
picture,
title
)
}
object DataMapper {
fun mapResponsesToEntities(input: List<BlogDTO?>?): List<BlogEntity> {
val blogList = ArrayList<BlogEntity>()
input?.map {
val news = BlogEntity(
id = it?.id ?: "",
image = it?.image ?: "",
likes = it?.likes ?: 0,
owner = it?.owner?.toEntity() ?: OwnerEntity("", "", "", "", ""),
publishDate = it?.publishDate ?: "",
tags = it?.tags ?: emptyList(),
text = it?.text ?: ""
)
blogList.add(news)
}
return blogList
}
fun mapEntitiesToDomain(input: List<BlogEntity>): List<Blog> =
input.map {
Blog(
id = it.id,
image = it.image,
likes = it.likes,
owner = it.owner.toDomain(),
publishDate = it.publishDate,
tags = it.tags,
text = it.text,
isFavorite = it.isFavorite
)
}
fun mapDomainToEntity(input: Blog) = BlogEntity(
id = input.id,
image = input.image,
likes = input.likes,
owner = input.owner.toEntity(),
publishDate = input.publishDate,
tags = input.tags,
text = input.text
)
} | JetBlogCleanArchitecture/core/src/main/java/com/example/core/Utils/DataMapper.kt | 3835502321 |
package com.example.core.Utils
import android.util.Log
import org.json.JSONException
import org.json.JSONObject
import retrofit2.Response
import java.io.IOException
abstract class SafeApiRequest {
suspend fun <T : Any> safeApiRequest(call: suspend () -> Response<T>): T {
val response = call.invoke()
if (response.isSuccessful) {
return response.body()!!
} else {
val responseErr = response.errorBody()?.string()
val message = StringBuilder()
responseErr.let {
try {
message.append(JSONObject(it).getString("error"))
} catch (e: JSONException) {
}
}
Log.d("TAG", "safeApiRequest: $message")
throw ApiException(message.toString())
}
}
}
class ApiException(message: String) : IOException(message)
class NoInternetException(message: String) : IOException(message) | JetBlogCleanArchitecture/core/src/main/java/com/example/core/Utils/SafeApiRequest.kt | 2168293322 |
package com.example.core.Utils
import androidx.room.TypeConverter
import com.example.core.data.local.entity.OwnerEntity
import com.google.gson.Gson
import com.google.gson.reflect.TypeToken
class StringListConverter {
@TypeConverter
fun fromString(value: String): List<String> {
val listType = object : TypeToken<List<String>>() {}.type
return Gson().fromJson(value, listType)
}
@TypeConverter
fun fromList(list: List<String>): String {
return Gson().toJson(list)
}
}
class OwnerEntityConverter {
@TypeConverter
fun fromOwnerEntity(owner: OwnerEntity): String {
return Gson().toJson(owner)
}
@TypeConverter
fun toOwnerEntity(ownerString: String): OwnerEntity {
return Gson().fromJson(ownerString, OwnerEntity::class.java)
}
}
| JetBlogCleanArchitecture/core/src/main/java/com/example/core/Utils/StringListConverter.kt | 2642156794 |
package com.example.core.Utils
import android.os.Handler
import android.os.Looper
import androidx.annotation.VisibleForTesting
import java.util.concurrent.Executor
import java.util.concurrent.Executors
import javax.inject.Inject
class AppExecutors @VisibleForTesting constructor(
private val diskIO: Executor,
private val networkIO: Executor,
private val mainThread: Executor
) {
companion object {
private const val THREAD_COUNT = 3
}
@Inject
constructor() : this(
Executors.newSingleThreadExecutor(),
Executors.newFixedThreadPool(THREAD_COUNT),
MainThreadExecutor()
)
fun diskIO(): Executor = diskIO
fun networkIO(): Executor = networkIO
fun mainThread(): Executor = mainThread
private class MainThreadExecutor : Executor {
private val mainThreadHandler = Handler(Looper.getMainLooper())
override fun execute(command: Runnable) {
mainThreadHandler.post(command)
}
}
} | JetBlogCleanArchitecture/core/src/main/java/com/example/core/Utils/AppExecutors.kt | 397977330 |
package com.example.core.data.source
import com.example.core.Utils.AppExecutors
import com.example.core.Utils.DataMapper
import com.example.core.data.local.LocalDataSource
import com.example.core.data.network.RemoteDataSource
import com.example.core.data.network.api.ApiResponse
import com.example.core.data.network.model.BlogDTO
import com.example.core.domain.model.Blog
import com.example.core.domain.repository.BlogRepository
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.FlowCollector
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.withContext
import javax.inject.Inject
class BlogRepositoryImpl @Inject constructor(
private val remoteDataSource: RemoteDataSource,
private val localDataSource: LocalDataSource,
private val appExcecutor: AppExecutors
) : BlogRepository {
// override suspend fun getAllBlogs(): Flow<Resource<List<Blog>>> {
// return flow {
// emit(Resource.Loading)
// try {
// val response = apiService.getBlogs()
// if (response.isSuccessful) {
// val bloglist = response.body()?.data?.toDomain() ?: emptyList()
// emit(Resource.Success(bloglist))
// } else {
// emit(Resource.Error(response.message()))
// }
// } catch (e: Exception) {
// emit(Resource.Error(e.message.toString()))
// }
// }.flowOn(Dispatchers.IO)
// }
override suspend fun getAllBlogs(): Flow<Resource<List<Blog>>> {
return object : NetworkBoundResource<List<Blog>, List<BlogDTO>>(),
Flow <Resource<List<Blog>>>{
override fun loadFromDB(): Flow<List<Blog>> {
return localDataSource.getAllBlogs().map { DataMapper.mapEntitiesToDomain(it) }
}
override suspend fun createCall(): Flow<ApiResponse<List<BlogDTO?>?>> {
return remoteDataSource.getAllBlogs()
}
override suspend fun saveCallResult(data: List<BlogDTO?>?) {
withContext(Dispatchers.IO){
localDataSource.insertBlog(DataMapper.mapResponsesToEntities(data))
}
}
override fun shouldFetch(data: List<Blog>?): Boolean {
return data.isNullOrEmpty()
}
override suspend fun collect(collector: FlowCollector<Resource<List<Blog>>>) {
}
}.asFlow()
}
override fun getFavorite(): Flow<List<Blog>> {
return localDataSource.getFavorite().map { DataMapper.mapEntitiesToDomain(it) }
}
override fun setFavorite(blog: Blog, state: Boolean) {
val newsEntity = DataMapper.mapDomainToEntity(blog)
appExcecutor.diskIO().execute {
localDataSource.setFavoriteBlogs(newsEntity,state)
}
}
} | JetBlogCleanArchitecture/core/src/main/java/com/example/core/data/source/BlogRepositoryImpl.kt | 2867771651 |
package com.example.core.data.source
sealed class Resource<out R> private constructor() {
data class Success<out T>(val data: T) : Resource<T>()
data class Error(val error: String) : Resource<Nothing>()
object Loading : Resource<Nothing>()
} | JetBlogCleanArchitecture/core/src/main/java/com/example/core/data/source/Resource.kt | 4023715196 |
package com.example.core.data.source
import com.example.core.data.network.api.ApiResponse
import com.example.core.data.network.model.BlogDTO
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.emitAll
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.map
abstract class NetworkBoundResource<ResultType, RequestType> {
private val result: Flow<Resource<ResultType>> = flow {
emit(Resource.Loading)
val dbSource = loadFromDB().first()
if (shouldFetch(dbSource)) {
emit(Resource.Loading)
when (val apiResponse = createCall().first()) {
is ApiResponse.Success -> {
saveCallResult(apiResponse.data)
emitAll(loadFromDB().map { Resource.Success(it) })
}
is ApiResponse.Error -> {
onFetchFailed()
emit(Resource.Error(apiResponse.errorMessage))
}
else -> {}
}
} else {
emitAll(loadFromDB().map { Resource.Success(it) })
}
}
protected open fun onFetchFailed() {}
protected abstract fun loadFromDB(): Flow<ResultType>
protected abstract fun shouldFetch(data: ResultType?): Boolean
protected abstract suspend fun createCall(): Flow<ApiResponse<List<BlogDTO?>?>>
protected abstract suspend fun saveCallResult(data: List<BlogDTO?>?)
fun asFlow(): Flow<Resource<ResultType>> = result
} | JetBlogCleanArchitecture/core/src/main/java/com/example/core/data/source/NetworkBoundResource.kt | 4016667672 |
package com.example.core.data.network
import android.util.Log
import com.example.core.data.network.api.ApiResponse
import com.example.core.data.network.api.ApiService
import com.example.core.data.network.model.BlogDTO
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.flowOn
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class RemoteDataSource @Inject constructor(private val apiService: ApiService) {
suspend fun getAllBlogs(): Flow<ApiResponse<List<BlogDTO?>?>> {
// return flow {
// try {
// val response = apiService.getBlogs()
// val bloglist = response.data
// if (bloglist?.isNotEmpty() == true) {
// emit(ApiResponse.Success(response.data))
// } else {
// emit(ApiResponse.Empty)
// }
// } catch (e: Exception) {
// emit(Resource.Error(e.message.toString()))
// }
// }.flowOn(Dispatchers.IO)
return flow {
try{
val response = apiService.getBlogs()
val data = response.data
if (data?.isNotEmpty() == true){
emit(ApiResponse.Success(response.data))
} else {
emit(ApiResponse.Empty)
}
} catch (e : Exception){
emit(ApiResponse.Error(e.toString()))
Log.e("RemoteDataSource", e.toString())
}
}.flowOn(Dispatchers.IO)
}
} | JetBlogCleanArchitecture/core/src/main/java/com/example/core/data/network/RemoteDataSource.kt | 4230506092 |
package com.example.core.data.network.model
import androidx.annotation.Keep
@Keep
data class BlogDTO(
val id: String?,
val image: String?,
val likes: Int?,
val owner: OwnerDTO?,
val publishDate: String?,
val tags: List<String>?,
val text: String?
) | JetBlogCleanArchitecture/core/src/main/java/com/example/core/data/network/model/BlogDTO.kt | 4135387463 |
package com.example.core.data.network.model
import androidx.annotation.Keep
@Keep
data class BlogsDTO(
val `data`: List<BlogDTO>?,
val limit: Int?,
val page: Int?,
val total: Int?
) | JetBlogCleanArchitecture/core/src/main/java/com/example/core/data/network/model/BlogsDTO.kt | 3688516073 |
package com.example.core.data.network.model
import androidx.annotation.Keep
@Keep
data class OwnerDTO(
val firstName: String?,
val id: String?,
val lastName: String?,
val picture: String?,
val title: String?
) | JetBlogCleanArchitecture/core/src/main/java/com/example/core/data/network/model/OwnerDTO.kt | 2802766273 |
package com.example.core.data.network.api
import com.example.core.Utils.Constant
import com.example.core.data.network.model.BlogsDTO
import retrofit2.http.GET
import retrofit2.http.Header
interface ApiService {
@GET("post")
suspend fun getBlogs (
@Header("app-id") appId:String= Constant.APP_ID
) : BlogsDTO
} | JetBlogCleanArchitecture/core/src/main/java/com/example/core/data/network/api/ApiService.kt | 2793111830 |
package com.example.core.data.network.api
sealed class ApiResponse<out R> {
data class Success<out T>(val data: T) : ApiResponse<T>()
data class Error(val errorMessage: String) : ApiResponse<Nothing>()
object Empty : ApiResponse<Nothing>()
} | JetBlogCleanArchitecture/core/src/main/java/com/example/core/data/network/api/ApiResponse.kt | 3345823014 |
package com.example.core.data.local.entity
import androidx.room.Entity
import androidx.room.PrimaryKey
import androidx.room.TypeConverters
import com.example.core.Utils.OwnerEntityConverter
import com.example.core.Utils.StringListConverter
@TypeConverters(StringListConverter::class, OwnerEntityConverter::class)
@Entity(tableName = "blog")
data class BlogEntity (
@PrimaryKey(autoGenerate = false)
var id: String,
val image: String,
val likes: Int,
val owner: OwnerEntity,
val publishDate: String,
val tags: List<String>,
val text: String,
var isFavorite: Boolean = false
) | JetBlogCleanArchitecture/core/src/main/java/com/example/core/data/local/entity/BlogEntity.kt | 1644172660 |
package com.example.core.data.local.entity
import android.os.Parcelable
import kotlinx.android.parcel.Parcelize
data class OwnerEntity(
val firstName: String,
val id: String,
val lastName: String,
val picture: String,
val title: String
) | JetBlogCleanArchitecture/core/src/main/java/com/example/core/data/local/entity/OwnerEntity.kt | 1121947572 |
package com.example.core.data.local
import com.example.core.data.local.db.BlogDao
import com.example.core.data.local.entity.BlogEntity
import kotlinx.coroutines.flow.Flow
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class LocalDataSource @Inject constructor(private val blogDao: BlogDao) {
fun getAllBlogs(): Flow<List<BlogEntity>> = blogDao.getAllBlog()
fun getFavorite(): Flow<List<BlogEntity>> = blogDao.getFavoriteBlog()
fun insertBlog(blogList: List<BlogEntity>) = blogDao.insertAllBlogs(blogList)
fun setFavoriteBlogs(blogs: BlogEntity, newState: Boolean) {
blogs.isFavorite = newState
blogDao.updateFavoriteBlogs(blogs)
}
} | JetBlogCleanArchitecture/core/src/main/java/com/example/core/data/local/LocalDataSource.kt | 392689265 |
package com.example.core.data.local.db
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import androidx.room.Update
import com.example.core.data.local.entity.BlogEntity
import kotlinx.coroutines.flow.Flow
@Dao
interface BlogDao {
@Query("SELECT * FROM blog")
fun getAllBlog() : Flow<List<BlogEntity>>
@Query("SELECT * FROM blog WHERE isFavorite = 1")
fun getFavoriteBlog() : Flow<List<BlogEntity>>
@Insert(onConflict = OnConflictStrategy.REPLACE)
fun insertAllBlogs(blogs: List<BlogEntity>)
@Update
fun updateFavoriteBlogs(blog: BlogEntity)
} | JetBlogCleanArchitecture/core/src/main/java/com/example/core/data/local/db/BlogDao.kt | 2578551915 |
package com.example.core.data.local.db
import androidx.room.Database
import androidx.room.RoomDatabase
import com.example.core.data.local.entity.BlogEntity
@Database(entities = [BlogEntity::class], version = 1, exportSchema = false)
abstract class BlogDatabase : RoomDatabase() {
abstract fun blogDao(): BlogDao
} | JetBlogCleanArchitecture/core/src/main/java/com/example/core/data/local/db/BlogDatabase.kt | 3152622531 |
package com.example.core.domain.repository
import com.example.core.data.source.Resource
import com.example.core.domain.model.Blog
import kotlinx.coroutines.flow.Flow
interface BlogRepository {
suspend fun getAllBlogs() : Flow<Resource<List<Blog>>>
fun getFavorite() :Flow<List<Blog>>
fun setFavorite(blog: Blog, state: Boolean)
} | JetBlogCleanArchitecture/core/src/main/java/com/example/core/domain/repository/BlogRepository.kt | 4100867191 |
package com.example.core.domain.model
import androidx.annotation.Keep
@Keep
data class Blogs(
val `data`: List<Blog>,
val limit: Int,
val page: Int,
val total: Int
) | JetBlogCleanArchitecture/core/src/main/java/com/example/core/domain/model/Blogs.kt | 3203038165 |
package com.example.core.domain.model
import android.os.Parcelable
import kotlinx.android.parcel.Parcelize
@Parcelize
data class Blog(
val id: String,
val image: String,
val likes: Int,
val owner: Owner,
val publishDate: String,
val tags: List<String>,
val text: String,
val isFavorite: Boolean
) : Parcelable | JetBlogCleanArchitecture/core/src/main/java/com/example/core/domain/model/Blog.kt | 3348109437 |
package com.example.core.domain.model
import android.os.Parcelable
import kotlinx.android.parcel.Parcelize
@Parcelize
data class Owner(
val firstName: String,
val id: String,
val lastName: String,
val picture: String,
val title: String
) : Parcelable | JetBlogCleanArchitecture/core/src/main/java/com/example/core/domain/model/Owner.kt | 798993651 |
package com.example.core.domain.usecases
import com.example.core.data.source.Resource
import com.example.core.domain.model.Blog
import com.example.core.domain.repository.BlogRepository
import kotlinx.coroutines.flow.Flow
import javax.inject.Inject
class BlogInteractor @Inject constructor(private val blogRepository: BlogRepository) : BlogUseCase {
override suspend fun getAllBlog(): Flow<Resource<List<Blog>>> {
return blogRepository.getAllBlogs()
}
override fun getFavorite(): Flow<List<Blog>> {
return blogRepository.getFavorite()
}
override fun setFavorite(blog: Blog, state: Boolean) {
return blogRepository.setFavorite(blog, state)
}
} | JetBlogCleanArchitecture/core/src/main/java/com/example/core/domain/usecases/BlogInteractor.kt | 466500262 |
package com.example.core.domain.usecases
import com.example.core.data.source.Resource
import com.example.core.domain.model.Blog
import kotlinx.coroutines.flow.Flow
interface BlogUseCase {
suspend fun getAllBlog() : Flow<Resource<List<Blog>>>
fun getFavorite(): Flow<List<Blog>>
fun setFavorite(blog: Blog, state: Boolean)
} | JetBlogCleanArchitecture/core/src/main/java/com/example/core/domain/usecases/BlogUseCase.kt | 1788538149 |
package com.example.jetblogca
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.jetblogca", appContext.packageName)
}
} | JetBlogCleanArchitecture/app/src/androidTest/java/com/example/jetblogca/ExampleInstrumentedTest.kt | 3162659573 |
package com.example.jetblogca
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)
}
} | JetBlogCleanArchitecture/app/src/test/java/com/example/jetblogca/ExampleUnitTest.kt | 3364174505 |
package com.example.jetblogca.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) | JetBlogCleanArchitecture/app/src/main/java/com/example/jetblogca/ui/theme/Color.kt | 1559614938 |
package com.example.jetblogca.ui.theme
import android.app.Activity
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.SideEffect
import androidx.compose.ui.graphics.toArgb
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalView
import androidx.core.view.WindowCompat
private val DarkColorScheme = darkColorScheme(
primary = Purple80,
secondary = PurpleGrey80,
tertiary = Pink80
)
private val LightColorScheme = lightColorScheme(
primary = Purple40,
secondary = PurpleGrey40,
tertiary = Pink40
/* Other default colors to override
background = Color(0xFFFFFBFE),
surface = Color(0xFFFFFBFE),
onPrimary = Color.White,
onSecondary = Color.White,
onTertiary = Color.White,
onBackground = Color(0xFF1C1B1F),
onSurface = Color(0xFF1C1B1F),
*/
)
@Composable
fun JetBlogCATheme(
darkTheme: Boolean = isSystemInDarkTheme(),
// Dynamic color is available on Android 12+
dynamicColor: Boolean = true,
content: @Composable () -> Unit
) {
val colorScheme = when {
dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
val context = LocalContext.current
if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
}
darkTheme -> DarkColorScheme
else -> LightColorScheme
}
val view = LocalView.current
if (!view.isInEditMode) {
SideEffect {
val window = (view.context as Activity).window
window.statusBarColor = colorScheme.primary.toArgb()
WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = darkTheme
}
}
MaterialTheme(
colorScheme = colorScheme,
typography = Typography,
content = content
)
} | JetBlogCleanArchitecture/app/src/main/java/com/example/jetblogca/ui/theme/Theme.kt | 521733272 |
package com.example.jetblogca.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
)
*/
) | JetBlogCleanArchitecture/app/src/main/java/com/example/jetblogca/ui/theme/Type.kt | 1757230384 |
package com.example.jetblogca
import android.os.Build
import android.os.Bundle
import android.util.Log
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.ui.Modifier
import androidx.navigation.compose.rememberNavController
import com.example.core.domain.model.Blog
import com.example.jetblogca.navigation.Navigation
import com.example.jetblogca.ui.theme.JetBlogCATheme
import dagger.hilt.android.AndroidEntryPoint
@AndroidEntryPoint
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
JetBlogCATheme {
// A surface container using the 'background' color from the theme
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
val isFromFav = intent.getBooleanExtra("fromfav", false)
val blog = if (Build.VERSION.SDK_INT >= 33) {
intent.getParcelableExtra<Blog>("blogf", Blog::class.java)
} else {
@Suppress("DEPRECATION")
intent.getParcelableExtra<Blog>("blogf")
}
Log.d("0212", "onCreate: $isFromFav, $blog")
val navController = rememberNavController()
Navigation(navController = navController, isFromFav, blogf = blog)
}
}
}
}
} | JetBlogCleanArchitecture/app/src/main/java/com/example/jetblogca/MainActivity.kt | 1538056851 |
package com.example.jetblogca.di
import com.example.core.domain.usecases.BlogInteractor
import com.example.core.domain.usecases.BlogUseCase
import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
@Module
@InstallIn(SingletonComponent::class)
abstract class AppModule {
@Binds
abstract fun provideBlogUseCase(blogInteractor: BlogInteractor): BlogUseCase
} | JetBlogCleanArchitecture/app/src/main/java/com/example/jetblogca/di/AppModule.kt | 2224339874 |
package com.example.jetblogca.di
import com.example.core.domain.usecases.BlogUseCase
import dagger.hilt.EntryPoint
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
@EntryPoint
@InstallIn(SingletonComponent::class)
interface FavoriteModuleDependencies {
fun blogUseCase(): BlogUseCase
} | JetBlogCleanArchitecture/app/src/main/java/com/example/jetblogca/di/FavoriteModuleDependencies.kt | 308858973 |
package com.example.jetblogca.navigation
import androidx.compose.runtime.Composable
import androidx.navigation.NavHostController
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import com.example.core.domain.model.Blog
import com.example.jetblogca.screen.detail.DetailScreen
import com.example.jetblogca.screen.home.HomeScreen
@Composable
fun Navigation(navController: NavHostController, from: Boolean, blogf: Blog? = null) {
// val detailViewModel: DetailViewModel = hiltViewModel()
NavHost(
navController = navController,
// startDestination = Screen.Home.route
startDestination = if (from) {
Screen.Detail.route
} else {
Screen.Home.route
}
) {
composable(Screen.Home.route) {
HomeScreen(navController = navController)
}
composable(Screen.Detail.route) {
val blog: Blog? = if (from) {
blogf
} else {
navController.previousBackStackEntry?.savedStateHandle?.get<Blog>("blog")
}
DetailScreen(blog,navController)
}
}
} | JetBlogCleanArchitecture/app/src/main/java/com/example/jetblogca/navigation/Navigation.kt | 439903012 |
package com.example.jetblogca.navigation
sealed class Screen (val route: String) {
object Home: Screen("home")
object Detail: Screen("detail")
object Favorite: Screen("detail")
} | JetBlogCleanArchitecture/app/src/main/java/com/example/jetblogca/navigation/Screen.kt | 2634271142 |
package com.example.jetblogca
import android.app.Application
import dagger.hilt.android.HiltAndroidApp
@HiltAndroidApp
class BaseApplication : Application() | JetBlogCleanArchitecture/app/src/main/java/com/example/jetblogca/BaseApplication.kt | 1130577937 |
package com.example.jetblogca.screen.home
import android.util.Log
import androidx.compose.runtime.State
import androidx.compose.runtime.mutableStateOf
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.core.data.source.Resource
import com.example.core.domain.usecases.BlogUseCase
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class HomeViewModel @Inject constructor(private val getBlogUseCase: BlogUseCase) : ViewModel() {
private val _blogs= mutableStateOf<HomeState>(HomeState())
val blogs: State<HomeState> = _blogs
init {
Log.d("MyApp", "homeviewmodel init ")
getBlogs()
}
fun getBlogs() {
Log.d("MyApp", "getblog exe")
viewModelScope.launch {
Log.d("MyApp", "getblog vscope")
getBlogUseCase.getAllBlog().collect {
Log.d("MyApp", "onEach executed: $it")
when(it){
is Resource.Loading -> {
_blogs.value = HomeState(isLoading = true)
}
is Resource.Success -> {
_blogs.value = HomeState(data = it.data)
}
is Resource.Error -> {
_blogs.value = HomeState(error = it.error.toString())
}
else -> {}
}
}
}
}
} | JetBlogCleanArchitecture/app/src/main/java/com/example/jetblogca/screen/home/HomeViewModel.kt | 3655097324 |
package com.example.jetblogca.screen.home
import com.example.core.domain.model.Blog
data class HomeState (
var isLoading: Boolean = false,
var data: List<Blog>? = null,
var error: String = ""
) | JetBlogCleanArchitecture/app/src/main/java/com/example/jetblogca/screen/home/HomeState.kt | 3378348156 |
package com.example.jetblogca.screen.home
import android.annotation.SuppressLint
import android.content.Intent
import android.widget.Toast
import androidx.compose.foundation.Image
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Favorite
import androidx.compose.material3.Card
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.Divider
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.FloatingActionButton
import androidx.compose.material3.Icon
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.graphics.Color
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.navigation.NavHostController
import coil.compose.rememberAsyncImagePainter
import com.example.core.domain.model.Blog
import com.example.jetblogca.navigation.Screen
@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun HomeScreen(navController: NavHostController, homeViewModel: HomeViewModel = hiltViewModel()) {
val res = homeViewModel.blogs.value
if (res.isLoading) {
Box(modifier = Modifier.fillMaxSize()) {
CircularProgressIndicator(modifier = Modifier.align(Alignment.Center))
}
}
if (res.error.isNotBlank()) {
Box(modifier = Modifier.fillMaxSize()) {
Text(text = res.error.toString(), modifier = Modifier.align(Alignment.Center))
}
}
val context = LocalContext.current
Scaffold(
floatingActionButton = {
FloatingActionButton(onClick = {
try {
context.startActivity(
Intent(
context,
Class.forName("com.example.favorite.fav.FavoriteActivity")
)
)
} catch (e: Exception) {
Toast.makeText(
context,
"Fitur ini belum ada, harap menunggu",
Toast.LENGTH_SHORT
).show()
}
}) {
Icon(imageVector = Icons.Default.Favorite, contentDescription = "favorite")
}
}
) {
LazyColumn(modifier = Modifier.fillMaxSize()) {
res.data?.let {
items(it) {
PostItem(it, onClick = {
navController.currentBackStackEntry?.savedStateHandle?.set(
key = "blog",
value = it
)
navController.navigate(Screen.Detail.route)
})
}
}
}
}
}
@Composable
fun PostItem(it: Blog, onClick: () -> Unit) {
Column(
modifier = Modifier
.fillMaxWidth()
.clickable {
onClick()
}
) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(8.dp), verticalAlignment = Alignment.CenterVertically
) {
CircularImage(50.0, 50.0, 25.0, it.owner.picture)
Spacer(modifier = Modifier.width(6.dp))
Text(text = "${it.owner.firstName} ${it.owner.lastName}")
}
Image(
modifier = Modifier
.fillMaxWidth()
.height(300.dp),
painter = rememberAsyncImagePainter(model = it.image), contentDescription = null,
contentScale = ContentScale.Crop
)
Text(
text = it.text,
modifier = Modifier.padding(12.dp),
style = TextStyle(color = Color.Gray, fontSize = 20.sp)
)
Divider()
}
}
@Composable
fun CircularImage(width: Double, height: Double, radius: Double, imageUrl: String) {
Card(
modifier = Modifier
.width(width = width.dp)
.height(height = height.dp), shape = RoundedCornerShape(radius.dp)
) {
Image(
painter = rememberAsyncImagePainter(model = imageUrl), contentDescription = null,
contentScale = ContentScale.Crop
)
}
}
| JetBlogCleanArchitecture/app/src/main/java/com/example/jetblogca/screen/home/HomeScreen.kt | 440186590 |
package com.example.jetblogca.screen.detail
import androidx.lifecycle.ViewModel
import com.example.core.domain.model.Blog
import com.example.core.domain.usecases.BlogUseCase
import dagger.hilt.android.lifecycle.HiltViewModel
import javax.inject.Inject
@HiltViewModel
class DetailViewModel @Inject constructor(private val blogUseCase: BlogUseCase) : ViewModel() {
fun setFavoriteBlog(blog: Blog, newStatus: Boolean) {
blogUseCase.setFavorite(blog, newStatus)
}
} | JetBlogCleanArchitecture/app/src/main/java/com/example/jetblogca/screen/detail/DetailViewModel.kt | 2245734239 |
package com.example.jetblogca.screen.detail
import android.util.Log
import androidx.compose.foundation.BorderStroke
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.foundation.layout.FlowRow
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.wrapContentHeight
import androidx.compose.foundation.layout.wrapContentWidth
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Favorite
import androidx.compose.material.icons.filled.FavoriteBorder
import androidx.compose.material3.Card
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.navigation.NavHostController
import coil.compose.rememberAsyncImagePainter
import com.example.core.domain.model.Blog
import com.example.jetblogca.screen.home.CircularImage
@OptIn(ExperimentalLayoutApi::class)
@Composable
fun DetailScreen(
blog: Blog? = null,
navController: NavHostController,
detailViewModel: DetailViewModel = hiltViewModel()
) {
var favoriteState by remember { mutableStateOf(blog?.isFavorite) }
Log.d("123r4", "DetailScreen: $favoriteState")
if (blog != null) {
Column(
modifier = Modifier
.fillMaxSize()
.padding(16.dp)
) {
Row(modifier = Modifier.fillMaxWidth()) {
CircularImage(50.0, 50.0, 25.0, blog.owner.picture)
Spacer(modifier = Modifier.height(16.dp))
Text(
text = "${blog.owner.firstName} ${blog.owner.lastName}",
style = TextStyle(
fontWeight = FontWeight.Bold,
fontSize = 24.sp,
color = Color.Black
)
)
IconButton(onClick = {
favoriteState = !favoriteState!!
Log.d("222TAG", "DetailScreen: $favoriteState")
detailViewModel.setFavoriteBlog(blog, favoriteState!!)
}) {
Icon(
imageVector = if (favoriteState!!) {
Icons.Default.Favorite
} else {
Icons.Default.FavoriteBorder
},
contentDescription = "favorite"
)
}
}
Spacer(modifier = Modifier.height(8.dp))
Image(
modifier = Modifier
.fillMaxWidth()
.height(300.dp),
painter = rememberAsyncImagePainter(model = blog.image),
contentDescription = null,
contentScale = ContentScale.Crop
)
Spacer(modifier = Modifier.height(16.dp))
Text(
text = blog.text,
style = TextStyle(
fontSize = 18.sp,
color = Color.Black
)
)
FlowRow {
blog.tags.forEach {
TagItem(it = it)
}
}
}
}
}
@Composable
fun TagItem(it: String) {
Card(
modifier = Modifier
.wrapContentWidth()
.wrapContentHeight()
.padding(8.dp), shape = RoundedCornerShape(
40.dp
),
border = BorderStroke(0.5.dp, color = Color.Gray)
) {
Text(text = it, style = TextStyle(color = Color.Black), modifier = Modifier.padding(12.dp))
}
}
| JetBlogCleanArchitecture/app/src/main/java/com/example/jetblogca/screen/detail/DetailScreen.kt | 2174471610 |
package com.example.favorite
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.favorite", appContext.packageName)
}
} | JetBlogCleanArchitecture/favorite/src/androidTest/java/com/example/favorite/ExampleInstrumentedTest.kt | 3624269527 |
package com.example.favorite
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)
}
} | JetBlogCleanArchitecture/favorite/src/test/java/com/example/favorite/ExampleUnitTest.kt | 509106448 |
package com.example.favorite.di
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import com.example.core.domain.usecases.BlogUseCase
import com.example.favorite.screen.FavoriteViewModel
import javax.inject.Inject
class ViewModelFactory @Inject constructor(private val blogUseCase: BlogUseCase) :
ViewModelProvider.NewInstanceFactory() {
@Suppress("UNCHECKED_CAST")
override fun <T : ViewModel> create(modelClass: Class<T>): T =
when {
modelClass.isAssignableFrom(FavoriteViewModel::class.java) -> {
FavoriteViewModel(blogUseCase) as T
}
else -> throw Throwable("Unknown ViewModel class: " + modelClass.name)
}
} | JetBlogCleanArchitecture/favorite/src/main/java/com/example/favorite/di/ViewModelFactory.kt | 1358166424 |
package com.example.favorite.di
import android.content.Context
import com.example.favorite.fav.FavoriteActivity
import com.example.jetblogca.di.FavoriteModuleDependencies
import dagger.BindsInstance
import dagger.Component
@Component(dependencies = [FavoriteModuleDependencies::class])
interface FavoriteModule {
fun inject(activity: FavoriteActivity)
// fun inject(fragment: FavoriteFragment)
@Component.Builder
interface Builder {
fun context(@BindsInstance context: Context): Builder
fun appDependencies(FavoriteModuleDependencies: FavoriteModuleDependencies): Builder
fun build(): FavoriteModule
}
} | JetBlogCleanArchitecture/favorite/src/main/java/com/example/favorite/di/FavoriteModule.kt | 3327120596 |
package com.example.favorite.fav
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.viewModels
import androidx.compose.ui.platform.LocalContext
import com.example.favorite.di.DaggerFavoriteModule
import com.example.favorite.di.ViewModelFactory
import com.example.favorite.screen.FavoriteScreen
import com.example.favorite.screen.FavoriteViewModel
import com.example.jetblogca.di.FavoriteModuleDependencies
import com.example.jetblogca.ui.theme.JetBlogCATheme
import dagger.hilt.android.EntryPointAccessors
import javax.inject.Inject
class FavoriteActivity : ComponentActivity() {
@Inject
lateinit var factory: ViewModelFactory
private val viewModel: FavoriteViewModel by viewModels {
factory
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
DaggerFavoriteModule.builder()
.context(this)
.appDependencies(
EntryPointAccessors.fromApplication(
applicationContext,
FavoriteModuleDependencies::class.java
)
)
.build()
.inject(this)
DaggerFavoriteModule.builder()
setContent {
JetBlogCATheme {
val context = LocalContext.current
FavoriteScreen(viewModel = viewModel)
}
}
}
} | JetBlogCleanArchitecture/favorite/src/main/java/com/example/favorite/fav/FavoriteActivity.kt | 1374667952 |
package com.example.favorite.screen
import androidx.lifecycle.ViewModel
import androidx.lifecycle.asLiveData
import com.example.core.domain.usecases.BlogUseCase
import javax.inject.Inject
class FavoriteViewModel @Inject constructor(blogUseCase: BlogUseCase) : ViewModel() {
val moviesFavorite = blogUseCase.getFavorite().asLiveData()
} | JetBlogCleanArchitecture/favorite/src/main/java/com/example/favorite/screen/FavoriteViewModel.kt | 2066409838 |
package com.example.favorite.screen
import android.annotation.SuppressLint
import android.content.Intent
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.livedata.observeAsState
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalContext
import com.example.jetblogca.MainActivity
import com.example.jetblogca.screen.home.PostItem
@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun FavoriteScreen(
viewModel: FavoriteViewModel,
) {
val blogFavorite by viewModel.moviesFavorite.observeAsState(initial = emptyList())
val context = LocalContext.current
Scaffold(
topBar = {
TopAppBar(
title = { Text(text = "Favorite Blog") }
)
}
) {
if (blogFavorite.isNotEmpty()) {
LazyColumn(modifier = Modifier.fillMaxSize().padding(it)) {
blogFavorite.let {
items(it) {
PostItem(it, onClick = {
context.startActivity(
Intent(
context,
MainActivity::class.java
).putExtra("blogf", it)
.putExtra("fromfav", true)
)
}
)
}
}
}
} else {
Box(
contentAlignment = Alignment.Center,
modifier = Modifier.fillMaxSize().padding(it)
) {
Text(text = "No favorite movies found")
}
}
}
}
| JetBlogCleanArchitecture/favorite/src/main/java/com/example/favorite/screen/FavoriteScreen.kt | 3805624731 |
package com.example.mobile_dev_endproject_jc_jvl
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.mobile_dev_endproject_jc_jvl", appContext.packageName)
}
} | Mobile_Development_EndProject_JC_JvL/app/src/androidTest/java/com/example/mobile_dev_endproject_jc_jvl/ExampleInstrumentedTest.kt | 1612852204 |
package com.example.mobile_dev_endproject_jc_jvl
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)
}
} | Mobile_Development_EndProject_JC_JvL/app/src/test/java/com/example/mobile_dev_endproject_jc_jvl/ExampleUnitTest.kt | 1883023079 |
package com.example.mobile_dev_endproject_jc_jvl.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) | Mobile_Development_EndProject_JC_JvL/app/src/main/java/com/example/mobile_dev_endproject_jc_jvl/ui/theme/Color.kt | 2579888121 |
package com.example.mobile_dev_endproject_jc_jvl.ui.theme
import android.app.Activity
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.SideEffect
import androidx.compose.ui.graphics.toArgb
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalView
import androidx.core.view.WindowCompat
private val DarkColorScheme = darkColorScheme(
primary = Purple80,
secondary = PurpleGrey80,
tertiary = Pink80
)
private val LightColorScheme = lightColorScheme(
primary = Purple40,
secondary = PurpleGrey40,
tertiary = Pink40
/* Other default colors to override
background = Color(0xFFFFFBFE),
surface = Color(0xFFFFFBFE),
onPrimary = Color.White,
onSecondary = Color.White,
onTertiary = Color.White,
onBackground = Color(0xFF1C1B1F),
onSurface = Color(0xFF1C1B1F),
*/
)
@Composable
fun Mobile_Dev_EndProject_JC_JvLTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
// Dynamic color is available on Android 12+
dynamicColor: Boolean = true,
content: @Composable () -> Unit
) {
val colorScheme = when {
dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
val context = LocalContext.current
if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
}
darkTheme -> DarkColorScheme
else -> LightColorScheme
}
val view = LocalView.current
if (!view.isInEditMode) {
SideEffect {
val window = (view.context as Activity).window
window.statusBarColor = colorScheme.primary.toArgb()
WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = darkTheme
}
}
MaterialTheme(
colorScheme = colorScheme,
typography = Typography,
content = content
)
} | Mobile_Development_EndProject_JC_JvL/app/src/main/java/com/example/mobile_dev_endproject_jc_jvl/ui/theme/Theme.kt | 2230991709 |
package com.example.mobile_dev_endproject_jc_jvl.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
)
*/
) | Mobile_Development_EndProject_JC_JvL/app/src/main/java/com/example/mobile_dev_endproject_jc_jvl/ui/theme/Type.kt | 1588491100 |
package com.example.mobile_dev_endproject_jc_jvl.dataClassesDirectory
data class MatchReservation(
val clubName: String = "",
val clubEstablishmentName: String = "",
val courtName: String = "",
val matchId: String = "",
val clubEstablishmentAddress: String = "",
val timeslot: String = "",
val dateReservation: String = "",
val typeOfMatch: String = "",
val gendersAllowed: String = "",
val participators: Map<String, Any> = emptyMap()
)
| Mobile_Development_EndProject_JC_JvL/app/src/main/java/com/example/mobile_dev_endproject_jc_jvl/dataClassesDirectory/MatchReservation.kt | 3080609153 |
package com.example.mobile_dev_endproject_jc_jvl.dataClassesDirectory
data class ClubEstablishment(
val clubName: String,
val clubEstablishmentName: String,
val clubEstablishmentAddress: String,
)
| Mobile_Development_EndProject_JC_JvL/app/src/main/java/com/example/mobile_dev_endproject_jc_jvl/dataClassesDirectory/ClubEstablishment.kt | 2526626354 |
package com.example.mobile_dev_endproject_jc_jvl.dataClassesDirectory
data class CourtReservation(
val clubEstablishmentName: String,
val clubEstablishmentAddress: String,
val courtName: String,
val dateReservation: String,
val timeslot: String
)
| Mobile_Development_EndProject_JC_JvL/app/src/main/java/com/example/mobile_dev_endproject_jc_jvl/dataClassesDirectory/CourtReservation.kt | 200284672 |
package com.example.mobile_dev_endproject_jc_jvl.dataClassesDirectory
data class Match(
val clubName: String = "",
val clubEstablishmentName: String = "",
val courtName: String = "",
val matchId: String = "",
val clubEstablishmentAddress: String = "",
val timeslot: String = "",
val dateReservation: String = "",
val typeOfMatch: String = "",
val gendersAllowed: String = "",
val participators: Map<String, String> = emptyMap()
)
| Mobile_Development_EndProject_JC_JvL/app/src/main/java/com/example/mobile_dev_endproject_jc_jvl/dataClassesDirectory/Match.kt | 2396903138 |
package com.example.mobile_dev_endproject_jc_jvl.dataClassesDirectory
data class PlayerReservation(
val clubName: String = "",
val clubEstablishmentName: String = "",
val courtName: String = "",
val matchId: String = "",
val clubEstablishmentAddress: String = "",
val timeslot: String = "",
val dateReservation: String = ""
)
| Mobile_Development_EndProject_JC_JvL/app/src/main/java/com/example/mobile_dev_endproject_jc_jvl/dataClassesDirectory/PlayerReservation.kt | 554268340 |
package com.example.mobile_dev_endproject_jc_jvl.dataClassesDirectory
import android.os.Parcel
import android.os.Parcelable
import com.google.firebase.firestore.GeoPoint
data class ClubDetails(
val clubName: String,
val clubAddress: String,
val clubLocation: GeoPoint
) : Parcelable {
constructor(parcel: Parcel) : this(
parcel.readString()!!,
parcel.readString()!!,
GeoPoint(parcel.readDouble(), parcel.readDouble())
)
override fun writeToParcel(parcel: Parcel, flags: Int) {
parcel.writeString(clubName)
parcel.writeString(clubAddress)
parcel.writeDouble(clubLocation.latitude)
parcel.writeDouble(clubLocation.longitude)
}
override fun describeContents(): Int {
return 0
}
companion object CREATOR : Parcelable.Creator<ClubDetails> {
override fun createFromParcel(parcel: Parcel): ClubDetails {
return ClubDetails(parcel)
}
override fun newArray(size: Int): Array<ClubDetails?> {
return arrayOfNulls(size)
}
}
}
| Mobile_Development_EndProject_JC_JvL/app/src/main/java/com/example/mobile_dev_endproject_jc_jvl/dataClassesDirectory/ClubDetails.kt | 1534659175 |
package com.example.mobile_dev_endproject_jc_jvl.dataClassesDirectory
data class Preferences(
val preferredPlayLocation: String = "",
val preferredTypeMatch: String = "",
val preferredHandPlay: String = "",
val preferredTimeToPlay: String = "",
val preferredCourtPosition: String = "",
val preferredGenderToPlayAgainst: String = ""
)
| Mobile_Development_EndProject_JC_JvL/app/src/main/java/com/example/mobile_dev_endproject_jc_jvl/dataClassesDirectory/Preferences.kt | 845601323 |
package com.example.mobile_dev_endproject_jc_jvl.adaptersDirectory
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import androidx.recyclerview.widget.RecyclerView
import com.example.mobile_dev_endproject_jc_jvl.dataClassesDirectory.ClubEstablishment
import com.example.mobile_dev_endproject_jc_jvl.R
class ClubEstablishmentAdapter(
private val establishments: List<ClubEstablishment>,
private val onItemClickListener: (ClubEstablishment) -> Unit
) : RecyclerView.Adapter<ClubEstablishmentAdapter.ViewHolder>() {
inner class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
val nameTextView: TextView = itemView.findViewById(R.id.textViewClubEstablishmentName)
val addressTextView: TextView = itemView.findViewById(R.id.textViewClubEstablishmentAddress)
init {
itemView.setOnClickListener {
val position = adapterPosition
if (position != RecyclerView.NO_POSITION) {
onItemClickListener(establishments[position])
}
}
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
val view = LayoutInflater.from(parent.context)
.inflate(R.layout.item_club_establishment, parent, false)
return ViewHolder(view)
}
override fun onBindViewHolder(holder: ViewHolder, position: Int) {
val establishment = establishments[position]
holder.nameTextView.text = establishment.clubEstablishmentName
holder.addressTextView.text = establishment.clubEstablishmentAddress
}
override fun getItemCount(): Int {
return establishments.size
}
} | Mobile_Development_EndProject_JC_JvL/app/src/main/java/com/example/mobile_dev_endproject_jc_jvl/adaptersDirectory/ClubEstablishmentAdapter.kt | 2565150760 |
package com.example.mobile_dev_endproject_jc_jvl.adaptersDirectory
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import androidx.recyclerview.widget.RecyclerView
import com.example.mobile_dev_endproject_jc_jvl.R
class CourtAdapter(private val onItemClick: (String) -> Unit) :
RecyclerView.Adapter<CourtAdapter.ViewHolder>() {
private val courtList: MutableList<String> = mutableListOf()
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
val view =
LayoutInflater.from(parent.context).inflate(R.layout.item_court, parent, false)
return ViewHolder(view)
}
override fun onBindViewHolder(holder: ViewHolder, position: Int) {
val courtName = courtList[position]
holder.bind(courtName)
holder.itemView.setOnClickListener { onItemClick(courtName) }
}
override fun getItemCount(): Int = courtList.size
fun addData(courtName: String) {
courtList.add(courtName)
notifyDataSetChanged()
}
fun clearData() {
courtList.clear()
notifyDataSetChanged()
}
class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
private val courtNameTextView: TextView = itemView.findViewById(R.id.courtNameTextView)
fun bind(courtName: String) {
courtNameTextView.text = courtName
}
}
}
| Mobile_Development_EndProject_JC_JvL/app/src/main/java/com/example/mobile_dev_endproject_jc_jvl/adaptersDirectory/CourtAdapter.kt | 4110165068 |
package com.example.mobile_dev_endproject_jc_jvl.adaptersDirectory
import android.annotation.SuppressLint
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import androidx.recyclerview.widget.RecyclerView
import com.example.mobile_dev_endproject_jc_jvl.R
import com.example.mobile_dev_endproject_jc_jvl.dataClassesDirectory.CourtReservation
class CourtReservationAdapter(private val courtReservations: List<CourtReservation>) :
RecyclerView.Adapter<CourtReservationAdapter.CourtReservationViewHolder>() {
class CourtReservationViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
val clubName: TextView = itemView.findViewById(R.id.clubName)
val establishmentName: TextView = itemView.findViewById(R.id.establishmentName)
val courtName: TextView = itemView.findViewById(R.id.courtName)
val dateReservation: TextView = itemView.findViewById(R.id.dateReservation)
val timeslot: TextView = itemView.findViewById(R.id.timeslot)
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): CourtReservationViewHolder {
val view = LayoutInflater.from(parent.context)
.inflate(R.layout.item_reservation, parent, false)
return CourtReservationViewHolder(view)
}
@SuppressLint("SetTextI18n")
override fun onBindViewHolder(holder: CourtReservationViewHolder, position: Int) {
val courtReservation = courtReservations[position]
holder.clubName.text = "Establishment: ${courtReservation.clubEstablishmentName}"
holder.establishmentName.text = "Address: ${courtReservation.clubEstablishmentAddress}"
holder.courtName.text = "Court: ${courtReservation.courtName}"
holder.dateReservation.text = "Date: ${courtReservation.dateReservation}"
holder.timeslot.text = "TimeSlot: ${courtReservation.timeslot}"
}
override fun getItemCount(): Int {
return courtReservations.size
}
}
| Mobile_Development_EndProject_JC_JvL/app/src/main/java/com/example/mobile_dev_endproject_jc_jvl/adaptersDirectory/CourtReservationAdapter.kt | 4126875113 |
package com.example.mobile_dev_endproject_jc_jvl.adaptersDirectory
import android.annotation.SuppressLint
import android.content.Intent
import android.view.Gravity
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.ImageView
import android.widget.LinearLayout
import android.widget.TextView
import androidx.recyclerview.widget.RecyclerView
import com.bumptech.glide.Glide
import com.example.mobile_dev_endproject_jc_jvl.R
import com.example.mobile_dev_endproject_jc_jvl.activitiesDirectory.AccountActivity
import com.example.mobile_dev_endproject_jc_jvl.activitiesDirectory.JoinMatchActivity
import com.example.mobile_dev_endproject_jc_jvl.dataClassesDirectory.Match
class MatchAdapter(private val matches: List<Match>) :
RecyclerView.Adapter<MatchAdapter.MatchViewHolder>() {
class MatchViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
val addressTextView: TextView = itemView.findViewById(R.id.textViewClubEstablishmentAddress)
val dateTimeTextView: TextView = itemView.findViewById(R.id.textViewDateTime)
val typeOfMatchAndGender: TextView = itemView.findViewById(R.id.typeOfMatchAndGender)
val imagesLayout: LinearLayout = itemView.findViewById(R.id.linearImages)
val usernamesLayout: LinearLayout = itemView.findViewById(R.id.linearUsernames)
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): MatchViewHolder {
val view = LayoutInflater.from(parent.context).inflate(R.layout.match_item, parent, false)
return MatchViewHolder(view)
}
@SuppressLint("ResourceAsColor")
override fun onBindViewHolder(holder: MatchViewHolder, position: Int) {
val match = matches[position]
holder.addressTextView.text = match.clubEstablishmentAddress
holder.dateTimeTextView.text =
"Date: ${match.dateReservation} TimeSlot: ${match.timeslot}"
holder.typeOfMatchAndGender.text =
"Type Match: ${match.typeOfMatch} Gender: ${match.gendersAllowed}"
// Clear existing views in layouts
holder.imagesLayout.removeAllViews()
holder.usernamesLayout.removeAllViews()
// Bind data to the images layout (LinearLayout)
val imageLinearLayout = LinearLayout(holder.itemView.context)
imageLinearLayout.layoutParams = LinearLayout.LayoutParams(
LinearLayout.LayoutParams.MATCH_PARENT,
LinearLayout.LayoutParams.WRAP_CONTENT
)
imageLinearLayout.orientation = LinearLayout.HORIZONTAL
imageLinearLayout.gravity = Gravity.CENTER
// Bind data to the usernames layout (LinearLayout)
val usernameLinearLayout = LinearLayout(holder.itemView.context)
usernameLinearLayout.layoutParams = LinearLayout.LayoutParams(
LinearLayout.LayoutParams.MATCH_PARENT,
LinearLayout.LayoutParams.WRAP_CONTENT
)
usernameLinearLayout.orientation = LinearLayout.HORIZONTAL
usernameLinearLayout.gravity = Gravity.CENTER
for (i in 1..4) {
val avatarKey = "UserAvatar_$i"
val usernameKey = "UserName_$i"
val userIdKey = "UserId_$i"
val avatarValue = match.participators[avatarKey]
val usernameValue = match.participators[usernameKey]
val userIdValue = match.participators[userIdKey]
val imageView = ImageView(holder.itemView.context)
val layoutParams = LinearLayout.LayoutParams(
0,
LinearLayout.LayoutParams.WRAP_CONTENT,
1f
)
// Check if avatar is "Default"
if (avatarValue != null && avatarValue == "Default") {
imageView.setImageResource(R.drawable.ic_joinmatch)
} else {
Glide.with(holder.itemView).load(avatarValue).into(imageView)
}
imageView.layoutParams = layoutParams
// Padding in pixels
val paddingPx = 16
imageView.setPadding(paddingPx, paddingPx, paddingPx, paddingPx)
imageView.setOnClickListener {
// Check if avatar is "Default"
if (avatarValue != null && avatarValue == "Default") {
// Launch JoinMatchActivity
val intent = Intent(holder.itemView.context, JoinMatchActivity::class.java)
intent.putExtra("dateReservation", match.dateReservation)
intent.putExtra("timeslot", match.timeslot)
intent.putExtra("PositionSquare", i.toString())
intent.putExtra("matchId", match.matchId)
intent.putExtra("typeOfMatch", match.typeOfMatch)
intent.putExtra("gendersAllowed", match.gendersAllowed)
val sentThroughClubName = sanitizeForFirestore(match.clubName)
val sentThroughClubEstablishmentName =
sanitizeForFirestore(match.clubEstablishmentName)
val sentThroughCourtName = sanitizeForFirestore(match.courtName)
intent.putExtra("sentThroughClubName", sentThroughClubName)
intent.putExtra(
"sentThroughClubEstablishmentName",
sentThroughClubEstablishmentName
)
intent.putExtra("sentThroughCourtName", sentThroughCourtName)
// Pass any necessary data to JoinMatchActivity using intent.putExtra if needed
holder.itemView.context.startActivity(intent)
} else {
// Launch AccountActivity
val intent = Intent(holder.itemView.context, AccountActivity::class.java)
intent.putExtra("sentThroughUserId", userIdValue)
// Pass any necessary data to AccountActivity using intent.putExtra if needed
holder.itemView.context.startActivity(intent)
}
}
imageLinearLayout.addView(imageView)
// Check if username is "Default"
if (usernameValue != null && usernameValue == "Default") {
// Add an empty TextView for "Default" username
val emptyUsernameTextView = TextView(holder.itemView.context)
emptyUsernameTextView.text = "Available"
emptyUsernameTextView.layoutParams = layoutParams
val usernamePaddingPx = 16
emptyUsernameTextView.setPadding(
usernamePaddingPx * 4,
0,
usernamePaddingPx,
usernamePaddingPx
)
usernameLinearLayout.addView(emptyUsernameTextView)
} else {
// Add the username TextView
val usernameTextView = TextView(holder.itemView.context)
usernameTextView.text = usernameValue
usernameTextView.layoutParams = layoutParams
val usernamePaddingPx = 16
usernameTextView.setPadding(
usernamePaddingPx * 4,
0,
usernamePaddingPx,
usernamePaddingPx
)
usernameLinearLayout.addView(usernameTextView)
}
}
holder.imagesLayout.addView(imageLinearLayout)
holder.usernamesLayout.addView(usernameLinearLayout)
}
override fun getItemCount(): Int {
return matches.size
}
private fun sanitizeForFirestore(username: String): String {
// Implement your logic to sanitize the username (remove spaces or special characters)
// For example, you can replace spaces with underscores
return username.replace("\\s+".toRegex(), "")
}
}
| Mobile_Development_EndProject_JC_JvL/app/src/main/java/com/example/mobile_dev_endproject_jc_jvl/adaptersDirectory/MatchAdapter.kt | 2302277557 |
package com.example.mobile_dev_endproject_jc_jvl.mapFunctionalitiesDirectory
import org.osmdroid.api.IGeoPoint
import org.osmdroid.views.overlay.OverlayItem
class CustomOverlayItem(title: String?, snippet: String?, point: IGeoPoint?) :
OverlayItem(title, snippet, point) {
var extraData: HashMap<String, String?> = HashMap()
} | Mobile_Development_EndProject_JC_JvL/app/src/main/java/com/example/mobile_dev_endproject_jc_jvl/mapFunctionalitiesDirectory/CustomOverlayItem.kt | 1641810435 |
package com.example.mobile_dev_endproject_jc_jvl.activitiesDirectory
import android.content.Intent
import android.os.Bundle
import android.os.Handler
import android.os.Parcelable
import android.util.Log
import android.view.MotionEvent
import androidx.appcompat.app.AppCompatActivity
import com.example.mobile_dev_endproject_jc_jvl.mapFunctionalitiesDirectory.CustomOverlayItem
import com.example.mobile_dev_endproject_jc_jvl.R
import com.google.android.material.bottomnavigation.BottomNavigationView
import com.google.firebase.firestore.FirebaseFirestore
import org.osmdroid.api.IGeoPoint
import org.osmdroid.config.Configuration
import org.osmdroid.events.MapEventsReceiver
import org.osmdroid.tileprovider.tilesource.TileSourceFactory
import org.osmdroid.util.GeoPoint
import org.osmdroid.views.CustomZoomButtonsController
import org.osmdroid.views.MapView
import org.osmdroid.views.overlay.ItemizedIconOverlay
import org.osmdroid.views.overlay.MapEventsOverlay
import org.osmdroid.views.overlay.OverlayItem
import org.osmdroid.views.overlay.mylocation.GpsMyLocationProvider
import org.osmdroid.views.overlay.mylocation.MyLocationNewOverlay
class MapActivity : AppCompatActivity() {
private lateinit var mapView: MapView
private val firestore = FirebaseFirestore.getInstance()
private val ZOOM_REPEAT_INTERVAL = 50L
private var isZoomingOut = false
private var zoomOutHandler: Handler? = null
private val zoomOutRunnable: Runnable = object : Runnable {
override fun run() {
if (isZoomingOut) {
mapView.controller.zoomOut()
zoomOutHandler?.postDelayed(this, ZOOM_REPEAT_INTERVAL)
}
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// Initialize osmdroid
Configuration.getInstance().load(applicationContext, getPreferences(MODE_PRIVATE))
setContentView(R.layout.map_screen)
val bottomNavigationView = findViewById<BottomNavigationView>(R.id.bottomNavigationView)
bottomNavigationView.labelVisibilityMode = BottomNavigationView.LABEL_VISIBILITY_LABELED
bottomNavigationView.menu.findItem(R.id.navigation_home).isChecked = true
bottomNavigationView.setOnItemSelectedListener { item ->
when (item.itemId) {
R.id.navigation_home -> {
launchActivity(HomeActivity::class.java)
true
}
R.id.navigation_establishment -> {
launchActivity(EstablishmentsActivity::class.java)
true
}
R.id.navigation_match -> {
launchActivity(MatchActivity::class.java)
true
}
R.id.navigation_account -> {
item.isChecked = true
launchActivity(AccountActivity::class.java)
true
}
else -> false
}
}
mapView = findViewById(R.id.mapView)
mapView.setTileSource(TileSourceFactory.MAPNIK)
mapView.zoomController.setVisibility(CustomZoomButtonsController.Visibility.SHOW_AND_FADEOUT)
mapView.setMultiTouchControls(true)
mapView.controller.setZoom(15.0)
fetchClubsFromFirebase()
val myLocationOverlay =
MyLocationNewOverlay(GpsMyLocationProvider(applicationContext), mapView)
myLocationOverlay.enableMyLocation()
mapView.overlays.add(myLocationOverlay)
val mapCoordinates = intent.getParcelableExtra<GeoPoint>("TheMapCoordinates")
if (mapCoordinates != null) {
// If "TheMapCoordinates" is present, set the map location to the geopoint
setMapLocation(mapCoordinates)
} else {
// Default location: Antwerp
mapView.controller.setCenter(createGeoPoint(51.2194, 4.4025))
}
val mapEventsOverlay = MapEventsOverlay(object : MapEventsReceiver {
override fun singleTapConfirmedHelper(p: GeoPoint): Boolean {
val threshold = 225
val itemList = getOverlayItemsList()
for (marker in itemList) {
val distance = p.distanceToAsDouble(marker.point)
if (distance < threshold) {
// If the tapped point is close to a marker, start HomeActivity
launchEstablishmentDetailsActivity(marker)
return true
}
}
// When nothing is pressed
return false
}
override fun longPressHelper(p: GeoPoint): Boolean {
if (!isZoomingOut) {
isZoomingOut = true
zoomOutHandler = Handler(mainLooper)
zoomOutHandler?.postDelayed(zoomOutRunnable, ZOOM_REPEAT_INTERVAL)
}
return true
}
})
mapView.overlays.add(mapEventsOverlay)
}
override fun onTouchEvent(event: MotionEvent): Boolean {
if (event.action == MotionEvent.ACTION_UP || event.action == MotionEvent.ACTION_CANCEL) {
// Long press ended
stopZoomingOut()
}
return super.onTouchEvent(event)
}
private fun stopZoomingOut() {
isZoomingOut = false
zoomOutHandler?.removeCallbacksAndMessages(null)
zoomOutHandler = null
}
private fun createGeoPoint(latitude: Double, longitude: Double): IGeoPoint {
return GeoPoint(latitude, longitude)
}
private fun fetchClubsFromFirebase() {
firestore.collection("TheClubDetails")
.get()
.addOnSuccessListener { result ->
for (document in result) {
val clubName = document.id
firestore.collection("TheClubDetails").document(clubName)
.collection("TheClubEstablishments")
.get()
.addOnSuccessListener { establishmentResult ->
for (establishmentDocument in establishmentResult) {
val clubEstablishmentName =
establishmentDocument.getString("ClubEstablishmentName")
val clubEstablishmentAddress =
establishmentDocument.getString("ClubEstablishmentAddress")
val clubEstablishmentLocation =
establishmentDocument.getGeoPoint("ClubEstablishmentLocation")
if (clubEstablishmentName != null && clubEstablishmentLocation != null) {
val clubMarker = CustomOverlayItem(
clubEstablishmentName,
"Club Location",
createGeoPoint(
clubEstablishmentLocation.latitude,
clubEstablishmentLocation.longitude
)
)
// Attach extra values
clubMarker.extraData = createMarkerExtrasData(
clubName,
clubEstablishmentAddress,
clubEstablishmentName
)
val clubMarkerOverlay = ItemizedIconOverlay<OverlayItem>(
applicationContext,
listOf(clubMarker),
null
)
mapView.overlays.add(clubMarkerOverlay)
}
}
// Force redraw of the map
mapView.invalidate()
}
.addOnFailureListener { exception ->
Log.e(
"MapActivity",
"Error fetching establishments from Firebase: $exception"
)
}
}
}
.addOnFailureListener { exception ->
Log.e("MapActivity", "Error fetching clubs from Firebase: $exception")
}
}
private fun launchEstablishmentDetailsActivity(marker: OverlayItem) {
val intent = Intent(this@MapActivity, EstablishmentDetailsActivity::class.java)
if (marker is CustomOverlayItem) {
val extrasData = marker.extraData
intent.putExtra("ClubName", extrasData["ClubName"])
intent.putExtra("ClubEstablishmentAddress", extrasData["ClubEstablishmentAddress"])
intent.putExtra("EstablishmentName", extrasData["EstablishmentName"])
}
intent.putExtra("TheMapCoordinates", marker.point as Parcelable)
startActivity(intent)
}
private fun getOverlayItemsList(): List<OverlayItem> {
val overlays = mapView.overlays
val itemList = mutableListOf<OverlayItem>()
for (overlay in overlays) {
if (overlay is ItemizedIconOverlay<*> && overlay.size() > 0) {
val item = overlay.getItem(0) as? OverlayItem
if (item != null) {
itemList.add(item)
}
}
}
return itemList
}
// Forward lifecycle events to the MapView
override fun onResume() {
super.onResume()
mapView.onResume()
}
override fun onPause() {
super.onPause()
mapView.onPause()
}
override fun onDestroy() {
super.onDestroy()
mapView.onDetach()
}
private fun launchActivity(cls: Class<*>) {
val intent = Intent(this, cls)
startActivity(intent)
}
private fun setMapLocation(geopoint: GeoPoint) {
mapView.controller.setCenter(geopoint)
}
private fun createMarkerExtrasData(
clubName: String,
establishmentAddress: String?,
establishmentName: String?
): HashMap<String, String?> {
val extrasData = HashMap<String, String?>()
extrasData["ClubName"] = clubName
extrasData["ClubEstablishmentAddress"] = establishmentAddress
extrasData["EstablishmentName"] = establishmentName
return extrasData
}
}
| Mobile_Development_EndProject_JC_JvL/app/src/main/java/com/example/mobile_dev_endproject_jc_jvl/activitiesDirectory/MapActivity.kt | 3134730418 |
package com.example.mobile_dev_endproject_jc_jvl.activitiesDirectory
import android.content.Intent
import android.os.Bundle
import android.widget.Button
import android.widget.EditText
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import com.example.mobile_dev_endproject_jc_jvl.R
import com.google.android.material.bottomnavigation.BottomNavigationView
import com.google.firebase.auth.EmailAuthProvider
import com.google.firebase.auth.FirebaseAuth
import com.google.firebase.auth.FirebaseUser
class ChangePasswordActivity : AppCompatActivity() {
private lateinit var etCurrentPassword: EditText
private lateinit var etNewPassword: EditText
private lateinit var etConfirmNewPassword: EditText
private lateinit var btnConfirm: Button
private lateinit var btnReturn: Button
private lateinit var auth: FirebaseAuth
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.change_password_screen)
val bottomNavigationView = findViewById<BottomNavigationView>(R.id.bottomNavigationView)
// Right Icon active
bottomNavigationView.menu.findItem(R.id.navigation_account).isChecked = true
bottomNavigationView.setOnItemSelectedListener { item ->
when (item.itemId) {
R.id.navigation_home -> {
launchActivity(HomeActivity::class.java)
true
}
R.id.navigation_establishment -> {
launchActivity(EstablishmentsActivity::class.java)
true
}
R.id.navigation_match -> {
launchActivity(MatchActivity::class.java)
true
}
R.id.navigation_account -> {
item.isChecked = true
launchActivity(AccountActivity::class.java)
true
}
else -> false
}
}
etCurrentPassword = findViewById(R.id.etCurrentPassword)
etNewPassword = findViewById(R.id.etNewPassword)
etConfirmNewPassword = findViewById(R.id.etConfirmNewPassword)
btnConfirm = findViewById(R.id.btnConfirm)
btnReturn = findViewById(R.id.btnReturn)
auth = FirebaseAuth.getInstance()
btnConfirm.setOnClickListener {
changePassword()
}
btnReturn.setOnClickListener {
finish()
}
}
private fun changePassword() {
val user: FirebaseUser? = auth.currentUser
val currentPassword = etCurrentPassword.text.toString()
val newPassword = etNewPassword.text.toString()
val confirmNewPassword = etConfirmNewPassword.text.toString()
if (newPassword != confirmNewPassword) {
showToast("New passwords do not match.")
return
}
if (user != null && user.email != null) {
// Reauthenticate with the current email and password
val credential = EmailAuthProvider
.getCredential(user.email!!, currentPassword)
user.reauthenticate(credential)
.addOnCompleteListener { reauthTask ->
if (reauthTask.isSuccessful) {
// Password successfully reauthenticated, now change the password
user.updatePassword(newPassword)
.addOnCompleteListener { updateTask ->
if (updateTask.isSuccessful) {
showToast("Password changed successfully.")
finish()
} else {
showToast("Failed to change password. Please try again.")
}
}
} else {
showToast("Authentication failed. Please check your current password.")
}
}
}
}
private fun showToast(message: String) {
Toast.makeText(this, message, Toast.LENGTH_SHORT).show()
}
private fun launchActivity(cls: Class<*>) {
val intent = Intent(this, cls)
startActivity(intent)
}
} | Mobile_Development_EndProject_JC_JvL/app/src/main/java/com/example/mobile_dev_endproject_jc_jvl/activitiesDirectory/ChangePasswordActivity.kt | 3653406269 |
package com.example.mobile_dev_endproject_jc_jvl.activitiesDirectory
import android.content.Intent
import com.google.firebase.firestore.ktx.firestore
import com.google.firebase.ktx.Firebase
import android.os.Bundle
import android.view.View
import android.widget.Button
import android.widget.EditText
import android.widget.Spinner
import androidx.appcompat.app.AppCompatActivity
import com.example.mobile_dev_endproject_jc_jvl.R
import com.google.android.material.snackbar.Snackbar
import com.google.firebase.auth.FirebaseAuth
class RegisterActivity : AppCompatActivity() {
private lateinit var emailEditText: EditText
private lateinit var passwordEditText: EditText
private lateinit var usernameEditText: EditText
private lateinit var genderOfPlayerSpinner: Spinner
private lateinit var submitButton: Button
private lateinit var returnButton: Button
private lateinit var auth: FirebaseAuth
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.register_screen)
auth = FirebaseAuth.getInstance()
emailEditText = findViewById(R.id.emailRegisterEditText)
passwordEditText = findViewById(R.id.passwordRegisterEditText)
usernameEditText = findViewById(R.id.usernameEditText)
genderOfPlayerSpinner = findViewById(R.id.chooseGenderSpinner)
submitButton = findViewById(R.id.submitButton)
returnButton = findViewById(R.id.returnButton)
submitButton.setOnClickListener {
val email = emailEditText.text.toString().trim()
val password = passwordEditText.text.toString().trim()
val username = usernameEditText.text.toString().trim()
val gender = genderOfPlayerSpinner.selectedItem.toString()
if (email.isNotEmpty() && password.isNotEmpty() && username.isNotEmpty()) {
registerUser(email, password, gender)
} else {
// Check which fields are empty and display corresponding error messages
when {
email.isEmpty() -> {
emailEditText.error = "Email cannot be empty"
}
password.isEmpty() -> {
passwordEditText.error = "Password cannot be empty"
}
username.isEmpty() -> {
usernameEditText.error = "Username cannot be empty"
}
}
showSnackbar("Please fill in all fields.")
}
}
returnButton.setOnClickListener {
startActivity(Intent(this, LoginActivity::class.java))
}
}
private fun registerUser(email: String, password: String, gender: String) {
auth.createUserWithEmailAndPassword(email, password)
.addOnCompleteListener(this) { task ->
if (task.isSuccessful) {
val user = auth.currentUser
user?.let {
val userId = user.uid
val username = usernameEditText.text.toString().trim()
// Add user to "ThePlayers" collection
val player = hashMapOf(
"userId" to userId,
"email" to email,
"username" to usernameEditText.text.toString().trim(),
"gender" to gender
)
val db = Firebase.firestore
val sanitizedUsername = username.replace("[\\s,\\\\/]".toRegex(), "")
db.collection("ThePlayers")
.document(userId)
.set(player)
.addOnSuccessListener {
// After success create sub-collection "TheProfileDetails" and its document
val profileDetails = hashMapOf(
"Avatar" to "https://firebasestorage.googleapis.com/v0/b/mobile-development4.appspot.com/o/default_image.jpg?alt=media",
"Followers" to 0,
"Following" to 0,
"Level" to 1,
"Username" to usernameEditText.text.toString().trim(),
"Gender" to gender
)
db.collection("ThePlayers")
.document(userId)
.collection("TheProfileDetails")
.document(sanitizedUsername)
.set(profileDetails)
.addOnSuccessListener {
// After success create sub-collection "ThePreferencesPlayer" and its document
val preferencesPlayer = hashMapOf(
"preferredPlayLocation" to "Location Not Yet Stated",
"preferredTypeMatch" to "Not Yet Stated",
"preferredHandPlay" to "Not Yet Stated",
"preferredTimeToPlay" to "Not Yet Stated",
"preferredCourtPosition" to "Not Yet Stated",
"preferredGenderToPlayAgainst" to "Not Yet Stated"
)
db.collection("ThePlayers")
.document(userId)
.collection("ThePreferencesPlayer")
.document("Preferences")
.set(preferencesPlayer)
.addOnSuccessListener {
// Document creation successful
showSnackbar("Registration successful!")
startActivity(
Intent(
this,
LoginActivity::class.java
)
)
finish()
}
.addOnFailureListener { e ->
// Handle document creation failure
showSnackbar("Error creating preferences player: ${e.message}")
}
}
.addOnFailureListener { e ->
// Handle document creation failure
showSnackbar("Error creating profile details: ${e.message}")
}
}
.addOnFailureListener { e ->
// Handle player creation failure
showSnackbar("Error creating player: ${e.message}")
}
}
} else {
// If registration fails, display a message to the user.
// You can customize the error message based on the task.exception
// For example, task.exception?.message
// Handle registration errors
val errorMessage = task.exception?.message ?: "Registration failed"
showSnackbar(errorMessage)
}
}
}
private fun showSnackbar(message: String) {
// Assuming your root view is a CoordinatorLayout, replace it with the appropriate view type if needed
val rootView = findViewById<View>(android.R.id.content)
Snackbar.make(rootView, message, Snackbar.LENGTH_LONG).show()
}
}
| Mobile_Development_EndProject_JC_JvL/app/src/main/java/com/example/mobile_dev_endproject_jc_jvl/activitiesDirectory/RegisterActivity.kt | 1853313713 |
package com.example.mobile_dev_endproject_jc_jvl.activitiesDirectory
import android.content.Intent
import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import com.example.mobile_dev_endproject_jc_jvl.adaptersDirectory.ClubEstablishmentAdapter
import com.example.mobile_dev_endproject_jc_jvl.dataClassesDirectory.ClubEstablishment
import com.example.mobile_dev_endproject_jc_jvl.R
import com.google.android.material.bottomnavigation.BottomNavigationView
import com.google.android.material.tabs.TabLayout
import com.google.firebase.firestore.FirebaseFirestore
class EstablishmentsActivity : AppCompatActivity() {
private val db = FirebaseFirestore.getInstance()
private val clubEstablishments = mutableListOf<ClubEstablishment>()
private lateinit var adapter: ClubEstablishmentAdapter
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.establishments_screen)
val tabLayout: TabLayout = findViewById(R.id.tabLayout_Establishments)
// Add tabs with titles
val establishmentsTab = tabLayout.newTab().setText("Establishments")
val reservationsTab = tabLayout.newTab().setText("Your Courts Reservations")
tabLayout.addTab(establishmentsTab)
tabLayout.addTab(reservationsTab)
// Set up a tab selected listener
tabLayout.addOnTabSelectedListener(object : TabLayout.OnTabSelectedListener {
override fun onTabSelected(tab: TabLayout.Tab) {
when (tab.position) {
0 -> {
// Start EstablishmentsActivity
//launchActivity(ClubEstablishmentsActivity::class.java)
}
1 -> {
// Start YourCourtReservationsActivity
launchActivity(YourCourtReservationsActivity::class.java)
}
}
}
override fun onTabUnselected(tab: TabLayout.Tab) {
// Handle tab unselection if needed
}
override fun onTabReselected(tab: TabLayout.Tab) {
// Handle tab reselection if needed
}
})
// Select the tab you want (e.g., "Your Courts Reservations")
establishmentsTab.select()
val recyclerView: RecyclerView = findViewById(R.id.recyclerViewClubEstablishments)
recyclerView.layoutManager = LinearLayoutManager(this)
val bottomNavigationView = findViewById<BottomNavigationView>(R.id.bottomNavigationView)
// Right Icon active
bottomNavigationView.menu.findItem(R.id.navigation_establishment).isChecked = true
bottomNavigationView.setOnItemSelectedListener { item ->
when (item.itemId) {
R.id.navigation_home -> {
launchActivity(HomeActivity::class.java)
true
}
R.id.navigation_establishment -> {
launchActivity(EstablishmentsActivity::class.java)
true
}
R.id.navigation_match -> {
launchActivity(MatchActivity::class.java)
true
}
R.id.navigation_account -> {
item.isChecked = true
launchActivity(AccountActivity::class.java)
true
}
else -> false
}
}
// Initialize the adapter
adapter = ClubEstablishmentAdapter(clubEstablishments) { clubEstablishment ->
onClubEstablishmentClicked(clubEstablishment)
}
recyclerView.adapter = adapter
// Replace this with the actual path to your Firestore collection
val collectionPath = "TheClubDetails"
// Retrieve data from Firestore
db.collection(collectionPath)
.get()
.addOnSuccessListener { documents ->
for (document in documents) {
// Extract data and add to the list
val clubNameDocumentId = document.id
val establishmentsCollectionPath =
"$collectionPath/$clubNameDocumentId/TheClubEstablishments"
// Retrieve data from the sub-collection
db.collection(establishmentsCollectionPath)
.get()
.addOnSuccessListener { establishmentDocuments ->
for (establishmentDocument in establishmentDocuments) {
val establishmentName =
establishmentDocument.getString("ClubEstablishmentName") ?: ""
val establishmentAddress =
establishmentDocument.getString("ClubEstablishmentAddress")
?: ""
Log.d(
"Firestore",
"Fetched document - ClubName: $clubNameDocumentId, EstablishmentName: $establishmentName, EstablishmentAddress: $establishmentAddress"
)
val clubEstablishment = ClubEstablishment(
clubNameDocumentId,
establishmentName,
establishmentAddress
)
clubEstablishments.add(clubEstablishment)
// Add log statement to check which documents are being fetched
Log.d(
"Firestore",
"Fetched document - ClubName: $clubNameDocumentId, EstablishmentName: $establishmentName, EstablishmentAddress: $establishmentAddress"
)
}
// Notify the adapter that the data set has changed
adapter.notifyDataSetChanged()
}
.addOnFailureListener { exception ->
// Handle failures here
Log.e("Firestore", "Error fetching establishment documents", exception)
}
}
}
.addOnFailureListener { exception ->
// Handle failures here
Log.e("Firestore", "Error fetching documents", exception)
}
}
private fun onClubEstablishmentClicked(clubEstablishment: ClubEstablishment) {
val intent = Intent(this, EstablishmentDetailsActivity::class.java).apply {
putExtra("ClubName", clubEstablishment.clubName)
putExtra("ClubEstablishmentAddress", clubEstablishment.clubEstablishmentAddress)
putExtra("EstablishmentName", clubEstablishment.clubEstablishmentName)
}
startActivity(intent)
}
private fun launchActivity(cls: Class<*>) {
val intent = Intent(this, cls)
startActivity(intent)
}
} | Mobile_Development_EndProject_JC_JvL/app/src/main/java/com/example/mobile_dev_endproject_jc_jvl/activitiesDirectory/EstablishmentsActivity.kt | 2328582091 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.