iOS Team / CNLiveMateCode · Files

//
//  CNLiveConfigUserInfo.swift
//  metaCode
//
//  Created by open on 2023/6/6.
//

import Foundation
import UIKit
import HandyJSON

class UserInfoModel: BaseModel {
    
//    required init() {}
    
    var appId:String = ""
    var appleUid:String = ""
    var bigFaceUrl:String = ""
    var birthday:String = ""
    var countryCode:String = ""
    var email:String = ""
    var extInfo:String = ""
    var faceUrl:String = ""
    var frmId:String = ""
    var gender:String = ""
    var hUid:String = ""
    var isNewUser:String = ""
    var location:String = ""
    var mobile:String = ""
    var newAccount:String = ""
    var nickName:String = ""
    var platformId:String = ""
    var qqUid:String = ""
    var renrenUid:String = ""
    var sinaUid:String = ""
    var token:String = ""
    var uid:String = ""
    var wxUid:String = ""
    var access_token:String = ""
    var expires_in:String = ""//过期时间
    
    override func mapping(mapper: HelpingMapper) {

        mapper <<<
            self.gender <-- TransformOf(fromJSON: { (rawString) -> String? in
                
                if let _str = rawString {
                    
                    if _str == "m" || _str == "男"  {
                        return "男"
                    }
                    if _str == "f" || _str == "女" {
                        return "女"
                    }
                }
                return "未知"
            }, toJSON: { (srcString) -> String? in
                return srcString
            })
    }
}

class UserInfoManager: NSObject {
    
    static let shared = UserInfoManager()
    
    fileprivate var _userInfo : UserInfoModel?
    private(set) var userInfo: UserInfoModel {
        
        set {
            _userInfo = newValue
        }
        
        get {
            if _userInfo != nil && (_userInfo?.uid.count)! > 0 {
                return _userInfo!
            }
            return UserInfoManager.readUserInfo()
        }
    }
    
    private override init() {}

    /// 缓存用户数据
    /// - Parameter userInfo: 用户数据 存储字符串
    static public func cacheUserInfo(userInfo: UserInfoModel) {
        UserInfoManager.clearUserInfo()
        UserInfoManager.shared._userInfo = userInfo
        //JsonUtil.modelToJson(userInfo)
        UserDefaults.standard.set(userInfo.toJSONString(), forKey: "mateCode_userInfo")
        if UserDefaults.standard.synchronize() {
            print("用户信息存储成功")
        }
    }
    
    /// 读取用户数据
    /// - Returns: 用户数据
    static public func readUserInfo() -> UserInfoModel {
        let user_info = UserDefaults.standard.object(forKey: "mateCode_userInfo")
        if user_info == nil {
            print("获取用户信息失败")
            return UserInfoModel()
        }
        if (user_info as! String).count == 0 {
            print("获取用户信息失败")
            return UserInfoModel()
        }
        let userInfo = jsonToModel(user_info as! String, UserInfoModel.self) as! UserInfoModel
        UserInfoManager.shared._userInfo = userInfo
        return userInfo
    }
    
    static public func clearUserInfo() {
        UserDefaults.standard.removeObject(forKey: "mateCode_userInfo")
        UserInfoManager.shared._userInfo = nil
        StandSortManager.removeStandSort()
        if UserDefaults.standard.synchronize() {
            print("用户信息删除成功")
        }
    }
}

class DSUserInfoManager: NSObject{
    static let shared = DSUserInfoManager()
    
    fileprivate var _dsUserInfo : CNLiveShopUserInfoModel?
    private(set) var dsUserInfo: CNLiveShopUserInfoModel {
        
        set {
            _dsUserInfo = newValue
        }
        
        get {
            if _dsUserInfo != nil && _dsUserInfo?.id != nil {
                return _dsUserInfo!
            }
            return DSUserInfoManager.readDSUserInfo()
        }
    }
    
    private override init() {}

    /// 缓存电商用户数据
    /// - Parameter dsuserInfo: 用户数据 存储字符串
    static public func cacheDSUserInfo(dsUserInfo: CNLiveShopUserInfoModel) {
        DSUserInfoManager.clearDSUserInfo()
        DSUserInfoManager.shared._dsUserInfo = dsUserInfo
        UserDefaults.standard.set(dsUserInfo.toJSONString(), forKey: "mateCode_dsUserInfo")
        if UserDefaults.standard.synchronize() {
            print("电商用户信息存储成功")
        }
    }
    
    /// 读取用户数据
    /// - Returns: 用户数据
    static public func readDSUserInfo() -> CNLiveShopUserInfoModel {
        let dsUser_info = UserDefaults.standard.object(forKey: "mateCode_dsUserInfo")
        if dsUser_info == nil {
            print("获取电商用户信息失败")
            return CNLiveShopUserInfoModel()
        }
        if (dsUser_info as! String).count == 0 {
            print("获取电商用户信息失败")
            return CNLiveShopUserInfoModel()
        }
        let dsUserInfo = jsonToModel(dsUser_info as! String, CNLiveShopUserInfoModel.self) as! CNLiveShopUserInfoModel
        DSUserInfoManager.shared._dsUserInfo = dsUserInfo
        return dsUserInfo
    }
    
    static public func clearDSUserInfo() {
        UserDefaults.standard.removeObject(forKey: "mateCode_dsUserInfo")
        DSUserInfoManager.shared._dsUserInfo = nil
        if UserDefaults.standard.synchronize() {
            print("电商用户信息删除成功")
        }
    }
}

class StandSortManager: NSObject {
    
    static let shared = StandSortManager()
    
    //根据用户信息设置key
//    static let sort_key: String = "mateCode_stand_sort_key_"+UserInfoManager.shared.userInfo.uid
    fileprivate var _indexs : Array<String>?
    private(set) var indexs: Array<String> {
        set {
            _indexs = newValue
        }
        
        get {
            return []
        }
    }
    
    static var sort_key: String {
        return "mateCode_stand_sort_key_"+UserInfoManager.shared.userInfo.uid
    }
    
    /// 存储排序信息
    /// - Parameter indexs: 排序的index
    static private func cacheStandSort(indexs: NSArray) {
        StandSortManager.shared._indexs = indexs as? Array<String>
        UserDefaults.standard.set(indexs, forKey: sort_key)
        if UserDefaults.standard.synchronize() {
            print("排序信息存储成功")
        }
    }
    
    /// 获取排序信息
    /// - Returns: 返回信息
    static private func readStandSort() -> NSArray {
        let indexs = UserDefaults.standard.object(forKey: sort_key)
        if indexs == nil {
            print("获取排序信息失败")
            return []
        }
        if (indexs as! NSArray).count == 0 {
            print("获取排序信息失败")
            return []
        }
        StandSortManager.shared._indexs = indexs as? Array<String>
        return indexs as! NSArray
    }
    
    /// 移除排序信息
    static public func removeStandSort() {
        UserDefaults.standard.removeObject(forKey: sort_key)
        StandSortManager.shared._indexs = []
        if UserDefaults.standard.synchronize() {
            print("排序信息删除成功")
        }
    }
    
    /// 对获取到的全部数据进行排序
    /// - Parameter stands: 获取到的数据
    /// - Returns: 返回  //<StandListModel>
    static public func sortAllListData(stands: NSArray) -> NSArray {
        let have_id_auths = StandSortManager.readStandSort()
        if have_id_auths.count == 0 {
            //1.29 需求 如果第一次的时候没有进行排序,则把已经认证的放在第一位
            let tempArray = NSMutableArray()
            var haveArray = Array<Any>()
            for item in stands {
                let listModel = item as! StandListModel
                if listModel.auth {
                    //2.21 需求把已经认证的第一次展示的时候再通过认证的时间先后顺序进行排序
//                    tempArray.insert(listModel, at: 0)
                    haveArray.append(listModel)
                } else {
                    //2.21 需求把未进行认证的第一次展示的时候根据后台返回的排序顺序进行排序,如果用户在进行了排序,则按照用户的排序为主
                    tempArray.add(listModel)
                }
            }
            haveArray = haveArray.sorted (by: { (item01, item02) -> Bool in
                return (item01 as! StandListModel).createTime < (item02 as! StandListModel).createTime
            })
            haveArray.forEach { item in
                tempArray.insert(item, at: 0)
            }
            return tempArray
        }
        print("allList接口里面===>\(have_id_auths)")
        let have_auths = NSMutableArray()
        let no_auths = NSMutableArray()
        for item in stands {
            let listModel = item as! StandListModel
//            print("listModel.auth==>\(listModel.auth)")
//            print("listModel.id==>\(listModel.id)")
//            print("have_id_auths==>\(have_id_auths)")
            //这里需要及时去刷新认证状态  如果没有及时刷新这里回出现已经认证的状态不会进行排序  listModel.auth &&
            have_id_auths.contains(listModel.id)  ? have_auths.add(listModel) : no_auths.add(listModel)
        }
        let tempArray = NSMutableArray()
        for item in have_auths {
            let standModel = item as! StandListModel
            let old_index = have_auths.index(of: standModel)
            let new_index = have_id_auths.index(of: standModel.id)
            if old_index != new_index && have_auths.count == have_id_auths.count {
                swap(&have_auths[new_index], &have_auths[old_index])
            }
        }
        tempArray.addObjects(from: have_auths as! [Any])
        tempArray.addObjects(from: no_auths as! [Any])
        return tempArray
    }
    
    
    /// 对已经获取到的认证身份进行排序
    /// - Parameter auths: 获取到的数据
    /// - Returns: 返回  //<MineAuthListModel>
    static public func sortMyListData(auths: NSArray) -> NSArray {
        let have_id_auths = StandSortManager.readStandSort()
        if have_id_auths.count == 0 {
            return auths
        }
        print("myList接口里面===>\(have_id_auths)")
        let have_auths = NSMutableArray.init(array: auths)
        for item in auths {
            let standModel = item as! MineAuthListModel
            let old_index = have_auths.index(of: standModel)
            let new_index = have_id_auths.index(of: standModel.identityId)
            if old_index != new_index && have_auths.count == have_id_auths.count  {
                swap(&have_auths[new_index], &have_auths[old_index])
            }
        }
        return have_auths
    }
    
    /// 更新之后重新插入
    /// - Parameter indexs: 所以
    static public func insertSortData(indexs: NSArray) {
        if (indexs.count > 0) {
            StandSortManager.shared._indexs = []
            StandSortManager.removeStandSort()
            StandSortManager.cacheStandSort(indexs: indexs)
        }
    }
    
}