Calcular tarifa

Instructions

Implementation Reference

• server.js:62-91 (registration)

  Registration of the 'calculate_tariff' tool with MCP server, including input schema, title, description, and a thin async handler that delegates to businessCalculator.calculateTariff with logging and error handling.

  server.registerTool(
    'calculate_tariff',
    {
      title: 'Calcular tarifa',
      description: 'Calcula tarifas para reservas según temporada, personas y canal basado en configuración real',
      inputSchema: z.object({
        checkin_date: z.string(),
        checkout_date: z.string(),
        guests: z.number().min(1).max(4),
        channel: z.string().optional().default('directo'),
      }),
    },
    async ({ checkin_date, checkout_date, guests, channel = 'directo' }) => {
      validator.log('info', `Iniciando cálculo de tarifa: ${guests} huéspedes, ${checkin_date} a ${checkout_date}, canal ${channel}`);
      
      try {
        // Usar módulo de cálculo sin hardcodeo
        const result = await businessCalculator.calculateTariff(checkin_date, checkout_date, guests, channel);
        
        validator.log('info', 'Cálculo de tarifa completado exitosamente');
        return result;
        
      } catch (error) {
        validator.log('error', `Error crítico en cálculo de tarifa: ${error.message}`);
        return validator.generateInsufficientDataResponse(
          'cálculo de tarifa',
          'Error interno del sistema. Contacta al administrador.'
        );
      }
    }

• src/business/calculator.js:15-113 (handler)

  Core implementation of the tariff calculation: validates inputs and dates, loads financial configuration data, determines season, calculates base tariff and commission based on channel, computes total, and formats response.

  async calculateTariff(checkinDate, checkoutDate, guests, channel = 'directo') {
    // Validar parámetros de entrada
    const inputValidation = validator.validateUserInput({
      checkin_date: checkinDate,
      checkout_date: checkoutDate,
      guests: guests,
      channel: channel
    }, {
      checkin_date: { required: true, type: 'string' },
      checkout_date: { required: true, type: 'string' },
      guests: { required: true, type: 'number', min: 1, max: 4 },
      channel: { required: false, type: 'string', enum: ['directo', 'airbnb', 'booking', 'whatsapp'] }
    });
  
    if (!inputValidation.valid) {
      return validator.generateInsufficientDataResponse(
        'parámetros de tarifa', 
        `Errores: ${inputValidation.errors.join(', ')}`
      );
    }
  
    // Validar fechas
    const dateValidation = validator.validateDateRange(checkinDate, checkoutDate);
    if (!dateValidation.valid) {
      return validator.generateInsufficientDataResponse(
        'fechas de reserva',
        dateValidation.error
      );
    }
  
    // Cargar configuración de tarifas desde datos reales
    const financialData = await dataLoader.loadFinancialData();
    if (!financialData || !financialData.configuracion_negocio) {
      return validator.generateInsufficientDataResponse(
        'configuración de tarifas',
        'No se pudo acceder a la configuración de precios del sistema'
      );
    }
  
    const config = financialData.configuracion_negocio;
    
    // Verificar que existen las tarifas por temporada
    if (!config.tarifas_temporada) {
      return validator.generateInsufficientDataResponse(
        'tarifas por temporada',
        'La configuración no incluye tarifas por temporada'
      );
    }
  
    try {
      const season = this.determineSeason(dateValidation.checkin, config);
      const seasonData = config.tarifas_temporada[season];
      
      if (!seasonData) {
        return validator.generateInsufficientDataResponse(
          `tarifas para temporada ${season}`,
          'No se encontraron tarifas para la temporada solicitada'
        );
      }
  
      // Calcular tarifa base según número de huéspedes
      const baseTariff = this.calculateBaseTariff(guests, seasonData);
      const nights = dateValidation.nights;
      const subtotal = baseTariff * nights;
      
      // Calcular comisión según canal
      const commissionRate = this.getCommissionRate(channel, config);
      const commission = Math.round(subtotal * commissionRate);
      const total = subtotal + commission;
  
      validator.log('info', `Tarifa calculada: ${guests} huéspedes, ${nights} noches, temporada ${season}, canal ${channel}`);
  
      return {
        content: [{
          type: 'text',
          text: this.formatTariffResponse({
            checkinDate,
            checkoutDate,
            guests,
            channel,
            season,
            nights,
            baseTariff,
            subtotal,
            commissionRate: commissionRate * 100,
            commission,
            total
          })
        }]
      };
  
    } catch (error) {
      validator.log('error', `Error calculando tarifa: ${error.message}`);
      return validator.generateInsufficientDataResponse(
        'cálculo de tarifa',
        'Error interno en el cálculo. Contacta al administrador.'
      );
    }
  }

• src/business/calculator.js:118-141 (helper)

  Helper method to determine the season (alta, media, etc.) for the given check-in date using business configuration or fallback logic.

  determineSeason(date, config) {
    if (!config.temporadas) {
      validator.log('warning', 'Configuración de temporadas no encontrada, usando lógica por defecto');
      // Lógica básica si no hay configuración
      const month = date.getMonth() + 1;
      if (month >= 12 || month <= 2) return 'alta';
      if (month >= 6 && month <= 8) return 'alta';
      return 'media';
    }
  
    // Usar configuración real de temporadas
    const month = date.getMonth() + 1;
    const day = date.getDate();
    
    for (const [seasonName, periods] of Object.entries(config.temporadas)) {
      for (const period of periods) {
        if (this.isDateInPeriod(month, day, period)) {
          return seasonName;
        }
      }
    }
    
    return 'media'; // temporada por defecto
  }

• src/business/calculator.js:171-182 (helper)

  Helper method to compute the base nightly tariff based on number of guests and season data configuration.

  calculateBaseTariff(guests, seasonData) {
    if (seasonData.por_huesped && seasonData.tarifa_base_por_persona) {
      return seasonData.tarifa_base_por_persona * guests;
    }
    
    if (seasonData.tarifas_por_ocupacion) {
      const guestKey = `${guests}_personas`;
      return seasonData.tarifas_por_ocupacion[guestKey] || seasonData.tarifa_base || 80000;
    }
    
    return seasonData.tarifa_base || 80000;
  }

• src/business/calculator.js:187-200 (helper)

  Helper method to get the commission rate for the booking channel from configuration or defaults.

  getCommissionRate(channel, config) {
    if (!config.comisiones_canal) {
      validator.log('warning', 'Configuración de comisiones no encontrada, usando valores por defecto');
      const defaultRates = {
        'directo': 0,
        'airbnb': 0.15,
        'booking': 0.18,
        'whatsapp': 0.05
      };
      return defaultRates[channel] || 0;
    }
    
    return config.comisiones_canal[channel] || 0;
  }