identi-recognition/src/devices/terminalUsers.js

identiRecognition

// src/devices/xcore.js
// --- DEPENDENCIES ---
const fs = require('fs')
const qs = require('qs')
const FormData = require('form-data')
// --- IMPORTS ---
const config = require('../config')
const { validateIPaddress, isValidDate } = require('../utils/utils')
const { requestGetCall, requestCallBase } = require('../utils/requestCall')
const { handleHttpError, throwCustomError, validateTerminalResponse, hfSecHerror } = require('../utils/errorHandler')
const CODES = require('../utils/codes')
const Terminal = require('./terminal')

const HEADER_CONFIG = { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }

class TerminalUser {
  constructor(parent) {
    try {
      this.parent = parent
      this.baseUrl = parent.baseUrl
      this.password = parent.password
      this.ip = parent.ip
    } catch (error) {
      throw new hfSecHerror(error)
    }
  }

  async getUserPhoto(userId) {
    try {
      if (!userId) {
        return { ...CODES.HFS002, message: { error: '[getUserPhoto] userId parameter missing' } }
      }

      const requestBody = qs.stringify({ pass: this.password, personId: userId })
      const currUrl = config.endpoints.terminal.user.getPhoto
      const requestResponse = await requestCallBase(this.baseUrl, currUrl, 'POST', requestBody, HEADER_CONFIG)
      await validateTerminalResponse(requestResponse)

      return { ...CODES.HFS001, message: { message: 'User Consulted Correct', result: requestResponse?.data } }
    } catch (error) {
      if (error instanceof hfSecHerror) {
        throw error
      }
      const errorMessage = `[getUserPhoto] RA08 Device unknown error`
      throw new hfSecHerror({ message: errorMessage, ...CODES.HFS004, baseError: error?.message })
    }
  }

  async matchFaceById(userId, base64Image) {
    try {
      const imageUser = await this.getUserPhoto(userId)
      if (!imageUser?.message?.result) {
        throw new hfSecHerror({
          ...CODES.HFS003,
          message: 'userId doesnt contain face',
          baseError: { error: '[matchFaceById] userId doesnt Exist' }
        })
      }

      const secondFaceUpload = await this.createUserPhoto(`${userId}p2`, base64Image)

      if (secondFaceUpload.data.code == '2000') {
        if (secondFaceUpload.data.msg.includes(userId) && secondFaceUpload.data.msg.includes('用户已存在')) {
          return true
        } else {
          currMsg = secondFaceUpload?.data?.msg
          currMsg = currMsg ? currMsg.replace(`${userId}p2`, `${userId}`) : 'Unknown image2_b64 validation error'
          return `ERROR image2_b64 : ${currMsg} `
        }
      } else {
        console.error(`Unkown error on image2_b64: ${JSON.stringify(secondFaceUpload)}`)
        return `Unkown Error on image2_b64, try again later`
      }
    } catch (error) {
      console.error(error)
      if (error instanceof hfSecHerror) {
        throw error
      }
      const errorMessage = `[matchFaceById] RA08 Device unknown error`
      throw new hfSecHerror({ message: errorMessage, ...CODES.HFS004, baseError: error?.message })
    } finally {
      await this.deleteUser(`${userId}p2`)
    }
  }

  async deleteUser(userId = null) {
    try {
      if (!userId) {
        return { ...CODES.HFS002, message: { error: 'userId parameter missing' } }
      }
      const requestBody = qs.stringify({ pass: this.password, id: userId })
      const currUrl = config.endpoints.terminal.deleteUser
      const requestResponse = await requestCallBase(this.baseUrl, currUrl, 'POST', requestBody, HEADER_CONFIG)
      await validateTerminalResponse(requestResponse)
      return { ...CODES.HFS001, message: { ...requestResponse?.data?.msg } }
    } catch (error) {
      if (error instanceof hfSecHerror) {
        throw error
      }
      const errorMessage = `[deleteUser] RA08 Device not responding`
      throw new hfSecHerror({ message: errorMessage, ...CODES.HFS005, baseError: error?.message })
    }
  }

  async createUserPhoto(userId, base64Image) {
    try {
      if (!userId || !base64Image) {
        throw new hfSecHerror({
          message: `[createUserPhoto] userId or base64Image parameter not recived`,
          ...CODES.HFS002
        })
      }
      const requestBody = qs.stringify({
        pass: this.password,
        personId: userId,
        imgBase64: base64Image
      })

      const currUrl = config.endpoints.terminal.user.enrollUserPhoto
      const requestResponse = await requestCallBase(this.baseUrl, currUrl, 'POST', requestBody, HEADER_CONFIG)

      await validateTerminalResponse(requestResponse)

      return requestResponse.data
    } catch (error) {
      if (error instanceof hfSecHerror) {
        throw error
      }
      const errorMessage = `[createUserPhoto] RA08 Unkown Device error`
      throw new hfSecHerror({ message: errorMessage, ...CODES.HFS004, baseError: error?.message })
    }
  }
}

module.exports = TerminalUser