emufs_gui/articulos.c

   1
   2 #include "articulos.h"
   3 #include "idx.h"
   4 #include "gui.h"
   5 #include "common.h"
   6 #include "lista.h"
   7 #include "menu.h"
   8 #include "facturas.h"
   9
  10 static t_LstArticulos *lst_articulos;
  11
  12 static t_Articulo *art_form_buscar(WINDOW *win, EMUFS_REG_ID *id);
  13
  14 static void *procesar_guardar_articulo(t_Articulo *src, EMUFS_REG_SIZE *size, t_LstArticulos *lst);
  15 static int procesar_leer_articulo(t_Articulo *dst, void *src, EMUFS_REG_SIZE size, t_LstArticulos *lst);
  16
  17 static void dump_articulos(char *tmpfile);
  18
  19 #ifdef TP_PRIMER_ENTREGA
  20 /* Manejo de la lista doble */
  21 static t_Reg_Articulo *crear_nodo_articulo(EMUFS_REG_ID reg, unsigned int num);
  22 static int agregar_nodo_articulo(t_LstArticulos *lst, t_Reg_Articulo *nodo);
  23 static int eliminar_nodo_articulo(t_LstArticulos *lst, t_Reg_Articulo *nodo);
  24
  25 int eliminar_nodo_articulo(t_LstArticulos *lst, t_Reg_Articulo *nodo)
  26 {
  27         if (nodo == NULL) return 0;
  28         if (nodo->ant == NULL) {
  29                 /* Me piden borrar el primer nodo */
  30                 if (nodo->sig) {
  31                         nodo->sig->ant = NULL;
  32                 }
  33                 lst->primero = nodo->sig;
  34         } else {
  35                 if (nodo->sig) {
  36                         nodo->sig->ant = nodo->ant;
  37                 }
  38                 nodo->ant->sig = nodo->sig;
  39         }
  40         free(nodo);
  41         return 1;
  42 }
  43
  44 t_Reg_Articulo *crear_nodo_articulo(EMUFS_REG_ID reg, unsigned int num)
  45 {
  46         t_Reg_Articulo *tmp;
  47         if (reg == EMUFS_NOT_FOUND) return NULL;
  48         tmp = malloc(sizeof(t_Reg_Articulo));
  49         if (tmp == NULL) return NULL;
  50         tmp->sig = tmp->ant = NULL;
  51         tmp->num_reg = reg;
  52         tmp->numero = num;
  53
  54         return tmp;
  55 }
  56
  57 int agregar_nodo_articulo(t_LstArticulos *lst, t_Reg_Articulo *nodo)
  58 {
  59         if (nodo == NULL) return 0;
  60
  61         if (lst->primero) {
  62                 lst->primero->ant = nodo;
  63                 nodo->sig = lst->primero;
  64                 lst->primero = nodo;
  65         } else {
  66                 lst->primero = nodo;
  67         }
  68         return 1;
  69 }
  70 #endif /* TP_PRIMER_ENTREGA */
  71
  72 t_LstArticulos *art_get_lst()
  73 {
  74         return lst_articulos;
  75 }
  76
  77 t_LstArticulos *art_cargar(t_Parametros *param)
  78 {
  79         xmlDocPtr document;
  80         xmlNode *node, *inicio;
  81         int error = 0;
  82         char *prop;
  83         EMUFS_REG_SIZE size;
  84         t_LstArticulos *tmp;
  85         t_Articulo *un_articulo;
  86         lst_articulos = NULL;
  87
  88         tmp = (t_LstArticulos *)malloc(sizeof(t_LstArticulos));
  89         if (tmp == NULL) return NULL;
  90         lst_articulos = tmp;
  91         tmp->primero = NULL;
  92
  93         if (param != NULL) {
  94                 PERR("Voy a crear desde un XML");
  95                 document = xmlReadFile(param->xml_art, "ISO-8859-1",0);
  96                 if (document == NULL) {
  97                         free(tmp);
  98                         lst_articulos = NULL;
  99                         return NULL;
 100                 }
 101
 102                 inicio = NULL;
 103                 node = xmlDocGetRootElement(document);
 104                 /* Busco el TAG principal "ARTICULOS" */
 105                 while (node) {
 106                         if (node->type == XML_ELEMENT_NODE) {
 107                                 if (strcmp(node->name, "ARTICULOS") == 0) {
 108                                         inicio = node->children;
 109                                         break;
 110                                 }
 111                         }
 112                         node = node->next;
 113                 }
 114                 /* Creo el FS */
 115                 tmp->fp = emufs_crear("articulos", param->tipo_arch_art, param->tam_bloque_art, sizeof(t_Articulo));
 116                 /* Agrego los indices */
 117                 PERR("Voy a agregar un indice");
 118                 emufs_agregar_indice(tmp->fp, "presentacion", IND_EXAHUSTIVO, param->ind_art[2].tipo_arbol, IDX_STRING, STRUCT_OFFSET(un_articulo, desc), param->ind_art[2].tam_bloque, 1);
 119                 emufs_agregar_indice(tmp->fp, "desc", IND_EXAHUSTIVO, param->ind_art[1].tipo_arbol, IDX_STRING, STRUCT_OFFSET(un_articulo, desc), param->ind_art[1].tam_bloque, 0);
 120
 121                 /* Para secuencial indexado el indice primario siempre es el B+ */
 122                 if ((param->tipo_arch_art != T4) && (param->tipo_arch_art != T5))
 123                         emufs_agregar_indice(tmp->fp, "codigo", IND_PRIMARIO, param->ind_art[0].tipo_arbol, IDX_INT, 0, param->ind_art[0].tam_bloque, 0);
 124                 else
 125                         emufs_agregar_indice(tmp->fp, "codigo", IND_PRIMARIO, IND_B_PLUS, IDX_INT, 0, param->ind_art[0].tam_bloque, 0);
 126                 if (!tmp->fp) {
 127                         PERR("NO SE PUDO CREAR ARCHIVO ARTICULOS");
 128                         free(tmp);
 129                         xmlFreeDoc(document);
 130                         xmlCleanupParser();
 131                         lst_articulos = NULL;
 132                         return NULL;
 133                 }
 134                 for (node=inicio ; node ; node = node->next) {
 135                         if (node->type == XML_ELEMENT_NODE) {
 136                                 if (strcmp(node->name, "ARTICULO") == 0) {
 137                                         t_Articulo art;
 138                                         void *save;
 139                                         memset(&art, 0, sizeof(t_Articulo));
 140                                         prop = xml_get_prop(node, "NroArtículo");
 141                                         art.numero = atoi(prop);
 142                                         xmlFree(prop);
 143                                         strcpy(art.desc, prop = xml_get_prop(node, "Descripción")); xmlFree(prop);
 144                                         art.desc[50] = '\0';
 145                                         strcpy(art.presentacion, prop = xml_get_prop(node, "Presentación")); xmlFree(prop);
 146                                         art.presentacion[30] = '\0';
 147                                         strcpy(art.existencia, prop = xml_get_prop(node, "Existencia")); xmlFree(prop);
 148                                         art.existencia[8] = '\0';
 149                                         strcpy(art.ubicacion, prop = xml_get_prop(node, "Ubicación")); xmlFree(prop);
 150                                         art.ubicacion[30] = '\0';
 151                                         strcpy(art.pvu, prop = xml_get_prop(node, "PVU")); xmlFree(prop);
 152                                         art.pvu[8] = '\0';
 153                                         strcpy(art.emin, prop = xml_get_prop(node, "Emín")); xmlFree(prop);
 154                                         art.emin[8] = '\0';
 155                                         /* Ya leido el articulo ahora paso a guardarlo en el archivo y agregarlo a la lista */
 156                                         save = procesar_guardar_articulo(&art, &size, lst_articulos);
 157                                         if (save != NULL) {
 158                                                 error = 0;
 159                                                 tmp->fp->grabar_registro(tmp->fp, save, size, &error);
 160                                                 free(save);
 161                                         }
 162                                 }
 163                         }
 164                 }
 165                 xmlFreeDoc(document);
 166                 xmlCleanupParser();
 167         } else {
 168                 PERR("Voy a recuperar desde un archivo");
 169                 tmp->fp = emufs_abrir("articulos");
 170                 fprintf(stderr, "PTR=%p %p\n", tmp, tmp->fp);
 171                 if (tmp->fp == NULL) {
 172                         PERR("No se pudo cargar archivo de articulos.");
 173                         free(tmp);
 174                         lst_articulos = NULL;
 175                         return NULL;
 176                 }
 177         }
 178
 179         return tmp;
 180 }
 181
 182 int art_liberar(t_LstArticulos *l)
 183 {
 184         t_Reg_Articulo *del;
 185         if (l == NULL) l = lst_articulos;
 186         if (l == NULL) return 1;
 187
 188         emufs_destruir(l->fp);
 189         while (l->primero) {
 190                 del = l->primero;
 191                 l->primero = l->primero->sig;
 192                 free(del);
 193         }
 194         free(l);
 195
 196         lst_articulos = NULL;
 197         return 0;
 198 }
 199
 200 t_Articulo *art_obtener(t_LstArticulos *lst, int numero, EMUFS_REG_ID *id)
 201 {
 202         t_Articulo *art;
 203         void *tmp;
 204         int error = 0;
 205         EMUFS_REG_SIZE size;
 206         CLAVE k;
 207
 208         if (lst == NULL) lst = lst_articulos;
 209         if (lst == NULL) return NULL;
 210
 211         (*id) = -1; /* XXX Ver que se hacia con esto */
 212         art = (t_Articulo *)malloc(sizeof(t_Articulo));
 213         /* Ya se cual tengo que retornar. Ahora veo si lo cargo desde el archivo */
 214         error = 0;
 215         k = emufs_indice_generar_clave_desde_valor(lst->fp->indices, (char *)&numero);
 216         tmp = lst->fp->leer_registro(lst->fp, k, &size, &error);
 217         if (error) {
 218                 free(art);
 219                 return NULL;
 220         }
 221
 222         if (procesar_leer_articulo(art, tmp, size, lst_articulos) != 1) {
 223                 free(art);
 224                 free(tmp);
 225                 return NULL;
 226         }
 227
 228         free(tmp);
 229         return art;
 230 }
 231
 232 t_Articulo *art_form_buscar(WINDOW *win, EMUFS_REG_ID *id)
 233 {
 234         t_Form *form;
 235         t_Articulo *articulo;
 236
 237         form = form_crear(win);
 238         form_agregar_widget(form, INPUT, "Numero de Artículo", 8, "");
 239         form_ejecutar(form, 1,1);
 240         articulo = art_obtener(NULL, form_obtener_valor_int(form, "Numero de Artículo"), id);
 241         form_destruir(form);
 242
 243         return articulo;
 244 }
 245
 246 void art_modificar(char *s)
 247 {
 248         WINDOW *win;
 249         t_Form *form;
 250         t_Articulo *articulo;
 251         char num[11];
 252         void *tmp;
 253         int error;
 254         EMUFS_REG_SIZE size;
 255         EMUFS_REG_ID codigo;
 256
 257         win = newwin(9, COLS-2, 13, 1);
 258         box(win, 0, 0);
 259         wrefresh(win);
 260
 261         if (s == NULL) {
 262                 PERR("Voy a buscar con el formulario");
 263                 articulo = art_form_buscar(win, &codigo);
 264                 PERR("Ya lo tengo!!!!!!");
 265         } else {
 266                 codigo = atoi(s);
 267                 /* Leo el registro directamente */
 268                 articulo = (t_Articulo *)malloc(sizeof(t_Articulo));
 269                 /* Ya se cual tengo que retornar. Ahora veo si lo cargo desde el archivo */
 270                 error = 0;
 271                 tmp = lst_articulos->fp->leer_registro(lst_articulos->fp,
 272                                                 emufs_indice_generar_clave_desde_valor(lst_articulos->fp->indices, (char *)&codigo), &size, &error);
 273                 if (error) {
 274                         free(articulo);
 275                         articulo = NULL;
 276                 } else {
 277                         if (procesar_leer_articulo(articulo, tmp, size, lst_articulos) != 1) {
 278                                 free(articulo);
 279                                 articulo = NULL;
 280                         }
 281                         free(tmp);
 282                 }
 283         }
 284
 285         if (articulo != NULL) {
 286                 form = form_crear(win);
 287                 sprintf(num, "%08d", articulo->numero);
 288                 form_agregar_widget(form, INPUT, "Numero de Artículo", 8, num);
 289                 form_es_modificable(form, "Numero de Artículo" , 0);
 290                 form_agregar_widget(form, INPUT, "Descripción", 50, articulo->desc);
 291                 form_agregar_widget(form, INPUT, "Presentación", 30, articulo->presentacion);
 292                 form_agregar_widget(form, INPUT, "Stock Actual", 8, articulo->existencia);
 293                 form_agregar_widget(form, INPUT, "Ubicacion", 30, articulo->ubicacion);
 294                 form_agregar_widget(form, INPUT, "PVU", 8, articulo->pvu);
 295                 form_agregar_widget(form, INPUT, "Stock Mínimo", 8, articulo->emin);
 296                 form_ejecutar(form, 1,1);
 297
 298                 /* Actualizar registro */
 299                 articulo->numero = form_obtener_valor_int(form, "Numero de Artículo");
 300                 strcpy(articulo->desc, form_obtener_valor_char(form, "Descripción"));
 301                 strcpy(articulo->presentacion, form_obtener_valor_char(form, "Presentación"));
 302                 strcpy(articulo->existencia, form_obtener_valor_char(form, "Stock Actual"));
 303                 strcpy(articulo->ubicacion, form_obtener_valor_char(form, "Ubicacion"));
 304                 strcpy(articulo->pvu, form_obtener_valor_char(form, "PVU"));
 305                 strcpy(articulo->emin, form_obtener_valor_char(form, "Stock Mínimo"));
 306                 /* Ya actualice los datos, ahora veo de grabarlos */
 307                 tmp = procesar_guardar_articulo(articulo, &size, lst_articulos);
 308                 if (tmp) {
 309                         CLAVE k;
 310                         INDICE_DATO dummy1;
 311                         error = 0;
 312                         k = emufs_indice_generar_clave_desde_valor(lst_articulos->fp->indices, (char *)&articulo->numero);
 313                         /* dummy se pasa porque esto se hace por clave primaria, y el INDICE_DATO que se
 314                          * pasa solo es requerido cuando son claves multiples
 315                          */
 316                         lst_articulos->fp->modificar_registro(lst_articulos->fp, k, tmp, size, &error, dummy1);
 317                         free(tmp);
 318                 }
 319
 320                 form_destruir(form);
 321                 free(articulo);
 322         } else {
 323                 wattron(win, COLOR_PAIR(COLOR_YELLOW));
 324                 mvwaddstr(win, 6, 4, "No existe artículo con ese código. Abortando!");
 325                 wattroff(win, COLOR_PAIR(COLOR_YELLOW));
 326                 wrefresh(win);
 327                 getch();
 328         }
 329         werase(win);
 330         wrefresh(win);
 331         delwin(win);
 332 }
 333
 334 void art_eliminar(char *s)
 335 {
 336         WINDOW *win;
 337         t_Articulo *articulo;
 338         EMUFS_REG_ID id;
 339         CLAVE k;
 340
 341         win = newwin(8, COLS-2, 13, 1);
 342         box(win, 0, 0);
 343         wrefresh(win);
 344
 345         articulo = art_form_buscar(win, &id);
 346
 347         if (articulo == NULL) {
 348                 wattron(win, COLOR_PAIR(COLOR_YELLOW));
 349                 mvwaddstr(win, 6, 4, "No existe artículo con ese código. Abortando!");
 350                 wattroff(win, COLOR_PAIR(COLOR_YELLOW));
 351                 wrefresh(win);
 352                 getch();
 353         } else {
 354                 INDICE_DATO dummy;
 355
 356                 /* Antes de borrar veo si existe alguna factura que contenga este articulo */
 357                 if (fact_hay_con_item(articulo->numero) == 0) {
 358                         k = emufs_indice_generar_clave_desde_valor(lst_articulos->fp->indices, (char *)&(articulo->numero));
 359                         PERR("Borrando ARTICULO")
 360                         lst_articulos->fp->borrar_registro(lst_articulos->fp, k, dummy);
 361                         PERR("LISTO BORRADO");
 362                 } else {
 363                         wattron(win, COLOR_PAIR(COLOR_YELLOW));
 364                         mvwaddstr(win, 6, 4, "No se pudo eliminar Articulo porque hay una factura que lo referencia.");
 365                         wattroff(win, COLOR_PAIR(COLOR_YELLOW));
 366                         wrefresh(win);
 367                         getch();
 368                 }
 369                 free(articulo);
 370         }
 371
 372         werase(win);
 373         wrefresh(win);
 374         delwin(win);
 375 }
 376
 377 void art_agregar(char *s)
 378 {
 379         WINDOW *win;
 380         t_Form *form;
 381         t_Articulo art;
 382         void *save;
 383         int error = 0, existe;
 384         EMUFS_REG_SIZE size;
 385         EMUFS_REG_ID id;
 386         INDICE_DATO dato;
 387         CLAVE k;
 388
 389         win = newwin(9, COLS-2, 13, 1);
 390         box(win, 0, 0);
 391         wrefresh(win);
 392
 393         form = form_crear(win);
 394         form_agregar_widget(form, INPUT, "Numero de Artículo", 8, "");
 395         form_agregar_widget(form, INPUT, "Descripción", 50, "");
 396         form_agregar_widget(form, INPUT, "Presentación", 30, "");
 397         form_agregar_widget(form, INPUT, "Stock Actual", 8, "");
 398         form_agregar_widget(form, INPUT, "Ubicacion", 30, "");
 399         form_agregar_widget(form, INPUT, "PVU", 8, "");
 400         form_agregar_widget(form, INPUT, "Stock Mínimo", 8, "");
 401         form_ejecutar(form, 1,1);
 402
 403         art.numero = atoi(form_obtener_valor_char(form, "Numero de Artículo"));
 404         existe = 0;
 405         /* Me dijo que no existe el codigo */
 406         k = emufs_indice_generar_clave_desde_valor(lst_articulos->fp->indices, (char *)&art.numero);
 407         dato = lst_articulos->fp->indices->existe_entrada(lst_articulos->fp->indices, k);
 408         if (dato.id != -1) existe = 1;
 409
 410         if (!existe) {
 411                 strcpy(art.desc, form_obtener_valor_char(form, "Descripción"));
 412                 strcpy(art.presentacion, form_obtener_valor_char(form, "Presentación"));
 413                 strcpy(art.existencia, form_obtener_valor_char(form, "Stock Actual"));
 414                 strcpy(art.ubicacion, form_obtener_valor_char(form, "Ubicacion"));
 415                 strcpy(art.pvu, form_obtener_valor_char(form, "PVU"));
 416                 strcpy(art.emin, form_obtener_valor_char(form, "Stock Mínimo"));
 417
 418                 /* Ya leido el articulo ahora paso a guardarlo en el archivo y agregarlo a la lista */
 419                 save = procesar_guardar_articulo(&art, &size, lst_articulos);
 420                 if (save != NULL) {
 421                         error = 0;
 422                         id = lst_articulos->fp->grabar_registro(lst_articulos->fp, save, size, &error);
 423                         if (error) {
 424                                 wattron(win, COLOR_PAIR(COLOR_YELLOW));
 425                                 mvwaddstr(win, 6, 4, "Error al tratar de agregar el nuevo registro");
 426                                 wattroff(win, COLOR_PAIR(COLOR_YELLOW));
 427                                 wrefresh(win);
 428                                 getch();
 429                         }
 430                         free(save);
 431                 }
 432         } else {
 433                 wattron(win, COLOR_PAIR(COLOR_YELLOW));
 434                 mvwaddstr(win, 7, 1, "El código ya existe!. Abortando.");
 435                 wattroff(win, COLOR_PAIR(COLOR_YELLOW));
 436                 wrefresh(win);
 437                 getch();
 438         }
 439         form_destruir(form);
 440
 441         werase(win);
 442         wrefresh(win);
 443         delwin(win);
 444 }
 445
 446 int procesar_leer_articulo(t_Articulo *dst, void *src, EMUFS_REG_SIZE size, t_LstArticulos *lst)
 447 {
 448         char *fin, *ini;
 449         switch (lst->fp->tipo) {
 450                 case T1:
 451                 case T4:
 452                 case T2:
 453                         ini = (char *)src;
 454                         /* Copio el primer campo, esto es facil :-) */
 455                         memset(dst, 0, sizeof(t_Articulo));
 456                         memcpy(&dst->numero, ini, sizeof(unsigned int));
 457                         ini+=sizeof(unsigned int);
 458                         /* Ahora empieza el juego */
 459                         /* Los \0 son los delimitadores de campo! */
 460                         fin = ini;
 461                         while (*fin!='\0') fin++;
 462                         memcpy(dst->desc, ini, fin-ini+1);
 463
 464                         ini = fin+1;
 465                         fin = ini;
 466                         while (*fin!='\0') fin++;
 467                         memcpy(dst->presentacion, ini, fin-ini+1);
 468
 469                         ini = fin+1;
 470                         fin = ini;
 471                         while (*fin!='\0') fin++;
 472                         memcpy(dst->existencia, ini, fin-ini+1);
 473
 474                         ini = fin+1;
 475                         fin = ini;
 476                         while (*fin!='\0') fin++;
 477                         memcpy(dst->ubicacion, ini, fin-ini+1);
 478
 479                         ini = fin+1;
 480                         fin = ini;
 481                         while (*fin!='\0') fin++;
 482                         memcpy(dst->pvu, ini, fin-ini+1);
 483
 484                         ini = fin+1;
 485                         fin = (char *)src+size;
 486                         memcpy(dst->emin, ini, fin-ini);
 487
 488                         break;
 489                 case T5:
 490                 case T3:
 491                         memcpy(dst, src, sizeof(t_Articulo));
 492         }
 493
 494         return 1; /* Todo ok */
 495 }
 496
 497 void *procesar_guardar_articulo(t_Articulo *src, EMUFS_REG_SIZE *size, t_LstArticulos *lst)
 498 {
 499         char *tmp=NULL;
 500         int i[7];
 501         char *from = (char *)src;
 502         switch(lst->fp->tipo) {
 503                 case T1:
 504                 case T2:
 505                 case T4:
 506                         /* Calculo el tamaño que voy a necesitar */
 507                         i[0] = sizeof(unsigned int);
 508                         i[1] = sizeof(char)*(strlen(src->desc)+1);
 509                         i[2] = sizeof(char)*(strlen(src->presentacion)+1);
 510                         i[3] = sizeof(char)*(strlen(src->existencia)+1);
 511                         i[4] = sizeof(char)*(strlen(src->ubicacion)+1);
 512                         i[5] = sizeof(char)*(strlen(src->pvu)+1);
 513                         i[6] = sizeof(char)*(strlen(src->emin)+1);
 514                         (*size) = i[0]+i[1]+i[2]+i[3]+i[4]+i[5]+i[6];
 515                         tmp = (char *)malloc((*size));
 516                         if (tmp == NULL) return NULL;
 517                         memset(tmp, 0, *size);
 518                         memcpy(tmp, &src->numero, i[0]);
 519                         memcpy(tmp+i[0], src->desc, i[1]);
 520                         memcpy(tmp+i[0]+i[1], src->presentacion, i[2]);
 521                         memcpy(tmp+i[0]+i[1]+i[2], src->existencia, i[3]);
 522                         memcpy(tmp+i[0]+i[1]+i[2]+i[3], src->ubicacion, i[4]);
 523                         memcpy(tmp+i[0]+i[1]+i[2]+i[3]+i[4], src->pvu, i[5]);
 524                         memcpy(tmp+i[0]+i[1]+i[2]+i[3]+i[4]+i[5], src->emin, i[6]);
 525                 break;
 526                 case T5:
 527                 case T3:
 528                         /* Lleno el lugar no ocupado de los strings con *, para que el ver
 529                          * registro se vea bien
 530                          */
 531                         tmp = (char *)malloc(sizeof(t_Articulo));
 532                         memset(tmp, '*', sizeof(t_Articulo));
 533                         memcpy(tmp, from, sizeof(t_Articulo));
 534                         (*size) = sizeof(t_Articulo);
 535         }
 536         return tmp;
 537 }
 538
 539 void art_reformatear(t_Parametros *param)
 540 {
 541         char *tmpfile = "tmp_file.xxx";
 542         FILE *fp;
 543         char *save;
 544         int error;
 545         EMUFS_REG_SIZE size;
 546         EMUFS *emu;
 547         t_Articulo articulo, *un_articulo;
 548
 549         /* Creo el archivo temporal con los datos actuales */
 550         PERR("Creo dumpfile");
 551         dump_articulos(tmpfile);
 552         PERR("Listo");
 553
 554         /* Destruyo el EMUFS y todos sus indices */
 555         art_liberar(NULL);
 556
 557         /* vuelvo a crear el EMUFS y sus indices (esto deberia pisar lo actual) */
 558         PERR("Creando todo de nuevo")
 559
 560         lst_articulos = (t_LstArticulos *)malloc(sizeof(t_LstArticulos));
 561         lst_articulos->primero = NULL;
 562
 563         emu = lst_articulos->fp = emufs_crear("articulos", param->tipo_arch_art, param->tam_bloque_art, sizeof(t_Articulo));
 564         fprintf(stderr, "NUEVO %s con tipo %d\n", emu->nombre, param->tipo_arch_art);
 565         emufs_agregar_indice(emu, "presentacion", IND_EXAHUSTIVO, param->ind_art[2].tipo_arbol, IDX_STRING, STRUCT_OFFSET(un_articulo, desc), param->ind_art[2].tam_bloque, 1);
 566         emufs_agregar_indice(emu, "desc", IND_EXAHUSTIVO, param->ind_art[1].tipo_arbol, IDX_STRING, STRUCT_OFFSET(un_articulo, desc), param->ind_art[1].tam_bloque, 0);
 567         if ((param->tipo_arch_art != T4) && (param->tipo_arch_art != T5))
 568                 emufs_agregar_indice(emu, "codigo", IND_PRIMARIO, param->ind_art[0].tipo_arbol, IDX_INT, 0, param->ind_art[0].tam_bloque, 0);
 569         else
 570                 emufs_agregar_indice(emu, "codigo", IND_PRIMARIO, IND_B_PLUS, IDX_INT, 0, param->ind_art[0].tam_bloque, 0);
 571         PERR("Listo");
 572         /* Ahora solo resta volver a meter todos los datos en el archivo */
 573         fp = fopen(tmpfile, "rb");
 574         PERR("Agregando datos de nuevo")
 575         while (!feof(fp)) {
 576                 if (fread(&articulo, sizeof(t_Articulo), 1, fp) != 1) continue;
 577                 save = procesar_guardar_articulo(&articulo, &size, lst_articulos);
 578                 if (save) {
 579                         error = 0;
 580                         emu->grabar_registro(emu, save, size, &error);
 581                         free(save);
 582                 }
 583         }
 584         fclose(fp);
 585         PERR("Todo listo");
 586         unlink(tmpfile);
 587 }
 588
 589 int art_exportar_xml(const char *filename)
 590 {
 591         t_Articulo *art;
 592         EMUFS_REG_ID id;
 593         FILE *fp;
 594         CLAVE k;
 595         INDICE *idx;
 596
 597         idx = lst_articulos->fp->indices;
 598
 599         k = idx->obtener_menor_clave(idx);
 600
 601         if (!(fp = fopen(filename, "wt"))) return 0;
 602
 603         fprintf(fp, "<?xml version=\"1.0\" encoding=\"ISO-8859-1\" ?>\n\n");
 604         fprintf(fp, "<ARTICULOS>\n");
 605         while (k.i_clave != -1) {
 606                 art = art_obtener(lst_articulos, k.i_clave, &id);
 607                 if (art != NULL) {
 608                         fprintf(fp, "\t<ARTICULO ");
 609                         fprintf(fp, "NroArtículo=\"%d\" ", art->numero);
 610                         fprintf(fp, "Descripción=\"%s\" ", art->desc);
 611                         fprintf(fp, "Presentación=\"%s\" ", art->presentacion);
 612                         fprintf(fp, "Ubicación=\"%s\" ", art->ubicacion);
 613                         fprintf(fp, "Existencia=\"%s\" ", art->existencia);
 614                         fprintf(fp, "PVU=\"%s\" ", art->pvu);
 615                         fprintf(fp, "Emín=\"%s\" />\n", art->emin);
 616                         free(art);
 617                 }
 618                 k = idx->obtener_sig_clave(idx, k);
 619         }
 620         fprintf(fp, "</ARTICULOS>\n");
 621
 622         fclose(fp);
 623         return 1;
 624 }
 625
 626 /* Dejo el test para que no se pierda */
 627 void art_consultas_old(char *s)
 628 {
 629         /* TEST DE LISTA! */
 630         char txt[80];
 631         int i;
 632         t_Lista *lista;
 633         WINDOW *win, *win1;
 634
 635         win = newwin(LINES-4, COLS-2, 2, 1);
 636         win1 = derwin(win, LINES-6, COLS-4, 1, 1);
 637         werase(win);
 638         box(win, 0, 0);
 639         wrefresh(win);
 640
 641         /* Creo la lista */
 642         lista = lista_crear(3, win1, COLS-4, LINES-6);
 643
 644         /* Creo las columnas */
 645         lista_agregar_columna(lista, "Col1", DATO_INT, 0, 8);
 646         lista_agregar_columna(lista, "Col2", DATO_STR, 10, 45);
 647         lista_agregar_columna(lista, "Col3", DATO_FLOAT, 60, 10);
 648
 649         /* Agrego unos datos a ver que pasa */
 650         /* Pongo 100 y rezo */
 651         for(i=0; i<100; i++) {
 652                 sprintf(txt, "Texto del item %d", i);
 653                 lista_agregar_fila(lista, i, txt, (rand()%100)/100.0f);
 654         }
 655         curs_set(0);
 656         lista_ejecutar(lista);
 657         curs_set(1);
 658         wrefresh(win1);
 659         wrefresh(win);
 660         werase(win1);
 661         werase(win);
 662         wrefresh(win);
 663         delwin(win);
 664 }
 665
 666 void art_consultas_codigos(char *s, t_Lista *lista)
 667 {
 668         EMUFS_REG_ID dummy;
 669         int desde_codigo, hasta_codigo;
 670         CLAVE k, menor, mayor;
 671         t_Articulo *articulo;
 672         t_Form *form;
 673         INDICE *idx;
 674         int editar;
 675
 676         idx = lst_articulos->fp->indices;
 677
 678         /* El usuario ingresa rango a listar */
 679         form = form_crear(lista->win);
 680         form_agregar_widget(form, INPUT, "Desde Codigo", 8, "0");
 681         form_agregar_widget(form, INPUT, "Hasta Codigo", 8, "99999999");
 682
 683         form_ejecutar(form, 2, 2);
 684
 685         desde_codigo = form_obtener_valor_int(form, "Desde Codigo");
 686         hasta_codigo = form_obtener_valor_int(form, "Hasta Codigo");
 687
 688         form_destruir(form);
 689         werase(lista->win);
 690         wrefresh(lista->win);
 691
 692         /* Leo los datos desde el archivo */
 693         k = emufs_indice_generar_clave_desde_valor(idx, (char *)&desde_codigo);
 694
 695         menor = idx->obtener_menor_clave(idx);
 696         mayor = idx->obtener_mayor_clave(idx);
 697
 698         if (k.i_clave < menor.i_clave)
 699                 k = menor;
 700         if (k.i_clave > mayor.i_clave)
 701                 hasta_codigo = mayor.i_clave;
 702         fprintf(stderr, "k.i_clave = %d  -- hasta_codigo = %d\n", k.i_clave, hasta_codigo);
 703         while ((k.i_clave != -1) && (k.i_clave <= hasta_codigo)) {
 704                 PERR("BUSCO ARTICULO");
 705                 articulo = art_obtener(lst_articulos, k.i_clave, &dummy);
 706                 PERR("LO TENGO");
 707                 if (articulo != NULL) {
 708                         PERR("AGREGO A LA LISTA");
 709                         fprintf(stderr, "%d - %s\n", articulo->numero, articulo->desc);
 710                         lista_agregar_fila(lista,
 711                                 articulo->numero,
 712                                 articulo->desc,
 713                                 articulo->existencia,
 714                                 articulo->emin
 715                         );
 716                         free(articulo);
 717                 }
 718                 PERR("OBTENGO SIGUIENTE CLAVE");
 719                 k = idx->obtener_sig_clave(idx, k);
 720                 fprintf(stderr, "k.i_clave = %d  -- hasta_codigo = %d\n", k.i_clave, hasta_codigo);
 721         }
 722
 723         curs_set(0);
 724         editar = lista_ejecutar(lista);
 725         curs_set(1);
 726
 727         if (editar != -1) {
 728                 char cc[20];
 729                 sprintf(cc, "%d", editar);
 730                 art_modificar(cc);
 731         }
 732 }
 733
 734 void art_consultas_stock(char *s, t_Lista *lista)
 735 {
 736         CLAVE k, menor;
 737         t_Articulo articulo;
 738         t_Form *form;
 739         INDICE *idx;
 740         float por;
 741         int editar;
 742
 743         idx = emufs_buscar_indice_por_nombre(lst_articulos->fp, "desc");
 744         if (idx == NULL) PERR("NO SE ENCUENTRA INDICE DESC!!!");
 745
 746         /* El usuario ingresa rango a listar */
 747         form = form_crear(lista->win);
 748         form_agregar_widget(form, INPUT, "Ingrese %", 8, "0");
 749
 750         form_ejecutar(form, 2, 2);
 751
 752         por = form_obtener_valor_float(form, "Ingrese %");
 753
 754         form_destruir(form);
 755         werase(lista->win);
 756         wrefresh(lista->win);
 757
 758         menor = idx->obtener_menor_clave(idx);
 759
 760         k = menor;
 761         while (k.i_clave != -1) {
 762                 char *tmp;
 763                 EMUFS_REG_SIZE size;
 764                 int error, cant, i;
 765                 INDICE_DATO *datos;
 766                 CLAVE k1;
 767                 datos = idx->buscar_entradas(idx, k, &cant);
 768                 for(i=0; i<cant; i++) {
 769                         error = 1;
 770                         k1.i_clave = datos[i].id;
 771                         tmp = lst_articulos->fp->leer_registro(lst_articulos->fp, k1, &size, &error);
 772
 773                         if (tmp != NULL) {
 774                                 procesar_leer_articulo(&articulo, tmp, size, lst_articulos);
 775
 776                                 if (atof(articulo.existencia) <= (1.0f+por)*atof(articulo.emin)) {
 777                                         lista_agregar_fila(lista,
 778                                                 articulo.numero,
 779                                                 articulo.desc,
 780                                                 articulo.existencia,
 781                                                 articulo.emin
 782                                         );
 783                                 }
 784                                 free(tmp);
 785                         }
 786                 }
 787                 if (datos) free(datos);
 788                 k = idx->obtener_sig_clave(idx, k);
 789         }
 790
 791         curs_set(0);
 792         editar = lista_ejecutar(lista);
 793         curs_set(1);
 794         if (editar != -1) {
 795                 char cc[20];
 796                 sprintf(cc, "%d", editar);
 797                 art_modificar(cc);
 798         }
 799 }
 800
 801 void art_consultas_cambiar_precio(char *s, t_Lista *lista)
 802 {
 803         CLAVE k, menor;
 804         t_Articulo articulo;
 805         t_Form *form;
 806         INDICE *idx;
 807         float por, pvu;
 808         char desc[51], uno_solo;
 809
 810         idx = emufs_buscar_indice_por_nombre(lst_articulos->fp, "desc");
 811         if (idx == NULL) PERR("NO SE ENCUENTRA INDICE DESC!!!");
 812
 813         /* El usuario ingresa rango a listar */
 814         form = form_crear(lista->win);
 815         form_agregar_widget(form, INPUT, "Desc. Articulo (nulo==Todos)", 50, "");
 816         form_agregar_widget(form, INPUT, "Ingrese %", 8, "0");
 817
 818         werase(lista->win);
 819         wrefresh(lista->win);
 820         form_ejecutar(form, 2, 2);
 821
 822         por = form_obtener_valor_float(form, "Ingrese %");
 823         strcpy(desc, form_obtener_valor_char(form, "Desc. Articulo (nulo==Todos)"));
 824
 825         form_destruir(form);
 826         werase(lista->win);
 827         wrefresh(lista->win);
 828
 829         uno_solo = 1;
 830         if (strlen(desc) == 0) {
 831                 uno_solo = 0;
 832                 k = menor = idx->obtener_menor_clave(idx);
 833         } else {
 834                 k.i_clave = 1;
 835         }
 836
 837         while (k.i_clave != -1) {
 838                 char *tmp;
 839                 EMUFS_REG_SIZE size;
 840                 int error, cant, i;
 841                 INDICE_DATO *datos;
 842                 CLAVE k1;
 843                 if (uno_solo == 0)
 844                         datos = idx->buscar_entradas(idx, k, &cant);
 845                 else
 846                         datos = emufs_buscar_registros(lst_articulos->fp, "desc", desc, &cant);
 847                 fprintf(stderr, "obtuve %d claves para %s\n", cant, desc);
 848                 for(i=0; i<cant; i++) {
 849                         error = 1;
 850                         k1.i_clave = datos[i].id;
 851                         tmp = lst_articulos->fp->leer_registro(lst_articulos->fp, k1, &size, &error);
 852
 853                         if (tmp != NULL) {
 854                                 procesar_leer_articulo(&articulo, tmp, size, lst_articulos);
 855                                 free(tmp);
 856
 857                                 /* XXX */
 858                                 pvu = atof(articulo.pvu);
 859                                 pvu += pvu*por;
 860
 861                                 sprintf(articulo.pvu, "%.2f", pvu);
 862                                 tmp = procesar_guardar_articulo(&articulo, &size, lst_articulos);
 863                                 error = 0;
 864                                 /* README : Aca si tengo que pasar el INDICE_DATO correcto, para que la funcion
 865                                  * borrar sea capaz de eliminar solo el item que corresponde en las
 866                                  * claves con repeticion
 867                                  */
 868                                 PERR("=== MODIFICANDO ===");
 869                                 fprintf(stderr, "Desc=%s , PVU=%s, Codigo=%d\n", articulo.desc, articulo.pvu, articulo.numero);
 870                                 lst_articulos->fp->modificar_registro(lst_articulos->fp, k1, tmp, size, &error, datos[i]);
 871                                 PERR("===     FIN     ===");
 872                         }
 873                 }
 874                 if (datos) free(datos);
 875                 if (uno_solo == 0)
 876                         k = idx->obtener_sig_clave(idx, k);
 877                 else
 878                         k.i_clave = -1;
 879         }
 880 }
 881
 882 void art_consultas_varias(char *nombre_indice, char *titulo, t_Lista *lista)
 883 {
 884         int i, cant, error, editar;
 885         char desc[51], *tmp;
 886         t_Articulo articulo;
 887         t_Form *form;
 888         INDICE_DATO *datos;
 889         CLAVE k;
 890         EMUFS *fs;
 891         EMUFS_REG_SIZE size;
 892
 893         fs = lst_articulos->fp;
 894
 895         /* El usuario ingresa rango a listar */
 896         form = form_crear(lista->win);
 897         form_agregar_widget(form, INPUT, titulo, 50, "");
 898
 899         werase(lista->win);
 900         form_ejecutar(form, 2, 2);
 901
 902         tmp = form_obtener_valor_char(form, titulo);
 903         strcpy(desc, tmp);
 904
 905         form_destruir(form);
 906         werase(lista->win);
 907         wrefresh(lista->win);
 908
 909         /* Leo los datos desde el archivo */
 910         datos = emufs_buscar_registros(fs, nombre_indice, desc, &cant);
 911         for(i=0; i<cant; i++) {
 912                 k.i_clave = datos[i].id;
 913                 error = 1;
 914                 tmp = (char *)fs->leer_registro(fs, k, &size, &error);
 915                 if (tmp != NULL) {
 916                         procesar_leer_articulo(&articulo, tmp, size, lst_articulos);
 917                         lista_agregar_fila(lista,
 918                                                         articulo.numero,
 919                                                         articulo.desc,
 920                                                         articulo.existencia,
 921                                                         articulo.emin
 922                                         );
 923                         free(tmp);
 924                 } else {
 925                         PERR("NO SE PUDO RECUPERAR EL REGISTRO DE DATOS");
 926                 }
 927         }
 928         if (datos) free(datos);
 929         curs_set(0);
 930         editar = lista_ejecutar(lista);
 931         curs_set(1);
 932         if (editar != -1) {
 933                 char cc[20];
 934                 sprintf(cc, "%d", editar);
 935                 art_modificar(cc);
 936         }
 937
 938 }
 939
 940 void art_consultas(char *s)
 941 {
 942         t_Lista *lista;
 943         WINDOW *win1, *win;
 944         MENU(mi_menu) {
 945                 MENU_OPCION("por Codigos", "Consulta de Articulos por rango de codigo."),
 946                 MENU_OPCION("por Descripcion", "Consulta por descripcion"),
 947                 MENU_OPCION("por Presentacion", "Consulta por Presentacion"),
 948                 MENU_OPCION("por Sock Faltante", "Consulta de articulos por stock"),
 949                 MENU_OPCION("Modificar Precios", "Permite Modificar los PVU"),
 950                 MENU_OPCION("Volver", "Volver al menu anterior.")
 951         };
 952         int opt;
 953
 954         win = newwin(LINES-4, COLS-2, 2, 1);
 955         win1 = derwin(win, LINES-6, COLS-4, 1, 1);
 956         werase(win1);
 957         werase(win);
 958         box(win, 0, 0);
 959         wrefresh(win1);
 960         wrefresh(win);
 961
 962         /* Creo la lista donde mostrar la consulta*/
 963         /* Muestro solo info relevante */
 964         lista = lista_crear(4, win1, COLS-4, LINES-6);
 965
 966         /* Creo las columnas */
 967         lista_agregar_columna(lista, "Numero", DATO_INT, 0, 8);    /* numero     */
 968         lista_agregar_columna(lista, "Descripcion", DATO_STR, 10, 51);  /* desc       */
 969         lista_agregar_columna(lista, "Existencia", DATO_STR, 55, 9);   /* existencia */
 970         lista_agregar_columna(lista, "S. Minimo", DATO_STR, 66, 9);   /* enim       */
 971
 972         while ((opt = menu_ejecutar(mi_menu, 6, "Consulta de Articulos")) != 5) {
 973                 switch (opt) {
 974                         case 0:
 975                                 art_consultas_codigos(s, lista);
 976                         break;
 977                         case 1:
 978                                 art_consultas_varias("desc", "Descripcion", lista);
 979                         break;
 980                         case 2:
 981                                 art_consultas_varias("presentacion", "Presentacion", lista);
 982                         break;
 983                         case 3:
 984                                 art_consultas_stock(s, lista);
 985                         break;
 986                         case 4:
 987                                 art_consultas_cambiar_precio(s, lista);
 988                 }
 989                 lista_clear(lista);
 990                 werase(win1);
 991                 werase(win);
 992                 box(win, 0, 0);
 993                 wrefresh(win1);
 994                 wrefresh(win);
 995         }
 996         werase(win1);
 997         werase(win);
 998         wrefresh(win);
 999         delwin(win);
1000 }
1001
1002
1003 void imprimir(WINDOW *win, int y, int x, char *s, char *b)
1004 {
1005         wmove(win, y, x);
1006         waddstr(win, s);
1007         waddstr(win, b);
1008 }
1009
1010 void mostrar_art(WINDOW *win, CLAVE k, char *s, INDICE *idx)
1011 {
1012         t_Articulo *art;
1013         EMUFS_REG_ID dummy;
1014         int y = 3;
1015         char numero[10];
1016         /* XXX SOLO PARA CODIGO XXX */
1017
1018         wattron(win, COLOR_PAIR(COLOR_RED));
1019         mvwaddstr(win, 1, 5, "Recorriendo Articulos por indice ");
1020         waddstr(win, s);
1021         wattroff(win, COLOR_PAIR(COLOR_RED));
1022
1023         wattron(win, A_BOLD);
1024         mvwaddstr(win, 18, 5, "Teclas:");
1025         wattroff(win, A_BOLD);
1026         mvwaddstr(win, 19, 5, " L = Siguiente");
1027         mvwaddstr(win, 20, 5, " K = Anterior");
1028
1029         if (strcmp(s, "codigo") == 0) {
1030                 art = art_obtener(lst_articulos, k.i_clave, &dummy);
1031         } else {
1032                 INDICE_DATO *datos;
1033                 EMUFS_REG_SIZE size;
1034                 int cant, error;
1035                 char *tmp;
1036
1037                 art = (t_Articulo *)malloc(sizeof(t_Articulo));
1038                 /* Ya se cual tengo que retornar. Ahora veo si lo cargo desde el archivo */
1039                 PERR("Busco todos los datos que tengan esta clave");
1040                 datos = idx->buscar_entradas(idx, k, &cant);
1041                 if (datos == NULL) {
1042                         free(art);
1043                         art = NULL;
1044                 } else {
1045                         fprintf(stderr, "Tengo %d datos\n", cant);
1046                         error = 1;
1047                         k.i_clave = datos[0].id;
1048                         PERR("Leo el primer dato");
1049                         tmp = lst_articulos->fp->leer_registro(lst_articulos->fp, k, &size, &error);
1050                         if (tmp == NULL) {
1051                                 free(art);
1052                                 art = NULL;
1053                         } else {
1054                                 if (procesar_leer_articulo(art, tmp, size, lst_articulos) != 1) {
1055                                         free(art);
1056                                         free(tmp);
1057                                         art = NULL;
1058                                 }
1059                         }
1060                         free(datos);
1061                 }
1062         }
1063
1064
1065         if (art != NULL) {
1066                 sprintf(numero, "%08d", art->numero);
1067
1068                 imprimir(win, y++, 5, "Numero      : ", numero);
1069                 imprimir(win, y++, 5, "Descripcion : ", art->desc);
1070                 imprimir(win, y++, 5, "Presentacion: ", art->presentacion);
1071                 imprimir(win, y++, 5, "Existencia  : ", art->existencia);
1072                 imprimir(win, y++, 5, "Ubicacion   : ", art->ubicacion);
1073                 imprimir(win, y++, 5, "P. Unitario : ", art->pvu);
1074                 imprimir(win, y++, 5, "Stock Minimo: ", art->emin);
1075
1076                 free(art);
1077         } else {
1078                 PERR("NO EXISTE EL ARTICULO");
1079         }
1080
1081 }
1082
1083 void art_recorrer_con_indice(char *s)
1084 {
1085         WINDOW *win, *win1;
1086         INDICE *idx;
1087         CLAVE stack[1000]; /* shhhh */
1088         CLAVE k;
1089         int stack_pos=0, c;
1090
1091         PERR("Busco indice");
1092         idx = emufs_buscar_indice_por_nombre(lst_articulos->fp, s);
1093
1094         win = newwin(LINES-4, COLS-2, 2, 1);
1095         win1 = derwin(win, LINES-6, COLS-4, 1, 1);
1096         werase(win);
1097         werase(win1);
1098         box(win, 0, 0);
1099         wrefresh(win1);
1100         wrefresh(win);
1101
1102         PERR("Obtengo clave menor");
1103         k = idx->obtener_menor_clave(idx);
1104
1105         PERR("Muestro el primer elemento");
1106
1107
1108         mostrar_art(win1, k, s, idx);
1109         wrefresh(win1);
1110         wrefresh(win);
1111         PERR("Sigue el usuario");
1112         curs_set(0);
1113         stack[0] = k;
1114         while ((c=wgetch(win)) != 13) {
1115                 switch (c) {
1116                         case 'L':
1117                         case 'l':
1118                                 stack[stack_pos++] = k; /* Guardo la clave para poder volver */
1119                                 k = idx->obtener_sig_clave(idx, k);
1120                                 /* TODO Verificar que no me pase del fin */
1121                                 break;
1122                         case 'K':
1123                         case 'k':
1124                                 /* recupero la anterior */
1125                                 stack_pos--;
1126                                 if (stack_pos < 0) stack_pos = 0;
1127                                 k = stack[stack_pos];
1128                                 break;
1129                         default:
1130                                 continue;
1131                 }
1132                 werase(win1);
1133                 werase(win);
1134                 mostrar_art(win1, k, s, idx);
1135                 wrefresh(win1);
1136                 wrefresh(win);
1137         }
1138         curs_set(1);
1139
1140         werase(win1);
1141         werase(win);
1142         wrefresh(win);
1143         delwin(win);
1144 }
1145
1146 void art_recorrer()
1147 {
1148         char *ind[3] = {"codigo", "desc", "presentacion"};
1149         MENU(mi_menu) {
1150                 MENU_OPCION("Codigos", "Recorrer por Indice Codigo"),
1151                 MENU_OPCION("Descripcion", "Recorrer por Indice Descripcionn"),
1152                 MENU_OPCION("Presentacion", "Recorrer por Indice Presentacion"),
1153                 MENU_OPCION("Volver", "Volver al menu anterior.")
1154         };
1155         int opt;
1156         while ((opt = menu_ejecutar(mi_menu, 4, "Recorrer Articulos")) != 3) {
1157                 art_recorrer_con_indice(ind[opt]);
1158         }
1159 }
1160
1161 void art_ver_ventas()
1162 {
1163 #ifdef cONDORITO
1164         char desde_fecha[10], hasta_fecha[10];
1165         t_Lista *lista;
1166         t_Form *form;
1167         WINDOW *win, *win1;
1168         INDICE *idx;
1169         CLAVE k_menor, k_mayor;
1170
1171         win = newwin(LINES-4, COLS-2, 2, 1);
1172         win1 = derwin(win, LINES-6, COLS-4, 1, 1);
1173         werase(win);
1174         werase(win1);
1175         box(win, 0, 0);
1176         wrefresh(win1);
1177         wrefresh(win);
1178
1179         /* El usuario ingresa rango a listar */
1180         form = form_crear(win1);
1181         form_agregar_widget(form, INPUT, "Desde Fecha", 8, "");
1182         form_agregar_widget(form, INPUT, "Hasta Fecha", 8, "");
1183         form_ejecutar(form, 2, 2);
1184
1185         strcpy(desde_fecha, form_obtener_valor_char(form, "Desde Fecha"));
1186         strcpy(hasta_fecha, form_obtener_valor_char(form, "Hasta Fecha"));
1187
1188         form_destruir(form);
1189         werase(win1);
1190         wrefresh(win1);
1191         werase(win);
1192         wrefresh(win);
1193
1194         /* Si el usuario no ingreso alguno de los datos, lo obtengo del indice */
1195         /*idx = emufs_buscar_indice_por_nombre(fact_get_lst()->fp, "emision");*/
1196
1197         /* Uso el indice por numero de articulo */
1198         idx = fact_get_lst()->fp->externo;
1199
1200         if (idx==NULL) PERR("INDICE EMISION NO SE ENCUENTRA!!");
1201         if (strlen(desde_fecha) == 0) {
1202                 k_menor = idx->obtener_menor_clave(idx);
1203                 emufs_indice_obtener_valor_desde_clave(idx, k_menor, desde_fecha);
1204                 PERR("OBTUVE MENOR CLAVE DESDE EL INDICE");
1205                 PERR(desde_fecha);
1206         }
1207         if (strlen(hasta_fecha) == 0) {
1208                 k_mayor = idx->obtener_mayor_clave(idx);
1209                 emufs_indice_obtener_valor_desde_clave(idx, k_mayor, hasta_fecha);
1210                 PERR("OBTUVE MAYOR CLAVE DESDE EL INDICE");
1211                 PERR(hasta_fecha);
1212         }
1213
1214         /* Creo la lista donde mostrar la consulta*/
1215         /* Muestro solo info relevante */
1216         lista = lista_crear(4, win1, COLS-4, LINES-6);
1217
1218         /* Creo las columnas */
1219         lista_agregar_columna(lista, "Fecha", DATO_STR, 0, 9);       /* emision    */
1220         lista_agregar_columna(lista, "Numero", DATO_INT, 20, 8);     /* numero articulo    */
1221         lista_agregar_columna(lista, "Cantidad", DATO_INT, 30, 10);  /* estado     */
1222
1223         /* Leo los datos desde el archivo */
1224         while (k_menor.i_clave != -1) {
1225                 t_Factura fact;
1226                 int error, cant, i;
1227                 char *leo;
1228                 EMUFS_REG_SIZE size;
1229                 INDICE_DATO *datos;
1230                 CLAVE k1;
1231                 datos = idx->buscar_entradas(idx, k_menor, &cant);
1232                 for(i=0; i<cant; i++) {
1233                         error = 1;
1234                         k1.i_clave = datos[i].id;
1235                         leo = lst_facturas->fp->leer_registro(lst_facturas->fp, k1, &size, &error);
1236                         if (leo != NULL) {
1237                                 procesar_leer_factura(&fact, leo, size, lst_facturas);
1238                                 free(leo);
1239                         }
1240                         lista_agregar_fila(lista,
1241                                 fact.emision,
1242                                 get_estado(fact.estado),
1243                                 get_forma_pago(fact.fp),
1244                                 get_importe_factura(fact.items, fact.cant_items, fact.procdoi)
1245                         );
1246                 }
1247                 if (datos) free(datos);
1248                 if (fact.items) free(fact.items);
1249                 k_menor = idx->obtener_sig_clave(idx, k_menor);
1250         }
1251
1252         curs_set(0);
1253         lista_ejecutar(lista);
1254         curs_set(1);
1255         wrefresh(win1);
1256         wrefresh(win);
1257         werase(win1);
1258         werase(win);
1259         wrefresh(win);
1260         delwin(win);
1261 #endif
1262 }
1263
1264 void art_actualizar_stock(int numero, int cv)
1265 {
1266         t_Articulo *articulo;
1267         EMUFS_REG_ID dummy;
1268         char *tmp;
1269         EMUFS_REG_SIZE size;
1270         int error, stock;
1271
1272         articulo = art_obtener(lst_articulos, numero, &dummy);
1273         if (articulo != NULL) {
1274                 /* Actualizo el stock */
1275                 stock = atoi(articulo->existencia);
1276                 stock -= cv;
1277                 sprintf(articulo->existencia, "%d", stock);
1278                 tmp = procesar_guardar_articulo(articulo, &size, lst_articulos);
1279                 if (tmp) {
1280                         CLAVE k;
1281                         INDICE_DATO dummy1;
1282                         k.i_clave = numero;
1283                         EMUFS *fp;
1284                         /* dummy se pasa porque esto se hace por clave primaria, y el INDICE_DATO que se
1285                          * pasa solo es requerido cuando son claves multiples
1286                          */
1287                         PERR("Guardando modificacion de Stock");
1288                         error = 0;
1289                         fprintf(stderr, "PTR=%p %p\n", lst_articulos, lst_articulos->fp);
1290                         fp = lst_articulos->fp;
1291                         PERR("Pase1");
1292                         fprintf(stderr, "METODO : %p\n", fp->modificar_registro);
1293                         fp->modificar_registro(fp, k, tmp, size, &error, dummy1);
1294                         PERR("Pase2");
1295                         PERR("Listo");
1296                         free(tmp);
1297                 }
1298         }
1299 }
1300
1301 static void dump_articulos(char *tmpfile)
1302 {
1303         t_Articulo *art;
1304         EMUFS_REG_ID id;
1305         FILE *fp;
1306         CLAVE k;
1307         INDICE *idx;
1308
1309         idx = lst_articulos->fp->indices;
1310
1311         k = idx->obtener_menor_clave(idx);
1312
1313         if (!(fp = fopen(tmpfile, "wb"))) return;
1314
1315         while (k.i_clave != -1) {
1316                 art = art_obtener(lst_articulos, k.i_clave, &id);
1317                 if (art != NULL) {
1318                         fwrite(art, 1, sizeof(t_Articulo), fp);
1319                         free(art);
1320                 }
1321                 k = idx->obtener_sig_clave(idx, k);
1322         }
1323
1324         fclose(fp);
1325         return;
1326 }
1327