Manipulando arquivos txt pt III

Continuando o programa de ler arquivos em txt:
O seguinte programa mostra como, a partir de um arquivo posicional em .txt, formatá-lo, gravar novamento o arquivo organizado a partir das agências, exibir um relatório mostrando o saldo total separado por agências e também contabilizar a quantidade de clientes (linhas de arquivo). A grande diferença desta versão, é que você não precisará informar o local em que estão os arquivos posicionais. Foi adicionada uma função que procura eles para você utilizando findfirst e findnext.
Ex de arq pos:

DAVI      RUA PAULINOFARIA 95 101001010100000599992
CELSO     RUA SANTA CELIA 4395101001010300000599992
VIVIAN    RUA ANTONIO PRADO 48101001010200000599992
RAFAEL    RUA VISCONDE 295    123001252399999999999
CAROLINA  RUA XYZ 45          123001251500000000221
DANI      RUA ASDF 87         121001232100056987771
MARCOS    RUA XXMN 09         121000001100022514111

A partir deste arquivo, temos o seguinte layout:

Nome – a10
Endereco – a20
Conta – n10
Saldo – n10
Dec_Saldo – n1

A partir desses dados, temos o seguinte programa:

/*-----------------------------------------------------------------------------*
* modulo .................: arqpos_v3.cpp                                      *
*                                                                              *
* data de criacao ........: 17/07/2009                                         *
* empresa desenvolvedora .: ----                                               *
* analista empresa .......: Rafael de Oliveira Marques                         *
*                                                                              *
* alteracoes:                                                                  *
*                                                                              *
* Data        Emp Nome        Descricao                                        *
* =========== === =========== =================================================*
*                                                                              *
*------------------------------------------------------------------------------*
* descricao do modulo:                                                         *
* Analisa um arquivo posicional de acordo com um layout estabelecido, gerando  *
* posteriormente um relatório.                                                 *
*                                                                              *
* observacoes:                                                                 *
*                                                                              *
*-----------------------------------------------------------------------------*/
/*=============================================================================*
* includes                                                                     *
*=============================================================================*/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <dirent.h>

/*=============================================================================*
* DEFINE DE ESTRUTURA                                                          *
*=============================================================================*/

#define NOME_LEN        11
#define ENDERECO_LEN    21
#define AGENCIA_LEN      4
#define CONTA_LEN        8
#define SALDO_LEN       11

/*=============================================================================*
* DEFINES GERAIS                                                               *
*=============================================================================*/

#define ARQ_PROCURA     "c:\\arqpos\\"
#define ARQ_LOG         "c:\\arq_log.txt"
#define DATA            __DATE__
#define HORA            __TIME__
#define TAM_CAM_ARQ     30
#define TAM_CAM_MOD     3


/*=============================================================================*
* DEFINES DE MENSAGENS DE ERROS                                                *
*=============================================================================*/

#define ERRO_ABRE       "Erro ao abrir o arquivo posicional"      
#define ERRO_GRAVA_LOG  "Falha ao gravar no log"    
#define ERRO_LOG_OUT    "Impossivel gravar no log"     
#define ERRO_PROCURA    "Nenhum arquivo encontrado"      

/*=============================================================================*
* TYPEDEF                                                                      *
*=============================================================================*/

typedef struct Entrada
{
          char nome[NOME_LEN];
          char endereco[ENDERECO_LEN];
          char agencia[AGENCIA_LEN];
          char conta[CONTA_LEN];
          char saldo[SALDO_LEN];
          char dec;
          Entrada *prox;
};

/*=============================================================================*
* Declaracao - protótipo de função                                             *
*=============================================================================*/

/*-----------------------------------------------------------------------------*
* Funções de manipulação de lista                                              *
*-----------------------------------------------------------------------------*/

Entrada *lu_insereinicio(Entrada *plst, char nome1[], char endereco1[], char agencia1[], char conta1[], char saldo1[], char dec1);
Entrada *lu_inseremeio (Entrada *pl, char nome1[], char endereco1[], char agencia1[], char conta1[], char saldo1[], char dec1);
Entrada *lu_limpatudo (Entrada *pl);
void lu_exibelista(Entrada *plst);

/*-----------------------------------------------------------------------------*
* Funções de manipulação de arquivo                                            *
*-----------------------------------------------------------------------------*/

FILE* abre_arq();
FILE* org_arq(FILE *arq, char str_caminho[]);
void grava_arq_org(Entrada *ent, FILE* arq, char str_caminho[]);
void grava_log_erro(char erro[]);
void procura_arq(FILE *arq);

/*-----------------------------------------------------------------------------*
* Funções de manipulação de relatório                                          *
*-----------------------------------------------------------------------------*/

void gera_relatorio();

/*-----------------------------------------------------------------------------*
* funcao "main"                                                                *
*-----------------------------------------------------------------------------*/

main()
{
      FILE *arq = NULL;
      procura_arq(arq);
      
      system("pause");
}

/*=============================================================================*
* Funções                                                                      *
*=============================================================================*/



/*-----------------------------------------------------------------------------*
* Função que recebe como parâmetro uma lista que contém os                     *
* dados coletados do arquivo posicional, e gera um relatório                   *
* contendo o saldo total por agência e a quantidade total                      *
* de clientes contidos no arquivo                                              *
*-----------------------------------------------------------------------------*/

void gera_relatorio(Entrada *ls)
{    
     int n;
     printf("Qual idioma?\n 1 - portugues\n2 - ingles");
     scanf("%d", &n);
     switch (n){
            case 1: {
                    system("\n\n\n\n");
                    printf("_________________________________________\n\n");
                    printf("Relatorio gerado em %s, %s\n\n", __DATE__, __TIME__);
                    Entrada *aux = ls;
                    int soma = 0, cont = 0, total = 0;
     
                    while (aux != NULL)
                    {
                          if (cont == 0)
                             printf("* * * * * *\n\nAgencia: %s\n", aux -> agencia);
                          soma += atoi(aux -> saldo);
                          cont++;
                          if (aux -> prox == NULL || atoi(aux -> agencia) != atoi(aux -> prox -> agencia))
                          {
                             printf("Saldo Total: %d\nQntde Clientes: %d\n\n", soma, cont);
                             printf("* * * * * *\n\n");
                             total += cont;
                             cont = 0;
                             soma = 0;
                          }
                    aux = aux -> prox;
                    }
     
                    printf("\n\nTotal clientes: %d\n\n", total);
                    lu_limpatudo(ls);
                    break;
                    }
                    
            case 2: {
                    system("\n\n\n\n");
                    printf("_________________________________________\n\n");
                    printf("Report generated on %s, %s\n\n", __DATE__, __TIME__);
                    Entrada *aux = ls;
                    int soma = 0, cont = 0, total = 0;
     
                    while (aux != NULL)
                    {
                          if (cont == 0)
                             printf("* * * * * *\n\nAgency: %s\n", aux -> agencia);
                          soma += atoi(aux -> saldo);
                          cont++;
                          if (aux -> prox == NULL || atoi(aux -> agencia) != atoi(aux -> prox -> agencia))
                          {
                             printf("Total balance: %d\nNumber of customers: %d\n\n", soma, cont);
                             printf("* * * * * *\n\n");
                             total += cont;
                             cont = 0;
                             soma = 0;
                          }
                    aux = aux -> prox;
                    }
     
                    printf("\n\nTotal number of customers : %d\n\n", total);
                    lu_limpatudo(ls);
                    break;
                    }
     }     
}

/*-----------------------------------------------------------------------------*
* Função que recebecomo parâmetro um cliente a ser                             *
* adicionado no início da lista                                                *
*-----------------------------------------------------------------------------*/

Entrada *lu_insereinicio(Entrada *plst, char nome1[], char endereco1[], char agencia1[], char conta1[], char saldo1[], char dec1)
{

     Entrada *aux;
     aux = (Entrada*)malloc(sizeof(Entrada));
     strncpy(aux -> nome, nome1, NOME_LEN);
     strncpy(aux -> endereco, endereco1, ENDERECO_LEN);
     strncpy(aux -> agencia, agencia1, AGENCIA_LEN);
     strncpy(aux -> conta, conta1, CONTA_LEN);
     strncpy(aux -> saldo, saldo1, SALDO_LEN);
     aux -> dec = dec1;
     aux -> prox = plst;
     return aux;
}

/*-----------------------------------------------------------------------------*
* Função que recebecomo parâmetro um cliente a ser                             *
* adicionado no meio da lista                                                  *
*-----------------------------------------------------------------------------*/

Entrada *lu_inseremeio (Entrada *pl, char nome1[], char endereco1[], char agencia1[], char conta1[], char saldo1[], char dec1)
{
    Entrada *aux, *ant = NULL, *novo;
    aux = pl;
    if (pl == NULL || atoi(pl -> agencia) >= atoi(agencia1))
       pl= lu_insereinicio (pl, nome1, endereco1, agencia1, conta1, saldo1, dec1);
    
    else
    {
        while (aux != NULL && atoi(aux -> agencia) < atoi(agencia1))
        {
            ant = aux;
            aux = aux -> prox;
        }
        novo = (Entrada*)malloc(sizeof(Entrada));
        strncpy(novo -> nome, nome1, NOME_LEN);
        strncpy(novo -> endereco, endereco1, ENDERECO_LEN);
        strncpy(novo -> agencia, agencia1, AGENCIA_LEN);
        strncpy(novo -> conta, conta1, CONTA_LEN);
        strncpy(novo -> saldo, saldo1, SALDO_LEN);
        novo -> dec = dec1;
        ant -> prox = novo;
        novo -> prox = aux;
    }
    return (pl);
}

/*-----------------------------------------------------------------------------*
* Função que libera a lista                                                    *
*-----------------------------------------------------------------------------*/

Entrada *lu_limpatudo (Entrada *pl)
{
    Entrada *aux;
    while (pl!= NULL)
    {
        aux= pl->prox;
        free (pl);
        pl= aux;
    }
    return (NULL);
}

/*-----------------------------------------------------------------------------*
* Função que exibe a lista                                                     *
*-----------------------------------------------------------------------------*/

void lu_exibelista(Entrada *plst)
{
     Entrada *aux = plst;
     if (aux == NULL)
        printf("Lista vazia\n");
     else
         
         while (aux != NULL)
         {
               printf("Nome: %s\nEndereco: %s\nAgencia: %s\nConta: %s\nSaldo %s\nDigito: %c\n\n", aux -> nome, aux -> endereco, aux -> agencia, aux -> conta, aux -> saldo, aux -> dec);
               aux = aux -> prox;
         }
}

/*-----------------------------------------------------------------------------*
* Função que abre um arquivo, retornando um ponteiro                           *
* para o arquivo aberto                                                        *
*-----------------------------------------------------------------------------*/

FILE* abre_arq()
{
      FILE *arq = NULL;
      char caminho[TAM_CAM_ARQ], modo[TAM_CAM_MOD];
      printf("Digite o nome do arquivo: ");
      gets(caminho);
      printf("Digite o modo de abertura: ");
      gets(modo);      
      arq = fopen(caminho, modo);
      if (arq)
         return arq;
      else
          {
                grava_log_erro(ERRO_ABRE);
                return NULL;
          }
}

/*-----------------------------------------------------------------------------*
* Função que organiza os clientes da lista de acordo com a agência             *
* que o mesmo se encontra. Esta função chamará uma outra função,               *
* chamada grava_arq_org(), que tem como objetivo gravar no arquivo             *
* posicional os dados organizados por agência                                  *
*-----------------------------------------------------------------------------*/

FILE* org_arq(FILE *arq, char str_caminho[])
{
      char nome[NOME_LEN], endereco[ENDERECO_LEN], agencia[AGENCIA_LEN], conta[CONTA_LEN], saldo[SALDO_LEN], dec, linha;
      Entrada *x = NULL;
      
      do
      {
        fgets(nome, NOME_LEN, arq);
        fgets(endereco, ENDERECO_LEN, arq);
        fgets(agencia, AGENCIA_LEN, arq);
        fgets(conta, CONTA_LEN, arq);
        fgets(saldo, SALDO_LEN, arq);
        dec = getc(arq);     

        linha = getc(arq);
        x = lu_inseremeio(x, nome, endereco, agencia, conta, saldo, dec);
        
      }while(!feof(arq));

      grava_arq_org(x, arq, str_caminho);
                         
                  
}

/*-----------------------------------------------------------------------------*
* Função inicializada pela função org_arq() e recebe como parâmentro           *
* a lista de clientes organizada e o arquivo a ser salvo. Ela tem              *
* como objetivo gravar a lista organizada no mesmo arquivo em que foi          *
* retirada a lista ou em um novo arquivo, de acordo com o layout               *
* previamente estabelecido.                                                    *
*-----------------------------------------------------------------------------*/

void grava_arq_org(Entrada *ent, FILE* arq, char str_caminho[])
{
     Entrada *aux = ent;
     fclose(arq);
     arq = NULL;
     arq = fopen(str_caminho, "w");

     //arq = NULL;
     //printf("\n\nAbrir arquivo organizado - abrir no modo w\n\n");
     //arq = abre_arq();
     while (aux != NULL)
     {
           if (aux -> prox != NULL)
           {
                   fprintf(arq, "%s", aux->nome);                     
                   fprintf(arq, "%s", aux->endereco);     
                   fprintf(arq, "%s", aux->agencia);
                   fprintf(arq, "%s", aux->conta);     
                   fprintf(arq, "%s", aux->saldo);
                   fprintf(arq, "%c\n", aux->dec);
                   aux = aux -> prox;
           } else {
                       fprintf(arq, "%s", aux->nome);                     
                       fprintf(arq, "%s", aux->endereco);     
                       fprintf(arq, "%s", aux->agencia);
                       fprintf(arq, "%s", aux->conta);     
                       fprintf(arq, "%s", aux->saldo);
                       fprintf(arq, "%c", aux->dec);
                       aux = aux -> prox;
                  }
                   
     }
     fclose(arq);
     gera_relatorio(ent);                     
}

/*-----------------------------------------------------------------------------*
* Função que grava no arquivo arq_log um erro causado durante                  *
* a execução do programa                                                       *
*-----------------------------------------------------------------------------*/

void grava_log_erro(char erro[])
{
     FILE *arq;
     arq = fopen(ARQ_LOG, "a+");
     int cont = 0;
     
     if (arq)
     {
        fprintf(arq, "**\n\n%s\n%s , %s\n\n***\n\n", erro, DATA, HORA);
        printf("\nLog de erro gravado com sucesso no dia %s as %s\nc:\\arq_log.txt\n\n", DATA, HORA);
     }
     else{
          if (cont <= 5)
             grava_log_erro(ERRO_GRAVA_LOG);
          else{
               printf(ERRO_LOG_OUT);
               }
          }
     fclose(arq);
}

/*-----------------------------------------------------------------------------*
* Função que procura por todos os arquivos txt no diretório de arquivos,       *
* disparando toda a transação para cada arquivo encontrado                     *
*-----------------------------------------------------------------------------*/

void procura_arq(FILE *arq)
{
     struct _finddata_t struct_arq;
     intptr_t dado;
     //char str_null[5];
     char str_caminho[TAM_CAM_ARQ];

     dado = _findfirst("c:\\arqpos\\*.txt", &struct_arq);
     if (dado == -1L)
        grava_log_erro(ERRO_PROCURA);
     else{
          do{
             strncpy(str_caminho, ARQ_PROCURA, TAM_CAM_ARQ);
             strcat(str_caminho, struct_arq.name);
             printf("__________\n__________\n\nAbrindo o arquivo %s\n\n%s , %s\n\n", str_caminho, DATA, HORA);
             arq = fopen(str_caminho, "r+");
             arq = org_arq(arq, str_caminho);
             
             }while(_findnext(dado, &struct_arq) == 0);
          }
}
Anúncios

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s