identi-recognition
Version:
identiRecognition
442 lines (400 loc) • 17.2 kB
JavaScript
// 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 { isAxiosError, requestGetCall, requestCallBase } = require('../utils/requestCall')
const { handleHttpError, throwCustomError, validateTerminalResponse, hfSecHerror } = require('../utils/errorHandler')
const TerminalUser = require('./terminalUsers')
const CODES = require('../utils/codes')
const HEADER_CONFIG = { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }
class RA08 {
constructor(ip, password, _versionPro = false) {
try {
if (!validateIPaddress(ip)) throw new Error('Invalid ip received', { ...CODES.HFS002 })
if (!password) throw new Error('Password parameter not received', { ...CODES.HFS002 })
this.ip = ip
this.password = password
this.baseUrl = `http://${ip}:8090`
this.deviceKey = ''
this.preparedReport
this.user = new TerminalUser(this)
} catch (error) {
throw new hfSecHerror(error)
}
}
async getStatus() {
try {
const currUrl = config.endpoints.terminal.getDeviceKey
const response = await requestCallBase(this.baseUrl, currUrl, 'POST', null, HEADER_CONFIG)
this.deviceKey = response.data.data
return response.data.msg
} catch (error) {
if (isAxiosError)
throw new hfSecHerror(error) // Usamos el manejador de errores HTTP
else {
const errorMessage = `[${arguments.callee.name}] RA08 Device not responding`
throw new hfSecHerror({ message: errorMessage, ...CODES.HFS004, baseError: error?.message })
}
}
}
async setCallbacks(endpointCallback) {
try {
const currUrl = config.endpoints.terminal.setCallback
const request_body = qs.stringify({
pass: this.password,
callbackUrl: endpointCallback
})
const requestResponse = await requestCallBase(this.baseUrl, currUrl, 'POST', request_body, HEADER_CONFIG)
await validateTerminalResponse(requestResponse)
return { ...CODES.HFS001, message: { messageResult: requestResponse?.data?.msg } }
} catch (error) {
if (isAxiosError)
throw new hfSecHerror(error) // Usamos el manejador de errores HTTP
else if (error instanceof hfSecHerror) {
throw error
}
throw new hfSecHerror({
message: `XCORE Device [setCallbacks] error`,
...CODES.HFS004,
baseError: error?.message
})
}
}
async showMessage(message = 'Hola Mundo', speak = true) {
try {
const requestBody = qs.stringify({ pass: this.password, content: message, speak: speak })
const currUrl = config.endpoints.terminal.showMessage
const requestResponse = await requestCallBase(this.baseUrl, currUrl, 'POST', requestBody, HEADER_CONFIG)
await validateTerminalResponse(requestResponse)
return requestResponse.date
} catch (error) {
if (error instanceof hfSecHerror) {
throw error
}
throw new hfSecHerror({ message: `RA08 Unknown Device With Errors`, ...CODES.HFS004, baseError: error?.message })
}
}
async deleteAllRecords(simetricalMonths = 1) {
try {
const requestBody = qs.stringify({
pass: this.password,
personId: -1,
startTime: myUtils.format_time(new Date(), -(simetricalMonths * 30 * 24 * 3600 * 1000)), // 1 Mes en el pasado
endTime: myUtils.format_time(new Date(), simetricalMonths * 30 * 24 * 3600 * 1000), // 1 Mes en el futuro
model: -1
})
const currUrl = config.endpoints.terminal.deleteAllRecords
const requestResponse = await requestCallBase(this.baseUrl, currUrl, 'POST', requestBody, HEADER_CONFIG)
await validateTerminalResponse(requestResponse)
return { ...CODES.HFS001, message: { bodyResponse: requestResponse?.data?.data } }
} catch (error) {
if (error instanceof hfSecHerror) {
throw error
}
const errorMessage = `[deleteAllRecords] RA08 Device not responding`
throw new hfSecHerror({ message: errorMessage, ...CODES.HFS004, baseError: error?.message })
}
}
// ----------------------------------------------------------------
// ----------------------------------------------------------------
// ----------------------------------------------------------------
// __ __ _ _
// | \/ |__ _ _ _ __ _ __ _ ___ | | | |___ ___ _ _ ___
// | |\/| / _` | ' \/ _` / _` / -_) | |_| (_-</ -_) '_(_-<
// |_| |_\__,_|_||_\__,_\__, \___| \___//__/\___|_| /__/
// |___/
// ----------------------------------------------------------------
// ----------------------------------------------------------------
// ----------------------------------------------------------------
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 updateUser(userId, newUserName) {
try {
if (!userId) {
return { ...CODES.HFS002, message: { error: '[updateUser] userId parameter missing' } }
}
const jsonPerson = {
id: userId,
name: newUserName
}
const requestBody = qs.stringify({ pass: this.password, person: JSON.stringify(jsonPerson) })
const currUrl = config.endpoints.terminal.updateUser
const requestResponse = await requestCallBase(this.baseUrl, currUrl, 'POST', requestBody, HEADER_CONFIG)
await validateTerminalResponse(requestResponse)
return { ...CODES.HFS001, message: { message: 'User Updated Succesfully', result: requestResponse?.data?.msg } }
} catch (error) {
if (error instanceof hfSecHerror) {
throw error
}
const errorMessage = `[updateUser] RA08 Device unknown error`
throw new hfSecHerror({ message: errorMessage, ...CODES.HFS004, baseError: error?.message })
}
}
async enrollUser(userId, userName) {
try {
if (!userId || !userName) {
return { ...CODES.HFS002, message: { error: '[enrollUser] userId or userName parameter missing' } }
}
const jsonPerson = { id: userId, name: userName }
const requestBody = qs.stringify({ pass: this.password, person: JSON.stringify(jsonPerson) })
const currUrl = config.endpoints.terminal.enrollUser
const requestResponse = await requestCallBase(this.baseUrl, currUrl, 'POST', requestBody, HEADER_CONFIG)
await validateTerminalResponse(requestResponse)
if (requestResponse?.data?.data.id === 'personId already exists') {
const errorMessage = `[enrollUser] Terminal error: id already exists in terminal`
throw new hfSecHerror({ message: errorMessage, ...CODES.HFS004, baseErrorCode: requestResponse?.data?.code })
}
return { ...CODES.HFS001, message: { bodyResponse: requestResponse?.data?.data } }
} catch (error) {
if (error instanceof hfSecHerror) {
throw error
}
const errorMessage = `[enrollUser] RA08 Device unknown error`
throw new hfSecHerror({ message: errorMessage, ...CODES.HFS004, baseError: error?.message })
}
}
async photoUpdate(idUser = null, imgBase64 = null) {
try {
if (!idUser || !imgBase64) {
throw new hfSecHerror({
message: `[photoUpdate] idUser or imgBase64 parameter not recived`,
...CODES.HFS002
})
}
const requestBody = qs.stringify({
pass: this.password,
personId: idUser,
faceId: -1,
imgBase64: imgBase64
})
const currUrl = config.endpoints.terminal.photoUpdate
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 = `[photoUpdate] RA08 Unkown Device error`
throw new hfSecHerror({ message: errorMessage, ...CODES.HFS004, baseError: error?.message })
}
}
async _photo_create(idUser = null, img_base64 = null, dev_ip = null) {
return new Promise((resolve, reject) => {
try {
if (!dev_ip || !idUser || !img_base64) {
return reject('_photo_create MISING INFORMAITON')
}
const request_body = qs.stringify({ pass: this.password, personId: idUser, imgBase64: img_base64 })
const url = `http://${dev_ip}:8090/face/create`
return axios
.post(url, request_body, HEADER_CONFIG)
.then((response) => {
if (response.data.msg.includes('baja calidad')) {
console.error('BAJA CALIDAD DE FOTO A SUBIR ')
return reject('Calidad Foto')
}
return resolve(validateTerminalResponse(response))
})
.catch((error) => {
return reject('_photo_create ERR-AXIOS: ' + error)
})
} catch (error) {
return reject('_photo_create ERR-AXIOS: ' + error)
}
})
}
async _logo_update(logoB64 = null) {
try {
if (!logoB64) {
return { ...CODES.HFS002, message: { error: '[_logo_update] logoB64 parameter missing' } }
}
const requestBody = qs.stringify({ pass: this.password, imgBase64: logoB64 })
const currUrl = config.endpoints.terminal.updateLogo
const requestResponse = await requestCallBase(this.baseUrl, currUrl, 'POST', requestBody, HEADER_CONFIG)
await validateTerminalResponse(requestResponse)
return { ...CODES.HFS001, message: { message: 'Logo Updated Succesfully', result: requestResponse?.data?.msg } }
} catch (error) {
if (error instanceof hfSecHerror) {
throw error
}
const errorMessage = `[_logo_update] RA08 Device unknown error`
throw new hfSecHerror({ message: errorMessage, ...CODES.HFS004, baseError: error?.message })
}
}
async photoTaking(userId = null) {
try {
if (!userId) {
throw new hfSecHerror({
message: `[_photoTaking] userId parameter not recived`,
...CODES.HFS002
})
}
const requestBody = qs.stringify({ pass: this.password, personId: userId })
const currUrl = config.endpoints.terminal.takeImg
const requestResponse = await requestCallBase(this.baseUrl, currUrl, 'POST', requestBody, HEADER_CONFIG)
await validateTerminalResponse(requestResponse)
return {
...CODES.HFS001,
message: { message: 'Proccess Started, get close to the terminal', result: requestResponse?.data?.msg }
}
} catch (error) {
if (error instanceof hfSecHerror) {
throw error
}
const errorMessage = `[_photoTaking] RA08 Device unknown error`
throw new hfSecHerror({ message: errorMessage, ...CODES.HFS004, baseError: error?.message })
}
}
async openDoor() {
try {
const requestBody = qs.stringify({ pass: this.password, type: 1, content: 1 })
const currUrl = config.endpoints.terminal.openDoor
const requestResponse = await requestCallBase(this.baseUrl, currUrl, 'POST', requestBody, HEADER_CONFIG)
console.log(requestResponse)
return requestResponse.data
return validateTerminalResponse(requestResponse, currentFunction)
} catch (error) {
if (error instanceof hfSecHerror) {
throw error
}
const errorMessage = `[${arguments.callee.name}] RA08 Device not responding`
throw new hfSecHerror({ message: errorMessage, ...CODES.HFS004, baseError: error?.message })
}
}
async restartTerminal(dev_ip = None) {
try {
if (!dev_ip) {
console.error('No device Passed to restart_terminal ')
return false
}
const request_body = qs.stringify({ pass: this.password })
const url = `http://${dev_ip}:8090/restartDevice`
axios
.post(url, request_body, HEADER_CONFIG)
.then((response) => {
return validateTerminalResponse(response)
})
.catch((error) => {
return 'restart_terminal ERR-AXIOS: ' + error
})
} catch (error) {
if (error instanceof hfSecHerror) {
throw error
}
const errorMessage = `[${arguments.callee.name}] RA08 Device not responding`
throw new hfSecHerror({ message: errorMessage, ...CODES.HFS004, baseError: error?.message })
}
}
async __setCallback(terminal_ip, dev_port = 8090) {
return new Promise((resolve, reject) => {
try {
const request_body = qs.stringify({
pass: this.password,
callbackUrl: `http://${server_ip}:${config.server.http.port}/IdentiCallback`
})
const url = `http://${terminal_ip}:${dev_port}/http://192.168.1.31:5000/api/identified`
return axios
.post(url, request_body, HEADER_CONFIG)
.then((response) => {
return resolve(validateTerminalResponse(response))
})
.catch((error) => {
return reject('__setCallback AXIOS-ERR: ' + error)
})
} catch (err) {
if (error instanceof hfSecHerror) {
throw error
}
const errorMessage = `[${arguments.callee.name}] RA08 Device not responding`
throw new hfSecHerror({ message: errorMessage, ...CODES.HFS004, baseError: error?.message })
}
})
}
async findByPage(personId, length, index = 0) {
try {
const jsonPerson = {
pass: this.password,
personId: personId,
length: length,
index: index
}
const requestBody = qs.stringify(jsonPerson)
const currUrl = config.endpoints.terminal.findByPage
const requestResponse = await requestCallBase(this.baseUrl, currUrl, 'POST', requestBody, HEADER_CONFIG)
if (requestResponse?.data?.code !== '000') {
const errorMessage = `[${arguments.callee.name}] RA08 error ${requestResponse.data.code}`
throw new hfSecHerror({ message: errorMessage, ...CODES.HFS004, baseErrorCode: requestResponse?.data?.code })
}
if (requestResponse?.data?.msg !== 'success') {
const errorMessage = `[${arguments.callee.name}] Terminal error: ${requestResponse?.data?.msg}`
throw new hfSecHerror({ message: errorMessage, ...CODES.HFS004, baseErrorCode: requestResponse?.data?.code })
}
return requestResponse?.data?.data
} catch (error) {
if (error instanceof hfSecHerror) {
throw error
}
const errorMessage = `[${arguments.callee.name}] RA08 Device not responding`
throw new hfSecHerror({ message: errorMessage, ...CODES.HFS004, baseError: error?.message })
}
}
async downloadImages(folderPath = '') {
try {
if (!folderPath || !fs.existsSync(folderPath)) {
const errorMessage = `FolderPath empty or doesnt exists.`
throw new hfSecHerror({ message: errorMessage, ...CODES.HFS002 })
}
const getAllUsers = await this.findByPage(-1, 1, 0)
let usersWithErrors = []
for (let i = 0; i < getAllUsers.pageInfo.total; i++) {
console.log(`Downloading ... (${i}/${getAllUsers.pageInfo.total})`)
const currUser = await this.findByPage(-1, 1, i)
const currUserId = currUser.records[0].id
const currUserName = currUser.records[0].name
const currUserFace = await this.User.getFace(currUserId)
const currUserB64 = currUserFace?.data[0]?.imgBase64
const currUserPath = `${folderPath}/${currUserId}_${currUserName}.jpg`
if (!currUserB64) {
usersWithErrors.push({ id: currUserId, name: currUserName })
console.error(`User ${currUserId} without Image`)
continue
}
fs.writeFileSync(currUserPath, currUserFace?.data[0]?.imgBase64, 'base64')
}
return {
totalUser: getAllUsers.pageInfo.total,
imagesDownloaded: getAllUsers.pageInfo.total - usersWithErrors.length,
userWithErrors: usersWithErrors
}
} catch (error) {
console.error(error)
if (error instanceof hfSecHerror) {
throw error
}
const errorMessage = `[${arguments.callee.name}] RA08 Device not responding`
throw new hfSecHerror({ message: errorMessage, ...CODES.HFS004, baseError: error?.message })
}
}
}
module.exports = RA08