smartmessage-react-native 2.11.2

package/src/SmartMessage.js

@@ -0,0 +1,385 @@
+import {NativeModules, PermissionsAndroid, Platform} from 'react-native';
+import { BaseResponseModel } from './SMDataModels';
+
+const {RNSmartMessage} = NativeModules;
+
+const ANDROID = 'android';
+const IOS = 'ios';
+
+export default class SmartMessage {
+
+  //android only
+  static async checkNotificationPermission() {
+  
+    if (Platform.OS === ANDROID) {
+      
+        try {
+          const granted = await PermissionsAndroid.check(
+            PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS,
+          );
+          return granted;
+        } catch (error) {
+          throw(error)
+        }
+      
+    }
+
+  }
+  
+  //android only
+  static async checkLocationPermission(){
+      try {
+        const coarseLocationPermission = await PermissionsAndroid.check(
+          PermissionsAndroid.PERMISSIONS.ACCESS_COARSE_LOCATION,
+        );
+        const fineLocationPermission = await PermissionsAndroid.check(
+          PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
+        );
+        
+        if(coarseLocationPermission || fineLocationPermission ){
+          console.log('Location permission is granted');
+          return true;
+        }
+       else {
+          console.log('Location permission is not granted');
+          return false;
+        }
+      } catch (error) {
+        throw(error);
+      }
+    
+  }
+
+  static async getNotificationContent(contentUrl) {
+    
+    try {
+      
+      if(contentUrl == null){
+        throw("contentUrl cannot be null");
+      }
+
+      let response = await RNSmartMessage.getNotificationContent(contentUrl);
+      return JSON.parse(response);
+
+    } catch (error) {
+      throw(error);  
+    }
+  }
+
+  
+  static async getToken() {
+   
+    try {
+      var token =  await RNSmartMessage.getToken();
+     
+      if(token != null)
+       return token;
+      else{
+        throw "token is not set yet";
+      }
+
+    } catch (error) {
+      throw(error);
+    }
+  
+  }
+
+  static async getUserInfo() {
+  
+    try {
+      let response = await RNSmartMessage.getUserInfo();
+      return JSON.parse(response);
+    } catch (error) {
+      throw(error);
+    }
+   
+  }
+
+  static setUserInfo(userInfo) {
+
+    try {
+      if (userInfo == null) {
+        throw("userInfo cannot be null");
+      }
+      RNSmartMessage.setUserInfo(JSON.stringify(userInfo));
+    } catch (error) {
+      throw(error);
+    }
+   
+  }
+
+  static async setUserInfoWithPromise(userInfo) {
+
+    try {
+
+      if (userInfo == null) {
+        throw("userInfo cannot be null");
+      }
+
+      let response = await RNSmartMessage.setUserInfoWithPromise(JSON.stringify(userInfo));
+      return new BaseResponseModel.fromJson(response);
+
+    } catch (error) {
+      throw(error);
+    }
+   
+  }
+
+  static displayDialog(message) {
+ 
+    try {
+    
+      if (message == null) {
+        throw('message cannot be null');
+      }
+
+      RNSmartMessage.displayDialog(JSON.stringify(message));
+    } catch (error) {
+      throw(error);
+    }
+   
+  }
+
+  static async displayDialogWithPromise(message) {
+    
+    try {
+    
+      if (message == null) {
+        throw('message cannot be null');
+      }
+
+      console.log(JSON.stringify(message));
+
+      if (Platform.OS === IOS) {
+        RNSmartMessage.displayDialog(JSON.stringify(message));
+        return; 
+      }
+
+      let response = await RNSmartMessage.displayDialogWithPromise(JSON.stringify(message));
+      return JSON.parse(response);
+    } catch (error) {
+      throw(error);
+    }
+   
+  }
+
+  static saveConfig(){
+    
+    try {
+      RNSmartMessage.saveConfig();
+    } catch (error) {
+      throw(error);
+    }
+
+  }
+
+  static async saveConfigWithPromise(){
+    
+    try {
+      let response = await RNSmartMessage.saveConfigWithPromise();
+      return response;
+    } catch (error) {
+      throw(error);
+    }
+
+  }
+
+  static matchContactDevice(matchContactDeviceRequestModel){
+
+    try {
+
+      if (matchContactDeviceRequestModel == null){
+        throw("matchContactDeviceRequestBody cannot be null");
+      }
+
+      RNSmartMessage.matchContactDevice(JSON.stringify(matchContactDeviceRequestModel));
+      return;
+    } catch (error) {
+      throw(error);
+    }
+
+  }
+
+  static async matchContactDeviceWithPromise(matchContactDeviceRequestModel){
+
+    try {
+   
+      if (matchContactDeviceRequestModel == null){
+        throw("matchContactDeviceRequestBody cannot be null");
+      }
+      
+      let response = await RNSmartMessage.matchContactDeviceWithPromise(
+        JSON.stringify(matchContactDeviceRequestModel)
+      );
+
+      return JSON.parse(response);
+    
+    } catch (error) {
+      throw(error);
+    }
+
+  }
+
+  static reportCustomEvent(eventIdentifier, uniqueId, parameters) {
+
+    try {
+
+      if(eventIdentifier == null || uniqueId == null || parameters == null){
+        throw("eventIdentifier, uniqueId or parameters cannot be null");
+      }
+
+      RNSmartMessage.reportCustomEvent(eventIdentifier, uniqueId, JSON.stringify(parameters));
+    } catch (error) {
+      throw(error);
+    }
+  }
+
+  static async reportCustomEventWithPromise(eventIdentifier, uniqueId, parameters) {
+
+    try {
+     
+      if(eventIdentifier == null || uniqueId == null || parameters == null){
+        throw("eventIdentifier, uniqueId or parameters cannot be null");
+      }
+
+      let response = await RNSmartMessage.reportCustomEventWithPromise(eventIdentifier, uniqueId, JSON.stringify(parameters));
+      return JSON.parse(response);
+    } catch (error) {
+      throw(error);
+    }
+  }
+  
+  static reportLoggedIn() {
+
+    try {
+      RNSmartMessage.reportLoggedIn();
+    } catch (error) {
+      throw(error);
+    }
+  }
+
+  static async reportLoggedInWithPromise() {
+
+    try {
+      let response = await RNSmartMessage.reportLoggedInWithPromise();
+      return JSON.parse(response);
+    } catch (error) {
+      throw(error);
+    }
+  }
+
+  static reportLoggedOut() {
+
+    try {
+      RNSmartMessage.reportLoggedOut();
+    } catch (error) {
+      throw(error);
+    }
+  }
+
+  static async reportLoggedOutWithPromise() {
+
+    try {
+
+      let response = await RNSmartMessage.reportLoggedOutWithPromise();
+      return JSON.parse(response);
+
+    } catch (error) {
+      throw(error);
+    }
+  }
+
+  static requestNotificationPermission() {
+   
+    try {
+      RNSmartMessage.requestNotificationPermission();
+    } catch (error) {
+      throw(error);
+    }
+
+  }
+
+  static async requestNotificationPermissionWithPromise() {
+   
+    try {
+      let response = await RNSmartMessage.requestNotificationPermissionWithPromise();
+      return JSON.parse(response);
+    } catch (error) {
+      throw(error);
+    }
+
+  }
+  
+  static permissionUpdate(permissionType, isGranted) {
+
+    try {
+
+      if(permissionType == null || isGranted == null){
+        throw("permissionType or isGranted cannot be null");
+      }
+
+      RNSmartMessage.permissionUpdate(permissionType, isGranted);
+    } catch (error) {
+      throw(error);
+    }
+  }
+
+  static async permissionUpdateWithPromise(permissionType, isGranted) {
+  
+    try {
+
+      if(permissionType == null || isGranted == null){
+        throw("permissionType or isGranted cannot be null");
+      }
+
+      let response = await RNSmartMessage.permissionUpdateWithPromise(permissionType, isGranted);
+      return JSON.parse(response);
+
+    } catch (error) {
+      throw(error);
+    }
+
+  }
+
+  static requestLocationPermission() {
+   
+    try {
+      RNSmartMessage.requestLocationPermission();
+    } catch (error) {
+      throw(error);
+    }
+
+  }
+
+  static async requestLocationPermissionWithPromise() {
+   
+    try {
+      let response = await RNSmartMessage.requestLocationPermissionWithPromise();
+      return JSON.parse(response);
+    } catch (error) {
+      throw(error);
+    }
+
+  }
+
+  static startLocationTracking() {
+
+    try {
+      return RNSmartMessage.startLocationTracking();
+    } catch (error) {
+      throw(error);
+    }
+  }
+
+  static stopLocationTracking() {
+
+    try {
+      return RNSmartMessage.stopLocationTracking();
+    } catch (error) {
+      throw(error);
+    }
+  }
+   
+}
+
+ 

package/src/index.d.ts

@@ -0,0 +1,238 @@
+declare class SmartMessage {
+
+  static async getToken(): Promise<string | null>;
+  static async getUserInfo(): Promise<UserInfoModel>;
+  static async getMessageList(messageListRequestBody: MessageListRequestBody): Promise<MessageListResponseModel[]>;
+  static async getNotificationContent(contentUrl: String): Promise<BaseNotificationModel>;
+  
+  static async setUserInfoWithPromise(userInfo: UserInfoModel): Promise<string>;
+  static setUserInfo(userInfo: UserInfoModel): void;
+
+  static displayDialog(message: BaseNotificationModel): void;
+  static displayDialogWithPromise(message: BaseNotificationModel): Promise<boolean>;
+  static async matchContactDevice(data: MatchContactDeviceRequestBody): void;
+  static async matchContactDeviceWithPromise(data: MatchContactDeviceRequestBody):Promise<BaseResponseModel>;
+  static  saveConfig() : void;
+  static async saveConfigWithPromise() :Promise <BaseResponseModel>;
+
+  static saveNotificationToDB(notificationModel: BaseNotificationModel,isSeen : boolean) : void;
+  static async getNotificationListFromDB():Promise<MessageListResponseModel[]>
+  static updateNotificationAsSeen(notificationId : string) : void;
+  static updateNotificationContent(notificationId : string, notificationModel : BaseNotificationModel) : void;
+
+  static reportCustomEvent(eventIdentifier : string, uniqueId : string, parameters : string) : void;
+  static reportCustomEventWithPromse(eventIdentifier : string, uniqueId : string, parameters : string) : Promise<BaseResponseModel>;
+
+  static reportLoggedIn(): void;
+  static async reportLoggedInWithPromise(): Promise<BaseResponseModel>; 
+  static reportLoggedOut(): void;
+  static async reportLoggedOutWithPromise(): Promise<BaseResponseModel>; 
+
+  static permissionUpdate(permissionType: PERMISSION_TYPE,isGranted: boolean): void;
+  static async permissionUpdateWithPromise( permissionType: PERMISSION_TYPE,isGranted: boolean): Promise<BaseResponseModel>;
+  static requestNotificationPermission(): void;
+  static async requestNotificationPermissionWithPromise(): Promise<boolean>;
+
+  static requestLocationPermission(): void;
+  static async requestLocationPermissionWithPromise(): Promise<boolean>;
+  static startLocationTracking(): void;
+  static stopLocationTracking(): void;
+  
+}
+
+declare class BaseResponseModel { 
+  httpStatus : number;
+  responseCode : number;
+  explanation : string;
+
+  constructor(httpStatusCode : number, responseCode : number, explanation : string ) : BaseResponseModel;
+    getExplanation() : String ;
+    getResponseCode() : number;
+    getHttpStatusCode() : number;
+
+  static fromJson(json: string) : BaseResponseModel;
+}
+
+declare class MatchContactDeviceRequestBody {
+  constructor(externalId : string, targetAddress : MatchContactDeviceTargetAddress[]) : MatchContactDeviceRequestBody;
+
+}
+
+declare class MatchContactDeviceTargetAddress {
+  constructor(key : string, value : string) : MatchContactDeviceTargetAddress
+
+}
+
+declare class MessageListRequestModel {
+
+  constructor (index : number, size : number, startDate : Date, endDate : Date, status : string[], pushType: string[], expiredPush: boolean) : MessageListRequestModel;
+}
+
+declare class MessageListResponseModel {
+
+  data: MessageEntity[];
+  count: number;
+  constructor(data: MessageEntity[], count: number) : MessageListResponseModel;
+  
+  getData() : MessageEntity[]
+  
+  getCount() : number;
+  
+  static fromJson(json: string) { 
+      var obj = JSON.parse(json); 
+      return new MessageListResponseModel(obj.data, obj.count);
+  } 
+  
+}
+
+declare class MessageEntity {
+  
+  id: String;
+  type: PushType;
+  tags: String;
+  seen: Boolean;
+  sentDate: String;
+  thumbnail: String;
+  title: String;
+  messageText: String;
+  contentUrl: String;
+  isDataDownloaded: Boolean;
+  notificationJson: String;
+ 
+  constructor(id: String,  type: PushType,  tags: String,  seen: Boolean,  sentDate: String,  thumbnail: String,  title: String,  messageText: String,  contentUrl: String,  isDataDownloaded: Boolean,  notificationJson: String) : MessageEntity;
+
+ static fromJson(json: string) : MessageEntity
+}
+
+
+declare class UserInfoModel {
+
+  constructor(id : String, name : String, surname : String, email : String, mobile : String, birthdate : Date, gender : String, username : String, rcvNot: any, tags: any, lang: any) : UserInfoModel;
+  static fromJson(json: string) : UserInfoModel;
+}
+
+export {SmartMessage, BaseResponseModel, UserInfoModel, MessageListRequestModel, MessageListResponseModel , MessageEntity} ;
+
+
+export interface Button {
+  label: string;
+  link: string;
+  color: string;
+  textColor: string;
+}
+
+export interface Slide {
+  title: string;
+  message: string;
+  imageUrl: string;
+  buttons: Button[];
+}
+
+export const PUSH_TYPE = {
+  BASIC: '0',
+  IMAGE: '1',
+  HTML_PUSH: '2',
+  GIF: '3',
+  VIDEO: '4',
+  AUDIO: '5',
+  BASIC_CAROUSEL: '6',
+  ROTARY_CAROUSEL: '7',
+  COVERFLOW_CAROUSEL: '8',
+  SLIDER: '9',
+  SMALL_DIALOG: '10',
+  MEDIUM_DIALOG: '11',
+  FULLSCREEN_DIALOG: '12',
+  INTERACTIVE_DIALOG: '13',
+  HTML_DIALOG: '14'
+}
+
+export const PERMISSION_TYPE = {
+  NOTIFICATION: 'notification',
+  LOCATION: 'location',
+  BACKGROUND_LOCATION: 'backgroundLocation',
+  APPROXIMATE_LOCATION: 'approx',
+  PRECISE_LOCATION: 'precise',
+  BLUETOOTH: 'bluetooth',
+}
+
+export type PushType = typeof PUSH_TYPE;
+
+export type PermissionType = typeof PERMISSION_TYPE;
+
+export interface BaseNotificationModel {
+  type: PushType;
+  id: string;
+  thumb: string;
+  sound: string;
+  title: string;
+  message: string;
+  link: string;
+  buttons: Button[];
+}
+
+export type BaseSliderNotificationModel = BaseNotificationModel & {
+  slides: Slide[];
+};
+
+export type BasicNotificationModel = BaseNotificationModel & {};
+
+export type ImageNotificationModel = BaseNotificationModel & {
+  media_url: string;
+};
+
+export type HTMLNotificationModel = BaseNotificationModel & {
+  media_url: string;
+};
+
+export type GifNotificationModel = BaseNotificationModel & {
+  cover_url: string;
+  media_url: string;
+};
+
+export type VideoNotificationModel = BaseNotificationModel & {
+  cover_url: string;
+  media_url: string;
+};
+
+export type AudioNotificationModel = BaseNotificationModel & {
+  media_url: string;
+};
+
+export type BasicCarouselNotificationModel = BaseSliderNotificationModel & {};
+export type RotaryCarouselNotificationModel = BaseSliderNotificationModel & {};
+export type CoverflowCarouselNotificationModel = BaseSliderNotificationModel & {};
+export type SliderNotificationModel = BaseSliderNotificationModel & {};
+
+export type SmallDialogModel = BaseNotificationModel & {};
+export type MediumDialogModel = BaseNotificationModel & {
+  image: string;
+};
+export type FullscreenDialogModel = BaseNotificationModel & {
+  image: string;
+};
+export type InteractiveDialogModel = BaseNotificationModel & {
+  image: string;
+};
+export type HTMLDialogModel = BaseNotificationModel & {
+  media_url: string;
+};
+
+export interface MessageListRequestModel {
+  index: number;
+  size: number;
+  startDate: Date;
+  endDate: Date;
+  customerNo: string;
+  externalId: string;
+  status: string[];
+  pushType: string[];
+  expiredPush: boolean;
+}
+
+export interface Media {
+  mediaUrl: string;
+
+  iconUrl: string;
+}
+
+

package/src/index.js

@@ -0,0 +1,8 @@
+// /**
+//  * SmartMessage React Native Bridge
+//  * @ODC
+//  */
+
+// import SmartMessage from './SmartMessage';
+
+// export default SmartMessage;