/** * *Metodo que cancela una venta * * @param id_venta string Id de la venta a cancelar **/ public static function Cancelar($id_venta, $billetes = null, $id_caja = null) { Logger::log("======= Cancenlando venta " . $id_venta . " ==========="); //valida que la venta exista y que este activa $venta = VentaDAO::getByPK($id_venta); if ($venta == null) { Logger::error("La venta con id: " . $id_venta . " no existe"); throw new Exception("La venta con id: " . $id_venta . " no existe"); } if ($venta->getCancelada()) { Logger::warn("La venta ya ha sido cancelada"); return; } //Deja la venta como cancelada y la guarda. $venta->setCancelada(1); //Obtiene al usuario al que se le vendio $usuario = UsuarioDAO::getByPK($venta->getIdCompradorVenta()); if ($usuario == null) { Logger::error("FATAL!!! Esta venta apunta a un usuario que no existe"); throw new Exception("FATAL!!! Esta venta apunta a un usuario que no existe"); } DAO::transBegin(); // regresar de almacenes // obtener los productos que se vendieron // insertalos como neuvo ingreso $detalle = VentaProductoDAO::search(new VentaProducto(array("id_venta" => $id_venta))); 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->getIdProducto() ) ) ); 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::getByPk(1); //busquemos la unidad que nos mandaron $uResults = UnidadMedidaDAO::search(new UnidadMedida(array("id_unidad_medida" => $p->getIdUnidad(), "activa" => 1))); if (sizeof($uResults) != 1) { throw new InvalidDataException("La unidad de medida `" . $p->id_unidad . "` no existe, o no esta activa."); } //busequemos si este producto ya existe en este lote $lp = LoteProductoDAO::getByPK($l->getIdLote(), $p->getIdProducto()); if (is_null($lp)) { //no existe, insertar $loteProducto = new LoteProducto(array("id_lote" => $l->getIdLote(), "id_producto" => $p->getIdProducto(), "cantidad" => $p->getCantidad(), "id_unidad" => $p->getIdUnidad())); LoteProductoDAO::save($loteProducto); } else { //ya existe, sumar //revisemos si es de la misma unidad if ($lp->getIdUnidad() == $p->getIdUnidad()) { //es igual, solo hay que sumar $lp->setCantidad($lp->getCantidad() + $p->getCantidad()); } else { //no es igual, hay que convertir try { $r = UnidadMedidaDAO::convertir($p->getIdUnidad(), $lp->getIdUnidad(), $p->getCantidad()); } 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); } $s = SesionController::getCurrentUser(); $loteEntrada = new LoteEntrada(array("id_lote" => $l->getIdLote(), "id_usuario" => $s->getIdUsuario(), "fecha_registro" => time(), "motivo" => "Venta (" . $id_venta . ") Cancelada")); LoteEntradaDAO::save($loteEntrada); LoteEntradaProductoDAO::save(new LoteEntradaProducto(array("id_lote_entrada" => $loteEntrada->getIdLoteEntrada(), "id_producto" => $p->getIdProducto(), "id_unidad" => $p->getIdUnidad(), "cantidad" => $p->getCantidad()))); /* $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); } } try { VentaDAO::save($venta); //Si la venta fue a credito, se cancelan todos los abonos hechos al mismo y el dinero se queda a cuenta del usuario. if ($venta->getTipoDeVenta() == "credito") { $abono_venta = new AbonoVenta(); $abono_venta->setIdVenta($id_venta); $abonos = AbonoVentaDAO::search($abono_venta); foreach ($abonos as $abono) { if (!$abono->getCancelado()) { CargosYAbonosController::EliminarAbono($abono->getIdAbonoVenta(), "Venta cancelada", 0, 1, 0, null, null); } } $usuario->setSaldoDelEjercicio($usuario->getSaldoDelEjercicio() + $venta->getTotal()); UsuarioDAO::save($usuario); } else { if ($venta->getTipoDeVenta() == "contado" && !is_null($id_caja)) { CajasController::modificarCaja($id_caja, 1, $billetes, $venta->getTotal()); } } } catch (Exception $e) { DAO::transRollback(); Logger::error("No se pudo cancelar la venta: " . $e); throw new Exception("No se pudo cancelar la venta"); } DAO::transEnd(); Logger::log("Venta cancelada exitosamente"); }
/** * *Cancela una compra * * @param id_compra int Id de la compra a cancelar **/ public static function Cancelar($id_compra, $billetes = null, $id_caja = null) { Logger::log("Cancenlando compra " . $id_compra); //valida que la compra exista y que este activa $compra = CompraDAO::getByPK($id_compra); if ($compra == null) { throw new Exception("La compra con id: " . $id_compra . " no existe", 901); } if ($compra->getCancelada()) { Logger::warn("La compra ya ha sido cancelada"); return; } //Obtiene al usuario al que se le compro $usuario = UsuarioDAO::getByPK($compra->getIdVendedorCompra()); if ($usuario == null) { throw new Exception("FATAL!!! Esta compra apunta a un usuario que no existe", 901); } //Deja la compra como cancelada y la guarda. $compra->setCancelada(1); DAO::transBegin(); try { $com_prod = new CompraProducto(); $com_prod->setIdCompra($id_compra); $prods_compra = CompraProductoDAO::search($com_prod); foreach ($prods_compra as $p) { //De que almacen/inventario lo descuento? , del almacen de la empresa? como identifico el lote de entrada prod? continue; $ven_prod = new VentaProducto(); $ven_prod->setIdProducto(); $ven_prod->setCantidad($p->getCantidad()); $ven_prod->setPrecio($p->getPrecio()); $ven_prod->setDescuento($p->getDescuento()); SucursalesController::DescontarDeAlmacenes($ven_prod, $compra->getIdSucursal()); } CompraDAO::save($compra); //Si la compra fue a credito, se cancelan todos los abonos hechos al mismo y el dinero se queda a cuenta del usuario. if ($compra->getTipoDeCompra() == "credito") { $abono_compra = new AbonoCompra(); $abono_compra->setIdCompra($id_compra); $abonos = AbonoCompraDAO::search($abono_compra); foreach ($abonos as $abono) { if (!$abono->getCancelado()) { CargosYAbonosController::EliminarAbono($abono->getIdAbonoCompra(), "Compra cancelada", 1, 0, 0, null, null); } } $usuario->setSaldoDelEjercicio($usuario->getSaldoDelEjercicio() - $compra->getTotal()); UsuarioDAO::save($usuario); } else { if ($compra->getTipoDeCompra() == "contado" && !is_null($id_caja)) { CajasController::modificarCaja($id_caja, 1, $billetes, $compra->getTotal()); } } } catch (Exception $e) { DAO::transRollback(); Logger::error("No se pudo cancelar la compra: " . $e); throw new Exception("No se pudo cancelar la compra, consulte a su administrador de sistema", 901); } DAO::transEnd(); Logger::log("Compra cancelada exitosamente"); }
/** * *Realiza un corte de caja. Este metodo reduce el dinero de la caja y va registrando el dinero acumulado de esa caja. Si faltase dinero se carga una deuda al cajero. La fecha sera tomada del servidor. El usuario sera tomado de la sesion. * * @param saldo_final float Saldo que se dejara en la caja para que continue realizando sus operaciones. * @param id_caja int Id de la caja a la que se le hace el corte * @param saldo_real float Saldo real encontrado en la caja * @param billetes_encontrados json Ids de billetes encontrados en la caja al hacer el corte * @param billetes_dejados json Ids de billetes dejados en la caja despues de hacer el corte * @param id_cajero int Id del cajero en caso de que no sea este el que realiza el corte * @param id_cajero_nuevo int Id del cajero que entrara despues de realizar el corte * @return id_corte_caja int Id generado por la insercion del nuevo corte **/ public static function CorteCaja($id_caja, $saldo_final, $saldo_real, $billetes_dejados = null, $billetes_encontrados = null, $id_cajero = null, $id_cajero_nuevo = null) { Logger::log("Realizando corte de caja"); //valida que la caja exista, que este abierta y que este activada $caja = CajaDAO::getByPK($id_caja); if (is_null($caja)) { Logger::error("La caja con id: " . $id_caja . " no existe"); throw new Exception("La caja con id: " . $id_caja . " no existe"); } if (!$caja->getActiva()) { Logger::error("La caja proporcionada no esta activa, no se le puede hacer un corte"); throw new Exception("La caja proporcionada no esta activa, no se le puede hacer un corte"); } if (!$caja->getAbierta()) { Logger::error("La caja proporcionada esta cerrada, no se pueden realizar movimientos a una caja cerrada"); throw new Exception("La caja proporcionada esta cerrada, no se pueden realizar movimientos a una caja cerrada"); } //se inicializa el registro de la tabla corte de caja $corte_de_caja = new CorteDeCaja(array("id_caja" => $id_caja, "id_cajero" => $id_cajero, "id_cajero_nuevo" => $id_cajero_nuevo, "fecha" => time(), "saldo_real" => $saldo_real, "saldo_esperado" => $caja->getSaldo(), "saldo_final" => $saldo_final)); DAO::transBegin(); try { //Se guarda el corte de caja y se modifica la caja, restandole los billetes encontrados y el saldo de la caja. CorteDeCajaDAO::save($corte_de_caja); CajasController::modificarCaja($id_caja, 0, $billetes_encontrados, $caja->getSaldo()); CajasController::modificarCaja($id_caja, 1, $billetes_dejados, $saldo_final); //Si se lleva control de billetes, se hac eun registro por cada tipo de billete encontrado. //Despues, se buscan los billetes que quedan en la caja entre los tipos de billetes encontrados, //si no se encuentran, se crea su registro. //Como los billetes ya han sido restados de la caja, los que queden con numeros positivos seran //aquellos que hagan falta, y los que queden en numeros negativos seran los que sobraran. if ($caja->getControlBilletes()) { $billete_corte_caja = new BilleteCorteCaja(array("id_corte_caja" => $corte_de_caja->getIdCorteDeCaja(), "cantidad_dejada" => 0, "cantidad_sobrante" => 0, "cantidad_faltante" => 0)); $billetes_encontrados = object_to_array($billetes_encontrados); foreach ($billetes_encontrados as $billete) { $billete_corte_caja->setIdBillete($billete["id_billete"]); $billete_corte_caja->setCantidadEncontrada($billete["cantidad"]); BilleteCorteCajaDAO::save($billete_corte_caja); } $billetes_caja = BilleteCajaDAO::search(new BilleteCaja(array("id_caja" => $id_caja))); foreach ($billetes_caja as $b_c) { $billete_corte_caja = BilleteCorteCajaDAO::getByPK($b_c->getIdBillete(), $corte_de_caja->getIdCorteDeCaja()); if (is_null($billete_corte_caja)) { $billete_corte_caja = new BilleteCorteCaja(array("id_billete" => $b_c->getIdBillete(), "id_corte_caja" => $corte_de_caja->getIdCorteDeCaja(), "cantidad_encontrada" => 0, "cantidad_dejada" => 0, "cantidad_sobrante" => 0, "cantidad_faltante" => 0)); } if ($b_c->getCantidad() < 0) { $billete_corte_caja->setCantidadSobrante($b_c->getCantidad()); } else { if ($b_c->getCantidad() > 0) { $billete_corte_caja->setCantidadFaltante($b_c->getCantidad() * -1); } else { continue; } } $b_c->setCantidad(0); BilleteCajaDAO::save($b_c); BilleteCorteCajaDAO::save($billete_corte_caja); } /* Fin del foreach */ //Si los billetes dejados despues del corte no son obtenidos y el saldo de la caja //no es cero, se arroja una excepcion. if (is_null($billetes_dejados) && $saldo_final != 0) { throw new Exception("No se encontro el parametro billetes_dejados cuando se esta llevando control de los billetes en esta caja y su saldo no quedara en 0"); } $billetes_dejados = object_to_array($billetes_dejados); //Por cada billete dejado se busca su registro en la tabla billete_corte_caja, si no existe se crea, //si existe, se actualiza su parametro cantidad_dejada foreach ($billetes_dejados as $b_d) { $billete_corte_caja = BilleteCorteCajaDAO::getByPK($b_d["id_billete"], $corte_de_caja->getIdCorteDeCaja()); if (is_null($billete_corte_caja)) { $billete_corte_caja = new BilleteCorteCaja(array("id_billete" => $b_d["id_billete"], "id_corte_caja" => $corte_de_caja->getIdCorteDeCaja(), "cantidad_encontrada" => 0, "cantidad_dejada" => 0, "cantidad_sobrante" => 0, "cantidad_faltante" => 0)); } $billete_corte_caja->setCantidadDejada($b_d["cantidad"]); BilleteCorteCajaDAO::save($billete_corte_caja); } } /* Fin if control billetes*/ } catch (Exception $e) { DAO::transRollback(); Logger::error("No se pudo realizar el corte de caja: " . $e); throw new Exception("No se pudo realizar el corte de caja"); } DAO::transEnd(); Logger::log("Corte de caja realizado correctamente"); return array("id_corte_caja" => $corte_de_caja->getIdCorteDeCaja()); }
/** * *Se crea un nuevo abono, la caja o sucursal y el usuario que reciben el abono se tomaran de la sesion. La fecha se tomara del servidor * * @param id_deudor int Id del usuario o la sucursal que realiza el abono, las sucursales seran negativas * @param tipo_pago json JSON con la informacion que describe el tipo de pago, si es con cheque, en efectivo o con tarjeta * @param monto float monto abonado de la sucursal * @param nota string Nota del abono * @param id_venta int Id de la venta a la que se le abona * @param varios bool True si el monto sera repartido en los prestamos,ventas o compras mas antiguas. Esto se define si se pasa el valor id_venta,id_prestamo o id_compra * @param cheques json Se toma el nombre del banco, el monto y los ultimos cuatro numeros del o los cheques usados para este abono * @param id_prestamo int Id del prestamo al que se le esta abonando * @param id_compra int Id de la compra a la que se abona * @return id_abono int El id autogenerado del abono de la sucursal **/ public static function NuevoAbono($id_deudor, $monto, $tipo_pago, $billetes = null, $cheques = null, $id_compra = null, $id_prestamo = null, $id_venta = null, $nota = null) { Logger::log("Insertando nuevo abono ... "); //Se obtiene la sesion del usuario $id_usuario = SesionController::getCurrentUser(); $id_usuario = $id_usuario->getIdUsuario(); if (is_null($id_usuario)) { Logger::error("No se pudo obtener el usuario de la sesion, ya inicio sesion?"); throw new AccessDeniedException("No se pudo obtener el usuario de la sesion, ya inicio sesion?"); } //Se validan los parametros obtenidos $validar = self::validarParametrosAbono($monto, $id_deudor, $nota, $tipo_pago); if (is_string($validar)) { Logger::error($validar); throw new Exception($validar); } //Si el tipo de pago es con cheque y no se reciben cheques, lanzas una excepcion if ($tipo_pago === "cheque" && is_null($cheques)) { Logger::error("Se intenta pagar con cheque mas no se envio info de cheques"); throw new Exception("No se recibio informacion del cheque"); } //Se inicializan las variables de los parametros de las tablas de abonos $usuario = UsuarioDAO::getByPK($id_deudor); $id_sucursal = self::getSucursal(); $id_caja = self::getCaja(); $fecha = time(); $cancelado = 0; $abono = null; //Nuevo regitro del abono $from = 0; //Bandera que indica a que operacion pertenece el abono $operacion = null; //Objeto de la operacion, puede ser un objeto de venta, de ocmpra o de prestamo /* * Se valida de que operacion pertenece el abono y de acuerdo a lo obtenido, se realizan * las operaciones necesarias en cada tabla. * * Primero se valida que la operacion exista, que sea a credito, que no haya sido cancelada, * que no haya sido saldada y que no se abone mas del total de la operacion. * * Despues se inicializa el registro de la tabla correspondiente, se modifica el saldo del deudor * y se activa la bandera from */ if (!is_null($id_compra)) { /************************************************************* * abono a compra ************************************************************* */ Logger::log("Abono pertenece a compra, compraid=" . $id_compra); $operacion = CompraDAO::getByPK($id_compra); if (is_null($operacion)) { Logger::error("La compra con id: " . $id_compra . " no existe"); throw new Exception("La compra con id: " . $id_compra . " no existe"); } if ($operacion->getTipoDeCompra() !== "credito") { Logger::error("La compra especificada no es a credito, no se puede abonar a una compra de contado"); throw new Exception("La compra especificada no es a credito, no se puede abonar a una compra de contado"); } if ($operacion->getCancelada()) { Logger::error("La compra ya ha sido cancelada, no se puede abonar a esta compra"); throw new Exception("La compra ya ha sido cancelada, no se puede abonar a esta compra"); } if ($operacion->getSaldo() > 0) { Logger::error("La compra ya ha sido saldada, no se puede abonar a esta compra"); throw new Exception("La compra ya ha sido saldada, no se puede abonar a esta compra"); } if ($operacion->getSaldo() - $monto < 0) { Logger::error("No se puede abonar esta cantidad a esta compra, pues sobrepasa el total de la misma"); throw new Exception("No se puede abonar esta cantidad a esta compra, pues sobrepasa el total de la misma"); } Logger::log("Insertando abono compra..."); $abono = new AbonoCompra(); $abono->setIdCompra($id_compra); $abono->setIdReceptor($id_deudor); $abono->setIdDeudor($id_usuario); $usuario->setSaldoDelEjercicio($usuario->getSaldoDelEjercicio() - $monto); $from = 1; } else { if (!is_null($id_prestamo)) { /************************************************************* * abono a prestamo ************************************************************* */ $operacion = PrestamoDAO::getByPK($id_prestamo); if (is_null($operacion)) { Logger::error("El prestamo con id: " . $id_prestamo . " no existe"); throw new Exception("El prestamo con id: " . $id_prestamo . " no existe"); } if ($operacion->getMonto() <= $operacion->getSaldo()) { Logger::error("El prestamo ya ha sido saldado, no se puede abonar a este prestamo"); throw new Exception("El prestamo ya ha sido saldad0, no se puede abonar a este prestamo"); } if ($operacion->getMonto() < $operacion->getSaldo() + $monto) { Logger::error("No se puede abonar esta cantidad a este prestamo, pues sobrepasa el total del mismo"); throw new Exception("No se puede abonar esta cantidad a este prestamo, pues sobrepasa el total del mismo"); } $abono = new AbonoPrestamo(); $abono->setIdPrestamo($id_prestamo); $abono->setIdReceptor($id_usuario); $abono->setIdDeudor($id_deudor); $usuario->setSaldoDelEjercicio($usuario->getSaldoDelEjercicio() + $monto); $from = 2; } else { if (!is_null($id_venta)) { /************************************************************* * abono a venta ************************************************************* */ $operacion = VentaDAO::getByPK($id_venta); if (is_null($operacion)) { Logger::error("La venta con id: " . $id_venta . " no existe"); throw new Exception("La venta con id: " . $id_venta . " no existe"); } if ($operacion->getTipoDeVenta() !== "credito") { Logger::error("La ventaa especificada no es a credito, no se puede abonar a una venta de contado"); throw new Exception("La venta especificada no es a credito, no se puede abonar a una venta de contado"); } if ($operacion->getCancelada()) { Logger::error("La venta ya ha sido cancelada, no se puede abonar a esta venta"); throw new Exception("La venta ya ha sido cancelada, no se puede abonar a esta venta"); } if ($operacion->getSaldo() <= 0) { Logger::error("La venta ya ha sido saldada, no se puede abonar a esta venta"); Logger::log("La venta {$id_venta} tiene un total de " . $operacion->getTotal() . " y un saldo pendiente de " . $operacion->getSaldo() . " por lo tanto ya ha sido saldada."); throw new Exception("La venta ya ha sido saldada, no se puede abonar a esta venta"); } if ($operacion->getSaldo() - $monto < 0) { Logger::error("No se puede abonar esta cantidad a esta venta, pues sobrepasa el total de la misma"); throw new Exception("No se puede abonar esta cantidad a esta venta, pues sobrepasa el total de la misma"); } Logger::log("Insertando AbonoVenta..."); $abono = new AbonoVenta(); $abono->setIdVenta($id_venta); $abono->setIdReceptor($id_usuario); $abono->setIdDeudor($id_deudor); //(OLD) $usuario->setSaldoDelEjercicio($usuario->getSaldoDelEjercicio() + $monto); //Figu: se establece el saldo del cliente restandole la venta y a su vez si tiene adelanto se le incrementa su saldo //$usuario->setSaldoDelEjercicio( ( $usuario->getSaldoDelEjercicio() - $operacion->getTotal() ) + $monto ); $usuario->setSaldoDelEjercicio($usuario->getSaldoDelEjercicio() + $monto); $from = 3; } else { Logger::error("No se recibio si el abono sera para una venta, una compra o un prestamo, no se hace nada"); throw new Exception("No se recibio si el abono sera para una venta, una compra o un prestamo, no se hace nada"); } } } //Una vez hecho los cambios particulaes, se realizan los cambios generales $operacion->setSaldo($operacion->getSaldo() - $monto); $abono->setCancelado($cancelado); $abono->setIdCaja($id_caja); $abono->setFecha($fecha); $abono->setIdSucursal($id_sucursal); $abono->setMonto($monto); $abono->setNota($nota); $abono->setTipoDePago($tipo_pago); $id_cheques = array(); $id_abono = null; DAO::transBegin(); try { //Si se reciben cheques y el tipo de pago es cheque, se genera el nuevo cheque y //se va almacenando su id en el arreglo id_cheques if ($tipo_pago === "cheque" && !is_null($cheques)) { foreach ($cheques as $cheque) { array_push($id_cheques, ChequesController::NuevoCheque($cheque["nombre_banco"], $cheque["monto"], $cheque["numero"], $cheque["expedido"])); } } //Dependiendo de que operacion se realizo se van guardando los cheques, los abonos y las operaciones //pues todas cambiaron. //Si se recibieron cheques, no se modifica la caja. //En el caso de las ventas, al final se busca la venta en la tabla venta_empresa y se pone como saldada //si ese ha sido el caso switch ($from) { case 1: AbonoCompraDAO::save($abono); CompraDAO::save($operacion); $id_abono = $abono->getIdAbonoCompra(); $cheque_abono_compra = new ChequeAbonoCompra(); $cheque_abono_compra->setIdAbonoCompra($id_abono); if (!is_null($id_caja) && empty($id_cheques)) { CajasController::modificarCaja($id_caja, 0, $billetes, $monto); } foreach ($id_cheques as $id_cheque) { $cheque_abono_compra->setIdCheque($id_cheque); ChequeAbonoCompraDAO::save($cheque_abono_compra); } break; case 2: AbonoPrestamoDAO::save($abono); PrestamoDAO::save($operacion); $id_abono = $abono->getIdAbonoPrestamo(); $cheque_abono_prestamo = new ChequeAbonoPrestamo(); $cheque_abono_prestamo->setIdAbonoPrestamo($id_abono); if (!is_null($id_caja) && empty($id_cheques)) { CajasController::modificarCaja($id_caja, 1, $billetes, $monto); } foreach ($id_cheques as $id_cheque) { $cheque_abono_prestamo->setIdCheque($id_cheque); ChequeAbonoPrestamoDAO::save($cheque_abono_prestamo); } break; case 3: AbonoVentaDAO::save($abono); VentaDAO::save($operacion); $id_abono = $abono->getIdAbonoVenta(); $cheque_abono_venta = new ChequeAbonoVenta(); $cheque_abono_venta->setIdAbonoVenta($id_abono); if (!is_null($id_caja) && empty($id_cheques)) { CajasController::modificarCaja($id_caja, 1, $billetes, $monto); } foreach ($id_cheques as $id_cheque) { $cheque_abono_venta->setIdCheque($id_cheque); ChequeAbonoVentaDAO::save($cheque_abono_venta); } if ($operacion->getSaldo() >= $operacion->getTotal()) { $ventas_empresa = VentaEmpresaDAO::search(new VentaEmpresa(array("id_venta" => $operacion->getIdVenta()))); foreach ($ventas_empresa as $venta_empresa) { $venta_empresa->setSaldada(1); VentaEmpresaDAO::save($venta_empresa); } } } /* Fin switch de from */ UsuarioDAO::save($usuario); } catch (Exception $e) { DAO::transRollback(); Logger::error("Error al crear el abono: " . $e); throw new Exception("Error al crear el abono"); } DAO::transEnd(); Logger::log("Abono creado exitosamente"); return array("id_abono" => $id_abono); }