PHP DAO::transEnd方法代码示例

 public static function NuevaDireccion($calle, $numero_exterior, $colonia, $id_ciudad, $codigo_postal, $numero_interior = null, $referencia = null, $telefono = null, $telefono2 = null)
 {
     $direccion = new Direccion();
     $id_usuario = SesionController::Actual();
     $id_usuario = $id_usuario["id_usuario"];
     if ($id_usuario == null) {
         Logger::error("SesionController::Actual() regreso null");
         throw new Exception("No se pudo obtener la sesion del usuario, ya inicio sesion?", 901);
     }
     if (!self::validarDireccion($direccion)) {
         throw new InvalidDataException();
     }
     $direccion->setCalle($calle);
     $direccion->setNumeroExterior($numero_exterior);
     $direccion->setColonia($colonia);
     $direccion->setIdCiudad($id_ciudad);
     $direccion->setCodigoPostal($codigo_postal);
     $direccion->setNumeroInterior($numero_interior);
     $direccion->setReferencia($referencia);
     $direccion->setTelefono($telefono);
     $direccion->setTelefono2($telefono2);
     $direccion->setUltimaModificacion(time());
     $direccion->setIdUsuarioUltimaModificacion($id_usuario);
     DAO::transBegin();
     try {
         DireccionDAO::save($direccion);
     } catch (Exception $e) {
         DAO::transRollback();
         throw new Exception("No se pudo crear la direccion: " . $e);
     }
     DAO::transEnd();
     Logger::log("Direccion creada exitosamente, id=" . $direccion->getIdDireccion());
     return $direccion->getIdDireccion();
 }

 /**
  *
  *Para poder editar un traspaso,este no tuvo que haber sido enviado aun
  *
  * @param id_traspaso int Id del traspaso a editar
  * @param productos json Productos a enviar con sus cantidades
  * @param fecha_envio_programada string Fecha de envio programada
  **/
 public static function EditarTraspasoAlmacen($id_traspaso, $fecha_envio_programada = null, $productos = null)
 {
     Logger::log("Editando traspaso " . $id_traspaso);
     //valida que el traspaso exista, que no haya sido cancelado y que no se hayan efectuado operaciones sobre el.
     $validar = self::validarParametrosTraspaso($id_traspaso, null, null, $fecha_envio_programada);
     if (is_string($validar)) {
         Logger::error($validar);
         throw new Exception($validar);
     }
     $traspaso = TraspasoDAO::getByPK($id_traspaso);
     if ($traspaso->getCancelado()) {
         Logger::error("El traspaso ya ha sido cancelado, no puede ser editado");
         throw new Exception("El traspaso ya ha sido cancelado, no puede ser editado");
     }
     if ($traspaso->getCompleto() || $traspaso->getEstado() !== "Envio programado") {
         Logger::error("No se puede editar el traspaso de almacen pues ya se han realizado acciones sobre el");
         throw new Exception("No se puede editar el traspaso de almacen pues ya se han realizado acciones sobre el");
     }
     //Si se recibe el parametro fecha de envio se toma como actualizacion.
     if (!is_null($fecha_envio_programada)) {
         $traspaso->setFechaEnvioProgramada($fecha_envio_programada);
     }
     DAO::transBegin();
     try {
         TraspasoDAO::save($traspaso);
         if (!is_null($productos)) {
             $productos = object_to_array($productos);
             if (!is_array($productos)) {
                 throw new Exception("Los productos son invalidos", 901);
             }
             //Se actualiza la cantidad de cada producto programado para este traspaso, si el producto
             //no se encuentra, se verifica que su empresa concuerde con la del almacen de recibo y
             //se crea el nuevo registro.
             //
             //Despues, se recorren los productos que se encuentran actualmente programados a enviarse en el traspaso,
             //los productos que no se encuentre en la nueva lista obtenida seran eliminados.
             foreach ($productos as $p) {
                 if (!array_key_exists("id_producto", $p) || !array_key_exists("id_unidad", $p) || !array_key_exists("cantidad", $p)) {
                     throw new Exception("Los productos no tienen todos los parametros necesarios", 901);
                 }
                 $traspaso_producto = TraspasoProductoDAO::getByPK($id_traspaso, $p["id_producto"], $p["id_unidad"]);
                 if (is_null($traspaso_producto)) {
                     $almacen_recibe = AlmacenDAO::getByPK($traspaso->getIdAlmacenRecibe());
                     $productos_empresa = ProductoEmpresaDAO::search(new ProductoEmpresa(array("id_producto" => $p["id_producto"])));
                     $encontrado = false;
                     foreach ($productos_empresa as $p_e) {
                         if ($p_e->getIdEmpresa() == $almacen_recibe->getIdEmpresa()) {
                             $encontrado = true;
                         }
                     }
                     if (!$encontrado) {
                         throw new Exception("Se busca enviar un producto que no es de la empresa del almacen que recibe", 901);
                     }
                     $traspaso_producto = new TraspasoProducto(array("id_traspaso" => $id_traspaso, "id_producto" => $p["id_producto"], "id_unidad" => $p["id_unidad"], "cantidad_recibida" => 0));
                 }
                 $traspaso_producto->setCantidadEnviada($p["cantidad"]);
                 TraspasoProductoDAO::save($traspaso_producto);
             }
             /* Fin de foreach de productos*/
             $traspasos_producto = TraspasoProductoDAO::search(new TraspasoProducto(array("id_traspaso" => $id_traspaso)));
             foreach ($traspasos_producto as $t_p) {
                 $encontrado = false;
                 foreach ($productos as $p) {
                     if ($t_p->getIdProducto() == $p["id_producto"] && $t_p->getIdUnidad() == $p["id_unidad"]) {
                         $encontrado = true;
                     }
                 }
                 if (!$encontrado) {
                     TraspasoProductoDAO::delete($t_p);
                 }
             }
             /* Fin de foreach de traspaso_producto*/
         }
         /* Fin de if de productos */
     } catch (Exception $e) {
         DAO::transRollback();
         Logger::error("No se pudo editar el traspaso: " . $e);
         if ($e->getCode() == 901) {
             throw new Exception("No se pudo editar el traspaso: " . $e->getMessage(), 901);
         }
         throw new Exception("No se pudo editar el traspaso", 901);
     }
     DAO::transEnd();
     Logger::log("Traspaso editado correctamente");
 }

//.........这里部分代码省略.........
     $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);
     $compra->setCancelada(false);
     $compra->setTipoDePago($tipo_de_pago);
     $compra->setRetencion(0);
     try {
         DAO::transBegin();
         CompraDAO::save($compra);
     } catch (Exception $e) {
         DAO::transRollback();
         throw InvalidDatabaseOperationException($e);
     }
     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->id_producto)));
             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::search(new Lote(array("folio" => $p->lote)));
             $l = $l[0];
             //busquemos la unidad que nos mandaron
             $uAbreviacion = $p->id_unidad;
             $uResults = UnidadMedidaDAO::search(new UnidadMedida(array("abreviacion" => $uAbreviacion, "activa" => 1)));
             if (sizeof($uResults) != 1) {
                 throw new InvalidDataException("La unidad de medida `" . $p->id_unidad . "` no existe, o no esta activa.");
             } else {
                 $p->id_unidad = $uResults[0]->getIdUnidadMedida();
             }
             //busequemos si este producto ya existe en este lote
             $lp = LoteProductoDAO::getByPK($l->getIdLote(), $p->id_producto);
             if (is_null($lp)) {
                 //no existe, insertar
                 $loteProducto = new LoteProducto(array("id_lote" => $l->getIdLote(), "id_producto" => $p->id_producto, "cantidad" => $p->cantidad, "id_unidad" => $p->id_unidad));
                 LoteProductoDAO::save($loteProducto);
             } else {
                 //ya existe, sumar
                 //revisemos si es de la misma unidad
                 if ($lp->getIdUnidad() == $p->id_unidad) {
                     //es igual, solo hay que sumar
                     $lp->setCantidad($lp->getCantidad() + $p->cantidad);
                 } else {
                     //no es igual, hay que convertir
                     try {
                         $r = UnidadMedidaDAO::convertir($p->id_unidad, $lp->getIdUnidad(), $p->cantidad);
                     } 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);
             }
             $loteEntrada = new LoteEntrada(array("id_lote" => $l->getIdLote(), "id_usuario" => $s->getIdUsuario(), "fecha_registro" => time(), "motivo" => "Compra a Proveedor"));
             LoteEntradaDAO::save($loteEntrada);
             LoteEntradaProductoDAO::save(new LoteEntradaProducto(array("id_lote_entrada" => $loteEntrada->getIdLoteEntrada(), "id_producto" => $p->id_producto, "id_unidad" => $p->id_unidad, "cantidad" => $p->cantidad)));
             $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);
         }
     }
     //for
     try {
         DAO::transEnd();
     } catch (Exception $e) {
         throw InvalidDatabaseOperationException($e);
     }
     Logger::log("===== COMPRA " . $compra->getIdCompra() . " EXITOSA ===== ");
     return array("id_compra" => $compra->getIdCompra());
 }

 public static function NuevoCheque($nombre_banco, $monto, $numero, $expedido, $id_usuario = null)
 {
     Logger::log("creando cheque");
     //Se validan los parametros obtenidos
     $validar = self::validarParametrosCheque(null, $nombre_banco, $monto, $numero, $expedido);
     if (is_string($validar)) {
         Logger::error($validar);
         throw new Exception($validar);
     }
     $cheque = new Cheque();
     $cheque->setNombreBanco($nombre_banco);
     $cheque->setMonto($monto);
     $cheque->setNumero($numero);
     $cheque->setExpedido($expedido);
     if ($expedido) {
         $id_usuario = SesionController::getCurrentUser();
         if (is_null($id_usuario)) {
             Logger::error("No se pudo obtener el usuario de la sesion, ya inicio sesion?");
             throw new Exception("No se pudo obtener el usuario de la sesion, ya inicio sesion?");
         }
     }
     $cheque->setIdUsuario($id_usuario);
     DAO::transBegin();
     try {
         ChequeDAO::save($cheque);
     } catch (Exception $e) {
         DAO::transRollback();
         Logger::error("No se pudo crear el cheque: " . $e);
         throw "No se pudo crear el cheque";
     }
     DAO::transEnd();
     Logger::log("Cheque creado exitosamente");
     return $cheque->getIdCheque();
 }

 /**
  *
  *Edita la informaci?e un abono
  *
  * @param id_abono int Id del abono a editar
  * @param nota string Nota del abono
  * @param motivo_cancelacion string Motivo por el cual se cancelo el abono
  **/
 public static function EditarAbono($id_abono, $compra = null, $motivo_cancelacion = null, $nota = null, $prestamo = null, $venta = null)
 {
     Logger::log("Editando abono");
     //Se validan los parametros
     $validar = self::validarParametrosAbono(null, null, $nota, null, $motivo_cancelacion);
     if (is_string($validar)) {
         Logger::error($validar);
         throw new Exception($validar);
     }
     //verifica si el abono sera de compra, de venta o de prestamo
     $abono = null;
     $from = 0;
     if ($compra) {
         $abono = AbonoCompraDAO::getByPK($id_abono);
         $from = 1;
     } else {
         if ($venta) {
             $abono = AbonoVentaDAO::getByPK($id_abono);
             $from = 2;
         } else {
             if ($prestamo) {
                 $abono = AbonoPrestamoDAO::getByPK($id_abono);
                 $from = 3;
             } else {
                 Logger::error("No se recibio si se editara un abono de compra, venta o prestamo");
                 throw new Exception("No se recibio si se editara un abono de compra, venta o prestamo");
             }
         }
     }
     //valida que el abono exista
     if (is_null($abono)) {
         $texto = "";
         switch ($from) {
             case 1:
                 $texto = "compra";
                 break;
             case 2:
                 $texto = "venta";
                 break;
             case 3:
                 $texto = "prestamo";
                 break;
         }
         Logger::error("El abono de " . $texto . " con id " . $id_abono . " no existe");
         throw new Exception("El abono de " . $texto . " con id " . $id_abono . " no existe");
     }
     //Los parametros que sean recibidos seran tomados como actalizacion
     if (!is_null($nota)) {
         $abono->setNota($nota);
     }
     if ($abono->getCancelado()) {
         if (!is_null($motivo_cancelacion)) {
             $abono->setMotivoCancelacion($motivo_cancelacion);
         }
     } else {
         if (!is_null($motivo_cancelacion)) {
             Logger::warn("No se editara el motivo de cancelacion pues el abono no ha sido cancelado aun");
         }
     }
     //guarda la actualizacion en la tabla correspondiente
     DAO::transBegin();
     try {
         switch ($from) {
             case 1:
                 AbonoCompraDAO::save($abono);
                 break;
             case 2:
                 AbonoVentaDAO::save($abono);
                 break;
             case 3:
                 AbonoPrestamoDAO::save($abono);
         }
     } catch (Exception $e) {
         DAO::transRollback();
         Logger::error("No se pudo editar el abono: " . $e);
         throw new Exception("No se pudo editar el abono");
     }
     DAO::transEnd();
     Logger::log("Abono editado exitosamente");
 }

 /**
  * Entry point for Create a User API
  *
  * @param Request $r
  * @return array
  * @throws InvalidDatabaseOperationException
  * @throws DuplicatedEntryInDatabaseException
  */
 public static function apiCreate(Request $r)
 {
     // Validate request
     Validators::isValidUsername($r['username'], 'username');
     Validators::isEmail($r['email'], 'email');
     // Check password
     $hashedPassword = null;
     if (!isset($r['ignore_password'])) {
         SecurityTools::testStrongPassword($r['password']);
         $hashedPassword = SecurityTools::hashString($r['password']);
     }
     // Does user or email already exists?
     try {
         $user = UsersDAO::FindByUsername($r['username']);
         $userByEmail = UsersDAO::FindByEmail($r['email']);
     } catch (Exception $e) {
         throw new InvalidDatabaseOperationException($e);
     }
     if (!is_null($userByEmail)) {
         throw new DuplicatedEntryInDatabaseException('mailInUse');
     }
     if (!is_null($user)) {
         throw new DuplicatedEntryInDatabaseException('usernameInUse');
     }
     // Prepare DAOs
     $user_data = array('username' => $r['username'], 'password' => $hashedPassword, 'solved' => 0, 'submissions' => 0, 'verified' => 0, 'verification_id' => self::randomString(50));
     if (isset($r['name'])) {
         $user_data['name'] = $r['name'];
     }
     if (isset($r['facebook_user_id'])) {
         $user_data['facebook_user_id'] = $r['facebook_user_id'];
     }
     if (!is_null(self::$permissionKey) && self::$permissionKey == $r['permission_key']) {
         $user_data['verified'] = 1;
     } elseif (OMEGAUP_VALIDATE_CAPTCHA) {
         // Validate captcha
         if (!isset($r['recaptcha'])) {
             throw new InvalidParameterException('parameterNotFound', 'recaptcha');
         }
         $url = 'https://www.google.com/recaptcha/api/siteverify';
         $data = array('secret' => OMEGAUP_RECAPTCHA_SECRET, 'response' => $r['recaptcha'], 'remoteip' => $_SERVER['REMOTE_ADDR']);
         // use key 'http' even if you send the request to https://...
         $options = array('http' => array('header' => "Content-type: application/x-www-form-urlencoded\r\n", 'method' => 'POST', 'content' => http_build_query($data)));
         $context = stream_context_create($options);
         $result = file_get_contents($url, false, $context);
         if ($result === false) {
             self::$log->error('POST Request to Google Recaptcha failed.');
             throw new CaptchaVerificationFailedException();
         }
         $resultAsJson = json_decode($result, true);
         if (is_null($resultAsJson)) {
             self::$log->error('Captcha response was not a json');
             self::$log->error('Here is the result:' . $result);
             throw new CaptchaVerificationFailedException();
         }
         if (!(array_key_exists('success', $resultAsJson) && $resultAsJson['success'])) {
             self::$log->error('Captcha response said no');
             throw new CaptchaVerificationFailedException();
         }
     }
     $user = new Users($user_data);
     $email = new Emails(array('email' => $r['email']));
     // Save objects into DB
     try {
         DAO::transBegin();
         UsersDAO::save($user);
         $email->setUserId($user->getUserId());
         EmailsDAO::save($email);
         $user->setMainEmailId($email->getEmailId());
         UsersDAO::save($user);
         DAO::transEnd();
     } catch (Exception $e) {
         DAO::transRollback();
         throw new InvalidDatabaseOperationException($e);
     }
     $r['user'] = $user;
     if (!$user->verified) {
         self::$log->info('User ' . $user->getUsername() . ' created, sending verification mail');
         self::sendVerificationEmail($r);
     } else {
         self::$log->info('User ' . $user->getUsername() . ' created, trusting e-mail');
     }
     return array('status' => 'ok', 'user_id' => $user->getUserId());
 }

 /**
  *
  *Crear un nuevo impuesto.
  *
  * @param monto_porcentaje float monto o porcentaje que representa este impuesto
  * @param nombre string Nombre del impuesto
  * @param es_monto bool Si es verdadero, el campo de monto_porcentaje sera tomado como un monto fijo, si es falso, sera tomado como un porcentaje
  * @param descripcion string Descripcion del impuesto
  * @return id_impuesto int Id del impuesto insertado.
  **/
 public static function NuevoImpuesto($es_monto, $monto_porcentaje, $nombre, $descripcion = null)
 {
     Logger::log("Creando un nuevo impuesto");
     //Se validan los parametros recibidos
     $e = self::validarEsMonto($es_monto);
     if (is_string($e)) {
         Logger::error($e);
         throw new Exception($e);
     }
     $e = self::validarMontoPorcentaje($monto_porcentaje);
     if (is_string($e)) {
         Logger::error($e);
         throw new Exception($e);
     }
     $e = self::validarNombre($nombre);
     if (is_string($e)) {
         Logger::error($e);
         throw new Exception($e);
     }
     if (!is_null($descripcion)) {
         $e = self::validarDescripcion($descripcion);
         if (is_string($e)) {
             Logger::error($e);
             throw new Exception($e);
         }
     }
     $impuesto = new Impuesto(array("es_monto" => $es_monto, "monto_porcentaje" => $monto_porcentaje, "nombre" => $nombre, "descripcion" => $descripcion));
     DAO::transBegin();
     try {
         ImpuestoDAO::save($impuesto);
     } catch (Exception $e) {
         DAO::transRollback();
         Logger::error("No se ha podido crear el nuevo impuesto: " . $e);
         throw new Exception("No se ha podido crear al nuevo impuesto, consulte a su administrador de sistema");
     }
     DAO::transEnd();
     Logger::log("Impuesto creado exitosamente");
     return array("id_impuesto" => $impuesto->getIdImpuesto());
 }

 /**
  *
  *Este metodo desactiva un grupo, solo se podra desactivar un grupo si no hay ningun usuario que pertenezca a el.
  *
  *
  * @author Juan Manuel Garc&iacute;a Carmona <manuel@caffeina.mx>
  * @param id_rol int Id del grupo a eliminar
  **/
 public static function EliminarRol($id_rol)
 {
     //Los roles de administrador (1), gerente (2), cajero(3), cliente (5) y proveedor(6) no pueden ser eliminados
     if ($id_rol >= 1 && $id_rol <= 3 || $id_rol >= 5 && $id_rol <= 6) {
         Logger::error("El rol predeterminado " . $id_rol . " no puede ser eliminado");
         throw new Exception("Los roles predeterminados no pueden ser eliminado", 901);
     }
     /*
      * Se obtiene la lista de usuarios con este rol.
      * Si almenos uno aun sigue activo, entonces no se puede eliminar el rol
      */
     $usuarios = UsuarioDAO::search(new Usuario(array("id_rol" => $id_rol)));
     if (!empty($usuarios)) {
         Logger::error("No se puede eliminar este rol pues el usuario " . $usuarios[0]->getNombre() . " lo tiene asignado");
         throw new Exception("No se puede eliminar este rol pues hay almenos un usuario asignado a el", 901);
     }
     DAO::transBegin();
     try {
         //Se elimina el rol
         $to_delete = RolDAO::getByPK($id_rol);
         RolDAO::delete($to_delete);
     } catch (Exception $e) {
         DAO::transRollback();
         Logger::error("Error al eliminar el rol: " . $e);
         throw new Exception("Error al eliminar el rol, consulte a su administrador de sistema", 901);
     }
     DAO::transEnd();
     Logger::log("Rol eliminado correctamente");
 }

//.........这里部分代码省略.........
             if (isset($d->telefono2)) {
                 $cambio_direccion = true;
                 $_direccion->setTelefono2($direccion['telefono2']);
             }
             //Si cambio algun parametro de direccion, se actualiza el usuario que modifica y la fecha
             if ($cambio_direccion) {
                 DireccionController::EditarDireccion($_direccion);
             } else {
                 DireccionController::NuevaDireccion($calle = isset($d->calle) ? $d->calle : "", $numero_exterior = isset($d->numero_exterior) ? $d->numero_exterior : "", $colonia = isset($d->colonia) ? $d->colonia : "", $id_ciudad = isset($d->id_ciudad) ? $d->id_ciudad : "", $codigo_postal = isset($d->codigo_postal) ? $d->codigo_postal : "", $numero_interior = isset($d->numero_interior) ? $d->numero_interior : "", $referencia = isset($d->referencia) ? $d->referencia : "", $telefono = isset($d->telefono) ? $d->telefono : "", $telefono2 = isset($d->telefono2) ? $d->telefono2 : "");
             }
         }
     }
     DAO::transBegin();
     try {
         //Se guardan los cambios hechos en la empresa
         EmpresaDAO::save($empresa);
     } catch (Exception $e) {
         DAO::transRollback();
         Logger::error("No se pudo modificar la empresa: " . $e);
         throw new Exception("No se pudo modificar la empresa");
     }
     $impuestos_empresa = ImpuestoEmpresaDAO::search(new ImpuestoEmpresa(array("id_empresa" => $empresa->getIdEmpresa())));
     //quitamos los impuestos que no estan actualmente
     foreach ($impuestos_empresa as $impuesto_empresa) {
         $exist_ic = false;
         foreach ($impuestos_compra as $impuesto_compra) {
             if ($impuesto_compra->getIdImpuesto() == $impuesto_empresa->getIdImpuesto()) {
                 $exist_ic = true;
             }
         }
         if (!$exist_ic) {
             try {
                 ImpuestoEmpresaDAO::delete($impuesto_empresa);
             } catch (Exception $e) {
                 Logger::warn("Error al eliminar impuesto : " . $e->getMessage());
             }
         }
     }
     $impuestos_empresa = ImpuestoEmpresaDAO::search(new ImpuestoEmpresa(array("id_empresa" => $empresa->getIdEmpresa())));
     foreach ($impuestos_empresa as $impuesto_empresa) {
         $exist_iv = false;
         foreach ($impuestos_venta as $impuesto_venta) {
             if ($impuesto_venta->getIdImpuesto() == $impuesto_venta->getIdImpuesto()) {
                 $exist_iv = true;
             }
         }
         if (!$exist_iv) {
             try {
                 ImpuestoEmpresaDAO::delete($impuesto_empresa);
             } catch (Exception $e) {
                 Logger::warn("Error al eliminar impuesto : " . $e->getMessage());
             }
         }
     }
     //agregamos los impuestos de compra que no existen
     $impuestos_empresa = ImpuestoEmpresaDAO::search(new ImpuestoEmpresa(array("id_empresa" => $empresa->getIdEmpresa())));
     if ($impuestos_compra != NULL) {
         foreach ($impuestos_compra as $impuesto_compra) {
             $exist_ic = false;
             foreach ($impuestos_empresa as $impuesto_empresa) {
                 if ($impuesto_compra->getIdImpuesto() == $impuesto_empresa->getIdImpuesto()) {
                     $exist_ic = true;
                 }
             }
             if (!$exist_ic) {
                 try {
                     ImpuestoEmpresaDAO::save(new ImpuestoEmpresa(array("id_empresa" => $empresa->getIdEmpresa(), "id_impuesto" => $impuesto_compra->getIdImpuesto())));
                 } catch (Exception $e) {
                     Logger::warn("Error al guardar un impuesto compra : " . $e->getMessage());
                 }
             }
         }
     }
     //agregamos los impuestos de venta que no existen
     $impuestos_empresa = ImpuestoEmpresaDAO::search(new ImpuestoEmpresa(array("id_empresa" => $empresa->getIdEmpresa())));
     if ($impuestos_venta != NULL) {
         foreach ($impuestos_venta as $impuesto_venta) {
             $exist_iv = false;
             foreach ($impuestos_venta as $impuesto_venta) {
                 if ($impuesto_venta->getIdImpuesto() == $impuesto_venta->getIdImpuesto()) {
                     $exist_iv = true;
                 }
             }
             if (!$exist_iv) {
                 try {
                     ImpuestoEmpresaDAO::save(new ImpuestoEmpresa(array("id_empresa" => $empresa->getIdEmpresa(), "id_impuesto" => $impuesto_venta->getIdImpuesto())));
                 } catch (Exception $e) {
                     Logger::warn("Error al guardar un impuesto venta : " . $e->getMessage());
                 }
             }
         }
     }
     if ($cuentas_bancarias != NULL) {
         foreach ($cuentas_bancarias as $cuenta_bancarias) {
             //Pendiente hasta que se haga el SPEC de cuentas bancarias
         }
     }
     DAO::transEnd();
     Logger::log("Empresa editada con exito");
 }

//.........这里部分代码省略.........
 public static function Nueva($fecha_termino, $folio, $id_consignatario, $productos, $tipo_consignacion, $fecha_envio_programada = null)
 {
     Logger::log("Creando nueva consignacion");
     //Se valida al consignatario
     $e = self::validarConsignatario($id_consignatario);
     if (is_string($e)) {
         Logger::error($e);
         throw new Exception($e);
     }
     $consignatario = UsuarioDAO::getByPK($id_consignatario);
     //Se obtiene al usuario de la sesion actual
     $id_usuario = LoginController::getCurrentUser();
     if (is_null($id_usuario)) {
         Logger::error("No se pudo obtener al usuario de la sesion, ya inicio sesion?");
         throw new Exception("No se pudo obtener al usuario de la sesion, ya inicio sesion?");
     }
     //Valida el parametro tipo de consignacion
     if ($tipo_consignacion != "credito" && $tipo_consignacion != "contado") {
         Logger::error("El parametro tipo de consignacion (" . $tipo_consignacion . ") es invalido");
         throw new Exception("El parametro tipo de consignacion (" . $tipo_consignacion . ") es invalido");
     }
     //Si no se recibio fecha de envio, se toma la fecha actual
     if (is_null($fecha_envio_programada)) {
         $fecha_envio_programada = date("Y-m-d H:i:s");
     }
     $consignacion = new Consignacion(array("id_cliente" => $id_consignatario, "id_usuario" => $id_usuario, "fecha_creacion" => date("Y-m-d H:i:s"), "activa" => 1, "cancelada" => 0, "folio" => $folio, "fecha_termino" => $fecha_termino, "saldo" => 0, "tipo_consignacion" => $tipo_consignacion));
     //Se agrupan los productos que vienen del mismo almacen en subarreglos para
     //programar un solo traspaso por almacen.
     $productos_por_almacen = array();
     $num_productos = count($productos);
     for ($i = 0; $i < $num_productos; $i++) {
         if ($productos[i] == null) {
             continue;
         }
         $temp = array();
         array_push($temp, $productos[i]);
         for ($j = $i + 1; $j < $num_productos; $j++) {
             if ($productos[$i]["id_almacen"] == $productos[$j]["id_almacen"]) {
                 array_push($temp, $productos[$j]);
                 $productos[$j] = null;
             }
         }
         $productos[$i] = null;
         array_push($productos_por_almacen, $temp);
     }
     DAO::transBegin();
     try {
         ConsignacionDAO::save($consignacion);
         $consignacion_producto = new ConsignacionProducto(array("id_consignacion" => $consignacion->getIdConsignacion()));
         foreach ($productos_por_almacen as $producto_por_almacen) {
             //Se validan los parametros obtenidos del arreglo de productos
             foreach ($producto_por_almacen as $producto) {
                 $validar = self::validarConsignacionProducto($producto["id_producto"], $producto["id_unidad"], $producto["cantidad"], $producto["impuesto"], $producto["descuento"], $producto["retencion"], $producto["precio"]);
                 if (is_string($validar)) {
                     throw new Exception($validar);
                 }
                 $validar = self::validarAlmacen($producto["id_almacen"]);
                 if (is_string($validar)) {
                     throw new Eception($validar);
                 }
             }
             /*
              * El consignatario puede contar con algún o ningún almacen de tipo consignacion,
              * pero solo tendra uno por empresa, esto quiere decir que todos los productos recibidos
              * seran repartidos en estos almacenes de acuerdo a la empresa a la que pertenece
              * el almacen de donde son extraidos.
              * 
              * Si el consignatario no cuenta con un almacen para la empresa de ese producto, se creara uno
              * nuevo y se realizara la transferencia.
              */
             //Se obtiene el id de la empresa de la cual vienen los productos
             $id_empresa = AlmacenDAO::getByPK($producto_por_almacen[0]["id_almacen"])->getIdEmpresa();
             //Se busca el almacen de consignacion de este cliente para esta empresa
             $almacen = null;
             $almacenes = AlmacenDAO::search(new Almacen(array("id_empresa" => $id_empresa, "nombre" => $consignatario->getCodigoUsuario(), "id_sucursal" => 0)));
             //Si no existe, se crea
             if (empty($almacenes)) {
                 $almacen = new Almacen(array("id_sucursal" => 0, "id_empresa" => $id_empresa, "id_tipo_almacen" => 2, "nombre" => $consignatario->getCodigoUsuario(), "descripcion" => "Almacen de consignacion del usuario " . $consignatario->getNombre() . " con clave " . $consignatario->getCodigoUsuario() . " para la empresa " . $id_empresa, "activo" => 1));
                 AlmacenDAO::save($almacen);
             } else {
                 $almacen = $almacenes[0];
             }
             //Se prepara el arreglo de productos para crear el traspaso de un almacen a otro
             $productos_para_traspaso = array();
             foreach ($producto_por_almacen as $producto) {
                 $p = array("id_producto" => $producto["id_producto"], "id_unidad" => $producto["id_unidad"], "cantidad" => $producto["cantidad"]);
                 array_push($productos_para_traspaso, $p);
             }
             //Se programa el traspaso del almacen de donde se tomaron estos productos al almacen de consignacion
             SucursalesController::ProgramarTraspasoAlmacen($almacen->getIdAlmacen(), $producto_por_almacen[0]["id_almacen"], $fecha_envio_programada, $productos_para_traspaso);
         }
     } catch (Exception $e) {
         DAO::transRollback();
         Logger::error("No se pudo crear la nueva consignacion: " . $e);
         throw new Exception("No se pudo crear la nueva consignacion");
     }
     DAO::transEnd();
     Logger::log("Consignacion creada exitosamente");
     return array("id_consignacion" => $consignacion->getIdConsignacion());
 }

 /**
  *
  *Crea un nuevo documento.
  *
  * @param id_documento_base int el documento base del cual este documento es instancia
  * @param extra_params json 
  * @param id_empresa int Si pertence a una empresa en especifico, o puede realizarse en cualquier empresa.
  * @param id_sucursal int Si pertenece a una sucursal en especifico o puede realizarse en cualquier sucursal.
  * @return id_documento int Id del nuevo documento
  **/
 public static function Nuevo($id_documento_base, $extra_params = null, $id_empresa = null, $id_sucursal = null)
 {
     $dbase = DocumentoBaseDAO::getByPK($id_documento_base);
     if (is_null($dbase)) {
         throw new InvalidDataException("This base doc does not exist");
     }
     $nDoc = new Documento();
     $nDoc->setIdDocumentoBase($id_documento_base);
     $nDoc->setFolio(0);
     $nDoc->setFecha(time());
     $nDoc->setIdOperacion(0);
     DAO::transBegin();
     try {
         DocumentoDAO::save($nDoc);
     } catch (Exception $e) {
         DAO::transRollback();
         throw InvalidDatabaseOperationException($e);
     }
     //test all extra params in base doc are present in $extra_params
     $pindb = ExtraParamsEstructuraDao::search(new ExtraParamsEstructura(array("tabla" => "documento_base-" . $id_documento_base)));
     foreach ($pindb as $campo) {
         if (!array_key_exists($campo->getCampo(), $extra_params)) {
             //no existe en extra params
             //salir si este parametro es
             //obligatorio
             if ($campo->getObligatorio()) {
                 throw new InvalidDataException("El campo " . $campo->getObligatorio() . " es obligatorio");
             }
         } else {
             $valueToStore = $extra_params->{$campo->getCampo()};
             $valueToStore = is_null($valueToStore) ? "" : $valueToStore;
             $val = new ExtraParamsValores(array("id_extra_params_estructura" => $campo->getIdExtraParamsEstructura(), "id_pk_tabla" => $nDoc->getIdDocumento(), "val" => $valueToStore));
             try {
                 ExtraParamsValoresDAO::save($val);
             } catch (Exception $e) {
                 DAO::transRollback();
                 throw new InvalidDatabaseOperationException($e);
             }
         }
     }
     //foreach
     DAO::transEnd();
 }

 /**
  *
  * Crea una nueva unidad de medida.
  *
  * @param abreviacion string Abreviacion de la unidad.
  * @param descripcion string Nombre de la unidad.
  * @param factor_conversion float Equivalencia de esta unidad con respecto a la unidad de medida base obtenida de la
  *        categoria a la cual pertenece esta unidad. En caso de que se seleccione el valor de tipo_unidad_medida =
  *        "Referencia UdM para esta categoría" este valor sera igual a uno automáticamente sin posibilidad de ingresar
  *        otro valor diferente.
  * @param id_categoria_unidad_medida int Id de la categoria a la cual pertenece la unidad.
  * @param tipo_unidad_medida enum Tipo de unidad cuyo valores son los siguientes: "Referencia UdM para esta categoria"
  *        (define a esta unidad como la unidad base de referencia de esta categoria, en caso de seleccionar esta opción
  *        automticamente el factor de conversion sera igual a uno sin posibilidad de ingresar otro valor diferente), "Mayor
  *        que la UdM de referencia" (indica que esta unidad de medida sera mayor que la unidad de medida base d la
  *        categoria que se indique) y "Menor que la UdM de referencia" (indica que esta unidad de medida sera menor que la
  *        unidad de medida base de la categora que se indique). Cuando se defina una nueva unidad de referencia las demás
  *        unidades de esta categoría se modificarán para establecer los nuevos factores de conversión.
  * @return id_unidad_medida int ID de la unidad de medida recién creada.
  * @throws BusinessLogicException si abreviacion y/o descripcion ya existen en la categoria, si factor_conversion no es
  *         mayor que cero o si tipo_unidad_medida no es valido.
  * @throws InvalidArgumentException si abreviacion y/o descripcion son cadenas vacias.
  * @throws InvalidDatabaseOperationException si la categoria no existe.
  **/
 public static function NuevaUnidadUdm($abreviacion, $descripcion, $factor_conversion, $id_categoria_unidad_medida, $tipo_unidad_medida)
 {
     Logger::log("Creando una nueva unidad de medida");
     $factor_conversion = self::validarParametrosUnidad($abreviacion, $descripcion, $id_categoria_unidad_medida, $tipo_unidad_medida, $factor_conversion);
     $udm = new UnidadMedida(array("abreviacion" => trim($abreviacion), "descripcion" => $descripcion, "factor_conversion" => $factor_conversion, "id_categoria_unidad_medida" => $id_categoria_unidad_medida, "tipo_unidad_medida" => $tipo_unidad_medida, "activa" => 1));
     DAO::transBegin();
     try {
         UnidadMedidaDAO::save($udm);
     } catch (Exception $e) {
         DAO::transRollback();
         Logger::error("No se pudo crear la unidad de medida: " . $e);
         throw new Exception("No se pudo crear la unidad de medida");
     }
     DAO::transEnd();
     Logger::log("Unidad de Medida creada exitosamente");
     return array("id_unidad_medida" => (int) $udm->getIdUnidadMedida());
 }

 /**
  *
  *En algunos servicios, se realiza la venta de productos de manera indirecta, por lo que se tiene que agregar a la orden de servicio.
  *
  * @param id_orden_de_servicio int Id de la orden de servicio a la cual se le agregaran los productos
  * @param productos json Arreglo de objetos con ids de producto, de unidad, sus cantidades, su precio, su impuesto, retencion y descuento.
  **/
 static function ProductosAgregarOrden($id_orden_de_servicio, $productos)
 {
     Logger::log("Agregando productos a la orden de servicio " . $id_orden_de_servicio);
     //Se valida la orden de servicio
     $validar = self::validarParametrosOrdenDeServicio($id_orden_de_servicio);
     if (is_string($validar)) {
         Logger::error($validar);
         throw new Exception($validar, 901);
     }
     //valida que los productos sean validos
     $productos = object_to_array($productos);
     if (!is_array($productos)) {
         throw new Exception("Los productos son invalidos", 901);
     }
     //El precio de la orden de servicio se incrementara por cada precio encontrado en los productos
     $orden_de_servicio = OrdenDeServicioDAO::getByPK($id_orden_de_servicio);
     //Se almacenaran todos los productos obtenidos con us informacion
     $producto_orden_de_servicio = new ProductoOrdenDeServicio(array("id_orden_de_servicio" => $id_orden_de_servicio));
     DAO::transBegin();
     try {
         /*
          * Por cada producto en el arreglo, se busca en la tabla de productos orden,
          * pues puede ser que el usuario haya querido agregar mas producto al que ya habia.
          * 
          * Si no se encuentra en la tabla, simplemente se crea un nuevo registro
          */
         foreach ($productos as $producto) {
             if (!array_key_exists("id_producto", $producto) || !array_key_exists("id_unidad", $producto) || !array_key_exists("cantidad", $producto) || !array_key_exists("precio", $producto) || !array_key_exists("descuento", $producto) || !array_key_exists("impuesto", $producto) || !array_key_exists("retencion", $producto)) {
                 throw new Exception("Los productos no contienen los parametros necesarios", 901);
             }
             $producto_anterior = ProductoOrdenDeServicioDAO::getByPK($id_orden_de_servicio, $producto["id_producto"], $producto["id_unidad"]);
             if (!is_null($producto_anterior)) {
                 $producto_orden_de_servicio = $producto_anterior;
                 $cantidad_anterior = $producto_orden_de_servicio->getCantidad();
                 $producto_orden_de_servicio->setCantidad($cantidad_anterior + $producto["cantidad"]);
             } else {
                 $validar = self::validarParametrosProductoOrdenDeServicio($producto["id_producto"], $producto["precio"], $producto["cantidad"], $producto["descuento"], $producto["impuesto"], $producto["retencion"], $producto["id_unidad"]);
                 if (is_string($validar)) {
                     throw new Exception($validar, 901);
                 }
                 $producto_orden_de_servicio->setCantidad($producto["cantidad"]);
                 $producto_orden_de_servicio->setDescuento($producto["descuento"]);
                 $producto_orden_de_servicio->setIdProducto($producto["id_producto"]);
                 $producto_orden_de_servicio->setIdUnidad($producto["id_unidad"]);
                 $producto_orden_de_servicio->setImpuesto($producto["impuesto"]);
                 $producto_orden_de_servicio->setPrecio($producto["precio"]);
                 $producto_orden_de_servicio->setRetencion($producto["retencion"]);
             }
             //@TODO
             //La linea de codigo siguiente puede causar problemas, pues el precio de un producto puede cmabiar a lo largo del tiempo.
             //Si este metodo fue llamado para agregar mas cantidad a uno ya existente para esta orden en un rango de tiempo
             //donde el precio del producto cambio de la primera vez que fue agregado a esta, el precio registrado en la tabla
             //sera el de la primera vez, pero el producto agregado recientemente ya tiene otro precio.
             //
             //Si este producto es retirado con el metodo Quitar_productoOrden se tiene que pasar el precio que tenia este
             //producto a la hora de agregarlo para que el precio total de la orden de servicio no se vea alterada.
             //
             $orden_de_servicio->setPrecio($orden_de_servicio->getPrecio() + $producto["cantidad"] * $producto["precio"]);
             ProductoOrdenDeServicioDAO::save($producto_orden_de_servicio);
             OrdenDeServicioDAO::save($orden_de_servicio);
         }
     } catch (Exception $e) {
         DAO::transRollback();
         Logger::error("No se pudo agregar el producto a la orden: " . $e);
         if ($e->getCode() == 901) {
             throw new Exception("No se pudo agregar el producto a la orden: " . $e->getMessage(), 901);
         }
         throw new Exception("No se pudo agregar el producto a la orden, consulte al administrador del sistema", 901);
     }
     DAO::transEnd();
     Logger::log("Producto agregado exitosamente");
 }

$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"));
$form->sendHidden("id_direccion");
$form->createComboBoxJoin("id_ciudad", "nombre", CiudadDAO::getAll(), $esta_dir->getIdCiudad());
$form->setCaption("id_ciudad", "Ciudad");
$form->addApiCall("api/personal/usuario/editar/");
$form->beforeSend("editar_direccion");
$page->partialRender();
?>
	

 /**
  *
  *Activa un paquete previamente desactivado
  *
  * @param id_paquete int Id del paquete a activar
  **/
 public static function Activar($id_paquete)
 {
     Logger::log("Activando el paquete " . $id_paquete);
     //valida que el paquete exista y este desactivado
     $paquete = PaqueteDAO::getByPK($id_paquete);
     if (is_null($paquete)) {
         Logger::error("El paquete " . $id_paquete . " esta desactivado");
         throw new Exception("El paquete " . $id_paquete . " esta desactivado");
     }
     if ($paquete->getActivo()) {
         Logger::warn("El paquete " . $id_paquete . " ya esta activo");
         throw new Exception("El paquete " . $id_paquete . " ya esta activo");
     }
     $paquete->setActivo(1);
     DAO::transBegin();
     try {
         PaqueteDAO::save($paquete);
     } catch (Exception $e) {
         DAO::transRollback();
         Logger::error("No se ha podido activar el paquete " . $id_paquete . " : " . $e);
         throw new Exception("No se ha podudo activar el paquete");
     }
     DAO::transEnd();
     Logger::log("El paquete ha sido activado exitosamente");
 }