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 = true) campusCode: String,
                      @RequestParam("collegeCode", required = false) collegeCode: String?,
                      @RequestParam("deptCode", required = false) deptCode: String?,
                      @RequestParam("name", required = false) name: String?,
                      @ParameterObject pageable: Pageable
    ): ResponseEntity<Page<MemberOut>> {
        return ResponseEntity.ok(
                memberQueryService.searchMembers(
                        role,
                        campusCode,
                        collegeCode,
                        deptCode,
                        name,
                        pageable)
        )
    }
}

// MemberQueryService

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

// DTO

data class MemberOut(
        val oid: Long,
        val campusName: String?,
        val collegeName: String?,
        val deptCode: String?,
        val deptName: 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(),
                    collegeName = e.collegeName(),
                    deptCode = e.deptCode(),
                    deptName = e.deptName(),
                    userId = e.userId,
                    name = e.name(),
                    email = e.email(),
            )
        }
    }
}

// MemberRepositoryCustom

interface MemberRepositoryCustom {

    fun searchMembers(
            role: Role,
            campusCode: String,
            collegeCode: String?,
            deptCode: 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,
            collegeCode: String?,
            deptCode: String?,
            name: String?,
            pageable: Pageable
    ): Page<Member> {
        val result = from(qMember)
                .where(
                        qMember.deleted.isFalse,
                        qMember.role.eq(role.name),
                        qMember.campusCode.eq(campusCode),
                        eqCollegeCode(collegeCode),
                        eqDeptCode(deptCode),
                        containsName(name),
                )
                .fetchAll()
        val pagedResult = querydsl!!.applyPagination(pageable, result).fetch() ?: emptyList()
        return PageableExecutionUtils.getPage(pagedResult, pageable) { result.fetchCount() }
    }

    private fun eqCollegeCode(collegeCode: String?): BooleanExpression? {
        return if (collegeCode == null) null
        else qMember.collegeCode.eq(collegeCode)
    }

    private fun eqDeptCode(deptCode: String?): BooleanExpression? {
        return if (deptCode == null) null
        else qMember.deptCode.eq(deptCode)
    }

    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 {

    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))
    }
}

/**
 * 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)
    }
}

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

        private val recrPartLevelRepository: RecrPartLevelRepository,
        private val evalDeptPartRepository: EvalDeptPartRepository

) {

    /**
     * 서비스는 단순 호출만 담당하고
     * DTO에서 자식 노드들을 계속 불러와 DTO에 담는다.
     * **/
    
    fun getAllRecrPartLevelByTree(
            memberOid: Long,
            recrSchlCode: String,
            enterYear: String,
            recrPartSeq: Int): List<RecrPartLevelTreeOut> {
        SecurityUtil.checkMemberOid(memberOid)
        if (recrSchlCode.isBlank()) throw BasicRuntimeException(MessageUtil.getMessage("NO_SCHL_CODE"))
        if (enterYear.isBlank()) throw BasicRuntimeException(MessageUtil.getMessage("NO_ENTER_YEAR"))
        val recrPartLevelParents = recrPartLevelRepository.getTopNodesByRecrParts(recrSchlCode, enterYear, recrPartSeq)
        return recrPartLevelParents.map { RecrPartLevelTreeOut.fromEntity(it) }
    }
}


// DTO

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

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

        @Id
        val recrPartLevelNo: String,

        @ManyToOne(fetch = FetchType.LAZY)
        @JoinColumns(
                JoinColumn(
                        name = "recr_schl_code",
                        referencedColumnName = "recr_schl_code",
                        insertable = false,
                        updatable = false
                ),
                JoinColumn(
                        name = "enter_year",
                        referencedColumnName = "enter_year",
                        insertable = false,
                        updatable = false
                ),
                JoinColumn(
                        name = "recr_part_seq",
                        referencedColumnName = "recr_part_seq",
                        insertable = false,
                        updatable = false
                )
        )
        private val recrPartId: RecrPart,
        
        /**
         * ManyToOne / OneToMany 양방향 참조가 하나의 엔터티에서 이루어져야 한다.
         * **/

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

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

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

fun dfs (
        recrPartLevel: RecrPartLevel, // tree 구조의 level
        korName: String?, // 이외 다른 파라미터
        engName: String?,
        evalApplId: String?,
        schlReciYn: Boolean?,
        applId: String?,
        pageable: Pageable
): Page<ApplOut> {
    
    // return 해 줄 빈 배열
    val leaves: MutableList<Appl> = mutableListOf()

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

    // 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()) {
            applRepository.getListByApplPartNoAndParams(
                    v.applPartNo()!!,
                    korName,
                    engName,
                    evalApplId,
                    schlReciYn,
                    applId
            ).forEach { leaves.add(it) }
        }
    }
    return ListToPageConverter.pageFromListAndPageable(leaves.map { ApplOut.fromEntity(it) }, pageable)
}

fun getPagedApplDoc(
            recrPartLevelNo: String,
            korName: String?,
            engName: String?,
            evalApplId: String?,
            schlReciYn: Boolean?,
            applId: String?,
            pageable: Pageable
    ): Page<ApplOut> {

        val recrPartLevel = recrPartLevelRepository.getById(recrPartLevelNo)

    
    /**
     * when 구문을 통해 기본 method가 정의되어 있고
     * 특정 조건에 해당하는 파라미터가 보내졌을 때 각자 다른 Domain을 호출
     * **/
        when {
            applId.isNullOrBlank() && evalApplId.isNullOrBlank() && schlReciYn == null-> {
                return dfs(recrPartLevel, korName, engName, evalApplId, schlReciYn, applId, pageable)
            }
            !applId.isNullOrBlank() && !evalApplId.isNullOrBlank() || schlReciYn != null-> {
                return ListToPageConverter.pageFromListAndPageable(
                        applRepository.getListByApplIdAndEvalApplIdAndSchlCode(applId, evalApplId, schlReciYn, recrPartLevel.recrPartId().recrSchlCode())
                                .map { ApplOut.fromEntity(it) }, pageable
                )
            }
            !applId.isNullOrBlank() -> {
                return ListToPageConverter.pageFromListAndPageable(
                        applRepository.getListByApplIdAndSchlCode(applId, recrPartLevel.recrPartId().recrSchlCode(), schlReciYn)
                                .map { ApplOut.fromEntity(it) }, pageable
                )
            }
            !evalApplId.isNullOrBlank() -> {
                return ListToPageConverter.pageFromListAndPageable(
                        applRepository.getListByEvalApplIdAndSchlCode(evalApplId, recrPartLevel.recrPartId().recrSchlCode(), schlReciYn)
                                .map { ApplOut.fromEntity(it) }, pageable
                )
            }
            else -> {
                return dfs(recrPartLevel, korName, engName, evalApplId, schlReciYn, applId, pageable)
            }
        }
    }

// 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()))
        
    }
}

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

    private WebView webView;
    private final String url = "https://hello-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
        ))
    }
}