[ Foro de Pascal ]

dawdas

03-Jan-2018 12:34
alberto gonzalez
0 Respuestas

PROGRAM practicaFinalIP;
CONST
NUMUSUARIOURJC = 9; {longitud usuario URJC}
LONGPERFIL = 3; {longitud perfil usuario}
LONGDNI = 9; {longitud dni}
LONGFECHA = 10; {longitud fecha}
MAXUSUARIOS = 100; {n?mero m?ximo de usuarios}
MAXRECURSOS = 150; {n?mero m?ximo de recursos}
MAXCONCESIONES = 200; {n?mero m?ximo de concesiones}
MAXHISTORICO = 500; {n?mero m?ximo de registros historico}
TYPE
tUsuarioURJC = string[NUMUSUARIOURJC];
tPerfil = string[LONGPERFIL];
tDni = string[LONGDNI];
tFecha = string[LONGFECHA];
{tipo usuario}
tUsuario = RECORD
nombre, apellidos: string;
dni : tDni;
usuarioURJC : tUsuarioURJC;
saldo : real;
perfil : tPerfil;
END;
{tipo recurso}
tRecurso = RECORD
id : integer;
titulo, ambito, genero : string;
numconcesiones: integer;
coste : real;
tiempo : integer;
END;
{tipo concesion}
tConcesion = RECORD
fecha : tFecha;
id: integer; {id del recurso}
usuarioURJC : tUsuarioURJC ;
END;
{tipo lista de usuarios}
tIndiceUsuarios = 1..MAXUSUARIOS;
tListaUsuarios = ARRAY [tIndiceUsuarios] OF tUsuario;

{Array parcialmente lleno para usuarios}
tUsuariosRegistrados = RECORD
usuarios: tListaUsuarios;
tope : integer;
END;
{tipo lista de recursos}
tIndiceRecursos = 1..MAXRECURSOS;
tListaRecursos = ARRAY [tIndiceRecursos] OF tRecurso;

{Array parcialmente lleno para recursos}
tRecursosDisponibles = RECORD
recursos: tListaRecursos;
tope : integer;
END;

{tipo lista de concesiones}
tIndiceConcesiones = 1..MAXCONCESIONES;
tListaConcesiones= ARRAY [tIndiceConcesiones] OF tConcesion;

{Array parcialmente lleno para concesiones}
tConcesionesActivas = RECORD
concesiones: tListaConcesiones;
tope : integer;
END;
{tipo lista de hist?rico concesiones}
tIndiceHistorico = 1..MAXHISTORICO;
tListaHistorico= ARRAY [tIndiceHistorico] OF tConcesion;

{Array parcialmente lleno para historico concesiones}
tHistoricoActivo = RECORD
historico: tListaHistorico;
tope : integer;
END;
{tipo archivo binario}
tArchivoUsuarios = FILE OF tUsuario;
tArchivoRecursos = FILE OF tRecurso;
tArchivoConcesiones = FILE OF tConcesion;
VAR
opc:char;
usuariosRegistrados:tUsuariosRegistrados;
usuarioNuevo:tUsuario;
recursosDisponibles:tRecursosDisponibles;
concesionesActivas:tConcesionesActivas;
recurso:tRecurso;
historicoActivo:tHistoricoActivo;
fecha:tFecha;


PROCEDURE mostrarNombres;
BEGIN
writeln ('***********************************************************************************');
writeln ('Trabajo hecho por: Fernando Ruano Gonzalez, Jorge Suela Martin y Carlos Pe?a Morante');
writeln ('************************************************************************************');
END;

PROCEDURE mostrarMenu;
BEGIN
writeln ('a) Alta usuario');
writeln ('b) Baja usuario');
writeln ('c) Alta recurso multimedia');
writeln ('d) Baja recurso multimedia');
writeln ('e) Listado usuarios');
writeln ('f) Listado recursos multimedia');
writeln ('g) Listado usuarios con concesiones');
writeln ('h) Listado historico de concesiones');
writeln ('i) Concesion de recurso multimedia');
writeln ('j) Guardar usuarios');
writeln ('k) Guardar recursos multimedia');
writeln ('l) Guardar concesiones');
writeln ('m) Guardar historico');
writeln ('n) Cargar usuarios');
writeln ('o) Cargar recursos multimedia');
writeln ('p) Cargar concesiones');
writeln ('q) Cargar historico de concesiones');
writeln ('r) Generar informe de usuarios en archivo');
writeln ('s) Salir');
END;

PROCEDURE inicializarUsuarios (VAR registrados:tUsuariosRegistrados);
BEGIN
registrados.tope:=0;
END; {inicializar usuarios}

PROCEDURE inicializarConcesiones(VAR concesionesAct:tConcesionesActivas);
BEGIN{Inicializar concesiones}
concesionesAct.tope:=0;
END;{Inicializar concesiones}

PROCEDURE altaUsuario (VAR user:tUsuario);
BEGIN
WITH user DO BEGIN
writeln ('Introduzca un nombre');
readln(nombre);
writeln ('Introduzca dos apellidos');
readln (apellidos);
writeln ('Introduzca el DNI');
readln (dni);
writeln ('Introduzca el Usuario URJC');
readln (usuarioURJC);
REPEAT
writeln ('Introduzca el perfil <ALU, PDI, PAS o PPI>');
readln(perfil);
UNTIL (perfil='ALU') OR (perfil='alu') OR (perfil='PDI') OR (perfil='pdi') OR (perfil='PAS') OR (perfil='pas') OR (perfil='PPI') OR (perfil='ppi');
saldo:=1000;
writeln()
END; {usuario}
END; {altaUsuario}

PROCEDURE insertarUsuario (VAR registrados:tUsuariosRegistrados; nuevo:tUsuario);
VAR
posicion:integer;
BEGIN
WITH registrados DO BEGIN
IF (tope>=MAXUSUARIOS) THEN
writeln ('Ha alcanzado el numero maximo de altas de usuarios')
ELSE BEGIN
posicion:=1;
WHILE (posicion<=tope) AND (usuarios[posicion].usuarioURJC<>nuevo.usuarioURJC) DO
posicion:=posicion+1;
IF (posicion>tope) THEN BEGIN
tope:=tope+1;
usuarios[tope]:=nuevo;
writeln ('El usuario ha sido a?adido');
writeln();
END {IF}
ELSE BEGIN
writeln ('El usuario esta repeitdo');
writeln();
END; {ELSE}
END; {else}
END; {with}
END; {insertar usuarios}

PROCEDURE listadoUsuarios (VAR registrados:tUsuariosRegistrados);
VAR
i:integer;
BEGIN
WITH registrados DO BEGIN
IF tope=0 THEN BEGIN
writeln ('No hay usuarios registrados');
writeln();
END {ELSE}
ELSE BEGIN
FOR i:=1 TO tope DO BEGIN
writeln ('Nombre: ', usuarios[i].nombre);
writeln ('Apellidos: ', usuarios[i].apellidos);
writeln ('DNI: ', usuarios[i].dni);
writeln ('Usuario URJC: ', usuarios[i].usuarioURJC);
writeln ('Perfil: ', usuarios[i].perfil);
writeln ('Saldo Bitcoins: ', (usuarios[i].saldo):0:2);
writeln();
END; {for}
END; {ELSE}
END; {with}
END;

PROCEDURE bajaUsuario (VAR registrados:tUsuariosRegistrados; user:tUsuario);
VAR
i:integer;
BEGIN {bajaUsuario}
WITH registrados DO BEGIN
i:=1;
WHILE (i<=tope) AND (usuarios[i].usuarioURJC<>user.usuarioURJC) DO
i:=i+1;
IF usuarios[i].usuarioURJC=user.usuarioURJC THEN BEGIN
usuarios[i]:=usuarios[tope];
tope:=tope-1;
writeln ('El usuario ha sido borrado');
writeln();
END {IF}
ELSE BEGIN
writeln ('ERROR: El usuario no existe');
writeln();
END; {ELSE}
END; {with}
END; {bajaUsuario}

PROCEDURE altaRecursos (VAR nuevaPeli:tRecurso; VAR pelisDisponibles:tRecursosDisponibles);
VAR
i:integer;
BEGIN
WITH nuevaPeli DO BEGIN
id:=pelisDisponibles.tope+1;
writeln ('ID: ',id);
writeln ('Titulo');
readln (titulo);
writeln ('Ambito');
readln(ambito);
writeln('Genero');
readln(genero);
numconcesiones:=0;
writeln ('Coste en Bitcoins');
readln(coste);
writeln('Tiempo (en minutos)');
readln(tiempo);
writeln();
END; {with}
END; {alta recursos}

PROCEDURE insertarRecursos (VAR pelisDisponibles:tRecursosDisponibles; nuevaPeli:tRecurso);
VAR
posicion:integer;
BEGIN {borrarRecurso}
posicion:=1;
WITH pelisDisponibles DO BEGIN
IF (tope>=MAXRECURSOS) THEN BEGIN
writeln ('No se pueden a?adir mas recursos');
writeln ();
END
ELSE BEGIN
WHILE (posicion<=tope) DO
posicion:=posicion+1;
IF (posicion>tope) THEN
tope:=tope+1;
recursos[tope]:=nuevaPeli;
writeln ('El recurso ha sido a?adido');
writeln()
END; {ELSE}
END; {WITH}
END; {insertarRecursos}

PROCEDURE borrarRecurso (VAR pelisDisponibles:tRecursosDisponibles; nuevaPeli:tRecurso);
VAR
posicion:integer;
BEGIN {borrarRecurso}
posicion:=1;
WITH pelisDisponibles DO BEGIN
WHILE (posicion<=tope) AND (recursos[posicion].id<>nuevaPeli.id) DO
posicion:=posicion+1;
IF (recursos[posicion].numconcesiones=0) AND (recursos[posicion].id=nuevaPeli.id) THEN BEGIN
recursos[posicion]:=recursos[tope];
writeln ('El recurso ha sido borrado');
writeln();
tope:=tope-1;
END
ELSE
writeln ('ERROR: el recurso tiene concesiones o no existe');
writeln();
END; {WITH}
END; {borrarRecurso}

PROCEDURE listadoRecursos (VAR pelisDisponibles:tRecursosDisponibles);
VAR
i:integer;
BEGIN {listadoRecursos}
WITH pelisDisponibles DO BEGIN
IF (tope=0) THEN BEGIN
writeln ('No hay recursos disponibles');
writeln();
END
ELSE BEGIN
FOR i:=1 TO tope DO BEGIN
writeln('ID: ',recursos[i].id);
writeln ('Titulo: ', recursos[i].titulo);
writeln ('Ambito: ', recursos[i].ambito);
writeln ('Genero: ', recursos[i].genero);
writeln ('Coste (en Bitcoins): ', recursos[i].coste:0:2);
writeln ('Tiempo (en minutos): ', recursos[i].tiempo);
writeln ('Numero de concesiones: ', recursos[i].numconcesiones);
writeln();
END; {FOR}
END; {ELSE}
END; {WITH}
END; {listadoRecursos}

PROCEDURE inicializarRecursos (VAR recursos:tRecursosDisponibles);
BEGIN {inicializar Recursos}
recursos.tope:=0;
END;  {inicializar Recursos}

PROCEDURE ordenarUsuariosConcesiones(VAR concesionesAct:tConcesionesActivas);
VAR
aux:tUsuarioURJC;
i,j:integer;
BEGIN {Ordenar usuarios Concesiones}
FOR i:=1 TO (MAXUSUARIOS-1) DO
FOR j:=1 TO (MAXUSUARIOS-i) DO
IF ((concesionesAct.concesiones[j].usuarioURJC)>(concesionesAct.concesiones[j+1].usuarioURJC)) THEN BEGIN
aux:=(concesionesAct.concesiones[j].usuarioURJC);
(concesionesAct.concesiones[j].usuarioURJC):=(concesionesAct.concesiones[j+1].usuarioURJC);
(concesionesAct.concesiones[j+1].usuarioURJC):=aux;
END; {IF}
END;{ordenar Usuarios Concesiones}

PROCEDURE listadoUsuariosConcesiones(concesionesActi:tConcesionesActivas;users:tUsuariosRegistrados;recur:tRecursosDisponibles);
VAR
i:integer;
userURJC:tUsuarioURJC;
BEGIN {listado Usuario con concesiones}
ordenarUsuariosConcesiones(concesionesActi);
FOR i:=1 TO concesionesActi.tope DO BEGIN
userURJC:=concesionesActi.concesiones[i].usuarioURJC;
writeln('Usuario URJC: ',userURJC);
writeln('Nombre: ',users.usuarios[i].nombre,'Apellidos: ',users.usuarios[i].apellidos);
writeln('Recurso: ',recur.recursos[i].titulo);
writeln('----------------------------');
END;{FOR}
END;{listado Usuario con concesiones}

PROCEDURE ordenarHistorico(VAR historicoActi:tHistoricoActivo);
VAR
aux:tFecha;
i,j:integer;
BEGIN {Ordenar historico}
FOR i:=1 TO (MAXHISTORICO-1) DO
FOR j:=1 TO (MAXHISTORICO-i) DO
IF ((historicoActi.historico[j].fecha)>(historicoActi.historico[j+1].fecha)) THEN BEGIN
aux:=(historicoActi.historico[j].fecha);
(historicoActi.historico[j].fecha):=(historicoActi.historico[j+1].fecha);
(historicoActi.historico[j+1].fecha):=aux;
END; {IF}
END;{ordenar Historico}

PROCEDURE historicoConcesiones(historicoAct:tHistoricoActivo;concesionesActi:tConcesionesActivas;users:tUsuariosRegistrados;recur:tRecursosDisponibles);
VAR
i:integer;
fechaConcesion:tFecha;
BEGIN {listado Historico}
ordenarHistorico(historicoAct);
FOR i:=1 TO historicoAct.tope DO BEGIN
writeln('Concesion: ');
writeln('Fecha de la concesion: ',historicoAct.historico[i].fecha);
writeln('Titulo del recurso: ',recur.recursos[i].titulo);
writeln('UsuarioURJC: ',users.usuarios[i].usuarioURJC);
writeln('----------------------------');
END;{FOR}
END;{listado Historico}

FUNCTION busquedaDNI (usua:tUsuariosRegistrados;buscardni:string):integer;
VAR
i:integer;
BEGIN {busqueda DNI}
i:= 1;
WHILE (buscardni<>usua.usuarios[i].dni) AND (i<MAXUSUARIOS) DO
i:=succ(i);
IF i = MAXUSUARIOS THEN
busquedaDNI:=MAXUSUARIOS
ELSE
busquedaDNI:=i;
END; {busqueda DNI}

FUNCTION busquedausuarioURJC (usua:tUsuariosRegistrados;buscarusuarioURJC:string):integer;
VAR
i:integer;
BEGIN {busqueda usuario}
i:= 1;
WHILE (buscarusuarioURJC<>usua.usuarios[i].usuarioURJC) AND (i<MAXUSUARIOS) DO
i:=succ(i);
IF i = MAXUSUARIOS THEN
busquedausuarioURJC:=MAXUSUARIOS
ELSE
busquedausuarioURJC:=i;
END; {busqueda usuario}

FUNCTION busquedarecurso(recurs:tRecursosDisponibles;tittle:string):integer;
VAR
i:integer;
BEGIN {busqueda recurso}
i:= 1;
WHILE (tittle<>recurs.recursos[i].titulo) AND (i<MAXRECURSOS) DO
i:=succ(i);
IF i = MAXRECURSOS THEN
busquedarecurso:=MAXRECURSOS
ELSE
busquedarecurso:=i;
END; {busqueda recurso}

PROCEDURE insertarenConcesion(VAR date:tFecha;identificacion:integer;userRJC:tUsuarioURJC;conceNueva:tConcesion);
BEGIN{insertar en Concesion}
WITH conceNueva DO BEGIN
fecha:=date;
id:=identificacion;
usuarioURJC:=userRJC;
END;
END;{insertar en Concesion}

PROCEDURE insertarEnHistorico(VAR histo: tHistoricoActivo; nuevaConce:tConcesion);
VAR
posicion: integer;
BEGIN { insertar En el Historico}
WITH histo DO BEGIN
IF tope>=MAXHISTORICO THEN
writeln('El historico esta lleno. No se puede a?adir')
ELSE BEGIN
IF posicion>tope THEN BEGIN {No est? repetido}
tope:=tope+1;
historico[tope]:=nuevaConce;
writeln('La concesion ha sido agregada al historico');
END
END {ELSE}
END; {WITH}
END;{ insertar En el Historico}

PROCEDURE concesionRecurso(VAR recur:tRecursosDisponibles;users:tUsuariosRegistrados;conceAct:tConcesionesActivas);
VAR
eleccion:string;
posicioncuentadni:integer;
posicioncuentausuario:integer;
precioRecurso:real;
posicionRecurso:integer;
titulorecurso:string;
idConcesion:integer;
userReyJuanCarlos:tUsuarioURJC;
unicaConcesion,concesionEspecifica:tConcesion;
BEGIN{concesion Recurso}
REPEAT
write('Introduzca el titulo del recurso: ');
readln(titulorecurso);
IF (busquedarecurso(recur,titulorecurso)=MAXRECURSOS) THEN
writeln('Recurso no encontrado');
UNTIL (busquedarecurso(recur,titulorecurso)<MAXRECURSOS);
posicionRecurso:=busquedarecurso(recur,titulorecurso);
IF recur.recursos[posicionRecurso].numConcesiones=MAXCONCESIONES THEN
writeln('No es posible concederle este recurso')
ELSE BEGIN
write('Introduzca su DNI o su UsuarioURJC: ');
readln(eleccion);
IF (busquedaDNI(users,eleccion)=MAXUSUARIOS) OR (busquedausuarioURJC(users,eleccion)=MAXUSUARIOS) THEN
writeln('No se ha encontrado ninguna cuenta con esos datos')
ELSE BEGIN
posicioncuentadni:=busquedadni(users,eleccion);
posicioncuentausuario:=busquedausuarioURJC(users,eleccion);
END;
preciorecurso:=(recur.recursos[posicionRecurso].coste);
IF (users.usuarios[posicioncuentausuario].saldo<preciorecurso) OR (users.usuarios[posicioncuentadni].saldo<preciorecurso) THEN
writeln('No dispone de suficientes bitcoins')
ELSE BEGIN
users.usuarios[posicioncuentausuario].saldo:=(users.usuarios[posicioncuentausuario].saldo)-preciorecurso;
users.usuarios[posicioncuentadni].saldo:=(users.usuarios[posicioncuentadni].saldo)-preciorecurso;
recur.recursos[posicionRecurso].numConcesiones:=(recur.recursos[posicionRecurso].numConcesiones)-1;
idConcesion:=recur.recursos[posicionRecurso].id;
userReyJuanCarlos:=users.usuarios[posicioncuentausuario].usuarioURJC;
unicaConcesion:=conceAct.concesiones[posicioncuentausuario];
concesionEspecifica:=conceAct.concesiones[posicioncuentadni];
insertarenConcesion(fecha,idConcesion,userReyJuanCarlos,concesionEspecifica);
unicaConcesion:=conceAct.concesiones[posicioncuentadni];
insertarEnHistorico(historicoActivo,unicaConcesion);
END;
END;
END;{concesion Recurso}



BEGIN {Programa principal}
mostrarNombres;
inicializarUsuarios(usuariosRegistrados);
inicializarRecursos(recursosDisponibles);
inicializarConcesiones(concesionesActivas);
writeln ('BIENVENIDO: Introduzca la fecha de hoy (en <aaaa-mm-dd>)');
readln (fecha);
writeln();
REPEAT
mostrarMenu;
readln(opc);
CASE opc OF
'a','A':BEGIN
writeln('xxxxxxxxxx Alta Usuario xxxxxxxxxx');
altaUsuario(usuarioNuevo);
insertarUsuario(usuariosRegistrados,usuarioNuevo);
END;
'b','B': BEGIN
writeln('xxxxxxxxxx Baja  Usuario xxxxxxxxxx');
writeln ('Introduzca el Usuario URJC que desee dar de baja');
readln (usuarioNuevo.usuarioURJC);
bajaUsuario(usuariosRegistrados,usuarioNuevo);
END;
'c','C': BEGIN
writeln('xxxxxxxxx Alta Recurso Multimedia xxxxxxxxxx');
altaRecursos(recurso,recursosDisponibles);
insertarRecursos(recursosDisponibles,recurso);
END;
'd','D': BEGIN
writeln('xxxxxxxxxx Baja Recurso Multimedia xxxxxxxxxx');
writeln ('Introduzca el ID del recurso que desee dar de baja');
readln(recurso.id);
borrarRecurso(recursosDisponibles,recurso);
END;
'e','E': BEGIN
writeln('xxxxxxxxxx Listado Usuarios xxxxxxxxxx');
listadoUsuarios (usuariosRegistrados);
END;
'f','F': BEGIN
writeln('xxxxxxxxxx Listado Recursos xxxxxxxxxx');
listadoRecursos (RecursosDisponibles);
END;
'g','G':BEGIN
writeln('xxxxxxxxxx Listado usuarios con concesiones xxxxxxxxx');
listadoUsuariosConcesiones(concesionesActivas,usuariosRegistrados,recursosDisponibles);

END;
'h','H':BEGIN
writeln('xxxxxxxxxx Listado Historico de Concesiones xxxxxxxxx');
historicoConcesiones(historicoActivo,concesionesActivas,usuariosRegistrados,recursosDisponibles);
END;
'i','I':BEGIN
writeln('xxxxxxxxxx Concesion de Recurso Multimedia xxxxxxxxx');
concesionRecurso(recursosDisponibles,usuariosRegistrados,concesionesActivas);
END;
END;
UNTIL (opc='s') OR (opc='S');
writeln ('Pulse <ENTER> para salir');
END. {Programa principal}




Si ya eres usuario del sistema, puedes contestar desde tu cuenta y así ganar prestigio.

Si sólo eres un visitante, puedes optar por...