KCD/TSVSupport.swift

   1 //
   2 //  File.swift
   3 //  KCD
   4 //
   5 //  Created by Hori,Masaki on 2017/02/05.
   6 //  Copyright © 2017年 Hori,Masaki. All rights reserved.
   7 //
   8
   9 import Cocoa
  10 import Doutaku
  11
  12 private struct LFSeparateLine {
  13
  14     static let empty = LFSeparateLine(line: "", empty: true)
  15
  16     let line: String
  17
  18     private let isEmpty: Bool
  19
  20     init(line: String, empty: Bool = false) {
  21
  22         self.line = line
  23         isEmpty = empty
  24     }
  25
  26     func append(_ column: String) -> LFSeparateLine {
  27
  28         if isEmpty { return LFSeparateLine(line: column) }
  29
  30         let newLine = line + "\t" + column
  31
  32         return LFSeparateLine(line: newLine)
  33     }
  34
  35     func append(_ dateCol: Date) -> LFSeparateLine {
  36
  37         return append("\(dateCol)")
  38     }
  39
  40     func append(_ intCol: Int) -> LFSeparateLine {
  41
  42         return append("\(intCol)")
  43     }
  44
  45     func append(_ boolCol: Bool) -> LFSeparateLine {
  46
  47         return append("\(boolCol)")
  48     }
  49 }
  50
  51 final class TSVSupport {
  52
  53     private let store = LocalDataStore.oneTimeEditor()
  54
  55     private var dateFomatter: DateFormatter = {
  56
  57         let formatter = DateFormatter()
  58         formatter.dateFormat = "yyyy'-'MM'-'dd' 'HH':'mm':'ss' 'Z"
  59         return formatter
  60     }()
  61
  62     func load() {
  63
  64         let panel = NSOpenPanel()
  65         panel.allowedFileTypes = ["kcdlocaldata"]
  66         panel.begin {
  67
  68             guard $0 == .OK else { return }
  69
  70             panel.urls.forEach { url in
  71
  72                 guard let fileW = try? FileWrapper(url: url) else { return }
  73
  74                 fileW.fileWrappers?.forEach {
  75
  76                     guard let data = $0.value.regularFileContents else { return }
  77
  78                     switch $0.key {
  79                     case "kaihatu.tsv": self.registerKaihatuHistory(data)
  80                     case "kenzo.tsv": self.registerKenzoHistory(data)
  81                     case "kenzoMark.tsv": self.registerKenzoMark(data)
  82                     case "dropShip.tsv": self.registerDropShipHistory(data)
  83                     default: break
  84                     }
  85                 }
  86
  87             }
  88         }
  89     }
  90
  91     func save() {
  92
  93         let panel = NSSavePanel()
  94         panel.allowedFileTypes = ["kcdlocaldata"]
  95         panel.begin {
  96
  97             guard $0 == .OK else { return }
  98             guard let url = panel.url else { return }
  99
 100             let data = self.store.sync { () -> (Data, Data, Data, Data)? in
 101
 102                 guard let kaihatuHistory = self.dataOfKaihatuHistory() else { return nil }
 103                 guard let kenzoHistory = self.dataOfKenzoHistory() else { return nil }
 104                 guard let kenzoMark = self.dataOfKenzoMark() else { return nil }
 105                 guard let dropShipHistory = self.dataOfDropShipHistory() else { return nil }
 106
 107                 return (kaihatuHistory, kenzoHistory, kenzoMark, dropShipHistory)
 108             }
 109             guard let (kaihatuHistory, kenzoHistory, kenzoMark, dropShipHistory) = data else { return }
 110
 111             let fileW = FileWrapper(directoryWithFileWrappers: [:])
 112             fileW.addRegularFile(withContents: kaihatuHistory, preferredFilename: "kaihatu.tsv")
 113             fileW.addRegularFile(withContents: kenzoHistory, preferredFilename: "kenzo.tsv")
 114             fileW.addRegularFile(withContents: kenzoMark, preferredFilename: "kenzoMark.tsv")
 115             fileW.addRegularFile(withContents: dropShipHistory, preferredFilename: "dropShip.tsv")
 116             do {
 117
 118                 try fileW.write(to: url, originalContentsURL: nil)
 119
 120             } catch {
 121
 122                 print("Error to write")
 123             }
 124         }
 125     }
 126
 127     private func localData<T, Value>(_ entity: Entity<T>, sortBy: KeyPath<T, Value>) -> [T] {
 128
 129         let sortDesc = SortDescriptors(keyPath: sortBy, ascending: true)
 130
 131         guard let array = try? store.objects(of: entity, sortDescriptors: sortDesc) else {
 132
 133             print("Can not get \(entity)")
 134             return []
 135         }
 136
 137         return array
 138     }
 139
 140     private func dataOfKaihatuHistory() -> Data? {
 141
 142         return localData(KaihatuHistory.entity, sortBy: \KaihatuHistory.date)
 143             .map {
 144                 LFSeparateLine.empty
 145                     .append($0.date)
 146                     .append($0.fuel)
 147                     .append($0.bull)
 148                     .append($0.steel)
 149                     .append($0.bauxite)
 150                     .append($0.kaihatusizai)
 151                     .append($0.name)
 152                     .append($0.flagShipName)
 153                     .append($0.flagShipLv)
 154                     .append($0.commanderLv)
 155                     .line
 156             }
 157             .joined(separator: "\n")
 158             .data(using: .utf8)
 159     }
 160
 161     private func dataOfKenzoHistory() -> Data? {
 162
 163         return localData(KenzoHistory.entity, sortBy: \KenzoHistory.date)
 164             .map {
 165             LFSeparateLine.empty
 166                 .append($0.date)
 167                 .append($0.fuel)
 168                 .append($0.bull)
 169                 .append($0.steel)
 170                 .append($0.bauxite)
 171                 .append($0.kaihatusizai)
 172                 .append($0.name)
 173                 .append($0.sTypeId)
 174                 .append($0.flagShipName)
 175                 .append($0.flagShipLv)
 176                 .append($0.commanderLv)
 177                 .line
 178             }
 179             .joined(separator: "\n")
 180             .data(using: .utf8)
 181     }
 182
 183     private func dataOfKenzoMark() -> Data? {
 184
 185         return localData(KenzoMark.entity, sortBy: \KenzoMark.kDockId)
 186             .map {
 187             LFSeparateLine.empty
 188                 .append($0.date)
 189                 .append($0.fuel)
 190                 .append($0.bull)
 191                 .append($0.steel)
 192                 .append($0.bauxite)
 193                 .append($0.kaihatusizai)
 194                 .append($0.created_ship_id)
 195                 .append($0.kDockId)
 196                 .append($0.flagShipName)
 197                 .append($0.flagShipLv)
 198                 .append($0.commanderLv)
 199                 .line
 200             }
 201             .joined(separator: "\n")
 202             .data(using: .utf8)
 203     }
 204
 205     private func dataOfDropShipHistory() -> Data? {
 206
 207         return localData(DropShipHistory.entity, sortBy: \DropShipHistory.date)
 208             .map {
 209                 LFSeparateLine.empty
 210                     .append($0.date)
 211                     .append($0.shipName)
 212                     .append($0.mapArea)
 213                     .append($0.mapInfo)
 214                     .append($0.mapCell)
 215                     .append($0.mapAreaName)
 216                     .append($0.mapInfoName)
 217                     .append($0.mark)
 218                     .append($0.winRank)
 219                     .line
 220             }
 221             .joined(separator: "\n")
 222             .data(using: .utf8)
 223     }
 224
 225     private func registerKaihatuHistory(_ data: Data) {
 226
 227         let array = String(data: data, encoding: .utf8)?.components(separatedBy: "\n")
 228         array?.forEach {
 229
 230             let attr = $0.components(separatedBy: "\t")
 231
 232             guard attr.count == 10 else { return }
 233             guard let date = dateFomatter.date(from: attr[0]) else { return }
 234             guard let fuel = Int(attr[1]) else { return }
 235             guard let bull = Int(attr[2]) else { return }
 236             guard let steel = Int(attr[3]) else { return }
 237             guard let bauxite = Int(attr[4]) else { return }
 238             guard let kaihatu = Int(attr[5]) else { return }
 239             guard let flagLv = Int(attr[8]) else { return }
 240             guard let commandLv = Int(attr[9]) else { return }
 241
 242             let predicate = Predicate(\KaihatuHistory.date, equalTo: date)
 243
 244             guard let oo = try? store.objects(of: KaihatuHistory.entity, predicate: predicate) else { return }
 245             guard oo.count != 0 else { return }
 246             guard let obj = store.insertNewObject(for: KaihatuHistory.entity) else { return }
 247
 248             obj.date = date
 249             obj.fuel = fuel
 250             obj.bull = bull
 251             obj.steel = steel
 252             obj.bauxite = bauxite
 253             obj.kaihatusizai = kaihatu
 254             obj.name = attr[6]
 255             obj.flagShipName = attr[7]
 256             obj.flagShipLv = flagLv
 257             obj.commanderLv = commandLv
 258         }
 259     }
 260
 261     private func registerKenzoHistory(_ data: Data) {
 262
 263         let array = String(data: data, encoding: .utf8)?.components(separatedBy: "\n")
 264
 265         array?.forEach {
 266
 267             let attr = $0.components(separatedBy: "\t")
 268
 269             guard attr.count == 11 else { return }
 270             guard let date = dateFomatter.date(from: attr[0]) else { return }
 271             guard let fuel = Int(attr[1]) else { return }
 272             guard let bull = Int(attr[2]) else { return }
 273             guard let steel = Int(attr[3]) else { return }
 274             guard let bauxite = Int(attr[4]) else { return }
 275             guard let kaihatu = Int(attr[5]) else { return }
 276             guard let sType = Int(attr[7]) else { return }
 277             guard let flagLv = Int(attr[9]) else { return }
 278             guard let commandLv = Int(attr[10]) else { return }
 279
 280             let predicate = Predicate(\KenzoHistory.date, equalTo: date)
 281
 282             guard let oo = try? store.objects(of: KenzoHistory.entity, predicate: predicate) else { return }
 283             guard oo.count != 0 else { return }
 284             guard let obj = store.insertNewObject(for: KenzoHistory.entity) else { return }
 285
 286             obj.date = date
 287             obj.fuel = fuel
 288             obj.bull = bull
 289             obj.steel = steel
 290             obj.bauxite = bauxite
 291             obj.kaihatusizai = kaihatu
 292             obj.name = attr[6]
 293             obj.sTypeId = sType
 294             obj.flagShipName = attr[8]
 295             obj.flagShipLv = flagLv
 296             obj.commanderLv = commandLv
 297         }
 298     }
 299
 300     private func registerKenzoMark( _ data: Data) {
 301
 302         let array = String(data: data, encoding: .utf8)?.components(separatedBy: "\n")
 303
 304         array?.forEach {
 305
 306             let attr = $0.components(separatedBy: "\t")
 307
 308             guard attr.count == 11 else { return }
 309             guard let date = dateFomatter.date(from: attr[0]) else { return }
 310             guard let fuel = Int(attr[1]) else { return }
 311             guard let bull = Int(attr[2]) else { return }
 312             guard let steel = Int(attr[3]) else { return }
 313             guard let bauxite = Int(attr[4]) else { return }
 314             guard let kaihatu = Int(attr[5]) else { return }
 315             guard let shiId = Int(attr[6]) else { return }
 316             guard let kDock = Int(attr[7]) else { return }
 317             guard let flagLv = Int(attr[9]) else { return }
 318             guard let commandLv = Int(attr[10]) else { return }
 319
 320             let predicate = Predicate(\KenzoMark.date, equalTo: date)
 321
 322             guard let oo = try? store.objects(of: KenzoMark.entity, predicate: predicate) else { return }
 323             guard oo.count != 0 else { return }
 324             guard let obj = store.insertNewObject(for: KenzoMark.entity) else { return }
 325
 326             obj.date = date
 327             obj.fuel = fuel
 328             obj.bull = bull
 329             obj.steel = steel
 330             obj.bauxite = bauxite
 331             obj.kaihatusizai = kaihatu
 332             obj.created_ship_id = shiId
 333             obj.kDockId = kDock
 334             obj.flagShipName = attr[8]
 335             obj.flagShipLv = flagLv
 336             obj.commanderLv = commandLv
 337         }
 338     }
 339
 340     private func registerDropShipHistory( _ data: Data) {
 341
 342         let array = String(data: data, encoding: .utf8)?.components(separatedBy: "\n")
 343
 344         array?.forEach {
 345
 346             let attr = $0.components(separatedBy: "\t")
 347
 348             guard attr.count == 9 else { return }
 349             guard let date = dateFomatter.date(from: attr[0]) else { return }
 350             guard let mapInfo = Int(attr[3]) else { return }
 351             guard let mapCell = Int(attr[4]) else { return }
 352             guard let mark = Int(attr[7]) else { return }
 353
 354             let predicate = Predicate(\DropShipHistory.date, equalTo: date)
 355
 356             guard let oo = try? store.objects(of: DropShipHistory.entity, predicate: predicate) else { return }
 357             guard oo.count != 0 else { return }
 358             guard let obj = store.insertNewObject(for: DropShipHistory.entity) else { return }
 359
 360             obj.date = date
 361             obj.shipName = attr[1]
 362             obj.mapArea = attr[2]
 363             obj.mapInfo = mapInfo
 364             obj.mapCell = mapCell
 365             obj.mapAreaName = attr[5]
 366             obj.mapInfoName = attr[6]
 367             obj.mark = mark != 0
 368             obj.winRank = attr[8]
 369         }
 370     }
 371 }