PHP UsuarioDAO::getByPK方法代码示例

function nombre_deudor($id_usuario, $obj)
{
    if (!UsuarioDAO::getByPK($id_usuario)) {
        return "";
    }
    return "<font title = \"Ir a detalles del usuario\" style = \"cursor:pointer;\" onClick = \"(function(){ window.location = 'clientes.ver.php?cid={$id_usuario}'; })();\" >" . UsuarioDAO::getByPK($id_usuario)->getNombre() . "</font>";
}

function nombre_receptor($id_receptor, $obj)
{
    if ($obj["cancelado"] == 1) {
        return "<font title = \"Abono cancelado debido a {$obj['motivo_cancelacion']}\" style = \"color:red; cursor: help;\" >" . UsuarioDAO::getByPK($id_receptor)->getNombre() . "</font>";
    }
    return UsuarioDAO::getByPK($id_receptor)->getNombre();
}

 public function testNuevaOrden()
 {
     $s = ServiciosController::Nuevo($codigo_servicio = "testNuevoServicio-2db94458_2" . time(), $compra_en_mostrador = false, $costo_estandar = 0, $metodo_costeo = "precio", $nombre_servicio = "testNuevoServicio-2db94458_2" . time(), $activo = true, $clasificaciones = null, $control_de_existencia = null, $descripcion_servicio = null, $empresas = null, $extra_params = null, $foto_servicio = null, $garantia = null, $impuestos = null, $precio = 1542.15, $retenciones = null, $sucursales = null);
     $c = ClientesController::Nuevo($razon_social = "testNuevaOrden-2db9445f" . time(), $clasificacion_cliente = null, $codigo_cliente = "t" . time(), $cuenta_de_mensajeria = null, $curp = null, $denominacion_comercial = null, $descuento_general = 0, $direcciones = null, $email = null, $id_cliente_padre = null, $id_moneda = 1, $id_tarifa_compra = null, $id_tarifa_venta = null, $limite_credito = 1542.15, $password = null, $representante_legal = null, $rfc = null, $sitio_web = null, $telefono_personal1 = null, $telefono_personal2 = null);
     Logger::testerLog("Nueva orde de servicio (" . $c["id_cliente"] . ", " . $s["id_servicio"] . " )");
     $o = ServiciosController::NuevaOrden($c["id_cliente"], $s["id_servicio"]);
     $this->assertInternalType("int", $o["id_orden"]);
     $this->assertInternalType("int", $o["id_venta"]);
     define("_pos_phpunit_servicios_id_cliente", $c["id_cliente"]);
     define("_pos_phpunit_servicios_id_servicio", $s["id_servicio"]);
     //ok ya que se hizo el servicio, ver que se halla creado
     //una venta a credito a este cliente
     $lista_de_ventas = VentasController::Lista();
     $found = false;
     for ($i = 0; $i < $lista_de_ventas["numero_de_resultados"]; $i++) {
         if ($lista_de_ventas["resultados"][$i]["cliente"]["id_cliente"] == $c["id_cliente"]) {
             $found = true;
         }
     }
     $this->assertTrue($found);
     //vamos a buscar que ese cliente ya no tenga limite de credito
     $u = UsuarioDAO::getByPK($c["id_cliente"]);
     $this->assertEquals(0, $u->getLimiteCredito());
     //hacerle un abono
     CargosYAbonosController::NuevoAbono($c["id_cliente"], 1, "efectivo", null, null, null, null, $o["id_venta"]);
 }

 static function UserFullNameFromId($user_id)
 {
     if (is_null($u = UsuarioDAO::getByPK($user_id))) {
         return self::NonExistent();
     } else {
         return $u->getNombre();
     }
 }

 private static function validarParametrosCheque($id_cheque = null, $nombre_banco = null, $monto = null, $numero = null, $expedido = null, $id_usuario = null)
 {
     //valida que el cheque exista en l abase de datos
     if (!is_null($id_cheque)) {
         if (is_null(ChequeDAO::getByPK($id_cheque))) {
             return "El cheque con id " . $id_cheque . " no existe";
         }
     }
     //valida que el nombre del banco no tenga mas de 100 caracteres
     if (!is_null($nombre_banco)) {
         $e = self::validarString($nombre_banco, 100, "nombre de banco");
         if (is_string($e)) {
             return $e;
         }
     }
     //valida que el monto este en rango
     if (!is_null($monto)) {
         $e = self::validarNumero($monto, 1.8E+200, "monto");
         if (is_string($e)) {
             return $e;
         }
     }
     //valida que el numero tenag 4 y solo 4 caracteres numericos
     if (!is_null($numero)) {
         $e = self::validarString($numero, 4, "numero del cheque", 3);
         if (is_string($e)) {
             return $e;
         }
         if (preg_match('/[^0-9]/', $numero)) {
             return "el numero de cheque (" . $numero . ") tiene caracteres invalidos, solo se permiten de 0-9";
         }
     }
     //valida el boleano expedido
     if (!is_null($expedido)) {
         $e = self::validarNumero($expedido, 1, "expedido");
         if (is_string($e)) {
             return $e;
         }
     }
     //valida que el usuario exista en la base de datos y que no este inactivo
     if (!is_null($id_usuario)) {
         $usuario = UsuarioDAO::getByPK($id_usuario);
         if (is_null($usuario)) {
             return "El usuario con id: " . $id_usuario . " no existe";
         }
         if (!$usuario->getActivo()) {
             return "El usuario esta inactivo y no puede expedir cheques";
         }
     }
 }

    protected function _renderTopMenu()
    {
        $s = SesionController::Actual();
        $u = UsuarioDAO::getByPK($s["id_usuario"]);
        ?>


			<a class="l" href="./helper.php">Ayuda</a>
			<a class="l">(<?php 
        echo $u->getNombre();
        ?>
)</a>
			<a class="l" href="./../?cs=1"> Salir</a>
		<?php 
    }

 /**
  *
  *
  *
  **/
 private static function GetUsuarioArray($id_usuario)
 {
     $result = UsuarioDAO::getByPK($id_usuario)->asArray();
     if (!is_null($result["id_direccion"])) {
         $result["direccion"] = DireccionDAO::getByPK($result["id_direccion"])->asArray();
         unset($result["direccion"]["id_direccion"]);
         if (!is_null($result["direccion"]["id_ciudad"])) {
             $result["direccion"]["ciudad"] = CiudadDAO::getByPK($result["direccion"]["id_ciudad"])->asArray();
             unset($result["direccion"]["ciudad"]["id_ciudad"]);
         }
         unset($result["direccion"]["id_ciudad"]);
     }
     if (!is_null($result["id_direccion_alterna"])) {
         $result["direccion_alterna"] = DireccionDAO::getByPK($result["id_direccion_alterna"])->asArray();
     }
     if (!is_null($result["id_rol"])) {
         if (!is_null($r = RolDAO::getByPK($result["id_rol"]))) {
             $result["rol"] = $r->asArray();
         }
         unset($result["id_rol"]);
     }
     unset($result["password"]);
     unset($result["id_direccion_alterna"]);
     unset($result["id_direccion"]);
     unset($result["id_usuario"]);
     unset($result["fecha_asignacion_rol"]);
     unset($result["token_recuperacion_pass"]);
     unset($result["id_clasificacion_proveedor"]);
     unset($result["id_clasificacion_cliente"]);
     unset($result["comision_ventas"]);
     unset($result["last_login"]);
     unset($result["consignatario"]);
     unset($result["salario"]);
     unset($result["saldo_del_ejercicio"]);
     unset($result["ventas_a_credito"]);
     unset($result["dia_de_pago"]);
     unset($result["mensajeria"]);
     unset($result["dias_de_embarque"]);
     unset($result["id_tarifa_compra"]);
     unset($result["tarifa_compra_obtenida"]);
     unset($result["id_tarifa_venta"]);
     unset($result["tarifa_venta_obtenida"]);
     unset($result["facturar_a_terceros"]);
     return $result;
 }

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

 private static function Cotizar($descuento, $id_comprador_venta, $impuesto, $subtotal, $tipo_venta, $total, $datos_cheque = null, $detalle_orden = null, $detalle_paquete = null, $detalle_venta = null, $id_sucursal = null, $saldo = "0", $tipo_de_pago = null)
 {
     Logger::log("Cotizando ....");
     //Se obtiene el id del usuario actualmente logueado
     $aS = SesionController::Actual();
     $id_usuario = $aS["id_usuario"];
     //Se busca al usuario comprador
     $usuario = UsuarioDAO::getByPK($id_comprador_venta);
     if (!is_null($id_sucursal)) {
         $sucursal = SucursalDAO::getByPK($id_sucursal);
         if (is_null($sucursal)) {
             Logger::error("La sucursal " . $id_sucursal . " no existe");
             throw new InvalidDataException("La sucursal no existe", 901);
         }
         if (!$sucursal->getActiva()) {
             Logger::error("La sucursal " . $id_sucursal . " esta desactivada");
             throw new InvalidDataException("La sucursal esta desactivada", 901);
         }
     }
     //Se inicializa la venta con los parametros obtenidos
     $venta = new Venta();
     $venta->setRetencion(0);
     $venta->setEsCotizacion(true);
     $venta->setIdCompradorVenta($id_comprador_venta);
     $venta->setSubtotal($subtotal);
     $venta->setImpuesto($impuesto);
     $venta->setTotal($total);
     $venta->setDescuento($descuento);
     $venta->setTipoDeVenta($tipo_venta);
     $venta->setIdCaja(null);
     $venta->setIdSucursal($id_sucursal);
     $venta->setIdUsuario($id_usuario);
     $venta->setIdVentaCaja(NULL);
     $venta->setCancelada(0);
     $venta->setTipoDePago(null);
     $venta->setSaldo(0);
     $venta->setFecha(time());
     DAO::transBegin();
     try {
         VentaDAO::save($venta);
     } catch (Exception $e) {
         DAO::transRollback();
         Logger::error("No se pudo realizar la venta: " . $e);
         throw new Exception("No se pudo realizar la venta", 901);
     }
     //Si el detalle de las ordenes compradas, el detalle de los paquetes y el detalle de los productos
     //son nulos, manda error.
     if (is_null($detalle_orden) && is_null($detalle_paquete) && is_null($detalle_venta)) {
         throw new InvalidDataException("No se recibieron ni paquetes ni productos ni servicios para esta venta", 901);
     }
     //Por cada detalle, se valida la informacion recibida, se guarda en un registro
     //que contiene el id de la venta generada y se guarda el detalle en su respectiva tabla.
     if (!is_null($detalle_venta)) {
         $detalle_producto = object_to_array($detalle_venta);
         if (!is_array($detalle_producto)) {
             throw new Exception("El detalle del producto es invalido", 901);
         }
         foreach ($detalle_producto as $d_p) {
             $d_producto = new VentaProducto();
             $d_producto->setIdVenta($venta->getIdVenta());
             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 del producto es invalido", 901);
             }
             Logger::log("Insertando venta_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"]);
             Logger::log($d_producto);
             try {
                 VentaProductoDAO::save($d_producto);
             } catch (Exception $e) {
                 DAO::transRollback();
                 Logger::error("No se pudo realizar la venta: " . $e);
                 throw new Exception("No se pudo realizar la venta", 901);
             }
         }
     }
     /* Fin de if para detalle_producto */
     DAO::transEnd();
     Logger::log("====== Cotizacion realizada exitosamente ======== ");
     return array("id_venta" => $venta->getIdVenta());
 }

 /**
  *
  *Hace un corte en los flujos de dinero de la sucursal. El Id de la sucursal se tomara de la sesion actual. La fehca se tomara del servidor.
  *
  * @param saldo_real float Saldo que hay actualmente en la caja
  * @param billetes json Ids de billetes y sus cantidades encontrados en la caja al hacer el cierre
  * @param id_cajero int Id del cajero en caso de que no sea este el que realiza el cierre
  * @return id_cierre int Id del cierre autogenerado.
  **/
 public static function CerrarCaja($id_caja, $saldo_real, $billetes = null, $id_cajero = null)
 {
     Logger::log("Cerrando caja " . $id_caja);
     //Se valida la caja obtenida, que exista, que este activa y que este abierta
     $caja = CajaDAO::getByPK($id_caja);
     if (is_null($caja)) {
         Logger::error("La caja con id:" . $id_caja . " no existe");
         throw new Exception("La caja con id:" . $id_caja . " no existe");
     }
     if (!$caja->getActiva()) {
         Logger::error("La caja proporcionada no esta activa, no se puede cerrar");
         throw new Exception("La caja proporcionada no esta activa, no se puede cerrar");
     }
     if (!$caja->getAbierta()) {
         Logger::warn("La caja proporcionada ya esta cerrada");
         throw new Exception("La caja proporcionada ya esta cerrada");
     }
     //Se valida que el cajero exista y tenga rol de cajero
     if (!is_null($id_cajero)) {
         $cajero = UsuarioDAO::getByPK($id_cajero);
         if (is_null($cajero)) {
             Logger::error("El cajero con id: " . $id_cajero . " no existe");
             throw new Exception("El cajero no existe");
         }
         if ($cajero->getIdRol() != 3) {
             Logger::error("El usuario " . $id_cajero . " no tiene rol de cajero");
             throw new Exception("El usuario no tiene rol de cajero");
         }
     }
     //Se valida el parametro saldo real.
     $validar = self::validarNumero($saldo_real, 1.8E+200, "saldo real");
     if (is_string($validar)) {
         Logger::error($validar);
         throw new Exception($validar);
     }
     //Se crea el registro de la tabla cierre_caja
     $cierre_caja = new CierreCaja(array("id_caja" => $id_caja, "id_cajero" => $id_cajero, "fecha" => time(), "saldo_real" => $saldo_real, "saldo_esperado" => $caja->getSaldo()));
     //Se realizan los movimientos de la caja antes de cerrarla, pues al cerrar la caja
     //ya no se pueden realizar movimientos sobre la misma.
     try {
         CajasController::modificarCaja($id_caja, 0, $billetes, $caja->getSaldo());
     } catch (Exception $e) {
         throw new Exception("No se pudo modificar la caja");
     }
     DAO::transBegin();
     try {
         //Se guardan los cambios en caja y cierre_caja
         $caja->setAbierta(0);
         CierreCajaDAO::save($cierre_caja);
         CajaDAO::save($caja);
         //Si la caja lleva control de los billetes, se crea un registro de la tabla billete_cierre_caja
         //y se registran cuantos billetes fueron encontrados, cuantos sobraron y cuantos faltaron.
         if ($caja->getControlBilletes()) {
             $billetes = object_to_array($billetes);
             //Se regitran los billetes recibidos como cantidad encontrada.
             $billete_cierre_caja = new BilleteCierreCaja(array("id_cierre_caja" => $cierre_caja->getIdCierreCaja()));
             $billete_cierre_caja->setCantidadFaltante(0);
             $billete_cierre_caja->setCantidadSobrante(0);
             foreach ($billetes as $b) {
                 $billete_cierre_caja->setIdBillete($b["id_billete"]);
                 $billete_cierre_caja->setCantidadEncontrada($b["cantidad"]);
                 BilleteCierreCajaDAO::save($billete_cierre_caja);
             }
             //Se buscan los billetes de la caja y se buscan en la tabla billete_cierre_caja
             //Si no se encuentra, se crea un registro nuevo
             //Si despues de haber modificado la caja, quedan billetes en ella, significa que
             //esos billetes estan faltando.
             //En cambio, si esos billetes tienen cantidad negativa, significa que estan sobrando
             $billetes_caja = BilleteCajaDAO::search(new BilleteCaja(array("id_caja" => $id_caja)));
             foreach ($billetes_caja as $b_c) {
                 $billete_cierre_caja = BilleteCierreCajaDAO::getByPK($b_c->getIdBillete(), $cierre_caja->getIdCierreCaja());
                 if (is_null($billete_cierre_caja)) {
                     $billete_cierre_caja = new BilleteCierreCaja(array("id_billete" => $b_c->getIdBillete(), "id_cierre_caja" => $cierre_caja->getIdCierreCaja(), "cantidad_encontrada" => 0, "cantidad_sobrante" => 0, "cantidad_faltante" => 0));
                 }
                 if ($b_c->getCantidad() < 0) {
                     $billete_cierre_caja->setCantidadSobrante($b_c->getCantidad());
                 } else {
                     if ($b_c->getCantidad() > 0) {
                         $billete_cierre_caja->setCantidadFaltante($b_c->getCantidad() * -1);
                     } else {
                         continue;
                     }
                 }
                 //Al final pone su cantidad en cero, pues al cerrar una caja esta debe quedar vacía.
                 $b_c->setCantidad(0);
                 BilleteCierreCajaDAO::save($billete_cierre_caja);
                 BilleteCajaDAO::save($b_c);
             }
             /* Fin foreach bil;etes_caja */
         }
         /* Fin if contrik billetes */
//.........这里部分代码省略.........

 /**
  *
  *Registra una nueva compra fuera de caja, puede usarse para que el administrador haga directamente una compra. El usuario y al sucursal seran tomados de la sesion. La fecha sera tomada del servidor. La empresa sera tomada del almacen del cual fueron tomados los productos.
  *
  * @param descuento float Monto descontado por descuentos
  * @param subtotal float Total de la compra antes de impuestos y descuentos.
  * @param detalle json Objeto que contendr el arreglo de id productos, cantidad,  precio, descuento, id de unidad y procesado que involucran esta compra.
  * @param impuesto float Monto agregado por impuestos
  * @param tipo_compra string Si la compra es a credito o de contado
  * @param retencion float Monto agregado por retenciones
  * @param id_usuario_compra int Id usuario al que se le compra, si es a una sucursal, se pone el id en negativo
  * @param id_empresa int Id de la empresa a nombre de la cual se hace la compra
  * @param total float Total 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
  * @param saldo float Cantidad pagada de la 
  * @param tipo_de_pago string Si el pago sera en efectivo, con cheque o tarjeta
  * @return id_compra int Id autogenerado por la inserci�n de la compra
  **/
 public static function Nueva($descuento, $detalle, $id_empresa, $id_usuario_compra, $impuesto, $retencion, $subtotal, $tipo_compra, $total, $cheques = null, $id_sucursal = null, $saldo = 0, $tipo_de_pago = null)
 {
     Logger::log(" ===== Creando nueva compra... ===== ");
     //validemos al comprador
     $proveedor = UsuarioDAO::getByPK($id_usuario_compra);
     if (is_null($proveedor)) {
         Logger::error("el provedor {$id_usuario_compra} no exite");
         throw new InvalidDataException("El proveedor no existe");
     }
     if ($proveedor->getActivo() == false) {
         throw new BusinessLogicException("No se puede comprar de un proveedor no activo.");
     }
     //validemos la empresa
     $empresa = EmpresaDAO::getByPK($id_empresa);
     if (is_null($empresa)) {
         Logger::error("La empresa {$id_empresa} no existe");
         throw new InvalidDataException("La empresa que compra no existe.");
     }
     if ($empresa->getActivo() == false) {
         throw new BusinessLogicException("Una empresa inactiva no puede hacer compras.");
     }
     //validemos los valores conocidos
     //( 0 >= descuento > 100, subtotal > 0, total >= subtotal, etc etc)
     //validemos sucursal
     $sucursal = null;
     if (!is_null($id_sucursal) && strlen($id_sucursal) > 0) {
         $sucursal = SucursalDAO::getByPK($id_sucursal);
         if (is_null($sucursal)) {
             Logger::error("La sucursal {$id_sucursal} no existe");
             //throw new InvalidDataException("La sucural que se envio no existe.");
         }
     }
     //validemos detalles de compra
     //debe traer
     // 	-id_producto
     //	-cantidad
     //	-precio
     //	-lote
     if (!is_array($detalle)) {
         throw InvalidDataException("El detalle no es un arreglo");
     }
     for ($detalleIterator = 0; $detalleIterator < sizeof($detalle); $detalleIterator++) {
         //por cada producto
         //	-debe existir
         //	-si se lo compro a un proveedor no hay pedo
         // 	 si se lo compro a un cliente, debe de tener comprar_caja = 1
         //	-debe tener cantidad mayor a 0
         //	-que exista el lote a donde va a ir
         $p = $detalle[$detalleIterator];
         if (!isset($p->precio)) {
             throw new InvalidArgumentException("No se envio el precio");
         }
         if (!isset($p->id_producto)) {
             throw new InvalidArgumentException("No se envio el id_producto");
         }
         if (!isset($p->cantidad)) {
             throw new InvalidArgumentException("No se envio la cantidad");
         }
         if (!isset($p->lote)) {
             throw new InvalidArgumentException("No se envio el lote");
         }
         $producto = ProductoDAO::getByPK($p->id_producto);
         if (is_null($producto)) {
             throw new InvalidArgumentException("El producto a comprar no existe");
         }
         if ($p->cantidad <= 0) {
             throw new InvalidArgumentException("No puedes comprar 0 unidades");
         }
     }
     $s = SesionController::getCurrentUser();
     //terminaron las validaciones
     $compra = new Compra();
     $compra->setIdVendedorCompra($id_usuario_compra);
     $compra->setTipoDeCompra($tipo_compra);
     $compra->setFecha(time());
     $compra->setSubtotal($subtotal);
     $compra->setImpuesto($impuesto);
     $compra->setDescuento($descuento);
     $compra->setTotal($subtotal + $impuesto);
     $compra->setIdUsuario($s->getIdUsuario());
     $compra->setIdEmpresa($id_empresa);
     $compra->setSaldo(0);
//.........这里部分代码省略.........

 /**
  *
  *Una nueva orden de servicio a prestar. Este debe ser un servicio activo. Y prestable desde la sucursal desde donde se inicio la llamada. Los conceptos a llenar estan definidos por el concepto. Se guardara el id del agente que inicio la orden y el id del cliente. La fecha se tomara del servidor.
  *
  * @param id_cliente int Id del cliente que contrata el servicio
  * @param id_servicio int Id del servicio que se contrata
  * @param fecha_entrega string Fecha en que se entregara el servicio.
  * @param descripcion string Descripcion de la orden o el porque del servicio
  * @param adelanto float Adelanto de la orden
  * @return id_orden int Id de la orden que se creo.
  **/
 public static function NuevaOrden($id_cliente, $id_servicio, $adelanto = null, $cliente_reporta = null, $condiciones_de_recepcion = null, $descripcion = "", $extra_params = null, $fecha_entrega = "", $fotografia = null, $id_usuario_asignado = null, $precio = null)
 {
     Logger::log("Creando nueva orden de servicio...");
     Logger::log("   id_servicio=" . $id_servicio);
     Logger::log("   id_cliente =" . $id_cliente);
     //Se obtiene al usuario de la sesion actual
     $s = SesionController::Actual();
     if (is_null($s)) {
         Logger::error("No se ha podido obtener al usuario de la sesion. Ya inicio sesion?");
         throw new AccessDeniedException("No se ha podido obtener al usuario de la sesion.");
     }
     $id_usuario = $s["id_usuario"];
     $cliente = UsuarioDAO::getByPK($id_cliente);
     $saldo_cliente = $cliente->getSaldoDelEjercicio();
     //se trae el monto que le resta por disponer de su limite de credito
     /*			if( $saldo_cliente < $precio )
     				throw new InvalidDataException("El saldo del cliente es insuficiente ($ {$saldo_cliente})");
     */
     //Valida que los datos sean correctos
     $validar = self::validarParametrosOrdenDeServicio(null, $id_servicio, $id_cliente, $descripcion, null, $adelanto);
     //Si no se recibe adelanto se toma como cero
     if (is_null($adelanto)) {
         $adelanto = 0;
     } else {
         if ($adelanto < 0) {
             throw new InvalidDataException("No es un valor de adelanto valido");
         }
     }
     if ($adelanto > $precio) {
         throw new InvalidDataException("El monto del adelanto rebaza el monto del servicio");
     }
     $servicio = ServicioDAO::getByPK($id_servicio);
     if (is_null($servicio)) {
         throw new InvalidDataException("Este servicio no existe");
     }
     $subtotal = 0;
     if ($servicio->getMetodoCosteo() == "variable") {
         if (is_null($precio)) {
             throw new InvalidDataException("Este servicio es de precio variable y no se envio el precio");
         }
         if ($precio < 0) {
             throw new InvalidDataException("{$precio} no es un precio valido, es menor a 0");
         }
         $subtotal = $precio;
     } else {
         $subtotal = $servicio->getPrecio();
         if (is_null($subtotal)) {
             Logger::error("el precio de este servicio esta mal!");
             $subtotal = 0;
         }
     }
     /*
     			//Figu: al llegar a este punto si tiene el saldo de la venta, pero se valida aun asi que su limite de credito cubra ese subtotal
     			//esto por si en algun momento se actualiza el limite de credito del cliente (que el admin del sis le decremente su limite por cualquier razon)
     			if(UsuarioDAO::getByPK($id_cliente)->getLimiteCredito() < $subtotal){
     				throw new BusinessLogicException("El limite de credito no cubre este monto");
     			}
     */
     //Se inicializa el registro de orden de servicio
     $orden_de_servicio = new OrdenDeServicio(array("id_servicio" => $id_servicio, "id_usuario_venta" => $id_cliente, "id_usuario" => $id_usuario, "fecha_orden" => time(), "fecha_entrega" => $fecha_entrega, "activa" => 1, "cancelada" => 0, "descripcion" => $descripcion, "adelanto" => $adelanto, "precio" => $subtotal));
     //ok, ya tengo el servicio, vamos a ver si necesito parametros extra
     if (!is_null($servicio->getExtraParams())) {
         Logger::log("El servicio require parametros extra.");
         //si se necesitan, vamos a ver cuales son,
         $extra_params_sent = $extra_params;
         $extra_params_required = json_decode($servicio->getExtraParams());
         //no se enviaron los parametros extra?
         if (is_null($extra_params_sent)) {
             Logger::warn("no se enviaron parametros extra");
         }
         foreach ($extra_params_required as $epr) {
             Logger::log("Extraparam:" . $epr->desc);
         }
         $orden_de_servicio->setExtraParams(json_encode($extra_params));
     }
     DAO::transBegin();
     try {
         Logger::log("Insertando la orden de servicio....");
         $orden = OrdenDeServicioDAO::save($orden_de_servicio);
     } catch (Exception $e) {
         DAO::transRollback();
         Logger::error($e->getMessage());
         throw new InvalidDatabaseOperationException("No se pudo crear la nueva orden de servicio");
     }
     $s = SesionController::Actual();
     //proceder a insertar venta a credito para este servicio
     /*
      */
     DAO::transEnd();
//.........这里部分代码省略.........

<?php

define("BYPASS_INSTANCE_CHECK", false);
require_once "../../../server/bootstrap.php";
$page = new GerenciaComponentPage();
//
// Parametros necesarios
//
$page->requireParam("uid", "GET", "Este usuario no existe.");
$este_usuario = UsuarioDAO::getByPK($_GET["uid"]);
$esta_direccion = DireccionDAO::getByPK($este_usuario->getIdDireccion());
//
// Titulo de la pagina
//
$page->addComponent(new TitleComponent("Editar usuario " . $este_usuario->getNombre(), 2));
//
// Forma de usuario
//
if (is_null($esta_direccion)) {
    $esta_direccion = new Direccion();
}
$este_usuario->setPassword("");
$form = new DAOFormComponent($este_usuario);
$form->hideField(array("id_usuario", "id_direccion", "id_direccion_alterna", "id_sucursal", "fecha_asignacion_rol", "fecha_alta", "fecha_baja", "activo", "last_login", "consignatario", "id_clasificacion_cliente", "id_clasificacion_proveedor", "tarifa_venta_obtenida", "tarifa_compra_obtenida", "id_tarifa_compra", "id_tarifa_venta", "saldo_del_ejercicio", "intereses_moratorios", "representante_legal", "pagina_web", "mensajeria", "denominacion_comercial", "dias_de_credito", "facturar_a_terceros", "limite_credito", "token_recuperacion_pass", "tiempo_entrega", "ventas_a_credito", "descuento", "dias_de_embarque", "cuenta_de_mensajeria"));
$form->setCaption("rfc", "RFC");
$form->setCaption("id_moneda", "Moneda default");
$form->setCaption("id_rol", "Rol");
$form->setHelp("id_rol", "Rol");
$form->sendHidden("id_usuario");
$form->addApiCall("api/personal/usuario/editar/");
$form->onApiCallSuccessRedirect("personal.usuario.ver.php?uid=" . $_GET["uid"]);

 /**
  * Crea un pdf con el estado de cuenta de el cliente especificado
  * @param Array $args,  $args['id_cliente'=>12[,'tipo_venta'=> 'credito | contado | saldo'] ], por default obtiene todas las compras del cliente
  */
 public static function imprimirEstadoCuentaCliente($args)
 {
     //verificamos que se haya especificado el id del cliente
     if (!isset($args['id_cliente'])) {
         Logger::log("Error al obtener el estado de cuenta, no se ha especificado un cliente.");
         die('{"success": false, "reason": "Error al obtener el estado de cuenta, no se ha especificado un cliente."}');
     }
     //verificamos que el cliente exista
     if (!($cliente = ClienteDAO::getByPK($args['id_cliente']))) {
         Logger::log("Error al obtener el estado de cuenta, no se tiene registro del cliente {$args['id_cliente']}.");
         die('{"success": false, "reason": "Error al obtener el estado de cuenta, no se tiene registro del cliente ' . $args['id_cliente'] . '"}');
     }
     //obtenemos los datos del emisor
     $estado_cuenta = estadoCuentaCliente($args);
     //buscar los datos del emisor
     if (!($emisor = PosConfigDAO::getByPK('emisor'))) {
         Logger::log("no encuentro los datos del emisor");
         die("no encuentro los datos del emisor");
     }
     $emisor = json_decode($emisor->getValue())->emisor;
     $sucursal = SucursalDAO::getByPK($_SESSION['sucursal']);
     if (!$sucursal) {
         die("Sucursal invalida");
     }
     include_once 'librerias/ezpdf/class.pdf.php';
     include_once 'librerias/ezpdf/class.ezpdf.php';
     $pdf = new Cezpdf();
     $pdf->selectFont('../server/librerias/ezpdf/fonts/Helvetica.afm');
     //margenes de un centimetro para toda la pagina
     $pdf->ezSetMargins(1, 1, 1, 1);
     /*
      * LOGO
      */
     if (!($logo = PosConfigDAO::getByPK('url_logo'))) {
         Logger::log("Verifique la configuracion del pos_config, no se encontro el camṕo 'url_logo'");
         die("Verifique la configuracion del POS, no se encontro el url del logo");
     }
     //addJpegFromFile(imgFileName,x,y,w,[h])
     //detectamos el tipo de imagen del logo
     if (substr($logo->getValue(), -3) == "jpg" || substr($logo->getValue(), -3) == "JPG" || substr($logo->getValue(), -4) == "jpeg" || substr($logo->getValue(), -4) == "JPEG") {
         $pdf->addJpegFromFile($logo->getValue(), puntos_cm(2), puntos_cm(25.5), puntos_cm(3.5));
     } elseif (substr($logo->getValue(), -3) == "png" || substr($logo->getValue(), -3) == "PNG") {
         $pdf->addPngFromFile($logo->getValue(), puntos_cm(2), puntos_cm(25.5), puntos_cm(3.5));
     } else {
         Logger::log("Verifique la configuracion del pos_config, la extension de la imagen del logo no es compatible");
         die("La extension de la imagen usada para el logo del negocio no es valida.");
     }
     /*     * ************************
      * ENCABEZADO
      * ************************* */
     $e = "<b>" . self::readableText($emisor->nombre) . "</b>\n";
     $e .= formatAddress($emisor);
     $e .= "RFC: " . $emisor->rfc . "\n\n";
     //datos de la sucursal
     $e .= "<b>Lugar de expedicion</b>\n";
     $e .= self::readableText($sucursal->getDescripcion()) . "\n";
     $e .= formatAddress($sucursal);
     $datos = array(array("emisor" => $e));
     $pdf->ezSetY(puntos_cm(28.6));
     $opciones_tabla = array();
     $opciones_tabla['showLines'] = 0;
     $opciones_tabla['showHeadings'] = 0;
     $opciones_tabla['shaded'] = 0;
     $opciones_tabla['fontSize'] = 8;
     $opciones_tabla['xOrientation'] = 'right';
     $opciones_tabla['xPos'] = puntos_cm(7.3);
     $opciones_tabla['width'] = puntos_cm(11);
     $opciones_tabla['textCol'] = array(0, 0, 0);
     $opciones_tabla['titleFontSize'] = 12;
     $opciones_tabla['rowGap'] = 3;
     $opciones_tabla['colGap'] = 3;
     $pdf->ezTable($datos, "", "", $opciones_tabla);
     $cajero = UsuarioDAO::getByPK($_SESSION['userid'])->getNombre();
     $datos = array(array("col" => "<b>Cajero</b>"), array("col" => self::readableText($cajero)), array("col" => "<b>Cliente</b>"), array("col" => self::readableText($cliente->getRazonSocial())), array("col" => "<b>Limite de  Credito</b>"), array("col" => FormatMoney($estado_cuenta->limite_credito, DONT_USE_HTML)), array("col" => "<b>Saldo</b>"), array("col" => FormatMoney($estado_cuenta->saldo, DONT_USE_HTML)));
     $pdf->ezSetY(puntos_cm(28.8));
     $opciones_tabla['xPos'] = puntos_cm(12.2);
     $opciones_tabla['width'] = puntos_cm(6);
     $opciones_tabla['showLines'] = 0;
     $opciones_tabla['shaded'] = 2;
     $opciones_tabla['shadeCol'] = array(1, 1, 1);
     //$opciones_tabla['shadeCol2'] = array(0.054901961, 0.756862745, 0.196078431);
     $opciones_tabla['shadeCol2'] = array(0.8984375, 0.95703125, 0.99609375);
     $pdf->ezTable($datos, "", "", $opciones_tabla);
     //roundRect($pdf, puntos_cm(12.2), puntos_cm(28.8), puntos_cm(6), puntos_cm(4.25));
     /**
      * ESTADO DE CUENTA
      */
     $elementos = array(array('id_venta' => 'Venta', 'fecha' => 'Fecha', 'sucursal' => 'Sucursal', 'cajero' => 'Cajero', 'tipo_venta' => 'Tipo', 'tipo_pago' => 'Pago', 'total' => 'Total', 'pagado' => 'Pagado', 'saldo' => 'Saldo'));
     foreach ($estado_cuenta->array_ventas as $venta) {
         $array_venta = array();
         $array_venta['id_venta'] = $venta['id_venta'];
         $array_venta['fecha'] = $venta['fecha'];
         $array_venta['sucursal'] = self::readableText($venta['sucursal']);
         $array_venta['cajero'] = self::readableText($venta['cajero']);
         $array_venta['cancelada'] = self::readableText($venta['cancelada']);
         $array_venta['tipo_venta'] = self::readableText($venta['tipo_venta']);
//.........这里部分代码省略.........

//
// Forma de producto
//
$esta_orden->setFechaOrden(FormatTime($esta_orden->getFechaOrden()));
$a = $esta_orden->getIdUsuarioAsignado();
$asignado = UsuarioDAO::getByPK($a);
if (!is_null($asignado)) {
    $esta_orden->setIdUsuarioAsignado($asignado->getNombre());
} else {
    $esta_orden->setIdUsuarioAsignado("<img src='../../media/iconos/user_delete.png'> Nadie esta asignado");
}
//$form->createComboBoxJoin("id_servicio", "nombre_servicio", ServicioDAO::getAll(), $esta_orden->getIdServicio());
//$form->createComboBoxJoin("id_usuario", "nombre", UsuarioDAO::getAll(), $esta_orden->getIdUsuario());
$servicio = ServicioDAO::getByPK($esta_orden->getIdServicio());
$esta_orden->setIdServicio($servicio->getNombreServicio());
$agente = UsuarioDAO::getByPK($esta_orden->getIdUsuario());
if (!is_null($agente)) {
    $esta_orden->setIdUsuario($agente->getNombre());
}
$esta_orden->setPrecio(FormatMoney($esta_orden->getPrecio()));
$form = new DAOFormComponent($esta_orden);
$form->setEditable(false);
$form->hideField(array("id_orden_de_servicio", "id_usuario_venta", "extra_params", "motivo_cancelacion", "fecha_entrega", "cancelada", "adelanto", "activa", "descripcion"));
$form->setCaption("id_usuario", "Agente que realizo");
$form->setCaption("id_usuario_asignado", "Agente asignado");
$form->setCaption("id_servicio", "Servicio");
//$form->createComboBoxJoinDistintName("id_usuario_venta", "id_usuario", "nombre", UsuarioDAO::getAll(), $esta_orden->getIdUsuarioVenta());
$page->addComponent($form);
$eP = $esta_orden->getExtraParams();
if (!is_null($eP)) {
    $ePObj = json_decode($eP);