C/Visual C - Ayuda con codigo mover ficheros

   
Vista:

Ayuda con codigo mover ficheros

Publicado por sysadmin (12 intervenciones) el 14/04/2016 09:28:05
Buenos días, hace unas semanas solicite ayuda en la web, y la verdad que me ayudaron mucho.. sobretodo "agustin" pedí ayuda para hacer un programa que mueva ficheros en C++, el programa funciona bien aunque me solicitan cambios que no se como realizar. Y aquí estoy de nuevo pidiendo ayuda, ya que es para el trabajo los cambios son los siguientes

el programa debe leer los nombres de los ficheros de la carpeta de una carpeta por ejemplo c:\Origen la estructura de los ficheros es la siguiente debe empezar por 8 digitos

"12345678__Pepe_Martinez__presupuesto.xls"

en la ruta c:\Destino existirán ya creadas las siguientes carpetas "12345678__Pepe_Martinez"

el programa debe fijarse en los 8 primeros dígitos, "12345678" y mover dichos ficheros que tengan el mismo código, pueden ser .doc, .xls, etc... y moverlos a su carpeta correspondiente " 12345678__Pepe_Martinez" para ello debe comparar solo los 8 dígitos de la carpeta y moverlos dentro si es el mismo codigo, en caso de que se produzca algun error como:

> que no se encuentre la carpeta, porque no exista
> el fichero no cumpla los requisitos, no tenga 8 digitos, sean menos o mas.... ya que hay que
contemplar el fallo humano.

Debe moverlo a otra carpeta por ejemplo c:\Errores , aquí se almaceran todos los ficheros que no cumplan. Si no existe solo debe moverlo a la carpeta c:\Errores.

Tengo el siguiente codigo, que hace algo parecido que planteo agustin, pero la verdad que no se modificarlo para adecuarlo.

//---------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <limits.h>
#include <string.h>
#include <dirent.h>
//---------------------------------------------------------------------------
#define ERROR_SUCCESS 0

void error(const char *s);
int ObtenerLargoCodigo(char* nombreArchivo);
int ObtenerNombreDirectorio(char* nombreArchivo,char* nombreDirectorio);
int CrearDirectorio(char* nombreDirectorio,char* ruta);
int MoverArchivos(char* rutaOrigen,char* rutaDestino);
//---------------------------------------------------------------------------

int main(int argc, char* argv[])
{
//Cambiar las rutas por las deseadas
char rutaOrigen[]={"C:\\Origen"};
char rutaDestino[]={"C:\\Destino"};

printf("Directorio raiz de origen: %s\n",rutaOrigen);
printf("Directorio raiz de destino: %s\n",rutaDestino);
if(MoverArchivos(rutaOrigen,rutaDestino)!=EXIT_SUCCESS)
printf("Asegurese de que la ruta del directorio es correcta\n");
system("PAUSE");
return 0;
}
//---------------------------------------------------------------------------

int MoverArchivos(char* rutaOrigen,char* rutaDestino)
{
DIR *dirOrigen,*dirDestino;
struct dirent *ent;
int retval,nleidos=0,nmovidos=0,ncodigoincorrecto=0,nDirCreados=0;
int ret;
char auxRutaOrigen[MAX_PATH],auxRutaDestino[MAX_PATH];
char nombreDir[MAX_PATH];

printf("=====================================================\n");
dirOrigen=opendir(rutaOrigen);
if(dirOrigen==NULL){
error("No puedo abrir el directorio de origen");
retval=EXIT_FAILURE;
}else{
dirDestino=opendir(rutaDestino);
if(dirDestino==NULL){
error("No puedo abrir el directorio de destino");
retval=EXIT_FAILURE;
}else{
closedir(dirDestino);
while((ent=readdir(dirOrigen)) != NULL){
if((strcmp(ent->d_name,".")!=0)&&(strcmp(ent->d_name,"..")!=0)){
ret=ObtenerLargoCodigo(ent->d_name);

if(ret==8){
if(ObtenerNombreDirectorio(ent->d_name,nombreDir)==ERROR_SUCCESS){
sprintf(auxRutaOrigen,"%s\\%s",rutaOrigen,ent->d_name);
if(CrearDirectorio(nombreDir,rutaDestino)==ERROR_SUCCESS){
printf("Se ha creado el directorio \"%s\"\n",nombreDir);
nDirCreados++;
}
sprintf(auxRutaDestino,"%s\\%s\\%s",rutaDestino,nombreDir,ent->d_name);
if(rename(auxRutaOrigen,auxRutaDestino)==ERROR_SUCCESS){
printf("El archivo \"%s\" se movio al directorio \"%s\n",ent->d_name,nombreDir);
nmovidos++;
}else{
printf("Huvo algun error al mover el archivo \"%s\" al directorio \"%s\"\n",ent->d_name,nombreDir);
}
}
nleidos++;
}else{
ncodigoincorrecto++;
}
}
}
printf("=====================================================\n");

if(nleidos > 0)
printf("Se han movido %i de %i archivos\n",nmovidos,nleidos+ncodigoincorrecto);
else if(ncodigoincorrecto==0)
printf("No se han encontrado archivos\n");
if(ncodigoincorrecto > 0)
printf("Se encontraron %i archivos con codigo de cliente incorrectos\n",ncodigoincorrecto);
if(nDirCreados > 0)
printf("Se han creado %i directorios\n",nDirCreados);
else
printf("No se han creado directorios\n");
retval=EXIT_SUCCESS;
}
closedir(dirOrigen);
}
return retval;
}
//---------------------------------------------------------------------------

int ObtenerLargoCodigo(char* nombreArchivo)
{
char ncliente[MAX_PATH],*ptr;
int i,pos=0,retval=0;

memset(ncliente,'\0',sizeof(ncliente));
ptr = strstr(nombreArchivo, "__");
pos=((int)ptr)-(int)nombreArchivo;
strncpy(ncliente,nombreArchivo,pos);

for(i=0;i<strlen(ncliente);i++){
if(isdigit(ncliente[i])==1)
retval++;
else
break;
}
return retval;
}
//---------------------------------------------------------------------------

int CrearDirectorio(char* nombreDirectorio,char* ruta)
{
int retval;
char aux[MAX_PATH]={0};

sprintf(aux,"%s\\%s",ruta,nombreDirectorio);
retval=mkdir(aux);
return retval;
}
//---------------------------------------------------------------------------

int ObtenerNombreDirectorio(char* nombreArchivo,char* nombreDirectorio)
{
int pos=0,retval;
char *ptr;

memset(nombreDirectorio,'\0',MAX_PATH);

while( (ptr = strstr(&nombreArchivo[pos], "__")) != NULL ){
pos=((int)ptr+2)-(int)nombreArchivo;
}
if(pos >= 2)
pos-=2;
strncpy(nombreDirectorio,nombreArchivo,pos);
if(strlen(nombreDirectorio)>0)
retval=EXIT_SUCCESS;
else
retval=EXIT_FAILURE;
return retval;
}
//---------------------------------------------------------------------------

void error(const char *s)
{
/* perror() devuelve la cadena S y el error (en cadena de caracteres) que tenga errno */
perror(s);
}
//---------------------------------------------------------------------------
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

Ayuda con codigo mover ficheros

Publicado por agustin (179 intervenciones) el 14/04/2016 14:57:37
Eso no es nada complejo y te lo puedo hacer en un momento pero hay algo que no tengo nada claro. Si hay por ejemplo los archivos "12345678__Pepe_Perez__prueba.txt" y "12345678__Juan_Gonzalez__prueba.txt" y existe el directorio "12345678__Pepe_Perez" ¿donde debe meterse el segundo? es que los codigos coinciden pero no el nombre.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Ayuda con codigo mover ficheros

Publicado por agustin (179 intervenciones) el 14/04/2016 17:17:46
Si lo unico que importa es el codigo y el nombre da igual te adjunto un codigo.
Si el nombre tambien importa y tiene que coincidir tanto el codigo como el nombre de la persona te adjunto otro codigo.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Ayuda con codigo mover ficheros

Publicado por sysadmin (12 intervenciones) el 14/04/2016 17:55:06
Buenas Agustin muchas gracias de verdad, efectivamente solo importa los 8 digitos numéricos "12345678" solo debe comparar esto el programa, es un identificador único para cada persona. Por lo tanto el nombre no importa, he estado probando el programa que has hecho y funciona bien lo unico dos detalles:

Cuando se encuentra un fichero de este estilo: 12345678_nombre.xxx entiendo que es porque solo lleva un subguion "_" no lo mueve a su carpeta indicada. La nomenclatura buena efectivamente es con dos subguiones "__" , pero hay que contemplar el fallo humano y es probable que alguna vez alguien grabe el fichero con solo "_"

Tambien cuando mueve un fichero a la carpeta errores, si dicho fichero existe ya no lo machaca ¿podria hacer que se sobrescriba en la carpeta errores?

Estoy intentando comprender el codigo con lo poquito que se de C, si pudieras comentar el codigo con mas detalle...

Gracias de nuevo
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Ayuda con codigo mover ficheros

Publicado por agustin (179 intervenciones) el 15/04/2016 01:17:33
Le añadí ambas correcciones:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
//---------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <dir.h>
#include <ctype.h>
#include <limits.h>
#include <sys/stat.h>
#include <string.h>
#include <dirent.h>
//---------------------------------------------------------------------------
#ifndef ERROR_SUCCESS
   #define ERROR_SUCCESS 0
#endif
 
//Prototipos de funciones
void error(const char *s);
int ObtenerLargoCodigo(char* nombreArchivo);
int ObtenerNombreDirectorio(char* codigo,char* ruta,char* nombre);
int CrearDirectorio(char* nombreDirectorio,char* ruta);
int MoverArchivos(char* rutaOrigen,char* rutaDestino,char* rutaDestinoErrores);
//---------------------------------------------------------------------------
 
int main(int argc, char* argv[])
{
   //Cambiar las rutas por las deseadas
   char rutaOrigen[]="C:\\Origen";
   char rutaDestino[]="C:\\Destino";
   char rutaDestinoErrores[]="C:\\Destino\\Errores";
 
   printf("Directorio raiz de origen: %s\n",rutaOrigen);
   printf("Directorio raiz de destino: %s\n",rutaDestino);
   printf("Directorio en caso de error: %s\n",rutaDestinoErrores);
 
   //Llamo a la funcion creada para mover los archivos
   if(MoverArchivos(rutaOrigen,rutaDestino,rutaDestinoErrores)!=EXIT_SUCCESS)
      //Si no se encontró el directorio de origen o de destino salgo de la funcion con error
      printf("Asegurese de que la ruta del directorio es correcta\n");
   system("PAUSE");
   return 0;
}
//---------------------------------------------------------------------------
 
//Funcion encargada de mover todos los archivos
int MoverArchivos(char* rutaOrigen,char* rutaDestino,char* rutaDestinoErrores)
{
   DIR *dirOrigen,*dirDestino,*dirDestinoErrores;
   struct dirent *ent;
   struct stat estado;
   int retval,nleidos=0,nmovidos=0,ncodigoincorrecto=0,ret;
   char auxRutaOrigen[MAX_PATH],auxRutaDestino[MAX_PATH],nombreDir[MAX_PATH],codigo[10];
 
   printf("=====================================================\n");
   //Abro el directorio de origen para poder leer todos los archivos que tiene dentro
   dirOrigen=opendir(rutaOrigen);
   //Si el directorio no existe nos devolverá NULL y salimos con un mensaje de error
   if(dirOrigen==NULL){
      error("No puedo abrir el directorio de origen");
      retval=EXIT_FAILURE;
   }else{
      //Abro el directorio de destino
      dirDestino=opendir(rutaDestino);
      //Si el directorio no existe nos devolverá NULL y salimos con un mensaje de error
      if(dirDestino==NULL){
         error("No puedo abrir el directorio de destino");
         retval=EXIT_FAILURE;
      }else{
         //Si el directorio de destino si existe lo cierro
         //Solo uso esto para comprobar que existe
         closedir(dirDestino);
         //Entro en el bucle para recorrer todos los archivos del directorio origen
         while((ent=readdir(dirOrigen)) != NULL){
            //En todo directorio de Windows al recorrerlo existen estos dos que compruebo en el siguiente
            //condicional y esos no hay que tocarlos asi que solo entramos si no es ninguno de ellos
            if((strcmp(ent->d_name,".")!=0)&&(strcmp(ent->d_name,"..")!=0)){
               //Concateno la ruta de origen y el nombre del archivo leido dandole el formato correcto a la ruta
               sprintf(auxRutaOrigen,"%s\\%s",rutaOrigen,ent->d_name);
               //Obtengo el tipo del archivo
               stat(auxRutaOrigen,&estado);
               //Si el tipo no es un directorio entro
               //Esto es solo para mover los archivos y no mover los directorios
               if(!S_ISDIR(estado.st_mode)){
                  //Obtengo el largo del codigo que tiene el archivo con la funcion diseñada para ello
                  ret=ObtenerLargoCodigo(ent->d_name);
                  //Si el largo del codigo es 8 es que es un largo correcto asi que entramos
                  if(ret==8){
                     //Copio en "codigo" el codigo de 8 digitos
                     strncpy(codigo,ent->d_name,8);
                     //Coloco el caracter de fin de cadena al final del codigo
                     codigo[8]='\0';
                     //Obtengo el nombre del directorio de destino para el codigo del archivo leido y si existe entro
                     if(ObtenerNombreDirectorio(codigo,rutaDestino,nombreDir)==ERROR_SUCCESS){
                        //Concateno la ruta de destino completa del archivo de destino
                        sprintf(auxRutaDestino,"%s\\%s\\%s",rutaDestino,nombreDir,ent->d_name);
                        //Si el archivo ya existe en la ruta de destino lo borro y si no no pasa nada
                        remove(auxRutaDestino);
                        //Muevo el archivo del directorio de origen al de destino
                        if(rename(auxRutaOrigen,auxRutaDestino)==ERROR_SUCCESS){
                           //Si no hubo error muestro el mensaje de que se movio correctamente e incremento el contador de archivos movidos
                           printf("El archivo \"%s\" se movio al directorio \"%s\n",ent->d_name,nombreDir);
                           nmovidos++;
                        }else{
                           //Si hubo algun error muestro un mensaje de error para ese archivo
                           printf("Huvo algun error al mover el archivo \"%s\" al directorio \"%s\"\n",ent->d_name,nombreDir);
                        }
                     }else{
                        //Si el directorio de destino no existe abro el directorio que guarda los errores
                        dirDestinoErrores=opendir(rutaDestinoErrores);
                        //Si no existe el directorio para los errores entro
                        if(dirDestinoErrores == NULL){
                           //Creo el directorio para los errores con la funcion diseñada para crear directorios
                           if(CrearDirectorio("",rutaDestinoErrores)!=ERROR_SUCCESS){
                              //Si no se pudo crear muestro un error y salgo del bucle terminando el programa
                              printf("Huvo algun error al crear el directorio de errores\n");
                              break;
                           }
                        }else{
                           //Si el directorio para los errores ya existe lo cierro
                           closedir(dirDestinoErrores);
                        }
                        //Concateno y doy formato a la ruta completa del archivo para guardarlo en el directorio de errores
                        sprintf(auxRutaDestino,"%s\\%s",rutaDestinoErrores,ent->d_name);
                        //Si el archivo ya existe lo borro y si no no pasa nada
                        remove(auxRutaDestino);
                        //Muevo el archivo a su nueva ubicacion
                        if(rename(auxRutaOrigen,auxRutaDestino)==ERROR_SUCCESS){
                           //Si se movio correctamente muestro un mensaje indicandolo e incremento el contador de archivos movidos
                           printf("No existe el directorio %s. El archivo \"%s\" se movio al directorio \"%s\n",nombreDir,ent->d_name,rutaDestinoErrores);
                           nmovidos++;
                        }else{
                           //Si no se pudo mover el archivo aviso con un error
                           printf("Huvo algun error al mover el archivo \"%s\" al directorio \"%s\"\n",ent->d_name,rutaDestinoErrores);
                        }
                     }
                     //Incremento el contador de archivos leidos
                     nleidos++;
                  }else{
                     //Si el largo del codigo no es correcto entramos aqui
                     //Abro el directorio de errores
                     dirDestinoErrores=opendir(rutaDestinoErrores);
                     //Si no existe lo creo con la funcion diseñada para ello
                     if(dirDestinoErrores == NULL){
                        if(CrearDirectorio("",rutaDestinoErrores)!=ERROR_SUCCESS){
                           printf("Huvo algun error al crear el directorio de errores\n");
                           break;
                        }
                     }else{
                        //Si ya existia el directorio lo cierro
                        closedir(dirDestinoErrores);
                     }
                     //Concateno y doy formato a la ruta del archivo para guardarlo en el directorio de errores
                     sprintf(auxRutaDestino,"%s\\%s",rutaDestinoErrores,ent->d_name);
                     //Si el archivo ya existe en dicha ruta lo borro y si no no pasa nada
                     remove(auxRutaDestino);
                     //Muevo el archivo a la ruta de errores
                     if(rename(auxRutaOrigen,auxRutaDestino)==ERROR_SUCCESS){
                        //Muestro un aviso indicando que se movió por tener un codigo erroneo e incremento el contador de archivos movidos
                        printf("Codigo incorrecto. El archivo \"%s\" se movio al directorio \"%s\n",ent->d_name,rutaDestinoErrores);
                        nmovidos++;
                     }else{
                        //Si no se pudo mover aviso del error
                        printf("Huvo algun error al mover el archivo \"%s\" al directorio \"%s\"\n",ent->d_name,rutaDestinoErrores);
                     }
                     //Incremento el contador de archivos con codigos incorrectos
                     ncodigoincorrecto++;
                  }
               }
            }
         }
         printf("=====================================================\n");

         //Muestro un pequeño informe
         if(nleidos > 0)
            printf("Se han movido %i de %i archivos\n",nmovidos,nleidos+ncodigoincorrecto);
         else if(ncodigoincorrecto==0)
            printf("No se han encontrado archivos\n");
         if(ncodigoincorrecto > 0)
            printf("Se encontraron %i archivos con codigo de cliente incorrectos\n",ncodigoincorrecto);
         retval=EXIT_SUCCESS;
      }
      //Cierro el directorio de origen
      closedir(dirOrigen);
   }
   return retval;
}
//---------------------------------------------------------------------------

//Esta funcion obtiene el largo del codigo que tiene el nombre del archivo
int ObtenerLargoCodigo(char* nombreArchivo)
{
   char *ptr;
   int i,pos,retval=0;

   //Busco la direccion del primer guion bajo en el nombre
   ptr = strchr(nombreArchivo, '_');
   //Le resto a la direccion donde está el guion la direccion inicial de la
   //cadena del nombre para obtener el largo del codigo
   pos=((int)ptr)-(int)nombreArchivo;
   //Si está en la posicion 8 es correcto y entro
   //Si no entro salgo de la funcion retornando 0
   if(pos==8){
      //Entro en el siguiente bucle donde compruebo caracter a caracter del codigo
      for(i=0;i<pos;i++){
         //Si el caracter es un numero incremento el contador
         if(isdigit(nombreArchivo[i])){
            retval++;
         }else{
            //Si no es un numero salgo del bucle
            break;
        }
      }
   }
   //Retorno el valor del contador
   return retval;
}
//---------------------------------------------------------------------------

//Esta funcion crea un directorio
int CrearDirectorio(char* nombreDirectorio,char* ruta)
{
   int retval;
   char aux[MAX_PATH]={0};

   //Concateno y doy formato a la ruta completa del directorio que deseo crear
   sprintf(aux,"%s\\%s",ruta,nombreDirectorio);
   //Creo el directorio
   retval=mkdir(aux);
   //Retorno el resultado obtenido al crear el directorio para indicar si se creo o no
   return retval;
}
//---------------------------------------------------------------------------

//Esta funcion obtiene el nombre del directorio para el codigo indicado
int ObtenerNombreDirectorio(char* codigo,char* ruta,char* nombre)
{
   DIR *dir;
   struct dirent *ent;
   struct stat estado;
   char codigoDir[9],rutaCompleta[MAX_PATH];
   int retval=EXIT_FAILURE;

   //Limpio la variable que guardará el nombre
   strset(nombre,'\0');
   //Abro la ruta indicada donde se desea buscar el directorio
   dir=opendir(ruta);
   //Si se pudo abrir la ruta entro
   if(dir!=NULL){
      //Entro en el bucle para ir leyendo todos los directorios
      while((ent=readdir(dir)) != NULL){
         //Si es diferente a estos dos entro
         if((strcmp(ent->d_name,".")!=0)&&(strcmp(ent->d_name,"..")!=0)){
            //Obtengo el tipo del archivo
            sprintf(rutaCompleta,"%s\\%s",ruta,ent->d_name);
            stat(rutaCompleta,&estado);
            //Si el tipo es un directorio entro
            //Esto es para leer solo los directorios por si hay algun otro tipo
            if(S_ISDIR(estado.st_mode)){
               //Copio a la variable codigo los 8 primeros caracteres del nombre del directorio
               strncpy(codigoDir,ent->d_name,8);
               //Coloco el caracter de fin de cadena detras
               codigoDir[8]='\0';
               //Comparo el codigo del directorio con el codigo del archivo y si son iguales entro
               if(strcmp(codigo,codigoDir)==0){
                  //Guardo en la variable "nombre" el nombre completo del directorio
                  strcpy(nombre,ent->d_name);
                  //Indico que se encontró
                  retval=EXIT_SUCCESS;
                  //Y salgo del bucle
                  break;
               }
            }
         }
      }
      //Cierro el directorio
      closedir(dir);
   }
   return retval;
}
//---------------------------------------------------------------------------

void error(const char *s)
{
   /* perror() devuelve la cadena S y el error (en cadena de caracteres) que tenga errno */
   perror(s);
}
//---------------------------------------------------------------------------
Tambien le añadí para que solo mueva los archivos por si en origen hay tambien directorios y no quieres que te los mueva.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Ayuda con codigo mover ficheros

Publicado por sysadmin (12 intervenciones) el 15/04/2016 12:09:47
Buenos dias agustin, probando el programa funciona perfectamente. Solo he detectado una cosa, que no se si se puede arreglar... si el programa se encuentra en la carpeta c:\Origen un fichero "12345678 Pepe_Martinez.xls" con espacio entre el codigo de 8 digitos y el nombre, o bien de este tipo "12345678 _Pepe_Martinez.xls" con un espacio y un guion... lo mueve a la carpeta errores... se puede hacer que lo mueva a su carpeta?

Muchas gracias por todo de verdad.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Ayuda con codigo mover ficheros

Publicado por agustin (179 intervenciones) el 15/04/2016 16:56:37
Hay que modificar un pelin la función que obtiene el código. Luego lo pongo.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Ayuda con codigo mover ficheros

Publicado por agustin (179 intervenciones) el 15/04/2016 17:19:02
Cambia la funcion que calcula el largo del codigo por esta:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//Esta funcion obtiene el largo del codigo que tiene el nombre del archivo
int ObtenerLargoCodigo(char* nombreArchivo)
{
   int i,retval=0;
 
   //Entro en el siguiente bucle donde compruebo caracter a caracter del codigo
   for(i=0;i<strlen(nombreArchivo);i++){
      //Si el caracter es un numero incremento el contador
      if(isdigit(nombreArchivo[i])){
         retval++;
      }else{
         //Si no es un numero salgo del bucle
         break;
      }
   }
   //Retorno el valor del contador
   return retval;
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Ayuda con codigo mover ficheros

Publicado por sysadmin (12 intervenciones) el 15/04/2016 19:17:24
Buenas agustin, funciona correctamente... voy a seguir testeandolo.. y lo mas importante comprender el codigo... muchas gracias
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Ayuda con codigo mover ficheros

Publicado por Chema (187 intervenciones) el 15/04/2016 19:17:54
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
 
#define NDIRS 7
 
char *file[NDIRS] = {
	"      1234670__Perico_Perez.txt",
	"12345671__Alberto_Narices.xls",
	"12345672__Julio_Lopez.po",
	"12345673__Mario_postigo_Carretero.porno",
	"1234567__Juan_zascario.yyy",
	"12345678_Juan_rojo.yyy",
	"12345678__.yyy",
};
 
enum Status {
	E_OX,
	E_PACH,
	E_ID_USER,
	E_FILE_EXTENSION,
	E_SEP
};
 
const char *ermsg [] = {
	"OK",
	"ruta no valida",
	"Identificador de usuario no valido",
	"extension de fichero incompleta o excesivamente larga",
	"No se encuentran separacion de giones"
 
};
 
int FileName(char *str) {
 
	int len;
	char *start;
	char *end;
	char *raw;
 
	len = strlen(str);
 
	start = raw = str;
	end = start + len;
	/*
	*Desechar espacios a la izquierda de la cadena
	*/
	while( isspace(*raw) )
		raw++;
 
	start = raw;
	/*
	*Comprobar los primeros 8 digitos.
	*/
	while( isdigit(*raw) )
		raw++;
 
	if ( (raw - start) != 8)
		return E_ID_USER;
	/*
	*Comprobar los dos guiones.
	*/
	start = raw;
 
	while( *raw == '_')
		raw++;
 
	if ( (raw - start) != 2)
		return E_SEP;
 
	start = raw;
	raw = end ;
	/*
	*Para comprobar la extenxión del fichero, se lee la cadena desde
	* el último caracter hacia atrás
	*/
	for( ; ( raw > start) && *raw != '.'; raw--)
		;
	/*
	* Si la cadena no contiene (.xxx) , o si la extensión sobrepasa 
	*4 caracteres, se marca como error.
	*/
	if ( (start == raw) || (end - raw) > 4 )
		return E_FILE_EXTENSION;
	/*
	* (raw), apunta al (.) de la extensión, se desplaza una posición
	* para apuntar al último caracter del nombre de usuario.
	*/
	raw--;
 
	for (; start <= raw; start++)
		printf("%c",*start);
 
	printf("\n------------\n");
 
	return 0;
}
 
 
int main(void){
	int i;
	int result;
 
	for ( i = 0 ; i < NDIRS; i++) {
		result = FileName(file[i]);
		if (result != E_OX) {
			printf("%s \n", ermsg[result] );
			printf("------------\n");
		}
	}
 
	return 0;
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar