void Servidor::modificarRegistro() {
Protocolo protocolo;
string resp;
/* Insertar en la base de datos */
Registro existReg(peticionRecibida.nombreCons, (char*) "", (char*) "");
Registro nuevoReg;
nuevoReg.crearDesdeMensaje(peticionRecibida);
int result = this->bd.modificar(existReg, nuevoReg);
/* Generar mensaje de respuesta */
if (result == SUCCESS){
resp = "El registro ha sido modificado con éxito con la siguiente información nueva.";
resp += (!nuevoReg.getNombre().empty()) ? "\nNombre: de " + existReg.getNombre() + " a " + nuevoReg.getNombre() : "";
resp += (!nuevoReg.getDireccion().empty()) ? "\nDirección: de " + existReg.getDireccion() + " a " + nuevoReg.getDireccion() : "";
resp += (!nuevoReg.getTelefono().empty()) ? "\nTeléfono: de " + existReg.getTelefono() + " a " + nuevoReg.getTelefono() : "";
resp += "\n";
} else if (result == ERR_NO_EXISTE){
resp = "El registro a modificar no existe. ";
} else if (result == ERR_DUPLICADO){
resp = "El registro no se ha modificado con éxito pues está en conflicto con otro existente.";
}
/* Generar respuesta */
mensaje respuesta;
respuesta.ttl = 1;
respuesta.mtype = RESPUESTA;
respuesta.pid = getpid();
strcpy(respuesta.textoRespuesta, resp.c_str());
this->respuestas.push_back(respuesta);
}
void Servidor::insertarRegistro() {
Protocolo protocolo;
string resp;
/* Insertar en la base de datos */
Registro reg;
reg.crearDesdeMensaje(peticionRecibida);
int result = this->bd.insertar(reg);
if (result == SUCCESS){
resp = "El registro ha sido insertado con éxito con la siguiente información.";
resp += "\nNombre: " + reg.getNombre();
resp += "\nDirección: " + reg.getDireccion();
resp += "\nTeléfono: " + reg.getTelefono();
resp += "\n";
} else if (result == ERR_DUPLICADO){
resp = "El registro no se ha insertado con éxito pues está duplicado";
} else if (result == ERR_CAMPO_REQUERIDO){
resp = "El registro no se ha insertado con éxito pues faltan datos requeridos.";
}
/* Generar respuesta */
mensaje respuesta;
respuesta.ttl = 1;
respuesta.mtype = RESPUESTA;
respuesta.pid = getpid();
strcpy(respuesta.textoRespuesta, resp.c_str());
this->respuestas.push_back(respuesta);
}
void TestParserDeLibros::testObtenerPalabrasConTodosLosDatos(){
string strLibro = generarMockLibroCompleto();
const char *auxlibro= strLibro.c_str();
char* libro;
libro = const_cast<char*>(auxlibro);
Registro* regLibro = this->parser->obtenerRegistroDeLibro((libro) );
list<string> palabrasPatron;
generarListaPatron(palabrasPatron);
list<string> palabras = regLibro->getPalabras();
bool diferencia = false;
list<string>::iterator it1 = palabrasPatron.begin();
list<string>::iterator it2 = palabras.begin();
string palabra, palabraPatron;
while (( it1 != palabrasPatron.end()) && !(diferencia)){
while (it2 != palabras.end()){
palabraPatron = (*it1);
palabra = (*it2);
it1++; it2++;
if (palabra.compare(palabraPatron)){
diferencia = true;
}
}
}
CPPUNIT_ASSERT_MESSAGE("La lista de palabras no es correcta", diferencia == false );
}
int Servicios::recuperarLibro(unsigned int idLibro, Libro **libro)
{
unsigned int offset = 0;
string pathArbolPrimario = Parametros().getParametro(CARPETA_DATOS);
pathArbolPrimario += NOMBRE_BMAS_PRIMARIO;
ArbolBMasNumerico *arbolP = new ArbolBMasNumerico(pathArbolPrimario, TAMANIO_BLOQUE_BMAS_NUMERICO);
resultadoOperacion resultado(OK) ;
Registro* registro = arbolP->buscarRegistroNumerico(idLibro, &resultado);
if (registro && resultado.getDescripcion() == "ENCONTRADO"){
offset = registro->getReferencias()->front();
}
else{
return ERROR_LIBRO_INEXISTENTE;
}
string rutaArcLibros = Parametros().getParametro(ARCHIVO_LIBROS);
if (rutaArcLibros == "") return ERROR_RUTA_ARCHIVO_LIBROS;
ArchivoLibros *archivo = new ArchivoLibros(rutaArcLibros);
*libro = (archivo->recuperarLibro(offset));
delete archivo;
delete arbolP;
return 0;
}
Registro* ArbolBMasNumerico::crearRegistroClave(string clave) {
stringstream buffer(stringstream::in | stringstream::out);
buffer << clave;
unsigned int claveNumerica;
buffer >> claveNumerica;
Registro* unRegistro = new Registro();
unRegistro->agregarAtribEntero(claveNumerica);
return unRegistro;
}
void TestParserDeLibros::testObtenerEditorialEnLibroSinEditorial(){
string strLibro = generarMockLibroSinEditorial();
const char *auxlibro= strLibro.c_str();
char* libro;
libro = const_cast<char*>(auxlibro);
Registro* regLibro = this->parser->obtenerRegistroDeLibro((libro) );
string editorial = regLibro->getEditorial();
CPPUNIT_ASSERT_MESSAGE( "No se creó la editorial por defecto en el registro",!(editorial.empty() ) );
}
int main()
{
// Prevent zombie processes
struct sigaction sigchld_action;
sigchld_action.sa_handler = SIG_DFL;
sigchld_action.sa_flags = SA_NOCLDWAIT;
sigaction(SIGCHLD, &sigchld_action, NULL);
Registro a;
a.init();
return 0;
}
// Asignado a Richard
Registro Data::selectRecord(unsigned int index)
{
InfoReg reg;
fstream disco;
disco.open(path, ios::binary | ios::in | ios::out);
if (!disco) {
throw SMException("No se pudo abrir el archivo tablespace.dat");
}
unsigned int offset = ( 4096 * header.blockID ) + sizeof(Header) + sizeof(InfoD);
int x=0;
int cant = getCantRegFisicos();
if(index>=getCantRegActivos())
{
throw SMException("Index invalido para el bloque de Data " + header.blockID);
}
else
{
for(int i=0; i< cant; i++)
{
disco.seekg(offset);
disco.read( (char*) ® , sizeof(InfoReg));
if(reg.tombstone) // == true
{
continue;
}
else if(!reg.tombstone)// == false
{
if(x==(int)index)
{
unsigned char *contenido = (unsigned char *)malloc(reg.tam);
disco.read((char*)contenido,reg.tam);
Registro registro;
registro.info = reg;
registro.setContentReg(contenido);
return registro;
}
else
{
x++;
}
}
offset+=sizeof(InfoReg) + reg.tam;
}
}
}
Registro Registro::CopiarCampos(const Conj<String> cc, const Registro r2) const{
Conj<String>::const_Iterador it = cc.CrearIt();
Registro res(*this);
while(it.HaySiguiente()){
if (Def(it.Siguiente())){
res.DefinirLento(it.Siguiente(), r2.Obtener(it.Siguiente()));
}else{
res.Definir(it.Siguiente(), r2.Obtener(it.Siguiente()));
}
it.Avanzar();
}
return res;
}
bool InterfazCliente::add(vector<string> vec){
bool valid,nombre,dir,tel;
Registro rec = getRecord(vec,valid,nombre,dir,tel);
if(valid&&(nombre&&dir&&tel)){
bool resultado = comunicador.enviarAlta(rec);
if (resultado) {
cout<<RESULT_ADD_MESSAGE<<rec.toString()<<endl;
} else {
cout<<RESULT_ADD_MESSAGE_FAIL<<rec.toString()<<endl;
}
}else{
cout<<INVALID_ADD_MESSAGE<<endl;
}
return true;
}
static void f(Hash* hash,unsigned int cant){
Registro* reg;
for (unsigned int i=0;i<cant;i++){
stringstream a;
unsigned int b= i;
a<<b;
string str;
a>>str;
reg=new Registro(str);
reg->agregarAtribEntero(i);
hash->insertar(reg);
delete reg;
}
}
response Servidor::armarResponse(Registro ®,long pid)
{
response resp;
resp.reg = reg.getRegistro();
resp.mtype = pid;
return resp;
}
int Servicios::listarLibros()
{
string rutaArcLibros = Parametros().getParametro(ARCHIVO_LIBROS);
if (rutaArcLibros == "") return ERROR_RUTA_ARCHIVO_LIBROS;
ArchivoLibros *archivo = new ArchivoLibros(rutaArcLibros);
//list<Libro> *lista = archivo->recuperacionComprensiva(); //en vez de usar el metodo de hernan
//uso el metodo siguiente del primario
list<Libro> *lista = new list<Libro>;
string pathArbolPrimario = Parametros().getParametro(CARPETA_DATOS);
pathArbolPrimario += NOMBRE_BMAS_PRIMARIO;
ArbolBMasNumerico* arbolPrimario = new ArbolBMasNumerico(pathArbolPrimario,TAMANIO_BLOQUE_BMAS_NUMERICO);
//para iniciar la recuperasion secuencial busco primero el id 0 = el primero
resultadoOperacion resultadoBus(OK);
Registro* registroObtenido = arbolPrimario->buscarRegistroNumerico(0,&resultadoBus);
unsigned int unId;
Libro* unLibro = NULL;
//armo las lista de libros con el metodo siguiente del arbol
while ( registroObtenido != NULL){
unId = registroObtenido->getAtributosEnteros()->front();
recuperarLibro(unId, &unLibro);
//agrego un libro a la lista de libros
lista->push_back(*unLibro);
registroObtenido = arbolPrimario->siguiente();
}
delete arbolPrimario;
cout << "Listado del libros: " << endl;
unsigned int i = 1;
for (list<Libro>::iterator it = lista->begin(); it != lista->end(); it++)
{
cout<<"************************** "<< i << " **************************" << endl;
cout << (*it).toString() << endl;
i++;
}
cout << "Fin listado del libros: " << endl;
delete lista;
return 0;
}
void TestParserDeLibros::testObtenerAutorEditorialTituloDeLibroConTodosLosDatos(){
string strLibro = generarMockLibroCompleto();
const char *auxlibro= strLibro.c_str();
char* libro;
libro = const_cast<char*>(auxlibro);
Registro* regLibro = this->parser->obtenerRegistroDeLibro((libro) );
string autor = regLibro->getAutor();
CPPUNIT_ASSERT( (autor.compare("darrenzshan")) == 0 );
string titulo = regLibro->getTitulo();
CPPUNIT_ASSERT( (titulo.compare("lazmontazzazdezloszvampiros")) == 0 );
string editorial = regLibro->getEditorial();
CPPUNIT_ASSERT( (editorial.compare("littlezzbrownzandzcompany")) == 0 );
}
Registro* ArbolBiselado::obtenerMayorDeLosMenores(Nodo* nodo){
Nodo* nodoActual = nodo;
while(true)
{
try
{
nodoActual = nodoActual->getHijoDerecho();
}
catch(NumeroDeBloqueInvalido e)
{
break;
}
nodosARotar->apilar(nodoActual);
movimientos->apilar('d');
}
//En caso de que el nodo hoja que contenia el registro sustituto
//haya quedado vacio, lo desapilo para el biselado y elimino la duplicacion
desapilarSiNodoQuedaVacio(nodoActual);
//obtengo el registro original a eliminar
Registro* original = nodoActual->getListaDeRegistros()->obtenerUltimo();
//duplico su informacion en el que se insertara en el nodo que quedo vacio
Registro* duplicado = new Registro(original->getID(),original->getCodigo(), original->getDescripcion());
//elimino el original si no es el unico registro restante o es hoja
if(nodoActual->getListaDeRegistros()->getTamanio() > 1 || nodoActual->esHoja()){
nodoActual->eliminarRegistro(original);
} else //en caso de que no (esta es la recursion) y el nodo prestador a su vez
//queda vacio le aplico recursion para que busque otra vez el menor de los mayores
//o mayor de los menores y repita todo el proceso, mejor dicho.
{
//fijate que en el unico caso que hay que hacer recursion
//es si caemos en un nodo interno con un solo registro
// (A || B) == ¬A && ¬B.
eliminarEnNodoInterno(original,nodoActual);
}
return duplicado;
}
void TestArchivoDeBuckets::mostrarBucket(ArchivoDeBuckets* archivo,int numeroDeBucket) {
Bucket* bucketNuevo = archivo->obtenerBucket(numeroDeBucket);
string* serializacion = bucketNuevo->serializar();
cout << "bucketSerializado "<< serializacion->size() << endl;
delete serializacion;
int cantRegistros = bucketNuevo->getCantidadDeRegistros();
list<Registro*>::iterator it = bucketNuevo->ubicarPrimero();
for(int i =0; i < cantRegistros; i++) {
Registro* registro = *it;
Distrito* d = (Distrito*)registro->getContenido();
cout << d->getDistrito() << endl;
delete d;
it++;
}
}
void BaseDeDatos::cargarBufferDesdeArchivo(){
fstream bdfile;
bdfile.open(ARCHIVO_BASE, ios_base::in | ios_base::binary);
if (!bdfile.is_open()){
bdfile.open(ARCHIVO_BASE, ios_base::in| ios_base::binary | ios_base::trunc);
}
while(!bdfile.eof() && !this->bufferLleno()) {
Registro r;
t_registro tr;
if(bdfile.read((char*)(&tr), Registro::getSize()) ){
r.crearDesdeRegistro(tr);
this->bufferRegistros.push_back(r);
} else {
break;
}
}
bdfile.close();
}
void MainWindow::on_actionNuevo_Archivo_triggered()
{
bool ok;
QList <Campo> arregloDeEstructura;
//QFile archivo("archivo.txt");
QString text = QInputDialog::getText(this, tr("Nombre del Archivo"),tr("Ingrese el nombre:"), QLineEdit::Normal,"", &ok);
//archivo.rename(text);
int num = QInputDialog::getInt(this,tr("Numero de Campos"),tr("Ingrese el numero de campos"),1,1,2147483647,1,&ok,0);
//vetanaCampos* window = new vetanaCampos(this,num);
//window->show();
vetanaCampos ventana(0,num);
ventana.setModal(true);
ventana.exec();
QList<Campo> campos=ventana.getListaCampos();
estructura=campos;
Registro registro;
registro.setListaCampos(ventana.getListaCampos());
cout<<"{";
arregloDeEstructura=campos;
int delimitadoresPorAgregar=0;
for(int i=0;i<registro.getLista().size();i++){
cout<<"elemento numero: "<<i<<endl;
registerLength+=(int)registro.getLista().at(i).getLength();
delimitadoresPorAgregar++;
}
delimitadoresPorAgregar++;//se agrega el delitadr de nueva linea
//registerLength+=delimitadoresPorAgregar;
cout<<"}"<<endl;
insertarEncabezadoBonito(arregloDeEstructura);
cout<<"buenaaaaaaaaaaaaaaaaaaaaas999";
}
//Cadastro de Aluno
Cadastrar::Cadastrar (const string nome, const string matricula, const string senha, const char turma)
{
bool existe;
int tam_registro = 44; //Tamanho de um registro
Registro registro (3);
int sucesso = registro.incluir_registro ();
ArquivoExiste arq ("dados/Aluno.txt");
existe = arq.getExistencia ();
//O arquivo jah existe e o registro sera inserido no meio do arquivo
if (existe && sucesso >= 0)
{
ofstream arquivo ("dados/Aluno.txt", ios_base::in);
arquivo.seekp (tam_registro*registro.getPos (), ios_base::beg);
arquivo << nome << "|" << matricula << "|" << senha << "|" << turma;
arquivo.close ();
}
//O arquivo jah existe e o registro sera inserido no final do arquivo
else if (existe)
{
ofstream arquivo ("dados/Aluno.txt", ios_base::app);
arquivo << "+" << nome << "|" << matricula << "|" << senha << "|" << turma;
arquivo.close ();
}
//O arquivo ainda não existe
else
{
ofstream arquivo ("dados/Aluno.txt");
arquivo << nome << "|" << matricula << "|" << senha << "|" << turma;
arquivo.close ();
}
}
//Checa os dados de um usuario, com o objetivo de exclui-lo (ver funcaos 'soliciar_excluir_......')
bool Excluir_user::excluir_user (const string nome, const string matricula, const int nivel)
{
int posicao;
Checar_user user;
posicao = user.checar_user (nome, matricula, nivel);
if (posicao == -1)
{
return false;
}
else
{
Registro registro (nivel);
registro.setPos ((long int) posicao);
registro.alterar_status_registro (0);
return true;
}
}
bool Registro::CoincideAlguno(const Conj<String> cc, const Registro r2) const{
bool b = false;
typename Conj<String>::const_Iterador it1 = cc.CrearIt();
while(it1.HaySiguiente() && !b){
if(Obtener(it1.Siguiente()) == r2.Obtener(it1.Siguiente()) ){
b = true;
}
it1.Avanzar();
}
return b;
}
void TestArchivoDeBuckets::testAgotamiento() {
char nombreDelArchivo[]= "Archivo.bin";
remove(nombreDelArchivo);
int numero = LONGITUD_BLOQUE_PRUEBA;
int nb;
int nb2;
Distrito* d;
ArchivoDeBuckets* archivo = new ArchivoDeBuckets(nombreDelArchivo,numero);
for (int i = 0; i < 10000; i++) {
if (i == 5000)
d = new Distrito("B");
else
d = new Distrito("A");
Registro* r = new Registro(d);
Bucket* b = new Bucket(0,numero);
b->agregarRegistro(r);
if (i==5000)
nb = archivo->guardarBucket(b);
else
nb2 = archivo->guardarBucket(b);
cout << "Bloque (" << i << ") almacenado en posicion :" << nb2 << endl;
delete b;
delete r;
delete d;
}
cout << nb << endl;
Bucket* buc = archivo->obtenerBucket(nb);
cout << "cant regs" << buc->getCantidadDeRegistros() << endl;
list<Registro*>::iterator it = buc->ubicarPrimero();
Registro* reg = *it;
Distrito* dis = (Distrito*)reg->getContenido();
cout << "distrito: " << dis->getDistrito() << endl;
delete archivo;
}
int DataHandler::guardarDatos(){
// Persistir datos de la lista en el archivo
cout << endl << "*Persisto los datos en archivo.."<<endl;
ofstream outputStream("ServerDatabase.txt", ios::out|ios::binary);
Registro* registro;
for(int i = 0; i< this->getCantidad(); i++){
registro = listaRegistros[i];
char* linea = registro->getNombre();
strcat(linea, ",");
strcat(linea, registro->getDireccion());
strcat(linea, ",");
strcat(linea, registro->getTelefono());
strcat(linea, "\n");
outputStream.write(linea, strlen(linea));
cout << "Escribo linea: " << linea;
}
outputStream.close();
cout << "**Fin persistencia**"<< endl;
}
Conj<String> Registro::DiferenciaSimetrica(const Registro r2) const{
Conj<String> res;
Conj<String> c2(r2.Campos());
typename Conj<String>::Iterador it = c2.CrearIt();
Conj<String> c1(Campos());
while(it.HaySiguiente()){
if(!(c1.Pertenece(it.Siguiente()))){
res.AgregarRapido(it.Siguiente());
}
it.Avanzar();
}
return res;
}
int nuevareserva(Registro &NuevoReg, CListaTfnos &Trabajo, Registro ®)
{
int distancia, coste, diasemana, // Declaracion de variables locales
coste_total, oferta, recargo;
destino(NuevoReg, Trabajo); // Llamada a funciones y asignacion de
//valores de distintas variables
distancia = NuevoReg.leedistancia(); //lee la distancia para luego
//utilizarlo en el precio
coste = precio(distancia, NuevoReg);
cuando(NuevoReg);
diasemana = NuevoReg.unafecha.leediasemana();
recargo = aumento(diasemana, coste);
oferta = descuento(coste, distancia, NuevoReg);
coste_total = coste + oferta + recargo;
if (NuevoReg.leevuelta()==true)
coste_total = coste_total * 2;
NuevoReg.precio=coste_total;
guardareserva(NuevoReg, reg, Trabajo); //guarda la reserva hecha a
//petición del usuario
return 0;
}
//Cadastra um usuário Master no sistema
InicializarSistema::InicializarSistema ()
{
ofstream arquivo ("dados/Master.txt");
//Não há espaço em disco
if ( arquivo.fail () )
{
cout << "Nao ha espaco suficiente em disco!\n\n";
abort ();
}
//Cadastrando um usuário Master inicial
else
{
arquivo << " m_user|123456789| 12345";
arquivo.close ();
Registro registro (1);
registro.incluir_registro ();
}
}
//Cadastro de usuário Master
Cadastrar::Cadastrar (const string nome, const string matricula, const string senha)
{
//Aqui, nao ha verificacao da existencia do arquivo de usuarios Master, pois,
//para que este codigo seja alcancado, eh necessario que a criacao deste
//arquivo jah tenha sido feita na primeira execucao do sistema.
int tam_registro = 42; //Tamanho de um registro
Registro registro (1);
int sucesso = registro.incluir_registro ();
//Inserir no final do arquivo
if (sucesso == -1)
{
ofstream arquivo ("dados/Master.txt", ios_base::app);
arquivo << "+" << nome << "|" << matricula << "|" << senha;
arquivo.close ();
}
else if (sucesso == 0)
{
ofstream arquivo ("dados/Master.txt", ios_base::in);
arquivo.seekp (tam_registro*registro.getPos (), ios_base::beg);
arquivo << nome << "|" << matricula << "|" << senha;
arquivo.close ();
}
/* Implementar um try-catch para lançar uma exceção aqui!!!!
else //sucesso = -2
{
throw "deu pau aqui! valor inválido para o nível de usuário!
}
*/
}
int BaseDeDatos::modificar(Registro& exist, const Registro& modif){
if (!this->existente(exist)){
return ERR_NO_EXISTE;
}
vector<Registro>::iterator it = currrentPosition;
if (this->existente(modif) && !exist.compararPorNombre(modif)){
return ERR_DUPLICADO;
}
exist.llenarVacios(*it);
Registro nuevo = modif;
nuevo.llenarVacios(*it);
/* Modificar en cache */
it = this->bufferRegistros.insert(it, nuevo);
if ((it+1) != this->bufferRegistros.end()){
this->bufferRegistros.erase(it+1);
}
currrentPosition = it;
/* Modificar en el archivo */
t_registro reg = nuevo.getRegistroASerializar();
t_registro rbusq;
Registro busq;
bool encontrado = false;
fstream bdfile;
bdfile.open (ARCHIVO_BASE, ios_base::out | ios_base::in | ios_base::binary);
while(!bdfile.eof() && !encontrado){
bdfile.read((char*)&rbusq, Registro::getSize());
busq.crearDesdeRegistro(rbusq);
if (exist.compararPorNombre(busq)){
bdfile.seekp(- Registro::getSize(), ios_base::cur);
bdfile.write((char*)®, Registro::getSize());
encontrado = true;
}
}
bdfile.close();
return SUCCESS;
}
int BaseDeDatos::insertar(const Registro& r){
if (this->existente(r)){
return ERR_DUPLICADO;
}
if (this->datosRequeridos(r)){
return ERR_CAMPO_REQUERIDO;
}
/* Insertar en cache */
this->bufferRegistros.push_back(r);
/* Insertar en archivo */
fstream bdfile;
bdfile.open (ARCHIVO_BASE, ios_base::out | ios_base::binary | ios_base::app);
t_registro reg = r.getRegistroASerializar();
bdfile.write((char*)®, Registro::getSize());
bdfile.close();
return SUCCESS;
}
bool BaseDeDatos::datosRequeridos(const Registro& r){
return r.getNombre().empty();
}
