spf_tracking 0.0.19 → 0.0.20

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MDAzOGViMzg3NmQwOTJiYjhjZjM0YWQwYmQzM2UwOTFjYzY3YzNlOQ==
+    YmIxY2UwYmQ1MzJlYjg5NDEzZTMxNTQwNDk0NDQxZDk4MDBhOGJhMQ==
   data.tar.gz: !binary |-
-    NGZjMWYwZDlkNzk2NmE2MGVkYWE3ZmJjYzg1ZmNlZmMxODJkMTYwZQ==
+    YjU5YWNiMjlhZTg5YjhlYmJiZmE0Mjk1NzcxNDg1YzlkMDAxOWZlZA==
 SHA512:
   metadata.gz: !binary |-
-    Yjk4OTViOTJjY2NkNzZiYmYxOGJiYTI2MDhkNmFmN2ZkY2IzZjA5NDliM2Zj
-    NzYxZmY5NmM0YjZjNDhhMmFkZjkzOGQ3NTlkNGU5NmYxMDQ2YmUyNmY2ZWI0
-    M2RmMDcwMTI1Zjg0ZTE4NzdjMjllYTU4ZTk3ZmZkNzg2ZGQ0MDI=
+    MmZiZTkzMDI5YzlhMzcxZTQwNWYwMTE3MGMwNTJhY2QwMGEwYzU0ZmZmZmQ3
+    YjE3Zjc4YzYzYzVmOWY5ZDRkNDA2ZjA3Y2U5MGVmMWQ5MTY5YjZkOGUwMmVi
+    MzU2MDM0ZjcyZDM0YjAxMTlhZGU4ZTZhYjY4NGU2YzVmZjVmYjU=
   data.tar.gz: !binary |-
-    Y2RiNzdhZjMxMjRhNjhjOGJiMjA4MzM3OGVjYWNlZGE0YTdlYjQ5ZDRjYmVk
-    Yjg3Zjg0MDljYzI3OTg1ZjQ0YmZiZmZmMzU0YTA4ZDNjYTI1YWU5NDYxZWY4
-    NmNlZjdkNjUwNjdjY2U3MTcxZmI0MDUxMzg3Y2QwZDgwNjE0ZWQ=
+    MzBiMzFkMzhiM2I5ZGE3ODZmZGEyZmE1MzA1NTM2ODI3ODYyYjI4ZmMxZmY5
+    YTNjMzU3MGM2MGNjNjU0YmI5YzM3YTM5MmZjYjIwOTczZmNlNzcxNDA1ZGNh
+    MDFiNzhkNjgxMjNmMDA0Y2JmYTUzZTBlMDg5ZmI5MzM4MzNmMTQ=

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spf_tracking
 version: !ruby/object:Gem::Version
-  version: 0.0.19
+  version: 0.0.20
 platform: ruby
 authors:
 - Carlos Ramseyer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-26 00:00:00.000000000 Z
+date: 2016-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -31,30 +31,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- MIT-LICENSE
-- README.rdoc
-- Rakefile
-- lib/descriptivo.rb
-- lib/experto_rotura_trazabilidad.rb
-- lib/experto_trazabilidad.rb
-- lib/proceso_de_producto.rb
-- lib/proxima_trazabilidad_rotura.rb
-- lib/rotura_anterior.rb
-- lib/ruta_seguimiento.rb
-- lib/service_track.rb
-- lib/service_track/busca_ultimo_puesto_completo.rb
-- lib/service_track/create_entrega_rapida.rb
-- lib/service_track/create_rotura.rb
-- lib/service_track/nueva_rotura.rb
-- lib/service_track/update_retrabajos.rb
-- lib/spf_tracking.rb
-- lib/spf_tracking/version.rb
-- lib/tasks/spf_tracking_tasks.rake
-- lib/tracking/carga_rotura.rb
-- lib/tracking/registro_trabajo.rb
 - lib/tracking/routes.rb
-- lib/tracking/trazabilidad_elemento.rb
-- lib/util_trazabilidad.rb
 - test/dummy/README.rdoc
 - test/dummy/Rakefile
 - test/dummy/app/assets/javascripts/application.js

data/MIT-LICENSE

@@ -1,20 +0,0 @@
-Copyright 2016 YOURNAME
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -1,3 +0,0 @@
-= SpfTracking
-
-This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -1,32 +0,0 @@
-begin
-  require 'bundler/setup'
-rescue LoadError
-  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
-end
-
-require 'rdoc/task'
-
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'SpfTracking'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-
-
-
-Bundler::GemHelper.install_tasks
-
-require 'rake/testtask'
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
-end
-
-
-task default: :test

data/lib/descriptivo.rb

@@ -1,77 +0,0 @@
-# encoding: utf-8
-module Descriptivo
-  
-  module DescriptivoItem
-    def descripcion_primer_vidrio
-      composicion.nil? ? "El item no tiene una compisición asignada" : composicion.primer_vidrio.elementos.map(&:descripcion).join(" ")
-    end
-  end
-
-  module DescriptivoItemMedida
-    def etiqueta_excel
-      pedido = item.pedido
-
-      e_im = self.cardinalidad.to_s.rjust(3, '0')
-      e_i = item.cardinalidad.to_s.rjust(3, '0')
-      e_p = pedido.id.to_s.rjust(6, '0')
-
-      "#{e_p}-#{e_i}-#{e_im}"
-    end  
-  end
-
-  module DescriptivoTrazabilidad    
-    def etiqueta_string
-      item = composicion.item
-      pedido = item.pedido
-      componente = self.componente || self.elemento.try(:componente)
-
-      pedido_string = pedido.id.to_s.rjust(7, '0')
-      item_string = item.cardinalidad.to_s.rjust(3, '0')
-      item_medida_string = self.item_medida.cardinalidad.to_s.rjust(3, '0')
-
-      if self.elemento
-        componente_string = componente.orden.to_s
-        elemento_string = self.elemento.orden.to_s.rjust(2, '0')
-      else
-        if self.componente
-          componente_string = self.componente.orden.to_s
-          elemento_string = "00"
-        else
-          componente_string = "0"
-          elemento_string = "00"
-        end
-      end
-
-      "#{pedido_string}-#{item_string}-#{item_medida_string}-#{componente_string}-#{elemento_string}"
-
-    end
-
-  end
-
-  module DescriptivoElemento
-    def descripcion
-      # (["Float 4"] + ["Pulido", "Termoendurecido"]).join(" ")
-      ([self.elemento_de_componente.descripcion] + self.procesos_de_procesos.map(&:nombre)).join(" ")
-    end
-
-    def descripcion_corta_tango
-      # (["Float 4"] + ["Pulido", "Termoendurecido"]).join(" ")
-      ([self.elemento_de_componente.descripcion_corta_tango] + self.procesos_de_procesos.map(&:descripcion_corta_tango)).join(" ")
-    end
-
-    def descripcion_tango
-      # (["Float 4"] + ["Pulido", "Termoendurecido"]).join(" ")
-      ([self.elemento_de_componente.descripcion_tango] + self.procesos_de_procesos.map(&:descripcion_corta_tango)).join(" ")
-    end
-
-    def descripcion_elemento
-      self.elemento_de_componente.descripcion
-    end
-
-    def descripcion_sin_procesos
-      self.descripcion_elemento
-    end
-  end
-
-
-end

data/lib/experto_rotura_trazabilidad.rb

@@ -1,28 +0,0 @@
-# encoding: utf-8
-
-# A ESTA CLASE LE LLEGAN OBJETOS Y DEVUELVE EL PRD_TRACK EN EL CUAL
-# TRAZABILIDAD TIENE QUE EJECUTAR EL METODO CARGAR_ROTURA
-
-# RECORDAR QUE ESTO ES POR EL PROBLEMA DE "LAS DOS ROTURAS, UNA REAL, OTRA
-# DEL SISTEMA DE TRAZABILIDAD"
-
-class ExpertoRoturaTrazabilidad
-
-  def initialize(item_medida, elemento, puesto_control)
-    @item_medida, @elemento, @puesto_control = item_medida, elemento, puesto_control
-  end
-
-  def get_prd_track_donde_se_rompe
-
-    prd_track_actual = RoturaAnterior.new(@item_medida, @elemento, @puesto_control).get_prd_track_actual
-
-
-    if prd_track_actual.trabajos_disponibles == 0
-      return ProximaTrazabilidadRotura.new(@item_medida, @elemento, @puesto_control).get_prd_track
-    else
-      return prd_track_actual
-    end
-
-  end
-
-end

data/lib/experto_trazabilidad.rb

@@ -1,104 +0,0 @@
-class ExpertoTrazabilidad
-
-
-
-  def finalizar_y_pasar_a_historico(pedido)
-    composicions_ids = pedido.composicions_ids
-    # busco todas las filas en trazabilidads que tengan composicion perteneciente al pedido
-    trazabilidads_ids = Trazabilidad.where(composicion_id: composicions_ids).ids
-    ActiveRecord::Base.transaction do
-      # si finaliza entonces sí hago el pasaje a historico
-      if pedido.finalizar
-        # pasaje de trabajos
-        Trabajo.pasar_trabajos_a_historico(trazabilidads_ids)
-        Trabajo.borrar_trabajo(trazabilidads_ids)
-        # pasaje de trazabilidad
-        Trazabilidad.pasar_trazabilidad_a_historico(composicions_ids) 
-        Trazabilidad.borrar_trazabilidad(composicions_ids)
-        # pasaje de tango a tango_historico
-        TangoHeader.pasar_a_historico(pedido.id)
-        TangoBody.pasar_a_historico(pedido.id)
-        TangoActivo.pasar_a_historico(pedido.id)
-        # borro de las tablas de tango_ los registros
-        TangoHeader.where(pedido_id: pedido.id).delete_all
-        TangoBody.where(pedido_id: pedido.id).delete_all
-        TangoActivo.where(pedido_id: pedido.id).delete_all
-        return true
-      end
-    end
-  end
-
-  def pasar_a_historico(pedido)
-    composicions_ids = pedido.composicions_ids
-    # busco todas las filas en trazabilidads que tengan composicion perteneciente al pedido
-    trazabilidads_ids = Trazabilidad.where(composicion_id: composicions_ids).ids
-    ActiveRecord::Base.transaction do
-      # si finaliza entonces sí hago el pasaje a historico
-      # pasaje de trabajos
-      Trabajo.pasar_trabajos_a_historico(trazabilidads_ids)
-      Trabajo.borrar_trabajo(trazabilidads_ids)
-      # pasaje de trazabilidad
-      Trazabilidad.pasar_trazabilidad_a_historico(composicions_ids) 
-      Trazabilidad.borrar_trazabilidad(composicions_ids)
-      # pasaje de tango a tango_historico
-      TangoHeader.pasar_a_historico(pedido.id)
-      TangoBody.pasar_a_historico(pedido.id)
-      TangoActivo.pasar_a_historico(pedido.id)
-      # borro de las tablas de tango_ los registros
-      TangoHeader.where(pedido_id: pedido.id).delete_all
-      TangoBody.where(pedido_id: pedido.id).delete_all
-      TangoActivo.where(pedido_id: pedido.id).delete_all
-      return true
-    end
-  end
-
-  
-  # devuelve falso solo si hay productos disponibles para terminar y estos estan en dvh, preparacion o facturacion
-  
-
-  
-  def descontar_remito(puesto_control, item_medida, cantidad)
-    if %w"Facturacion Expedicion Entregado".include?(puesto_control.nombre)
-      facturacion = Facturacion.where(linea_item: item_medida).max_by{|x| x.created_at}
-      new_cantidad = facturacion.cantidad == 0 ? 0 : facturacion.cantidad - cantidad
-      Rails.logger.info "Del comprobante_medida_id #{facturacion.id} se le descuenta 1 a #{facturacion.cantidad} y queda #{new_cantidad}"
-      facturacion.update_attribute :cantidad, new_cantidad
-    end
-  end
-
-  def terminados_de_medidas_en_puesto(item_medidas, puesto)
-    prd_tracks = puesto.get_prd_track.where(linea_item_type: "ItemMedida", linea_item_id: item_medidas.map(&:id))
-    prd_tracks.to_a.sum(&:terminado_listo)
-  end
-
-  def items_que_pasan_por(pedido, puesto)
-    pedido.items.map{|i| i if i.composicion.composicion_pasa_por?(puesto)}.compact
-  end
-
-  def medidas_que_pasan_por(pedido, puesto)
-    items_que_pasan_por(pedido, puesto).map(&:item_medidas).flatten
-  end
-
-
- 
-  # si los terminados en dvh son mayor que los terminados en preparacion, entonces el pedido entra en el array de pedidos con dvh listos para preparar
-  def pedidos_con_dvh_para_preparar_old(pedidos)
-    pedidos.map{|p| p if (p.pedido_pasa_por_dvh? && self.terminados_de_medidas_en_puesto(self.medidas_que_pasan_por(p, PuestoControl.dvh), PuestoControl.dvh) > self.terminados_de_medidas_en_puesto(self.medidas_que_pasan_por(p, PuestoControl.dvh), PuestoControl.preparacion)) }.compact
-  end
-
-  def pedidos_con_dvh_para_preparar(array_pedidos_puestos)
-    # me quedo solamente con pedidos que tengan activo Preparacion
-    # para aplicarles el filtro siguiente
-
-    pedidos_prepa = []
-
-    array_pedidos_puestos.each do |pedido|
-      pedidos_prepa << pedido[0] if pedido[1].include?(PuestoControl.preparacion)
-    end
-
-    pedidos_prepa.map{|p| p if (self.terminados_de_medidas_en_puesto(self.medidas_que_pasan_por(p, PuestoControl.dvh), PuestoControl.dvh) > self.terminados_de_medidas_en_puesto(self.medidas_que_pasan_por(p, PuestoControl.dvh), PuestoControl.preparacion)) }.compact
-
-  end
-
-
-end

data/lib/proceso_de_producto.rb

@@ -1,31 +0,0 @@
-module ProcesoDeProducto
-  module ProcesoDeProductoElemento
-    def procesos
-      proceso_de_elementos
-    end
-
-    def procesos_de_procesos
-      proceso_de_elementos.sort{|a,b| a.orden <=> b.orden}.map(&:proceso)
-    end
-  end
-
-  module ProcesoDeProductoComponente
-    def procesos
-      proceso_de_componentes
-    end
-
-    def procesos_de_procesos
-      proceso_de_componentes.sort{|a,b| a.orden <=> b.orden}.map(&:proceso)
-    end
-  end
-
-  module ProcesoDeProductoComposicion
-    def procesos
-      proceso_de_composicions
-    end
-
-    def procesos_de_procesos
-      proceso_de_composicions.sort{|a,b| a.orden <=> b.orden}.map(&:proceso)
-    end
-  end
-end

data/lib/proxima_trazabilidad_rotura.rb

@@ -1,47 +0,0 @@
-# encoding: utf-8
-
-# ESTE OBJETO SIRVE PARA IMPLEMENTAR MOMENTANEAMENTE LA ROTURA POR ETIQUETA
-# ACTUALMENTE ESTA EL PROBLEMA DE QUE POR LOS PUESTOS QUE PASAN A TERMINADO
-# EN FORMA AUTOMATICA, POR EJEMPLO UN VIDRIO TEMPLADO DE UN PEDIDO QUE SE
-# ACTIVA, YA PASA A ESTADO TEMPLADO TERMINADO Y A LA ESPERA DE PREPARACION
-# AUNQUE EN FABRICA, EN LA REALIDAD, TODAVIA NI SIQUIERA FUE CORTADO
-
-# ENTONCES SURGE LA CUESTIÓN DE QUE UN VIDRIO "SE ROMPE EN DOS PUESTOS"
-
-# SI EL VIDRIO SE ROMPE EN LA REALIDAD EN TALLER AL MOMENTO DE SER PULIDO
-# ENTONCES VOY A GUARDAR EN LA TABLA ROTURAVIDRIOS ESE DATO
-# PERO... PERO
-# EN EL SISTEMA DE TRAZABILIDAD NO PUEDO HACER QUE EL VIDRIO SE ROMPA AHÍ
-# PORQUE NO ES CONSISTENTE, YA QUE SUPUESTAMENTE EL VIDRIO YA ESTÁ TALLER
-# TERMINADO Y TEMPLADO TAMBIÉN TERMINADO -POR LA NATURALEZA DE TERMINARSE
-# AUTOMÁTICAMENTE LOS PUESTOS QUE NO TIENEN AUN UNA PC EN PLANTA
-
-# RESUMIENDO
-# SI SE ROMPE ALGO EN TALLER, COMO TALLER NO ESTÁ IMPLEMENTADO EN PLANTA,
-# EL VIDRIO EN LA TEORIA SE HACE ROMPER LUEGO DEL ULTIMO PUESTO COMPLETO
-
-
-class ProximaTrazabilidadRotura
-
-  def initialize(item_medida, elemento, puesto_control)
-    @item_medida = item_medida
-    @elemento = elemento
-    @puesto_control = puesto_control
-  end
-
-  # REFACTORIZAR Y AGREGAR QUE TAMBIEN DEVUELVA POR COMPONENTE Y ELEMENTO
-  def get_prd_track
-    prd_track = @puesto_control.get_prd_track.find_by(linea_item: @item_medida, elemento_id: @elemento.id) || @puesto_control.get_prd_track.find_by(linea_item: @item_medida, componente_id: @elemento.componente_id) || @puesto_control.get_prd_track.find_by(linea_item: @item_medida, composicion_id: @elemento.componente.composicion.id) 
-
-    
-
-    while prd_track.next.trabajos_disponibles == 0 do
-      prd_track = prd_track.next 
-    end
-
-    prd_track
-  end
-
-
-
-end

data/lib/rotura_anterior.rb

@@ -1,18 +0,0 @@
-class RoturaAnterior
-
-  def initialize(item_medida, elemento, puesto_control_actual)
-    @item_medida = item_medida
-    @elemento = elemento
-    @puesto_control_actual = puesto_control_actual
-  end
-
-  # REFACTORIZAR Y AGREGAR QUE TAMBIEN DEVUELVA POR COMPONENTE Y ELEMENTO
-  def get_prd_track_actual
-    @puesto_control_actual.get_prd_track.find_by(linea_item: @item_medida, elemento_id: @elemento.id) || @puesto_control_actual.get_prd_track.find_by(linea_item: @item_medida, componente_id: @elemento.componente_id) || @puesto_control_actual.get_prd_track.find_by(linea_item: @item_medida, composicion_id: @elemento.componente.composicion.id) 
-  end
-
-  def get_prd_track_anterior
-    Trazabilidad.find_by(linea_item: @item_medida, elemento_id: @elemento.id, proximo_prd_track_id: get_prd_track_actual.try(:id)) || Trazabilidad.find_by(linea_item: @item_medida, componente_id: @elemento.componente_id, proximo_prd_track_id: get_prd_track_actual.try(:id)) 
-  end
-
-end

data/lib/ruta_seguimiento.rb

@@ -1,233 +0,0 @@
-module RutaSeguimiento
-  module RutaSeguimientoPedido
-    def lista_de_puestos_de_pedido
-      self.items.map(&:composicion).map(&:get_elementos_trackeables).flatten.map(&:lista_de_puestos_del_elemento).flatten.uniq
-    end
-
-    # mas general incluye adjuntos y taller(agujeros), administracion, etc
-    def lista_de_puestos_de_pedido_mas_general
-      lista = lista_de_puestos_de_pedido
-      lista << PuestoControl.adjunto if self.tiene_adjuntos?
-      lista << PuestoControl.expedicion
-      lista << PuestoControl.corte
-      lista << PuestoControl.glassware_produccion
-      lista << PuestoControl.glassware_administracion
-
-      lista << PuestoControl.taller if (!lista.include?(PuestoControl.taller) && self.tiene_agujeros_o_entrantes?)
-      
-      lista.flatten
-    end
-
-    # completa desde inicio hasta entrega, sin adjunto, glassware admin, etc
-    def lista_de_puestos_de_pedido_completa
-      (self.items.map(&:composicion).map(&:get_elementos_trackeables).flatten.map(&:lista_de_puestos_del_elemento_completa) + self.items.map(&:item_complementos).flatten.map(&:lista_de_puestos_del_complemento_completa)).flatten.uniq
-    end
-  end
-
-  module RutaSeguimientoComposicion
-    
-    # DVH EXP
-    def lista_de_racks
-      lista = []
-      lista << PuestoControl.dvh if multicomponente?
-      lista << procesos_de_procesos.map(&:puesto_control)
-      lista.flatten.uniq
-    end
-
-    def lista_de_puestos_de_composicion
-      get_elementos_trackeables.map(&:lista_de_puestos_del_elemento).flatten.uniq
-    end
-
-    def lista_de_puestos_de_composicion_completa
-      lista = []
-      lista = agregar_puestos_pre_composicion(lista)
-      lista << lista_de_puestos_de_composicion
-      lista = agregar_puestos_post_composicion(lista)
-      lista.flatten.uniq
-    end
-
-    def lista_de_puestos_de_composicion_track_tercer_nivel
-      lista = []
-      lista << PuestoControl.dvh if self.multicomponente?
-      lista << procesos_de_procesos.map(&:puesto_control)
-      lista = self.agregar_puestos_post_composicion(lista)
-      lista.flatten.uniq
-    end
-
-    # ver de refactorizar, este metodo se usa en un showlogic
-    def composicion_pasa_por?(puesto_control)
-      lista_de_puestos_de_composicion_track_tercer_nivel.include?(puesto_control)
-    end
-  end
-
-  module RutaSeguimientoComponente
-    # LAM TLL DVH
-    def lista_de_racks
-      lista = []
-      if !cantidad_de_pvb.zero?
-        lista << PuestoControl.prelaminado
-        lista << PuestoControl.laminado
-      end
-      lista << procesos_de_procesos.map(&:puesto_control)
-      lista << PuestoControl.dvh if composicion.multicomponente?
-      lista << composicion.procesos_de_procesos.map(&:puesto_control)
-      lista.flatten.uniq
-    end
-
-    def lista_de_puestos_del_componente_track_segundo_nivel
-      # devuelve como mucho [LAM, TLL]
-      lista = []
-      if !cantidad_de_pvb.zero?
-        lista << PuestoControl.prelaminado
-        lista << PuestoControl.laminado
-      end
-      lista << procesos_de_procesos.map(&:puesto_control)
-      return lista.flatten.uniq 
-    end
-  end
-
-  module RutaSeguimientoElemento
-    # TLL TMP CUR LAM DVH
-    def lista_de_racks
-      lista = []
-      lista << procesos_de_procesos.map(&:puesto_control)
-      if !componente.cantidad_de_pvb.zero?
-        lista << PuestoControl.prelaminado
-        lista << PuestoControl.laminado
-      end
-      lista << componente.procesos_de_procesos.map(&:puesto_control)
-      lista << PuestoControl.dvh if componente.composicion.multicomponente?
-      lista << componente.composicion.procesos_de_procesos.map(&:puesto_control)
-      lista.flatten.uniq  
-    end
-
-    def lista_de_puestos_del_elemento # excel ????????
-
-      composicion = componente.composicion
-
-      lista = []
-      # procesos de elementos
-      lista << procesos_de_procesos.map(&:puesto_control)
-      # pvb; laminados
-      if !componente.cantidad_de_pvb.zero?
-        lista << PuestoControl.prelaminado
-        lista << PuestoControl.laminado
-      end
-      # procesos de componentes
-      lista << componente.procesos_de_procesos.map(&:puesto_control)
-      # dvh
-      lista << PuestoControl.dvh if composicion.multicomponente?
-      # procesos de composicion
-      lista << composicion.procesos_de_procesos.map(&:puesto_control)
-      lista.flatten
-    end
-
-    def lista_de_puestos_del_elemento_completa
-      lista = []
-      agregar_puestos_pre_composicion(lista)
-      lista << lista_de_puestos_del_elemento
-      agregar_puestos_post_composicion(lista)
-    end
-
-    # este incluye LAMINADO (a diferencia de primer nivel)
-    def lista_de_puestos_del_elemento_track
-      composicion = componente.composicion
-
-      lista = []
-      agregar_puestos_pre_composicion(lista)
-      # procesos de elementos
-      lista << procesos_de_procesos.map(&:puesto_control)
-      # pvb; laminados
-      if !componente.cantidad_de_pvb.zero?
-        lista << PuestoControl.prelaminado
-        lista << PuestoControl.laminado
-      end
-      lista.flatten
-    end
-
-    # todos los que tienen elemento_id en tabla trazabilidad [ini... corte, templado] (LAMINADO NO)
-    def lista_de_puestos_del_elemento_track_primer_nivel
-      composicion = componente.composicion
-
-      lista = []
-      agregar_puestos_pre_composicion(lista)
-      # procesos de elementos
-      lista << procesos_de_procesos.map(&:puesto_control)
-      lista.flatten
-    end
-
-  end
-
-  module RutaSeguimientoItemComplemento
-    
-    def lista_de_puestos_del_complemento_completa
-      lista = []
-      agregar_puestos_comunes_complemento(lista)
-      lista.flatten
-    end
-
-  end
-
-  module RutaSeguimientoGeneral
-
-    # si puesto_control_actual es corte => devuelve el primer rack
-    # caso contrario devuelve el proximo rack respecto al actual
-    def proximo_rack(puesto_control_actual)
-
-      if puesto_control_actual == PuestoControl.corte
-        if lista_de_racks.empty?
-          return PuestoControl.expedicion
-        else
-          return lista_de_racks[0]
-        end
-      end
-
-
-      index_puesto_actual = lista_de_racks.index(puesto_control_actual) || 0
-
-      # si lista[index_puesto_actual + 1] no existe entonces devuelve EXPEDICION
-
-      return PuestoControl.expedicion if lista_de_racks[index_puesto_actual + 1].nil?
-
-      # devuelve el proximo
-      lista_de_racks[index_puesto_actual + 1]
-    end
-
-    def agregar_puestos_post_composicion(lista)
-      # lista << PuestoControl.find_by_nombre("Embalaje")
-      lista << PuestoControl.preparacion
-      lista << PuestoControl.facturacion
-      lista << PuestoControl.expedicion
-      # lista << PuestoControl.find_by_nombre("Salida de camiones")
-      lista << PuestoControl.entregado
-      # lista << PuestoControl.find_by_nombre("Devolucion")
-      lista.flatten
-    end
-
-    def agregar_puestos_pre_composicion(lista)
-      lista << PuestoControl.inicial
-      lista << PuestoControl.compra
-      lista << PuestoControl.stock
-      lista << PuestoControl.sin_programar
-      lista << PuestoControl.borrador
-      lista << PuestoControl.planificado
-      lista << PuestoControl.corte
-      lista.flatten
-    end
-
-    def agregar_puestos_comunes_complemento(lista)
-      lista << PuestoControl.inicial
-      lista << PuestoControl.compra
-      lista << PuestoControl.stock
-      # lista << PuestoControl.find_by_nombre("Embalaje")
-      lista << PuestoControl.preparacion
-      lista << PuestoControl.facturacion
-      lista << PuestoControl.expedicion
-      # lista << PuestoControl.find_by_nombre("Salida de camiones")
-      lista << PuestoControl.entregado
-      # lista << PuestoControl.find_by_nombre("Devolucion")
-      lista.flatten
-    end
-  end
-
-end

data/lib/service_track/busca_ultimo_puesto_completo.rb

@@ -1,54 +0,0 @@
-class ServiceTrack::BuscaUltimoPuestoCompleto
-
-  def initialize(opts = {})
-    @puesto = opts.has_key?(:item) ? ultimo_puesto_completo_item(opts[:item]) : ultimo_puesto_completo_item_medida(opts[:item_medida])
-  end
-
-  def verbo_terminado
-    @puesto ? @puesto.verbo_terminado : "Mixto"
-  end
-
-  private
-
-  def ultimo_puesto_completo_item_medida(item_medida)
-
-    ultimo_puesto_completo = nil
-    PuestoControl.trazables.order(:orden).each do |puesto|
-
-      if !%w("Inicial Compra Stock Sin\ programar Planificado Borrador Taller Templado Serigrafiado").include?(puesto.nombre)
-      
-        klass_prd_track = puesto.get_prd_track
-        prd_tracks = klass_prd_track.where(item_medida_id: item_medida.id)
-
-        if prd_tracks.any?
-          puesto_todo_terminado = true
-          prd_tracks.each do |prd_track|
-            if !prd_track.esta_terminado?
-              puesto_todo_terminado = false
-              break
-            end 
-          end
-
-          ultimo_puesto_completo = puesto if puesto_todo_terminado
-        end
-
-      end
-
-    end
-
-    ultimo_puesto_completo
-  end
-
-  def ultimo_puesto_completo_item(item)
-    puestos = []
-    item.item_medidas.each do |item_medida|
-      puestos << ultimo_puesto_completo_item_medida(item_medida)
-    end
-
-    puestos = puestos.uniq.compact
-
-    puestos.count == 1 ? puestos[0] : nil
-
-  end  
-
-end

data/lib/service_track/create_entrega_rapida.rb

@@ -1,26 +0,0 @@
-class ServiceTrack::CreateEntregaRapida
-
-  def initialize(opts = {})
-    @opts = opts
-  end
-
-  def save
-    ActiveRecord::Base.transaction do
-      terminar_facturacion
-      nuevas_expediciones # con los comprobantes generados en el paso anterior
-      # comprobar coherencia?
-    end
-  end
-
-  def terminar_facturacion
-    @comprobante_temps_generados = TerminarFacturacion.new(@opts).save
-  end
-
-  def nuevas_expediciones
-    @comprobante_temps_generados.each do |comprobante|
-      @opts[:comprobante_temp_id] = comprobante.id
-      NuevaExpedicion.new(@opts).save
-    end
-  end
-
-end

data/lib/service_track/create_rotura.rb

@@ -1,42 +0,0 @@
-class ServiceTrack::CreateRotura
-
-  def initialize(opts)
-    opts.each_pair { |k, v| instance_variable_set("@#{k}", v) }
-    @opts = opts
-
-    @cantidad = 1 # de momento ?
-  end
-
-  
-  
-  def save 
-    ActiveRecord::Base.transaction do
-      update_roturas
-      update_retrabajos
-      domino
-      create_rotura_vidrios
-      # comprobar coherencia?
-    end
-  end
-
-  def update_roturas
-    @elementos_y_prd_tracks.each do |eypt|
-      eypt[:prd_track].cargar_rotura(@cantidad, @current_user)
-    end
-  end
-
-  def update_retrabajos
-    ServiceTrack::UpdateRetrabajos.new(@elementos_y_prd_tracks, @item_medida, @cantidad).start()
-  end
-
-  def domino
-    @elementos_y_prd_tracks.each do |eypt|
-      Tracking::PrdIniTrack.find_by(linea_item: @item_medida, elemento_id: eypt[:elemento].id).domino
-    end
-  end
-
-  def create_rotura_vidrios
-    ServiceTrack::NuevaRotura.new(@opts).save
-  end
-
-end

data/lib/service_track/nueva_rotura.rb

@@ -1,21 +0,0 @@
-class ServiceTrack::NuevaRotura
-
-  def initialize(opts)
-    opts.each_pair { |k, v| instance_variable_set("@#{k}", v) }
-
-    @cantidad = 1 # de momento ?
-  end
-
-  def save
-    ActiveRecord::Base.transaction do
-      create_roturas
-    end
-  end
-
-  def create_roturas
-    @elementos_y_prd_tracks.each do |eypt|
-      RoturaVidrio.create(item_medida_id: @item_medida.id, elemento_id: eypt[:elemento].id, observacion: @motivo_rotura, motivo_id: @motivo_id, momento_id: @momento_id, puesto_control_id: @puesto_rotura_vidrio.id, user_id: @current_user.try(:id))
-    end
-  end
-
-end

data/lib/service_track/update_retrabajos.rb

@@ -1,87 +0,0 @@
-class ServiceTrack::UpdateRetrabajos
-
-  # cuando hay una rotura, actualiza los prd_track de los puestos anteriores hasta "puesto_control" en el parámetro
-  def initialize(elementos_y_prd_tracks, item_medida, cantidad)
-    @elementos_y_prd_tracks = elementos_y_prd_tracks
-    @item_medida = item_medida
-    
-    @cantidad = cantidad
-  end
-
-  def puestos_de_primer_nivel_a_actualizar(elemento)
-    elemento.lista_de_puestos_del_elemento_track_primer_nivel
-  end
-
-  def puestos_de_segundo_nivel_a_actualizar(componente)
-    componente.lista_de_puestos_del_componente_track_segundo_nivel
-  end
-
-  def puestos_de_tercer_nivel_a_actualizar(composicion)
-    composicion.lista_de_puestos_de_composicion_track_tercer_nivel
-  end
-
-  def prd_track_de_primer_nivel_a_actualizar(lista_de_puestos, elemento)
-    lista_de_puestos.collect do |puesto|
-      puesto.get_prd_track.find_by(linea_item: @item_medida, elemento_id: elemento.id)
-    end
-  end
-
-  def prd_track_de_segundo_nivel_a_actualizar(lista_de_puestos, componente)
-    lista_de_puestos.collect do |puesto|
-      puesto.get_prd_track.find_by(linea_item: @item_medida, componente_id: componente.id)
-    end
-  end
-
-  def prd_track_de_tercer_nivel_a_actualizar(lista_de_puestos, composicion)
-    lista_de_puestos.collect do |puesto|
-      puesto.get_prd_track.find_by(linea_item: @item_medida, composicion_id: composicion.id)
-    end
-  end
-
-  # se le pasa una lista, y devuelve la misma lista hasta encontrarse con el prd_track pasado por parametro
-  # el 9999 es para que si el prd_track no esta dentro de la lista, devuelva toda la lista
-  # recordar que las listas son por niveles 
-  # -> nivel 1 (Ini, Cmp, Crt, etc)
-  # -> nivel 2 (Lam, Tll)
-  # quiere decir que si quiero marcar retrabajos hasta DVH, en las listas de primer y segundo nivel, no va a aparecer el prd_track de DVH, por eso index = 9999
-  def hasta_puesto(lista, prd_track_hasta)
-    index_de_este_puesto_en_la_lista = lista.index(prd_track_hasta) || 9999
-    lista[0..index_de_este_puesto_en_la_lista] 
-  end
-
-  def update_retrabajos(prd_tracks, cantidad)
-    Rails.logger.info "ENTRA AL UPDATE_RETRABAJOS"
-    prd_tracks.map{ |pt| pt.update_attribute :retrabajo, pt.retrabajo + cantidad }
-  end
-
-  def start(rotura_anterior = nil)
-    
-    prd_tracks = []
-
-    @elementos_y_prd_tracks.each do |eypt|
-
-      elemento = eypt[:elemento]
-      prd_track_hasta = eypt[:prd_track]
-
-      componente = elemento.componente
-      composicion = componente.composicion
-
-      prd_tracks_parcial = []
-      
-      prd_tracks_parcial << prd_track_de_primer_nivel_a_actualizar(puestos_de_primer_nivel_a_actualizar(elemento), elemento).flatten
-
-      prd_tracks_parcial << prd_track_de_segundo_nivel_a_actualizar(puestos_de_segundo_nivel_a_actualizar(componente), componente).flatten
-
-      prd_tracks_parcial << prd_track_de_tercer_nivel_a_actualizar(puestos_de_tercer_nivel_a_actualizar(composicion), composicion).flatten
-
-      prd_tracks << hasta_puesto(prd_tracks_parcial.flatten, prd_track_hasta)
-      
-    end
-
-    prd_tracks.flatten!.uniq! # borro los repetidos para que no se actualicen dos veces duplicando valores de retrabajo
-  
-    update_retrabajos(prd_tracks, @cantidad)
-
-  end
-
-end

data/lib/service_track.rb

@@ -1,2 +0,0 @@
-class ServiceTrack
-end

data/lib/spf_tracking/version.rb

@@ -1,3 +0,0 @@
-module SpfTracking
-  VERSION = "0.0.19"
-end

data/lib/spf_tracking.rb

@@ -1,2 +0,0 @@
-#require 'tracking/registro_trabajo'
-#require 'tracking/routes'

data/lib/tasks/spf_tracking_tasks.rake

@@ -1,4 +0,0 @@
-# desc "Explaining what the task does"
-# task :spf_tracking do
-#   # Task goes here
-# end

data/lib/tracking/carga_rotura.rb

@@ -1,20 +0,0 @@
-# encoding: utf-8
-
-module Tracking::CargaRotura
-
-# solo carga la rotura del puesto actual
-  def cargar_rotura(cant, current_user)
-    if validacion_carga_rotura(cant)
-
-      self.update_attribute :rotura, self.rotura + cant
-      self.trabajos.build(type: "Rotura", cantidad: cant, hora_fecha: Time.now, user_id: current_user.try(:id)).save!
-    end
-    
-  end
-
-  def validacion_carga_rotura(cant)
-    (cant == 1) # mientras la carga de rotura sea unitaria
-    #(cant <= self.terminado - self.retrabajo)
-  end
-
-end

data/lib/tracking/registro_trabajo.rb

@@ -1,61 +0,0 @@
-# encoding: utf-8
-
-module Tracking::RegistroTrabajo
-
-
-  def registrar_trabajo(cant_trabajada, opts = {})
-
-    cant_trabajada = cant_trabajada.to_i
-
-    proximo = self.next
-
-    if validaciones_actualizar_terminados(cant_trabajada)
-      actualizar_terminados(cant_trabajada, opts)
-
-      proximo.registrar_trabajo(cant_trabajada, opts) if proximo.try(:modo) == "auto" # si proximo no es nil (si self == PrdDevTrack, proximo es nil )
-    end
-
-    # REFACTORIZAR: ESTO MEPA QUE NO SE USA MAS, ERA DE LA PREFACTURACION
-    # post_proceso(cant_trabajada)
-
-  end
-
-
-  def validaciones_actualizar_terminados(cant_trabajada)
-    validar_disponible_anterior(cant_trabajada) && validar_limite_total_pedido(cant_trabajada)
-  end
-
-  # la cantidad trabajada tiene que ser menor o igual a lo que haya di
-  def validar_disponible_anterior(cant)
-    disponibles = self.disponibles_anterior || 9999
-    (cant.to_i <= disponibles)
-  end
-
-  # la cantidad trabajada más lo que ya hay terminado y listo no puede superar al total de paños pedidos
-  def validar_limite_total_pedido(cant)
-    (self.total_pedido >= cant.to_i + self.terminado_listo)
-  end
-
-
-
-  def disponibles_anterior
-    self.prev.min_by(&:terminado_listo).try(:terminado_listo)
-  end
-
-  # terminado listo es lo que está terminado y en existencia física
-  def terminado_listo
-    terminado - retrabajo
-  end
-
-
-
-
-  def actualizar_terminados(cant_trabajada, opts = {})
-    usuario_id = opts.fetch(:usuario_id, nil)
-    self.trabajos.build(type: "Terminado", cantidad: cant_trabajada, hora_fecha: Time.now, user_id: usuario_id).save!
-    self.update_attribute :terminado, self.terminado + cant_trabajada
-  end
-
-
-
-end

data/lib/tracking/trazabilidad_elemento.rb

@@ -1,70 +0,0 @@
-# encoding: utf-8
-
-# se le pasa una medida y un elemento
-
-# ente otras cosas sabe calcular la cantidad de disponibles que hay en cada
-# puesto, no solo de pustos referidos a ese elemento, sino también a su
-# componente y a su composición
-
-# EJEMPLO
-
-# si se le pasa IM1 y E1, no solamente busca en Trazabilidad las filas con esos
-# parametros, sino también los que tienen componente E1.componente y
-# composición E1.componente.composicion
-
-
-class Tracking::TrazabilidadElemento
-
-  def initialize(item_medida, elemento, puesto_control)
-    @puesto_control = puesto_control
-    @elemento = elemento
-    @componente = elemento.componente
-    @composicion = @componente.composicion
-    @trazabilidads = []
-    @trazabilidads += Trazabilidad.where(linea_item: item_medida, elemento: elemento)
-    @trazabilidads += Trazabilidad.where(linea_item: item_medida, componente: @componente) 
-    @trazabilidads += Trazabilidad.where(linea_item: item_medida, composicion: @composicion, componente_id: nil, elemento_id: nil)
-    @trazabilidads = @trazabilidads.flatten.compact.uniq
-  end
-
-  def cantidad_terminados_listos
-    @trazabilidads.each do |t|
-      if t.puesto_control == @puesto_control
-        listo = t.terminado_listo
-        listo_siguiente = t.next.terminado_listo
-        
-        return listo - listo_siguiente
-      end  
-    end
-    raise "Error al calcular los terminados listos para Medida: #{@item_medida.ancho}x#{@item_medida.alto} ; Puesto: #{@puesto_control.nombre} ; Elemento: #{@elemento.descripcion} Id: #{@elemento.id}"
-  end
-
-  # Ejemplo: Float 6 Pulido Templado + cam + lam3+3
-  # Hoy 1/12/15 el Corte, Taller, Temp no están implementados
-  # Entonces
-  # Este método va a devovler la cantidad disponible no sólo para DVH
-  # Sino también para Corte, Taller, Etc
-  # Se usaba en el lector de roturas, selección de Puesto
-  def cantidad_terminados_listos_ultimo_auto
-    @trazabilidads.each do |t|
-      if t.puesto_control == @puesto_control
-        listo = t.terminado_listo
-        listo_siguiente = t.next.terminado_listo
-        
-        return 1 #listo - listo_siguiente
-      end  
-    end
-    raise "Error al calcular los terminados listos para Medida: #{@item_medida.ancho}x#{@item_medida.alto} ; Puesto: #{@puesto_control.nombre} ; Elemento: #{@elemento.descripcion} Id: #{@elemento.id}"
-  end
-
-  def ya_fue_laminado?
-    lista = @elemento.lista_de_puestos_del_elemento_completa
-
-    index_laminado = lista.index(PuestoControl.laminado) || (return false)
-    index_actual = lista.index(@puesto_control)
-
-    index_actual > index_laminado ? true : false
-  end
-
-end
-

data/lib/util_trazabilidad.rb

@@ -1,40 +0,0 @@
-module UtilTrazabilidad
-  
-  extend ActiveSupport::Concern
-  
-  def estado_string
-    esta_terminado? ? puesto_control.verbo_terminado : trabajos_disponibles > 0 ? "Disponible" : "No disponible"
-  end
-
-  def esta_terminado?
-    terminado - retrabajo == total_pedido
-  end
-
-  def esta_terminado_parcial?
-    (!esta_terminado? && (terminado - retrabajo > 0))
-  end
-
-  # trabajos disponibles reales en cada sección
-  # terminados seccion anterior menos terminados de la actual
-  # REVISAR ceros y nulos
-  def trabajos_disponibles
-    if self.class == Tracking::PrdIniTrack
-      return total_pedido - (terminado - retrabajo)
-    else
-      minimo_de_los_terminados_anterior = prev.min_by(&:terminado_listo)
-      return minimo_de_los_terminados_anterior.terminado_listo - terminado_listo
-    end
-  end
-
-  def puesto_actual_y_siguiente_completos?
-    prd_track_actual_completo = self.try(:esta_terminado?)
-    prd_track_siguiente_completo = self.next.try(:esta_terminado?)
-    # si están completos, entonces el icono no se muestra
-    (prd_track_actual_completo && prd_track_siguiente_completo)
-  end
-
-  def cant_disponibles_siguiente
-    self.next.try(:trabajos_disponibles)
-  end
-
-end