Retorno de step.get_ola_runtime_function

Flow
1

Introdução

O retorno da função step.get_ola_runtime_function é um objeto do tipo Ola que define o valor e o modo de cálculo do OLA (Operational Level Agreement) para uma etapa específica. Este objeto permite customizar completamente o cálculo de OLA, substituindo ou ajustando o cálculo padrão do sistema.

O retorno é utilizado pelo sistema durante o cálculo de OLA para determinar o prazo e o modo de cálculo que será aplicado ao card na etapa.

Estrutura Básica

O retorno deve ser um objeto JavaScript com a seguinte estrutura:

{
  ola: number,                        // Valor do OLA (em horas ou fração de SLA)
  mode: 'relative-sla' | 'absolute'    // Modo de cálculo do OLA
}

Retornando o Valor

A função deve retornar um objeto único (não um array):

// Retornando um objeto Ola
return {
  ola: 0.5,
  mode: 'relative-sla'
};

// Retornando um objeto Ola com modo absoluto
return {
  ola: 24,
  mode: 'absolute'
};

Referência de Retorno

Objeto Ola

Parâmetro Tipo Obrigatório Descrição
ola number Sim Valor do OLA. O significado depende do mode: se mode === 'absolute', o valor está em horas absolutas; se mode === 'relative-sla', o valor é uma fração do SLA (ex: 0.5 = 50% do SLA)
mode 'relative-sla' | 'absolute' Não Define como o valor de ola deve ser interpretado. Se não especificado, o sistema assume 'absolute' como padrão

Modos de Cálculo

'absolute'

  • O valor de ola está em horas absolutas
  • O sistema converterá para relativo ao SLA se necessário
  • Exemplo: { ola: 24, mode: 'absolute' } significa 24 horas

'relative-sla'

  • O valor de ola é uma fração do SLA
  • O sistema usará diretamente este valor
  • Exemplo: { ola: 0.5, mode: 'relative-sla' } significa 50% do SLA

Valores Padrão

Se a função retornar null, undefined ou não retornar um objeto válido, o sistema usará os seguintes valores padrão:

{
  ola: 0,
  mode: 'absolute'
}

Se o mode não for especificado no retorno, o sistema assumirá 'absolute' como padrão.

Exemplos de Uso

Exemplo 1: Retorno com Modo Relativo ao SLA

module.exports = async (req, comunicationService) => {
  const { card, step, flow, form, ola } = req.data;
  
  // Calcular OLA baseado em um campo do formulário
  const priority = form.priority || 'normal';
  
  let calculatedOla;
  if (priority === 'high') {
    calculatedOla = 0.3; // 30% do SLA para alta prioridade
  } else if (priority === 'low') {
    calculatedOla = 0.7; // 70% do SLA para baixa prioridade
  } else {
    // Usar o valor calculado pelo sistema se disponível
    calculatedOla = ola ? ola.ola : 0.5; // 50% padrão
  }
  
  return {
    ola: calculatedOla,
    mode: 'relative-sla'
  };
};

Exemplo 2: Retorno com Modo Absoluto

module.exports = async (req, comunicationService) => {
  const { form } = req.data;
  
  // Calcular OLA em horas absolutas baseado em um campo
  const complexity = form.complexity || 1;
  const hours = complexity * 8; // 8 horas por nível de complexidade
  
  return {
    ola: hours,
    mode: 'absolute'
  };
};

Exemplo 3: Ajuste do OLA Calculado pelo Sistema

module.exports = async (req, comunicationService) => {
  const { ola, form } = req.data;
  
  // Quando behavior === 'override', o sistema já calculou o OLA
  // A função pode ajustar o valor
  if (ola && ola.mode === 'relative-sla') {
    // Aumentar o OLA em 20% para casos especiais
    const adjustedOla = ola.ola * 1.2;
    
    return {
      ola: Math.min(adjustedOla, 1.0), // Limitar a 100% do SLA
      mode: 'relative-sla'
    };
  }
  
  // Fallback para o valor padrão
  return {
    ola: 0.5,
    mode: 'relative-sla'
  };
};

Exemplo 4: Cálculo Baseado em Múltiplos Fatores

module.exports = async (req, comunicationService) => {
  const { card, form, ola } = req.data;
  
  // Calcular OLA baseado em múltiplos fatores
  let multiplier = 1.0;
  
  // Ajustar baseado na prioridade
  if (form.priority === 'high') {
    multiplier *= 0.7; // Reduzir OLA para alta prioridade
  } else if (form.priority === 'low') {
    multiplier *= 1.3; // Aumentar OLA para baixa prioridade
  }
   
  // Usar o OLA calculado pelo sistema como base (se disponível)
  const baseOla = ola ? ola.ola : 0.5;
  const finalOla = baseOla * multiplier;
  
  return {
    ola: Math.max(0.1, Math.min(finalOla, 1.0)), // Limitar entre 10% e 100%
    mode: 'relative-sla'
  };
};