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;
}
$page = new GerenciaComponentPage();
//
// Parametros necesarios
//
$page->requireParam("tid", "GET", "Este tipo de almacen no existe.");
$este_tipo_almacen = TipoAlmacenDAO::getByPK($_GET["tid"]);
//
// Titulo de la pagina
//
$page->addComponent(new TitleComponent("Detalles de " . $este_tipo_almacen->getDescripcion(), 2));
//
// Menu de opciones
//
$menu = new MenuComponent();
$menu->addItem("Editar este tipo de almacen", "sucursales.editar.tipo_almacen.php?tid=" . $_GET["tid"]);
$almacenes = AlmacenDAO::search(new Almacen(array("id_tipo_almacen" => $_GET["tid"])));
if (empty($almacenes)) {
$btn_eliminar = new MenuItem("Eliminar este tipo de almacen", null);
$btn_eliminar->addApiCall("api/sucursal/tipo_almacen/eliminar", "GET");
$btn_eliminar->onApiCallSuccessRedirect("sucursales.lista.tipo_almacen.php");
$btn_eliminar->addName("eliminar");
$funcion_eliminar = " function eliminar_sucursal(btn){" . "if(btn == 'yes')" . "{" . "var p = {};" . "p.id_tipo_almacen = " . $_GET["tid"] . ";" . "sendToApi_eliminar(p);" . "}" . "}" . " " . "function confirmar(){" . " Ext.MessageBox.confirm('Eliminar', 'Desea eliminar este tipo de almacen?', eliminar_sucursal );" . "}";
$btn_eliminar->addOnClick("confirmar", $funcion_eliminar);
$menu->addMenuItem($btn_eliminar);
}
$page->addComponent($menu);
//
// Forma de producto
//
$form = new DAOFormComponent($este_tipo_almacen);
$form->setEditable(false);
/**
*
* 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;
}
['Carol2', 'Bob', '']
*/
<?php
$empresas = EmpresaDAO::getAll();
//iterar empresas
foreach ($empresas as $e) {
echo "[ { v: '" . $e->getRazonSocial() . "', f: '<div>Empresa</div>" . $e->getRazonSocial() . "' } , '' ],\n ";
//buscar sucursales de compui
$id_sucursales = SucursalEmpresaDAO::search(new SucursalEmpresa(array("id_empresa" => $e->getIdEmpresa())));
//iterear sucursales
foreach ($id_sucursales as $id_s) {
$s = SucursalDAO::getByPK($id_s->getIdSucursal());
echo "/* sucursal, empresa */[ { v: '" . $s->getRazonSocial() . "', f: '<div>Sucursal</div>" . $s->getRazonSocial() . "' } , '" . $e->getRazonSocial() . "' ], \n";
//iterar almacenes
$almacenes = AlmacenDAO::search(new Almacen(array("id_almacen")));
foreach ($almacenes as $a) {
echo "/* almacen, sucursal */ [ { v: '" . $a->getNombre() . "', f: '<div>Almacen</div>" . $a->getNombre() . "' }, '" . $s->getRazonSocial() . "' ], \n";
//lotes de esa sucursal
$lotes = LoteDAO::search(new Lote(array("id_almacen" => $a->getIdAlmacen())));
foreach ($lotes as $l) {
echo "/* lote, almacen */[ { v: '" . $l->getFolio() . "', f: '<div>Lote</div>" . $l->getFolio() . "' }, '" . $a->getNombre() . "' ], \n";
}
}
//for-each sucursales
}
//for-each id_sucursales
}
//for-each empresas
?>
]);
/**
*
*Desactiva una sucursal. Para poder desactivar una sucursal su saldo a favor tiene que ser mayor a cero y sus almacenes tienen que estar vacios.
*
* @author Juan Manuel García Carmona <*****@*****.**>
* @param id_sucursal int Id de la sucursal a desactivar
**/
public static function Eliminar($id_sucursal)
{
//verifica que la caja exista y este activa
if (!($sucursal = SucursalDAO::getByPK($id_sucursal))) {
Logger::error("La sucursal con id :" . $id_sucursal . " no existe");
throw new Exception("La sucursal con id :" . $id_sucursal . " no existe");
}
if (!$sucursal->getActiva()) {
Logger::error("La sucursal actualmente esta desactivada");
throw new Exception("La sucursal actualmente esta desactivada");
}
//verificamos si los almacenes de la sucursal ya han sido previamente desactivados
$almacenes = AlmacenDAO::search(new Almacen(array("id_sucursal" => $id_sucursal)));
//Se eliminan los almacenes de esta sucursal
foreach ($almacenes as $almacen) {
if ($almacen->getActivo() == true) {
Logger::error("No se puede desactivar la sucursal dado que el almacen" . $almacen->getNombre() . " sigue activo");
throw new Exception("No se puede desactivar la sucursal dado que el almacen" . $almacen->getNombre() . " sigue activo");
}
}
//verificamos si hay cajas abiertas
$cajas = CajaDAO::search(new Caja(array("id_sucursal" => $id_sucursal)));
foreach ($cajas as $c) {
if ($c->getAbierta == true) {
Logger::error("No se puede desactivar la sucursal dado que la caja" . $c->getDescripcion() . " sigue abierta");
throw new Exception("No se puede desactivar la sucursal dado que la caja" . $c->getDescripcion() . " sigue abierta");
}
}
$sucursal->setFechaBaja(time());
$sucursal->setActiva(0);
DAO::transBegin();
try {
SucursalDAO::save($sucursal);
} catch (Exception $e) {
DAO::transRollback();
Logger::error("La sucursal no pudo ser desactivada: " . $e);
throw new Exception("La sucursal no pudo ser desactivada");
}
DAO::transEnd();
Logger::log("Sucursal desactivada exitosamente");
}
<?php
define("BYPASS_INSTANCE_CHECK", false);
require_once "../../../server/bootstrap.php";
$page = new GerenciaComponentPage();
//titulos
$page->addComponent(new TitleComponent("Programar traspaso de almacen"));
//forma de traspaso a almacen
$form = new DAOFormComponent(array(new Traspaso()));
$form->hideField(array("id_traspaso", "id_usuario_programa", "id_usuario_envia", "fecha_envio", "id_usuario_recibe", "fecha_recibo", "estado", "cancelado", "completo"));
// $form->renameField( array(
// "nombre" => "razon_social",
// "codigo_usuario" => "codigo_cliente"
// ));
$form->addApiCall("api/sucursal/almacen/traspaso/programar", "GET");
$form->makeObligatory(array("fecha_envio_programada", "id_almacen_recibe", "id_almacen_envia"));
$form->createComboBoxJoinDistintName("id_almacen_recibe", "id_almacen", "nombre", AlmacenDAO::search(new Almacen(array("activo" => 1))));
$form->createComboBoxJoinDistintName("id_almacen_envia", "id_almacen", "nombre", AlmacenDAO::search(new Almacen(array("activo" => 1))));
$form->addField("id_producto", "Productos", "text", "", "productos");
$form->createListBoxJoin("id_producto", "nombre_producto", ProductoDAO::search(new Producto(array("activo" => 1))));
$form->renameField(array("id_producto" => "productos"));
$page->addComponent($form);
$page->render();
/**
*
*Iniciar una orden de consignaci?n. La fecha sera tomada del servidor.
*
* @param productos json Objeto que contendra los ids de los productos que se daran a consignacion a ese cliente con sus cantidades. Se incluira el id del almacen del cual seran tomados para determinar a que empresa pertenece esta consignacion
* @param id_consignatario int Id del cliente al que se le hace la consignacion
* @return id_consignacion int Id de la consignacion autogenerado por la insercion.
**/
public static function Nueva($fecha_termino, $folio, $id_consignatario, $productos, $tipo_consignacion, $fecha_envio_programada = null)
{
Logger::log("Creando nueva consignacion");
//Se valida al consignatario
$e = self::validarConsignatario($id_consignatario);
if (is_string($e)) {
Logger::error($e);
throw new Exception($e);
}
$consignatario = UsuarioDAO::getByPK($id_consignatario);
//Se obtiene al usuario de la sesion actual
$id_usuario = LoginController::getCurrentUser();
if (is_null($id_usuario)) {
Logger::error("No se pudo obtener al usuario de la sesion, ya inicio sesion?");
throw new Exception("No se pudo obtener al usuario de la sesion, ya inicio sesion?");
}
//Valida el parametro tipo de consignacion
if ($tipo_consignacion != "credito" && $tipo_consignacion != "contado") {
Logger::error("El parametro tipo de consignacion (" . $tipo_consignacion . ") es invalido");
throw new Exception("El parametro tipo de consignacion (" . $tipo_consignacion . ") es invalido");
}
//Si no se recibio fecha de envio, se toma la fecha actual
if (is_null($fecha_envio_programada)) {
$fecha_envio_programada = date("Y-m-d H:i:s");
}
$consignacion = new Consignacion(array("id_cliente" => $id_consignatario, "id_usuario" => $id_usuario, "fecha_creacion" => date("Y-m-d H:i:s"), "activa" => 1, "cancelada" => 0, "folio" => $folio, "fecha_termino" => $fecha_termino, "saldo" => 0, "tipo_consignacion" => $tipo_consignacion));
//Se agrupan los productos que vienen del mismo almacen en subarreglos para
//programar un solo traspaso por almacen.
$productos_por_almacen = array();
$num_productos = count($productos);
for ($i = 0; $i < $num_productos; $i++) {
if ($productos[i] == null) {
continue;
}
$temp = array();
array_push($temp, $productos[i]);
for ($j = $i + 1; $j < $num_productos; $j++) {
if ($productos[$i]["id_almacen"] == $productos[$j]["id_almacen"]) {
array_push($temp, $productos[$j]);
$productos[$j] = null;
}
}
$productos[$i] = null;
array_push($productos_por_almacen, $temp);
}
DAO::transBegin();
try {
ConsignacionDAO::save($consignacion);
$consignacion_producto = new ConsignacionProducto(array("id_consignacion" => $consignacion->getIdConsignacion()));
foreach ($productos_por_almacen as $producto_por_almacen) {
//Se validan los parametros obtenidos del arreglo de productos
foreach ($producto_por_almacen as $producto) {
$validar = self::validarConsignacionProducto($producto["id_producto"], $producto["id_unidad"], $producto["cantidad"], $producto["impuesto"], $producto["descuento"], $producto["retencion"], $producto["precio"]);
if (is_string($validar)) {
throw new Exception($validar);
}
$validar = self::validarAlmacen($producto["id_almacen"]);
if (is_string($validar)) {
throw new Eception($validar);
}
}
/*
* El consignatario puede contar con algún o ningún almacen de tipo consignacion,
* pero solo tendra uno por empresa, esto quiere decir que todos los productos recibidos
* seran repartidos en estos almacenes de acuerdo a la empresa a la que pertenece
* el almacen de donde son extraidos.
*
* Si el consignatario no cuenta con un almacen para la empresa de ese producto, se creara uno
* nuevo y se realizara la transferencia.
*/
//Se obtiene el id de la empresa de la cual vienen los productos
$id_empresa = AlmacenDAO::getByPK($producto_por_almacen[0]["id_almacen"])->getIdEmpresa();
//Se busca el almacen de consignacion de este cliente para esta empresa
$almacen = null;
$almacenes = AlmacenDAO::search(new Almacen(array("id_empresa" => $id_empresa, "nombre" => $consignatario->getCodigoUsuario(), "id_sucursal" => 0)));
//Si no existe, se crea
if (empty($almacenes)) {
$almacen = new Almacen(array("id_sucursal" => 0, "id_empresa" => $id_empresa, "id_tipo_almacen" => 2, "nombre" => $consignatario->getCodigoUsuario(), "descripcion" => "Almacen de consignacion del usuario " . $consignatario->getNombre() . " con clave " . $consignatario->getCodigoUsuario() . " para la empresa " . $id_empresa, "activo" => 1));
AlmacenDAO::save($almacen);
} else {
$almacen = $almacenes[0];
}
//Se prepara el arreglo de productos para crear el traspaso de un almacen a otro
$productos_para_traspaso = array();
foreach ($producto_por_almacen as $producto) {
$p = array("id_producto" => $producto["id_producto"], "id_unidad" => $producto["id_unidad"], "cantidad" => $producto["cantidad"]);
array_push($productos_para_traspaso, $p);
}
//Se programa el traspaso del almacen de donde se tomaron estos productos al almacen de consignacion
SucursalesController::ProgramarTraspasoAlmacen($almacen->getIdAlmacen(), $producto_por_almacen[0]["id_almacen"], $fecha_envio_programada, $productos_para_traspaso);
}
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se pudo crear la nueva consignacion: " . $e);
throw new Exception("No se pudo crear la nueva consignacion");
}
DAO::transEnd();
Logger::log("Consignacion creada exitosamente");
return array("id_consignacion" => $consignacion->getIdConsignacion());
}
/**
*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;
}
/**
*
*Elimina un tipo de almacen
*
* @param id_tipo_almacen int Id del tipo de almacen a editar
**/
static function DesactivarTipo($id_tipo_almacen)
{
Logger::log("Eliminando tipo de almacen " . $id_tipo_almacen);
//El almacen de consignacion no se puede borrar
if ($id_tipo_almacen == 2) {
Logger::error("Se intento eliminar el almacen de consginacion");
throw new Exception("El almacen de consignacion no puede ser eliminado", 901);
}
//Se valida que el tipo de almacen exista
$tipo_almacen = TipoAlmacenDAO::getByPK($id_tipo_almacen);
if (is_null($tipo_almacen)) {
Logger::error("El tipo de almacen " . $id_tipo_almacen . " no existe");
throw new Exception("El tipo de almacen " . $id_tipo_almacen . " no existe", 901);
}
//Si un almacen activo aun pertenece a este tipo de almacen, no se podra eliminar
$almacenes = AlmacenDAO::search(new Almacen(array("id_tipo_almacen" => $id_tipo_almacen)));
foreach ($almacenes as $almacen) {
if ($almacen->getActivo()) {
Logger::error("No se puede eliminar el tipo de almacen " . $id_tipo_almacen . " pues aun es usado por almacenes activos");
throw new Exception("No se puede eliminar este tipo de almacen pues aun hay almacenes activos con este tipo", 901);
}
}
DAO::transBegin();
try {
$tipo_almacen->setActivo(0);
TipoAlmacenDAO::save($tipo_almacen);
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se pudo eliminar el tipo de almacen: " . $e);
throw new Exception("No se pudo eliminar el tipo de almacen, consulte a su administrador de sistema");
}
DAO::transEnd();
Logger::log("Tipo de almacen eliminado exitosamente");
}
