Esempio n. 1
0
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>";
}
Esempio n. 2
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;
 }
$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);
<?php

define("BYPASS_INSTANCE_CHECK", false);
require_once "../../../server/bootstrap.php";
$page = new GerenciaComponentPage();
//
// Parametros necesarios
//
$page->requireParam("tid", "GET", "Este traspaso no existe.");
$este_traspaso = TraspasoDAO::getByPK($_GET["tid"]);
//
// Titulo de la pagina
//
$page->addComponent(new TitleComponent("Editar traspaso " . $este_traspaso->getIdTraspaso() . "\n                    . De almacen: " . AlmacenDAO::getByPK($este_traspaso->getIdAlmacenEnvia())->getNombre() . "\n                        al almacen: " . AlmacenDAO::getByPK($este_traspaso->getIdAlmacenRecibe())->getNombre(), 2));
//
// Forma de usuario
//
$form = new DAOFormComponent($este_traspaso);
$form->hideField(array("id_traspaso", "id_usuario_programa", "id_usuario_envia", "fecha_envio", "id_usuario_recibe", "fecha_recibo", "estado", "cancelado", "completo", "id_almacen_envia", "id_almacen_recibe"));
$form->addApiCall("api/sucursal/almacen/traspaso/editar/", "GET");
$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"));
//$form->createComboBoxJoin( "id_ciudad", "nombre", CiudadDAO::getAll(), $esta_direccion->getIdCiudad() );
//                $form->createComboBoxJoin( "id_rol", "nombre", RolDAO::getAll(), $este_usuario->getIdRol() );
//
//                $form->createComboBoxJoin( "id_moneda", "nombre", MonedaDAO::search( new Moneda( array( "activa" => 1 ) ) ),$este_usuario->getIdMoneda() );
//
//                $form->createComboBoxJoin( "id_clasificacion_cliente", "nombre", ClasificacionClienteDAO::getAll(), $este_usuario->getIdClasificacionCliente() );
//
//                $form->createComboBoxJoin( "id_clasificacion_proveedor", "nombre", ClasificacionProveedorDAO::search( new ClasificacionProveedor( array( "activa" => 1 ) ) ), $este_usuario->getIdClasificacionProveedor() );
Esempio n. 5
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;
 }
Esempio n. 6
0
        }
        //for-each sucursales
    }
    //for-each id_sucursales
}
//for-each empresas
?>
	        ]);
	        var chart = new google.visualization.OrgChart(document.getElementById('chart_div'));
	
	        chart.draw(data, {allowHtml:true});
	
			google.visualization.events.addListener(chart, 'select', function(a,b,c) {
				console.log(chart.getSelection()[0].row,a,b,c);
			  });
	      }
	
	
	    </script>

	    <div id='chart_div'></div>
		<?php 
$page->addComponent(new TitleComponent("Nuevo lote", 2));
$nuevoLote = new DAOFormComponent(new Lote());
$nuevoLote->addApiCall("api/almacen/lote/nuevo", "POST");
$nuevoLote->makeObligatory(array("id_almacen", "folio"));
$nuevoLote->hideField(array("id_usuario", "id_lote"));
$nuevoLote->createComboBoxJoin("id_almacen", "nombre", AlmacenDAO::GetAll());
$nuevoLote->setCaption("id_almacen", "Almacen contenedor");
$page->addComponent($nuevoLote);
$page->render();
<?php

define("BYPASS_INSTANCE_CHECK", false);
require_once "../../../server/bootstrap.php";
$page = new GerenciaComponentPage();
//
// Parametros necesarios
//
$page->requireParam("aid", "GET", "Este almacen no existe.");
$este_almacen = AlmacenDAO::getByPK($_GET["aid"]);
//
// Titulo de la pagina
//
$page->addComponent(new TitleComponent("Editar almacen " . $este_almacen->getNombre(), 2));
//
// Forma de usuario
//
$form = new DAOFormComponent($este_almacen);
$form->hideField(array("id_almacen", "id_empresa", "id_sucursal", "activo"));
$form->addApiCall("api/sucursal/almacen/editar/", "GET");
$form->onApiCallSuccessRedirect("sucursales.lista.almacen.php");
$form->sendHidden("id_almacen");
$form->createComboBoxJoin("id_tipo_almacen", "descripcion", array_diff(TipoAlmacenDAO::getAll(), TipoAlmacenDAO::search(new TipoAlmacen(array("id_tipo_almacen" => 2)))), $este_almacen->getIdTipoAlmacen());
$page->addComponent($form);
$page->render();
Esempio n. 8
0
 /**
  *
  *Para poder editar un traspaso,este no tuvo que haber sido enviado aun
  *
  * @param id_traspaso int Id del traspaso a editar
  * @param productos json Productos a enviar con sus cantidades
  * @param fecha_envio_programada string Fecha de envio programada
  **/
 public static function EditarTraspasoAlmacen($id_traspaso, $fecha_envio_programada = null, $productos = null)
 {
     Logger::log("Editando traspaso " . $id_traspaso);
     //valida que el traspaso exista, que no haya sido cancelado y que no se hayan efectuado operaciones sobre el.
     $validar = self::validarParametrosTraspaso($id_traspaso, null, null, $fecha_envio_programada);
     if (is_string($validar)) {
         Logger::error($validar);
         throw new Exception($validar);
     }
     $traspaso = TraspasoDAO::getByPK($id_traspaso);
     if ($traspaso->getCancelado()) {
         Logger::error("El traspaso ya ha sido cancelado, no puede ser editado");
         throw new Exception("El traspaso ya ha sido cancelado, no puede ser editado");
     }
     if ($traspaso->getCompleto() || $traspaso->getEstado() !== "Envio programado") {
         Logger::error("No se puede editar el traspaso de almacen pues ya se han realizado acciones sobre el");
         throw new Exception("No se puede editar el traspaso de almacen pues ya se han realizado acciones sobre el");
     }
     //Si se recibe el parametro fecha de envio se toma como actualizacion.
     if (!is_null($fecha_envio_programada)) {
         $traspaso->setFechaEnvioProgramada($fecha_envio_programada);
     }
     DAO::transBegin();
     try {
         TraspasoDAO::save($traspaso);
         if (!is_null($productos)) {
             $productos = object_to_array($productos);
             if (!is_array($productos)) {
                 throw new Exception("Los productos son invalidos", 901);
             }
             //Se actualiza la cantidad de cada producto programado para este traspaso, si el producto
             //no se encuentra, se verifica que su empresa concuerde con la del almacen de recibo y
             //se crea el nuevo registro.
             //
             //Despues, se recorren los productos que se encuentran actualmente programados a enviarse en el traspaso,
             //los productos que no se encuentre en la nueva lista obtenida seran eliminados.
             foreach ($productos as $p) {
                 if (!array_key_exists("id_producto", $p) || !array_key_exists("id_unidad", $p) || !array_key_exists("cantidad", $p)) {
                     throw new Exception("Los productos no tienen todos los parametros necesarios", 901);
                 }
                 $traspaso_producto = TraspasoProductoDAO::getByPK($id_traspaso, $p["id_producto"], $p["id_unidad"]);
                 if (is_null($traspaso_producto)) {
                     $almacen_recibe = AlmacenDAO::getByPK($traspaso->getIdAlmacenRecibe());
                     $productos_empresa = ProductoEmpresaDAO::search(new ProductoEmpresa(array("id_producto" => $p["id_producto"])));
                     $encontrado = false;
                     foreach ($productos_empresa as $p_e) {
                         if ($p_e->getIdEmpresa() == $almacen_recibe->getIdEmpresa()) {
                             $encontrado = true;
                         }
                     }
                     if (!$encontrado) {
                         throw new Exception("Se busca enviar un producto que no es de la empresa del almacen que recibe", 901);
                     }
                     $traspaso_producto = new TraspasoProducto(array("id_traspaso" => $id_traspaso, "id_producto" => $p["id_producto"], "id_unidad" => $p["id_unidad"], "cantidad_recibida" => 0));
                 }
                 $traspaso_producto->setCantidadEnviada($p["cantidad"]);
                 TraspasoProductoDAO::save($traspaso_producto);
             }
             /* Fin de foreach de productos*/
             $traspasos_producto = TraspasoProductoDAO::search(new TraspasoProducto(array("id_traspaso" => $id_traspaso)));
             foreach ($traspasos_producto as $t_p) {
                 $encontrado = false;
                 foreach ($productos as $p) {
                     if ($t_p->getIdProducto() == $p["id_producto"] && $t_p->getIdUnidad() == $p["id_unidad"]) {
                         $encontrado = true;
                     }
                 }
                 if (!$encontrado) {
                     TraspasoProductoDAO::delete($t_p);
                 }
             }
             /* Fin de foreach de traspaso_producto*/
         }
         /* Fin de if de productos */
     } catch (Exception $e) {
         DAO::transRollback();
         Logger::error("No se pudo editar el traspaso: " . $e);
         if ($e->getCode() == 901) {
             throw new Exception("No se pudo editar el traspaso: " . $e->getMessage(), 901);
         }
         throw new Exception("No se pudo editar el traspaso", 901);
     }
     DAO::transEnd();
     Logger::log("Traspaso editado correctamente");
 }
<?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());
 }
Esempio n. 11
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;
 }
function funcion_almacen($id_almacen)
{
    return AlmacenDAO::getByPK($id_almacen) ? AlmacenDAO::getByPK($id_almacen)->getNombre() : "------";
}
Esempio n. 13
0
$btn_recibir->addApiCall("api/sucursal/almacen/traspaso/recibir/", "GET");
$btn_recibir->onApiCallSuccessRedirect("sucursales.lista.traspaso.almacen.php");
$btn_recibir->addName("recibir");
$funcion_recibir = " function recibir_traspaso(btn){" . "if(btn == 'yes')" . "{" . "var p = {};" . "p.id_traspaso = " . $_GET["tid"] . ";" . "sendToApi_recibir(p);" . "}" . "}" . "      " . "function confirmar_recibo(){" . " Ext.MessageBox.confirm('Recibir', 'Desea recibir este traspaso?', recibir_traspaso );" . "}";
$btn_recibir->addOnClick("confirmar_recibo", $funcion_recibir);
$menu->addMenuItem($btn_recibir);
$page->addComponent($menu);
//
// Forma de producto
//
$form = new DAOFormComponent($este_traspaso);
$form->setEditable(false);
//$form->setEditable(false);
$form->hideField(array("id_traspaso"));
//		$form->makeObligatory(array(
//				"compra_en_mostrador",
//				"costo_estandar",
//				"nombre_producto",
//				"id_empresas",
//				"codigo_producto",
//				"metodo_costeo",
//				"activo"
//			));
//	    $form->createComboBoxJoin("id_unidad", "nombre", UnidadDAO::getAll(), $este_producto->getIdUnidad() );
$form->createComboBoxJoinDistintName("id_almacen_recibe", "id_almacen", "nombre", AlmacenDAO::getAll(), $este_traspaso->getIdAlmacenRecibe());
$form->createComboBoxJoinDistintName("id_almacen_envia", "id_almacen", "nombre", AlmacenDAO::getAll(), $este_traspaso->getIdAlmacenEnvia());
$form->createComboBoxJoinDistintName("id_usuario_recibe", "id_usuario", "nombre", UsuarioDAO::getAll(), $este_traspaso->getIdUsuarioRecibe());
$form->createComboBoxJoinDistintName("id_usuario_envia", "id_usuario", "nombre", UsuarioDAO::getAll(), $este_traspaso->getIdUsuarioEnvia());
$form->createComboBoxJoinDistintName("id_usuario_programa", "id_usuario", "nombre", UsuarioDAO::getAll(), $este_traspaso->getIdUsuarioPrograma());
$page->addComponent($form);
$page->render();
Esempio n. 14
0
 /**
  * Desactivar Almacen
  */
 public function testDesactivarAlmacen()
 {
     POSController::DropBd();
     $usuario = UsuarioDAO::getAll();
     if (sizeof($usuario) == 0) {
         Logger::error("WHOOOT no hay usuarios en la BD");
         return;
     }
     $id_usuario = $usuario[0]->getIdUsuario();
     @DireccionDAO::save($direccion = new Direccion(array("calle" => "Una Calle", "numero_exterior" => "322", "id_ciudad" => "12", "codigo_postal" => "38000", "ultima_modificacion" => "2012-02-21 22:10:45", "id_usuario_ultima_modificacion" => "2")));
     @EmpresaDAO::save($empresa = new Empresa(array("id_direccion" => $direccion->getIdDireccion(), "rfc" => "RFC_" . time(), "razon_social" => "Empresa_Razon_Social__" . time(), "fecha_alta" => "2012-02-21 22:10:45", "activo" => 1, "direccion_web" => "Dir_" . time())));
     @SucursalDAO::save($sucursal = new Sucursal(array("id_direccion" => $direccion->getIdDireccion(), "razon_social" => "Sucursal_Razon_Social__" . time(), "saldo_a_favor" => 2000, "fecha_apertura" => "2012-02-21 22:10:45", "activa" => 1)));
     $tipo_almacen = AlmacenesController::NuevoTipo("Nuevo_Tipo_Almacen___" . time());
     Logger::log("Nuevo almacen");
     $almacen = AlmacenesController::Nuevo($id_empresa = $empresa->getIdEmpresa(), $id_sucursal = $sucursal->getIdSucursal(), $id_tipo_almacen = $tipo_almacen["id_tipo_almacen"], $nombre = "Almacen_Editar" . time(), $descripcion = "Almacen de prueba_ " . time());
     // Desactivamos el Almacen
     Logger::log("A desactivar almacen recien creado");
     $almacen_desactivado = AlmacenesController::Desactivar($id_almacen = $almacen["id_almacen"]);
     $_almacen = AlmacenDAO::getByPK($almacen["id_almacen"]);
     $this->assertEquals(0, $_almacen->getActivo());
 }
Esempio n. 15
0
 /**
  *
  *Crear un nuevo lote
  *
  * @param id_almacen int A que almacen pertenecera este lote.
  * @param observaciones string Alguna observacin o detalle relevante que se deba documentar
  * @return id_lote int El identificador del lote recien generado.
  **/
 static function NuevoLote($id_almacen, $folio = null)
 {
     if (!($almacen = AlmacenDAO::getByPK($id_almacen))) {
         Logger::error("No se tiene registro del almacen {$id_almacen}");
         throw new BusinessLogicException("No se tiene registro del almacen {$id_almacen}");
     }
     $sesion = SesionController::Actual();
     $l = new Lote(array("id_almacen" => $almacen->getIdAlmacen(), "id_usuario" => $sesion['id_usuario'], "folio" => is_null($folio) ? "" : $folio));
     try {
         LoteDAO::save($l);
     } catch (Exception $e) {
         Logger::error("Error al crear nuevo lote {$e->getMessage()}");
         throw new InvalidDatabaseOperationException("Error al crear el nuevo lote");
     }
     return array("id_lote" => $l->getIdLote());
 }