해상 기상 데이터 수집 프로그램 소스

데이터 출처 : 공공데이터포털

OpenAPI05

SeaWeatherDataCollector

 

package com.yusen.i2b.openapi05

import android.os.Build
import android.util.Log
import org.json.JSONObject
import java.lang.Exception
import java.time.LocalDate
import java.time.format.DateTimeFormatter
import java.util.*
import kotlin.collections.ArrayList

class cSeaWeatherDataCollector{
    companion object{
        const val TAG = "SeaWeatherDataCollector"
        const val REQUESTING = 11
        const val RESPONDED = 12
        const val NEXTREQUEST = 13
        const val NEXTSTATION = 15
        const val PROCESSCOMPLETED = 19
        const val NOCOMMAND = 91
        const val IDLING= 1
        const val PREPARING = 2
    }
    private val Constants = cConstants()
    val mHandler:UploadHandler = UploadHandler()
    private val ServiceKey = Constants.ServiceKey_MarineWeatherData
    private val baseURL_requestSeaWeatherData = Constants.BaseURL_requestSeaWeatherData
    private val baseURL_BilientServer = Constants.BilientServer
    private val DataManager = cDataManager()
    private val Params_requestSeaWeatherData = JSONObject()
    private val Params_loadStationList = JSONObject()
    private val Params_updateStation = JSONObject()
    private val Params_removeSeaWeatherData = JSONObject()
    private val Params_loadData_Essential = JSONObject()
    private val StationList = ArrayList<JSONObject>()
    public var IsStationListReady = false
    private val WebAccess = cWebAccess()
    private var processID = NOCOMMAND
    private var StationNumber = -1
    private var StationIndex = -1
    public var IsInService = false
    private var AccessCount = 0
    var IsUploaded = false
    var UploadedString = "-"

    constructor(){
        SetParams_RequestSeaWeatherData()
        SetParams_loadStationList()
        SetParams_updateStation()
    }

    public fun Start_SetStationList(){
        processID = IDLING
        this.WebAccess.ClearValues()
        CheckProcess_SetStationList()
    }

    public fun CheckProcess_SetStationList():Int{
        if(IsStationListReady) return 1
        when(processID){
            IDLING ->{
                Log.d("[SeaWeatherStation-21]", "IDLING")
                this.WebAccess.Request_POST(this.baseURL_BilientServer, Params_loadStationList)
                this.processID = REQUESTING
                return 0
            }
            REQUESTING ->{
                if(WebAccess.IsResponded) this.processID = RESPONDED
                return 0
            }
            RESPONDED ->{
                processID = PROCESSCOMPLETED
                val SL1s = DataManager.String2JSONArray(WebAccess.ResponseString, "Results")
                if(SL1s == null) return -1
                StationNumber = SL1s.size
                Log.d("[SeaWeatherStation-22]", StationNumber.toString())
                for(aStation in SL1s){
                    StationList.add(aStation)
                }
                IsStationListReady = true
                return 1
            }
            PROCESSCOMPLETED ->{
                return 2
            }
        }
        return -1
    }

    public fun Start_requestSeaWeatherData(){
        processID = IDLING
        this.WebAccess.ClearValues()
        CheckProcess_requestSeaWeatherData()
    }

    public fun Start_CollectSeaWeatherData() {
        processID = IDLING
        this.WebAccess.ClearValues()
        CheckProcess_CollectSeaWeatherData()
    }

    public fun CheckProcess_CollectSeaWeatherData():Int{
        when(this.processID){
            IDLING ->{
                this.StationNumber = this.StationList.size
                if(this.StationNumber < 1){
                    processID = PROCESSCOMPLETED
                    return -1
                }
                this.StationIndex = -1
                this.processID = NEXTSTATION
                return 0
            }
            REQUESTING ->{
                if(!this.WebAccess.IsResponded) return 0
                this.processID = RESPONDED
                return 0
            }
            RESPONDED ->{
                AccessCount++
                this.processID = NEXTREQUEST
                UpdateStationData()
                StationList.get(StationIndex).put("LatestDate", Params_updateStation.getString("LatestDate"))
                if(this.WebAccess.ResponseString == "-"){
                    return 0
                }
                val SeaWeatherData = ConvertResponse2SeaWeatherData(this.WebAccess.ResponseString)
                if(SeaWeatherData == null ) return 0
                UploadSeaWeatherData(SeaWeatherData)
                IsUploaded = true
                UploadedString = StationList.get(StationIndex).getString("BranchCode") + " : " +  SeaWeatherData[0].getString("DATETIME")
                //val lastIndex1 = SeaWeatherData.lastIndex
                //val dateString1 = SeaWeatherData.get(lastIndex1).getString("DATETIME")
                //val finalDate = dateString1.substring(0, 4) + dateString1.substring(4, 6) + dateString1.substring(6, 8)
                if(IsInService) return 1
                return 0
            }
            NEXTREQUEST ->{
                val station1: JSONObject = StationList.get(StationIndex)
                if (station1 == null) {
                    this.processID = PROCESSCOMPLETED
                    return 1
                }
                var latestDate = "20100101"
                try {
                    latestDate = station1.getString("LatestDate")
                }catch(e: Exception){
                    latestDate = "20100101"
                }
                val Date_JSON = UpdateDate(latestDate, 14)
                if(Date_JSON == null){
                    Log.d(
                        "[Uploading sea Weather-data]",
                        "No more sea weather data for " + station1.getInt("BranchCode")
                    )
                    processID = NEXTSTATION
                    SendNotice(station1)
                    if((AccessCount > 2) && IsInService) return 1
                    return 0
                }
                val DateString = Date_JSON.getString("StartDate")
                Log.d("[CollectSeaWeatherData-12]", station1.getString("BranchCode") + ", " + DateString)
                this.Params_requestSeaWeatherData.put(
                    "mmaf",
                    station1.getInt("OrgCode")
                )
                this.Params_requestSeaWeatherData.put(
                    "mmsi",
                    station1.getString("BranchCode")
                )
                this.Params_requestSeaWeatherData.put(
                    "date",
                    DateString
                )
                Params_updateStation.put("BranchCode", station1.getString("BranchCode"))
                Params_updateStation.put("SNo", station1.getInt("SNo"))
                Params_updateStation.put("LatestDate", DateString)
                this.WebAccess.ClearValues()
                this.WebAccess.Request_GET10m(
                    this.baseURL_requestSeaWeatherData,
                    this.Params_requestSeaWeatherData
                )
                this.processID = REQUESTING
                return 0
            }
            NEXTSTATION ->{
                AccessCount=0
                val random = Random()
                StationIndex = random.nextInt(StationNumber)
                processID = NEXTREQUEST
                return 0
            }
            PROCESSCOMPLETED ->{
                return 2
            }
            else->{
                return -2
            }

        }
    }
    private fun SendNotice(stationInfo:JSONObject){
        val webAccess = cWebAccess()
        val mailParam = JSONObject()
        val constants1 = cConstants()
        val sender = constants1.SenderEmail
        val receiver = constants1.ReceiverEmail
        mailParam.accumulate("RequestType", "sendNotice")
        mailParam.accumulate("MailTo", receiver)
        val mailSubject = "[MarineWeather-data] "+stationInfo.getString("BranchCode")+" completed"
        mailParam.accumulate("MailSubject", mailSubject)
        val mailBody = stationInfo.getString("BranchCode") + "/" +stationInfo.getString("OrgName") +
                " : " + stationInfo.getString("LatestDate") +
                " with " + Build.DEVICE
        mailParam.accumulate("MailBody", mailBody)
        webAccess.Request_POST(baseURL_BilientServer, mailParam)
    }

    private fun ConvertResponse2SeaWeatherData(ResponseString:String):ArrayList<JSONObject>?{ //*******************************

        //Log.d("[SeaWeatherData-30]", ResponseString)
        val result_XML = this.DataManager.String2XMLList(ResponseString, "result")
        if(result_XML == null) return null
        Log.d("[SeaWeatherData-31]", result_XML.item(0).nodeName.toString())
        if(result_XML == null){
            return null
        }
        val result_JSON = this.DataManager.XMLList2JSON(result_XML.item(0).childNodes)
        if(result_JSON == null){
            return null
        }
        Log.d("[SeaWeatherData-32]", result_JSON.toString())
        when(result_JSON.getString("status")) {
            "OK" -> {
                val Items_XML = DataManager.FindtheNodeList(result_XML, "recordset")
                if (Items_XML == null) {
                    return null
                }
                val ItemNumber = Items_XML.length
                val ItemArray_JSON = ArrayList<JSONObject>()
                for (Index1 in 0..(ItemNumber - 1)) {
                    val Item1 = Items_XML.item(Index1)
                    if (Item1.nodeName == "record") {
                        val Items_JSON = this.DataManager.XMLList2JSON(Item1.childNodes)
                        if (Items_JSON == null) continue
                        ItemArray_JSON.add(Items_JSON)
                    }
                }
                return ItemArray_JSON
            }
            else->{
                Log.d("[result-XML]", "No result" )
                return null
            }
        }
    }

    private fun UpdateStationData(){
        val msg1 = mHandler.obtainMessage(UploadHandler.MSG_UPLOADWEATHERDATA)
        val RequestInfo = cRequestInfo(baseURL_BilientServer, Params_updateStation)
        msg1.obj = RequestInfo
        mHandler.sendMessage(msg1)
    }

    private fun UpdateDate(DateString0:String, DayIncrement:Long): JSONObject?{
        val theBeginning: LocalDate = LocalDate.of(2017, 1, 1)
        val theNow: LocalDate = LocalDate.now()
        val Rst_JSON = JSONObject()
        if(DateString0 == null){
            val Start0String = theBeginning.format(DateTimeFormatter.ofPattern("yyyyMMdd"))
            val End0String = theBeginning.plusDays(DayIncrement).format(DateTimeFormatter.ofPattern("yyyyMMdd"))
            Rst_JSON.accumulate("StartDate", Start0String.toString())
            Rst_JSON.accumulate("EndDate", End0String.toString())
            return Rst_JSON
        }
        val Year0 = DateString0.substring(0, 4).toInt()
        val Month0 = DateString0.substring(4, 6).toInt()
        val Day0 = DateString0.substring(6).toInt()
        var Date1: LocalDate = LocalDate.of(Year0, Month0, Day0).plusDays(1)
        if (Date1.compareTo(theBeginning) < 0) Date1 = theBeginning
        if (Date1.compareTo(theNow) >= 0) return null
        var Date2: LocalDate = Date1.plusDays(DayIncrement)
        if(Date2.compareTo(theNow) >= 0){
            Date2 = theNow.minusDays(1)
        }
        if(Date1.compareTo(Date2) > 0) return null
        val Date1String = Date1.format(DateTimeFormatter.ofPattern("yyyyMMdd"))
        val Date2String = Date2.format(DateTimeFormatter.ofPattern("yyyyMMdd"))
        Rst_JSON.accumulate("StartDate", Date1String)
        Rst_JSON.accumulate("EndDate", Date2String)
        return Rst_JSON
    }

    public fun CheckProcess_requestSeaWeatherData():Int{
        when(processID){
            IDLING->{
                this.WebAccess.ClearValues()
                this.WebAccess.Request_GET10m(this.baseURL_requestSeaWeatherData, Params_requestSeaWeatherData)
                this.processID = REQUESTING
                return 0
            }
            REQUESTING->{
                if(!WebAccess.IsResponded) return 0
                processID = RESPONDED
                return 0
            }
            RESPONDED->{
                processID = PROCESSCOMPLETED
                val seaWeatherData = ExtractSeaWeatherData(WebAccess.ResponseString)
                if(seaWeatherData == null) return -1
                this.WebAccess.ClearValues()
                return 1

            }
            PROCESSCOMPLETED->{
                return 2
            }
            else->{
                return -2
            }
        }
        return 0;
    }

    private fun UploadSeaWeatherData(WeatherData_JSON:ArrayList<JSONObject>){
        var timeIndex = -1
        for(JSON1 in WeatherData_JSON ){
            //val JSON1 = JSONObject(WeatherData_JSON.get(Index1).toString())
            if(JSON1 == null) return
            val dateString = JSON1.getString("DATETIME")
            if(dateString.substring(8, 10).toInt() <= timeIndex) continue
            timeIndex = dateString.substring(8, 10).toInt()
            val msg1 = mHandler.obtainMessage(UploadHandler.MSG_UPLOADWEATHERDATA)
            JSON1.accumulate("RequestType", "uploadSeaWeatherData")
            val RequestInfo = cRequestInfo(baseURL_BilientServer, JSON1)
//            val RequestInfo = cRequestInfo(baseURL_uploadTest, JSON1)
            msg1.obj = RequestInfo
            mHandler.sendMessage(msg1)
        }
    }

    public fun ExtractSeaWeatherData(ResponseString:String):ArrayList<JSONObject>?{
        val DM1 = cDataManager()
        val XML1 = DM1.String2XMLList(ResponseString, "result")
        if(XML1 == null) return null
        val XML11 = DM1.FindtheNodeList(XML1, "status")
        val XML12 = DM1.FindtheNodeList(XML1, "recordset")

        val jsonArray = ArrayList<JSONObject>()
        var count1 = 0
        if(XML12 != null) {
            for(Index1 in 0..(XML12.length-1)){
                val XML21 = XML12.item(Index1)
                if(XML21 == null) break;
                if(XML21.nodeName == "record"){
                    val json1 = DM1.XMLList2JSON(XML21.childNodes)
                    if(json1 != null) jsonArray.add(json1)
                    count1+=1
                }
            }
        }
        if(count1==0) return null
        return jsonArray
    }

    private fun SetParams_RequestSeaWeatherData(){
        Params_requestSeaWeatherData.accumulate("serviceKey", this.ServiceKey)
        Params_requestSeaWeatherData.accumulate("resultType", "xml")
        Params_requestSeaWeatherData.accumulate("mmaf", 101)
        Params_requestSeaWeatherData.accumulate("mmsi", 994401583)
    }

    private fun SetParams_loadStationList(){
        Params_loadStationList.accumulate("DataNumber", 200)
        Params_loadStationList.accumulate("RequestType", "loadSeaWeatherStations")
    }
    private fun SetParams_loadDatas(){
        Params_loadStationList.accumulate("DataNumber", 200)
        Params_loadStationList.accumulate("RequestType", "loadSeaWeatherDatas")
    }

    private fun SetParams_updateStation(){
        Params_updateStation.accumulate("RequestType", "updateSeaWeatherStation")
        Params_updateStation.accumulate("LatestDate", "20100101")
        Params_updateStation.accumulate("BranchCode", "-1")
    }
    private fun SetParams_removeSeaWeatherData(){
        Params_removeSeaWeatherData.accumulate("RequestType", "removeSeaWeatherData")
        Params_removeSeaWeatherData.accumulate("SNo", "-1")
        Params_removeSeaWeatherData.accumulate("MMSI_CODE", "-1")
    }
    private fun SetParams_loadData_Essential(){
        Params_loadData_Essential.accumulate("RequestType", "loadEssentialDatas_SeaWeatherData")
        Params_loadData_Essential.accumulate("StartDate", "20100101000000")
        Params_loadData_Essential.accumulate("EndDate", "20100131235959")
    }
}