spf_tracking 0.0.20 → 0.0.22

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YmIxY2UwYmQ1MzJlYjg5NDEzZTMxNTQwNDk0NDQxZDk4MDBhOGJhMQ==
+    OWE5YTllMjBhMDhhMGY5MTA2NDYwYmIwY2U1ODBhZDkyOGQxNjZhNg==
   data.tar.gz: !binary |-
-    YjU5YWNiMjlhZTg5YjhlYmJiZmE0Mjk1NzcxNDg1YzlkMDAxOWZlZA==
+    YmQ5NDI1NTVkNzIzMjlhNDM5NWZiOWJiNGU5NjZlZWUxNTJlYmFjOQ==
 SHA512:
   metadata.gz: !binary |-
-    MmZiZTkzMDI5YzlhMzcxZTQwNWYwMTE3MGMwNTJhY2QwMGEwYzU0ZmZmZmQ3
-    YjE3Zjc4YzYzYzVmOWY5ZDRkNDA2ZjA3Y2U5MGVmMWQ5MTY5YjZkOGUwMmVi
-    MzU2MDM0ZjcyZDM0YjAxMTlhZGU4ZTZhYjY4NGU2YzVmZjVmYjU=
+    YjY4NWVmNDljYTdmNzA5MDI4NGM1ZDNmY2MwYWJiOTEzZjE1OTg4MGQzYjE4
+    NWQ5NGFkN2M0ZGVmZTA2MTQ2NDA0NDZiZjRjODRhYTgxN2Y5NTI5N2U0N2Q0
+    NDI1MzI3OTNlN2M2MzI5ZjNkMmIwNjg5ODI0ZDVmZjhjOGJmZDM=
   data.tar.gz: !binary |-
-    MzBiMzFkMzhiM2I5ZGE3ODZmZGEyZmE1MzA1NTM2ODI3ODYyYjI4ZmMxZmY5
-    YTNjMzU3MGM2MGNjNjU0YmI5YzM3YTM5MmZjYjIwOTczZmNlNzcxNDA1ZGNh
-    MDFiNzhkNjgxMjNmMDA0Y2JmYTUzZTBlMDg5ZmI5MzM4MzNmMTQ=
+    Yjg0ZTY5Yjk2Njc5NTFlNWE0ODM0Y2ZmMzdiZDdiNTQxYjU5OWJmNWE2YTlm
+    N2Q4ZjhmOGQzOTgwNGFlZTFmOGNhNjk5YTkwNGUwOWQ1Mzc1NWQ5MDIyMDMz
+    NWVjMzAyNTg0NmQ2ZDUzY2EzM2ZhMDgxYWE2NTg5NGFlNmI5OWY=

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+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

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

data/Rakefile

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,77 @@
+# 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

@@ -0,0 +1,28 @@
+# 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

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,47 @@
+# 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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,233 @@
+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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,87 @@
+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

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

data/lib/spf_tracking/version.rb

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

data/lib/spf_tracking.rb

@@ -0,0 +1,10 @@
+require 'service_track/busca_ultimo_puesto_completo'
+require 'service_track/create_entrega_rapida'
+require 'service_track/create_rotura'
+require 'service_track/nueva_rotura'
+require 'service_track/update_retrabajos'
+
+require 'tracking/carga_rotura'
+require 'tracking/registro_trabajo'
+require 'tracking/trazabilidad_elemento'
+require 'tracking/routes'

data/lib/tasks/spf_tracking_tasks.rake

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

data/lib/tracking/carga_rotura.rb

@@ -0,0 +1,20 @@
+# 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

@@ -0,0 +1,61 @@
+# 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

@@ -0,0 +1,70 @@
+# 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

@@ -0,0 +1,40 @@
+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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spf_tracking
 version: !ruby/object:Gem::Version
-  version: 0.0.20
+  version: 0.0.22
 platform: ruby
 authors:
 - Carlos Ramseyer
@@ -31,7 +31,30 @@ 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