vibes-react-native 5.0.0 → 5.0.1-rc2

package/vendor/VibesPush/Sources/InboxMessage.swift

@@ -0,0 +1,219 @@
+//
+//  InboxMessage.swift
+//  VibesPush
+//
+//  Created by Moin' Victor on 12/07/2019.
+//  Copyright © 2019 Vibes. All rights reserved.
+//
+
+import Foundation
+
+/// Inbox Message Model
+@objcMembers
+public class InboxMessage: NSObject, JSONDecodable, LocalObjectType, JSONEncodable {
+
+    static let kActivityTypeKey = "activityType"
+    static let kActivityUidKey = "activityUid"
+
+    static let eActivityTypeKey = "activity_type"
+    static let eActivityUidKey = "activity_uid"
+    static let eMessageUidKey = "message_uid"
+
+    /// Local Atrributes
+    public var attributes: [String: Any] {
+        return [
+            "message_uid": messageUID ?? "",
+            "subject": subject ?? "",
+            "content": content ?? "",
+            "detail": detail ?? "",
+            "expires_at": expiresAt ?? Date(),
+            "created_at": createdAt,
+            "collapse_key": collapseKey ?? "",
+            "images": images,
+            "read": read,
+            "inbox_custom_data": inboxCustomData,
+            "client_app_data": clientAppData,
+            "apprefdata": apprefData,
+        ]
+    }
+
+    public func encodeJSON() -> VibesJSONDictionary {
+        return [
+            "message_uid": messageUID as AnyObject,
+            "subject": subject as AnyObject,
+            "content": content as AnyObject,
+            "detail": detail as AnyObject,
+            "expires_at": expiresAt?.iso8601 as AnyObject,
+            "created_at": createdAt.iso8601 as AnyObject,
+            "collapse_key": collapseKey as AnyObject,
+            "images": images as AnyObject,
+            "read": read as AnyObject,
+            "inbox_custom_data": inboxCustomData as AnyObject,
+            "client_app_data": clientAppData as AnyObject,
+            "apprefdata": apprefData as AnyObject,
+        ] as VibesJSONDictionary
+    }
+
+    public var jsonString: String? {
+        let jsonData = try? JSONSerialization.data(withJSONObject: encodeJSON(), options: .prettyPrinted)
+        return String(data: jsonData!, encoding: .utf8)
+    }
+
+    /// Main Image for this inbox message
+    public var mainImage: String? {
+        return images["main"]
+    }
+
+    /// Icon image for this push message
+    public var iconImage: String? {
+        return images["icon"]
+    }
+
+    /// Inbox message uid
+    public var inboxMessageUID: String? {
+        return clientAppData["inbox_message_uid"] as? String
+    }
+
+    /// An uniqie identifier assosiated with the message
+    public internal(set) var messageUID: String!
+    /// The collapse key
+    public internal(set) var collapseKey: String?
+    /// The subject of the message
+    public var subject: String?
+    /// A message content
+    public var content: String!
+    /// Some details for this message, Currently this is the media URL
+    public internal(set) var detail: String?
+    /// If the message is read
+    public var read: Bool = false
+    /// images details for this message
+    public internal(set) var images = [String: String]()
+    /// inbox custom data details for this message
+    public internal(set) var inboxCustomData = VibesJSONDictionary()
+    /// client app data details for this message
+    public internal(set) var clientAppData = VibesJSONDictionary()
+    /// Appref data details for this message
+    public internal(set) var apprefData = VibesJSONDictionary()
+    /// When the message expires
+    public var expiresAt: Date?
+    /// When the message was created
+    public internal(set) var createdAt: Date = Date()
+
+    override init() {
+    }
+
+    /// Initialize new InboxMessage using properties
+    ///
+    /// - Parameters:
+    ///   - messageUID: The message id
+    ///   - subject: The subject of the message
+    ///   - content: The content of the message
+    ///   - detail: The message details
+    ///   - readStatus: The read status of the message in bool
+    ///   - expiresAt: Date when the message expires
+    init(messageUID: String, subject: String?, content: String, detail: String?, read: Bool, expiresAt: Date? = nil) {
+        self.messageUID = messageUID
+        self.subject = subject
+        self.content = content
+        self.detail = detail
+        self.read = read
+        self.expiresAt = expiresAt
+    }
+
+    /// Initialize new InboxMessage from JSONObject
+    ///
+    /// - Parameter json: The JSON object
+    required convenience init?(json: VibesJSONDictionary) {
+        self.init()
+        guard let messageUID = json["message_uid"] as? String,
+            let content = json["content"] as? String else { return nil }
+
+        self.subject = json["subject"] as? String
+        detail = json["detail"] as? String
+        collapseKey = json["collapse_key"] as? String
+        if let readStatusValue = json["read"] as? Bool {
+            read = readStatusValue
+        }
+        if let expireDateString = json["expires_at"] as? String,
+            let expireDateTime = expireDateString.iso8601 {
+            expiresAt = expireDateTime
+        }
+        if let createdDateString = json["created_at"] as? String,
+            let createdDateTime = createdDateString.iso8601 {
+            createdAt = createdDateTime
+        }
+        if let images = json["images"] as? [String: String] {
+            self.images = images
+        }
+        if let inboxCustomData = json["inbox_custom_data"] as? VibesJSONDictionary {
+            self.inboxCustomData = inboxCustomData
+        }
+        if let clientAppData = json["client_app_data"] as? VibesJSONDictionary {
+            self.clientAppData = clientAppData
+        }
+        if let apprefData = json["apprefdata"] as? VibesJSONDictionary {
+            self.apprefData = apprefData
+        }
+        self.messageUID = messageUID
+        self.content = content
+    }
+
+    /// Initialize this object using Attributes
+    ///
+    /// - Parameter attributes: - The dictionary with attributes
+    public required convenience init?(attributes: [String: Any]) {
+        self.init()
+
+        guard let messageUID = attributes["message_uid"] as? String, !messageUID.isEmpty,
+            let content = attributes["content"] as? String else { return nil }
+
+        self.subject = attributes["subject"] as? String
+        detail = attributes["detail"] as? String
+        collapseKey = attributes["collapse_key"] as? String
+        if let readStatusValue = attributes["read"] as? Bool {
+            read = readStatusValue
+        }
+        if let expireDate = attributes["expires_at"] as? Date {
+            expiresAt = expireDate
+        }
+        if let createdDateTime = attributes["created_at"] as? Date {
+            createdAt = createdDateTime
+        }
+        if let images = attributes["images"] as? [String: String] {
+            self.images = images
+        }
+        if let inboxCustomData = attributes["inbox_custom_data"] as? VibesJSONDictionary {
+            self.inboxCustomData = inboxCustomData
+        }
+        if let clientAppData = attributes["client_app_data"] as? VibesJSONDictionary {
+            self.clientAppData = clientAppData
+        }
+        if let apprefData = attributes["apprefdata"] as? VibesJSONDictionary {
+            self.apprefData = apprefData
+        }
+        self.messageUID = messageUID
+        self.content = content
+    }
+}
+
+/// Equals Comparison operator for InboxMessage
+///
+/// - Parameters:
+///   - lhs: The left hand side InboxMessage
+///   - rhs: The right hand side InboxMessage
+/// - Returns: `True` if `lhs` is equal to `rhs`, else returns `False`
+public func == (lhs: InboxMessage, rhs: InboxMessage) -> Bool {
+    return lhs.messageUID == rhs.messageUID
+}
+
+extension InboxMessage {
+
+    /// The vent map for this inbox message
+    internal func eventMap() -> [String: String] {
+        var evMap = [String: String]()
+        evMap[InboxMessage.eMessageUidKey] = messageUID
+        evMap[InboxMessage.eActivityTypeKey] = apprefData[InboxMessage.kActivityTypeKey] as? String
+        evMap[InboxMessage.eActivityUidKey] = apprefData[InboxMessage.kActivityUidKey] as? String
+        return evMap
+    }
+}

package/vendor/VibesPush/Sources/Info.plist

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>en</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleShortVersionString</key>
+	<string>5.0.0</string>
+	<key>CFBundleVersion</key>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
+	<key>LSApplicationCategoryType</key>
+	<string></string>
+	<key>NSPrincipalClass</key>
+	<string></string>
+</dict>
+</plist>

package/vendor/VibesPush/Sources/InputStream+readToString.swift

@@ -0,0 +1,19 @@
+import Foundation
+
+extension InputStream {
+  /// Read input stream to a String
+  func readToString() -> String? {
+    var data = Data()
+    self.open()
+
+    let bufferSize = 1024
+    let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: bufferSize)
+    while self.hasBytesAvailable {
+      let read = self.read(buffer, maxLength: bufferSize)
+      data.append(buffer, count: read)
+    }
+    buffer.deallocate()
+    self.close()
+    return String(data: data, encoding: String.Encoding.utf8)
+  }
+}

package/vendor/VibesPush/Sources/KeychainStorage.swift

@@ -0,0 +1,64 @@
+import Foundation
+/// A storage adapter that uses the Keychain as a local storage mechanism.
+struct KeychainStorage {
+  /// The "service" name to use
+  fileprivate let service: String
+
+  /// Initialize this object.
+  ///
+  /// - parameters:
+  ///   - service: the "service" name to use
+  init(service: String) {
+    self.service = service
+  }
+}
+
+extension KeychainStorage: LocalStorageType {
+  /// Retrieves the value in the keychain for the provided item.
+  ///
+  /// - parameters:
+  ///   - item: the local storage item to retreive
+  /// - returns: the previously-stored value, or nil
+  func get<T>(_ item: LocalValue<T>) -> T? {
+    let attributes = [
+      String(kSecClass): kSecClassGenericPassword,
+      String(kSecAttrService): service,
+      String(kSecMatchLimit): kSecMatchLimitOne,
+      String(kSecAttrAccount): item.key,
+      String(kSecReturnData): true,
+      ] as [String: Any]
+
+    var result: AnyObject?
+    let status = SecItemCopyMatching(attributes as CFDictionary, &result)
+
+    guard status == noErr else { return nil }
+    guard let data = result as? Data else { return nil }
+
+    return T.unarchive(data: data)
+  }
+
+  /// Stores a value in the keychain with the key provided.
+  ///
+  /// - parameters:
+  ///   - value: the value to store
+  ///   - item: the local storage item to use for storage
+  /// - returns: a boolean indicating whether storing the value was successful
+  func set<T>(_ value: T?, for item: LocalValue<T>) -> Bool {
+    var attributes = [
+      String(kSecClass): kSecClassGenericPassword,
+      String(kSecAttrService): service,
+      String(kSecAttrAccount): item.key,
+    ] as [String: Any]
+
+    if let value = value {
+      attributes[String(kSecValueData)] = T.archive(value: value)
+      SecItemDelete(attributes as CFDictionary)
+
+      let status = SecItemAdd(attributes as CFDictionary, nil)
+      return status == noErr
+    } else {
+      let status = SecItemDelete(attributes as CFDictionary)
+      return status == noErr
+    }
+  }
+}

package/vendor/VibesPush/Sources/LocalObject.swift

@@ -0,0 +1,25 @@
+/// A protocol for anything that can be stored as an object.
+public protocol LocalObjectType {
+  /// Attributes that should be used to store this object in local storage.
+  var attributes: [String: Any] { get }
+
+  /// Creates an object from a set of previously-stored attributes.
+  ///
+  /// - parameters:
+  ///   - attributes: a dictionary of attributes to use to create this object
+  init?(attributes: [String: Any])
+}
+
+/// A simple struct for identifying an object that is held in local storage.
+public struct LocalObject<T: LocalObjectType> {
+  /// The identifier to use to store this object.
+  let key: String
+
+  /// Initialize this object
+  ///
+  /// - paremeters:
+  ///   - key: the identifier to use to store this object
+  init(_ key: String) {
+    self.key = key
+  }
+}

package/vendor/VibesPush/Sources/LocalStorageKeys.swift

@@ -0,0 +1,19 @@
+/// Type-safe local storage used by Vibes; these static instances encapsulate
+/// the key used to store some data in local storage, along with encoding the
+/// expected type information that should be returned.
+enum LocalStorageKeys {
+    /// The current device's push token
+    static let pushToken = LocalValue<String>("VIBES_PUSH_TOKEN")
+
+    /// The current Credential
+    static let currentCredential = LocalObject<VibesCredential>("VIBES_CURRENT_CREDENTIAL")
+
+    /// The set of all known Credentials
+    static let allCredentials = LocalValue<[String: String]>("VIBES_ALL_CREDENTIALS")
+
+    /// All events that have been stored locally
+    static let events = LocalObject<EventCollection>("VIBES_EVENTS")
+
+    /// The current Vibes Person
+    static let currentPerson = LocalObject<Person>("VIBES_CURRENT_PERSON")
+}

package/vendor/VibesPush/Sources/LocalStorageType.swift

@@ -0,0 +1,47 @@
+/// A protocol that defines an adapter for allowing the storage of  values in 
+/// some sort of local storage mechanism (e.g. UserDefaults, Keychain, etc.).
+///
+/// Adopters of this protocol get the ability to get and set custom objects as 
+/// well.
+public protocol LocalStorageType {
+  /// Retrieves the value for the given item.
+  ///
+  /// - parameters:
+  ///   - item: a local value that identifies this item
+  /// - returns: an instance of T, if it was found; nil otherwise
+  func get<T>(_ item: LocalValue<T>) -> T?
+
+  /// Stores a value for the item provided.
+  ///
+  /// - parameters:
+  ///   - value: the value to store at the given key
+  ///   - item: a local value to identify this item
+  /// - returns: true if storing was successful; nil otherwise
+  @discardableResult
+  func set<T>(_ value: T?, for item: LocalValue<T>) -> Bool
+}
+
+extension LocalStorageType {
+  /// Retrieves the object stored for the given item.
+  ///
+  /// - parameters:
+  ///   - item: the local storage item to retreive
+  /// - returns: the previously-stored object, or nil
+  func get<T>(_ item: LocalObject<T>) -> T? {
+    let localValue = LocalValue<[String: Any]>(item.key)
+    guard let attributes = get(localValue) else { return nil }
+    return T.init(attributes: attributes)
+  }
+
+  /// Stores an object for the item provided.
+  ///
+  /// - parameters:
+  ///   - value: the object to store
+  ///   - item: the local storage item to use for storage
+  /// - returns: a boolean indicating whether storing the object was successful
+  @discardableResult
+  func set<T>(_ value: T?, for item: LocalObject<T>) -> Bool {
+    let localValue = LocalValue<[String: Any]>(item.key)
+    return set(value?.attributes, for: localValue)
+  }
+}

package/vendor/VibesPush/Sources/LocalValue.swift

@@ -0,0 +1,67 @@
+/// A protocol for anything that can be stored as a value. This protocol 
+/// inherits default implementations, so new values can be added just be 
+/// adopting the bare protocol, e.g. `extension Date: LocalValueType {}`
+import Foundation
+
+public protocol VibesLocalValueType {
+  /// Archives this value to Data that can be stored.
+  ///
+  /// - paremeters:
+  ///   - value: an instance of self, e.g. String
+  /// - returns: the encoded value, as data
+  static func archive(value: Self) -> Data
+
+  /// Unarchives this value from Data
+  ///
+  /// - paremeters:
+  ///   - data: the data to convert into a value
+  /// - returns: the value that was decoded
+  static func unarchive(data: Data) -> Self?
+}
+
+extension VibesLocalValueType {
+  public static func archive(value: Self) -> Data {
+    return NSKeyedArchiver.archivedData(withRootObject: value)
+  }
+
+  public static func unarchive(data: Data) -> Self? {
+    let object = NSKeyedUnarchiver.unarchiveObject(with: data)
+    return object as? Self
+  }
+}
+
+extension String: VibesLocalValueType {
+    public static func archive(value: String) -> Data {
+        return NSKeyedArchiver.archivedData(withRootObject: value)
+    }
+
+    public static func unarchive(data: Data) -> String? {
+        let object = NSKeyedUnarchiver.unarchiveObject(with: data)
+        return object as? String
+    }
+}
+
+extension Dictionary: VibesLocalValueType {
+    public static func archive(value: Dictionary) -> Data {
+        return NSKeyedArchiver.archivedData(withRootObject: value)
+    }
+
+    public static func unarchive(data: Data) -> Dictionary? {
+        let object = NSKeyedUnarchiver.unarchiveObject(with: data)
+        return object as? Dictionary
+    }
+}
+
+/// A simple struct for identifying a value that is held in local storage.
+public struct LocalValue<T: VibesLocalValueType> {
+  /// The identifier to use to store this value.
+  let key: String
+
+  /// Initialize this object.
+  ///
+  /// - paremeters:
+  ///   - key: the identifier to use to store this value.
+  init(_ key: String) {
+    self.key = key
+  }
+}

package/vendor/VibesPush/Sources/PersistentEventStorage.swift

@@ -0,0 +1,81 @@
+import Foundation
+/// An object to take care of persisting incoming events when they are received
+/// and removing them once they have been successfully sent to Vibes.
+class PersistentEventStorage {
+  /// A serial dispatch queue for changing local storage
+  private let internalQueue: DispatchQueue
+
+  /// The local storage mechanism we are using for storing events
+  private let storage: LocalStorageType
+
+  /// A property for the events currently stored locally.
+  var storedEvents: [Event] {
+    get {
+      return storage.get(LocalStorageKeys.events)?.events ?? []
+    }
+    set(newEvents) {
+      storage.set(EventCollection(events: newEvents), for: LocalStorageKeys.events)
+    }
+  }
+
+  /// Initialize this object.
+  ///
+  /// - parameters:
+  ///   - storage: a local storage mechanism for storing events
+  init(storage: LocalStorageType) {
+    self.storage = storage
+    self.internalQueue = DispatchQueue(label: "Vibes")
+  }
+
+  /// A convenience typelias for the completion of sending events to be tracked
+  /// over the API.
+  typealias TrackCompletion = (VibesResult<Void>) -> Void
+
+  /// A wrapper around sending events to Vibes; this is what handles
+  /// persisting/removing events from local storage.
+  ///
+  /// - parameters:
+  ///   - events: an Array of events to track.
+  ///   - callback: a callback for when events have been tracked via the API.
+  ///     It receives the events to store (which may be a superset of the
+  ///     events passed in) and a completion to call with the result of sending
+  ///     the events over the API.
+  func tracking(events incomingEvents: [Event], callback: ([Event], @escaping TrackCompletion) -> Void) {
+    guard let event = incomingEvents.first else {
+      return
+    }
+
+    let uniqueEvents = incomingEvents.firstUniqueElements
+    persistEvents(uniqueEvents)
+
+    let outgoingEvents = storedEvents.filter { $0.type == event.type }
+    callback(outgoingEvents, { result in
+      switch result {
+      case .success:
+        self.removeEvents(outgoingEvents)
+      default:
+        break
+      }
+    })
+  }
+
+  /// Persist events in local storage.
+  ///
+  /// - parameters:
+  ///   - events: an Array of events to persist.
+  private func persistEvents(_ events: [Event]) {
+    internalQueue.sync {
+      storedEvents.append(contentsOf: events)
+    }
+  }
+
+  /// Removes events from local storage.
+  ///
+  /// - parameters:
+  ///   - events: an Array of events to remove.
+  private func removeEvents(_ events: [Event]) {
+    internalQueue.sync {
+      storedEvents = storedEvents.filter { !events.contains($0) }
+    }
+  }
+}

package/vendor/VibesPush/Sources/Person.swift

@@ -0,0 +1,98 @@
+//
+//  Person.swift
+//  VibesPush
+//
+//  Created by clemwek on 12/07/2019.
+//  Copyright © 2019 Vibes. All rights reserved.
+//
+import Foundation
+
+@objcMembers
+public class Person: NSObject, JSONDecodable, LocalObjectType {
+    public var attributes: [String: Any] {
+        return [
+            "person_key": personKey ?? "",
+            "external_person_id": externalPersonId ?? "",
+            "mobile_phone": mobilePhone,
+        ]
+    }
+
+    /// An external identifier assosiated with the device or person if available
+    public var externalPersonId: String?
+    /// The phone number of the assosiated person if available
+    public var mdn: String?
+    /// A unique identifier for the person, provided by Vibes when  assosiated.
+    public var personKey: String?
+
+    private var mobilePhone: [String: String] = [:]
+
+    override init() {
+    }
+
+    /// Initialize for testing
+    ///
+    /// - Parameters:
+    ///   - externalPersonId: external person id
+    ///   - mdn: phone number
+    ///   - personKey: person key
+    init(externalPersonId: String, mdn: String, personKey: String) {
+        self.externalPersonId = externalPersonId
+        self.mdn = mdn
+        self.personKey = personKey
+    }
+
+    /// Initialize this object using JSONObject
+    ///
+    /// - Parameter json: The JSONObject
+    required convenience init?(json: VibesJSONDictionary) {
+        self.init()
+
+        let mdn: String?
+
+        guard let personKey = json["person_key"] as? String else { return nil }
+
+        if let mobilePhone = json["mobile_phone"] as? [String: String] {
+            mdn = mobilePhone["mdn"]
+        } else {
+            mdn = nil
+        }
+
+        self.personKey = personKey
+        externalPersonId = json["external_person_id"] as? String
+        self.mdn = mdn
+    }
+
+    /// Initialize this object using Attributes
+    ///
+    /// - Parameter attributes: - The dictionary with attributes
+    public required convenience init?(attributes: [String: Any]) {
+        self.init()
+
+        let mdn: String?
+
+        guard let personKey = attributes["person_key"] as? String,
+            !personKey.isEmpty else { return nil }
+
+        if let mobilePhone = attributes["mobile_phone"] as? [String: String] {
+            mdn = mobilePhone["mdn"]
+        } else {
+            mdn = nil
+        }
+
+        externalPersonId = attributes["external_person_id"] as? String
+        self.mdn = mdn
+        self.personKey = personKey
+    }
+}
+
+/// Equals Comparison operator for Person
+///
+/// - Parameters:
+///   - lhs: The left hand side Person
+///   - rhs: The right hand side Person
+/// - Returns: `True` if `lhs` is equal to `rhs`, else returns `False`
+public func == (lhs: Person, rhs: Person) -> Bool {
+    return lhs.personKey == rhs.personKey &&
+        lhs.externalPersonId == rhs.externalPersonId &&
+        lhs.mdn == rhs.mdn
+}