Proyectos de Subversion LeadersLinked - SPA

import React, { useRef, useState, useEffect } from 'react'

import { Link } from 'react-router-dom'

import { useForm } from 'react-hook-form'

import { useDispatch, useSelector } from 'react-redux'

import { Mail, Lock, Person, CheckCircleOutline } from '@mui/icons-material'

import Recaptcha from 'react-recaptcha'

import styled from 'styled-components'

import { axios } from '../../utils'

import { addNotification } from '../../redux/notification/notification.actions'

import CryptoJSAesJson from '../../utils/crypto-js/cryptojs-aes-format'

import Spinner from 'components/UI/Spinner'

import AuthForm from '../../components/auth/AuthForm'

import Input from 'components/UI/form/FormInputText'

import Paraphrase from 'components/UI/Paraphrase'

import SwitchInput from 'components/UI/SwitchInput'

import Checkbox from 'components/UI/checkbox/Checkbox'

import Button from '@app/components/UI/buttons/Buttons'

const StyledCheck = styled.div`

  display: flex;

  flex-direction: column;

  justify-content: center;

  align-items: center;

  gap: 0.5rem;

  p {

    text-align: center;

  }

`

const StyledSpinnerContainer = styled.div`

  position: absolute;

  left: 0;

  top: 0;

  width: 100%;

  height: 100%;

  background: rgba(255, 255, 255, 0.4);

  display: flex;

  justify-content: center;

  align-items: center;

  z-index: 300;

`

const Signup = () => {

  const [registered, setRegistered] = useState(false)

  const [isLoading, setIsLoading] = useState(false)

  const [isAdult, setIsAdult] = useState(false)

  const [isVerified, setIsVerified] = useState(false)

  const reCaptchaInstance = useRef(null)

  const reCaptchaToken = useRef('')

  const dispatch = useDispatch()

  const { site_key, aes } = useSelector(({ auth }) => auth)

  const { control, handleSubmit, setError, errors, watch } = useForm({

    mode: 'all'

  })

  const signupVerifyCallbackHandler = (response) => {

    if (!response) return

    reCaptchaToken.current = response

    setIsVerified(true)

  }

  const signupExpiredCallbackHandler = () => {

    reCaptchaToken.current = ''

    setIsVerified(false)

  }

  const handleOnRecaptchaLoad = () => {

    reCaptchaToken.current = ''

  }

  const onSubmitHandler = handleSubmit(

    async ({

      email,

      first_name,

      last_name,

      password,

      confirmation,

      terms_and_conditions

    }) => {

      setIsLoading(true)

      const formData = new FormData()

      formData.append('first_name', first_name)

      formData.append('last_name', last_name)

      formData.append('email', CryptoJSAesJson.encrypt(email, aes))

      formData.append('password', CryptoJSAesJson.encrypt(password, aes))

      formData.append(

        'confirmation',

        CryptoJSAesJson.encrypt(confirmation, aes)

      )

      formData.append('terms_and_conditions', terms_and_conditions ? 1 : 0)

      formData.append('captcha', reCaptchaToken.current)

      formData.append('is_adult', isAdult ? 'y' : 'n')

      await axios

        .post('/signup', formData)

        .then(({ data }) => {

          if (!data.success) {

            if (typeof data.data !== 'string') {

              Object.entries(data.data).forEach(([key, value]) => {

                setError(key, {

                  type: 'manual',

                  message: Array.isArray(value) ? value[0] : value

                })

              })

              return

            }

            dispatch(addNotification({ style: 'danger', msg: data.data }))

            reCaptchaInstance.current.reset()

            signupVerifyCallbackHandler()

            return

          }

          reCaptchaInstance.current.reset()

          signupExpiredCallbackHandler()

          setRegistered(true)

        })

        .catch((err) => {

          console.log(`Error: ${err}`)

          dispatch(

            addNotification({

              style: 'danger',

              msg: 'Disculpe, ha ocurrido un error'

            })

          )

        })

        .finally(() => setIsLoading(false))

    }

  )

  useEffect(() => {

    reCaptchaInstance.current?.reset()

  }, [])

  if (registered) {

    return (

      <StyledCheck>

        <CheckCircleOutline sx={{ color: '#7FFF00', fontSize: '3rem' }} />

        <Paraphrase>

          Se ha registrado correctamente. Por favor, active la cuenta desde su

          correo

        </Paraphrase>

        <Link to='/signin'>

          <button className='btn btn-primary'>Entrar</button>

        </Link>

      </StyledCheck>

    )

  }

  return (

    <AuthForm onSubmit={onSubmitHandler}>

      <h3>Registrarse</h3>

      <Input

        type='email'

        name='email'

        placeholder='Correo electrónico'

        icon={Mail}

        control={control}

        rules={{

          required: 'Este campo es requerido',

          pattern: {

            value: /^[\w-.]+@([\w-]+\.)+[\w-]{2,4}$/i,

            message: 'Debe ser una dirección de correo electrónico valida'

          }

        }}

        error={errors.email?.message}

      />

      <Input

        type='text'

        name='first_name'

        icon={Person}

        placeholder='Nombre'

        control={control}

        rules={{

          required: 'Este campo es requerido',

          maxLength: {

            value: 64,

            message: 'Limite de carateres superior al permitido'

          }

        }}

        error={errors.first_name?.message}

      />

      <Input

        type='text'

        name='last_name'

        icon={Person}

        placeholder='Apellido'

        control={control}

        rules={{

          required: 'Este campo es requerido',

          maxLength: {

            value: 64,

            message: 'Limite de carateres superior al permitido'

          }

        }}

        error={errors.last_name?.message}

      />

      <Input

        type='password'

        name='password'

        icon={Lock}

        placeholder='Clave'

        control={control}

        rules={{

          required: 'Este campo es requerido',

          pattern: {

            value:

              /^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9])(?=.*?[#?!@$^x%x*-]).{6,16}$/i,

            message:

              'Debe contener entre 6 y 16 caracteres, incluida una letra mayúscula, un número y un carácter especial #?!@$^%*-'

          }

        }}

        error={errors.password?.message}

      />

      <Input

        type='password'

        name='confirmation'

        icon={Lock}

        placeholder='Confirme su clave'

        control={control}

        rules={{

          required: 'Este campo es requerido',

          validate: (v) =>

            v === watch('password') ||

            'Disculpe, las claves tienen que coincidir'

        }}

        error={errors.confirmation?.message}

      />

      <SwitchInput

        label='Eres mayor de 18'

        setValue={(value) => setIsAdult(value)}

      />

      <Checkbox

        name='terms_and_conditions'

        control={control}

        label='Si, acepto los Términos y Condiciones.'

        rules={{

          required: 'Este campo es requerido'

        }}

        error={errors.terms_and_conditions?.message}

      />

      <Recaptcha

        sitekey={site_key}

        verifyCallback={signupVerifyCallbackHandler}

        verifyCallbackName='signupVerifyCallbackHandler'

        expiredCallback={signupExpiredCallbackHandler}

        expiredCallbackName='signupExpiredCallbackHandler'

        ref={reCaptchaInstance}

        render='explicit'

        onloadCallback={handleOnRecaptchaLoad}

        hl='es'

      />

      <div className='links'>

        <Link to='/signin'>¿Ya tienes cuenta?</Link>

      </div>

      <Button variant='secondary' type='submit' disabled={!isVerified}>

        Registrarse

      </Button>

      {isLoading && (

        <StyledSpinnerContainer>

          <Spinner />

        </StyledSpinnerContainer>

      )}

    </AuthForm>

  )

}

export default Signup