Merge pull request #17909 from wordpress-mobile/issue/17873-parse-dashboard-response

My Site Dashboard: handle local and remote cards

Author: leandroalonso

WordPress/Classes/ViewRelated/Blog/Blog Dashboard/BlogDashboardViewController.swift

@@ -1,5 +1,11 @@
 import UIKit
 
+typealias DashboardCollectionViewCell = UICollectionViewCell & Reusable & BlogDashboardCardConfigurable
+
+protocol BlogDashboardCardConfigurable {
+    func configure(blog: Blog, viewController: BlogDashboardViewController?, dataModel: NSDictionary?)
+}
+
 final class BlogDashboardViewController: UIViewController {
 
     var blog: Blog
@@ -57,8 +63,9 @@ final class BlogDashboardViewController: UIViewController {
     private func setupCollectionView() {
         collectionView.isScrollEnabled = false
         collectionView.backgroundColor = .listBackground
-        collectionView.register(QuickLinksHostCell.self, forCellWithReuseIdentifier: QuickLinksHostCell.defaultReuseID)
-        collectionView.register(DashboardPostsCardCell.self, forCellWithReuseIdentifier: DashboardPostsCardCell.defaultReuseID)
+        DashboardCard.allCases.forEach {
+            collectionView.register($0.cell, forCellWithReuseIdentifier: $0.cell.defaultReuseID)
+        }
 
         view.addSubview(collectionView)
         view.pinSubviewToAllEdges(collectionView)

WordPress/Classes/ViewRelated/Blog/Blog Dashboard/BlogDashboardViewModel.swift

@@ -1,8 +1,22 @@
 import UIKit
 
-class DashboardPostsCardCell: UICollectionViewCell, Reusable {
-    func configure(_ viewController: UIViewController, blog: Blog) {
+class DashboardPostsCardCell: UICollectionViewCell, Reusable, BlogDashboardCardConfigurable {
+    func configure(blog: Blog, viewController: BlogDashboardViewController?, dataModel: NSDictionary?) {
+        guard let viewController = viewController, let dataModel = dataModel else {
+            return
+        }
+
+        let hasDrafts = dataModel["show_drafts"] as? Bool ?? false
+        let hasScheduled = dataModel["show_scheduled"] as? Bool ?? false
+
         let postsViewController = PostsCardViewController(blog: blog)
+
+        if hasDrafts {
+            postsViewController.status = .draft
+        } else if hasScheduled {
+            postsViewController.status = .scheduled
+        }
+
         viewController.addChild(postsViewController)
         contentView.addSubview(postsViewController.view)
         postsViewController.view.translatesAutoresizingMaskIntoConstraints = false

WordPress/Classes/ViewRelated/Blog/Blog Dashboard/Cards/Posts/DashboardPostsCardCell.swift

@@ -13,7 +13,7 @@ import UIKit
     private var ghostableTableView: UITableView?
     private var errorView: DashboardCardInnerErrorView?
 
-    private let status: BasePost.Status = .draft
+    var status: BasePost.Status = .draft
 
     // TODO: add status as an init param
     @objc init(blog: Blog) {

WordPress/Classes/ViewRelated/Blog/Blog Dashboard/Cards/Posts/PostsCardViewController.swift

@@ -0,0 +1,7 @@
+import UIKit
+
+class DashboardStatsCardCell: UICollectionViewCell, Reusable, BlogDashboardCardConfigurable {
+    func configure(blog: Blog, viewController: BlogDashboardViewController?, dataModel: NSDictionary?) {
+
+    }
+}

WordPress/Classes/ViewRelated/Blog/Blog Dashboard/Cards/Stats/DashboardStatsCardCell.swift

@@ -0,0 +1,47 @@
+import Foundation
+
+/// Describes all the available cards.
+///
+/// Notice that the order here matters and it will take
+/// precedence over the backend.
+///
+/// If the card `isRemote` the `String` should match its
+/// identifier on the backend.
+enum DashboardCard: String, CaseIterable {
+    case quickActions
+    case posts
+    case todaysStats = "todays_stats"
+
+    /// If the card is backed by API data
+    var isRemote: Bool {
+        switch self {
+        case .quickActions:
+            return false
+        case .posts:
+            return true
+        case .todaysStats:
+            return true
+        }
+    }
+
+    var cell: DashboardCollectionViewCell.Type {
+        switch self {
+        case .quickActions:
+            return HostCollectionViewCell<QuickLinksView>.self
+        case .posts:
+            return DashboardPostsCardCell.self
+        case .todaysStats:
+            return DashboardStatsCardCell.self
+        }
+    }
+
+    /// All cards that are remote
+    static var remoteCases: [DashboardCard] {
+        return DashboardCard.allCases.filter { $0.isRemote }
+    }
+
+    /// All cards that are local
+    static var localCases: [DashboardCard] {
+        return DashboardCard.allCases.filter { !$0.isRemote }
+    }
+}

WordPress/Classes/ViewRelated/Blog/Blog Dashboard/DashboardCard.swift

@@ -47,3 +47,9 @@ class HostCollectionViewCell<Content>: UICollectionViewCell, Hostable where Cont
 }
 
 extension HostCollectionViewCell: Reusable { }
+
+extension HostCollectionViewCell: BlogDashboardCardConfigurable {
+    func configure(blog: Blog, viewController: BlogDashboardViewController?, dataModel: NSDictionary?) {
+        hostedView = QuickLinksView(title: "Quick Links") as? Content
+    }
+}

WordPress/Classes/ViewRelated/Blog/Blog Dashboard/HostCollectionViewCell.swift

@@ -0,0 +1,95 @@
+import Foundation
+import WordPressKit
+
+class BlogDashboardService {
+    let remoteService: DashboardServiceRemote
+
+    init(managedObjectContext: NSManagedObjectContext, remoteService: DashboardServiceRemote? = nil) {
+        self.remoteService = remoteService ?? DashboardServiceRemote(wordPressComRestApi: WordPressComRestApi.defaultApi(in: managedObjectContext, localeKey: WordPressComRestApi.LocaleKeyV2))
+    }
+
+    func fetch(wpComID: Int, completion: @escaping (DashboardSnapshot) -> Void) {
+        let cardsToFetch: [String] = DashboardCard.remoteCases.map { $0.rawValue }
+
+        remoteService.fetch(cards: cardsToFetch, forBlogID: wpComID, success: { [weak self] cards in
+
+            var snapshot = DashboardSnapshot()
+
+            DashboardCard.allCases.forEach { card in
+
+                if card.isRemote {
+
+                    if card == .posts,
+                       let posts = cards[DashboardCard.posts.rawValue] as? NSDictionary,
+                       let (sections, items) = self?.parsePostCard(posts) {
+                        snapshot.appendSections(sections)
+                        sections.enumerated().forEach { key, section in
+                            snapshot.appendItems([items[key]], toSection: section)
+                        }
+                    } else {
+
+                        if let viewModel = cards[card.rawValue] {
+                            let section = DashboardCardSection(id: card.rawValue)
+                            let item = DashboardCardModel(id: card, cellViewModel: viewModel as? NSDictionary)
+
+                            snapshot.appendSections([section])
+                            snapshot.appendItems([item], toSection: section)
+                        }
+
+                    }
+
+                } else {
+                    let section = DashboardCardSection(id: card.rawValue)
+                    let item = DashboardCardModel(id: card)
+
+                    snapshot.appendSections([section])
+                    snapshot.appendItems([item], toSection: section)
+                }
+
+            }
+
+            completion(snapshot)
+        }, failure: { _ in
+
+        })
+    }
+}
+
+private extension BlogDashboardService {
+    /// Posts are a special case: they might not be a 1-1 relation
+    /// If the user has draft and scheduled posts, we show two cards
+    /// One for each. This function takes care of this
+    func parsePostCard(_ posts: NSDictionary) -> ([DashboardCardSection], [DashboardCardModel]) {
+        var sections: [DashboardCardSection] = []
+        var items: [DashboardCardModel] = []
+
+        let draftsCount = (posts["draft"] as? Array<Any>)?.count ?? 0
+        let scheduledCount = (posts["scheduled"] as? Array<Any>)?.count ?? 0
+
+        let hasDrafts = draftsCount > 0
+        let hasScheduled = scheduledCount > 0
+
+        if hasDrafts && hasScheduled {
+            var draft = posts.copy() as? [String: Any]
+            draft?["show_drafts"] = true
+            draft?["show_scheduled"] = false
+            sections.append(DashboardCardSection(id: "posts", subtype: "draft"))
+            items.append(DashboardCardModel(id: .posts, cellViewModel: draft as NSDictionary?))
+
+            var scheduled = posts.copy() as? [String: Any]
+            scheduled?["show_drafts"] = false
+            scheduled?["show_scheduled"] = true
+            sections.append(DashboardCardSection(id: "posts", subtype: "scheduled"))
+            items.append(DashboardCardModel(id: .posts, cellViewModel: scheduled as NSDictionary?))
+        } else {
+            var postsWithFlags = posts.copy() as? [String: Any]
+            postsWithFlags?["show_drafts"] = hasDrafts
+            postsWithFlags?["show_scheduled"] = hasScheduled
+
+            sections.append(DashboardCardSection(id: "posts"))
+            items.append(DashboardCardModel(id: .posts, cellViewModel: postsWithFlags as NSDictionary?))
+        }
+
+        return (sections, items)
+    }
+}

WordPress/Classes/ViewRelated/Blog/Blog Dashboard/Service/BlogDashboardService.swift

@@ -0,0 +1,79 @@
+import Foundation
+import UIKit
+import CoreData
+
+typealias DashboardSnapshot = NSDiffableDataSourceSnapshot<DashboardCardSection, DashboardCardModel>
+typealias DashboardDataSource = UICollectionViewDiffableDataSource<DashboardCardSection, DashboardCardModel>
+
+class BlogDashboardViewModel {
+    private weak var viewController: BlogDashboardViewController?
+
+    enum Section: CaseIterable {
+        case quickLinks
+        case posts
+    }
+
+    typealias QuickLinksHostCell = HostCollectionViewCell<QuickLinksView>
+
+    private let managedObjectContext: NSManagedObjectContext
+    private let blog: Blog
+
+    private lazy var service: BlogDashboardService = {
+        return BlogDashboardService(managedObjectContext: managedObjectContext)
+    }()
+
+    private lazy var dataSource: DashboardDataSource? = {
+        guard let viewController = viewController else {
+            return nil
+        }
+
+        return DashboardDataSource(collectionView: viewController.collectionView) { [unowned self] collectionView, indexPath, identifier in
+
+            let cellType = identifier.id.cell
+            let cell = collectionView.dequeueReusableCell(withReuseIdentifier: cellType.defaultReuseID, for: indexPath)
+
+            if let cellConfigurable = cell as? BlogDashboardCardConfigurable {
+                cellConfigurable.configure(blog: blog, viewController: viewController, dataModel: identifier.cellViewModel)
+            }
+
+            return cell
+
+        }
+    }()
+
+    init(viewController: BlogDashboardViewController, managedObjectContext: NSManagedObjectContext = ContextManager.shared.mainContext, blog: Blog) {
+        self.viewController = viewController
+        self.managedObjectContext = managedObjectContext
+        self.blog = blog
+    }
+
+    /// Call the API to return cards for the current blog
+    func start() {
+        guard let dotComID = blog.dotComID?.intValue else {
+            return
+        }
+
+        viewController?.showLoading()
+        applySnapshotForInitialData()
+
+        service.fetch(wpComID: dotComID, completion: { [weak self] snapshot in
+            self?.viewController?.stopLoading()
+            self?.apply(snapshot: snapshot)
+        })
+    }
+}
+
+// MARK: - Private methods
+
+private extension BlogDashboardViewModel {
+    // This is necessary when using an IntrinsicCollectionView
+    // Otherwise, the collection view will never update its height
+    func applySnapshotForInitialData() {
+        let snapshot = DashboardSnapshot()
+        dataSource?.apply(snapshot, animatingDifferences: false)
+    }
+
+    func apply(snapshot: DashboardSnapshot) {
+        dataSource?.apply(snapshot, animatingDifferences: false)
+    }
+}