API tools faq
paste
Guest User

Untitled

a guest
Jun 24th, 2018
75
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 51.55 KB | None | 0 0
raw download clone embed print report
  1. /*------------------------------------------------------------------------------------HEADER-PROYECTO INF2240--------------------------------------------------------------------------------*/
  2. /********************************************************************************************************************************************************************************************
  3. Documento: Libreria propia de la aplicacion.
  4.  
  5. Nombre de archivo: "header.h"
  6.  
  7. Desarrolladores: - Felipe Concha Almeida
  8. - Hector Gutierrez Moya
  9. - David Rojas Sanchez
  10. - Byron Guerrero Fuel
  11. - Roberto Rojas Barraza
  12.  
  13. *********************************************************************************************************************************************************************************************/
  14.  
  15.  
  16.  
  17.  
  18. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  19. Librerias
  20. ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  21.  
  22. /*---------------Libreria standard de ANSI C-------------------*/
  23. #include <stdlib.h>
  24.  
  25. /*--------------Libreria standard para manejo de E/S-----------*/
  26. #include <stdio.h>
  27.  
  28. /*---------Libreria para manejo de funciones de windows--------*/
  29. #include <windows.h>
  30.  
  31. /*-----------Libreria para manejo de directorios---------------*/
  32. #include <direct.h>
  33.  
  34. /*----------Libreria para manejo de memoria y cadenas----------*/
  35. #include <string.h>
  36.  
  37. /*--------------Libreria para manejo de tipografia-------------*/
  38. #include <ctype.h>
  39.  
  40. /*-----------Libreria para manejo de fecha y hora--------------*/
  41. #include <time.h>
  42. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  43.  
  44.  
  45.  
  46.  
  47. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  48. Macros
  49. ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  50.  
  51. #define ENTER '\n'
  52.  
  53. /*----Color: Rojo----*/
  54. #define C31 "\x1b[31m"
  55.  
  56. /*----Color: Verde---*/
  57. #define C32 "\x1b[32m"
  58.  
  59. /*--Color: Amarillo--*/
  60. #define C33 "\x1b[33m"
  61.  
  62. /*----Color: Azul----*/
  63. #define C34 "\x1b[94m"
  64.  
  65. /*---Color: Blanco---*/
  66. #define C00 "\x1b[0m"
  67. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  68.  
  69.  
  70.  
  71.  
  72. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  73. Registros
  74. ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  75.  
  76. struct Auto
  77. {
  78. char *patente;
  79. char *rutPropietario;
  80. char *nombreComuna;
  81. };
  82.  
  83. struct NodoAuto
  84. {
  85. long id;
  86. struct Auto *datos;
  87. struct NodoAuto *izq;
  88. struct NodoAuto *der;
  89. };
  90.  
  91. struct Comuna
  92. {
  93. char nombre[100];
  94. struct NodoAuto *arbolRobados;
  95. int totalRobados;
  96. struct NodoAuto *arbolRecuperados;
  97. int totalRecuperados;
  98. };
  99.  
  100. struct Provincia
  101. {
  102. char nombre[100];
  103. struct Comuna **listaComunas;
  104. int totalComunas;
  105. };
  106.  
  107. struct Region
  108. {
  109. char nombre[100];
  110. struct Provincia **listaProvincias;
  111. int totalProvincias;
  112. };
  113.  
  114. struct Pais
  115. {
  116. struct Region **listaRegiones;
  117. int totalRegiones;
  118.  
  119. struct NodoAuto *arbolRobadosEnPais;
  120. int totalRobadosEnPais;
  121.  
  122. struct NodoAuto *arbolRecuperadosEnPais;
  123. int totalRecuperadosEnPais;
  124. };
  125.  
  126. struct Pila
  127. {
  128. struct NodoAuto *nodo;
  129. struct Pila *sig;
  130. };
  131. /*--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  132.  
  133.  
  134.  
  135.  
  136. /*--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  137. Prototipos de Funciones
  138. ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  139.  
  140. /*----------------------------------Funciones sobre el sistema----------------------------------*/
  141. void link( char *url );
  142. /*----------------------------------------------------------------------------------------------*/
  143.  
  144.  
  145. /*----------------------------------Funciones de Fecha y Hora-----------------------------------*/
  146. char *mostrarFechaActual( void );
  147. char *mostrarFechaActualHoraActual( void );
  148. /*----------------------------------------------------------------------------------------------*/
  149.  
  150.  
  151. /*---------------------------Funciones de Carga de Datos del Sistema----------------------------*/
  152. void inicializarPais( struct Pais *pais, int totalRegiones );
  153. void reservarMemoriaRegiones( struct Pais *pais );
  154. void contarProvinciasPorRegion( struct Pais *pais, FILE *file );
  155. void reservarMemoriaProvincias( struct Pais *pais );
  156. void contarComunasPorProvincia( struct Pais *pais, FILE *file );
  157. void reservarMemoriaComunas( struct Pais *pais );
  158. void reservarMemoriaDatosDelSistema( struct Pais *pais, FILE *fileRegiones, FILE *fileProvincias);
  159. void cargarDatosDelSistema( struct Pais *pais, FILE *archivo );
  160. /*----------------------------------------------------------------------------------------------*/
  161.  
  162.  
  163. /*----------------------------------Funciones sobre archivos------------------------------------*/
  164. short exportarCsv( struct Pais pais, short exportarRobados, char *comuna, int *posComuna, int *posProvincia, int *posRegion, char ubicacion );
  165. int cuentaFilasDiferentes( FILE *file );
  166. short estaArchivoVacio( FILE* file );
  167. short copiarArchivo( FILE *destino, FILE *archivo );
  168. long totalFilas( FILE *file );
  169. /*----------------------------------------------------------------------------------------------*/
  170.  
  171.  
  172. /*--------------------------------Funciones sobre base de datos---------------------------------*/
  173. FILE *existeDataBase( void );
  174. void cargarDataBase( struct Pais *pais );
  175. void crearArchivoPropiedades( void );
  176. FILE *crearDataBase( void );
  177. void imprimeEnCsv( struct NodoAuto *arbol, int cont, FILE *file );
  178. void salvarCambios( struct Pais pais );
  179. /*----------------------------------------------------------------------------------------------*/
  180.  
  181.  
  182. /*------------------------------------Funciones sobre Arboles-----------------------------------*/
  183. short tieneHijos( struct NodoAuto *elem );
  184. struct NodoAuto *estaEnArbol( struct NodoAuto *arbol, long id );
  185. void insertarNodoAuto( struct NodoAuto **arbol, struct NodoAuto *nuevo );
  186. void podarNodoAuto( struct NodoAuto **arbol, long id );
  187. void mostrarArbolRecursivo( struct NodoAuto *arbol, int cont );
  188. void mostrarArbolIterativo( struct NodoAuto *arbol );
  189. /*----------------------------------------------------------------------------------------------*/
  190.  
  191.  
  192. /*-----------------------------------Funciones sobre Nodos--------------------------------------*/
  193. struct NodoAuto *crearNodoAuto( char *rut, char *patente, char *comuna );
  194. void intercambiarDatosNodoAuto( struct NodoAuto **elem1, struct NodoAuto **elem2 );
  195. void liberarNodoAuto( struct NodoAuto **elem );
  196. void apilarNodo( struct Pila **cumbrePila, struct NodoAuto *nuevo );
  197. struct NodoAuto *desapilarNodo( struct Pila **cumbrePila );
  198. /*----------------------------------------------------------------------------------------------*/
  199.  
  200.  
  201. /*-----------------------------------Funciones de comparacion-----------------------------------*/
  202. int cmpComunas( struct Comuna **elem1, struct Comuna **elem2 );
  203. int cmpProvincias( struct Provincia **elem1, struct Provincia **elem2 );
  204. int cmpRegiones( struct Region **elem1, struct Region **elem2 );
  205. /*----------------------------------------------------------------------------------------------*/
  206.  
  207.  
  208. /*-----------------------------------Funciones sobre Arreglos-----------------------------------*/
  209. int buscarComuna( struct Pais pais, char *nombreComuna, int *posRegion, int *posProvincia, int *posComuna );
  210. /*----------------------------------------------------------------------------------------------*/
  211.  
  212.  
  213. /*-----------------------------------Funciones de Validacion------------------------------------*/
  214. int esPatenteValida( char *patente );
  215. int esRutValido( char *rut );
  216. int esPalabra( char *str );
  217. /*----------------------------------------------------------------------------------------------*/
  218.  
  219.  
  220. /*-----------------------------------Funciones sobre Cadenas------------------------------------*/
  221. char *capitalizar( char *frase );
  222. char *strupr( char *str );
  223. char *leerHastaEnter( void );
  224. void suprimePuntosGuiones( char *rut );
  225. char *formatearRut( char *rut );
  226. long idPatente( char *patente );
  227. long parteEnteraRut( char *rut );
  228. char *suprimeEspacios( char *cadena );
  229. char *reiniciarCadena( char *str );
  230. /*----------------------------------------------------------------------------------------------*/
  231. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  232.  
  233.  
  234.  
  235.  
  236. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  237. Funciones sobre el sistema
  238. ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  239.  
  240. /*-----------------------Incia una pagina web en el navegador por defecto-----------------------*/
  241. void link( char *url )
  242. {
  243. size_t bytes = sizeof( "start " ) + strlen( url ) + 1;
  244. char *comando = ( char * ) malloc( bytes );
  245.  
  246. _snprintf( comando, bytes, "%s%s", "start ", url );
  247.  
  248. system( comando );
  249. free( comando );
  250. }
  251. /*----------------------------------------------------------------------------------------------*/
  252. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  253.  
  254.  
  255.  
  256.  
  257. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  258. Funciones de Fecha y Hora
  259. ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  260.  
  261. /*------------------------------------Retorna la fecha actual-----------------------------------*/
  262. char *mostrarFechaActual( void )
  263. {
  264. time_t tiempo;
  265. struct tm *ptrFecha;
  266. char *fecha;
  267.  
  268. const size_t bytes = 200;
  269. char *buffer = ( char * ) malloc( bytes );
  270.  
  271. tiempo = time( 0 );
  272. ptrFecha = localtime( &tiempo );
  273.  
  274. strftime( buffer, bytes, "%d %b %Y", ptrFecha );
  275.  
  276. fecha = ( char * ) malloc( strlen( buffer ));
  277. strcpy( fecha, buffer );
  278.  
  279. return fecha;
  280. }
  281. /*----------------------------------------------------------------------------------------------*/
  282.  
  283.  
  284. /*---------------------------------Retorna la fecha y hora actual-------------------------------*/
  285. char *mostrarFechaActualHoraActual( void )
  286. {
  287. time_t tiempo;
  288. struct tm *ptrFechaHora;
  289. char *fechaHora;
  290.  
  291. const size_t bytes = 200;
  292. char *buffer = ( char * ) malloc( bytes );
  293.  
  294. tiempo = time( 0 );
  295. ptrFechaHora = localtime( &tiempo );
  296.  
  297. strftime( buffer, bytes, "%a %b %d %X %Y", ptrFechaHora );
  298.  
  299. fechaHora = ( char * ) malloc( strlen( buffer ));
  300. strcpy( fechaHora, buffer );
  301.  
  302. return fechaHora;
  303. }
  304. /*----------------------------------------------------------------------------------------------*/
  305. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  306.  
  307.  
  308.  
  309.  
  310. /*--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  311. Funciones para Carga de datos del sistema
  312. ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  313.  
  314. /*--------------Incializa los arreglos dinamicos y los arboles en la estructura pais------------*/
  315. void inicializarPais( struct Pais *pais, int totalRegiones )
  316. {
  317. pais->totalRegiones = totalRegiones;
  318. pais->listaRegiones = NULL;
  319. pais->arbolRobadosEnPais = NULL;
  320. pais->arbolRecuperadosEnPais = NULL;
  321. }
  322. /*----------------------------------------------------------------------------------------------*/
  323.  
  324.  
  325. /*-------------------------------Reserva memoria para las regiones------------------------------*/
  326. void reservarMemoriaRegiones( struct Pais *pais )
  327. {
  328. int i;
  329. pais->listaRegiones = ( struct Region ** ) malloc( 15 * sizeof( struct Region * ));
  330.  
  331. for( i = 0; i < 15; i++ )
  332. {
  333. pais->listaRegiones[i] = ( struct Region * ) malloc( sizeof( struct Region ));
  334. }
  335. }
  336. /*----------------------------------------------------------------------------------------------*/
  337.  
  338.  
  339. /*-------------------------Cuenta el total de provincias de cada region-------------------------*/
  340. void contarProvinciasPorRegion( struct Pais *pais, FILE *file )
  341. {
  342. char *region = (char*) malloc(50), *buffer = (char*) malloc(50);
  343. int i = 0, j = 1;
  344.  
  345. fscanf( file,"%[^\n]\n", region );
  346. strcpy( buffer, region );
  347.  
  348. while( strcmp( region, "EOF" ) && fscanf( file, "%[^\n]\n", region ))
  349. {
  350. if( strcmp( region, buffer ))
  351. {
  352. pais->listaRegiones[i]->totalProvincias = j;
  353. strcpy( buffer, region );
  354.  
  355. j = 1;
  356. i++;
  357. }
  358. else j++;
  359. }
  360.  
  361. fclose( file );
  362. }
  363. /*----------------------------------------------------------------------------------------------*/
  364.  
  365.  
  366. /*------------------------------Reserva memoria para las provincias-----------------------------*/
  367. void reservarMemoriaProvincias( struct Pais *pais )
  368. {
  369. int i, j, bytesListaProvincia = pais->listaRegiones[i]->totalProvincias * sizeof( struct Provincia * );
  370.  
  371. for( i = 0; i < pais->totalRegiones; i++ )
  372. {
  373. pais->listaRegiones[i]->listaProvincias = ( struct Provincia ** ) malloc( bytesListaProvincia );
  374.  
  375. for( j = 0; j < pais->listaRegiones[i]->totalProvincias; j++ )
  376. {
  377. pais->listaRegiones[i]->listaProvincias[j] = ( struct Provincia * ) malloc( sizeof( struct Provincia ));
  378. }
  379. }
  380. }
  381. /*----------------------------------------------------------------------------------------------*/
  382.  
  383.  
  384. /*----------------------Cuenta el total de comunas que tiene cada provincia---------------------*/
  385. void contarComunasPorProvincia( struct Pais *pais, FILE *file )
  386. {
  387. char *provincia = (char*) malloc(50), *buffer = (char*) malloc(50);
  388. int i = 0, j = 1;
  389. int region = 0;
  390.  
  391. fscanf( file,"%[^\n]\n", provincia );
  392. strcpy( buffer, provincia );
  393.  
  394. while( strcmp( provincia, "EOF" ) && fscanf( file, "%[^\n]\n", provincia ))
  395. {
  396. if( strcmp( provincia, buffer ))
  397. {
  398. pais->listaRegiones[ region ]->listaProvincias[i]->totalComunas = j;
  399. strcpy( buffer, provincia );
  400. j = 1;
  401.  
  402. if( i+1 == pais->listaRegiones[ region ]->totalProvincias )
  403. {
  404. region++;
  405. i = 0;
  406. }
  407. else i++;
  408. }
  409. else j++;
  410. }
  411.  
  412. fclose( file );
  413. }
  414. /*----------------------------------------------------------------------------------------------*/
  415.  
  416.  
  417. /*-------------------------------Reserva memorias para las comunas------------------------------*/
  418. void reservarMemoriaComunas( struct Pais *pais )
  419. {
  420. int i, j, k, bytesListaComunas = pais->listaRegiones[i]->listaProvincias[j]->totalComunas * sizeof( struct Comuna * );
  421.  
  422. for( i = 0; i < pais->totalRegiones; i++ )
  423. {
  424. for( j = 0; j < pais->listaRegiones[i]->totalProvincias; j++ )
  425. {
  426. pais->listaRegiones[i]->listaProvincias[j]->listaComunas = ( struct Comuna ** ) malloc( bytesListaComunas );
  427.  
  428. for( k = 0; k < pais->listaRegiones[i]->listaProvincias[j]->totalComunas; k++ )
  429. {
  430. pais->listaRegiones[i]->listaProvincias[j]->listaComunas[k] = ( struct Comuna* ) malloc( sizeof( struct Comuna ));
  431. pais->listaRegiones[i]->listaProvincias[j]->listaComunas[k]->arbolRobados = NULL;
  432. pais->listaRegiones[i]->listaProvincias[j]->listaComunas[k]->arbolRecuperados = NULL;
  433.  
  434. }
  435. }
  436. }
  437. }
  438. /*----------------------------------------------------------------------------------------------*/
  439.  
  440.  
  441. /*------------Cuenta las regiones, provincias y comunas y reserva memorias para ellas-----------*/
  442. void reservarMemoriaDatosDelSistema( struct Pais *pais, FILE *fileRegiones, FILE *fileProvincias)
  443. {
  444. reservarMemoriaRegiones( pais );
  445. contarProvinciasPorRegion( pais, fileRegiones );
  446. reservarMemoriaProvincias( pais );
  447. contarComunasPorProvincia( pais, fileProvincias );
  448. reservarMemoriaComunas( pais );
  449. }
  450. /*----------------------------------------------------------------------------------------------*/
  451.  
  452.  
  453. /*--------------------------------Compara * a comunas por nombre--------------------------------*/
  454. int cmpComunas( struct Comuna **elem1, struct Comuna **elem2 )
  455. {
  456. return strcmp(( *elem1 )->nombre, ( *elem2 )->nombre );
  457. }
  458. /*----------------------------------------------------------------------------------------------*/
  459.  
  460.  
  461. /*--------------------------------Compara * a provincias por nombre-----------------------------*/
  462. int cmpProvincias( struct Provincia **elem1, struct Provincia **elem2 )
  463. {
  464. return strcmp(( *elem1 )->nombre, ( *elem2 )->nombre );
  465. }
  466. /*----------------------------------------------------------------------------------------------*/
  467.  
  468.  
  469. /*--------------------------------Compara * a regiones por nombre-------------------------------*/
  470. int cmpRegiones( struct Region **elem1, struct Region **elem2 )
  471. {
  472. return strcmp(( *elem1 )->nombre, ( *elem2 )->nombre );
  473. }
  474. /*----------------------------------------------------------------------------------------------*/
  475.  
  476.  
  477. /*-------------------------------------Conversion a tipo int------------------------------------*/
  478. typedef int( *cast )( const void*, const void* );
  479. /*----------------------------------------------------------------------------------------------*/
  480.  
  481.  
  482. /*-----------------Lee los datos en los archivos y los almacena en los registros----------------*/
  483. void cargarDatosDelSistema( struct Pais *pais, FILE *archivo )
  484. {
  485. char nombreRegion[100], nombreProvincia[100], nombreComuna[100];
  486. int region = 0, provincia = 0, comuna = 0, totalComunas, totalProvincias, bytesComunas, bytesProvincias;
  487.  
  488. while( fscanf( archivo, "%[^;];", nombreRegion ) && strcmp( nombreRegion, "EOF" ))
  489. {
  490. fscanf( archivo, "%[^;];%[^\n]\n",nombreProvincia, nombreComuna );
  491.  
  492. strcpy( pais->listaRegiones[region]->listaProvincias[provincia]->listaComunas[comuna]->nombre, nombreComuna );
  493. comuna++;
  494.  
  495. if( comuna == pais->listaRegiones[region]->listaProvincias[provincia]->totalComunas )
  496. {
  497. totalComunas = pais->listaRegiones[region]->listaProvincias[provincia]->totalComunas;
  498. qsort( pais->listaRegiones[region]->listaProvincias[provincia]->listaComunas, totalComunas,
  499. sizeof( struct Comuna * ), (cast)cmpComunas );
  500.  
  501. strcpy(pais->listaRegiones[region]->listaProvincias[provincia]->nombre,nombreProvincia);
  502.  
  503. provincia++;
  504. comuna = 0;
  505. }
  506.  
  507. if( provincia == pais->listaRegiones[region]->totalProvincias )
  508. {
  509. qsort( pais->listaRegiones[region]->listaProvincias, pais->listaRegiones[region]->totalProvincias,
  510. sizeof( struct Provincia * ), (cast)cmpProvincias );
  511.  
  512. strcpy(pais->listaRegiones[region]->nombre,nombreRegion);
  513.  
  514. region++;
  515. provincia = 0;
  516. comuna = 0;
  517. }
  518. }
  519.  
  520. qsort( pais->listaRegiones, pais->totalRegiones, sizeof( struct Region * ), (cast)cmpRegiones );
  521. fclose( archivo );
  522. }
  523. /*----------------------------------------------------------------------------------------------*/
  524. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  525.  
  526.  
  527.  
  528.  
  529. /*--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  530. Funciones sobre archivos
  531. ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  532.  
  533. /*----------------------Cuenta el total de filas diferentes en un archivo-----------------------*/
  534. int cuentaFilasDiferentes( FILE *file )
  535. {
  536. char cadena[100], buffer[100];
  537. int contador = 1;
  538.  
  539. fscanf( file, "%[^\n]\n", cadena );
  540. strcpy( buffer, cadena );
  541.  
  542. while( fscanf( file, "%[^\n]\n", cadena ) && strcmp( cadena, "EOF" ))
  543. {
  544. if( strcmp( cadena, buffer ))
  545. {
  546. contador++;
  547. strcpy( buffer, cadena );
  548. }
  549. }
  550.  
  551. rewind( file );
  552. return contador;
  553. }
  554. /*----------------------------------------------------------------------------------------------*/
  555.  
  556.  
  557. /*-------------------------------Verifica si un archivo esta vacio------------------------------*/
  558. short estaArchivoVacio( FILE* file )
  559. {
  560. fseek( file, 0, SEEK_END );
  561.  
  562. if( ftell( file )) return 1;
  563.  
  564. rewind( file );
  565. return 0;
  566. }
  567. /*----------------------------------------------------------------------------------------------*/
  568.  
  569.  
  570. /*---------------------------Copia el contenido de un archivo en otro---------------------------*/
  571. short copiarArchivo( FILE *destino, FILE *archivo )
  572. {
  573. char caracter;
  574. rewind( archivo );
  575.  
  576. if( destino != NULL )
  577. {
  578. while( fscanf( archivo, "%c", &caracter ) != EOF )
  579. {
  580. fprintf( destino, "%c", caracter );
  581. }
  582.  
  583. return 1;
  584. }
  585. return 0;
  586. }
  587. /*----------------------------------------------------------------------------------------------*/
  588.  
  589.  
  590. /*--------------------------Retorna la cantidad de filas de un archivo--------------------------*/
  591. long totalFilas( FILE *file )
  592. {
  593. char car;
  594. long contador = 0;
  595.  
  596. while( fscanf( file, "%c", &car ) && !feof( file ))
  597. {
  598. if( car == '\n' ) contador++;
  599. }
  600.  
  601. return contador;
  602.  
  603. rewind( file );
  604. fclose( file );
  605. }
  606. /*----------------------------------------------------------------------------------------------*/
  607.  
  608.  
  609. /*------------Crear un archivo CSV con los vehiculos robados en el pais o por comuna------------*/
  610. short exportarCsv( struct Pais pais, short exportarRobados, char *comuna, int *posComuna, int *posProvincia, int *posRegion, char ubicacion )
  611. {
  612. enum AccesosRapidos{ Documentos = '1', Escritorio = '2', Descargas = '3', DiscoLocalC = '4' };
  613.  
  614. char *rutaDeExportacion = ( char * ) malloc( 500 ), *nombreUsuario = getenv( "USERPROFILE" );
  615. FILE *exportar;
  616.  
  617. /*-----------------------------------Se crea la ruta en funcion de la ubicacion seleccionada por el usuario----------------------------------*/
  618. switch( ubicacion )
  619. {
  620. case Documentos:
  621.  
  622. if( exportarRobados )
  623. {
  624. _snprintf( rutaDeExportacion, 500, "%s\\Documents\\vehiculos_robados.csv", nombreUsuario )
  625. }
  626. else _snprintf( rutaDeExportacion, 500, "%s\\Documents\\vehiculos_recuperados.csv", nombreUsuario );
  627.  
  628. break;
  629.  
  630. case Escritorio:
  631.  
  632. if( exportarRobados )
  633. {
  634. _snprintf( rutaDeExportacion, 500, "%s\\Desktop\\vehiculos_robados.csv", nombreUsuario )
  635. }
  636. else _snprintf( rutaDeExportacion, 500, "%s\\Desktop\\vehiculos_recuperados.csv", nombreUsuario );
  637.  
  638. break;
  639.  
  640. case Descargas:
  641.  
  642. if( exportarRobados )
  643. {
  644. _snprintf( rutaDeExportacion, 500, "%s\\Downloads\\vehiculos_robados.csv", nombreUsuario )
  645. }
  646. else _snprintf( rutaDeExportacion, 500, "%s\\Downloads\\vehiculos_recuperados.csv", nombreUsuario );
  647.  
  648. break;
  649.  
  650. case DiscoLocalC:
  651.  
  652. strcpy( rutaDeExportacion, "C:\\" );
  653. break;
  654. }
  655.  
  656. exportar = fopen( rutaDeExportacion, "w" );
  657.  
  658. if( exportar == NULL ) return 0;
  659.  
  660. fprintf( exportar, "%s%c%s%c%s\n", "R.U.T", ';', "PATENTE", ';', "COMUNA" );
  661.  
  662. /*-------------------------------------Si la posicion es invalada entonces se debe exportar la tabla completa------------------------------------*/
  663. if( *posComuna == -1 )
  664. {
  665. exportarRobados ? imprimeEnCsv( pais.arbolRobadosEnPais, 0, exportar ) : imprimeEnCsv( pais.arbolRecuperadosEnPais, 0, exportar );
  666. }
  667. else
  668. {
  669. exportarRobados ? imprimeEnCsv( pais.arbolRobadosEnPais, 0, exportar ) : imprimeEnCsv( pais.arbolRecuperadosEnPais, 0, exportar );
  670. }
  671.  
  672. return 1;
  673. }
  674. /*----------------------------------------------------------------------------------------------*/
  675. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  676.  
  677.  
  678.  
  679.  
  680. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  681. Funciones sobre base de datos (Tablas CSV).
  682. ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  683.  
  684. /*-------------------------Verifica la existencia de una base de datos--------------------------*/
  685. FILE *existeDataBase( void )
  686. {
  687. FILE * verificador = fopen( "data-base/create=true", "r" );
  688. return verificador;
  689. }
  690. /*----------------------------------------------------------------------------------------------*/
  691.  
  692.  
  693. /*-------------------------Carga la base de datos en la estructura pais-------------------------*/
  694. void cargarDataBase( struct Pais *pais )
  695. {
  696. char patente[7], rut[12], comuna[30];
  697. int posRegion, posProvincia, posComuna;
  698.  
  699. FILE *tablaRobados = fopen( "data-base/tablas/tabla_robados.csv", "r+" );
  700. FILE *tablaRecuperados = fopen( "data-base/tablas/tabla_recuperados.csv", "r+" );
  701.  
  702. if( tablaRobados != NULL )
  703. {
  704. /*-----------------------------Se carga la tabla de vehiculos robados-----------------------------*/
  705. while( fscanf( tablaRobados, "%[^;];%[^;];%[^\n]\n", rut, patente, comuna ) != EOF )
  706. {
  707. if( buscarComuna(( *pais ), comuna, &posRegion, &posProvincia, &posComuna ))
  708. {
  709. insertarNodoAuto( &pais->arbolRobadosEnPais , crearNodoAuto( rut, patente, comuna ));
  710. insertarNodoAuto( &pais->listaRegiones[ posRegion ]->listaProvincias[ posProvincia ]->listaComunas[ posComuna ]->arbolRobados,
  711. crearNodoAuto( rut, patente, comuna ));
  712. }
  713. }
  714.  
  715. fclose( tablaRobados );
  716. }
  717.  
  718. if( tablaRecuperados != NULL )
  719. {
  720. /*---------------------------Se carga la tabla de vehiculos recuperados---------------------------*/
  721. while( fscanf( tablaRecuperados, "%[^;];%[^;];%[^\n]\n", rut, patente, comuna ) != EOF )
  722. {
  723. if( buscarComuna(( *pais ), comuna, &posRegion, &posProvincia, &posComuna ))
  724. {
  725. insertarNodoAuto( &pais->arbolRecuperadosEnPais, crearNodoAuto( rut, patente, comuna ));
  726. insertarNodoAuto( &pais->listaRegiones[ posRegion ]->listaProvincias[ posProvincia ]->listaComunas[ posComuna ]->arbolRecuperados,
  727. crearNodoAuto( rut, patente, comuna ));
  728. }
  729. }
  730.  
  731. fclose( tablaRecuperados );
  732. }
  733. }
  734. /*----------------------------------------------------------------------------------------------*/
  735.  
  736.  
  737. /*-------------------Crear un archivo con las propiedades de la base de datos-------------------*/
  738. void crearArchivoPropiedades( void )
  739. {
  740. FILE *filePropiedades = fopen( "data-base/propiedades.properties", "w" );
  741. const size_t bytes = 500;
  742. char *directorioDeTrabajo = ( char * ) malloc( bytes );
  743.  
  744. getcwd( directorioDeTrabajo, bytes );
  745.  
  746. fprintf( filePropiedades, "%s%s%s\n", "# ", directorioDeTrabajo,"/data-base" );
  747. fprintf( filePropiedades, "%s\n", "# ********************************************************************" );
  748. fprintf( filePropiedades, "%s\n", "# *** Por favor NO editar este archivo. ***" );
  749. fprintf( filePropiedades, "%s\n", "# *** CAMBIAR EL CONTENIDO PUEDE CAUSAR CORuUPCION EN LOS DATOS. ***" );
  750. fprintf( filePropiedades, "%s\n", "# ********************************************************************" );
  751. fprintf( filePropiedades, "%s%s\n", "# ",mostrarFechaActualHoraActual());
  752.  
  753. fclose( filePropiedades );
  754. }
  755. /*----------------------------------------------------------------------------------------------*/
  756.  
  757.  
  758. /*---------------------------------Crea una nueva base de datos---------------------------------*/
  759. FILE *crearDataBase( void )
  760. {
  761. FILE *logError, *verificador, *aviso, *avisoCopia, *tablaRobados, *tablaRecuperados;
  762.  
  763. if( mkdir( "data-base" ) != -1 )
  764. {
  765. aviso = fopen( "data-base/LEEME_NO_TOCAR_ESTOS_ARCHIVOS.txt", "w" );
  766. fprintf( aviso, "%s", "************ NO TOCAR LOS ARCHIVOS DE ESTE DIRECTORIO! ************ " );
  767.  
  768. crearArchivoPropiedades();
  769. logError = fopen( "data-base/reporte_errores.dat", "w" );
  770.  
  771. if( mkdir( "data-base/tablas" ) != -1 )
  772. {
  773. tablaRobados = fopen( "data-base/tablas/tabla_robados.csv", "a" );
  774. tablaRecuperados = fopen( "data-base/tablas/tabla_recuperados.csv", "a" );
  775.  
  776. if( tablaRobados && tablaRecuperados )
  777. {
  778. verificador = fopen( "data-base/create=true", "w" );
  779. avisoCopia = fopen( "data-base/tablas/LEEME_NO_TOCAR_ESTOS_ARCHIVOS.txt", "w" );
  780. copiarArchivo( avisoCopia, aviso );
  781.  
  782. fclose( aviso );
  783. fclose( logError );
  784. fclose( tablaRobados );
  785. fclose( tablaRecuperados );
  786.  
  787. return verificador;
  788. }
  789. else return NULL;
  790. }
  791. else return NULL;
  792. }
  793. else return NULL;
  794. }
  795. /*----------------------------------------------------------------------------------------------*/
  796.  
  797.  
  798. /*-----------------------Imprime el contenido de un arbol en un archivo CSV---------------------*/
  799. void imprimeEnCsv( struct NodoAuto *arbol, int cont, FILE *file )
  800. {
  801. if ( arbol != NULL )
  802. {
  803. imprimeEnCsv( arbol->izq, cont+1, file );
  804. fprintf( file, "%s%c%s%c%s\n", arbol->datos->rutPropietario, ';', arbol->datos->patente, ';', arbol->datos->nombreComuna );
  805. imprimeEnCsv( arbol->der, cont+1, file );
  806. }
  807. else return;
  808. }
  809. /*----------------------------------------------------------------------------------------------*/
  810.  
  811.  
  812. /*--------------------Guarda el contenido de los arboles en la base de datos--------------------*/
  813. void salvarCambios( struct Pais pais )
  814. {
  815. FILE *tablaRobados = fopen( "data-base/tablas/tabla_robados.csv", "w" );
  816. FILE *tablaRecuperados = fopen( "data-base/tablas/tabla_recuperados.csv", "w" );
  817.  
  818. imprimeEnCsv( pais.arbolRobadosEnPais, 0, tablaRobados );
  819. imprimeEnCsv( pais.arbolRecuperadosEnPais, 0, tablaRecuperados );
  820.  
  821. fclose( tablaRobados );
  822. fclose( tablaRecuperados );
  823. }
  824. /*----------------------------------------------------------------------------------------------*/
  825. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  826.  
  827.  
  828.  
  829.  
  830. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  831. Funciones sobre arreglos
  832. ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  833.  
  834. /*--------------------Busca una comuna en un arreglo y guarda las posiciones--------------------*/
  835. int buscarComuna( struct Pais pais, char *nombreComuna, int *posRegion, int *posProvincia, int *posComuna )
  836. {
  837. int i, j, k;
  838.  
  839. for( i = 0; i < pais.totalRegiones; i++ )
  840. {
  841. for( j = 0; j < pais.listaRegiones[i]->totalProvincias; j++ )
  842. {
  843. for( k = 0; k < pais.listaRegiones[i]->listaProvincias[j]->totalComunas; k++ )
  844. {
  845. if( !strcmp( pais.listaRegiones[i]->listaProvincias[j]->listaComunas[k]->nombre, strupr( nombreComuna )))
  846. {
  847. *posRegion = i;
  848. *posProvincia = j;
  849. *posComuna = k;
  850. return 1;
  851. }
  852. }
  853. }
  854. }
  855. return 0;
  856. }
  857. /*----------------------------------------------------------------------------------------------*/
  858. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  859.  
  860.  
  861.  
  862.  
  863. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  864. Funciones sobre Nodos
  865. ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  866.  
  867. /*------------------------------------Crea un nuevo nodo auto-----------------------------------*/
  868. struct NodoAuto *crearNodoAuto( char *rut, char *patente, char *comuna )
  869. {
  870. struct NodoAuto *nuevo = ( struct NodoAuto * ) malloc( sizeof( struct NodoAuto ));
  871.  
  872. nuevo->datos = ( struct Auto * ) malloc( sizeof( struct Auto ));
  873. nuevo->id = idPatente( patente );
  874.  
  875. nuevo->datos->rutPropietario = ( char * ) malloc( 12 );
  876. strcpy( nuevo->datos->rutPropietario, rut );
  877.  
  878. nuevo->datos->patente = ( char * ) malloc( 7 );
  879. strcpy( nuevo->datos->patente, patente );
  880.  
  881. nuevo->datos->nombreComuna = ( char * ) malloc( 30 );
  882. strcpy( nuevo->datos->nombreComuna, comuna );
  883.  
  884. nuevo->izq = NULL;
  885. nuevo->der = NULL;
  886.  
  887. return nuevo;
  888. }
  889. /*----------------------------------------------------------------------------------------------*/
  890.  
  891.  
  892. /*--------------------------Intercambia el contenido de dos nodos auto--------------------------*/
  893. void intercambiarDatosNodoAuto( struct NodoAuto **elem1, struct NodoAuto **elem2 )
  894. {
  895. struct Auto *datos;
  896. long id;
  897.  
  898. datos = ( *elem1 )->datos;
  899. id = ( *elem1 )->id;
  900.  
  901. ( *elem1 )->datos = ( *elem2 )->datos;
  902. ( *elem1 )->id = ( *elem2 )->id;
  903.  
  904. ( *elem2 )->datos = datos;
  905. ( *elem2 )->id = id;
  906.  
  907. *elem1 = *elem2;
  908. }
  909. /*----------------------------------------------------------------------------------------------*/
  910.  
  911.  
  912. /*----------------------Libera la memoria de un nodo auto y lo inicializa-----------------------*/
  913. void liberarNodoAuto( struct NodoAuto **elem )
  914. {
  915. free( *elem );
  916. *elem = NULL;
  917. }
  918. /*----------------------------------------------------------------------------------------------*/
  919.  
  920.  
  921. /*-------------------------------Inserta un nodo auto en una pila-------------------------------*/
  922. void apilarNodo( struct Pila **cumbrePila, struct NodoAuto *nuevo )
  923. {
  924. struct Pila *pila = ( struct Pila * ) malloc( sizeof( struct Pila ));
  925.  
  926. pila->nodo = nuevo;
  927. pila->sig = *cumbrePila;
  928. *cumbrePila = pila;
  929. }
  930. /*----------------------------------------------------------------------------------------------*/
  931.  
  932.  
  933. /*---------------------------Retorna el nodo auto cumbre de una pila----------------------------*/
  934. struct NodoAuto *desapilarNodo( struct Pila **cumbrePila )
  935. {
  936. struct Pila *pila = NULL;
  937. struct NodoAuto *nodo = NULL;
  938.  
  939. pila = *cumbrePila;
  940. nodo = pila->nodo;
  941. *cumbrePila = pila->sig;
  942. free( pila );
  943.  
  944. return nodo;
  945. }
  946. /*----------------------------------------------------------------------------------------------*/
  947.  
  948.  
  949. /*--------------------------------Modifica el rut en un nodo auto-------------------------------*/
  950. short modificarRut( struct NodoAuto **arbol, long id, char *nuevoRut )
  951. {
  952. struct NodoAuto *nodoModificar = estaEnArbol((*arbol),id);
  953.  
  954. if (nodoModificar != NULL)
  955. {
  956. strcpy( nodoModificar->datos->rutPropietario, nuevoRut );
  957. return 1;
  958. }
  959. return 0;
  960. }
  961. /*----------------------------------------------------------------------------------------------*/
  962.  
  963.  
  964. /*-------------------------------Modica la patente de un nodo auto------------------------------*/
  965. short modificarPatente (struct NodoAuto **arbol, long id, char *nuevaPatente) {
  966.  
  967. struct NodoAuto *nodoModificar = estaEnArbol(( *arbol ), id );
  968.  
  969. if( nodoModificar != NULL )
  970. {
  971. strcpy( nodoModificar->datos->patente, nuevaPatente );
  972. nodoModificar->id = idPatente( nuevaPatente );
  973. return 1;
  974. }
  975. return 0;
  976. }
  977. /*----------------------------------------------------------------------------------------------*/
  978.  
  979.  
  980. /*------------------------Modifica la nombre de la comuna en un nodo auto-----------------------*/
  981. short modificarComuna (struct NodoAuto **arbol, long id, char *nuevaComuna)
  982. {
  983. struct NodoAuto *nodoModificar = estaEnArbol(( *arbol ), id );
  984.  
  985. if( nodoModificar != NULL )
  986. {
  987. strcpy( nodoModificar->datos->nombreComuna, nuevaComuna );
  988. return 1;
  989. }
  990. return 0;
  991. }
  992. /*----------------------------------------------------------------------------------------------*/
  993. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  994.  
  995.  
  996.  
  997.  
  998. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  999. Funciones sobre Arboles
  1000. ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  1001.  
  1002. /*-----------------------Verifica si un nodo de un arbol tiene nodos hijos----------------------*/
  1003. short tieneHijos( struct NodoAuto *elem )
  1004. {
  1005. if( elem->izq != NULL || elem->der != NULL ) return 1;
  1006. else return 0;
  1007. }
  1008. /*----------------------------------------------------------------------------------------------*/
  1009.  
  1010.  
  1011. /*-----------------Retorna un nodo buscado en un arbol o NULL en caso contrario-----------------*/
  1012. struct NodoAuto *estaEnArbol( struct NodoAuto *arbol, long id )
  1013. {
  1014. struct NodoAuto *actual = arbol;
  1015.  
  1016. while( actual != NULL )
  1017. {
  1018. if( id != actual->id )
  1019. {
  1020. if( id < actual->id )
  1021. {
  1022. actual = actual->izq;
  1023. }
  1024. else actual = actual->der;
  1025. }
  1026. else return actual;
  1027. }
  1028. return NULL;
  1029. }
  1030. /*----------------------------------------------------------------------------------------------*/
  1031.  
  1032.  
  1033. /*-----------------------------------Inserta un nodo ordenado-----------------------------------*/
  1034. void insertarNodoAuto( struct NodoAuto **arbol, struct NodoAuto *nuevo )
  1035. {
  1036. struct NodoAuto *anterior = NULL, *actual = *arbol;
  1037.  
  1038. if( *arbol != NULL )
  1039. {
  1040. do
  1041. {
  1042. anterior = actual;
  1043.  
  1044. if( nuevo->id < actual->id )
  1045. {
  1046. actual = actual->izq;
  1047. }
  1048. else actual = actual->der;
  1049. }
  1050. while( actual != NULL );
  1051.  
  1052. actual = nuevo;
  1053.  
  1054. if( nuevo->id < anterior->id )
  1055. {
  1056. anterior->izq = actual;
  1057. }
  1058. else anterior->der = actual;
  1059.  
  1060. }
  1061. else *arbol = nuevo;
  1062. }
  1063. /*----------------------------------------------------------------------------------------------*/
  1064.  
  1065.  
  1066. /*----------------------------------Suprime un nodo de un arbol---------------------------------*/
  1067. void podarNodoAuto( struct NodoAuto **arbol, long id )
  1068. {
  1069. struct NodoAuto *nodoPadre = NULL, *nodoTemporal = NULL, *nodoActual = *arbol;
  1070.  
  1071. if( !tieneHijos( *arbol ) && ( *arbol )->id == id )
  1072. {
  1073. *arbol = NULL;
  1074. return;
  1075. }
  1076.  
  1077. while( nodoActual != NULL )
  1078. {
  1079. if( id != nodoActual->id )
  1080. {
  1081. nodoPadre = nodoActual;
  1082.  
  1083. if( id < nodoActual->id )
  1084. {
  1085. nodoActual = nodoActual->izq;
  1086. }
  1087. else nodoActual = nodoActual->der;
  1088. }
  1089. else
  1090. {
  1091. if( !tieneHijos( nodoActual ))
  1092. {
  1093. if( nodoPadre != NULL )
  1094. {
  1095. if( nodoPadre->izq == nodoActual )
  1096. {
  1097. nodoPadre->izq = NULL;
  1098. }
  1099. else nodoPadre->der = NULL;
  1100. }
  1101.  
  1102. liberarNodoAuto( &nodoActual );
  1103. return;
  1104. }
  1105. else
  1106. {
  1107. nodoPadre = nodoActual;
  1108.  
  1109. if( nodoActual->der != NULL )
  1110. {
  1111. for( nodoTemporal = nodoActual->der; nodoTemporal->izq != NULL; nodoPadre = nodoTemporal, nodoTemporal = nodoTemporal->izq );
  1112. }
  1113. else for( nodoTemporal = nodoActual->izq; nodoTemporal->der != NULL; nodoPadre = nodoTemporal, nodoTemporal = nodoTemporal->der );
  1114.  
  1115. intercambiarDatosNodoAuto( &nodoActual, &nodoTemporal );
  1116. }
  1117. }
  1118. }
  1119. }
  1120. /*----------------------------------------------------------------------------------------------*/
  1121.  
  1122.  
  1123. /*-----------Busca una patente especifa guardando el valor de verdad en estaEncargado-----------*/
  1124. void consultarPatente( struct NodoAuto *arbol, char *patente, short *estaEncargado )
  1125. {
  1126. if ( arbol != NULL )
  1127. {
  1128. if( !strcmp( patente, arbol->datos->patente ))
  1129. {
  1130. *estaEncargado = 1;
  1131. return;
  1132. }
  1133.  
  1134. consultarPatente( arbol->der, patente, estaEncargado );
  1135. consultarPatente( arbol->izq, patente, estaEncargado );
  1136. }
  1137. else return;
  1138. }
  1139. /*----------------------------------------------------------------------------------------------*/
  1140.  
  1141.  
  1142. /*---------------------Imprime de forma recursiva el contenido de un arbol----------------------*/
  1143. void mostrarArbolRecursivo( struct NodoAuto *arbol, int cont )
  1144. {
  1145. if ( arbol != NULL )
  1146. {
  1147. mostrarArbolRecursivo( arbol->izq, cont+1 );
  1148. printf( "\t%s\n", "| | | |" );
  1149. printf( "\t%s%-11s%s", "| ", arbol->datos->rutPropietario, "| " );
  1150. printf( "%-8s%s%-21s%s\n", strupr( arbol->datos->patente ), "| ", capitalizar( arbol->datos->nombreComuna ), "|");
  1151. printf( "\t%s\n", "|____________|_________|______________________|" );
  1152. mostrarArbolRecursivo( arbol->der, cont+1 );
  1153. }
  1154. else return;
  1155. }
  1156. /*----------------------------------------------------------------------------------------------*/
  1157.  
  1158.  
  1159. /*--------------------Muestra el contenido de un arbol, en formato de tabla---------------------*/
  1160. void muestraConFormato( struct NodoAuto *arbol, char *encabezado )
  1161. {
  1162. printf( "\n\t"C33"%s\n"C00, encabezado );
  1163. printf( "\t%s\n", " _____________________________________________" );
  1164. printf( "\t%s\n", "| | | |" );
  1165. printf( "\t%s\n", "| RUT | PATENTE | COMUNA |" );
  1166. printf( "\t%s\n", "|____________|_________|______________________|" );
  1167. mostrarArbolRecursivo( arbol, 0 );
  1168. printf( "\n\t"C34 );
  1169. }
  1170. /*----------------------------------------------------------------------------------------------*/
  1171.  
  1172.  
  1173. /*--------------Funcion iterativa para recorrer y mostrar el contenido de un arbol--------------*/
  1174. void mostrarArbolIterativo( struct NodoAuto *arbol )
  1175. {
  1176. struct Pila *pila = NULL;
  1177.  
  1178. apilarNodo( &pila, NULL );
  1179.  
  1180. while( pila )
  1181. {
  1182. while( arbol )
  1183. {
  1184. apilarNodo( &pila, arbol );
  1185. arbol = arbol->izq;
  1186. }
  1187. if( pila )
  1188. {
  1189. arbol = desapilarNodo( &pila );
  1190.  
  1191. if( pila )
  1192. {
  1193. printf( "%ld\n", arbol->id );
  1194. }
  1195. }
  1196. arbol = arbol->der;
  1197. }
  1198. }
  1199. /*----------------------------------------------------------------------------------------------*/
  1200. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  1201.  
  1202.  
  1203.  
  1204.  
  1205. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  1206. Funciones de Validación
  1207. ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  1208.  
  1209. /*-------------------Valida que la cadena recibida, corresponda a una patente-------------------*/
  1210. int esPatenteValida( char *patente )
  1211. {
  1212. int i;
  1213. int flag = 0, letras = 0,numeros = 0;
  1214. char *abecedarioValido = ( char * ) "ABCDEFGHJKLPRSTVWXYZ";
  1215.  
  1216. if( strlen( patente ) == 6 )
  1217. {
  1218. for( i = 0; i < 6; i++ )
  1219. {
  1220. if( isalpha( patente[i] ) && strchr( abecedarioValido, toupper( patente[i] )))
  1221. {
  1222. letras++;
  1223.  
  1224. if(( letras == 2 || letras == 4 ) && numeros == 0 )
  1225. {
  1226. flag = 1;
  1227. }
  1228. else flag = 0;
  1229. }
  1230.  
  1231. if( isdigit( patente[i] )) numeros++;
  1232. }
  1233.  
  1234. if(( numeros == 2 || numeros == 4 ) && flag ) return 1;
  1235. return 0;
  1236. }
  1237. else return 0;
  1238. }
  1239. /*----------------------------------------------------------------------------------------------*/
  1240.  
  1241.  
  1242. /*---------------------Valida que la cadena recibida, corresponda a un RUT----------------------*/
  1243. int esRutValido( char *rut )
  1244. {
  1245. if( strlen( rut ) < 8 || strlen( rut ) > 9 )
  1246. return 0;
  1247. else return 1;
  1248. }
  1249. /*----------------------------------------------------------------------------------------------*/
  1250.  
  1251.  
  1252. /*------------------Funcion booleana que permite verificar si un rut es valido------------------*/
  1253. short validarDigitoVerificadorRut( char *rut )
  1254. {
  1255. int i, j, mod, sumatoria = 0, largo = strlen( rut );
  1256. char verificador;
  1257.  
  1258. for( i = largo - 2, j = 2; i >= 0; i--, j++ )
  1259. {
  1260. sumatoria += ( rut[i] - 48 ) * j;
  1261.  
  1262. if( j == 7 )
  1263. j = 1;
  1264. }
  1265.  
  1266. mod = sumatoria % 11;
  1267. sumatoria = 11 - mod;
  1268.  
  1269. if( sumatoria == 11 )
  1270. {
  1271. verificador = '0';
  1272. }
  1273. else
  1274. {
  1275. if( sumatoria == 10 )
  1276. {
  1277. verificador = 'k';
  1278. }
  1279. else verificador = sumatoria + 48;
  1280. }
  1281.  
  1282. if( verificador == rut[ largo-1 ] )
  1283. {
  1284. return 1;
  1285. }
  1286. else return 0;
  1287. }
  1288. /*----------------------------------------------------------------------------------------------*/
  1289. /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  1290.  
  1291.  
  1292.  
  1293.  
  1294. /*--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  1295. Funciones sobre Cadenas
  1296. ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
  1297.  
  1298. /*---------------------------Suprime espacios sobrantes en una cadena---------------------------*/
  1299. char *suprimeEspacios( char *cadena )
  1300. {
  1301. size_t bytes = sizeof( strlen( cadena ));
  1302. char *buffer = ( char * ) malloc( bytes );
  1303.  
  1304. int i = 0, j = 0, k = 0;
  1305.  
  1306. while( isspace( cadena[j] ))
  1307. j++;
  1308.  
  1309. for( i = j, j = 0; cadena[i] != '\0'; i++ )
  1310. {
  1311. if( isspace( cadena[i] ))
  1312. {
  1313. buffer[k] = cadena[i];
  1314. k++;
  1315. j = 0;
  1316. }
  1317. else j++;
  1318.  
  1319. if( j == 1 )
  1320. {
  1321. buffer[k] = cadena[i];
  1322. k++;
  1323. }
  1324. }
  1325.  
  1326. buffer[k] = '\0';
  1327. return buffer;
  1328. }
  1329. /*----------------------------------------------------------------------------------------------*/
  1330.  
  1331.  
  1332. /*------------------------Deja en Mayus la primera letra de cada palabra------------------------*/
  1333. char *capitalizar( char *frase )
  1334. {
  1335. int i;
  1336. frase[0] = toupper( frase[0] );
  1337.  
  1338. for( i = 1; frase[i] != '\0'; i++ )
  1339. {
  1340. if( isspace( frase[i-1] ))
  1341. {
  1342. frase[i] = toupper( frase[i] );
  1343. }
  1344. else frase[i] = tolower( frase[i] );
  1345. }
  1346.  
  1347. return frase;
  1348. }
  1349. /*----------------------------------------------------------------------------------------------*/
  1350.  
  1351.  
  1352. /*-----------------------------Genera un Id unico para cada patente-----------------------------*/
  1353. long idPatente( char *patente )
  1354. {
  1355. int i;
  1356. long acumulador = 0, prod = 1;
  1357.  
  1358. for( i = 0; patente[i] != '\0'; i++ )
  1359. {
  1360. acumulador += toupper( patente[i] ) * prod;
  1361. prod *= 10;
  1362. }
  1363.  
  1364. return acumulador;
  1365. }
  1366. /*----------------------------------------------------------------------------------------------*/
  1367.  
  1368.  
  1369. /*--------------------Lee caracter a caracter hasta encontrar un enter '\n'---------------------*/
  1370. char *leerHastaEnter( void )
  1371. {
  1372. int i;
  1373. char caracter;
  1374. char *cadena, *buffer = ( char * ) malloc( 200 ); ;
  1375.  
  1376. scanf( "%c", &caracter );
  1377.  
  1378. for( i = 0; caracter != ENTER; i++ )
  1379. {
  1380. buffer[i] = caracter;
  1381. scanf( "%c", &caracter );
  1382. }
  1383. buffer[i] = '\0';
  1384.  
  1385. cadena = ( char * ) malloc( i );
  1386. strcpy( cadena, buffer );
  1387. free( buffer );
  1388.  
  1389. return cadena;
  1390. }
  1391. /*----------------------------------------------------------------------------------------------*/
  1392.  
  1393.  
  1394. /*----------------------------Suprime los puntos y guiones en un rut----------------------------*/
  1395. void suprimePuntosGuiones( char *rut )
  1396. {
  1397. char *buffer = ( char * ) malloc( strlen( rut ));
  1398. char *digitos = "1234567890Kk";
  1399.  
  1400. int i, j;
  1401.  
  1402. for( i = 0, j = 0; rut[i] != '\0'; i++ )
  1403. {
  1404. if( strchr( digitos, rut[i] ) != NULL )
  1405. {
  1406. buffer[j] = rut[i];
  1407. j++;
  1408. }
  1409. }
  1410.  
  1411. buffer[j] = '\0';
  1412.  
  1413. strcpy( rut, buffer );
  1414. }
  1415. /*----------------------------------------------------------------------------------------------*/
  1416.  
  1417.  
  1418. /*------------------------------Inserta los puntos y guion en el rut----------------------------*/
  1419. char *formatearRut( char *rut )
  1420. {
  1421. int i, j, largo = strlen( rut );
  1422. char *buffer = ( char * ) malloc( strlen( rut ) + 3 );
  1423.  
  1424. if( largo == 8 )
  1425. {
  1426. for( i = 0, j = 0; j < strlen( rut ); i++ )
  1427. {
  1428. if( i != 1 && i != 5 && i != 9 )
  1429. {
  1430. buffer[i] = rut[j];
  1431. j++;
  1432. }
  1433. }
  1434.  
  1435. buffer[1] = '.';
  1436. buffer[5] = '.';
  1437. buffer[9] = '-';
  1438. buffer[11] = '\0';
  1439.  
  1440. return buffer;
  1441. }
  1442. else
  1443. {
  1444. if( largo == 9 )
  1445. {
  1446. for( i = 0, j = 0; j < strlen( rut ); i++ )
  1447. {
  1448. if( i != 2 && i != 6 && i != 10 )
  1449. {
  1450. buffer[i] = rut[j];
  1451. j++;
  1452. }
  1453. }
  1454.  
  1455. buffer[2] = '.';
  1456. buffer[6] = '.';
  1457. buffer[10] = '-';
  1458. buffer[12] = '\0';
  1459.  
  1460. return buffer;
  1461. }
  1462. }
  1463. return rut;
  1464. }
  1465. /*----------------------------------------------------------------------------------------------*/
  1466.  
  1467.  
  1468. /*------------------------------Retorna la parte entera de un RUT-S/Dv--------------------------*/
  1469. long parteEnteraRut( char *rut )
  1470. {
  1471. int i;
  1472. long sumatoria = 0, prod = 1;
  1473.  
  1474. for( i = strlen( rut ) - 2; i >= 0; i-- )
  1475. {
  1476. sumatoria += ( rut[i] - '0' ) * prod;
  1477. prod *= 10;
  1478. }
  1479.  
  1480. return sumatoria;
  1481. }
  1482. /*----------------------------------------------------------------------------------------------*/
  1483.  
  1484.  
  1485. /*-------------------------------Convierte una cadena a mayuscula-------------------------------*/
  1486. char *strupr( char *str )
  1487. {
  1488. int i;
  1489.  
  1490. for( i = 0; str[i] != '\0'; i++ )
  1491. {
  1492. if( isalpha( str[i] ))
  1493. str[i] = toupper( str[i] );
  1494. }
  1495. str[i] = '\0';
  1496.  
  1497. return str;
  1498. }
  1499. /*----------------------------------------------------------------------------------------------*/
  1500.  
  1501.  
  1502. /*-----------------Determina si una cadena contiene solo caracteres alfabeticos-----------------*/
  1503. int esPalabra( char *str )
  1504. {
  1505. int i;
  1506.  
  1507. for( i = 0; str[i] != '\0'; i++ )
  1508. {
  1509. if( !isalpha( str[i] ) && !isspace( str[i] )) return 0;
  1510. }
  1511.  
  1512. return 1;
  1513. }
  1514. /*----------------------------------------------------------------------------------------------*/
  1515.  
  1516.  
  1517. /*----------------------------------------Vacia la cadena---------------------------------------*/
  1518. char *reiniciarCadena( char *str )
  1519. {
  1520. strcpy( str, "" );
  1521. }
  1522. /*----------------------------------------------------------------------------------------------*/
  1523. /*--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!