F47215AA1E1F96B60083D3BC /* ResourceHistoryDataStore.swift in Sources */ = {isa = PBXBuildFile; fileRef = F47215A91E1F96B60083D3BC /* ResourceHistoryDataStore.swift */; };
F47215AC1E1FA2460083D3BC /* TemporaryDataStore.swift in Sources */ = {isa = PBXBuildFile; fileRef = F47215AB1E1FA2460083D3BC /* TemporaryDataStore.swift */; };
F47215B01E1FEACC0083D3BC /* ServerDataStore.swift in Sources */ = {isa = PBXBuildFile; fileRef = F47215AF1E1FEACC0083D3BC /* ServerDataStore.swift */; };
+ F4760CE81FDAC5F100702C3E /* API.swift in Sources */ = {isa = PBXBuildFile; fileRef = F4760CE71FDAC5F100702C3E /* API.swift */; };
F47B06DD1E97ECD4006711D9 /* WindowManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = F47B06DC1E97ECD4006711D9 /* WindowManager.swift */; };
F47C3E981E5DB29300D97449 /* JSONMapper.swift in Sources */ = {isa = PBXBuildFile; fileRef = F47C3E971E5DB29300D97449 /* JSONMapper.swift */; };
F47C3E9A1E5DC90000D97449 /* MasterSTypeMapper.swift in Sources */ = {isa = PBXBuildFile; fileRef = F47C3E991E5DC90000D97449 /* MasterSTypeMapper.swift */; };
F47215A91E1F96B60083D3BC /* ResourceHistoryDataStore.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ResourceHistoryDataStore.swift; sourceTree = "<group>"; };
F47215AB1E1FA2460083D3BC /* TemporaryDataStore.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = TemporaryDataStore.swift; sourceTree = "<group>"; };
F47215AF1E1FEACC0083D3BC /* ServerDataStore.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = ServerDataStore.swift; sourceTree = "<group>"; };
+ F4760CE71FDAC5F100702C3E /* API.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = API.swift; sourceTree = "<group>"; };
F47B06DC1E97ECD4006711D9 /* WindowManager.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = WindowManager.swift; sourceTree = "<group>"; };
F47C3E971E5DB29300D97449 /* JSONMapper.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = JSONMapper.swift; sourceTree = "<group>"; };
F47C3E991E5DC90000D97449 /* MasterSTypeMapper.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = MasterSTypeMapper.swift; sourceTree = "<group>"; };
F4FC3E8F1E437E1F00E41228 /* JSONReciever.swift */,
F4CF25A91E338ED000C02A66 /* JSONTracker.swift */,
F4CF25A71E325ABA00C02A66 /* APIResponse.swift */,
+ F4760CE71FDAC5F100702C3E /* API.swift */,
F4CF25BF1E36428400C02A66 /* MissionStatus.swift */,
F4CF25BD1E361F4600C02A66 /* NyukyoDockStatus.swift */,
F4CF25BB1E34F67400C02A66 /* KenzoDockStatus.swift */,
F47C3EAE1E5F26E900D97449 /* DeckMapper.swift in Sources */,
F4048AA11E1951BB008ACFD6 /* SuppliesCell.swift in Sources */,
F490977D1E19DF390085A45D /* SlotItemFrameView.swift in Sources */,
+ F4760CE81FDAC5F100702C3E /* API.swift in Sources */,
F4E471291E46ECF1009B5AF4 /* CoreDataCore.swift in Sources */,
F4AF56811F7BF0CF004F4F4E /* IntConvertable.swift in Sources */,
F47C3EA01E5DE08F00D97449 /* MasterMapInfoMapper.swift in Sources */,
--- /dev/null
+//
+// API.swift
+// KCD
+//
+// Created by Hori,Masaki on 2017/12/08.
+// Copyright © 2017年 Hori,Masaki. All rights reserved.
+//
+
+
+import Foundation
+
+enum Endpoint: String {
+
+ case start2 = "/kcsapi/api_start2"
+ case requireInfo = "/kcsapi/api_get_member/require_info"
+ case mapInfo = "/kcsapi/api_get_member/mapinfo"
+
+ // Port
+ case port = "/kcsapi/api_port/port"
+
+ // Dock
+ case ndock = "/kcsapi/api_get_member/ndock"
+ case kdock = "/kcsapi/api_get_member/kdock"
+
+ // Deck
+ case deck = "/kcsapi/api_get_member/deck"
+ case deckPort = "/kcsapi/api_get_member/deck_port"
+ case presetSelect = "/kcsapi/api_req_hensei/preset_select"
+
+ // Supplies
+ case material = "/kcsapi/api_get_member/material"
+ case basic = "/kcsapi/api_get_member/basic"
+
+ // Ship
+ case ship = "/kcsapi/api_get_member/ship"
+ case ship2 = "/kcsapi/api_get_member/ship2"
+ case ship3 = "/kcsapi/api_get_member/ship3"
+ case shipDeck = "/kcsapi/api_get_member/ship_deck"
+
+ case createShip = "/kcsapi/api_req_kousyou/createship"
+ case getShip = "/kcsapi/api_req_kousyou/getship"
+ case destroyShip = "/kcsapi/api_req_kousyou/destroyship"
+
+ case powerup = "/kcsapi/api_req_kaisou/powerup"
+
+ case shipLock = "/kcsapi/api_req_kaisou/lock"
+
+ // SlotItem
+ case slotItem = "/kcsapi/api_get_member/slot_item"
+
+ case exchangeIndex = "/kcsapi/api_req_kaisou/slot_exchange_index"
+ case slotDeprive = "/kcsapi/api_req_kaisou/slot_deprive"
+
+ case createItem = "/kcsapi/api_req_kousyou/createitem"
+ case destroyItem2 = "/kcsapi/api_req_kousyou/destroyitem2"
+
+ case remodelSlot = "/kcsapi/api_req_kousyou/remodel_slot"
+
+ // Hensei
+ case henseiCombined = "/kcsapi/api_req_hensei/combined"
+ case change = "/kcsapi/api_req_hensei/change"
+
+ // Nyukyo
+ case startNyukyo = "/kcsapi/api_req_nyukyo/start"
+ case speedChange = "/kcsapi/api_req_nyukyo/speedchange"
+
+ // Charge
+ case charge = "/kcsapi/api_req_hokyu/charge"
+
+ // Airbase
+ case setPlane = "/kcsapi/api_req_air_corps/set_plane"
+ case setAction = "/kcsapi/api_req_air_corps/set_action"
+ case airCorpsSupply = "/kcsapi/api_req_air_corps/supply"
+ case airCorpsRename = "/kcsapi/api_req_air_corps/change_name"
+
+ // Battle
+ case battle = "/kcsapi/api_req_sortie/battle"
+
+ case combinedBattle = "/kcsapi/api_req_combined_battle/battle"
+ case combinedAirBattle = "/kcsapi/api_req_combined_battle/airbattle"
+ case combinedBattleWater = "/kcsapi/api_req_combined_battle/battle_water"
+ case combinedEcBattle = "/kcsapi/api_req_combined_battle/ec_battle"
+ case combinedEachBattle = "/kcsapi/api_req_combined_battle/each_battle"
+ case combinedEachBattleWater = "/kcsapi/api_req_combined_battle/each_battle_water"
+
+ case combinedEachNightToDay = "/kcsapi/api_req_combined_battle/ec_night_to_day"
+
+ case airBattle = "/kcsapi/api_req_sortie/airbattle"
+ case ldAirBattle = "/kcsapi/api_req_sortie/ld_airbattle"
+ case combinedLdAirBattle = "/kcsapi/api_req_combined_battle/ld_airbattle"
+
+ case midnightBattle = "/kcsapi/api_req_battle_midnight/battle"
+ case midnightSpMidnight = "/kcsapi/api_req_battle_midnight/sp_midnight"
+ case combinedEcMidnightBattle = "/kcsapi/api_req_combined_battle/ec_midnight_battle"
+ case combinedMidnightBattle = "/kcsapi/api_req_combined_battle/midnight_battle"
+ case combinedSpMidnight = "/kcsapi/api_req_combined_battle/sp_midnight"
+
+ case battleResult = "/kcsapi/api_req_sortie/battleresult"
+ case combinedBattleResult = "/kcsapi/api_req_combined_battle/battleresult"
+
+ // GuardEscape
+ case goback = "/kcsapi/api_req_combined_battle/goback_port"
+ case gobakAlone = "/kcsapi/api_req_sortie/goback_port"
+
+ // Map
+ case start = "/kcsapi/api_req_map/start"
+ case next = "/kcsapi/api_req_map/next"
+
+ //Quest
+ case questList = "/kcsapi/api_get_member/questlist"
+ case clearItemGet = "/kcsapi/api_req_quest/clearitemget"
+
+ // Unknown
+ case unknown = "UNKNOWN_API_STRING"
+}
+
+enum APIType {
+
+ case port
+
+ case deck
+
+ case battle
+
+ case battleResult
+
+ case guardEscape
+
+ case map
+
+ case other
+}
+
+private func apiType(of endpoint: Endpoint) -> APIType {
+
+ switch endpoint {
+
+ case .port:
+ return .port
+
+ case .deck, .deckPort, .presetSelect:
+ return .deck
+
+ case .battle,
+ .combinedBattle, .combinedAirBattle, .combinedBattleWater,
+ .combinedEcBattle, .combinedEachBattle, .combinedEachBattleWater,
+ .combinedEachNightToDay,
+ .airBattle, .ldAirBattle, .combinedLdAirBattle,
+ .midnightBattle, .midnightSpMidnight,
+ .combinedMidnightBattle, .combinedEcMidnightBattle, .combinedSpMidnight:
+ return .battle
+
+ case .battleResult, .combinedBattleResult:
+ return .battleResult
+
+ case .goback, .gobakAlone:
+ return .guardEscape
+
+ case .start, .next:
+ return .map
+
+ default:
+ return .other
+ }
+}
+
+struct API {
+
+ let endpoint: Endpoint
+
+ var type: APIType {
+
+ return apiType(of: endpoint)
+ }
+
+ private var endpointString: String {
+
+ switch endpoint {
+ case .unknown: return rawEndpointString ?? "Not Recorded"
+ default: return endpoint.rawValue
+ }
+ }
+
+ private var rawEndpointString: String?
+
+ init(endpointPath rawValue: String) {
+
+ endpoint = Endpoint(rawValue: rawValue) ?? .unknown
+
+ if endpoint == .unknown {
+
+ rawEndpointString = rawValue
+ }
+ }
+
+ func includs(in rawValues: [String]) -> Bool {
+
+ return rawValues.contains(endpointString)
+ }
+
+ func isRanking() -> Bool {
+
+ return endpointString.hasPrefix("/kcsapi/api_req_ranking/")
+ }
+}
+
+extension API: CustomStringConvertible {
+
+ var description: String {
+
+ return "API: \(endpointString)"
+ }
+}
+
+extension API: CustomDebugStringConvertible {
+
+ var debugDescription: String {
+
+ return endpointString
+ }
+}
struct APIResponse {
- let api: String
+ let api: API
let parameter: Parameter
let json: JSON
let date: Date
return false
}
- init(api: String, parameter: Parameter, json: JSON) {
+ init(api: API, parameter: Parameter, json: JSON) {
self.api = api
self.parameter = parameter
return nil
}
- self.api = api
+ self.api = API(endpointPath: api)
}
}
final class AirCorpsChangeNameCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_req_air_corps/change_name" { return true }
-
- return false
+ return api.endpoint == .airCorpsRename
}
override func execute() {
final class AirCorpsSupplyCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_req_air_corps/supply" { return true }
-
- return false
+ return api.endpoint == .airCorpsSupply
}
override func execute() {
editorStore: ServerDataStore.oneTimeEditor())
}
- private enum BasicAPI: String {
-
- case getMemberBasic = "/kcsapi/api_get_member/basic"
- case port = "/kcsapi/api_port/port"
- }
-
private class func dataKeys(_ apiResponse: APIResponse) -> [String] {
- guard let basicApi = BasicAPI(rawValue: apiResponse.api) else { return ["api_data"] }
-
- switch basicApi {
+ switch apiResponse.api.endpoint {
+
case .port: return ["api_data", "api_basic"]
- case .getMemberBasic: return ["api_data"]
+ case .basic: return ["api_data"]
+
+ default: return Logger.shared.log("Missing API: \(apiResponse.api)", value: ["api_data"])
}
}
import Cocoa
-enum BattleAPI: String {
-
- case battle = "/kcsapi/api_req_sortie/battle"
-
- case combinedBattle = "/kcsapi/api_req_combined_battle/battle"
- case combinedAirBattle = "/kcsapi/api_req_combined_battle/airbattle"
- case combinedBattleWater = "/kcsapi/api_req_combined_battle/battle_water"
- case combinedEcBattle = "/kcsapi/api_req_combined_battle/ec_battle"
- case combinedEachBattle = "/kcsapi/api_req_combined_battle/each_battle"
- case combinedEachBattleWater = "/kcsapi/api_req_combined_battle/each_battle_water"
-
- case combinedEachNightToDay = "/kcsapi/api_req_combined_battle/ec_night_to_day"
-
- case airBattle = "/kcsapi/api_req_sortie/airbattle"
- case ldAirBattle = "/kcsapi/api_req_sortie/ld_airbattle"
- case combinedLdAirBattle = "/kcsapi/api_req_combined_battle/ld_airbattle"
-
- case midnightBattle = "/kcsapi/api_req_battle_midnight/battle"
- case midnightSpMidnight = "/kcsapi/api_req_battle_midnight/sp_midnight"
- case combinedEcMidnightBattle = "/kcsapi/api_req_combined_battle/ec_midnight_battle"
- case combinedMidnightBattle = "/kcsapi/api_req_combined_battle/midnight_battle"
- case combinedSpMidnight = "/kcsapi/api_req_combined_battle/sp_midnight"
-
- case battleResult = "/kcsapi/api_req_sortie/battleresult"
- case combinedBattleResult = "/kcsapi/api_req_combined_battle/battleresult"
-}
-
final class BattleCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- return BattleAPI(rawValue: api) != nil
+ return api.type == .battle || api.type == .battleResult
}
override func execute() {
CalculateDamageCommand(apiResponse: apiResponse).execute()
- guard let battleApi = BattleAPI(rawValue: apiResponse.api) else { return }
-
- switch battleApi {
+ switch apiResponse.api.endpoint {
+
case .battleResult, .combinedBattleResult:
DropShipHistoryCommand(apiResponse: apiResponse).execute()
DummyShipCommand(apiResponse: apiResponse).execute()
override func execute() {
- guard let battleApi = BattleAPI(rawValue: api) else { return }
-
- switch battleApi {
+ switch api.endpoint {
+
case .battle, .airBattle, .ldAirBattle:
normalBattle(battleType: .normal)
case .battleResult, .combinedBattleResult:
applyDamage()
resetDamage()
+
+ default: return Logger.shared.log("Missing API: \(apiResponse.api)")
}
}
static let userInfoKey = "HenseiDidChangeUserInfoKey"
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_req_hensei/change" { return true }
-
- return false
+ return api.endpoint == .change
}
// api_ship_id の値
final class ClearItemGetComand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_req_quest/clearitemget" { return true }
-
- return false
+ return api.endpoint == .clearItemGet
}
override func execute() {
static let userInfoKey = "com.masakih.KCD.Notification.CombinedDidCange.CombinedType"
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_req_hensei/combined" { return true }
-
- return false
+ return api.endpoint == .henseiCombined
}
override func execute() {
- if api == "/kcsapi/api_port/port" {
+ if api.endpoint == .port {
if let t = data["api_combined_flag"].int {
final class CreateShipCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_req_kousyou/createship" { return true }
-
- return false
+ return api.endpoint == .createShip
}
override func execute() {
final class CreateSlotItemCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_req_kousyou/createitem" { return true }
-
- return false
+ return api.endpoint == .createItem
}
override func execute() {
editorStore: ServerDataStore.oneTimeEditor())
}
-
- private enum DeckAPI: String {
-
- case getMemberDeck = "/kcsapi/api_get_member/deck"
- case port = "/kcsapi/api_port/port"
- case getMemberShip2 = "/kcsapi/api_get_member/ship2"
- case getMemberShip3 = "/kcsapi/api_get_member/ship3"
- case getMemberShipDeck = "/kcsapi/api_get_member/ship_deck"
- case getMemberDeckPort = "/kcsapi/api_get_member/deck_port"
- case henseiPresetSelect = "/kcsapi/api_req_hensei/preset_select"
- case kaisouPowerUp = "/kcsapi/api_req_kaisou/powerup"
- }
-
private class func dataKeys(_ apiResponse: APIResponse) -> [String] {
- guard let deckApi = DeckAPI(rawValue: apiResponse.api) else { return ["api_data"] }
-
- switch deckApi {
+ switch apiResponse.api.endpoint {
+
case .port: return ["api_data", "api_deck_port"]
- case .getMemberShip2: return ["api_data_deck"]
+ case .ship3, .shipDeck: return ["api_data", "api_deck_data"]
- case .getMemberShip3: return ["api_data", "api_deck_data"]
+ case .ship2: return ["api_data_deck"]
- case .getMemberShipDeck: return ["api_data", "api_deck_data"]
+ case .powerup: return ["api_data", "api_deck"]
- case .kaisouPowerUp: return ["api_data", "api_deck"]
+ case .deck, .deckPort, .presetSelect: return ["api_data"]
- case .getMemberDeck, .getMemberDeckPort, .henseiPresetSelect: return ["api_data"]
+ default: return Logger.shared.log("Missing API: \(apiResponse.api)", value: ["api_data"])
}
}
}
final class DestroyItem2Command: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_req_kousyou/destroyitem2" { return true }
-
- return false
+ return api.endpoint == .destroyItem2
}
override func execute() {
final class DestroyShipCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_req_kousyou/destroyship" { return true }
-
- return false
+ return api.endpoint == .destroyShip
}
override func execute() {
override func execute() {
- if api == "/kcsapi/api_port/port" || api == "/kcsapi/api_get_member/ship_deck" {
+ if api.endpoint == .port || api.endpoint == .shipDeck {
storeToVisible()
-
}
- if !api.hasSuffix("battleresult") { return }
+ if api.type != .battleResult { return }
guard let shipName = data["api_get_ship"]["api_ship_name"].string else { return }
guard let winRank = data["api_win_rank"].string else { return }
override func execute() {
- if api == "/kcsapi/api_req_sortie/battleresult" { checkGetShip() }
- if api == "/kcsapi/api_get_member/ship_deck" { enterDummy() }
- if api == "/kcsapi/api_port/port" { removeDummy() }
+ switch api.endpoint {
+
+ case .battleResult, .combinedBattleResult: checkGetShip()
+
+ case .shipDeck: enterDummy()
+
+ case .port: removeDummy()
+
+ default: return Logger.shared.log("Missing API: \(apiResponse.api)")
+ }
}
private func checkGetShip() {
final class GetShipCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_req_kousyou/getship" { return true }
-
- return false
+ return api.endpoint == .getShip
}
override func execute() {
import Cocoa
-
-enum GuardEscapeAPI: String {
-
- case goback = "/kcsapi/api_req_combined_battle/goback_port"
- case gobakAlone = "/kcsapi/api_req_sortie/goback_port"
-}
-
extension Notification.Name {
static let DidUpdateGuardEscape = Notification.Name("com.masakih.KCD.Notification.DidUpdateGuardEscape")
final class GuardShelterCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- return GuardEscapeAPI(rawValue: api) != nil
+ return api.type == .guardEscape
}
override func execute() {
- if let b = BattleAPI(rawValue: api) {
+ switch api.type {
- switch b {
- case .battleResult, .combinedBattleResult:
- registerReserve()
-
- default:
- break
- }
- }
- if let m = MapAPI(rawValue: api), m == .next {
+ case .battleResult:
+ registerReserve()
+ case .map:
removeInvalidEntry()
- }
- if let _ = GuardEscapeAPI(rawValue: api) {
+ case .guardEscape:
ensureGuardShelter()
- }
- if let _ = PortAPI(rawValue: api) {
+ case .port:
removeAllEntry()
+
+ default: return Logger.shared.log("Missing API: \(apiResponse.api)")
}
}
final class HokyuChargeCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_req_hokyu/charge" { return true }
-
- return false
+ return api.endpoint == .charge
}
override func execute() {
return array
}()
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if ignores.contains(api) { return true }
- if api.hasPrefix("/kcsapi/api_req_ranking/") { return true }
+ if api.includs(in: ignores) { return true }
+ if api.isRanking() { return true }
return false
}
class JSONCommand {
- class func canExecuteAPI(_ api: String) -> Bool { return false }
+ class func canExecuteAPI(_ api: API) -> Bool { return false }
let apiResponse: APIResponse
self.apiResponse = apiResponse
}
- var api: String { return apiResponse.api }
+ var api: API { return apiResponse.api }
var parameter: Parameter { return apiResponse.parameter }
var json: JSON { return apiResponse.json }
DispatchQueue.main.async {
let commands: [String: Any] = [
- "api": self.api,
+ "api": self.api.debugDescription,
"argument": self.parameterList,
"json": self.jsonTree ?? [],
"recieveDate": self.recieveDate ?? Date(),
final class KaisouLockCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_req_kaisou/lock" { return true }
-
- return false
+ return api.endpoint == .shipLock
}
override func execute() {
editorStore: ServerDataStore.oneTimeEditor())
}
-
- private enum KenzoDockAPI: String {
-
- case getMemberKDock = "/kcsapi/api_get_member/kdock"
- case kousyouGetShip = "/kcsapi/api_req_kousyou/getship"
- case getMemberRequireInfo = "/kcsapi/api_get_member/require_info"
- }
-
private class func dataKeys(_ apiResponse: APIResponse) -> [String] {
- guard let kenzoDockApi = KenzoDockAPI(rawValue: apiResponse.api) else { return ["api_data"] }
-
- switch kenzoDockApi {
- case .kousyouGetShip: return ["api_data", "api_kdock"]
+ switch apiResponse.api.endpoint {
- case .getMemberRequireInfo: return ["api_data", "api_kdock"]
+ case .getShip, .requireInfo: return ["api_data", "api_kdock"]
+
+ case .kdock: return ["api_data"]
- case .getMemberKDock: return ["api_data"]
+ default: return Logger.shared.log("Missing API: \(apiResponse.api)", value: ["api_data"])
}
}
}
final class MapInfoCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_get_member/mapinfo" { return true }
-
- return false
+ return api.endpoint == .mapInfo
}
override func execute() {
import Cocoa
-enum MapAPI: String {
-
- case start = "/kcsapi/api_req_map/start"
- case next = "/kcsapi/api_req_map/next"
-}
-
final class MapStartCommand: JSONCommand {
private let store = TemporaryDataStore.oneTimeEditor()
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- return MapAPI(rawValue: api) != nil
+ return api.type == .map
}
override func execute() {
- MapAPI(rawValue: api).map {
+ switch api.endpoint {
+ case .start: startBattle()
- switch $0 {
- case .start: startBattle()
-
- case .next:
- nextCell()
- updateBattleCell()
- }
+ case .next:
+ nextCell()
+ updateBattleCell()
+
+ default: return Logger.shared.log("Missing API: \(apiResponse.api)")
}
GuardShelterCommand(apiResponse: apiResponse).execute()
editorStore: ServerDataStore.oneTimeEditor())
}
-
- private enum MaterialAPI: String {
-
- case port = "/kcsapi/api_port/port"
- case kousyouCreateItem = "/kcsapi/api_req_kousyou/createitem"
- case kousyouDestoroyShip = "/kcsapi/api_req_kousyou/destroyship"
- case kousyouRemodelSlot = "/kcsapi/api_req_kousyou/remodel_slot"
- case hokyuCharge = "/kcsapi/api_req_hokyu/charge"
- }
-
private class func dataKeys(_ apiResponse: APIResponse) -> [String] {
-
- guard let materialApi = MaterialAPI(rawValue: apiResponse.api) else { return ["api_data"] }
-
- switch materialApi {
- case .port: return ["api_data", "api_material"]
+
+ switch apiResponse.api.endpoint {
- case .kousyouCreateItem: return ["api_data", "api_material"]
+ case .material: return ["api_data"]
- case .kousyouDestoroyShip: return ["api_data", "api_material"]
+ case .port, .createItem, .destroyShip, .charge: return ["api_data", "api_material"]
- case .kousyouRemodelSlot: return ["api_data", "api_after_material"]
+ case .remodelSlot: return ["api_data", "api_after_material"]
- case .hokyuCharge: return ["api_data", "api_material"]
+ default: return Logger.shared.log("Missing API: \(apiResponse.api)", value: ["api_data"])
}
}
final class MemberBasicCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_get_member/basic" { return true }
-
- return false
+ return api.endpoint == .basic
}
override func execute() {
final class MemberDeckCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_get_member/deck" { return true }
- if api == "/kcsapi/api_get_member/deck_port" { return true }
- if api == "/kcsapi/api_req_hensei/preset_select" { return true }
-
- return false
+ return api.type == .deck
}
override func execute() {
final class MemberKDockCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_get_member/kdock" { return true }
-
- return false
+ return api.endpoint == .kdock
}
override func execute() {
final class MemberMaterialCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_get_member/material" { return true }
-
- return false
+ return api.endpoint == .material
}
override func execute() {
final class MemberNDockCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_get_member/ndock" { return true }
-
- return false
+ return api.endpoint == .ndock
}
override func execute() {
final class MemberRequireInfoCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_get_member/require_info" { return true }
-
- return false
+ return api.endpoint == .requireInfo
}
override func execute() {
final class MemberShip2Command: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_get_member/ship2" { return true }
-
- return false
+ return api.endpoint == .ship2
}
override func execute() {
final class MemberShip3Command: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_get_member/ship3" { return true }
-
- return false
+ return api.endpoint == .ship3
}
override func execute() {
final class MemberShipCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_get_member/ship" { return true }
-
- return false
+ return api.endpoint == .ship
}
override func execute() {
final class MemberSlotItemCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_get_member/slot_item" { return true }
-
- return false
+ return api.endpoint == .slotItem
}
override func execute() {
editorStore: ServerDataStore.oneTimeEditor())
}
-
- private enum DeckAPI: String {
-
- case getMemberNDock = "/kcsapi/api_get_member/ndock"
- case port = "/kcsapi/api_port/port"
- }
-
private class func dataKeys(_ apiResponse: APIResponse) -> [String] {
- guard let deckApi = DeckAPI(rawValue: apiResponse.api) else { return ["api_data"] }
-
- switch deckApi {
+ switch apiResponse.api.endpoint {
+
case .port: return ["api_data", "api_ndock"]
- case .getMemberNDock: return ["api_data"]
+ case .ndock: return ["api_data"]
+
+ default: return Logger.shared.log("Missing API: \(apiResponse.api)", value: ["api_data"])
}
}
}
final class NyukyoSpeedChangeCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_req_nyukyo/speedchange" { return true }
-
- return false
+ return api.endpoint == .speedChange
}
override func execute() {
final class NyukyoStartCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_req_nyukyo/start" { return true }
-
- return false
+ return api.endpoint == .startNyukyo
}
override func execute() {
import Cocoa
-enum PortAPI: String {
-
- case port = "/kcsapi/api_port/port"
-}
-
final class PortCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- return PortAPI(rawValue: api) != nil ? true : false
+ return api.type == .port
}
override func execute() {
final class PowerUpCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_req_kaisou/powerup" { return true }
-
- return false
+ return api.endpoint == .powerup
}
override func execute() {
final class QuestListCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_get_member/questlist" { return true }
-
- return false
+ return api.endpoint == .questList
}
override func execute() {
final class RemodelSlotCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_req_kousyou/remodel_slot" { return true }
-
- return false
+ return api.endpoint == .remodelSlot
}
override func execute() {
final class SetActionCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_req_air_corps/set_action" { return true }
-
- return false
+ return api.endpoint == .setAction
}
override func execute() {
final class SetPlaneCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_req_air_corps/set_plane" { return true }
-
- return false
+ return api.endpoint == .setPlane
}
override func execute() {
final class ShipDeckCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_get_member/ship_deck" { return true }
-
- return false
+ return api.endpoint == .shipDeck
}
override func execute() {
ShipMapper(apiResponse).commit()
DeckMapper(apiResponse).commit()
DummyShipCommand(apiResponse: apiResponse).execute()
- GuardShelterCommand(apiResponse: apiResponse).execute()
DropShipHistoryCommand(apiResponse: apiResponse).execute()
}
}
"api_fuel_max", "api_bull_max"])
// kaisouSlotDepriveでは同時に２種類のデータが入る
- if let api = ShipAPI(rawValue: apiResponse.api), api == .kaisouSlotDeprive {
+ if apiResponse.api.endpoint == .slotDeprive {
let conf = self.configuration.change(dataKeys: ["api_data", "api_ship_data", "api_unset_ship"])
ShipMapper(apiResponse, configuration: conf).commit()
self.configuration = configuration
}
-
- private enum ShipAPI: String {
-
- case getMemberShip = "/kcsapi/api_get_member/ship"
- case port = "/kcsapi/api_port/port"
- case getMemberShip3 = "/kcsapi/api_get_member/ship3"
- case kousyouGetShip = "/kcsapi/api_req_kousyou/getship"
- case getMemberShipDeck = "/kcsapi/api_get_member/ship_deck"
- case kaisouPowerUp = "/kcsapi/api_req_kaisou/powerup"
- case kaisouSlotDeprive = "/kcsapi/api_req_kaisou/slot_deprive"
- }
-
private class func dataKeys(_ apiResponse: APIResponse) -> [String] {
- guard let shipApi = ShipAPI(rawValue: apiResponse.api) else { return ["api_data"] }
-
- switch shipApi {
- case .port: return ["api_data", "api_ship"]
-
- case .getMemberShip3: return ["api_data", "api_ship_data"]
+ switch apiResponse.api.endpoint {
- case .kousyouGetShip: return ["api_data", "api_ship"]
+ case .port, .getShip, .powerup: return ["api_data", "api_ship"]
- case .getMemberShipDeck: return ["api_data", "api_ship_data"]
+ case .ship3, .shipDeck: return ["api_data", "api_ship_data"]
- case .kaisouPowerUp: return ["api_data", "api_ship"]
+ case .slotDeprive: return ["api_data", "api_ship_data", "api_set_ship"]
- case .kaisouSlotDeprive: return ["api_data", "api_ship_data", "api_set_ship"]
+ case .ship: return ["api_data"]
- case .getMemberShip: return ["api_data"]
+ default: return Logger.shared.log("Missing API: \(apiResponse.api)", value: ["api_data"])
}
}
}()
private var isDeleteNotExist: Bool {
- guard let shipApi = ShipAPI(rawValue: apiResponse.api) else { return true }
-
- switch shipApi {
- case .getMemberShip3, .kousyouGetShip, .getMemberShipDeck,
- .kaisouPowerUp, .kaisouSlotDeprive:
+ switch apiResponse.api.endpoint {
+ case .ship3, .getShip, .shipDeck,
+ .powerup, .slotDeprive:
return false
default:
final class SlotDepriveCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_req_kaisou/slot_deprive" { return true }
-
- return false
+ return api.endpoint == .slotDeprive
}
override func execute() {
editorStore: ServerDataStore.oneTimeEditor())
}
-
- private enum SlotItemAPI: String {
-
- case getMemberSlotItem = "/kcsapi/api_get_member/slot_item"
- case kousyouGetShip = "/kcsapi/api_req_kousyou/getship"
- case getMemberRequireInfo = "/kcsapi/api_get_member/require_info"
- }
-
private class func dataKeys(_ apiResponse: APIResponse) -> [String] {
- guard let slotItemApi = SlotItemAPI(rawValue: apiResponse.api) else { return ["api_data"] }
-
- switch slotItemApi {
- case .kousyouGetShip: return ["api_data", "api_slotitem"]
+ switch apiResponse.api.endpoint {
+
+ case .getShip: return ["api_data", "api_slotitem"]
- case .getMemberRequireInfo: return ["api_data", "api_slot_item"]
+ case .requireInfo: return ["api_data", "api_slot_item"]
- case .getMemberSlotItem: return ["api_data"]
+ case .slotItem: return ["api_data"]
+
+ default: return Logger.shared.log("Missing API: \(apiResponse.api)", value: ["api_data"])
}
}
func finishOperating() {
// getshipの時は取得した艦娘の装備のみのデータのため無視
- if let slotItemApi = SlotItemAPI(rawValue: apiResponse.api),
- slotItemApi == .kousyouGetShip {
+ if apiResponse.api.endpoint == .getShip {
return
-
}
guard let store = configuration.editorStore as? ServerDataStore else { return }
final class SlotResetCommand: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_req_kaisou/slot_exchange_index" { return true }
-
- return false
+ return api.endpoint == .exchangeIndex
}
override func execute() {
final class Start2Command: JSONCommand {
- override class func canExecuteAPI(_ api: String) -> Bool {
+ override class func canExecuteAPI(_ api: API) -> Bool {
- if api == "/kcsapi/api_start2" { return true }
-
- return false
+ return api.endpoint == .start2
}
override func execute() {
]
let param = Parameter(paramValue)
- let api = APIResponse(api: MapAPI.start.rawValue, parameter: param, json: json)
+ let api = APIResponse(api: API(rawValue: RawAPI.start.rawValue), parameter: param, json: json)
XCTAssertEqual(api.json, json)
XCTAssertEqual(api.parameter, param)
]
guard let json = JSON(rawValue: rawValue) else { return XCTFail("json is nil") }
let param = Parameter(["Test": "Test"])
- let api = APIResponse(api: BattleAPI.combinedBattle.rawValue, parameter: param, json: json)
+ let api = APIResponse(api: API(rawValue: RawAPI.combinedBattle.rawValue), parameter: param, json: json)
let command = BattleCommand(apiResponse: api)
command.execute()
]
guard let json = JSON(rawValue: rawValue) else { return XCTFail("json is nil") }
let param = Parameter(["Test": "Test"])
- let api = APIResponse(api: BattleAPI.combinedMidnightBattle.rawValue, parameter: param, json: json)
+ let api = APIResponse(api: API(rawValue: RawAPI.combinedMidnightBattle.rawValue), parameter: param, json: json)
let command = BattleCommand(apiResponse: api)
command.execute()
]
guard let json = JSON(rawValue: rawValue) else { return XCTFail("json is nil") }
let param = Parameter(["Test": "Test"])
- let api = APIResponse(api: BattleAPI.combinedBattleResult.rawValue, parameter: param, json: json)
+ let api = APIResponse(api: API(rawValue: RawAPI.combinedBattleResult.rawValue), parameter: param, json: json)
let command = BattleCommand(apiResponse: api)
command.execute()
guard let json = JSON(rawValue: rawValue) else { return XCTFail("json is nil") }
let param = Parameter(["Test": "Test"])
- let resultApi = APIResponse(api: BattleAPI.battleResult.rawValue, parameter: param, json: json)
+ let resultApi = APIResponse(api: API(rawValue: RawAPI.battleResult.rawValue), parameter: param, json: json)
GuardShelterCommand(apiResponse: resultApi).execute()
- let goBackApi = APIResponse(api: GuardEscapeAPI.goback.rawValue, parameter: param, json: json)
+ let goBackApi = APIResponse(api: API(rawValue: RawAPI.goback.rawValue), parameter: param, json: json)
GuardShelterCommand(apiResponse: goBackApi).execute()
}
guard let json = JSON(rawValue: rawValue) else { return XCTFail("json is nil") }
let param = Parameter(["Test": "Test"])
- let resultApi = APIResponse(api: BattleAPI.battleResult.rawValue, parameter: param, json: json)
+ let resultApi = APIResponse(api: API(rawValue: RawAPI.battleResult.rawValue), parameter: param, json: json)
GuardShelterCommand(apiResponse: resultApi).execute()
- let goBackApi = APIResponse(api: GuardEscapeAPI.gobakAlone.rawValue, parameter: param, json: json)
+ let goBackApi = APIResponse(api: API(rawValue: RawAPI.gobakAlone.rawValue), parameter: param, json: json)
GuardShelterCommand(apiResponse: goBackApi).execute()
}
let param = Parameter(paramValue)
XCTAssertEqual(param["api_deck_id"].string, "\(fleet)")
- let api = APIResponse(api: MapAPI.start.rawValue, parameter: param, json: json)
+ let api = APIResponse(api: API(endpointPath: Endpoint.start.rawValue), parameter: param, json: json)
XCTAssertEqual(api.json, json)
XCTAssertEqual(api.parameter, param)
]
guard let json = JSON(rawValue: rawValue) else { return XCTFail("json is nil") }
let param = Parameter(["Test": "Test"])
- let api = APIResponse(api: BattleAPI.battle.rawValue, parameter: param, json: json)
+ let api = APIResponse(api: API(endpointPath: Endpoint.battle.rawValue), parameter: param, json: json)
let command = BattleCommand(apiResponse: api)
command.execute()
]
guard let json = JSON(rawValue: rawValue) else { return XCTFail("json is nil") }
let param = Parameter(["Test": "Test"])
- let api = APIResponse(api: BattleAPI.midnightBattle.rawValue, parameter: param, json: json)
+ let api = APIResponse(api: API(endpointPath: Endpoint.midnightBattle.rawValue), parameter: param, json: json)
let command = BattleCommand(apiResponse: api)
command.execute()
]
guard let json = JSON(rawValue: rawValue) else { return XCTFail("json is nil") }
let param = Parameter(["Test": "Test"])
- let api = APIResponse(api: BattleAPI.battleResult.rawValue, parameter: param, json: json)
+ let api = APIResponse(api: API(endpointPath: Endpoint.battleResult.rawValue), parameter: param, json: json)
let command = BattleCommand(apiResponse: api)
command.execute()
]
guard let json = JSON(rawValue: rawValue) else { return XCTFail("json is nil") }
let param = Parameter(["Test": "Test"])
- let api = APIResponse(api: BattleAPI.midnightBattle.rawValue, parameter: param, json: json)
+ let api = APIResponse(api: API(endpointPath: Endpoint.midnightBattle.rawValue), parameter: param, json: json)
let command = BattleCommand(apiResponse: api)
command.execute()
]
guard let json = JSON(rawValue: rawValue) else { return XCTFail("json is nil") }
let param = Parameter(["Test": "Test"])
- let api = APIResponse(api: BattleAPI.battleResult.rawValue, parameter: param, json: json)
+ let api = APIResponse(api: API(endpointPath: Endpoint.battleResult.rawValue), parameter: param, json: json)
let command = BattleCommand(apiResponse: api)
command.execute()
OSDN Git Service
