656 lines
18 KiB
Swift
656 lines
18 KiB
Swift
//
|
|
// UserConfigResponse.swift
|
|
// QuickLocation
|
|
//
|
|
// Created by 八条 on 2026/5/26.
|
|
//
|
|
|
|
import Foundation
|
|
import ObjectMapper
|
|
|
|
private let kUserStatusTransformInt64 = TransformOf<Int64, Any>(fromJSON: { value in
|
|
switch value {
|
|
case let value as Int64:
|
|
return value
|
|
case let value as Int:
|
|
return Int64(value)
|
|
case let value as Double:
|
|
return Int64(value)
|
|
case let value as String:
|
|
return Int64(value)
|
|
default:
|
|
return nil
|
|
}
|
|
}, toJSON: { value in
|
|
value
|
|
})
|
|
|
|
class UserConfigResponse: BaseModelProtocol {
|
|
var code: String?
|
|
|
|
var message: String?
|
|
|
|
var model: UserConfigModel?
|
|
|
|
required init?(map: Map) {
|
|
|
|
}
|
|
|
|
func mapping(map: Map) {
|
|
code <- map["code"]
|
|
message <- map["message"]
|
|
model <- map["data"]
|
|
}
|
|
}
|
|
|
|
class UserLoginRespons: BaseModelProtocol {
|
|
var code: String?
|
|
|
|
var message: String?
|
|
|
|
var model: UserConfigModel?
|
|
|
|
required init?(map: Map) {
|
|
|
|
}
|
|
|
|
func mapping(map: Map) {
|
|
code <- map["code"]
|
|
message <- map["message"]
|
|
model <- map["data"]
|
|
}
|
|
}
|
|
|
|
struct UserStatusResponse: BaseModelProtocol {
|
|
var code: String?
|
|
var message: String?
|
|
var model: UserStatusModel?
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
code <- (map["code"], kIntTransformStr)
|
|
message <- map["message"]
|
|
model <- map["data"]
|
|
}
|
|
}
|
|
|
|
struct UserStatusModel: Mappable {
|
|
var status: Int = 0
|
|
var mood: Int = 0
|
|
var bubbleTime: Int64 = 0
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
status <- (map["status"], kStrTransformInt)
|
|
mood <- (map["mood"], kStrTransformInt)
|
|
bubbleTime <- (map["end_time"], kUserStatusTransformInt64)
|
|
if bubbleTime == 0 {
|
|
bubbleTime <- (map["bubble_time"], kUserStatusTransformInt64)
|
|
}
|
|
}
|
|
|
|
var bubbleEndDate: Date? {
|
|
guard bubbleTime > 0 else { return nil }
|
|
let seconds = bubbleTime >= 100_000_000_000
|
|
? TimeInterval(bubbleTime) / 1000
|
|
: TimeInterval(bubbleTime)
|
|
return Date(timeIntervalSince1970: seconds)
|
|
}
|
|
}
|
|
|
|
struct PhoneUsageTripsResponse: BaseModelProtocol {
|
|
var code: String?
|
|
var message: String?
|
|
var success: Bool = false
|
|
var date: String = ""
|
|
var userId: String = ""
|
|
var trips: [ScheduleRecordModel] = []
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
code <- (map["code"], kIntTransformStr)
|
|
message <- map["message"]
|
|
success <- map["success"]
|
|
date <- map["data.date"]
|
|
userId <- (map["data.user_id"], kIntTransformStr)
|
|
trips <- map["data.trips"]
|
|
}
|
|
}
|
|
|
|
struct PhoneUsageTodayResponse: BaseModelProtocol {
|
|
var code: String?
|
|
var message: String?
|
|
var model: PhoneUsageTodayModel?
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
code <- (map["code"], kIntTransformStr)
|
|
message <- map["message"]
|
|
model <- map["data"]
|
|
}
|
|
}
|
|
|
|
struct PhoneUsageTodayModel: Mappable {
|
|
var appCount: Int?
|
|
var phoneInfo: PhoneUsageInfoModel?
|
|
var stayPoints: [PhoneUsageStayPointModel] = []
|
|
var topApps: [PhoneUsageAppModel] = []
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
appCount <- (map["app_count"], kStrTransformInt)
|
|
phoneInfo <- map["phone_info"]
|
|
stayPoints <- map["stay_points"]
|
|
topApps <- map["top_apps"]
|
|
}
|
|
}
|
|
|
|
struct PhoneUsageAppModel: Mappable {
|
|
var package: String = ""
|
|
var appName: String = ""
|
|
var appIcon: String = ""
|
|
var usageTime: Int = 0
|
|
var percentage: Int?
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
package <- (map["package"], kIntTransformStr)
|
|
appName <- (map["app_name"], kIntTransformStr)
|
|
appIcon <- (map["app_icon"], kIntTransformStr)
|
|
if appIcon.isEmpty {
|
|
appIcon <- (map["icon"], kIntTransformStr)
|
|
}
|
|
usageTime <- (map["usage_time"], kStrTransformInt)
|
|
percentage <- (map["percentage"], kStrTransformInt)
|
|
}
|
|
}
|
|
|
|
struct PhoneUsagePeriodResponse: BaseModelProtocol {
|
|
var code: String?
|
|
var message: String?
|
|
var model: PhoneUsagePeriodModel?
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
code <- (map["code"], kIntTransformStr)
|
|
message <- map["message"]
|
|
model <- map["data"]
|
|
}
|
|
}
|
|
|
|
struct PhoneUsagePeriodModel: Mappable {
|
|
var favoriteApps: [PhoneUsageAppModel] = []
|
|
var totalUsageTime: Int = 0
|
|
var useTime: String = ""
|
|
var unlockCount: String = ""
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
favoriteApps <- map["favorite_apps"]
|
|
totalUsageTime <- (map["total_usage_time"], kStrTransformInt)
|
|
useTime <- (map["use_time"], kIntTransformStr)
|
|
unlockCount <- (map["unlock_count"], kIntTransformStr)
|
|
}
|
|
}
|
|
|
|
struct PhoneUsageReportResponse: BaseModelProtocol {
|
|
var code: String?
|
|
var message: String?
|
|
var model: PhoneUsageReportModel?
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
code <- (map["code"], kIntTransformStr)
|
|
message <- map["message"]
|
|
model <- map["data"]
|
|
}
|
|
}
|
|
|
|
struct PhoneUsageReportModel: Mappable {
|
|
var phoneInfo: PhoneUsageInfoModel?
|
|
var brand: String = ""
|
|
var brandIcon: String = ""
|
|
var screenUseTimes: [PhoneUsageReportDayModel] = []
|
|
var appUseCounts: [PhoneUsageReportDayModel] = []
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
phoneInfo <- map["phone_info"]
|
|
brand <- (map["brand"], kIntTransformStr)
|
|
brandIcon <- (map["brand_icon"], kIntTransformStr)
|
|
screenUseTimes <- map["screen_use_times"]
|
|
appUseCounts <- map["app_use_counts"]
|
|
}
|
|
}
|
|
|
|
struct PhoneUsageReportDayModel: Mappable {
|
|
var day: String = ""
|
|
var useTime: Int?
|
|
var count: Int?
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
day <- (map["day"], kIntTransformStr)
|
|
useTime <- (map["use_time"], kStrTransformInt)
|
|
count <- (map["count"], kStrTransformInt)
|
|
}
|
|
}
|
|
|
|
struct PhoneUsageInfoModel: Mappable {
|
|
var brand: String = ""
|
|
var model: String = ""
|
|
var memoryTotal: String = ""
|
|
var memoryUsed: String = ""
|
|
var battery: String = ""
|
|
var network: String = ""
|
|
var brightness: String = ""
|
|
var volume: String = ""
|
|
var weather: String = ""
|
|
var useTime: String = ""
|
|
var unlockCount: String = ""
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
brand <- (map["brand"], kIntTransformStr)
|
|
model <- (map["model"], kIntTransformStr)
|
|
memoryTotal <- (map["memory_total"], kIntTransformStr)
|
|
memoryUsed <- (map["memory_used"], kIntTransformStr)
|
|
battery <- (map["battery"], kIntTransformStr)
|
|
network <- (map["network"], kIntTransformStr)
|
|
brightness <- (map["brightness"], kIntTransformStr)
|
|
volume <- (map["volume"], kIntTransformStr)
|
|
weather <- (map["weather"], kIntTransformStr)
|
|
useTime <- (map["use_time"], kIntTransformStr)
|
|
unlockCount <- (map["unlock_count"], kIntTransformStr)
|
|
}
|
|
}
|
|
|
|
struct PhoneUsageStayPointModel: Mappable {
|
|
var id: String = ""
|
|
var userId: String = ""
|
|
var location: PhoneUsageStayLocationModel?
|
|
var startTime: String = ""
|
|
var endTime: String = ""
|
|
var durationMinutes: Int?
|
|
var visitCount: Int?
|
|
var address: PhoneUsageStayAddressModel?
|
|
var createdAt: String = ""
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
id <- (map["id"], kIntTransformStr)
|
|
userId <- (map["user_id"], kIntTransformStr)
|
|
location <- map["location"]
|
|
startTime <- (map["start_time"], kIntTransformStr)
|
|
endTime <- (map["end_time"], kIntTransformStr)
|
|
durationMinutes <- (map["duration_minutes"], kStrTransformInt)
|
|
visitCount <- (map["visit_count"], kStrTransformInt)
|
|
address <- map["address"]
|
|
createdAt <- (map["created_at"], kIntTransformStr)
|
|
}
|
|
|
|
var startDate: Date? {
|
|
Self.date(from: startTime)
|
|
}
|
|
|
|
var resolvedDurationMinutes: Int? {
|
|
if let durationMinutes, durationMinutes >= 0 {
|
|
return durationMinutes
|
|
}
|
|
guard let startDate = Self.date(from: startTime),
|
|
let endDate = Self.date(from: endTime),
|
|
endDate >= startDate else { return nil }
|
|
return Int(endDate.timeIntervalSince(startDate) / 60)
|
|
}
|
|
|
|
private static func date(from value: String) -> Date? {
|
|
guard !value.isEmpty else { return nil }
|
|
let fractional = ISO8601DateFormatter()
|
|
fractional.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
|
|
if let date = fractional.date(from: value) {
|
|
return date
|
|
}
|
|
let standard = ISO8601DateFormatter()
|
|
standard.formatOptions = [.withInternetDateTime]
|
|
return standard.date(from: value)
|
|
}
|
|
}
|
|
|
|
struct PhoneUsageStayLocationModel: Mappable {
|
|
var latitude: Double = 0
|
|
var longitude: Double = 0
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
latitude <- map["latitude"]
|
|
longitude <- map["longitude"]
|
|
}
|
|
}
|
|
|
|
struct PhoneUsageStayAddressModel: Mappable {
|
|
var formattedAddress: String = ""
|
|
var country: String = ""
|
|
var province: String = ""
|
|
var city: String = ""
|
|
var district: String = ""
|
|
var street: String = ""
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
formattedAddress <- (map["formatted_address"], kIntTransformStr)
|
|
country <- (map["country"], kIntTransformStr)
|
|
province <- (map["province"], kIntTransformStr)
|
|
city <- (map["city"], kIntTransformStr)
|
|
district <- (map["district"], kIntTransformStr)
|
|
street <- (map["street"], kIntTransformStr)
|
|
}
|
|
}
|
|
|
|
struct PhoneUsageIconResponse: BaseModelProtocol {
|
|
var code: String?
|
|
var message: String?
|
|
var fileId: String = ""
|
|
|
|
static var empty: PhoneUsageIconResponse {
|
|
Mapper<PhoneUsageIconResponse>().map(JSON: [:])!
|
|
}
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
code <- (map["code"], kIntTransformStr)
|
|
message <- map["message"]
|
|
if message == nil {
|
|
message <- map["msg"]
|
|
}
|
|
fileId <- (map["data.file_id"], kIntTransformStr)
|
|
if fileId.isEmpty {
|
|
fileId <- (map["data.icon"], kIntTransformStr)
|
|
}
|
|
if fileId.isEmpty {
|
|
fileId <- (map["data.id"], kIntTransformStr)
|
|
}
|
|
if fileId.isEmpty {
|
|
fileId <- (map["data"], kIntTransformStr)
|
|
}
|
|
}
|
|
}
|
|
|
|
struct PhoneLockAppsResponse: BaseModelProtocol {
|
|
var code: String?
|
|
var message: String?
|
|
var model: PhoneLockAppsModel?
|
|
var fromUser: String = ""
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
code <- (map["code"], kIntTransformStr)
|
|
message <- map["message"]
|
|
if message == nil {
|
|
message <- map["msg"]
|
|
}
|
|
model <- map["data"]
|
|
fromUser <- (map["data.from_user"], kIntTransformStr)
|
|
if fromUser.isEmpty {
|
|
fromUser <- (map["from_user"], kIntTransformStr)
|
|
}
|
|
}
|
|
|
|
var resolvedFromUser: String {
|
|
let modelFromUser = model?.resolvedFromUser ?? ""
|
|
return modelFromUser.isEmpty ? fromUser.trimmed : modelFromUser
|
|
}
|
|
}
|
|
|
|
struct PhoneLockAppsModel: Mappable {
|
|
var apps: [PhoneLockAppItem] = []
|
|
var fromUser: String = ""
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
apps <- map["apps"]
|
|
fromUser <- (map["from_user"], kIntTransformStr)
|
|
}
|
|
|
|
var resolvedFromUser: String {
|
|
let value = fromUser.trimmed
|
|
if !value.isEmpty { return value }
|
|
return apps.first { $0.locked && !$0.fromUser.trimmed.isEmpty }?.fromUser.trimmed ?? ""
|
|
}
|
|
}
|
|
|
|
struct PhoneLockAppItem: Mappable {
|
|
var os: String = ""
|
|
var token: String = ""
|
|
var icon: String = ""
|
|
var locked: Bool = false
|
|
var fromUser: String = ""
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
os <- (map["os"], kIntTransformStr)
|
|
token <- (map["token"], kIntTransformStr)
|
|
icon <- (map["icon"], kIntTransformStr)
|
|
fromUser <- (map["from_user"], kIntTransformStr)
|
|
locked = Self.parseBool(map.JSON["locked"]) || Self.parseBool(map.JSON["is_locked"])
|
|
}
|
|
|
|
private static func parseBool(_ value: Any?) -> Bool {
|
|
switch value {
|
|
case let flag as Bool:
|
|
return flag
|
|
case let number as Int:
|
|
return number != 0
|
|
case let number as Double:
|
|
return number != 0
|
|
case let text as String:
|
|
let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
|
|
return trimmed == "1" || trimmed == "true" || trimmed == "yes"
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
|
|
struct PhoneLockedResponse: BaseModelProtocol {
|
|
var code: String?
|
|
var message: String?
|
|
var model: PhoneLockedModel?
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
code <- (map["code"], kIntTransformStr)
|
|
message <- map["message"]
|
|
if message == nil {
|
|
message <- map["msg"]
|
|
}
|
|
model <- map["data"]
|
|
}
|
|
}
|
|
|
|
struct PhoneUnlockAllowResponse: BaseModelProtocol {
|
|
var code: String?
|
|
var message: String?
|
|
var model: PhoneLockedModel?
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
code <- (map["code"], kIntTransformStr)
|
|
message <- map["message"]
|
|
if message == nil {
|
|
message <- map["msg"]
|
|
}
|
|
model <- map["data"]
|
|
}
|
|
}
|
|
|
|
struct PhoneLockedModel: Mappable {
|
|
var locks: [PhoneLockRecord] = []
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
locks <- map["locks"]
|
|
}
|
|
}
|
|
|
|
struct PhoneLockRecord: Mappable {
|
|
var id: String = ""
|
|
var fromUser: String = ""
|
|
var groupKey: String = ""
|
|
var groupName: String = ""
|
|
var userId: String = ""
|
|
var tokens: [String] = []
|
|
var os: String = ""
|
|
var iconIndex: Int = 0
|
|
var message: String = ""
|
|
var lockTime: Int64 = 0
|
|
var appIcon: String = ""
|
|
|
|
init() {}
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
id <- (map["id"], kIntTransformStr)
|
|
fromUser <- (map["from_user"], kIntTransformStr)
|
|
groupKey <- (map["group_key"], kIntTransformStr)
|
|
groupName <- (map["group_name"], kIntTransformStr)
|
|
userId <- (map["user_id"], kIntTransformStr)
|
|
os <- (map["os"], kIntTransformStr)
|
|
iconIndex <- (map["icon_index"], kStrTransformInt)
|
|
message <- (map["message"], kIntTransformStr)
|
|
lockTime <- (map["lock_time"], kUserStatusTransformInt64)
|
|
appIcon <- (map["app_icon"], kIntTransformStr)
|
|
tokens = Self.parseTokens(map.JSON["token"])
|
|
}
|
|
|
|
var displayGroupName: String {
|
|
let name = groupName.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
return name.isEmpty ? "圈子" : name
|
|
}
|
|
|
|
var lockStartDate: Date {
|
|
guard lockTime > 0 else { return Date() }
|
|
let seconds = lockTime >= 100_000_000_000
|
|
? TimeInterval(lockTime) / 1000
|
|
: TimeInterval(lockTime)
|
|
return Date(timeIntervalSince1970: seconds)
|
|
}
|
|
|
|
var wallpaperImageName: String {
|
|
let index = min(max(iconIndex, 0), 6) + 1
|
|
return "LockDistract/lock_icon_\(index)"
|
|
}
|
|
|
|
static func parseTokens(_ value: Any?) -> [String] {
|
|
if let array = value as? [Any] {
|
|
return array.compactMap(transformStr).filter { !$0.isEmpty }
|
|
}
|
|
if let text = transformStr(value), !text.isEmpty {
|
|
return [text]
|
|
}
|
|
return []
|
|
}
|
|
}
|
|
|
|
enum PhoneLockSession {
|
|
static var currentLocks: [PhoneLockRecord] = []
|
|
}
|
|
|
|
struct PhoneUnlockRequestsResponse: BaseModelProtocol {
|
|
var code: String?
|
|
var message: String?
|
|
var list: [PhoneUnlockRequestItem] = []
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
code <- (map["code"], kIntTransformStr)
|
|
message <- map["message"]
|
|
if message == nil {
|
|
message <- map["msg"]
|
|
}
|
|
list <- map["data.requests"]
|
|
if list.isEmpty {
|
|
list <- map["data.list"]
|
|
}
|
|
if list.isEmpty {
|
|
list <- map["data.locks"]
|
|
}
|
|
if list.isEmpty {
|
|
list <- map["data"]
|
|
}
|
|
}
|
|
}
|
|
|
|
struct PhoneUnlockRequestItem: Mappable {
|
|
var fromUser: String = ""
|
|
var userId: String = ""
|
|
var toUser: String = ""
|
|
var groupKey: String = ""
|
|
var os: String = ""
|
|
var nickName: String = ""
|
|
var headPic: String = ""
|
|
var tokens: [String] = []
|
|
var lockTime: Int64 = 0
|
|
var requestUnlock: Int = 0
|
|
|
|
init?(map: Map) {}
|
|
|
|
mutating func mapping(map: Map) {
|
|
fromUser <- (map["from_user"], kIntTransformStr)
|
|
userId <- (map["user_id"], kIntTransformStr)
|
|
toUser <- (map["to_user"], kIntTransformStr)
|
|
groupKey <- (map["group_key"], kIntTransformStr)
|
|
os <- (map["os"], kIntTransformStr)
|
|
nickName <- (map["nick_name"], kIntTransformStr)
|
|
if nickName.isEmpty {
|
|
nickName <- (map["name"], kIntTransformStr)
|
|
}
|
|
headPic <- (map["head_pic"], kFlexString)
|
|
if headPic.isEmpty {
|
|
headPic <- (map["avater"], kFlexString)
|
|
}
|
|
lockTime <- (map["lock_time"], kUserStatusTransformInt64)
|
|
requestUnlock <- (map["request_unlock"], kStrTransformInt)
|
|
tokens = PhoneLockRecord.parseTokens(map.JSON["token"])
|
|
}
|
|
|
|
var targetUserId: String {
|
|
let to = toUser.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
if !to.isEmpty { return to }
|
|
let from = fromUser.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
if !from.isEmpty { return from }
|
|
return userId.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
}
|
|
|
|
var lockStartDate: Date {
|
|
guard lockTime > 0 else { return Date() }
|
|
let seconds = lockTime >= 100_000_000_000
|
|
? TimeInterval(lockTime) / 1000
|
|
: TimeInterval(lockTime)
|
|
return Date(timeIntervalSince1970: seconds)
|
|
}
|
|
}
|