* BUGFIX : procesar_guardar_factura grababa mal

* BUGFIX : leer_items no leia si el tipo de archivo era variable
* Completo : Completo Ver Registros para factura para cualquier tipo de archivo.

diff --git a/emufs_gui/facturas.c b/emufs_gui/facturas.c
index f1b60aafc8f2e43521ace8bf9c922708603783fe..af01d26efdbc440305c9e438b8783a174e702626 100644 (file)
--- a/emufs_gui/facturas.c
+++ b/emufs_gui/facturas.c
@@ -83,8 +83,25 @@ t_Item *leer_items(xmlNode *node, int *cant, int size)
        int count;
        char *prop;
        if (size == -1) {
-               *cant = 0;
-               return NULL;
+               tmp = NULL;
+               count = 0;
+               node = node->children;
+               while (node) {
+                       if (node->type == XML_ELEMENT_NODE) {
+                               if (strcmp(node->name, "ITEMVENTA") == 0) {
+                                       count++;
+                                       tmp = realloc(tmp, sizeof(t_Item)*count);
+                                       memset(&tmp[count-1], '*', sizeof(t_Item));
+                                       prop = xml_get_prop(node, "NroArtículo");
+                                       tmp[count-1].numero = atoi(prop);
+                                       xmlFree(prop);
+                                       strcpy(tmp[count-1].cv, prop = xml_get_prop(node, "CV")); xmlFree(prop);
+                                       strcpy(tmp[count-1].pvu, prop = xml_get_prop(node, "PVU")); xmlFree(prop);
+                               }
+                       }
+                       node = node->next;
+               }
+               *cant = count;
        } else {
                (*cant) = size;
                tmp = (t_Item *)malloc(sizeof(t_Item)*size);
@@ -206,7 +223,7 @@ t_LstFacturas *fact_cargar(const char *filename, int tipo, int tam_bloque)
                                        strcpy(fact.cheque, prop = xml_get_prop(node, "NroCheque")); xmlFree(prop);
 
                                        fact.nota = leer_nota(node);
-                                       fact.items = leer_items(node, &fact.cant_items, (tipo==3)?10:-1);
+                                       fact.items = leer_items(node, &fact.cant_items, ((tipo-1)==T3)?10:-1);
 
                                        error = 0;
                                        id = tmp->fp_texto->grabar_registro(tmp->fp_texto, fact.nota, strlen(fact.nota)+1, &error);
@@ -586,17 +603,18 @@ void *procesar_guardar_factura(t_Factura *f, t_LstFacturas *lst, EMUFS_REG_SIZE
                        memset(tmp, 0, *size);
                        /* Ahora copio la info */
                        memcpy(tmp, &f->numero, i[0]);
-                       memcpy(tmp, &f->procdoi, i[1]);
-                       memcpy(tmp, &f->numero_remito, i[2]);
-                       memcpy(tmp, &f->cant_items, i[3]);
-                       memcpy(tmp, &f->reg_nota, i[4]);
+                       memcpy(tmp+i[0], &f->procdoi, i[1]);
+                       memcpy(tmp+i[0]+i[1], &f->numero_remito, i[2]);
+                       memcpy(tmp+i[0]+i[1]+i[2], &f->cant_items, i[3]);
+                       memcpy(tmp+i[0]+i[1]+i[2]+i[3], &f->reg_nota, i[4]);
                        memcpy(tmp+i[0]+i[1]+i[2]+i[3]+i[4], f->emision, i[5]);
                        memcpy(tmp+i[0]+i[1]+i[2]+i[3]+i[4]+i[5], f->vencimiento, i[6]);
                        memcpy(tmp+i[0]+i[1]+i[2]+i[3]+i[4]+i[5]+i[6], f->estado, i[7]);
                        memcpy(tmp+i[0]+i[1]+i[2]+i[3]+i[4]+i[5]+i[6]+i[7], f->fp, i[8]);
                        memcpy(tmp+i[0]+i[1]+i[2]+i[3]+i[4]+i[5]+i[6]+i[7]+i[8], f->ctacte, i[9]);
                        memcpy(tmp+i[0]+i[1]+i[2]+i[3]+i[4]+i[5]+i[6]+i[7]+i[8]+i[9], f->cheque, i[10]);
-                       memcpy(tmp+i[0]+i[1]+i[2]+i[3]+i[4]+i[5]+i[6]+i[7]+i[8]+i[9]+i[10], f->items, i[11]);
+                       if (i[11] != 0)
+                               memcpy(tmp+i[0]+i[1]+i[2]+i[3]+i[4]+i[5]+i[6]+i[7]+i[8]+i[9]+i[10], f->items, i[11]);
                break;
                case T3:
                        (*size) = sizeof(t_Factura)-sizeof(char *)-sizeof(t_Item *) + f->cant_items*sizeof(t_Item);

diff --git a/emufs_gui/registros.c b/emufs_gui/registros.c
index babea55ff39345375b86a35fb76290c30e69f4b3..65f8070d8436d58ff468faea34449cce700ce52e 100644 (file)
--- a/emufs_gui/registros.c
+++ b/emufs_gui/registros.c
@@ -9,7 +9,7 @@ static char *procesar_registro_articulo_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_S
 static char *procesar_registro_articulo_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);
 
 static char *procesar_registro_factura_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);
-/*static char *procesar_registro_factura_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);*/
+static char *procesar_registro_factura_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho);
 
 static int preguntar_id(WINDOW *win, EMUFS *fp);
 
@@ -80,7 +80,10 @@ void ver_registros(WINDOW *padre, int w, int h, int cual)
        switch (fp->tipo) {
                case T1:
                        waddstr(padre, "Registro variable con bloque parametrizado.");
-                       procesar = procesar_registro_articulo_tipo1;
+                       if (cual == 0)
+                               procesar = procesar_registro_articulo_tipo1;
+                       else
+                               procesar = procesar_registro_factura_tipo1;
                break;
                case T2:
                        waddstr(padre, "Registro variable sin bloques.");
@@ -510,7 +513,7 @@ char *procesar_registro_factura_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *siz
                tmp1 += 10;
                tmp += sizeof(int);
                /* Pongo reg_nota */
-               sprintf(tmp1, "{%08lu}", *((EMUFS_BLOCK_ID*)tmp));
+               sprintf(tmp1, "(%08lu)", *((EMUFS_BLOCK_ID*)tmp));
                tmp1 += 10;
                tmp += sizeof(EMUFS_BLOCK_ID);
 
@@ -580,3 +583,159 @@ char *procesar_registro_factura_tipo3(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *siz
 
        return salida;
 }
+
+char *procesar_registro_factura_tipo1(EMUFS *emu, char *ptr, EMUFS_REG_SIZE *size, int *pos_actual, int *ancho)
+{
+       char *tmp, *salida, *tmp1, pos_actualizada, ant;
+       EMUFS_REG_SIZE offset, curr_size;
+       char flotante[10];
+       int cant_header, i=0, j, tam_data, k;
+       int cant_items;
+       if (ptr == NULL) return NULL;
+
+       PERR("Empieza el baile");
+       cant_header = 0;
+       offset = 0;
+       do {
+               /* Me salto el ID, que no me interesa saber su valor */
+               offset += sizeof(EMUFS_REG_ID);
+               /* Copio el tamaño del registro de la cabecera. */
+               memcpy(&curr_size, ptr + offset, sizeof(EMUFS_REG_SIZE));
+               offset += sizeof(EMUFS_REG_SIZE);
+
+               /* Desplazo el offset */
+               if (curr_size == 0) {
+                       /* Si el tamaño de registro es 0, quiere decir que llegue a la
+                        * parte que esta vacia */
+                       break;
+               } else {
+                       cant_header++;
+                       offset += curr_size;
+               }
+       } while (offset+sizeof(EMUFS_REG_SIZE)+sizeof(EMUFS_REG_ID) < (*size));
+
+       fprintf(stderr, "Tengo %d headers\n", cant_header);
+       /* El tamaño del nuevo array lo calculo asi :
+        *   
+        */
+       tmp1 = salida = (char *)malloc(1000000); /*(*size)-(sizeof(char *)+sizeof(t_Item *)+sizeof(EMUFS_REG_ID)+sizeof(int)*3+sizeof(float)+sizeof(EMUFS_BLOCK_ID))*cant_header + 5*cant_header*10+1);*/
+       if (salida == NULL) {
+               PERR("Error de malloc en salida");
+               return NULL;
+       }
+       tmp = ptr;
+       pos_actualizada = 0;
+       (*ancho) = 0;
+       i = 0;
+       while (i<cant_header) {
+               fprintf(stderr, "Voy a hacer el %d de %d\n", i, cant_header);
+               /* Verifico la pos_actual para el resaltado, asi queda coherente 
+                * en el cambio de formato
+                */
+               if (((tmp - ptr) == *pos_actual) && (!pos_actualizada)) {
+                       (*pos_actual) = tmp1-salida;
+                       pos_actualizada = 1;
+               }
+               /* Pongo el ID del registro */
+               sprintf(tmp1, "(%08lu)", *((EMUFS_REG_ID *)tmp));
+               tmp1 += 10;
+               tmp += sizeof(EMUFS_REG_ID);
+               /* Cantidad de espacio que ocupa la data */
+               sprintf(tmp1, "{%08lu}", *((EMUFS_REG_SIZE *)tmp));
+               tam_data = *((EMUFS_REG_SIZE *)tmp) - sizeof(int)*3 - sizeof(float) - sizeof(EMUFS_BLOCK_ID);
+               tmp1 += 10;
+               tmp += sizeof(EMUFS_REG_SIZE);
+               /* Pongo el campo numero */
+               sprintf(tmp1, "[%08d]", *((int *)tmp));
+               tmp1 += 10;
+               tmp += sizeof(int);
+               /* Pongo campo procdoi */
+               sprintf(flotante, "[%5.2f]", *((float *)tmp));
+               memcpy(tmp1, flotante, strlen(flotante));
+               tmp1 += strlen(flotante);
+               tmp += sizeof(float);
+               /* Pongo campo numero_remito */
+               sprintf(tmp1, "[%08d]", *((int *)tmp));
+               tmp1 += 10;
+               tmp += sizeof(int);
+               /* Pongo numero de items */
+               sprintf(tmp1, "[%08d]", *((int *)tmp));
+               cant_items = *((int *)tmp);
+               tmp1 += 10;
+               tmp += sizeof(int);
+               /* Pongo reg_nota */
+               sprintf(tmp1, "(%08lu)", *((EMUFS_BLOCK_ID*)tmp));
+               tmp1 += 10;
+               tmp += sizeof(EMUFS_BLOCK_ID);
+
+               if (pos_actualizada == 1) {
+                       (*ancho) = 60+strlen(flotante);
+               }
+               j = 0;
+               PERR("Voy por la data");
+               fprintf(stderr, "Tam = %d , items = %d\n", tam_data, cant_items);
+               while (j < (tam_data-cant_items*sizeof(t_Item))) {
+                       if (*tmp == '\0') {
+                               if (ant == (*tmp)){
+                                       (*tmp1) = '.';
+                               } else {
+                                       (*tmp1) = '|';
+                               }
+                       } else {
+                               (*tmp1) = (*tmp);
+                       }
+                       ant = (*tmp);
+                       tmp++;
+                       tmp1++;
+                       if (pos_actualizada == 1)
+                               (*ancho)++;
+                       j++;
+               }
+               /* Ahora proceso los items */
+               k = 0;
+               fprintf(stderr, "ahora por los %d items\n", cant_items);
+               while (k < cant_items) {
+                       sprintf(tmp1, "[%08d]", *((int *)tmp));
+                       tmp1 += 10;
+                       tmp += sizeof(int);
+                       if (pos_actualizada == 1)
+                               (*ancho)+=10;
+                       j = 0;
+                       while (j < (sizeof(t_Item)-sizeof(int))) {
+                               if (*tmp == '\0') {
+                                       if (ant == (*tmp)){
+                                               (*tmp1) = '.';
+                                       } else {
+                                               (*tmp1) = '|';
+                                       }
+                               } else {
+                                       (*tmp1) = (*tmp);
+                               }
+                               ant = (*tmp);
+                               tmp++;
+                               tmp1++;
+                               if (pos_actualizada == 1)
+                                       (*ancho)++;
+                               j++;
+                       }
+                       k++;
+               }
+               if (pos_actualizada == 1)
+                       pos_actualizada = 2;
+               PERR(salida);
+               i++;
+       }
+       free(ptr);
+
+       PERR("Termine");
+       if (emu->tam_bloque > emu->tam_reg) {
+               (*size) = tmp1-salida;
+       } else {
+               (*size) = tmp1-salida;
+               (*ancho) = tmp1-salida;
+       }
+       salida[*size-1] = '\0';
+
+       return salida;
+}
+