hypertrack-sdk-react-native 13.2.3 → 13.3.1

package/android/src/main/java/com/reactnativehypertracksdk/common/Serialization.kt

@@ -9,7 +9,6 @@ import com.hypertrack.sdk.android.Result
  * to Map<String, T> or List<T> where T is any JSON-compatible type
  */
 internal object Serialization {
-
     fun deserializeDynamicPublishableKey(args: Serialized): WrapperResult<String> {
         return parse(args) {
             it.assertValue<String>(key = KEY_TYPE, value = TYPE_DYNAMIC_PUBLISHABLE_KEY)
@@ -19,6 +18,39 @@ internal object Serialization {
         }
     }
 
+    fun deserializeGeotagData(map: Map<String, Any?>): WrapperResult<GeotagData> {
+        return parse(map) {
+            val data =
+                it
+                    .get<Map<String, Any?>>(KEY_GEOTAG_DATA)
+                    .getOrThrow()
+            val expectedLocationData =
+                it
+                    .getOptional<Map<String, Any?>>(KEY_GEOTAG_EXPECTED_LOCATION)
+                    .getOrThrow()
+            val expectedLocation =
+                expectedLocationData?.let {
+                    deserializeLocation(it).getOrThrow()
+                }
+            val orderHandleData =
+                it
+                    .getOptional<Map<String, Any?>>(KEY_GEOTAG_ORDER_HANDLE)
+                    .getOrThrow()
+            val orderHandle = orderHandleData?.let { deserializeOrderHandle(it).getOrThrow() }
+            val orderStatusData =
+                it
+                    .getOptional<Map<String, Any?>>(KEY_GEOTAG_ORDER_STATUS)
+                    .getOrThrow()
+            val orderStatus = orderStatusData?.let { deserializeOrderStatus(it).getOrThrow() }
+            GeotagData(
+                data = data,
+                expectedLocation = expectedLocation,
+                orderHandle = orderHandle,
+                orderStatus = orderStatus,
+            )
+        }
+    }
+
     fun deserializeIsAvailable(isAvailable: Map<String, Any?>): WrapperResult<Boolean> {
         return parse(isAvailable) {
             it.assertValue<String>(key = KEY_TYPE, value = TYPE_IS_AVAILABLE)
@@ -55,49 +87,37 @@ internal object Serialization {
         }
     }
 
-    fun deserializeGeotagData(map: Map<String, Any?>): WrapperResult<GeotagData> {
-        return parse(map) {
-            val data = it
-                .get<Map<String, Any?>>(KEY_GEOTAG_DATA)
-                .getOrThrow()
-            val locationData = it
-                .getOptional<Map<String, Any?>>(KEY_GEOTAG_EXPECTED_LOCATION)
-                .getOrThrow()
-            val location = locationData?.let { deserializeLocation(it).getOrThrow() }
-            GeotagData(data, location)
-        }
-    }
-
     fun serializeDeviceId(deviceId: String): Map<String, Any?> {
         return mapOf(
             KEY_TYPE to TYPE_DEVICE_ID,
-            KEY_VALUE to deviceId
+            KEY_VALUE to deviceId,
         )
     }
 
     fun serializeDynamicPublishableKey(publishableKey: String): Serialized {
         return mapOf(
             KEY_TYPE to TYPE_DYNAMIC_PUBLISHABLE_KEY,
-            KEY_VALUE to publishableKey
+            KEY_VALUE to publishableKey,
         )
     }
 
     fun serializeError(error: HyperTrack.Error): Map<String, String> {
         return mapOf(
             KEY_TYPE to TYPE_ERROR,
-            KEY_VALUE to when (error) {
-                HyperTrack.Error.BlockedFromRunning -> "blockedFromRunning"
-                HyperTrack.Error.InvalidPublishableKey -> "invalidPublishableKey"
-                HyperTrack.Error.Location.Mocked -> "location.mocked"
-                HyperTrack.Error.Location.ServicesDisabled -> "location.servicesDisabled"
-                HyperTrack.Error.Location.ServicesUnavailable -> "location.servicesUnavailable"
-                HyperTrack.Error.Location.SignalLost -> "location.signalLost"
-                HyperTrack.Error.NoExemptionFromBackgroundStartRestrictions -> "noExemptionFromBackgroundStartRestrictions"
-                HyperTrack.Error.Permissions.Location.Denied -> "permissions.location.denied"
-                HyperTrack.Error.Permissions.Location.InsufficientForBackground -> "permissions.location.insufficientForBackground"
-                HyperTrack.Error.Permissions.Location.ReducedAccuracy -> "permissions.location.reducedAccuracy"
-                HyperTrack.Error.Permissions.Notifications.Denied -> "permissions.notifications.denied"
-            }
+            KEY_VALUE to
+                when (error) {
+                    HyperTrack.Error.BlockedFromRunning -> "blockedFromRunning"
+                    HyperTrack.Error.InvalidPublishableKey -> "invalidPublishableKey"
+                    HyperTrack.Error.Location.Mocked -> "location.mocked"
+                    HyperTrack.Error.Location.ServicesDisabled -> "location.servicesDisabled"
+                    HyperTrack.Error.Location.ServicesUnavailable -> "location.servicesUnavailable"
+                    HyperTrack.Error.Location.SignalLost -> "location.signalLost"
+                    HyperTrack.Error.NoExemptionFromBackgroundStartRestrictions -> "noExemptionFromBackgroundStartRestrictions"
+                    HyperTrack.Error.Permissions.Location.Denied -> "permissions.location.denied"
+                    HyperTrack.Error.Permissions.Location.InsufficientForBackground -> "permissions.location.insufficientForBackground"
+                    HyperTrack.Error.Permissions.Location.ReducedAccuracy -> "permissions.location.reducedAccuracy"
+                    HyperTrack.Error.Permissions.Notifications.Denied -> "permissions.notifications.denied"
+                },
         )
     }
 
@@ -110,34 +130,18 @@ internal object Serialization {
     fun serializeIsAvailable(isAvailable: Boolean): Map<String, Any?> {
         return mapOf(
             KEY_TYPE to TYPE_IS_AVAILABLE,
-            KEY_VALUE to isAvailable
+            KEY_VALUE to isAvailable,
         )
     }
 
     fun serializeIsTracking(isTracking: Boolean): Map<String, Any?> {
         return mapOf(
             KEY_TYPE to TYPE_IS_TRACKING,
-            KEY_VALUE to isTracking
+            KEY_VALUE to isTracking,
         )
     }
 
-    fun serializeMetadata(metadata: Map<String, Any?>): Map<String, Any?> {
-        return mapOf(
-            KEY_TYPE to TYPE_METADATA,
-            KEY_VALUE to metadata
-        )
-    }
-
-    fun serializeName(name: String): Map<String, Any?> {
-        return mapOf(
-            KEY_TYPE to TYPE_NAME,
-            KEY_VALUE to name
-        )
-    }
-
-    fun serializeLocateResult(
-        locationResult: Result<HyperTrack.Location, Set<HyperTrack.Error>>
-    ): Map<String, Any?> {
+    fun serializeLocateResult(locationResult: Result<HyperTrack.Location, Set<HyperTrack.Error>>): Map<String, Any?> {
         return when (locationResult) {
             is Result.Failure -> {
                 serializeFailure(serializeErrors(locationResult.failure))
@@ -149,9 +153,7 @@ internal object Serialization {
         }
     }
 
-    fun serializeLocationResult(
-        locationResult: Result<HyperTrack.Location, HyperTrack.LocationError>
-    ): Map<String, Any?> {
+    fun serializeLocationResult(locationResult: Result<HyperTrack.Location, HyperTrack.LocationError>): Map<String, Any?> {
         return when (locationResult) {
             is Result.Failure -> {
                 serializeLocationErrorFailure(locationResult.failure)
@@ -171,41 +173,55 @@ internal object Serialization {
         return serializeSuccess(serializeLocation(location))
     }
 
-    fun serializeLocationWithDeviationSuccess(
-        locationWithDeviation: HyperTrack.LocationWithDeviation,
-    ): Map<String, Any?> {
+    fun serializeLocationWithDeviationSuccess(locationWithDeviation: HyperTrack.LocationWithDeviation): Map<String, Any?> {
         return serializeSuccess(
             serializeLocationWithDeviation(
-                locationWithDeviation
-            )
+                locationWithDeviation,
+            ),
         )
     }
 
-    private fun serializeLocationWithDeviation(
-        locationWithDeviation: HyperTrack.LocationWithDeviation,
-    ): Map<String, Any?> {
+    fun serializeLocation(location: HyperTrack.Location): Map<String, Any?> {
         return mapOf(
-            KEY_TYPE to TYPE_LOCATION_WITH_DEVIATION,
-            KEY_VALUE to mapOf(
-                KEY_LOCATION to serializeLocation(locationWithDeviation.location),
-                KEY_DEVIATION to locationWithDeviation.deviation
-            )
+            KEY_TYPE to TYPE_LOCATION,
+            KEY_VALUE to
+                mapOf(
+                    KEY_LATITUDE to location.latitude,
+                    KEY_LONGITUDE to location.longitude,
+                ),
+        )
+    }
+
+    fun serializeMetadata(metadata: Map<String, Any?>): Map<String, Any?> {
+        return mapOf(
+            KEY_TYPE to TYPE_METADATA,
+            KEY_VALUE to metadata,
+        )
+    }
+
+    fun serializeName(name: String): Map<String, Any?> {
+        return mapOf(
+            KEY_TYPE to TYPE_NAME,
+            KEY_VALUE to name,
         )
     }
 
     private fun deserializeLocation(map: Map<String, Any?>): WrapperResult<Location> {
         return parse(map) {
             it.assertValue<String>(key = KEY_TYPE, value = TYPE_LOCATION)
-            val value = it
-                .get<Map<String, Any?>>(KEY_VALUE)
-                .getOrThrow()
-            parse(value) { parser ->
-                val latitude = parser
-                    .get<Double>(KEY_LATITUDE)
-                    .getOrThrow()
-                val longitude = parser
-                    .get<Double>(KEY_LONGITUDE)
+            val value =
+                it
+                    .get<Map<String, Any?>>(KEY_VALUE)
                     .getOrThrow()
+            parse(value) { parser ->
+                val latitude =
+                    parser
+                        .get<Double>(KEY_LATITUDE)
+                        .getOrThrow()
+                val longitude =
+                    parser
+                        .get<Double>(KEY_LONGITUDE)
+                        .getOrThrow()
                 Location("api").also {
                     it.latitude = latitude
                     it.longitude = longitude
@@ -214,38 +230,62 @@ internal object Serialization {
         }
     }
 
+    private fun deserializeOrderHandle(map: Map<String, Any?>): WrapperResult<String> {
+        return parse(map) {
+            it.assertValue<String>(key = KEY_TYPE, value = TYPE_ORDER_HANDLE)
+            it
+                .get<String>(KEY_VALUE)
+                .getOrThrow()
+        }
+    }
+
+    private fun deserializeOrderStatus(map: Map<String, Any?>): WrapperResult<HyperTrack.OrderStatus> {
+        return parse(map) {
+            when (it.get<String>(KEY_TYPE).getOrThrow()) {
+                TYPE_GEOTAG_ORDER_STATUS_CLOCK_IN -> HyperTrack.OrderStatus.ClockIn
+                TYPE_GEOTAG_ORDER_STATUS_CLOCK_OUT -> HyperTrack.OrderStatus.ClockOut
+                TYPE_GEOTAG_ORDER_STATUS_CUSTOM ->
+                    HyperTrack.OrderStatus.Custom(
+                        it.get<String>(KEY_VALUE).getOrThrow(),
+                    )
+
+                else -> throw Error("Unknown order status: $map")
+            }
+        }
+    }
+
+    private fun serializeLocationWithDeviation(locationWithDeviation: HyperTrack.LocationWithDeviation): Map<String, Any?> {
+        return mapOf(
+            KEY_TYPE to TYPE_LOCATION_WITH_DEVIATION,
+            KEY_VALUE to
+                mapOf(
+                    KEY_LOCATION to serializeLocation(locationWithDeviation.location),
+                    KEY_DEVIATION to locationWithDeviation.deviation,
+                ),
+        )
+    }
+
     private fun serializeFailure(failure: List<Map<String, Any?>>): Map<String, Any?> {
         return mapOf(
             KEY_TYPE to TYPE_RESULT_FAILURE,
-            KEY_VALUE to failure
+            KEY_VALUE to failure,
         )
     }
 
     private fun serializeFailure(failure: Map<String, Any?>): Map<String, Any?> {
         return mapOf(
             KEY_TYPE to TYPE_RESULT_FAILURE,
-            KEY_VALUE to failure
+            KEY_VALUE to failure,
         )
     }
 
     private fun serializeSuccess(success: Map<String, Any?>): Map<String, Any?> {
         return mapOf(
             KEY_TYPE to TYPE_RESULT_SUCCESS,
-            KEY_VALUE to success
+            KEY_VALUE to success,
         )
     }
 
-    fun serializeLocation(location: HyperTrack.Location): Map<String, Any?> {
-        return mapOf(
-            KEY_TYPE to TYPE_LOCATION,
-            KEY_VALUE to mapOf(
-                KEY_LATITUDE to location.latitude,
-                KEY_LONGITUDE to location.longitude
-            )
-        )
-    }
-
-
     private fun serializeLocationError(locationError: HyperTrack.LocationError): Map<String, Any?> {
         return when (locationError) {
             HyperTrack.LocationError.NotRunning -> {
@@ -259,8 +299,9 @@ internal object Serialization {
             is HyperTrack.LocationError.Errors -> {
                 mapOf(
                     KEY_TYPE to TYPE_LOCATION_ERROR_ERRORS,
-                    KEY_VALUE to locationError.errors
-                        .map { serializeError(it) }
+                    KEY_VALUE to
+                        locationError.errors
+                            .map { serializeError(it) },
                 )
             }
         }
@@ -268,7 +309,7 @@ internal object Serialization {
 
     fun <T> parse(
         source: Map<String, Any?>,
-        parseFunction: (Parser) -> T
+        parseFunction: (Parser) -> T,
     ): WrapperResult<T> {
         val parser = Parser(source)
         return try {
@@ -283,20 +324,18 @@ internal object Serialization {
                     ParsingExceptions(source, parser.exceptions + e)
                 } else {
                     e
-                }
+                },
             )
         }
     }
 
     internal class Parser(
-        private val source: Map<String, Any?>
+        private val source: Map<String, Any?>,
     ) {
         private val _exceptions = mutableListOf<Exception>()
         val exceptions: List<Exception> = _exceptions
 
-        inline fun <reified T> get(
-            key: String
-        ): WrapperResult<T> {
+        inline fun <reified T> get(key: String): WrapperResult<T> {
             return try {
                 Success(source[key]!! as T)
             } catch (e: Exception) {
@@ -304,14 +343,12 @@ internal object Serialization {
                     ParsingException(key, e)
                         .also {
                             _exceptions.add(it)
-                        }
+                        },
                 )
             }
         }
 
-        inline fun <reified T> getOptional(
-            key: String
-        ): WrapperResult<T?> {
+        inline fun <reified T> getOptional(key: String): WrapperResult<T?> {
             return try {
                 Success(source[key] as T?)
             } catch (e: Exception) {
@@ -319,14 +356,14 @@ internal object Serialization {
                     ParsingException(key, e)
                         .also {
                             _exceptions.add(it)
-                        }
+                        },
                 )
             }
         }
 
         inline fun <reified T> assertValue(
             key: String,
-            value: Any
+            value: Any,
         ) {
             if (source[key] != value) {
                 _exceptions.add(Exception("Assertion failed: $key != $value"))
@@ -336,17 +373,17 @@ internal object Serialization {
 
     internal data class ParsingExceptions(
         val source: Any,
-        val exceptions: List<Exception>
+        val exceptions: List<Exception>,
     ) : Throwable(
-        exceptions.joinToString("\n")
-            .let {
-                "Invalid input:\n\n${source}\n\n$it"
-            }
-    )
+            exceptions.joinToString("\n")
+                .let {
+                    "Invalid input:\n\n${source}\n\n$it"
+                },
+        )
 
     internal class ParsingException(
         key: String,
-        exception: Exception
+        exception: Exception,
     ) : Exception("Invalid value for '$key': $exception", exception)
 
     private const val KEY_TYPE = "type"
@@ -369,11 +406,18 @@ internal object Serialization {
     private const val TYPE_LOCATION_ERROR_NOT_RUNNING = "notRunning"
     private const val TYPE_LOCATION_ERROR_STARTING = "starting"
 
+    private const val TYPE_ORDER_HANDLE = "orderHandle"
+    private const val TYPE_GEOTAG_ORDER_STATUS_CLOCK_IN = "orderStatusClockIn"
+    private const val TYPE_GEOTAG_ORDER_STATUS_CLOCK_OUT = "orderStatusClockOut"
+    private const val TYPE_GEOTAG_ORDER_STATUS_CUSTOM = "orderStatusCustom"
+
     private const val KEY_LATITUDE = "latitude"
     private const val KEY_LONGITUDE = "longitude"
 
-    const val KEY_DEVIATION = "deviation"
-    const val KEY_GEOTAG_DATA = "data"
-    const val KEY_GEOTAG_EXPECTED_LOCATION = "expectedLocation"
-    const val KEY_LOCATION = "location"
+    private const val KEY_DEVIATION = "deviation"
+    private const val KEY_GEOTAG_DATA = "data"
+    private const val KEY_GEOTAG_EXPECTED_LOCATION = "expectedLocation"
+    private const val KEY_GEOTAG_ORDER_HANDLE = "orderHandle"
+    private const val KEY_GEOTAG_ORDER_STATUS = "orderStatus"
+    private const val KEY_LOCATION = "location"
 }

package/android/src/main/java/com/reactnativehypertracksdk/common/WrapperResult.kt

@@ -1,9 +1,7 @@
 package com.reactnativehypertracksdk.common
 
 internal sealed class WrapperResult<SuccessType> {
-    fun <MappedSuccess> flatMapSuccess(
-        onSuccess: (SuccessType) -> WrapperResult<MappedSuccess>
-    ): WrapperResult<MappedSuccess> {
+    fun <MappedSuccess> flatMapSuccess(onSuccess: (SuccessType) -> WrapperResult<MappedSuccess>): WrapperResult<MappedSuccess> {
         return when (this) {
             is Success -> {
                 onSuccess.invoke(this.success)
@@ -32,7 +30,7 @@ internal sealed class WrapperResult<SuccessType> {
             is Success -> this.success
             is Failure -> throw Exception(
                 "Result unwrapping failed: ${this.failure}",
-                this.failure
+                this.failure,
             )
         }
     }
@@ -49,4 +47,5 @@ internal sealed class WrapperResult<SuccessType> {
 }
 
 internal data class Success<SuccessType>(val success: SuccessType) : WrapperResult<SuccessType>()
+
 internal data class Failure<SuccessType>(val failure: Throwable) : WrapperResult<SuccessType>()

package/hypertrack-sdk-react-native.podspec

@@ -18,7 +18,7 @@ Pod::Spec.new do |s|
   s.source_files = "ios/**/*.{h,m,mm,swift}"
 
   s.dependency "React-Core"
-  s.dependency 'HyperTrack', '5.4.1'
+  s.dependency 'HyperTrack', '5.5.2'
 
   # Don't install the dependencies when we run `pod install` in the old architecture.
   if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then

package/ios/common/GeotagData.swift

@@ -3,9 +3,18 @@ import HyperTrack
 struct GeotagData {
     let data: [String: Any]
     let expectedLocation: HyperTrack.Location?
+    let orderHandle: String?
+    let orderStatus: HyperTrack.OrderStatus?
 
-    init(data: [String: Any], expectedLocation: HyperTrack.Location?) {
+    init(
+        data: [String: Any],
+        expectedLocation: HyperTrack.Location?,
+        orderHandle: String?,
+        orderStatus: HyperTrack.OrderStatus?
+    ) {
         self.data = data
         self.expectedLocation = expectedLocation
+        self.orderHandle = orderHandle
+        self.orderStatus = orderStatus
     }
 }

package/ios/common/HyperTrackSDKWrapper.swift

@@ -14,12 +14,41 @@ enum FailureResult: Error {
 func addGeotag(_ args: [String: Any]) -> Result<SuccessResult, FailureResult> {
     return deserializeGeotagData(args).flatMap { geotagData in
         if let metadata: HyperTrack.JSON.Object = toJSON(geotagData.data) {
+            let expectedLocation = geotagData.expectedLocation
+            let orderHandle = geotagData.orderHandle
+            let orderStatus = geotagData.orderStatus
+
             if let expectedLocation = geotagData.expectedLocation {
-                let result = HyperTrack.addGeotag(metadata, expectedLocation: expectedLocation)
-                return .success(.dict(serializeLocationWithDeviationResult(result)))
+                if orderHandle != nil || orderStatus != nil {
+                    if orderHandle == nil || orderStatus == nil {
+                        return .failure(.error("orderHandle and orderStatus must be provided"))
+                    }
+                    let result = HyperTrack.addGeotag(
+                        orderHandle: orderHandle!,
+                        orderStatus: orderStatus!,
+                        metadata: metadata,
+                        expectedLocation: expectedLocation
+                    )
+                    return .success(.dict(serializeLocationWithDeviationResult(result)))
+                } else {
+                    let result = HyperTrack.addGeotag(metadata, expectedLocation: expectedLocation)
+                    return .success(.dict(serializeLocationWithDeviationResult(result)))
+                }
             } else {
-                let result = HyperTrack.addGeotag(metadata)
-                return .success(.dict(serializeLocationResult(result)))
+                if orderHandle != nil || orderStatus != nil {
+                    if orderHandle == nil || orderStatus == nil {
+                        return .failure(.error("orderHandle and orderStatus must be provided"))
+                    }
+                    let result = HyperTrack.addGeotag(
+                        orderHandle: orderHandle!,
+                        orderStatus: orderStatus!,
+                        metadata: metadata
+                    )
+                    return .success(.dict(serializeLocationResult(result)))
+                } else {
+                    let result = HyperTrack.addGeotag(metadata)
+                    return .success(.dict(serializeLocationResult(result)))
+                }
             }
         } else {
             return .failure(.error("Failed to deserialize geotag metadata"))

package/ios/common/Serialization.swift

@@ -32,16 +32,56 @@ func deserializeGeotagData(
     guard let data = args[keyGeotagData] as? [String: Any] else {
         return .failure(.fatalError(getParseError(args, key: keyGeotagData)))
     }
+    let orderHandleData = args["orderHandle"] as? [String: Any]
+    let orderHandleResult: Result<String, FailureResult>? = if let orderHandleData = orderHandleData {
+        deserializeOrderHandle(orderHandleData)
+    } else {
+        nil
+    }
+    if case let .failure(failure) = orderHandleResult {
+        return .failure(failure)
+    }
+    let orderHandle: String? = if case let .success(orderHandle) = orderHandleResult {
+        orderHandle
+    } else {
+        nil
+    }
+
+    let orderStatusData = args["orderStatus"] as? [String: Any]
+    let orderStatusResult: Result<HyperTrack.OrderStatus, FailureResult>? = if let orderStatusData = orderStatusData {
+        deserializeOrderStatus(orderStatusData)
+    } else {
+        nil
+    }
+    if case let .failure(failure) = orderStatusResult {
+        return .failure(failure)
+    }
+    let orderStatus: HyperTrack.OrderStatus? = if case let .success(orderStatus) = orderStatusResult {
+        orderStatus
+    } else {
+        nil
+    }
+
     if let expectedLocationData = args[keyExpectedLocation] as? [String: Any] {
         let expectedLocation = deserializeLocation(expectedLocationData)
         switch expectedLocation {
         case let .failure(failure):
             return .failure(failure)
         case let .success(expectedLocation):
-            return .success(.init(data: data, expectedLocation: expectedLocation))
+            return .success(.init(
+                data: data,
+                expectedLocation: expectedLocation,
+                orderHandle: orderHandle,
+                orderStatus: orderStatus
+            ))
         }
     } else {
-        return .success(.init(data: data, expectedLocation: nil))
+        return .success(.init(
+            data: data,
+            expectedLocation: nil,
+            orderHandle: orderHandle,
+            orderStatus: orderStatus
+        ))
     }
 }
 
@@ -101,6 +141,35 @@ func deserializeName(_ data: [String: Any]) -> Result<String, FailureResult> {
     return .success(value)
 }
 
+func deserializeOrderHandle(_ data: [String: Any]) -> Result<String, FailureResult> {
+    if data[keyType] as? String != "orderHandle" {
+        return .failure(.fatalError(getParseError(data, key: keyType)))
+    }
+    guard let value = data[keyValue] as? String else {
+        return .failure(.fatalError(getParseError(data, key: keyValue)))
+    }
+    return .success(value)
+}
+
+func deserializeOrderStatus(_ data: [String: Any]) -> Result<HyperTrack.OrderStatus, FailureResult> {
+    guard let type = data[keyType] as? String else {
+        return .failure(.fatalError(getParseError(data, key: keyType)))
+    }
+    switch type {
+    case "orderStatusClockIn":
+        return .success(.clockIn)
+    case "orderStatusClockOut":
+        return .success(.clockOut)
+    case "orderStatusCustom":
+        guard let value = data[keyValue] as? String else {
+            return .failure(.fatalError(getParseError(data, key: keyValue)))
+        }
+        return .success(.custom(value))
+    default:
+        return .failure(.fatalError(getParseError(data, key: keyType)))
+    }
+}
+
 func serializeDeviceID(_ deviceID: String) -> [String: Any] {
     return [
         keyType: "deviceID",