campo-sirio/ha/ha3800.cpp

#include <applicat.h>
#include <automask.h>
#include <config.h>
#include <recarray.h>
#include <reputils.h>
#include <tabmod.h>

#include <doc.h>
#include <rdoc.h>
#include <../mg/rmovmag.h>
#include <../ve/velib.h>

#include "halib.h"
#include "ha3800a.h"

//////////////////////////////////////////////
//  Maschera
//////////////////////////////////////////////
class TInserimento_storico_mask : public TAutomask
{

protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

public:
  TInserimento_storico_mask();
};


bool TInserimento_storico_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  case F_ANNO:
    if (e == fe_modify)
    {
      //cambiando l'anno propone in automatico il dadata adata
      const int anno = o.get_long();
      const TDate ini_anno(1, 1, anno);
      set(F_DADATA, ini_anno);
      const TDate fine_anno(31, 12, anno);
      set(F_ADATA, fine_anno);
    }
    break;
  case F_DADATA:
  case F_ADATA:
    if (e == fe_modify || e == fe_close)
    {
      //controlla che le date appartengano all'anno selezionato (e impedisce di lasciare date vuote!!!)
      const TDate data = get_date(o.dlg());
      const int anno = get_int(F_ANNO);
      if (data.year() != anno)
        return error_box("La data deve appartenere all'anno selezionato!");
    }
    break;
  default:
    break;
  }
  return true;
}

TInserimento_storico_mask::TInserimento_storico_mask() : TAutomask("ha3800a")
{
}

//////////////////////////////////////////////
//  Applicazione
//////////////////////////////////////////////
class TInserimento_storico : public TSkeleton_application
{
protected:
  void elabora_aperture(const TMask& mask, TLog_report& log);
  void elabora_chiusure(const TMask& mask, TLog_report& log);
  void elabora(const TMask& mask);

public:
  void main_loop();
};

void TInserimento_storico::elabora_aperture(const TMask& mask, TLog_report& log)
{
  //1) legge la configurazione per avere i parametri di query
  TConfig config(CONFIG_DITTA, "ha");
  const TString4 tipo2elab = config.get("Doc2ElabTip");
  const TString4 stato2elab = config.get("Doc2ElabSta");
  const TString8 caus_open = config.get("CausOpen");
  // const TString8 caus_close = config.get("CausClose");  Ignorata dal 19-06-2012
  
  //..e anche la maschera
  const long anno = mask.get_long(F_ANNO);
  const TDate da_data = mask.get_date(F_DADATA);
  const TDate a_data = mask.get_date(F_ADATA);

  //2) raccatta le numerazioni valide in base al tipo di documento in configurazione 
  TString_array num_doc;
  const int num_del_tipo = numerazioni_documenti(num_doc, tipo2elab);

#ifdef DBG
  ofstream numerazioni("c:/temp/numerazioni.txt", ios::app);
#endif


  //3) giro su ogni numerazione per trovare le righe che servono
  for (int n = 0; n < num_del_tipo; n++)
  {
    const TString4 codnum = num_doc.row(n);
#ifdef DBG
    if (codnum == "B009")
      int cazzone = 1;
#endif

    TString query;
    query << "USE RDOC KEY 2";
    query << "\nSELECT (DOC.STATO=#STATO)&&(BETWEEN(DOC.DATADOC,#DADATA,#ADATA))";
    query << "\nJOIN DOC INTO PROVV==PROVV ANNO==ANNO CODNUM==CODNUM NDOC==NDOC";
    query << "\nFROM CODNUM=#CODNUM ANNO=#ANNO PROVV=D";
    query << "\nTO CODNUM=#CODNUM ANNO=#ANNO PROVV=D";

    TISAM_recordset rdoc_recset(query);
    rdoc_recset.set_var("#STATO", stato2elab);
    rdoc_recset.set_var("#DADATA", da_data);
    rdoc_recset.set_var("#ADATA", a_data);
    rdoc_recset.set_var("#CODNUM", codnum);
    rdoc_recset.set_var("#ANNO", anno);

    const long rdoc_recset_items = rdoc_recset.items();

    //date tutte le righedoc che soddisfano la query, deve tener conto solo di quelle..
    //..non ancora registrate in precedenza e che, soprattutto, abbiano una causale sensata
    for (bool ok = rdoc_recset.move_first(); ok; ok = rdoc_recset.move_next())
    {
      //controllo della causale
      TString8 caus = rdoc_recset.get(RDOC_CAUSMAG).as_string();
      //se la causale non <20> sulla riga controlla quella di testata
      if (caus.empty())
        caus = rdoc_recset.get("33."DOC_CAUSMAG).as_string();

      //solo le righdoc con causale sensata proseguono
      if (caus == caus_open /*|| caus == caus_close*/)
      {
        //bool di scrimage
        const bool bopen = caus == caus_open;

        //3_A) tabella &ATT
        //poich<63> documento apertura deve controllare se per caso la macchina <20> nuova
        //dati del record corrente (vale anche per le chiusure in quanto esistono macchine..
        //..di antica data senza registrazioni!)
        const long doc_anno = rdoc_recset.get(RDOC_ANNO).as_int();
        const TString4 doc_codnum = rdoc_recset.get(RDOC_CODNUM).as_string();
        const long doc_ndoc = rdoc_recset.get(RDOC_NDOC).as_int();
        const TString& codart = rdoc_recset.get(RDOC_CODART).as_string();
        const TString& matricola = rdoc_recset.get(RDOC_LIVELLO).as_string();
        TModule_table tab_att("&ATT");
        tab_att.put("CODTAB", matricola);
        const int err = tab_att.read();
        //se l'attrezzatura (intesa come codart+matricola) non esiste -> la deve aggiungere (sara' sicuramente la prima)...
        //..per quanto riguarda il progressivo)
        if (err != NOERR)
        {
          TString msg;
          msg << "Articolo " << codart << " senza matricola sul documento " << doc_codnum << " " << doc_anno << "/" << doc_ndoc;
          log.log(1, msg); 
          continue;
        }
        //comunque deve scrivere il cliente e la data perch<63> <20> un'apertura quindi la macchina <20> assegnata..
        //..al cliente con questo documento
        const long doc_clifo = rdoc_recset.get("33.CODCF").as_int();
        const TDate doc_datadoc = rdoc_recset.get("33.DATADOC").as_date();
        const int indsped = rdoc_recset.get("33.CODINDSP").as_int();

        //se la macchina viene assegnata ad un cliente (movimento di apertura) -> va messo il clifo..
        if (bopen)
          tab_att.put("I0", doc_clifo);
        else  //..senno' torna alla casa madre e sparisce il clifo
          tab_att.put("I0", 0L);

        tab_att.put("D0", doc_datadoc);
        tab_att.put("I1", indsped);

        tab_att.write_rewrite();

        //3_B) tabella &HIS
        //controllo sul ndoc se per caso questa riga l'ha gi<67> importata, senno' deve aggiungere un record
        //query sulla storia di questa macchina
        TString query_his;
        query_his << "USE &HIS";
        query_his << "\nFROM CODTAB=#CODTAB";
        query_his << "\nTO CODTAB=#CODTAB";
        TISAM_recordset recset_his(query_his);
        recset_his.set_var("#CODTAB", matricola);

        const long recset_his_items = recset_his.items();

        TModule_table tab_his("&HIS");
        int n_line_to_update = 0;

        //cerca se la riga esiste gi<67> nello storico e va solo aggiornata
        for (bool ok = recset_his.move_last(); ok; ok = recset_his.move_prev())
        { 
          long curr_anno;
          if (bopen)
            curr_anno = recset_his.get("S4[1,4]").as_int();
          else
            curr_anno = recset_his.get("S5[1,4]").as_int();
          if (curr_anno == doc_anno)
          {
            TString4 curr_codnum;
            if (bopen)
              curr_codnum = recset_his.get("S4[5,8]").as_string();
            else
              curr_codnum = recset_his.get("S5[5,8]").as_string();
            if (curr_codnum == doc_codnum)
            {
              long curr_ndoc;
              if (bopen)
                curr_ndoc = recset_his.get("S4[9,15]").as_int();
              else
                curr_ndoc = recset_his.get("S5[9,15]").as_int();
              if (curr_ndoc == doc_ndoc)
              {
                n_line_to_update = recset_his.get("CODTAB[9,13]").as_int();
                break;
              }
            }
          }
        } //for (bool ok = recset_his.move...

        TString80 new_codtab;
        //se la riga non c'era -> va aggiunta
        if (n_line_to_update == 0)
        {
          n_line_to_update = recset_his_items + 1;

          //adesso ha il numero di riga da aggiornare e crea il nuovo record
          new_codtab.format("%08s%05d", (const char*)matricola, n_line_to_update);
          tab_his.put("CODTAB", new_codtab);
          tab_his.write();
          new_codtab.cut(0);
        }

        //rimette il codtab per riposizionarsi sul record corretto
        new_codtab.format("%08s%05d", (const char*)matricola, n_line_to_update);
        tab_his.put("CODTAB", new_codtab);
        
        //ed aggiunge tutti i campi
        const TString& descr = rdoc_recset.get(RDOC_DESCR).as_string();
        tab_his.put("S0", descr);
        //tab_his.put("S3", articolo_collegato);

        TString16 str_key_doc;
        str_key_doc.format("%4d%4s%7d", doc_anno, (const char*)doc_codnum, doc_ndoc);
        if (bopen)
          tab_his.put("S4", str_key_doc);
        else
          tab_his.put("S5", str_key_doc);
        tab_his.put("S6", rdoc_recset.get(RDOC_UMQTA).as_string());
        const TString& codmag = rdoc_recset.get(RDOC_CODMAG).as_string();
        TString4 s7;    //s7[1,1]=tipo s7[2,4]=codmag
        s7 << "C" << codmag;
        tab_his.put("S7", s7);
        tab_his.put("I0", doc_clifo);
        tab_his.put("I1", indsped);
        tab_his.put("D0", doc_datadoc);
        const real qta = rdoc_recset.get(RDOC_QTA).as_real();
        tab_his.put("R0", qta);
        const real prezzo = rdoc_recset.get(RDOC_PREZZO).as_real();
        const real importo = qta * prezzo;
        tab_his.put("R1", importo);      
        tab_his.put("B0", !bopen); //se <20> il documento di chiusura va segnalato

        const int written = tab_his.write_rewrite();
        //segna sul log la riga aggiunta alla tabella storico &HIS
        if (written == NOERR)
        {
          TString msg;
          msg.format("%4d-%4s/%7d--%s--%s--%6d", 
                     doc_anno, (const char*)doc_codnum, doc_ndoc, 
                     (const char*)codart, (const char*)matricola, doc_clifo);
          log.log(0, msg);
        }
      } //if (caus==caus_open || ..

    } //for (bool ok = rdoc_recset.move_first()...
    
  } //for (int n = 0; n < num_del_tipo...
}

void TInserimento_storico::elabora_chiusure(const TMask& mask, TLog_report& log)
{
  TConfig config(CONFIG_DITTA, "ha");
  const TString8 caus_close = config.get("CausClose");
  
  //..e anche la maschera
  const long anno = mask.get_long(F_ANNO);
  const TDate da_data = mask.get_date(F_DADATA);
  const TDate a_data = mask.get_date(F_ADATA);
  TString query;
  query << "USE MOVMAG KEY 3 SELECT CODCAUS=#CODCAUS";
  query << "\nFROM DATAREG=#DADATA";
  query << "\nTO DATAREG=#ADATA";

  TISAM_recordset mov_recset(query);
  mov_recset.set_var("#CODCAUS", caus_close);
  mov_recset.set_var("#DADATA", da_data);
  mov_recset.set_var("#ADATA", a_data);

  for (bool ok = mov_recset.move_first(); ok; ok = mov_recset.move_next())
  {
    const TDate mov_datareg = mov_recset.get(MOVMAG_DATAREG).as_date();
    const long mov_nreg = mov_recset.get(MOVMAG_NUMREG).as_int();

    TToken_string key; key << mov_recset.get(MOVMAG_NUMREG);
    TRecord_array rmovmag(key, LF_RMOVMAG);
    for (int r = 1; r > 0 && r <= rmovmag.last_row(); r++)
    {
      const TRectype& row = rmovmag.row(r);
      //controllo della causale
      const TString& caus = row.get(RMOVMAG_CODCAUS);
      if (caus.full() && caus != caus_close)
        continue;
      
      const TString80 codart = row.get(RMOVMAG_CODART);
      const TString16 matricola = row.get(RMOVMAG_LIVGIAC);

      TModule_table tab_att("&ATT");
      tab_att.put("CODTAB", matricola);
      const int err = tab_att.read();
      if (err != NOERR)
      {
        TString msg;
        msg << "Articolo " << codart << " senza matricola sul movimento " << mov_recset.get(MOVMAG_NUMREG) << " del " << mov_recset.get(MOVMAG_DATAREG);
        log.log(1, msg); 
        continue;
      }

      const long clifo = tab_att.get_long("I0");
      const int indsped = tab_att.get_int("I1");
      if (clifo <= 0)
      {
        TString msg;
        msg << "Matricola " << matricola << " senza cliente: probabilmente l'articolo " << codart << " <20> gi<67> rientrato";
        log.log(1, msg); 
        continue;
      }

      tab_att.put("I0", ""); // Azzera cliente
      tab_att.put("I1", ""); // Azzera indsped
      tab_att.put("D0", mov_datareg);
      tab_att.write_rewrite();

      TString query_his;
      query_his << "USE &HIS";
      query_his << "\nFROM CODTAB=#CODTAB";
      query_his << "\nTO CODTAB=#CODTAB";
      TISAM_recordset recset_his(query_his);
      recset_his.set_var("#CODTAB", matricola);

      const long recset_his_items = recset_his.items();

      TModule_table tab_his("&HIS");
      int n_line_to_update = 0;

      //cerca se la riga esiste gi<67> nello storico e va solo aggiornata
      for (bool ok = recset_his.move_last(); ok; ok = recset_his.move_prev())
      { 
        const long curr_anno = recset_his.get("S5[1,4]").as_int();
        const long curr_nreg = recset_his.get("S5[9,15]").as_int();
        if (curr_anno == anno && curr_nreg == mov_nreg)
        {
          n_line_to_update = recset_his.get("CODTAB[9,13]").as_int();
          break;
        }
      } //for (bool ok = recset_his.move...

      TString80 new_codtab;
      //se la riga non c'era -> va aggiunta
      if (n_line_to_update == 0)
      {
        n_line_to_update = recset_his_items + 1;

        //adesso ha il numero di riga da aggiornare e crea il nuovo record
        new_codtab.format("%08s%05d", (const char*)matricola, n_line_to_update);
        tab_his.put("CODTAB", new_codtab);
        tab_his.write();
      }

      //rimette il codtab per riposizionarsi sul record corretto
      new_codtab.format("%08s%05d", (const char*)matricola, n_line_to_update);
      tab_his.put("CODTAB", new_codtab);
        
      //ed aggiunge tutti i campi
      const TString& descr = mov_recset.get(MOVMAG_DESCR).as_string();
      tab_his.put("S0", descr);
      
      TString16 str_key_doc;
      str_key_doc.format("%4d%4s%7d", anno, "", mov_nreg);
      tab_his.put("S5", str_key_doc);
      tab_his.put("S6", row.get(RMOVMAG_UM));
      const TString& codmag = row.get(RMOVMAG_CODMAG);
      TString4 s7;    //s7[1,1]=tipo s7[2,4]=codmag
      s7 << "C" << codmag;
      tab_his.put("S7", s7);
      tab_his.put("I0", clifo);
      tab_his.put("I1", indsped);
      tab_his.put("D0", mov_datareg);
      const real qta = row.get(RMOVMAG_QUANT);
      tab_his.put("R0", qta);
      const real prezzo = row.get(RMOVMAG_PREZZO);
      const real importo = qta * prezzo;
      tab_his.put("R1", importo);
      tab_his.put("B0", true); // Chiusura

      const int written = tab_his.write_rewrite();
      //segna sul log la riga aggiunta alla tabella storico &HIS
      if (written == NOERR)
      {
        TString msg;
        msg.format("%4d-%4s/%7d--%s--%s--%6d", 
                    anno, (const char*)caus_close, mov_nreg, 
                    (const char*)codart, (const char*)matricola, clifo);
        log.log(0, msg);
      }
    }
  }
}

void TInserimento_storico::elabora(const TMask& mask) 
{ 
  //vogliono pure il log! che rompicazzo
  TLog_report log(TR("Righe storico aggiunte"));
  log.kill_duplicates();
  log.log(0, "");
  log.log(0, HR("Anno-Num.-Ndoc--Articolo     --Matricola      --Cliente"));
  log.log(0, "");

  elabora_aperture(mask, log);  
  elabora_chiusure(mask, log); 

  log.preview();
}


void TInserimento_storico::main_loop()
{
  TInserimento_storico_mask mask;
  while (mask.run() == K_ENTER)
    elabora(mask);
}

int ha3800(int argc, char* argv[])
{
  TInserimento_storico app;
  app.run(argc, argv, TR("Inserimento storico attrezzature"));
  return 0;
}