private static function validarParametrosProductoOrdenDeServicio($id_producto = null, $precio = null, $cantidad = null, $descuento = null, $impuesto = null, $retencion = null, $id_unidad = null)
 {
     //valida que el producto exista en la base de datos
     if (!is_null($id_producto)) {
         $producto = ProductoDAO::getByPK($id_producto);
         if (is_null($producto)) {
             return "El producto con id " . $id_producto . " no existe";
         }
         if (!$producto->getActivo()) {
             return "El producto " . $id_producto . " no esta activo";
         }
     }
     //valida que el precio este en el rango
     if (!is_null($precio)) {
         $e = self::validarNumero($precio, 1.8E+200, "precio");
         if (is_string($e)) {
             return $e;
         }
     }
     //valida que la cantidad este en el rango
     if (!is_null($cantidad)) {
         $e = self::validarNumero($cantidad, PHP_INT_MAX, "cantidad");
         if (is_string($e)) {
             return $e;
         }
     }
     //valida que el descuento este en el rango
     if (!is_null($descuento)) {
         $e = self::validarNumero($descuento, 1.8E+200, "descuento");
         if (is_string($e)) {
             return $e;
         }
     }
     //valida que el impuesto este en rango
     if (!is_null($impuesto)) {
         $e = self::validarNumero($impuesto, 1.8E+200, "impuesto");
         if (is_string($e)) {
             return $e;
         }
     }
     //valida que la retencion este en rango
     if (!is_null($retencion)) {
         $e = self::validarNumero($retencion, 1.8E+200, "retencion");
         if (is_string($e)) {
             return $e;
         }
     }
     //valida que la unidad exista en la base de datos
     if (!is_null($id_unidad)) {
         $unidad = UnidadDAO::getByPK($id_unidad);
         if (is_null($unidad)) {
             return "La unidad con id " . $id_unidad . " no existe";
         }
         if (!$unidad->getActiva()) {
             return "La unidad " . $id_unidad . " no esta activa";
         }
     }
     //no se encontro error, regresa true
     return true;
 }
Beispiel #2
0
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();
}
Beispiel #3
0
 /**
  * Override default validation
  * @see Phreezable::Validate()
  */
 public function Validate()
 {
     // example of custom validation
     // $this->ResetValidationErrors();
     // $errors = $this->GetValidationErrors();
     // if ($error == true) $this->AddValidationError('FieldName', 'Error Information');
     // return !$this->HasValidationErrors();
     return parent::Validate();
 }
Beispiel #4
0
function funcion_producto($id_producto)
{
    return ProductoDAO::getByPK($id_producto) ? ProductoDAO::getByPK($id_producto)->getNombreProducto() : "---------";
}
Beispiel #5
0
 /**
  *
  *Lista el detalle de una venta, se puede ordenar de acuerdo a sus atributos.
  *
  * @param id_venta int Id de la venta a revisar
  * @param ordenar json Valor que determina el orden de la lista
  * @return detalle_venta json Objeto que contiene el detalle de la venta.
  **/
 public static function Detalle($id_venta)
 {
     Logger::log("Listando el detalle de la venta " . $id_venta);
     //Se regresara un arreglo que contendra en la primera posicion la venta en sí, en la segunda
     //contendra otro arreglo de arreglos, estos arreglos en la primera posicion tendran un arreglo con la informacion del producto,
     //en la segunda un arreglo con la informacion de la unidad, y en las siguientes posiciones la demas informacion
     //del detalle (cantidad, precio, descuento, etc.)
     //
     //En la tercera posicion contendra todos los abonos realizados para esta venta
     $detalle = array();
     array_push($detalle, VentaDAO::getByPK($id_venta));
     $ventas_productos = array();
     $venta_productos = VentaProductoDAO::search(new VentaProducto(array("id_venta" => $id_venta)));
     foreach ($venta_productos as $v_p) {
         $venta_producto = array();
         array_push($venta_producto, ProductoDAO::getByPK($v_p->getIdProducto()));
         array_push($venta_producto, UnidadDAO::getByPK($v_p->getIdUnidad()));
         array_push($venta_producto, $v_p->getCantidad());
         array_push($venta_producto, $v_p->getPrecio());
         array_push($venta_producto, $v_p->getDescuento());
         array_push($venta_producto, $v_p->getImpuesto());
         array_push($venta_producto, $v_p->getRetencion());
         array_push($ventas_productos, $venta_producto);
     }
     array_push($detalle, $ventas_productos);
     array_push($detalle, AbonoVentaDAO::search(new AbonoVenta(array("id_venta" => $id_venta))));
     Logger::log("Detalle obtenido exitosamente");
     return $detalle;
 }
Beispiel #6
0
 private static function ValidarParametrosRegla($id_regla = null, $nombre = null, $id_producto = null, $id_clasificacion_producto = null, $id_unidad = null, $id_servicio = null, $id_clasificacion_servicio = null, $id_paquete = null, $cantidad_minima = null, $porcentaje_utilidad = null, $utilidad_neta = null, $metodo_redondeo = null, $margen_min = null, $margen_max = null, $secuencia = null)
 {
     //valida que la regla exista
     if (!is_null($id_regla)) {
         if (is_null(ReglaDAO::getByPK($id_regla))) {
             return "La regla " . $id_regla . " no existe";
         }
     }
     //valida que el nombre este en rango
     if (!is_null($nombre)) {
         if (!self::validarLongitudDeCadena($nombre, 0, 100)) {
             throw new InvalidDataException("nombre muy largo");
         }
     }
     //valida que el producto exista y este activo
     if (!is_null($id_producto)) {
         $producto = ProductoDAO::getByPK($id_producto);
         if (is_null($producto)) {
             return "El producto " . $id_producto . " no existe";
         }
         if (!$producto->getActivo()) {
             return "El producto " . $id_producto . " esta inactivo";
         }
     }
     //valida que la clasificacion de producto exista y este activa
     if (!is_null($id_clasificacion_producto)) {
         $clasificacion_producto = ClasificacionProductoDAO::getByPK($id_clasificacion_producto);
         if (is_null($clasificacion_producto)) {
             return "La clasificacion de producto " . $id_clasificacion_producto . " no existe";
         }
         if (!$clasificacion_producto->getActiva()) {
             return "La clasificacion de producto " . $id_clasificacion_producto . " no esta activa";
         }
     }
     //valida que la unidad exista y este activa
     if (!is_null($id_unidad)) {
         $unidad = UnidadDAO::getByPK($id_unidad);
         if (is_null($unidad)) {
             return "La unidad " . $id_unidad . " no existe";
         }
         if (!$unidad->getActiva()) {
             return "La unidad " . $id_unidad . " no esta activa";
         }
     }
     //valida que el servicio exista y este activo
     if (!is_null($id_servicio)) {
         $servicio = ServicioDAO::getByPK($id_servicio);
         if (is_null($servicio)) {
             return "El servicio " . $id_servicio . " no existe";
         }
         if (!$servicio->getActivo()) {
             return "El servicio " . $id_servicio . " no esta activo";
         }
     }
     //valida que la clasificacion de servicio exista y este activa
     if (!is_null($id_clasificacion_servicio)) {
         $clasificacion_servicio = ClasificacionServicioDAO::getByPK($id_clasificacion_servicio);
         if (is_null($clasificacion_servicio)) {
             return "La clasificacion de servicio " . $id_clasificacion_servicio . " no existe";
         }
         if (!$clasificacion_servicio->getActiva()) {
             return "La clasificacion de servicio " . $id_clasificacion_servicio . " no esta activa";
         }
     }
     //valida que el paquete exista y este activo
     if (!is_null($id_paquete)) {
         $paquete = PaqueteDAO::getByPK($id_paquete);
         if (is_null($paquete)) {
             return "El paquete " . $id_paquete . " no existe";
         }
         if (!$paquete->getActivo()) {
             return "El paquete " . $id_paquete . " esta inactivo";
         }
     }
     //valida que la cantidad minima este en rango
     if (!is_null($cantidad_minima)) {
         $e = self::validarNumero($cantidad_minima, 1.8E+200, "cantidad minima");
         if (is_string($e)) {
             return $e;
         }
     }
     //valida que el porcentaje de utilidad este en rango
     if (!is_null($porcentaje_utilidad)) {
         $e = self::validarNumero($porcentaje_utilidad, 1, "porcentaje_utilidad", -1);
         if (is_string($e)) {
             return $e;
         }
     }
     //valida que la utilidad neta este en rango
     if (!is_null($utilidad_neta)) {
         $e = self::validarNumero($utilidad_neta, 1.8E+200, "Utilidad neta", -1.8E+200);
         if (is_string($e)) {
             return $e;
         }
     }
     //valida que el metodo de redondeo este en rango
     if (!is_null($metodo_redondeo)) {
         $e = self::validarNumero($metodo_redondeo, 1.8E+200, "metodo_redondeo");
         if (is_string($e)) {
             return $e;
         }
     }
     //valida que el margen minimo este en rango
     if (!is_null($margen_min)) {
         $e = self::validarNumero($margen_min, 1.8E+200, "margen minimo");
         if (is_string($e)) {
             return $e;
         }
     }
     //valida que el margen maximo este en rango
     if (!is_null($margen_max)) {
         $e = self::validarNumero($margen_max, 1.8E+200, "margen maximo");
         if (is_string($e)) {
             return $e;
         }
     }
     //valida que la secuencia este en rango
     if (!is_null($secuencia)) {
         $e = self::validarNumero($secuencia, PHP_INT_MAX, "secuencia");
         if (is_string($e)) {
             return $e;
         }
     }
     //no se encontro error, regresa verdadero
     return true;
 }
 /**
  *
  *Envia productos fuera del almacen. Ya sea que sea un traspaso de un alamcen a otro o por motivos de inventarios fisicos.
  *
  * @param id_lote int Id del lote de donde se descontaran los productos.
  * @param productos json Objeto que contendra los ids de los productos que seran sacados del alamcen con sus cantidades y sus unidades
  * @param motivo string Motivo de la salida del producto
  * @return id_salida_lote int ID de la salida del producto
  **/
 static function SalidaLote($id_lote, $productos, $motivo = null)
 {
     if (is_null(LoteDAO::getByPK($id_lote))) {
         throw new InvalidDataException("este lote no existe");
     }
     if (!is_array($productos)) {
         throw new InvalidDataException("productos no es un array");
     }
     $sesion = SesionController::Actual();
     DAO::transBegin();
     $sl = new LoteSalida();
     $sl->setIdLote($id_lote);
     $sl->setIdUsuario($sesion["id_usuario"]);
     $sl->setFechaRegistro(time());
     $sl->setMotivo(is_null($motivo) ? "" : $motivo);
     try {
         LoteSalidaDAO::save($sl);
     } catch (Exception $e) {
         DAO::transRollback();
         throw new InvalidDatabaseOperationException($e);
     }
     for ($i = 0; $i < sizeof($productos); $i++) {
         if (!is_array($productos[$i])) {
             throw new InvalidDataException("El producto en la posicion {$i} no es un arreglo como se esperaba");
         }
         if (!array_key_exists("id_producto", $productos[$i])) {
             throw new InvalidDataException("El producto en {$i} no tiene id_prodcuto");
         }
         if (!array_key_exists("cantidad", $productos[$i])) {
             throw new InvalidDataException("El producto en {$i} no tiene cantidad");
         }
         if (is_null(ProductoDAO::getByPK($productos[$i]["id_producto"]))) {
             throw new InvalidDataException("El producto " . $productos[$i]["id_producto"] . " no existe.");
         }
         $lp = LoteProductoDAO::getByPK($id_lote, $productos[$i]["id_producto"]);
         if (is_null($lp)) {
             throw new InvalidDataException("El lote {$id_lote} no tiene el producto " . $productos[$i]["id_producto"]);
         }
         if ($productos[$i]["cantidad"] > $lp->getCantidad()) {
             throw new InvalidDataException("Estas intentando sacar mas de lo que hay en el lote.");
         }
         if (!isset($productos[$i]["id_unidad"])) {
             throw new InvalidDataException("El producto " . $productos[$i]["id_producto"] . " proporcionado no tiene id_unidad");
         }
         $equivalencia = UnidadMedidaDAO::convertir($productos[$i]["id_unidad"], $lp->getIdUnidad(), $productos[$i]["cantidad"]);
         if ($equivalencia > $lp->getCantidad()) {
             Logger::log("Se Comparara {$equivalencia} > {$lp->getCantidad()}");
             throw new InvalidDataException("Estas intentando sacar mas de lo que hay en el lote.");
         }
         $lp->setCantidad($lp->getCantidad() - $productos[$i]["cantidad"]);
         try {
             LoteProductoDAO::save($lp);
             LoteSalidaProductoDAO::save(new LoteSalidaProducto(array("id_lote_salida" => $sl->getIdLoteSalida(), "id_producto" => $productos[$i]["id_producto"], "id_unidad" => $productos[$i]["id_unidad"], "cantidad" => $productos[$i]["cantidad"])));
             Logger::log("Removiendo qty=" . $productos[$i]["cantidad"] . "; prod=" . $productos[$i]["id_producto"] . "; lote=" . $id_lote);
         } catch (Exception $e) {
             Logger::error($e);
             throw new InvalidDatabaseOperationException($e);
         }
     }
     DAO::transEnd();
     return array("id_salida_lote" => $sl->getIdLoteSalida());
 }
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() );
//$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();
            <th> Cant Min </th>
        </tr>
        
        <?php 
$html = "";
$reglas = ReglaDAO::search(new Regla(array("id_version" => $version->getIdVersion())));
foreach ($reglas as $regla) {
    $html .= "<tr>";
    $html .= "   <td>";
    $html .= "       {$regla->getSecuencia()}";
    $html .= "   </td>";
    $html .= "   <td>";
    $html .= "       {$regla->getNombre()}";
    $html .= "   </td>";
    $html .= "   <td>";
    if ($producto = ProductoDAO::getByPK($regla->getIdProducto())) {
        $html .= "       " . $producto->getNombreProducto();
    } else {
        $html .= "-";
    }
    $html .= "   </td>";
    $html .= "   <td>";
    if ($categoria = ClasificacionProductoDAO::getByPK($regla->getIdClasificacionProducto())) {
        $html .= "       " . $categoria->getNombre();
    } else {
        $html .= "-";
    }
    $html .= "   </td>";
    $html .= "   <td>";
    if ($servicio = ServicioDAO::getByPK($regla->getIdServicio())) {
        $html .= "       " . $servicio->getNombreServicio();
 private static function validarConsignacionProducto($id_producto = null, $id_unidad = null, $cantidad = null, $impuesto = null, $descuento = null, $retencion = null, $precio = null)
 {
     //Se valida que el producto exista y que este activo
     if (!is_null($id_producto)) {
         $producto = ProductoDAO::getByPK($id_producto);
         if (is_null($producto)) {
             return "El producto " . $id_producto . " no existe";
         }
         if (!$producto->getActivo()) {
             return "El producto " . $id_producto . " no esta activo";
         }
     }
     //Se valida que la unidad exista y que este activa
     if (!is_null($id_unidad)) {
         $unidad = UnidadDAO::getByPK($id_unidad);
         if (is_null($unidad)) {
             return "La unidad " . $id_unidad . " no existe";
         }
         if (is_null($unidad->getActiva())) {
             return "La unidad " . $id_unidad . " no esta activa";
         }
     }
     //Se valida que la cantidad este en rango
     if (!is_null($cantidad)) {
         $e = self::validarNumero($cantidad, 1.8E+200, "cantidad");
         if (is_string($e)) {
             return $e;
         }
     }
     //Se valida que el impuesto este en rango
     if (!is_null($impuesto)) {
         $e = self::validarNumero($impuesto, 1.8E+200, "impuesto");
         if (is_string($e)) {
             return $e;
         }
     }
     //Se valida que el descuento este en rango
     if (!is_null($descuento)) {
         $e = self::validarNumero($descuento, 100, "descuento");
         if (is_string($e)) {
             return $e;
         }
     }
     //Se valida que la retencion este en rango
     if (!is_null($retencion)) {
         $e = self::validarNumero($retencion, 1.8E+200, "retencion");
         if (is_string($e)) {
             return $e;
         }
     }
     //Se valida que el precio este en rango
     if (!is_null($precio)) {
         $e = self::validarNumero($precio, 1.8E+200, "precio");
         if (is_string($e)) {
             return $e;
         }
     }
     //No se encontro error
     return true;
 }
Beispiel #11
0
 /**
  * Regresa la cantidad total de producto en un lote especifico
  * 
  * ESTE METODO SIRVE PARA CUANDO EN LOTE PRODUCTO HAY REGISTROS CON UNIDADES DIFERENTES, YA QUE EN EL CASO DE ExistenciasTotales NO 
  * TRABAJARIA DE MANERA CORRECTA YA QUE SE INFIERE QUE TODOS LOS TEGISTROS EN LOTE PRODUCTO TIENEN LA MISMA UNIDAD
  * 
  * @param type $id_producto
  * @param type $id_lote
  * @param type $id_unidad
  * @return \stdClass 
  */
 public static function ExistenciasLote($id_producto, $id_lote, $id_unidad)
 {
     //Logger::log("EXISTENCIAS LOTE PARA RECIBE " . ProductoDAO::getByPK($id_producto)->getNombreProducto() . ", LOTE {$id_lote}, todas las operaciones para el calculo deberan hacerse en {$id_unidad} (" . UnidadMedidaDAO::getByPK($id_unidad)->getAbreviacion() . ")");
     $error = "";
     $cantidad = 0;
     $nentradas = 0;
     $nsalidas = 0;
     //verificamos si el producto existe
     if (!($producto = ProductoDAO::getByPK($id_producto))) {
         $error .= "No se tiene registro del producto {$id_producto}. \n";
     }
     //verificamos si se envia el lote
     if (!($lote = LoteDAO::getByPK($id_lote))) {
         $error .= "No se tiene registro del lote {$id_lote}. \n";
     }
     //obtenemos los lotes de entrada
     $lotes_entrada = LoteEntradaDAO::search(new LoteEntrada(array("id_lote" => $id_lote)));
     //Logger::log("Iteramos sobre los lote entrada, se encontraron " . count($lotes_entrada) . " lotes entrada.");
     //iteramos sobre los lote de entrada
     foreach ($lotes_entrada as $lote_entrada) {
         if ($lote_entrada->getIdLote() != $id_lote) {
             continue;
         }
         $array = array("id_lote_entrada" => $lote_entrada->getIdLoteEntrada(), "id_producto" => $id_producto);
         $lotes_entrada_producto = LoteEntradaProductoDAO::search(new LoteEntradaProducto($array));
         //Logger::log("--- Iteramos sobre los lote entrada producto , se encontraron " . count($lotes_entrada_producto) . " lotes entrada.");
         foreach ($lotes_entrada_producto as $lote_entrada_producto) {
             //Logger::log("--- Revisando el lote entrada producto tiene como unidad " . UnidadMedidaDAO::getByPK($lote_entrada_producto->getIdUnidad())->getAbreviacion() . " se comparara contra " . UnidadMedidaDAO::getByPK($id_unidad)->getAbreviacion() . ".");
             if ($lote_entrada_producto->getIdProducto() != $id_producto) {
                 //Logger::error("El search fallo!! el lote entrada producto trajo al producto {$lote_entrada_producto->getIdProducto()} y lo compara con {$id_producto}");
                 continue;
             } else {
                 //revisemos si es de la misma unidad
                 if ($lote_entrada_producto->getIdUnidad() == $id_unidad) {
                     //Logger::log("Se detectaron que las unidades son iguales, el conteo se encuentra en {$cantidad}, se agregaran {$lote_entrada_producto->getCantidad()}");
                     //es igual, solo hay que sumar
                     $cantidad += $lote_entrada_producto->getCantidad();
                     $nentradas += $lote_entrada_producto->getCantidad();
                     // Logger::log("Des pues de la operacion el conteo se encuentra en {$cantidad}");
                 } else {
                     //no es igual, hay que convertir
                     //Logger::log("Se detecto que las unidades son diferentes, se procede a transformar {$lote_entrada_producto->getCantidad()} " . UnidadMedidaDAO::getByPK($lote_entrada_producto->getIdUnidad())->getDescripcion() . " a " . UnidadMedidaDAO::getByPK($id_unidad)->getDescripcion());
                     //Logger::log("**** INFO DEL LOTE : " . $lote_entrada_producto . " ***");
                     $equivalencia = UnidadMedidaDAO::convertir($lote_entrada_producto->getIdUnidad(), $id_unidad, $lote_entrada_producto->getCantidad());
                     // Logger::log("El conteo se encuentra en {$cantidad}, se agregaran {$equivalencia} " . UnidadMedidaDAO::getByPK($id_unidad)->getDescripcion());
                     $cantidad += $equivalencia;
                     $nentradas += $equivalencia;
                     // Logger::log("Des pues de la operacion el conteo se encuentra en {$cantidad}");
                 }
             }
         }
     }
     //obtenemos los lotes de salida
     $lotes_salida = LoteSalidaDAO::search(new LoteSalida(array("id_lote" => $id_lote)));
     //Logger::log("Iteramos sobre los lote salida, se encontraron " . count($lotes_entrada) . " lotes salida.");
     //iteramos sobre los lote de salida
     foreach ($lotes_salida as $lote_salida) {
         $array = array("id_lote_salida" => $lote_salida->getIdLoteSalida(), "id_producto" => $id_producto);
         $lotes_salida_producto = LoteSalidaProductoDAO::search(new LoteSalidaProducto($array));
         //Logger::log("--- Iteramos sobre los lote salida producto , se encontraron " . count($lotes_salida_producto) . " lotes salida producto.");
         foreach ($lotes_salida_producto as $lote_salida_producto) {
             //Logger::log("--- Revisando el lote salida producto tiene como unidad " . UnidadMedidaDAO::getByPK($lote_salida_producto->getIdUnidad())->getAbreviacion() . " se comparara contra " . UnidadMedidaDAO::getByPK($id_unidad)->getAbreviacion() . ".");
             if ($lote_salida_producto->getIdProducto() != $id_producto) {
                 //Logger::error("El search fallo!! el lote salida producto trajo al producto {$lote_salida_producto->getIdProducto()} y lo compara con {$id_producto}");
                 continue;
             } else {
                 //revisemos si es de la misma unidad
                 if ($lote_salida_producto->getIdUnidad() == $id_unidad) {
                     //Logger::log("Se detectaron que las unidades son iguales, el conteo se encuentra en {$cantidad}, se restaran {$lote_salida_producto->getCantidad()}");
                     //es igual, solo hay que restar
                     $cantidad -= $lote_salida_producto->getCantidad();
                     $nsalidas += $lote_salida_producto->getCantidad();
                     //Logger::log("Des pues de la operacion el conteo se encuentra en {$cantidad}");
                 } else {
                     //Logger::log("Se detecto que las unidades son diferentes, se procede a transformar {$lote_salida_producto->getCantidad()} " . UnidadMedidaDAO::getByPK($lote_salida_producto->getIdUnidad())->getDescripcion() . " a " . UnidadMedidaDAO::getByPK($id_unidad)->getDescripcion());
                     // Logger::log("**** INFO DEL LOTE : " . $lote_salida_producto . " ***");
                     //no es igual, hay que convertir
                     $equivalencia = UnidadMedidaDAO::convertir($lote_salida_producto->getIdUnidad(), $id_unidad, $lote_salida_producto->getCantidad());
                     //   Logger::log("El conteo se encuentra en {$cantidad}, se restaran {$equivalencia} " . UnidadMedidaDAO::getByPK($id_unidad)->getDescripcion());
                     $cantidad -= $equivalencia;
                     $nsalidas += $equivalencia;
                     // Logger::log("Des pues de la operacion el conteo se encuentra en {$cantidad}");
                 }
             }
         }
     }
     if ($error != "") {
         Logger::error($error);
     }
     // Logger::log("########### Se encontro que para el producto " . ProductoDAO::getByPK($id_producto)->getNombreProducto() . " existen {$cantidad} " . UnidadMedidaDAO::getByPK($id_unidad)->getAbreviacion() . ". Hubo {$nentradas} entradas y {$nsalidas} salidas ###############");
     return $cantidad;
 }
 /**
  *Lista los productos por empresa, almacen y lote
  */
 public static function listarProductosLote($activo = null, $id_almacen = null, $id_empresa = null)
 {
     //objeto que se regresara
     $company = new stdClass();
     //contiene todas las empresas
     $company->empresas = array();
     //obtenemos todas las empresas
     $empresas = EmpresaDAO::getAll();
     //iteramos las empresas para obtener sus almacenes
     foreach ($empresas as $empresa) {
         //insertamos la empresa a la compañia
         $e = new stdClass();
         $e->id_empresa = $empresa->getIdEmpresa();
         $e->nombre = $empresa->getRazonSocial();
         $e->almacenes = array();
         $almacenes = AlmacenDAO::search(new Almacen(array("id_empresa" => $empresa->getIdEmpresa())));
         //iteramos todos los almacenes de la empresa
         foreach ($almacenes as $almacen) {
             $a = new stdClass();
             $a->id_almacen = $almacen->getIdAlmacen();
             $a->nombre = $almacen->getNombre();
             $a->id_sucursal = $almacen->getIdSucursal();
             $a->sucursal = SucursalDAO::getByPK($a->id_sucursal)->getRazonSocial();
             $a->lotes = array();
             //obtenemos todos los lotes del almacen
             $lotes = LoteDAO::search(new Lote(array("id_almacen" => $almacen->getIdAlmacen())));
             //iteramos todos los lotes del almacen
             foreach ($lotes as $lote) {
                 $l = new StdClass();
                 $l->id_lote = $lote->getIdLote();
                 $l->id_almacen = $lote->getIdAlmacen();
                 $l->folio = $lote->getFolio();
                 $l->lotes_producto = array();
                 //obtenemos todos los productos de un lote
                 $lotes_producto = LoteProductoDAO::search(new LoteProducto(array("id_lote" => $lote->getIdLote())));
                 //iteramos lodos los lotes con producto que perteneces al lote
                 foreach ($lotes_producto as $lote_producto) {
                     $producto = ProductoDAO::getByPK($lote_producto->getIdProducto());
                     $lp = new StdClass();
                     $lp->id_lote = $lote_producto->getIdLote();
                     $lp->id_producto = $lote_producto->getIdProducto();
                     $lp->cantidad = $lote_producto->getCantidad();
                     $lp->id_unidad = $lote_producto->getIdUnidad();
                     $lp->unidad = UnidadMedidaDAO::getByPK($lp->id_unidad)->getAbreviacion();
                     //$lp->recalculo = ProductoDAO::ExistenciasTotales($lp->id_producto);
                     $lp->recalculo = ProductoDAO::ExistenciasLote($lp->id_producto, $lp->id_lote, $lp->id_unidad);
                     $lp->nombre = $producto->getNombreProducto();
                     $lp->codigo = $producto->getCodigoProducto();
                     array_push($l->lotes_producto, $lp);
                 }
                 array_push($a->lotes, $l);
             }
             array_push($e->almacenes, $a);
         }
         array_push($company->empresas, $e);
     }
     return $company;
 }
 /**
  *
  *
  *	Lotes
  *
  **/
 public function testLotes()
 {
     $almacenes = AlmacenesController::Buscar(true);
     $almacenId = $almacenes["resultados"][0]->getIdAlmacen();
     //nuevo lote
     $nLote = AlmacenesController::NuevoLote($almacenId);
     $this->assertNotNull($l = LoteDAO::getByPK($nLote["id_lote"]));
     $producto = new Producto(array("compra_en_mostrador" => false, "metodo_costeo" => "precio", "precio" => 123.123, "activo" => true, "codigo_producto" => time() . "tp", "nombre_producto" => time() . "np", "costo_estandar" => 12.3123, "id_unidad" => 1));
     ProductoDAO::save($producto);
     $r = AlmacenesController::EntradaLote($nLote["id_lote"], array(array("id_producto" => $producto->getIdProducto(), "cantidad" => 23)));
     //Vamos a validar estas tablas
     $this->assertNotNull(LoteEntradaDAO::getByPK($r["id_entrada_lote"]));
     $this->assertNotNull(LoteProductoDAO::getByPK($nLote["id_lote"], $producto->getIdProducto()));
     $this->assertNotNull(LoteEntradaProductoDAO::getByPK($r["id_entrada_lote"], $producto->getIdProducto(), 1));
     //sacar de ese lote, uno por uno hasta llegar a retirar todo
     for ($i = 0; $i < 23; $i++) {
         AlmacenesController::SalidaLote($nLote["id_lote"], array(array("id_producto" => $producto->getIdProducto(), "cantidad" => 1, "id_unidad" => 1)));
     }
     Logger::log("la siguiente vez que retire algo, debe de arrojar una exception");
     try {
         AlmacenesController::SalidaLote($nLote["id_lote"], array(array("id_producto" => $producto->getIdProducto(), "cantidad" => 1, "id_unidad" => 1)));
         //esto nunca se deberia de ejecutar
         $this->assertTrue(false);
     } catch (InvalidDataException $ivde) {
         $this->assertNotNull($ivde);
     }
 }
Beispiel #14
0
 /**
  *
  *Muestra los productos y/o servicios englobados en este paquete as? como las sucursales y las empresas donde lo ofrecen
  *
  * @param id_paquete int Id del paquete a visualizar sus detalles
  * @return detalle_paquete json Informacion del detalle del paquete
  **/
 public static function Detalle($id_paquete)
 {
     Logger::log("consiguiendo los detalles del paquete");
     //valida que el paquete exista
     $paquete = PaqueteDAO::getByPK($id_paquete);
     if (is_null($paquete)) {
         Logger::error("El paquete " . $id_paquete . " no existe");
         throw new Exception("El paquete " . $id_paquete . " no existe");
     }
     //En el primer campo de un arreglo se almacena el paquete en sí, en el segundo las empresas en las que esta disponible el paquete,
     //en el tercero las sucursales en las que esta disponible, en el cuarto los productos que contiene y en el quinto los servicios
     $detalle_paquete = array();
     array_push($detalle_paquete, $paquete);
     $empresas = array();
     $paquetes_empresa = PaqueteEmpresaDAO::search(new PaqueteEmpresa(array("id_paquete" => $id_paquete)));
     foreach ($paquetes_empresa as $paquete_empresa) {
         array_push($empresas, EmpresaDAO::getByPK($paquete_empresa->getIdEmpresa()));
     }
     array_push($detalle_paquete, $empresas);
     $sucursales = array();
     $paquetes_sucursal = PaqueteSucursalDAO::search(new PaqueteSucursal(array("id_paquete" => $id_paquete)));
     foreach ($paquetes_sucursal as $paquete_sucursal) {
         array_push($sucursales, SucursalDAO::getByPK($paquete_sucursal->getIdSucursal()));
     }
     array_push($detalle_paquete, $sucursales);
     $productos = array();
     $productos_paquete = ProductoPaqueteDAO::search(new ProductoPaquete(array("id_paquete" => $id_paquete)));
     foreach ($productos_paquete as $producto_paquete) {
         array_push($productos, ProductoDAO::getByPK($producto_paquete->getIdProducto()));
     }
     array_push($detalle_paquete, $productos);
     $servicios = array();
     $servicios_paquete = OrdenDeServicioPaqueteDAO::search(new OrdenDeServicioPaquete(array("id_paquete" => $id_paquete)));
     foreach ($servicios_paquete as $servicio_paquete) {
         array_push($servicios, ServicioDAO::getByPK($servicio_paquete->getIdServicio()));
     }
     array_push($detalle_paquete, $servicios);
     Logger::log("Detalle de paquete " . $id_paquete . " conseguido exitosamente con " . count($empresas) . "\n                empresas, " . count($sucursales) . " sucursales, " . count($productos) . " productos y " . count($servicios) . " servicios");
     return $detalle_paquete;
 }
 /**
  *
  * 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);
         }
     }
 }
Beispiel #16
0
               //backwards compatibility
               "existenciasOriginales" => $producto['cantidad'],
               "existenciasProcesadas" => 0,
               // 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';
 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);
 }
Beispiel #18
0
 /**
  *
  *Registra una nueva compra fuera de caja, puede usarse para que el administrador haga directamente una compra. El usuario y al sucursal seran tomados de la sesion. La fecha sera tomada del servidor. La empresa sera tomada del almacen del cual fueron tomados los productos.
  *
  * @param descuento float Monto descontado por descuentos
  * @param subtotal float Total de la compra antes de impuestos y descuentos.
  * @param detalle json Objeto que contendr el arreglo de id productos, cantidad,  precio, descuento, id de unidad y procesado que involucran esta compra.
  * @param impuesto float Monto agregado por impuestos
  * @param tipo_compra string Si la compra es a credito o de contado
  * @param retencion float Monto agregado por retenciones
  * @param id_usuario_compra int Id usuario al que se le compra, si es a una sucursal, se pone el id en negativo
  * @param id_empresa int Id de la empresa a nombre de la cual se hace la compra
  * @param total float Total de la compra
  * @param cheques json Si el tipo de pago es con cheque, se almacena el nombre del banco, el monto y los ultimos 4 numeros del o de los cheques
  * @param saldo float Cantidad pagada de la 
  * @param tipo_de_pago string Si el pago sera en efectivo, con cheque o tarjeta
  * @return id_compra int Id autogenerado por la inserci�n de la compra
  **/
 public static function Nueva($descuento, $detalle, $id_empresa, $id_usuario_compra, $impuesto, $retencion, $subtotal, $tipo_compra, $total, $cheques = null, $id_sucursal = null, $saldo = 0, $tipo_de_pago = null)
 {
     Logger::log(" ===== Creando nueva compra... ===== ");
     //validemos al comprador
     $proveedor = UsuarioDAO::getByPK($id_usuario_compra);
     if (is_null($proveedor)) {
         Logger::error("el provedor {$id_usuario_compra} no exite");
         throw new InvalidDataException("El proveedor no existe");
     }
     if ($proveedor->getActivo() == false) {
         throw new BusinessLogicException("No se puede comprar de un proveedor no activo.");
     }
     //validemos la empresa
     $empresa = EmpresaDAO::getByPK($id_empresa);
     if (is_null($empresa)) {
         Logger::error("La empresa {$id_empresa} no existe");
         throw new InvalidDataException("La empresa que compra no existe.");
     }
     if ($empresa->getActivo() == false) {
         throw new BusinessLogicException("Una empresa inactiva no puede hacer compras.");
     }
     //validemos los valores conocidos
     //( 0 >= descuento > 100, subtotal > 0, total >= subtotal, etc etc)
     //validemos sucursal
     $sucursal = null;
     if (!is_null($id_sucursal) && strlen($id_sucursal) > 0) {
         $sucursal = SucursalDAO::getByPK($id_sucursal);
         if (is_null($sucursal)) {
             Logger::error("La sucursal {$id_sucursal} no existe");
             //throw new InvalidDataException("La sucural que se envio no existe.");
         }
     }
     //validemos detalles de compra
     //debe traer
     // 	-id_producto
     //	-cantidad
     //	-precio
     //	-lote
     if (!is_array($detalle)) {
         throw InvalidDataException("El detalle no es un arreglo");
     }
     for ($detalleIterator = 0; $detalleIterator < sizeof($detalle); $detalleIterator++) {
         //por cada producto
         //	-debe existir
         //	-si se lo compro a un proveedor no hay pedo
         // 	 si se lo compro a un cliente, debe de tener comprar_caja = 1
         //	-debe tener cantidad mayor a 0
         //	-que exista el lote a donde va a ir
         $p = $detalle[$detalleIterator];
         if (!isset($p->precio)) {
             throw new InvalidArgumentException("No se envio el precio");
         }
         if (!isset($p->id_producto)) {
             throw new InvalidArgumentException("No se envio el id_producto");
         }
         if (!isset($p->cantidad)) {
             throw new InvalidArgumentException("No se envio la cantidad");
         }
         if (!isset($p->lote)) {
             throw new InvalidArgumentException("No se envio el lote");
         }
         $producto = ProductoDAO::getByPK($p->id_producto);
         if (is_null($producto)) {
             throw new InvalidArgumentException("El producto a comprar no existe");
         }
         if ($p->cantidad <= 0) {
             throw new InvalidArgumentException("No puedes comprar 0 unidades");
         }
     }
     $s = SesionController::getCurrentUser();
     //terminaron las validaciones
     $compra = new Compra();
     $compra->setIdVendedorCompra($id_usuario_compra);
     $compra->setTipoDeCompra($tipo_compra);
     $compra->setFecha(time());
     $compra->setSubtotal($subtotal);
     $compra->setImpuesto($impuesto);
     $compra->setDescuento($descuento);
     $compra->setTotal($subtotal + $impuesto);
     $compra->setIdUsuario($s->getIdUsuario());
     $compra->setIdEmpresa($id_empresa);
     $compra->setSaldo(0);
     $compra->setCancelada(false);
     $compra->setTipoDePago($tipo_de_pago);
     $compra->setRetencion(0);
     try {
         DAO::transBegin();
         CompraDAO::save($compra);
     } catch (Exception $e) {
         DAO::transRollback();
         throw InvalidDatabaseOperationException($e);
     }
     for ($detalleIterator = 0; $detalleIterator < sizeof($detalle); $detalleIterator++) {
         //por cada producto
         //	--- procesos ---
         //	-insertar en productoempresa
         //	-insertar en loteproducto
         //	-insertar en entradalote
         //	-si el tipo de precio de venta es costo, actualizar
         //	-insertar compra producto
         $p = $detalle[$detalleIterator];
         try {
             ProductoEmpresaDAO::save(new ProductoEmpresa(array("id_empresa" => $id_empresa, "id_producto" => $p->id_producto)));
             if (is_null($p->lote)) {
                 throw new InvalidDataException("No selecciono a que lote ira el producto " . $p->id_producto);
             }
             if (strlen($p->lote) == 0) {
                 throw new InvalidDataException("No selecciono a que lote ira el producto " . $p->id_producto);
             }
             //busquemos el id del lote
             $l = LoteDAO::search(new Lote(array("folio" => $p->lote)));
             $l = $l[0];
             //busquemos la unidad que nos mandaron
             $uAbreviacion = $p->id_unidad;
             $uResults = UnidadMedidaDAO::search(new UnidadMedida(array("abreviacion" => $uAbreviacion, "activa" => 1)));
             if (sizeof($uResults) != 1) {
                 throw new InvalidDataException("La unidad de medida `" . $p->id_unidad . "` no existe, o no esta activa.");
             } else {
                 $p->id_unidad = $uResults[0]->getIdUnidadMedida();
             }
             //busequemos si este producto ya existe en este lote
             $lp = LoteProductoDAO::getByPK($l->getIdLote(), $p->id_producto);
             if (is_null($lp)) {
                 //no existe, insertar
                 $loteProducto = new LoteProducto(array("id_lote" => $l->getIdLote(), "id_producto" => $p->id_producto, "cantidad" => $p->cantidad, "id_unidad" => $p->id_unidad));
                 LoteProductoDAO::save($loteProducto);
             } else {
                 //ya existe, sumar
                 //revisemos si es de la misma unidad
                 if ($lp->getIdUnidad() == $p->id_unidad) {
                     //es igual, solo hay que sumar
                     $lp->setCantidad($lp->getCantidad() + $p->cantidad);
                 } else {
                     //no es igual, hay que convertir
                     try {
                         $r = UnidadMedidaDAO::convertir($p->id_unidad, $lp->getIdUnidad(), $p->cantidad);
                     } catch (BusinessLogicException $ide) {
                         //no se pudo convertir porque son de
                         //diferentes categorias
                         throw $ide;
                         //mostrar una excpetion mas fresona
                     }
                     $lp->setCantidad($lp->getCantidad() + $r);
                 }
                 //$lp->setCantidad( $lp->getCantidad() + $p->cantidad );
                 LoteProductoDAO::save($lp);
             }
             $loteEntrada = new LoteEntrada(array("id_lote" => $l->getIdLote(), "id_usuario" => $s->getIdUsuario(), "fecha_registro" => time(), "motivo" => "Compra a Proveedor"));
             LoteEntradaDAO::save($loteEntrada);
             LoteEntradaProductoDAO::save(new LoteEntradaProducto(array("id_lote_entrada" => $loteEntrada->getIdLoteEntrada(), "id_producto" => $p->id_producto, "id_unidad" => $p->id_unidad, "cantidad" => $p->cantidad)));
             $compraProducto = new CompraProducto(array("id_compra" => $compra->getIdCompra(), "id_producto" => $p->id_producto, "cantidad" => $p->cantidad, "precio" => $p->precio, "descuento" => 0, "impuesto" => 0, "id_unidad" => $p->id_unidad, "retencion" => 0));
             CompraProductoDAO::save($compraProducto);
         } catch (InvalidDataException $e) {
             Logger::error($e);
             DAO::transRollback();
             throw $e;
         } catch (exception $e) {
             Logger::error($e);
             DAO::transRollback();
             throw new InvalidDatabaseOperationException($e);
         }
     }
     //for
     try {
         DAO::transEnd();
     } catch (Exception $e) {
         throw InvalidDatabaseOperationException($e);
     }
     Logger::log("===== COMPRA " . $compra->getIdCompra() . " EXITOSA ===== ");
     return array("id_compra" => $compra->getIdCompra());
 }
 public function testDesactivarProducto()
 {
     //se crea un nuevo cliente que es el que debe de ser encontrado en el query
     $nombre = self::RandomString(15, FALSE, FALSE, FALSE) . " - " . time();
     $codigo = self::RandomString(5, FALSE, FALSE, FALSE);
     $nuevo_prod = ProductosController::Nuevo($activo = true, $codigo_producto = $codigo, $compra_mostrador = true, $costo_estandar = "costo", $id_unidad_compra = 1, $metodo_costeo = "costo", $nombre_producto = $nombre);
     $this->assertInternalType("int", $nuevo_prod["id_producto"], "---- 'testDesactivarProducto' 'id_producto' NO ES UN ENTERO");
     ProductosController::Desactivar($nuevo_prod["id_producto"]);
     //se busca el prod recien insertado para ver si esta activo = 0
     $res = ProductoDAO::getByPK($nuevo_prod["id_producto"]);
     $this->assertEquals(0, $res->getActivo(), "---- 'testDesactivarProducto' EL PRODUCTO NO SE DESACTIVÓ  id_producto= " . $nuevo_prod["id_producto"]);
 }
 /**
  *
  *Crea un registro de traspaso de producto de un almacen a otro. El usuario que envia sera tomada de la sesion.
  *
  * @param id_almacen_recibe int Id del almacen al que se envia el producto
  * @param id_almacen_envia int Id del almacen que envia el producto
  * @param fecha_envio_programada string Fecha de envio programada para este traspaso
  * @param productos json Productos a ser enviados con sus cantidades
  * @return id_traspaso int Id del traspaso autogenerado
  **/
 public static function ProgramarTraspasoAlmacen($fecha_envio_programada, $id_almacen_envia, $id_almacen_recibe, $productos)
 {
     Logger::log("Creando traspaso");
     //Se obtiene al usuario de la sesion actual
     $id_usuario = SesionController::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?");
     }
     //verifica que los almacenes no sean iguales, que existan en la base de datos, que esten abiertos
     if ($id_almacen_envia == $id_almacen_recibe) {
         Logger::error("El almacen que envia es el mismo que el que recibe");
         throw new Exception("El almacen que envia es el mismo que el que recibe");
     }
     $validar = self::validarParametrosTraspaso(null, NULL, $id_almacen_recibe, $fecha_envio_programada);
     if (is_string($validar)) {
         Logger::error($validar);
         throw new Exception($validar);
     }
     $validar = self::validarParametrosTraspaso(null, null, $id_almacen_envia);
     if (is_string($validar)) {
         Logger::error($validar);
         throw new Exception($validar);
     }
     $almacen_recibe = AlmacenDAO::getByPK($id_almacen_recibe);
     if (!$almacen_recibe->getActivo()) {
         Logger::error("El almacen que recibe no esta activo, no se le puede programar un traspaso");
         throw new Exception("El almacen que recibe no esta activo, no se le puede programar un traspaso");
     }
     $almacen_envia = AlmacenDAO::getByPK($id_almacen_envia);
     if (!$almacen_envia->getActivo()) {
         Logger::error("El almacen que envia no esta activo, no se le puede programar un traspaso");
         throw new Exception("El almacen que envia no esta activo, no se le puede programar un traspaso");
     }
     //Inicializa el registro de traspaso
     $traspaso = new Traspaso(array("id_usuario_programa" => $id_usuario, "id_usuario_envia" => 0, "id_almacen_envia" => $id_almacen_envia, "fecha_envio_programada" => $fecha_envio_programada, "fecha_envio" => "0000-00-00 00:00:00", "id_usuario_recibe" => 0, "id_almacen_recibe" => $id_almacen_recibe, "fecha_recibo" => "0000-00-00 00:00:00", "estado" => "Envio programado", "cancelado" => 0, "completo" => 0));
     DAO::transBegin();
     try {
         //Se guarda el registro de traspaso y se insertan los registros de traspaso_producto.
         TraspasoDAO::save($traspaso);
         $traspaso_producto = new TraspasoProducto(array("id_traspaso" => $traspaso->getIdTraspaso(), "cantidad_recibida" => 0));
         $productos = object_to_array($productos);
         if (!is_array($productos)) {
             throw new Exception("Los productos son invalidos", 901);
         }
         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 son invalidos", 901);
             }
             //Se validan los parametros de producto
             if (is_null(ProductoDAO::getByPK($p["id_producto"]))) {
                 throw new Exception("El producto con id: " . $p["id_producto"] . " no existe");
             }
             $validar = self::validarNumero($p["cantidad"], 1.8E+200, "cantidad");
             if (is_string($validar)) {
                 throw new Exception($validar);
             }
             //Se valida que los productos enviados pertenezcan a la empresa del almacen que recibe,
             //pues un almacen no puede tener producto de una empresa que no es la suya.
             $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;
                     break;
                 }
             }
             if (!$encontrado) {
                 throw new Exception("Se quiere enviar producto que pertenece a otra empresa");
             }
             $traspaso_producto->setIdProducto($p["id_producto"]);
             $traspaso_producto->setIdUnidad($p["id_unidad"]);
             $traspaso_producto->setCantidadEnviada($p["cantidad"]);
             TraspasoProductoDAO::save($traspaso_producto);
         }
         /* Fin de foreach */
     } catch (Exception $e) {
         DAO::transRollback();
         Logger::error("Error al crear el traspaso de producto: " . $e);
         throw new Exception("Error al crear el traspaso de producto");
     }
     DAO::transEnd();
     Logger::log("traspaso creado exitosamente");
     return array("id_traspaso" => $traspaso->getIdTraspaso());
 }
Beispiel #21
0
<?php

define("BYPASS_INSTANCE_CHECK", false);
require_once "../../../server/bootstrap.php";
$page = new GerenciaComponentPage();
//
// Parametros necesarios
//
$page->requireParam("pid", "GET", "Este producto no existe.");
$este_producto = ProductoDAO::getByPK($_GET["pid"]);
//
// Titulo de la pagina
//
$page->addComponent(new TitleComponent("Editar  " . $este_producto->getNombreProducto(), 2));
//
// Forma de usuario
//
$form = new DAOFormComponent($este_producto);
$form->hideField(array("id_producto", "activo"));
$form->sendHidden("id_producto");
$form->addApiCall("api/producto/editar/", "POST");
$form->renameField(array("descripcion" => "descripcion_producto"));
$form->onApiCallSuccessRedirect("productos.ver.php?pid=" . $este_producto->getIdProducto());
$form->createComboBoxJoinDistintName("id_unidad_compra", "id_unidad_medida", "abreviacion", UnidadMedidaDAO::search(new UnidadMedida(array("activa" => 1))));
$form->createComboBoxJoinDistintName("id_unidad", "id_unidad_medida", "abreviacion", UnidadMedidaDAO::search(new UnidadMedida(array("activa" => 1))));
$form->createComboBoxJoin("metodo_costeo", "metodo_costeo", array("precio", "costo"), $este_producto->getMetodoCosteo());
$form->createComboBoxJoin("compra_en_mostrador", "compra_en_mostrador", array(array("id" => 1, "caption" => "si"), array("id" => 0, "caption" => "no")), $este_producto->getCompraEnMostrador());
$form->createComboBoxJoin("visible_en_vc", "visible_en_vc", array(array("id" => 1, "caption" => "Si"), array("id" => 0, "caption" => "No")), 1);
$page->addComponent($form);
$page->render();
Beispiel #22
0
    for ($i = 0; $i < 4; $i++) {
        if (isset($totales_compras[$key][$i])) {
            $bar++;
        }
    }
    if ($foo > 1 || $bar > 1) {
        echo "<td><div style='color:red'> <---- distintas unidades</div></td>";
    } else {
        echo "<td></td>";
    }
    if ($total < 0) {
        echo "<td><strong style='color:red'>" . $total . "</strong></td>";
    } else {
        echo "<td><strong>" . $total . "</strong></td>";
    }
    $nexistencias = ProductoDAO::ExistenciasTotales($key);
    if ($nexistencias != $total) {
        echo "<td><div style='background-color:red'>" . $nexistencias . "</div></td>";
    } else {
        echo "<td><div style='background-color:green'>" . $nexistencias . "</div></td>";
    }
    echo "</tr>";
}
echo "</table>";
/*
SucursalesController::DescontarDeAlmacenes( $d_producto, $id_sucursal );
SucursalesController::IncrementarDeAlmacenes( $d_producto, $id_sucursal );
*/
/*
TRUNCATE `lote_entrada`;
TRUNCATE `lote_entrada_producto`;