public static function NuevaDireccionParaUsuario($id_usuario)
{
$u = UsuarioDAO::getByPK($id_usuario);
if (is_null($u)) {
throw invalidDataException("el {$id_usuario} no existe");
}
if (!is_null($u->getIdDireccion())) {
throw new InvalidDataException("el {$id_usuario} ya tiene una direccion");
}
$did = self::NuevaDireccion("", "", "", "", "");
DAO::transBegin();
$u->setIdDireccion($did);
try {
UsuarioDAO::save($u);
} catch (Exception $e) {
DAO::transRollback();
throw new Exception("No se pudo crear la direccion: " . $e);
}
DAO::transEnd();
}
/**
*
*Edita la informacion de una clasificacion de proveedor
*
* @param id_clasificacion_proveedor int Id de la clasificacion del proveedor a editar
* @param retenciones json Ids de las retenciones de la clasificacion de proveedor
* @param impuestos json Ids de los impuestos de la clasificacion del proveedor
* @param descripcion string Descripcion de la clasificacion del proveedor
* @param nombre string Nombre de la clasificacion del proveedor
**/
public static function EditarClasificacion($id_clasificacion_proveedor, $descripcion = null, $id_tarifa_compra = null, $id_tarifa_venta = null, $impuestos = null, $nombre = null, $retenciones = null)
{
Logger::log("Editando la clasificacion de proveedor " . $id_clasificacion_proveedor);
//valida los parametros recibidos
$validar = self::validarParametrosClasificacionProveedor($id_clasificacion_proveedor, $nombre, $descripcion, null, $id_tarifa_compra, $id_tarifa_venta);
if (is_string($validar)) {
Logger::error($validar);
throw new Exception($validar);
}
//Los parametros que no sean nulos seran tomados como actualizacion
$clasificacion_proveedor = ClasificacionProveedorDAO::getByPK($id_clasificacion_proveedor);
if (!is_null($descripcion)) {
$clasificacion_proveedor->setDescripcion($descripcion);
}
if (!is_null($nombre)) {
$clasificacion_proveedor->setNombre($nombre);
}
$cambio_tarifa_compra = false;
$cambio_tarifa_venta = false;
if (!is_null($id_tarifa_compra)) {
if ($id_tarifa_compra != $clasificacion_proveedor->getIdTarifaCompra()) {
$cambio_tarifa_compra = true;
$clasificacion_proveedor->setIdTarifaCompra($id_tarifa_compra);
}
}
if (!is_null($id_tarifa_venta)) {
if ($id_tarifa_venta != $clasificacion_proveedor->getIdTarifaVenta()) {
$cambio_tarifa_venta = true;
$clasificacion_proveedor->setIdTarifaVenta($id_tarifa_venta);
}
}
//Se actualiza el registro. Si se reciben listas de impuestos y/o registros se guardan los
//que estan en la lista, despues se recorren los registros de la base de datos y aquellos que no
//se encuentren en la lista nueva seran eliminados.
DAO::transBegin();
try {
ClasificacionProveedorDAO::save($clasificacion_proveedor);
//Si se cambia la tarifa de compra o de venta, se actualizan aquellos proveedores
//con etsa clasificacion de proveedor y cuya tarifa haya sido obtenida por el rol
//o por la clasificacion de proveedor.
if ($cambio_tarifa_compra || $cambio_tarifa_venta) {
$proveedores = UsuarioDAO::search(new Usuario(array("id_clasificacion_proveedor" => $id_clasificacion_proveedor)));
foreach ($proveedores as $proveedor) {
if ($cambio_tarifa_compra) {
if ($proveedor->getTarifaCompraObtenida() == "rol" || $proveedor->getTarifaCompraObtenida() == "proveedor") {
$proveedor->setIdTarifaCompra($id_tarifa_compra);
$proveedor->setTarifaCompraObtenida("proveedor");
}
}
if ($cambio_tarifa_venta) {
if ($proveedor->getTarifaVentaObtenida() == "rol" || $proveedor->getTarifaVentaObtenida() == "proveedor") {
$proveedor->setIdTarifaVenta($id_tarifa_venta);
$proveedor->setTarifaVentaObtenida("proveedor");
}
}
UsuarioDAO::save($proveedor);
}
}
if (!is_null($impuestos)) {
$impuestos = object_to_array($impuestos);
if (!is_array($impuestos)) {
throw new Exception("Los impuestos son invalidos");
}
$impuesto_clasificacion_proveedor = new ImpuestoClasificacionProveedor(array("id_clasificacion_proveedor" => $clasificacion_proveedor->getIdClasificacionProveedor()));
foreach ($impuestos as $impuesto) {
if (is_null(ImpuestoDAO::getByPK($impuesto))) {
throw new Exception("El impuesto " . $impuesto . " no existe", 901);
}
$impuesto_clasificacion_proveedor->setIdImpuesto($impuesto);
ImpuestoClasificacionProveedorDAO::save($impuesto_clasificacion_proveedor);
}
$impuestos_clasificacion_proveedor = ImpuestoClasificacionProveedorDAO::search(new ImpuestoClasificacionProveedor(array("id_clasificacion_proveedor" => $id_clasificacion_proveedor)));
foreach ($impuestos_clasificacion_proveedor as $impuesto_clasificacion_proveedor) {
$encontrado = false;
foreach ($impuestos as $impuesto) {
if ($impuesto == $impuesto_clasificacion_proveedor->getIdImpuesto()) {
$encontrado = true;
}
}
if (!$encontrado) {
ImpuestoClasificacionProveedorDAO::delete($impuesto_clasificacion_proveedor);
}
}
}
/* Fin if de impuestos */
if (!is_null($retenciones)) {
$retenciones = object_to_array($retenciones);
if (!is_array($retenciones)) {
throw new Exception("Las retenciones son invalidas", 901);
}
$retencion_clasificacion_proveedor = new RetencionClasificacionProveedor(array("id_clasificacion_proveedor" => $clasificacion_proveedor->getIdClasificacionProveedor()));
foreach ($retenciones as $retencion) {
if (is_null(RetencionDAO::getByPK($retencion))) {
throw new Exception("La retencion " . $retencion . " no existe", 901);
}
$retencion_clasificacion_proveedor->setIdRetencion($retencion);
RetencionClasificacionProveedorDAO::save($retencion_clasificacion_proveedor);
}
$retenciones_clasificacion_proveedor = RetencionClasificacionProveedorDAO::search(new RetencionClasificacionProveedor(array("id_clasificacion_proveedor" => $id_clasificacion_proveedor)));
foreach ($retenciones_clasificacion_proveedor as $retencion_clasificacion_proveedor) {
$encontrado = false;
foreach ($retenciones as $retencion) {
if ($retencion == $retencion_clasificacion_proveedor->getIdRetencion()) {
$encontrado = true;
}
}
if (!$encontrado) {
RetencionClasificacionProveedorDAO::delete($retencion_clasificacion_proveedor);
}
}
}
/* Fin if de retenciones */
} catch (Exception $e) {
DAO::transRollback();
Logger::error("La clasificacion de proveedor no ha podido ser editada: " . $e);
if ($e->getCode() == 901) {
throw new Exception("La clasificacion de proveedor no ha podido ser editada: " . $e->getCode(), 901);
}
throw new Exception("La clasificacion de proveedor no ha podido ser editada", 901);
}
DAO::transEnd();
Logger::log("La clasificacion de proveedor ha sido eeditada exitosamente ");
}
/**
*
*Crear un nuevo cliente. Para los campos de Fecha_alta y Fecha_ultima_modificacion se usar?a fecha actual del servidor. El campo Agente y Usuario_ultima_modificacion ser?tomados de la sesi?ctiva. Para el campo Sucursal se tomar?a sucursal activa donde se est?reando el cliente.
* Al crear un cliente se le creara un usuario para la interfaz de cliente y pueda ver sus facturas y eso, si tiene email. Al crearse se le enviara un correo electronico con el url.
*
* @param razon_social string Nombre o razon social del cliente.
* @param password string Password del cliente
* @param codigo_cliente string Codigo interno del cliente
* @param codigo_postal string Codigo postal del cliente
* @param direccion_web string Direccin web del cliente.
* @param rfc string RFC del cliente.
* @param clasificacion_cliente int Id de la clasificacin del cliente.
* @param calle string Calle del cliente
* @param curp string CURP del cliente.
* @param telefono2 string Segundo telfono del cliente.
* @param mensajeria bool Si el cliente cuenta con un cliente de mensajera y paquetera.
* @param numero_exterior string Nmero exterior del cliente
* @param cuenta_de_mensajeria string Este parmetro se vuelve obligatorio si el parmetro Mensajera es true. Especifica la cuenta de mensajera instantanea del cliente.
* @param denominacion_comercial string Nombre comercial del cliente.
* @param representante_legal string Nombre del representante legal del cliente.
* @param colonia string Colonia del cliente
* @param numero_interior string Nmero interior del cliente.
* @param moneda_del_cliente int Moneda que maneja el cliente.
* @param telefono1 string Telefono del cliente
* @param id_ciudad int id de la ciudad
* @param retenciones json Objeto que contendra los ids de las retenciones que afectan a este cliente
* @param impuestos json Objeto que contendra los impuestos que afectan a este cliente
* @param email string E-mail del cliente
* @param texto_extra string Comentario sobre la direccin del cliente.
* @return id_cliente int Id autogenerado del cliente que se insert�
**/
public static function Nuevo($razon_social, $clasificacion_cliente = null, $codigo_cliente = null, $cuenta_de_mensajeria = null, $curp = null, $denominacion_comercial = null, $descuento_general = "0", $direcciones = null, $email = null, $extra_params = null, $id_cliente_padre = null, $id_moneda = 1, $id_tarifa_compra = null, $id_tarifa_venta = null, $limite_credito = "0", $password = null, $representante_legal = null, $rfc = null, $sitio_web = null, $telefono_personal1 = null, $telefono_personal2 = null)
{
//Se toma la sucursal actual para asignarsela al cliente
$actual = SesionController::Actual();
if (is_null($clasificacion_cliente)) {
$clasificacion_cliente = 1;
}
if (!is_null($codigo_cliente)) {
$res = UsuarioDAO::search(new Usuario(array("codigo_usuario" => $codigo_cliente)));
if (sizeof($res) >= 1) {
throw new InvalidDataException("El codigo de cliente ya esta en uso");
}
}
//se crea la cliente utilizando el metodo Nuevo usuario, este se encarga de la validacion
//y se toma como rol de cliente el 5
if (strlen($rfc) == 0) {
$rfc = null;
}
if (strlen($curp) == 0) {
$curp = null;
}
if (strlen($email) == 0) {
$email = null;
}
if (is_null($direcciones)) {
$direcciones = array(new Direccion());
}
if (is_null($password)) {
$password = "******" . rand(1, 9) . rand(1, 9);
}
try {
$cliente = PersonalYAgentesController::NuevoUsuario(null, 5, $razon_social, $password, null, $email, null, $cuenta_de_mensajeria, $curp, $denominacion_comercial, $descuento_general, null, null, null, null, $direcciones, 0, $clasificacion_cliente, null, $id_moneda, $actual["id_sucursal"], $id_tarifa_compra, $id_tarifa_venta, $id_cliente_padre, null, null, $limite_credito, null, $sitio_web, $representante_legal, null, $rfc, null, null, null, $telefono_personal1, $telefono_personal2);
ExtraParamsValoresDAO::setVals("usuarios", $extra_params, $cliente["id_usuario"]);
$clienteObj = UsuarioDAO::getByPK($cliente["id_usuario"]);
$clienteObj->setCodigoUsuario($codigo_cliente);
UsuarioDAO::save($clienteObj);
//guardar el codigo cliente
} catch (Exception $e) {
Logger::error($e);
throw new InvalidDataException($e->getMessage());
}
ExtraParamsValoresDAO::actualizarRegistros("usuarios");
return array("id_cliente" => (int) $cliente["id_usuario"]);
}
/**
*
*Este metodo desactiva un usuario, usese cuando un empleado ya no trabaje para usted. Que pasa cuando el usuario tiene cuentas abiertas o ventas a credito con saldo.
*
* @param id_usuario int Id del usuario a eliminar
**/
public static function EliminarUsuario($id_usuario)
{
Logger::log("Eliminando usuario " . $id_usuario);
//Se obtiene y se verifica que el usuario exista en la base de datos.
$usuario = UsuarioDAO::getByPK($id_usuario);
if (is_null($usuario)) {
Logger::error("El usuario con id " . $id_usuario . " no existe");
throw new Exception("El usuario no existe", 901);
}
//Si el usuario ya esta inactivo, no se le hacen cambios.
if (!$usuario->getActivo()) {
Logger::warn("El usuario con id: " . $id_usuario . " ya esta inactivo");
throw new Exception("El usuario ya esta inactivo", 901);
}
//Si el saldo del ejercicio del usuario no es cero, siginifica que debe o que
//se le debe, entonces no se puede eliminar.
if ($usuario->getSaldoDelEjercicio() != 0) {
Logger::error("El usuario con id: " . $id_usuario . " no tiene un saldo en ceros");
throw new Exception("El usuario no tiene un saldo en ceros", 901);
}
//Si el usuario tiene una orden de servicio activa, no se puede eliminar
$ordenes_de_servicio = OrdenDeServicioDAO::search(new OrdenDeServicio(array("id_usuario_venta" => $id_usuario)));
foreach ($ordenes_de_servicio as $orden_de_servicio) {
if ($orden_de_servicio->getActiva()) {
Logger::error("El usuario " . $id_usuario . " no puede ser desactivado, tiene la orden " . $orden_de_servicio->getIdOrdenDeServicio() . " activa");
throw new Exception("El usuario no puede ser desactivado pues aun cuenta con ordenes de servicio activas", 901);
}
}
//Se cambia su estado activo a falso y se le asigna como hoy la fecha de baja.
$usuario->setActivo(0);
$usuario->setFechaBaja(time());
DAO::transBegin();
try {
//Si el usuario era consignatario se desactiva como tal.
if ($usuario->getConsignatario()) {
ConsignacionesController::DesactivarConsignatario($id_usuario);
}
//Se actualiza el usuario
UsuarioDAO::save($usuario);
//Se eliminan los registros de la tabla permiso_usuario que contengan a este usuario
$permisos_usuario = PermisoUsuarioDAO::search(new PermisoUsuario(array("id_usuario" => $id_usuario)));
foreach ($permisos_usuario as $permiso_usuario) {
PermisoUsuarioDAO::delete($permiso_usuario);
}
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se pudo eliminar el usuario: " . $e);
if ($e->getCode() == 901) {
throw new Exception("No se pudo eliminar el usuario: " . $e->getMessage());
}
throw new Exception("No se pudo eliminar el usuario, consulte a su administrador de sistema", 901);
}
DAO::transEnd();
Logger::log("Usuario eliminado exitosamente");
}
/**
*
*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");
}
/**
*
*Comprar productos en mostrador. No debe confundirse con comprar productos a un proveedor. Estos productos se agregaran al inventario de esta sucursal de manera automatica e instantanea. La IP ser?omada de la m?ina que realiza la compra. El usuario y la sucursal ser?tomados de la sesion activa. El estado del campo liquidada ser?omado de acuerdo al campo total y pagado.
*
* @param retencion float Cantidad sumada por retenciones
* @param detalle json Objeto que contendr la informacin de los productos comprados, sus cantidades, sus descuentos, y sus precios
* @param id_vendedor int Id del cliente al que se le compra
* @param total float Total de la compra despues de impuestos y descuentos
* @param tipo_compra string Si la compra es a credito o de contado
* @param subtotal float Total de la compra antes de incluirle impuestos.
* @param id_empresa int Empresa a nombre de la cual se realiza la compra
* @param descuento float Cantidad restada por descuento
* @param impuesto float Cantidad sumada por impuestos
* @param billetes_pago json Ids de billetes que se usaron para pagar
* @param billetes_cambio json Ids de billetes que se recibieron como cambio
* @param tipo_pago string Si el pago ser en efectivo, con tarjeta o con cheque
* @param saldo float Saldo 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
* @return id_compra_cliente string Id de la nueva compra
**/
public static function ComprarCaja($descuento, $detalle, $id_empresa, $id_vendedor, $impuesto, $retencion, $subtotal, $tipo_compra, $total, $billetes_cambio = null, $billetes_pago = null, $cheques = null, $id_caja = null, $id_compra_caja = null, $id_sucursal = null, $saldo = 0, $tipo_pago = null)
{
Logger::log("Realizando la compra");
//Se obtiene el id del 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 actual, ya inicio sesion?");
throw new Exception("No se pudo obtener al usuario de la sesion actual, ya inicio sesion?");
}
//Se validan los parametros recibidos
$validar = self::validarParametrosCompra(null, $id_compra_caja, $id_vendedor, $tipo_compra, $subtotal, $impuesto, $descuento, $total, $id_empresa, $saldo, null, $tipo_pago, $retencion);
if (is_string($validar)) {
Logger::error($validar);
throw new Exception($validar);
}
//Se inicializa el usuario con los parametros recibidos.
$usuario = UsuarioDAO::getByPK($id_vendedor);
$compra = new Compra();
$compra->setRetencion($retencion);
$compra->setIdVendedorCompra($id_vendedor);
$compra->setSubtotal($subtotal);
$compra->setImpuesto($impuesto);
$compra->setTotal($total);
$compra->setDescuento($descuento);
$compra->setTipoDeCompra($tipo_compra);
$compra->setIdCaja(self::getCaja());
$compra->setIdSucursal(self::getSucursal());
$compra->setIdUsuario($id_usuario);
$compra->setIdCompraCaja($id_compra_caja);
$compra->setCancelada(0);
$compra->setTipoDePago($tipo_pago);
$compra->setFecha(time());
$compra->setIdEmpresa($id_empresa);
DAO::transBegin();
try {
//Si la compra es a contado, se realizan operaciones dependiendo del tipo de pago
if ($tipo_compra === "contado") {
//Si se recibe un saldo, se loguea una advertencia indicando que se ignorará
if (!is_null($saldo)) {
Logger::warn("Se recibio un saldo cuando la venta es de contado, el saldo se tomara del total");
}
$compra->setSaldo($total);
CompraDAO::save($compra);
//Si el tipo de pago es cheque, se crean los nuevos cheques con la informacion obtenida
//y se almacenan registros por cada cheque para esta compra en la tabla cheque_compra
if ($tipo_pago === "cheque") {
//Si no se recibe informacion de los cheques se lanza una excepcion
if (is_null($cheques)) {
throw new Exception("El tipo de pago es con cheque pero no se recibio informacion del mismo");
}
$cheques = object_to_array($cheques);
if (!is_array($cheques)) {
throw new Exception("Los cheques son invalidos", 901);
}
$cheque_compra = new ChequeCompra();
$cheque_compra->setIdCompra($compra->getIdCompra());
foreach ($cheques as $cheque) {
$id_cheque = ChequesController::NuevoCheque($cheque["nombre_banco"], $cheque["monto"], $cheque["numero"], 1);
$cheque_compra->setIdCheque($id_cheque);
ChequeCompraDAO::save($cheque_compra);
}
} else {
if ($tipo_pago === "efectivo") {
CajasController::modificarCaja($compra->getIdCaja(), 0, $billetes_pago, $total);
if (!is_null($billetes_cambio)) {
CajasController::modificarCaja($compra->getIdCaja(), 1, $billetes_cambio, 0);
}
}
}
} else {
if ($tipo_compra == "credito") {
if (is_null($saldo)) {
Logger::warn("No se recibio un saldo, se tomara 0 como saldo");
$saldo = 0;
}
//El saldo no puede ser mayor que la cantidad a comprar
if ($saldo > $total) {
throw new Exception("El saldo no puede ser mayor que el total de la compra");
}
$compra->setSaldo($saldo);
CompraDAO::save($compra);
$usuario->setSaldoDelEjercicio($usuario->getSaldoDelEjercicio() + $total - $saldo);
UsuarioDAO::save($usuario);
}
}
//Si se recibio detalle de productos, se agregan al almacen correspondiente a la empresa
//dentro de esta sucursal. Tambien se guarda el detalle en la tabla compra_producto
if (!is_null($detalle)) {
$detalle = object_to_array($detalle);
if (!is_array($detalle)) {
throw new Exception("El detalle del producto es invalido", 901);
}
//Se inicializan variables para el almacenamiento de los registros.
$d_producto = new CompraProducto();
$d_producto->setIdCompra($compra->getIdCompra());
//se buscan los almacenes de esta empresa para esta sucursal y se ignoran los de consginacion
$almacenes = AlmacenDAO::search(new Almacen(array("id_sucursal" => self::getSucursal(), "id_empresa" => $id_empresa)));
$id_almacen = null;
foreach ($almacenes as $a) {
if ($a->getIdTipoAlmacen() == 2) {
continue;
}
$id_almacen = $a->getIdAlmacen();
}
//Si no se encontro un almacen, se arroja una excepcion
if (is_null($id_almacen)) {
throw new Exception("No existe un almacen para esta empresa en esta sucursal");
}
//Por cada producto en el detalle se almacena en la tabla compra_producto y se agregan al
//almacen de la empresa
foreach ($detalle as $d_p) {
if (!array_key_exists("id_producto", $d_p) || !array_key_exists("cantidad", $d_p) || !array_key_exists("precio", $d_p) || !array_key_exists("descuento", $d_p) || !array_key_exists("impuesto", $d_p) || !array_key_exists("retencion", $d_p) || !array_key_exists("id_unidad", $d_p)) {
throw new Exception("El detalle de paquete recibido es invalido", 901);
}
$validar = self::validarParametrosCompraProducto(null, $d_p["id_producto"], $d_p["precio"], $d_p["cantidad"], $d_p["descuento"], $d_p["impuesto"], $d_p["retencion"], $d_p["id_unidad"]);
if (is_string($validar)) {
throw $validar;
}
$producto = ProductoDAO::getByPK($d_p["id_producto"]);
//Si el producto no puede ser comprado en mostrador arroja una excepcion
if (!$producto->getCompraEnMostrador()) {
throw new Exception("No se puede comprar el producto con id " . $d_p["id_producto"] . " en mostrador");
}
//Si el producto no pertenece a la empresa que quiere hacer la compra, arroja una excepcion
if (is_null(ProductoEmpresaDAO::getByPK($d_p["id_producto"], $id_empresa))) {
throw new Exception("El producto no pertenece a la empresa seleccionada");
}
//Se incializa ys e guarda el nuevo registro de la tabla compra_producto
$d_producto->setCantidad($d_p["cantidad"]);
$d_producto->setDescuento($d_p["descuento"]);
$d_producto->setIdProducto($d_p["id_producto"]);
$d_producto->setIdUnidad($d_p["id_unidad"]);
$d_producto->setImpuesto($d_p["impuesto"]);
$d_producto->setPrecio($d_p["precio"]);
$d_producto->setRetencion($d_p["retencion"]);
CompraProductoDAO::save($d_producto);
//Se busca el producto en el almacen en la unidad obtenida, si no existe aun
//se crea uno nuevo y al final se guarda.
$producto_almacen = ProductoAlmacenDAO::getByPK($d_p["id_producto"], $id_almacen, $d_p["id_unidad"]);
if (is_null($producto_almacen)) {
$producto_almacen = new ProductoAlmacen(array("id_producto" => $d_p["id_producto"], "id_almacen" => $id_almacen, "id_unidad" => $d_p["id_unidad"]));
}
$producto_almacen->setCantidad($producto_almacen->getCantidad() + $d_p["cantidad"]);
ProductoAlmacenDAO::save($producto_almacen);
}
} else {
throw new Exception("No se recibieron productos para esta compra");
}
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se pudo realizar la compra: " . $e);
throw new Exception("No se pudo realizar la compra");
}
DAO::transEnd();
Logger::log("compra realizada exitosamente");
return array("id_compra_cliente" => $compra->getIdCompra());
}
/**
*
*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");
}
/**
*
*Desactiva la bandera de consignatario a un cliente y elimina su almacen correspondiente. Para poder hacer esto, el almacen debera estar vacio.
*
* @param id_cliente int Id del cliente a desactivar como consignatario
**/
public static function DesactivarConsignatario($id_cliente)
{
Logger::log("Desactivando consignatario " . $id_cliente);
//valida que el cliente exista, que este activo y que sea un cliente
$e = self::validarConsignatario($id_cliente);
if (is_string($e)) {
Logger::error($e);
throw new Exception($e);
}
$cliente = UsuarioDAO::getByPK($id_ciente);
$consignaciones = ConsignacionDAO::search(new Consignacion(array("id_cliente" => $id_cliente)));
foreach ($consignaciones as $consignacion) {
if ($consignacion->getActiva()) {
Logger::error("El consignatario no puede ser desactivado pues aun tiene consignaciones activas: id_consignacion= " . $consignacion->getIdConsignacion());
throw new Exception("El consignatario no puede ser desactivado pues aun tiene consignaciones activas");
}
}
$cliente->setConsignatario(0);
$almacenes = AlmacenDAO::search(new Almacen(array("nombre" => $cliente->getCodigoUsuario(), "activo" => 1)));
DAO::transBegin();
try {
UsuarioDAO::save($cliente);
foreach ($almacenes as $almacen) {
$productos_almacen = ProductoAlmacenDAO::search(new ProductoAlmacen(array("id_almacen" => $almacen->getIdAlmacen())));
foreach ($productos_almacen as $producto_almacen) {
if ($producto_almacen->getCantidad() != 0) {
throw new Exception("El almacen no puede ser borrado pues aun contiene productos");
}
}
$almacen->setActivo(0);
AlmacenDAO::save($almacen);
}
} catch (Exception $e) {
DAO::transRollback();
Logger::error("No se ha podido desactivar al consignatario: " . $e);
throw new Exception("No se ha podido desactivar al consignatario");
}
DAO::transEnd();
Logger::log("Consignatario desactivado exitosamente");
}
$this_personal = UsuarioDAO::getByPK($_GET["uid"]);
if (is_null($this_personal->getIdDireccion())) {
//no existe direccion
Logger::log("El uid=" . $_GET["uid"] . " no tiene direccion. Insertando.");
DireccionController::NuevaDireccionParaUsuario($_GET["uid"]);
//recargar el objeto de cliente
$this_personal = UsuarioDAO::getByPK($_GET["uid"]);
}
$esta_dir = DireccionDAO::getByPK($this_personal->getIdDireccion());
if (is_null($esta_dir)) {
//esta definida pero el registro no existe por alguna razon
Logger::error("user " . $_GET["uid"] . " se supone que tiene id direccion = " . $this_personal->getIdDireccion() . " , pero esta en null ...");
DAO::transBegin();
$this_personal->setIdDireccion(NULL);
try {
UsuarioDAO::save($this_personal);
DireccionController::NuevaDireccionParaUsuario($this_personal->getIdUsuario());
//recargar el objeto de cliente
$this_personal = UsuarioDAO::getByPK($_GET["uid"]);
} catch (Exception $e) {
DAO::transRollback();
throw new Exception("No se pudo crear la direccion: " . $e);
}
DAO::transEnd();
}
$esta_dir = DireccionDAO::getByPK($this_personal->getIdDireccion());
//titulos
$page->addComponent(new TitleComponent("Editar direccion: " . $esta_dir->getColonia()));
//forma de nuevo usuario
$form = new DAOFormComponent($esta_dir);
$form->hideField(array("id_direccion", "id_usuario_ultima_modificacion", "ultima_modificacion"));
$page->nextTab("Direccion");
if (is_null($este_cliente->getIdDireccion())) {
//no existe direccion
Logger::log("El uid=" . $_GET["cid"] . " no tiene direccion. Insertando.");
DireccionController::NuevaDireccionParaUsuario($_GET["cid"]);
//recargar el objeto de cliente
$este_cliente = UsuarioDAO::getByPK($_GET["cid"]);
}
$esta_dir = DireccionDAO::getByPK($este_cliente->getIdDireccion());
if (is_null($esta_dir)) {
//esta definida pero el registro no existe por alguna razon
Logger::error("user " . $_GET["cid"] . " se supone que tiene id direccion = " . $este_cliente->getIdDireccion() . " , pero esta en null ...");
DAO::transBegin();
$este_cliente->setIdDireccion(NULL);
try {
UsuarioDAO::save($este_cliente);
DireccionController::NuevaDireccionParaUsuario($este_cliente->getIdUsuario());
//recargar el objeto de cliente
$este_cliente = UsuarioDAO::getByPK($_GET["cid"]);
} catch (Exception $e) {
DAO::transRollback();
throw new Exception("No se pudo crear la direccion: " . $e);
}
DAO::transEnd();
}
$esta_dir = DireccionDAO::getByPK($este_cliente->getIdDireccion());
//titulos
//forma de nuevo cliente
$form = new DAOFormComponent($esta_dir);
$form->hideField(array("id_direccion", "id_usuario_ultima_modificacion", "ultima_modificacion"));
$form->sendHidden("id_direccion");
$this_client = UsuarioDAO::getByPK($_GET["cid"]);
if (is_null($this_client->getIdDireccion())) {
//no existe direccion
Logger::log("El uid=" . $_GET["cid"] . " no tiene direccion. Insertando.");
DireccionController::NuevaDireccionParaUsuario($_GET["cid"]);
//recargar el objeto de cliente
$this_client = UsuarioDAO::getByPK($_GET["cid"]);
}
$esta_dir = DireccionDAO::getByPK($this_client->getIdDireccion());
if (is_null($esta_dir)) {
//esta definida pero el registro no existe por alguna razon
Logger::error("user " . $_GET["cid"] . " se supone que tiene id direccion = " . $this_client->getIdDireccion() . " , pero esta en null ...");
DAO::transBegin();
$this_client->setIdDireccion(NULL);
try {
UsuarioDAO::save($this_client);
DireccionController::NuevaDireccionParaUsuario($this_client->getIdUsuario());
//recargar el objeto de cliente
$this_client = UsuarioDAO::getByPK($_GET["cid"]);
} catch (Exception $e) {
DAO::transRollback();
throw new Exception("No se pudo crear la direccion: " . $e);
}
DAO::transEnd();
}
$esta_dir = DireccionDAO::getByPK($this_client->getIdDireccion());
//titulos
$page->addComponent(new TitleComponent("Editar direccion: " . $esta_dir->getColonia()));
//forma de nuevo cliente
$form = new DAOFormComponent($esta_dir);
$form->hideField(array("id_direccion", "id_usuario_ultima_modificacion", "ultima_modificacion"));
/**
*
*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);
}
