esoftplay-event 0.0.0-p → 0.0.0-q

package/modules/lib/notif_translate.ts

@@ -1,49 +0,0 @@
-// 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

@@ -1,518 +0,0 @@
-
-// 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

@@ -1,148 +0,0 @@
-// 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);
-      });
-  }
-}