esoftplay-event 0.0.0-n → 0.0.0-p

package/modules/lib/notif_translate.ts

@@ -0,0 +1,49 @@
+// useLibs
+// noPage
+
+
+export interface Notif_translate {
+  translate: any
+}
+
+export default function m(): Notif_translate {
+
+  function translate(result: any) {
+    const notificationData = Array.isArray(result?.notifications) ? result?.notifications : result?.notifications?.list
+    let item: any = []
+    notificationData?.map?.((t: any) => {
+      t?.accounts.map((x: any) => {
+        x.tokens.map((y: any) => {
+          item.push({
+            user_id: x?.user_id,
+            group_id: x?.group_id,
+            created: t?.created,
+            access_token: result?.notifications?.access_token || "", //FCM v1
+            to: y,
+            sound: t?.sound,
+            title: t?.title,
+            body: t?.message,
+            params: JSON.stringify({
+              action: t?.data?.action,
+              module: t.data.module,
+              arguments: t?.data?.arguments
+            }),
+            data: {
+              action: t?.data?.action,
+              module: t.data.module,
+              title: t.data.title,
+              message: t.data.message,
+              params: t?.data?.arguments
+            }
+          });
+        })
+      })
+    })
+    return { notifications: item || [] }
+  }
+
+  return {
+    translate: translate
+  }
+
+}

package/modules/lib/notification.ts

@@ -0,0 +1,518 @@
+
+// noPage
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import messaging from '@react-native-firebase/messaging';
+import { LibCrypt } from 'esoftplay/cache/lib/crypt/import';
+import { LibCurl } from 'esoftplay/cache/lib/curl/import';
+import { LibNavigation } from 'esoftplay/cache/lib/navigation/import';
+import { LibNotification } from 'esoftplay/cache/lib/notification/import';
+import { LibObject } from 'esoftplay/cache/lib/object/import';
+import { UserClass } from 'esoftplay/cache/user/class/import';
+import { UserNotification } from 'esoftplay/cache/user/notification/import';
+import esp from 'esoftplay/esp';
+import useGlobalState, { useGlobalReturn } from 'esoftplay/global';
+import moment from 'esoftplay/moment';
+import { createTimeout } from 'esoftplay/timeout';
+import * as Notifications from 'expo-notifications';
+import { Alert, Linking, Platform } from "react-native";
+/*
+{
+  to: // exp token
+  data:{
+    action: // [route, dialog,  ]
+    module: // routeName of ReactNavigation
+    params:
+    title:
+    message:
+  }
+  title:
+  body:
+  sound:
+  param:
+  ttl:
+  expiration:
+  priority:
+  badge:
+} */
+
+
+// const url = useGlobalState()
+// Set up the notification handler for the app
+const lastUrlState = useGlobalState<any>(undefined)
+
+// Set up the notification handler for the app
+Notifications.setNotificationHandler({
+  handleNotification: async () => ({
+    shouldShowAlert: true,
+    shouldPlaySound: true,
+    shouldSetBadge: true,
+    priority: Notifications.AndroidNotificationPriority.MAX,
+  }),
+});
+
+function rebuildNotificationData(data: any) {
+  const out: { title: string, body: string, data: any } = { title: '', body: '', data: null }
+  if (Platform.OS == 'android') {
+    if (data.notification) {
+      if (data.notification?.request?.content) {
+        out.title = data.notification?.request?.content?.title
+        out.body = data.notification?.request?.content?.body
+        out.data = { ...data.notification?.request?.content?.data, title: out.title, body: out.body }
+      } else if (data.notification?.title) {
+        out.title = data.notification?.title
+        out.body = data.notification?.body
+        out.data = { ...data?.data, title: out.title, body: out.body }
+      }
+    }
+  } else if (Platform.OS == 'ios') {
+    if (data.notification?.request?.content) {
+      out.title = data.notification?.request?.content?.title
+      out.body = data.notification?.request?.content?.body
+      if (data.notification?.request?.trigger?.payload) {
+        let rawData = data.notification?.request?.trigger?.payload
+        delete rawData["aps"]
+        delete rawData["google.c.sender.id"]
+        delete rawData["gcm.message_id"]
+        delete rawData["google.c.fid"]
+        delete rawData["google.c.a.e"]
+        out.data = { ...rawData, title: out.title, body: out.body }
+      } else {
+        out.data = { ...data.notification?.request?.content?.data, title: out.title, body: out.body }
+      }
+    } else if (data?.notification?.title) {
+      out.title = data.notification?.title
+      out.body = data.notification?.body
+      out.data = { ...data?.data, title: out.title, body: out.body }
+    }
+  }
+  return out
+}
+
+
+function checkNotifStorage(title?: string) {
+  AsyncStorage.getItem('remoteMessage').then((v) => {
+    try {
+      if (v) {
+        LibNotification.onAction(JSON.parse(v), title)
+        AsyncStorage.removeItem("remoteMessage")
+      }
+    } catch (error) {
+
+    }
+  })
+}
+
+// Handle push notifications when the app is in the background
+messaging().setBackgroundMessageHandler(async (remoteMessage: any) => {
+  // handlePushNotification(remoteMessage)
+  AsyncStorage.setItem('remoteMessage', JSON.stringify(remoteMessage))
+  // if (remoteMessage) {
+  // }
+  // setTimeout(() => {
+  //   checkNotifStorage("setBackgroundMessageHandler")
+  // }, 500);
+});
+
+messaging().onTokenRefresh((token) => {
+  AsyncStorage.getItem("token").then((old) => {
+    if (old != token) {
+      UserClass.sendToken(token)
+    }
+  })
+})
+
+
+
+function mainUrl(): string {
+  const { protocol, domain, uri } = esp.config()
+  return protocol + "://" + domain + uri;
+}
+
+function readAll(ids: (string | number)[]) {
+  let url = mainUrl() + "user/push-read";
+  const { salt } = esp.config()
+  let post: any = {
+    notif_id: ids.join(','),
+    user_id: "",
+    secretkey: new LibCrypt().encode(salt + "|" + moment().serverFormat("YYYY-MM-DD hh:mm:ss"))
+  }
+  new LibCurl(url, post)
+}
+
+function splitArray(array: any[], maxLength: number): any[] {
+  const parts = maxLength // items per chunk
+  const splitedArray = array.reduce((resultArray: any, item, index) => {
+    const chunkIndex = Math.floor(index / parts)
+    if (!resultArray[chunkIndex]) {
+      resultArray[chunkIndex] = [] // start a new chunk
+    }
+    resultArray[chunkIndex].push(item)
+    return resultArray
+  }, [])
+  return splitedArray
+}
+
+
+export interface notificationTrigger {
+  delayInMinutes: number,
+  repeats?: boolean
+}
+
+export interface notificationContent {
+  title: string,
+  message: string,
+  module?: string,
+  url?: string
+  arguments?: any
+}
+
+
+const handlePushNotification = async (remoteMessage: any) => {
+  const notification = {
+    title: remoteMessage?.notification?.title,
+    body: remoteMessage?.notification?.body,
+    data: { ...remoteMessage.data, messageId: remoteMessage?.messageId }, // optional data payload
+  };
+  if (remoteMessage) {
+    AsyncStorage.setItem('remoteMessage', JSON.stringify(remoteMessage))
+  }
+  await Notifications.scheduleNotificationAsync({ content: notification, trigger: null });
+};
+
+
+export default {
+  state(): useGlobalReturn<any> {
+    return lastUrlState
+  },
+  effect() {
+    // Listen for push notifications when the app is in the foreground
+    // const uns = AppState.addEventListener('focus', () => {
+    // })
+    setTimeout(() => {
+      checkNotifStorage()
+    }, 500);
+
+    let unMessage = messaging().onMessage(handlePushNotification);
+    // Handle user opening the app from a notification (when the app is in the background)
+    let unonNotificationOpenedApp = messaging().onNotificationOpenedApp((remoteMessage) => {
+      if (remoteMessage) {
+        AsyncStorage.setItem('remoteMessage', JSON.stringify(remoteMessage))
+      }
+      setTimeout(() => {
+        checkNotifStorage("onNotificationOpenedApp")
+      }, 500);
+    });
+
+    // Check if the app was opened from a notification (when the app was completely quit)
+    messaging().getInitialNotification().then((remoteMessage) => {
+      if (remoteMessage) {
+        AsyncStorage.setItem('remoteMessage', JSON.stringify(remoteMessage))
+      }
+      setTimeout(() => {
+        checkNotifStorage("getInitialNotification")
+      }, 500);
+    });
+
+    return () => {
+      unMessage()
+      unonNotificationOpenedApp()
+      // uns.remove()
+    }
+  },
+  loadData(isFirst?: boolean): void {
+    let _uri = mainUrl() + "user/push-notif/desc"
+    let lastUrl = lastUrlState.get()
+    if (isFirst) {
+      lastUrl = undefined
+    }
+    if (lastUrl == -1) {
+      return
+    }
+    if (lastUrl && !isFirst) {
+      _uri = lastUrl
+    }
+    const user = UserClass.state().get()
+    if (!user?.id) {
+      Notifications.setBadgeCountAsync(0)
+    }
+    const { salt } = esp.config()
+    let post: any = {
+      user_id: "",
+      secretkey: new LibCrypt().encode(salt + "|" + moment().serverFormat("YYYY-MM-DD hh:mm:ss"))
+    }
+    if (user) {
+      post["user_id"] = user.id || user.user_id
+      post["group_id"] = user.group_id || esp.config('group_id')
+    }
+
+    new LibCurl(_uri, post,
+      (res: any) => {
+        if (res?.list?.length > 0) {
+          let urls: string[] = UserNotification.state().get().urls
+          if (isFirst) {
+            urls = []
+          }
+          if (urls && urls.indexOf(_uri) < 0) {
+            let { data, unread } = UserNotification.state().get()
+            let nUnread
+            if (isFirst) {
+              nUnread = res.list.filter((row: any) => row.status != 2).length
+              UserNotification.state().set({
+                data: res.list,
+                urls: [],
+                unread: nUnread
+              })
+
+            } else {
+              nUnread = unread + res.list.filter((row: any) => row.status != 2).length
+              data.push(...res.list)
+              UserNotification.state().set({
+                data: data,
+                urls: [_uri, ...urls],
+                unread: nUnread
+              })
+            }
+            Notifications.setBadgeCountAsync(nUnread)
+          }
+        }
+        if (res.next) {
+          lastUrlState.set(res.next)
+        } else {
+          lastUrlState.set(-1)
+        }
+      }, (msg) => {
+
+      }
+    )
+  },
+  add(id: number, user_id: number, group_id: number, title: string, message: string, params: string, status: 0 | 1 | 2, created?: string, updated?: string): void {
+    const item = { id, user_id, group_id, title, message, params, status, created, updated }
+    let data = UserNotification.state().get().data
+    data.unshift(item)
+    UserNotification.state().set({
+      ...UserNotification.state().get(),
+      data: data
+    })
+  },
+  drop(): void {
+    UserNotification.state().reset()
+  },
+  markRead(id?: string | number, ..._ids: (string | number)[]): void {
+    let { data, unread, urls } = UserNotification.state().get()
+    let nUnread = unread > 0 ? unread - 1 : 0
+    let ids = [id, ..._ids]
+    ids.forEach((id) => {
+      const index = data.findIndex((row: any) => String(row.id) == String(id))
+      if (index > -1) {
+        data = LibObject.set(data, 2)(index, 'status')
+        nUnread = unread > 0 ? unread - 1 : 0
+      }
+    })
+    UserNotification.state().set({
+      urls,
+      data: data,
+      unread: nUnread
+    })
+    Notifications.setBadgeCountAsync(nUnread)
+    const idsToPush = splitArray(ids, 20)
+    idsToPush.forEach((ids) => {
+      readAll(ids)
+    })
+  }
+  ,
+  onAction(notification: any, title?: string): void {
+    this.loadData(true)
+    const data = this.getData(notification)
+    // Alert.alert(title || 'default', JSON.stringify(data?.data, undefined, 2))
+    const timeout1 = createTimeout()
+    const timeout2 = createTimeout()
+    const doOpen = (data: any) => {
+      if (!LibNavigation.getIsReady()) {
+        timeout1.set(() => {
+          doOpen(data)
+          timeout1.clear()
+        }, 300);
+        return
+      } else {
+        timeout2.set(() => {
+          this.openPushNotif(data?.data)
+          timeout2.clear()
+        }, 300)
+      }
+    }
+    doOpen(data)
+  },
+  getData(x: any): any {
+    return rebuildNotificationData(x)
+  },
+  listen(dataRef: any): void {
+    if (esp.config('notification') == 1) {
+      if (Platform.OS == 'android')
+        Notifications.setNotificationChannelAsync(
+          'android',
+          {
+            sound: 'default',
+            enableLights: true,
+            description: esp.lang("lib/notification", "permission"),
+            name: esp.appjson().expo.name,
+            importance: Notifications.AndroidImportance.MAX,
+            showBadge: true,
+            enableVibrate: true,
+            lockscreenVisibility: Notifications.AndroidNotificationVisibility.PUBLIC
+          }
+        )
+      UserClass.pushToken();
+      dataRef.receive = Notifications.addNotificationReceivedListener(() => { })
+    }
+  },
+  requestPermission(callback?: (token: any) => void): Promise<any> {
+    return new Promise(async (r) => {
+      let settings = await Notifications.getPermissionsAsync();
+      if (!settings.granted) {
+        settings = await Notifications.requestPermissionsAsync({
+          ios: {
+            allowAlert: true,
+            allowBadge: true,
+            allowSound: true,
+            allowAnnouncements: true,
+          },
+          android: {}
+        });
+      }
+      const authStatus = await messaging().requestPermission();
+      const enabled = authStatus === messaging.AuthorizationStatus.AUTHORIZED || authStatus === messaging.AuthorizationStatus.PROVISIONAL;
+      if (enabled) {
+        await messaging().registerDeviceForRemoteMessages()
+        messaging()
+          .getToken()
+          .then(
+            token => {
+              callback?.(token)
+            }
+          )
+          .catch(() => {
+            callback?.(null)
+          })
+      } else {
+        callback?.(null)
+      }
+    })
+  },
+  cancelLocalNotification(notif_id: string) {
+    Notifications.cancelScheduledNotificationAsync(notif_id)
+  },
+  setLocalNotification(action: "alert" | "default" | "update", content: notificationContent, trigger: notificationTrigger, callback?: (notif_id: string) => void): void {
+    const triggerSeconds = Number(trigger?.delayInMinutes) * 60
+    const _trigger = {
+      seconds: triggerSeconds,
+      repeats: !!trigger?.repeats,
+    }
+    const params = { status: 3, url: content?.url, ...content?.arguments }
+    Notifications.scheduleNotificationAsync({
+      content: {
+        title: content?.title,
+        body: content?.message,
+        data: {
+          action: action,
+          module: content.module,
+          title: content?.title,
+          message: content?.message,
+          params,
+        },
+      },
+      trigger: _trigger,
+    }).then((notifId) => {
+      console.log("BERHASIL", r)
+      callback?.(notifId)
+    }).catch((r) => {
+      console.log("GAGAL", r)
+    })
+  },
+  openPushNotif(data: any): void {
+    if (!data) return
+    if (typeof data == 'string')
+      data = JSON.parse(data)
+    this.markRead(data?.id)
+    const _arguments = data.arguments ? ((typeof data.arguments == 'string') ? JSON.parse(data.arguments) : data.arguments) : data
+    if (data.action)
+      switch (data.action) {
+        case "alert":
+          const timeout = createTimeout()
+          let hasLink = _arguments?.url
+          let btns: any = []
+          if (hasLink) {
+            btns.push({ text: "OK", onPress: () => Linking.openURL(_arguments.url) })
+          } else {
+            btns.push({ text: "OK", onPress: () => { }, style: "cancel" })
+          }
+          timeout.set(() => {
+            Alert.alert(
+              data.title,
+              data.message,
+              btns,
+              { cancelable: false }
+            )
+            timeout.clear()
+          }, 10)
+          break;
+        case "default":
+          if (data.module && data.module != "") {
+            const timeout1 = createTimeout()
+            if (!String(data.module).includes("/")) data.module = data.module + "/index"
+            timeout1.set(() => {
+              LibNavigation.navigate(data.module, _arguments)
+              timeout1.clear()
+            }, 10)
+          }
+          break;
+        case "update":
+          const timeout2 = createTimeout()
+          const update = esp.modProp('lib/updater')
+          timeout2.set(() => {
+            update?.check?.()
+            timeout2.clear()
+          }, 50);
+          break;
+        default:
+          break;
+      }
+  },
+  openNotif(data: any): void {
+    this.markRead(data.id)
+    let param = JSON.parse(data.params)
+    const timeout1 = createTimeout()
+    const timeout2 = createTimeout()
+    const _arguments = param.arguments ? ((typeof param.arguments == 'string') ? JSON.parse(param.arguments) : param.arguments) : param
+    switch (param.action) {
+      case "alert":
+        let hasLink = _arguments.hasOwnProperty("url") && _arguments.url != ""
+        let btns: any = []
+        if (hasLink) {
+          btns.push({ text: "OK", onPress: () => Linking.openURL(_arguments.url) })
+        } else {
+          btns.push({ text: "OK", onPress: () => { }, style: "cancel" })
+        }
+        timeout1.set(() => {
+          Alert.alert(
+            data.title,
+            data.message,
+            btns,
+            { cancelable: false }
+          )
+          timeout1.clear()
+        }, 10)
+        break;
+      case "default":
+        if (param.module != "") {
+          if (!String(param.module).includes("/")) param.module = param.module + "/index"
+          timeout2.set(() => {
+            LibNavigation.navigate(param.module, _arguments)
+            timeout2.clear()
+          }, 10)
+        }
+        break;
+      default:
+        break;
+    }
+  }
+}

package/modules/lib/notify.ts

@@ -0,0 +1,148 @@
+// useLibs
+// noPage
+import { LibObject } from 'esoftplay/cache/lib/object/import';
+import esp from 'esoftplay/esp';
+
+export interface LibNotifyItem {
+  to: string,
+  sound: string,
+  title: string,
+  body: string,
+  data: any,
+  access_token?: string
+}
+export interface LibNotifyProps {
+  notifications: LibNotifyItem[]
+}
+
+export default function libnotify(res: LibNotifyProps): any {
+  const notifications = res.notifications
+  if (notifications && Array.isArray(notifications)) {
+    notifications.forEach((val, i) => {
+      if (val?.access_token) {
+        curlFCM(val)
+      } else {
+        curl(val)
+      }
+    })
+  }
+}
+
+const curlFCM = (data: any) => {
+  const LibCrypt = esp.mod("lib/crypt")
+  const token = new LibCrypt().decode(data.to)
+
+  if (!token.includes('ExponentPushToken')) {
+    const projectId = esp.config("firebase", "projectId")
+    const _data = LibObject.assign(data?.data || data, data?.data?.params || data?.params)()
+
+    let payloadData: any = {
+      action: _data?.action || "default",
+      title: _data?.title,
+      message: _data?.message,
+    }
+
+    if (_data?.module) {
+      payloadData['module'] = _data?.module
+    }
+    if (_data?.url) {
+      payloadData['url'] = _data?.url
+    }
+
+    const payload = {
+      message: {
+        token: token,
+        notification: {
+          title: data?.title,
+          body: data?.body
+        },
+        android: {
+          priority: "high",
+          notification: {
+            sound: "default",
+            icon: "notification_icon",
+            color: "#f39c12"
+          },
+        },
+        apns: {
+          payload: {
+            aps: {
+              sound: "default"
+            }
+          }
+        },
+        data: payloadData
+      }
+    };
+
+    const url = `https://fcm.googleapis.com/v1/projects/${projectId}/messages:send`;
+    const headers = {
+      'Authorization': `Bearer ${data?.access_token}`,
+      'Content-Type': 'application/json'
+    };
+
+    fetch(url, {
+      method: 'POST',
+      headers: headers,
+      body: JSON.stringify(payload)
+    })
+      .then(response => {
+        if (response.ok) {
+        } else {
+          console.error('Failed to send notification. Status code:', response.status);
+          return response.json().then(errorData => {
+            console.error('Error details:', errorData);
+          });
+        }
+      })
+      .catch(error => {
+        console.error('Error sending notification:', error);
+      });
+
+  }
+}
+
+const curl = (data: LibNotifyItem) => {
+  let dData: any = data
+  const LibCrypt = esp.mod("lib/crypt")
+  const token = new LibCrypt().decode(dData.to)
+  if (!token.includes('ExponentPushToken')) {
+    dData['to'] = token
+    const serverKey = esp.isDebug('server_key') ?
+      'AAAAOrW_DY4:APA91bEHxfawXU5H0lRhx0QyOJxKjusrp2KBXbPaKXq1RnTucgbi4MYodFBSCQobUbQSITY1056mTduORUixgWjv4TNSy_1VMXcrZU0oeUvWBALR8tDLZujDrbYyPEnBRt404EzCeazD' :
+      "AAAA_xCvBYI:APA91bE--DA0p9ArQmJ7jxrxpCvmNdGBdeW7IMHweQh5dKCt5bY7Ji9wlp9Y8-7zlFQA-CyacgKTLQEYa6EpMRzBiM8UmSy6YInN-vujP5NNJ53RxNSL8innpldUk3wQwjw8rHnnXKiv"
+
+    const payload = {
+      to: dData?.to,
+      notification: {
+        title: data?.title,
+        body: data?.body,
+        icon: "notification_icon",
+        color: "@color/notification_icon_color"
+      },
+      notification_priority: "PRIORITY_MAX",
+      data: LibObject.assign(data?.data || data, dData?.data?.params || dData?.params)()
+    };
+
+    const url = 'https://fcm.googleapis.com/fcm/send';
+    const headers = {
+      'Authorization': 'key=' + serverKey,
+      'Content-Type': 'application/json'
+    };
+
+    fetch(url, {
+      method: 'POST',
+      headers: headers,
+      body: JSON.stringify(payload)
+    })
+      .then((response) => {
+        if (response.ok) {
+        } else {
+          console.error('Failed to send notification. Status code:', response.status);
+        }
+      })
+      .catch(error => {
+        console.error('Error sending notification:', error);
+      });
+  }
+}