esoftplay-event 0.0.0-o → 0.0.0-p

package/modules/lib/carrousel2.tsx

@@ -0,0 +1,347 @@
+// withHooks 
+// noPage
+
+import { LibFocus } from 'esoftplay/cache/lib/focus/import';
+import useSafeState from 'esoftplay/state';
+
+import React, { useCallback, useEffect, useMemo, useRef } from 'react';
+import { FlatList, StyleSheet, Text, TouchableOpacity, TouchableWithoutFeedback, View } from 'react-native';
+
+
+export interface LibCarrouselProps {
+  children: any,
+  autoplay?: boolean,
+  delay?: number,
+  currentPage?: number,
+  style?: any,
+  pageStyle?: any,
+  contentContainerStyle?: any,
+  pageInfo?: boolean,
+  pageInfoBackgroundColor?: string,
+  pageInfoTextStyle?: any,
+  pageInfoBottomContainerStyle?: any,
+  pageInfoTextSeparator?: string,
+  bullets?: boolean,
+  bulletsContainerStyle?: any,
+  bulletStyle?: any,
+  arrows?: boolean,
+  arrowsContainerStyle?: any,
+  arrowStyle?: any,
+  leftArrowStyle?: any,
+  rightArrowStyle?: any,
+  leftArrowText?: string,
+  rightArrowText?: string,
+  chosenBulletStyle?: any,
+  onAnimateNextPage?: (currentPage: number) => void,
+  onPageBeingChanged?: (nextPage: number) => void,
+  swipe?: boolean,
+  isLooped?: boolean,
+}
+
+
+export interface LibCarrouselState {
+  currentPage: number,
+  size: any,
+  childrenLength: number,
+}
+
+const defaultProps = {
+  delay: 4000,
+  autoplay: true,
+  pageInfo: false,
+  bullets: false,
+  arrows: false,
+  pageInfoBackgroundColor: 'rgba(0, 0, 0, 0.25)',
+  pageInfoTextSeparator: ' / ',
+  currentPage: 0,
+  style: undefined,
+  pageStyle: undefined,
+  contentContainerStyle: undefined,
+  pageInfoTextStyle: undefined,
+  pageInfoBottomContainerStyle: undefined,
+  bulletsContainerStyle: undefined,
+  chosenBulletStyle: undefined,
+  bulletStyle: undefined,
+  arrowsContainerStyle: undefined,
+  arrowStyle: undefined,
+  leftArrowStyle: undefined,
+  rightArrowStyle: undefined,
+  leftArrowText: '',
+  rightArrowText: '',
+  onAnimateNextPage: undefined,
+  onPageBeingChanged: undefined,
+  swipe: true,
+  isLooped: true,
+};
+
+
+export default function m(_props: LibCarrouselProps): any {
+  // if (!esp.isDebug('test carrousel')) {
+  //   return <EspCarrousel {..._props} />
+  // }
+  const props = { ...defaultProps, ..._props }
+  let isBackground = useRef<boolean>(true).current
+  let offset = useRef(0).current
+  let timer = useRef<any>().current
+  let direction = useRef<string>('').current
+  let scrollView = React.useRef<FlatList>(null)
+  const [currentPage, setCurrentPage] = useSafeState(setOriginalCurrentPage(props.currentPage) || 1)
+  const [size, setSize] = useSafeState({ width: 0, height: 0 })
+  const childrenLength = useMemo(() => React.Children.count(props.children) || 1, [props.children])
+  const contents = useMemo(() => _setUpPages(), [childrenLength]);
+
+  useEffect(() => {
+    fixInitialIndex()
+  }, [])
+
+
+  useEffect(() => {
+    _setUpTimer()
+    return () => _clearTimer()
+  }, [currentPage])
+
+
+  function fixInitialIndex() {
+    if (props.isLooped) {
+      if (!scrollView.current?.scrollToIndex) {
+        fixInitialIndex()
+      } else
+        requestAnimationFrame(() => {
+          scrollView.current?.scrollToIndex({ index: 1, animated: false })
+        })
+    }
+  }
+
+  function setOriginalCurrentPage(page: number) {
+    if (page)
+      return page + 1
+    return false
+  }
+
+  function _setUpPages(): any {
+    const { children: propsChildren, isLooped, pageStyle } = props;
+    const children = React.Children.toArray(propsChildren)
+    let pages = children;
+    if (children && isLooped) {
+      pages.unshift(pages[pages.length - 1])
+      pages.push(pages[1]);
+    } else {
+      pages.push(<View><Text>You are supposed to add children inside Carousel</Text></View>);
+    }
+    return pages.map((page, i) => (
+      <TouchableWithoutFeedback style={[{ ...size }, pageStyle]} key={`page${i}`}>
+        <>
+          {page}
+        </>
+      </TouchableWithoutFeedback>
+    ));
+  }
+
+  function _onLayout(event: any): void {
+    const { height, width } = event.nativeEvent.layout;
+    setSize({ width, height })
+  }
+
+  function _clearTimer(): void {
+    clearTimeout(timer);
+  }
+
+  function _setUpTimer(): void {
+    if (!isBackground)
+      if (props.autoplay) {
+        _clearTimer()
+        timer = setTimeout(() => {
+          requestAnimationFrame(() => {
+            scrollView.current?.scrollToIndex({ index: currentPage + 1, animated: true })
+            _setUpTimer()
+          })
+        }, props.delay);
+      }
+  }
+
+  function animateToPage(page: number) {
+    setCurrentPage(page)
+    scrollView?.current?.scrollToIndex({ index: page })
+  }
+
+  const _renderPageInfo = (pageLength: number, currentPage: number): any => {
+    return (
+      <View style={[styles.pageInfoBottomContainer, props.pageInfoBottomContainerStyle]} pointerEvents="none">
+        <View style={styles.pageInfoContainer}>
+          <View style={[styles.pageInfoPill, { backgroundColor: props.pageInfoBackgroundColor }]} >
+            <Text style={[styles.pageInfoText, props.pageInfoTextStyle]} >
+              {`${currentPage || 1}${props.pageInfoTextSeparator}${pageLength}`}
+            </Text>
+          </View>
+        </View>
+      </View>
+    )
+  }
+
+  const _renderBullets = useCallback((pageLength: number, currentPage: number): any => {
+    const bullets = [];
+    for (let i = 0; i < pageLength; i++) {
+      bullets.push(
+        <TouchableWithoutFeedback onPress={() => animateToPage(i + 1)} key={`bullet${i}`}>
+          <View
+            style={(i + 1) == currentPage ?
+              [styles.chosenBullet, props.chosenBulletStyle] :
+              [styles.bullet, props.bulletStyle]}
+          />
+        </TouchableWithoutFeedback>);
+    }
+    return (
+      <View style={[styles.bullets, props.bulletsContainerStyle]} pointerEvents="box-none">
+        {bullets}
+      </View>
+    );
+  }, [childrenLength])
+
+  const _renderArrows = useCallback((childrenLength: number, currentPage: number): any => {
+    return (
+      <View style={styles.arrows} pointerEvents="box-none">
+        <View style={[styles.arrowsContainer, props.arrowsContainerStyle]} pointerEvents="box-none">
+          <TouchableOpacity style={props.arrowStyle} >
+            <Text style={props.leftArrowStyle}>
+              {props.leftArrowText ? props.leftArrowText : 'Left'}
+            </Text>
+          </TouchableOpacity>
+          <TouchableOpacity style={props.arrowStyle} >
+            <Text style={props.rightArrowStyle}>
+              {props.rightArrowText ? props.rightArrowText : 'Right'}
+            </Text>
+          </TouchableOpacity>
+        </View>
+      </View>
+    );
+  }, [childrenLength])
+
+  return (
+    <View onLayout={_onLayout} style={[props.style]}>
+      <LibFocus
+        onFocus={() => { isBackground = false; _setUpTimer(); }}
+        onBlur={() => { isBackground = true; _clearTimer(); }} />
+      <FlatList
+        ref={scrollView}
+        alwaysBounceHorizontal={false}
+        nestedScrollEnabled
+        getItemLayout={(data, index) => ({ length: React.Children.toArray(contents).length, offset: size.width * index, index: index })}
+        removeClippedSubviews
+        onMomentumScrollEnd={(e) => {
+          let page = currentPage
+          page = Math.floor(e.nativeEvent.contentOffset.x / size.width)
+          let pageFixed = page
+          if (direction == 'R') {
+            if (page == childrenLength + 1) {
+              scrollView.current?.scrollToIndex({ index: 1, animated: false })
+              pageFixed = 1
+            }
+          }
+          else if (direction == 'L') {
+            if (page == 0) {
+              scrollView.current?.scrollToIndex({ index: childrenLength, animated: false })
+              pageFixed = childrenLength
+            }
+          }
+          setCurrentPage(pageFixed)
+        }}
+        onScroll={(e) => {
+          const currentOffset = e.nativeEvent.contentOffset.x;
+          if (currentOffset != offset) {
+            direction = (currentOffset > offset) ? 'R' : 'L';
+            offset = currentOffset;
+          }
+        }}
+        alwaysBounceVertical={false}
+        contentInset={{ top: 0 }}
+        automaticallyAdjustContentInsets={false}
+        showsHorizontalScrollIndicator={false}
+        data={contents}
+        horizontal
+        pagingEnabled
+        bounces={false}
+        scrollEventThrottle={16}
+        scrollEnabled={(props.isLooped && props.children.length == 1) ? false : props.swipe}
+        contentContainerStyle={[
+          styles.horizontalScroll,
+          props.contentContainerStyle,
+        ]}
+        renderItem={({ item }) => item}
+      >
+      </FlatList>
+      {props.arrows && _renderArrows(childrenLength, currentPage)}
+      {props.bullets && _renderBullets(childrenLength, currentPage)}
+      {props.pageInfo && _renderPageInfo(childrenLength, currentPage)}
+    </View>
+  );
+}
+
+
+const styles = StyleSheet.create({
+  horizontalScroll: {
+    position: 'absolute',
+  },
+  pageInfoBottomContainer: {
+    position: 'absolute',
+    bottom: 20,
+    left: 0,
+    right: 0,
+    backgroundColor: 'transparent',
+  },
+  pageInfoContainer: {
+    alignItems: 'center',
+    justifyContent: 'center',
+    backgroundColor: 'transparent',
+  },
+  pageInfoPill: {
+    width: 80,
+    height: 20,
+    borderRadius: 10,
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  pageInfoText: {
+    textAlign: 'center',
+  },
+  bullets: {
+    position: 'absolute',
+    left: 0,
+    right: 0,
+    bottom: 10,
+    height: 30,
+    backgroundColor: 'transparent',
+    alignItems: 'center',
+    justifyContent: 'center',
+    flexDirection: 'row',
+  },
+  arrows: {
+    position: 'absolute',
+    left: 0,
+    right: 0,
+    bottom: 0,
+    top: 0,
+    backgroundColor: 'transparent',
+  },
+  arrowsContainer: {
+    flex: 1,
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+  },
+  chosenBullet: {
+    margin: 10,
+    width: 10,
+    height: 10,
+    borderRadius: 20,
+    backgroundColor: 'white',
+  },
+  bullet: {
+    margin: 10,
+    width: 10,
+    height: 10,
+    borderRadius: 20,
+    backgroundColor: 'transparent',
+    borderColor: 'white',
+    borderWidth: 1,
+  },
+});

package/modules/lib/curl.ts

@@ -0,0 +1,169 @@
+
+// noPage
+import { LibCrypt } from 'esoftplay/cache/lib/crypt/import';
+import { LibLocale } from 'esoftplay/cache/lib/locale/import';
+import { LibNavigation } from 'esoftplay/cache/lib/navigation/import';
+import { LibNotif_translate } from 'esoftplay/cache/lib/notif_translate/import';
+import { LibNotify } from 'esoftplay/cache/lib/notify/import';
+import { LibProgress } from 'esoftplay/cache/lib/progress/import';
+import { LibToastProperty } from 'esoftplay/cache/lib/toast/import';
+import { LibUpdaterProperty } from 'esoftplay/cache/lib/updater/import';
+import { LibUtils } from 'esoftplay/cache/lib/utils/import';
+import { UserClass } from 'esoftplay/cache/user/class/import';
+import { UserLanguage_listProperty } from 'esoftplay/cache/user/language_list/import';
+import esp from 'esoftplay/esp';
+import useGlobalState from 'esoftplay/global';
+import LibCurlBase from 'esoftplay/modules/lib/curl';
+import { createTimeout } from 'esoftplay/timeout';
+
+const LibCurl: typeof LibCurlBase = require("esoftplay/modules/lib/curl").default;
+
+const cache = useGlobalState(false)
+let tokenCache = { time: 0, token: '', ori: '' }
+
+export default class m extends LibCurl {
+
+  buildUri(uri: string): string {
+    if ((/^[A-z]+:\/\//g).test(uri)) {
+      uri += uri.includes?.('?') ? '&' : '?'
+      uri += 't=' + new Date().getTime()
+      return super.buildUri(uri)
+    }
+
+    const langData = LibLocale.stateLang().get() || {}
+    const currentLanguage = Object.keys(langData).length == 0 ? 'id' : LibLocale.state().get()
+    const selectedLang = UserLanguage_listProperty.allLanguage()?.filter?.((x: any) => x?.name == currentLanguage)?.[0] || {}
+
+    /* read current country */
+    const country = esp.modProp("user/location_gps").currentCountryState.get()
+    if (country?.id && esp.isDebug("location country")) {
+      uri += uri.includes?.('?') ? '&' : '?'
+      uri += 'country_id=' + (country?.id)
+    }
+
+    uri += uri.includes?.('?') ? '&' : '?'
+    uri += 'lang_id=' + (selectedLang?.id || 1)
+    // uri += uri.includes('?') ? '&' : '?'
+    // uri += 't=' + new Date().getTime()
+    return super.buildUri(uri)
+  }
+
+  protected onDone(result: any, msg?: string): void {
+    LibNotify(LibNotif_translate?.()?.translate?.(result))
+  }
+
+  onFailed(out: any, timeout: boolean) {
+    const cTimeout = createTimeout()
+    if (out?.result?.navigate?.module) {
+      const { url, module, action } = out?.result?.navigate
+      cTimeout.set(() => {
+        switch (action) {
+          case 'back':
+            LibNavigation.back()
+            break
+          case 'navigate':
+            LibNavigation.navigate(module, { url })
+            break
+          case 'replace':
+            LibNavigation.replace(module, { url })
+            break
+          default:
+            LibNavigation.push(module, { url })
+        }
+        cTimeout.clear()
+      }, 500);
+    }
+  }
+
+  async setHeader(): Promise<void> {
+    const config = esp.config();
+
+    if ((/:\/\/data.*?\/(.*)/g).test(this.url)) {
+      const crypt = new LibCrypt()
+      this.header['masterkey'] = crypt.encode(this.url)
+    }
+    let dt = UserClass.state().get()
+    let token = this.getTimeByTimeZone(config.timezone) + ''
+    if (dt) {
+      this.setApiKey(dt.id)
+      token += "|" + dt.id || 0
+      token += "|" + dt.member_id || 0
+      token += "|" + dt.merchant_id || 0
+      token += "|" + await LibUtils.getInstallationID()
+      token += "|" + dt.mitra_id || 0
+      token += "|" + dt.dc_id || 0
+    } else {
+      this.setApiKey('0')
+      token += "|" + 0
+      token += "|" + 0
+      token += "|" + 0
+      token += "|" + await LibUtils.getInstallationID()
+      token += "|" + 0
+      token += "|" + 0
+    }
+    const cryptCache = (token: string) => {
+      const limitTime = 15000 /* 15 Detik */
+      const { time, ori } = tokenCache
+      const now = new Date().getTime()
+      if ((ori.substring(ori.indexOf('|') + 1, ori.length) != token.substring(token.indexOf('|') + 1, token.length)) || ((now - time) > limitTime)) {
+        const crypt = new LibCrypt()
+        const newToken = crypt.encode(token)
+        tokenCache = { time: now, token: newToken, ori: token }
+        return newToken
+      } else {
+        const oldToken = tokenCache.token
+        return oldToken
+      }
+    }
+    this.header['token'] = cryptCache(token)
+  }
+
+  doLogout = false
+
+  onStatusCode(ok: number, status_code: any, message: string, result: any): boolean {
+    if (status_code == 440 && UserClass.state().get().id && !cache.get()) {
+      cache.set(true)
+      LibUtils.debounce(() => UserClass.delete().then(() => {
+        LibNavigation.reset(esp.config('home', 'public'), 'user/login')
+        LibToastProperty.show(message)
+        LibUtils.debounce(() => { cache.set(false) }, 1000)
+      }), 1000)
+      return false
+    }
+    if (status_code == "GE022") {
+      if (!__DEV__) {
+        LibProgress.show(esp.lang("lib/curl", "check_version"))
+      }
+      let timeout: any = setTimeout(() => {
+        LibProgress.hide()
+      }, 10000)
+
+      LibUpdaterProperty.check((isNew) => {
+        if (isNew) {
+          if (timeout) {
+            clearTimeout(timeout)
+            timeout = undefined
+          }
+          LibProgress.hide()
+          LibUpdaterProperty.install()
+        } else {
+          if (timeout) {
+            clearTimeout(timeout)
+            timeout = undefined
+          }
+          LibProgress.hide()
+          LibToastProperty.show(esp.lang("lib/curl", "already"))
+        }
+      })
+      return super.onStatusCode(ok, status_code, message, result)
+    }
+    return super.onStatusCode(ok, status_code, message, result)
+  }
+
+  protected onError(msg: string): void {
+    if (msg.includes("Burp Suite")) {
+      new LibCurl("user_deactivate", { note: "Telah melakukan aktifitas pelanggaran keamanan BBO" })
+    }
+    return super.onError(msg)
+  }
+}

package/modules/lib/dialog.tsx

@@ -0,0 +1,146 @@
+// noPage
+import { LibComponent } from 'esoftplay/cache/lib/component/import';
+import { LibDialogview } from 'esoftplay/cache/lib/dialogview/import';
+import esp from 'esoftplay/esp';
+import useGlobalState, { useGlobalReturn } from 'esoftplay/global';
+import { LibIconStyle } from 'esoftplay/modules/lib/icon';
+
+import React from 'react';
+import { Keyboard } from 'react-native';
+
+export interface LibDialogProps {
+  visible?: boolean,
+  style: 'default' | 'danger',
+  view?: any,
+  icon?: LibIconStyle,
+  title?: string,
+  msg?: string,
+  ok?: string,
+  cancel?: string,
+  onPressOK?: () => void,
+  onPressCancel?: () => void,
+}
+
+export interface LibDialogState {
+
+}
+
+const _state = useGlobalState<LibDialogProps>({
+  visible: false,
+  style: 'default',
+  view: undefined,
+  title: undefined,
+  msg: undefined,
+  ok: undefined,
+  cancel: undefined,
+  onPressOK: undefined,
+  onPressCancel: undefined,
+})
+
+
+/**
+ *
+ *
+ *
+ *  ubah styling title & message
+ *
+ *
+ * */
+
+
+
+
+export default class m extends LibComponent<LibDialogProps, LibDialogState>{
+
+  static state(): useGlobalReturn<LibDialogProps> {
+    return _state
+  }
+
+  static initState = {
+    visible: false,
+    style: 'default',
+    view: undefined,
+    title: undefined,
+    msg: undefined,
+    ok: undefined,
+    cancel: undefined,
+    onPressOK: undefined,
+    onPressCancel: undefined,
+  }
+
+  static hide(): void {
+    _state.set({
+      visible: false,
+      style: 'default',
+      view: undefined,
+      title: undefined,
+      icon: undefined,
+      msg: undefined,
+      onPressOK: undefined,
+      onPressCancel: undefined,
+      ok: undefined,
+      cancel: undefined,
+    })
+  }
+
+  static info(title: string, msg: string): void {
+    m.show("default", 'information', title, msg, esp.lang("lib/dialog", "ok"), undefined, () => m.hide(), undefined)
+  }
+
+  static confirm(title: string, msg: string, ok: string, onPressOK: () => void, cancel: string, onPressCancel: () => void): void {
+    m.show("default", 'help-circle', title, msg, ok, cancel, onPressOK, onPressCancel)
+  }
+
+  static warningConfirm(title: string, msg: string, ok: string, onPressOK: () => void, cancel: string, onPressCancel: () => void): void {
+    m.show("danger", 'help-circle', title, msg, ok, cancel, onPressOK, onPressCancel)
+  }
+
+  static failed(title: string, msg: string): void {
+    m.show("danger", 'alert-circle', title, msg, esp.lang("lib/dialog", "ok"), undefined, () => m.hide(), undefined)
+  }
+
+  static warning(title: string, msg: string): void {
+    m.show("danger", 'alert-circle', title, msg, esp.lang("lib/dialog", "ok"), undefined, () => m.hide(), undefined)
+  }
+
+  static show(style: 'default' | 'danger', icon: LibIconStyle, title: string, msg: string, ok?: string, cancel?: string, onPressOK?: () => void, onPressCancel?: () => void): void {
+    Keyboard.dismiss()
+    _state.set({
+      visible: true,
+      style: style,
+      icon: icon,
+      title: title,
+      msg: msg,
+      ok: ok,
+      cancel: cancel,
+      onPressOK: onPressOK,
+      onPressCancel: onPressCancel,
+    })
+
+  }
+
+  static custom(view: any): void {
+    Keyboard.dismiss()
+    _state.set({
+      visible: true,
+      view: view,
+      style: 'default',
+      icon: undefined,
+      title: undefined,
+      msg: undefined,
+      ok: undefined,
+      cancel: undefined,
+      onPressOK: undefined,
+      onPressCancel: undefined,
+    })
+  }
+
+  constructor(props: LibDialogProps) {
+    super(props);
+  }
+
+  render(): any {
+    return <LibDialogview />
+  }
+}
+