예제 #1
0
 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;
 }
예제 #2
0
 /**
      *
      * Ver la lista de productos y sus existencias, se puede filtrar por empresa, sucursal, almac?n, y lote.
       Se puede ordenar por los atributos de producto.
      *
      * @param existencia_mayor_que float Se regresaran los productos cuya existencia sea mayor a la especificada por este valor
      * @param existencia_igual_que float Se regresaran los productos cuya existencia sea igual a la especificada por este valor
      * @param existencia_menor_que float Se regresaran los productos cuya existencia sea menor a la especificada por este valor
      * @param id_empresa int Id de la empresa de la cual se vern los productos.
      * @param id_sucursal int Id de la sucursal de la cual se vern los productos.
      * @param id_almacen	 int Id del almacen del cual se vern los productos.
      * @param activo	 bool Si es true, mostrar solo los productos que estn activos, si es false mostrar solo los productos que no lo sean.
      * @param id_lote int Id del lote del cual se veran los productos en existencia
      * @return existecias json Lista de existencias
      * */
 public static function Existencias($id_almacen = null, $id_empresa = null, $id_producto = null, $id_sucursal = null)
 {
     $e = AlmacenDAO::Existencias();
     return array("resultados" => $e, "numero_de_resultados" => sizeof($e));
     $daoProductos = ProductoDAO::getAll();
     $aOut = array();
     $daoAlmacenes = AlmacenDAO::getAll();
     for ($iProd = 0; $iProd < sizeof($daoProductos); $iProd++) {
         //por cada almacen
         for ($iAl = 0; $iAl < sizeof($daoAlmacenes); $iAl++) {
             //buscar sus lotes
         }
         array_push($aOut, $daoProductos[$iProd]->asArray());
     }
     return array("numero_de_resultados" => sizeof($aOut), "resultados" => $aOut);
     //Si se recibe un id producto, solo se listan las existencias de dicho producto, se puede combinar con
     //los demas parametros. Si no se recibe ningun otro, se realiza un acumulado de este producto en todos los almacenes.
     //
     //Si se recibe un id almacen, solo se listan las existencias de dicho almacen
     //
     //Si se recibe la variable id_empresa o id_sucursal, se listara un acumulado de todos los productos
     //con las cantidades de productos de los diferentes almacenes dentro de ella
     //
     //Cuando se recibe alguno de ellos, primero se consiguen todos los almacenes que le pertencen, despues
     //se consiguen todos los productos de cada almacen y se guardan en un arreglo temporal que despues es ordenado.
     //EL arreglo ordenado es el que se envia.
     //
     //Si no se recibe ningun parametro, se listaran todos los productos existentes en todos los almacenes
     $productos_almacenes = array();
     //Si solo se especifica un producto, se regresa un arreglo con las sucursales donde esta ese producto y
     //la cantidad total en cada una
     if (!is_null($id_producto) && is_null($id_almacen) && is_null($id_empresa) && is_null($id_sucursal)) {
         //Se obtienen todas las sucursales y se llama recursivamente a este metodo
         $sucursales = SucursalDAO::search(new Sucursal(array("activa" => 1)));
         $result = array();
         foreach ($sucursales as $sucursal) {
             $p_a = self::Existencias(null, null, $id_producto, $sucursal->getIdSucursal());
             if ($p_a["numero_de_resultados"] > 0) {
                 foreach ($p_a["resultados"] as $p) {
                     $result["id_sucursal"] = $sucursal->getIdSucursal();
                     $suc = SucursalDAO::getByPK($sucursal->getIdSucursal());
                     $result["nombre_sucursal"] = $suc->getDescripcion();
                     $result["id_producto"] = $p->getIdProducto();
                     $result["id_unidad"] = $p->getIdUnidad();
                     $result["cantidad"] = $p->getCantidad();
                     array_push($productos_almacenes, $result);
                 }
             }
         }
     } else {
         if (!is_null($id_almacen)) {
             //Se buscan los registros de productos que cumplan con el almacen y con el producto recibidos
             $productos_almacenes = LoteProductoDAO::search(new LoteProducto(array("id_almacen" => $id_almacen, "id_producto" => $id_producto)));
         } else {
             if (!is_null($id_empresa)) {
                 //Se obtienen todos los almacenes de la empresa
                 $almacenes_empresa = AlmacenDAO::search(new Almacen(array("id_empresa" => $id_empresa)));
                 $productos_almacenes_empresa = array();
                 //Se recorre cada almacen y se obtiene un arreglo de sus productos, para poder agruparlos, tenemos que seacarlos
                 //de su arreglo y ponerlos en un arreglo general
                 foreach ($almacenes_empresa as $almacen_empresa) {
                     //Se obtiene el arreglo de productos
                     $productos_almacen_empresa = LoteProductoDAO::search(new LoteProducto(array("id_almacen" => $almacen_empresa->getIdAlmacen(), "id_producto" => $id_producto)));
                     //Se vacía el arreglo en uno general
                     foreach ($productos_almacen_empresa as $producto_almacen_empresa) {
                         array_push($productos_almacenes_empresa, $producto_almacen_empresa);
                     }
                 }
                 //Se agrupan los productos iguales
                 $productos_almacenes = self::AgruparProductos($productos_almacenes_empresa);
             } else {
                 if (!is_null($id_sucursal)) {
                     //Se obtienen todos los almacenes de la sucursal
                     $almacenes_sucursal = AlmacenDAO::search(new Almacen(array("id_sucursal" => $id_sucursal)));
                     $productos_almacenes_sucursal = array();
                     //Se recorre cada almacen y se obtiene un arreglo de sus productos, para poder agruparlos, tenemos que sacarlos
                     //de su arreglo y ponerlos en un arreglo general
                     foreach ($almacenes_sucursal as $almacen_sucursal) {
                         //Se obtiene el arreglo de productos
                         $productos_almacen_sucursal = LoteProductoDAO::search(new LoteProducto(array("id_almacen" => $almacen_sucursal->getIdAlmacen(), "id_producto" => $id_producto)));
                         //Se vacía el arreglo en uno general
                         foreach ($productos_almacen_sucursal as $producto_almacen_sucursal) {
                             array_push($productos_almacenes_sucursal, $producto_almacen_sucursal);
                         }
                     }
                     //Se agrupan los productos iguales
                     $productos_almacenes = self::AgruparProductos($productos_almacenes_sucursal);
                 } else {
                     //Se obtienen todos los almacenes
                     $almacenes = AlmacenDAO::getAll();
                     $productos_almacen = array();
                     //Se recorre cada almacen y se obtiene un arreglo de sus productos, para poder agruparlos, tenemos que sacarlos
                     //de su arreglo y ponerlos en un arreglo general
                     foreach ($almacenes as $almacen) {
                         //Se obtiene el arreglo de productos
                         $productos_a = LoteProductoDAO::search(new LoteProducto(array("id_almacen" => $almacen->getIdAlmacen(), "id_producto" => $id_producto)));
                         //Se vacía el arreglo en uno general
                         foreach ($productos_a as $p_a) {
                             array_push($productos_almacen, $p_a);
                         }
                     }
                     //Se agrupan los productos iguales
                     $productos_almacenes = self::AgruparProductos($productos_almacen);
                 }
             }
         }
     }
     Logger::log("Se listan " . count($productos_almacenes) . " registros");
     $existencias = array("resultados" => $productos_almacenes, "numero_de_resultados" => count($productos_almacenes));
     return $existencias;
 }
예제 #3
0
    $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";
예제 #4
0
 /**
  *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;
 }
예제 #5
0
 /**
  *
  *Descativa un almacen. Para poder desactivar un almacen, este tiene que estar vac?o
  *
  * @param id_almacen int Id del almacen a desactivar
  **/
 static function Desactivar($id_almacen)
 {
     $almacen = AlmacenDAO::getByPK($id_almacen);
     //verifica que el almacen exista, que este activo y que su tipo no sea de consignacion
     if (is_null($almacen)) {
         Logger::error("El almacen con id: " . $id_almacen . " no existe");
         throw new InvalidDataException("El almacen con id: " . $id_almacen . " no existe");
     }
     if (!$almacen->getActivo()) {
         Logger::warn("El almacen ya esta inactivo");
         throw new BusinessLogicException("El almacen ya esta inactivo");
     }
     if ($almacen->getIdTipoAlmacen() == 2) {
         Logger::error("No se puede eliminar con este metodo un almacen de tipo consignacion");
         throw new BusinessLogicException("No se puede eliminar con este metodo un almacen de tipo consignacion");
     }
     //verificamos que se hayan terminado todos los productos de los lotes de esta sucursal
     $lotes_almacen = LoteDAO::search(new Lote(array("id_almacen" => $id_almacen)));
     Logger::log("El almacen a desactivar tiene " . sizeof($lotes_almacen) . " lotes.");
     foreach ($lotes_almacen as $lote_almacen) {
         $lote_producto = LoteProductoDAO::search(new LoteProducto(array("id_lote" => $lote_almacen->getIdLote())));
         foreach ($lote_producto as $lote) {
             if ($lote->getCantidad() > 0) {
                 Logger::error("El lote {$lote->getIdLote()} tiene cantidad > 0 (" . $lote->getCantidad() . ") ");
                 throw new BusinessLogicException("El lote {$lote->getIdLote()} no esta vacio.");
             }
         }
     }
     //TODO : Revisar como se manejaran los traspasos ya que por ahora se estan omitiendo
     $almacen->setActivo(0);
     DAO::transBegin();
     try {
         AlmacenDAO::save($almacen);
     } catch (Exception $e) {
         DAO::transRollback();
         Logger::error("No se pudo eliminar el almacen: " . $e);
         throw new InvalidDatabaseOperationException("No se pudo eliminar el almacen");
     }
     DAO::transEnd();
     Logger::log("Almacen eliminado exitosamente");
 }