示例#1
0
 protected function GenerateResponse()
 {
     try {
         $this->response = AlmacenesController::SalidaLote(isset($_POST['id_lote']) ? $_POST['id_lote'] : null, isset($_POST['productos']) ? json_decode($_POST['productos']) : null, isset($_POST['motivo']) ? $_POST['motivo'] : null);
     } catch (Exception $e) {
         //Logger::error($e);
         throw new ApiException($this->error_dispatcher->invalidDatabaseOperation($e->getMessage()));
     }
 }
示例#2
0
 public static function DescontarDeAlmacenes(VentaProducto $detalle_producto, $id_sucursal)
 {
     Logger::log(" ===== Descontando de almacenes ====== ");
     //Validemos la sucursal
     $sucursal = SucursalDAO::GetByPK($id_sucursal);
     Logger::log("sucursal=" . $id_sucursal);
     if (is_null($sucursal)) {
         throw new InvalidDataException("Esta sucursal no existe");
     }
     if (!$sucursal->getActiva()) {
         throw new BusinessLogicException("No se pueden descontar de una sucursal inactiva");
     }
     //buscar sus lotes y buscar que exista el proudcto en esos lotes
     $almacenes = AlmacenDAO::search(new Almacen(array("id_sucursal" => $id_sucursal)));
     if (sizeof($almacenes) == 0) {
         throw new InvalidDataException("Esta scursal no tiene almacenes");
     }
     $existencias = ProductoDAO::buscarProductoEnSucursal($detalle_producto->getIdProducto(), $id_sucursal);
     $total_existencias = 0;
     $a_descontar = array();
     $necesito = $detalle_producto->getCantidad();
     Logger::log("Necesito " . $necesito . " del producto pid=" . $detalle_producto->getIdProducto());
     foreach ($existencias as $e) {
         Logger::log("En el lote idlote=" . $e["id_lote"] . " tengo c=" . $e["cantidad"]);
         $total_existencias += $e["cantidad"];
         if ($necesito - $e["cantidad"] < 0) {
             //me basta con el producto
             //en este lote
             Logger::log("con este me basta...");
             array_push($a_descontar, array("id_lote" => $e["id_lote"], "cantidad" => $necesito));
             $necesito = 0;
         } else {
             Logger::log("no me basta, necesito mas...");
             array_push($a_descontar, array("id_lote" => $e["id_lote"], "cantidad" => $e["cantidad"]));
             $necesito -= $e["cantidad"];
         }
     }
     if ($total_existencias < $detalle_producto->getCantidad()) {
         $_p = ProductoDAO::getByPK($detalle_producto->getIdProducto());
         throw new BusinessLogicException("No hay suficientes existencias  del producto " . $_p->getCodigoProducto() . " en los almacenes de esta sucursal.");
     }
     for ($i = 0; $i < sizeof($a_descontar); $i++) {
         Logger::log("Descontando " . $a_descontar[$i]["cantidad"] . " de lote  id_lote=" . $a_descontar[$i]["id_lote"]);
         AlmacenesController::SalidaLote($a_descontar[$i]["id_lote"], array(array("id_producto" => $detalle_producto->getIdProducto(), "cantidad" => $a_descontar[$i]["cantidad"], "id_unidad" => $detalle_producto->getIdUnidad())), "venta");
     }
     //while($cantidad > 0){
     //AlmacenController::SalidaLote( /* id_lote */, /* productos */, /* motivo */ "venta" );
     //}
     Logger::log(" ===== Descontando de almacenes [OK] ====== ");
 }
示例#3
0
 /**
  *
  * Permite dar conocer al sistema las verdaderas existencias en un almacen, o sucursal.
  *
  * @param inventario json [{id_producto: 1,id_unidad: 2,cantidad: 0,id_lote : 2}]
  * @param id_sucursal int 
  * */
 static function Fisico($inventario, $id_sucursal = "")
 {
     //POS.API.POST("api/inventario/fisico", {inventario : Ext.JSON.encode([{id_producto:8, id_unidad:1, cantidad:7, id_lote:1}]) } , {callback:function(){}})
     $s = SesionController::Actual();
     Logger::log("---------- INVENTARIO FISICO SE ENCONTRARON " . count($inventario) . " AJUSTES ----------");
     foreach ($inventario as $producto) {
         //self::ajustarLoteProducto($producto->id_lote, $producto->id_producto, $producto->id_unidad);
         //[{id_producto: 1,id_unidad: 2,cantidad: 0,id_lote : 2}]
         $producto->nombre = ProductoDAO::getByPK($producto->id_producto)->getNombreProducto();
         Logger::log(" Estamos en {$producto->nombre}, id_unidad {$producto->id_unidad}, {$producto->cantidad} " . UnidadMedidaDAO::getByPK($producto->id_unidad)->getAbreviacion() . ", lote {$producto->id_lote}");
         try {
             //verificamos si el lote indicado existe
             if (is_null($producto->id_lote) || strlen($producto->id_lote) == 0) {
                 throw new InvalidDataException("No selecciono a que lote ira el producto {$producto->id_producto}");
             }
             //busquemos el id del lote
             if (!($lote = LoteDAO::getByPK($producto->id_lote))) {
                 throw new InvalidDataException("No se tiene registro del lote {$producto->id_lote}");
             }
             //verificamos que exista la unidad de medida y este activa
             if (!UnidadMedidaDAO::getByPK($producto->id_unidad)) {
                 throw new InvalidDataException("La unidad de medida {$producto->id_unidad} no existe, o no esta activa.");
             }
             //busquemos si este producto ya existe en este lote
             $lote_producto = LoteProductoDAO::getByPK($lote->getIdLote(), $producto->id_producto);
             if (is_null($lote_producto)) {
                 Logger::log("El producto no estaba en el lote, se insertara");
                 /*
                  //no existe, insertar
                  $loteProducto = new LoteProducto(array(
                  "id_lote" => $lote->getIdLote(),
                  "id_producto" => $producto->id_producto,
                  "cantidad" => $producto->cantidad,
                  "id_unidad" => $producto->id_unidad
                  ));
                 
                  LoteProductoDAO::save($loteProducto);
                  Logger::log("Se guardo el LoteProducto : id_lote {$lote->getIdLote()}, id_producto {$producto->id_producto}, cantidad {$producto->cantidad} id_unidad {$producto->id_unidad}");
                 
                  $loteEntrada = new LoteEntrada(array(
                  "id_lote" => $lote->getIdLote(),
                  "id_usuario" => $s['id_usuario'],
                  "fecha_registro" => time(),
                  "motivo" => "Entrada por ajuste de inventario"
                  ));
                 
                  LoteEntradaDAO::save($loteEntrada);
                  Logger::log("Se guardo el LoteEntrada: id_lote {$lote->getIdLote()}, id_usuario {$s['id_usuario']}, motivo {Entrada por ajuste de inventario}");
                 */
                 AlmacenesController::EntradaLote($lote->getIdLote(), array($producto), "Entrada por ajuste de inventario");
             } else {
                 Logger::log("El producto si estaba en el lote, verificaremos las cantidades");
                 //revisemos si es de la misma unidad
                 if ($lote_producto->getIdUnidad() == $producto->id_unidad) {
                     Logger::log("Se encontro que la unidad enviada es igual a la unidad del lote producto");
                     Logger::log("Se detecto una merma de {$producto->cantidad} " . UnidadMedidaDAO::getByPK($producto->id_unidad)->getAbreviacion() . " de {$producto->nombre}");
                     //$existencias_lote = ProductoDAO::ExistenciasLote($producto->id_producto, $lote->getIdLote(), $lote_producto->getIdUnidad());
                     $existencias_lote = ProductoDAO::ExistenciasTotales($producto->id_producto);
                     Logger::log("Se encontraron {$existencias_lote} existencias en el lote {$lote->getIdLote()} para el producto {$producto->id_producto}");
                 } else {
                     Logger::log("Se encontro que la unidad enviada es diferente a la unidad del lote producto, se procede a transformar");
                     //$existencias_lote = ProductoDAO::ExistenciasLote($producto->id_producto, $lote->getIdLote(), $lote_producto->getIdUnidad());
                     $existencias_lote = ProductoDAO::ExistenciasTotales($producto->id_producto);
                     Logger::log("Se encontraron {$existencias_lote} " . UnidadMedidaDAO::getByPK($lote_producto->getIdUnidad())->getAbreviacion() . " en el lote {$lote->getIdLote()} para el producto " . ProductoDAO::getByPK($producto->id_producto)->getNombreProducto() . " , nosotros necesitamos que se transforme en " . UnidadMedidaDAO::getByPK($producto->id_unidad)->getAbreviacion());
                     //var_dump($producto->id_unidad, $lote_producto->getIdUnidad(), $existencias_lote);
                     try {
                         Logger::log("Enviara a transformar unidad base : {$producto->id_unidad}, unidad a transformar : {$lote_producto->getIdUnidad()}, cantidad a transformar : {$existencias_lote}");
                         $existencias_lote = UnidadMedidaDAO::convertir($lote_producto->getIdUnidad(), $producto->id_unidad, $existencias_lote);
                         Logger::log("Como producto de la transformacion se obtuvo {$existencias_lote} ");
                     } catch (BusinessLogicException $ide) {
                         //no se pudo convertir porque son de
                         //diferentes categorias
                         throw $ide;
                         //mostrar una excpetion mas fresona
                     }
                 }
                 Logger::log("se evaluara {$existencias_lote} - {$producto->cantidad}");
                 //hacemos el ajuste
                 $diff = $existencias_lote - $producto->cantidad;
                 if ($diff > 0) {
                     //entonces hay una merma y se reporta una salida al lote igual a $diff, especificando en motivo el id del movimiento realizado
                     //se actualiza la cantidad de producto en lote producto
                     //AlmacenesController::Salida($l->getIdAlmacen(), $producto, "100");
                     $diff = abs($diff);
                     Logger::log("Se detecto una merma de {$diff} " . UnidadMedidaDAO::getByPK($producto->id_unidad)->getAbreviacion() . " de {$producto->nombre}");
                     /*
                      $lote_salida = new LoteSalida(array(
                      "id_lote" => $lote->getIdLote(),
                      "id_usuario" => $s['id_usuario'],
                      "fecha_registro" => time(),
                      "motivo" => "Salida de producto por ajuste de inventario (merma)"
                      ));
                     
                      LoteSalidaDAO::save($lote_salida);
                     
                      Logger::log("Se creo un lote salida id_lote {$lote->getIdLote()}, id_usuario {$s['id_usuario']}, motivo Salida de producto por ajuste de inventario (merma)");
                     
                      $lote_salida_producto = new LoteSalidaProducto(array(
                      "id_lote_salida" => $lote_salida->getIdLoteSalida(),
                      "id_producto" => $producto->id_producto,
                      "id_unidad" => $producto->id_unidad,
                      "cantidad" => $producto->cantidad
                      ));
                     
                      LoteSalidaProductoDAO::save($lote_salida_producto);
                     
                      Logger::log("Se creo un lote salida producto con id_lote_salida {$lote_salida->getIdLoteSalida()}, id_producto {$producto->id_producto}, id_unidad {$producto->id_unidad}, cantidad {$producto->cantidad}");
                     */
                     AlmacenesController::SalidaLote($lote->getIdLote(), array(array("id_producto" => $producto->id_producto, "cantidad" => $diff, "id_unidad" => $producto->id_unidad)), "Salida de producto por ajuste de inventario (merma)");
                 }
                 if ($diff < 0) {
                     $diff = abs($diff);
                     //entonces hay un sobrante y se reporta una entrada al lote igual a $diff, especificando en motivo el id del movimiento realizado
                     //se actualiza la cantidad de producto en lote producto
                     //AlmacenesController::Entrada($l->getIdAlmacen(), $producto, "101");
                     Logger::log("Se detecto una sobrante de {$diff} " . UnidadMedidaDAO::getByPK($producto->id_unidad)->getAbreviacion());
                     /*
                      $lote_entrada = new LoteEntrada(array(
                      "id_lote" => $lote->getIdLote(),
                      "id_usuario" => $s['id_usuario'],
                      "fecha_registro" => time(),
                      "motivo" => "Entrada de producto por ajuste de inventario (sobrante)"
                      ));
                     
                      LoteEntradaDAO::save($lote_entrada);
                     
                      Logger::log("Se creo un lote entrada id_lote {$lote->getIdLote()}, id_usuario {$s['id_usuario']}, motivo Entrada de producto por ajuste de inventario (sobrante)");
                     
                      $lote_entrada_producto = new LoteEntradaProducto(array(
                      "id_lote_entrada" => $lote_entrada->getIdLote(),
                      "id_producto" => $producto->id_producto,
                      "id_unidad" => $producto->id_unidad,
                      "cantidad" => $producto->cantidad
                      ));
                     
                      LoteEntradaProductoDAO::save($lote_entrada_producto);
                     
                      Logger::log("Se creo un lote entrada producto con id_lote_entrada {$lote_entrada->getIdLoteEntrada()}, id_producto {$producto->id_producto}, id_unidad {$producto->id_unidad}, cantidad {$producto->cantidad}");
                     */
                     //AlmacenesController::EntradaLote($lote->getIdLote(), array($producto), "Entrada de producto por ajuste de inventario (sobrante)");
                     AlmacenesController::EntradaLote($lote->getIdLote(), array(array("id_producto" => $producto->id_producto, "cantidad" => $diff, "id_unidad" => $producto->id_unidad)), "Entrada de producto por ajuste de inventario (sobrante)");
                 }
                 //TODO:HAY QUE AHCER PRUEBAS EXHAUSTIVAS PARA VER SI ESTE ULTIMO BLOQUE DE CODIGO SE DEBERIA DE ELIMINAR
                 //actualizamos las existencias de lote producto
                 if ($diff != 0) {
                     Logger::log("Se procede a hacer el ajuste del lote producto");
                     self::ajustarLoteProducto($producto->id_lote, $producto->id_producto, $producto->id_unidad);
                 } else {
                     Logger::log("Se detecto que la cantidad en tote producto concuerda con la cantidad inventariada, pero aun asi se llamara al metodo de ajuste de prodcuto");
                     self::ajustarLoteProducto($producto->id_lote, $producto->id_producto, $producto->id_unidad);
                 }
             }
         } catch (InvalidDataException $e) {
             Logger::error($e);
             DAO::transRollback();
             throw $e;
         } catch (exception $e) {
             Logger::error($e);
             DAO::transRollback();
             throw new InvalidDatabaseOperationException($e);
         }
     }
 }
 /**
  *
  *
  *	Lotes
  *
  **/
 public function testLotes()
 {
     $almacenes = AlmacenesController::Buscar(true);
     $almacenId = $almacenes["resultados"][0]->getIdAlmacen();
     //nuevo lote
     $nLote = AlmacenesController::NuevoLote($almacenId);
     $this->assertNotNull($l = LoteDAO::getByPK($nLote["id_lote"]));
     $producto = new Producto(array("compra_en_mostrador" => false, "metodo_costeo" => "precio", "precio" => 123.123, "activo" => true, "codigo_producto" => time() . "tp", "nombre_producto" => time() . "np", "costo_estandar" => 12.3123, "id_unidad" => 1));
     ProductoDAO::save($producto);
     $r = AlmacenesController::EntradaLote($nLote["id_lote"], array(array("id_producto" => $producto->getIdProducto(), "cantidad" => 23)));
     //Vamos a validar estas tablas
     $this->assertNotNull(LoteEntradaDAO::getByPK($r["id_entrada_lote"]));
     $this->assertNotNull(LoteProductoDAO::getByPK($nLote["id_lote"], $producto->getIdProducto()));
     $this->assertNotNull(LoteEntradaProductoDAO::getByPK($r["id_entrada_lote"], $producto->getIdProducto(), 1));
     //sacar de ese lote, uno por uno hasta llegar a retirar todo
     for ($i = 0; $i < 23; $i++) {
         AlmacenesController::SalidaLote($nLote["id_lote"], array(array("id_producto" => $producto->getIdProducto(), "cantidad" => 1, "id_unidad" => 1)));
     }
     Logger::log("la siguiente vez que retire algo, debe de arrojar una exception");
     try {
         AlmacenesController::SalidaLote($nLote["id_lote"], array(array("id_producto" => $producto->getIdProducto(), "cantidad" => 1, "id_unidad" => 1)));
         //esto nunca se deberia de ejecutar
         $this->assertTrue(false);
     } catch (InvalidDataException $ivde) {
         $this->assertNotNull($ivde);
     }
 }