Small progress on syncing shows

CouchTrackerSync/CouchTrackerSync.swift

@@ -1,23 +1,56 @@
+import TraktSwift
 import RxSwift
+import Moya
 
-enum SyncState {
-  case notSyncing
-  case started
+enum SyncError: Error {
+  case showIsNil
 }
 
-struct SyncData {
-  var state: SyncState
-}
+struct WatchedProgressOptions {
+  let hidden: Bool
+  let specials: Bool
+  let countSpecials: Bool
 
-enum SyncAction {
-  case start
+  init(hidden: Bool = false, specials: Bool = false, countSpecials: Bool = false) {
+    self.hidden = hidden
+    self.specials = specials
+    self.countSpecials = countSpecials
+  }
 }
 
-func syncReducer(syncData: inout SyncData, action: SyncAction) -> [Observable<SyncAction>] {
-  switch action {
-  case .start:
-    syncData.state = .started
+struct SyncOptions {
+  let watchedProgress: WatchedProgressOptions
+
+  init(watchedProgress: WatchedProgressOptions = WatchedProgressOptions()) {
+    self.watchedProgress = watchedProgress
   }
+}
+
+func startSync(options: SyncOptions) -> Observable<BaseShow> {
+  return syncMain(options)
+}
+
+private func syncMain(_ options: SyncOptions) -> Observable<BaseShow> {
+  return Current.syncWatchedShows(.noSeasons)
+    .flatMap { Observable.from($0) }
+    .flatMap { watchedProgress(options: options.watchedProgress, baseShow: $0) }
+}
+
+private func watchedProgress(options: WatchedProgressOptions, baseShow: BaseShow) -> Observable<BaseShow> {
+  guard let show = baseShow.show else { return Observable.error(SyncError.showIsNil) }
+  return Current.watchedProgress(options, show.ids).map { merge(syncBaseShow: baseShow, progressBaseShow: $0) }
+}
 
-  return []
+private func merge(syncBaseShow: BaseShow, progressBaseShow: BaseShow) -> BaseShow {
+  BaseShow(show: syncBaseShow.show,
+           seasons: progressBaseShow.seasons,
+           lastCollectedAt: nil,
+           listedAt: nil,
+           plays: syncBaseShow.plays,
+           lastWatchedAt: progressBaseShow.lastWatchedAt,
+           aired: progressBaseShow.aired,
+           completed: progressBaseShow.completed,
+           hiddenSeasons: progressBaseShow.hiddenSeasons,
+           nextEpisode: progressBaseShow.nextEpisode,
+           lastEpisode: progressBaseShow.lastEpisode)
 }

CouchTrackerSync/SyncEnvironment.swift

@@ -1,31 +1,41 @@
 import TraktSwift
 import RxSwift
 
-struct SyncEnvironment {
-  var networkScheduler: SchedulerType
-  var trakt: TraktProvider
+let traktBuilder = TraktBuilder {
+  $0.clientId = Secrets.Trakt.clientId
+  $0.clientSecret = Secrets.Trakt.clientSecret
+  $0.redirectURL = Secrets.Trakt.redirectURL
+  $0.callbackQueue = DispatchQueue(label: "NetworkQueue", qos: .default)
 }
 
-extension SyncEnvironment {
-  static let live: SyncEnvironment = {
-    let networkQueue = DispatchQueue(label: "NetworkQueue", qos: .default)
+private let trakt = Trakt(builder: traktBuilder)
 
-    let traktBuilder = TraktBuilder {
-      $0.clientId = Secrets.Trakt.clientId
-      $0.clientSecret = Secrets.Trakt.clientSecret
-      $0.redirectURL = Secrets.Trakt.redirectURL
-      $0.callbackQueue = networkQueue
-    }
+struct SyncEnvironment {
+  var syncWatchedShows: (Extended) -> Observable<[BaseShow]>
+  var watchedProgress: (WatchedProgressOptions, ShowIds) -> Observable<BaseShow>
+}
 
-    return SyncEnvironment(
-      networkScheduler: ConcurrentDispatchQueueScheduler(queue: networkQueue),
-      trakt: Trakt(builder: traktBuilder)
-    )
-  }()
+extension SyncEnvironment {
+  static let live = SyncEnvironment(syncWatchedShows: syncWatchedShows(extended:), watchedProgress: watchedProgress(options:showIds:))
 }
 
 #if DEBUG
 var Current = SyncEnvironment.live
 #else
 let Current = SyncEnvironment.live
 #endif
+
+private func syncWatchedShows(extended: Extended) -> Observable<[BaseShow]> {
+  return trakt.sync.rx.request(.watched(type: .shows, extended: extended)).map([BaseShow].self).asObservable()
+}
+
+private func watchedProgress(options: WatchedProgressOptions, showIds: ShowIds) -> Observable<BaseShow> {
+  return trakt.shows.rx.request(
+    .watchedProgress(
+      showId: showIds.realId,
+      hidden: options.countSpecials,
+      specials: options.countSpecials,
+      countSpecials: options.countSpecials
+    )
+  ).map(BaseShow.self).asObservable()
+}

CouchTrackerSyncTests/SyncWatchedShows/SyncWatchedShowsTests.swift → CouchTrackerSyncTests/CouchTrackerSyncTests.swift

@@ -9,35 +9,37 @@ import RxNimble
 
 @testable import CouchTrackerSync
 
-final class SyncWatchedShowsTests: XCTestCase {
-  private var originalTrakt: TraktProvider!
+final class CouchTrackerSyncTests: XCTestCase {
   private var scheduler: TestScheduler!
   private var disposeBag: DisposeBag!
 
   override func setUp() {
     super.setUp()
 
     disposeBag = DisposeBag()
-    originalTrakt = Current.trakt
     scheduler = TestScheduler(initialClock: 0)
   }
 
   override func tearDown() {
-    Current.trakt = originalTrakt
     scheduler = nil
     disposeBag = nil
     super.tearDown()
   }
 
-  func testSyncWatchedShows() throws {
-    let data = contentsOf(file: "SyncWatchedShowsSuccess")
-    let responseStubbed = EndpointSampleResponse.networkResponse(200, data)
-    let trakt: SyncTestableTrakt<Sync> = makeTestableTrakt(responseStubbed)
-    Current.trakt = trakt
+  func testSync() {
+    Current.syncWatchedShows = { _ in
+      Observable.just(decode(file: "syncWatchedShows-Success", as: [BaseShow].self))
+    }
 
-    let expectedShows = try JSONDecoder().decode([BaseShow].self, from: data)
+    Current.watchedProgress = { _, _ in
+      Observable.just(decode(file: "watchedProgress-Success", as: BaseShow.self))
+    }
 
-    expect(syncWatchedShows())
+    let expectedShows = decode(file: "baseShow-Success", as: BaseShow.self)
+
+    let observable = startSync(options: SyncOptions())
+
+    expect(observable)
       .events(scheduler: scheduler, disposeBag: disposeBag)
       .to(equal([
         Recorded.next(0, expectedShows),