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
  60         return formatter
  61     }()
  62
  63     func load() {
  64
  65         let panel = NSOpenPanel()
  66         panel.allowedFileTypes = ["kcdlocaldata"]
  67         panel.begin {
  68
  69             guard $0 == .OK else {
  70
  71                 return
  72             }
  73
  74             panel.urls.forEach { url in
  75
  76                 guard let fileW = try? FileWrapper(url: url) else {
  77
  78                     return
  79                 }
  80
  81                 fileW.fileWrappers?.forEach {
  82
  83                     guard let data = $0.value.regularFileContents else {
  84
  85                         return
  86                     }
  87
  88                     switch $0.key {
  89
  90                     case "kaihatu.tsv": self.registerKaihatuHistory(data)
  91
  92                     case "kenzo.tsv": self.registerKenzoHistory(data)
  93
  94                     case "kenzoMark.tsv": self.registerKenzoMark(data)
  95
  96                     case "dropShip.tsv": self.registerDropShipHistory(data)
  97
  98                     default: break
  99
 100                     }
 101                 }
 102
 103             }
 104         }
 105     }
 106
 107     func save() {
 108
 109         let panel = NSSavePanel()
 110         panel.allowedFileTypes = ["kcdlocaldata"]
 111         panel.begin {
 112
 113             guard $0 == .OK else {
 114
 115                 return
 116             }
 117             guard let url = panel.url else {
 118
 119                 return
 120             }
 121
 122             let data = self.store.sync { () -> (Data, Data, Data, Data)? in
 123
 124                 guard let kaihatuHistory = self.dataOfKaihatuHistory() else {
 125
 126                     return nil
 127                 }
 128                 guard let kenzoHistory = self.dataOfKenzoHistory() else {
 129
 130                     return nil
 131                 }
 132                 guard let kenzoMark = self.dataOfKenzoMark() else {
 133
 134                     return nil
 135                 }
 136                 guard let dropShipHistory = self.dataOfDropShipHistory() else {
 137
 138                     return nil
 139                 }
 140
 141                 return (kaihatuHistory, kenzoHistory, kenzoMark, dropShipHistory)
 142             }
 143             guard let (kaihatuHistory, kenzoHistory, kenzoMark, dropShipHistory) = data else {
 144
 145                 return
 146             }
 147
 148             let fileW = FileWrapper(directoryWithFileWrappers: [:])
 149             fileW.addRegularFile(withContents: kaihatuHistory, preferredFilename: "kaihatu.tsv")
 150             fileW.addRegularFile(withContents: kenzoHistory, preferredFilename: "kenzo.tsv")
 151             fileW.addRegularFile(withContents: kenzoMark, preferredFilename: "kenzoMark.tsv")
 152             fileW.addRegularFile(withContents: dropShipHistory, preferredFilename: "dropShip.tsv")
 153             do {
 154
 155                 try fileW.write(to: url, originalContentsURL: nil)
 156
 157             } catch {
 158
 159                 print("Error to write")
 160             }
 161         }
 162     }
 163
 164     private func localData<ResultType: Entity, Value>(_ type: ResultType.Type, sortBy: KeyPath<ResultType, Value>) -> [ResultType] {
 165
 166         let sortDesc = SortDescriptors(keyPath: sortBy, ascending: true)
 167
 168         guard let array = try? store.objects(of: type, sortDescriptors: sortDesc) else {
 169
 170             print("Can not get \(type)")
 171
 172             return []
 173         }
 174
 175         return array
 176     }
 177
 178     private func dataOfKaihatuHistory() -> Data? {
 179
 180         return localData(KaihatuHistory.self, sortBy: \KaihatuHistory.date)
 181             .map {
 182                 LFSeparateLine.empty
 183                     .append($0.date)
 184                     .append($0.fuel)
 185                     .append($0.bull)
 186                     .append($0.steel)
 187                     .append($0.bauxite)
 188                     .append($0.kaihatusizai)
 189                     .append($0.name)
 190                     .append($0.flagShipName)
 191                     .append($0.flagShipLv)
 192                     .append($0.commanderLv)
 193                     .line
 194             }
 195             .joined(separator: "\n")
 196             .data(using: .utf8)
 197     }
 198
 199     private func dataOfKenzoHistory() -> Data? {
 200
 201         return localData(KenzoHistory.self, sortBy: \KenzoHistory.date)
 202             .map {
 203                 LFSeparateLine.empty
 204                     .append($0.date)
 205                     .append($0.fuel)
 206                     .append($0.bull)
 207                     .append($0.steel)
 208                     .append($0.bauxite)
 209                     .append($0.kaihatusizai)
 210                     .append($0.name)
 211                     .append($0.sTypeId)
 212                     .append($0.flagShipName)
 213                     .append($0.flagShipLv)
 214                     .append($0.commanderLv)
 215                     .line
 216             }
 217             .joined(separator: "\n")
 218             .data(using: .utf8)
 219     }
 220
 221     private func dataOfKenzoMark() -> Data? {
 222
 223         return localData(KenzoMark.self, sortBy: \KenzoMark.kDockId)
 224             .map {
 225                 LFSeparateLine.empty
 226                     .append($0.date)
 227                     .append($0.fuel)
 228                     .append($0.bull)
 229                     .append($0.steel)
 230                     .append($0.bauxite)
 231                     .append($0.kaihatusizai)
 232                     .append($0.created_ship_id)
 233                     .append($0.kDockId)
 234                     .append($0.flagShipName)
 235                     .append($0.flagShipLv)
 236                     .append($0.commanderLv)
 237                     .line
 238             }
 239             .joined(separator: "\n")
 240             .data(using: .utf8)
 241     }
 242
 243     private func dataOfDropShipHistory() -> Data? {
 244
 245         return localData(DropShipHistory.self, sortBy: \DropShipHistory.date)
 246             .map {
 247                 LFSeparateLine.empty
 248                     .append($0.date)
 249                     .append($0.shipName)
 250                     .append($0.mapArea)
 251                     .append($0.mapInfo)
 252                     .append($0.mapCell)
 253                     .append($0.mapAreaName)
 254                     .append($0.mapInfoName)
 255                     .append($0.mark)
 256                     .append($0.winRank)
 257                     .line
 258             }
 259             .joined(separator: "\n")
 260             .data(using: .utf8)
 261     }
 262
 263     private func registerKaihatuHistory(_ data: Data) {
 264
 265         let array = String(data: data, encoding: .utf8)?.components(separatedBy: "\n")
 266         array?.forEach {
 267
 268             let attr = $0.components(separatedBy: "\t")
 269
 270             guard attr.count == 10 else {
 271
 272                 return
 273             }
 274             guard let date = dateFomatter.date(from: attr[0]) else {
 275
 276                 return
 277             }
 278             guard let fuel = Int(attr[1]) else {
 279
 280                 return
 281             }
 282             guard let bull = Int(attr[2]) else {
 283
 284                 return
 285             }
 286             guard let steel = Int(attr[3]) else {
 287
 288                 return
 289             }
 290             guard let bauxite = Int(attr[4]) else {
 291
 292                 return
 293             }
 294             guard let kaihatu = Int(attr[5]) else {
 295
 296                 return
 297             }
 298             guard let flagLv = Int(attr[8]) else {
 299
 300                 return
 301             }
 302             guard let commandLv = Int(attr[9]) else {
 303
 304                 return
 305             }
 306
 307             let predicate = Predicate(\KaihatuHistory.date, equalTo: date)
 308
 309             guard let oo = try? store.objects(of: KaihatuHistory.self, predicate: predicate) else {
 310
 311                 return
 312             }
 313             guard oo.count != 0 else {
 314
 315                 return
 316             }
 317             guard let obj = store.insertNewObject(for: KaihatuHistory.self) else {
 318
 319                 return
 320             }
 321
 322             obj.date = date
 323             obj.fuel = fuel
 324             obj.bull = bull
 325             obj.steel = steel
 326             obj.bauxite = bauxite
 327             obj.kaihatusizai = kaihatu
 328             obj.name = attr[6]
 329             obj.flagShipName = attr[7]
 330             obj.flagShipLv = flagLv
 331             obj.commanderLv = commandLv
 332         }
 333     }
 334
 335     private func registerKenzoHistory(_ data: Data) {
 336
 337         let array = String(data: data, encoding: .utf8)?.components(separatedBy: "\n")
 338
 339         array?.forEach {
 340
 341             let attr = $0.components(separatedBy: "\t")
 342
 343             guard attr.count == 11 else {
 344
 345                 return
 346             }
 347             guard let date = dateFomatter.date(from: attr[0]) else {
 348
 349                 return
 350             }
 351             guard let fuel = Int(attr[1]) else {
 352
 353                 return
 354             }
 355             guard let bull = Int(attr[2]) else {
 356
 357                 return
 358             }
 359             guard let steel = Int(attr[3]) else {
 360
 361                 return
 362             }
 363             guard let bauxite = Int(attr[4]) else {
 364
 365                 return
 366             }
 367             guard let kaihatu = Int(attr[5]) else {
 368
 369                 return
 370             }
 371             guard let sType = Int(attr[7]) else {
 372
 373                 return
 374             }
 375             guard let flagLv = Int(attr[9]) else {
 376
 377                 return
 378             }
 379             guard let commandLv = Int(attr[10]) else {
 380
 381                 return
 382             }
 383
 384             let predicate = Predicate(\KenzoHistory.date, equalTo: date)
 385
 386             guard let oo = try? store.objects(of: KenzoHistory.self, predicate: predicate) else {
 387
 388                 return
 389             }
 390             guard oo.count != 0 else {
 391
 392                 return
 393             }
 394             guard let obj = store.insertNewObject(for: KenzoHistory.self) else {
 395
 396                 return
 397             }
 398
 399             obj.date = date
 400             obj.fuel = fuel
 401             obj.bull = bull
 402             obj.steel = steel
 403             obj.bauxite = bauxite
 404             obj.kaihatusizai = kaihatu
 405             obj.name = attr[6]
 406             obj.sTypeId = sType
 407             obj.flagShipName = attr[8]
 408             obj.flagShipLv = flagLv
 409             obj.commanderLv = commandLv
 410         }
 411     }
 412
 413     private func registerKenzoMark( _ data: Data) {
 414
 415         let array = String(data: data, encoding: .utf8)?.components(separatedBy: "\n")
 416
 417         array?.forEach {
 418
 419             let attr = $0.components(separatedBy: "\t")
 420
 421             guard attr.count == 11 else {
 422
 423                 return
 424             }
 425             guard let date = dateFomatter.date(from: attr[0]) else {
 426
 427                 return
 428             }
 429             guard let fuel = Int(attr[1]) else {
 430
 431                 return
 432             }
 433             guard let bull = Int(attr[2]) else {
 434
 435                 return
 436             }
 437             guard let steel = Int(attr[3]) else {
 438
 439                 return
 440             }
 441             guard let bauxite = Int(attr[4]) else {
 442
 443                 return
 444             }
 445             guard let kaihatu = Int(attr[5]) else {
 446
 447                 return
 448             }
 449             guard let shiId = Int(attr[6]) else {
 450
 451                 return
 452             }
 453             guard let kDock = Int(attr[7]) else {
 454
 455                 return
 456             }
 457             guard let flagLv = Int(attr[9]) else {
 458
 459                 return
 460             }
 461             guard let commandLv = Int(attr[10]) else {
 462
 463                 return
 464             }
 465
 466             let predicate = Predicate(\KenzoMark.date, equalTo: date)
 467
 468             guard let oo = try? store.objects(of: KenzoMark.self, predicate: predicate) else {
 469
 470                 return
 471             }
 472             guard oo.count != 0 else {
 473
 474                 return
 475             }
 476             guard let obj = store.insertNewObject(for: KenzoMark.self) else {
 477
 478                 return
 479             }
 480
 481             obj.date = date
 482             obj.fuel = fuel
 483             obj.bull = bull
 484             obj.steel = steel
 485             obj.bauxite = bauxite
 486             obj.kaihatusizai = kaihatu
 487             obj.created_ship_id = shiId
 488             obj.kDockId = kDock
 489             obj.flagShipName = attr[8]
 490             obj.flagShipLv = flagLv
 491             obj.commanderLv = commandLv
 492         }
 493     }
 494
 495     private func registerDropShipHistory( _ data: Data) {
 496
 497         let array = String(data: data, encoding: .utf8)?.components(separatedBy: "\n")
 498
 499         array?.forEach {
 500
 501             let attr = $0.components(separatedBy: "\t")
 502
 503             guard attr.count == 9 else {
 504
 505                 return
 506             }
 507             guard let date = dateFomatter.date(from: attr[0]) else {
 508
 509                 return
 510             }
 511             guard let mapInfo = Int(attr[3]) else {
 512
 513                 return
 514             }
 515             guard let mapCell = Int(attr[4]) else {
 516
 517                 return
 518             }
 519             guard let mark = Int(attr[7]) else {
 520
 521                 return
 522             }
 523
 524             let predicate = Predicate(\DropShipHistory.date, equalTo: date)
 525
 526             guard let oo = try? store.objects(of: DropShipHistory.self, predicate: predicate) else {
 527
 528                 return
 529             }
 530             guard oo.count != 0 else {
 531
 532                 return
 533             }
 534             guard let obj = store.insertNewObject(for: DropShipHistory.self) else {
 535
 536                 return
 537             }
 538
 539             obj.date = date
 540             obj.shipName = attr[1]
 541             obj.mapArea = attr[2]
 542             obj.mapInfo = mapInfo
 543             obj.mapCell = mapCell
 544             obj.mapAreaName = attr[5]
 545             obj.mapInfoName = attr[6]
 546             obj.mark = mark != 0
 547             obj.winRank = attr[8]
 548         }
 549     }
 550 }