KCD/APIResponse.swift

   1 //
   2 //  APIResponse.swift
   3 //  KCD
   4 //
   5 //  Created by Hori,Masaki on 2017/01/20.
   6 //  Copyright © 2017年 Hori,Masaki. All rights reserved.
   7 //
   8
   9 import Cocoa
  10 import SwiftyJSON
  11
  12 extension JSON {
  13
  14     func value(for keyPath: String) -> JSON {
  15
  16         return self[keyPath.components(separatedBy: ".")]
  17     }
  18
  19     var last: JSON {
  20
  21         let index = self.count - 1
  22
  23         return self[index]
  24     }
  25 }
  26
  27 private extension Data {
  28
  29     var utf8String: String? { return String(data: self, encoding: .utf8) }
  30 }
  31
  32 func +<Key, Value> (lhs: [Key: Value], rhs: (Key, Value)) -> [Key: Value] {
  33
  34     var new = lhs
  35     new[rhs.0] = rhs.1
  36
  37     return new
  38 }
  39
  40 private func splitJSON(_ data: Data) -> String? {
  41
  42     let prefix = "svdata="
  43
  44     guard let string = data.utf8String,
  45         let range = string.range(of: prefix) else {
  46
  47             print("data is wrong")
  48             return nil
  49     }
  50
  51     return String(string[range.upperBound...])
  52 }
  53
  54 private func parseParameter(_ request: URLRequest) -> [String: String]? {
  55
  56     return request
  57         .httpBody?
  58         .utf8String?
  59         .removingPercentEncoding?
  60         .components(separatedBy: "&")
  61         .map { $0.components(separatedBy: "=") }
  62         .filter { $0.count == 2 }
  63         .map { (piar: [String]) -> (String, String) in (piar[0], piar[1]) }
  64         .reduce(into: [String: String]()) { (dict: inout [String: String], value: (String, String)) in
  65
  66             dict[value.0] = value.1
  67     }
  68 }
  69
  70 struct ParameterValue {
  71
  72     private let rawValue: String?
  73
  74     var int: Int? { return rawValue.flatMap { Int($0) } }
  75     var double: Double? { return rawValue.flatMap { Double($0) } }
  76     var string: String? { return rawValue }
  77     var bool: Bool? {
  78
  79         guard let _ = rawValue else { return nil }
  80
  81         if let i = self.int {
  82
  83             return i != 0
  84         }
  85
  86         if let s = self.string?.lowercased() {
  87
  88             switch s {
  89             case "true", "yes", "t", "y": return true
  90
  91             default: return false
  92             }
  93         }
  94
  95         return false
  96     }
  97
  98     var valid: Bool { return rawValue != nil }
  99
 100     init(_ rawValue: String?) {
 101
 102         self.rawValue = rawValue
 103     }
 104 }
 105
 106 struct Parameter {
 107
 108     private let rawValue: [String: String]
 109
 110     init(_ rawValue: [String: String]) {
 111
 112         self.rawValue = rawValue
 113     }
 114
 115     init?(_ request: URLRequest) {
 116
 117         guard let paramList = parseParameter(request) else { return nil }
 118
 119         self.init(paramList)
 120     }
 121
 122     subscript(_ key: String) -> ParameterValue {
 123
 124         return ParameterValue(rawValue[key])
 125     }
 126
 127     func map<T>(_ transform: (String, String) throws -> T) rethrows -> [T] {
 128
 129         return try rawValue.map(transform)
 130     }
 131 }
 132
 133 struct APIResponse {
 134
 135     let api: String
 136     let parameter: Parameter
 137     let json: JSON
 138     let date: Date
 139     var success: Bool {
 140
 141         if let r = json["api_result"].int { return r == 1 }
 142
 143         return false
 144     }
 145
 146     init(api: String, parameter: Parameter, json: JSON) {
 147
 148         self.api = api
 149         self.parameter = parameter
 150         self.json = json
 151         self.date = Date()
 152     }
 153
 154     init?(request: URLRequest, data: Data) {
 155
 156         date = Date()
 157
 158         guard let josn = splitJSON(data) else {
 159
 160             print("Can not parse JSON")
 161             return nil
 162         }
 163
 164         self.json = JSON(parseJSON: josn)
 165
 166         guard let parameter = Parameter(request) else {
 167
 168             print("Can not parse Parameter")
 169             return nil
 170         }
 171
 172         self.parameter = parameter
 173
 174         guard let api = request.url?.path else {
 175
 176             print("URLRequest is wrong")
 177             return nil
 178         }
 179
 180         self.api = api
 181     }
 182 }