gistfile1.txt

# De esta clase heredan todos los controladores
# aquí es un buen lugar para definir métodos que puedan ser
# invocados desde cualquier controlador
class Application < Merb::Controller

  # Cuando alguna clase herede de ésta le declaramos (agregamos) las
  # excepciones definidas en self.declara_excepciones
  def self.inherited(subclass)
    subclass.declara_excepciones
  end

  # Definimos una conjunto de excepciones que cada controlador podrá arrojar
  # TODO: Evaluar si no conviene tenerlas todas en algún lado en lugar de
  # definir un conjunto para cada controlador
  def self.declara_excepciones
    code = %Q{
      class NoHayDatos < Exception;  end
      class NoSeEncontro < Exception;  end
      class NoSeElimino < Exception;  end
      class NoSeGuardo < Exception; end
      class NoTieneEstatusNuevo < Exception;  end
      class YaExiste < Exception;  end
      class RfcInvalido< Exception;  end
    }
    class_eval(code)
  end

  # Método invocado "antes" de cada acción
  before :inicializa_resultado

  # Prepara una variable que reportará el resultado de la acción
  # invocada en el controlador
  def inicializa_resultado
    @resultado = Hash.new
    @resultado[:exito] = false
    @resultado[:msj] = "[#{self.class}] Resultado preparado"
  end

  # [Busca, Guarda, Elimina, RevisaExistenDatos, RevisaEstatusNuevo] en una
  # instancia en un modelo, si no puede realizar la acción levanta una excepción
  def busca(modelo, id)
    instancia = modelo.get(id)
    raise self.class::NoSeEncontro, "No existe el #{modelo.name}[#{id}]" if instancia.nil?
    instancia
  end
  
  def guarda(instancia)
    raise self.class::NoSeGuardo, "No se guardó #{instancia.model}[#{instancia.id}]: #{instancia.errors.full_messages}" if !instancia.save
    true
  end

  def elimina(instancia)
    raise self.class::NoSeElimino, "No se eliminó #{instancia.model}[#{instancia.id}]" if !instancia.destroy
    true
  end

  def revisa_existen_datos(instancia)
    raise self.class::NoHayDatos, "No hay datos para #{self.class}" if instancia.nil?
    true
  end
  
  def revisa_estatus_nuevo(instancia)
    raise self.class::NoTieneEstatusNuevo, "El #{instancia.model} no es nuevo" if instancia.estatus != 'nuevo'
  end

  # Método de utilería que registra en los resultados los datos de la excepción
  # arrojada
  def registra_excepcion(excepcion)
    @resultado[:exito] = false
    @resultado[:excepcion] = excepcion.class
    @resultado[:msj] = excepcion.message
  end
  
end

gistfile2.txt

class Socios < Application

  # Definimos el tipo de información que servirá este controlador
  provides :json
  
  def lista
    begin
      if params[:estatus].nil?
        # Si no hay especificado un estatus, desplegamos todos los clientes
        @resultado[:datos] = Cliente.all
      else
        # Buscamos con el estatus especificado
        @resultado[:datos] = Cliente.all(:estatus => params[:estatus])
      end
      @resultado[:exito] = true
      @resultado[:msj] = "Lista de #{self.class} obtenida"
    rescue Exception => e
      registra_excepcion(e)
    ensure
      return display(@resultado)
    end
  end

  def muestra
    begin
      @resultado[:datos] = busca(Cliente, params[:id].to_i)
      @resultado[:exito] = true
      @resultado[:msj] = "Información de #{self.class.to_s.singularize} obtenida"
    rescue Exception => e
      registra_excepcion(e)
    ensure
      return display(@resultado)
    end
  end
  
  def destruye
    begin
      @cliente = busca(Cliente, params[:id].to_i)
      elimina(@cliente)
      @resultado[:exito] = true
      @resultado[:msj] = "#{self.class.to_s.singularize} eliminado"
    rescue Exception => e
      registra_excepcion(e)
    ensure
      return display(@resultado)
    end
  end
  
  def crea
    begin
      # Levantamos una excepción si no se enviaron datos para crear un socio
      revisa_existen_datos(params[:socio])
      # Revisamos si existe alguien con ese RFC
      @sujeto = Sujeto.first(:rfc => params[:socio][:rfc])
      # Si encontramos a alguien...
      unless @sujeto.nil?
        # Levantamos una excepción si ya tiene un Cliente asociado
        raise YaExiste, "El socio ya existe en el sistema" if !@sujeto.cliente.nil?
      end
      # Checamos el tipo de RFC (Persona o Empresa)
      clase_sujeto = Sujeto.identifica_clase(params[:socio][:rfc])
      # Levantamos una excepción si no se encontró el RFC
      # y no se identificó el tipo de persona
      raise RfcInvalido, "RFC inválido" if (clase_sujeto.nil? && @sujeto.nil?)
      # Si no hay algo en @sujeto...
      if @sujeto.nil?
        # Instanciamos una nueva Persona o Empresa
        @sujeto = clase_sujeto.new(params[:socio])
        # Levantamos una excepción si no se puede guardar el registro
        guarda(@sujeto)
      end
      # Si no hay algo en @sujeto.cliente...
      if @sujeto.cliente.nil?
        # Creamos un Cliente para esa persona
        # el Cliente es el que tiene acceso a los servicios
        @cliente = Cliente.new(:sujeto => @sujeto)
        # Levantamos una excepción si no se puede guardar
        guarda(@cliente)
      end
      @resultado[:exito] = true
      @resultado[:msj] = "#{self.class.to_s.singularize} creado"
    rescue Exception => e
      registra_excepcion(e)
    ensure
      return display(@resultado)
    end
  end
  
  def actualiza
    begin
      # Levantamos una excepción si no se enviaron datos para crear un socio
      revisa_existen_datos(params[:socio])
      # Revisamos si existe alguien con ese RFC
      @socio = busca(Cliente, params[:id].to_i)
      @sujeto = busca(Sujeto, @socio.sujeto_id)
      @sujeto.attributes = params[:socio]
      guarda(@sujeto)
      @resultado[:exito] = true
      @resultado[:msj] = "#{self.class.to_s.singularize} actualizado"
    rescue Exception => e
      registra_excepcion(e)
    ensure
      return display(@resultado)
    end
  end
  
  def autoriza
    begin
      @cliente = busca(Cliente, params[:id].to_i)
      revisa_estatus_nuevo(@cliente)
      @cliente.autorizar!
      guarda(@cliente)
      @resultado[:exito] = true
      @resultado[:msj] = "#{self.class.to_s.singularize} autorizado"
    rescue Exception => e
      registra_excepcion(e)
    ensure
      return display(@resultado)
    end
  end
  
end