PHP UsuarioDAO::save方法代码示例

 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);
             }
//.........这里部分代码省略.........

 /**
  *
  *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 = "pass" . 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,
//.........这里部分代码省略.........

 /**
  *
  *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);
//.........这里部分代码省略.........

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

//.........这里部分代码省略.........
                 $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);
 }