NetNewsWire/Shared/Extensions/ArticleUtilities.swift

212 lines
5.0 KiB
Swift
Raw Normal View History

2017-05-27 19:43:27 +02:00
//
// ArticleUtilities.swift
2018-08-29 07:18:24 +02:00
// NetNewsWire
2017-05-27 19:43:27 +02:00
//
// Created by Brent Simmons on 7/25/15.
// Copyright © 2015 Ranchero Software, LLC. All rights reserved.
//
import Foundation
import RSCore
import Articles
2017-09-17 21:34:10 +02:00
import Account
2017-05-27 19:43:27 +02:00
// These handle multiple accounts.
func markArticles(_ articles: Set<Article>, statusKey: ArticleStatus.Key, flag: Bool, completion: (() -> Void)? = nil) {
2017-05-27 19:43:27 +02:00
2017-09-17 21:54:08 +02:00
let d: [String: Set<Article>] = accountAndArticlesDictionary(articles)
let group = DispatchGroup()
for (accountID, accountArticles) in d {
guard let account = AccountManager.shared.existingAccount(with: accountID) else {
continue
2017-05-27 19:43:27 +02:00
}
group.enter()
account.markArticles(accountArticles, statusKey: statusKey, flag: flag) { _ in
group.leave()
}
}
group.notify(queue: .main) {
completion?()
2017-05-27 19:43:27 +02:00
}
}
2017-09-17 21:54:08 +02:00
private func accountAndArticlesDictionary(_ articles: Set<Article>) -> [String: Set<Article>] {
2017-05-27 19:43:27 +02:00
let d = Dictionary(grouping: articles, by: { $0.accountID })
return d.mapValues{ Set($0) }
2017-05-27 19:43:27 +02:00
}
2017-09-17 21:54:08 +02:00
extension Article {
2017-05-27 19:43:27 +02:00
var webFeed: WebFeed? {
return account?.existingWebFeed(withWebFeedID: webFeedID)
2017-09-18 02:03:58 +02:00
}
2017-09-18 01:30:45 +02:00
var preferredLink: String? {
if let url = url, !url.isEmpty {
return url
}
if let externalURL = externalURL, !externalURL.isEmpty {
return externalURL
}
return nil
2017-09-18 01:30:45 +02:00
}
var preferredURL: URL? {
guard let link = preferredLink else { return nil }
// If required, we replace any space characters to handle malformed links that are otherwise percent
// encoded but contain spaces. For performance reasons, only try this if initial URL init fails.
if let url = URL(string: link) {
return url
} else if let url = URL(string: link.replacingOccurrences(of: " ", with: "%20")) {
return url
}
return nil
}
2017-09-18 01:30:45 +02:00
var body: String? {
return contentHTML ?? contentText ?? summary
2017-05-27 19:43:27 +02:00
}
2017-09-18 02:03:58 +02:00
var logicalDatePublished: Date {
return datePublished ?? dateModified ?? status.dateArrived
2017-09-18 02:03:58 +02:00
}
var isAvailableToMarkUnread: Bool {
guard let markUnreadWindow = account?.behaviors.compactMap( { behavior -> Int? in
switch behavior {
case .disallowMarkAsUnreadAfterPeriod(let days):
return days
default:
return nil
}
}).first else {
return true
}
if logicalDatePublished.byAdding(days: markUnreadWindow) > Date() {
return true
} else {
return false
}
}
func iconImage() -> IconImage? {
return IconImageCache.shared.imageForArticle(self)
}
2020-12-24 00:31:44 +01:00
func iconImageUrl(webFeed: WebFeed) -> URL? {
if let image = iconImage() {
let fm = FileManager.default
var path = fm.urls(for: .cachesDirectory, in: .userDomainMask)[0]
let feedID = webFeed.webFeedID.replacingOccurrences(of: "/", with: "_")
2020-12-24 00:31:44 +01:00
#if os(macOS)
path.appendPathComponent(feedID + "_smallIcon.tiff")
2020-12-24 00:31:44 +01:00
#else
path.appendPathComponent(feedID + "_smallIcon.png")
2020-12-24 00:31:44 +01:00
#endif
fm.createFile(atPath: path.path, contents: image.image.dataRepresentation()!, attributes: nil)
return path
} else {
return nil
}
}
func byline() -> String {
guard let authors = authors ?? webFeed?.authors, !authors.isEmpty else {
return ""
}
// If the author's name is the same as the feed, then we don't want to display it.
// This code assumes that multiple authors would never match the feed name so that
// if there feed owner has an article co-author all authors are given the byline.
if authors.count == 1, let author = authors.first {
if author.name == webFeed?.nameForDisplay {
return ""
}
}
var byline = ""
var isFirstAuthor = true
for author in authors {
if !isFirstAuthor {
byline += ", "
}
isFirstAuthor = false
var authorEmailAddress: String? = nil
if let emailAddress = author.emailAddress, !(emailAddress.contains("noreply@") || emailAddress.contains("no-reply@")) {
authorEmailAddress = emailAddress
}
if let emailAddress = authorEmailAddress, emailAddress.contains(" ") {
byline += emailAddress // probably name plus email address
}
else if let name = author.name, let emailAddress = authorEmailAddress {
byline += "\(name) <\(emailAddress)>"
}
else if let name = author.name {
byline += name
}
else if let emailAddress = authorEmailAddress {
byline += "<\(emailAddress)>"
}
else if let url = author.url {
byline += url
}
}
return byline
}
2017-05-27 19:43:27 +02:00
}
// MARK: Path
2019-10-03 16:53:21 +02:00
struct ArticlePathKey {
static let accountID = "accountID"
static let accountName = "accountName"
static let webFeedID = "webFeedID"
static let articleID = "articleID"
}
extension Article {
2019-10-03 16:53:21 +02:00
public var pathUserInfo: [AnyHashable : Any] {
2019-10-03 16:53:21 +02:00
return [
ArticlePathKey.accountID: accountID,
ArticlePathKey.accountName: account?.nameForDisplay ?? "",
ArticlePathKey.webFeedID: webFeedID,
ArticlePathKey.articleID: articleID
2019-10-03 16:53:21 +02:00
]
}
}
// MARK: SortableArticle
extension Article: SortableArticle {
var sortableName: String {
return webFeed?.name ?? ""
}
var sortableDate: Date {
return logicalDatePublished
}
var sortableArticleID: String {
return articleID
}
var sortableWebFeedID: String {
return webFeedID
}
}