C++ Usuario类代码示例

/**
 * @param email
 * @param password
 * @return Usuario
 */
Usuario* GestorUsuarios::login(QString email, QByteArray password) {
    QString error="";
    //Obtengo el usuario con ese correo si no existe retorno NULL
    Usuario *user = gestorDB->cargarUsuario(email);
    if(user==NULL){
        return NULL;
    }

    //Comparo las contraseñas

    if(password!=user->getPassword())
        return NULL;
    else{
     //Registro el inicio de sesión
        Auditoria* aud=new Auditoria();
        aud->setFecha(QDateTime::currentDateTime().toString(Qt::ISODate));
        aud->setPc(QHostInfo::localHostName());
        QVector<Auditoria*> auditorias=user->getAuditorias();
        auditorias.push_back(aud);
        user->setAuditorias(auditorias);
        //Guardo para que quede registrado el nuevo inicio de sesión
        gestorDB->saveUsuario(user);
        this->setActual(user);
        //retorno el usuario cargado
        return user;
    }
}

//Definición de los métodos de la clase Pedido
Pedido::Pedido (Usuario_Pedido& up, Pedido_Articulo& pa, Usuario& u, const Tarjeta& t, const Fecha& f) : num_(N_pedidos + 1), tarjeta_(&t), fecha_(f), total_(0) {
    if (t.caducidad() < f) throw Tarjeta::Caducada(t.caducidad());
    if (&u != t.titular()) throw Pedido::Impostor(u);
    Fecha actual = Fecha();
    for(auto& i : u.compra()) {
        if (LibroDigital* ld = dynamic_cast<LibroDigital*> (i.first)) {
            if (ld->f_expir() < actual)
                u.compra(*ld, 0);
        }
        else {
            ArticuloAlmacenable* pa = dynamic_cast<ArticuloAlmacenable*> (i.first);
            if (i.second > pa->stock()){
                Articulo& aux = *(i.first);
                vaciar_carrito(u);
                throw Pedido::SinStock(aux);
            }
        }
    }
    if (u.n_articulos() == 0) throw Pedido::Vacio(u);
    for(auto& i : u.compra()) {
        if (ArticuloAlmacenable* aa = dynamic_cast<ArticuloAlmacenable*> (i.first)){
            aa->stock() = aa->stock() - 1;
        }
        pa.pedir (*this, *(i.first), (i.first)->precio(), i.second);
        total_ += (i.first)->precio() * i.second;
        u.compra (*(i.first), 0);
    }
    up.asocia(u, *this);
    N_pedidos++;
}

Tarjeta::~Tarjeta()
{
        if(titular_ !=  nullptr)
        {
                Usuario* usaux = const_cast<Usuario*>(titular_);
                usaux->no_es_titular_de(*this);
        }
}

Tarjeta::Tarjeta(Numero n, Usuario& us, Fecha fecha) : num(n), titular_(&us){
  titular_facial_ = us.nombre();
  titular_facial_ += " ";
  titular_facial_ += us.apellidos();
  
  Fecha actual;
  if(actual > fecha) throw Tarjeta::Caducada(fecha);
  caducidad_ = fecha;
  
  us.es_titular_de(*this);
}

/// GET: /usuario
RequestResult Request_GET_Usuario(Database* db, const std::string& uriparams, const std::string& qparams, const std::string& body) {
	RequestResult ret;
	auto qdict = parseQueryParams(qparams);
	Usuario usr;
	if(qdict.size() < 2 || !db->validateSession(qdict["r_user"], qdict["token"]) || !db->loadUsuario(uriparams, usr)) {
		ret.code = 401;
		ret.data = "{\"error\": \"token invalido\" }";
	}else{
		ret.data = usr.asJson();
	}
	return ret;
}

void TestConversacion::testSerializacionDeDatosUnaConversacion() {
	Usuario* user = new Usuario("Pepe", "foto", "1568017070");
	Usuario* user2 = new Usuario("Jose", "foto2", "156801515");

	BaseDeDatos* db = BaseDeDatos::getInstance();
	db->setUsuario(user);
	db->setUsuario(user2);

	vector<Usuario*> usuarios;
	usuarios.push_back(user);
	usuarios.push_back(user2);

	vector<Mensaje*> mensajes;
	mensajes.push_back(new Mensaje("cuerpo mensaje 1", "asdasd", "fecha1"));
	mensajes.push_back(new Mensaje("cuerpo mensaje 2", "asdasd2", "fecha2"));

	Conversacion* conversacion = new Conversacion(usuarios, mensajes);
	string conversacionSerializada = conversacion->serializar();

	Conversacion* conv2 = new Conversacion(conversacionSerializada);
	vector<Mensaje*> mensajesDeserealizados = conv2->getMensajes();

	vector<Usuario*> usuariosDeserealizados = conv2->getUsuarios();

	CPPUNIT_ASSERT(
			mensajes[0]->getCuerpo() == mensajesDeserealizados[0]->getCuerpo());
	CPPUNIT_ASSERT(
			mensajes[1]->getCuerpo() == mensajesDeserealizados[1]->getCuerpo());
	CPPUNIT_ASSERT(
			mensajes[0]->getIdUsuarioEmisor()
					== mensajesDeserealizados[0]->getIdUsuarioEmisor());
	CPPUNIT_ASSERT(
			mensajes[1]->getIdUsuarioEmisor()
					== mensajesDeserealizados[1]->getIdUsuarioEmisor());
	CPPUNIT_ASSERT(
			mensajes[0]->getFecha() == mensajesDeserealizados[0]->getFecha());
	CPPUNIT_ASSERT(
			mensajes[1]->getFecha() == mensajesDeserealizados[1]->getFecha());

	CPPUNIT_ASSERT(user->getNombre() == usuariosDeserealizados[0]->getNombre());
	CPPUNIT_ASSERT(user->getId() == usuariosDeserealizados[0]->getId());

	CPPUNIT_ASSERT(
			user2->getNombre() == usuariosDeserealizados[1]->getNombre());
	CPPUNIT_ASSERT(user2->getId() == usuariosDeserealizados[1]->getId());

	delete user;
	delete user2;
	delete conversacion;
	delete conv2;

}

void imprimir_opciones(Usuario sesion){
	ifstream in("db/perfiles.db");
	 string s,reg;
	 int contador;
	 list<Usuario> usuarios;
	 // Cargamos los usuarios guardados
	 contador = 0;
	 while (getline(in,reg)){	
		Usuario u;
		u.decodificar(reg);
		usuarios.push_back(u);
		contador = contador + 1;
	 }
};

/* Metodos para mantenimiento */
void listar_usuarios(){
	string registro;
	ifstream in("db/usuarios.db");
	cout << "+----------+--------------------+" << endl;
	cout << "| CODIGO   | NOMBRE COMPLETO    |" << endl;
	cout << "+----------+--------------------+" << endl;
	while (getline(in,registro)){	
		Usuario u;
		u.decodificar(registro);
		u.iniciar();
		u.to_string();
	}
	cout << "+----------+--------------------+" << endl;
};

Tarjeta::Tarjeta(Tarjeta::Tipo t, const Numero& num, Usuario& u,const Fecha& f)
:tipo_{t}, num_{num}, titular_{&u}, f_cad_{f}
{

        if(caducidad() < Fecha())
                throw Tarjeta::Caducada(caducidad());
        else
        {
                titular_facial_= u.nombre() +" "+u.apellidos();

                for(int i = 0; i<titular_facial_.length(); i++)
                        titular_facial_[i]= std::toupper(titular_facial_[i]);

                u.es_titular_de(*this);
        }
}

/**
 * Se encarga de calcular en que lugar se encuentra el cliente
 * en base a sus coordenadas geográficas y los lugares precargados.
 *
 */
void Servicio::checkIn() {
	Json::Value coordenadas;
	string latitud = this->getParametro(keyLatitud, keyDefault);
	string longitud = this->getParametro(keyLongitud, keyDefault);
	coordenadas["latitud"] = atof(latitud.c_str());
	coordenadas["longitud"] = atof(longitud.c_str());

	Usuario* usuario = this->obtenerUsuario();
	if (usuario->getId() != keyIdUsuarioNoEncontrado) {
		string localizacion = Localizacion::calcularUbicacion(coordenadas)+" "+fechaYhoraActual();
		usuario->setLocalizacion(localizacion);
		usuario->persistir();
		this->responder(localizacion, true);
	} else {
		this->responder("el usuario no existe.", false);
	}
}

/**
 * Obtiene los contactos que se encuentran registrados en el sistemas y estan conectados,
 * a partir de numeros de telefono que recibe
 *
 */
void Servicio::obtenerContactos() {
	Json::Value contactosTelefonoValue = this->getParametroArray(
	keyContantosTelefono, keyDefault);
	vector<string> contactosTelefono = StringUtil::jsonValueToVector(
			contactosTelefonoValue);

	Json::Value respuesta;
	int counter = 0;
	for (unsigned i = 0; i < contactosTelefono.size(); i++) {
		string telefonoActual = contactosTelefono[i];
		Usuario* usuario = Usuario::obtenerPorTelefono(telefonoActual);

		//Agrego los usuarios que estan registrados y que se encuentran conectados

		if (usuario->getId() != keyIdUsuarioNoEncontrado
				&& usuario->getEstadoConexion()) {
			respuesta["contactos"][counter][keyNombre] = usuario->getNombre();
			respuesta["contactos"][counter][keyTelefono] =
					usuario->getTelefono();
			respuesta["contactos"][counter][keyFotoDePerfil] =
					usuario->getFotoDePerfil();
			respuesta["contactos"][counter][keyLocalizacion] = usuario->getLocalizacion();
			counter++;
		}
	}

	this->responder(respuesta.toStyledString(), true);
}

/// POST: /usuario
RequestResult Request_POST_Usuario(Database* db, const std::string& uriparams, const std::string& qparams, const std::string& body) {
	RequestResult ret;
	Usuario user;
	// Parseamos el JSON para cargar los datos posteados
	auto js = JSONParse(body);
	user.load(js);
	// Cargamos el usuario del uri
	user.id = uriparams;
	std::string err_str;
	if(db->createUsuario(user, err_str)) {
		ret.code = 201;
	}else{
		log.msg(LOG_TYPE::INFO, std::string("Error creando usuario `") + user.id + "`");
		ret.code = 401;
                ret.data = std::string("{ \"error\": \"") + err_str + "\" }";
	}
	return ret;
}

/// PUT: /usuario
RequestResult Request_PUT_Usuario(Database* db, const std::string& uriparams, const std::string& qparams, const std::string& body) {
	RequestResult ret;
	auto qdict = parseQueryParams(qparams);
	Usuario usr;
	// Debe pasar la clave tambien
	if(qdict.size() < 2 || !db->validateSession(qdict["r_user"], qdict["token"])) {
		ret.code = 401;
		ret.data = "{\"error\": \"token invalido\" }";
		return ret;
	}
	if(uriparams != qdict["r_user"]) {
		ret.code = 401;
		ret.data = "{\"error\": \"permiso denegado\" }";
		return ret;
	}
	if(!db->loadUsuario(uriparams, usr)) {
		ret.code = 500;
		ret.data = "{\"error\": \"error cargando usuario\" }";
		return ret;
	}
	if(qdict["password"] != usr.password) {
		ret.code = 401;
		ret.data = "{\"error\": \"password invalido\" }";
		return ret;
	}
	// Editamos los valores que nos pasaron (si los pasaron)
	auto js = JSONParse(body);
	usr.load(js);
	// Guardamos el usuario
	if(!db->saveUsuario(usr)) {
		// TODO: desdoblar en los distintos
		ret.code = 401;
		ret.data = "{ \"error\": \"atributos invalidos\" }";
	}else{
		ret.code = 201;
	}
	return ret;
}

// Metodo que retorna el usuario de sesion
Usuario login(list<Usuario> usuarios){
	/* Metodo que genera sesion de usuario correctamente logueado */
  list<Usuario>::iterator it;
  string user;
  string pass;
  int ok = 0;
  Usuario sesion; 
  // comparar hasta encontrar igualdades y cambiar ok a 1
  while (ok == 0){
  cout << "Ingrese su usuario:";
  cin >> user;
  cout << "Ingrese su password:";
  cin >> pass;
	it = usuarios.begin();
	// Hasta recorrer todos los emementos
	while(it != usuarios.end()){ 
		if (user.compare(it->username) == 0) {
			// Reiniciamos en iterador
			it = usuarios.begin();
			// Comparamos los passwords
			while(it != usuarios.end()){
				if (pass.compare(it->password) == 0){
					// Valores correctos
					ok = 1;
  					sesion.decodificar(it->text_encoded);
  					cout << "Bienvenido " << sesion.full_name << endl;	
					break;
				}
				it++;
			}
			break;
		}
		it++;
	}
  }
  return sesion;
};

int main(){
	/* Metodo principal */
	list<Usuario> usuarios;
	Usuario sesion;
	string s,reg;
	int contador;
	// Cargamos los usuarios guardados
	//contador = 0;
	ifstream in("db/usuarios.db");
	while (getline(in,reg)){	
		Usuario u;
		u.decodificar(reg);
		usuarios.push_back(u);
	}
	// Usando comandos unix
	system("clear"); // linux
	system("cls"); // linux
	imprimir_logo();
	pausa();
	sesion = login(usuarios); 
	sesion.iniciar();
	menu_principal(sesion);
	return 0;
}