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; }
private static function printProducts(&$pdf, $productos) { $opciones_tabla = array(); $opciones_tabla['showLines'] = 0; $opciones_tabla['showHeadings'] = 0; $opciones_tabla['shaded'] = 0; $opciones_tabla['fontSize'] = 8; $opciones_tabla['xOrientation'] = 'right'; $opciones_tabla['xPos'] = self::puntos_cm(7.5); $opciones_tabla['width'] = self::puntos_cm(11); $opciones_tabla['textCol'] = array(0, 0, 0); $opciones_tabla['titleFontSize'] = 12; $opciones_tabla['rowGap'] = 3; $opciones_tabla['colGap'] = 3; $opciones_tabla['xPos'] = self::puntos_cm(14.2); $opciones_tabla['showLines'] = 0; $opciones_tabla['shaded'] = 2; $opciones_tabla['shadeCol'] = array(1, 1, 1); $opciones_tabla['shadeCol2'] = array(0.8984375, 0.95703125, 0.99609375); /* ************************* * PRODUCTOS * ************************* */ $elementos = array(array('cantidad' => 'Cantidad', 'descripcion' => 'Descripcion ', 'precio' => 'Precio', 'importe' => 'Importe')); $subtotal = 0; $total = 0; $impuesto = 0; foreach ($productos as $p) { if ($p instanceof VentaProducto) { $prodDao = ProductoDAO::getByPK($p->getIdProducto()); if (!is_null($prodDao)) { $prod['cantidad'] = $p->getCantidad(); if (!is_null($p->getIdUnidad())) { $unidad = UnidadMedidaDAO::getByPK($p->getIdUnidad()); if (!is_null($unidad)) { $prod['cantidad'] .= " " . $unidad->getAbreviacion(); } } $prod['descripcion'] = $prodDao->getNombreProducto(); $prod['precio'] = FormatMoney($p->getPrecio(), DONT_USE_HTML); $prod['importe'] = FormatMoney($p->getPrecio() * $p->getCantidad(), DONT_USE_HTML); $subtotal += $p->getPrecio() * $p->getCantidad(); $total = $subtotal; array_push($elementos, $prod); } else { Logger::error("El producto que se intentaba imprimir ya no existe !!"); } } else { if ($p instanceof VentaOrden) { $ordenDao = OrdenDeServicioDAO::getByPK($p->getIdOrdenDeServicio()); $serv = ServicioDAO::getByPK($ordenDao->getIdServicio()); $prod['cantidad'] = "-"; $prod['descripcion'] = $serv->getNombreServicio(); $prod['precio'] = FormatMoney($p->getPrecio(), DONT_USE_HTML); $prod['importe'] = FormatMoney($p->getPrecio(), DONT_USE_HTML); $subtotal += $p->getPrecio(); $total = $subtotal; array_push($elementos, $prod); } else { if ($p instanceof Venta) { array_push($elementos, array("cantidad" => "", "descripcion" => "", "precio" => "Subtotal", "importe" => FormatMoney($p->getSubtotal(), DONT_USE_HTML))); array_push($elementos, array("cantidad" => "", "descripcion" => "", "precio" => "Descuento", "importe" => FormatMoney($p->getDescuento(), DONT_USE_HTML))); array_push($elementos, array("cantidad" => "", "descripcion" => "", "precio" => "IVA", "importe" => FormatMoney($p->getImpuesto(), DONT_USE_HTML))); array_push($elementos, array("cantidad" => "", "descripcion" => "", "precio" => "Total", "importe" => FormatMoney($p->getTotal(), DONT_USE_HTML))); $letra = new CNumeroaLetra(); $letra->setNumero($p->getTotal()); array_push($elementos, array("cantidad" => "", "descripcion" => $letra->letra(), "precio" => "", "importe" => "")); } } } } $pdf->ezSetY(self::puntos_cm(18.6)); $opciones_tabla['xPos'] = self::puntos_cm(2); $opciones_tabla['width'] = self::puntos_cm(16.2); $pdf->ezTable($elementos, "", "", $opciones_tabla); }
/** * * Permite dar conocer al sistema las verdaderas existencias en un almacen, o sucursal. * * @param inventario json [{id_producto: 1,id_unidad: 2,cantidad: 0,id_lote : 2}] * @param id_sucursal int * */ static function Fisico($inventario, $id_sucursal = "") { //POS.API.POST("api/inventario/fisico", {inventario : Ext.JSON.encode([{id_producto:8, id_unidad:1, cantidad:7, id_lote:1}]) } , {callback:function(){}}) $s = SesionController::Actual(); Logger::log("---------- INVENTARIO FISICO SE ENCONTRARON " . count($inventario) . " AJUSTES ----------"); foreach ($inventario as $producto) { //self::ajustarLoteProducto($producto->id_lote, $producto->id_producto, $producto->id_unidad); //[{id_producto: 1,id_unidad: 2,cantidad: 0,id_lote : 2}] $producto->nombre = ProductoDAO::getByPK($producto->id_producto)->getNombreProducto(); Logger::log(" Estamos en {$producto->nombre}, id_unidad {$producto->id_unidad}, {$producto->cantidad} " . UnidadMedidaDAO::getByPK($producto->id_unidad)->getAbreviacion() . ", lote {$producto->id_lote}"); try { //verificamos si el lote indicado existe if (is_null($producto->id_lote) || strlen($producto->id_lote) == 0) { throw new InvalidDataException("No selecciono a que lote ira el producto {$producto->id_producto}"); } //busquemos el id del lote if (!($lote = LoteDAO::getByPK($producto->id_lote))) { throw new InvalidDataException("No se tiene registro del lote {$producto->id_lote}"); } //verificamos que exista la unidad de medida y este activa if (!UnidadMedidaDAO::getByPK($producto->id_unidad)) { throw new InvalidDataException("La unidad de medida {$producto->id_unidad} no existe, o no esta activa."); } //busquemos si este producto ya existe en este lote $lote_producto = LoteProductoDAO::getByPK($lote->getIdLote(), $producto->id_producto); if (is_null($lote_producto)) { Logger::log("El producto no estaba en el lote, se insertara"); /* //no existe, insertar $loteProducto = new LoteProducto(array( "id_lote" => $lote->getIdLote(), "id_producto" => $producto->id_producto, "cantidad" => $producto->cantidad, "id_unidad" => $producto->id_unidad )); LoteProductoDAO::save($loteProducto); Logger::log("Se guardo el LoteProducto : id_lote {$lote->getIdLote()}, id_producto {$producto->id_producto}, cantidad {$producto->cantidad} id_unidad {$producto->id_unidad}"); $loteEntrada = new LoteEntrada(array( "id_lote" => $lote->getIdLote(), "id_usuario" => $s['id_usuario'], "fecha_registro" => time(), "motivo" => "Entrada por ajuste de inventario" )); LoteEntradaDAO::save($loteEntrada); Logger::log("Se guardo el LoteEntrada: id_lote {$lote->getIdLote()}, id_usuario {$s['id_usuario']}, motivo {Entrada por ajuste de inventario}"); */ AlmacenesController::EntradaLote($lote->getIdLote(), array($producto), "Entrada por ajuste de inventario"); } else { Logger::log("El producto si estaba en el lote, verificaremos las cantidades"); //revisemos si es de la misma unidad if ($lote_producto->getIdUnidad() == $producto->id_unidad) { Logger::log("Se encontro que la unidad enviada es igual a la unidad del lote producto"); Logger::log("Se detecto una merma de {$producto->cantidad} " . UnidadMedidaDAO::getByPK($producto->id_unidad)->getAbreviacion() . " de {$producto->nombre}"); //$existencias_lote = ProductoDAO::ExistenciasLote($producto->id_producto, $lote->getIdLote(), $lote_producto->getIdUnidad()); $existencias_lote = ProductoDAO::ExistenciasTotales($producto->id_producto); Logger::log("Se encontraron {$existencias_lote} existencias en el lote {$lote->getIdLote()} para el producto {$producto->id_producto}"); } else { Logger::log("Se encontro que la unidad enviada es diferente a la unidad del lote producto, se procede a transformar"); //$existencias_lote = ProductoDAO::ExistenciasLote($producto->id_producto, $lote->getIdLote(), $lote_producto->getIdUnidad()); $existencias_lote = ProductoDAO::ExistenciasTotales($producto->id_producto); Logger::log("Se encontraron {$existencias_lote} " . UnidadMedidaDAO::getByPK($lote_producto->getIdUnidad())->getAbreviacion() . " en el lote {$lote->getIdLote()} para el producto " . ProductoDAO::getByPK($producto->id_producto)->getNombreProducto() . " , nosotros necesitamos que se transforme en " . UnidadMedidaDAO::getByPK($producto->id_unidad)->getAbreviacion()); //var_dump($producto->id_unidad, $lote_producto->getIdUnidad(), $existencias_lote); try { Logger::log("Enviara a transformar unidad base : {$producto->id_unidad}, unidad a transformar : {$lote_producto->getIdUnidad()}, cantidad a transformar : {$existencias_lote}"); $existencias_lote = UnidadMedidaDAO::convertir($lote_producto->getIdUnidad(), $producto->id_unidad, $existencias_lote); Logger::log("Como producto de la transformacion se obtuvo {$existencias_lote} "); } catch (BusinessLogicException $ide) { //no se pudo convertir porque son de //diferentes categorias throw $ide; //mostrar una excpetion mas fresona } } Logger::log("se evaluara {$existencias_lote} - {$producto->cantidad}"); //hacemos el ajuste $diff = $existencias_lote - $producto->cantidad; if ($diff > 0) { //entonces hay una merma y se reporta una salida al lote igual a $diff, especificando en motivo el id del movimiento realizado //se actualiza la cantidad de producto en lote producto //AlmacenesController::Salida($l->getIdAlmacen(), $producto, "100"); $diff = abs($diff); Logger::log("Se detecto una merma de {$diff} " . UnidadMedidaDAO::getByPK($producto->id_unidad)->getAbreviacion() . " de {$producto->nombre}"); /* $lote_salida = new LoteSalida(array( "id_lote" => $lote->getIdLote(), "id_usuario" => $s['id_usuario'], "fecha_registro" => time(), "motivo" => "Salida de producto por ajuste de inventario (merma)" )); LoteSalidaDAO::save($lote_salida); Logger::log("Se creo un lote salida id_lote {$lote->getIdLote()}, id_usuario {$s['id_usuario']}, motivo Salida de producto por ajuste de inventario (merma)"); $lote_salida_producto = new LoteSalidaProducto(array( "id_lote_salida" => $lote_salida->getIdLoteSalida(), "id_producto" => $producto->id_producto, "id_unidad" => $producto->id_unidad, "cantidad" => $producto->cantidad )); LoteSalidaProductoDAO::save($lote_salida_producto); Logger::log("Se creo un lote salida producto con id_lote_salida {$lote_salida->getIdLoteSalida()}, id_producto {$producto->id_producto}, id_unidad {$producto->id_unidad}, cantidad {$producto->cantidad}"); */ AlmacenesController::SalidaLote($lote->getIdLote(), array(array("id_producto" => $producto->id_producto, "cantidad" => $diff, "id_unidad" => $producto->id_unidad)), "Salida de producto por ajuste de inventario (merma)"); } if ($diff < 0) { $diff = abs($diff); //entonces hay un sobrante y se reporta una entrada al lote igual a $diff, especificando en motivo el id del movimiento realizado //se actualiza la cantidad de producto en lote producto //AlmacenesController::Entrada($l->getIdAlmacen(), $producto, "101"); Logger::log("Se detecto una sobrante de {$diff} " . UnidadMedidaDAO::getByPK($producto->id_unidad)->getAbreviacion()); /* $lote_entrada = new LoteEntrada(array( "id_lote" => $lote->getIdLote(), "id_usuario" => $s['id_usuario'], "fecha_registro" => time(), "motivo" => "Entrada de producto por ajuste de inventario (sobrante)" )); LoteEntradaDAO::save($lote_entrada); Logger::log("Se creo un lote entrada id_lote {$lote->getIdLote()}, id_usuario {$s['id_usuario']}, motivo Entrada de producto por ajuste de inventario (sobrante)"); $lote_entrada_producto = new LoteEntradaProducto(array( "id_lote_entrada" => $lote_entrada->getIdLote(), "id_producto" => $producto->id_producto, "id_unidad" => $producto->id_unidad, "cantidad" => $producto->cantidad )); LoteEntradaProductoDAO::save($lote_entrada_producto); Logger::log("Se creo un lote entrada producto con id_lote_entrada {$lote_entrada->getIdLoteEntrada()}, id_producto {$producto->id_producto}, id_unidad {$producto->id_unidad}, cantidad {$producto->cantidad}"); */ //AlmacenesController::EntradaLote($lote->getIdLote(), array($producto), "Entrada de producto por ajuste de inventario (sobrante)"); AlmacenesController::EntradaLote($lote->getIdLote(), array(array("id_producto" => $producto->id_producto, "cantidad" => $diff, "id_unidad" => $producto->id_unidad)), "Entrada de producto por ajuste de inventario (sobrante)"); } //TODO:HAY QUE AHCER PRUEBAS EXHAUSTIVAS PARA VER SI ESTE ULTIMO BLOQUE DE CODIGO SE DEBERIA DE ELIMINAR //actualizamos las existencias de lote producto if ($diff != 0) { Logger::log("Se procede a hacer el ajuste del lote producto"); self::ajustarLoteProducto($producto->id_lote, $producto->id_producto, $producto->id_unidad); } else { Logger::log("Se detecto que la cantidad en tote producto concuerda con la cantidad inventariada, pero aun asi se llamara al metodo de ajuste de prodcuto"); self::ajustarLoteProducto($producto->id_lote, $producto->id_producto, $producto->id_unidad); } } } catch (InvalidDataException $e) { Logger::error($e); DAO::transRollback(); throw $e; } catch (exception $e) { Logger::error($e); DAO::transRollback(); throw new InvalidDatabaseOperationException($e); } } }
function funcion_producto($id_producto) { return ProductoDAO::getByPK($id_producto) ? ProductoDAO::getByPK($id_producto)->getNombreProducto() : "---------"; }
/** * *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; }
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; }
/** * *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()); }
/** * *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()); }
<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; }
/** * 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; }
/** * *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; }
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"]); }
/** * *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()); }
<?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();
} if (!isset($totales_ventas[$productos[$p]->getIdProducto()])) { $totales_ventas[$productos[$p]->getIdProducto()] = array(); } if (!isset($totales_ventas[$productos[$p]->getIdProducto()][$productos[$p]->getIdUnidad()])) { $totales_ventas[$productos[$p]->getIdProducto()][$productos[$p]->getIdUnidad()] = 0; } $totales_ventas[$productos[$p]->getIdProducto()][$productos[$p]->getIdUnidad()] += $productos[$p]->getCantidad(); } echo "</div>"; } echo "<hr><table border=1>"; echo "<tr><td colspan=2>idprod</td><td colspan=3>compras</td><td colspan=3>ventas</td><td >warnings</td><td >total</td></tr>"; foreach ($totales_ventas as $key => $value) { echo "<tr><td>producto " . $key . "</td>"; $p = ProductoDAO::getByPK($key); echo "<td>" . $p->getNombreProducto() . "</td>"; $total = 0; if (isset($totales_compras[$key])) { //si tiene compras echo "<td><span style='color:green'>" . (isset($totales_compras[$key][1]) ? $totales_compras[$key][1] : "") . "</span></td>"; echo "<td><span style='color:green'>" . (isset($totales_compras[$key][2]) ? $totales_compras[$key][2] : "") . "</span></td>"; echo "<td><span style='color:green'>" . (isset($totales_compras[$key][3]) ? $totales_compras[$key][3] : "") . "</span></td>"; $total += isset($totales_compras[$key][1]) ? $totales_compras[$key][1] : 0; $total += isset($totales_compras[$key][2]) ? $totales_compras[$key][2] : 0; $total += isset($totales_compras[$key][3]) ? $totales_compras[$key][3] : 0; } else { echo "<td></td><td></td><td></td>"; } echo "<td><span style='color:red'>" . (isset($value[1]) ? $value[1] : "") . "</span></td>"; echo "<td><span style='color:red'>" . (isset($value[2]) ? $value[2] : "") . "</span></td>";