#include "common.h"
#include "menu.h"
#include "lista.h"
+#include "articulos.h"
+#include "base.h"
+#include "extsort.h"
static t_LstFacturas *lst_facturas;
int eliminar_nodo_factura(t_LstFacturas *lst, t_Reg_Factura *nodo);
#endif
+/* Tipo de dato a meter en el archivo para un ord. externo */
+typedef struct _ord_data_ {
+ int numero;
+ char emision[9];
+ char estado[3];
+ char fp[3];
+ float importe;
+} t_OrdExt_Data;
+
+int comparar_externo(void *it1, void *it2);
+
/* Funciones para carga desde el XML */
static t_Item *leer_items(xmlNode *, int *cant, int size);
static char *leer_nota(xmlNode *, int max);
count++;
}
}
- if (count == 10) break; /* No me entran mas items! */
+ if (count == size) break; /* No me entran mas items! */
node = node->next;
}
}
/* En el registro no guardo los punteros de nota ni items. Si guardo la cantidad de items
* y los items al final del registro.
*/
- if ((param->tipo_arch_fact) == T3) {
+ if (param->tipo_arch_fact == T3) {
/* Limito a 10 items en el caso de registro constante! */
cant_items = 10;
} else {
cant_items = 0;
}
tmp->fp = emufs_crear("facturas", param->tipo_arch_fact, param->tam_bloque_fact, sizeof(t_Factura)-sizeof(char *)-sizeof(t_Item*)+cant_items*sizeof(t_Item));
- emufs_agregar_indice(tmp->fp, "emision", IND_EXAHUSTIVO, IND_B, IDX_STRING, STRUCT_OFFSET(factura, emision), 512, 0);
- emufs_agregar_indice(tmp->fp, "numero", IND_PRIMARIO, IND_B, IDX_INT, 0, 512, 0);
+ emufs_agregar_indice(tmp->fp, "ctacte", IND_SELECCION, param->ind_fac[4].tipo_arbol, IDX_STRING, STRUCT_OFFSET(factura, emision), param->ind_fac[4].tam_bloque, 5);
+ emufs_agregar_indice(tmp->fp, "cheque", IND_SELECCION, param->ind_fac[3].tipo_arbol, IDX_STRING, STRUCT_OFFSET(factura, emision), param->ind_fac[3].tam_bloque, 4);
+ emufs_agregar_indice(tmp->fp, "vto", IND_SELECCION, param->ind_fac[2].tipo_arbol, IDX_STRING, STRUCT_OFFSET(factura, emision), param->ind_fac[2].tam_bloque, 1);
+ emufs_agregar_indice(tmp->fp, "emision", IND_EXAHUSTIVO, param->ind_fac[1].tipo_arbol, IDX_STRING, STRUCT_OFFSET(factura, emision), param->ind_fac[1].tam_bloque, 0);
+ emufs_agregar_indice(tmp->fp, "numero", IND_PRIMARIO, param->ind_fac[0].tipo_arbol, IDX_INT, 0, param->ind_fac[0].tam_bloque, 0);
+
+ /* Creo el indice externo por Nro Articulo */
+ tmp->fp->externo = emufs_indice_crear(tmp->fp, "articulo", IND_SELECCION, IND_B, IDX_INT, 0, 512, 0);
+
tmp->fp_texto = emufs_crear("notas", param->tipo_arch_nota, param->tam_bloque_nota, 100);
for (node=inicio ; node ; node = node->next) {
if (node->type == XML_ELEMENT_NODE) {
void *save;
memset(&fact, 0, sizeof(t_Factura));
prop = xml_get_prop(node, "NroFac");
- PERR(prop);
fact.numero = atoi(prop); xmlFree(prop);
prop = xml_get_prop(node, "PorcDoI");
fact.procdoi = atof(prop); xmlFree(prop);
fact.reg_nota = id;
save = procesar_guardar_factura(&fact, lst_facturas, &size);
if (save != NULL) {
+ int i;
error = 0;
- tmp->fp->grabar_registro(tmp->fp, save, size, &error);
+ id = tmp->fp->grabar_registro(tmp->fp, save, size, &error);
+
+ /* Agrego los Items al indice externo */
+ for(i=0; i<fact.cant_items; i++) {
+ if (fact.items[i].numero != 0) {
+ CLAVE _k; /* HACK Para hacer mas rapido */
+ INDICE_DATO _dato;
+ _k.i_clave = fact.items[i].numero;
+ _dato.id = id;
+ tmp->fp->externo->agregar_entrada(tmp->fp->externo, _k, _dato);
+ }
+ }
+
if (fact.items) {
free(fact.items);
fact.items = NULL;
xmlFreeDoc(document);
xmlCleanupParser();
} else {
-#ifdef NO_SE_USA_MAS
- /* TODO RECUPERAR INDICES DESDE EL ARCHIVO */
PERR("Voy a recuperar desde un archivo");
tmp->fp = emufs_abrir("facturas");
if (tmp->fp == NULL) {
lst_facturas = NULL;
return NULL;
}
-
- /* Ahora trato de recuperar la info */
- indices = emufs_idx_get(tmp->fp, &indices_cant);
- for(i=0; i<indices_cant; i++) {
- t_Factura art;
- void *save;
- /* Leo el registro */
- save = tmp->fp->leer_registro(tmp->fp, indices[i], &size, &error);
- if (procesar_leer_factura(&art, save, size, tmp) == 1) {
- agregar_nodo_factura(tmp, crear_nodo_factura(indices[i], art.reg_nota, art.numero));
- free(save);
- }
- }
- free(indices);
-#endif
}
PERR("Facturas todo Ok");
k = emufs_indice_generar_clave_desde_valor(lst->fp->indices, (char*)&numero);
error = 0;
leo = lst->fp->leer_registro(lst->fp, k, &size, &error);
+ PERR("Registro Leido");
if (leo != NULL) {
fact = (t_Factura *)malloc(sizeof(t_Factura));
if (fact == NULL) {
free(leo);
return NULL;
}
+ PERR("Procesando");
procesar_leer_factura(fact, leo, size, lst);
/* y esto ??!
(*id) = reg->num_reg;
(*id_texto) = reg->texto_reg;
*/
free(leo);
+ PERR("Leo nota");
k.i_clave = fact->reg_nota;
error = 0;
fact->nota = lst->fp_texto->leer_registro(lst->fp_texto, k, &size, &error);
+ PERR("DONE");
}
return fact;
EMUFS_REG_SIZE size;
EMUFS_REG_ID id_texto;
int y_actual, cant, error;
+ float total;
char *entrada;
win = newwin(LINES-4, COLS-2, 2, 1);
form = form_crear(win);
form_agregar_widget(form, INPUT, "Nro de Articulo (* == fin)", 8, "");
- form_agregar_widget(form, INPUT, "CV", 8, "");
- form_agregar_widget(form, INPUT, "PVU", 8, "");
+ form_agregar_widget(form, INPUT, "Cant. Vendida", 8, "");
+ /*form_agregar_widget(form, INPUT, "PVU", 8, "");*/
y_actual = 0;
scrollok(items, 1);
mvwaddstr(win, 15, 2, "Numero");
- mvwaddstr(win, 15, 11, "CV");
- mvwaddstr(win, 15, 21, "PVU");
+ mvwaddstr(win, 15, 11, "Cant. Vendida");
+ mvwaddstr(win, 15, 31, "PVU");
+ mvwaddstr(win, 15, 41, "Subtotal");
cant = 0;
+ total = 0.0f;
do {
form_set_valor(form, "Nro de Articulo (* == fin)", "");
- form_set_valor(form, "CV", "");
- form_set_valor(form, "PVU", "");
+ form_set_valor(form, "Cant. Vendida", "");
+ /*form_set_valor(form, "PVU", "");*/
form_ejecutar(form, 2, 11);
entrada = form_obtener_valor_char(form, "Nro de Articulo (* == fin)");
if ((entrada[0] != '\0') && (entrada[0] != '*')){
- y_actual++;
- if (y_actual > LINES-22) {
- y_actual = LINES-22;
- wscrl(items, 1);
- }
- mvwaddstr(items, y_actual, 1, entrada);
- mvwaddstr(items, y_actual, 10, form_obtener_valor_char(form, "CV"));
- mvwaddstr(items, y_actual, 20, form_obtener_valor_char(form, "PVU"));
- wrefresh(items);
- /* Agrego el Item */
- cant++;
- its = (t_Item *)realloc(its, cant*sizeof(t_Item));
- if (its != NULL) {
- its[cant-1].numero = atoi(entrada);
- strcpy(its[cant-1].cv, form_obtener_valor_char(form, "CV"));
- strcpy(its[cant-1].pvu, form_obtener_valor_char(form, "PVU"));
+ /* Veamos si existe el articulo */
+ t_Articulo *art;
+ EMUFS_REG_ID dummy;
+
+ art = art_obtener(NULL, atoi(entrada), &dummy);
+
+ if (art != NULL) {
+ char subtotal[20];
+ char *cv;
+ y_actual++;
+ if (y_actual > LINES-22) {
+ y_actual = LINES-22;
+ wscrl(items, 1);
+ }
+ cv = form_obtener_valor_char(form, "Cant. Vendida");
+ mvwaddstr(items, y_actual, 1, entrada);
+ mvwaddstr(items, y_actual, 10, cv);
+ mvwaddstr(items, y_actual, 30, art->pvu);
+
+ sprintf(subtotal, "%.2f", atof(cv)*atof(art->pvu));
+ total += atof(subtotal);
+
+ mvwaddstr(items, y_actual, 40, subtotal);
+
+ wrefresh(items);
+ /* Agrego el Item */
+ cant++;
+ its = (t_Item *)realloc(its, cant*sizeof(t_Item));
+ if (its != NULL) {
+ art_actualizar_stock(atoi(entrada), atoi(cv));
+ its[cant-1].numero = atoi(entrada);
+ strcpy(its[cant-1].cv, cv);
+ strcpy(its[cant-1].pvu, art->pvu);
+ }
+ free(art);
}
}
} while (entrada[0] != '*');
entrada = procesar_guardar_factura(&fact,lst_facturas, &size);
if (entrada) {
error = 0;
+ PERR("GUARDANDO NUEVA FACTURA");
lst_facturas->fp->grabar_registro(lst_facturas->fp, entrada, size, &error);
+ PERR("DONE");
free(entrada);
}
switch (lst->fp->tipo) {
case T1:
case T2:
+ case T4:
/* Calculo el tamaño que voy a necesitar */
i[0] = sizeof(int);
i[1] = sizeof(float);
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:
+ case T5:
(*size) = sizeof(t_Factura)-sizeof(char *)-sizeof(t_Item *) + f->cant_items*sizeof(t_Item);
tmp = (char *)malloc(*size);
if (tmp == NULL) return NULL;
switch (lst->fp->tipo) {
case T1:
case T2:
+ case T4:
ini = (char *)src;
/* Copio los campos numericos, muy facil:-) */
memcpy(&dst->numero, ini, sizeof(int));
return 0;
break;
case T3:
+ case T5:
/* Se que tengo 10 items */
/* TODO : Ver porque leer_registro_tipo3 tira mal el size */
size = lst->fp->tam_reg;
int fact_exportar_xml(const char *filename)
{
int j;
- t_Reg_Factura *nodo;
t_Factura *fact;
EMUFS_REG_ID id, id1;
FILE *fp;
+ CLAVE k;
+ INDICE *idx;
- if (lst_facturas->primero == NULL) return 0;
+ idx = lst_facturas->fp->indices;
- nodo = lst_facturas->primero;
+ k = idx->obtener_menor_clave(idx);
if (!(fp = fopen(filename, "wt"))) return 0;
fprintf(fp, "<?xml version=\"1.0\" encoding=\"ISO-8859-1\" ?>\n");
fprintf(fp, "<FACTURAS>\n");
- while (nodo) {
- fact = fact_buscar(lst_facturas, nodo->numero, &id, &id1);
- fprintf(fp, "\t<FACTURA NroFac=\"%08d\" ", nodo->numero);
- fprintf(fp, "FechaEmisión=\"%s\" ", fact->emision);
- fprintf(fp, "FechaVto=\"%s\" ", fact->vencimiento);
- fprintf(fp, "NroRemito=\"%08d\" ", fact->numero_remito);
- fprintf(fp, "FP=\"%s\" ", fact->fp);
- fprintf(fp, "Estado=\"%s\" ", fact->estado);
- fprintf(fp, "NroCheque=\"%s\" ", fact->cheque);
- fprintf(fp, "PorcDoI=\"%.2f\" ", fact->procdoi);
- fprintf(fp, "NroCtaCte=\"%s\" ", fact->ctacte);
- fprintf(fp, ">\n");
- fprintf(fp, "\t\t<NOTA>%s</NOTA>\n", fact->nota);
- for(j=0; j<fact->cant_items; j++) {
- if (fact->items[j].numero != 0)
- fprintf(fp, "\t\t<ITEMVENTA NroArtículo=\"%08d\" CV=\"%s\" PVU=\"%s\" />\n", fact->items[j].numero, fact->items[j].cv, fact->items[j].pvu);
+ while (k.i_clave != -1) {
+ fact = fact_buscar(lst_facturas, k.i_clave, &id, &id1);
+ if (fact != NULL) {
+ fprintf(fp, "\t<FACTURA NroFac=\"%08d\" ", fact->numero);
+ fprintf(fp, "FechaEmisión=\"%s\" ", fact->emision);
+ fprintf(fp, "FechaVto=\"%s\" ", fact->vencimiento);
+ fprintf(fp, "NroRemito=\"%08d\" ", fact->numero_remito);
+ fprintf(fp, "FP=\"%s\" ", fact->fp);
+ fprintf(fp, "Estado=\"%s\" ", fact->estado);
+ fprintf(fp, "NroCheque=\"%s\" ", fact->cheque);
+ fprintf(fp, "PorcDoI=\"%.2f\" ", fact->procdoi);
+ fprintf(fp, "NroCtaCte=\"%s\" ", fact->ctacte);
+ fprintf(fp, ">\n");
+ fprintf(fp, "\t\t<NOTA>%s</NOTA>\n", fact->nota);
+ for(j=0; j<fact->cant_items; j++) {
+ if (fact->items[j].numero != 0)
+ fprintf(fp, "\t\t<ITEMVENTA NroArtículo=\"%08d\" CV=\"%s\" PVU=\"%s\" />\n", fact->items[j].numero, fact->items[j].cv, fact->items[j].pvu);
+ }
+ fprintf(fp, "\t</FACTURA>\n");
+ free(fact);
}
- fprintf(fp, "\t</FACTURA>\n");
- nodo = nodo->sig;
+ k = idx->obtener_sig_clave(idx, k);
}
fprintf(fp, "\t</FACTURAS>\n");
{
EMUFS_REG_ID dummy;
int desde_codigo, hasta_codigo;
- int i;
t_Factura *factura;
t_Lista *lista;
t_Form *form;
WINDOW *win, *win1;
+ INDICE *idx;
+ CLAVE k, menor, mayor;
+ int editar;
+
+ idx = lst_facturas->fp->indices;
win = newwin(LINES-4, COLS-2, 2, 1);
win1 = derwin(win, LINES-6, COLS-4, 1, 1);
werase(win1);
wrefresh(win1);
+ menor = idx->obtener_menor_clave(idx);
+ mayor = idx->obtener_mayor_clave(idx);
+
+ if (desde_codigo < menor.i_clave)
+ desde_codigo = menor.i_clave;
+ if (hasta_codigo > mayor.i_clave)
+ hasta_codigo = mayor.i_clave;
+
/* Creo la lista donde mostrar la consulta*/
/* Muestro solo info relevante */
lista = lista_crear(4, win1, COLS-4, LINES-6);
lista_agregar_columna(lista, "F. Pago", DATO_STR, 40, 9); /* fp */
/* Leo los datos desde el archivo */
- for(i=desde_codigo; i<=hasta_codigo; i++) {
- factura = fact_buscar(lst_facturas, i, &dummy, &dummy);
+ k.i_clave = desde_codigo;
+ while ((k.i_clave != -1) && (k.i_clave <= hasta_codigo)) {
+ factura = fact_buscar(lst_facturas, k.i_clave, &dummy, &dummy);
if (factura != NULL) {
lista_agregar_fila(lista,
factura->numero,
get_forma_pago(factura->fp)
);
}
+ k = idx->obtener_sig_clave(idx, k);
}
curs_set(0);
- lista_ejecutar(lista);
+ editar = lista_ejecutar(lista);
curs_set(1);
+ if (editar != -1) {
+ char cc[20];
+ sprintf(cc, "%d", editar);
+ fact_modificar(cc);
+ }
+
wrefresh(win1);
wrefresh(win);
werase(win1);
WINDOW *win, *win1;
INDICE *idx;
CLAVE k_menor, k_mayor;
+ int todo=0;
+ int editar;
win = newwin(LINES-4, COLS-2, 2, 1);
win1 = derwin(win, LINES-6, COLS-4, 1, 1);
/* Si el usuario no ingreso alguno de los datos, lo obtengo del indice */
idx = emufs_buscar_indice_por_nombre(lst_facturas->fp, "emision");
if (idx==NULL) PERR("INDICE EMISION NO SE ENCUENTRA!!");
+
+ /* XXX Politica de seleccion de uso de ord externo
+ *
+ * Se usa ordenamiento externo en alguno de estos 2 casos :
+ * * Se requiere un listado de todo el rango de fechas
+ * * Se requiere un listado de todos los Estados
+ *
+ * Para cualquier otro caso, se ordena directamente
+ * en la lista
+ */
if (strlen(desde_fecha) == 0) {
k_menor = idx->obtener_menor_clave(idx);
emufs_indice_obtener_valor_desde_clave(idx, k_menor, desde_fecha);
PERR("OBTUVE MENOR CLAVE DESDE EL INDICE");
PERR(desde_fecha);
+ todo++;
}
if (strlen(hasta_fecha) == 0) {
k_mayor = idx->obtener_mayor_clave(idx);
emufs_indice_obtener_valor_desde_clave(idx, k_mayor, hasta_fecha);
PERR("OBTUVE MAYOR CLAVE DESDE EL INDICE");
PERR(hasta_fecha);
+ todo++;
+ }
+
+ if (strcmp(estado, "Todos") == 0) todo = 2;
+
+ if (todo == 2) {
+ /* Debo utilizar un ord, externo!! */
+ FILE *fp;
+ /* Creo el archivo a ordenar */
+ fp = fopen("tmp_ord.xxx", "w");
+ while (k_menor.i_clave != -1) {
+ t_Factura fact;
+ int error, cant, i;
+ char *leo;
+ t_OrdExt_Data ord;
+ EMUFS_REG_SIZE size;
+ INDICE_DATO *datos;
+ CLAVE k1;
+ datos = idx->buscar_entradas(idx, k_menor, &cant);
+ for(i=0; i<cant; i++) {
+ error = 1;
+ k1.i_clave = datos[i].id;
+ leo = lst_facturas->fp->leer_registro(lst_facturas->fp, k1, &size, &error);
+ if (leo != NULL) {
+ procesar_leer_factura(&fact, leo, size, lst_facturas);
+ free(leo);
+ ord.numero = fact.numero;
+ strcpy(ord.emision, fact.emision);
+ strcpy(ord.estado, fact.estado);
+ strcpy(ord.fp, fact.fp);
+ ord.importe = get_importe_factura(fact.items, fact.cant_items, fact.procdoi);
+ fwrite(&ord, sizeof(t_OrdExt_Data), 1, fp);
+ }
+ }
+ if (datos) free(datos);
+ if (fact.items) free(fact.items);
+ k_menor = idx->obtener_sig_clave(idx, k_menor);
+ }
+ fclose(fp);
+ /* Mando a ordenar */
+ extsort("tmp_ord.xxx", 4096, sizeof(t_OrdExt_Data), comparar_externo);
}
-
/* Creo la lista donde mostrar la consulta*/
/* Muestro solo info relevante */
lista = lista_crear(4, win1, COLS-4, LINES-6);
lista_agregar_columna(lista, "Importe", DATO_FLOAT, 50, 8); /* importe */
/* Leo los datos desde el archivo */
- while (k_menor.i_clave != -1) {
- t_Factura fact;
- int error, cant, i;
- char *leo;
- EMUFS_REG_SIZE size;
- INDICE_DATO *datos;
- CLAVE k1;
- datos = idx->buscar_entradas(idx, k_menor, &cant);
- for(i=0; i<cant; i++) {
- error = 1;
- k1.i_clave = datos[i].id;
- leo = lst_facturas->fp->leer_registro(lst_facturas->fp, k1, &size, &error);
- if (leo != NULL) {
- procesar_leer_factura(&fact, leo, size, lst_facturas);
- free(leo);
- /*k.i_clave = fact->reg_nota;
- error = 0;
- fact->nota = lst->fp_texto->leer_registro(lst->fp_texto, k, &size, &error);
- */
- }
- if (strcmp(estado, "Todos") != 0) {
+ if (todo != 2) {
+ while (k_menor.i_clave != -1) {
+ t_Factura fact;
+ int error, cant, i;
+ char *leo;
+ EMUFS_REG_SIZE size;
+ INDICE_DATO *datos;
+ CLAVE k1;
+ datos = idx->buscar_entradas(idx, k_menor, &cant);
+ for(i=0; i<cant; i++) {
+ error = 1;
+ k1.i_clave = datos[i].id;
+ leo = lst_facturas->fp->leer_registro(lst_facturas->fp, k1, &size, &error);
+ if (leo != NULL) {
+ procesar_leer_factura(&fact, leo, size, lst_facturas);
+ free(leo);
+ }
if (strcmp(estado, fact.estado) == 0) {
- fprintf(stderr, "Agrego factura num=%d con %d items\n", fact.numero, fact.cant_items);
lista_agregar_fila_ordenada(lista,
fact.numero,
fact.emision,
);
}
}
+ if (datos) free(datos);
+ if (fact.items) free(fact.items);
}
- if (datos) free(datos);
- if (fact.items) free(fact.items);
k_menor = idx->obtener_sig_clave(idx, k_menor);
- }
+ } else {
+ /* Cargo la lista a partir del archivo ordenado externamente */
+ FILE *fp;
+ int j;
+ char st[3];
+ t_OrdExt_Data ord;
+
+ j =( strcmp(estado, "Todos") == 0);
+ fp = fopen("tmp_ord.xxx", "r");
+
+ /* si j == 1 tengo que paginar por estado */
+ fread(&ord, sizeof(t_OrdExt_Data), 1, fp);
+ strcpy(st, ord.estado);
+ while (!feof(fp)) {
+ lista_agregar_fila(lista,
+ ord.numero,
+ ord.emision,
+ get_estado(ord.estado),
+ get_forma_pago(ord.fp),
+ ord.importe
+ );
+ strcpy(st, ord.estado);
+
+ fread(&ord, sizeof(t_OrdExt_Data), 1, fp);
+ /* Si el estado cambio y j == 1 */
+ if ((strcmp(st, ord.estado) != 0) && (j == 1)) {
+ /* Hago la pausa para mostrar lo que hay */
+ editar = lista_ejecutar(lista);
+ if (editar != -1) {
+ char cc[20];
+ sprintf(cc, "%d", editar);
+ fact_modificar(cc);
+ }
+ /* bue, ya miraron, ahora limpio y sigo con el resto */
+ lista_clear(lista);
+ }
+ }
+ /* Elimino el archivo temporal */
+ unlink("tmp_ord.xxx");
+ }
curs_set(0);
- lista_ejecutar(lista);
+ editar = lista_ejecutar(lista);
curs_set(1);
+ if (editar != -1) {
+ char cc[20];
+ sprintf(cc, "%d", editar);
+ fact_modificar(cc);
+ }
wrefresh(win1);
wrefresh(win);
werase(win1);
CLAVE k;
EMUFS *fs;
EMUFS_REG_SIZE size;
+ int editar;
fs = lst_facturas->fp;
if (tmp != NULL) {
procesar_leer_factura(&factura, tmp, size, lst_facturas);
lista_agregar_fila(lista,
- factura.numero,
- factura.emision,
- get_estado(factura.estado),
- get_forma_pago(factura.fp)
- );
+ factura.numero,
+ factura.emision,
+ get_estado(factura.estado),
+ get_forma_pago(factura.fp)
+ );
free(tmp);
} else {
PERR("NO SE PUDO RECUPERAR EL REGISTRO DE DATOS");
}
curs_set(0);
- lista_ejecutar(lista);
+ editar = lista_ejecutar(lista);
curs_set(1);
+ if (editar != -1) {
+ char cc[20];
+ sprintf(cc, "%d", editar);
+ fact_modificar(cc);
+ }
wrefresh(win1);
wrefresh(win);
}
}
+void imprimir1(WINDOW *win, int y, int x, char *s, char *b)
+{
+ wmove(win, y, x);
+ waddstr(win, s);
+ waddstr(win, b);
+}
+
+void mostrar_fact(WINDOW *win, CLAVE k, char *s, INDICE *idx)
+{
+ t_Factura *fact;
+ EMUFS_REG_ID dummy;
+ int y = 3;
+ char numero[10];
+ /* XXX SOLO PARA CODIGO XXX */
+
+ wattron(win, COLOR_PAIR(COLOR_RED));
+ mvwaddstr(win, 1, 5, "Recorriendo Facturas por indice ");
+ waddstr(win, s);
+ wattroff(win, COLOR_PAIR(COLOR_RED));
+
+ wattron(win, A_BOLD);
+ mvwaddstr(win, 18, 5, "Teclas:");
+ wattroff(win, A_BOLD);
+ mvwaddstr(win, 19, 5, " L = Siguiente");
+ mvwaddstr(win, 20, 5, " K = Anterior");
+
+ if (strcmp(s, "numero") == 0) {
+ fact = fact_buscar(lst_facturas, k.i_clave, &dummy, &dummy);
+ } else {
+ INDICE_DATO *datos;
+ EMUFS_REG_SIZE size;
+ int cant, error;
+ char *tmp;
+
+ fact = (t_Factura *)malloc(sizeof(t_Factura));
+ /* Ya se cual tengo que retornar. Ahora veo si lo cargo desde el archivo */
+ PERR("Busco todos los datos que tengan esta clave");
+ datos = idx->buscar_entradas(idx, k, &cant);
+ if (datos == NULL) {
+ free(fact);
+ fact = NULL;
+ } else {
+ k.i_clave = datos[0].id;
+ PERR("Leo el primer dato");
+ error = 1;
+ tmp = lst_facturas->fp->leer_registro(lst_facturas->fp, k, &size, &error);
+ if (tmp == NULL) {
+ free(fact);
+ fact = NULL;
+ } else {
+ if (procesar_leer_factura(fact, tmp, size, lst_facturas) != 0) {
+ free(fact);
+ free(tmp);
+ fact = NULL;
+ }
+ }
+ free(datos);
+ }
+ }
+
+ if (fact != NULL) {
+ sprintf(numero, "%08d", fact->numero);
+
+ imprimir1(win, y++, 5, "Numero : ", numero);
+ imprimir1(win, y++, 5, "Fecha Emision : ", fact->emision);
+ imprimir1(win, y++, 5, "Fecha Vto : ", fact->vencimiento);
+ imprimir1(win, y++, 5, "Estado : ", fact->estado);
+ imprimir1(win, y++, 5, "Forma de Pago : ", fact->fp);
+ imprimir1(win, y++, 5, "Cuenta Cte : ", fact->ctacte);
+ imprimir1(win, y++, 5, "Cheque Nro : ", fact->cheque);
+ sprintf(numero, "%08d", fact->numero_remito);
+ imprimir1(win, y++, 5, "Remito : ", numero);
+ sprintf(numero, "%.2f", fact->procdoi);
+ imprimir1(win, y++, 5, "% Descuento : ", numero);
+ sprintf(numero, "%d", fact->cant_items);
+ imprimir1(win, y++, 5, "Cant de Items : ", numero);
+
+ if (fact->items) free(fact->items);
+ free(fact);
+ } else {
+ PERR("NO EXISTE LA FACTURA");
+ }
+}
+
+void fact_recorrer_con_indice(char *s)
+{
+ WINDOW *win, *win1;
+ INDICE *idx;
+ CLAVE stack[1000]; /* shhhh */
+ CLAVE k;
+ int stack_pos=0, c;
+
+ PERR("Busco indice");
+ idx = emufs_buscar_indice_por_nombre(lst_facturas->fp, s);
+
+ win = newwin(LINES-4, COLS-2, 2, 1);
+ win1 = derwin(win, LINES-6, COLS-4, 1, 1);
+ werase(win);
+ box(win, 0, 0);
+ wrefresh(win);
+
+ PERR("Obtengo clave menor");
+ k = idx->obtener_menor_clave(idx);
+
+ PERR("Muestro el primer elemento");
+ mostrar_fact(win1, k, s, idx);
+ wrefresh(win1);
+ PERR("Sigue el usuario");
+ curs_set(0);
+ stack[0] = k;
+ while ((c=wgetch(win)) != 13) {
+ switch (c) {
+ case 'L':
+ case 'l':
+ stack[stack_pos++] = k; /* Guardo la clave para poder volver */
+ k = idx->obtener_sig_clave(idx, k);
+ /* TODO Verificar que no me pase del fin */
+ break;
+ case 'K':
+ case 'k':
+ /* recupero la anterior */
+ stack_pos--;
+ if (stack_pos < 0) stack_pos = 0;
+ k = stack[stack_pos];
+ break;
+ default:
+ continue;
+ }
+ werase(win1);
+ mostrar_fact(win1, k, s, idx);
+ wrefresh(win1);
+ }
+ curs_set(1);
+
+ werase(win1);
+ werase(win);
+ wrefresh(win);
+ delwin(win);
+}
+
+void fact_recorrer()
+{
+ char *ind[5] = {"numero", "emision", "vto", "cheque", "ctacte"};
+ MENU(mi_menu) {
+ MENU_OPCION("Numero", "Recorrer por Indice Numero Factura"),
+ MENU_OPCION("Emision", "Recorrer por Indice Fecha Emision"),
+ MENU_OPCION("Vencimiento", "Recorrer por Indice Fecha Vencimiento"),
+ MENU_OPCION("Cheque", "Recorrer por Indice Cheque"),
+ MENU_OPCION("Cuenta Cte", "Recorrer por Indice Cuenta Cte"),
+ MENU_OPCION("Volver", "Volver al menu anterior.")
+ };
+ int opt;
+ while ((opt = menu_ejecutar(mi_menu, 6, "Recorrer Facturas")) != 5) {
+ fact_recorrer_con_indice(ind[opt]);
+ }
+}
+
+int fact_hay_con_item(int numero)
+{
+ INDICE *idx;
+ CLAVE k;
+ INDICE_DATO dato;
+ /* Busco si existe alguna factura que contenga al articulo "numero" */
+ idx = lst_facturas->fp->externo;
+
+ k.i_clave = numero;
+ dato = idx->existe_entrada(idx, k);
+
+ if (dato.id == -1)
+ return 0; /* No existe factura que contenga este articulo!! */
+
+ return 1; /* Hay alguna factura que contiene el articulo */
+}
+
+int comparar_externo(void *it1, void *it2)
+{
+ t_OrdExt_Data *d1, *d2;
+ d1 = (t_OrdExt_Data *)it1;
+ d2 = (t_OrdExt_Data *)it2;
+
+ /* Primero veo de ordenar por Estado */
+ if (strcmp(d1->estado, d2->estado) == 0) {
+ /* Tienen el mismo estado, los ordeno por numero de fatura */
+ return d1->numero - d2->numero;
+ }
+
+ /* como no son iguales, comparo los estados */
+ return strcmp(d1->estado, d2->estado);
+}
+
projects / z.facultad / 75.06 / emufs.git / blobdiff