Xây dựng swift package để gọi network trong swift

//
//  GithubAPI.swift
//  QNetworkDemo
//
//  Created by Xuân Quỳnh Lê on 2021/06/26.
//

import Foundation
import QNetwork
import Moya

enum GithubAPI {
    case searchRepositories(q: String, sort: String, order: String, page: Int)
}

extension GithubAPI: TargetType {
    var baseURL: URL {
        let url = URL(string: Configs.Network.baseUrl)!
        return url
    }

    var path: String {
        switch self {
        case .searchRepositories:
            return "search/repositories"
        }
    }

    var method: Moya.Method {
        return .get
    }

    var sampleData: Data {
        var dataUrl: URL?

        switch self {
        case .searchRepositories:
            if let file = Bundle.main.url(forResource: "SearchRepositoriesResponse", withExtension: "json") {
                dataUrl = file
            }
        }
        if let url = dataUrl, let data = try? Data(contentsOf: url) {
            return data
        }

        return Data()
    }

    var task: Task {
        switch self {
        case .searchRepositories:
            if let parameters = parameters {
                return .requestParameters(parameters: parameters, encoding: parameterEncoding)
            }
        }
        return .requestPlain
    }

    var headers: [String: String]? {
        return ["Content-type": "application/json"]
    }

    var parameters: [String: Any]? {
        var params: [String: Any] = [:]

        switch self {
        case .searchRepositories(let q, let sort, let order, let page):
            params["q"] = q
            params["sort"] = sort
            params["order"] = order
            params["page"] = page
        }

        return params
    }

    // For json encode. Use in post request
    var jsonEncoding: JSONEncoding {
        return JSONEncoding.default
    }

    // For param encode. Use in get request
    var parameterEncoding: ParameterEncoding {
        return URLEncoding.default
    }
}

// MARK: - GithubSearchResponse
struct GithubSearchResponse: Codable {
    let totalCount: Int?
    let incompleteResults: Bool
    let items: [GithubSearchItem]?

    enum CodingKeys: String, CodingKey {
        case totalCount = "total_count"
        case incompleteResults = "incomplete_results"
        case items
    }
}

// MARK: - Item
struct GithubSearchItem: Codable {
    let id: Int
    let name: String?
    let htmlURL: String?
    let itemDescription: String?

    enum CodingKeys: String, CodingKey {
        case id, name
        case htmlURL = "html_url"
        case itemDescription = "description"
    }
}

import Foundation

class GithubViewModel {
    // Service call API
    let service: GithubSearchService!
    // Callback to view
    var needReloadTableView: (() -> Void)?
    var needShowError: ((String) -> Void)?
    var needSetStateBottomIndicatorView: ((_ show: Bool) -> Void)?

    private var page: Int = 0
    private var language = ""
    private var incompleteResults = false
    
    // Datasource
    private var githubSearchItem: [GithubSearchItem] = []

    init() {
        // Turn on is test is true if you need test for API
        self.service = GithubSearchService(isTest: false)
    }

    /// Clear tableview data source
    func clearTableView() {
        self.page = 0
        self.incompleteResults = false
        self.githubSearchItem.removeAll()
        self.needReloadTableView?()
    }

    /// Request repositories
    func requestRepositories(language: String, loadMore: Bool = false) {
        // Check when load more
        if self.incompleteResults {
            return
        }
        if !loadMore {
            self.page = 0
            self.githubSearchItem.removeAll()
        }

        self.language = language

        // Default param
        let sort = "stars"
        let order = "desc"

        self.service.searchRepositories(language: language, sort: sort, order: order, page: self.page) { [weak self] result in
            guard let strongSelf = self else { return }
            // Check when load more
            if loadMore {
                strongSelf.needSetStateBottomIndicatorView?(false)
            }

            switch result {
            case .success(let githubResponse):
                strongSelf.incompleteResults = githubResponse.incompleteResults
                if let items = githubResponse.items {
                    items.forEach( {strongSelf.githubSearchItem.append( $0 )})
                }
                strongSelf.needReloadTableView?()
            case .failure(let error):
                strongSelf.needShowError?(error.description)
            }
        }
    }

    func numberOfRowsInSection(section: Int) -> Int {
        return githubSearchItem.count
    }

    func cellForRowAt(indexPath: IndexPath) -> GithubSearchItem {
        // Check if the last row number is the same as the last current data element
            if indexPath.row == self.githubSearchItem.count - 1 {
                self.page += 1
                self.requestRepositories(language: language, loadMore: true)
                self.needSetStateBottomIndicatorView?(true)
            }

        return githubSearchItem[indexPath.row]
    }
}