Renamed GoogleReaderCompatible to just Reader

Frameworks/Account/ReaderAPI/ReaderAPICaller.swift

@@ -0,0 +1,947 @@
+//
+//  ReaderAPICaller.swift
+//  Account
+//
+//  Created by Jeremy Beker on 5/28/19.
+//  Copyright © 2019 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+import RSWeb
+
+enum CreateReaderAPISubscriptionResult {
+	case created(ReaderAPISubscription)
+	case alreadySubscribed
+	case notFound
+}
+
+final class ReaderAPICaller: NSObject {
+	
+	struct ConditionalGetKeys {
+		static let subscriptions = "subscriptions"
+		static let tags = "tags"
+		static let taggings = "taggings"
+		static let icons = "icons"
+		static let unreadEntries = "unreadEntries"
+		static let starredEntries = "starredEntries"
+	}
+	
+	enum ReaderState: String {
+		case read = "user/-/state/com.google/read"
+		case starred = "user/-/state/com.google/starred"
+	}
+	
+	enum ReaderStreams: String {
+		case readingList = "user/-/state/com.google/reading-list"
+	}
+	
+	enum ReaderAPIEndpoints: String {
+		case login = "/accounts/ClientLogin"
+		case token = "/reader/api/0/token"
+		case disableTag = "/reader/api/0/disable-tag"
+		case renameTag = "/reader/api/0/rename-tag"
+		case tagList = "/reader/api/0/tag/list"
+		case subscriptionList = "/reader/api/0/subscription/list"
+		case subscriptionEdit = "/reader/api/0/subscription/edit"
+		case subscriptionAdd = "/reader/api/0/subscription/quickadd"
+		case contents = "/reader/api/0/stream/items/contents"
+		case itemIds = "/reader/api/0/stream/items/ids"
+		case editTag = "/reader/api/0/edit-tag"
+	}
+	
+	private var transport: Transport!
+	
+	var credentials: Credentials?
+	private var accessToken: String?
+	
+	weak var accountMetadata: AccountMetadata?
+
+	var server: String? {
+		get {
+			return APIBaseURL?.host
+		}
+	}
+	
+	private var APIBaseURL: URL? {
+		get {
+			guard let accountMetadata = accountMetadata else {
+				return nil
+			}
+	
+			return accountMetadata.endpointURL
+		}
+	}
+	
+	
+	init(transport: Transport) {
+		super.init()
+		self.transport = transport
+	}
+	
+	func validateCredentials(endpoint: URL, completion: @escaping (Result<Credentials?, Error>) -> Void) {
+		guard let credentials = credentials else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		guard case .googleBasicLogin(let username, _) = credentials else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		let request = URLRequest(url: endpoint.appendingPathComponent(ReaderAPIEndpoints.login.rawValue), credentials: credentials)
+
+		transport.send(request: request) { result in
+			switch result {
+			case .success(let (_, data)):
+				guard let resultData = data else {
+					completion(.failure(TransportError.noData))
+					break
+				}
+				
+				// Convert the return data to UTF8 and then parse out the Auth token
+				guard let rawData = String(data: resultData, encoding: .utf8) else {
+					completion(.failure(TransportError.noData))
+					break
+				}
+				
+				var authData: [String: String] = [:]
+				rawData.split(separator: "\n").forEach({ (line: Substring) in
+					let items = line.split(separator: "=").map{String($0)}
+					authData[items[0]] = items[1]
+				})
+				
+				guard let authString = authData["Auth"] else {
+					completion(.failure(CredentialsError.incompleteCredentials))
+					break
+				}
+				
+				// Save Auth Token for later use
+				self.credentials = .googleAuthLogin(username: username, apiKey: authString)
+				
+				completion(.success(self.credentials))
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+		
+	}
+	
+	func requestAuthorizationToken(endpoint: URL, completion: @escaping (Result<String, Error>) -> Void) {
+		// If we have a token already, use it
+		if let accessToken = accessToken {
+			completion(.success(accessToken))
+			return
+		}
+		
+		// Otherwise request one.
+		guard let credentials = credentials else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		let request = URLRequest(url: endpoint.appendingPathComponent(ReaderAPIEndpoints.token.rawValue), credentials: credentials)
+		
+		transport.send(request: request) { result in
+			switch result {
+			case .success(let (_, data)):
+				guard let resultData = data else {
+					completion(.failure(TransportError.noData))
+					break
+				}
+				
+				// Convert the return data to UTF8 and then parse out the Auth token
+				guard let accessToken = String(data: resultData, encoding: .utf8) else {
+					completion(.failure(TransportError.noData))
+					break
+				}
+				
+				self.accessToken = accessToken
+				completion(.success(accessToken))
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+	}
+	
+	
+	func retrieveTags(completion: @escaping (Result<[ReaderAPITag]?, Error>) -> Void) {
+		guard let baseURL = APIBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		// Add query string for getting JSON (probably should break this out as I will be doing it a lot)
+		guard var components = URLComponents(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.tagList.rawValue), resolvingAgainstBaseURL: false) else {
+			completion(.failure(TransportError.noURL))
+			return
+		}
+		
+		components.queryItems = [
+			URLQueryItem(name: "output", value: "json")
+		]
+
+		guard let callURL = components.url else {
+			completion(.failure(TransportError.noURL))
+			return
+		}
+
+		let conditionalGet = accountMetadata?.conditionalGetInfo[ConditionalGetKeys.tags]
+		let request = URLRequest(url: callURL, credentials: credentials, conditionalGet: conditionalGet)
+		
+		transport.send(request: request, resultType: ReaderAPITagContainer.self) { result in
+			
+			switch result {
+			case .success(let (response, wrapper)):
+				self.storeConditionalGet(key: ConditionalGetKeys.tags, headers: response.allHeaderFields)
+				completion(.success(wrapper?.tags))
+			case .failure(let error):
+				completion(.failure(error))
+			}
+			
+		}
+		
+	}
+
+	func renameTag(oldName: String, newName: String, completion: @escaping (Result<Void, Error>) -> Void) {
+		guard let baseURL = APIBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		self.requestAuthorizationToken(endpoint: baseURL) { (result) in
+			switch result {
+			case .success(let token):
+				var request = URLRequest(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.renameTag.rawValue), credentials: self.credentials)
+				
+				request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+				request.httpMethod = "POST"
+				
+				let oldTagName = "user/-/label/\(oldName)"
+				let newTagName = "user/-/label/\(newName)"
+				let postData = "T=\(token)&s=\(oldTagName)&dest=\(newTagName)".data(using: String.Encoding.utf8)
+				
+				self.transport.send(request: request, method: HTTPMethod.post, payload: postData!, completion: { (result) in
+					switch result {
+					case .success:
+						completion(.success(()))
+						break
+					case .failure(let error):
+						completion(.failure(error))
+						break
+					}
+				})
+				
+				
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+	}
+	
+	func deleteTag(name: String, completion: @escaping (Result<Void, Error>) -> Void) {
+		
+		guard let baseURL = APIBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		self.requestAuthorizationToken(endpoint: baseURL) { (result) in
+			switch result {
+			case .success(let token):
+				var request = URLRequest(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.disableTag.rawValue), credentials: self.credentials)
+				
+				
+				request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+				request.httpMethod = "POST"
+				
+				let tagName = "user/-/label/\(name)"
+				let postData = "T=\(token)&s=\(tagName)".data(using: String.Encoding.utf8)
+				
+				self.transport.send(request: request, method: HTTPMethod.post, payload: postData!, completion: { (result) in
+					switch result {
+					case .success:
+						completion(.success(()))
+						break
+					case .failure(let error):
+						completion(.failure(error))
+						break
+					}
+				})
+				
+				
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+		
+	}
+	
+	func retrieveSubscriptions(completion: @escaping (Result<[ReaderAPISubscription]?, Error>) -> Void) {
+		guard let baseURL = APIBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		// Add query string for getting JSON (probably should break this out as I will be doing it a lot)
+		guard var components = URLComponents(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.subscriptionList.rawValue), resolvingAgainstBaseURL: false) else {
+			completion(.failure(TransportError.noURL))
+			return
+		}
+		
+		components.queryItems = [
+			URLQueryItem(name: "output", value: "json")
+		]
+		
+		guard let callURL = components.url else {
+			completion(.failure(TransportError.noURL))
+			return
+		}
+		
+		let conditionalGet = accountMetadata?.conditionalGetInfo[ConditionalGetKeys.subscriptions]
+		let request = URLRequest(url: callURL, credentials: credentials, conditionalGet: conditionalGet)
+		
+		transport.send(request: request, resultType: ReaderAPISubscriptionContainer.self) { result in
+			
+			switch result {
+			case .success(let (response, container)):
+				self.storeConditionalGet(key: ConditionalGetKeys.subscriptions, headers: response.allHeaderFields)
+				completion(.success(container?.subscriptions))
+			case .failure(let error):
+				completion(.failure(error))
+			}
+			
+		}
+		
+	}
+	
+	func createSubscription(url: String, completion: @escaping (Result<CreateReaderAPISubscriptionResult, Error>) -> Void) {
+		guard let baseURL = APIBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		self.requestAuthorizationToken(endpoint: baseURL) { (result) in
+			switch result {
+			case .success(let token):
+				guard var components = URLComponents(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.subscriptionAdd.rawValue), resolvingAgainstBaseURL: false) else {
+					completion(.failure(TransportError.noURL))
+					return
+				}
+				
+				components.queryItems = [
+					URLQueryItem(name: "quickadd", value: url)
+				]
+				
+				guard let callURL = components.url else {
+					completion(.failure(TransportError.noURL))
+					return
+				}
+				
+				var request = URLRequest(url: callURL, credentials: self.credentials)
+				request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+				request.httpMethod = "POST"
+				
+				let postData = "T=\(token)".data(using: String.Encoding.utf8)
+				
+				self.transport.send(request: request, method: HTTPMethod.post, data: postData!, resultType: ReaderAPIQuickAddResult.self, completion: { (result) in
+					switch result {
+					case .success(let (_, subResult)):
+						
+						switch subResult?.numResults {
+						case 0:
+							completion(.success(.alreadySubscribed))
+						default:
+							// We have a feed ID but need to get feed information
+							guard let streamId = subResult?.streamId else {
+								completion(.failure(AccountError.createErrorNotFound))
+								return
+							}
+							
+							// There is no call to get a single subscription entry, so we get them all,
+							// look up the one we just subscribed to and return that
+							self.retrieveSubscriptions(completion: { (result) in
+								switch result {
+								case .success(let subscriptions):
+									guard let subscriptions = subscriptions else {
+										completion(.failure(AccountError.createErrorNotFound))
+										return
+									}
+									
+									let newStreamId = "feed/\(streamId)"
+									
+									guard let subscription = subscriptions.first(where: { (sub) -> Bool in
+										sub.feedID == newStreamId
+									}) else {
+										completion(.failure(AccountError.createErrorNotFound))
+										return
+									}
+									
+									completion(.success(.created(subscription)))
+									
+								case .failure(let error):
+									completion(.failure(error))
+								}
+							})
+							}
+					case .failure(let error):
+						completion(.failure(error))
+					}
+				})
+				
+				
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+	}
+	
+	func renameSubscription(subscriptionID: String, newName: String, completion: @escaping (Result<Void, Error>) -> Void) {
+		guard let baseURL = APIBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		self.requestAuthorizationToken(endpoint: baseURL) { (result) in
+			switch result {
+			case .success(let token):
+				var request = URLRequest(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.subscriptionEdit.rawValue), credentials: self.credentials)
+				
+				
+				request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+				request.httpMethod = "POST"
+				
+				let postData = "T=\(token)&s=\(subscriptionID)&ac=edit&t=\(newName)".data(using: String.Encoding.utf8)
+				
+				self.transport.send(request: request, method: HTTPMethod.post, payload: postData!, completion: { (result) in
+					switch result {
+					case .success:
+						completion(.success(()))
+						break
+					case .failure(let error):
+						completion(.failure(error))
+						break
+					}
+				})
+				
+				
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+	}
+	
+	func deleteSubscription(subscriptionID: String, completion: @escaping (Result<Void, Error>) -> Void) {
+		guard let baseURL = APIBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		self.requestAuthorizationToken(endpoint: baseURL) { (result) in
+			switch result {
+			case .success(let token):
+				var request = URLRequest(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.subscriptionEdit.rawValue), credentials: self.credentials)
+
+				
+				request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+				request.httpMethod = "POST"
+				
+				let postData = "T=\(token)&s=\(subscriptionID)&ac=unsubscribe".data(using: String.Encoding.utf8)
+				
+				self.transport.send(request: request, method: HTTPMethod.post, payload: postData!, completion: { (result) in
+					switch result {
+					case .success:
+						completion(.success(()))
+						break
+					case .failure(let error):
+						completion(.failure(error))
+						break
+					}
+				})
+				
+				
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+	}
+	
+	func createTagging(subscriptionID: String, tagName: String, completion: @escaping (Result<Void, Error>) -> Void) {
+		
+		guard let baseURL = APIBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		self.requestAuthorizationToken(endpoint: baseURL) { (result) in
+			switch result {
+			case .success(let token):
+				var request = URLRequest(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.subscriptionEdit.rawValue), credentials: self.credentials)
+				
+				
+				request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+				request.httpMethod = "POST"
+				
+				let tagName = "user/-/label/\(tagName)"
+				let postData = "T=\(token)&s=\(subscriptionID)&ac=edit&a=\(tagName)".data(using: String.Encoding.utf8)
+				
+				self.transport.send(request: request, method: HTTPMethod.post, payload: postData!, completion: { (result) in
+					switch result {
+					case .success:
+						completion(.success(()))
+						break
+					case .failure(let error):
+						completion(.failure(error))
+						break
+					}
+				})
+				
+				
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+		
+	}
+
+	func deleteTagging(subscriptionID: String, tagName: String, completion: @escaping (Result<Void, Error>) -> Void) {
+		guard let baseURL = APIBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		self.requestAuthorizationToken(endpoint: baseURL) { (result) in
+			switch result {
+			case .success(let token):
+				var request = URLRequest(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.subscriptionEdit.rawValue), credentials: self.credentials)
+				
+				
+				request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+				request.httpMethod = "POST"
+				
+				let tagName = "user/-/label/\(tagName)"
+				let postData = "T=\(token)&s=\(subscriptionID)&ac=edit&r=\(tagName)".data(using: String.Encoding.utf8)
+				
+				self.transport.send(request: request, method: HTTPMethod.post, payload: postData!, completion: { (result) in
+					switch result {
+					case .success:
+						completion(.success(()))
+						break
+					case .failure(let error):
+						completion(.failure(error))
+						break
+					}
+				})
+				
+				
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+	}
+	
+	func retrieveEntries(articleIDs: [String], completion: @escaping (Result<([ReaderAPIEntry]?), Error>) -> Void) {
+		
+		guard !articleIDs.isEmpty else {
+			completion(.success(([ReaderAPIEntry]())))
+			return
+		}
+		
+		guard let baseURL = APIBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		self.requestAuthorizationToken(endpoint: baseURL) { (result) in
+			switch result {
+			case .success(let token):
+				// Do POST asking for data about all the new articles
+				var request = URLRequest(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.contents.rawValue), credentials: self.credentials)
+				request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+				request.httpMethod = "POST"
+				
+				// Get ids from above into hex representation of value
+				let idsToFetch = articleIDs.map({ (reference) -> String in
+					return "i=\(reference)"
+				}).joined(separator:"&")
+				
+				let postData = "T=\(token)&output=json&\(idsToFetch)".data(using: String.Encoding.utf8)
+				
+				self.transport.send(request: request, method: HTTPMethod.post, data: postData!, resultType: ReaderAPIEntryWrapper.self, completion: { (result) in
+					switch result {
+					case .success(let (_, entryWrapper)):
+						guard let entryWrapper = entryWrapper else {
+							completion(.failure(ReaderAPIAccountDelegateError.invalidResponse))
+							return
+						}
+						
+						completion(.success((entryWrapper.entries)))
+					case .failure(let error):
+						completion(.failure(error))
+					}
+				})
+				
+				
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+
+	}
+
+	func retrieveEntries(feedID: String, completion: @escaping (Result<([ReaderAPIEntry]?, String?), Error>) -> Void) {
+		
+		let since = Calendar.current.date(byAdding: .month, value: -3, to: Date()) ?? Date()
+		
+		guard let baseURL = APIBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		// Add query string for getting JSON (probably should break this out as I will be doing it a lot)
+		guard var components = URLComponents(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.itemIds.rawValue), resolvingAgainstBaseURL: false) else {
+			completion(.failure(TransportError.noURL))
+			return
+		}
+		
+		components.queryItems = [
+			URLQueryItem(name: "s", value: feedID),
+			URLQueryItem(name: "ot", value: String(since.timeIntervalSince1970)),
+			URLQueryItem(name: "output", value: "json")
+		]
+		
+		guard let callURL = components.url else {
+			completion(.failure(TransportError.noURL))
+			return
+		}
+		
+		let request = URLRequest(url: callURL, credentials: credentials, conditionalGet: nil)
+		
+		transport.send(request: request, resultType: ReaderAPIReferenceWrapper.self) { result in
+			
+			switch result {
+			case .success(let (_, unreadEntries)):
+				
+				guard let itemRefs = unreadEntries?.itemRefs else {
+					completion(.success(([], nil)))
+					return
+				}
+				
+				let itemIds = itemRefs.map { (reference) -> String in
+					// Convert the IDs to the (stupid) Google Hex Format
+					let idValue = Int(reference.itemId)!
+					return String(idValue, radix: 16, uppercase: false)
+				}
+				
+				self.retrieveEntries(articleIDs: itemIds) { (results) in
+					switch results {
+					case .success(let entries):
+						completion(.success((entries,nil)))
+					case .failure(let error):
+						completion(.failure(error))
+					}
+				}
+				
+			case .failure(let error):
+				completion(.failure(error))
+			}
+			
+		}
+		
+	}
+
+	func retrieveEntries(completion: @escaping (Result<([ReaderAPIEntry]?, String?, Int?), Error>) -> Void) {
+		
+		guard let baseURL = APIBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		let since: Date = {
+			if let lastArticleFetch = self.accountMetadata?.lastArticleFetch {
+				return lastArticleFetch
+			} else {
+				return Calendar.current.date(byAdding: .month, value: -3, to: Date()) ?? Date()
+			}
+		}()
+		
+		let sinceString = since.timeIntervalSince1970
+		
+		// Add query string for getting JSON (probably should break this out as I will be doing it a lot)
+		guard var components = URLComponents(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.itemIds.rawValue), resolvingAgainstBaseURL: false) else {
+			completion(.failure(TransportError.noURL))
+			return
+		}
+		
+		components.queryItems = [
+			URLQueryItem(name: "o", value: String(sinceString)),
+			URLQueryItem(name: "n", value: "10000"),
+			URLQueryItem(name: "output", value: "json"),
+			URLQueryItem(name: "xt", value: ReaderState.read.rawValue),
+			URLQueryItem(name: "s", value: ReaderStreams.readingList.rawValue)
+		]
+		
+		guard let callURL = components.url else {
+			completion(.failure(TransportError.noURL))
+			return
+		}
+		
+		let conditionalGet = accountMetadata?.conditionalGetInfo[ConditionalGetKeys.unreadEntries]
+		let request = URLRequest(url: callURL, credentials: credentials, conditionalGet: conditionalGet)
+		
+		self.transport.send(request: request, resultType: ReaderAPIReferenceWrapper.self) { result in
+			
+			switch result {
+			case .success(let (_, entries)):
+				
+				guard let entries = entries else {
+					completion(.failure(ReaderAPIAccountDelegateError.invalidResponse))
+					return
+				}
+				
+				self.requestAuthorizationToken(endpoint: baseURL) { (result) in
+					switch result {
+					case .success(let token):
+						// Do POST asking for data about all the new articles
+						var request = URLRequest(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.contents.rawValue), credentials: self.credentials)
+						request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+						request.httpMethod = "POST"
+						
+						// Get ids from above into hex representation of value
+						let idsToFetch = entries.itemRefs.map({ (reference) -> String in
+							let idValue = Int(reference.itemId)!
+							let idHexString = String(idValue, radix: 16, uppercase: false)
+							return "i=\(idHexString)"
+						}).joined(separator:"&")
+						
+						let postData = "T=\(token)&output=json&\(idsToFetch)".data(using: String.Encoding.utf8)
+
+						self.transport.send(request: request, method: HTTPMethod.post, data: postData!, resultType: ReaderAPIEntryWrapper.self, completion: { (result) in
+							switch result {
+							case .success(let (response, entryWrapper)):
+								guard let entryWrapper = entryWrapper else {
+									completion(.failure(ReaderAPIAccountDelegateError.invalidResponse))
+									return
+								}
+								
+								let dateInfo = HTTPDateInfo(urlResponse: response)
+								self.accountMetadata?.lastArticleFetch = dateInfo?.date
+								
+								
+								completion(.success((entryWrapper.entries, nil, nil)))
+							case .failure(let error):
+								completion(.failure(error))
+							}
+						})
+						
+						
+					case .failure(let error):
+						completion(.failure(error))
+					}
+				}
+				
+			case .failure(let error):
+				self.accountMetadata?.lastArticleFetch = nil
+				completion(.failure(error))
+			}
+			
+		}
+	}
+	
+	func retrieveEntries(page: String, completion: @escaping (Result<([ReaderAPIEntry]?, String?), Error>) -> Void) {
+		
+		guard let url = URL(string: page), var callComponents = URLComponents(url: url, resolvingAgainstBaseURL: false) else {
+			completion(.success((nil, nil)))
+			return
+		}
+		
+		callComponents.queryItems?.append(URLQueryItem(name: "mode", value: "extended"))
+		let request = URLRequest(url: callComponents.url!, credentials: credentials)
+
+		transport.send(request: request, resultType: [ReaderAPIEntry].self) { result in
+			
+			switch result {
+			case .success(let (response, entries)):
+				
+				let pagingInfo = HTTPLinkPagingInfo(urlResponse: response)
+				completion(.success((entries, pagingInfo.nextPage)))
+
+			case .failure(let error):
+				self.accountMetadata?.lastArticleFetch = nil
+				completion(.failure(error))
+			}
+			
+		}
+		
+	}
+
+	func retrieveUnreadEntries(completion: @escaping (Result<[Int]?, Error>) -> Void) {
+		
+		guard let baseURL = APIBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		// Add query string for getting JSON (probably should break this out as I will be doing it a lot)
+		guard var components = URLComponents(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.itemIds.rawValue), resolvingAgainstBaseURL: false) else {
+			completion(.failure(TransportError.noURL))
+			return
+		}
+		
+		components.queryItems = [
+			URLQueryItem(name: "s", value: ReaderStreams.readingList.rawValue),
+			URLQueryItem(name: "n", value: "10000"),
+			URLQueryItem(name: "xt", value: ReaderState.read.rawValue),
+			URLQueryItem(name: "output", value: "json")
+		]
+		
+		guard let callURL = components.url else {
+			completion(.failure(TransportError.noURL))
+			return
+		}
+
+		let conditionalGet = accountMetadata?.conditionalGetInfo[ConditionalGetKeys.unreadEntries]
+		let request = URLRequest(url: callURL, credentials: credentials, conditionalGet: conditionalGet)
+		
+		transport.send(request: request, resultType: ReaderAPIReferenceWrapper.self) { result in
+			
+			switch result {
+			case .success(let (response, unreadEntries)):
+				
+				guard let itemRefs = unreadEntries?.itemRefs else {
+					completion(.success([]))
+					return
+				}
+				
+				let itemIds = itemRefs.map{ Int($0.itemId)! }
+				
+				self.storeConditionalGet(key: ConditionalGetKeys.unreadEntries, headers: response.allHeaderFields)
+				completion(.success(itemIds))
+			case .failure(let error):
+				completion(.failure(error))
+			}
+			
+		}
+		
+	}
+	
+	func updateStateToEntries(entries: [Int], state: ReaderState, add: Bool, completion: @escaping (Result<Void, Error>) -> Void) {
+		guard let baseURL = APIBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		self.requestAuthorizationToken(endpoint: baseURL) { (result) in
+			switch result {
+			case .success(let token):
+				// Do POST asking for data about all the new articles
+				var request = URLRequest(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.editTag.rawValue), credentials: self.credentials)
+				request.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+				request.httpMethod = "POST"
+				
+				// Get ids from above into hex representation of value
+				let idsToFetch = entries.map({ (idValue) -> String in
+					let idHexString = String(format: "%.16llx", idValue)
+					return "i=\(idHexString)"
+				}).joined(separator:"&")
+				
+				let actionIndicator = add ? "a" : "r"
+				
+				let postData = "T=\(token)&\(idsToFetch)&\(actionIndicator)=\(state.rawValue)".data(using: String.Encoding.utf8)
+				
+				self.transport.send(request: request, method: HTTPMethod.post, payload: postData!, completion: { (result) in
+					switch result {
+					case .success:
+						completion(.success(()))
+					case .failure(let error):
+						completion(.failure(error))
+					}
+				})
+				
+				
+			case .failure(let error):
+				completion(.failure(error))
+			}
+		}
+	}
+	
+	func createUnreadEntries(entries: [Int], completion: @escaping (Result<Void, Error>) -> Void) {
+		updateStateToEntries(entries: entries, state: .read, add: false, completion: completion)
+	}
+	
+	func deleteUnreadEntries(entries: [Int], completion: @escaping (Result<Void, Error>) -> Void) {
+		updateStateToEntries(entries: entries, state: .read, add: true, completion: completion)
+
+	}
+	
+	func createStarredEntries(entries: [Int], completion: @escaping (Result<Void, Error>) -> Void) {
+		updateStateToEntries(entries: entries, state: .starred, add: true, completion: completion)
+		
+	}
+	
+	func deleteStarredEntries(entries: [Int], completion: @escaping (Result<Void, Error>) -> Void) {
+		updateStateToEntries(entries: entries, state: .starred, add: false, completion: completion)
+	}
+	
+	func retrieveStarredEntries(completion: @escaping (Result<[Int]?, Error>) -> Void) {
+		guard let baseURL = APIBaseURL else {
+			completion(.failure(CredentialsError.incompleteCredentials))
+			return
+		}
+		
+		guard var components = URLComponents(url: baseURL.appendingPathComponent(ReaderAPIEndpoints.itemIds.rawValue), resolvingAgainstBaseURL: false) else {
+			completion(.failure(TransportError.noURL))
+			return
+		}
+		
+		components.queryItems = [
+			URLQueryItem(name: "s", value: "user/-/state/com.google/starred"),
+			URLQueryItem(name: "n", value: "10000"),
+			URLQueryItem(name: "output", value: "json")
+		]
+		
+		guard let callURL = components.url else {
+			completion(.failure(TransportError.noURL))
+			return
+		}
+		
+		let conditionalGet = accountMetadata?.conditionalGetInfo[ConditionalGetKeys.starredEntries]
+		let request = URLRequest(url: callURL, credentials: credentials, conditionalGet: conditionalGet)
+		
+		transport.send(request: request, resultType: ReaderAPIReferenceWrapper.self) { result in
+			
+			switch result {
+			case .success(let (response, unreadEntries)):
+				
+				guard let itemRefs = unreadEntries?.itemRefs else {
+					completion(.success([]))
+					return
+				}
+				
+				let itemIds = itemRefs.map{ Int($0.itemId)! }
+				
+				self.storeConditionalGet(key: ConditionalGetKeys.starredEntries, headers: response.allHeaderFields)
+				completion(.success(itemIds))
+			case .failure(let error):
+				completion(.failure(error))
+			}
+			
+		}
+		
+	}
+	
+
+	
+}
+
+// MARK: Private
+
+extension ReaderAPICaller {
+	
+	func storeConditionalGet(key: String, headers: [AnyHashable : Any]) {
+		if var conditionalGet = accountMetadata?.conditionalGetInfo {
+			conditionalGet[key] = HTTPConditionalGetInfo(headers: headers)
+			accountMetadata?.conditionalGetInfo = conditionalGet
+		}
+	}
+}

Frameworks/Account/ReaderAPI/ReaderAPIEntry.swift

@@ -0,0 +1,128 @@
+//
+//  ReaderAPIArticle.swift
+//  Account
+//
+//  Created by Jeremy Beker on 5/28/19.
+//  Copyright © 2017 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+import RSParser
+import RSCore
+
+struct ReaderAPIEntryWrapper: Codable {
+	let id: String
+	let updated: Int
+	let entries: [ReaderAPIEntry]
+	
+	
+	enum CodingKeys: String, CodingKey {
+		case id = "id"
+		case updated = "updated"
+		case entries = "items"
+	}
+}
+
+/* {
+"id": "tag:google.com,2005:reader/item/00058a3b5197197b",
+"crawlTimeMsec": "1559362260113",
+"timestampUsec": "1559362260113787",
+"published": 1554845280,
+"title": "",
+"summary": {
+"content": "\n<p>Found an old screenshot of NetNewsWire 1.0 for iPhone!</p>\n\n<p><img src=\"https://nnw.ranchero.com/uploads/2019/c07c0574b1.jpg\" alt=\"Netnewswire 1.0 for iPhone screenshot showing the list of feeds.\" title=\"NewsGator got renamed to Sitrion, years later, and then renamed again as Limeade.\" border=\"0\" width=\"260\" height=\"320\"></p>\n"
+},
+"alternate": [
+{
+"href": "https://nnw.ranchero.com/2019/04/09/found-an-old.html"
+}
+],
+"categories": [
+"user/-/state/com.google/reading-list",
+"user/-/label/Uncategorized"
+],
+"origin": {
+"streamId": "feed/130",
+"title": "NetNewsWire"
+}
+}
+*/
+struct ReaderAPIEntry: Codable {
+
+	let articleID: String
+	let title: String?
+
+	let publishedTimestamp: Double?
+	let crawledTimestamp: String?
+	let timestampUsec: String?
+	
+	let summary: ReaderAPIArticleSummary
+	let alternates: [ReaderAPIAlternateLocation]
+	let categories: [String]
+	let origin: ReaderAPIEntryOrigin
+
+	enum CodingKeys: String, CodingKey {
+		case articleID = "id"
+		case title = "title"
+		case summary = "summary"
+		case alternates = "alternate"
+		case categories = "categories"
+		case publishedTimestamp = "published"
+		case crawledTimestamp = "crawlTimeMsec"
+		case origin = "origin"
+		case timestampUsec = "timestampUsec"
+	}
+	
+	func parseDatePublished() -> Date? {
+		
+		guard let unixTime = publishedTimestamp else {
+			return nil
+		}
+		
+		return Date(timeIntervalSince1970: unixTime)
+	}
+	
+	func uniqueID() -> String {
+		// Should look something like "tag:google.com,2005:reader/item/00058b10ce338909"
+		// REGEX feels heavy, I should be able to just split on / and take the last element
+		
+		guard let idPart =  articleID.components(separatedBy: "/").last else {
+			return articleID
+		}
+		
+		// Convert hex representation back to integer and then a string representation
+		guard let idNumber = Int(idPart, radix: 16) else {
+			return articleID
+		}
+		
+		return String(idNumber, radix: 10, uppercase: false)
+	}
+}
+
+struct ReaderAPIArticleSummary: Codable {
+	let content: String?
+	
+	enum CodingKeys: String, CodingKey {
+		case content = "content"
+	}
+}
+
+struct ReaderAPIAlternateLocation: Codable {
+	let url: String?
+	
+	enum CodingKeys: String, CodingKey {
+		case url = "href"
+	}
+}
+
+
+struct ReaderAPIEntryOrigin: Codable {
+	let streamId: String?
+	let title: String?
+
+	enum CodingKeys: String, CodingKey {
+		case streamId = "streamId"
+		case title = "title"
+	}
+}
+

Frameworks/Account/ReaderAPI/ReaderAPISubscription.swift

@@ -0,0 +1,104 @@
+//
+//  ReaderAPIFeed.swift
+//  Account
+//
+//  Created by Jeremy Beker on 5/28/19.
+//  Copyright © 2017 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+import RSCore
+import RSParser
+
+/*
+
+	{
+		"numResults":0,
+		"error": "Already subscribed! https://inessential.com/xml/rss.xml
+	}
+
+*/
+
+struct ReaderAPIQuickAddResult: Codable {
+	let numResults: Int
+	let error: String?
+	let streamId: String?
+	
+	enum CodingKeys: String, CodingKey {
+		case numResults = "numResults"
+		case error = "error"
+		case streamId = "streamId"
+	}
+}
+
+struct ReaderAPISubscriptionContainer: Codable {
+	let subscriptions: [ReaderAPISubscription]
+	
+	enum CodingKeys: String, CodingKey {
+		case subscriptions = "subscriptions"
+	}
+}
+
+/*
+{
+	"id": "feed/1",
+	"title": "Questionable Content",
+	"categories": [
+	{
+		"id": "user/-/label/Comics",
+		"label": "Comics"
+	}
+	],
+	"url": "http://www.questionablecontent.net/QCRSS.xml",
+	"htmlUrl": "http://www.questionablecontent.net",
+	"iconUrl": "https://rss.confusticate.com/f.php?24decabc"
+}
+
+*/
+struct ReaderAPISubscription: Codable {
+	let feedID: String
+	let name: String?
+	let categories: [ReaderAPICategory]
+	let url: String
+	let homePageURL: String?
+	let iconURL: String?
+
+	enum CodingKeys: String, CodingKey {
+		case feedID = "id"
+		case name = "title"
+		case categories = "categories"
+		case url = "url"
+		case homePageURL = "htmlUrl"
+		case iconURL = "iconUrl"
+	}
+
+}
+
+struct ReaderAPICategory: Codable {
+	let categoryId: String
+	let categoryLabel: String
+	
+	enum CodingKeys: String, CodingKey {
+		case categoryId = "id"
+		case categoryLabel = "label"
+	}
+}
+
+struct ReaderAPICreateSubscription: Codable {
+	let feedURL: String
+	enum CodingKeys: String, CodingKey {
+		case feedURL = "feed_url"
+	}
+}
+
+struct ReaderAPISubscriptionChoice: Codable {
+	
+	let name: String?
+	let url: String
+	
+	enum CodingKeys: String, CodingKey {
+		case name = "title"
+		case url = "feed_url"
+	}
+	
+}

Frameworks/Account/ReaderAPI/ReaderAPITag.swift

@@ -0,0 +1,29 @@
+//
+//  ReaderAPICompatibleTag.swift
+//  Account
+//
+//  Created by Jeremy Beker on 5/28/19.
+//  Copyright © 2019 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+
+struct ReaderAPITagContainer: Codable {
+	let tags: [ReaderAPITag]
+	
+	enum CodingKeys: String, CodingKey {
+		case tags = "tags"
+	}
+}
+
+struct ReaderAPITag: Codable {
+	
+	let tagID: String
+	let type: String?
+	
+	enum CodingKeys: String, CodingKey {
+		case tagID = "id"
+		case type = "type"
+	}
+	
+}

Frameworks/Account/ReaderAPI/ReaderAPITagging.swift

@@ -0,0 +1,35 @@
+//
+//  ReaderAPICompatibleTagging.swift
+//  Account
+//
+//  Created by Jeremy Beker on 5/28/19.
+//  Copyright © 2018 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+
+struct ReaderAPITagging: Codable {
+
+	let taggingID: Int
+	let feedID: Int
+	let name: String
+
+	enum CodingKeys: String, CodingKey {
+		case taggingID = "id"
+		case feedID = "feed_id"
+		case name = "name"
+	}
+
+}
+
+struct ReaderAPICreateTagging: Codable {
+	
+	let feedID: Int
+	let name: String
+	
+	enum CodingKeys: String, CodingKey {
+		case feedID = "feed_id"
+		case name = "name"
+	}
+	
+}

Frameworks/Account/ReaderAPI/ReaderAPIUnreadEntry.swift

@@ -0,0 +1,27 @@
+//
+//  ReaderAPIUnreadEntry.swift
+//  Account
+//
+//  Created by Jeremy Beker on 5/28/19.
+//  Copyright © 2019 Ranchero Software, LLC. All rights reserved.
+//
+
+import Foundation
+
+struct ReaderAPIReferenceWrapper: Codable {
+	let itemRefs: [ReaderAPIReference]
+	
+	enum CodingKeys: String, CodingKey {
+		case itemRefs = "itemRefs"
+	}
+}
+
+struct ReaderAPIReference: Codable {
+	
+	let itemId: String
+	
+	enum CodingKeys: String, CodingKey {
+		case itemId = "id"
+	}
+	
+}