/**
* @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:"******"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;
}
void StrategyNotificaciones::notificar(Consulta* consulta)
{
stringstream notificacion;
string tipoConsulta = (consulta->tipo() == TipoConsulta::comun) ? "COMUN" : "URGENCIA";
Usuario* medico = consulta->medico();
Usuario* paciente = consulta->paciente();
notificacion << "Paciente diagnosticado: " << paciente->getNombre() << " " << paciente->getApellido() << endl
<< "Médico notificado: " << medico->getNombre() << " " << medico->getApellido() << endl
<< "Tipo de consulta: " << tipoConsulta << endl
<< "Hora de consulta: " << consulta->fechaConsulta() << endl;
_notificaciones.push_back(notificacion.str());
}
/**
* Registra un usuario en el sistema
*
*/
void Servicio::registrarUsuario() {
Usuario* user = this->obtenerUsuario();
if (user->getId() != keyIdUsuarioNoEncontrado) {
//El usuario ya existe. Devuelvo error
Loger::getLoger()->warn(
"Se intento registrar un usuario ya existente. Id: "
+ user->getId());
this->responder("El usuario ya existe", false);
} else {
string nombre = this->getParametro(keyNombre, keyDefault);
string fotoPerfil = this->getParametro(keyFotoDePerfil, keyDefault);
string telefono = this->getParametro(keyTelefono, keyDefault);
string password = this->getParametro(keyPassword, keyDefault);
Usuario* user = new Usuario(nombre, telefono, password);
user->persistir();
this->responder("Usuario registrado correctamente", true);
Loger::getLoger()->info(
"Se registro el usuario con Id: " + user->getId());
delete user;
}
}
Tarjeta::~Tarjeta(){
Usuario* user = const_cast<Usuario*>(titular_);
if(user != 0) user->no_es_titular_de(*this);
}
int menu_principal(Usuario sesion){
/* Menu pricipal según perfil de usuario */
int opcion = 1;
list<Permiso> mis_permisos = sesion.permisos;
list<Permiso>::iterator it;
while (opcion!=0){
it = mis_permisos.begin();
//Mostrando la lista de modulos segun permisos
cout << "+---------------------+"<< endl;
cout << "|---MENU PRINCIPAL----|"<< endl;
cout << "+---------------------+"<< endl;
cout << "|" + pull_left(" 0 SALIR.",21)+ "|"<< endl;
while(it != mis_permisos.end()){
cout << "| " << pull_left(it->codigo + " " + it->descripcion + ".",20) << "|"<< endl;
it++;
}
cout << "+---------------------+"<< endl;
cout << "Seleccionar:";
cin >> opcion;
if (sesion.tiene_permiso(opcion)){
switch(opcion){
case 0 :
salir();
break;
case 1 :
inicio();
break;
case 2 :
pedidos();
break;
case 3 :
pagos();
break;
case 4 :
stock();
break;
case 5 :
finanzas();
break;
case 6 :
cout << "Modulo de mantenimiento" << endl;
mantenimiento(sesion);
break;
case 7 :
miscelaneos();
break;
default:
cout << "Opcion inválida." << endl;
}
}else{
if (opcion!=0){
cout << "Ingrese una opción válida." << endl;
}else{
salir();
}
}
}
return 1;
};
/**
* Devuelve el id de una conversacion a partir de dos telefonos
*
*/
void Servicio::obtenerIdConversacion() {
string telefonoUsuarioEmisor = this->getParametro(keyTelefonoEmisor,
keyDefault);
;
string telefonoUsuarioRecceptor = this->getParametro(keyTelefonoReceptor,
keyDefault);
Usuario* usuarioEmisor = Usuario::obtenerPorTelefono(telefonoUsuarioEmisor);
Usuario* usuarioReceptor = Usuario::obtenerPorTelefono(
telefonoUsuarioRecceptor);
if (usuarioEmisor->getId() != keyIdUsuarioNoEncontrado
&& usuarioReceptor->getId() != keyIdUsuarioNoEncontrado) {
vector<Mensaje*> mensajes;
vector<Usuario*> usuarios;
usuarios.push_back(usuarioEmisor);
usuarios.push_back(usuarioReceptor);
Conversacion *conversacion = Conversacion::obtener(
usuarioEmisor->getId() + "-" + usuarioReceptor->getId());
if (conversacion->getId() == keyIdConversacionNoEncontrada) {
conversacion = Conversacion::obtener(
usuarioReceptor->getId() + "-" + usuarioEmisor->getId());
}
string idConversacion = conversacion->getId();
if (idConversacion != keyIdUsuarioNoEncontrado) {
this->responder(idConversacion, true);
} else {
//Si la conversacion no existe devuelvo como id uno default para estos dos usuarios
Conversacion* conversacion = new Conversacion(usuarios, mensajes);
string idConversacion = conversacion->getId();
this->responder(idConversacion, false);
}
} else {
Usuario* user;
if (usuarioEmisor->getId() == keyIdUsuarioNoEncontrado) {
user = usuarioEmisor;
} else {
user = usuarioReceptor;
}
string msj_warn = "Usuario " + user->getNombre()
+ " no se encuentra registrado en el sistema";
Loger::getLoger()->warn(msj_warn);
this->responder(msj_warn, false);
}
delete usuarioEmisor;
delete usuarioReceptor;
}
void Servicio::obtenerConversaciones() {
Json::Value idsConversacionesValue = this->getParametroArray(
keyIdConversaciones, keyDefault);
vector<string> idsConversaciones = StringUtil::jsonValueToVector(
idsConversacionesValue);
string idUsuario = this->getParametroIdMetodoGET(
urlBaseUsuarioConversaciones);
Usuario* usuario = Usuario::obtenerPorTelefono(idUsuario);
if (usuario->getId() != keyIdUsuarioNoEncontrado) {
vector<string> idsConversacionesActuales =
usuario->obtnerIdsConversaciones();
vector<Conversacion*> nuevasConversaciones;
for (unsigned i = 0; i < idsConversacionesActuales.size(); i++) {
string idActual = idsConversacionesActuales[i];
//Si no esta en las conversaciones que me llegan, quiere decir que es una nueva conversacion.
//Tengo que enviarla al cliente
if (!StringUtil::vectorContiene(idsConversaciones, idActual)) {
Conversacion* nuevaConversacion = Conversacion::obtener(
idActual);
if (nuevaConversacion->getId()
!= keyIdConversacionNoEncontrada) {
nuevasConversaciones.push_back(nuevaConversacion);
} else {
Loger::getLoger()->warn(
"La conversacion " + idActual
+ " no se encuentra en el sistema");
}
}
}
Json::Value respuesta;
for (unsigned i = 0; i < nuevasConversaciones.size(); i++) {
Conversacion* conv = nuevasConversaciones[i];
vector<Mensaje*> mens = conv->getMensajes();
Mensaje* ultimoMensj = mens[mens.size() - 1];
Usuario* usuarioContacto = conv->getUsuarios().at(0);
if (usuarioContacto->getId() == usuario->getId()) {
usuarioContacto = conv->getUsuarios().at(1);
}
respuesta["conversaciones"][i]["id"] = conv->getId();
respuesta["conversaciones"][i]["ultimoMensaje"] =
ultimoMensj->getCuerpo();
respuesta["conversaciones"][i]["usuarioNombre"] =
usuarioContacto->getNombre();
respuesta["conversaciones"][i]["usuarioTelefono"] =
usuarioContacto->getTelefono();
respuesta["conversaciones"][i]["usuarioFotoDePerfil"] =
usuarioContacto->getFotoDePerfil();
}
this->responder(respuesta.toStyledString(), true);
} else {
Loger::getLoger()->warn(
"El usuario " + idUsuario + " no se encuentra en el sistema");
}
}
/*
* Agrega el mensaje que envió el cliente a la conversacion correspondiente y luego la almacena en
* la Base de Datos.
*
*/
void Servicio::almacenarListaDifusion() {
string idEmisor = this->getParametro(keyIdUsuarioEmisor, keyDefault);
string token = this->getParametro(keyTokenSesion, keyDefault);
Json::Value contactosTelefonoValue = this->getParametroArray(
keyContantosTelefono, keyDefault);
vector<string> contactosTelefono = StringUtil::jsonValueToVector(
contactosTelefonoValue);
//chequeo que los usuarios existan:
Usuario *emisor = Usuario::obtenerPorTelefono(idEmisor);
if (emisor->getId() == keyIdUsuarioNoEncontrado) {
string msj_warning =
"No se pudo almacenar la lista de difusion porque el emisor no existe";
this->responder(msj_warning, false);
Loger::getLoger()->warn(msj_warning);
Loger::getLoger()->guardarEstado();
} else if (emisor->getToken() != token) {
Loger::getLoger()->warn(
"El usuario " + emisor->getNombre()
+ " no posee un token de session correcto");
this->responder(
"El usuario " + emisor->getNombre()
+ " no posee un token de session correcto", false);
} else {
//Obtengo el mensaje:
string cuerpo = this->getParametro(keyCuerpo, keyDefault);
string fecha = this->getParametro(keyFecha, keyDefault);
Mensaje* mensaje = new Mensaje(cuerpo, emisor->getId(), fecha);
//Recorro los contactos del telefono para verificar cuales estan registrados y conectados
for (unsigned i = 0; i < contactosTelefono.size(); i++) {
string telefonoActual = contactosTelefono[i];
Usuario* usuario = Usuario::obtenerPorTelefono(telefonoActual);
//Envío mensaje a los usuarios que estan registrados y que se encuentran conectados
if (usuario->getId() != keyIdUsuarioNoEncontrado
&& usuario->getEstadoConexion()) {
//almaceno la conversacion (si no existe la creo):
Conversacion *conversacion = Conversacion::obtener(
emisor->getId() + "-" + usuario->getId());
if (conversacion->getId() != keyIdConversacionNoEncontrada) {
conversacion->agregarMensaje(mensaje);
conversacion->persistir();
delete conversacion;
} else {
Conversacion *conversacion = Conversacion::obtener(
usuario->getId() + "-" + emisor->getId());
if (conversacion->getId()
!= keyIdConversacionNoEncontrada) {
conversacion->agregarMensaje(mensaje);
conversacion->persistir();
delete conversacion;
} else {
vector<Usuario*> usuarios;
usuarios.push_back(emisor);
usuarios.push_back(usuario);
vector<Mensaje*> mensajes;
mensajes.push_back(mensaje);
Conversacion *nuevaConversacion = new Conversacion(
usuarios, mensajes);
nuevaConversacion->persistir();
delete nuevaConversacion;
}
}
}
}
this->responder("Lista de difusion enviada correctamente", true);
delete mensaje;
}
}
/**
* Se encarga de actualizar los datos del usuario que recibe, en la
* base de datos.
*/
void Servicio::administrarPerfil() {
string nombreUsuario = this->getParametro(keyNombre, keyDefault);
string estadoDeConexion = this->getParametro(keyEstadoDeConexion,
keyDefault);
string fotoDePerfil = this->getParametro(keyFotoDePerfil, keyDefault);
bool estado = StringUtil::toBoolean(estadoDeConexion);
string localizacion = this->getParametro(keyLocalizacion, keyDefault);
string password = this->getParametro(keyPassword, keyDefault);
Usuario* user = this->obtenerUsuario();
string token = this->getParametro(keyTokenSesion, keyDefault);
if (user->getId() != keyIdUsuarioNoEncontrado) {
if (user->getToken() == token) {
user->setNombre(nombreUsuario);
user->setEstadoConexion(estado);
user->setFotoDePerfil(fotoDePerfil);
user->setLocalizacion(localizacion);
user->setPassword(password);
user->persistir();
Loger::getLoger()->info(
"Se modificaron los datos del usuario " + user->getNombre()
+ " correctamente.");
this->responder(
"Se modificaron los datos del usuario " + user->getNombre()
+ " correctamente. Token:" + user->getToken(),
true);
} else {
Loger::getLoger()->warn(
"El usuario " + user->getNombre()
+ " no posee un token de session correcto");
this->responder(
"El usuario " + user->getNombre()
+ " no posee un token de session correcto", false);
}
} else {
Loger::getLoger()->warn(
"El usuario " + user->getNombre()
+ " no se encuentra registrado en el sistema");
this->responder(
"El usuario " + user->getNombre()
+ " no se encuentra registrado en el sistema", false);
}
Loger::getLoger()->guardarEstado();
delete user;
}
/*
* Agrega el mensaje que envió el cliente a la conversacion correspondiente y luego la almacena en
* la Base de Datos.
*
*/
void Servicio::almacenarConversacion() {
string idEmisor = this->getParametro(keyIdUsuarioEmisor, keyDefault);
string idReceptor = this->getParametro(keyIdUsuarioReceptor, keyDefault);
//chequeo que los usuarios existan:
Usuario *emisor = Usuario::obtenerPorTelefono(idEmisor);
Usuario *receptor = Usuario::obtenerPorTelefono(idReceptor);
string token = this->getParametro(keyTokenSesion, keyDefault);
if (emisor->getId() == keyIdUsuarioNoEncontrado
|| receptor->getId() == keyIdUsuarioNoEncontrado) {
string msj_warning = "No se pudo almacenar la conversacion porque: ";
if (emisor->getId() == keyIdUsuarioNoEncontrado)
msj_warning.append("el emisor no existe.");
if (receptor->getId() == keyIdUsuarioNoEncontrado)
msj_warning.append(" el receptor no existe.");
this->responder(msj_warning, false);
Loger::getLoger()->warn(msj_warning);
Loger::getLoger()->guardarEstado();
} else {
if (emisor->getToken() == token) {
//Obtengo el mensaje:
string cuerpo = this->getParametro(keyCuerpo, keyDefault);
string fecha = this->getParametro(keyFecha, keyDefault);
Mensaje* mensaje = new Mensaje(cuerpo, emisor->getId(), fecha);
//almaceno la conversacion (si no existe la creo):
Conversacion *conversacion = Conversacion::obtener(
emisor->getId() + "-" + receptor->getId());
if (conversacion->getId() != keyIdConversacionNoEncontrada) {
conversacion->agregarMensaje(mensaje);
conversacion->persistir();
delete conversacion;
} else {
Conversacion *conversacion = Conversacion::obtener(
receptor->getId() + "-" + emisor->getId());
if (conversacion->getId() != keyIdConversacionNoEncontrada) {
conversacion->agregarMensaje(mensaje);
conversacion->persistir();
delete conversacion;
} else {
vector<Usuario*> usuarios;
usuarios.push_back(emisor);
usuarios.push_back(receptor);
vector<Mensaje*> mensajes;
mensajes.push_back(mensaje);
Conversacion *nuevaConversacion = new Conversacion(usuarios,
mensajes);
nuevaConversacion->persistir();
delete nuevaConversacion;
}
}
this->responder(mensaje->getId(), true);
delete mensaje;
} else {
string msj = "El usuario " + emisor->getNombre()
+ " no posee un token de session correcto";
Loger::getLoger()->warn(msj);
this->responder(msj, false);
}
}
}
void Moderador::editarPonto(Logradouro &L,vector<Pessoa *> &usuarios){
int opcao,ncomentario;
float area;
string descricao,cep,rua,referencia,nomelocal;
Comentario comentantigo,comentnovo;
Usuario *ptrU;
cout<<"Informacoes do local a ser editado: "<<endl;
getch();
cout<<L;
getch();
do{
cout<<"Escolha um dado para editar: "<<endl;
getch();
cout<<"1. Nome: "<<endl;
cout<<"2. Area: "<<endl;
cout<<"3. Descricao: "<<endl;
cout<<"4. Comentarios: "<<endl;
cout<<"5. CEP: "<<endl;
cout<<"6. Rua: "<<endl;
cout<<"7. Referencia"<<endl;
cout<<"8. Voltar: "<<endl;
cin >> opcao;
switch(opcao){
case 1:
do{
cout<<"Digite o novo nome do local: "<<endl;
cin >> nomelocal;
nomelocal = Logradouro::validaNome(nomelocal);
if (nomelocal == "Padrao"){
cout<<"Nome digitado e' invalido!"<<endl;
getch();
}
}while(nomelocal == "Padrao");
cout<<"Nome modificado de '"<<L.getNome()<<"' para '"<<nomelocal<<"'. "<<endl;
L.setNome(nomelocal);
getch();
break;
case 2:
do{
cout<<"Digite a nova area em km²(digite -1 caso nao saiba o valor correto): "<<endl;
cin >> area;
if (area == 0 || area < -1){
cout<<"Valor invalido!"<<endl;
getch();
}
}while(area == 0 || area < -1);
cout<<"Area modificada de '"<<L.getArea()<<"' km² para '"<<area<<"' km². "<<endl;
getch();
L.setArea(area);
break;
case 3:
cout<<"Digite a nova descricao para o Local "<<L.getNome()<<": "<<endl;
cin.sync();
getline(cin,descricao);
cout<<"Descricao antiga: "<<endl;
cout<<" - "<<L.getDescricao()<<"."<<endl;
getch();
cout<<"Descricao nova: "<<endl;
cout<<" - "<<descricao<<"."<<endl;
getch();
L.setDescricao(descricao);
break;
case 4:
if (L.getNComentarios() > 0){
L.mostrarComentarios();
do{
cout<<"Digite o numero do comentario que deseja editar: "<<endl;
cin >> ncomentario;
if (ncomentario < 1 || ncomentario > L.getNComentarios()){
cout<<"Opcao invalida!"<<endl;
getch();
}
}while(ncomentario < 1 || ncomentario > L.getNComentarios());
//modifica o comentario dentro do objeto B do tipo Bairro
comentantigo = L.getComentario(ncomentario);
comentnovo = comentantigo;
this->editarComentario(comentnovo);
L.setComentario(ncomentario,comentnovo);
for (unsigned int i = 0;i < usuarios.size();i++){ //atualiza com o texto novo os comentários de todos os usuários
ptrU = dynamic_cast<Usuario *>(usuarios[i]);
if(ptrU && ptrU->getUsername() == comentantigo.getNomeUsuario())
this->editarComentario(*ptrU,comentantigo.getTexto(),comentnovo.getTexto());
}
}
else{
cout<<"O local nao tem nenhum comentario!"<<endl;
getch();
}
break;
case 5:
do{
cout<<"Digite o novo CEP: "<<endl;
cin >> cep;
cep = Logradouro::validaCEP(cep);
if (cep == "00000000000")
cout<<"CEP invalido!"<<endl;
}while(cep == "00000000000");
cout<<"CEP modificado de '"<<L.getCEP()<<"' para '"<<cep<<"'. "<<endl;
getch();
L.setCEP(cep);
break;
case 6:
cout<<"Digite o novo nome da rua do local '"<<L.getNome()<<"'. "<<endl;
cin.sync();
getline(cin,rua);
cout<<"Rua modificada de '"<<L.getRua()<<"' para '"<<rua<<"'. "<<endl;
getch();
L.setRua(rua);
break;
case 7:
cout<<"Digite a nova referencia do local '"<<L.getNome()<<"'. "<<endl;
cin.sync();
getline(cin,referencia);
cout<<"Referencia modificada de '"<<L.getReferencia()<<"' para '"<<referencia<<"'. "<<endl;
getch();
L.setReferencia(referencia);
break;
case 8:
break;
default:
cout<<"Opcao invalida!"<<endl;
getch();
break;
}
/**
* Devuelve los datos correspondientes al usuario con telefono igual al
* recibido.
*/
void Servicio::consultarUsuarioOnline() {
string telefono = this->getParametroIdMetodoGET(urlBaseUsuario);
Usuario* user = Usuario::obtenerPorTelefono(telefono);
string renovarToken = this->getParametro(keyRenovarToken, keyDefault);
bool renovar = StringUtil::toBoolean(renovarToken);
if (user->getId() != keyIdUsuarioNoEncontrado) {
user->registrarUltimaConexion();
Json::Value respuesta;
respuesta[keyNombre] = user->getNombre();
respuesta[keyPassword] = user->getPassword();
if(renovar){
respuesta[keyTokenSesion] = user->calcularTokenDeSesion();
}else{
respuesta[keyTokenSesion] = user->getToken();
}
respuesta[keyEstadoDeConexion] = StringUtil::toString(
user->getEstadoConexion());
respuesta[keyFotoDePerfil] = user->getFotoDePerfil();
respuesta["idUsuario"] = user->getId();
respuesta[keyLocalizacion] = user->getLocalizacion();
user->persistir();
this->responder(respuesta.toStyledString(), true);
Loger::getLoger()->info(
"Consulta del usuario " + user->getNombre() + " exitosa.");
} else {
string msj = "No se pudo obtener el estado del usuario con numero: "
+ this->getParametro(keyTelefono, keyDefault)
+ " ya que no se encuentra registrado en el sistema.";
Loger::getLoger()->warn(msj);
this->responder(msj, false);
}
Loger::getLoger()->guardarEstado();
delete user;
}
void Pedido::vaciar_carrito(Usuario& u) {
for(auto& i: u.compra())
u.compra (*(i.first), 0);
}
void ComandosUsuario::altaReactivacionUsuario()
{
IControladorUsuario* cUsuario = FabricaControladores::instancia()->controladorUsuario()->instancia();
bool exito;
Usuario* newUser;
do
{
exito = true;
string ci;
cout << "Ingrese la Cedula de Identidad del Usuario (o presione q para salir): " << endl;
cin >> ci;
if (ci=="q")
return;
if (cUsuario->findUsuario(ci) != NULL)
{
cout << "El usuario ya existe en el sistema. " << endl;
Usuario* usuario = cUsuario->findUsuario(ci);
cout << "Nombre: " << usuario->getNombre() << endl;
cout << "Apellido: " << usuario->getApellido() << endl;
if (usuario->getGenero() == Genero::femenino)
cout << "Sexo: Femenino" << endl;
else
{
if (usuario->getGenero() == Genero::indeterminado)
cout << "Sexo: Indeterminado" << endl;
else
cout << "Sexo: Masculino" << endl;
}
cout << "Edad: " << usuario->edad() << endl;
vector<Rol> roles;
for (vector<Rol>::iterator it = usuario->roles().begin(); it != usuario->roles().end(); ++it)
{
Rol rol = *it;
if (rol == Rol::admin)
cout << "Rol: Admin" << endl;
if (rol == Rol::medico)
cout << "Rol: Medico" << endl;
if (rol == Rol::socio)
cout << "Rol: Socio" << endl;
if (rol == Rol::master)
cout << "Rol: Master" << endl;
}
if (usuario->estaActivo())
cout << "Estado: Activo" << endl;
// roles.insert(roles.begin(), rol);
else
{
cout << "Estado: Inactivo" << endl;
cout << "¿Desea reactivar el usuario? (y/n)?" << endl;
string reactivar;
cin >> reactivar;
if (reactivar=="y")
{
usuario->activar();
cout << "El usuario ha sido reactivado." << endl;
}
}
}
else
{
string nombre;
string apellido;
Fecha fechaNac;
string gen;
string r1, r2;
Genero genero;
Roles roles {};
cout << "Ingrese el nombre del Usuario: " << endl;
cin >> nombre;
cout << "Ingrese el apellido del Usuario: " << endl;
cin >> apellido;
cout << "Ingrese el sexo (M/f): " << endl;
cin >> gen;
if (gen=="f")
genero = Genero::femenino;
else
genero = Genero::masculino;
int dia, mes, anyo;
cout << "Ingrese el dia del nacimiento: " << endl;
cin >> dia;
cout << "Ingrese el mes del nacimiento: " << endl;
cin >> mes;
cout << "Ingrese el anyo del nacimiento: " << endl;
cin >> anyo;
fechaNac = Fecha(dia, mes, anyo);
cout << "Ingrese el primer rol [a(dmin), m(edico), s(ocio)]: " << endl;
cin >> r1;
cout << "Ingrese el segundo rol (n para omitir): " << endl;
cin >> r2;
if (r1 == "a")
{
roles.push_back(Rol::admin);
}
else if (r1 == "m")
{
roles.push_back(Rol::medico);
}
else // socio por defecto
{
roles.push_back(Rol::socio);
}
if (r2 == "a")
{
if (r1 == "m")
{
cout << "Error, el usuario no puede ser medico y administrativo a la vez." << endl;
exito = false;
}
else
roles.push_back(Rol::admin);
}
else if (r2 == "m")
{ if (r1 == "a")
{
cout << "Error, el usuario no puede ser medico y administrativo a la vez." << endl;
exito = false;
}
else
roles.push_back(Rol::medico);
}
else if (r2 != "n") // socio por defecto
{
roles.push_back(Rol::socio);
}
if (exito)
{
newUser = cUsuario->altaUsuario(ci, nombre, apellido, genero, fechaNac, roles);
cout << "El usuario fue dado de alta con exito." << endl;
}
else
cout << "Ocurrió un error imprevisto." << endl;
}
}