Skip to content

Commit

Permalink
TRABAJO FINAL
Browse files Browse the repository at this point in the history
  • Loading branch information
miaitovich committed Nov 17, 2023
1 parent cdd3db1 commit 5fdb3f8
Show file tree
Hide file tree
Showing 6 changed files with 139 additions and 71 deletions.
49 changes: 15 additions & 34 deletions Proyecto/libreria/archivos.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -13,8 +13,9 @@ using namespace std;
eArchivos leerArchivoAsistencias(std::ifstream &archivo, sAsistencias *&asistencias, unsigned int &tam) //tam es igual en la funcion que afuera
{
unsigned int id_aux;
unsigned int cant_ins_aux;
sAsistencias*asistencia = new sAsistencias[tam];
unsigned int cant_ins_aux=0; //tal vez no es asi
archivo.clear();
archivo.seekg(0);

while(!archivo.eof())
{
Expand All @@ -23,41 +24,21 @@ eArchivos leerArchivoAsistencias(std::ifstream &archivo, sAsistencias *&asistenc
sInscripcion*inscripcion_aux= new sInscripcion[cant_ins_aux];
//sInscripcion*inscripcion_aux = new sInscripcion [cant_ins_aux];

for(int i=0; i<cant_ins_aux; i++)
for(unsigned int i=0; i<cant_ins_aux; i++)
{
//levanto directamente la estructura de inscripcion
archivo.read((char*)&inscripcion_aux[i],sizeof(inscripcion));
}
//ver que esta persona no este en el archivo
bool personaExistente = false; //declaro como que no existe
int i=0;
if(tam>1)
{
while(i<(tam-1))
{
if (asistencia[i].idCliente == id_aux)
{
personaExistente = true;
break;
}
i++;
}
}
//veo que los cupos de las clases se respeten

if (!personaExistente)//si no esta, la copio en mi nuevo array sin los repetidos
{
// La persona no existe en el archivo, por lo que podemos agregarla al array y actualizar el tamaño
resizeAsistencia(asistencia, tam); //agrego memoria a medida que agrego clientes
asistencia[tam-1].idCliente=id_aux;
asistencia[tam-1].cantInscriptos=cant_ins_aux;
asistencia[tam-1].Inscripcion=inscripcion_aux;
} else // La persona ya existe en el archivo, por lo que no la agregamos y liberamos la memoria de inscripcion_aux
delete[] inscripcion_aux;
}
resizeAsistencia(asistencias, tam); //agrego memoria a medida que agrego clientes
asistencias[tam-1].idCliente=id_aux;
asistencias[tam-1].cantInscriptos=cant_ins_aux;
asistencias[tam-1].Inscripcion=inscripcion_aux;

delete[] inscripcion_aux;
}

delete[] asistencia; // Liberar la memoria original
asistencias=asistencia; //copia la lista sin repetidos
delete[] asistencias; // Liberar la memoria origina
return eArchivos::ExitoOperacion;
}

Expand Down Expand Up @@ -179,16 +160,16 @@ void resizeAsistencia (sAsistencias *& asistencia, unsigned int &tam)
{
if(tam<=0)
asistencia = new sAsistencias[++tam];
return;
return;
}
sAsistencias*aux=new sAsistencias[tam+1];
sAsistencias*aux=new sAsistencias[++tam];

for(unsigned int i=0; i< tam-1; i++)
{
aux[i]= asistencia[i];
}
delete[]asistencia;
asistencia=aux; //sAsistencias apunta al nuevo array
tam++;
}

void resizeClientes (sClientes *& clientes, unsigned int &tamC)
Expand Down
41 changes: 22 additions & 19 deletions Proyecto/libreria/clases.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -7,41 +7,44 @@
using namespace std;

eReserva reservar_clase(sClientes* cliente, unsigned int cant, sClases* clases, unsigned int tamT,sAsistencias*asistencia,
unsigned int tam, string actividad, float horario, string nombre, string apellido)
unsigned int tamMañana, string actividad, float horario, string nombre, string apellido)
{
int poscliente;
int poscliente=0;
int IdClase = buscar_idclases(clases,tamT,actividad,horario);
unsigned int aux_cantins=0;
unsigned int n=0;
int*grupitos=nullptr;

int idCliente = buscar_idcliente(cliente, cant,nombre,apellido);
if(idCliente == -1)
return eReserva::ErrorReserva;

//recorro asistencias--> corto cuando el id coincide con el id del cliente--> guardo su cantinscriptos
//recorro las inscripciones del cliente(cant_inscrptos) y si ya tiene una clase en el mismo horario--> errorReserva
for(unsigned int i=0;i<tam;i++)
for(unsigned int i=0; i< tamMañana; i++)
{
if(asistencia[i].idCliente==idCliente)
if(asistencia[i].idCliente==0)
{
aux_cantins=asistencia[i].cantInscriptos;
poscliente=i;
aux_cantins=0;
}
}
for(unsigned int i=0;i<aux_cantins;i++)
{
AgruparPorHorarios(clases,tamT,grupitos,n,horario);
for(unsigned int j=0; j<n; j++)
else
if(asistencia[i].idCliente==idCliente) //el cliente ya vino
{
aux_cantins=asistencia[i].cantInscriptos;
poscliente=i;
}
}
for(unsigned int i=0; i<aux_cantins; i++)
{
if(asistencia[poscliente].Inscripcion[i].idClase==grupitos[j])
return eReserva::ErrorReserva; //ya tiene una reserva en ese horario
AgruparPorHorarios(clases,tamT,grupitos,n,horario);
for(unsigned int j=0; j<n; j++)
{
if(asistencia[poscliente].Inscripcion[i].idClase==grupitos[j])
return eReserva::ErrorReserva; //ya tiene una reserva en ese horario
}
}
}

delete[]grupitos;
//una vez que hacemos la funcion de grupitos, tambien estamos viendo que el cliente no este dos veces en la misma clase

if(HayEspacio(asistencia,IdClase,tam)==true)
if(HayEspacio(asistencia,IdClase,tamMañana)==true)
{
return eReserva::ExitoReserva;
}else
Expand Down Expand Up @@ -167,7 +170,7 @@ void clienteRandom (sClientes*clientes, sClases*clases, string &nombrecito, stri
{
int num_cliente=rand()%(sizeof(clientes));
nombrecito=clientes[num_cliente].nombre;
apellidito=clientes[num_cliente].nombre;
apellidito=clientes[num_cliente].apellido;
//emailcito=clientes[num_cliente].nombre;

int num_clase=rand()%(sizeof(clases));
Expand Down
4 changes: 2 additions & 2 deletions Proyecto/libreria/clasess.h
Original file line number Diff line number Diff line change
Expand Up @@ -15,11 +15,11 @@ struct clases
};
typedef struct clases sClases;

enum Reserva {ErrorReserva=-1, ExitoReserva=1};
enum Reserva {ErrorReserva=-1, ExitoReserva=1, PrimerReserva=-2};
typedef enum Reserva eReserva;

eReserva reservar_clase(sClientes* cliente, unsigned int cant, sClases* clases, unsigned int tamT,sAsistencias*asistencia,
unsigned int tam, string actividad, float horario, string nombre, string apellido);
unsigned int tamMañana, string actividad, float horario, string nombre, string apellido);
bool HayEspacio (sAsistencias*asistencia, unsigned int idClase, int tam);
int buscar_idclases(sClases *clases, unsigned int tamT, string actividad, float horario);
void AgruparPorHorarios(sClases*clases, int tamT, int*&grupitos, unsigned int &n, float horario);
Expand Down
2 changes: 1 addition & 1 deletion Proyecto/libreria/cliente.h
Original file line number Diff line number Diff line change
Expand Up @@ -32,7 +32,7 @@ struct asistencia
{
int idCliente;
int cantInscriptos;
sInscripcion *Inscripcion=new sInscripcion[cantInscriptos];
sInscripcion *Inscripcion;
};
typedef struct asistencia sAsistencias;

Expand Down
31 changes: 22 additions & 9 deletions Proyecto/main/main.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -4,6 +4,7 @@
#include "cliente.h"
#include "archivos.cpp"
#include "clases.cpp"
#include <ctime>

int main()
{
Expand All @@ -30,31 +31,37 @@ int main()
ifstream archivoAsistenciasAyer;
archivoAsistenciasAyer.open("asistencias_1697673600000.dat", ios::binary);
unsigned int tam=0;
sAsistencias*asistenciasAyer=new sAsistencias[tam];
sAsistencias*asistenciasAyer = new sAsistencias[tam];
int result3=leerArchivoAsistencias(archivoAsistenciasAyer, asistenciasAyer, tam);
if(result3<0)
cout<<"Ocurrio un error leyendo mis clases para hoy";
archivoAsistenciasAyer.close();

//hago el random de mi lista de clientes [una posicion]
//hago un random que me diga la cantidad de clientes que se van a anotar hoy
int CantidadClientesHoy= rand()%(cant);
int CantidadClientesMañana= rand()%(cant);
string nombrecito=" ", apellidito=" ", actividadd=" ";
float horarioo=0.0;
sAsistencias*asistenciasMañana= new sAsistencias[CantidadClientesHoy];
sAsistencias*asistenciasMañana= new sAsistencias[CantidadClientesMañana];
for(unsigned int k=0; k<CantidadClientesMañana;k++)
{
asistenciasMañana[k].idCliente=0;
}
int Reserva=0;
unsigned int i=0;
unsigned int tamMañana=0;

while(i<CantidadClientesHoy)
while(i<CantidadClientesMañana)
{
unsigned int j=0;
clienteRandom (ClientesGYM, ClasesGYM, nombrecito, apellidito, actividadd, horarioo);
Reserva = reservar_clase (ClientesGYM, cant, ClasesGYM, tamT, asistenciasMañana, tam, actividadd, horarioo, nombrecito, apellidito);
Reserva = reservar_clase (ClientesGYM, cant, ClasesGYM, tamT, asistenciasMañana, tamMañana, actividadd, horarioo, nombrecito, apellidito);
int idclaseR= buscar_idclases(ClasesGYM,tamT,actividadd,horarioo);
int idclienteR=buscar_idcliente(ClientesGYM,cant,nombrecito,apellidito);

if(Reserva>0)
{
i++;
while(j<i) //recorro la cantidad de asistencias que tengo por ahora
{
if(asistenciasMañana[j].idCliente== idclienteR) // el cliente y tiene alguna inscripcion
Expand All @@ -65,18 +72,20 @@ int main()
}
else
{
asistenciasMañana[j].Inscripcion[0]={idclaseR,timezone};
asistenciasMañana[j].cantInscriptos+=1;
asistenciasMañana[j].cantInscriptos += 1;
asistenciasMañana[j].Inscripcion = new sInscripcion[1];
asistenciasMañana[j].Inscripcion[0] = {idclaseR, time(nullptr)};

}
j++;
}
}
i++;
tamMañana++;
}

ofstream archivoMañana;
archivoMañana.open("AsistenciaMañana.dat",ios::binary);
int result4 = escribirArchivoMañana(archivoMañana,asistenciasMañana,CantidadClientesHoy);
int result4 = escribirArchivoMañana(archivoMañana,asistenciasMañana,CantidadClientesMañana);
if(result4<0)
cout<<"No se pudo escribir el archivo de mañana";
archivoMañana.close();
Expand All @@ -86,6 +95,10 @@ int main()
delete[]ClientesGYM;
delete[]asistenciasAyer;
delete[]asistenciasMañana;
for (unsigned int k = 0; k < CantidadClientesMañana; k++)
{
delete[] asistenciasMañana[k].Inscripcion;
}

return 0;
}
83 changes: 77 additions & 6 deletions Proyecto/testing/tst_proyecto.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -4,25 +4,33 @@
#include "clases.cpp"
#include "archivos.h"
#include "archivos.cpp"
#include <ctime>

int buscar_idcliente_test(sClientes* misClientes, unsigned int tamT, string nombre, string apellido){
return buscar_idcliente(misClientes, tamT, nombre, apellido);
}
sClientes Clientes[3]={
sClientes Clientes[4]={
{1,"Agusti­n","Guerra","Agusti­[email protected]","462-185-1730","10-12-1966",0},
{11,"Celeste","Ortega","[email protected]","414-820-0908","12-08-1992",-2480},
{26,"Daniela","Cortez","[email protected]","995-806-6312","27-02-1965",423}
{26,"Daniela","Cortez","[email protected]","995-806-6312","27-02-1965",423},
{10,"Gonzalo","Espinosa","[email protected]","216-995-2329","29-12-1993",0}
};

sClases Clases[5]={
{5,"Spinning",18},{6,"Yoga",9},{26,"Zumba",12},{3,"Spinning",12},
{16,"Pilates",18} };

time_t obtenerFechaHoraActual()
{
return std::time(nullptr);
}


TEST_CASE("buscar_id", "[fancy]")
{
unsigned int tamT_test=3;
unsigned int tamT_test=4;
sClientes * micliente= Clientes;
REQUIRE(micliente != nullptr);

int idnuevo=buscar_idcliente(micliente,tamT_test,"Celeste", "Ortega");
REQUIRE(idnuevo == -1);

Expand Down Expand Up @@ -62,6 +70,8 @@ TEST_CASE("Archivos")
archivoClientes.open("iriClientesGYM.csv");
ifstream archivoClases;
archivoClases.open("iriClasesGYM.csv");
ifstream archivoAyer;
archivoAyer.open("asistencias_1697673600000.dat", ios::binary);

SECTION("LeerArchivoClientes")
{
Expand Down Expand Up @@ -91,10 +101,71 @@ TEST_CASE("Archivos")
REQUIRE(clases[32].actividad=="Boxeo");
REQUIRE(clases[32].horario==19);

delete[]clases;
}
SECTION("LeerArchivoAyer")
{

sAsistencias*asistencias=nullptr;
unsigned int i=0;
int result=leerArchivoAsistencias(archivoAyer,asistencias,i);
REQUIRE(result==eArchivos::ExitoOperacion);
}
}
TEST_CASE("Reservar clase")
{
sClientes * micliente= Clientes; //tengo 4 declarados
sClases*misClases=Clases; //tengo 5 declaradas
sAsistencias asistencias[4]=
{
//agustin guerra
{1,3,new sInscripcion[3]{{5,obtenerFechaHoraActual()},{26,obtenerFechaHoraActual()},{16,obtenerFechaHoraActual()}}}, //tiene dos clases en el mismo horario--> error
//celeste ortega
{11,2,new sInscripcion[2]{{14,obtenerFechaHoraActual()},{19,obtenerFechaHoraActual()}}},
//daniela cortez
{26,4,new sInscripcion[4]{{1,obtenerFechaHoraActual()},{18,obtenerFechaHoraActual()},
{14,obtenerFechaHoraActual()},{3,obtenerFechaHoraActual()}}}, // 1 y 18 son al mismo horario.
{10,2,new sInscripcion[2]{{1,obtenerFechaHoraActual()},{18,obtenerFechaHoraActual()}}}
};
//BoolHayEspacio (adentro de reservar clase) siempre va a dar true en estos casos
int result= reservar_clase(Clientes,4, Clases, 5, asistencias, 3, "Yoga", 9, "Agustin", "Guerra");
REQUIRE(result == eReserva::ErrorReserva); //dos clases el mismo horario

int result2= reservar_clase(Clientes,4, Clases, 5, asistencias,3, "Zumba", 12, "Daniela", "Cortez");
REQUIRE(result2 == eReserva::ErrorReserva); //dos clases el mismo horario

int result3= reservar_clase(Clientes,4, Clases, 5, asistencias,3, "Zumba", 12, "Celeste", "Ortega");
REQUIRE(result3 == eReserva::ErrorReserva);//tiene estado negativo

int result4= reservar_clase (Clientes,4,Clases,5,asistencias,3,"Yoga",9,"Gonzalo","Espinosa");
REQUIRE(result4== eReserva::ExitoReserva);
}
/*
TEST_CASE("Resizes")
{
SECTION ("Resize clientes")
{
// Crear un array de clientes inicializado con algunos valores
sClientes * misClientes= Clientes;
unsigned int tam = 4;
// Llamar a resizeClientes para agregar un nuevo cliente
resizeClientes(misClientes, tam);
// Verificar que el tamaño se haya incrementado
REQUIRE(tam == 5);
}
// Verificar que los datos antiguos se copiaron correctamente
REQUIRE(misClientes[0].id == 1);
REQUIRE(misClientes[0].nombre == "Agustin");
REQUIRE(misClientes[1].id == 11);
REQUIRE(misClientes[1].nombre == "Celeste");
REQUIRE(misClientes[2].id == 26);
REQUIRE(misClientes[2].nombre == "Daniela");
REQUIRE(misClientes[3].id==10);
REQUIRE(misClientes[3].nombre=="Gonzalo");
// Verificar que el nuevo espacio se haya inicializado correctamente
//REQUIRE(misClientes[4].id == 0); // Asumiendo que el valor predeterminado para el ID es 0
//REQUIRE(misClientes[4].nombre == " ");
*/


0 comments on commit 5fdb3f8

Please sign in to comment.