@woosmap/react-native-plugin-geofencing 0.1.4 → 0.1.7

package/android/src/main/java/com/reactnativeplugingeofencing/WoosmapTask.java

@@ -0,0 +1,299 @@
+package com.reactnativeplugingeofencing;
+
+import android.content.Context;
+import android.os.Build;
+
+
+import androidx.annotation.RequiresApi;
+
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableNativeArray;
+import com.google.android.gms.maps.model.LatLng;
+import com.webgeoservices.woosmapgeofencing.Woosmap;
+import com.webgeoservices.woosmapgeofencing.database.MovingPosition;
+import com.webgeoservices.woosmapgeofencing.database.POI;
+import com.webgeoservices.woosmapgeofencing.database.Region;
+import com.webgeoservices.woosmapgeofencing.database.WoosmapDb;
+
+import org.json.JSONObject;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.function.Supplier;
+
+public class WoosmapTask {
+  private static WoosmapTask _instance = null;
+  private final Context context;
+
+  public static WoosmapTask getInstance(Context context) {
+    if (_instance == null) {
+      _instance = new WoosmapTask(context);
+    }
+    return _instance;
+  }
+
+  private WoosmapTask(Context context) {
+    this.context = context;
+  }
+
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  public void addRegion(final Region region, final Promise promise) {
+    CompletableFuture.supplyAsync(() -> {
+      try {
+        if ((!region.type.isEmpty()) && (!region.type.equalsIgnoreCase(WoosmapMessageAndKey.isochroneTypeKey) && !region.type.equalsIgnoreCase(WoosmapMessageAndKey.circleTypeKey))) {
+          throw new Exception(WoosmapMessageAndKey.validRegionTypeMessage);
+        }
+        if (region.idStore.isEmpty() && region.type.isEmpty()) {
+          Woosmap.getInstance().addGeofence(region.identifier, new LatLng(region.lat, region.lng), (float) region.radius);
+        } else if (!region.idStore.isEmpty() && region.type.isEmpty()) {
+          Woosmap.getInstance().addGeofence(region.identifier, new LatLng(region.lat, region.lng), (float) region.radius, region.idStore);
+        } else if (!region.type.isEmpty() && region.idStore.isEmpty()) {
+          Woosmap.getInstance().addGeofence(region.identifier, new LatLng(region.lat, region.lng), (float) region.radius, region.type);
+        } else {
+          Woosmap.getInstance().addGeofence(region.identifier, new LatLng(region.lat, region.lng), (float) region.radius, region.idStore, region.type);
+        }
+
+      } catch (Exception ex) {
+        throw new CompletionException(ex);
+      }
+      return region.identifier;
+    }).whenComplete((data, throwable) -> {
+      if (throwable != null) {
+        promise.reject(WoosmapMessageAndKey.errorCode, throwable.getMessage());
+      } else {
+        promise.resolve(data);
+      }
+    });
+  }
+
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  public void enqueGetRegionsRequest(String regionID,Promise promise) {
+    CompletableFuture.supplyAsync(() -> {
+      try {
+        Region region;
+        region = WoosmapDb.getInstance(context).getRegionsDAO().getRegionFromId(regionID);
+        if(region!=null){
+          return WoosmapUtil.getRegionWritableMap(region);
+        }
+      } catch (Exception ex) {
+        throw new CompletionException(ex);
+      }
+      return null;
+    }).whenComplete((data, throwable) -> {
+      if (throwable == null) {
+        if(data==null){
+          promise.reject(WoosmapMessageAndKey.errorCode,WoosmapMessageAndKey.invalidRegionid);
+        }else {
+          promise.resolve(data);
+        }
+      } else {
+        promise.reject(WoosmapMessageAndKey.errorCode,throwable.getMessage());
+      }
+    });
+  }
+
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  public void enqueGetRegionsRequest(Promise promise) {
+    CompletableFuture.supplyAsync(() -> {
+      try {
+        Region[] regions;
+        WritableArray array= Arguments.createArray();
+        regions = WoosmapDb.getInstance(context).getRegionsDAO().getAllRegions();
+        for (Region region : regions) {
+          array.pushMap(WoosmapUtil.getRegionWritableMap(region));
+        }
+        return array;
+      } catch (Exception ex) {
+        throw new CompletionException(ex);
+      }
+    }).whenComplete((data, throwable) -> {
+      if (throwable == null) {
+        promise.resolve(data);
+      } else {
+        promise.reject(WoosmapMessageAndKey.errorCode,throwable.getMessage());
+      }
+    });
+  }
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  public void removeRegion(String regionId, final Promise promise){
+    CompletableFuture.supplyAsync((Supplier<Void>) () -> {
+      try{
+        if (!regionId.isEmpty()){
+          Woosmap.getInstance().removeGeofence(regionId);
+          WoosmapDb.getInstance(context).getRegionsDAO().deleteRegionFromId(regionId);
+        }
+        else{
+          Woosmap.getInstance().removeGeofence();
+          WoosmapDb.getInstance(context).getRegionsDAO().deleteAllRegions();
+        }
+      }
+      catch (Exception ex){
+        throw new CompletionException(ex);
+      }
+      return null;
+    }).whenComplete((unused, throwable) -> {
+      if (throwable==null){
+       promise.resolve(WoosmapMessageAndKey.deleteMessage);
+      }
+      else{
+        promise.reject(WoosmapMessageAndKey.errorCode,throwable.getMessage());
+      }
+    });
+  }
+
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  public void removeAllPois(final Promise promise){
+    CompletableFuture.supplyAsync((Supplier<Void>) () -> {
+      try{
+          WoosmapDb.getInstance(context).getPOIsDAO().deleteAllPOIs();
+      }
+      catch (Exception ex){
+        throw new CompletionException(ex);
+      }
+      return null;
+    }).whenComplete((unused, throwable) -> {
+      if (throwable==null){
+        promise.resolve(WoosmapMessageAndKey.deleteMessage);
+      }
+      else{
+        promise.reject(WoosmapMessageAndKey.errorCode,throwable.getMessage());
+      }
+    });
+  }
+
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  public void enqueGetAllPoiRequest(Promise promise) {
+    CompletableFuture.supplyAsync(() -> {
+      try {
+        POI[] pois;
+        WritableArray array= Arguments.createArray();
+        pois = WoosmapDb.getInstance(context).getPOIsDAO().getAllPOIs();
+        for (POI poi : pois) {
+          array.pushMap(WoosmapUtil.getPOIWritableMap(poi));
+        }
+        return array;
+      } catch (Exception ex) {
+        throw new CompletionException(ex);
+      }
+    }).whenComplete((data, throwable) -> {
+      if (throwable == null) {
+        promise.resolve(data);
+      } else {
+        promise.reject(WoosmapMessageAndKey.errorCode,throwable.getMessage());
+      }
+    });
+  }
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  public void enqueGetPOIRequest(String locationID,Promise promise) {
+    CompletableFuture.supplyAsync(() -> {
+      try {
+        POI poi;
+        poi = WoosmapDb.getInstance(context).getPOIsDAO().getPOIbyStoreId(locationID);
+        if(poi!=null){
+          return WoosmapUtil.getPOIWritableMap(poi);
+        }else {
+          if(WoosmapUtil.onlyContainsNumbers(locationID)){
+            poi = WoosmapDb.getInstance(context).getPOIsDAO().getPOIbyLocationID(Integer.parseInt(locationID));
+            if(poi!=null){
+              return WoosmapUtil.getPOIWritableMap(poi);
+            }
+          }
+        }
+      } catch (Exception ex) {
+        throw new CompletionException(ex);
+      }
+      return null;
+    }).whenComplete((data, throwable) -> {
+      if (throwable == null) {
+        if(data==null){
+          promise.reject(WoosmapMessageAndKey.errorCode,WoosmapMessageAndKey.invalidLocationid);
+        }else {
+          promise.resolve(data);
+        }
+      } else {
+        promise.reject(WoosmapMessageAndKey.errorCode,throwable.getMessage());
+      }
+    });
+  }
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  protected void enqueueGetLocationRequest(String locationID,Promise promise) {
+    CompletableFuture.supplyAsync(() -> {
+      try {
+        MovingPosition requiredLocation=null;
+        MovingPosition[]movingPosition;
+        movingPosition = WoosmapDb.getInstance(context).getMovingPositionsDao().getMovingPositions(-1);
+        for (MovingPosition location : movingPosition) {
+          if(location.id==Integer.parseInt(locationID)){
+            requiredLocation=location;
+            break;
+          }
+        }
+        if(requiredLocation!=null){
+          return WoosmapUtil.getMovingPositionObject(requiredLocation);
+        }
+
+      } catch (Exception ex) {
+        throw new CompletionException(ex);
+      }
+      return null;
+    }).whenComplete((data, throwable) -> {
+      if (throwable == null) {
+        if(data==null){
+          promise.reject(WoosmapMessageAndKey.errorCode,WoosmapMessageAndKey.invalidLocationID);
+        }else {
+          promise.resolve(data);
+        }
+      } else {
+        promise.reject(WoosmapMessageAndKey.errorCode,throwable.getMessage());
+      }
+    });
+  }
+
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  protected void enqueueGetLocationRequest(Promise promise) {
+    CompletableFuture.supplyAsync(() -> {
+      try {
+        MovingPosition[]movingPosition;
+        WritableArray array= Arguments.createArray();
+        movingPosition = WoosmapDb.getInstance(context).getMovingPositionsDao().getMovingPositions(-1);
+        for (MovingPosition location : movingPosition) {
+          array.pushMap(WoosmapUtil.getMovingPositionObject(location));
+        }
+        return array;
+      } catch (Exception ex) {
+        throw new CompletionException(ex);
+      }
+    }).whenComplete((data, throwable) -> {
+      if (throwable == null) {
+        promise.resolve(data);
+      } else {
+        promise.reject(WoosmapMessageAndKey.errorCode,throwable.getMessage());
+      }
+    });
+  }
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  protected void removeAllLocation(final Promise promise){
+    CompletableFuture.supplyAsync((Supplier<Void>) () -> {
+      try{
+        WoosmapDb.getInstance(context).getMovingPositionsDao().deleteAllMovingPositions();
+      }
+      catch (Exception ex){
+        throw new CompletionException(ex);
+      }
+      return null;
+    }).whenComplete((unused, throwable) -> {
+      if (throwable==null){
+        promise.resolve(WoosmapMessageAndKey.deleteMessage);
+      }
+      else{
+        promise.reject(WoosmapMessageAndKey.errorCode,throwable.getMessage());
+      }
+    });
+  }
+
+
+
+}

package/android/src/main/java/com/reactnativeplugingeofencing/WoosmapUtil.java

@@ -3,10 +3,14 @@ package com.reactnativeplugingeofencing;
 import android.location.Location;
 import android.util.Log;
 
+import androidx.annotation.Nullable;
+
 import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeArray;
 import com.facebook.react.bridge.WritableNativeMap;
+import com.webgeoservices.woosmapgeofencing.database.MovingPosition;
+import com.webgeoservices.woosmapgeofencing.database.POI;
 import com.webgeoservices.woosmapgeofencing.database.Region;
 import com.webgeoservices.woosmapgeofencing.database.RegionLog;
 
@@ -71,4 +75,108 @@ public class WoosmapUtil {
     return null;
   }
 
+  @Nullable
+  protected static WritableMap getPOIWritableMap(POI poi){
+    WritableMap map=new WritableNativeMap();
+    try{
+      map.putDouble("date", poi.dateTime);
+      map.putDouble("distance", poi.distance);
+      map.putString("locationid", String.valueOf(poi.locationId));
+      map.putDouble("latitude", poi.lat);
+      map.putDouble("longitude", poi.lng);
+      map.putString("city", poi.city);
+      map.putString("idstore", poi.idStore);
+      map.putString("name", poi.name);
+      map.putString("duration", poi.duration);
+      map.putString("zipcode", poi.zipCode);
+      //map.putString("jsondata", poi.data);
+      try {
+        JSONObject obj = new JSONObject(poi.data);
+        map.putMap("jsondata", convertJsonToMap(obj));
+      } catch (Throwable t) {
+        Log.e("Geofence Plugin", "Could not parse malformed JSON: \"" + poi.data + "\"");
+      }
+
+      return map;
+    }
+    catch (Exception ex){
+      Log.e(TAG,ex.toString());
+    }
+    return null;
+  }
+
+  public static WritableArray convertJsonToArray(JSONArray jsonArray) throws JSONException {
+    WritableArray array = new WritableNativeArray();
+
+    for (int i = 0; i < jsonArray.length(); i++) {
+      Object value = jsonArray.get(i);
+      if (value instanceof JSONObject) {
+        array.pushMap(convertJsonToMap((JSONObject) value));
+      } else if (value instanceof JSONArray) {
+        array.pushArray(convertJsonToArray((JSONArray) value));
+      } else if (value instanceof Boolean) {
+        array.pushBoolean((Boolean) value);
+      } else if (value instanceof Integer) {
+        array.pushInt((Integer) value);
+      } else if (value instanceof Double) {
+        array.pushDouble((Double) value);
+      } else if (value instanceof String) {
+        array.pushString((String) value);
+      } else {
+        array.pushString(String.valueOf(value));
+      }
+    }
+    return array;
+  }
+
+  private static WritableMap convertJsonToMap(JSONObject jsonObject) throws JSONException {
+    WritableMap map = new WritableNativeMap();
+
+    Iterator<String> iterator = jsonObject.keys();
+    while (iterator.hasNext()) {
+      String key = iterator.next();
+      Object value = jsonObject.get(key);
+      if (value instanceof JSONObject) {
+        map.putMap(key, convertJsonToMap((JSONObject) value));
+      } else if (value instanceof  JSONArray) {
+        map.putArray(key, convertJsonToArray((JSONArray) value));
+      } else if (value instanceof  Boolean) {
+        map.putBoolean(key, (Boolean) value);
+      } else if (value instanceof  Integer) {
+        map.putInt(key, (Integer) value);
+      } else if (value instanceof  Double) {
+        map.putDouble(key, (Double) value);
+      } else if (value instanceof String)  {
+        map.putString(key, (String) value);
+      } else {
+        map.putString(key, String.valueOf(value));
+      }
+    }
+    return map;
+  }
+  protected static WritableMap getMovingPositionObject(MovingPosition location){
+    try{
+      WritableMap map=new WritableNativeMap();
+      map.putDouble("latitude", location.lat);
+      map.putDouble("longitude", location.lng);
+      map.putString("locationid", String.valueOf(location.id));
+      map.putString("locationdescription", "description");
+      map.putDouble("date", location.dateTime);
+      return map;
+    }
+    catch (Exception ex){
+      Log.e(TAG,ex.toString());
+    }
+    return null;
+  }
+  protected static boolean onlyContainsNumbers(String text) {
+    try {
+      Long.parseLong(text);
+      return true;
+    } catch (NumberFormatException ex) {
+      return false;
+    }
+  }
+
+
 }

package/ios/DataDistance.swift

@@ -7,29 +7,22 @@
 import Foundation
 import CoreLocation
 import WoosmapGeofencing
+import SwiftUI
 
 public class DataDistance: DistanceAPIDelegate {
-    public func distanceAPIResponse(distance: [Distance]) {
-        
-    }
     
     public init() {}
 
-    public func distanceAPIResponseData(distanceAPIData: DistanceAPIData, locationId: String) {
-        if distanceAPIData.status == "OK" {
-            if distanceAPIData.rows?.first?.elements?.first?.status == "OK" {
-                let distance = distanceAPIData.rows?.first?.elements?.first?.distance
-                let duration = distanceAPIData.rows?.first?.elements?.first?.duration
-                if distance != nil && duration != nil {
-                    // TODO: Implementation missing
-                    //let result: DistanceResponseResult = DistanceResponseResult.init(locationId: locationId, distance: distance!, duration: duration!)
-                    //NotificationCenter.default.post(name: .distanceCalculated, object: self, userInfo: ["Distance": result])
-                }
-            }
-        } else {
-            let result: DistanceResponseError = DistanceResponseError.init(locationId: locationId, error: distanceAPIData.status ?? "-")
-            NotificationCenter.default.post(name: .distanceCalculated, object: self, userInfo: ["Distance": result])
-        }
+    public func distanceAPIResponse(distance: [Distance]) {
+
+        distance.forEach({ distanceElement in
+            let distance = distanceElement.distance
+            let duration = distanceElement.duration
+                let result: DistanceResponseResult = DistanceResponseResult.init(distance: distance, duration: duration)
+                    NotificationCenter.default.post(name: .distanceCalculated, object: self, userInfo: ["Distance": result])
+                    // print(distance?.value ?? 0)
+                    // print(duration?.text ?? 0)
+        })
     }
 
     public func distanceAPIError(error: String) {
@@ -42,11 +35,9 @@ extension Notification.Name {
 }
 
 class DistanceResponseResult {
-    var locationId: String = ""
-    var distance: Distance
-    var duration: Distance
-    required init(locationId: String, distance: Distance, duration: Distance) {
-        self.locationId = locationId
+    var distance: Int
+    var duration: Int
+    required init(distance: Int, duration: Int) {
         self.distance = distance
         self.duration = duration
     }

package/ios/DataLocation.swift

@@ -15,6 +15,18 @@ public class DataLocation: LocationServiceDelegate {
 
     public func tracingLocation(location: Location) {
         NotificationCenter.default.post(name: .newLocationSaved, object: self, userInfo: ["Location": location])
+
+//        let content = UNMutableNotificationContent()
+//        content.title = "Location update"
+//        content.body = "Location = " + "Lat = " + String(format: "%f", location.latitude) + " Lng = " + String(format: "%f", location.longitude)
+//        // Create the request
+//        let uuidString = UUID().uuidString
+//        let request = UNNotificationRequest(identifier: uuidString,
+//                    content: content, trigger: nil)
+//
+//        // Schedule the request with the system.
+//        let notificationCenter = UNUserNotificationCenter.current()
+//        notificationCenter.add(request)
     }
 
     public func tracingLocationDidFailWithError(error: Error) {
@@ -24,6 +36,10 @@ public class DataLocation: LocationServiceDelegate {
     public func readLocations() -> [Location] {
         return Locations.getAll()
     }
+    
+    public func readLocations(id:String) -> Location? {
+        return Locations.getLocationByLocationID(locationId: id)
+    }
 
     public func eraseLocations() {
         Locations.deleteAll()

package/ios/DataPOI.swift

@@ -22,6 +22,17 @@ public class DataPOI: SearchAPIDelegate {
     public func readPOI() -> [POI] {
         return POIs.getAll()
     }
+    
+    public func readPOI(id: String) ->POI? {
+        if let poiinfo = POIs.getPOIbyIdStore(idstore: id){
+            return poiinfo
+        }
+        return POIs.getPOIbyLocationID(locationId: id);
+    }
+    
+    public func readPOIByStore(id: String) ->POI? {
+        return POIs.getPOIbyIdStore(idstore: id);
+    }
 
     func getPOIbyLocationID(locationId: String) -> POI? {
         return POIs.getPOIbyLocationID(locationId: locationId)

package/ios/DataRegion.swift

@@ -20,12 +20,10 @@ public class DataRegion: RegionsServiceDelegate {
 
     public func didEnterPOIRegion(POIregion: Region) {
         NotificationCenter.default.post(name: .didEventPOIRegion, object: self, userInfo: ["Region": POIregion])
-        sendNotification(POIregion: POIregion, didEnter: true)
     }
 
     public func didExitPOIRegion(POIregion: Region) {
         NotificationCenter.default.post(name: .didEventPOIRegion, object: self, userInfo: ["Region": POIregion])
-        sendNotification(POIregion: POIregion, didEnter: false)
     }
 
     public func workZOIEnter(classifiedRegion: Region) {
@@ -35,40 +33,45 @@ public class DataRegion: RegionsServiceDelegate {
     public func homeZOIEnter(classifiedRegion: Region) {
         NotificationCenter.default.post(name: .didEventPOIRegion, object: self, userInfo: ["Region": classifiedRegion])
     }
-
+    
+    /// Read POI Regions
+    /// - Returns: Region info
     public func readRegions() -> [Region] {
         return Regions.getAll()
     }
-
+    
+    /// Read POI Regions
+    /// - Parameter id: Identifier
+    /// - Returns: Region info
+    public func readRegions(id:String) -> Region? {
+        return Regions.getRegionFromId(id: id)
+    }
+    
+    /// Read Isochrone Regions
+    /// - Returns: Region info
+    public func readIsochroneRegions() -> [RegionIsochrone] {
+        return RegionIsochrones.getAll()
+    }
+    
+    /// Read Isochrone Regions
+    /// - Parameter id: Identifier
+    /// - Returns: Region info
+    public func readIsochroneRegions(id:String) -> RegionIsochrone? {
+        return RegionIsochrones.getRegionFromId(id: id)
+    }
+    
+    /// Erase All Regions
     public func eraseRegions() {
         Regions.deleteAll()
+        RegionIsochrones.deleteAll()
     }
-
-    public func sendNotification(POIregion: Region, didEnter: Bool) {
-        let content = UNMutableNotificationContent()
-        if didEnter {
-            content.title = "Region enter"
-        } else {
-            content.title = "Region exit"
-        }
-        content.body = "Region = " + POIregion.identifier
-        content.body += "Lat = " + String(format: "%f", POIregion.latitude) + " Lng = " + String(format: "%f", POIregion.longitude)
-        content.body += "\n FromPositionDetection = " + String(POIregion.fromPositionDetection)
-        // Create the request
-        let uuidString = UUID().uuidString
-        let request = UNNotificationRequest(identifier: uuidString,
-                                            content: content, trigger: nil)
-
-        let center = UNUserNotificationCenter.current()
-        center.getNotificationSettings { settings in
-            if settings.authorizationStatus == .authorized {
-                // Schedule the request with the system.
-                let notificationCenter = UNUserNotificationCenter.current()
-                notificationCenter.add(request)
-            }
-        }
-
+    
+    /// Erase Regions by ID
+    /// - Parameter id: Identifier
+    public func eraseRegions(id:String) {
+        RegionIsochrones.removeRegionIsochrone(id: id)
     }
+        
 }
 
 extension Notification.Name {

package/ios/MarketingCloudEvents.swift

@@ -22,42 +22,42 @@ public class MarketingCloudEvents: MarketingCloudEventsDelegate {
 
     public func regionEnterEvent(regionEvent: [String: Any], eventName: String) {
         // here you can modify your event name and add your data in the dictonnary
-        print("MarketingCloudEvents regionEnterEvent")
+        //print("MarketingCloudEvents regionEnterEvent")
         let result: MarketingData = MarketingData.init(eventname: eventName, properties: regionEvent)
         NotificationCenter.default.post(name: .marketingEvent, object: self, userInfo: ["Marketing": result])
     }
 
     public func regionExitEvent(regionEvent: [String: Any], eventName: String) {
         // here you can modify your event name and add your data in the dictonnary
-        print("MarketingCloudEvents regionExitEvent")
+        //print("MarketingCloudEvents regionExitEvent")
         let result: MarketingData = MarketingData.init(eventname: eventName, properties: regionEvent)
         NotificationCenter.default.post(name: .marketingEvent, object: self, userInfo: ["Marketing": result])
     }
 
     public func visitEvent(visitEvent: [String: Any], eventName: String) {
         // here you can modify your event name and add your data in the dictonnary
-        print("MarketingCloudEvents visitEvent")
+        //print("MarketingCloudEvents visitEvent")
         let result: MarketingData = MarketingData.init(eventname: eventName, properties: visitEvent)
         NotificationCenter.default.post(name: .marketingEvent, object: self, userInfo: ["Marketing": result])
     }
 
     public func poiEvent(POIEvent: [String: Any], eventName: String) {
         // here you can modify your event name and add your data in the dictonnary
-        print("MarketingCloudEvents poiEvent")
+        //print("MarketingCloudEvents poiEvent")
         let result: MarketingData = MarketingData.init(eventname: eventName, properties: POIEvent)
         NotificationCenter.default.post(name: .marketingEvent, object: self, userInfo: ["Marketing": result])
     }
 
     public func ZOIclassifiedEnter(regionEvent: [String: Any], eventName: String) {
         // here you can modify your event name and add your data in the dictonnary
-        print("MarketingCloudEvents ZOIclassifiedEnter")
+        //print("MarketingCloudEvents ZOIclassifiedEnter")
         let result: MarketingData = MarketingData.init(eventname: eventName, properties: regionEvent)
         NotificationCenter.default.post(name: .marketingEvent, object: self, userInfo: ["Marketing": result])
     }
 
     public func ZOIclassifiedExit(regionEvent: [String: Any], eventName: String) {
         // here you can modify your event name and add your data in the dictonnary
-        print("MarketingCloudEvents ZOIclassifiedExit")
+        //print("MarketingCloudEvents ZOIclassifiedExit")
         let result: MarketingData = MarketingData.init(eventname: eventName, properties: regionEvent)
         NotificationCenter.default.post(name: .marketingEvent, object: self, userInfo: ["Marketing": result])
     }