@dashx/react-native 0.1.23 → 1.0.2

package/android/src/main/java/com/dashx/rn/sdk/DashXReactNativeModule.kt

@@ -0,0 +1,250 @@
+package com.dashx.rn.sdk
+
+import android.annotation.TargetApi
+import android.content.Context
+import android.database.Cursor
+import android.net.Uri
+import android.os.Build
+import android.provider.DocumentsContract
+import android.provider.MediaStore
+import com.dashx.rn.sdk.util.*
+import com.dashx.sdk.DashXLog
+import com.dashx.sdk.data.ExternalAsset
+import com.facebook.react.bridge.*
+import com.google.gson.Gson
+import java.io.File
+import com.dashx.sdk.DashXClient as DashX
+
+
+class DashXReactNativeModule(private val reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    private val tag = DashXReactNativeModule::class.java.simpleName
+    private var dashXClient: DashX? = null
+
+    override fun getName(): String {
+        return "DashXReactNative"
+    }
+
+    @ReactMethod
+    fun setLogLevel(logLevel: Int) {
+        DashXLog.setLogLevel(logLevel)
+    }
+
+    @ReactMethod
+    fun configure(options: ReadableMap) {
+        dashXClient = DashX.createInstance(
+            reactContext, 
+            options.getString("publicKey")!!,
+            options.getStringIfPresent("baseURI"),
+            options.getStringIfPresent("targetEnvironment")
+        )
+    }
+
+    @ReactMethod
+    fun identify(options: ReadableMap?) {
+        val optionsHashMap = MapUtil.toMap(options)
+        dashXClient?.identify(optionsHashMap as HashMap<String, String>?)
+    }
+
+    @ReactMethod
+    fun setIdentity(uid: String?, token: String?) {
+        dashXClient?.setIdentity(uid, token)
+    }
+
+    @ReactMethod
+    fun reset() {
+        dashXClient?.reset()
+    }
+
+    @ReactMethod
+    fun track(event: String, data: ReadableMap?) {
+        val jsonData = try {
+            MapUtil.toMap(data) as HashMap<String, String>
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            return
+        }
+
+        dashXClient?.track(event, jsonData)
+    }
+
+    @ReactMethod
+    fun screen(screenName: String, data: ReadableMap?) {
+        dashXClient?.screen(screenName, MapUtil.toMap(data) as HashMap<String, String>)
+    }
+
+    @ReactMethod
+    fun fetchContent(urn: String, options: ReadableMap?, promise: Promise) {
+        dashXClient?.fetchContent(
+            urn,
+            options?.getBooleanIfPresent("preview"),
+            options?.getStringIfPresent("language"),
+            listOf(options?.getArray("fields")) as List<String>?,
+            listOf(options?.getArray("include")) as List<String>?,
+            listOf(options?.getArray("exclude")) as List<String>?,
+            onError = {
+                promise.reject("EUNSPECIFIED", it)
+            },
+            onSuccess = {
+                promise.resolve(convertJsonToMap(it))
+            }
+        )
+    }
+
+    @ReactMethod
+    fun searchContent(contentType: String, options: ReadableMap?, promise: Promise) {
+        val jsonFilter = try {
+            convertMapToJson(options?.getMap("filter"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            throw Exception("Encountered an error while parsing filter")
+        }
+
+        val jsonOrder = try {
+            convertMapToJson(options?.getMap("order"))
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            throw Exception("Encountered an error while parsing order")
+        }
+
+        dashXClient?.searchContent(
+            contentType,
+            options?.getString("returnType") ?: "all",
+            jsonFilter,
+            jsonOrder,
+            options?.getIntIfPresent("limit"),
+            options?.getBooleanIfPresent("preview"),
+            options?.getStringIfPresent("language"),
+            listOf(options?.getArray("fields")) as List<String>?,
+            listOf(options?.getArray("include")) as List<String>?,
+            listOf(options?.getArray("exclude")) as List<String>?,
+            onError = {
+                promise.reject("EUNSPECIFIED", it)
+            },
+            onSuccess = { content ->
+                val readableArray = Arguments.createArray()
+                content.forEach {
+                    readableArray.pushMap(convertJsonToMap(it))
+                }
+                promise.resolve(readableArray)
+            }
+        )
+    }
+
+    @ReactMethod
+    fun addItemToCart(
+        itemId: String,
+        pricingId: String,
+        quantity: String,
+        reset: Boolean? = false,
+        custom: ReadableMap? = null,
+        promise: Promise
+    ) {
+        val jsonCustom = try {
+            convertMapToJson(custom)
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            throw Exception("Encountered an error while parsing custom")
+        }
+
+        dashXClient?.addItemToCart(
+            itemId,
+            pricingId,
+            quantity,
+            reset ?: false,
+            jsonCustom,
+            onError = {
+                promise.reject("EUNSPECIFIED", it)
+            },
+            onSuccess = { content ->
+                promise.resolve(convertJsonToMap(content))
+            }
+        )
+    }
+
+    @ReactMethod
+    fun fetchCart(promise: Promise) {
+        dashXClient?.fetchCart(
+            onError = {
+                promise.reject("EUNSPECIFIED", it)
+            },
+            onSuccess = { content ->
+                promise.resolve(convertJsonToMap(content))
+            }
+        )
+    }
+
+    @ReactMethod
+    fun fetchStoredPreferences(promise: Promise) {
+        dashXClient?.fetchStoredPreferences(
+            onError = {
+                promise.reject("EUNSPECIFIED", it)
+            },
+            onSuccess = { content ->
+                promise.resolve(convertJsonToMap(content))
+            }
+        )
+    }
+
+    @ReactMethod
+    fun uploadExternalAsset(
+        file: ReadableMap, 
+        externalColumnId: String, 
+        promise: Promise
+    ) {
+        val jsonFile = try {
+            convertMapToJson(file)
+        } catch (e: Exception) {
+            DashXLog.d(tag, e.message)
+            throw Exception("Encountered an error while parsing file")
+        }
+
+        // Remove unnecessary double quotes from RN URI
+        val filePath = getFilePathFromURIString(jsonFile?.get("uri").toString())
+        val fileObject = File(filePath)
+
+        dashXClient?.uploadExternalAsset(
+            fileObject,
+            externalColumnId,
+            onError = {
+                promise.reject("EUNSPECIFIED", it)
+            },
+            onSuccess = { content ->
+                val jsonObject = Gson().toJsonTree(content, ExternalAsset::class.java).asJsonObject
+                promise.resolve(convertJsonToMap(jsonObject))
+            }
+        )
+    }
+
+    @ReactMethod
+    fun externalAsset(
+            id: String,
+            promise: Promise
+    ) {
+        dashXClient?.externalAsset(
+            id,
+            onError = {
+                promise.reject("EUNSPECIFIED", it)
+            },
+            onSuccess = { content ->
+                val jsonObject = Gson().toJsonTree(content, ExternalAsset::class.java).asJsonObject
+                promise.resolve(convertJsonToMap(jsonObject))
+            }
+        )
+    }
+
+    @ReactMethod
+    fun subscribe() {
+        dashXClient?.subscribe()
+    }
+
+    //FIXME Amend the logic to work with React Native content URIs
+    fun getFilePathFromURIString(contentUriString: String): String {
+        val sanitizedURI = contentUriString.replace("\"", "")
+        val path = Uri.parse(sanitizedURI).path
+
+        // Remove unnecessary URI component
+        val filePath = path!!.substring(path?.indexOf(':') + 1)
+
+        return filePath
+    }
+}

package/android/src/main/java/com/dashx/rn/sdk/{DashXPackage.kt → DashXReactNativePackage.kt}

@@ -1,6 +1,7 @@
 package com.dashx.rn.sdk
 
 import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.JavaScriptModule
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
@@ -8,7 +9,7 @@ import java.util.Arrays
 
 class DashXPackage : ReactPackage {
     override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-        return Arrays.asList<NativeModule>(DashXModule(reactContext))
+        return Arrays.asList<NativeModule>(DashXReactNativeModule(reactContext))
     }
 
     override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {

package/android/src/main/java/com/dashx/rn/sdk/util/ArrayUtil.java

@@ -0,0 +1,163 @@
+
+/*
+  ArrayUtil exposes a set of helper methods for working with
+  ReadableArray (by React Native), Object[], and JSONArray.
+
+  MIT License
+
+  Copyright (c) 2020 Marc Mendiola
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+ */
+
+package com.dashx.rn.sdk.util;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.bridge.WritableArray;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.json.JSONException;
+
+public class ArrayUtil {
+
+  public static JSONArray toJSONArray(ReadableArray readableArray) throws JSONException {
+    JSONArray jsonArray = new JSONArray();
+
+    for (int i = 0; i < readableArray.size(); i++) {
+      ReadableType type = readableArray.getType(i);
+
+      switch (type) {
+        case Null:
+          jsonArray.put(i, null);
+          break;
+        case Boolean:
+          jsonArray.put(i, readableArray.getBoolean(i));
+          break;
+        case Number:
+          jsonArray.put(i, readableArray.getDouble(i));
+          break;
+        case String:
+          jsonArray.put(i, readableArray.getString(i));
+          break;
+        case Map:
+          jsonArray.put(i, MapUtil.toJSONObject(readableArray.getMap(i)));
+          break;
+        case Array:
+          jsonArray.put(i, ArrayUtil.toJSONArray(readableArray.getArray(i)));
+          break;
+      }
+    }
+
+    return jsonArray;
+  }
+
+  public static Object[] toArray(JSONArray jsonArray) throws JSONException {
+    Object[] array = new Object[jsonArray.length()];
+
+    for (int i = 0; i < jsonArray.length(); i++) {
+      Object value = jsonArray.get(i);
+
+      if (value instanceof JSONObject) {
+        value = MapUtil.toMap((JSONObject) value);
+      }
+      if (value instanceof JSONArray) {
+        value = ArrayUtil.toArray((JSONArray) value);
+      }
+
+      array[i] = value;
+    }
+
+    return array;
+  }
+
+  public static Object[] toArray(ReadableArray readableArray) {
+    Object[] array = new Object[readableArray.size()];
+
+    for (int i = 0; i < readableArray.size(); i++) {
+      ReadableType type = readableArray.getType(i);
+
+      switch (type) {
+        case Null:
+          array[i] = null;
+          break;
+        case Boolean:
+          array[i] = readableArray.getBoolean(i);
+          break;
+        case Number:
+          array[i] = readableArray.getDouble(i);
+          break;
+        case String:
+          array[i] = readableArray.getString(i);
+          break;
+        case Map:
+          array[i] = MapUtil.toMap(readableArray.getMap(i));
+          break;
+        case Array:
+          array[i] = ArrayUtil.toArray(readableArray.getArray(i));
+          break;
+      }
+    }
+
+    return array;
+  }
+
+  public static List<Object> toList(ReadableArray readableArray) {
+    return Arrays.asList(toArray(readableArray));
+  }
+
+  public static WritableArray toWritableArray(Object[] array) {
+    WritableArray writableArray = Arguments.createArray();
+
+    for (int i = 0; i < array.length; i++) {
+      Object value = array[i];
+
+      if (value == null) {
+        writableArray.pushNull();
+      }
+      if (value instanceof Boolean) {
+        writableArray.pushBoolean((Boolean) value);
+      }
+      if (value instanceof Double) {
+        writableArray.pushDouble((Double) value);
+      }
+      if (value instanceof Integer) {
+        writableArray.pushInt((Integer) value);
+      }
+      if (value instanceof String) {
+        writableArray.pushString((String) value);
+      }
+      if (value instanceof Map) {
+        writableArray.pushMap(MapUtil.toWritableMap((Map<String, Object>) value));
+      }
+      if (value.getClass().isArray()) {
+        writableArray.pushArray(ArrayUtil.toWritableArray((Object[]) value));
+      }
+    }
+
+    return writableArray;
+  }
+}

package/android/src/main/java/com/dashx/rn/sdk/util/MapUtil.java

@@ -0,0 +1,168 @@
+/*
+  MapUtil exposes a set of helper methods for working with
+  ReadableMap (by React Native), Map<String, Object>, and JSONObject.
+
+  MIT License
+
+  Copyright (c) 2020 Marc Mendiola
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+ */
+
+package com.dashx.rn.sdk.util;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.bridge.WritableMap;
+
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.json.JSONException;
+
+public class MapUtil {
+
+  public static JSONObject toJSONObject(ReadableMap readableMap) throws JSONException {
+    JSONObject jsonObject = new JSONObject();
+
+    ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
+
+    while (iterator.hasNextKey()) {
+      String key = iterator.nextKey();
+      ReadableType type = readableMap.getType(key);
+
+      switch (type) {
+        case Null:
+          jsonObject.put(key, null);
+          break;
+        case Boolean:
+          jsonObject.put(key, readableMap.getBoolean(key));
+          break;
+        case Number:
+          jsonObject.put(key, readableMap.getDouble(key));
+          break;
+        case String:
+          jsonObject.put(key, readableMap.getString(key));
+          break;
+        case Map:
+          jsonObject.put(key, MapUtil.toJSONObject(readableMap.getMap(key)));
+          break;
+        case Array:
+          jsonObject.put(key, ArrayUtil.toJSONArray(readableMap.getArray(key)));
+          break;
+      }
+    }
+
+    return jsonObject;
+  }
+
+  public static Map<String, Object> toMap(JSONObject jsonObject) throws JSONException {
+    Map<String, Object> map = new HashMap<>();
+    Iterator<String> iterator = jsonObject.keys();
+
+    while (iterator.hasNext()) {
+      String key = iterator.next();
+      Object value = jsonObject.get(key);
+
+      if (value instanceof JSONObject) {
+        value = MapUtil.toMap((JSONObject) value);
+      }
+      if (value instanceof JSONArray) {
+        value = ArrayUtil.toArray((JSONArray) value);
+      }
+
+      map.put(key, value);
+    }
+
+    return map;
+  }
+
+  public static Map<String, Object> toMap(ReadableMap readableMap) {
+    Map<String, Object> map = new HashMap<>();
+
+    if(readableMap == null) {
+      return map;
+    }
+
+    ReadableMapKeySetIterator iterator = readableMap.keySetIterator();
+
+    while (iterator.hasNextKey()) {
+      String key = iterator.nextKey();
+      ReadableType type = readableMap.getType(key);
+
+      switch (type) {
+        case Null:
+          map.put(key, null);
+          break;
+        case Boolean:
+          map.put(key, readableMap.getBoolean(key));
+          break;
+        case Number:
+          map.put(key, readableMap.getDouble(key));
+          break;
+        case String:
+          map.put(key, readableMap.getString(key));
+          break;
+        case Map:
+          map.put(key, MapUtil.toMap(readableMap.getMap(key)));
+          break;
+        case Array:
+          map.put(key, ArrayUtil.toArray(readableMap.getArray(key)));
+          break;
+      }
+    }
+
+    return map;
+  }
+
+  public static WritableMap toWritableMap(Map<String, Object> map) {
+    WritableMap writableMap = Arguments.createMap();
+    Iterator iterator = map.entrySet().iterator();
+
+    while (iterator.hasNext()) {
+      Map.Entry pair = (Map.Entry)iterator.next();
+      Object value = pair.getValue();
+
+      if (value == null) {
+        writableMap.putNull((String) pair.getKey());
+      } else if (value instanceof Boolean) {
+        writableMap.putBoolean((String) pair.getKey(), (Boolean) value);
+      } else if (value instanceof Double) {
+        writableMap.putDouble((String) pair.getKey(), (Double) value);
+      } else if (value instanceof Integer) {
+        writableMap.putInt((String) pair.getKey(), (Integer) value);
+      } else if (value instanceof String) {
+        writableMap.putString((String) pair.getKey(), (String) value);
+      } else if (value instanceof Map) {
+        writableMap.putMap((String) pair.getKey(), MapUtil.toWritableMap((Map<String, Object>) value));
+      } else if (value.getClass() != null && value.getClass().isArray()) {
+        writableMap.putArray((String) pair.getKey(), ArrayUtil.toWritableArray((Object[]) value));
+      }
+
+      iterator.remove();
+    }
+
+    return writableMap;
+  }
+}

package/android/src/main/java/com/dashx/rn/sdk/{Utils.kt → util/Utils.kt}

@@ -1,6 +1,6 @@
 @file:JvmName("Utils")
 
-package com.dashx.rn.sdk
+package com.dashx.rn.sdk.util
 
 import com.facebook.react.bridge.*
 import com.google.gson.JsonArray
@@ -45,8 +45,8 @@ fun convertArrayToJson(readableArray: ReadableArray?): JsonArray {
 @JvmOverloads
 @Throws(Exception::class)
 fun convertToWritableMap(
-    map: Map<*, *>,
-    blacklist: List<String> = emptyList<String>()
+        map: Map<*, *>,
+        blacklist: List<String> = emptyList<String>()
 ): WritableMap {
     val writableMap: WritableMap = WritableNativeMap()
     val iterator: Iterator<String> = map.keys.iterator() as Iterator<String>
@@ -54,7 +54,7 @@ fun convertToWritableMap(
         val key = iterator.next()
 
         if (blacklist.contains(key)) {
-            continue;
+            continue
         }
 
         when (val value = map[key]) {
@@ -128,4 +128,4 @@ fun ReadableMap.getStringIfPresent(key: String): String? {
 
 fun ReadableMap.getBooleanIfPresent(key: String): Boolean? {
     return if (this.hasKey(key)) this.getBoolean(key) else null
-}
+}