esoftplay-event 0.0.0-o → 0.0.0-p

package/modules/user/location_gps.tsx

@@ -0,0 +1,175 @@
+// withHooks
+
+import { LibCurl } from 'esoftplay/cache/lib/curl/import';
+import { LibLoading } from 'esoftplay/cache/lib/loading/import';
+import { LibNavigation } from 'esoftplay/cache/lib/navigation/import';
+import { LibPicture } from 'esoftplay/cache/lib/picture/import';
+import { LibStyle } from 'esoftplay/cache/lib/style/import';
+import esp from 'esoftplay/esp';
+import useGlobalState from 'esoftplay/global';
+import useSafeState from 'esoftplay/state';
+import * as Location from 'expo-location';
+import React, { useEffect } from 'react';
+import { ActivityIndicator, Linking, Pressable, Text, View } from 'react-native';
+
+export interface UserLocation_gpsArgs {
+
+}
+export interface UserLocation_gpsProps {
+
+}
+
+export const currentCountryState = useGlobalState<any>(undefined, { inFastStorage: true, loadOnInit: true, persistKey: "user/location_gps" })
+
+export const findCountryByCountryCode = (code: string, callback?: (result: any) => void) => {
+  const progress = esp.mod("lib/progress")
+  const curl = esp.mod("lib/curl")
+
+  progress.show()
+  new curl("location_country?country_code=" + code + "&t=" + new Date().getTime(), null, (res) => {
+    getDefaultCountry(res?.list?.[0], res?.list[0]?.code, (result) => {
+      callback?.(result)
+      progress.hide()
+    })
+  }, (error) => {
+    progress.hide()
+  }, 1)
+
+  function getDefaultCountry(result: any, code: string, callback: (result: any) => void) {
+    const country = esp.modProp("user/location_country_server").state.get()?.find((item: any) => item.code == code)
+    if (!country) {
+      fallbackToID(code, callback)
+    } else {
+      findCountryFlag(code, (image) => {
+        currentCountryState.set({ ...result, image })
+        callback({ ...result, image })
+      })
+    }
+  }
+
+  function fallbackToID(code: string, callback: (result: any) => void) {
+    new curl("location_country?country_code=ID&t=" + new Date().getTime(), null, (res) => {
+      findCountryFlag(code, (image) => {
+        currentCountryState.set({ ...res.list[0], image })
+        callback({ ...res.list[0], image })
+      })
+    }, (error) => {
+      progress.hide()
+    }, 1)
+  }
+
+}
+
+function findCountryFlag(code: string, callback: (image: any) => void) {
+  const countries = esp.modProp("user/location_country_server").state.get() || [];
+  const match = countries.find((item: any) => item.code === code);
+  const fallback = countries.find((item: any) => item.code === "ID");
+  callback(match?.image || fallback?.image);
+}
+
+export default function m(props: UserLocation_gpsProps): any {
+  const [hasPermission, setHasPermission] = useSafeState<any>()
+
+  useEffect(() => {
+    const requestPermission = async () => {
+      const { status, canAskAgain } = await Location.getForegroundPermissionsAsync();
+      if (status !== 'granted') {
+        if (canAskAgain) {
+          const { status: newStatus } = await Location.requestForegroundPermissionsAsync();
+          if (newStatus !== 'granted') {
+            setHasPermission("denied")
+            return
+          }
+        } else {
+          setHasPermission("denied")
+          return
+        }
+      }
+      if (status == 'granted') {
+        setHasPermission("granted")
+      }
+      getCurrentLocation()
+    }
+    requestPermission()
+  }, [])
+
+  async function getCurrentLocation() {
+    try {
+      let location = await Location.getCurrentPositionAsync({
+        accuracy: Location.Accuracy.Highest
+      });
+      const latlong = location?.coords?.latitude + ',' + location?.coords?.longitude
+      getCountryCode(latlong).then((res) => {
+        doSetCountry(res.short_name)
+      })
+    } catch (error) {
+      doSetCountry("ID")
+    }
+  }
+
+  async function getCountryCode(latlong: string): Promise<any> {
+    return new Promise((r) => {
+      new LibCurl().custom('https://maps.googleapis.com/maps/api/geocode/json?latlng=' + latlong + '&result_type=country&key=' + esp.assets("google-services.json").client[0].api_key[0].current_key, null, (res) => {
+        r(res?.results[0]?.address_components?.[0] || null)
+      }, 1)
+    })
+  }
+
+  function doSetCountry(code: string) {
+    findCountryByCountryCode(code, (res: any) => {
+      LibNavigation.back()
+    })
+  }
+
+  if (!hasPermission || hasPermission == "granted") {
+
+    return (
+      <View style={{ flex: 1, alignItems: "center", justifyContent: "center" }}>
+        {/* @ts-ignore */}
+        <LibPicture source={esp.assets("icons/ic_pin_grey.png")} style={{ width: 100, height: 100, marginBottom: 30 }} resizeMode='contain' tintColor="#9f9f9f" />
+        <ActivityIndicator size="large" color={LibStyle.colorPrimary} style={{ marginTop: 8 }} />
+        <Text style={{ fontFamily: "SFProText", fontSize: 16, color: "#767676", marginTop: 8 }}>{esp.lang("user/location_gps", "finding_location")}</Text>
+        <Pressable onPress={() => {
+          LibNavigation.navigateForResult("user/location_country_server", undefined, 15).then((value) => {
+            doSetCountry(value.code)
+          })
+        }}>
+          <Text style={{ fontFamily: "SFProText", fontSize: 16, color: "#767676", textAlign: 'center' }}>{esp.lang("user/location_gps", "or")}
+            <Text style={{ fontFamily: "SFProText", fontSize: 16, fontWeight: "bold", color: LibStyle.colorPrimary }}>{esp.lang("user/location_gps", "manual_select")}</Text>
+          </Text>
+        </Pressable>
+      </View>
+    )
+  }
+
+  if (hasPermission == "denied") {
+    return (
+      <View style={{ flex: 1, alignItems: "center", justifyContent: "center" }}>
+        {/* @ts-ignore */}
+        <LibPicture source={esp.assets("icons/ic_pin_grey.png")} style={{ width: 100, height: 100, marginBottom: 30 }} resizeMode='contain' tintColor="#9f9f9f" />
+        <Text style={{ fontFamily: "SFProText", fontSize: 20, color: "#111111" }}>{esp.lang("user/location_gps", "cant_access_location")}</Text>
+        <Text style={{ fontFamily: "SFProText", fontSize: 16, color: "#767676", marginTop: 8 }}>{esp.lang("user/location_gps", "cant_access_location2")}</Text>
+        <View style={{ flexDirection: "row", alignItems: "center", marginTop: 4, marginHorizontal: 20 }}>
+          <Pressable onPress={() => {
+            Linking.openSettings()
+          }}>
+            <Text style={{ fontFamily: "SFProText", fontSize: 16, color: "#767676", textAlign: 'center' }}>{esp.lang("component/camera", "enable_access")}
+              <Text style={{ fontFamily: "SFProText", fontSize: 16, fontWeight: "bold", color: LibStyle.colorPrimary }}>{esp.lang("component/camera", "enable_access2")}</Text>
+            </Text>
+          </Pressable>
+        </View>
+        <Pressable onPress={() => {
+          LibNavigation.navigateForResult("user/location_country_server", undefined, 15).then((value) => {
+            doSetCountry(value.code)
+          })
+        }}>
+          <Text style={{ fontFamily: "SFProText", fontSize: 16, color: "#767676", textAlign: 'center' }}>{esp.lang("user/location_gps", "or2")}
+            <Text style={{ fontFamily: "SFProText", fontSize: 16, fontWeight: "bold", color: LibStyle.colorPrimary }}>{esp.lang("user/location_gps", "manual_select2")}</Text>
+          </Text>
+        </Pressable>
+      </View>
+    )
+  }
+
+  return <LibLoading />
+}

package/modules/user/location_item.tsx

@@ -0,0 +1,40 @@
+// withHooks
+// noPage
+
+import { LibStyle } from 'esoftplay/cache/lib/style/import';
+
+import React from 'react';
+import { Text, TouchableOpacity, View } from 'react-native';
+
+
+export interface UserLocation_itemProps {
+  detail: string,
+  id: string,
+  latitude: string,
+  longitude: string,
+  par_id: string,
+  phone: string,
+  postcode: string,
+  publish: string,
+  title: string,
+  type: string,
+  testID?: string,
+  onPress: (location: any) => void
+}
+export default function m(props: UserLocation_itemProps): any {
+  return (
+    <TouchableOpacity testID={props.testID} onPress={() => { props.onPress(props) }} style={styleId_jv5kW} >
+      <View style={styleId_ZJECRs} >
+        <Text allowFontScaling={false} style={styleId_ZLcYQx} >{props.title}</Text>
+        {
+          props.detail !== "" &&
+          <Text allowFontScaling={false} style={styleId_ZdXNyQ} >{props.detail}</Text>
+        }
+      </View>
+    </TouchableOpacity>
+  )
+}
+const styleId_jv5kW: any = { borderBottomWidth: 1, borderBottomColor: '#F6F6F6' }
+const styleId_ZJECRs: any = { margin: 15, width: LibStyle.width, flex: 1 }
+const styleId_ZLcYQx: any = { fontFamily: "Arial", fontSize: 13, fontWeight: "bold", fontStyle: "normal", letterSpacing: 0, color: LibStyle.colorBlue }
+const styleId_ZdXNyQ: any = { fontFamily: "Arial", fontSize: 11, fontWeight: "normal", fontStyle: "normal", letterSpacing: 0, color: "#9b9b9b", marginTop: 3 }

package/modules/user/login.tsx

@@ -0,0 +1,346 @@
+// withHooks
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { BboConfigProperty } from 'esoftplay/cache/bbo/config/import';
+import { BigbangIndexProperty } from 'esoftplay/cache/bigbang/index/import';
+import { ComponentButton } from 'esoftplay/cache/component/button/import';
+import { ComponentLabel_input } from 'esoftplay/cache/component/label_input/import';
+import { ComponentSlidingup } from 'esoftplay/cache/component/slidingup/import';
+import { ComponentTouchable } from 'esoftplay/cache/component/touchable/import';
+import { LibCrypt } from 'esoftplay/cache/lib/crypt/import';
+import { LibCurl } from 'esoftplay/cache/lib/curl/import';
+import { LibDialog } from 'esoftplay/cache/lib/dialog/import';
+import { LibIcon } from 'esoftplay/cache/lib/icon/import';
+import { LibInput_circle } from 'esoftplay/cache/lib/input_circle/import';
+import { LibInput_circle2 } from 'esoftplay/cache/lib/input_circle2/import';
+import { LibKeyboard_avoid } from 'esoftplay/cache/lib/keyboard_avoid/import';
+import { LibLogin } from 'esoftplay/cache/lib/login/import';
+import { LibNavigation } from 'esoftplay/cache/lib/navigation/import';
+import { LibNotification } from 'esoftplay/cache/lib/notification/import';
+import { LibPicture } from 'esoftplay/cache/lib/picture/import';
+import { LibProgress } from 'esoftplay/cache/lib/progress/import';
+import { LibStyle } from 'esoftplay/cache/lib/style/import';
+import { LibTextstyle } from 'esoftplay/cache/lib/textstyle/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 { UserProfileProperty } from 'esoftplay/cache/user/profile/import';
+import { UserReminderProperty } from 'esoftplay/cache/user/reminder/import';
+import esp from 'esoftplay/esp';
+import useSafeState from 'esoftplay/state';
+import * as AppleAuthentication from 'expo-apple-authentication';
+import Constants from 'expo-constants';
+import React, { useEffect } from 'react';
+import { ImageBackground, Platform, Pressable, ScrollView, Text, TouchableOpacity, View } from 'react-native';
+
+export interface UserLoginProps {
+  navigation: any
+}
+
+export function forgetPassword(email: string): void {
+  let post = {
+    email: email,
+  }
+  LibProgress.show(esp.lang("user/login", "msg_wait"))
+  new LibCurl('user_password_forget', post,
+    (res, msg) => {
+      LibProgress.hide();
+      LibDialog.info(esp.lang("user/login", "title_success_forgot_password"), String(res));
+    }, (error) => {
+      LibProgress.hide();
+      LibDialog.warning(esp.lang("user/login", "forget_err"), error?.message);
+    })
+}
+
+
+export default function m(props: UserLoginProps): any {
+  let inputUsername = React.useRef<LibInput_circle>(null)
+  let inputPassword = React.useRef<LibInput_circle>(null)
+  let inputEmail = React.useRef<LibInput_circle2>(null)
+  const [bigbangConfig] = BboConfigProperty.state().useState()
+  const [showPass, setShowPass] = useSafeState<boolean>(true)
+
+  let dialogForgetPassword = React.useRef<ComponentSlidingup>(null)
+
+  useEffect(() => {
+    BboConfigProperty.curlConfig('v2/config_form')
+    const user = UserClass.state()?.get()?.id
+    if (user) {
+      LibNavigation.back()
+    }
+    if (bigbangConfig?.form?.login?.length == 0) {
+      LibDialog.failed(esp.lang("user/login", "info"), bigbangConfig?.form?.login_message)
+    }
+    UserClass.delete()
+  }, [])
+
+  function extractEmailFromToken(identityToken: string) {
+    const tokenParts = identityToken.split('.');
+    if (tokenParts.length !== 3) {
+      throw new Error('Invalid JWT format');
+    }
+    const payload = decodeBase64Url(tokenParts[1]);
+    const parsedPayload = JSON.parse(payload);
+
+    function decodeBase64Url(base64Url: string) {
+      const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+      const decoded = atob(base64);
+      return decodeURIComponent(
+        Array.prototype.map
+          .call(decoded, c => `%${('00' + c.charCodeAt(0).toString(16)).slice(-2)}`)
+          .join('')
+      );
+    }
+    return parsedPayload.email || null; // Return email if present
+  }
+
+  function doLogin(username?: string, password?: string, email?: string, googleToken?: string, apple_token?: string): void {
+    setTimeout(async () => {
+
+      const token = await AsyncStorage.getItem('token')
+      if (!email && inputUsername.current!.getText() == "") {
+        // LibToastProperty.show("Username wajib diisi.")
+        LibDialog.warning(esp.lang("user/login", "title_alert_failed"), esp.lang("user/login", "alert_error_input_email"))
+        inputUsername.current!.focus()
+        return
+      }
+      if (!email && inputPassword.current!.getText() == "") {
+        // LibToastProperty.show("Password wajib diisi.")
+        LibDialog.warning(esp.lang("user/login", "title_alert_failed"), esp.lang("user/login", "alert_error_input_password"))
+        inputPassword.current!.focus()
+        return
+      }
+      LibProgress.show(esp.lang("user/login", "msg_wait"))
+      let post: any = {}
+      if (username && password) {
+        post = {
+          username: new LibCrypt().encode(username),
+          password: new LibCrypt().encode(password),
+        }
+      } else if (email && email != "") {
+        post = {
+          email: new LibCrypt().encode(email.trim())
+        }
+      }
+      if (googleToken && googleToken != "") {
+        post = {
+          ...post,
+          google_token: googleToken
+        }
+      }
+      if (apple_token) {
+        post['apple_token'] = apple_token
+      }
+      const ids = [
+        "cf889c0fcad23690",
+        "a901c58e-22ce-4007-bb55-59202f2f69e1",
+        "08cd4ba5-b429-4e5c-b091-0c2f5ef0b646",
+        "0f842adf-dea8-4248-a6ab-5d2fbf785fac",
+        "7b234c39-0ab6-4cb0-8ce0-10299805e643",
+        "b709df3e-412d-47a4-bed1-e76b0c344740",
+        "f74e8203-145f-4697-91b4-75c543786234",
+        "cafc440f22b832fc",
+        "669050c545a61028",
+        "aea2cd08feb2e007"
+      ]
+      post = {
+        ...post,
+        device_name: Constants.deviceName,
+        installation_id: await LibUtils.getInstallationID(),
+        token: token,
+        device_os: Platform.OS.toUpperCase(),
+        os_version: Platform.Version,
+        is_expo: ids.includes(await LibUtils.getInstallationID()) ? 1 : 0,
+        version: esp.versionName()
+      }
+      if (post.hasOwnProperty("email") || post.hasOwnProperty("username") || post.hasOwnProperty("password")) {
+        LibProgress.show(esp.lang("user/login", "msg_wait"))
+        new LibCurl('user_login', post,
+          (res, msg) => {
+            UserClass.create(res).then(() => {
+              const ChattingLib = esp.mod('chatting/lib')
+              ChattingLib().setUser(res.name, res.image, false)
+              LibProgress.hide()
+              UserReminderProperty?.setReminder?.()
+              LibNotification.drop()
+              LibNavigation.reset()
+              BigbangIndexProperty.setTab(0)
+            })
+            UserProfileProperty.pushToken()
+          },
+          (error) => {
+            LibProgress.hide()
+            LibDialog.warning(esp.lang("user/login", "login_err"), error?.message)
+          }, 1)
+      } else {
+        LibProgress.hide()
+      }
+    })
+  }
+
+  return (
+    <View style={{ flex: 1 }}>
+      <ImageBackground source={esp.assets('background/bg_register.png')} style={{ flex: 1, paddingTop: LibStyle.STATUSBAR_HEIGHT }} resizeMode={'cover'} >
+        <LibKeyboard_avoid style={{ flex: 1 }}>
+          <ScrollView showsVerticalScrollIndicator={false}  >
+            <LibPicture source={esp.assets('background/logo_bbo.png')} style={{ width: LibStyle.width / 2, height: LibStyle.width / 3, alignSelf: 'center', marginTop: 60 }} />
+            <View style={{ margin: 20, marginTop: 40 }}>
+              <Text allowFontScaling={false} style={{ fontSize: 16, fontWeight: 'bold', textAlign: "center", color: "#70472b", marginBottom: 15 }} >{esp.lang("user/login", "login_your_account")}</Text>
+              {(bigbangConfig?.form?.login?.includes?.(1)) &&
+                <>
+                  <LibInput_circle
+                    ref={inputUsername}
+                    icon={'icons/ic_login_email.png'}
+                    placeholder={esp.lang("user/login", "placeholder_input_email")}
+                    keyboardType="email-address"
+                    autoCapitalize="none"
+                    returnKeyType="next"
+                    onSubmitEditing={() => inputPassword.current!.focus()} />
+                  <View style={{ flexDirection: 'row', marginBottom: 10 }}>
+                    <LibInput_circle
+                      ref={inputPassword}
+                      style={{ flex: 1 }}
+                      icon={'icons/ic_login_pass.png'}
+                      placeholder={esp.lang("user/login", "placeholder_input_password")}
+                      returnKeyType="done"
+                      onSubmitEditing={() => doLogin(inputUsername.current!.getText(), inputPassword.current!.getText())}
+                      secureTextEntry={showPass} />
+                    <TouchableOpacity style={{ position: 'absolute', top: 25, right: 10 }} onPress={() => {
+                      setShowPass(showPass == true ? false : true)
+                    }}>
+                      <LibIcon name={showPass == true ? "eye" : "eye-off"} />
+                    </TouchableOpacity>
+                  </View>
+
+                  <ComponentButton icon={'icons/ic_login_submit.png'} label={esp.lang("user/login", "btn_login")} style={{ marginTop: 15 }} onPress={() => doLogin(inputUsername.current!.getText(), inputPassword.current!.getText())} />
+                  <View style={{ flexDirection: 'row-reverse', marginTop: 10 }} >
+                    <ComponentTouchable onPress={() => { dialogForgetPassword?.current?.show?.() }} >
+                      <Text allowFontScaling={false} style={{ fontFamily: "ArialBold", fontSize: 12, textAlign: "center", color: "#c5906c" }} >{esp.lang("user/login", "forget_password")}</Text>
+                    </ComponentTouchable>
+                  </View>
+                </>}
+              <View style={{ flexDirection: 'row', marginTop: 20, justifyContent: 'center' }} >
+                <Text allowFontScaling={false} style={{ fontFamily: "Arial", fontSize: 12, textAlign: "center", color: "#c5906c" }} >{esp.lang("user/login", "dont_have_account")}</Text>
+                <ComponentTouchable onPress={() => {
+                  LibNavigation.navigate('user/register_email')
+                }} >
+                  <Text allowFontScaling={false} style={{ fontFamily: "ArialBold", fontSize: 12, textAlign: "center", color: LibStyle.colorRed }} >{esp.lang("user/login", "register_here")}</Text>
+                </ComponentTouchable>
+              </View>
+              {
+                esp.config().showLoginWith && (bigbangConfig?.form?.login?.includes?.(2)) && <>
+                  <View>
+                    <Text allowFontScaling={false} style={{ fontFamily: "Arial", fontSize: 12, textAlign: "center", marginTop: 20, color: "#70472b" }} >{esp.lang("user/login", "login_with")}</Text>
+                    <View style={{ alignItems: "center", flexDirection: 'row', marginHorizontal: 80, justifyContent: 'space-evenly', marginVertical: 10 }} >
+                      <ComponentTouchable onPress={() => LibLogin.google().then((res) => {
+                        doLogin(undefined, undefined, res?.email, res?.token)
+                      })} >
+                        <LibPicture style={{ height: 48, width: 48, resizeMode: 'contain' }} source={esp.assets('icons/group_2.png')} />
+                      </ComponentTouchable>
+                    </View>
+                    {
+                      Platform.OS == 'ios' && Platform.Version >= '13.0' &&
+                      <AppleAuthentication.AppleAuthenticationButton
+                        buttonType={AppleAuthentication.AppleAuthenticationButtonType.SIGN_IN}
+                        buttonStyle={AppleAuthentication.AppleAuthenticationButtonStyle.WHITE_OUTLINE}
+                        cornerRadius={5}
+                        style={{ width: 200, height: 44, marginBottom: 20, alignSelf: 'center' }}
+                        onPress={async () => {
+                          try {
+                            const credential = await AppleAuthentication.signInAsync({
+                              requestedScopes: [
+                                AppleAuthentication.AppleAuthenticationScope.FULL_NAME,
+                                AppleAuthentication.AppleAuthenticationScope.EMAIL
+                              ],
+                            });
+                            console.log(JSON.stringify(credential));
+                            let email = credential.email || extractEmailFromToken(credential.identityToken)
+                            if (email) {
+                              doLogin(undefined, undefined, email, undefined, credential.authorizationCode || '')
+                            } else {
+                              LibToastProperty.show(esp.lang("user/login", "email_not_found"))
+                            }
+                          } catch (e: any) {
+                            if (e.code === 'ERR_CANCELED') {
+                              LibToastProperty.show(esp.lang("user/login", "auth_canceled"))
+                            } else {
+                              LibToastProperty.show(esp.lang("user/login", "error_try_again_later"))
+                            }
+                          }
+                        }}
+                      />
+                    }
+                  </View>
+                </>
+              }
+              <Pressable onPress={() => {
+                if (!__DEV__) {
+                  LibProgress.show(esp.lang("user/login", "check_update"))
+                }
+                let timeout: any = setTimeout(() => {
+                  LibProgress.hide()
+                }, 100000)
+
+                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("user/login", "app_new"))
+                  }
+                })
+              }} style={{ marginTop: 20 }}>
+                <LibTextstyle
+                  style={{ textAlign: 'center', color: "#999", marginBottom: 15 }}
+                  textStyle='caption2' text={esp.appjson().expo.name + ' v' + esp.versionName()} />
+              </Pressable>
+            </View>
+          </ScrollView>
+          <Pressable
+            onPress={() => LibNavigation.back()}
+            style={{ position: 'absolute', marginTop: 16, marginLeft: 16, flexDirection: 'row', alignItems: 'center' }} >
+            <LibIcon.SimpleLineIcons name='arrow-left' />
+            <Text style={{ marginLeft: 5 }} >{esp.lang("user/login", "back")}</Text>
+          </Pressable>
+        </LibKeyboard_avoid>
+        {
+          esp.isDebug("") &&
+          <TouchableOpacity onPress={() => LibNavigation.navigate('bigbang/faq')}>
+            <Text allowFontScaling={false}
+              style={{ textAlign: 'center', color: LibStyle.colorBlue, marginBottom: 15, fontWeight: 'bold', fontSize: 16, }} >{esp.lang("user/login", "need_help")}</Text>
+          </TouchableOpacity>
+        }
+      </ImageBackground>
+      <ComponentSlidingup ref={dialogForgetPassword}>
+        <View style={{ backgroundColor: 'white', borderTopRightRadius: 20, borderTopLeftRadius: 20, paddingTop: 23, paddingBottom: 17, paddingHorizontal: 19, height: 170 }}>
+          <ComponentLabel_input label={esp.lang("user/login", "label_input_email")} mandatory mandatoryColor={'#d0021b'} />
+          <LibInput_circle2
+            autoFocus
+            ref={inputEmail}
+            style={{ borderColor: '#c4c4c4', height: 35, marginTop: 8 }}
+            placeholder={esp.lang("user/login", "placeholder_input_email_forgot_password")}
+          />
+          <ComponentButton label={esp.lang("user/login", "send_email_recovery")} style={{ marginTop: 20 }} onPress={() => {
+            if (inputEmail?.current?.getText?.() && inputEmail?.current?.getText?.() !== '') {
+              dialogForgetPassword?.current?.hide?.()
+              forgetPassword(inputEmail?.current?.getText?.()?.trim?.())
+            } else {
+              LibProgress.hide();
+              LibDialog.warning(esp.lang("user/login", "empty_email"), esp.lang("user/login", "empty_email1"));
+            }
+          }} />
+        </View>
+      </ComponentSlidingup>
+    </View >
+  )
+}