Busqueda de una fecha

[diegocadorna]

ABAJO DE TODO AGREGUE EL COIGO COMPLETO LO ESTOY HACIENDO CON EL BORLAND C++ 5.02 Y LA PLATAFORMA ES WINDOWS, CON RESPECTO A LO DE LA ESTRUCTURA LES CUENTO QUE LA FECHA DE BUSQUEDA LA TOMO CON UN CHAR Y LA DEL ALTA CON UN STRING ES POR ESO QUE HAGO UNA FUNCION CASTING PARA PASAR TODO A CHAR EL TEMA ES QUE LA VALIDACION POR LA FECHA ESTA MAL OBVIO Y NO TENGO NI IDEA DE COMO HACERLA
Hola gente tengo un problema en una busqueda, necesito que me busque por fecha pero no lo hace bien lo estoy haciendo con un if anidado ya que tengo el día, mes y año por separado en formato dd/mm/aaaa.


////////////// ACA VA EL PROGRAMA COMPLETO////////////////////////////

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <iostream.h>
#include "tools.h"

/***********************DEFINICION DE TIPO DE DATOS*****************************/


typedef struct
{
char usuario[11]; // 11 Caracteres como maximo y 5 como minimo
char contrasenia[11]; // 11 Caracteres como maximo y 5 como minimo
int prioridad;
int id;
bool activo;
char fecha_lock[30];
}Clave;

typedef struct // Reg. Tabla
{
int codigo;
char descrip[51];
int stock;
int stockMax;
int stockMin;
char ultima_modif[30];
char estado_pro; // A(ctivo) B(aja) F(altante) S(obrante)
int activo;
}Principal;


typedef struct{ // Reg. Articulo Principal
int id;
int codigo;
float precio;
char fecha_modif[30];
char estado;
char user_log[11];
}Articulo;

typedef struct
{
char paraCodigo[101];
char paraValor[101];
}Parametros;

typedef struct{ // Reg. LOG

int id_log;
int codigo_art;
int cantidad;
char fecha[30];
char user[11];
char operacion;
} log;

typedef struct // Reg. Estadisticas
{
int codigo;
int total;
}Estadistica;

/************************ INICIO ** LOGIN ** SEGURIDAD**************************/
Parametros *vecParametros;
void cargarEstruc(void);
void presentacion(void);
int contadorRegistroINI(void);
void espera(long sec);
int validar(void);
void menu1(void);
void menu2(void);
void menu3(void);
void menu4(void);
int administra(void);
void altaDeUnaClave(void);
void ocultar(char *);
int verificar(char []); // Verifica (user)
void encripta(char *); // Se modifico para reutilizacion, encripta el texto que ingrese (user) o (password)
char *desencripta(char []); // Descripta el user para el LOG
char *buscarParametro(char []);
void lockearUsuario(char *);
void cargar_user_vecest(char *);
char *localtimesys(void);
void grabar_log_aplicacion(void);

/*********************** OPERACIONES *******************************************/
Principal ingresoUnArticulo(void);
int pantalla(void);
void altaDeUnArticulo(void);
void mostrarArchivo(void);
void mostrarUnArticulo(Principal a);
void ingresoArticulo(void);
int listadoCodigo(void);
void listarArticulo(void);
int menuIngresar(void);
void mostrar_registros(Articulo *, int);
void listar_todos(Articulo *, int);
void listar_filtros(Articulo *, int, char);
void busqueda_campo(Articulo *, int, int, int, char, int, int, int, int, int, int);
void busqueda(void);
void casting(char [], int&, int&, int&);
void grabar_log_ppal(char, int);
void leer_log_ppal(void);
void listar_reg_log(log *, int, int);
void mostrar_reg_log(log *, int);
void actualizar_stock(int, int, char);
void modificar_estado();
char *traer_descr(int);
void estadisticas(void);
/*********************** FIN DECLARACION DE FUNCIONES **************************/
int main(){
int op;
cargarEstruc();

do{
op=validar();

switch (op)
{
case 1: menu1();
break;

case 2: menu2();
break;

case 3: menu3();
break;

case 4: menu4();
break;
}
if (op==5){
do{
gotoxy(38,10); printf("0)Salir del sistema 1)Continuar : ");
gotoxy(72,10); scanf("%d",&op);
fflush(stdin);
}while((op!=0&&op!=1));
}
}while(op!=0);

return 1;
}

/**************************** CARGA LA ESTRUCTURA ******************************/
void cargarEstruc(void){

int i=0, cant;
FILE *at;
char linea[100];
char *p;
presentacion();

at=fopen("C://lp//project.ini", "r");
if(at==NULL)
{
clrscr();;
printf("\nNO SE PUEDE ABRIR EL ARCHIVO %s NO TIENE DATOS\n");
printf("\nPresione una tecla para continuar");getch();
exit (1);
}


fseek(at,0,SEEK_END);
cant=ftell(at);
rewind(at);

vecParametros=(Parametros*)malloc(sizeof(Parametros)*(cant));

fgets(linea,sizeof(linea),at); //tomo la primer linea
while(!feof(at))//mientras no sea fin de archivo
{

p=(char *)strtok(linea,"=");//pongo en p la cadena hasta el 1º =
strcpy(vecParametros[i].paraCodigo,p);
p=(char *)strtok(NULL,";");//pongo en p la parte de la cad desde el 1º = hasta el ;
strcpy(vecParametros[i].paraValor,p);
i++;
fgets(linea,sizeof(linea),at);//tomo las lineas sucesivas

}

strcpy(vecParametros[i].paraCodigo,"userlog");

fclose(at);
}

char *buscarParametro(char parametro[]){

int i=0;
while(i<contadorRegistroINI()){
if(!strcmp(parametro,vecParametros[i].paraCodigo)){

return vecParametros[i].paraValor;
}
i++;
}
return NULL;
}


int contadorRegistroINI(void){

int c=0;
while(strcmp(vecParametros[c].paraCodigo,"userlog")){
c++;
}
return c+1;
}

void cargar_user_vecest(char *user){

int i, cont;
cont=contadorRegistroINI();

for(i=0; i<cont; i++){

if (!strcmp(vecParametros[i].paraCodigo,"userlog")){
strcpy(vecParametros[i].paraValor,desencripta(user));
}
}
}

/******************************** PRESENTACION *********************************/
void presentacion(void)
{
printf(" -------------------------------------------------------------\n");


gotoxy(5, 2);
printf("FECHA Y HORA:");
while(!kbhit()) //el bucle se ejecuta mientras no se pulse una tecla cualquiera
{
time(&t);
gotoxy(42, 2);
printf("%s", ctime(&t));
espera(1);
}
getch();
}

void espera(long sec)
{
long inicio, actual;
time(&inicio) ;
time(&actual) ;
while((actual-inicio)<sec)
{
time(&actual) ;
}
}

/*************************** VALIDACION DE USUARIO *****************************/
int validar(void){

int back;
char user[11];
char clave[11];
clrscr();;
marco (27,55,10,14,6,1);
marco (25,57,9,15,6,1);
gotoxy(30 ,11); printf("%s", "USUARIO: ");
gotoxy(30, 13); printf("%s","PASSWORD: ");
gotoxy(40, 11); gets(user);
fflush(stdin);
encripta(user);

if(!strcmp(user,buscarParametro("user"))){
ocultar(clave);
encripta(clave);}

if(!strcmp(clave,buscarParametro("password"))){
//Verifica con el INI
return 1;}


back=verificar(user); // Verificar utiliza usuario.dat
return back;
}

int verificar(char *user){

Clave *h;
FILE *p;
int i, cant, cantidadin;
int intentos=0;
char cl[11];

cantidadin=atoi(buscarParametro("cant_ingresos"));
p=fopen(buscarParametro("arch_password"), "rb");
if(p==NULL)
{
clrscr();
printf("\nERROR AL ABRIR EL ARCHIVO ==> %s\n",buscarParametro("arch_password"));
getch();
return 1;
}
fseek(p,0,SEEK_END);
cant=ftell(p)/sizeof(Clave);
h=(Clave *)malloc(cant*sizeof(Clave));
if(h==NULL) {printf("\nNo hay memoria disponible");
getch();
exit (1);
}
rewind(p);

for (i=1; i<cant+1; i++){
fread((h+i),i*sizeof(Clave),1,p);
if(!strcmp(user,(h+i)->usuario)){

if((h+i)->activo==0){
clrscr();;
printf("\n Usuario Bloqueado");
printf("\n Fecha de bloqueo: %s", (h+i)->fecha_lock);
getch();
return 5;
}
while(intentos<cantidadin){
marco (27,55,10,14,6,1);
marco (25,57,9,15,6,1);
//gotoxy(1,1);printf("INTENTOS:%d",intentos);
gotoxy(30,13);printf("%s","PASSWORD: ");
ocultar(cl);
encripta(cl);
fflush(stdin);
if(!strcmp(cl,(h+i)->contrasenia)){
fclose(p);
free(h);

cargar_user_vecest(user); //Cargo el usuario en el vector de estructuras para uso de LOG

if((h+i)->prioridad==1) return 2;
if((h+i)->prioridad==2) return 3;
if((h+i)->prioridad==3) return 4;
}
intentos++;
}
fclose(p);
lockearUsuario(user);
free(h);
return 5;
}

}
fclose(p);
free(h);
gotoxy(26,20); printf(" Ingreso Invalido -> ");

return 5;
}

/**************************** LOCKEO DE USUARIO ********************************/
void lockearUsuario(char* user)
{

FILE *ptrUsuarios;
bool salir;
long pos;
Clave r;

clrscr();
printf("\nBloqueando Usuario...");
printf("\nFecha %s", localtimesys());
getch();


ptrUsuarios=fopen(buscarParametro("arch_password"),"rb+");
if(ptrUsuarios==NULL)
{
clrscr();;
printf("\nERROR AL ABRIR EL ARCHIVO dat en lockear ==> %s\n",(buscarParametro("arch_password")));
printf("\nPresione una tecla para continuar");getch();
exit (1);
}
salir = 0;
pos = ftell(ptrUsuarios);
fread(&r,sizeof(Clave),1,ptrUsuarios);

while( (!feof(ptrUsuarios)) && (!salir))
{
if((r.activo) && (strcmp(user,r.usuario)==0))
{

strcat(r.fecha_lock, localtimesys());

r.activo=0;
fseek(ptrUsuarios,pos,SEEK_SET);
fwrite(&r,sizeof(Clave),1,ptrUsuarios);
salir=1;
}
else
{
pos = ftell(ptrUsuarios);
fread(&r,sizeof(Clave),1,ptrUsuarios);
}
}
if(salir == 0)
{
clrscr();
printf("ERROR ===>no se encontro el usuario a bloquear");
printf("\nPresione una tecla para continuar");getch();
}
fclose(ptrUsuarios);
}

void ocultar(char *clave){

int letra=0,x=40;
for(;
{
clave[letra]=(char)getch(); //capta el codigo ascii de una letra
/*si el codigo de letra es 13(ENTER), 27(ESCAPE) O 32(ESPACIO),
entonces se almacena en la ultima letra ingresada un valor nulo,
el cual remplaza al de las teclas anteriormente mencionadas, y
asi no se pueda hacer una mala comparacion.
Luego se rompe el for infinito con el comando break.
*/
if((clave[letra]==13)||(clave[letra]==27)||(clave[letra]==32))
{ clave[letra]=0;
break;
}

//SI SE PRESIONA LA TECLA BACKSPACE(
/*si el codigo de letra es 8(BACKSPACE)entonces se ubica el cursor un espacio antes,
a partir de comienza a limpiar lo que hay, usando simplemente un cout que imprime
un espacio en blanco, luego se disminuye "x" y "letra" en una unidad y se ubica
el cursor en una nueva posicion (x,6).
Si el numero de letras fuera cero,es decir no hemos ingresado letra alguna o hemos
borrado todo porque se ingreso mal la clave entonces el cursor no tiene porque
moverse el cursor, consevar su posicion inicial(40,6)
*/
if(clave[letra]==
{ if(letra==0)
{ gotoxy(40, 13);
}
else
{
gotoxy(x-1,13);
printf("%s"," ");
x--;
letra--;
gotoxy(x,13);
}
}
else
{ //se imprime un asterisco porque la letra ingresada es un caracter normal(no es una tecla de control)
gotoxy(x,13);
printf("%s","*");
letra++;
x++;
}
}
}

/******************************* MENU MASTER ***********************************/
void menu1(void){
int op;
while(1)
{
clrscr();;
//Titulos & Marcos
textmode(C80); //Seteo Modo de Pantalla a 80x24
textcolor(WHITE); //Seteo Color del Texto
textbackground(BLACK); //Seteo Color del Background
clrscr(); //Limpio la Pantalla
marco (1,80,1,24,6,1);
marco (10,61,4,16,6,1);
gotoxy(34, 1); printf(" BODEGAS MOE ");
gotoxy(4, 24); printf(" LOGIN: MASTER ");
gotoxy(15, 4); printf(" MENU PRINCIPAL ");
gotoxy(15, 6); printf(" (1) ---- ADMINISTRAR PRODUCTOS");
gotoxy(15, 7); printf(" (2) ---- VER LOG ");
gotoxy(15, ; printf(" (3) ---- ESTADISTICAS");
gotoxy(15, 9); printf(" (4) ---- ADMINISTRAR USUARIOS");
gotoxy(15, 10); printf(" (5) ---- SALIR");
gotoxy(15, 11); printf(" -> OPCION : ");scanf("%d",&op);
clrscr();

switch (op)
{
case 1: menuIngresar();
break;

case 2: leer_log_ppal();
break;

case 3: estadisticas();
break;

case 4: op=administra();
break;

case 5: exit(0);

default: gotoxy(15, 25); printf("OPCION INVALIDA");
}
}
}

/******************************* MENU ADMINISTRADOR ****************************/
void menu2(void){
int op;
while(1)
{
clrscr();;
marco (1,80,1,24,6,1);
marco (10,61,4,12,6,1);
gotoxy(34, 1); printf(" BODEGAS MOE ");
gotoxy(4, 24); printf(" LOGIN: ADMINISTRADOR ");
gotoxy(15, 4); printf(" MENU PRINCIPAL ");
gotoxy(15, 6); printf(" (1) ---- ADMINISTRAR PRODUCTOS");
gotoxy(15, 7); printf(" (2) ---- ADMINISTRAR USUARIOS");
gotoxy(15, ; printf(" (3) ---- SALIR");
gotoxy(15, 11); printf(" -> OPCION : ");scanf("%d",&op);

switch (op)
{
case 1: menuIngresar();
break;

case 2: op=administra();
break;

case 3: exit(0);
break;

default: gotoxy(15, 25); printf("OPCION INVALIDA");
}
}
}

/******************************* MENU OPERADOR *********************************/
void menu3(void){
int op;
while(1)
{
clrscr();;
marco (1,80,1,24,6,1);
marco (20,61,6,16,6,1);
gotoxy(34, 1); printf(" BODEGAS MOE ");
gotoxy(4, 24); printf(" LOGIN: OPERADOR ");
gotoxy(22, 6); printf(" MENU PRINCIPAL ");
gotoxy(21, ; printf(" (1) ---- INGRESAR STOCK");
gotoxy(21, 9); printf(" (2) ---- LISTAR");
gotoxy(21, 10); printf(" (3) ---- BUSCAR");
gotoxy(21, 11); printf(" (4) ---- MOSTRAR STOCK");
gotoxy(21, 12); printf(" (5) ---- MODIFICAR ESTADO");
gotoxy(21, 13); printf(" (6) ---- SALIR");
gotoxy(21, 15); printf(" -> OPCION : ");scanf("%d",&op);
clrscr();

switch (op)
{
case 1: ingresoArticulo();
break;

case 2: listarArticulo();
break;

case 3: busqueda();
break;

case 4: mostrarArchivo();
break;

case 5: modificar_estado();
break;

case 6: exit(0);

default: gotoxy(21, 20); printf("OPCION INVALIDA");
}
}
}

/******************************* MENU GERENCIA *********************************/
void menu4(void){
int op;
while(1)
{
clrscr();;
marco (1,80,1,24,6,1);
marco (10,61,4,12,6,1);
gotoxy(34, 1); printf(" BODEGAS MOE ");
gotoxy(4, 24); printf(" LOGIN: GERENCIA ");
gotoxy(15, 4); printf(" MENU PRINCIPAL ");
gotoxy(15, 6); printf(" (1) ---- ESTADISTICAS");
gotoxy(15, 7); printf(" (2) ---- VER LOG");
gotoxy(15, ; printf(" (3) ---- SALIR");
gotoxy(15, 11); printf(" -> OPCION : ");scanf("%d",&op);
clrscr();

switch (op)
{
case 1: estadisticas();
break;

case 2: leer_log_ppal();
break;

case 3: exit(0);

default: gotoxy(15, 25); printf("OPCION INVALIDA");
}
}
}

/**************************** ADMINISTRAR USUARIOS *****************************/
int administra(){
int op;
clrscr();

while(1)
{
marco (1,80,1,24,6,1);
marco (10,61,4,13,6,1);
gotoxy(33, 1); printf(" BODEGAS MOE ");
gotoxy(15, 4); printf(" ADMINISTRAR USUARIOS ");
gotoxy(15, 6); printf(" (1) ---- ALTA DE USUARIO");
gotoxy(15, 7); printf(" (2) ----VOLVER AL MENU ANTERIOR");
gotoxy(15, ; printf(" -> OPCION : ");scanf("%d",&op);
clrscr();

switch (op)
{
case 1: gotoxy(15, 11); printf("ALTA DE USUARIO\n");
altaDeUnaClave();
break;

case 2: return op;


default: gotoxy(15, 10); printf("OPCION INVALIDA");
}
}
}

/****************************** INGRESO DE CLAVE *******************************/
Clave ingresoUnaClave(char unCartel[])
{
Clave r;
clrscr();;
gotoxy(27,4);
printf("\n%s\n",unCartel);
do{
gotoxy(27,4); printf("USUARIO: ");
fflush(stdin);
scanf("%s",r.usuario);
if (strlen(r.usuario)<atoi(buscarParametro("cant_min_caract"))){
clrscr();;
printf("\n ERROR ====> Usuario debe tener como minimo %s caracteres", buscarParametro("cant_min_caract"));
getch();}
if (strlen(r.usuario)>atoi(buscarParametro("cant_max_caract"))){
clrscr();;
printf("\n ERROR ====> Usuario debe tener como maximo %s caracteres", buscarParametro("cant_max_caract"));
getch();}
}while ((strlen(r.usuario)<atoi(buscarParametro("cant_min_caract")))||(strlen(r.usuario)>atoi(buscarParametro("cant_max_caract"))));
gotoxy(27,6);
do{
gotoxy(27,6); printf("PASSWORD: ");
fflush(stdin);
ocultar(r.contrasenia);
if (strlen(r.contrasenia)<atoi(buscarParametro("cant_min_caract"))){
clrscr();;
printf("\n ERROR ====> El password debe tener como minimo %s caracteres", buscarParametro("cant_min_caract"));
getch();}
if (strlen(r.contrasenia)>atoi(buscarParametro("cant_max_caract"))){
clrscr();;
printf("\n ERROR ====> El password debe tener como maximo %s caracteres", buscarParametro("cant_max_caract"));
getch();}
}while((strlen(r.contrasenia)<atoi(buscarParametro("cant_min_caract")))||(strlen(r.contrasenia)>atoi(buscarParametro("cant_max_caract"))));

r.activo=!0;//ACTIVO EL REGISTRO EN VERDADERO
clrscr();
return r;
}

/****************************** ALTA DE USUARIOS *******************************/
void altaDeUnaClave(void)
{
int op, cant;
Clave r;
Clave rNuevo;
FILE *ab;
bool salir;

ab=fopen(buscarParametro("arch_password"),"rb+");
if(ab==NULL)
{
ab=fopen(buscarParametro("arch_password"),"wb");//INTENTO CREAR EL ARCHIVO
if(ab==NULL)
{
clrscr();;
printf("\nERROR AL CREAR EL ARCHIVO ==> %s\n",buscarParametro("arch_password"));
printf("\nPresione una tecla para continuar");getch();
return;
}
fclose(ab);
ab=fopen(buscarParametro("arch_password"),"rb+");
if(ab==NULL)
{
clrscr();;
printf("\nERROR AL ABRIR EL ARCHIVO ==> %s\n",buscarParametro("arch_password"));
printf("\nPresione una tecla para continuar");getch();
return;
}
}
rNuevo = ingresoUnaClave("ALTA DE UNA CLAVE");
clrscr();

do{
gotoxy(10, 2); printf("INGRESE ROLE-> \n");
gotoxy(15, 6); printf(" 1)Administrador\n");
gotoxy(15, 7); printf(" 2)Operador\n");
gotoxy(15, ; printf(" 3)Gerencia\n");
scanf("%d",&op);
clrscr();
}while(op<1 || op>3);
switch (op)
{
case 1:rNuevo.prioridad = 1 ;
break;
case 2:rNuevo.prioridad = 2 ;
break;
case 3:rNuevo.prioridad = 3 ;
break;
default: gotoxy(15, 10); printf("OPCION INVALIDA");
}

salir = 0;
fread(&r,sizeof(Clave),1,ab);
while( (!feof(ab)) && (!salir))
{
if((r.activo) && (strcmp(r.usuario,rNuevo.usuario)==0)
&& (strcmp(r.contrasenia,rNuevo.contrasenia)==0))
{
clrscr();;
printf("ERROR ===> LA CLAVE YA EXISTE");
printf("\nPresione una tecla para continuar");getch();
salir = !0;
}
else
{
fread(&r,sizeof(Clave),1,ab);
}
}

if(salir == 0)//SI NO ENCUENTRO UN REGISTRO IGUAL
{//AGREGO UN NUEVO REGISTRO AL ARCHIVO
fseek(ab,0,SEEK_END);
cant=ftell(ab)/sizeof(Clave);
rNuevo.id=cant+1; // ID cantidad de registros + 1
encripta(rNuevo.usuario);
encripta(rNuevo.contrasenia);
fwrite(&rNuevo,sizeof(Clave),1,ab);
}
fclose(ab);
}

void encripta(char *user){

int i;
for (i=0; user[i]!='\0'; i++){
user[i]+=(char)2;
}
}

char *desencripta(char aux[]){

int i;
for (i=0; aux[i]!='\0'; i++){
aux[i]-=(char)2;
}
return aux;
}

/**********************OPERACIONES PRINCIPALES**********************************/
void mostrarUnArticulo(Principal a)
{
printf("\nCODIGO : %d",a.codigo);
printf("\nDESCRIP : %-50s",a.descrip);
printf("\nSTOCK : %d",a.stock);
printf("\nSTOCK MAXIMO: %d",a.stockMax);
printf("\nSTOCK MINIMO: %d",a.stockMin);
printf("\nESTADO DEL PRODUCTO: %c", a.estado_pro);
printf("\nFECHA : %s",a.ultima_modif);
}

void mostrarArchivo(void)
{
FILE *ab;
Principal r;

ab=fopen(buscarParametro("arch_principal"),"rb");
if(ab==NULL)
{
clrscr();
printf("\nERROR AL ABRIR EL ARCHIVO ==> %s\n",buscarParametro("arch_principal"));
printf("\nPresione una tecla para continuar");getch();
return;
}

fread(&r,sizeof(Principal),1,ab);

while(!feof(ab))
{
if(r.activo)
{
mostrarUnArticulo(r);
printf("\n-----------------------------------------------");
}
fread(&r,sizeof(Principal),1,ab);
}
fclose(ab);
printf("\nPresione una tecla para continuar");getch();
}


void altaDeUnArticulo(void)
{
Principal r;
Principal rNuevo;
FILE *ab;
bool salir;

clrscr();
rNuevo = ingresoUnArticulo();

ab=fopen(buscarParametro("arch_principal"),"rb+");
if(ab==NULL)
{
ab=fopen(buscarParametro("arch_principal"),"wb");//INTENTO CREAR EL ARCHIVO

if(ab==NULL)
{
clrscr();
printf("\nERROR AL CREAR EL ARCHIVO ==> %s\n",buscarParametro("arch_principal"));
printf("\nPresione una tecla para continuar");getch();
return;
}

fclose(ab);

ab=fopen(buscarParametro("arch_principal"),"rb+");
if(ab==NULL)
{
clrscr();
printf("\nERROR AL ABRIR EL ARCHIVO ==> %s\n",buscarParametro("arch_principal"));
printf("\nPresione una tecla para continuar");getch();
return;
}
}

salir = 0;
fread(&r,sizeof(Principal),1,ab);

while( (!feof(ab)) && (!salir))
{
if((r.activo) && (r.codigo==rNuevo.codigo))
{
clrscr();
printf("ERROR ===> CODIGO YA EXISTE");
printf("\nPresione una tecla para continuar");getch();
salir=!0;
}
else
{
fread(&r,sizeof(Principal),1,ab);
}
}
if(salir == 0)
{
fwrite(&rNuevo,sizeof(Principal),1,ab);
}
fclose(ab);
}

Principal ingresoUnArticulo() // INGRESO POR TECLADO ARTICULO AL PRINCIPAL
{
Principal r;
strcpy(r.ultima_modif," ");
r.stock=0;
printf("CODIGO: ");fflush(stdin);scanf("%d",&r.codigo);
printf("DESCRIP: ");fflush(stdin);scanf("%s",r.descrip);
printf("STOCK MAXIMO: ");fflush(stdin);scanf("%d",&r.stockMax);
printf("STOCK MINIMO: ");fflush(stdin);scanf("%f",&r.stockMin);

strcat(r.ultima_modif,localtimesys());
r.estado_pro='A';
r.activo=1; //ACTIVO EL REGISTRO EN VERDADERO
return r;
}

/**************************** MENU ADM. PRODUCTOS ******************************/
int pantalla(void)
{
int op;

clrscr();
marco (1,80,1,24,6,1);
marco (10,61,4,18,6,1);
gotoxy(34, 1); printf(" BODEGAS MOE ");
gotoxy(15, 4); printf(" ADMINISTRAR PRODUCTOS ");
gotoxy(15, 6); printf(" (1) ---- ALTA DE PRODUCTO");;
gotoxy(15, 7); printf(" (2) ---- MOSTRAR PRODUCTOS");
gotoxy(15, ; printf(" (3) ---- VOLVER AL MENU ANTERIOR");
gotoxy(15, 9); printf(" -> OPCION : ");scanf("%d",&op);
return(op);
}


int menuIngresar(void)
{
int opcion;

do{
opcion=pantalla();
switch(opcion)
{
case 1: //ALta de reg. Ppal
{altaDeUnArticulo();} break;

case 2: // Mostrar el reg. Ppal
{mostrarArchivo();} break;

}
}while(opcion != 3); // 3 -----> SALIR
return 0;
}

/***************************** INGRESAR ARTICULOS ******************************/
void ingresoArticulo(void){

FILE *arti;
long cant;
int op, cant_art,i;
Articulo r;

strcpy(r.fecha_modif," ");

arti=fopen(buscarParametro("arch_articulo"),"rb+");
if(arti==NULL)
{
arti=fopen(buscarParametro("arch_articulo"),"wb");//INTENTO CREAR EL ARCHIVO

if(arti==NULL)
{
clrscr();
printf("\nERROR AL CREAR EL ARCHIVO ==> %s\n",buscarParametro("arch_articulo"));
printf("\nPresione una tecla para continuar");getch();
return;
}

fclose(arti);

arti=fopen(buscarParametro("arch_articulo"),"rb+");
if(arti==NULL)
{
clrscr();
printf("\nERROR AL ABRIR EL ARCHIVO ==> %s\n",buscarParametro("arch_articulo"));
printf("\nPresione una tecla para continuar");getch();
return;
}
}

fseek(arti,0,SEEK_END);
cant=ftell(arti)/sizeof(Articulo);

fread(&r,sizeof(Articulo),1,arti);

r.codigo=listadoCodigo(); // Trae el codigo validado.
do{
gotoxy(69, ; clreol();
marco (67,76,4,6,6,1);
marco (1,80,1,24,6,1);
marco (3,78,3,21,6,1);
marco (38,78,3,21,6,1);
gotoxy(7, 3); printf(" CODIGO DESCRIPCION ");
gotoxy(41, 3); printf(" INGRESAR STOCK ");
marco (67,76,7,9,6,1);
gotoxy(69, ; scanf("%f", &r.precio);
}while(r.precio<1 || r.precio>2000); // 1 articulo como maximo vale 2000$

do{
gotoxy(69, 11); clreol();
marco (67,76,4,6,6,1);
marco (1,80,1,24,6,1);
marco (3,78,3,21,6,1);
marco (38,78,3,21,6,1);
gotoxy(7, 3); printf(" CODIGO DESCRIPCION ");
gotoxy(41, 3); printf(" INGRESAR STOCK ");
marco (67,76,10,12,6,1);
gotoxy(69, 11); scanf("%d",&cant_art);
}while(cant_art<1 || cant_art>1000); // Como maximo puede ingresar 1000 articulos

r.estado='A';

strcpy(r.user_log,buscarParametro("userlog"));

gotoxy(40, 14); printf(" -> USER: %s", r.user_log);

strcat(r.fecha_modif,localtimesys());

do{
gotoxy(69, 1; clreol();
marco (67,76,4,6,6,1);
marco (1,80,1,24,6,1);
marco (3,78,3,21,6,1);
marco (38,78,3,21,6,1);
gotoxy(7, 3); printf(" CODIGO DESCRIPCION ");
gotoxy(41, 3); printf(" INGRESAR STOCK ");
gotoxy(41, 1; printf("(1)Grabar (2)Cancelar: ");
marco (67,76,17,19,6,1);
gotoxy(69, 1; scanf("\n %d",&op);
}while(op<1||op>2);

if(op==1) {
for(i=0; i<cant_art; i++){

r.id=++cant;
fwrite(&r,sizeof(Articulo),1,arti);


}
actualizar_stock(cant_art,r.codigo,r.estado);
}

fclose(arti);
}

/************************** LISTADO DE CODIGOS DE VINOS ************************/
int listadoCodigo(void){

FILE *ppal;
Principal r,v;
int op,flag;

ppal=fopen(buscarParametro("arch_principal"),"rb");

if(ppal==NULL)
{
clrscr();
printf("\n ERROR AL ABRIR EL ARCHIVO ==> %s\n",buscarParametro("arch_principal"));
printf("\n Presione una tecla para continuar");getch();
exit(1);
}

fread(&r,sizeof(Principal),1,ppal);

printf("\n \n \n");


while ((!feof(ppal)))
{
printf("\n \t(%d)", r.codigo);
printf("\t %s", r.descrip);
printf("\n");
fread(&r,sizeof(Principal),1,ppal);
}

gotoxy(40, 5); printf(" -> CODIGO : ");
gotoxy(40, ; printf(" -> PRECIO : ");
gotoxy(40, 11); printf(" -> CANTIDAD : ");




do{
gotoxy(69, 5); clreol();
marco (67,76,4,6,6,1);
marco (1,80,1,24,6,1);
marco (3,78,3,21,6,1);
marco (38,78,3,21,6,1);
gotoxy(7, 3); printf(" CODIGO DESCRIPCION ");
gotoxy(41, 3); printf(" INGRESAR STOCK ");
flag=0;
gotoxy(69, 5);fflush(stdin); scanf("%d", &op);
fflush(stdin);
rewind(ppal);
fread(&v,sizeof(Principal),1,ppal);
while ((!feof(ppal))) // Valida el ingreso contra el archivo
{
if(v.codigo==op){flag=1;}
fread(&v,sizeof(Principal),1,ppal);
}

}while(flag==0);
fclose(ppal);
return (op);
}

char *localtimesys(){

char *dato;
char dia[3];
char mes[3];
char anio[5];
char hora[3];
char minutos[3];
time_t t;
struct tm *tiempo;
t=time(NULL);
tiempo=localtime(&t);

dato=(char *)malloc(30*sizeof(char *));
if(dato==NULL){
printf("\n Error de memoria");
getch();
exit(1);
}
strcpy(dato," ");

itoa(tiempo->tm_mday,dia,10);
itoa(tiempo->tm_mon+1,mes,10);
itoa(tiempo->tm_year+1900,anio,10);
itoa(tiempo->tm_hour,hora,10);
itoa(tiempo->tm_min,minutos,10);

if(strlen(dia)==1){
strcat(dato,"0");}
dato= strcat(dato, dia);
dato= strcat(dato, "/");
if(strlen(mes)==1){
strcat(dato,"0");}
dato= strcat(dato, mes);
dato= strcat(dato, "/");
dato= strcat(dato, anio);
dato= strcat(dato, " ");
dato= strcat(dato, hora);
dato= strcat(dato, ":");
if(strlen(minutos)==1){
strcat(dato,"0");}
dato= strcat(dato, minutos);
return dato;
}

/**************************** LISTAR ARTICULOS CARGADOS ************************/

void listarArticulo(void) // Listado por Filtros (TODOS, ALTAS, RESERVADO o BAJAS)
{
FILE *ab;
Articulo *r;


int op, d;
int cant;


ab=fopen(buscarParametro("arch_articulo"),"rb");
if(ab==NULL)
{
clrscr();
printf("\nERROR AL ABRIR EL ARCHIVO ==> %s\n",buscarParametro("arch_articulo"));
printf("\nPresione una tecla para continuar");getch();
return;
}

fseek(ab,0,SEEK_END);
cant=ftell(ab)/sizeof(Articulo);
rewind(ab);
r=(Articulo *)malloc(cant*sizeof(Articulo));

do{
gotoxy(6, 7); clreol();
marco (1,80,1,24,6,1);
marco (3,70,3,8,6,1);
gotoxy(7, 3); printf(" LISTAR ");
gotoxy(7, 5); printf("(1)TODOS");
gotoxy(22, 5); printf("(2)ALTAS");
gotoxy(37, 5); printf("(3)RESERVADOS");
gotoxy(57, 5); printf("(4)BAJA");
gotoxy(6, 7); printf(" -> OPCION : "); scanf("%d",&op); fflush(stdin);
// if (op != 13 ) {ungetch(op);gotoxy(20,20);printf("Prueba");getch();}
}while(op<1||op>4);

clrscr();
gotoxy(2, 2); printf("------------------------------------------------------------------------");
gotoxy(2, 3); printf("ID");
gotoxy(8, 3); printf("CODIGO");
gotoxy(18, 3); printf("PRECIO");
gotoxy(28, 3); printf("FECHA DE CARGA");
gotoxy(48, 3); printf("ESTADO");
gotoxy(57, 3); printf("OPERADOR DE CARGA");
gotoxy(2, 4); printf("------------------------------------------------------------------------");

for(d=0; d<cant; d++){

fread((r+d),sizeof(Articulo),1,ab);

}

fclose(ab);

switch(op)
{
case 1: // Lista todos ordenados de mayor a menor por el id
{
listar_todos(r, cant);
mostrar_registros(r, cant);
}
break;

case 2: // Lista el filtro Altas ordenado por id de mayor a menor
{
listar_todos(r, cant);
listar_filtros(r,cant,'A');
}
break;

case 3: // Lista el filtro Reservados ordenado por id de mayor a menor
{
listar_todos(r, cant);
listar_filtros(r,cant,'R');
}
break;

case 4: // Lista el filtro Bajas ordenado por id de mayor a menor
{
listar_todos(r, cant);
listar_filtros(r,cant,'B');
}
break;
}

free(r);
printf("\n \n Presione una tecla para continuar");getch();
clrscr();

}


void mostrar_registros(Articulo *t, int c){

int i;

for (i=0; i<c; i++){
printf("\n %d",(t+i)->id);
printf("\t %d", (t+i)->codigo);
printf("\t %s",traer_descr((t+i)->codigo));
printf("\t %6.2f", (t+i)->precio);
printf("\t %s", (t+i)->fecha_modif);
printf("\t %c", (t+i)->estado);
printf("\t %s", (t+i)->user_log);
}
}

void listar_todos(Articulo *r, int cant){

int i, c;
Articulo aux;
for(i=0; i<cant; i++){
for (c=i+1; c<cant; c++){
if(((r+i)->id) < ((r+c)->id)){

aux=r[i];
r[i]=r[c];
r[c]=aux;
}
}
}
}


void listar_filtros(Articulo *r, int cant, char fil){

int i, c=0;
Articulo *aux;
aux=(Articulo *)malloc(cant*sizeof(Articulo));

for (i=0; i<cant; i++){
if( ((r+i)->estado) == (fil) ){
aux[c]=r[i];
c++;
}
}
mostrar_registros(aux, c);
}


/**************************** BUSCAR ARTICULOS CARGADOS ************************/

void busqueda(void) // Busqueda x ID o Fecha de Alta o Estado
{
FILE *ab;
Articulo *r;

int d, DesdeID, HastaID, diad, mesd, yeard, diah, mesh, yearh;
int cant;
char estado;



ab=fopen(buscarParametro("arch_articulo"),"rb");
if(ab==NULL)
{
clrscr();
printf("\nERROR AL ABRIR EL ARCHIVO ==> %s\n",buscarParametro("arch_articulo"));
printf("\nPresione una tecla para continuar");getch();
return;
}

fseek(ab,0,SEEK_END);
cant=ftell(ab)/sizeof(Articulo);
rewind(ab);
r=(Articulo *)malloc(cant*sizeof(Articulo));
clrscr();
gotoxy(3, 5); printf("ARTICULO:");
gotoxy(36,3); printf("DESDE ");fflush(stdin);
gotoxy(47,3); printf("HASTA ");fflush(stdin);
gotoxy(3, 7); printf("FECHA DE CARGA(DD/MM/AA):");
gotoxy(3, 9); printf("ESTADO(A=ALTA B=BAJA R=RESER.):");

gotoxy(38,5);scanf("%d",&DesdeID);
gotoxy(49,5);scanf("%d",&HastaID);
fflush(stdin);
do{
gotoxy(35,7); fflush(stdin);scanf("%d", &diad);
}while((diad > 31) || diad <1 );
gotoxy(37,7); fflush(stdin);printf("/");
do{
gotoxy(38,7); fflush(stdin);scanf("%d", &mesd);
}while((mesd > 12) || mesd <1 );
gotoxy(40,7); fflush(stdin);printf("/");
do{
gotoxy(41,7); fflush(stdin);scanf("%d", &yeard);
}while((yeard > 2200) || yeard <1800);
fflush(stdin);
do{
gotoxy(46,7); fflush(stdin);scanf("%d", &diah);
}while((diah > 31) || diah <1 );
gotoxy(48,7); fflush(stdin);printf("/");
do{
gotoxy(49,7); fflush(stdin);scanf("%d", &mesh);
}while((mesh > 12) || mesh <1 );
gotoxy(51,7); fflush(stdin);printf("/");
do{
gotoxy(52,7); fflush(stdin);scanf("%d", &yearh);
}while((yearh > 2200) || yearh <1800);

gotoxy(38,9); fflush(stdin); scanf("%c",&estado);
estado=toupper(estado);


printf("\n-----------------------------------------------------------------------------");
printf("\t ARTICULO");
printf("\t DESCRIPCION");
printf("\t PRECIO");
printf("\t FECHA DE CARGA");
printf("\t \t ESTADO");
printf("\t USUARIO");

for(d=0; d<cant; d++){

fread((r+d),sizeof(Articulo),1,ab);

}


fclose(ab);

busqueda_campo(r, cant, DesdeID, HastaID, estado, diad, mesd, yeard, diah, mesh, yearh);
free(r);
printf("\nPresione una tecla para continuar");
getch();
clrscr();
}

void busqueda_campo(Articulo *r, int cant, int des, int has, char fil, int diad, int mesd, int yeard, int diah, int mesh, int yearh){

int i, c=0, j=0,dia,mes,year;
Articulo *aux;
Articulo *aux2;
aux=(Articulo *)malloc(cant*sizeof(Articulo));


for (i=0; i<cant; i++){

if ((((r+i)->codigo) >= des) && (((r+i)->codigo) <= has)){

if( (fil) == 'T'){ aux[c]=r[i];
c++;}

if( ((r+i)->estado) == (fil) ){
aux[c]=r[i];
c++;
}
}
}
aux2=(Articulo *)malloc(c*sizeof(Articulo));

for (i=0; i<c; i++){

casting((aux+i)->fecha_modif,dia,mes,year);
printf("");
if ( (year) >= (yeard) && ( (year) <= (yearh)))
{
if ( (mes) >= (mesd) && ( (mes) <= (mesh)))
{
if( (dia)>= (diad) && ( (dia) <= (diah)))
{
aux2[j]=aux[i];
j++;
}

} }
} mostrar_registros(aux2,j);
}

void casting (char fecha[], int &d, int &m, int &y){

int n,l=0;
char diass[3], mess[3], year[5];

for (n=2; n<4; n++){
diass[l]=fecha[n];
l++;
}
d=atoi(diass);
l=0;
for (n=5; n<7; n++){
mess[l]=fecha[n];
l++;
}
m=atoi(mess);
l=0;
for (n=8; n<12; n++){
year[l]=fecha[n];
l++;
}
y=atoi(year);
}

/*************************LOG FILE**********************************************/

void grabar_log_aplicacion(void){


FILE *ab;

ab=fopen(buscarParametro("arch_log"),"rt+");
if(ab==NULL)
{
ab=fopen(buscarParametro("arch_log"),"wt");//INTENTO CREAR EL ARCHIVO
if(ab==NULL)
{
clrscr();;
printf("\nERROR AL CREAR EL ARCHIVO ==> %s\n",buscarParametro("arch_log"));
printf("\nPresione una tecla para continuar");getch();
return;
}
fclose(ab);
}
ab=fopen(buscarParametro("arch_log"),"at+");
if(ab==NULL)
{
clrscr();;
printf("\nERROR AL ABRIR EL ARCHIVO ==> %s\n",buscarParametro("arch_log"));
printf("\nPresione una tecla para continuar");getch();
return;
}

fprintf(ab,"%s;%s;\n",localtimesys(), buscarParametro("userlog"));

fclose(ab);

}

void grabar_log_ppal(char oper, int codigo, int total){

FILE *ab;
log r;
int cant;


ab=fopen(buscarParametro("arch_log_pp"),"rb+");
if(ab==NULL)
{
ab=fopen(buscarParametro("arch_log_pp"),"wb");//INTENTO CREAR EL ARCHIVO

if(ab==NULL)
{
clrscr();
printf("\nERROR AL CREAR EL ARCHIVO ==> %s\n",buscarParametro("arch_log_pp"));
printf("\nPresione una tecla para continuar");getch();
return;
}

fclose(ab);

ab=fopen(buscarParametro("arch_log_pp"),"rb+");
if(ab==NULL)
{
clrscr();
printf("\nERROR AL ABRIR EL ARCHIVO ==> %s\n",buscarParametro("arch_log_pp"));
printf("\nPresione una tecla para continuar");getch();
return;
}
}

fseek(ab,0,SEEK_END);
cant=ftell(ab)/sizeof(log);
fread(&r,sizeof(log),1,ab);

r.id_log=++cant;
r.codigo_art=codigo;
r.cantidad=total;
strcpy(r.fecha,localtimesys());
strcpy(r.user,buscarParametro("userlog"));
r.operacion=oper;
fwrite(&r,sizeof(log),1,ab);


fclose(ab);

}

void leer_log_ppal(void){

FILE *ab;
log *r;
int cant,d,codi;

ab=fopen(buscarParametro("arch_log_pp"),"rb");
if(ab==NULL)
{
clrscr();
printf("\nERROR AL ABRIR EL ARCHIVO ==> %s\n",buscarParametro("arch_log_pp"));
printf("\nPresione una tecla para continuar");getch();
return;
}

fseek(ab,0,SEEK_END);
cant=ftell(ab)/sizeof(log);
rewind(ab);
r=(log *)malloc(cant*sizeof(log));

printf("\n INGRESE EL CODIGO DEL ARTICULO PARA VER EL LOG: ");
scanf("%d", &codi);


clrscr();
printf("\n-----------------------------------------------------------------------------");
printf("\n ID");
printf("\t CODIGO");
printf("\t CANTIDAD");
printf("\t \tFECHA");
printf("\t \tUSUARIO");
printf("\tOPERACION");;

for(d=0; d<cant; d++){

fread((r+d),sizeof(log),1,ab);

}

listar_reg_log(r,cant,codi);
getch();
fclose(ab);
}

void mostrar_reg_log(log *r, int c){

int d;
for (d=0; d<c; d++){
printf("\n %d",(r+d)->id_log);
printf("\t %s",traer_descr((r+d)->codigo_art));
printf("\t %d",(r+d)->cantidad);
printf("\t \t%s",(r+d)->fecha);
printf("\t %s",(r+d)->user);
printf("\t%c",(r+d)->operacion);
}
}

char *traer_descr(int codigo){

FILE *ppal;
Principal r;

ppal=fopen(buscarParametro("arch_principal"),"rb");

if(ppal==NULL)
{
clrscr();
printf("\n ERROR AL ABRIR EL ARCHIVO ==> %s\n",buscarParametro("arch_principal"));
printf("\n Presione una tecla para continuar");getch();
exit(1);
}

fread(&r,sizeof(Principal),1,ppal);

while ( (!feof(ppal)))
{
if(r.codigo==codigo){
fclose(ppal);
return r.descrip;

}
fread(&r,sizeof(Principal),1,ppal);
}
fclose(ppal);
return r.descrip;
}


void listar_reg_log(log *r, int cant, int codi){

int i, c=0,d;
log *aux;
log aux2;

aux=(log *)malloc(cant*sizeof(log));
for(i=0; i<cant; i++){

if( ((r+i)->codigo_art) == (codi)){

aux[c]=r[i];
c++;
}

}

for(i=0; i<c; i++){
for (d=i+1; d<c; d++){
if(((aux+i)->id_log) < ((aux+d)->id_log)){

aux2=aux[i];
aux[i]=aux[d];
aux[d]=aux2;
}
}
}

mostrar_reg_log(aux, c);
free(aux);
}

void actualizar_stock(int cant, int codigo, char operacion){

FILE *ab;
int flag=0 ,flag2=0;
Principal r;

ab=fopen(buscarParametro("arch_principal"),"rb+");
if(ab==NULL)
{
clrscr();
printf("\nERROR AL ABRIR EL ARCHIVO ==> %s\n",buscarParametro("arch_principal"));
printf("\nPresione una tecla para continuar");getch();
return;
}

fread(&r,sizeof(Principal),1,ab);

while(!feof(ab)&&(!flag==1))
{
if(r.codigo==codigo){

fseek(ab,-sizeof(Principal),SEEK_CUR);
r.stock+=cant;
if( r.stock<r.stockMin)
{r.estado_pro='F';
flag2=1;
grabar_log_ppal(r.estado_pro,codigo,cant);}
if( r.stock>r.stockMax)
{r.estado_pro='S';
flag2=1;
grabar_log_ppal(r.estado_pro,codigo,cant);}

if( (r.estado_pro!='A') && (flag2==0))
{r.estado_pro='A';
grabar_log_ppal(r.estado_pro,codigo,cant);}


fwrite(&r,sizeof(Principal),1,ab);
grabar_log_ppal(operacion,codigo,cant);
fclose(ab);
flag=1;
}
fread(&r,sizeof(Principal),1,ab);
}

if (flag==0){
printf("\n No se pudo actualizar el stock");
getch();}

fclose(ab);
}

void modificar_estado(){

FILE *ab, *bb;
int cod, can, op, canreg, ind, contador=0,flag;
float st;
char car;
Principal r,v; // Stock total
Articulo *t; // Art x art

ab=fopen(buscarParametro("arch_principal"),"rb");
if(ab==NULL)
{
clrscr();
printf("\nERROR AL ABRIR EL ARCHIVO ==> %s\n",buscarParametro("arch_principal"));
printf("\nPresione una tecla para continuar");getch();
return;
}
bb=fopen(buscarParametro("arch_articulo"),"rb+");
if(bb==NULL)
{
clrscr();
printf("\nERROR AL ABRIR EL ARCHIVO ==> %s\n",buscarParametro("arch_articulo"));
printf("\nPresione una tecla para continuar");getch();
return;
}

fseek(bb,0,SEEK_END);
canreg=ftell(bb)/sizeof(Articulo);
rewind(bb);
t=(Articulo *)malloc(canreg*sizeof(Articulo));

do{ flag=0;
printf("\n Ingrese el codigo del articulo: ");
scanf("%d",&cod);
fflush(stdin);
rewind(ab);
fread(&v,sizeof(Principal),1,ab);
while ((!feof(ab))) // Valida el ingreso contra el archivo
{
if(v.codigo==cod){flag=1;}
fread(&v,sizeof(Principal),1,ab);
}

}while(flag==0);

rewind(ab);
do{
marco (1,80,1,24,6,1);
marco (3,70,3,8,6,1);
gotoxy(37, 5); printf("(1)RESERVADO");
gotoxy(57, 5); printf("(2)BAJA");
gotoxy(6, 7); printf(" -> INGRESE UNA OPCION : "); scanf("%d",&op);
}while(op<1||op>2);

if (op==1)
car='R';
else
car='B';


fread(&r,sizeof(Principal),1,ab);

while(!feof(ab))
{
if(r.codigo==cod){
st=r.stock;
}
fread(&r,sizeof(Principal),1,ab);
}

do{
printf("\n Ingrese la cantidad de articulos: ");
scanf("%d",&can);
if(can>st){printf("\n NO HAY ARTICULOS SUFICIENTES PARA ESTA TRANSACCION");
getch();}
}while(can>st);

for (ind=0; ind<canreg; ind++){

fread((t+ind),sizeof(Articulo),1,bb);

if( ((t+ind)->codigo==cod) && (t+ind)->estado=='A'){
if(contador<can){
(t+ind)->estado=car;
fseek(bb,-sizeof(Articulo),SEEK_CUR);
fwrite((t+ind),sizeof(Articulo),1,bb);
contador++;
fseek(bb,0L*sizeof(Articulo),SEEK_CUR);
}
}

}
actualizar_stock((-contador),cod,car);

fclose(ab);
fclose(bb);
}


//estadistcias
void estadisticas(void) // estadisticas de workflow por estados ( ALTAS, RESERVADO o BAJAS)
{
//para estructura principal de articulos
FILE *ppal;
Principal *r;
int cant,d,i,op;
//para estructura log
FILE *ab;
log *l;
int cantlog,acumulador;
//para estadisitca
Estadistica *estadis;
Estadistica aux;

char estadoEstadistica;
char estadoEstadistica2[20];

//INGRESO OPCION DE TIPO DE ESTADISTICA
do{
gotoxy(6, 7); clreol();
marco (1,80,1,24,6,1);
marco (3,70,3,8,6,1);
gotoxy(7, 3); printf(" ESTADISTICAS ");
gotoxy(5, 5); printf("(1) ALTAS POR ART");
gotoxy(25, 5); printf("(2) RESERVAS POR ART");
gotoxy(47, 5); printf("(3) BAJAS POR ART");
gotoxy(6, 7); printf(" -> OPCION : "); scanf("%d",&op); fflush(stdin);
// if (op != 13 ) {ungetch(op);gotoxy(20,20);printf("Prueba");getch();}
}while(op<1||op>3);
clrscr();
if(op==1){
estadoEstadistica='A';
strcpy(estadoEstadistica2,"ALTAS");
} else {
if(op==2){
estadoEstadistica='R';
strcpy(estadoEstadistica2,"RESERVAS");
}else {
estadoEstadistica='B';
strcpy(estadoEstadistica2,"BAJAS");
}
}

//cargo en la estructura principal los articulos que existen
ppal=fopen(buscarParametro("arch_principal"),"rb"); //abro el log
if(ppal==NULL)
{
clrscr();
printf("\nERROR AL ABRIR EL ARCHIVO ==> %s\n",buscarParametro("arch_principal"));
printf("\nPresione una tecla para continuar");getch();
return;
}
fseek(ppal,0,SEEK_END);
cant=ftell(ppal)/sizeof(Principal);
rewind(ppal);
r=(Principal *)malloc(cant*sizeof(Principal));
estadis=(Estadistica *)malloc(cant*sizeof(Estadistica)); //creo vec estructura para estadisitcia

for(d=0;d<cant;d++)
{
fread((r+d),sizeof(Principal),1,ppal);
}
fclose(ppal);
/*hasta aca tengo los distintos articulos*/


//ahora cargo en estructura l los movimientos de log con sus cantidades
ab=fopen(buscarParametro("arch_log_pp"),"rb"); //abro log
if(ab==NULL)
{
clrscr();
printf("\nERROR AL ABRIR EL ARCHIVO ==> %s\n",buscarParametro("arch_log_pp"));
printf("\nPresione una tecla para continuar");getch();
return;
}
fseek(ab,0,SEEK_END);
cantlog=ftell(ab)/sizeof(log);//cant registros log
rewind(ab);
l=(log *)malloc(cantlog*sizeof(log)); //reserv memoria
for(d=0;d<cantlog;d++) //cargo log en estructura l
{
fread((l+d),sizeof(log),1,ab);
}
fclose(ab);


/*por cada articulo del principal recorro la estructura log
para sumar las cantidades de los movimientos segun el tipo de flujo*/

for(d=0;d<cant;d++) //recorro articulos
{
(estadis+d)->codigo=(r+d)->codigo;
acumulador=0;
for(i=0;i<cantlog;i++) //por cada art recorro log
{

if( ((r+d)->codigo)==((l+i)->codigo_art) && (l+i)->operacion==estadoEstadistica)
{

acumulador+=(l+i)->cantidad;
(estadis+d)->total=acumulador;
}
}
}//fin primer for
//ordeno vector cantidades
for(i=0;i<cant;i++){
for(d=i+1;d<cant;d++){
if(((estadis+i)->total)<((estadis+d)->total)){
aux=estadis[i];
estadis[i]=estadis[d];
estadis[d]=aux;

}
}
}

/***/gotoxy(6, 7); clreol();

marco (3,70,3,8,6,1);
/***/
gotoxy(15,3);printf("ESTADISTICA \n");
gotoxy(11,5);printf(" %s POR ARTICULO (ordenado por cantidad)",estadoEstadistica2);
gotoxy(9,12); printf("ARTICULO");
gotoxy(22,12); printf("DESCRIPCION");
gotoxy(40,12);printf("CANTIDAD");


gotoxy(17,15);
for(d=0;d<cant;d++) //recorro articulos
{

printf("\n \n\t %d ",(estadis+d)->codigo);
printf("\t \t %s",traer_descr((estadis+d)->codigo) ) ;
printf("\t \t %d ",(estadis+d)->total);
}
getch();
//ERROR NO SE PUEDE ENTRAR DOS VECES!

free(l);
free(r);
free(estadis);

}
_________________
Diego

[rir3760]

Cuando tengas un problema con un programa es importante que publiques el programa completo o si eso no es posible el programa completo mas pequeño posible que exhiba el problema en cuestion.

En este caso el uso de punteros a estructuras de tipo "Articulo *" no se puede revisar porque no das la definicion de ella como tampoco de funciones "localtimesys" o "listar_reg_log".

Tambien es importante indicar el lenguaje, compilador y plataforma que estas utilizando.

Un saludo
_________________
The capacity to learn is a gift;
The ability to learn is a skill;
The willingness to learn is a choice.
--
Rebec of Ginaz