function calcExistencias($id_unidad, $row)
{
$unidadM = UnidadMedidaDAO::getByPK($id_unidad);
if (is_null($unidadM)) {
return ProductoDAO::ExistenciasTotales($row["id_producto"]);
}
return ProductoDAO::ExistenciasTotales($row["id_producto"]) . " " . $unidadM->getAbreviacion();
}
public function testEditarUnidadUdm()
{
//se crea un nueva udm y categoria
$abreviatura_Udm = self::RandomString(5, true, FALSE, FALSE);
$abreviatura_Udm_editada = self::RandomString(5, true, FALSE, FALSE);
$descripcion_Udm = self::RandomString(15, true, FALSE, FALSE);
$descripcion_catUdm = self::RandomString(15, true, FALSE, FALSE);
$cat = ProductosController::NuevaCategoriaUdm($descripcion_catUdm);
$udm = ProductosController::NuevaUnidadUdm($abreviatura = $abreviatura_Udm, $descripcion = $descripcion_Udm, $factor_conversion = 1, $id_categoria_unidad_medida = $cat['id_categoria_unidad_medida'], $tipo_unidad_medida = "Referencia UdM para esta categoria");
$this->assertInternalType("int", $udm["id_unidad_medida"], "---- 'testEditarUnidadUdm' 'id_unidad_medida' NO ES UN ENTERO");
$udmObj = UnidadMedidaDAO::getByPK($udm['id_unidad_medida']);
//se edita la Udm recien ingresada
ProductosController::EditarUnidadUdm($id_unidad_medida = $udmObj->getIdUnidadMedida(), $id_categoria_unidad_medida = $udmObj->getIdCategoriaUnidadMedida(), $abreviacion = $abreviatura_Udm_editada, $descripcion = "descripcion", $factor_conversion = $udmObj->getFactorConversion(), $tipo_unidad_medida = $udmObj->getTipoUnidadMedida());
//se redefine el obj para comparar valores
$udmObj2 = UnidadMedidaDAO::getByPK($udmObj->getIdUnidadMedida());
$this->assertEquals($udmObj2->getAbreviacion(), $abreviatura_Udm_editada, "NO SE EDITÓ LA CategoriaUdm");
}
private static function printProducts(&$pdf, $productos)
{
$opciones_tabla = array();
$opciones_tabla['showLines'] = 0;
$opciones_tabla['showHeadings'] = 0;
$opciones_tabla['shaded'] = 0;
$opciones_tabla['fontSize'] = 8;
$opciones_tabla['xOrientation'] = 'right';
$opciones_tabla['xPos'] = self::puntos_cm(7.5);
$opciones_tabla['width'] = self::puntos_cm(11);
$opciones_tabla['textCol'] = array(0, 0, 0);
$opciones_tabla['titleFontSize'] = 12;
$opciones_tabla['rowGap'] = 3;
$opciones_tabla['colGap'] = 3;
$opciones_tabla['xPos'] = self::puntos_cm(14.2);
$opciones_tabla['showLines'] = 0;
$opciones_tabla['shaded'] = 2;
$opciones_tabla['shadeCol'] = array(1, 1, 1);
$opciones_tabla['shadeCol2'] = array(0.8984375, 0.95703125, 0.99609375);
/* *************************
* PRODUCTOS
* ************************* */
$elementos = array(array('cantidad' => 'Cantidad', 'descripcion' => 'Descripcion ', 'precio' => 'Precio', 'importe' => 'Importe'));
$subtotal = 0;
$total = 0;
$impuesto = 0;
foreach ($productos as $p) {
if ($p instanceof VentaProducto) {
$prodDao = ProductoDAO::getByPK($p->getIdProducto());
if (!is_null($prodDao)) {
$prod['cantidad'] = $p->getCantidad();
if (!is_null($p->getIdUnidad())) {
$unidad = UnidadMedidaDAO::getByPK($p->getIdUnidad());
if (!is_null($unidad)) {
$prod['cantidad'] .= " " . $unidad->getAbreviacion();
}
}
$prod['descripcion'] = $prodDao->getNombreProducto();
$prod['precio'] = FormatMoney($p->getPrecio(), DONT_USE_HTML);
$prod['importe'] = FormatMoney($p->getPrecio() * $p->getCantidad(), DONT_USE_HTML);
$subtotal += $p->getPrecio() * $p->getCantidad();
$total = $subtotal;
array_push($elementos, $prod);
} else {
Logger::error("El producto que se intentaba imprimir ya no existe !!");
}
} else {
if ($p instanceof VentaOrden) {
$ordenDao = OrdenDeServicioDAO::getByPK($p->getIdOrdenDeServicio());
$serv = ServicioDAO::getByPK($ordenDao->getIdServicio());
$prod['cantidad'] = "-";
$prod['descripcion'] = $serv->getNombreServicio();
$prod['precio'] = FormatMoney($p->getPrecio(), DONT_USE_HTML);
$prod['importe'] = FormatMoney($p->getPrecio(), DONT_USE_HTML);
$subtotal += $p->getPrecio();
$total = $subtotal;
array_push($elementos, $prod);
} else {
if ($p instanceof Venta) {
array_push($elementos, array("cantidad" => "", "descripcion" => "", "precio" => "Subtotal", "importe" => FormatMoney($p->getSubtotal(), DONT_USE_HTML)));
array_push($elementos, array("cantidad" => "", "descripcion" => "", "precio" => "Descuento", "importe" => FormatMoney($p->getDescuento(), DONT_USE_HTML)));
array_push($elementos, array("cantidad" => "", "descripcion" => "", "precio" => "IVA", "importe" => FormatMoney($p->getImpuesto(), DONT_USE_HTML)));
array_push($elementos, array("cantidad" => "", "descripcion" => "", "precio" => "Total", "importe" => FormatMoney($p->getTotal(), DONT_USE_HTML)));
$letra = new CNumeroaLetra();
$letra->setNumero($p->getTotal());
array_push($elementos, array("cantidad" => "", "descripcion" => $letra->letra(), "precio" => "", "importe" => ""));
}
}
}
}
$pdf->ezSetY(self::puntos_cm(18.6));
$opciones_tabla['xPos'] = self::puntos_cm(2);
$opciones_tabla['width'] = self::puntos_cm(16.2);
$pdf->ezTable($elementos, "", "", $opciones_tabla);
}
/**
*
* 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);
}
}
}
public function testDesactivar()
{
ProductosController::DesactivarUnidadUdm(1);
$unidad = UnidadMedidaDAO::getByPK(1);
$this->assertEquals($unidad->getActiva(), 0);
$unidad->setActiva(1);
UnidadMedidaDAO::save($unidad);
}
<?php
define("BYPASS_INSTANCE_CHECK", false);
require_once "../../../server/bootstrap.php";
$page = new GerenciaComponentPage();
//
// Parametros necesarios
//
$page->requireParam("umid", "GET", "Esta unidad no existe.");
$esta_unidad = UnidadMedidaDAO::getByPK($_GET["umid"]);
//
// Titulo de la pagina
//
$page->addComponent(new TitleComponent("Editar unidad medida " . $esta_unidad->getAbreviacion(), 2));
//
// Forma de usuario
//
$form = new DAOFormComponent($esta_unidad);
$form->createComboBoxJoin("id_categoria_unidad_medida", "descripcion", CategoriaUnidadMedidaDAO::getAll());
$form->createComboBoxJoin("tipo_unidad_medida", "tipo_unidad_medida", array("Referencia UdM para esta categoria", "Mayor que la UdM de referencia", "Menor que la UdM de referencia"));
$form->hideField(array("id_unidad_medida", "activa"));
$form->sendHidden("id_unidad_medida");
$form->sendHidden("activa");
$form->addApiCall("api/producto/udm/unidad/editar/", "POST");
$form->onApiCallSuccessRedirect("productos.lista.unidad_medida.php");
$form->makeObligatory(array("id_categoria_unidad_medida", "tipo_unidad_medida"));
$page->addComponent($form);
$page->render();
function rCantidad($v, $obj)
{
$um = UnidadMedidaDAO::getByPK($obj["id_unidad"]);
return $v . " " . $um->getAbreviacion();
}
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"])));
}
// estos precios si vienen de la tabla de
// actualizacion de precio
"precioIntersucursal" => $p->getPrecio(),
"precioIntersucursalProcesado" => $p->getPrecio()
));
}
$json = json_encode($json);
printf('{ "success": true, "hash" : "%s" , "datos": %s }', md5($json), $json); */
$inventario = ProductoDAO::getAll();
$json = array();
foreach ($inventario as $producto) {
Array_push($json, array("productoID" => $producto->getIdProducto(), "descripcion" => $producto->getNombreProducto(), "tratamiento" => 0, "medida" => UnidadMedidaDAO::getByPK($producto->getIdUnidad())->getAbreviacion(), "agrupacion" => UnidadMedidaDAO::getByPK($producto->getIdUnidad())->getAbreviacion(), "agrupacionTam" => 1, "precioPorAgrupacion" => $producto->getPrecio(), "precioVenta" => $producto->getPrecio(), "precioVentaProcesado" => $producto->getPrecio(), "existencias" => 0, "existenciasOriginales" => 0, "existenciasProcesadas" => 0, "precioIntersucursal" => $producto->getPrecio(), "precioIntersucursalProcesado" => $producto->getPrecio()));
}
$json = json_encode($json);
printf('{ "success": true, "hash" : "%s" , "datos": %s }', md5($json), $json);
break;
case 500:
require_once 'controller/personal.controller.php';
break;
case 600:
require_once 'controller/efectivo.controller.php';
break;
case 700:
require_once 'controller/sucursales.controller.php';
break;
case 800:
require_once 'controller/ventas.controller.php';
}
}
// sacar los productos correspondientes
function filter($product)
{
return $product->getVisibleEnVc();
}
$products = array_filter(ProductosController::Lista(), "filter");
// dar formato a los campos como corresponda
foreach ($products as $product) {
$product->setPrecio(FormatMoney($product->getPrecio()));
$product->setCostoEstandar(FormatMoney($product->getCostoEstandar()));
$product->setCostoExtraAlmacen(FormatMoney($product->getCostoExtraAlmacen()));
if ($product->getCompraEnMostrador()) {
$product->setCompraEnMostrador("Sí");
} else {
$product->setCompraEnMostrador("No");
}
$unidad = UnidadMedidaDAO::getByPK($product->getIdUnidadCompra());
if (!is_null($unidad)) {
$product->setIdUnidadCompra($unidad->getDescripcion());
}
$unidad = UnidadMedidaDAO::getByPK($product->getIdUnidad());
if (!is_null($unidad)) {
$product->setIdUnidad($unidad->getDescripcion());
}
}
$table = new TableComponent($columns, $products);
$table->addOnClick("id_producto", "(function(a) {window.location = 'productos.ver.php?pid=' + a;})");
$page->addComponent($table);
$page->render();
function toReadableUnidad($v, $obj)
{
$u = UnidadMedidaDAO::getByPK($v);
return $u->getDescripcion();
}
/**
*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;
}
