PHP DAO::transRollback方法代码示例

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

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

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

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

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

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

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

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

 /**
  *
  * Un administrador puede editar una sucursal, incuso si hay puntos de venta con sesiones activas que pertenecen a esa empresa. 
  *
  * @author Juan Manuel Garc&iacute;a Carmona <manuel@caffeina.mx>
  * @param id_empresa int Id de la empresa a modificar
  * @param cuentas_bancarias json Arreglo que contiene los id de las cuentas bancarias
  * @param direccion json {    "tipo": "fiscal",    "calle": "Francisco I Madero",    "numero_exterior": "1009A",    "numero_interior": 12,    "colonia": "centro",    "codigo_postal": "38000",    "telefono1": "4611223312",    "telefono2": "",       "id_ciudad": 3,    "referencia": "El local naranja"}
  * @param direccion_web string Direccion del sitio de la empresa
  * @param email string Correo electronico de la empresa
  * @param id_moneda string Id de la moneda base que manejaran las sucursales
  * @param impuestos_compra json Impuestos de compra por default que se heredan a las sucursales y estas a su vez a los productos
  * @param impuestos_venta json Impuestos de venta por default que se heredan a las sucursales y estas a su vez a los productos
  * @param mensaje_morosos string mensaje enviado a los clientes (email) cuando un pago es demorado
  * @param razon_social string El nombre de la nueva empresa.
  * @param representante_legal string El nombre del representante legal de la nueva empresa.
  * @param rfc string RFC de la empresa
  * @param uri_logo string url del logo de la empresa
  **/
 public static function Editar($id_empresa, $cuentas_bancarias = null, $direccion = null, $direccion_web = null, $email = null, $id_moneda = "0", $impuestos_compra = null, $impuestos_venta = null, $mensaje_morosos = null, $razon_social = null, $representante_legal = null, $rfc = null, $uri_logo = null)
 {
     //se guarda el registro de la empresa y se verifica que este activa
     $empresa = EmpresaDAO::getByPK($id_empresa);
     if (!$empresa->getActivo()) {
         Logger::error("La empresa no esta activa, no se puede editar una empresa desactivada");
         throw new Exception("La empresa no esta activa, no se puede editar una empresa desactivada", 901);
     }
     $empresa->setDireccionWeb($direccion_web);
     //TODO : Por que carajos no esta el campo email!!
     //$empresa->setEmail($email);
     //TODO : No se debe de editar
     //$empresa->setIdMoneda($id_moneda);
     $empresa->setMensajeMorosos($mensaje_morosos);
     $empresa->setRazonSocial($razon_social);
     $empresa->setRepresentanteLegal($representante_legal);
     $empresa->setRfc($rfc);
     //editamos el id del logo
     if (!empty($uri_logo)) {
         //varificamos si cambio el logo
         $_logo = LogoDAO::getByPK($empresa->getIdLogo());
         if ($uri_logo !== $_logo->getImagen()) {
             $logo = new Logo(array("imagen" => $uri_logo, "tipo" => "-"));
             try {
                 LogoDAO::save($logo);
             } catch (Exception $e) {
                 DAO::transRollback();
                 Logger::error("No se pudo crear la empresa, error al crear el logo: " . $e->getMessage());
                 throw new Exception("No se pudo crear la empresa, consulte a su administrador de sistema", 901);
             }
             $id_logo = $logo->getIdLogo();
             $empresa->setIdLogo($id_logo);
         }
     }
     //lógica para manejar la edicion o agregado de una direccion verificamos si se cambiaron las direcciones
     if (!is_null($direccion)) {
         if (!is_array($direccion)) {
             //Logger::error("Verifique el formato de los datos de las direcciones, se esperaba un array ");
             //throw new Exception("Verifique el formato de los datos de las empresas, se esperaba un array ");
             $direccion = object_to_array($direccion);
         }
         $_direccion = new Direccion($direccion);
         $d = DireccionDAO::getByPK($empresa->getIdDireccion());
         //verificamos si se va a editar una direccion o se va a crear una nueva
         if (isset($d->id_direccion)) {
             //se edita la direccion
             if (!($_direccion = DireccionDAO::getByPK($d->id_direccion))) {
                 DAO::transRollback();
                 Logger::error("No se tiene registro de la dirección con id : {$direccion->id_direccion}");
                 throw new InvalidDataException("No se tiene registro de la dirección con id : {$direccion->id_direccion}");
             }
             $_direccion->setIdDireccion($d->id_direccion);
             //bandera que indica si cambia algun parametro de la direccion
             $cambio_direccion = false;
             //calle
             if (isset($d->calle)) {
                 $cambio_direccion = true;
                 $_direccion->setCalle($direccion['calle']);
             }
             //numero_exterior
             if (isset($d->numero_exterior)) {
                 $cambio_direccion = true;
                 $_direccion->setNumeroExterior($direccion['numero_exterior']);
             }
             //numero_interior
             if (isset($d->numero_interior)) {
                 $cambio_direccion = true;
                 $_direccion->setNumeroInterior($direccion['numero_interior']);
             }
             //referencia
             if (isset($d->referencia)) {
                 $cambio_direccion = true;
                 $_direccion->setReferencia($direccion['referencia']);
             }
             //colonia
             if (isset($d->colonia)) {
                 $cambio_direccion = true;
                 $_direccion->setColonia($direccion['colonia']);
             }
             //id_ciudad
             if (isset($d->id_ciudad)) {
//.........这里部分代码省略.........

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

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

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

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

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

 /**
  	 *
  	 *Desactiva una tarifa. Para poder desactivar una tarifa, esta no tiene que estar asignada como default para ningun usuario. La tarifa default del sistema no puede ser eliminada.
 
 La tarifa instalada por default no puede ser eliminada
  	 *
  	 * @param id_tarifa int Id de la tarifa a eliminar
  	 **/
 public static function Desactivar($id_tarifa)
 {
     Logger::log("Desactivando la tarifa " . $id_tarifa);
     //Se valida la tarifa recibida
     $validar = self::ValidarParametrosTarifa($id_tarifa);
     if (is_string($validar)) {
         Logger::error($validar);
         throw new Exception($validar);
     }
     $tarifa = TarifaDAO::getByPK($id_tarifa);
     if ($tarifa->getDefault()) {
         Logger::error("Se quiere eliminar una tarifa por default");
         throw new Exception("Se quiere eliminar una tarifa por default, primero cambie la tarifa default y despues vuelva a intentarlo", 901);
     }
     $tarifa->setActiva(0);
     DAO::transBegin();
     try {
         TarifaDAO::save($tarifa);
     } catch (Exception $e) {
         DAO::transRollback();
         Logger::error("No se pudo eliminar la tarifa: " . $e);
         throw new Exception("No se pudo eliminar la tarifa, intentelo de nuevo mas tarde o consulte al administrado del sistema", 901);
     }
     DAO::transEnd();
     Logger::log("Tarifa desactivada exitosamente");
 }