content
stringlengths 0
13M
| path
stringlengths 4
263
| contentHash
stringlengths 1
10
|
|---|---|---|
package com.crud.usersweb.entity
import jakarta.persistence.Column
import jakarta.persistence.Convert
import jakarta.persistence.Entity
import jakarta.persistence.GeneratedValue
import jakarta.persistence.GenerationType
import jakarta.persistence.Id
import jakarta.persistence.Lob
import jakarta.persistence.Table
import java.time.LocalDateTime
import java.util.UUID
@Entity
@Table(name = "users")
data class User(
@Id
@GeneratedValue(strategy = GenerationType.UUID)
val id: UUID?,
@Column(name = "nick", length = 32)
val nick: String?,
@Column(name = "name", length = 255, unique = true, nullable = false)
val name: String,
@Column(name = "birth_date", nullable = false)
val birthDate: LocalDateTime,
@Convert(converter = StringListConverter::class)
@Lob
@Column(name = "stack")
val stack: List<String>?,
) | crud-users-kotlin/users-web/src/main/kotlin/com/crud/usersweb/entity/User.kt | 2956736016 |
package com.crud.usersweb
fun User.toUserResponse(): UserResponse {
return UserResponse(
id = id,
birthDate = birthDate,
nick = nick,
name = name,
stack = stack
)
} | crud-users-kotlin/users-web/src/main/kotlin/com/crud/usersweb/UserConverter.kt | 2120070833 |
package com.crud.usersweb.exceptions
class ResourceNotFoundException(
message: String,
) : Exception(message) {
} | crud-users-kotlin/users-web/src/main/kotlin/com/crud/usersweb/exceptions/ResourceNotFoundException.kt | 716765939 |
package com.crud.usersweb.controller
import jakarta.validation.Constraint
import jakarta.validation.ConstraintValidator
import jakarta.validation.ConstraintValidatorContext
import jakarta.validation.Payload
import kotlin.reflect.KClass
@Target(AnnotationTarget.FIELD)
@MustBeDocumented
@Constraint(validatedBy = [SizeElementsOfListValidator::class])
annotation class SizeElementsOfList(
val message: String = "Os elementos da lista devem estar entre 1 e {size}",
val groups: Array<KClass<*>> = [],
val payload: Array<KClass<out Payload>> = [],
val size: Int = 32
)
class SizeElementsOfListValidator : ConstraintValidator<SizeElementsOfList, List<String>> {
private var size: Int = 32
override fun initialize(constraintAnnotation: SizeElementsOfList?) {
if (constraintAnnotation != null) {
size = constraintAnnotation.size
}
}
override fun isValid(value: List<String>?, context: ConstraintValidatorContext?): Boolean =
value == null || value.all { it.isNotBlank() && it.length in 0..size }
} | crud-users-kotlin/users-web/src/main/kotlin/com/crud/usersweb/controller/CustomValidator.kt | 413302283 |
package com.crud.usersweb.controller
import com.crud.usersweb.entity.User
fun User.toUserResponse(): UserResponse {
return UserResponse(
id = id,
birthDate = birthDate,
nick = nick,
name = name,
stack = stack
)
} | crud-users-kotlin/users-web/src/main/kotlin/com/crud/usersweb/controller/UserConverter.kt | 746730276 |
package com.crud.usersweb.controller
import java.time.LocalDateTime
import java.util.UUID
data class UserResponse(
val id: UUID?,
val birthDate: LocalDateTime,
val nick: String?,
val name: String,
val stack: List<String>?,
) {
} | crud-users-kotlin/users-web/src/main/kotlin/com/crud/usersweb/controller/UserResponse.kt | 3772469241 |
package com.crud.usersweb.controller
import com.crud.usersweb.entity.User
import jakarta.validation.constraints.Size
import java.time.LocalDateTime
data class CreateUserRequest(
val birthDate: LocalDateTime,
@field:Size(min = 1, max = 32, message = "O campo apelido deve estar entre 1 e 32")
val nick: String?,
@field:Size(min = 1, max = 255, message = "O campo nome é obrigatório e deve estar entre 1 e 255")
val name: String,
@field:SizeElementsOfList
val stack: List<String>? = null,
) {
}
fun CreateUserRequest.toUser(): User {
return User(
id = null,
nick = nick,
name = name,
birthDate = birthDate,
stack = stack
)
}
data class UpdateUserRequest(
var birthDate: LocalDateTime,
@field:Size(min= 1, max = 32, message = "O campo apelido deve estar entre 1 e 32")
var nick: String?,
@field:Size(min = 1, max = 255, message = "O campo nome é obrigatório e deve estar entre 1 e 255")
var name: String,
@field:SizeElementsOfList
var stack: List<String>?,
) {} | crud-users-kotlin/users-web/src/main/kotlin/com/crud/usersweb/controller/UserRequest.kt | 1073127196 |
package com.crud.usersweb.controller
import com.crud.usersweb.exceptions.ResourceNotFoundException
import com.crud.usersweb.service.UserService
import jakarta.validation.Valid
import org.springframework.http.HttpHeaders
import org.springframework.http.HttpStatus
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.DeleteMapping
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PathVariable
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.PutMapping
import org.springframework.web.bind.annotation.RequestBody
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RestController
import java.net.URI
import java.util.UUID
@RestController
@RequestMapping("/users")
class UserController(
private val userService: UserService
) {
@GetMapping("/{id}")
fun getUser(@PathVariable("id") id: UUID): ResponseEntity<UserResponse> {
val user = userService.findById(id)
.orElseThrow { ResourceNotFoundException("User not found") }
return ResponseEntity.ok(user.toUserResponse())
}
@GetMapping
fun listUsers(): ResponseEntity<List<UserResponse>> {
val users = userService.findAll()
return ResponseEntity.ok(users.map { it.toUserResponse() })
}
@DeleteMapping("/{id}")
fun deleteUser(@PathVariable("id") id: UUID): ResponseEntity<Nothing> {
if (!userService.existsById(id)) {
return ResponseEntity.notFound().build()
}
userService.deleteById(id)
return ResponseEntity.noContent().build()
}
@PostMapping
fun createUser(@Valid @RequestBody createUserRequest: CreateUserRequest): ResponseEntity<UserResponse> {
val user = createUserRequest.toUser()
val userCreated = userService.save(user)
val httpHeaders = HttpHeaders()
httpHeaders.location = URI.create("/users/${userCreated.id}")
return ResponseEntity(userCreated.toUserResponse(), httpHeaders, HttpStatus.CREATED)
}
@PutMapping("/{id}")
fun updateUser(
@PathVariable("id") id: UUID,
@Valid @RequestBody updateUserRequest: UpdateUserRequest
): ResponseEntity<UserResponse> {
val userUpdated = userService.findById(id)
.orElseThrow { ResourceNotFoundException("User not found") }
.copy(
nick = updateUserRequest.nick,
name = updateUserRequest.name,
birthDate = updateUserRequest.birthDate,
stack = updateUserRequest.stack,
)
.run { userService.save(this) }
return ResponseEntity.ok(userUpdated.toUserResponse())
}
} | crud-users-kotlin/users-web/src/main/kotlin/com/crud/usersweb/controller/UserController.kt | 1637167849 |
package com.crud.usersweb.service
import com.crud.usersweb.entity.User
import com.crud.usersweb.repository.UserRepository
import org.springframework.stereotype.Service
import java.util.UUID
@Service
class UserService(
private val userRepository: UserRepository
) {
fun findById(id: UUID) = userRepository.findById(id)
fun findAll(): MutableIterable<User> = userRepository.findAll()
fun existsById(id: UUID): Boolean = userRepository.existsById(id)
fun deleteById(id: UUID) = userRepository.deleteById(id)
fun save(user: User): User = userRepository.save(user)
} | crud-users-kotlin/users-web/src/main/kotlin/com/crud/usersweb/service/UserService.kt | 4126146544 |
package com.crud.usersweb.handlers
import com.crud.usersweb.exceptions.ResourceNotFoundException
import jakarta.servlet.http.HttpServletRequest
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.MethodArgumentNotValidException
import org.springframework.web.bind.annotation.ControllerAdvice
import org.springframework.web.bind.annotation.ExceptionHandler
data class ErrorsResponse(
var errors: List<String>
)
@ControllerAdvice
class ExceptionHandler {
@ExceptionHandler(ResourceNotFoundException::class)
fun resourceNotFoundException(
req: HttpServletRequest,
exception: ResourceNotFoundException
): ResponseEntity<Nothing> {
return ResponseEntity.notFound().build()
}
@ExceptionHandler(MethodArgumentNotValidException::class)
fun methodArguentNotValidException(
req: HttpServletRequest,
exception: MethodArgumentNotValidException
): ResponseEntity<ErrorsResponse> {
val response = ErrorsResponse(mutableListOf())
response.errors = exception.bindingResult.allErrors.map { it.defaultMessage ?: "" }
return ResponseEntity.badRequest().body(response)
}
} | crud-users-kotlin/users-web/src/main/kotlin/com/crud/usersweb/handlers/ExceptionHandler.kt | 3744871913 |
package com.crud.usersweb
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
@SpringBootApplication
class CrudUsersKotlinApplication
fun main(args: Array<String>) {
runApplication<CrudUsersKotlinApplication>(*args)
}
| crud-users-kotlin/users-web/src/main/kotlin/com/crud/usersweb/UsersWebApplication.kt | 2756909540 |
package com.crud.userswebfluxcoroutine
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
@SpringBootTest
class UsersWebfluxCoroutineApplicationTests {
@Test
fun contextLoads() {
}
}
| crud-users-kotlin/users-webflux-coroutine/src/test/kotlin/com/crud/userswebfluxcoroutine/UsersWebfluxCoroutineApplicationTests.kt | 4151901039 |
package com.crud.userswebfluxcoroutine
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Nested
import org.junit.jupiter.api.Test
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ValueSource
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.jdbc.core.JdbcTemplate
import org.springframework.test.jdbc.JdbcTestUtils
import org.springframework.test.web.reactive.server.WebTestClient
import java.time.LocalDateTime
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class UserControllerTest : AbstractIntegrationTest() {
@Autowired
lateinit var webClient: WebTestClient
@AfterEach
fun setDown(@Autowired jdbcTemplate: JdbcTemplate) {
JdbcTestUtils.deleteFromTables(jdbcTemplate, "users")
}
@Nested
inner class GetUser {
@Test
fun `Get user by id`() {
val userRequest = CreateUserRequest(
name = "Name",
nick = "nick",
birthDate = LocalDateTime.of(2024, 1, 17, 1, 1),
stack = listOf("NodeJS")
)
val userCreated = webClient.post().uri("/users")
.bodyValue(userRequest)
.exchange()
.expectStatus().isCreated
.expectBody(UserResponse::class.java)
.returnResult()
.responseBody
if (userCreated != null) {
webClient.get().uri("/users/${userCreated.id}")
.exchange()
.expectStatus().isOk
.expectBody(UserResponse::class.java)
.isEqualTo(userCreated)
}
}
@Test
fun `Get user that not exists`() {
}
}
@Nested
inner class ListUser {
@Test
fun `List users when not have users`() {
}
@Test
fun `List users when have one user`() {
}
}
@Nested
inner class CreateUser {
@Test
fun `Create User`() {
}
@ParameterizedTest()
@ValueSource(
strings = [
"",
"abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc" +
"abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc" +
"abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc" +
"abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc"
]
)
fun `Not create user when name is invalid value`(name: String) {
}
@Test
fun `Not create user when have empty value on stack`() {
}
@Test
fun `Should create user when not have stack`() {
}
}
@Nested
inner class DeleteUser {
@Test
fun `Delete user by id`() {
}
@Test
fun `Delete user that not exists`() {
}
}
@Nested
inner class UpdateUser {
@Test
fun `Update User`() {
}
}
} | crud-users-kotlin/users-webflux-coroutine/src/test/kotlin/com/crud/userswebfluxcoroutine/UserControllerTest.kt | 3647774886 |
package com.crud.userswebfluxcoroutine
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.context.ApplicationContextInitializer
import org.springframework.context.ConfigurableApplicationContext
import org.springframework.test.context.ActiveProfiles
import org.springframework.test.context.ContextConfiguration
import org.testcontainers.containers.OracleContainer
import org.testcontainers.utility.DockerImageName
@SpringBootTest
@ActiveProfiles("test")
@ContextConfiguration(initializers = [AbstractIntegrationTest.Initializer::class])
abstract class AbstractIntegrationTest {
companion object {
private val oracleContainer = OracleContainer(
DockerImageName
.parse("container-registry.oracle.com/database/express:21.3.0-xe")
.asCompatibleSubstituteFor("gvenzl/oracle-xe")
).apply {
withEnv("ORACLE_PWD", "123456")
portBindings = listOf("1521:1521")
}
}
internal class Initializer : ApplicationContextInitializer<ConfigurableApplicationContext> {
override fun initialize(configurableApplicationContext: ConfigurableApplicationContext) {
oracleContainer.start()
}
}
}
| crud-users-kotlin/users-webflux-coroutine/src/test/kotlin/com/crud/userswebfluxcoroutine/AbstractIntegrationTest.kt | 658733340 |
package com.crud.userswebfluxcoroutine
import io.r2dbc.spi.ConnectionFactory
import io.r2dbc.spi.Row
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.core.convert.converter.Converter
import org.springframework.data.convert.ReadingConverter
import org.springframework.data.convert.WritingConverter
import org.springframework.data.r2dbc.convert.R2dbcCustomConversions
import org.springframework.data.r2dbc.dialect.DialectResolver
import java.nio.ByteBuffer
import java.util.UUID
@Configuration
class R2dbcConfiguration {
@Bean
fun customConversions(connectionFactory: ConnectionFactory): R2dbcCustomConversions {
val converters = listOf(
ListStringReadConverter(),
ListStringWriteConverter(),
UUIDReadConverter(),
UUIDWriteConverter(),
ByteBufferToUUIDConverter()
)
return R2dbcCustomConversions.of(DialectResolver.getDialect(connectionFactory), converters)
}
}
@ReadingConverter
class ListStringReadConverter : Converter<Row, List<String>> {
override fun convert(source: Row): List<String> {
val text = source.get("stack", String::class.java)
return StringListConverter.convertToEntityAttribute(text)
}
}
@WritingConverter
class ListStringWriteConverter : Converter<List<String>, String> {
override fun convert(source: List<String>): String {
return StringListConverter.convertToDatabaseColumn(source)
}
}
@ReadingConverter
class UUIDReadConverter : Converter<Row, UUID> {
override fun convert(row: Row): UUID {
val bb = ByteBuffer.wrap(row.get("id", ByteArray::class.java))
return UUID(bb.getLong(), bb.getLong())
}
}
@ReadingConverter
class ByteBufferToUUIDConverter : Converter<ByteBuffer, UUID> {
override fun convert(source: ByteBuffer): UUID {
val buffer = source.duplicate()
val mostSigBits = buffer.long
val leastSigBits = buffer.long
return UUID(mostSigBits, leastSigBits)
}
}
@WritingConverter
class UUIDWriteConverter : Converter<UUID, ByteArray> {
override fun convert(uuid: UUID): ByteArray {
val bb = ByteBuffer.wrap(ByteArray(16))
bb.putLong(uuid.mostSignificantBits)
bb.putLong(uuid.leastSignificantBits)
return bb.array()
}
}
fun UUID.toByteArray(): ByteArray {
return UUIDWriteConverter().convert(this)
} | crud-users-kotlin/users-webflux-coroutine/src/main/kotlin/com/crud/userswebfluxcoroutine/R2dbcConverters.kt | 491021233 |
package com.crud.userswebfluxcoroutine
import jakarta.validation.Constraint
import jakarta.validation.ConstraintValidator
import jakarta.validation.ConstraintValidatorContext
import jakarta.validation.Payload
import kotlin.reflect.KClass
@Target(AnnotationTarget.FIELD)
@MustBeDocumented
@Constraint(validatedBy = [SizeElementsOfListValidator::class])
annotation class SizeElementsOfList(
val message: String = "Os elementos da lista devem estar entre 1 e {size}",
val groups: Array<KClass<*>> = [],
val payload: Array<KClass<out Payload>> = [],
val size: Int = 32
)
class SizeElementsOfListValidator : ConstraintValidator<SizeElementsOfList, List<String>> {
private var size: Int = 32
override fun initialize(constraintAnnotation: SizeElementsOfList?) {
if (constraintAnnotation != null) {
size = constraintAnnotation.size
}
}
override fun isValid(value: List<String>?, context: ConstraintValidatorContext?): Boolean =
value == null || value.all { it.isNotBlank() && it.length in 0..size }
} | crud-users-kotlin/users-webflux-coroutine/src/main/kotlin/com/crud/userswebfluxcoroutine/CustomValidator.kt | 1350837679 |
package com.crud.userswebfluxcoroutine
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
@SpringBootApplication
class UsersWebfluxCoroutineApplication
fun main(args: Array<String>) {
runApplication<UsersWebfluxCoroutineApplication>(*args)
}
| crud-users-kotlin/users-webflux-coroutine/src/main/kotlin/com/crud/userswebfluxcoroutine/UsersWebfluxCoroutineApplication.kt | 4065060666 |
package com.crud.userswebfluxcoroutine
import io.r2dbc.spi.Readable
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.reactive.awaitFirstOrNull
import kotlinx.coroutines.reactor.awaitSingle
import org.springframework.r2dbc.core.DatabaseClient
import org.springframework.r2dbc.core.awaitSingleOrNull
import org.springframework.r2dbc.core.flow
import org.springframework.stereotype.Repository
import java.nio.ByteBuffer
import java.time.LocalDateTime
import java.util.UUID
@Repository
class UserDatabaseClientRepository(
val client: DatabaseClient,
) : UserRepository {
private fun rowToUser(row: Readable): User {
val bb = ByteBuffer.wrap(row.get("id", ByteArray::class.java))
return User(
id = UUID(bb.getLong(), bb.getLong()),
name = row.get("name", String::class.java)!!,
nick = row.get("nick", String::class.java),
birthDate = row.get("birth_date", LocalDateTime::class.java)!!,
stack = StringListConverter.convertToEntityAttribute(row.get("stack", String::class.java))
)
}
private fun userToMap(user: User) = mapOf(
"id" to UUIDWriteConverter().convert(user.id!!),
"nick" to user.nick,
"name" to user.name,
"birthDate" to user.birthDate,
"stack" to StringListConverter.convertToDatabaseColumn(user.stack),
)
override suspend fun findById(id: UUID): User? {
return client.sql("SELECT * FROM users WHERE id = :id")
.bind("id", UUIDWriteConverter().convert(id))
.map { row -> rowToUser(row) }
.first()
.awaitFirstOrNull()
}
override fun findAll(): Flow<User> {
return client.sql("SELECT * FROM users")
.map { row -> rowToUser(row) }
.flow()
}
override suspend fun insert(user: User): User? {
user.id = UUID.randomUUID()
client.sql { "INSERT INTO users (id, nick, name, birth_date, stack) VALUES (:id, :nick, :name, :birthDate, :stack)" }
.bindValues(userToMap(user))
.fetch()
.awaitSingleOrNull()
return findById(user.id!!)
}
override suspend fun update(user: User): User? {
client.sql { "UPDATE users SET nick = :nick, name = :name, birth_date = :birthDate, stack = :stack WHERE id = :id" }
.bindValues(userToMap(user))
.fetch()
.first()
.awaitFirstOrNull()
return findById(user.id!!)
}
override suspend fun existsById(id: UUID): Boolean {
val exists = client.sql("SELECT COUNT(*) FROM users WHERE id = :id")
.bind("id", UUIDWriteConverter().convert(id))
.map { row -> row.get(0, String::class.java)?.toLong()!! > 0 }
.first()
.awaitSingle()
return exists ?: false
}
override suspend fun deleteById(id: UUID) {
client.sql("DELETE FROM users WHERE id = :id")
.bind("id", UUIDWriteConverter().convert(id))
.fetch()
.rowsUpdated()
.awaitSingle()
}
} | crud-users-kotlin/users-webflux-coroutine/src/main/kotlin/com/crud/userswebfluxcoroutine/UserDatabaseClientRepository.kt | 3532878844 |
package com.crud.userswebfluxcoroutine
fun User.toUserResponse(): UserResponse {
return UserResponse(
id = id,
birthDate = birthDate,
nick = nick,
name = name,
stack = stack
)
} | crud-users-kotlin/users-webflux-coroutine/src/main/kotlin/com/crud/userswebfluxcoroutine/UserConverter.kt | 1210468283 |
package com.crud.userswebfluxcoroutine
import org.springframework.web.bind.annotation.ControllerAdvice
data class ErrorsResponse(
var errors: List<String>
)
@ControllerAdvice
class ExceptionHandler {
/*@ExceptionHandler(ResourceNotFoundException::class)
fun resourceNotFoundException(
req: HttpServletRequest,
exception: ResourceNotFoundException
): ResponseEntity<Nothing> {
return ResponseEntity.notFound().build()
}
@ExceptionHandler(MethodArgumentNotValidException::class)
fun methodArguentNotValidException(
req: HttpServletRequest,
exception: MethodArgumentNotValidException
): ResponseEntity<ErrorsResponse> {
val response = ErrorsResponse(mutableListOf())
response.errors = exception.bindingResult.allErrors.map { it.defaultMessage ?: "" }
return ResponseEntity.badRequest().body(response)
}*/
} | crud-users-kotlin/users-webflux-coroutine/src/main/kotlin/com/crud/userswebfluxcoroutine/ExceptionHandler.kt | 3870333006 |
package com.crud.userswebfluxcoroutine
import kotlinx.coroutines.flow.Flow
import java.util.UUID
interface UserRepository {
suspend fun findById(id: UUID): User?
fun findAll(): Flow<User>
suspend fun insert(user: User): User?
suspend fun update(user: User): User?
suspend fun existsById(id: UUID): Boolean
suspend fun deleteById(id: UUID)
} | crud-users-kotlin/users-webflux-coroutine/src/main/kotlin/com/crud/userswebfluxcoroutine/UserRepository.kt | 892751546 |
package com.crud.userswebfluxcoroutine
import java.time.LocalDateTime
import java.util.UUID
data class UserResponse(
val id: UUID?,
val birthDate: LocalDateTime,
val nick: String?,
val name: String,
val stack: List<String>?,
) {
} | crud-users-kotlin/users-webflux-coroutine/src/main/kotlin/com/crud/userswebfluxcoroutine/UserResponse.kt | 557908696 |
package com.crud.userswebfluxcoroutine
import jakarta.validation.constraints.Size
import java.time.LocalDateTime
data class CreateUserRequest(
val birthDate: LocalDateTime,
@field:Size(min = 1, max = 32, message = "O campo apelido deve estar entre 1 e 32")
val nick: String?,
@field:Size(min = 1, max = 255, message = "O campo nome é obrigatório e deve estar entre 1 e 255")
val name: String,
@field:SizeElementsOfList
val stack: List<String>? = null,
) {
}
fun CreateUserRequest.toUser(): User {
return User(
id = null,
nick = nick,
name = name,
birthDate = birthDate,
stack = stack
)
}
data class UpdateUserRequest(
var birthDate: LocalDateTime?,
@field:Size(min= 1, max = 32, message = "O campo apelido deve estar entre 1 e 32")
var nick: String?,
@field:Size(min = 1, max = 255, message = "O campo nome é obrigatório e deve estar entre 1 e 255")
var name: String?,
@field:SizeElementsOfList
var stack: List<String>?,
) {} | crud-users-kotlin/users-webflux-coroutine/src/main/kotlin/com/crud/userswebfluxcoroutine/UserRequest.kt | 4147705943 |
package com.crud.userswebfluxcoroutine
import jakarta.validation.Valid
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map
import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.http.HttpHeaders
import org.springframework.http.HttpStatus
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.DeleteMapping
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PathVariable
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.PutMapping
import org.springframework.web.bind.annotation.RequestBody
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RestController
import java.net.URI
import java.util.UUID
@RestController
@RequestMapping("/users")
class UserController(
@Qualifier("userDatabaseClientRepository") private val userRepository: UserRepository
) {
@GetMapping("/{id}")
suspend fun getUser(@PathVariable("id") id: UUID): ResponseEntity<UserResponse> {
val user = userRepository.findById(id) ?: throw ResourceNotFoundException("User not found")
return ResponseEntity.ok(user.toUserResponse())
}
@GetMapping
suspend fun listUsers(): ResponseEntity<Flow<UserResponse>> {
val users = userRepository.findAll()
.map { it.toUserResponse() }
return ResponseEntity.ok(users)
}
@PostMapping
suspend fun createUser(@Valid @RequestBody createUserRequest: CreateUserRequest): ResponseEntity<UserResponse> {
val user = createUserRequest.toUser()
val userCreated = userRepository.insert(user)
val httpHeaders = HttpHeaders()
httpHeaders.location = URI.create("/users/${userCreated?.id}")
return ResponseEntity(userCreated?.toUserResponse(), httpHeaders, HttpStatus.CREATED)
}
@DeleteMapping("/{id}")
suspend fun deleteUser(@PathVariable("id") id: UUID): ResponseEntity<Nothing> {
if (!userRepository.existsById(id)) {
return ResponseEntity.notFound().build()
}
userRepository.deleteById(id)
return ResponseEntity.noContent().build()
}
@PutMapping("/{id}")
suspend fun updateUser(
@PathVariable("id") id: UUID,
@Valid @RequestBody updateUserRequest: UpdateUserRequest
): ResponseEntity<UserResponse> {
val userUpdated = userRepository.findById(id) ?: throw ResourceNotFoundException("User not found")
userUpdated.apply {
updateUserRequest.nick.also { nick = it }
updateUserRequest.name?.also { name = it }
updateUserRequest.birthDate?.also { birthDate = it }
updateUserRequest.stack.also { stack = it }
}.run { userRepository.update(this) }
return ResponseEntity.ok(userUpdated.toUserResponse())
}
} | crud-users-kotlin/users-webflux-coroutine/src/main/kotlin/com/crud/userswebfluxcoroutine/UserController.kt | 184342161 |
package com.crud.userswebfluxcoroutine
object StringListConverter {
fun convertToDatabaseColumn(attribute: List<String>?): String = attribute?.joinToString(";") ?: ""
fun convertToEntityAttribute(dbData: String?): List<String> =
if (dbData?.isNotBlank() == true) dbData.split(";") else listOf()
} | crud-users-kotlin/users-webflux-coroutine/src/main/kotlin/com/crud/userswebfluxcoroutine/StringListConverter.kt | 2221560300 |
package com.crud.userswebfluxcoroutine
import java.time.LocalDateTime
import java.util.UUID
data class User(
var id: UUID?,
var nick: String?,
var name: String,
var birthDate: LocalDateTime,
var stack: List<String>?,
) | crud-users-kotlin/users-webflux-coroutine/src/main/kotlin/com/crud/userswebfluxcoroutine/User.kt | 2086566936 |
package com.crud.userswebfluxcoroutine
class ResourceNotFoundException(
message: String,
) : Exception(message) {
} | crud-users-kotlin/users-webflux-coroutine/src/main/kotlin/com/crud/userswebfluxcoroutine/ResourceNotFoundException.kt | 3090706284 |
package com.crud.userswebfluxcoroutine
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.reactive.awaitFirstOrNull
import kotlinx.coroutines.reactor.awaitSingle
import org.springframework.data.r2dbc.core.R2dbcEntityOperations
import org.springframework.data.r2dbc.core.delete
import org.springframework.data.r2dbc.core.flow
import org.springframework.data.r2dbc.core.insert
import org.springframework.data.r2dbc.core.select
import org.springframework.data.relational.core.query.Criteria.where
import org.springframework.data.relational.core.query.Query.query
import org.springframework.data.relational.core.query.Update
import org.springframework.stereotype.Repository
import java.util.UUID
import kotlin.math.absoluteValue
@Repository
class UserR2dbcEntityOperationsRepository(
val r2dbcEntityOperations: R2dbcEntityOperations
) : UserRepository {
override suspend fun findById(id: UUID): User? {
return r2dbcEntityOperations.select<User>()
.from("users")
.matching(query(where("id").`is`(id.toByteArray())))
.first()
.awaitFirstOrNull()
}
override fun findAll(): Flow<User> {
return r2dbcEntityOperations.select<User>()
.from("users")
.flow()
}
override suspend fun insert(user: User): User? {
user.id = UUID.randomUUID()
return r2dbcEntityOperations.insert<User>()
.into("users")
.using(user)
.awaitFirstOrNull()
}
override suspend fun update(user: User): User? {
val query = r2dbcEntityOperations.update(User::class.java)
.inTable("users")
.matching(query(where("id").`is`(user.id!!.toByteArray())))
.apply(Update.update("nick", user.nick)
.set("name", user.name)
.set("birth_date", user.birthDate)
.set("stack", user.stack))
r2dbcEntityOperations.update(query)
.awaitFirstOrNull()
return findById(user.id!!)
}
override suspend fun existsById(id: UUID): Boolean {
return r2dbcEntityOperations.count(
query(where("id").`is`(id.toByteArray())),
User::class.java
)
.map { row -> row.absoluteValue > 0 }
.awaitSingle()
}
override suspend fun deleteById(id: UUID) {
r2dbcEntityOperations.delete<User>()
.from("users")
.matching(query(where("id").`is`(id.toByteArray())))
.all()
.awaitSingle()
}
}
| crud-users-kotlin/users-webflux-coroutine/src/main/kotlin/com/crud/userswebfluxcoroutine/UserR2dbcEntityOperationsRepository.kt | 295666324 |
package com.crud
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
@SpringBootTest
class UsersWebfluxApplicationTests {
@Test
fun contextLoads() {
}
}
| crud-users-kotlin/users-webflux/src/test/kotlin/com/crud/UsersWebfluxApplicationTests.kt | 1639984908 |
package com.crud
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
@SpringBootApplication
class UsersWebfluxApplication
fun main(args: Array<String>) {
runApplication<UsersWebfluxApplication>(*args)
}
| crud-users-kotlin/users-webflux/src/main/kotlin/com/crud/UsersWebfluxApplication.kt | 2018727832 |
package com.crud
import org.springframework.data.repository.CrudRepository
import org.springframework.stereotype.Repository
import java.util.*
@Repository
interface UserRepository : CrudRepository<User, UUID> | crud-users-kotlin/users-webflux/src/main/kotlin/com/crud/UserRepository.kt | 3782541875 |
package com.crud
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
import reactor.core.publisher.Mono
import java.util.*
@RestController
@RequestMapping("/users")
class UserController(
private val userRepository: UserRepository
) {
@GetMapping("/{id}")
fun getUser(@PathVariable("id") id: UUID): Mono<ResponseEntity<User>> {
return Mono.fromCallable {
val user = userRepository.findById(id)
.orElseThrow { ResourceNotFoundException("User not found") }
ResponseEntity.ok(user)
}.onErrorResume { throw ResourceNotFoundException("User not found") }
}
@GetMapping
fun listUsers(): Mono<ResponseEntity<List<User>>> {
return Mono.fromCallable {
ResponseEntity.ok(userRepository.findAll().map {
it
})
}
}
} | crud-users-kotlin/users-webflux/src/main/kotlin/com/crud/UserController.kt | 2194476771 |
package com.crud
import jakarta.persistence.AttributeConverter
import jakarta.persistence.Converter
@Converter
class StringListConverter : AttributeConverter<List<String>, String> {
override fun convertToDatabaseColumn(attribute: List<String>?): String = attribute?.joinToString(";") ?: ""
override fun convertToEntityAttribute(dbData: String?): List<String> = if (dbData?.isNotBlank() == true) dbData.split(";") else listOf()
} | crud-users-kotlin/users-webflux/src/main/kotlin/com/crud/StringListConverter.kt | 765499298 |
package com.crud
import jakarta.persistence.*
import java.time.LocalDateTime
import java.util.*
@Entity
@Table(name = "users")
class User(
@Id
@GeneratedValue(strategy = GenerationType.UUID)
val id: UUID?,
@Column(name = "nick", length = 32)
val nick: String?,
@Column(name = "name", length = 255, unique = true, nullable = false)
val name: String,
@Column(name = "birth_date", nullable = false)
val birthDate: LocalDateTime?,
@Convert(converter = StringListConverter::class)
@Lob
@Column(name = "stack")
val stack: List<String>?,
) {
constructor() : this(null, null, "", null, null)
} | crud-users-kotlin/users-webflux/src/main/kotlin/com/crud/User.kt | 3470562705 |
package com.crud
class ResourceNotFoundException(
message: String,
) : Exception(message) {
} | crud-users-kotlin/users-webflux/src/main/kotlin/com/crud/ResourceNotFoundException.kt | 3525699138 |
package com.example.peoplelistapp
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.peoplelistapp", appContext.packageName)
}
} | people-list-app/app/src/androidTest/java/com/example/peoplelistapp/ExampleInstrumentedTest.kt | 2425403591 |
package com.example.peoplelistapp
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)
}
} | people-list-app/app/src/test/java/com/example/peoplelistapp/ExampleUnitTest.kt | 2256542506 |
package com.example.peoplelistapp.ui.home
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
class HomeViewModel : ViewModel() {
private val _text = MutableLiveData<String>().apply {
value = "This is home Fragment"
}
val text: LiveData<String> = _text
} | people-list-app/app/src/main/java/com/example/peoplelistapp/ui/home/HomeViewModel.kt | 3274525980 |
package com.example.peoplelistapp.ui.home
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import androidx.activity.viewModels
import androidx.fragment.app.Fragment
import androidx.fragment.app.viewModels
import androidx.lifecycle.ViewModelProvider
import com.example.peoplelistapp.data.DataApplication
import com.example.peoplelistapp.data.person.Person
import com.example.peoplelistapp.data.person.PersonViewModel
import com.example.peoplelistapp.data.person.PersonViewModelFactory
import com.example.peoplelistapp.databinding.FragmentHomeBinding
import java.lang.StringBuilder
class HomeFragment : Fragment() {
private var _binding: FragmentHomeBinding? = null
// This property is only valid between onCreateView and
// onDestroyView.
private val binding get() = _binding!!
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
val homeViewModel =
ViewModelProvider(this).get(HomeViewModel::class.java)
_binding = FragmentHomeBinding.inflate(inflater, container, false)
val root: View = binding.root
val textView: TextView = binding.textHome
homeViewModel.text.observe(viewLifecycleOwner) {
textView.text = it
}
return root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
val dataViewModel: PersonViewModel by viewModels {
PersonViewModelFactory((activity?.application as DataApplication).repository)
}
//adding new record
//dataViewModel.insert(Person(name = "Ivan", age = 22))
dataViewModel.allPeople.observe(viewLifecycleOwner){
val builder = StringBuilder()
it.forEach {
builder.append(it).append('\n')
}
binding.textHome.text = builder.toString()
}
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | people-list-app/app/src/main/java/com/example/peoplelistapp/ui/home/HomeFragment.kt | 2942650208 |
package com.example.peoplelistapp.ui.gallery
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
class GalleryViewModel : ViewModel() {
private val _text = MutableLiveData<String>().apply {
value = "This is gallery Fragment"
}
val text: LiveData<String> = _text
} | people-list-app/app/src/main/java/com/example/peoplelistapp/ui/gallery/GalleryViewModel.kt | 1530799915 |
package com.example.peoplelistapp.ui.gallery
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModelProvider
import com.example.peoplelistapp.databinding.FragmentGalleryBinding
class GalleryFragment : Fragment() {
private var _binding: FragmentGalleryBinding? = null
// This property is only valid between onCreateView and
// onDestroyView.
private val binding get() = _binding!!
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
val galleryViewModel =
ViewModelProvider(this).get(GalleryViewModel::class.java)
_binding = FragmentGalleryBinding.inflate(inflater, container, false)
val root: View = binding.root
val textView: TextView = binding.textGallery
galleryViewModel.text.observe(viewLifecycleOwner) {
textView.text = it
}
return root
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | people-list-app/app/src/main/java/com/example/peoplelistapp/ui/gallery/GalleryFragment.kt | 1288063284 |
package com.example.peoplelistapp.ui.slideshow
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
class SlideshowViewModel : ViewModel() {
private val _text = MutableLiveData<String>().apply {
value = "This is slideshow Fragment"
}
val text: LiveData<String> = _text
} | people-list-app/app/src/main/java/com/example/peoplelistapp/ui/slideshow/SlideshowViewModel.kt | 2495960811 |
package com.example.peoplelistapp.ui.slideshow
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import androidx.fragment.app.Fragment
import androidx.lifecycle.ViewModelProvider
import com.example.peoplelistapp.databinding.FragmentSlideshowBinding
class SlideshowFragment : Fragment() {
private var _binding: FragmentSlideshowBinding? = null
// This property is only valid between onCreateView and
// onDestroyView.
private val binding get() = _binding!!
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
val slideshowViewModel =
ViewModelProvider(this).get(SlideshowViewModel::class.java)
_binding = FragmentSlideshowBinding.inflate(inflater, container, false)
val root: View = binding.root
val textView: TextView = binding.textSlideshow
slideshowViewModel.text.observe(viewLifecycleOwner) {
textView.text = it
}
return root
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
} | people-list-app/app/src/main/java/com/example/peoplelistapp/ui/slideshow/SlideshowFragment.kt | 772547433 |
package com.example.peoplelistapp
import android.os.Bundle
import android.view.Menu
import android.widget.Toast
import androidx.activity.viewModels
import com.google.android.material.snackbar.Snackbar
import com.google.android.material.navigation.NavigationView
import androidx.navigation.findNavController
import androidx.navigation.ui.AppBarConfiguration
import androidx.navigation.ui.navigateUp
import androidx.navigation.ui.setupActionBarWithNavController
import androidx.navigation.ui.setupWithNavController
import androidx.drawerlayout.widget.DrawerLayout
import androidx.appcompat.app.AppCompatActivity
import androidx.navigation.Navigation
import com.example.peoplelistapp.data.DataApplication
import com.example.peoplelistapp.data.person.Person
import com.example.peoplelistapp.data.person.PersonViewModel
import com.example.peoplelistapp.data.person.PersonViewModelFactory
import com.example.peoplelistapp.databinding.ActivityMainBinding
class MainActivity : AppCompatActivity() {
private lateinit var appBarConfiguration: AppBarConfiguration
private lateinit var binding: ActivityMainBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
setSupportActionBar(binding.appBarMain.toolbar)
val drawerLayout: DrawerLayout = binding.drawerLayout
val navView: NavigationView = binding.navView
val navController = findNavController(R.id.nav_host_fragment_content_main)
// Passing each menu ID as a set of Ids because each
// menu should be considered as top level destinations.
appBarConfiguration = AppBarConfiguration(
setOf(
R.id.nav_home, R.id.nav_gallery, R.id.nav_slideshow
), drawerLayout
)
setupActionBarWithNavController(navController, appBarConfiguration)
navView.setupWithNavController(navController)
binding.appBarMain.fab.setOnClickListener { view ->
Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
.setAction("Action"){
Toast.makeText(applicationContext, "Action clicked", Toast.LENGTH_SHORT).show()
}
.setAnchorView(R.id.fab).show()
navController.navigate(R.id.nav_gallery)
}
}
override fun onCreateOptionsMenu(menu: Menu): Boolean {
// Inflate the menu; this adds items to the action bar if it is present.
menuInflater.inflate(R.menu.main, menu)
return true
}
override fun onSupportNavigateUp(): Boolean {
val navController = findNavController(R.id.nav_host_fragment_content_main)
return navController.navigateUp(appBarConfiguration) || super.onSupportNavigateUp()
}
} | people-list-app/app/src/main/java/com/example/peoplelistapp/MainActivity.kt | 2958211973 |
package com.example.peoplelistapp.data
import android.app.Application
import com.example.peoplelistapp.data.person.PersonRepository
class DataApplication : Application() {
private val database: AppDatabase by lazy { AppDatabase.getInstance(this) }
val repository by lazy { PersonRepository(database.getPersonDao()) }
} | people-list-app/app/src/main/java/com/example/peoplelistapp/data/DataApplication.kt | 1787348723 |
package com.example.peoplelistapp.data.person
import androidx.annotation.WorkerThread
import kotlinx.coroutines.flow.Flow
class PersonRepository(private val dao: PersonDao) {
val allPeople: Flow<List<Person>> = dao.getAll()
@WorkerThread
suspend fun insert(person: Person){
dao.insert(person)
}
} | people-list-app/app/src/main/java/com/example/peoplelistapp/data/person/PersonRepository.kt | 1165713165 |
package com.example.peoplelistapp.data.person
import androidx.room.Dao
import androidx.room.Delete
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import com.example.peoplelistapp.data.person.Person
import kotlinx.coroutines.flow.Flow
@Dao
interface PersonDao {
@Insert
suspend fun insert(person: Person)
@Insert (onConflict = OnConflictStrategy.IGNORE)
suspend fun insertAll(vararg person: Person)
@Delete
suspend fun delete(person: Person)
@Query ("SELECT * FROM person")
fun getAll() : Flow<List<Person>>
} | people-list-app/app/src/main/java/com/example/peoplelistapp/data/person/PersonDao.kt | 1491782916 |
package com.example.peoplelistapp.data.person
import androidx.room.Entity
import androidx.room.PrimaryKey
@Entity (tableName = "person")
data class Person(
@PrimaryKey (autoGenerate = true) val id: Int = 0,
val name: String,
val age: Int)
{
override fun toString(): String {
return "id: $id $name $age"
}
}
| people-list-app/app/src/main/java/com/example/peoplelistapp/data/person/Person.kt | 3217355953 |
package com.example.peoplelistapp.data.person
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.asLiveData
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import java.lang.IllegalArgumentException
class PersonViewModel(private val repository: PersonRepository) : ViewModel() {
val allPeople = repository.allPeople.asLiveData()
fun insert(person: Person){
viewModelScope.launch (Dispatchers.IO){
repository.insert(person)
}
}
}
@Suppress("UNCHECKED_CAST")
class PersonViewModelFactory(private val repository: PersonRepository): ViewModelProvider.Factory{
override fun <T : ViewModel> create(modelClass: Class<T>): T {
if (modelClass.isAssignableFrom(PersonViewModel::class.java)){
return PersonViewModel(repository) as T
}
throw IllegalArgumentException("No such ViewModel class")
}
} | people-list-app/app/src/main/java/com/example/peoplelistapp/data/person/PersonViewModel.kt | 3519927877 |
package com.example.peoplelistapp.data
import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
import com.example.peoplelistapp.data.person.Person
import com.example.peoplelistapp.data.person.PersonDao
@Database(entities = arrayOf(Person::class), version = 1, exportSchema = false)
abstract class AppDatabase : RoomDatabase() {
abstract fun getPersonDao(): PersonDao
companion object {
@Volatile
private var INSTANCE: AppDatabase? = null
fun getInstance(context: Context) : AppDatabase {
return INSTANCE ?: synchronized(this){
val instance = Room.databaseBuilder(
context,
AppDatabase::class.java,
"app_database"
).build()
INSTANCE = instance
return instance
}
}
}
} | people-list-app/app/src/main/java/com/example/peoplelistapp/data/AppDatabase.kt | 446987469 |
package com.john.proyectodog
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.john.proyectodog", appContext.packageName)
}
} | proyectoDog/app/src/androidTest/java/com/john/proyectodog/ExampleInstrumentedTest.kt | 3534540132 |
package com.john.proyectodog
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)
}
} | proyectoDog/app/src/test/java/com/john/proyectodog/ExampleUnitTest.kt | 1259096878 |
package com.john.proyectodog.ui.adapter
import android.view.View
import androidx.recyclerview.widget.RecyclerView
import com.bumptech.glide.Glide
import com.john.proyectodog.data.models.Dog
import com.john.proyectodog.databinding.ItemDogsBinding
class ViewHDog (view: View): RecyclerView.ViewHolder (view) {
private lateinit var binding: ItemDogsBinding
init {
binding = ItemDogsBinding.bind(view)
}
//método que se encarga de mapear los item por propiedad del modelo.
fun renderize(dog : Dog){
binding.txtviewName.setText(dog. name)
Glide
.with( itemView.context)
.load(dog.image)
.centerCrop()
.into( binding.ivDogs)
}
} | proyectoDog/app/src/main/java/com/john/proyectodog/ui/adapter/ViewHDog.kt | 2033879447 |
package com.john.proyectodog.ui.adapter
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.recyclerview.widget.RecyclerView
import com.john.proyectodog.R
import com.john.proyectodog.data.models.Dog
import com.john.proyectodog.data.models.Repository
class DogAdapter: RecyclerView.Adapter<ViewHDog>(){
var dogRepository: List<Dog> = Repository. dogs //cargo del repsitorio dememoria.
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHDog {
val layoutInflater = LayoutInflater.from(parent. context)//objeto para crear la vista.
val layoutItemRestaurant = R.layout.item_dogs //accedo al xml del item a crear.
return ViewHDog(
layoutInflater.inflate(layoutItemRestaurant, parent, false)
)
}
override fun onBindViewHolder(holder: ViewHDog, position: Int) {
holder.renderize(dogRepository[position]) //renderizamos la view.
}
override fun getItemCount(): Int = dogRepository.size
} | proyectoDog/app/src/main/java/com/john/proyectodog/ui/adapter/DogAdapter.kt | 3531523702 |
package com.john.proyectodog.ui.modelView
import android.util.Log
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.john.proyectodog.data.models.Dog
import com.john.proyectodog.domain.userCase.GetDogsBreedUseCase
import com.john.proyectodog.domain.userCase.GetDogsUseCase
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
class DogViewModel: ViewModel() {
var dogListLiveData = MutableLiveData<List<Dog>>() //repositorio observable.
var progressBarLiveData = MutableLiveData<Boolean> () //progressbar observable
var search = MutableLiveData<String>() //para el campo search observable
lateinit var useCaseList : GetDogsUseCase
lateinit var useCaseBreedList : GetDogsBreedUseCase
fun searchByBreed(breed: String){
Log.i("TAG-DOGS", "La raza elegida es $breed")
search.value = breed //notificamos cambio
}
fun list() {
viewModelScope.launch { //La corrutina se ejecuta en segundo plano.
progressBarLiveData.value = true //LiveData notifica del cambio.
delay(2000)
useCaseList = GetDogsUseCase()
var data: List<Dog>? =
useCaseList() //Invocamos a nuestro caso de uso (lógica de negocio).
data.let {
dogListLiveData.value = it //LiveData notifica del cambio.
// dogListLiveData.postValue(it)
progressBarLiveData.value = false //LiveData notifica del cambio.
}
}
}
fun listForBreed(breed: String) {
viewModelScope.launch {
progressBarLiveData.value = true //notifico
delay(2000)
useCaseBreedList = GetDogsBreedUseCase(breed)
var data : List<Dog> ? = useCaseBreedList() //Invocamos a nuestro caso de uso (lógica de negocio).
data.let {
// dogListLiveData.postValue(it)
dogListLiveData.value = it //El LiveData notifica el cambio.
progressBarLiveData.value = false //El LiveData notifica el cambio.
}
}
}
} | proyectoDog/app/src/main/java/com/john/proyectodog/ui/modelView/DogViewModel.kt | 197946486 |
package com.john.proyectodog
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import android.view.inputmethod.InputMethodManager
import androidx.activity.viewModels
import androidx.appcompat.widget.SearchView
import androidx.core.view.isVisible
import androidx.recyclerview.widget.LinearLayoutManager
import com.john.proyectodog.databinding.ActivityMainBinding
import com.john.proyectodog.ui.adapter.DogAdapter
import com.john.proyectodog.ui.modelView.DogViewModel
class MainActivity : AppCompatActivity(), SearchView.OnQueryTextListener{
lateinit var binding: ActivityMainBinding
lateinit var adapter: DogAdapter
val dogViewModel: DogViewModel by viewModels() //tiene que ser constante.
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate( layoutInflater)
setContentView(binding.root)
binding.mySearch.setOnQueryTextListener( this) //cargamos el listener, para el EditText
initRecyclerView() //inicializamos el recyclerView. De memento, contendrá lista empty.
adapter = DogAdapter() // Inicializa el adaptador con una lista vacía
registerLiveData() //Suscribimos nuestro Activity a recibir notificaciones del ViewModel.
loadDada()
}
private fun initRecyclerView(){
binding.myRecyclerView.layoutManager = LinearLayoutManager( this)
}
private fun loadDada() {
dogViewModel.list() //simulamos un evento para iniciar la carga de datos desde el viewmodel
}
private fun registerLiveData() {
dogViewModel.dogListLiveData.observe(
this
) { myList ->
//Aquí hacemos la actualización del adapter.
adapter.dogRepository = myList!! //aseguro los datos.
binding.myRecyclerView.adapter = adapter //le asigno el adapter.
adapter.notifyDataSetChanged()
}
dogViewModel.progressBarLiveData.observe(
this
) { visible ->
binding.progressBar.isVisible = visible
Log.i("TAG-DOGS", "ProgressBar esta $visible")
}
/*
Observamos un cambio en el search. De la misma forma, será notificado y actualizará la UI.
*/
dogViewModel.search.observe( //el campo search, ha cambiado
this
) { bread ->
dogViewModel.listForBreed(bread) //cambiamos los datos.
hideKeyBoard() //Este método oculta el teclado.
}
}
override fun onQueryTextSubmit(query: String?): Boolean {
if (!query. isNullOrEmpty())
dogViewModel.searchByBreed(query!!)
return true
}
/*
Cualquier cambio, llamará a este método. Estoy obligado a sobreescribirlo.
Lo utilizo para cargar toda la lista de nuevo, al
estar el campo vacío. Es lo que se me ha ocurrido para borrar la raza y que los cargue todos.
*/
override fun onQueryTextChange(newText: String?): Boolean {
if (newText. isNullOrEmpty()) {
dogViewModel.list()
hideKeyBoard() //esconde el teclado.
}
return true
}
private fun hideKeyBoard() {
val imn = getSystemService( INPUT_METHOD_SERVICE) as InputMethodManager
imn.hideSoftInputFromWindow( binding.myRecyclerView .windowToken, 0)
}
} | proyectoDog/app/src/main/java/com/john/proyectodog/MainActivity.kt | 3429242965 |
package com.john.proyectodog.data.models
data class Dog(
val name: String,
val image: String
)
{
override fun toString(): String {
return "Dog(name='$name', image='$image')"
}
} | proyectoDog/app/src/main/java/com/john/proyectodog/data/models/Dog.kt | 3729831901 |
package com.john.proyectodog.data.models
interface DogRepositoryInterfaceDao {
fun getDogs() : List<Dog>
fun getBreedDogs (breed:String) : List<Dog>
} | proyectoDog/app/src/main/java/com/john/proyectodog/data/models/DogRepositoryInterfaceDao.kt | 1083639443 |
package com.john.proyectodog.data.models
class Repository {
companion object {
var dogs:List<Dog> = emptyList()
}
} | proyectoDog/app/src/main/java/com/john/proyectodog/data/models/Repository.kt | 3401952136 |
package com.john.proyectodog.data.models
import com.john.proyectodog.data.service.DogService
class DogRepositoryDao : DogRepositoryInterfaceDao {
companion object {
val myDogRepositoryDao: DogRepositoryDao by lazy{ //lazy delega a un primer acceso
DogRepositoryDao() //Me creo sólo este objeto una vez.
}
}
/*
Método que a partir de los datos nativos, devuelve la lista
de objetos que necesita el modelo.
*/
override fun getDogs(): List<Dog> {
var mutableDogs : MutableList <Dog> = mutableListOf()
val dataSource = DogService.service.getDogs()
dataSource .forEach{ dog->
mutableDogs .add(Dog(dog. first, dog.second))
}
Repository .dogs = mutableDogs //AQUÍ CARGO LOS DATOS EN MEMORIA.
return Repository .dogs
}
override fun getBreedDogs(breed: String): List<Dog> {
var mutableDogs : MutableList <Dog> = mutableListOf()
val dataSource = DogService.service.getBreedDogs(breed)
dataSource .forEach{ dog->
mutableDogs .add(Dog(dog. first, dog.second))
}
Repository .dogs = mutableDogs //AQUÍ CARGO LOS DATOS EN MEMORIA.
return Repository .dogs
}
} | proyectoDog/app/src/main/java/com/john/proyectodog/data/models/DogRepositoryDao.kt | 2875042108 |
package com.john.proyectodog.data.dataSorce
object Dogs {
val dogs : List<Pair<String, String>> = listOf(
Pair( "basenji", "https://images.dog.ceo/breeds/basenji/n02110806_5744.jpg" ),
Pair( "pastor aleman","https://images.dog.ceo/breeds/germanshepherd/n02106662_6966.jpg" ),
Pair( "san bernardo","https://images.dog.ceo/breeds/stbernard/n02109525_6693.jpg" ),
Pair( "pincher", "https://images.dog.ceo/breeds/pinscher-miniature/n02107312_5077.jpg" ),
Pair( "collie border","https://images.dog.ceo/breeds/collie-border/n02106166_3850.jpg" )
)
} | proyectoDog/app/src/main/java/com/john/proyectodog/data/dataSorce/Dogs.kt | 320298721 |
package com.john.proyectodog.data.service
interface DogServiceInterface {
fun getDogs(): List<Pair<String,String>>
fun getBreedDogs (breed: String) : List<Pair<String,String>>
} | proyectoDog/app/src/main/java/com/john/proyectodog/data/service/DogServiceInterface.kt | 414219669 |
package com.john.proyectodog.data.service
import com.john.proyectodog.data.dataSorce.Dogs
class DogService : DogServiceInterface {
companion object {
val service: DogService by lazy{ //lazy delega a un primer acceso
DogService() //Me creo sólo este objeto una vez.
}
}
//Método que accede a la BBDD y devuelve todos los datos
override fun getDogs(): List<Pair<String, String>> {
return Dogs.dogs
}
override fun getBreedDogs(breed: String): List<Pair<String, String>> {
val newDogs = Dogs.dogs.filter {
it.first == breed
}
return newDogs
}
} | proyectoDog/app/src/main/java/com/john/proyectodog/data/service/DogService.kt | 2585414507 |
package com.john.proyectodog.domain.userCase
import com.john.proyectodog.data.models.Dog
import com.john.proyectodog.data.models.DogRepositoryDao
class GetDogsBreedUseCase (private val breed: String){
operator fun invoke() : List<Dog>{
return DogRepositoryDao.myDogRepositoryDao.getBreedDogs(breed)
}
} | proyectoDog/app/src/main/java/com/john/proyectodog/domain/userCase/GetDogsBreedUseCase.kt | 1897688754 |
package com.john.proyectodog.domain.userCase
import com.john.proyectodog.data.models.Dog
import com.john.proyectodog.data.models.DogRepositoryDao
class GetDogsUseCase {
operator fun invoke(): List<Dog>?{
return DogRepositoryDao.myDogRepositoryDao.getDogs()
}
} | proyectoDog/app/src/main/java/com/john/proyectodog/domain/userCase/GetDogsUseCase.kt | 2192441666 |
package com.example.screenshotandshare
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.screenshotandshare", appContext.packageName)
}
} | ScreenShotAndShare/app/src/androidTest/java/com/example/screenshotandshare/ExampleInstrumentedTest.kt | 1325275286 |
package com.example.screenshotandshare
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)
}
} | ScreenShotAndShare/app/src/test/java/com/example/screenshotandshare/ExampleUnitTest.kt | 1544890225 |
package com.example.screenshotandshare.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) | ScreenShotAndShare/app/src/main/java/com/example/screenshotandshare/ui/theme/Color.kt | 502064046 |
package com.example.screenshotandshare.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 ScreenShotAndShareTheme(
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
)
} | ScreenShotAndShare/app/src/main/java/com/example/screenshotandshare/ui/theme/Theme.kt | 532626221 |
package com.example.screenshotandshare.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
)
*/
) | ScreenShotAndShare/app/src/main/java/com/example/screenshotandshare/ui/theme/Type.kt | 1324599872 |
package com.example.screenshotandshare.screenshot
import android.app.Activity
import android.graphics.Bitmap
import android.graphics.Canvas
import android.os.Build
import android.os.Handler
import android.os.Looper
import android.view.PixelCopy
import android.view.View
import androidx.compose.ui.geometry.Rect
import androidx.compose.ui.graphics.toAndroidRect
fun View.screenshot(
bounds: Rect,
): ImageResult {
try {
val bitmap = Bitmap.createBitmap(
bounds.height.toInt(),
bounds.width.toInt(),
Bitmap.Config.ARGB_8888
)
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
// Above Android O not using PixelCopy throws exception
// https://stackoverflow.com/questions/58314397/java-lang-illegalstateexception-software-rendering-doesnt-support-hardware-bit
PixelCopy.request(
(this.context as Activity).window,
android.graphics.Rect(
bounds.left.toInt(),
bounds.top.toInt(),
bounds.right.toInt(),
bounds.bottom.toInt()
),
bitmap,
{},
Handler(Looper.getMainLooper())
)
}else{
val canvas = Canvas(bitmap)
.apply {
translate(-bounds.left, -bounds.top)
}
this.draw(canvas)
canvas.setBitmap(null)
}
return ImageResult.Success(bitmap)
} catch (exception: Exception) {
return ImageResult.Error(exception)
}
}
fun View.screenshot(
bounds: Rect,
bitmapCallback: (ImageResult) -> Unit
) {
try {
val bitmap = Bitmap.createBitmap(
bounds.width.toInt(),
bounds.height.toInt(),
Bitmap.Config.ARGB_8888,
)
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
// Above Android O not using PixelCopy throws exception
// https://stackoverflow.com/questions/58314397/java-lang-illegalstateexception-software-rendering-doesnt-support-hardware-bit
PixelCopy.request(
(this.context as Activity).window,
bounds.toAndroidRect(),
bitmap,
{
when (it) {
PixelCopy.SUCCESS -> {
bitmapCallback.invoke(ImageResult.Success(bitmap))
}
PixelCopy.ERROR_DESTINATION_INVALID -> {
bitmapCallback.invoke(
ImageResult.Error(
Exception(
"The destination isn't a valid copy target. " +
"If the destination is a bitmap this can occur " +
"if the bitmap is too large for the hardware to " +
"copy to. " +
"It can also occur if the destination " +
"has been destroyed"
)
)
)
}
PixelCopy.ERROR_SOURCE_INVALID -> {
bitmapCallback.invoke(
ImageResult.Error(
Exception(
"It is not possible to copy from the source. " +
"This can happen if the source is " +
"hardware-protected or destroyed."
)
)
)
}
PixelCopy.ERROR_TIMEOUT -> {
bitmapCallback.invoke(
ImageResult.Error(
Exception(
"A timeout occurred while trying to acquire a buffer " +
"from the source to copy from."
)
)
)
}
PixelCopy.ERROR_SOURCE_NO_DATA -> {
bitmapCallback.invoke(
ImageResult.Error(
Exception(
"The source has nothing to copy from. " +
"When the source is a Surface this means that " +
"no buffers have been queued yet. " +
"Wait for the source to produce " +
"a frame and try again."
)
)
)
}
else -> {
bitmapCallback.invoke(
ImageResult.Error(
Exception(
"The pixel copy request failed with an unknown error."
)
)
)
}
}
},
Handler(Looper.getMainLooper())
)
} else {
val canvas = Canvas(bitmap)
.apply {
translate(-bounds.left, -bounds.top)
}
this.draw(canvas)
canvas.setBitmap(null)
bitmapCallback.invoke(ImageResult.Success(bitmap))
}
} catch (e: Exception) {
bitmapCallback.invoke(ImageResult.Error(e))
}
}
| ScreenShotAndShare/app/src/main/java/com/example/screenshotandshare/screenshot/ScreenshotExtension.kt | 3508572788 |
package com.example.screenshotandshare.screenshot
import android.graphics.Bitmap
sealed class ImageResult {
//every class and object extends the ImageResult class
object Initial : ImageResult()
data class Error(val exception: Exception) : ImageResult()
data class Success(val bitmapData: Bitmap) :ImageResult()
} | ScreenShotAndShare/app/src/main/java/com/example/screenshotandshare/screenshot/ImageResult.kt | 918264697 |
package com.example.screenshotandshare.screenshot
import android.graphics.Bitmap
import android.os.Build
import android.view.View
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import androidx.compose.ui.geometry.Rect
import androidx.compose.ui.layout.boundsInRoot
import androidx.compose.ui.layout.boundsInWindow
import androidx.compose.ui.layout.onGloballyPositioned
import androidx.compose.ui.platform.LocalView
@Composable
fun ScreenShotBox(
modifier: Modifier = Modifier,
capture:MutableState<Boolean>,
capturedBitmap:(Bitmap?)->Unit,
content: @Composable () -> Unit
){
val view: View = LocalView.current
var composableBounds = remember {
mutableStateOf<Rect?>(null)
}
DisposableEffect(key1 = capture.value ){
if(capture.value){
composableBounds.value?.let{ bounds ->
if(bounds.width == 0f || bounds.height == 0f)return@let
view.screenshot(bounds){ imageResult: ImageResult ->
if (imageResult is ImageResult.Success) {
capturedBitmap(imageResult.bitmapData)
}
}
}
}
onDispose {
composableBounds.value?.let{ bounds ->
if(bounds.width == 0f || bounds.height == 0f)return@let
view.screenshot(bounds){ imageResult: ImageResult ->
if (imageResult is ImageResult.Success) {
if(!imageResult.bitmapData.isRecycled){
imageResult.bitmapData.recycle()
}
}
}
}
}
}
Box(modifier = modifier.fillMaxSize()
.onGloballyPositioned {
composableBounds.value = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
it.boundsInWindow()
} else {
it.boundsInRoot()
}
}
) {
content()
}
} | ScreenShotAndShare/app/src/main/java/com/example/screenshotandshare/screenshot/ScreenshotBox.kt | 3761234375 |
package com.example.screenshotandshare
import android.content.ContentValues
import android.content.Context
import android.content.Intent
import android.graphics.Bitmap
import android.os.Bundle
import android.provider.MediaStore
import android.widget.Toast
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.material.MaterialTheme
import androidx.compose.material.Text
import androidx.compose.material.TextField
import androidx.compose.material3.FilledTonalButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.unit.dp
import androidx.core.content.ContextCompat
import com.example.screenshotandshare.screenshot.ImageResult
import com.example.screenshotandshare.screenshot.ScreenShotBox
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
MyApp()
}
}
@Composable
fun MyApp() {
var text by remember { mutableStateOf("Hello, World!") }
val capture = remember { mutableStateOf(false) }
val captureBitmap = remember { mutableStateOf<Bitmap?>(null) }
Column(
modifier = Modifier
.fillMaxSize()
.padding(16.dp)
)
{
ScreenShotBox(capture = capture, capturedBitmap = {
captureBitmap.value = it
}) {
TextField(
value = text,
onValueChange = { newText -> text = newText },
label = { Text("Enter text") },
modifier = Modifier
.fillMaxWidth()
.padding(bottom = 16.dp)
)
// Clickable composable to take a screenshot and share
Box(
modifier = Modifier
.fillMaxWidth()
.height(48.dp)
.clip(MaterialTheme.shapes.medium)
.background(MaterialTheme.colors.primary)
.clickable {
capture.value = true
},
contentAlignment = Alignment.Center
) {
Text(
text = "Take Screenshot and Share",
color = Color.White
)
}
}
}
if(capture.value){
ImageAlertDialog(bitmap = captureBitmap.value) {
capture.value = false
}
}
}
// Function to share the captured screenshot
private fun shareScreenshot(bitmap: Bitmap, context: Context) {
val imageUri = context.contentResolver.insert(
MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
ContentValues()
) ?: return
context.contentResolver.openOutputStream(imageUri)?.use { outputStream ->
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, outputStream)
}
val shareIntent = Intent(Intent.ACTION_SEND).apply {
type = "image/jpeg"
putExtra(Intent.EXTRA_STREAM, imageUri)
}
ContextCompat.startActivity(
context,
Intent.createChooser(shareIntent, "Share screenshot"),
null
)
}
}
@Composable
private fun ImageAlertDialog(bitmap:Bitmap?, onDismiss: () -> Unit) {
androidx.compose.material.AlertDialog(
onDismissRequest = onDismiss,
confirmButton = {
FilledTonalButton(onClick = { onDismiss() }) {
Text(text = "Confirm")
}
},
dismissButton = {
FilledTonalButton(onClick = { onDismiss() }) {
Text(text = "Dismiss")
}
},
text = {
if(bitmap!= null) {
Image(
bitmap = bitmap.asImageBitmap(),
contentDescription = null
)
}else{
Text(text = "Error in capturing")
}
})
}
| ScreenShotAndShare/app/src/main/java/com/example/screenshotandshare/MainActivity.kt | 3285779114 |
package miu.edu.localizingdate
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("miu.edu.localizingdate", appContext.packageName)
}
} | bonus-trick/app/src/androidTest/java/miu/edu/localizingdate/ExampleInstrumentedTest.kt | 745333722 |
package miu.edu.localizingdate
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)
}
} | bonus-trick/app/src/test/java/miu/edu/localizingdate/ExampleUnitTest.kt | 1995182601 |
package miu.edu.localizingdate
import android.content.Context
import android.content.res.Configuration
import android.os.Build
import android.os.Bundle
import androidx.annotation.RequiresApi
import androidx.annotation.StringRes
import androidx.appcompat.app.AppCompatActivity
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.async
import kotlinx.coroutines.launch
import miu.edu.localizingdate.databinding.ActivityMainBinding
import org.json.JSONObject
import java.io.BufferedReader
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.text.SimpleDateFormat
import java.time.LocalDateTime
import java.time.ZoneId
import java.util.Locale
class MainActivity : AppCompatActivity() {
private lateinit var binding: ActivityMainBinding
@RequiresApi(Build.VERSION_CODES.O)
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
GlobalScope.launch(Dispatchers.Main) {
val sunriseDeferred = async(Dispatchers.IO) { fetchTime("sunrise") }
val sunsetDeferred = async(Dispatchers.IO) { fetchTime("sunset") }
val sunriseTime = sunriseDeferred.await()
val sunsetTime = sunsetDeferred.await()
if (sunriseTime != null && sunsetTime != null) {
val localizedSunrise = getLocalizedTime(sunriseTime, this@MainActivity)
val localizedSunset = getLocalizedTime(sunsetTime, this@MainActivity)
binding.textviewSunrise.text =
"${getString(Locale.SIMPLIFIED_CHINESE, R.string.SunriseTime)} $localizedSunrise"
binding.textviewSunset.text =
"${getString(Locale.SIMPLIFIED_CHINESE, R.string.SunriseTime)} $localizedSunset"
}
}
}
private fun Context.getString(locale: Locale, @StringRes resId: Int, vararg formatArgs: Any): String {
var conf: Configuration = resources.configuration
conf = Configuration(conf)
conf.setLocale(locale)
val localizedContext = createConfigurationContext(conf)
return localizedContext.resources.getString(resId, *formatArgs)
}
@RequiresApi(Build.VERSION_CODES.O)
private fun getLocalizedTime(time: LocalDateTime, context: Context): String {
val userPreferredLanguage = Locale.SIMPLIFIED_CHINESE.language
val sdf = SimpleDateFormat("hh:mm a", Locale(userPreferredLanguage))
return sdf.format(
time.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli()
)
}
@RequiresApi(Build.VERSION_CODES.O)
private suspend fun fetchTime(type: String): LocalDateTime? {
return try {
val apiUrl =
URL("https://api.sunrise-sunset.org/json?lat=37.7749&lng=-122.4194&formatted=0")
val urlConnection: HttpURLConnection = apiUrl.openConnection() as HttpURLConnection
try {
val reader = BufferedReader(InputStreamReader(urlConnection.inputStream))
val response = StringBuilder()
var line: String?
while (reader.readLine().also { line = it } != null) {
response.append(line)
}
val jsonResponse = JSONObject(response.toString())
val timeUTC = jsonResponse.getJSONObject("results").getString(type)
val formatter = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssX", Locale.getDefault())
val dateTime = formatter.parse(timeUTC)
LocalDateTime.ofInstant(dateTime.toInstant(), ZoneId.systemDefault())
} finally {
urlConnection.disconnect()
}
} catch (e: Exception) {
e.printStackTrace()
null
}
}
} | bonus-trick/app/src/main/java/miu/edu/localizingdate/MainActivity.kt | 3915972513 |
package chan.spring.demo
import org.junit.jupiter.api.Test
import org.springframework.boot.test.context.SpringBootTest
@SpringBootTest
class DemoApplicationTests {
@Test
fun contextLoads() {
}
}
| chan-spring/src/test/kotlin/chan/spring/demo/DemoApplicationTests.kt | 3723174193 |
package chan.spring.demo.member.service.command
import chan.spring.demo.exception.exception.JwtCustomException
import chan.spring.demo.exception.exception.MemberException
import chan.spring.demo.jwt.service.JwtTokenService
import chan.spring.demo.member.domain.Role
import chan.spring.demo.member.dto.request.*
import chan.spring.demo.member.service.query.MemberQueryService
import jakarta.persistence.EntityManager
import org.assertj.core.api.Assertions
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.transaction.annotation.Transactional
@SpringBootTest
class MemberCommandServiceTest @Autowired constructor(
private val entityManager: EntityManager,
private val memberCommandService: MemberCommandService,
private val memberQueryService: MemberQueryService,
private val jwtTokenService: JwtTokenService
) {
private fun flushAndClear() {
entityManager.flush()
entityManager.clear()
}
@Test
@Transactional
fun signup() {
// given
val email = "[email protected]"
val pw = "1234"
val request = SignupDto(email, pw)
// when
memberCommandService.signup(request)
flushAndClear()
// then
val loginDto = LoginDto(email, pw)
val jwtTokenInfo = memberCommandService.login(loginDto)
Assertions.assertThat(memberQueryService.getMemberById(jwtTokenInfo.id).auth)
.isEqualTo(Role.MEMBER)
}
@Test
@Transactional
fun reissueJwtToken() {
// given
val email = "[email protected]"
val pw = "1234"
val request = SignupDto(email, pw)
memberCommandService.signup(request)
flushAndClear()
val loginDto = LoginDto(email, pw)
val jwtTokenInfo = memberCommandService.login(loginDto)
// when
val reissueJwtToken = memberCommandService.reissueJwtToken(jwtTokenInfo.id, jwtTokenInfo.refreshToken)
flushAndClear()
// then
val jwtTokenInfo2 = memberCommandService.login(loginDto)
Assertions.assertThat(reissueJwtToken.refreshToken.equals(jwtTokenInfo2.refreshToken)).isTrue()
}
@Test
@Transactional
fun updatePassword() {
// given
val email = "[email protected]"
val pw = "1234"
val request = SignupDto(email, pw)
memberCommandService.signup(request)
flushAndClear()
val loginDto = LoginDto(email, pw)
val id = memberCommandService.login(loginDto).id
//when
val newPw = "1111"
val updatePasswordDto = UpdatePasswordDto(newPw, pw)
memberCommandService.updatePassword(updatePasswordDto, id)
flushAndClear()
//then
Assertions.assertThat(memberCommandService.login(LoginDto(email, newPw)).id).isEqualTo(id)
}
@Test
@Transactional
fun recoveryMember() {
// given
val email = "[email protected]"
val pw = "1234"
val request = SignupDto(email, pw)
memberCommandService.signup(request)
flushAndClear()
val loginDto = LoginDto(email, pw)
val id = memberCommandService.login(loginDto).id
val withdrawDto = WithdrawDto(pw)
memberCommandService.withdraw(withdrawDto, id)
flushAndClear()
// when
memberCommandService.recoveryMember(RecoveryDto(email, pw))
flushAndClear()
// then
Assertions.assertThat(memberQueryService.getMemberById(id)).isNotNull
}
@Test
@Transactional
fun withdraw() {
// given
val email = "[email protected]"
val pw = "1234"
val request = SignupDto(email, pw)
memberCommandService.signup(request)
flushAndClear()
val loginDto = LoginDto(email, pw)
val id = memberCommandService.login(loginDto).id
// when
val withdrawDto = WithdrawDto(pw)
memberCommandService.withdraw(withdrawDto, id)
flushAndClear()
// then
Assertions.assertThatThrownBy { jwtTokenService.getRefreshToken(id) }
.isInstanceOf(JwtCustomException::class.java)
Assertions.assertThatThrownBy { (memberQueryService.getMemberById(id)) }
.isInstanceOf(MemberException::class.java)
}
}
| chan-spring/src/test/kotlin/chan/spring/demo/member/service/command/MemberCommandServiceTest.kt | 1485311469 |
package chan.spring.demo.member.domain
import chan.spring.demo.globalUtil.isMatchPassword
import org.assertj.core.api.Assertions
import org.junit.jupiter.api.Test
class MemberTest {
@Test
fun isAdmin() {
//given
val email = "[email protected]"
val pw = "1234"
//when
val admin = Member.create(email, pw)
//then
Assertions.assertThat(admin.isAdmin()).isTrue()
}
@Test
fun updatePw() {
// given
val email = "[email protected]"
val pw = "1234"
val member = Member.create(email, pw)
// when
val updatedPw = "1111"
member.updatePw(updatedPw, pw)
// then
Assertions.assertThat(isMatchPassword(updatedPw, member.pw)).isTrue()
}
@Test
fun withdraw() {
// given
val email = "[email protected]"
val pw = "1234"
val member = Member.create(email, pw)
// when
member.withdraw()
//then
Assertions.assertThat(member.auth).isEqualTo(Role.WITHDRAW)
}
@Test
fun recovery() {
// given
val email = "[email protected]"
val pw = "1234"
val member = Member.create(email, pw)
member.withdraw()
// when
member.recovery(pw)
//then
Assertions.assertThat(member.auth).isEqualTo(Role.MEMBER)
}
}
| chan-spring/src/test/kotlin/chan/spring/demo/member/domain/MemberTest.kt | 829507047 |
package chan.spring.demo.jwt.dto
import java.util.UUID
data class JwtTokenInfo(
val id: UUID,
val accessToken: String,
val refreshToken: String
) {
companion object {
fun create(
id: UUID,
accessToken: String,
refreshToken: String
) = JwtTokenInfo(id, accessToken, refreshToken)
}
}
| chan-spring/src/main/kotlin/chan/spring/demo/jwt/dto/JwtTokenInfo.kt | 1864836911 |
package chan.spring.demo.jwt.cache
object JwtCache {
const val REFRESH_TOKEN_NAME = "RefreshToken::"
}
| chan-spring/src/main/kotlin/chan/spring/demo/jwt/cache/JwtCache.kt | 915122385 |
package chan.spring.demo.jwt.filterLogic
import chan.spring.demo.exception.exception.JwtCustomException
import chan.spring.demo.exception.message.JwtExceptionMessage
import chan.spring.demo.jwt.constant.JwtConstant
import chan.spring.demo.jwt.dto.JwtTokenInfo
import chan.spring.demo.logger
import chan.spring.demo.member.domain.Role
import io.jsonwebtoken.*
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken
import org.springframework.security.core.Authentication
import org.springframework.security.core.GrantedAuthority
import org.springframework.security.core.authority.SimpleGrantedAuthority
import org.springframework.security.core.userdetails.User
import org.springframework.security.core.userdetails.UserDetails
import org.springframework.stereotype.Component
import java.util.*
@Component
class JwtTokenProvider {
private val key = Jwts.SIG.HS256.key().build()
fun generateToken(authentication: Authentication): JwtTokenInfo {
val id = UUID.fromString(authentication.name)
return JwtTokenInfo.create(id, generateAccessToken(authentication), generateRefreshToken())
}
private fun generateAccessToken(authentication: Authentication): String {
return Jwts.builder()
.subject(authentication.name)
.claim(JwtConstant.CLAIM_NAME, authentication.authorities.iterator().next().authority)
.expiration(Date(Date().time + JwtConstant.TWO_HOUR_MS))
.signWith(key)
.compact()
}
fun reissueToken(
id: UUID,
role: Role
): JwtTokenInfo {
return JwtTokenInfo.create(id, generateAccessTokenWhenReissue(id, role), generateRefreshToken())
}
private fun generateAccessTokenWhenReissue(
id: UUID,
role: Role
): String {
return Jwts.builder()
.subject(id.toString())
.claim(JwtConstant.CLAIM_NAME, role.auth)
.expiration(Date(Date().time + JwtConstant.TWO_HOUR_MS))
.signWith(key)
.compact()
}
private fun generateRefreshToken(): String {
return Jwts.builder()
.expiration(Date(Date().time + JwtConstant.THIRTY_DAY_MS))
.signWith(key)
.compact()
}
fun getAuthentication(accessToken: String): Authentication {
val claims = parseClaims(accessToken)
val authorities: Collection<GrantedAuthority> =
claims[JwtConstant.CLAIM_NAME].toString()
.split(JwtConstant.AUTH_DELIMITER)
.map { role: String? -> SimpleGrantedAuthority(role) }
val principal: UserDetails = User(claims.subject, JwtConstant.EMPTY_PW, authorities)
return UsernamePasswordAuthenticationToken(principal, JwtConstant.CREDENTIAL, authorities)
}
private fun parseClaims(accessToken: String): Claims {
return try {
Jwts.parser()
.verifyWith(key)
.build()
.parseSignedClaims(accessToken).payload
} catch (e: ExpiredJwtException) {
e.claims
}
}
fun validateToken(token: String) {
if (token.isBlank()) {
throw JwtCustomException(JwtExceptionMessage.TOKEN_IS_NULL)
}
try {
Jwts.parser().verifyWith(key).build().parseSignedClaims(token)
} catch (e: MalformedJwtException) {
logger().info(JwtExceptionMessage.INVALID_TOKEN.message)
throw JwtCustomException(JwtExceptionMessage.EMPTY_CLAIMS)
} catch (e: ExpiredJwtException) {
logger().info(JwtExceptionMessage.EXPIRED_JWT_TOKEN.message)
throw JwtCustomException(JwtExceptionMessage.EXPIRED_JWT_TOKEN)
} catch (e: UnsupportedJwtException) {
logger().info(JwtExceptionMessage.UNSUPPORTED_TOKEN.message)
throw JwtCustomException(JwtExceptionMessage.UNSUPPORTED_TOKEN)
} catch (e: SecurityException) {
logger().info(JwtExceptionMessage.INVALID_TOKEN.message)
throw JwtCustomException(JwtExceptionMessage.INVALID_TOKEN)
}
}
}
| chan-spring/src/main/kotlin/chan/spring/demo/jwt/filterLogic/JwtTokenProvider.kt | 556043768 |
package chan.spring.demo.jwt.filterLogic
import com.fasterxml.jackson.databind.ObjectMapper
import chan.spring.demo.exception.exception.JwtCustomException
import chan.spring.demo.jwt.constant.JwtConstant
import chan.spring.demo.logger
import jakarta.servlet.FilterChain
import jakarta.servlet.ServletRequest
import jakarta.servlet.ServletResponse
import jakarta.servlet.http.HttpServletRequest
import jakarta.servlet.http.HttpServletResponse
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.http.MediaType
import org.springframework.security.core.context.SecurityContextHolder
import org.springframework.web.filter.GenericFilterBean
class JwtAuthenticationFilter
@Autowired
constructor(
private val jwtTokenProvider: JwtTokenProvider
) : GenericFilterBean() {
override fun doFilter(
request: ServletRequest,
response: ServletResponse,
chain: FilterChain
) {
try {
resolveToken(request as HttpServletRequest)?.let {
jwtTokenProvider.validateToken(it)
val authentication = jwtTokenProvider.getAuthentication(it)
SecurityContextHolder.getContext().authentication = authentication
}
chain.doFilter(request, response)
} catch (e: JwtCustomException) {
val httpResponse = response as HttpServletResponse
httpResponse.status = e.jwtExceptionMessage.status
httpResponse.contentType = MediaType.APPLICATION_JSON_VALUE
val errorResponse = e.message
logger().warn(e.message)
val objectMapper = ObjectMapper()
httpResponse.writer.write(objectMapper.writeValueAsString(errorResponse))
}
}
private fun resolveToken(request: HttpServletRequest): String? {
return request.getHeader(JwtConstant.HEADER)
?.takeIf { it.startsWith(JwtConstant.BEARER_TOKEN) }
?.substring(JwtConstant.TOKEN_SUB_INDEX)
}
}
| chan-spring/src/main/kotlin/chan/spring/demo/jwt/filterLogic/JwtAuthenticationFilter.kt | 2369479166 |
package chan.spring.demo.jwt.constant
object JwtConstant {
const val HEADER = "Authorization"
const val CLAIM_NAME = "auth"
const val AUTH_DELIMITER = ","
const val EMPTY_PW = ""
const val CREDENTIAL = ""
const val TWO_HOUR_MS = 7200000
const val THIRTY_DAY_MS = 2592000000
const val BEARER_TOKEN = "Bearer"
const val TOKEN_SUB_INDEX = 7
}
| chan-spring/src/main/kotlin/chan/spring/demo/jwt/constant/JwtConstant.kt | 2201423729 |
package chan.spring.demo.jwt.log
object JwtServiceLog {
const val NOT_EXIST_REFRESH_TOKEN = "Refresh 토큰이 존재하지 않습니다. 회원 ID : "
const val UN_MATCH_REFRESH_TOKEN = "Refresh 토큰이 일치하지 않습니다. 회원 ID : "
}
| chan-spring/src/main/kotlin/chan/spring/demo/jwt/log/JwtServiceLog.kt | 3685150778 |
package chan.spring.demo.jwt.service
import chan.spring.demo.exception.exception.JwtCustomException
import chan.spring.demo.exception.message.JwtExceptionMessage
import chan.spring.demo.globalConfig.redis.RedisKeyValueTimeOut
import chan.spring.demo.globalConfig.redis.RedisRepository
import chan.spring.demo.jwt.cache.JwtCache
import chan.spring.demo.jwt.domain.RefreshToken
import chan.spring.demo.jwt.dto.JwtTokenInfo
import chan.spring.demo.jwt.filterLogic.JwtTokenProvider
import chan.spring.demo.jwt.log.JwtServiceLog
import chan.spring.demo.logger
import chan.spring.demo.member.domain.Role
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.stereotype.Service
import java.util.UUID
import java.util.concurrent.TimeUnit
@Service
class JwtTokenService
@Autowired
constructor(
private val redisRepository: RedisRepository,
private val jwtTokenProvider: JwtTokenProvider
) {
fun getRefreshToken(id: UUID): RefreshToken =
redisRepository.getByKey(JwtCache.REFRESH_TOKEN_NAME + id, RefreshToken::class.java)
?: throw JwtCustomException(JwtExceptionMessage.NOT_EXIST_REFRESH_TOKEN).apply {
logger().warn(JwtServiceLog.NOT_EXIST_REFRESH_TOKEN + id)
}
fun createRefreshToken(
id: UUID,
refreshToken: String
) {
redisRepository.save(
JwtCache.REFRESH_TOKEN_NAME + id,
RefreshToken.create(id, refreshToken),
RedisKeyValueTimeOut(15, TimeUnit.DAYS)
)
}
fun reissueToken(
id: UUID,
refreshToken: String,
role: Role
): JwtTokenInfo {
jwtTokenProvider.validateToken(refreshToken)
val key = JwtCache.REFRESH_TOKEN_NAME + id
redisRepository.getByKey(key, RefreshToken::class.java)
?.let {
check(it.refreshToken.equals(refreshToken)) {
logger().warn(JwtServiceLog.UN_MATCH_REFRESH_TOKEN + id)
throw JwtCustomException(JwtExceptionMessage.UN_MATCH_REFRESH_TOKEN)
}
val reissueToken = jwtTokenProvider.reissueToken(id, role)
it.reissueRefreshToken(reissueToken.refreshToken)
redisRepository.save(key, it)
return reissueToken
}
?: throw JwtCustomException(JwtExceptionMessage.NOT_EXIST_REFRESH_TOKEN).apply {
logger().warn(JwtServiceLog.NOT_EXIST_REFRESH_TOKEN + id)
}
}
fun removeRefreshToken(id: UUID) {
redisRepository.delete(JwtCache.REFRESH_TOKEN_NAME + id)
}
}
| chan-spring/src/main/kotlin/chan/spring/demo/jwt/service/JwtTokenService.kt | 2406447153 |
package chan.spring.demo.jwt.domain
import java.util.UUID
class RefreshToken private constructor(
val id: UUID,
var refreshToken: String
) {
companion object {
fun create(
id: UUID,
refreshToken: String
) = RefreshToken(id, refreshToken)
}
fun reissueRefreshToken(reissuedRefreshToken: String) {
this.refreshToken = reissuedRefreshToken
}
}
| chan-spring/src/main/kotlin/chan/spring/demo/jwt/domain/RefreshToken.kt | 3189397998 |
package chan.spring.demo.converter
import chan.spring.demo.member.domain.Role
import jakarta.persistence.AttributeConverter
import jakarta.persistence.Converter
@Converter
class RoleConverter : AttributeConverter<Role, String> {
override fun convertToDatabaseColumn(attribute: Role) = attribute.name
override fun convertToEntityAttribute(dbData: String) = Role.valueOf(dbData)
}
| chan-spring/src/main/kotlin/chan/spring/demo/converter/RoleConverter.kt | 458002860 |
package chan.spring.demo.globalConfig.security
import chan.spring.demo.jwt.filterLogic.JwtAuthenticationFilter
import chan.spring.demo.jwt.filterLogic.JwtTokenProvider
import chan.spring.demo.member.controller.constant.MemberUrl
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.security.config.annotation.web.builders.HttpSecurity
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity
import org.springframework.security.config.http.SessionCreationPolicy
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder
import org.springframework.security.crypto.password.PasswordEncoder
import org.springframework.security.web.SecurityFilterChain
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter
@Configuration
@EnableWebSecurity
class SecurityConfig
@Autowired
constructor(
private val jwtTokenProvider: JwtTokenProvider
) {
@Bean
fun passwordEncoder(): PasswordEncoder = BCryptPasswordEncoder()
@Bean
fun filterChain(http: HttpSecurity): SecurityFilterChain? {
http.csrf { obj -> obj.disable() }
http.requestCache { cache -> cache.disable() }
http.sessionManagement { session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS) }
http.authorizeHttpRequests { path ->
path.requestMatchers(
MemberUrl.SIGNUP,
MemberUrl.LOGIN,
MemberUrl.JWT_TOKEN_REISSUE,
MemberUrl.RECOVERY_MEMBER
).permitAll().anyRequest().authenticated()
}
http.addFilterBefore(
JwtAuthenticationFilter(jwtTokenProvider),
UsernamePasswordAuthenticationFilter::class.java
)
http.exceptionHandling { exception -> exception.accessDeniedPage(MemberUrl.PROHIBITION) }
return http.build()
}
}
| chan-spring/src/main/kotlin/chan/spring/demo/globalConfig/security/SecurityConfig.kt | 3632885209 |
package chan.spring.demo.globalConfig.redis
import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.databind.jsontype.BasicPolymorphicTypeValidator
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule
import com.fasterxml.jackson.module.kotlin.KotlinFeature
import com.fasterxml.jackson.module.kotlin.KotlinModule
import chan.spring.demo.globalConfig.redis.constant.RedisConstant
import io.lettuce.core.RedisURI
import org.springframework.beans.factory.annotation.Value
import org.springframework.cache.CacheManager
import org.springframework.cache.annotation.EnableCaching
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.data.redis.cache.RedisCacheConfiguration
import org.springframework.data.redis.cache.RedisCacheManager
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory
import org.springframework.data.redis.core.RedisTemplate
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer
import org.springframework.data.redis.serializer.RedisSerializationContext
import org.springframework.data.redis.serializer.StringRedisSerializer
import java.time.Duration
@Configuration
@EnableCaching
class RedisConfig(
@Value(RedisConstant.REDIS_URL)
val url: String
) {
@Bean
fun lettuceConnectionFactory(): LettuceConnectionFactory {
val redisURI: RedisURI = RedisURI.create(url)
val configuration = LettuceConnectionFactory.createRedisConfiguration(redisURI)
return LettuceConnectionFactory(configuration)
}
@Bean
fun cacheManager(): CacheManager {
val objectMapper =
ObjectMapper()
.registerModules(
JavaTimeModule(),
KotlinModule.Builder()
.withReflectionCacheSize(RedisConstant.REFLECTION_CACHE_SIZE)
.configure(KotlinFeature.NullToEmptyCollection, false)
.configure(KotlinFeature.NullToEmptyMap, false)
.configure(KotlinFeature.NullIsSameAsDefault, false)
.configure(KotlinFeature.SingletonSupport, false)
.configure(KotlinFeature.StrictNullChecks, false)
.build()
)
.activateDefaultTyping(
BasicPolymorphicTypeValidator.builder()
.allowIfBaseType(Any::class.java).build(),
ObjectMapper.DefaultTyping.EVERYTHING
)
val configuration =
RedisCacheConfiguration.defaultCacheConfig()
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(StringRedisSerializer()))
.serializeValuesWith(
RedisSerializationContext.SerializationPair.fromSerializer(
GenericJackson2JsonRedisSerializer(objectMapper)
)
)
.entryTtl(Duration.ofMinutes(RedisConstant.TTL))
.disableCachingNullValues()
return RedisCacheManager.RedisCacheManagerBuilder
.fromConnectionFactory(lettuceConnectionFactory())
.cacheDefaults(configuration)
.build()
}
@Bean
fun redisTemplate(): RedisTemplate<String, Any> {
return RedisTemplate<String, Any>().apply {
this.connectionFactory = lettuceConnectionFactory()
this.keySerializer = StringRedisSerializer()
this.valueSerializer = StringRedisSerializer()
this.hashKeySerializer = StringRedisSerializer()
this.hashValueSerializer = StringRedisSerializer()
}
}
}
| chan-spring/src/main/kotlin/chan/spring/demo/globalConfig/redis/RedisConfig.kt | 1960949494 |
package chan.spring.demo.globalConfig.redis.constant
object RedisConstant {
const val REDIS_URL = "\${spring.redis.url}"
const val REFLECTION_CACHE_SIZE = 512
const val TTL: Long = 15
}
| chan-spring/src/main/kotlin/chan/spring/demo/globalConfig/redis/constant/RedisConstant.kt | 1302965249 |
package chan.spring.demo.globalConfig.redis
import com.fasterxml.jackson.databind.ObjectMapper
import org.springframework.data.redis.core.RedisTemplate
import org.springframework.stereotype.Component
import java.util.concurrent.TimeUnit
class RedisKeyValueTimeOut(
val time: Long,
val timeUnit: TimeUnit
)
@Component
class RedisRepository(
private val redisTemplate: RedisTemplate<String, Any>,
private val objectMapper: ObjectMapper
) {
fun save(
key: String,
value: Any,
timeOut: RedisKeyValueTimeOut? = null
) {
timeOut?.let {
redisTemplate.opsForValue().set(
key,
objectMapper.writeValueAsString(value),
timeOut.time,
timeOut.timeUnit
)
} ?: run {
redisTemplate.opsForValue().set(
key,
objectMapper.writeValueAsString(value)
)
}
}
fun delete(key: String) {
redisTemplate.delete(key)
}
fun <T> getByKey(
key: String,
clazz: Class<T>
): T? {
val result = redisTemplate.opsForValue()[key].toString()
return if (result.isEmpty()) {
null
} else {
return objectMapper.readValue(result, clazz)
}
}
operator fun <T> get(
key: String,
clazz: Class<T>
): T? {
return getByKey(key = key, clazz = clazz)
}
operator fun set(
key: String,
value: Any
) {
return save(key = key, value = value)
}
}
| chan-spring/src/main/kotlin/chan/spring/demo/globalConfig/redis/RedisRepository.kt | 2862233390 |
package chan.spring.demo.globalConfig.querydsl
import com.querydsl.jpa.impl.JPAQueryFactory
import jakarta.persistence.EntityManager
import jakarta.persistence.PersistenceContext
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
@Configuration
class QueryDslConfig(
@PersistenceContext
val entityManager: EntityManager
) {
@Bean
fun jpaQueryFactory(): JPAQueryFactory = JPAQueryFactory(entityManager)
}
| chan-spring/src/main/kotlin/chan/spring/demo/globalConfig/querydsl/QueryDslConfig.kt | 1736868055 |
package chan.spring.demo
import org.slf4j.LoggerFactory
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
inline fun <reified T> T.logger() = LoggerFactory.getLogger(T::class.java)!!
@SpringBootApplication
class DemoApplication
fun main(args: Array<String>) {
runApplication<DemoApplication>(*args)
}
| chan-spring/src/main/kotlin/chan/spring/demo/DemoApplication.kt | 447530623 |
package chan.spring.demo.member.dto.response
import chan.spring.demo.member.domain.Role
import java.util.*
data class MemberInfo(
val id: UUID,
val auth: Role,
val email: String
)
| chan-spring/src/main/kotlin/chan/spring/demo/member/dto/response/MemberInfo.kt | 529624776 |
package chan.spring.demo.member.dto.request
import jakarta.validation.constraints.NotBlank
data class LoginDto(
@field:NotBlank(message = "이메일을 입력하세요.") val email: String?,
@field:NotBlank(message = "비밀번호를 입력하세요.") val pw: String?
)
| chan-spring/src/main/kotlin/chan/spring/demo/member/dto/request/LoginDto.kt | 3505864540 |
package chan.spring.demo.member.dto.request
import jakarta.validation.constraints.NotBlank
data class UpdatePasswordDto(
@field:NotBlank(message = "새 비밀번호를 입력하세요.") val newPassword: String?,
@field:NotBlank(message = "기존 비밀번호를 입력하세요.") val oldPassword: String?
)
| chan-spring/src/main/kotlin/chan/spring/demo/member/dto/request/UpdatePasswordDto.kt | 2528651212 |
package chan.spring.demo.member.dto.request
import jakarta.validation.constraints.NotBlank
data class SignupDto(
@field:NotBlank(message = "이메일을 입력하세요.") val email: String?,
@field:NotBlank(message = "비밀번호를 입력하세요.") val pw: String?
)
| chan-spring/src/main/kotlin/chan/spring/demo/member/dto/request/SignupDto.kt | 390465659 |
package chan.spring.demo.member.dto.request
import jakarta.validation.constraints.NotBlank
data class RecoveryDto(
@field:NotBlank(message = "이메일을 입력하세요.") val email: String?,
@field:NotBlank(message = "비밀번호를 입력하세요.") val pw: String?
)
| chan-spring/src/main/kotlin/chan/spring/demo/member/dto/request/RecoveryDto.kt | 3915503733 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.