Merge pull request #431 from Iterable/feature/mob-2400-createdAt

tapashmajumder · web-flow · commit fddfc95a7f23 · 2020-12-16T10:58:15.000+05:30
[MOB-2400] - Add createdAt and sentAt
diff --git a/swift-sdk/Constants.swift b/swift-sdk/Constants.swift
@@ -173,6 +173,11 @@ public enum JsonKey: String, JsonKeyRepresentable {
         static let sdkVersion = "SDK-Version"
         static let sdkPlatform = "SDK-Platform"
         static let authorization = "Authorization"
+        static let sentAt = "sentAt"
+    }
+    
+    public enum Body {
+        static let createdAt = "createdAt"
     }
     
     public enum InApp {
diff --git a/swift-sdk/Internal/IterableAPICallRequest.swift b/swift-sdk/Internal/IterableAPICallRequest.swift
@@ -14,12 +14,19 @@ struct IterableAPICallRequest {
     let deviceMetadata: DeviceMetadata
     let iterableRequest: IterableRequest
     
-    func convertToURLRequest() -> URLRequest? {
+    func convertToURLRequest(currentDate: Date) -> URLRequest? {
         switch iterableRequest {
         case let .get(getRequest):
-            return IterableRequestUtil.createGetRequest(forApiEndPoint: endPoint, path: getRequest.path, headers: createIterableHeaders(), args: getRequest.args)
+            return IterableRequestUtil.createGetRequest(forApiEndPoint: endPoint,
+                                                        path: getRequest.path,
+                                                        headers: createIterableHeaders(currentDate: currentDate),
+                                                        args: getRequest.args)
         case let .post(postRequest):
-            return IterableRequestUtil.createPostRequest(forApiEndPoint: endPoint, path: postRequest.path, headers: createIterableHeaders(), args: postRequest.args, body: postRequest.body)
+            return IterableRequestUtil.createPostRequest(forApiEndPoint: endPoint,
+                                                         path: postRequest.path,
+                                                         headers: createIterableHeaders(currentDate: currentDate),
+                                                         args: postRequest.args,
+                                                         body: postRequest.body)
         }
     }
     
@@ -32,18 +39,32 @@ struct IterableAPICallRequest {
         }
     }
     
-    private func createIterableHeaders() -> [String: String] {
+    func addingBodyField(key: AnyHashable, value: Any) -> IterableAPICallRequest {
+        IterableAPICallRequest(apiKey: apiKey,
+                               endPoint: endPoint,
+                               auth: auth,
+                               deviceMetadata: deviceMetadata,
+                               iterableRequest: iterableRequest.addingBodyField(key: key, value: value))
+    }
+    
+    private func createIterableHeaders(currentDate: Date) -> [String: String] {
         var headers = [JsonKey.contentType.jsonKey: JsonValue.applicationJson.jsonStringValue,
                        JsonKey.Header.sdkPlatform: JsonValue.iOS.jsonStringValue,
                        JsonKey.Header.sdkVersion: IterableAPI.sdkVersion,
-                       JsonKey.Header.apiKey: apiKey]
+                       JsonKey.Header.apiKey: apiKey,
+                       JsonKey.Header.sentAt: Self.format(sentAt: currentDate),
+        ]
         
         if let authToken = auth.authToken {
             headers[JsonKey.Header.authorization] = "Bearer \(authToken)"
         }
         
         return headers
     }
+    
+    private static func format(sentAt: Date) -> String {
+        return "\(IterableUtil.int(fromDate: sentAt))"
+    }
 }
 
 extension IterableAPICallRequest: Codable {}
diff --git a/swift-sdk/Internal/IterableAPICallTaskProcessor.swift b/swift-sdk/Internal/IterableAPICallTaskProcessor.swift
@@ -8,14 +8,22 @@ import Foundation
 struct IterableAPICallTaskProcessor: IterableTaskProcessor {
     let networkSession: NetworkSessionProtocol
     
+    init(networkSession: NetworkSessionProtocol, dateProvider: DateProviderProtocol = SystemDateProvider()) {
+        self.networkSession = networkSession
+        self.dateProvider = dateProvider
+    }
+    
     func process(task: IterableTask) throws -> Future<IterableTaskResult, IterableTaskError> {
         ITBInfo()
         guard let data = task.data else {
             return IterableTaskError.createErroredFuture(reason: "expecting data")
         }
         
-        let iterableRequest = try JSONDecoder().decode(IterableAPICallRequest.self, from: data)
-        guard let urlRequest = iterableRequest.convertToURLRequest() else {
+        let decodedIterableRequest = try JSONDecoder().decode(IterableAPICallRequest.self, from: data)
+        let iterableRequest = decodedIterableRequest.addingBodyField(key: JsonKey.Body.createdAt,
+                                                                     value: IterableUtil.int(fromDate: task.scheduledAt))
+        
+        guard let urlRequest = iterableRequest.convertToURLRequest(currentDate: dateProvider.currentDate) else {
             return IterableTaskError.createErroredFuture(reason: "could not convert to url request")
         }
         
@@ -38,6 +46,8 @@ struct IterableAPICallTaskProcessor: IterableTaskProcessor {
         return result
     }
     
+    private let dateProvider: DateProviderProtocol
+    
     private static func isNetworkUnavailable(sendRequestError: SendRequestError) -> Bool {
         if let originalError = sendRequestError.originalError {
             return originalError.localizedDescription.lowercased().contains("offline")
diff --git a/swift-sdk/Internal/IterableRequest.swift b/swift-sdk/Internal/IterableRequest.swift
@@ -45,6 +45,14 @@ extension IterableRequest: Codable {
         }
     }
     
+    func addingBodyField(key: AnyHashable, value: Any) -> IterableRequest {
+        if case .post(let postRequest) = self {
+            return .post(postRequest.addingBodyField(key: key, value: value))
+        } else {
+            return self
+        }
+    }
+    
     private static let requestTypeGet = "get"
     private static let requestTypePost = "post"
 }
@@ -58,6 +66,12 @@ struct PostRequest {
     let path: String
     let args: [String: String]?
     let body: [AnyHashable: Any]?
+    
+    func addingBodyField(key: AnyHashable, value: Any) -> PostRequest {
+        var newBody = body ?? [AnyHashable: Any]()
+        newBody[key] = value
+        return PostRequest(path: path, args: args, body: newBody)
+    }
 }
 
 extension PostRequest: Codable {
diff --git a/swift-sdk/Internal/IterableRequestUtil.swift b/swift-sdk/Internal/IterableRequestUtil.swift
@@ -8,15 +8,35 @@
 import Foundation
 
 struct IterableRequestUtil {
-    static func createPostRequest(forApiEndPoint apiEndPoint: String, path: String, headers: [String: String]? = nil, args: [String: String]? = nil, body: [AnyHashable: Any]? = nil) -> URLRequest? {
-        createPostRequest(forApiEndPoint: apiEndPoint, path: path, headers: headers, args: args, body: dictToJsonData(body))
+    static func createPostRequest(forApiEndPoint apiEndPoint: String,
+                                  path: String,
+                                  headers: [String: String]? = nil,
+                                  args: [String: String]? = nil,
+                                  body: [AnyHashable: Any]? = nil) -> URLRequest? {
+        createPostRequest(forApiEndPoint: apiEndPoint,
+                          path: path,
+                          headers: headers,
+                          args: args,
+                          body: dictToJsonData(body))
     }
     
-    static func createPostRequest<T: Encodable>(forApiEndPoint apiEndPoint: String, path: String, headers: [String: String]? = nil, args: [String: String]? = nil, body: T) -> URLRequest? {
-        createPostRequest(forApiEndPoint: apiEndPoint, path: path, headers: headers, args: args, body: try? JSONEncoder().encode(body))
+    static func createPostRequest<T: Encodable>(forApiEndPoint apiEndPoint: String,
+                                                path: String,
+                                                headers: [String: String]? = nil,
+                                                args: [String: String]? = nil,
+                                                body: T) -> URLRequest? {
+        createPostRequest(forApiEndPoint: apiEndPoint,
+                          path: path,
+                          headers: headers,
+                          args: args,
+                          body: try? JSONEncoder().encode(body))
     }
     
-    static func createPostRequest(forApiEndPoint apiEndPoint: String, path: String, headers: [String: String]? = nil, args: [String: String]? = nil, body: Data? = nil) -> URLRequest? {
+    static func createPostRequest(forApiEndPoint apiEndPoint: String,
+                                  path: String,
+                                  headers: [String: String]? = nil,
+                                  args: [String: String]? = nil,
+                                  body: Data? = nil) -> URLRequest? {
         guard let url = getUrlComponents(forApiEndPoint: apiEndPoint, path: path, args: args)?.url else {
             return nil
         }
@@ -29,7 +49,10 @@ struct IterableRequestUtil {
         return request
     }
     
-    static func createGetRequest(forApiEndPoint apiEndPoint: String, path: String, headers: [String: String]? = nil, args: [String: String]? = nil) -> URLRequest? {
+    static func createGetRequest(forApiEndPoint apiEndPoint: String,
+                                 path: String,
+                                 headers: [String: String]? = nil,
+                                 args: [String: String]? = nil) -> URLRequest? {
         guard let url = getUrlComponents(forApiEndPoint: apiEndPoint, path: path, args: args)?.url else {
             return nil
         }
diff --git a/swift-sdk/Internal/IterableTask.swift b/swift-sdk/Internal/IterableTask.swift
@@ -11,17 +11,17 @@ struct IterableTask {
     let id: String
     let name: String?
     let version: Int
-    let createdAt: Date?
-    let modifiedAt: Date?
+    let createdAt: Date? // Time at which this task record was created
+    let modifiedAt: Date? // Time when this record was modified
     let type: IterableTaskType
     let attempts: Int
     let lastAttemptedAt: Date?
     let processing: Bool
-    let scheduledAt: Date
+    let scheduledAt: Date // Time after which this task can be scheduled
     let data: Data?
     let failed: Bool
     let blocking: Bool
-    let requestedAt: Date
+    let requestedAt: Date // Time when the request was made by SDK
     let taskFailureData: Data?
     
     init(id: String,
diff --git a/swift-sdk/Internal/IterableTaskRunner.swift b/swift-sdk/Internal/IterableTaskRunner.swift
@@ -13,12 +13,14 @@ class IterableTaskRunner: NSObject {
          persistenceContextProvider: IterablePersistenceContextProvider,
          notificationCenter: NotificationCenterProtocol = NotificationCenter.default,
          timeInterval: TimeInterval = 1.0 * 60,
-         connectivityManager: NetworkConnectivityManager = NetworkConnectivityManager()) {
+         connectivityManager: NetworkConnectivityManager = NetworkConnectivityManager(),
+         dateProvider: DateProviderProtocol = SystemDateProvider()) {
         ITBInfo()
         self.networkSession = networkSession
         self.persistenceContextProvider = persistenceContextProvider
         self.notificationCenter = notificationCenter
         self.timeInterval = timeInterval
+        self.dateProvider = dateProvider
         self.connectivityManager = connectivityManager
         
         super.init()
@@ -174,7 +176,7 @@ class IterableTaskRunner: NSObject {
 
         switch task.type {
         case .apiCall:
-            let processor = IterableAPICallTaskProcessor(networkSession: networkSession)
+            let processor = IterableAPICallTaskProcessor(networkSession: networkSession, dateProvider: dateProvider)
             return processAPICallTask(processor: processor, task: task)
         }
     }
@@ -183,7 +185,6 @@ class IterableTaskRunner: NSObject {
                                     task: IterableTask) -> Future<TaskExecutionResult, Never> {
         ITBInfo()
         let result = Promise<TaskExecutionResult, Never>()
-        let processor = IterableAPICallTaskProcessor(networkSession: networkSession)
         do {
             try processor.process(task: task).onSuccess { taskResult in
                 switch taskResult {
@@ -254,6 +255,7 @@ class IterableTaskRunner: NSObject {
     private let persistenceContextProvider: IterablePersistenceContextProvider
     private let notificationCenter: NotificationCenterProtocol
     private let timeInterval: TimeInterval
+    private let dateProvider: DateProviderProtocol
     private let connectivityManager: NetworkConnectivityManager
     private weak var timer: Timer?
     private var running = false
diff --git a/tests/offline-events-tests/RequestProcessorTests.swift b/tests/offline-events-tests/RequestProcessorTests.swift
@@ -684,7 +684,9 @@ class RequestProcessorTests: XCTestCase {
         let networkSession = MockNetworkSession(statusCode: 400)
         networkSession.requestCallback = { request in
             TestUtils.validate(request: request, apiEndPoint: Endpoint.api, path: path)
-            XCTAssertTrue(TestUtils.areEqual(dict1: bodyDict, dict2: request.bodyDict))
+            var requestBody = request.bodyDict
+            requestBody.removeValue(forKey: "createdAt")
+            XCTAssertTrue(TestUtils.areEqual(dict1: bodyDict, dict2: requestBody))
         }
         let requestProcessor = createRequestProcessor(networkSession: networkSession,
                                                       notificationCenter: notificationCenter,
@@ -737,7 +739,9 @@ class RequestProcessorTests: XCTestCase {
                                            expectation: XCTestExpectation) {
         networkSession.requestCallback = { request in
             TestUtils.validate(request: request, apiEndPoint: Endpoint.api, path: path)
-            XCTAssertTrue(TestUtils.areEqual(dict1: bodyDict, dict2: request.bodyDict))
+            var requestBody = request.bodyDict
+            requestBody.removeValue(forKey: "createdAt")
+            XCTAssertTrue(TestUtils.areEqual(dict1: bodyDict, dict2: requestBody))
         }
         
         request().onSuccess { json in
@@ -754,7 +758,9 @@ class RequestProcessorTests: XCTestCase {
                                            expectation: XCTestExpectation) {
         networkSession.requestCallback = { request in
             TestUtils.validate(request: request, apiEndPoint: Endpoint.api, path: path)
-            XCTAssertTrue(TestUtils.areEqual(dict1: bodyDict, dict2: request.bodyDict))
+            var requestBody = request.bodyDict
+            requestBody.removeValue(forKey: "createdAt")
+            XCTAssertTrue(TestUtils.areEqual(dict1: bodyDict, dict2: requestBody))
         }
         request().onSuccess { json in
             XCTFail()
diff --git a/tests/offline-events-tests/TaskProcessorTests.swift b/tests/offline-events-tests/TaskProcessorTests.swift
@@ -142,8 +142,80 @@ class TaskProcessorTests: XCTestCase {
         try persistenceProvider.mainQueueContext().save()
         wait(for: [expectation1], timeout: 15.0)
     }
+    
+    func testSentAtInHeader() throws {
+        let expectation1 = expectation(description: #function)
+        let task = try createSampleTask()!
+        let date = Date()
+        let sentAtTime = "\(Int(date.timeIntervalSince1970 * 1000))"
+        let dateProvider = MockDateProvider()
+        dateProvider.currentDate = date
+        
+        let networkSession = MockNetworkSession()
+        networkSession.requestCallback = { request in
+            if request.allHTTPHeaderFields!.contains(where: { $0.key == "sentAt" && $0.value == sentAtTime }) {
+                expectation1.fulfill()
+            }
+        }
+        
+        // process data
+        let processor = IterableAPICallTaskProcessor(networkSession: networkSession, dateProvider: dateProvider)
+        try processor.process(task: task)
+            .onSuccess { taskResult in
+                switch taskResult {
+                case .success(detail: _):
+                    break
+                case .failureWithNoRetry(detail: _):
+                    XCTFail("not expecting failure with no retry")
+                case .failureWithRetry(retryAfter: _, detail: _):
+                    XCTFail("not expecting failure with retry")
+                }
+            }
+            .onError { _ in
+                XCTFail()
+            }
 
-    private func createSampleTask() throws -> IterableTask? {
+        try persistenceProvider.mainQueueContext().delete(task: task)
+        try persistenceProvider.mainQueueContext().save()
+        wait(for: [expectation1], timeout: 5.0)
+    }
+
+    func testCreatedAtInBody() throws {
+        let expectation1 = expectation(description: #function)
+        let date = Date()
+        let createdAtTime = Int(date.timeIntervalSince1970 * 1000)
+        let task = try createSampleTask(scheduledAt: date)!
+        
+        let networkSession = MockNetworkSession()
+        networkSession.requestCallback = { request in
+            if request.bodyDict.contains(where: { $0.key == "createdAt" && ($0.value as! Int) == createdAtTime }) {
+                expectation1.fulfill()
+            }
+        }
+        
+        // process data
+        let processor = IterableAPICallTaskProcessor(networkSession: networkSession)
+        try processor.process(task: task)
+            .onSuccess { taskResult in
+                switch taskResult {
+                case .success(detail: _):
+                    break
+                case .failureWithNoRetry(detail: _):
+                    XCTFail("not expecting failure with no retry")
+                case .failureWithRetry(retryAfter: _, detail: _):
+                    XCTFail("not expecting failure with retry")
+                }
+            }
+            .onError { _ in
+                XCTFail()
+            }
+
+        try persistenceProvider.mainQueueContext().delete(task: task)
+        try persistenceProvider.mainQueueContext().save()
+        wait(for: [expectation1], timeout: 5.0)
+    }
+
+    private func createSampleTask(scheduledAt: Date = Date(), requestedAt: Date = Date()) throws -> IterableTask? {
         let apiKey = "test-api-key"
         let email = "user@example.com"
         let eventName = "CustomEvent1"
@@ -169,9 +241,9 @@ class TaskProcessorTests: XCTestCase {
         let taskId = IterableUtil.generateUUID()
         try persistenceProvider.mainQueueContext().create(task: IterableTask(id: taskId,
                                                                              type: .apiCall,
-                                                                             scheduledAt: Date(),
+                                                                             scheduledAt: scheduledAt,
                                                                              data: data,
-                                                                             requestedAt: Date()))
+                                                                             requestedAt: requestedAt))
         try persistenceProvider.mainQueueContext().save()
 
         return try persistenceProvider.mainQueueContext().findTask(withId: taskId)
diff --git a/tests/offline-events-tests/TaskRunnerTests.swift b/tests/offline-events-tests/TaskRunnerTests.swift
diff --git a/tests/swift-sdk-swift-tests/InAppTests.swift b/tests/swift-sdk-swift-tests/InAppTests.swift
