campo-sirio/ha/ha1200.cpp

#include <applicat.h>
#include <automask.h>
#include <progind.h>

#include <comuni.h>
#include <scadenze.h>
#include "../cg/cgsaldac.h"
#include "../ve/condv.h"

#include "halib.h"

#include "ha1200a.h"

///////////////////////////////////////////////////////////
// TAutomask
///////////////////////////////////////////////////////////
class TFile2Txt_mask : public TAutomask
{
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

public:
  TFile2Txt_mask();
};


bool TFile2Txt_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  /*switch (o.dlg())
	{
  default:
    break;
  }*/
  return true;
}

TFile2Txt_mask::TFile2Txt_mask() : TAutomask ("ha1200a")
{
  TConfig config(CONFIG_DITTA, "ha");
  const TString& path = config.get("OutputPath");
  set(F_PATH, path);
}

///////////////////////////////////////
// TSkeleton_application
///////////////////////////////////////
class TFile2Txt : public TSkeleton_application
{
  TFilename _output_dir;

protected:
  void elabora(const TMask& mask);

  void genera_agenti_txt();
  void genera_clienti_txt(const long da_codcli);
  void genera_sospesi_txt();
  void genera_righelistini_txt();
  void genera_contratti_txt();
  void genera_promozioni_txt();
  void genera_prodotti_txt();
  void genera_barcode_txt();
  void genera_decodart_txt();
  void genera_attrezzature_txt();
  void genera_tabpag_txt();
  void genera_carico_txt();

  void fill_anagrafica_cliente(const TISAM_recordset& archivio_clienti, 
                               TEsporta_clienti_recordset& clienti, const bool is_fatt = false);
  TFilename genera_path(const TString& prefisso);

public:
  virtual void main_loop();
  virtual bool create();
};


TFilename TFile2Txt::genera_path(const TString& prefisso)
{
  TFilename output_path;
  output_path = _output_dir;
  output_path.add(prefisso);
  output_path.ext(".txt");
  return output_path;
}


void TFile2Txt::genera_agenti_txt()
{
  //AS400 recordset da riempire (da lui nascerà il .txt)
  TEsporta_agenti_recordset agenti;

  //ISAM recordset con tutti i dati degli archivi Campo (servirà per riempire l'AS400 recset)
  TISAM_recordset archivio_agenti("USE AGENTI");
  const long archivio_agenti_items = archivio_agenti.items();
  //scansione ISAM
  TProgind progind(archivio_agenti_items, "Agenti...", false, true);
  for (bool ok = archivio_agenti.move_first(); ok; ok = archivio_agenti.move_next())
  {
    progind.addstatus(1);

    //riga dell'AS400 recset da riempire
    agenti.new_rec("");

    TString8 codage = archivio_agenti.get(AGE_CODAGE).as_string();
    codage = codage.right(3);
    agenti.set("CodiceTerminale", codage);
    agenti.set(AGE_CODAGE, codage);
    agenti.set(AGE_RAGSOC, archivio_agenti.get(AGE_RAGSOC));
  }

  //prepara il nome corretto del file .txt e lo genera
  TFilename output_path = genera_path("agenti");
  //..e alla fine della fiera salva il file di testo nell directory selezionata
  agenti.save_as(output_path, fmt_text);
}


void TFile2Txt::fill_anagrafica_cliente(const TISAM_recordset& archivio_clienti,
                                        TEsporta_clienti_recordset& clienti, const bool is_fatt)
{

    clienti.set_fatt("RagioneSociale", archivio_clienti.get(CLI_RAGSOC), is_fatt);

    TString80 indcf = archivio_clienti.get(CLI_INDCF).as_string();
    indcf << " " << archivio_clienti.get(CLI_CIVCF).as_string();

    clienti.set_fatt("Indirizzo", indcf, is_fatt);

    const TString80 localitacf = archivio_clienti.get(CLI_LOCCF).as_string();
    clienti.set_fatt("Localita", localitacf, is_fatt);

    const TString& statocf = archivio_clienti.get(CLI_STATOCF).as_string();
    if (statocf.blank())
    {
      const TString& comcf = archivio_clienti.get(CLI_COMCF).as_string();
      TToken_string key;
      key.add(statocf);
      key.add(comcf);
      const TRectype& rec_comuni = cache().get(LF_COMUNI, key);
      if (localitacf.blank())
      {
        TString80 dencom = rec_comuni.get(COM_DENCOM);
        clienti.set_fatt("Localita", dencom, is_fatt);
      }
      const TString& provcf = rec_comuni.get(COM_PROVCOM);
      clienti.set_fatt("Provincia", provcf, is_fatt);
    }

    clienti.set_fatt("CAP", archivio_clienti.get(CLI_CAPCF), is_fatt);

    clienti.set_fatt("PartitaIVA", archivio_clienti.get(CLI_PAIV), is_fatt);
    clienti.set_fatt("CodiceFiscale", archivio_clienti.get(CLI_COFI), is_fatt);
}

//clienti: i commenti del metodo sono nella genera_cliente_txt() della ha1100 (che è la mamma di questo)
void TFile2Txt::genera_clienti_txt(const long da_codcli)
{
  //controlla se c'è un codice selezionato da cui partire

  TEsporta_clienti_recordset clienti;

  TString query;
  query << "USE CLIFO";
  query << "\nSELECT (SOSPESO!=\"X\")";
  query << "\nJOIN CFVEN INTO TIPOCF=TIPOCF CODCF=CODCF";
  query << "\nFROM TIPOCF=C";
  if (da_codcli > 0L)
    query << " CODCF=" << da_codcli;
  query << "\nTO TIPOCF=C";

  TISAM_recordset archivio_clienti(query);
  const long archivio_clienti_items = archivio_clienti.items();

  TProgind progind(archivio_clienti_items, "Clienti...", false, true);
  for (bool ok = archivio_clienti.move_first(); ok; ok = archivio_clienti.move_next())
  {
    progind.addstatus(1);

    clienti.new_rec("");

    //il codice terminale è il codagente legato al cliente
    TString8 codage = archivio_clienti.get("CFVEN.CODAG").as_string();
    codage = codage.right(3);
    clienti.set("CodiceTerminale", codage);

    clienti.set("CodiceCliente", archivio_clienti.get(CLI_CODCF));

    //riempie l'anagrafica del cliente principale
    fill_anagrafica_cliente(archivio_clienti, clienti, false);

    //riempie l'anagrafica del cliente in allegato (se c'è)
    const long codalleg = archivio_clienti.get(CLI_CODALLEG).as_int();
    if (codalleg > 0)
    {
      TString queryna;
      queryna << "USE CLIFO";
      queryna << "\nJOIN CFVEN INTO TIPOCF=TIPOCF CODCF=CODCF";
      queryna << "\nFROM TIPOCF=C CODCF=#CODALLEG";
      queryna << "\nTO TIPOCF=C CODCF=#CODALLEG";

      TISAM_recordset cliente_allegato(queryna);
      cliente_allegato.set_var("#CODALLEG", codalleg);

      fill_anagrafica_cliente(cliente_allegato, clienti, true);
    }


    TString4 codpag = archivio_clienti.get(CLI_CODPAG).as_string();
    clienti.set("CodicePagamento", codpag.right(2));

    TString query;
    query << "USE CONDV";
    query << "\nFROM TIPO=C TIPOCF=C CODCF=#CODCF";
    query << "\nTO TIPO=C TIPOCF=C CODCF=#CODCF";

    TISAM_recordset contratti(query);
    contratti.set_var("#CODCF", archivio_clienti.get(CLI_CODCF).as_int());
    if (contratti.move_last())
    {
      const TString& cod_contr = contratti.get(CONDV_COD).as_string();
      clienti.set("CodiceListino", cod_contr);
    }


    const TString& str_sconto = archivio_clienti.get(CFV_SCONTO).as_string();
    clienti.set("ScontoFineFattura", hd_find_sconto(str_sconto));

    TString80 ntel = archivio_clienti.get(CLI_PTEL).as_string();
    ntel << archivio_clienti.get(CLI_TEL).as_string();
    clienti.set("NumeroTelefono", ntel);

    clienti.set("EsenteIVA", archivio_clienti.get(CFV_ASSFIS));

    clienti.set(CLI_CODCFFATT, archivio_clienti.get(CLI_CODCFFATT));
    clienti.set("TipoDoc", "F");

    real fido = archivio_clienti.get(CLI_FIDO).as_real();
    fido *= CENTO;
    fido.round();
    clienti.set("Fido", fido);

    /*const bool sospeso = archivio_clienti.get(CLI_SOSPESO).as_bool();
    TString4 s;
    if (sospeso)
      s='S';
    clienti.set("NoConsegna", TVariant(s));*/

  }

  TFilename output_path = genera_path("clienti");
  clienti.save_as(output_path, fmt_text);
}


void TFile2Txt::genera_sospesi_txt()
{
  TEsporta_sospesi_recordset sospesi;

  TString query;
  query << "USE PART";
  query << "\nSELECT (CHIUSA!=\"X\")&&(TIPOMOV=1)";
  query << "\nFROM TIPOC=C";
  query << "\nTO TIPOC=C";

  TISAM_recordset archivio_part(query);
  const long archivio_part_items = archivio_part.items();

  TProgind progind(archivio_part_items, "Sospesi...", false, true);
  for (bool ok = archivio_part.move_first(); ok; ok = archivio_part.move_next())
  {
    progind.addstatus(1);

    sospesi.new_rec("");

    //per riempire i campi è necessario un po' di casino sulla partita in esame
    const TRectype& rec_part = archivio_part.cursor()->curr();
    TPartita partita(rec_part);
    //cerca il saldo, il totale del doc originale, il residuo
    TImporto saldo, doc, pag, imp;
    partita.calcola_saldo(saldo, doc, pag, imp);
    TImporto residuo = doc;
    residuo -= saldo;

    const int nriga = rec_part.get_int(PART_NRIGA);
    const TRiga_scadenze& scad = partita.rata(nriga, 1);
    const TDate datascad = scad.get_date(SCAD_DATASCAD);

    //e vai che riempiamo i campi
    const long codcf = rec_part.get_long(PART_SOTTOCONTO);  //riprendiamo il codcf come long
    const TString& codage = hd_find_codag(codcf);
    sospesi.set("CodiceTerminale", codage);
    sospesi.set("CodiceCliente", codcf);
    const TString& ndoc = rec_part.get(PART_NUMDOC);
    sospesi.set("NumeroFattura", ndoc);
    const TDate datadoc = rec_part.get_date(PART_DATADOC);
    sospesi.set("DataFattura", hd_format_date6(datadoc));
    sospesi.set("ImportoResiduo", residuo.valore());
    sospesi.set("ImpOriginalDoc", doc.valore());
    sospesi.set("DataScadenza", hd_format_date6(datascad));
    TString16 cod_partita;
    cod_partita << rec_part.get_int(PART_ANNO) << "-" << rec_part.get(PART_NUMPART);
    sospesi.set("Partita", cod_partita);
    sospesi.set("TipoDoc", "F");
  }

  TFilename output_path = genera_path("sospesi");
  sospesi.save_as(output_path, fmt_text);
}

//listini: i commenti del metodo sono nella genera_listino_txt() della ha1100
void TFile2Txt::genera_righelistini_txt()
{
  TEsporta_listini_recordset righe_listini;

  TISAM_recordset agenti("USE AGENTI");
  const long agenti_items = agenti.items();
  for (bool ok = agenti.move_first(); ok; ok = agenti.move_next())
  {
    TString8 codage = agenti.get(AGE_CODAGE).as_string();
    codage = codage.right(3);

    TString query;
    query << "USE RCONDV";
    query << "\nFROM TIPO=L";
    query << "\nTO TIPO=L";

    TISAM_recordset archivio_rcondv(query);
    const long archivio_rcondv_items = archivio_rcondv.items();

    TProgind progind(archivio_rcondv_items, "Listini...", false, true);
    for (bool ok = archivio_rcondv.move_first(); ok; ok = archivio_rcondv.move_next())
    {
      progind.addstatus(1);

      righe_listini.new_rec("");

      righe_listini.set("CodiceTerminale", codage);
      righe_listini.set(RCONDV_COD, archivio_rcondv.get(RCONDV_COD));
      TString80 codart = archivio_rcondv.get(RCONDV_CODRIGA).as_string();
      righe_listini.set(RCONDV_CODRIGA, codart);

      real prezzo = archivio_rcondv.get(RCONDV_PREZZO).as_real();
      if (prezzo.is_zero())
      {
        TToken_string key_umart;
        key_umart.add(codart);
        key_umart.add(1);
        const TRectype& rec_umart = cache().get(LF_UMART, key_umart);
        prezzo = rec_umart.get_real(UMART_PREZZO);
      }
      prezzo *= 1000;
      prezzo.round();
      righe_listini.set(RCONDV_PREZZO, prezzo.integer());

      const TString& str_sconto = archivio_rcondv.get(RCONDV_SCONTO).as_string();
      righe_listini.set(RCONDV_SCONTO, hd_find_sconto(str_sconto));
    }
  }

  TFilename output_path = genera_path("listini");
  righe_listini.save_as(output_path, fmt_text);
}


void TFile2Txt::genera_contratti_txt()
{
  TEsporta_contratti_recordset righe_contratti;

  TString query;
  query << "USE RCONDV";
  query << "\nJOIN CONDV INTO TIPO=TIPO TIPOCF=TIPOCF CODCF=CODCF COD=COD";
  query << "\nFROM TIPO=C";
  query << "\nTO TIPO=C";

  TISAM_recordset archivio_rcondv(query);
  const long archivio_rcondv_items = archivio_rcondv.items();

  TProgind progind(archivio_rcondv_items, "Contratti...", false, true);
  for (bool ok = archivio_rcondv.move_first(); ok; ok = archivio_rcondv.move_next())
  {
    progind.addstatus(1);

    righe_contratti.new_rec("");

    const long codcf = archivio_rcondv.get(CONDV_CODCF).as_int();
    righe_contratti.set("CodiceTerminale", hd_find_codag(codcf));
    righe_contratti.set(RCONDV_CODRIGA, archivio_rcondv.get(RCONDV_CODRIGA));
    real prezzo = archivio_rcondv.get(RCONDV_PREZZO).as_real();
    prezzo *= 1000;
    prezzo.round();
    righe_contratti.set(RCONDV_PREZZO, prezzo.integer());
    const TString& str_sconto = archivio_rcondv.get(RCONDV_SCONTO).as_string();
    righe_contratti.set(RCONDV_SCONTO, hd_find_sconto(str_sconto));

    TDate dataini = archivio_rcondv.get("CONDV.VALIN").as_date();
    righe_contratti.set(CONDV_VALIN, hd_format_date8(dataini));
    TDate datafine = archivio_rcondv.get("CONDV.VALFIN").as_date();
    righe_contratti.set(CONDV_VALFIN, hd_format_date8(datafine));
  }

  TFilename output_path = genera_path("particolari");
  righe_contratti.save_as(output_path, fmt_text);
}

void TFile2Txt::genera_promozioni_txt()
{
  TEsporta_contratti_recordset righe_offerte;

  TString query;
  query << "USE RCONDV";
  query << "\nJOIN CONDV INTO TIPO=TIPO TIPOCF=TIPOCF CODCF=CODCF COD=COD";
  query << "\nFROM TIPO=O";
  query << "\nTO TIPO=O";

  TISAM_recordset archivio_rcondv(query);
  const long archivio_rcondv_items = archivio_rcondv.items();

  TProgind progind(archivio_rcondv_items, "Promozioni...", false, true);
  for (bool ok = archivio_rcondv.move_first(); ok; ok = archivio_rcondv.move_next())
  {
    progind.addstatus(1);

    righe_offerte.new_rec("");
    //non si sa quali campi trasferire!
  }

  TFilename output_path = genera_path("promo");
  righe_offerte.save_as(output_path, fmt_text);
}

//prodotti: i commenti del metodo sono nella genera_prodotto_txt() della ha1100
void TFile2Txt::genera_prodotti_txt()
{
  TEsporta_prodotti_recordset prodotti;

  TString query;
  query << "USE ANAMAG";
  query << "\nSELECT USER1=\"X\"";
  query << "\nJOIN UMART INTO CODART=CODART NRIGA=1";

  TISAM_recordset archivio_anamag(query);
  const long archivio_anamag_items = archivio_anamag.items();

  TProgind progind(archivio_anamag_items, "Prodotti...", false, true);
  for (bool ok = archivio_anamag.move_first(); ok; ok = archivio_anamag.move_next())
  {
    progind.addstatus(1);

    prodotti.new_rec("");

    prodotti.set(ANAMAG_CODART, archivio_anamag.get(ANAMAG_CODART));
    prodotti.set(ANAMAG_DESCR, archivio_anamag.get(ANAMAG_DESCR));
    real prezzo = archivio_anamag.get("UMART.PREZZO").as_real();
    prezzo *= 1000;
    prezzo.round();
    prodotti.set(UMART_PREZZO, prezzo.integer());

    const TString& codiva = archivio_anamag.get(ANAMAG_CODIVA).as_string();
    //esportiamo un'aliquota, non un codice iva!
    const real aliq_iva = cache().get("%IVA", codiva, "R0");
    prodotti.set(ANAMAG_CODIVA, aliq_iva.integer());

    prodotti.set(UMART_UM, archivio_anamag.get("UMART.UM"));
    const TString& str_sconto = archivio_anamag.get(ANAMAG_SCONTO).as_string();
    prodotti.set(ANAMAG_SCONTO, hd_find_sconto(str_sconto));
  }

  TFilename output_path = genera_path("prodotti");
  prodotti.save_as(output_path, fmt_text);
}

void TFile2Txt::genera_barcode_txt()
{
  TEsporta_barcode_recordset barcode;

  TString query;
  query << "USE CODCORR";
  query << "\nSELECT (TIPO=#TIPO)";

  TISAM_recordset archivio_codcorr(query);
  TConfig config(CONFIG_DITTA, "ha");
  const TString& tipo = config.get("TipoBarcode");
  archivio_codcorr.set_var("#TIPO", tipo);
  const long archivio_codcorr_items = archivio_codcorr.items();

  TProgind progind(archivio_codcorr_items, "Barcode...", false, true);
  for (bool ok = archivio_codcorr.move_first(); ok; ok = archivio_codcorr.move_next())
  {
    progind.addstatus(1);

    barcode.new_rec("");

    barcode.set(CODCORR_CODARTALT, archivio_codcorr.get(CODCORR_CODARTALT));
    barcode.set(CODCORR_CODART, archivio_codcorr.get(CODCORR_CODART));
  }

  TFilename output_path = genera_path("barcode");
  barcode.save_as(output_path, fmt_text);
}


void TFile2Txt::genera_decodart_txt()
{
  TEsporta_decodart_recordset decodart;

  TString query;
  query << "USE CODCORR";
  query << "\nSELECT (TIPOCF='C')";
  query << "\nBY CODCF";

  TISAM_recordset archivio_codcorr(query);
  const long archivio_codcorr_items = archivio_codcorr.items();

  TProgind progind(archivio_codcorr_items, "Decodart...", false, true);
  for (bool ok = archivio_codcorr.move_first(); ok; ok = archivio_codcorr.move_next())
  {
    progind.addstatus(1);

    decodart.new_rec("");

    decodart.set(CODCORR_CODART, archivio_codcorr.get(CODCORR_CODART));
    decodart.set(CODCORR_CODCF, archivio_codcorr.get(CODCORR_CODCF));
    decodart.set(CODCORR_CODARTALT, archivio_codcorr.get(CODCORR_CODARTALT));
  }

  TFilename output_path = genera_path("decodart");
  decodart.save_as(output_path, fmt_text);
}


void TFile2Txt::genera_attrezzature_txt()
{
  TEsporta_attrezzature_recordset attrezzature;
}


void TFile2Txt::genera_tabpag_txt()
{
  TEsporta_pagamenti_recordset tabpag;

  TString query;
  query << "USE %CPG";
  query << "\nJOIN %RPG ALIAS 401 INTO CODTAB=CODTAB";

  TISAM_recordset archivio_pagamenti(query);
  const long archivio_pagamenti_items = archivio_pagamenti.items();

  TProgind progind(archivio_pagamenti_items, "Pagamenti...", false, true);
  for (bool ok = archivio_pagamenti.move_first(); ok; ok = archivio_pagamenti.move_next())
  {
    progind.addstatus(1);

    tabpag.new_rec("");
    const TString& codtab = archivio_pagamenti.get("CODTAB").as_string();
    tabpag.set("CodicePagamento", codtab.right(2));
    const TString& cpg_s0 = archivio_pagamenti.get("S0").as_string();
    tabpag.set("DescrPagamento", cpg_s0);
    long giorni = archivio_pagamenti.get("401@.I0").as_int();
    if (giorni <= 0)
      giorni = archivio_pagamenti.get("I3").as_int();
    tabpag.set("GiorniScadenza", giorni);
  }

  TFilename output_path = genera_path("tabpag");
  tabpag.save_as(output_path, fmt_text);
}

void TFile2Txt::genera_carico_txt()
{
  TEsporta_carico_recordset carico;

  TString query;
  query << "USE RDOC";
  query << "\nSELECT (DOC.TIPODOC=#TIPODOC)&&(DOC.STATO=#STATO)";
  query << "\nJOIN DOC INTO PROVV=PROVV ANNO=ANNO CODNUM=CODNUM NDOC=NDOC";
  query << "\nBY DOC.CODAG";
  query << "\nFROM CODNUM=#CODNUM";
  query << "\nTO CODNUM=#CODNUM";

  TISAM_recordset archivio_rdoc(query);

  TConfig config(CONFIG_DITTA, "ha");
  const TString& tipodoc = config.get("CarDocTip");
  archivio_rdoc.set_var("#TIPODOC", tipodoc);
  const TString& stato = config.get("CarDocSta");
  archivio_rdoc.set_var("#STATO", stato);
  const TString& codnum = config.get("CarDocNum");
  archivio_rdoc.set_var("#CODNUM", codnum);

  const long archivio_rdoc_items = archivio_rdoc.items();

  TProgind progind(archivio_rdoc_items, "Documenti carico...", false, true);
  for (bool ok = archivio_rdoc.move_first(); ok; ok = archivio_rdoc.move_next())
  {
    progind.addstatus(1);

    carico.new_rec("");

    TString8 codage = archivio_rdoc.get("DOC.CODAG").as_string();
    codage = codage.right(3);
    carico.set("CodiceTerminale", codage);
    carico.set(RDOC_CODART, archivio_rdoc.get(RDOC_CODART));
    real qta = archivio_rdoc.get(RDOC_QTA).as_real();
    qta *= CENTO;
    qta.round();
    carico.set(RDOC_QTA, qta);
    carico.set(RDOC_LIVELLO, archivio_rdoc.get(RDOC_LIVELLO));
  }

  TFilename output_path = genera_path("carico");
  carico.save_as(output_path, fmt_text);
}

//metodo di alto livello per la gestione delle chiamate
void TFile2Txt::elabora(const TMask& mask)
{
  if (mask.get_bool(F_AGENTI))
    genera_agenti_txt();

  if (mask.get_bool(F_CLIENTI))
  {
    const long da_codcli = mask.get_long(F_DA_CODCLI);
    genera_clienti_txt(da_codcli);
  }

  if (mask.get_bool(F_SOSPESI))
    genera_sospesi_txt();

  if (mask.get_bool(F_LISTINI))
    genera_righelistini_txt();

  if (mask.get_bool(F_CONTRATTI))
    genera_contratti_txt();

  if (mask.get_bool(F_PROMOZIONI))
    genera_promozioni_txt();

  if (mask.get_bool(F_PRODOTTI))
    genera_prodotti_txt();

  if (mask.get_bool(F_BARCODE))
    genera_barcode_txt();

  if (mask.get_bool(F_DECODART))
    genera_decodart_txt();

  if (mask.get_bool(F_ATTREZZA))
    genera_attrezzature_txt();

  if (mask.get_bool(F_TABPAG))
    genera_tabpag_txt();

  if (mask.get_bool(F_CARICO))
    genera_carico_txt();
}


void TFile2Txt::main_loop()
{
  TFile2Txt_mask mask;
  _output_dir = mask.get(F_PATH);
  if (!_output_dir.exist())
    error_box("Non esiste la cartella di destinazione indicata!");
  while (mask.run() == K_ENTER)
  {
    elabora(mask);
  }
}

bool TFile2Txt::create()
{
	return TSkeleton_application::create();
}

int ha1200(int argc, char* argv[])
{
  TFile2Txt a;
  a.run(argc, argv, "Generazione .txt da archivi");
  return 0;
}