mirror of
https://github.com/mastodon/mastodon-ios.git
synced 2024-12-10 15:47:02 +01:00
0c224f47df
Co-authored-by: Marcus Kida <marcus.kida@bearologics.com> Co-authored-by: Jed Fox <git@jedfox.com>
215 lines
6.9 KiB
Swift
215 lines
6.9 KiB
Swift
//
|
|
// Persistence+MastodonPoll.swift
|
|
//
|
|
//
|
|
// Created by MainasuK on 2021-12-9.
|
|
//
|
|
|
|
import CoreData
|
|
import CoreDataStack
|
|
import Foundation
|
|
import MastodonSDK
|
|
import os.log
|
|
|
|
extension Persistence.Poll {
|
|
|
|
public struct PersistContext {
|
|
public let domain: String
|
|
public let entity: Mastodon.Entity.Poll
|
|
public let me: MastodonUser?
|
|
public let networkDate: Date
|
|
public let log = Logger(subsystem: "Poll", category: "Persistence")
|
|
public init(
|
|
domain: String,
|
|
entity: Mastodon.Entity.Poll,
|
|
me: MastodonUser?,
|
|
networkDate: Date
|
|
) {
|
|
self.domain = domain
|
|
self.entity = entity
|
|
self.me = me
|
|
self.networkDate = networkDate
|
|
}
|
|
}
|
|
|
|
public struct PersistResult {
|
|
public let poll: Poll
|
|
public let isNewInsertion: Bool
|
|
|
|
public init(
|
|
poll: Poll,
|
|
isNewInsertion: Bool
|
|
) {
|
|
self.poll = poll
|
|
self.isNewInsertion = isNewInsertion
|
|
}
|
|
|
|
#if DEBUG
|
|
public let logger = Logger(subsystem: "Persistence.MastodonPoll.PersistResult", category: "Persist")
|
|
public func log() {
|
|
let pollInsertionFlag = isNewInsertion ? "+" : "-"
|
|
logger.log(level: .debug, "\((#file as NSString).lastPathComponent, privacy: .public)[\(#line, privacy: .public)], \(#function, privacy: .public): [\(pollInsertionFlag)](\(poll.id)):")
|
|
}
|
|
#endif
|
|
}
|
|
|
|
public static func createOrMerge(
|
|
in managedObjectContext: NSManagedObjectContext,
|
|
context: PersistContext
|
|
) -> PersistResult {
|
|
|
|
if let old = fetch(in: managedObjectContext, context: context) {
|
|
merge(in: managedObjectContext, poll: old, context: context)
|
|
return PersistResult(
|
|
poll: old,
|
|
isNewInsertion: false
|
|
)
|
|
} else {
|
|
let poll = create(
|
|
in: managedObjectContext,
|
|
context: context
|
|
)
|
|
|
|
return PersistResult(
|
|
poll: poll,
|
|
isNewInsertion: true
|
|
)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
extension Persistence.Poll {
|
|
|
|
public static func fetch(
|
|
in managedObjectContext: NSManagedObjectContext,
|
|
context: PersistContext
|
|
) -> Poll? {
|
|
let request = Poll.sortedFetchRequest
|
|
request.predicate = Poll.predicate(domain: context.domain, id: context.entity.id)
|
|
request.fetchLimit = 1
|
|
do {
|
|
return try managedObjectContext.fetch(request).first
|
|
} catch {
|
|
assertionFailure(error.localizedDescription)
|
|
return nil
|
|
}
|
|
}
|
|
|
|
@discardableResult
|
|
public static func create(
|
|
in managedObjectContext: NSManagedObjectContext,
|
|
context: PersistContext
|
|
) -> Poll {
|
|
let property = Poll.Property(
|
|
entity: context.entity,
|
|
domain: context.domain,
|
|
networkDate: context.networkDate
|
|
)
|
|
let poll = Poll.insert(
|
|
into: managedObjectContext,
|
|
property: property
|
|
)
|
|
update(in: managedObjectContext, poll: poll, context: context)
|
|
return poll
|
|
}
|
|
|
|
public static func merge(
|
|
in managedObjectContext: NSManagedObjectContext,
|
|
poll: Poll,
|
|
context: PersistContext
|
|
) {
|
|
guard context.networkDate > poll.updatedAt else { return }
|
|
let property = Poll.Property(
|
|
entity: context.entity,
|
|
domain: context.domain,
|
|
networkDate: context.networkDate
|
|
)
|
|
poll.update(property: property)
|
|
update(in: managedObjectContext, poll: poll, context: context)
|
|
}
|
|
|
|
public static func update(
|
|
in managedObjectContext: NSManagedObjectContext,
|
|
poll: Poll,
|
|
context: PersistContext
|
|
) {
|
|
let optionEntities = context.entity.options
|
|
let options = poll.options.sorted(by: { $0.index < $1.index })
|
|
for (option, entity) in zip(options, optionEntities) {
|
|
Persistence.PollOption.merge(
|
|
option: option,
|
|
context: Persistence.PollOption.PersistContext(
|
|
index: Int(option.index),
|
|
poll: poll,
|
|
entity: entity,
|
|
me: context.me,
|
|
networkDate: context.networkDate
|
|
)
|
|
)
|
|
} // end for in
|
|
|
|
if let me = context.me {
|
|
if let voted = context.entity.voted {
|
|
poll.update(voted: voted, by: me)
|
|
}
|
|
|
|
let ownVotes = context.entity.ownVotes ?? []
|
|
for option in options {
|
|
let index = Int(option.index)
|
|
let isVote = ownVotes.contains(index)
|
|
option.update(voted: isVote, by: me)
|
|
}
|
|
}
|
|
|
|
// update options
|
|
if needsPollOptionsUpdate(context: context, poll: poll) {
|
|
// options differ, update them
|
|
for option in poll.options {
|
|
option.update(poll: nil)
|
|
managedObjectContext.delete(option)
|
|
}
|
|
var attachableOptions = [PollOption]()
|
|
for (index, option) in context.entity.options.enumerated() {
|
|
attachableOptions.append(
|
|
Persistence.PollOption.create(
|
|
in: managedObjectContext,
|
|
context: Persistence.PollOption.PersistContext(
|
|
index: index,
|
|
poll: poll,
|
|
entity: option,
|
|
me: context.me,
|
|
networkDate: context.networkDate
|
|
)
|
|
)
|
|
)
|
|
}
|
|
poll.attach(options: attachableOptions)
|
|
}
|
|
|
|
poll.update(updatedAt: context.networkDate)
|
|
}
|
|
|
|
private static func needsPollOptionsUpdate(context: PersistContext, poll: Poll) -> Bool {
|
|
let entityPollOptions = context.entity.options.map { (title: $0.title, votes: $0.votesCount) }
|
|
let pollOptions = poll.options.sortedByIndex().map { (title: $0.title, votes: Int($0.votesCount)) }
|
|
|
|
guard entityPollOptions.count == pollOptions.count else {
|
|
// poll definitely needs to be updated due to differences in count of options
|
|
return true
|
|
}
|
|
|
|
for (entityPollOption, pollOption) in zip(entityPollOptions, pollOptions) {
|
|
guard entityPollOption.title == pollOption.title else {
|
|
// update poll because at least one title differs
|
|
return true
|
|
}
|
|
guard entityPollOption.votes == pollOption.votes else {
|
|
// update poll because at least one vote count differs
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
}
|