userManager（实训）

路由只是相当于将那些请求区分然后把他跟要传的参数什么的匹配一下，列好，非常清晰，但是很明显，没有具体的方法实现代码。Router关注的是要发送的请求，就是Alamofire.request()括号里面的，但是真的要发送请求，然后把再对返回的数据进行解析什么的还是要用userManager。还是先贴代码！！

import Foundation
import Alamofire
import UIKit
import SwiftyJSON

public class UserManager: Notifier {
    
    public static let shared: UserManager = UserManager()
    
    fileprivate let userDefaults = UserDefaults.standard
    
    // MARK: - 用户相关
    
    var isLogIn = false
    
    //手机号
    var tel = ""
    //密码
    private var password = ""
    //token
    private var token = ""
    //昵称
    var username = ""
    //信用等级
    private var creditLevel = ""
    //头像
    var avatar: UIImage?
    //地点
    var location = ""
    
    public enum Notification : String {
        case didGetMessage
        case didGetMessageFailure
        case didexists
        case didexistsFailure
        case didSignup
        case didSignupFailure
        case didLogin
        case didLoginFailure
        //        case didLogout
        //        case didLogoutFailure
        case didGetUserInfo
        case didGetUserInfoFailure
        case didSetUserInfo
        case didSetUserInfoFailure
        case didGetUserAvatar
        case didGetUserAvatarFailure
    }
    
    private enum Action {
        //获取验证码
        case getMessage
        case exists
        case signUp
        case logIn
        case getUserInfo
        case setUserInfo
        case getAvatar
        case getCarInfo
    }
    
    private let actionDict: [Action: (Notification, Notification)] =
        [.getMessage: (.didGetMessage, .didGetMessageFailure),
         .exists: (.didexists, .didexistsFailure),
         .signUp: (.didSignup, .didSignupFailure),
         .logIn: (.didLogin, .didLoginFailure),
         .getUserInfo: (.didGetUserInfo, .didGetUserInfoFailure),
         .setUserInfo: (.didSetUserInfo, .didSetUserInfoFailure),
         .getAvatar: (.didGetUserAvatar, .didGetUserAvatarFailure)]
    
    private func handleResult(_ action: Action, _ response: DataResponse<Any>, completionHandler: (JSON) -> ()) {
        switch response.result {
        case .success:
            guard let value = response.result.value else {
                log("response.result.value is nil", .error)
                return
            }
            let json = JSON(value)
            guard let status = json["status"].int else { return }
            guard status == 200 else {
                log(json, .error)
                
                let (_, failureNoti) = actionDict[action]!
                UserManager.postNotification(failureNoti)
                
                return
            }
            let (successNoti, _) = actionDict[action]!
            completionHandler(json)
            UserManager.postNotification(successNoti)
            return
        case .failure(let error):
            log(error, .error)
            let (_, failureNoti) = actionDict[action]!
            UserManager.postNotification(failureNoti)
            return
        }
    }
    
    func getMessage(_ phone: String) {
        log("send message to \(phone)", .json)
        DispatchQueue.main.asyncAfter(deadline: .now() + .seconds(2), execute: {
            UserManager.postNotification(.didGetMessage)
        })
    }
    
    func exists(tel: String) {
        Alamofire.request(Router.exists(tel)).responseJSON { response in
            self.handleResult(.exists, response, completionHandler: { (json) in
                log(json, .json)
            })
        }
    }
    
    func signup(tel: String, password: String) {
        Alamofire.request(Router.signUp(tel, password)).responseJSON { response in
            self.handleResult(.signUp, response, completionHandler: { (json) in
                log(json, .json)
            })
        }
    }
    
    func login(tel: String, password: String) {
        Alamofire.request(Router.logIn(tel, password)).responseJSON { response in
            self.handleResult(.logIn, response, completionHandler: { (json) in
                log(json, .json)
                
                self.token = json["data"].string!
                log(self.token, .json)
                
                self.isLogIn = true
                self.getUserInfo()
                // 用url获得头像
                //self.avatar = UIImage(data: <#T##Data#>)
                
                self.tel = tel
                self.password = password
                
                self.userDefaults.set(true, forKey: "didLogInLastTIme")
                self.userDefaults.set(self.tel, forKey: "tel")
                self.userDefaults.set(self.password, forKey: "password")
                self.userDefaults.synchronize()
            })
        }
    }
    
    func getUserInfo() {
        Alamofire.request(Router.getUserInfo()).responseJSON { response in
            self.handleResult(.getUserInfo, response, completionHandler: { (json) in
                log(json, .json)
                self.location = json["result"]["location"].string!
                self.username = json["result"]["username"].string!
                
            })
        }
    }
    
    func setUserInfo(username: String, location: String) {
        Alamofire.request(Router.setUserInfo(username, location)).responseJSON { response in
            self.handleResult(.setUserInfo, response, completionHandler: { (json) in
                log(json, .json)
                
            })
        }
    }
    
    func setUserAvatar() {
        Alamofire.request(Router.setUserAvatar()).responseJSON { response in
            log(response, .url)
//            guard let image = response.result.value as? UIImage else {
//                log("convert to image failure", .error)
//                log(response, .error)
//                self.avatar = UIImage(named: "left_icon_defaultAvatar")
//                UserManager.postNotification(.didGetUserAvatarFailure)
//                return
//            }
//            self.avatar = image
//            UserManager.postNotification(.didGetUserAvatar)
        }
    }
    
    
    func userLogOut(){
        
        isLogIn = false
        
        password = ""
        token = ""
        username = ""
        tel = ""
        location = ""
        creditLevel = ""
        avatar = nil
        
        // 设置上次登录信息
        userDefaults.set(false, forKey: "didLogInLastTIme")
        userDefaults.set("", forKey: "tel")
        userDefaults.set("", forKey: "password")
        userDefaults.synchronize()
        
    }
    
    func getToken() -> String {
        return self.token
    }
    
    func logInWithLastTimeInfo() {
        if userDefaults.bool(forKey: "didLogInLastTIme") {
            let tel = userDefaults.string(forKey: "tel")
            let password = userDefaults.string(forKey: "password")
            log(tel, .happy)
            log(password, .happy)
            self.login(tel: tel!, password: password!)
        }
    }
    
    

其实看了前面写的Alamofire发网络请求的那一章，应该就没什么不明白的了，也应该能看明白Router跟userManager的关系了。其实这里就是把前面说的用Alamofire发送的网络挪过来了，然后发送的请求，以及发送请求的方式，都用Router封装好了。这样的话，等到我们在登录注册界面编写的时候，就不用再写用Alamofire发送各种手机号什么的参数，或者再解析JSON数据了，直接调用userManager里的相应的方法就行了。