/**
  *
  * 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);
         }
     }
 }
Beispiel #2
0
 /**
  *
  *Metodo que cancela una venta
  *
  * @param id_venta string Id de la venta a cancelar
  **/
 public static function Cancelar($id_venta, $billetes = null, $id_caja = null)
 {
     Logger::log("======= Cancenlando venta " . $id_venta . " ===========");
     //valida que la venta exista y que este activa
     $venta = VentaDAO::getByPK($id_venta);
     if ($venta == null) {
         Logger::error("La venta con id: " . $id_venta . " no existe");
         throw new Exception("La venta con id: " . $id_venta . " no existe");
     }
     if ($venta->getCancelada()) {
         Logger::warn("La venta ya ha sido cancelada");
         return;
     }
     //Deja la venta como cancelada y la guarda.
     $venta->setCancelada(1);
     //Obtiene al usuario al que se le vendio
     $usuario = UsuarioDAO::getByPK($venta->getIdCompradorVenta());
     if ($usuario == null) {
         Logger::error("FATAL!!! Esta venta apunta a un usuario que no existe");
         throw new Exception("FATAL!!! Esta venta apunta a un usuario que no existe");
     }
     DAO::transBegin();
     // regresar de almacenes
     // obtener los productos que se vendieron
     // insertalos como neuvo ingreso
     $detalle = VentaProductoDAO::search(new VentaProducto(array("id_venta" => $id_venta)));
     for ($detalleIterator = 0; $detalleIterator < sizeof($detalle); $detalleIterator++) {
         //por cada producto
         //  --- procesos ---
         //  -insertar en productoempresa
         //  -insertar en loteproducto
         //  -insertar en entradalote
         //  -si el tipo de precio de venta es costo, actualizar
         //  -insertar compra producto
         $p = $detalle[$detalleIterator];
         try {
             /*
             ProductoEmpresaDAO::save( new ProductoEmpresa( array(
                     "id_empresa" => $id_empresa,
                     "id_producto" => $p->getIdProducto()
                 ) ) );
                 
             
             if(is_null($p->lote)){
                 throw new InvalidDataException("No selecciono a que lote ira el producto " . $p->id_producto);
             }
             
             
             if(strlen($p->lote) == 0){
                 throw new InvalidDataException("No selecciono a que lote ira el producto " . $p->id_producto);
             }
             */
             //busquemos el id del lote
             $l = LoteDAO::getByPk(1);
             //busquemos la unidad que nos mandaron
             $uResults = UnidadMedidaDAO::search(new UnidadMedida(array("id_unidad_medida" => $p->getIdUnidad(), "activa" => 1)));
             if (sizeof($uResults) != 1) {
                 throw new InvalidDataException("La unidad de medida `" . $p->id_unidad . "` no existe, o no esta activa.");
             }
             //busequemos si este producto ya existe en este lote
             $lp = LoteProductoDAO::getByPK($l->getIdLote(), $p->getIdProducto());
             if (is_null($lp)) {
                 //no existe, insertar
                 $loteProducto = new LoteProducto(array("id_lote" => $l->getIdLote(), "id_producto" => $p->getIdProducto(), "cantidad" => $p->getCantidad(), "id_unidad" => $p->getIdUnidad()));
                 LoteProductoDAO::save($loteProducto);
             } else {
                 //ya existe, sumar
                 //revisemos si es de la misma unidad
                 if ($lp->getIdUnidad() == $p->getIdUnidad()) {
                     //es igual, solo hay que sumar
                     $lp->setCantidad($lp->getCantidad() + $p->getCantidad());
                 } else {
                     //no es igual, hay que convertir
                     try {
                         $r = UnidadMedidaDAO::convertir($p->getIdUnidad(), $lp->getIdUnidad(), $p->getCantidad());
                     } catch (BusinessLogicException $ide) {
                         //no se pudo convertir porque son de
                         //diferentes categorias
                         throw $ide;
                         //mostrar una excpetion mas fresona
                     }
                     $lp->setCantidad($lp->getCantidad() + $r);
                 }
                 //$lp->setCantidad( $lp->getCantidad() + $p->cantidad );
                 LoteProductoDAO::save($lp);
             }
             $s = SesionController::getCurrentUser();
             $loteEntrada = new LoteEntrada(array("id_lote" => $l->getIdLote(), "id_usuario" => $s->getIdUsuario(), "fecha_registro" => time(), "motivo" => "Venta (" . $id_venta . ") Cancelada"));
             LoteEntradaDAO::save($loteEntrada);
             LoteEntradaProductoDAO::save(new LoteEntradaProducto(array("id_lote_entrada" => $loteEntrada->getIdLoteEntrada(), "id_producto" => $p->getIdProducto(), "id_unidad" => $p->getIdUnidad(), "cantidad" => $p->getCantidad())));
             /*
             $compraProducto = new CompraProducto(array(
                     "id_compra"         => $compra->getIdCompra(),
                     "id_producto"       => $p->id_producto,
                     "cantidad"          => $p->cantidad,
                     "precio"            => $p->precio,
                     "descuento"         => 0,
                     "impuesto"          => 0,
                     "id_unidad"         => $p->id_unidad,
                     "retencion"         => 0
                 ) );
             
             CompraProductoDAO::save ( $compraProducto);
             */
         } catch (InvalidDataException $e) {
             Logger::error($e);
             DAO::transRollback();
             throw $e;
         } catch (exception $e) {
             Logger::error($e);
             DAO::transRollback();
             throw new InvalidDatabaseOperationException($e);
         }
     }
     try {
         VentaDAO::save($venta);
         //Si la venta fue a credito, se cancelan todos los abonos hechos al mismo y el dinero se queda a cuenta del usuario.
         if ($venta->getTipoDeVenta() == "credito") {
             $abono_venta = new AbonoVenta();
             $abono_venta->setIdVenta($id_venta);
             $abonos = AbonoVentaDAO::search($abono_venta);
             foreach ($abonos as $abono) {
                 if (!$abono->getCancelado()) {
                     CargosYAbonosController::EliminarAbono($abono->getIdAbonoVenta(), "Venta cancelada", 0, 1, 0, null, null);
                 }
             }
             $usuario->setSaldoDelEjercicio($usuario->getSaldoDelEjercicio() + $venta->getTotal());
             UsuarioDAO::save($usuario);
         } else {
             if ($venta->getTipoDeVenta() == "contado" && !is_null($id_caja)) {
                 CajasController::modificarCaja($id_caja, 1, $billetes, $venta->getTotal());
             }
         }
     } catch (Exception $e) {
         DAO::transRollback();
         Logger::error("No se pudo cancelar la venta: " . $e);
         throw new Exception("No se pudo cancelar la venta");
     }
     DAO::transEnd();
     Logger::log("Venta cancelada exitosamente");
 }
 public static function IncrementarDeAlmacenes($d_producto, $id_sucursal)
 {
     //busquemos el primer lote de esa sucursal
     $l = LoteDAO::getAll();
     $l = $l[0];
     //busquemos la unidad que nos mandaron
     $uResults = UnidadMedidaDAO::getByPK($d_producto["id_unidad"]);
     if (is_null($uResults)) {
         throw new InvalidDataException("La unidad de medida `" . $d_producto["id_unidad"] . "` no existe, o no esta activa.");
     }
     //busequemos si este producto ya existe en este lote
     $lp = LoteProductoDAO::getByPK($l->getIdLote(), $d_producto["id_producto"]);
     if (is_null($lp)) {
         //no existe, insertar
         $loteProducto = new LoteProducto(array("id_lote" => $l->getIdLote(), "id_producto" => $d_producto["id_producto"], "cantidad" => $d_producto["cantidad"], "id_unidad" => $d_producto["id_unidad"]));
         LoteProductoDAO::save($loteProducto);
     } else {
         //ya existe, sumar
         //revisemos si es de la misma unidad
         if ($lp->getIdUnidad() == $d_producto["id_unidad"]) {
             //es igual, solo hay que sumar
             $lp->setCantidad($lp->getCantidad() + $d_producto["cantidad"]);
         } else {
             //no es igual, hay que convertir
             try {
                 $r = UnidadMedidaDAO::convertir($d_producto["id_unidad"], $lp->getIdUnidad(), $d_producto["cantidad"]);
             } catch (BusinessLogicException $ide) {
                 //no se pudo convertir porque son de
                 //diferentes categorias
                 throw $ide;
                 //mostrar una excpetion mas fresona
             }
             $lp->setCantidad($lp->getCantidad() + $r);
         }
         //$lp->setCantidad( $lp->getCantidad() + $p->cantidad );
         LoteProductoDAO::save($lp);
     }
     $s = SesionController::Actual();
     $loteEntrada = new LoteEntrada(array("id_lote" => $l->getIdLote(), "id_usuario" => 1, "fecha_registro" => time(), "motivo" => "Compra a Proveedor"));
     LoteEntradaDAO::save($loteEntrada);
     LoteEntradaProductoDAO::save(new LoteEntradaProducto(array("id_lote_entrada" => $loteEntrada->getIdLoteEntrada(), "id_producto" => $d_producto["id_producto"], "id_unidad" => $d_producto["id_unidad"], "cantidad" => $d_producto["cantidad"])));
 }
Beispiel #4
0
 /**
  *
  *Registra una nueva compra fuera de caja, puede usarse para que el administrador haga directamente una compra. El usuario y al sucursal seran tomados de la sesion. La fecha sera tomada del servidor. La empresa sera tomada del almacen del cual fueron tomados los productos.
  *
  * @param descuento float Monto descontado por descuentos
  * @param subtotal float Total de la compra antes de impuestos y descuentos.
  * @param detalle json Objeto que contendr el arreglo de id productos, cantidad,  precio, descuento, id de unidad y procesado que involucran esta compra.
  * @param impuesto float Monto agregado por impuestos
  * @param tipo_compra string Si la compra es a credito o de contado
  * @param retencion float Monto agregado por retenciones
  * @param id_usuario_compra int Id usuario al que se le compra, si es a una sucursal, se pone el id en negativo
  * @param id_empresa int Id de la empresa a nombre de la cual se hace la compra
  * @param total float Total de la compra
  * @param cheques json Si el tipo de pago es con cheque, se almacena el nombre del banco, el monto y los ultimos 4 numeros del o de los cheques
  * @param saldo float Cantidad pagada de la 
  * @param tipo_de_pago string Si el pago sera en efectivo, con cheque o tarjeta
  * @return id_compra int Id autogenerado por la inserci�n de la compra
  **/
 public static function Nueva($descuento, $detalle, $id_empresa, $id_usuario_compra, $impuesto, $retencion, $subtotal, $tipo_compra, $total, $cheques = null, $id_sucursal = null, $saldo = 0, $tipo_de_pago = null)
 {
     Logger::log(" ===== Creando nueva compra... ===== ");
     //validemos al comprador
     $proveedor = UsuarioDAO::getByPK($id_usuario_compra);
     if (is_null($proveedor)) {
         Logger::error("el provedor {$id_usuario_compra} no exite");
         throw new InvalidDataException("El proveedor no existe");
     }
     if ($proveedor->getActivo() == false) {
         throw new BusinessLogicException("No se puede comprar de un proveedor no activo.");
     }
     //validemos la empresa
     $empresa = EmpresaDAO::getByPK($id_empresa);
     if (is_null($empresa)) {
         Logger::error("La empresa {$id_empresa} no existe");
         throw new InvalidDataException("La empresa que compra no existe.");
     }
     if ($empresa->getActivo() == false) {
         throw new BusinessLogicException("Una empresa inactiva no puede hacer compras.");
     }
     //validemos los valores conocidos
     //( 0 >= descuento > 100, subtotal > 0, total >= subtotal, etc etc)
     //validemos sucursal
     $sucursal = null;
     if (!is_null($id_sucursal) && strlen($id_sucursal) > 0) {
         $sucursal = SucursalDAO::getByPK($id_sucursal);
         if (is_null($sucursal)) {
             Logger::error("La sucursal {$id_sucursal} no existe");
             //throw new InvalidDataException("La sucural que se envio no existe.");
         }
     }
     //validemos detalles de compra
     //debe traer
     // 	-id_producto
     //	-cantidad
     //	-precio
     //	-lote
     if (!is_array($detalle)) {
         throw InvalidDataException("El detalle no es un arreglo");
     }
     for ($detalleIterator = 0; $detalleIterator < sizeof($detalle); $detalleIterator++) {
         //por cada producto
         //	-debe existir
         //	-si se lo compro a un proveedor no hay pedo
         // 	 si se lo compro a un cliente, debe de tener comprar_caja = 1
         //	-debe tener cantidad mayor a 0
         //	-que exista el lote a donde va a ir
         $p = $detalle[$detalleIterator];
         if (!isset($p->precio)) {
             throw new InvalidArgumentException("No se envio el precio");
         }
         if (!isset($p->id_producto)) {
             throw new InvalidArgumentException("No se envio el id_producto");
         }
         if (!isset($p->cantidad)) {
             throw new InvalidArgumentException("No se envio la cantidad");
         }
         if (!isset($p->lote)) {
             throw new InvalidArgumentException("No se envio el lote");
         }
         $producto = ProductoDAO::getByPK($p->id_producto);
         if (is_null($producto)) {
             throw new InvalidArgumentException("El producto a comprar no existe");
         }
         if ($p->cantidad <= 0) {
             throw new InvalidArgumentException("No puedes comprar 0 unidades");
         }
     }
     $s = SesionController::getCurrentUser();
     //terminaron las validaciones
     $compra = new Compra();
     $compra->setIdVendedorCompra($id_usuario_compra);
     $compra->setTipoDeCompra($tipo_compra);
     $compra->setFecha(time());
     $compra->setSubtotal($subtotal);
     $compra->setImpuesto($impuesto);
     $compra->setDescuento($descuento);
     $compra->setTotal($subtotal + $impuesto);
     $compra->setIdUsuario($s->getIdUsuario());
     $compra->setIdEmpresa($id_empresa);
     $compra->setSaldo(0);
     $compra->setCancelada(false);
     $compra->setTipoDePago($tipo_de_pago);
     $compra->setRetencion(0);
     try {
         DAO::transBegin();
         CompraDAO::save($compra);
     } catch (Exception $e) {
         DAO::transRollback();
         throw InvalidDatabaseOperationException($e);
     }
     for ($detalleIterator = 0; $detalleIterator < sizeof($detalle); $detalleIterator++) {
         //por cada producto
         //	--- procesos ---
         //	-insertar en productoempresa
         //	-insertar en loteproducto
         //	-insertar en entradalote
         //	-si el tipo de precio de venta es costo, actualizar
         //	-insertar compra producto
         $p = $detalle[$detalleIterator];
         try {
             ProductoEmpresaDAO::save(new ProductoEmpresa(array("id_empresa" => $id_empresa, "id_producto" => $p->id_producto)));
             if (is_null($p->lote)) {
                 throw new InvalidDataException("No selecciono a que lote ira el producto " . $p->id_producto);
             }
             if (strlen($p->lote) == 0) {
                 throw new InvalidDataException("No selecciono a que lote ira el producto " . $p->id_producto);
             }
             //busquemos el id del lote
             $l = LoteDAO::search(new Lote(array("folio" => $p->lote)));
             $l = $l[0];
             //busquemos la unidad que nos mandaron
             $uAbreviacion = $p->id_unidad;
             $uResults = UnidadMedidaDAO::search(new UnidadMedida(array("abreviacion" => $uAbreviacion, "activa" => 1)));
             if (sizeof($uResults) != 1) {
                 throw new InvalidDataException("La unidad de medida `" . $p->id_unidad . "` no existe, o no esta activa.");
             } else {
                 $p->id_unidad = $uResults[0]->getIdUnidadMedida();
             }
             //busequemos si este producto ya existe en este lote
             $lp = LoteProductoDAO::getByPK($l->getIdLote(), $p->id_producto);
             if (is_null($lp)) {
                 //no existe, insertar
                 $loteProducto = new LoteProducto(array("id_lote" => $l->getIdLote(), "id_producto" => $p->id_producto, "cantidad" => $p->cantidad, "id_unidad" => $p->id_unidad));
                 LoteProductoDAO::save($loteProducto);
             } else {
                 //ya existe, sumar
                 //revisemos si es de la misma unidad
                 if ($lp->getIdUnidad() == $p->id_unidad) {
                     //es igual, solo hay que sumar
                     $lp->setCantidad($lp->getCantidad() + $p->cantidad);
                 } else {
                     //no es igual, hay que convertir
                     try {
                         $r = UnidadMedidaDAO::convertir($p->id_unidad, $lp->getIdUnidad(), $p->cantidad);
                     } catch (BusinessLogicException $ide) {
                         //no se pudo convertir porque son de
                         //diferentes categorias
                         throw $ide;
                         //mostrar una excpetion mas fresona
                     }
                     $lp->setCantidad($lp->getCantidad() + $r);
                 }
                 //$lp->setCantidad( $lp->getCantidad() + $p->cantidad );
                 LoteProductoDAO::save($lp);
             }
             $loteEntrada = new LoteEntrada(array("id_lote" => $l->getIdLote(), "id_usuario" => $s->getIdUsuario(), "fecha_registro" => time(), "motivo" => "Compra a Proveedor"));
             LoteEntradaDAO::save($loteEntrada);
             LoteEntradaProductoDAO::save(new LoteEntradaProducto(array("id_lote_entrada" => $loteEntrada->getIdLoteEntrada(), "id_producto" => $p->id_producto, "id_unidad" => $p->id_unidad, "cantidad" => $p->cantidad)));
             $compraProducto = new CompraProducto(array("id_compra" => $compra->getIdCompra(), "id_producto" => $p->id_producto, "cantidad" => $p->cantidad, "precio" => $p->precio, "descuento" => 0, "impuesto" => 0, "id_unidad" => $p->id_unidad, "retencion" => 0));
             CompraProductoDAO::save($compraProducto);
         } catch (InvalidDataException $e) {
             Logger::error($e);
             DAO::transRollback();
             throw $e;
         } catch (exception $e) {
             Logger::error($e);
             DAO::transRollback();
             throw new InvalidDatabaseOperationException($e);
         }
     }
     //for
     try {
         DAO::transEnd();
     } catch (Exception $e) {
         throw InvalidDatabaseOperationException($e);
     }
     Logger::log("===== COMPRA " . $compra->getIdCompra() . " EXITOSA ===== ");
     return array("id_compra" => $compra->getIdCompra());
 }
 /**
  *
  *
  *	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);
     }
 }
 /**
  *
  *Envia productos fuera del almacen. Ya sea que sea un traspaso de un alamcen a otro o por motivos de inventarios fisicos.
  *
  * @param id_lote int Id del lote de donde se descontaran los productos.
  * @param productos json Objeto que contendra los ids de los productos que seran sacados del alamcen con sus cantidades y sus unidades
  * @param motivo string Motivo de la salida del producto
  * @return id_salida_lote int ID de la salida del producto
  **/
 static function SalidaLote($id_lote, $productos, $motivo = null)
 {
     if (is_null(LoteDAO::getByPK($id_lote))) {
         throw new InvalidDataException("este lote no existe");
     }
     if (!is_array($productos)) {
         throw new InvalidDataException("productos no es un array");
     }
     $sesion = SesionController::Actual();
     DAO::transBegin();
     $sl = new LoteSalida();
     $sl->setIdLote($id_lote);
     $sl->setIdUsuario($sesion["id_usuario"]);
     $sl->setFechaRegistro(time());
     $sl->setMotivo(is_null($motivo) ? "" : $motivo);
     try {
         LoteSalidaDAO::save($sl);
     } catch (Exception $e) {
         DAO::transRollback();
         throw new InvalidDatabaseOperationException($e);
     }
     for ($i = 0; $i < sizeof($productos); $i++) {
         if (!is_array($productos[$i])) {
             throw new InvalidDataException("El producto en la posicion {$i} no es un arreglo como se esperaba");
         }
         if (!array_key_exists("id_producto", $productos[$i])) {
             throw new InvalidDataException("El producto en {$i} no tiene id_prodcuto");
         }
         if (!array_key_exists("cantidad", $productos[$i])) {
             throw new InvalidDataException("El producto en {$i} no tiene cantidad");
         }
         if (is_null(ProductoDAO::getByPK($productos[$i]["id_producto"]))) {
             throw new InvalidDataException("El producto " . $productos[$i]["id_producto"] . " no existe.");
         }
         $lp = LoteProductoDAO::getByPK($id_lote, $productos[$i]["id_producto"]);
         if (is_null($lp)) {
             throw new InvalidDataException("El lote {$id_lote} no tiene el producto " . $productos[$i]["id_producto"]);
         }
         if ($productos[$i]["cantidad"] > $lp->getCantidad()) {
             throw new InvalidDataException("Estas intentando sacar mas de lo que hay en el lote.");
         }
         if (!isset($productos[$i]["id_unidad"])) {
             throw new InvalidDataException("El producto " . $productos[$i]["id_producto"] . " proporcionado no tiene id_unidad");
         }
         $equivalencia = UnidadMedidaDAO::convertir($productos[$i]["id_unidad"], $lp->getIdUnidad(), $productos[$i]["cantidad"]);
         if ($equivalencia > $lp->getCantidad()) {
             Logger::log("Se Comparara {$equivalencia} > {$lp->getCantidad()}");
             throw new InvalidDataException("Estas intentando sacar mas de lo que hay en el lote.");
         }
         $lp->setCantidad($lp->getCantidad() - $productos[$i]["cantidad"]);
         try {
             LoteProductoDAO::save($lp);
             LoteSalidaProductoDAO::save(new LoteSalidaProducto(array("id_lote_salida" => $sl->getIdLoteSalida(), "id_producto" => $productos[$i]["id_producto"], "id_unidad" => $productos[$i]["id_unidad"], "cantidad" => $productos[$i]["cantidad"])));
             Logger::log("Removiendo qty=" . $productos[$i]["cantidad"] . "; prod=" . $productos[$i]["id_producto"] . "; lote=" . $id_lote);
         } catch (Exception $e) {
             Logger::error($e);
             throw new InvalidDatabaseOperationException($e);
         }
     }
     DAO::transEnd();
     return array("id_salida_lote" => $sl->getIdLoteSalida());
 }