golscontrol-frontend-v1/src/pages/UnitsMeasure/services/UnitsMeasureService.js

/**
 * Servicio para Units of Measure
 * 
 * @author Sistema
 * @version 1.0.0
 */

import { api, apiURL } from '@Services/Api';

export default class UnitsMeasureService {
  
  /**
   * Obtener todas las unidades de medida
   * @param {Object} params - Parámetros de la consulta
   * @returns {Promise} Promesa con la respuesta
   */
  async getAll(params = {}) {
    return new Promise((resolve, reject) => {
      api.get(apiURL('catalogs/units-of-measure'), {
        params,
        onSuccess: (response) => resolve(response),
        onError: (error) => reject(error)
      });
    });
  }

  /**
   * Obtener una unidad de medida por ID
   * @param {number} id - ID de la unidad de medida
   * @returns {Promise} Promesa con la respuesta
   */
  async getById(id) {
    return new Promise((resolve, reject) => {
      api.get(apiURL(`catalogs/units-of-measure/${id}`), {
        onSuccess: (response) => resolve(response),
        onError: (error) => reject(error)
      });
    });
  }

  /**
   * Crear una nueva unidad de medida
   * @param {Object} data - Datos de la unidad de medida
   * @param {string} data.code - Código de la unidad
   * @param {string} data.name - Nombre de la unidad
   * @param {string} data.abbreviation - Abreviación de la unidad
   * @param {number} data.type - Tipo de medida (1-7)
   * @param {boolean} data.is_active - Estado activo/inactivo
   * @returns {Promise} Promesa con la respuesta
   */
  async create(data) {
    return new Promise((resolve, reject) => {
      api.post(apiURL('catalogs/units-of-measure'), data, {
        onSuccess: (response) => resolve(response),
        onError: (error) => reject(error)
      });
    });
  }

  /**
   * Actualizar una unidad de medida existente
   * @param {number} id - ID de la unidad de medida
   * @param {Object} data - Datos actualizados
   * @returns {Promise} Promesa con la respuesta
   */
  async update(id, data) {
    return new Promise((resolve, reject) => {
      api.put(apiURL(`catalogs/units-of-measure/${id}`), data, {
        onSuccess: (response) => resolve(response),
        onError: (error) => reject(error)
      });
    });
  }

  /**
   * Eliminar una unidad de medida
   * @param {number} id - ID de la unidad de medida
   * @returns {Promise} Promesa con la respuesta
   */
  async delete(id) {
    return new Promise((resolve, reject) => {
      api.delete(apiURL(`catalogs/units-of-measure/${id}`), {
        onSuccess: (response) => resolve(response),
        onError: (error) => reject(error)
      });
    });
  }

  /**
   * Actualizar el estado de una unidad de medida
   * @param {number} id - ID de la unidad de medida
   * @param {boolean} isActive - Nuevo estado
   * @returns {Promise} Promesa con la respuesta
   */
  async updateStatus(id, isActive) {
    return new Promise((resolve, reject) => {
      api.put(apiURL(`catalogs/units-of-measure/${id}`), {
        data: { is_active: isActive },
        onSuccess: (response) => {
          resolve(response);
        },
        onError: (error) => {
          // Mejorar el manejo de errores
          const enhancedError = {
            ...error,
            timestamp: new Date().toISOString(),
            action: 'updateStatus',
            id: id,
            is_active: isActive
          };
          reject(enhancedError);
        }
      });
    });
  }

  /**
   * Obtener tipos de medida disponibles desde la API
   * @returns {Promise} Promesa con la respuesta
   */
  async getUnitTypes() {
    return new Promise((resolve, reject) => {
      api.get(apiURL('catalogs/unit-types'), {
        onSuccess: (response) => {
          // Extraer los tipos de la respuesta y formatearlos para el Selectable
          const unitTypes = response.data?.unit_types || response.unit_types || [];
          const formattedTypes = unitTypes.map(type => ({
            value: type.id,
            label: type.name
          }));
          resolve(formattedTypes);
        },
        onError: (error) => reject(error)
      });
    });
  }

  /**
   * Obtener tipos de medida como objetos completos (para mapping)
   * @returns {Promise} Promesa con los tipos completos
   */
  async getUnitTypesMap() {
    return new Promise((resolve, reject) => {
      api.get(apiURL('catalogs/unit-types'), {
        onSuccess: (response) => {
          const unitTypes = response.data?.unit_types || response.unit_types || [];
          // Crear un mapa para acceso rápido por ID
          const typesMap = {};
          unitTypes.forEach(type => {
            typesMap[type.id] = type;
          });
          resolve(typesMap);
        },
        onError: (error) => reject(error)
      });
    });
  }

  /**
   * Obtener tipos de medida disponibles (método legacy - mantener por compatibilidad)
   * @returns {Array} Array con los tipos de medida
   */
  getTypes() {
    return [
      { id: 1, name: 'Distancia', description: 'Medidas de longitud (metros, kilómetros, etc.)' },
      { id: 2, name: 'Peso', description: 'Medidas de masa (kilogramos, gramos, etc.)' },
      { id: 3, name: 'Temperatura', description: 'Medidas de temperatura (grados Celsius, etc.)' },
      { id: 4, name: 'Unidad', description: 'Unidades discretas (piezas, unidades, etc.)' },
      { id: 5, name: 'Volumen', description: 'Medidas de volumen (litros, mililitros, etc.)' }
    ];
  }

  /**
   * Obtener unidades de medida activas
   * @returns {Promise} Promesa con las unidades activas
   */
  async getActive() {
    return new Promise((resolve, reject) => {
      this.getAll({ is_active: true })
        .then(response => {
          const activeUnits = response.data?.units_of_measure?.data || [];
          resolve(activeUnits.filter(unit => unit.is_active));
        })
        .catch(error => reject(error));
    });
  }

  /**
   * Buscar unidades de medida por término
   * @param {string} term - Término de búsqueda
   * @returns {Promise} Promesa con los resultados
   */
  async search(term) {
    return new Promise((resolve, reject) => {
      this.getAll({ search: term })
        .then(response => resolve(response))
        .catch(error => reject(error));
    });
  }

  /**
   * Validar datos antes de enviar
   * @param {Object} data - Datos a validar
   * @returns {Object} Objeto con errores si los hay
   */
  validate(data) {
    const errors = {};

    if (!data.code || data.code.trim() === '') {
      errors.code = 'El código es requerido';
    }

    if (!data.name || data.name.trim() === '') {
      errors.name = 'El nombre es requerido';
    }

    if (!data.abbreviation || data.abbreviation.trim() === '') {
      errors.abbreviation = 'La abreviación es requerida';
    }

    if (!data.type || ![1, 2, 3, 4, 5, 6, 7].includes(data.type)) {
      errors.type = 'El tipo de medida es requerido y debe ser válido';
    }

    return errors;
  }
}