public static function ExistenciasTotales($id_producto, $id_lote = null, $id_sucursal = null)
{
$total = 0;
//calcula las existencias de todos los productos de todos los lotes y todas las sucursales
if (is_null($id_sucursal) && is_null($id_lote)) {
$lotes = LoteProductoDAO::search(new LoteProducto(array("id_producto" => $id_producto)));
foreach ($lotes as $l) {
$total += $l->getCantidad();
}
return $total;
}
//calcula las existencias de un lote en especifico
if (is_null($id_sucursal) && !is_null($id_lote)) {
$lotes = LoteProductoDAO::search(new LoteProducto(array("id_producto" => $id_producto, "id_lote" => $id_lote)));
foreach ($lotes as $l) {
$total += $l->getCantidad();
}
return $total;
}
//calcula las existencias de un producto de todos los lotes de una sucursal en especifico
if (!is_null($id_sucursal) && is_null($id_lote)) {
//obtenemos los lotes de una sucursal
$almacenes = AlmacenDAO::search(new Almacen(array("id_sucursal" => $id_sucursal)));
//iteramos los almacenes para sacar sus lotes
foreach ($almacenes as $almacen) {
$lotes = LoteDAO::search(new Lote(array("id_almacen" => $almacen->getIdAlacen())));
//iteramos los lotes para conocer las existencias del producto en ese lote especifico
foreach ($lotes as $lote) {
$loteProducto = LoteProductoDAO::search(new LoteProducto(array("id_producto" => $id_producto, "id_lote" => $lote->getIdLote())));
foreach ($loteProducto as $l) {
$total += $l->getCantidad();
}
}
}
return $total;
}
return $total;
}
/**
*
* 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);
}
}
}
$este_producto->setIdUnidadCompra($um->getDescripcion());
}
$um = UnidadMedidaDAO::getByPK($este_producto->getIdUnidad());
if (!is_null($um)) {
$este_producto->setIdUnidad($um->getDescripcion());
}
//$form->createComboBoxJoinDistintName("id_unidad_compra","id_unidad_medida" ,"descripcion", UnidadMedidaDAO::getAll(), $este_producto->getIdUnidadCompra());
//$form->createComboBoxJoinDistintName("id_unidad", "id_unidad_medida", "descripcion", UnidadMedidaDAO::getAll(), $este_producto->getIdUnidad());
$form = new DAOFormComponent($este_producto);
$form->setEditable(false);
$form->hideField(array("id_producto", "foto_del_producto", "precio", "control_de_existencia", "activo", "compra_en_mostrador"));
$form->setCaption("id_unidad", "Unidad de medida");
$form->setCaption("id_unidad_compra", "Unidad de medida al comprar");
$page->addComponent($form);
$page->nextTab("Existencias");
$existencias = LoteProductoDAO::search(new LoteProducto(array("id_producto" => $_GET["pid"])));
$table_e = new TableComponent(array("id_lote" => "Lote", "cantidad" => "Cantidad", "id_unidad" => "Unidad"), $existencias);
function lotename($l)
{
$lvo = LoteDAO::GetByPK($l);
if (is_null($lvo)) {
return "";
}
$avo = AlmacenDAO::getByPK($lvo->getIdAlmacen());
return $lvo->getFolio() . " <div style='font-size:11px; color: gray;'>Almacen " . $avo->getNombre() . "</div>";
}
function unidadname($l)
{
$ll = UnidadMedidaDAO::GetByPK($l);
if (is_null($ll)) {
return "ERROR";
/**
*
*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"])));
}
/**
*
*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());
}
/**
*Lista los productos por empresa, almacen y lote
*/
public static function listarProductosLote($activo = null, $id_almacen = null, $id_empresa = null)
{
//objeto que se regresara
$company = new stdClass();
//contiene todas las empresas
$company->empresas = array();
//obtenemos todas las empresas
$empresas = EmpresaDAO::getAll();
//iteramos las empresas para obtener sus almacenes
foreach ($empresas as $empresa) {
//insertamos la empresa a la compañia
$e = new stdClass();
$e->id_empresa = $empresa->getIdEmpresa();
$e->nombre = $empresa->getRazonSocial();
$e->almacenes = array();
$almacenes = AlmacenDAO::search(new Almacen(array("id_empresa" => $empresa->getIdEmpresa())));
//iteramos todos los almacenes de la empresa
foreach ($almacenes as $almacen) {
$a = new stdClass();
$a->id_almacen = $almacen->getIdAlmacen();
$a->nombre = $almacen->getNombre();
$a->id_sucursal = $almacen->getIdSucursal();
$a->sucursal = SucursalDAO::getByPK($a->id_sucursal)->getRazonSocial();
$a->lotes = array();
//obtenemos todos los lotes del almacen
$lotes = LoteDAO::search(new Lote(array("id_almacen" => $almacen->getIdAlmacen())));
//iteramos todos los lotes del almacen
foreach ($lotes as $lote) {
$l = new StdClass();
$l->id_lote = $lote->getIdLote();
$l->id_almacen = $lote->getIdAlmacen();
$l->folio = $lote->getFolio();
$l->lotes_producto = array();
//obtenemos todos los productos de un lote
$lotes_producto = LoteProductoDAO::search(new LoteProducto(array("id_lote" => $lote->getIdLote())));
//iteramos lodos los lotes con producto que perteneces al lote
foreach ($lotes_producto as $lote_producto) {
$producto = ProductoDAO::getByPK($lote_producto->getIdProducto());
$lp = new StdClass();
$lp->id_lote = $lote_producto->getIdLote();
$lp->id_producto = $lote_producto->getIdProducto();
$lp->cantidad = $lote_producto->getCantidad();
$lp->id_unidad = $lote_producto->getIdUnidad();
$lp->unidad = UnidadMedidaDAO::getByPK($lp->id_unidad)->getAbreviacion();
//$lp->recalculo = ProductoDAO::ExistenciasTotales($lp->id_producto);
$lp->recalculo = ProductoDAO::ExistenciasLote($lp->id_producto, $lp->id_lote, $lp->id_unidad);
$lp->nombre = $producto->getNombreProducto();
$lp->codigo = $producto->getCodigoProducto();
array_push($l->lotes_producto, $lp);
}
array_push($a->lotes, $l);
}
array_push($e->almacenes, $a);
}
array_push($company->empresas, $e);
}
return $company;
}
/**
*
*
* 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());
}