vibes-react-native 5.0.0 → 5.0.1-rc2

package/vendor/VibesPush/Sources/HTTP/Operations/BaseOperation.swift

@@ -0,0 +1,153 @@
+//
+//  BackendOperation.swift
+//  VibesPush-iOS
+//
+//  Created by Jean-Michel Barbieri on 2/21/18.
+//  Copyright © 2018 Vibes. All rights reserved.
+//
+import Foundation
+
+struct VibesQueueConstant {
+    static let NONE = ""
+    static let MAX_RETRY = 3
+    static let MAX_SEC: UInt32 = 15
+}
+
+internal class BaseOperation<A>: VibesQueueOperation {
+    internal var credentialManager: CredentialManager
+    fileprivate let api: VibesAPIType
+    fileprivate let advertisingId: String
+    fileprivate let appId: String
+    fileprivate let MAX_SEC = 15
+
+    /// Initialize this object
+    ///
+    /// - parameters:
+    ///   - credentialManager: an object to store credentials, keeping track of the current Credential..
+    ///   - api: an object that allows talking to the Vibes API
+    ///   - advertisingId: AdSupport.advertisingId
+    ///   - appId: the application ID provided by Vibes to identify this application
+    init(credentials: CredentialManager,
+         api: VibesAPIType,
+         advertisingId: String,
+         appId: String) {
+        self.credentialManager = credentials
+        self.api = api
+        self.advertisingId = advertisingId
+        self.appId = appId
+
+        super.init()
+    }
+
+    /// If the auth token expires (error 401), this method is called before retrying to execute the failing request.
+    /// It requests a new auth token, and if the call is successful, store it locally in the keychain.
+    /// - parameters:
+    ///   - completion: a handler for receiving the result of updating the auth token
+    fileprivate func updateDeviceToken(completion: @escaping VibesCompletion<VibesCredential>) {
+        guard let credential = credentialManager.currentCredential else {
+            // Should never be the case as we check credential for every request except reg_device
+            completion(VibesResult<VibesCredential>.failure(.noCredentials))
+            return
+        }
+        let device = Device(advertisingIdentifier: self.advertisingId)
+        let resource = APIDefinition.updateDeviceInfoPut(appId: self.appId, deviceId: credential.deviceId, device: device)
+
+        self.api.request(authToken: credential.authToken, resource: resource) {[weak self] apiResult in
+            if case .success(let credential) = apiResult {
+                self?.credentialManager.currentCredential = credential
+                // after updating token, we want to delay before retrying, just so we are sure the token update to storage has happened.
+                self?.delayWithSeconds(0.5, completion: {
+                    completion(VibesResult<VibesCredential>(apiResult))
+                })
+            } else {
+                completion(VibesResult<VibesCredential>(apiResult))
+            }
+        }
+    }
+
+    func delayWithSeconds(_ seconds: Double, completion: @escaping () -> ()) {
+        DispatchQueue.main.asyncAfter(deadline: .now() + seconds) {
+            completion()
+        }
+    }
+
+    /// Validate that credentials aren't nil
+    /// - returns:
+    ///     - VibesError: .noCredential if currentCredential are nil
+    func validateOperation() -> VibesError? {
+        if self.credentialManager.currentCredential == nil {
+            return .noCredentials
+        }
+        return nil
+    }
+
+    /// Whether to inject the auth header, override and return false to disable `Authorization` header in the request
+    /// - Returns: `true` or `false`
+    func injectAuthHeader() -> Bool {
+        return true
+    }
+
+    /// Method called to execute a new http request. The request might be first added to a queue. This persisted queue
+    /// will be reexecuted later on, if for instance a request is failing, even after several attempts.
+    /// Between each request attempt, there is a delay of several seconds (random(15s))
+    /// - parameters:
+    ///   - type: the request type (ex: REG_DEVICE, REG_PUSH ...)
+    ///   - retry: Number of retry if the request is failing. By default, if no value is provided, the retry == 2
+    ///   - resource: The resource to request
+    ///   - completion: Completion block executed after the request execution.
+    internal func execute<A>(retry: Int = VibesQueueConstant.MAX_RETRY,
+                             resource: @escaping () -> HTTPResource<A>,
+                             completion: @escaping VibesCompletion<A>) {
+        if let error = validateOperation() {
+            completion(VibesResult.failure(error))
+            self.finish()
+            return
+        }
+        let retry = (retry > VibesQueueConstant.MAX_RETRY) ? VibesQueueConstant.MAX_RETRY : retry
+        // if the auth_token is nil, 'Authorization' is not injected in the header (see class AuthTokenBehavior)
+        let authToken = self.injectAuthHeader() ? self.credentialManager.currentCredential?.authToken : nil
+        self.api.request(authToken: authToken, resource: resource()) {[weak self] initialResult in
+            // Check for Token expiration error. If so, this piece of code get a new auth_token and retry the request.
+            guard let _self = self else { return }
+
+            func doRetry() {
+                guard retry == 0 else {
+                    // When run in a unit Test, DispatchQueue.asynAfter... throws an exception.
+                    if Vibes.isRunningThroughUnitTest {
+                        self?.execute(retry: retry - 1, resource: resource, completion: completion)
+                    } else {
+                      let randomDelay = Int(arc4random_uniform(VibesQueueConstant.MAX_SEC))
+                        DispatchQueue.global(qos: .background).asyncAfter(deadline: .now() + .seconds(randomDelay)) {
+                          self?.execute(retry: retry - 1, resource: resource, completion: completion)
+                        }
+                    }
+                    return
+                }
+                let vibesResult = VibesResult<A>(initialResult)
+                completion(vibesResult)
+                _self.finish()
+            }
+
+            switch initialResult {
+            case .failure(.unauthorized):
+                _self.updateDeviceToken(completion: { updateResult in
+                    switch updateResult {
+                    case .success:
+                        _self.execute(retry: retry, resource: resource, completion: completion)
+                    case .failure(let error):
+                        completion(VibesResult<A>.failure(error))
+                        _self.finish()
+                    }
+                })
+            case .failure(.unreachable):
+                doRetry()
+            case .failure(.invalidResponse(let statusCode, _)) where statusCode.isStatusCodeForRetryableServerError():
+                doRetry()
+            default:
+                let vibesResult = VibesResult<A>(initialResult)
+                completion(vibesResult)
+                _self.finish()
+            }
+        }
+    }
+}

package/vendor/VibesPush/Sources/HTTP/Operations/EventOperation.swift

@@ -0,0 +1,73 @@
+//
+//  EventOperation.swift
+//  VibesPush-iOS
+//
+//  Created by Jean-Michel Barbieri on 2/21/18.
+//  Copyright © 2018 Vibes. All rights reserved.
+//
+
+internal class EventOperation: BaseOperation<[Event]> {
+    fileprivate let completion: VibesCompletion<[Event]>?
+    fileprivate let resource: () -> HTTPResource<Void>
+    fileprivate let outgoingEvents: [Event]
+    fileprivate let trackCompletion: (VibesResult<Void>) -> Void?
+
+    /// Initialize this object
+    ///
+    /// - parameters:
+    ///   - credentialManager: an object to store credentials, keeping track of the current Credential..
+    ///   - api: an object that allows talking to the Vibes API
+    ///   - advertisingId: AdSupport.advertisingId
+    ///   - appId: the application ID provided by Vibes to identify this application
+    ///   - completion: Vibes completion block executed by BaseOperation when the request is finished.
+    ///   - outgoingEvents: contains the list of event to send
+    ///   - trackCompletion: Completion block for the tracking system
+    public init(credentials: CredentialManager,
+                api: VibesAPIType,
+                advertisingId: String,
+                appId: String,
+                completion: VibesCompletion<[Event]>?,
+                outgoingEvents: [Event],
+                trackCompletion: @escaping (VibesResult<Void>) -> Void?) {
+        self.completion = completion
+        self.outgoingEvents = outgoingEvents
+        self.trackCompletion = trackCompletion
+        self.resource = {
+            let deviceId = credentials.currentCredential?.deviceId ?? VibesQueueConstant.NONE
+            return APIDefinition.trackEvents(appId: appId, deviceId: deviceId, events: outgoingEvents)
+        }
+        super.init(credentials: credentials, api: api, advertisingId: advertisingId, appId: appId)
+    }
+
+    /// Validate that the event are present and that the event sending concerns only one type.
+    /// Super will validate that credential exist.
+    /// - returns:
+    ///     - VibesError: nullable error
+    override func validateOperation() -> VibesError? {
+        guard outgoingEvents.first != nil else {
+            completion?(.failure(.noEvents))
+            return .noEvents
+        }
+
+        guard Set(outgoingEvents.map { $0.type }).count == 1 else {
+            completion?(.failure(.tooManyEventTypes))
+            return .tooManyEventTypes
+        }
+
+        return super.validateOperation()
+    }
+
+    /// Execute the operation
+    override func start() {
+        super.start()
+        super.execute(retry: 0, resource: resource) {[weak self] result in
+            switch result {
+            case .success:
+                self?.trackCompletion(VibesResult.success(()))
+                self?.completion?(VibesResult.success((self?.outgoingEvents)!))
+            case .failure(let error):
+                self?.completion?(VibesResult.failure(error))
+            }
+        }
+    }
+}

package/vendor/VibesPush/Sources/HTTP/Operations/GetGitTagsOperation.swift

@@ -0,0 +1,61 @@
+//
+//  GetGitTagsOperation.swift
+//  VibesPush
+//
+//  Created by Moin' Victor on 15/09/2020.
+//  Copyright © 2020 Vibes. All rights reserved.
+//
+
+import Foundation
+
+/// Get Git Tags Operation
+internal class GetGitTagsOperation: BaseOperation<GitTag> {
+    fileprivate let storage: LocalStorageType
+    fileprivate let resource: () -> HTTPResource<[GitTag]>
+    fileprivate var callback: GetGitTagsCallback
+
+    /// Completion handler responsible for notifying the caller
+    fileprivate lazy var completionHandler: VibesCompletion<[GitTag]> = { [weak self] result in
+        switch result {
+        case let .success(tags):
+            self?.callback(tags, nil)
+        case let .failure(error):
+            self?.callback([], error)
+        }
+    }
+
+    /// Initialize this object
+    ///
+    /// - parameters:
+    ///   - credentialManager: an object to store credentials, keeping track of the current Credential..
+    ///   - storage: an object that allows storing data locally
+    ///   - api: an object that allows talking to the Vibes API
+    ///   - advertisingId: AdSupport.advertisingId
+    ///   - appId: the application ID provided by Vibes to identify this application
+    ///   - callback: GetGitTagsCallback ([GitTag]], Error?)
+    public init(credentials: CredentialManager,
+                storage: LocalStorageType,
+                api: VibesAPIType,
+                advertisingId: String,
+                appId: String,
+                callback: @escaping GetGitTagsCallback) {
+        self.callback = callback
+        self.storage = storage
+        resource = {
+            APIDefinition.getGitTags()
+        }
+        super.init(credentials: credentials, api: api, advertisingId: advertisingId, appId: appId)
+    }
+
+    /// Override BaseOperation validateOperation: For this request we don't want to check
+    /// if the credentials exists.
+    override func validateOperation() -> VibesError? {
+        return nil
+    }
+
+    /// Execute the operation
+    override func start() {
+        super.start()
+        super.execute(resource: resource, completion: completionHandler)
+    }
+}

package/vendor/VibesPush/Sources/HTTP/Operations/GetInboxMessageOperation.swift

@@ -0,0 +1,59 @@
+//
+//  GetInboxMessageOperation.swift
+//  VibesPush-iOS
+//
+//  Created by Moin' Victor on 22/10/2019.
+//  Copyright © 2019 Vibes. All rights reserved.
+//
+
+import Foundation
+
+/// Get Inbox Messages Operation
+internal class GetInboxMessageOperation: BaseOperation<InboxMessage> {
+    fileprivate let storage: LocalStorageType
+    fileprivate let resource: () -> HTTPResource<InboxMessage>
+    fileprivate var callback: GetInboxMessageCallback
+
+    /// Completion handler responsible for notifying sdk users
+    fileprivate lazy var completionHandler: VibesCompletion<InboxMessage> = { [weak self] result in
+        switch result {
+        case let .success(message):
+            self?.callback(message, nil)
+        case let .failure(error):
+            self?.callback(nil, error)
+        }
+    }
+
+    /// Initialize this object
+    ///
+    /// - parameters:
+    ///   - credentialManager: an object to store credentials, keeping track of the current Credential..
+    ///   - storage: an object that allows storing data locally
+    ///   - api: an object that allows talking to the Vibes API
+    ///   - advertisingId: AdSupport.advertisingId
+    ///   - appId: the application ID provided by Vibes to identify this application
+    ///   - personKey: The alppanumeric person key
+    ///   - messageUID: The alppanumeric message UID
+    ///   - callback: GetInboxMessageCallback (InboxMessage?, Error?)
+    public init(credentials: CredentialManager,
+                storage: LocalStorageType,
+                api: VibesAPIType,
+                advertisingId: String,
+                appId: String,
+                personKey: String,
+                messageUID: String,
+                callback: @escaping GetInboxMessageCallback) {
+        self.callback = callback
+        self.storage = storage
+        resource = {
+            APIDefinition.getInboxMessage(appId: appId, personKey: personKey, messageUID: messageUID)
+        }
+        super.init(credentials: credentials, api: api, advertisingId: advertisingId, appId: appId)
+    }
+
+    /// Execute the operation
+    override func start() {
+        super.start()
+        super.execute(resource: resource, completion: completionHandler)
+    }
+}

package/vendor/VibesPush/Sources/HTTP/Operations/GetInboxMessagesOperation.swift

@@ -0,0 +1,57 @@
+//
+//  GetInboxMessagesOperation.swift
+//  VibesPush-iOS
+//
+//  Created by Moin' Victor on 16/07/2019.
+//  Copyright © 2019 Vibes. All rights reserved.
+//
+
+import Foundation
+
+/// Get Inbox Messages Operation
+internal class GetInboxMessagesOperation: BaseOperation<[InboxMessage]> {
+    fileprivate let storage: LocalStorageType
+    fileprivate let resource: () -> HTTPResource<[InboxMessage]>
+    fileprivate var callback: GetInboxMessagesCallback?
+
+    /// Completion handler responsible for notifying sdk users
+    fileprivate lazy var completionHandler: VibesCompletion<[InboxMessage]> = { [weak self] result in
+        switch result {
+        case let .success(messages):
+            self?.callback?(messages, nil)
+        case let .failure(error):
+            self?.callback?([], error)
+        }
+    }
+
+    /// Initialize this object
+    ///
+    /// - parameters:
+    ///   - credentialManager: an object to store credentials, keeping track of the current Credential..
+    ///   - storage: an object that allows storing data locally
+    ///   - api: an object that allows talking to the Vibes API
+    ///   - advertisingId: AdSupport.advertisingId
+    ///   - appId: the application ID provided by Vibes to identify this application
+    ///   - personKey: The alppanumeric person key
+    ///   - callback: GetInboxMessagesCallback ([InboxMessage], Error?)
+    public init(credentials: CredentialManager,
+                storage: LocalStorageType,
+                api: VibesAPIType,
+                advertisingId: String,
+                appId: String,
+                personKey: String,
+                callback: GetInboxMessagesCallback? = nil) {
+        self.callback = callback
+        self.storage = storage
+        resource = {
+            APIDefinition.getInboxMessages(appId: appId, personKey: personKey)
+        }
+        super.init(credentials: credentials, api: api, advertisingId: advertisingId, appId: appId)
+    }
+
+    /// Execute the operation
+    override func start() {
+        super.start()
+        super.execute(resource: resource, completion: completionHandler)
+    }
+}

package/vendor/VibesPush/Sources/HTTP/Operations/GetPersonOperation.swift

@@ -0,0 +1,53 @@
+//
+//  GetPersonOperation.swift
+//  VibesPush-iOS
+//
+//  Created by clemwek on 16/07/2019.
+//  Copyright © 2019 Vibes. All rights reserved.
+//
+
+/// Get Vibes Person Operation
+internal class GetPersonOperation: BaseOperation<Person> {
+    fileprivate let storage: LocalStorageType
+    fileprivate let resource: () -> HTTPResource<Person>
+    fileprivate var callback: GetPersonCallback?
+    /// Completion handler responsible for notifying sdk users
+    fileprivate lazy var completionHandler: VibesCompletion<Person> = { [weak self] result in
+        switch result {
+        case let .success(person):
+            self?.callback?(person, nil)
+        case let .failure(error):
+            self?.callback?(nil, error)
+        }
+    }
+
+    /// Initialize this object
+    ///
+    /// - parameters:
+    ///   - credentialManager: an object to store credentials, keeping track of the current Credential..
+    ///   - storage: an object that allows storing data locally
+    ///   - api: an object that allows talking to the Vibes API
+    ///   - advertisingId: AdSupport.advertisingId
+    ///   - appId: the application ID provided by Vibes to identify this application
+    ///   - callback: GetPersonCallback (Person?, Error?)
+    public init(credentials: CredentialManager,
+                storage: LocalStorageType,
+                api: VibesAPIType,
+                advertisingId: String,
+                appId: String,
+                callback: GetPersonCallback? = nil) {
+        self.storage = storage
+        self.callback = callback
+        resource = {
+            let deviceId = credentials.currentCredential?.deviceId ?? VibesQueueConstant.NONE
+            return APIDefinition.getPerson(appId: appId, deviceId: deviceId)
+        }
+        super.init(credentials: credentials, api: api, advertisingId: advertisingId, appId: appId)
+    }
+
+    /// Execute the operation
+    override func start() {
+        super.start()
+        super.execute(resource: resource, completion: completionHandler)
+    }
+}

package/vendor/VibesPush/Sources/HTTP/Operations/GetVibesAppInfoOperation.swift

@@ -0,0 +1,45 @@
+/// Check Vibes App Info Operation
+internal class GetVibesAppInfoOperation: BaseOperation<VibesAppInfo> {
+  fileprivate let storage: LocalStorageType
+  fileprivate let resource: () -> HTTPResource<VibesAppInfo>
+  fileprivate var callback: GetVibesAppInfoCallback?
+
+  /// Completion handler responsible for notifying sdk users
+  fileprivate lazy var completionHandler: VibesCompletion<VibesAppInfo> = { [weak self] result in
+    switch result {
+    case let .success(status):
+      self?.callback?(status, nil)
+    case let .failure(error):
+      self?.callback?(nil, error)
+    }
+  }
+
+  /// Initialize this object
+  ///
+  /// - parameters:
+  ///   - credentialManager: an object to store credentials, keeping track of the current Credential..
+  ///   - storage: an object that allows storing data locally
+  ///   - api: an object that allows talking to the Vibes API
+  ///   - advertisingId: AdSupport.advertisingId
+  ///   - appId: the application ID provided by Vibes to identify this application
+  ///   - callback: GetVibesAppInfoCallback (status?, Error?)
+  public init(credentials: CredentialManager,
+              storage: LocalStorageType,
+              api: VibesAPIType,
+              advertisingId: String,
+              appId: String,
+              callback: GetVibesAppInfoCallback? = nil) {
+    self.callback = callback
+    self.storage = storage
+    resource = {
+      APIDefinition.fetchVibesAppInfo(appId: appId)
+    }
+    super.init(credentials: credentials, api: api, advertisingId: advertisingId, appId: appId)
+  }
+
+  /// Execute the operation
+  override func start() {
+    super.start()
+    super.execute(resource: resource, completion: completionHandler)
+  }
+}

package/vendor/VibesPush/Sources/HTTP/Operations/MigrationCallbackOperation.swift

@@ -0,0 +1,45 @@
+/// Migration callback Operation
+internal class MigrationCallbackOperation: BaseOperation<Void> {
+    fileprivate let resource: () -> HTTPResource<Void>
+    fileprivate var callback: VibesCompletion<Void>?
+
+    /// Completion handler responsible for notifying sdk users
+    fileprivate lazy var completionHandler: VibesCompletion<Void> = { [weak self] result in
+        switch result {
+        case .success:
+            self?.callback?(.success(()))
+        case let .failure(error):
+            self?.callback?(.failure(error))
+        }
+    }
+
+    /// Initialize this object
+    ///
+    /// - parameters:
+    ///   - credentialManager: an object to store credentials, keeping track of the current Credential..
+    ///   - api: an object that allows talking to the Vibes API
+    ///   - advertisingId: AdSupport.advertisingId
+    ///   - appId: the application ID provided by Vibes to identify this application
+    ///   - migrationItemId: The migration item Id
+    ///   - vibesDeviceId: Vibes Device Id
+    ///   - callback: MigrationCallback (Error?)
+    public init(credentials: CredentialManager,
+                api: VibesAPIType,
+                advertisingId: String,
+                appId: String,
+                migrationItemId: String,
+                vibesDeviceId: String,
+                callback: VibesCompletion<Void>? = nil) {
+        self.callback = callback
+        resource = {
+            APIDefinition.migrationCallback(appId: appId, migrationItemId: migrationItemId, vibesDeviceId: vibesDeviceId)
+        }
+        super.init(credentials: credentials, api: api, advertisingId: advertisingId, appId: appId)
+    }
+
+    /// Execute the operation.
+    override func start() {
+        super.start()
+        super.execute(resource: resource, completion: completionHandler)
+    }
+}

package/vendor/VibesPush/Sources/HTTP/Operations/RegisterDeviceOperation.swift

@@ -0,0 +1,66 @@
+//
+//  RegisterDeviceOperation.swift
+//  VibesPush-iOS
+//
+//  Created by Jean-Michel Barbieri on 2/21/18.
+//  Copyright © 2018 Vibes. All rights reserved.
+//
+import Foundation
+
+internal class RegisterDeviceOperation: BaseOperation<VibesCredential> {
+    fileprivate let resource: () -> HTTPResource<VibesCredential>
+    fileprivate weak var delegate: VibesAPIDelegate?
+    fileprivate var callback: VibesCompletion<VibesCredential>?
+    /// Completion handler responsible for notifying sdk users
+    private lazy var completionHandler: VibesCompletion<VibesCredential> = {[weak self] (result) in
+        switch result {
+        case .success(let credential):
+            self?.credentialManager.currentCredential = credential
+            self?.delegate?.didRegisterDevice?(deviceId: credential.deviceId, error: nil)
+            self?.callback?(.success(credential))
+        case .failure(let error):
+            self?.delegate?.didRegisterDevice?(deviceId: nil, error: error)
+            self?.callback?(.failure(error))
+        }
+    }
+
+    /// Initialize this object
+    ///
+    /// - parameters:
+    ///   - credentialManager: an object to store credentials, keeping track of the current Credential..
+    ///   - api: an object that allows talking to the Vibes API
+    ///   - advertisingId: AdSupport.advertisingId
+    ///   - appId: the application ID provided by Vibes to identify this application
+    ///   - delegate: VibesAPIDelegate.
+    public init(credentials: CredentialManager,
+                api: VibesAPIType,
+                advertisingId: String,
+                appId: String,
+                delegate: VibesAPIDelegate?,
+                callback: VibesCompletion<VibesCredential>? = nil) {
+        self.delegate = delegate
+        self.callback = callback
+        resource = {
+            let device = Device(advertisingIdentifier: advertisingId)
+            return APIDefinition.registerDevice(appId: appId, device: device)
+        }
+        super.init(credentials: credentials, api: api, advertisingId: advertisingId, appId: appId)
+    }
+
+    /// Override BaseOperation validateOperation: For this request we don't want to check
+    /// if the credentials exists.
+    override func validateOperation() -> VibesError? {
+        return nil
+    }
+
+    // Execute the operation
+    override func start() {
+        super.start()
+        if let credentials = self.credentialManager.currentCredential {
+            completionHandler(VibesResult<VibesCredential>.success(credentials))
+            finish()
+            return
+        }
+        super.execute(resource: resource, completion: completionHandler)
+    }
+}