212 lines
7 KiB
TypeScript
212 lines
7 KiB
TypeScript
import { Injectable } from '@nestjs/common';
|
|
import { InjectRepository } from '@nestjs/typeorm';
|
|
import { Repository } from 'typeorm';
|
|
import { Dispositivo } from './entities/dispositivo.entity.js';
|
|
import { DispositivoDto, UpdateDispositivoDto } from './dto/dispositivo.dto.js';
|
|
import { defaultServiceResult, ServiceResult } from '../../common/interfaces/service.result.js';
|
|
import { WhereCondition } from '../../common/types/query-builder.types.js';
|
|
import { DISPOSITIVO_FIND_WHITELIST } from './dispositivo.constants.js';
|
|
|
|
@Injectable()
|
|
export class DispositivoService {
|
|
constructor(
|
|
@InjectRepository(Dispositivo)
|
|
private dispositivoRepository: Repository<Dispositivo>,
|
|
) {}
|
|
|
|
/**
|
|
* Registra o actualiza el token FCM de la persona logueada.
|
|
* Si el token ya existe para esa persona, se reactiva/actualiza.
|
|
*/
|
|
async register(idPersona: string, dto: DispositivoDto): Promise<ServiceResult> {
|
|
const serviceResult = defaultServiceResult();
|
|
|
|
const existing = await this.dispositivoRepository.findOneBy({
|
|
idPersona,
|
|
token: dto.token,
|
|
});
|
|
|
|
if (existing) {
|
|
const result = await this.dispositivoRepository.update(existing.idDispositivo, {
|
|
activo: dto.activo ?? true,
|
|
plataforma: dto.plataforma ?? existing.plataforma,
|
|
ultimaConexion: new Date(),
|
|
});
|
|
serviceResult.boolean = result.affected === 1;
|
|
serviceResult.message = 'Dispositivo actualizado.';
|
|
serviceResult.number = result.affected || 0;
|
|
const updated = await this.dispositivoRepository.findOneBy({
|
|
idDispositivo: existing.idDispositivo,
|
|
});
|
|
serviceResult.object = updated;
|
|
return serviceResult;
|
|
}
|
|
|
|
const entity = this.dispositivoRepository.create({
|
|
idPersona,
|
|
token: dto.token,
|
|
plataforma: dto.plataforma ?? 'android',
|
|
activo: dto.activo ?? true,
|
|
ultimaConexion: new Date(),
|
|
});
|
|
const result = await this.dispositivoRepository.save(entity);
|
|
|
|
serviceResult.boolean = true;
|
|
serviceResult.message = 'Dispositivo registrado correctamente.';
|
|
serviceResult.number = 1;
|
|
serviceResult.object = result;
|
|
|
|
return serviceResult;
|
|
}
|
|
|
|
async findOne(idDispositivo: string, user?: { idPersona?: string; autorizacion?: string }): Promise<ServiceResult> {
|
|
const serviceResult = defaultServiceResult();
|
|
|
|
const result = await this.dispositivoRepository.findOneBy({ idDispositivo });
|
|
|
|
if (!result) {
|
|
serviceResult.message = 'No existe el dispositivo.';
|
|
return serviceResult;
|
|
}
|
|
|
|
if (user && user.autorizacion !== 'Developer' && result.idPersona !== user.idPersona) {
|
|
serviceResult.message = 'No tiene permiso sobre este dispositivo.';
|
|
return serviceResult;
|
|
}
|
|
|
|
serviceResult.boolean = true;
|
|
serviceResult.message = 'Existe el dispositivo.';
|
|
serviceResult.number = 1;
|
|
serviceResult.object = result;
|
|
|
|
return serviceResult;
|
|
}
|
|
|
|
async find(
|
|
whereConditions: WhereCondition[],
|
|
orderByAttribute: string,
|
|
orderByDirection: 'ASC' | 'DESC',
|
|
limit: number,
|
|
offset: number,
|
|
): Promise<ServiceResult> {
|
|
const serviceResult = defaultServiceResult();
|
|
|
|
try {
|
|
let query = this.dispositivoRepository.createQueryBuilder('dispositivo');
|
|
|
|
whereConditions.forEach((condition, index) => {
|
|
const { attribute, value, operator = '=' } = condition;
|
|
|
|
if (!DISPOSITIVO_FIND_WHITELIST.includes(attribute)) {
|
|
throw new Error(`Atributo no permitido: ${attribute}`);
|
|
}
|
|
|
|
const paramKey = `param${index}`;
|
|
const param = {
|
|
[paramKey]: operator === 'like' ? `%${value}%` : value,
|
|
};
|
|
const whereMethod = index === 0 ? 'where' : 'andWhere';
|
|
|
|
query = query[whereMethod](
|
|
`dispositivo.${attribute} ${operator} :${paramKey}`,
|
|
param,
|
|
);
|
|
});
|
|
|
|
const orderAttr = DISPOSITIVO_FIND_WHITELIST.includes(orderByAttribute)
|
|
? orderByAttribute
|
|
: 'ultimaConexion';
|
|
query = query.orderBy(`dispositivo.${orderAttr}`, orderByDirection);
|
|
|
|
const totalRegistros = await query.getCount();
|
|
const skip = (offset - 1) * limit;
|
|
query = query.skip(skip).take(limit);
|
|
|
|
const result = await query.getMany();
|
|
serviceResult.boolean = result.length > 0;
|
|
serviceResult.message = `${result.length} dispositivo(s) encontrado(s).`;
|
|
serviceResult.number = totalRegistros;
|
|
serviceResult.data = result;
|
|
} catch (error) {
|
|
serviceResult.boolean = false;
|
|
serviceResult.message = `Error en el servicio: ${error.message}`;
|
|
}
|
|
|
|
return serviceResult;
|
|
}
|
|
|
|
async update(
|
|
idDispositivo: string,
|
|
dto: UpdateDispositivoDto,
|
|
user?: { idPersona?: string; autorizacion?: string },
|
|
): Promise<ServiceResult> {
|
|
const serviceResult = defaultServiceResult();
|
|
|
|
const existente = await this.dispositivoRepository.findOneBy({ idDispositivo });
|
|
if (!existente) {
|
|
serviceResult.message = 'No se encontró el dispositivo.';
|
|
return serviceResult;
|
|
}
|
|
if (user && user.autorizacion !== 'Developer' && existente.idPersona !== user.idPersona) {
|
|
serviceResult.message = 'No tiene permiso sobre este dispositivo.';
|
|
return serviceResult;
|
|
}
|
|
|
|
const result = await this.dispositivoRepository.update(idDispositivo, dto);
|
|
|
|
serviceResult.boolean = result.affected === 1;
|
|
serviceResult.message =
|
|
result.affected === 1
|
|
? 'Dispositivo actualizado correctamente.'
|
|
: 'No se encontró el dispositivo.';
|
|
serviceResult.number = result.affected || 0;
|
|
|
|
return serviceResult;
|
|
}
|
|
|
|
async remove(
|
|
idDispositivo: string,
|
|
user?: { idPersona?: string; autorizacion?: string },
|
|
): Promise<ServiceResult> {
|
|
const serviceResult = defaultServiceResult();
|
|
|
|
const existente = await this.dispositivoRepository.findOneBy({ idDispositivo });
|
|
if (!existente) {
|
|
serviceResult.message = 'No se encontró el dispositivo.';
|
|
return serviceResult;
|
|
}
|
|
if (user && user.autorizacion !== 'Developer' && existente.idPersona !== user.idPersona) {
|
|
serviceResult.message = 'No tiene permiso sobre este dispositivo.';
|
|
return serviceResult;
|
|
}
|
|
|
|
const result = await this.dispositivoRepository.update(idDispositivo, { activo: false });
|
|
|
|
serviceResult.boolean = result.affected === 1;
|
|
serviceResult.message =
|
|
result.affected === 1
|
|
? 'Dispositivo desactivado correctamente.'
|
|
: 'No se encontró el dispositivo.';
|
|
serviceResult.number = result.affected || 0;
|
|
|
|
return serviceResult;
|
|
}
|
|
|
|
async findActiveTokensByPersona(idPersona: string): Promise<string[]> {
|
|
const rows = await this.dispositivoRepository.findBy({
|
|
idPersona,
|
|
activo: true,
|
|
});
|
|
return rows.map((r) => r.token);
|
|
}
|
|
|
|
async findActiveTokensByPersonas(ids: string[]): Promise<string[]> {
|
|
if (!ids.length) return [];
|
|
const rows = await this.dispositivoRepository
|
|
.createQueryBuilder('d')
|
|
.where('d."idPersona" IN (:...ids)', { ids })
|
|
.andWhere('d.activo = :activo', { activo: true })
|
|
.getMany();
|
|
return rows.map((r) => r.token);
|
|
}
|
|
}
|