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