How to parse Prismapp settings

UiSettings.kt

/**
 * Created by rakawm on 6/6/17.
 */
class UiSettings {
    var revision: Double? = null
    var initialized: Boolean = false
    var siteName: String? = null
    var siteUrl: String? = null
    var phone: String? = null
    var installationComplete: Boolean? = null
    var chatTourAgentsStatus: MutableList<String>? = null
    var visitorConnect: VisitorConnect? = null
    var appearance: Appearance? = null
    var triggers: MutableList<Trigger>? = null
    var autoResponders: MutableList<AutoResponder>? = null
    var workingHours: WeeklyWorkingHours? = null
    var offlineWidget: OfflineWidget? = null
    var timezone: String? = null

    companion object {
        private const val REVISION = "revision"
        private const val PUBLIC = "public"
        private const val WIDGET = "widget"
        private const val GENERAL_INFORMATION = "general_information"
        private const val SITE_NAME = "site_name"
        private const val SITE_URL = "site_url"
        private const val PHONE = "phone"
        private const val INSTALLATION_COMPLETE = "installation_complete"
        private const val CHAT_TOUR_AGENT_STATUS = "chat_tour_agents_status"
        private const val VISITOR_CONNECT = "visitor_connect"
        private const val APPEARANCE = "appearance"
        private const val TRIGGER = "triggers"
        private const val TRIGGER_URL = "url"
        private const val TRIGGER_WAIT_TIME = "wait_time"
        private const val TRIGGER_ACTION = "action"
        private const val TRIGGER_ENABLED = "enabled"
        private const val AUTO_RESPONDER = "auto_responders"
        private const val CHANNEL_ID = "channel_id"
        private const val CHANNEL_TYPE = "channel_type"
        private const val CONDITION = "condition"
        private const val RESPONSE_MESSAGE = "response_message"
        private const val AUTO_RESPONDER_ENABLED = "enabled"
        private const val WORKING_HOURS = "working_hours"
        private const val HOURS_FROM = "from"
        private const val HOURS_TO = "to"
        private const val OFFLINE_WIDGET = "offline_widget"
        private const val TIMEZONE = "timezone"

        const val DAY_MONDAY = "monday"
        const val DAY_TUESDAY = "tuesday"
        const val DAY_WEDNESDAY = "wednesday"
        const val DAY_THURSDAY = "thursday"
        const val DAY_FRIDAY = "friday"
        const val DAY_SATURDAY = "saturday"
        const val DAY_SUNDAY = "sunday"
    }

    fun build(settings: Map<String, Any>) {
        if (settings.containsKey(REVISION)) {
            this.revision = settings[REVISION] as Double
        }

        if (settings.containsKey(PUBLIC)) {
            val publicSettings = settings[PUBLIC] as Map<String, Any>

            if (publicSettings.containsKey(GENERAL_INFORMATION)) {
                val generalInformation = publicSettings[GENERAL_INFORMATION] as Map<String, Any>
                setSiteName(generalInformation)
                setSiteUrl(generalInformation)
                setPhone(generalInformation)
                setInstallationComplete(generalInformation)
                setChatTourAgentsStatus(generalInformation)
            }

            if (publicSettings.containsKey(WIDGET)) {
                initialized = true
                val widgetSettings = publicSettings[WIDGET] as Map<String, Any>
                setVisitorConnect(widgetSettings)
                setAppearance(widgetSettings)
                setTriggers(widgetSettings)
                setAutoResponders(widgetSettings)
                setWorkingHours(widgetSettings)
                setOfflineWidget(widgetSettings)
                setTimezone(widgetSettings)
            }
        }
    }

    private fun setSiteName(map: Map<String, Any>) {
        if (map.containsKey(SITE_NAME)) {
            siteName = map[SITE_NAME] as String
        }
    }

    private fun setSiteUrl(map: Map<String, Any>) {
        if (map.containsKey(SITE_URL)) {
            siteUrl = map[SITE_URL] as String
        }
    }

    private fun setPhone(map: Map<String, Any>) {
        if (map.containsKey(PHONE)) {
            phone = map[PHONE] as String
        }
    }

    private fun setInstallationComplete(map: Map<String, Any>) {
        if (map.containsKey(INSTALLATION_COMPLETE)) {
            installationComplete = map[INSTALLATION_COMPLETE] as Boolean
        }
    }

    private fun setChatTourAgentsStatus(map: Map<String, Any>) {
        if (map.containsKey(CHAT_TOUR_AGENT_STATUS)) {
            clearChatTourAgentsStatus()
            val chatTourAgentsStatusList = map[CHAT_TOUR_AGENT_STATUS] as ArrayList<String>
            saveChatTourAgentsStatus(chatTourAgentsStatusList)
        }
    }

    private fun clearChatTourAgentsStatus() {
        chatTourAgentsStatus?.clear()
    }

    private fun saveChatTourAgentsStatus(chatTourAgentsStatusList: ArrayList<String>) {
        for (item in chatTourAgentsStatusList) {
            chatTourAgentsStatus?.add(item)
        }
    }

    private fun setVisitorConnect(map: Map<String, Any>) {
        if (map.containsKey(VISITOR_CONNECT)) {
            val visitorConnectMap = map[VISITOR_CONNECT] as Map<String, Any>
            val visitorConnect = VisitorConnect()
            visitorConnect.build(visitorConnectMap)

            this.visitorConnect = visitorConnect
        }
    }

    private fun setAppearance(map: Map<String, Any>) {
        if (map.containsKey(APPEARANCE)) {
            val appearanceMap = map[APPEARANCE] as Map<String, Any>
            val appearance = Appearance()
            appearance.build(appearanceMap)

            this.appearance = appearance
        }
    }

    private fun setTriggers(map: Map<String, Any>) {
        if (map.containsKey(TRIGGER)) {
            clearTriggers()
            val triggers = map[TRIGGER] as ArrayList<Map<String, Any>>
            saveTriggers(triggers)
        }
    }

    private fun clearTriggers() {
        triggers?.clear()
    }

    private fun saveTriggers(triggers: ArrayList<Map<String, Any>>) {
        for (item in triggers) {
            val trigger = Trigger()
            if (item.containsKey(TRIGGER_URL)) {
                trigger.url = item[TRIGGER_URL] as String
            }

            if (item.containsKey(TRIGGER_WAIT_TIME)) {
                trigger.waitTime = item[TRIGGER_WAIT_TIME] as String
            }

            if (item.containsKey(TRIGGER_ACTION)) {
                trigger.action = item[TRIGGER_ACTION] as String
            }

            if (item.containsKey(TRIGGER_ENABLED)) {
                trigger.enabled = item[TRIGGER_ENABLED] as Boolean
            }

            this.triggers?.add(trigger)
        }
    }

    private fun setAutoResponders(map: Map<String, Any>) {
        if (map.containsKey(AUTO_RESPONDER)) {
            clearAutoResponders()
            val autoResponders = map[AUTO_RESPONDER] as ArrayList<Map<String, Any>>
            saveAutoResponders(autoResponders)
        }
    }

    private fun clearAutoResponders() {
        autoResponders?.clear()
    }

    private fun saveAutoResponders(autoResponders: ArrayList<Map<String, Any>>) {
        for (item in autoResponders) {
            val autoResponder = AutoResponder()
            if (item.containsKey(CHANNEL_ID)) {
                autoResponder.channelId = item[CHANNEL_ID] as String
            }

            if (item.containsKey(CHANNEL_TYPE)) {
                autoResponder.channelType = item[CHANNEL_TYPE] as String
            }

            if (item.containsKey(CONDITION)) {
                autoResponder.condition = item[CONDITION] as String
            }

            if (item.containsKey(RESPONSE_MESSAGE)) {
                autoResponder.responseMessage = item[RESPONSE_MESSAGE] as String
            }

            if (item.containsKey(AUTO_RESPONDER_ENABLED)) {
                autoResponder.enabled = item[AUTO_RESPONDER_ENABLED] as Boolean
            }
            this.autoResponders?.add(autoResponder)
        }
    }

    private fun setWorkingHours(map: Map<String, Any>) {
        if (map.containsKey(WORKING_HOURS)) {
            val daily = map[WORKING_HOURS] as Map<String, Any>

            workingHours = WeeklyWorkingHours()
            setDailyWorkingHours(daily, DAY_MONDAY)
            setDailyWorkingHours(daily, DAY_TUESDAY)
            setDailyWorkingHours(daily, DAY_WEDNESDAY)
            setDailyWorkingHours(daily, DAY_THURSDAY)
            setDailyWorkingHours(daily, DAY_FRIDAY)
            setDailyWorkingHours(daily, DAY_SATURDAY)
            setDailyWorkingHours(daily, DAY_SUNDAY)
        }
    }

    private fun setDailyWorkingHours(daily: Map<String, Any>,
                                     day: String) {
        if (daily.containsKey(day)) {
            clearWorkingHours(day)
            val dayWorkingHours = daily[day] as ArrayList<Map<String, Any>>
            saveWorkingHours(day, dayWorkingHours)
        }
    }

    private fun clearWorkingHours(day: String) {
        when (day) {
            DAY_MONDAY -> workingHours?.monday?.clear()
            DAY_TUESDAY -> workingHours?.tuesday?.clear()
            DAY_WEDNESDAY -> workingHours?.wednesday?.clear()
            DAY_THURSDAY -> workingHours?.thursday?.clear()
            DAY_FRIDAY -> workingHours?.friday?.clear()
            DAY_SATURDAY -> workingHours?.saturday?.clear()
            DAY_SUNDAY -> workingHours?.sunday?.clear()
        }
    }

    private fun saveWorkingHours(day: String,
                                 dayWorkingHours: ArrayList<Map<String, Any>>) {
        for (item in dayWorkingHours) {
            val hours = WorkingHours()
            if (item.containsKey(HOURS_FROM)) {
                hours.start = item[HOURS_FROM] as String
            }

            if (item.containsKey(HOURS_TO)) {
                hours.end = item[HOURS_TO] as String
            }
            saveDailyWorkingHours(day, hours)
        }
    }

    private fun saveDailyWorkingHours(day: String, hours: WorkingHours) {
        when (day) {
            DAY_MONDAY -> workingHours?.monday?.add(hours)
            DAY_TUESDAY -> workingHours?.tuesday?.add(hours)
            DAY_WEDNESDAY -> workingHours?.wednesday?.add(hours)
            DAY_THURSDAY -> workingHours?.thursday?.add(hours)
            DAY_FRIDAY -> workingHours?.friday?.add(hours)
            DAY_SATURDAY -> workingHours?.saturday?.add(hours)
            DAY_SUNDAY -> workingHours?.sunday?.add(hours)
        }
    }

    private fun setOfflineWidget(map: Map<String, Any>) {
        if (map.containsKey(OFFLINE_WIDGET)) {
            val offlineWidgetMap = map[OFFLINE_WIDGET] as Map<String, Any>
            val offlineWidgetSettings = OfflineWidget()
            offlineWidgetSettings.build(offlineWidgetMap)

            this.offlineWidget = offlineWidgetSettings
        }
    }

    private fun setTimezone(map: Map<String, Any>) {
        if (map.containsKey(TIMEZONE)) {
            timezone = map[TIMEZONE] as String
        }
    }
}

WeeklyWorkingHours.kt

/**
 * Created by rakawm on 6/6/17.
 */
class WeeklyWorkingHours(val monday: MutableList<WorkingHours> = mutableListOf(),
                         val tuesday: MutableList<WorkingHours> = mutableListOf(),
                         val wednesday: MutableList<WorkingHours> = mutableListOf(),
                         val thursday: MutableList<WorkingHours> = mutableListOf(),
                         val friday: MutableList<WorkingHours> = mutableListOf(),
                         val saturday: MutableList<WorkingHours> = mutableListOf(),
                         val sunday: MutableList<WorkingHours> = mutableListOf())

WorkingHours.kt

/**
 * Created by rakawm on 6/6/17.
 */
class WorkingHours : Serializable {
    var start: String? = null
    var end: String? = null
}