/**
*
*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);
}
