520 lines
20 KiB
Ruby
520 lines
20 KiB
Ruby
# app/controllers/admin/edicao_lancamentos_controller.rb
|
|
#
|
|
# Correção de lançamentos do SimpliRoute pelo ADM. Busca a entrega pela NF (na
|
|
# base de rastreio local), resolve o id numérico na API e grava a alteração
|
|
# DIRETO na API do SimpliRoute — registrando tudo no AuditoriaLog.
|
|
#
|
|
# ⚠️ A base de rastreio local (Entrega) é só leitura e sincroniza depois: a
|
|
# alteração só reflete no painel na próxima sincronização.
|
|
class Admin::EdicaoLancamentosController < ApplicationController
|
|
before_action :garantir_configurado
|
|
|
|
# Campos que o ADM pode editar (fase 1). checkout_observation = UUID do motivo.
|
|
CAMPOS_EDITAVEIS = %w[
|
|
status checkout_observation checkout_comment notes
|
|
checkout_time checkout_latitude checkout_longitude
|
|
].freeze
|
|
|
|
STATUS_VALIDOS = %w[pending partial completed failed canceled].freeze
|
|
|
|
def show
|
|
authorize :edicao_lancamento
|
|
@motivos = motivos_seguros
|
|
end
|
|
|
|
# GET /admin/edicao_lancamento/buscar?nf=79774 → JSON com TODOS os lançamentos
|
|
# daquela NF.
|
|
#
|
|
# ⚠️ Uma NF pode ter mais de um lançamento: quando o plano é duplicado no
|
|
# SimpliRoute nasce uma visita nova (outro tracking_id) com a mesma NF, e a
|
|
# antiga — a que tem o motorista/checkout — continua existindo. Por isso a
|
|
# busca devolve a LISTA e o ADM escolhe qual editar; assumir "1 NF = 1
|
|
# lançamento" escondia justamente o lançamento antigo.
|
|
#
|
|
# Com um único lançamento já vem o card montado, para não custar um segundo
|
|
# round-trip no caso comum.
|
|
#
|
|
# Aceita ?de=&ate= para varrer um período (a API só filtra por UM dia, então
|
|
# varremos dia a dia). Sem período, usa as datas que o espelho conhece.
|
|
def buscar
|
|
authorize :edicao_lancamento
|
|
|
|
nf = params[:nf].to_s.strip
|
|
return render_erro('Informe o número da NF.') if nf.blank?
|
|
|
|
entregas = Entrega.por_nf(nf).to_a
|
|
datas = datas_de_busca(entregas)
|
|
return render_erro(sem_datas_msg(nf, entregas)) if datas.empty?
|
|
|
|
falhas = []
|
|
ocorrencias = ocorrencias_da_nf(nf, entregas, datas, falhas)
|
|
unica = ocorrencias.first if ocorrencias.one? && ocorrencias.first[:id].present?
|
|
|
|
render json: {
|
|
ok: true,
|
|
ocorrencias: ocorrencias,
|
|
visita: (unica && payload_seguro(unica, entregas, falhas)),
|
|
periodo: { de: datas.first, ate: datas.last, dias: datas.size },
|
|
# Dias que a API não respondeu. Vão para a tela: uma busca que devolve
|
|
# menos do que existe TEM que dizer que devolveu menos.
|
|
falhas: falhas,
|
|
motivos: motivos_seguros
|
|
}
|
|
rescue SimpliRoute::NotFound => e
|
|
render_erro(e.message)
|
|
rescue SimpliRoute::Error => e
|
|
render_erro("Erro ao consultar o SimpliRoute: #{e.message}", status: :bad_gateway)
|
|
end
|
|
|
|
# GET /admin/edicao_lancamento/carregar?visit_id=871407488&tracking_id=SR...
|
|
# Monta o card de UM lançamento escolhido na lista de ocorrências.
|
|
def carregar
|
|
authorize :edicao_lancamento
|
|
|
|
id = params[:visit_id].to_s.strip
|
|
return render_erro('Lançamento não identificado.') if id.blank?
|
|
|
|
entrega = Entrega.find_by(tracking_id: params[:tracking_id]) if params[:tracking_id].present?
|
|
|
|
render json: { ok: true, visita: payload_visita(id, entrega), motivos: motivos_seguros }
|
|
rescue SimpliRoute::NotFound => e
|
|
render_erro(e.message)
|
|
rescue SimpliRoute::Error => e
|
|
render_erro("Erro ao consultar o SimpliRoute: #{e.message}", status: :bad_gateway)
|
|
end
|
|
|
|
# PATCH /admin/edicao_lancamento/atualizar
|
|
# HTML: fluxo de form clássico (fallback). JSON: salvar-por-campo do card
|
|
# (click-to-edit) — o fetch manda visit_id + só o campo editado.
|
|
def atualizar
|
|
authorize :edicao_lancamento
|
|
|
|
id = params[:visit_id].to_s.strip
|
|
return responder_erro('Visita não identificada.') if id.blank?
|
|
|
|
anterior = client.visita(id)
|
|
attrs = mudancas(anterior)
|
|
|
|
# Confirmar um valor idêntico não é erro no inline edit — só não há o que fazer.
|
|
if attrs.empty?
|
|
return respond_to do |format|
|
|
format.json { render json: { ok: true, campos: [], visita: {} } }
|
|
format.html { redirect_to admin_edicao_lancamento_path, alert: 'Nenhuma alteração informada.' }
|
|
end
|
|
end
|
|
if attrs['status'].present? && STATUS_VALIDOS.exclude?(attrs['status'])
|
|
return responder_erro('Status inválido.')
|
|
end
|
|
|
|
atualizada = client.atualizar_visita(id, attrs)
|
|
|
|
AuditoriaLog.registrar(
|
|
user: current_user,
|
|
acao: 'editar',
|
|
entidade: 'SimpliRoute::Visita',
|
|
entidade_id: id,
|
|
dados_anteriores: anterior.slice(*attrs.keys),
|
|
dados_novos: atualizada.slice(*attrs.keys),
|
|
request: request
|
|
)
|
|
|
|
# Mudança na operação feita POR DENTRO do sistema. A maioria das mudanças
|
|
# vem de fora e é pega pelo DetectarMudancasOperacaoJob; esta chega na hora
|
|
# e sabe exatamente qual NF e o que mudou.
|
|
Notificacao::Gatilhos.operacao_alterada(
|
|
operacao: anterior['title'].presence || 'SimpliRoute',
|
|
o_que_mudou: descrever_mudanca(anterior, atualizada, attrs.keys),
|
|
nf: anterior['reference']
|
|
)
|
|
|
|
respond_to do |format|
|
|
format.json do
|
|
render json: { ok: true, campos: attrs.keys, visita: atualizada.slice(*CAMPOS_EDITAVEIS) }
|
|
end
|
|
format.html do
|
|
redirect_to admin_edicao_lancamento_path,
|
|
notice: "Lançamento da NF #{atualizada['reference']} atualizado no SimpliRoute. " \
|
|
'O painel refletirá na próxima sincronização.'
|
|
end
|
|
end
|
|
rescue SimpliRoute::Error => e
|
|
responder_erro("Não foi possível atualizar: #{e.message}", status: :bad_gateway)
|
|
end
|
|
|
|
# GET /admin/edicao_lancamento/historico?visit_id=123 → JSON com as DUAS fontes:
|
|
# o histórico da API do SimpliRoute (best-effort, costuma vir vazio) e a nossa
|
|
# trilha do AuditoriaLog (quem editou, quando, de→para).
|
|
def historico
|
|
authorize :edicao_lancamento
|
|
|
|
id = params[:visit_id].to_s.strip
|
|
interno = AuditoriaLog.por_entidade('SimpliRoute::Visita')
|
|
.where(entidade_id: id)
|
|
.includes(:user).recentes.limit(50)
|
|
.map do |log|
|
|
{
|
|
usuario: log.user&.nome_display || '—',
|
|
acao: log.acao,
|
|
quando: log.created_at.in_time_zone.strftime('%d/%m/%Y %H:%M'),
|
|
de: log.dados_anteriores,
|
|
para: log.dados_novos
|
|
}
|
|
end
|
|
|
|
render json: { ok: true, api: client.historico(id), interno: interno }
|
|
end
|
|
|
|
private
|
|
|
|
# "status: pending → completed; observação: … → ÓBITO" — o texto que vai para
|
|
# a variável {{o_que_mudou}} do editor de blocos.
|
|
def descrever_mudanca(anterior, atualizada, campos)
|
|
Array(campos).filter_map do |campo|
|
|
de = anterior[campo].to_s.strip
|
|
para = atualizada[campo].to_s.strip
|
|
next if de == para
|
|
|
|
"#{campo}: #{de.presence || '(vazio)'} → #{para.presence || '(vazio)'}"
|
|
end.join('; ').presence || 'lançamento atualizado'
|
|
end
|
|
|
|
def client
|
|
@client ||= SimpliRoute::Client.new
|
|
end
|
|
|
|
# Máximo de dias varridos numa busca por período. A API só filtra por UM dia,
|
|
# então cada dia é uma chamada — com `search` cada uma custa ~0,6 s e elas vão
|
|
# em lotes paralelos, o que torna dois meses viável; o teto existe para a tela
|
|
# não virar uma varredura sem fim.
|
|
MAX_DIAS_VARREDURA = 62
|
|
|
|
# Quais dias consultar na API:
|
|
# • com ?de=/?ate= — o período pedido (o SimpliRoute duplica plano para
|
|
# outra data, e aí o espelho não tem como saber qual é);
|
|
# • sem período — as datas que o espelho conhece (barato: 1 ou 2 chamadas).
|
|
def datas_de_busca(entregas)
|
|
de = data_param(:de)
|
|
ate = data_param(:ate)
|
|
|
|
if de || ate
|
|
inicio, fim = [de || ate, ate || de].minmax
|
|
(inicio..fim).first(MAX_DIAS_VARREDURA)
|
|
else
|
|
entregas.filter_map { |e| e.planned_date&.to_date }.uniq.sort
|
|
end
|
|
end
|
|
|
|
def data_param(chave)
|
|
valor = params[chave].to_s.strip
|
|
return nil if valor.blank?
|
|
|
|
Date.parse(valor)
|
|
rescue Date::Error
|
|
nil
|
|
end
|
|
|
|
# Sem datas não há o que consultar — e o motivo muda a saída para o ADM.
|
|
def sem_datas_msg(nf, entregas)
|
|
if entregas.empty?
|
|
"NF #{nf} não encontrada na base de rastreio. Informe um período para procurar direto no SimpliRoute."
|
|
else
|
|
"NF #{nf} está na base de rastreio mas sem data planejada. Informe um período para procurar na API."
|
|
end
|
|
end
|
|
|
|
# Todos os lançamentos da NF, cruzando as DUAS fontes:
|
|
# • espelho de rastreio (Entrega) — traz motorista/veículo;
|
|
# • API do SimpliRoute, nas datas varridas — pega a visita duplicada que a
|
|
# sincronização ainda não trouxe para o espelho.
|
|
def ocorrencias_da_nf(nf, entregas, datas, falhas)
|
|
trackings = entregas.map { |e| e.tracking_id.to_s }
|
|
do_dia = visitas_dos_dias(datas, nf, falhas)
|
|
|
|
visitas = do_dia.select { |v| v['reference'].to_s == nf || trackings.include?(v['tracking_id'].to_s) }
|
|
.uniq { |v| v['id'] }
|
|
visitas = com_tracking_id(visitas)
|
|
|
|
achadas = visitas.map { |v| ocorrencia_da_api(v, entrega_de(entregas, v['tracking_id'])) }
|
|
|
|
# Lançamento que existe no espelho mas não apareceu na API (data sem plano,
|
|
# visita removida): entra na lista como não editável, para o ADM ver que
|
|
# ele existe em vez de sumir silenciosamente — que é o bug que estamos
|
|
# corrigindo.
|
|
vistos = visitas.map { |v| v['tracking_id'].to_s }
|
|
orfas = entregas.reject { |e| vistos.include?(e.tracking_id.to_s) }
|
|
.map { |e| ocorrencia_do_espelho(e, datas.include?(e.planned_date&.to_date)) }
|
|
|
|
# Mais recente primeiro (a data vem como texto ISO da API e como timestamp
|
|
# do espelho — os 10 primeiros caracteres normalizam as duas).
|
|
(achadas + orfas).sort_by { |o| [o[:data].to_s[0, 10], o[:id].to_i] }.reverse
|
|
end
|
|
|
|
# Dias consultados de uma vez. Cada chamada abre a própria conexão HTTP (ver
|
|
# SimpliRoute::Client#requisicao) e não toca o banco, então dá para
|
|
# paralelizar em lotes; o lote pequeno evita martelar a API do SimpliRoute.
|
|
MAX_PARALELO_VARREDURA = 6
|
|
|
|
# Passa a NF como `search` — sem isso cada dia baixaria ~3,8 MB (o dia inteiro)
|
|
# e um mês seria inviável. Ver a nota em SimpliRoute::Client#visitas_da_data.
|
|
def visitas_dos_dias(datas, nf, falhas)
|
|
mutex = Mutex.new
|
|
|
|
datas.each_slice(MAX_PARALELO_VARREDURA).flat_map do |lote|
|
|
lote.map { |data| Thread.new { visitas_do_dia(data, nf, falhas, mutex) } }.flat_map(&:value)
|
|
end
|
|
end
|
|
|
|
# Um dia que a API não responde NÃO pode derrubar a busca inteira: registra a
|
|
# falha e segue com os outros dias. (Foi assim que uma NF com visitas em duas
|
|
# datas passou a não devolver nada em vez de devolver o que deu certo.)
|
|
def visitas_do_dia(data, nf, falhas, mutex)
|
|
client.visitas_da_data(data, busca: nf)
|
|
rescue SimpliRoute::Error => e
|
|
mutex.synchronize { falhas << { data: data.strftime('%d/%m/%Y'), erro: e.message } }
|
|
[]
|
|
end
|
|
|
|
# Abrir o card do lançamento único é conveniência: se falhar, a lista ainda
|
|
# tem que aparecer.
|
|
def payload_seguro(ocorrencia, entregas, falhas)
|
|
payload_visita(ocorrencia[:id], entrega_de(entregas, ocorrencia[:tracking_id]))
|
|
rescue SimpliRoute::Error => e
|
|
falhas << { data: ocorrencia[:data].to_s[0, 10], erro: "não foi possível abrir o lançamento: #{e.message}" }
|
|
nil
|
|
end
|
|
|
|
def entrega_de(entregas, tracking_id)
|
|
return nil if tracking_id.blank?
|
|
|
|
entregas.find { |e| e.tracking_id.to_s == tracking_id.to_s }
|
|
end
|
|
|
|
# Quantas visitas da lista vale a pena detalhar (1 GET cada). Uma NF com mais
|
|
# que isso é dado estranho, não plano duplicado.
|
|
MAX_DETALHES_LISTA = 5
|
|
|
|
# A lista-por-data nem sempre traz o `tracking_id`, e é ele que liga a visita
|
|
# ao espelho — de onde vêm motorista e veículo. Sem esse casamento a NF
|
|
# duplicada aparece com as duas linhas sem motorista, que é exatamente o dado
|
|
# que distingue uma da outra. Quando faltar, busca a visita completa.
|
|
def com_tracking_id(visitas)
|
|
visitas.each_with_index.map do |visita, i|
|
|
next visita if visita['tracking_id'].present? || i >= MAX_DETALHES_LISTA
|
|
|
|
detalhar(visita)
|
|
end
|
|
end
|
|
|
|
# Best-effort: se o detalhe falhar, segue com o que a lista deu.
|
|
def detalhar(visita)
|
|
client.visita(visita['id']).presence || visita
|
|
rescue SimpliRoute::Error
|
|
visita
|
|
end
|
|
|
|
# Resumo de um lançamento para a lista de escolha (não carrega fotos/detalhe —
|
|
# isso só acontece quando o ADM abre um).
|
|
def ocorrencia_da_api(visita, entrega)
|
|
{
|
|
id: visita['id'],
|
|
tracking_id: visita['tracking_id'],
|
|
titulo: visita['title'],
|
|
endereco: visita['address'],
|
|
status: visita['status'],
|
|
data: visita['planned_date'],
|
|
checkout_time: visita['checkout_time'],
|
|
motorista: entrega&.driver,
|
|
veiculo: entrega&.vehicle,
|
|
editavel: true,
|
|
# Sem linha no espelho não há como saber motorista/veículo: a API não
|
|
# devolve esses campos na visita. O ADM diferencia pelo status/checkout.
|
|
no_painel: entrega.present?,
|
|
aviso: entrega ? nil : 'Ainda não sincronizado no painel — motorista e veículo indisponíveis'
|
|
}
|
|
end
|
|
|
|
def ocorrencia_do_espelho(entrega, data_varrida)
|
|
{
|
|
id: nil,
|
|
tracking_id: entrega.tracking_id,
|
|
titulo: entrega.local,
|
|
endereco: entrega.address,
|
|
status: entrega.status,
|
|
data: entrega.planned_date,
|
|
checkout_time: entrega.checkout,
|
|
motorista: entrega.driver,
|
|
veiculo: entrega.vehicle,
|
|
editavel: false,
|
|
no_painel: true,
|
|
aviso: (if data_varrida
|
|
'Só no painel — não está entre as visitas desta data no SimpliRoute, então não dá para editar'
|
|
else
|
|
'Fora do período consultado — inclua a data deste lançamento no período para poder editá-lo'
|
|
end)
|
|
}
|
|
end
|
|
|
|
# Estado completo de UMA visita para o card (inclui a galeria de fotos, que
|
|
# custa uma chamada extra ao POD). `entrega` pode ser nil quando a visita
|
|
# ainda não sincronizou no espelho.
|
|
def payload_visita(id, entrega)
|
|
visita = client.visita(id)
|
|
# Segunda fonte de imagens (POD). Não é obrigatória: se falhar, vem {}.
|
|
detalhe = client.detalhe_visita(id)
|
|
|
|
{
|
|
id: id,
|
|
tracking_id: visita['tracking_id'],
|
|
nf: visita['reference'],
|
|
titulo: visita['title'],
|
|
endereco: visita['address'],
|
|
status: visita['status'],
|
|
checkout_observation: visita['checkout_observation'],
|
|
checkout_comment: visita['checkout_comment'],
|
|
notes: visita['notes'],
|
|
checkout_time: visita['checkout_time'],
|
|
checkout_latitude: visita['checkout_latitude'],
|
|
checkout_longitude: visita['checkout_longitude'],
|
|
planned_date: visita['planned_date'],
|
|
contato: visita['contact_name'],
|
|
telefone: visita['contact_phone'],
|
|
# Galeria unificada — TODAS as fotos do lançamento, de todas as fontes,
|
|
# cada uma etiquetada para o ADM saber o que está conferindo.
|
|
fotos: fotos_do_lancamento(entrega, visita, detalhe),
|
|
motorista: entrega&.driver,
|
|
veiculo: entrega&.vehicle
|
|
}
|
|
end
|
|
|
|
# Monta o hash de PATCH só com os campos que vieram no form E que realmente
|
|
# mudaram em relação ao estado atual — PATCH mínimo, sem sobrescrever à toa.
|
|
def mudancas(anterior)
|
|
CAMPOS_EDITAVEIS.each_with_object({}) do |campo, memo|
|
|
next unless params.key?(campo)
|
|
|
|
novo = normalizar(campo, params[campo])
|
|
next if equivalente?(campo, novo, anterior[campo])
|
|
|
|
memo[campo] = novo
|
|
end
|
|
end
|
|
|
|
# Evita PATCH falso: nil/"" são equivalentes; datas comparadas por instante;
|
|
# lat/long por valor numérico (o reparse difere do texto original da API).
|
|
def equivalente?(campo, novo, atual)
|
|
return true if novo.to_s == atual.to_s
|
|
|
|
case campo
|
|
when 'checkout_time'
|
|
a = (Time.zone.parse(novo.to_s) rescue nil)
|
|
b = (Time.zone.parse(atual.to_s) rescue nil)
|
|
a.present? && b.present? && a.to_i == b.to_i
|
|
when 'checkout_latitude', 'checkout_longitude'
|
|
novo.is_a?(Float) && atual.present? && (novo - atual.to_f).abs < 1e-9
|
|
else
|
|
false
|
|
end
|
|
end
|
|
|
|
# Normaliza valores por campo. Campos em branco viram nil (permite LIMPAR o
|
|
# motivo/comentário). checkout_time aceita datetime-local e vira ISO8601.
|
|
def normalizar(campo, valor)
|
|
valor = valor.to_s.strip
|
|
return nil if valor.blank?
|
|
|
|
case campo
|
|
when 'checkout_latitude', 'checkout_longitude'
|
|
Float(valor) rescue valor
|
|
when 'checkout_time'
|
|
(Time.zone.parse(valor)&.iso8601 rescue nil) || valor
|
|
else
|
|
valor
|
|
end
|
|
end
|
|
|
|
# Lista de motivos; nunca quebra a tela se a API estiver fora.
|
|
def motivos_seguros
|
|
client.observations
|
|
rescue SimpliRoute::Error
|
|
[]
|
|
end
|
|
|
|
def render_erro(msg, status: :unprocessable_entity)
|
|
render json: { ok: false, erro: msg }, status: status
|
|
end
|
|
|
|
# Erro do atualizar nos dois formatos (JSON p/ inline edit, HTML p/ fallback).
|
|
def responder_erro(msg, status: :unprocessable_entity)
|
|
respond_to do |format|
|
|
format.json { render json: { ok: false, erro: msg }, status: status }
|
|
format.html { redirect_to admin_edicao_lancamento_path, alert: msg }
|
|
end
|
|
end
|
|
|
|
# Só aceita URL http(s) — evita injetar lixo no <img src> do card (mesmo
|
|
# filtro do foto_url do OperacaoMetricas).
|
|
def url_imagem(valor)
|
|
url = valor.to_s.strip
|
|
url.match?(%r{\Ahttps?://}i) ? url : nil
|
|
end
|
|
|
|
# Campos de foto customizados do SimpliRoute (extra_field_values). É AQUI que
|
|
# ficam as fotos reais tiradas pelo motorista — o array `pictures` só traz uma
|
|
# imagem genérica. Mapa: campo da API => [rótulo p/ o ADM, categoria de cor].
|
|
# Campos fora deste mapa ainda aparecem (rótulo derivado do nome do campo).
|
|
FOTOS_EXTRA = {
|
|
'foto_prova_visita' => ['Prova da visita', 'prova'],
|
|
'foto_nf' => ['Nota Fiscal', 'nf'],
|
|
'foto_termo' => ['Termo', 'termo'],
|
|
'foto_relatorio2' => ['Relatório', 'relatorio']
|
|
}.freeze
|
|
|
|
# Reúne TODAS as imagens do lançamento numa lista única e etiquetada:
|
|
# 1. espelho de rastreio -> foto da fachada (mesma do mapa de operações)
|
|
# 2. extra_field_values -> fotos reais do motorista (foto_nf, prova, etc.)
|
|
# 3. pictures[]/signature -> imagens genéricas + assinatura
|
|
#
|
|
# A mesma foto pode vir de mais de uma fonte, então deduplica por URL mantendo
|
|
# a primeira etiqueta (a ordem abaixo é a mais informativa).
|
|
def fotos_do_lancamento(entrega, visita, detalhe)
|
|
brutas = []
|
|
brutas << [entrega.try(:foto_da_fachada), 'Fachada', 'fachada', 'Rastreio']
|
|
|
|
# Fotos customizadas — o /detail/ é a fonte mais completa; cai p/ a visita.
|
|
extras = detalhe['extra_field_values'].presence || visita['extra_field_values'] || {}
|
|
extras.each do |campo, valor|
|
|
rotulo, cat = FOTOS_EXTRA[campo] || [rotulo_do_campo(campo), 'extra']
|
|
brutas << [valor, rotulo, cat, 'SimpliRoute']
|
|
end
|
|
|
|
[[visita, 'Visita'], [detalhe, 'Comprovante']].each do |fonte, origem|
|
|
Array(fonte['pictures']).each { |u| brutas << [u, 'Comprovante', 'entrega', origem] }
|
|
brutas << [fonte['signature'], 'Assinatura', 'assinatura', origem]
|
|
end
|
|
|
|
vistas = Set.new
|
|
brutas.filter_map do |valor, rotulo, cat, origem|
|
|
url = url_imagem(valor)
|
|
next if url.nil? || !vistas.add?(url)
|
|
|
|
{ url: url, rotulo: rotulo, cat: cat, origem: origem }
|
|
end
|
|
end
|
|
|
|
# "foto_relatorio2" -> "Relatorio2". Fallback p/ campos de foto não mapeados.
|
|
def rotulo_do_campo(campo)
|
|
campo.to_s.sub(/\Afoto_?/, '').tr('_', ' ').strip.capitalize.presence || campo.to_s
|
|
end
|
|
|
|
# Sem token não há o que fazer — avisa e volta.
|
|
def garantir_configurado
|
|
return if SimpliRoute.configurado?
|
|
|
|
msg = 'Integração com o SimpliRoute não configurada (defina SIMPLIROUTE_TOKEN no servidor).'
|
|
respond_to do |format|
|
|
format.html { redirect_to dashboard_path, alert: msg }
|
|
format.json { render json: { ok: false, erro: msg }, status: :service_unavailable }
|
|
end
|
|
end
|
|
end
|