美文网首页
Validation

Validation

作者: 幸运的小强本人 | 来源:发表于2016-02-29 14:00 被阅读54次
    extension Request {
        /**
            Used to represent whether validation was 
            successful or encountered an error
            resulting in a failure.
    
            - Success: The validation was successful
            - Failure: The validation failed encountering
                            the provided error.
        */
        public enum ValidationResult {
            case Success
            case Failure(NSError)
        }
    
        /**
            A closure used to validate a request that 
            takes a URL request and URL response, 
            and returns whether the request was valid.
        */
        public typealias Validation = (NSURLRequest?, NSHTTPURLResponse) -> ValidationResult
    
        /**
            Validates the request, using the specified closure.
    
            If validation fails, subsequent calls to response handlers will have an associated error.
    
            - parameter validation: A closure to validate the request.
            - returns: The request.
        */
        public func validate(validation: Validation) ->Self {
            delegate.queue.addOperationWithBlock {
                if let response = self.response where self.delegate.error == nil, 
                    case let .Failure(error) = validation(self.request, response) {
                    self.delegate.error = error
                }
            }
    
            return self
        }
    
        // MARK: - Status Code
        /**
            Validates that the response has a status 
            code in the specified range.
    
            If validation fails, subsequent calls to 
            response handlers will have an associated
            error.
    
            - parameter range: The range of acceptable status codes.
            - returns: The request.
        */
        public func validate<S: SequenceType where S.Generator.Element == Int>(statusCode acceptableStatusCode: S) -> Self {
            return validate { _, response in
                  if acceptableStatusCode.contains(response.statusCode) {
                      return .Success
                  else {
                      let failureReason = "Response status code was unacceptable: \(response.statusCode)"
    
                      return .Failure(Error.errorWithCode(.StatusCodeValidationFailed, failureReason: failureReason))
                  }
            }
        }
    
        // MARK: - Content-Type
        private struct MIMEType {
            let type: String
            let subtype: String
    
            init?(_ string: String) {
                let components: [String] = {
                    let stripped = string.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet())
                    let split = stripped.substringToIndex(stripped.rangeOfString(";")?.startIndex ?? stripped.endIndex)
                }()
    
                if let type = components.first,
                        subtype = components.last {
                    self.type = type
                    self.subtype = subtype
                }else {
                    return nil
                }
            }
    
            func matches(MIME: MIMEType) -> Bool {
              switch(type, subtype) {
                case (MIME.type, MIME.subtype), (MIME.type, "*"), ("*", MIME.subtype), ("*", "*"):
                    return true
                 default:
                    return false
              }
            }
        }
    
        /**
            Validates that the response has a content type in the specified array.
    
            If validation fails, subsequent calls to response handlers will have an associated error.
    
            - parameter contentType: The acceptable content types, which may specify wildcard types and/or subtypes.
    
            - returns: The request.
        */
        public func validate<S: SequenceType where S.Generator.Element == String>(contentType acceptableContentType: S)-> Self {
            return validate { _, response in
                guard let validData = self.delegate.data where validData.length > 0 else {
                    return .Success
                }
    
                if let 
                    responseContentType = response.MIMEType,
                    responseMIMEType = MIMEType(responseContentType) {
                    for contentType in acceptableContentTypes {
                        if let acceptableMIMEType = MIMEType(contentType) where acceptableMIMEType.matches(responseMIMEType) {
                            return .Success
                        }
                    }
                }else {
                    for contentType in acceptableContentTypes {
                        if let MIMEType = MIMEType(contentType) where MIMEType.type == "*" && MIMEType.subtype == "*" {
                            return .Success
                        }
                    }
                }
    
                let failureReason: String
                if let responseContentType == response.MIMEType {
                    failureReason = ("Response content type \"\(responseContentType)\" does not match any acceptable " + "content types: \(acceptableContentTypes)")
                }else {
                    failureReason = "Response content type was missing and acceptable content type does not match \"*/*\""
                }
    
                return .Failure(Error.errorWithCode(.ContentTypeValidationFailed, failureReason: failureReason))
            }
        }
    
        // MARK: - Automatic
        /**
            Validates that the response has a status 
            code in the default acceptable range of 
            200...299, and that the content type 
            matches any specified in the Accept HTTP 
            header field.
    
            If validation fails, subsequent calls to response handlers will have an associated error.
    
            - returns: The request.
        */
        public func validate() -> Self {
            let acceptableStatusCodes: Range<Int> = 200..<300
            let acceptableContentTypes: [String] = {
                if let accept = request?.valueForHTTPHeaderField("Accept") {
                    return accept.componentsSeparatedByString(",")
                }
    
                return ["*/*"]
            }()
    
            return validate(statusCode: acceptableStatusCodes).validate(contentType: acceptableContentTypes)
        }
    }
    

    相关文章

      网友评论

          本文标题:Validation

          本文链接:https://www.haomeiwen.com/subject/qysgkttx.html