2. 개발 경험

/**
 * Domain에 핵심 비즈니스 로직이 집중되므로 유지보수가 용이하고 상대적으로 가벼운 컨트롤러와 서비스
 * Service단에서 Transaction을 readOnly와 mutable로 분리
 * 자주 조회되는 데이터는 캐싱을 통해 조회 성능을 향상
 * QueryDSL을 사용한 자유로운 select 구성
**/

// MemberController

@Tag(name = "MemberController", description = "사용자 컨트롤러")
@RestController
@RequestMapping("/api/users")
class CommonInfoController(
        private val memberQueryService: MemberQueryService

) {
    @Operation(summary = "교수/교직원 검색")
    @GetMapping("/paged")
    fun searchMembers(@RequestParam("role", required = true) role: Role,
                      @RequestParam("campusCode", required = false) campusCode: String?,
                      @RequestParam("name", required = false) name: String?,
                      @ParameterObject pageable: Pageable
    ): ResponseEntity<Page<MemberOut>> {
        return ResponseEntity.ok(
                memberQueryService.searchMembers(
                        role,
                        campusCode,
                        name,
                        pageable)
        )
    }
}

// MemberQueryService

@Service
@Transactional(readOnly = true)
class CommonInfoQueryService(
        private val memberRepository: MemberRepository
) {
    @Cacheable(cacheNames = ["members"])
    fun searchMembers(role: Role,
                      campusCode: String?,
                      name: String?,
                      pageable: Pageable): Page<MemberOut> {
        return memberRepository.searchMembers(
                role,
                campusCode,
                name,
                pageable)
                .map { MemberOut.fromEntity(it) }
    }
}

// DTO

data class MemberOut(
        val oid: Long,
        val campusName: String?,
        val userId: String,
        val name: String,
        val email: String,
) {
    
    // companion object를 사용함으로서 DTO를 통한 데이터 In/Out에 비즈니스 로직을 담아 낼 수 있음
    companion object {

        fun fromEntity(e: Member): MemberOut {
            return MemberOut(
                    oid = e.oid!!,
                    campusName = e.campusName(),
                    userId = e.userId,
                    name = e.name(),
                    email = e.email(),
            )
        }
    }
}

// MemberRepositoryCustom

interface MemberRepositoryCustom {

    fun searchMembers(
            role: Role,
            campusCode: String?,
            name: String?,
            pageable: Pageable
    ): Page<Member>
    
}

// MemberRepositoryImpl

class MemberRepositoryImpl : QuerydslRepositorySupport(Member::class.java), MemberRepositoryCustom {

    private val qMember = QMember.member

    override fun searchMembers(
        role: Role,
        campusCode: String?,
        name: String?,
        pageable: Pageable
    ): Page<Member> {
        val result = from(qMember)
            .where(
                qMember.deleted.isFalse,
                qMember.role.eq(role.name),
                eqCampusCode(campusCode)
                        containsName (name)
            )
            .fetchAll()
        val pagedResult = querydsl!!.applyPagination(pageable, result).fetch() ?: emptyList()
        return PageableExecutionUtils.getPage(pagedResult, pageable) { result.fetchCount() }
    }

    private fun eqCampusCode(campusCode: String?) : BooleanExpression? {
        return if (campusCode.isNullOrBlank()) null
        else qMember.campusCode.eq(campusCode)
    }

    private fun containsName(name: String?): BooleanExpression? {
        return if (name == null) null
        else qMember.name.contains(name)
    }
}

/**
 * Server Side AWS S3 Bucket Upload / Download
 * **/

// FileRepository
interface FileRepository {

    fun uploadToS3(fileRequest: FileRequest): FileResponse

    fun getFileFromFileRepository(fileKey: String): FileWrapper
    
}

// FileRepositoryImpl

@Service
@Transactional
class S3FileRepositoryImpl(
        
        @Value("\${aws.s3.bucketName}")
        private val bucketName: String,

        @Value("\${aws.s3.URL}")
        private val s3URL: String,

        @Autowired
        private val amazonS3: AmazonS3
        
) : FileRepository {

    // trangerManager를 통한 업로드
    override fun uploadToS3(fileRequest: FileRequest): FileResponse {
        try {
            val request = createPutObjectRequest(fileRequest)
            val tm = createTransferManager()
            val upload = tm.upload(request)
            upload.waitForCompletion()
        } catch (e: Exception) {
            throw S3UploadException(
                    "FileRequest",
                    fileRequest.fileName
            )
        }
        return FileResponse(
                fileRequest.fileName, fileRequest.originalFileName, fileRequest.fileSize,
                fileRequest.fileDirPath, fileRequest.getFileKey())
    }

    // AWS S3 Bucket에 안정적으로 파일을 전송 할 수 있도록 TransferManager 호출
    private fun createTransferManager(): TransferManager {
        return TransferManagerBuilder
                .standard()
                .withS3Client(amazonS3)
                .withMultipartUploadThreshold((5 * 1024 * 1025).toLong())
                .build()
    }
    
    // AWS SDK를 사용해 Amazon S3 버킷에 객체 업로드
    private fun createPutObjectRequest(fileRequest: FileRequest): PutObjectRequest {
        return PutObjectRequest(
                bucketName, fileRequest.getFileKey(),
                fileRequest.file
        )
                .withCannedAcl(CannedAccessControlList.Private)
                .withMetadata(createObjectMetadata(fileRequest))
    }

    // Front에서 filekey를 받아 Repo에서 파일을 탐색 후 return
    override fun getFileFromFileRepository(fileKey: String): FileWrapper {
        var s3Object = try {
            amazonS3!!.getObject(
                    GetObjectRequest(
                            bucketName,
                            fileKey
                    )
            )
        } catch (e: AmazonS3Exception) {
            throw S3GetDataException("fileKey", fileKey)
        }
        return FileWrapper(
                s3Object!!.objectContent,
                createFileMeta(s3Object.objectMetadata)
        )
    }

    private fun createFileMeta(`object`: Any): FileMeta {
        var fileMeta: FileMeta? = null
        if (`object` is ObjectMetadata) {
            val metadata = `object`
            fileMeta = FileMeta(metadata.contentType, metadata.contentEncoding,
                    metadata.eTag,metadata.lastModified.toString() ,metadata.contentLength)
        }
        return fileMeta!!
    }
}

// MemberCommandService

@Service
@Transactional
class MemberCommandService(
        
        @Autowired
        private var resourceLoader: ResourceLoader,

        @Value("\${front.url}")
        private val frontUrl: String,

        private val mailService: MailService,

        private val jwtGenerator: JwtGenerator,
) {
    // 미리 정해진 HTML 템플릿에 Collection으로 내용 전달
    fun sendEmail(userId: String, email: String) {
        val dto =  MailDto(listOf(email), "비밀번호 찾기 안내 메일입니다. This is Your password.",
                "find-password.html", Map.of("url", getModifyPwdUrl(userId, email)) as kotlin.collections.Map<String, String>, resourceLoader)

        mailService.send(dto)
    }

    // 개인정보 노출방지를 위해 Hashcode 적용 한 Url로 사용자 화면을 이동시킴
    private fun getModifyPwdUrl(userId: String, email: String): String {
        val expireDate = LocalDateTime.now().plusMinutes(30).format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"))
        return frontUrl + "/user/modify-pwd/" + userId + "/" + expireDate + "/" + getHashcode(userId, email)
    }

    private fun getHashcode(userId: String, email: String): String? {
        // create Hashcode
    }
    
}

// SESMailService

class SESMailServiceImpl : MailService {

    @Autowired
    private val sesClient: AmazonSimpleEmailServiceAsync? = null

    @Value("\${aws.ses.sendMail}")

    // AWS 가이드에 따라 SES 메일 전송
    fun sendMail(mailDto: MailDto, isAsync: Boolean) {
        val emailRequest: SendEmailRequest = EmailRequestDto(mailDto) //ses전송 공통객체 만들기
        val mailList: List<String> = mailDto.to
        val listSize = mailList.size
        val MAIL_MAX_SIZE = 50 //ses는 한번에 50개씩 메일 전송 가능
        var firstMailIndex = 0
        var lastMailIndex = 0
        var maxSize = if (listSize < MAIL_MAX_SIZE) listSize else MAIL_MAX_SIZE
        while (lastMailIndex < listSize) {
            lastMailIndex = firstMailIndex + maxSize
            val addr: List<String> = ArrayList(mailList.subList(firstMailIndex, lastMailIndex))
            val destination = Destination()
            destination.setToAddresses(addr)
            emailRequest.withDestination(destination)
            if (isAsync) sesClient!!.sendEmailAsync(emailRequest, SesAsyncHandler())
            else sesClient!!.sendEmail(emailRequest)
            maxSize = if (listSize - lastMailIndex < MAIL_MAX_SIZE) listSize - lastMailIndex else MAIL_MAX_SIZE
            firstMailIndex = lastMailIndex
        }
    }

    fun EmailRequestDto(mailDto: MailDto): SendEmailRequest {
        return SendEmailRequest()
                .withSource(sendMail)
                .withMessage(newMessage(mailDto))
    }
}

@Operation(summary = "JDBCTepmlate - fecthOne")
@GetMapping("/jdbc-fetch-one")
fun fetchOneJdbcTemplate(
    @RequestParam param1: String
) : ResponseEntity<Nothing> {
    jdbcTemplateService.fetchOneJdbcTemplate(param1)
    return ResponseEntity.noContent().build()
}

@Operation(summary = "JDBCTepmlate - fecth")
@GetMapping("/jdbc-fetch")
fun fetchOneJdbcTemplate() : ResponseEntity<Nothing> {
    jdbcTemplateService.fetchJdbcTemplate()
    return ResponseEntity.noContent().build()
}

/**
 * JDBCTemplate Service Class
 *
 * JDBCTemplate를 이용해 다른 DB의 Connection 및 Datasource를 획득하고
 * 해당 DB에서 데이터를 CRUD 할 수 있다.
 *
 * 각 메서드마다 파라미터를 받을 수 있다.
 *
 * 반드시 try ~ catch 안에 작성해야 하며,
 * catch와  finally에서 항상 커넥션을 close해 주어야 한다.
 *
 * **/
@Service
@Transactional
class JdbcTemplateService (

    @Value("\${jdbcTemplateSource.url}")
    private val databaseUrl: String,
    @Value("\${jdbcTemplateSource.username}")
    private val userName: String,
    @Value("\${jdbcTemplateSource.password}")
    private val password: String,
    private val resourceLoader: ResourceLoader

) {

    fun fetchOneJdbcTemplate(id: String) {
        val dataSource = getDriverManagerDataSource()

        try {
            val jdbcTemplate = JdbcTemplate(dataSource)
            val sql = "select * from member where id = $id"

            /**
             * queryForMap
             * 여러 컬럼을 가진 단일 행 조회
             * **/
            val fetchOne = jdbcTemplate.queryForMap(sql)
            println(fetchOne)
        } catch (e: SQLException) {
            dataSource.connection.close()
            throw SQLException(e.message)
        } finally {
            dataSource.connection.close()
        }
    }

    fun fetchJdbcTemplate() {
        val dataSource = getDriverManagerDataSource()
        try {
            val jdbcTemplate = JdbcTemplate(dataSource)
            val sql = "select * from member"

            /**
             * queryForList
             * 여러 컬럼을 가진 여러 행 조회
             * **/
            val fetch = jdbcTemplate.queryForList(sql)

            fetch.forEach {
                val entries = it.entries
                entries.forEach {
                    print("${it.key}: ${it.value} ")
                }
            }

        } catch (e: SQLException) {
            dataSource.connection.close()
            throw SQLException(e.message)
        } finally {
            dataSource.connection.close()
        }
    }

    // DriverManagerDataSource Connect
    private fun getDriverManagerDataSource() = DriverManagerDataSource(databaseUrl, userName, password)

    // Connection Close
    private fun disconnect(dataSource: DriverManagerDataSource) = dataSource.connection.close()

    // 텍스트 파일 load
    private fun loadTextFile(location: String): String {
        val resource = resourceLoader.getResource(location)
        val filePath = Paths.get(resource.uri)
        val reader = Files.readAllLines(filePath)
        var result = ""
        reader.forEach {
            result += " $it "
        }
        return result
    }

    /**
     * ResultSet 자체를 반환 할 경우 List로 변환
     * **/
    private fun convertResultSetToList(resultSet: ResultSet): MutableList<HashMap<String, Any?>> {
        val metaData = resultSet.metaData
        val columns = metaData.columnCount
        val result: MutableList<HashMap<String, Any?>> = mutableListOf()

        while (resultSet.next()) {

            val row: HashMap<String, Any?> = HashMap(columns)
            for (c in 1 until columns) {
                row[metaData.getColumnName(c)] = resultSet.getObject(c)
            }
            result.add(row)
        }
        return result
    }

}

// Controller

@Tag(name = "zoom api 컨트롤러")
@RestController
@RequestMapping("/api/zoom")
class ZoomController (

        private val zoomQueryService: ZoomQueryService
) {

    @Operation(summary = "zoom token 발급")
    @GetMapping("/access-token")
    fun getAccessToken() = ResponseEntity.ok(zoomQueryService.getAccessToken())

    @Operation(summary = "zoom meeting url 발급")
    @PostMapping("/meetings")
    fun getMeetings(
            @RequestParam("accessToken") accessToken: String
    ) = ResponseEntity.ok(zoomQueryService.getMeetings(accessToken))

}

// Service

@Service
@Transactional(readOnly = true)
class ZoomQueryService (

        @Value("\${zoom.oauth.endPoint}")
        private val ZOOM_OAUTH_ENDPOINT: String,

        @Value("\${zoom.oauth.accountId}")
        private val ZOOM_ACCOUNT_ID: String,

        @Value("\${zoom.oauth.clientId}")
        private val ZOOM_CLIENT_ID: String,

        @Value("\${zoom.oauth.clientSecret}")
        private val ZOOM_CLIENT_SECRET: String,

        @Value("\${zoom.oauth.userId}")
        private val ZOOM_USER_ID: String
        ) {
    
    fun getAccessToken(): String {
        
        val authHeader = "Basic ${getBase64EncodedCredentials()}"

        val headers = HttpHeaders()
        headers.set("Authorization", authHeader)
        headers.contentType = MediaType.APPLICATION_FORM_URLENCODED

        val body: MultiValueMap<String, String> = LinkedMultiValueMap()
        body.add("grant_type", "account_credentials")
        body.add("account_id", ZOOM_ACCOUNT_ID)

        val requestEntity = HttpEntity(body, headers)
        val responseEntity: ResponseEntity<Map<*, *>> = RestTemplate().postForEntity(ZOOM_OAUTH_ENDPOINT, requestEntity, Map::class.java)

        return responseEntity.body!!["access_token"].toString()
    }

    // 회의실 url을 Front에 전달 후, 지원자의 email로 회의실 링크 전달
    fun getMeetings(accessToken: String): String {

        val headers = HttpHeaders()
        headers.set("Authorization", "Bearer $accessToken")
        headers.contentType = MediaType.APPLICATION_JSON

        val requestEntity = HttpEntity({}, headers)
        
        /**
         * zoom host로 post요청을 통해 ResponseBody중 url만 획득
         * 다른 Res가 필요 할 경우 DTO로 변환 후 return 필요
         * **/
        val responseEntity: ResponseEntity<Map<*, *>> = RestTemplate().postForEntity("https://api.zoom.us/v2/users/$ZOOM_USER_ID/meetings", requestEntity, Map::class.java)
        
        return responseEntity.body!!["join_url"].toString()
    }

    private fun getBase64EncodedCredentials(): String {
        
        val credentials = "$ZOOM_CLIENT_ID:$ZOOM_CLIENT_SECRET"
        return String(java.util.Base64.getEncoder().encode(credentials.toByteArray()))
        
    }
}

@Service
@Transactional(readOnly = true)
class LevelQueryService (

        private val levelRepository: LevelRepository,
        private val someRepository: SomeRepository

) {

    /**
     * 서비스는 단순 호출만 담당하고
     * DTO에서 자식 노드들을 계속 불러와 DTO에 담는다.
     * **/
    
    fun getAllLevelByTree(
            param1: String,
            param2: String,
            param3: Int): List<LevelTreeOut> {
        if (param1.isBlank()) throw BasicRuntimeException(MessageUtil.getMessage("SOME_MESSGAE"))
        val parents = levelRepository.getTopNodesByParams(param1, param2, param3)
        return levelParents.map { LevelTreeOut.fromEntity(it) }
    }
}


// DTO

data class LevelTreeOut (
        val levelNo: String,
        val parentLevelNo: LevelSimpleOut?,
        val level: Int,
        val lastYn: Boolean,
        val leaves: List<LevelTreeOut>
) {
    companion object {
        fun fromEntity(e: SomeLevel): LevelTreeOut {
            return LevelTreeOut(
                    levelNo = e.levelNo(),
                    parentLevelNo =
                    if (e.parentLevelNo() == null) null
                    else LevelSimpleOut.fromEntity(e.parentLevelNo()!!),
                    level = e.level(),
                    lastYn = e.lastYn(),
                    // 자식노드들을 불러 올 때 자기 자신을 다시 map으로 변환해 호출하도록 fromEntity 메서드를 다시 활용
                    leaves = e.subLevel().map { fromEntity(it) }
            )
        }
    }
}

/**
 * Entity를 아래와 같이 구성해야
 * 자기 자신을 참조하는 재귀구조의 데이터 형태가 된다.
 * **/
@Entity
class SomeLevel (

        @Id
        val levelNo: String,
        
        /**
         * ManyToOne / OneToMany 양방향 참조가 하나의 엔터티에서 이루어져야 한다.
         * **/

        // 자기 자신을 참조하기 위한 부모노드
        @ManyToOne
        @JoinColumn(
                name = "level_no",
        )
        val parentLevel: SomeLevel?,

        // 자식노드
        @OneToMany(
                mappedBy = "parentLevel",
                targetEntity = SomeLevel::class,
                fetch = FetchType.LAZY,
                cascade = [CascadeType.ALL],
                orphanRemoval = true
        )
        private val subLevel: MutableList<SomeLevel> = mutableListOf(),

        // 레벨
        val level: Int,
        
        // 마지막 노드 Yn
        val lastYn: Boolean
)

fun dfs (
        level: SomeLevel, // tree 구조의 level
        pageable: Pageable
): Page<SomeDtoOut> {
    
    // return 해 줄 빈 배열
    val leaves: MutableList<SomeEntity> = mutableListOf()

    // 한 번 방문 한 트리를 담아 낼 배열
    val visited: MutableList<SomeLevel> = mutableListOf()
    
    // queue에서 add / pop을 통해 while문을 실행
    val queue: Queue<SomeLevel> = LinkedList()
    queue.add(level)

    // queue가 다 비어있을 때 까지 실행
    while (queue.isNotEmpty()) {
        
        // 현재 node를 하나 꺼내온 후 방문 한 배열에 추가
        val currentNode = queue.poll()
        visited.add(currentNode)

        // 현재 노드의 자식 노드들
        val subLevel = currentNode.subLevel()
        
        // 자식 노드들이 없을 경우에만 return
        if (subLevel.isNotEmpty()) for (sub in subLevel) queue.add(sub)
    }
    
    // while 문이 끝나고 다 풀어진 트리구조의 데이터를 원하는 비즈니스 로직을 통해 처리
    for (v in visited) {
        if (v.lastYn()) {
            someRepository.getListBySomeParams(
                    v.levelNo()!!,
            ).forEach { leaves.add(it) }
        }
    }
    return ListToPageConverter.pageFromListAndPageable(leaves.map { SomeDtoOut.fromEntity(it) }, pageable)
}

/**
 * JPA 설정 클래스
 * 2개의 빈은 디비 테이블에 createdAt, createdBy 등 audit 정보를 자동으로 저장하는데 사용
 * 
 * @Primary 어노테이션으로 n개의 DB중 어떤 DB를 main으로 Entity Manager Factory에 지정 할 지 선언 
 */
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
    entityManagerFactoryRef = "primaryEntityManagerFactory",
    transactionManagerRef = "primaryTransactionManager",
    basePackages = ["com.example.project.*.*.*.repository"]
)
@EnableJpaAuditing(dateTimeProviderRef = "auditingDateTimeProvider")
class PrimaryJpaConfig () {

    @Bean
    fun auditingDateTimeProvider() = DateTimeProvider {
        Optional.of(LocalDateTime.now())
    }

    @Bean
    fun auditorAwareProvider() = AuditorAware {
        val authentication = SecurityContextHolder.getContext().authentication
        if (authentication == null) {
            Optional.empty()
        } else when (val principal: Any = authentication.principal) {
            is String -> Optional.of(principal)
            is AuthUser -> Optional.of(principal.memberId)
            else -> Optional.empty()
        }
    }

    @Primary
    @Bean
    @ConfigurationProperties("primary.datasource")
    fun primaryDataSourceProperties(): DataSourceProperties? {
        return DataSourceProperties()
    }

    @Primary
    @Bean
    @ConfigurationProperties("primary.datasource.configuration")
    fun primaryDataSource(@Qualifier("primaryDataSourceProperties") dataSourceProperties: DataSourceProperties): DataSource? {
        return dataSourceProperties.initializeDataSourceBuilder().type(HikariDataSource::class.java).build()
    }

    @Primary
    @Bean
    fun primaryEntityManagerFactory(
        builder: EntityManagerFactoryBuilder,
        @Qualifier("primaryDataSource") dataSource: DataSource?
    ): LocalContainerEntityManagerFactoryBean? {
        return builder
            .dataSource(dataSource)
            .packages("com.example.project.*.*.domain")
            .persistenceUnit("primaryEntityManager")
            .build()
    }

    @Primary
    @Bean
    fun primaryTransactionManager(@Qualifier("primaryEntityManagerFactory") entityManagerFactory: EntityManagerFactory?): PlatformTransactionManager? {
        return JpaTransactionManager(entityManagerFactory!!)
    }

}

/**
 * QueryDSL도 Main과 Sub를 각각 지정 해 줘야함
 * **/
@Repository
abstract class PrimaryQueryDslSupport(domainClass: Class<*>) : QuerydslRepositorySupport(domainClass) {

    private var queryFactory: JPAQueryFactory by Delegates.notNull()

    @PersistenceContext(unitName = "primaryEntityManager")
    override fun setEntityManager(entityManager: EntityManager) {
        super.setEntityManager(entityManager)
        this.queryFactory = JPAQueryFactory(entityManager)
    }
}

public class MainActivity extends AppCompatActivity {
    
    // 안드로이드 웹뷰 설정

    private WebView webView;
    private final String url = "https://gunpla-list.xyz";
    private long backPressedTime = 0;

    @SuppressLint("SetJavaScriptEnabled")
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        /**
         * 인터넷 연결이 없을 때 알림
         * **/
        if(!isNetworkAvailable(this)){
            Toast toast = Toast.makeText(this, "인터넷 연결을 확인해주세요.", Toast.LENGTH_LONG);
            toast.setGravity(Gravity.CENTER, Gravity.CENTER_HORIZONTAL, Gravity.CENTER_VERTICAL);
            toast.show();

            ActivityCompat.finishAffinity(this);
        }

        // 캡쳐 방지
//        getWindow().addFlags(WindowManager.LayoutParams.FLAG_SECURE);

        // 세로모드로 고정 + Manifest.xml portrait 추가 해야함
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

        webView = findViewById(R.id.gunpla_list_app);

        // 웹뷰에서 자바 스크립트로 빌드 된 화면을 렌더링 할 수 있도록 설정
        webView.getSettings().setJavaScriptEnabled(true);
        webView.getSettings().setDomStorageEnabled(true);

        // 웹뷰가 동작할 때 호환되는 브라우저 설정 - Front 개발 환경에 맞게 Chrome으로 설정함
        webView.setWebChromeClient(new WebChromeClient());

        // 웹뷰 로드 시 캐시 및 히스토리를 삭제 해 웹 업데이트를 반영하도록 함
        webView.clearCache(true);
        webView.clearHistory();
        webView.loadUrl(url);

    }

    // 네트워크가 없을 때
    private Boolean isNetworkAvailable(MainActivity application) {
        ConnectivityManager connectivityManager = (ConnectivityManager) application.getSystemService(Context.CONNECTIVITY_SERVICE);
        Network nw = connectivityManager.getActiveNetwork();
        if (nw == null) return false;
        NetworkCapabilities actNw = connectivityManager.getNetworkCapabilities(nw);
        return actNw != null && (actNw.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) || actNw.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) || actNw.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET) || actNw.hasTransport(NetworkCapabilities.TRANSPORT_BLUETOOTH));
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {

        long tempTime = System.currentTimeMillis();
        long intervalTime = tempTime - backPressedTime;

        if ((keyCode == KeyEvent.KEYCODE_BACK)) {

            // 로그인 혹은 메인 화면에서 뒤로가기 클릭 시 앱 종료 토스트 발생
            if(webView.getUrl().equals(url) ||
                    webView.getUrl().equals(url + "/login") ||
                    webView.getUrl().equals(url + "/user/gunpla-list")
            ) {
                long FINISH_INTERNAL_TIME = 2000;
                if (0 <= intervalTime && FINISH_INTERNAL_TIME >= intervalTime) finish();
                else {
                    backPressedTime = tempTime;
                    Toast.makeText(getApplicationContext(), "한번 더 누르면 앱이 종료됩니다.", Toast.LENGTH_SHORT).show();
                }
            } else {
                webView.goBack();
            }
            return true;
        }

        return super.onKeyDown(keyCode, event);
    }
}

plugins {
    val kotlinVersion = "1.6.21"

    id("org.springframework.boot") version "2.7.7"
    id("io.spring.dependency-management") version "1.0.15.RELEASE"
    kotlin("jvm")
    kotlin("plugin.spring") version kotlinVersion
    kotlin("plugin.jpa") version kotlinVersion
}

// QueryDsl
implementation("com.querydsl:querydsl-jpa:5.0.0")
kapt("com.querydsl:querydsl-apt:5.0.0:jpa")

// GraphQl
implementation("com.graphql-java-kickstart:graphql-spring-boot-starter:11.0.0")
implementation("com.graphql-java-kickstart:playground-spring-boot-starter:11.0.0")

/**
 * Url: http://localhost:8080/graphql
 * Https Method: POST
 * Header: 'Content-Type : application/json'
 * **/
@Controller
@Transactional
class UserGraphController (

    private val userRepository: UserRepository,
    private val passwordEncoder: PasswordEncoder

        ) : GraphQLQueryResolver, GraphQLMutationResolver {

    /**
    {
    "query": "{ findAllUsers { oid userId name email } }"
    }
     **/
    fun findAllUsers(): List<User> = userRepository.findAll()

    /**
    {
        "query": "query ($userId: String!) { getByUserId(userId: $userId) { oid, userId, name, email } }",
            "variables": {
                "userId": "userId"
            }
    }
     **/
    fun getByUserId(
        @RequestParam userId: String
    ) = userRepository.getByUserId(userId)

    /**
    {
        "query": "mutation ($signUpIn: SignUpIn!) { createUser(signUpIn: $signUpIn) { oid, userId, name, email } }",
            "variables": {
                "signUpIn": {
                    "userId": "newUserID",
                    "name": "New User",
                    "email": "newuser@example.com",
                    "password": "NewPassword"
            }
        }
    }
    **/

    fun createUser(
        @RequestBody signUpIn: SignUpIn
    ) = userRepository.save(signUpIn.toEntity(passwordEncoder))

    /**
    {
        "query": "mutation ($userOid: ID!) { deleteUserByUserOid(userOid: $userOid) }",
            "variables": {
                "userOid": "Some UserOid"
            }
    }
     **/
    fun deleteUserByUserOid(
        @RequestParam userOid: Long
    ) = userRepository.delete(userRepository.getByOid(userOid))

    /**
    {
        "query": "mutation updateUserByUserOid($userOid: ID!, $userUpdateIn: UserUpdateIn!) { updateUserByUserOid(userOid: $userOid, userUpdateIn: $userUpdateIn) { oid, userId, name, email } }",
            "variables": {
                "userOid": "1",
                "userUpdateIn": {
                    "name": "NewName",
                    "email": "newemail@example.com"
            }
        }
    }
    **/
    fun updateUserByUserOid(
        @RequestParam userOid: Long,
        @RequestBody userUpdateIn: UserUpdateIn
    ) {
        val user = userRepository.getByOid(userOid)
        user.updateWith(User.NewValue(
            name = userUpdateIn.name,
            email = userUpdateIn.email
        ))
    }
}