[ Foro de Pascal ]

dawdas

03-Jan-2018 12:34
alberto gonzalez
1 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}
 


 


24-Jan-2018 23:13
Nacho Cabanes (+36)

Pero... ¿hay alguna duda...?






(No se puede continuar esta discusión porque tiene más de dos meses de antigüedad. Si tienes dudas parecidas, abre un nuevo hilo.)