127 lines
3.8 KiB
Swift
127 lines
3.8 KiB
Swift
// Copyright © 2022 Rangeproof Pty Ltd. All rights reserved.
|
|
|
|
import Foundation
|
|
import GRDB
|
|
import SessionUtilitiesKit
|
|
|
|
public struct Reaction: Codable, Equatable, Hashable, FetchableRecord, PersistableRecord, TableRecord, ColumnExpressible {
|
|
public static var databaseTableName: String { "reaction" }
|
|
internal static let profileForeignKey = ForeignKey([Columns.authorId], to: [Profile.Columns.id])
|
|
internal static let interactionForeignKey = ForeignKey([Columns.interactionId], to: [Interaction.Columns.id])
|
|
private static let profile = hasOne(Profile.self, using: profileForeignKey)
|
|
internal static let interaction = belongsTo(Interaction.self, using: interactionForeignKey)
|
|
|
|
public typealias Columns = CodingKeys
|
|
public enum CodingKeys: String, CodingKey, ColumnExpression {
|
|
case interactionId
|
|
case serverHash
|
|
case timestampMs
|
|
case authorId
|
|
case emoji
|
|
case count
|
|
case sortId
|
|
}
|
|
|
|
/// The id for the interaction this reaction belongs to
|
|
public let interactionId: Int64
|
|
|
|
/// The server hash for this reaction in the swarm
|
|
///
|
|
/// **Note:** This value will be `null` for reactions in open groups
|
|
public let serverHash: String?
|
|
|
|
/// When the reaction was created in milliseconds since epoch
|
|
public let timestampMs: Int64
|
|
|
|
/// The id for the user who made this reaction
|
|
public let authorId: String
|
|
|
|
/// The emoji for this reaction
|
|
public let emoji: String
|
|
|
|
/// The number of times this emoji was used
|
|
///
|
|
/// **Note:** This value will always be `1` for 1-1 messages and closed groups, but will be either `0` or
|
|
/// the total number of emoji's used in open groups (this allows us to `SUM` this column to get the official total
|
|
/// regardless of the type of conversation)
|
|
public let count: Int64
|
|
|
|
/// The first timestamp that an emoji is added
|
|
public let sortId: Int64
|
|
|
|
// MARK: - Relationships
|
|
|
|
public var interaction: QueryInterfaceRequest<Interaction> {
|
|
request(for: Reaction.interaction)
|
|
}
|
|
|
|
public var profile: QueryInterfaceRequest<Profile> {
|
|
request(for: Reaction.profile)
|
|
}
|
|
|
|
// MARK: - Initialization
|
|
|
|
public init(
|
|
interactionId: Int64,
|
|
serverHash: String?,
|
|
timestampMs: Int64,
|
|
authorId: String,
|
|
emoji: String,
|
|
count: Int64,
|
|
sortId: Int64
|
|
) {
|
|
self.interactionId = interactionId
|
|
self.serverHash = serverHash
|
|
self.timestampMs = timestampMs
|
|
self.authorId = authorId
|
|
self.emoji = emoji
|
|
self.count = count
|
|
self.sortId = sortId
|
|
}
|
|
}
|
|
|
|
// MARK: - Mutation
|
|
|
|
public extension Reaction {
|
|
func with(
|
|
interactionId: Int64? = nil,
|
|
serverHash: String? = nil,
|
|
authorId: String? = nil,
|
|
count: Int64? = nil,
|
|
sortId: Int64? = nil
|
|
) -> Reaction {
|
|
return Reaction(
|
|
interactionId: (interactionId ?? self.interactionId),
|
|
serverHash: (serverHash ?? self.serverHash),
|
|
timestampMs: self.timestampMs,
|
|
authorId: (authorId ?? self.authorId),
|
|
emoji: self.emoji,
|
|
count: (count ?? self.count),
|
|
sortId: (sortId ?? self.sortId)
|
|
)
|
|
}
|
|
}
|
|
|
|
// MARK: - SortId
|
|
|
|
public extension Reaction {
|
|
static func getSortId(
|
|
_ db: Database,
|
|
interactionId: Int64,
|
|
emoji: String,
|
|
timestamp: Int64
|
|
) -> Int64 {
|
|
if let existingSortId: Int64 = try? Reaction
|
|
.select(Columns.sortId)
|
|
.filter(Columns.interactionId == interactionId)
|
|
.filter(Columns.emoji == emoji)
|
|
.asRequest(of: Int64.self)
|
|
.fetchOne(db)
|
|
{
|
|
return existingSortId
|
|
}
|
|
|
|
return timestamp
|
|
}
|
|
}
|