campo-sirio/ve/ve6300.cpp

// ve6300.cpp: programma di generazione effetti
// Muliebrica parodia...
//      Il cavo delirante che irrompe nel silenzio dell'apogeo
//              *  * *  *   *    *     *
//           *
//        _                _______ _____________      ___================
//      _I_I___oo_____ii__| |_|| | |            \     |  |O|  |_|  |_|
//     |   | -  -   |     I    | | |    L M S    |    |  | |
//    _|___|________|____ I____|_|=|_____________|=II=|__|_|_____________
//  I=| o (_)--(_)--(_)--(_) O--O   O-O +++++ O-O \--/  ()==()   ++++
//=======================================================================
// 
//                               
//     ____||____============____||___    ___===============================
//    /__|     OOOOOOOOOOOOO    [_]  |    |  |[]|  [_]    [_]    [_]    [_]
//  /             S N C F            |    |  |  |
//  \________________________________|_ii_|__|__|___________________________
//    ()==()    === ++++ ===   ()==()       ()==()     +++   +++   ++++++++
//=========================================================================
//
// Have you ever heard MK ?

#include <applicat.h>
#include <relation.h>
#include <tabutil.h>
#include <mask.h>
#include <sheet.h>
#include <urldefid.h>
#include <progind.h>
#include <modaut.h>
#include <doc.h>

#include "velib.h"
#include "ve6300a.h"

// TGenerazioneEffetti_app
// Applicazione di generazione effetti
class TGenerazioneEffetti_app : public TApplication
{
  TString16     _cod_el;       // codice elaborazione immesso
  TDate         _data_ini;     // data di inizio intervallo
  TDate         _data_fine;    // data di fine intervallo
  bool          _raggruppa;    // se TRUE raggruppa gli effetti secondo i criteri
  TMask         *_msk;         // maschera di selezione dati
  TBit_array     _valid_array; // array dei tipi di pagamento validi per la generazione di effetti
  TArray_sheet   *_num_sheet;  // Array sheet selezionabile dei codici numerazione
  TAssoc_array   _group_array; // Assoc_array dei documenti da raggruppare. La chiave di ogni elemento
  TString_array  _tipi_doc;    // Array di stringhe contenente i tipi documenti da elaborare
  char           _final_doc_status; // Valore per lo stato finale del documento
                                    // Flags di raggruppamento opzionali (%ELD->S1):
  bool           _group_by_date,    // raggruppa per data di scadenza
                 _group_by_sosp,    // raggruppa per flag sosp. d'imposta
                 _group_by_change,  // raggruppa per cambio
                 _group_by_pag,     // raggruppa per cond. di pagamento
                 _group_by_bank,    // raggruppa per banca (ABI-CAB)
                 _group_by_type,    // raggruppa per tipo di documento
                 _group_by_num,     // raggruppa per cod. numerazione
                 _group_by_agent;   // raggruppa per agente
  TArray        _file;
protected: // TApplication
  void open_files(int logicnum, ...);  
  // Le 4 seguenti non hanno bisogno di commenti
  virtual bool menu(MENU_TAG mt);
  virtual bool create();
  virtual bool destroy();
  // Cambia lo stato del documento
  int change_doc_status(TDocumento*);
  // Coontrolla se lo stato ed il tipo del documento sono validi e rispettano la selezione
  bool doc_tipo_stato_ok(TDocumento*);
  // Handler del codice elaborazione differita
  static bool handle_cod_eld(TMask_field& f, KEY k);
  // Handler dell'intervallo di date
  static bool handle_data_range(TMask_field& f, KEY k);
  // Handler del pulsante di selezione codici numerazione
  static bool handle_select(TMask_field& f, KEY k);
  // Ritorna il TArray_sheet contenente le selezioni sui codici numerazione
  TArray_sheet* get_num_sheet() const { return _num_sheet; }
  // Costruisce lo sheet dei codici numerazione
  void   build_num_sheet();
  // Aggiunge il documento corrente alla lista dei documenti raggruppabili
  void   add_to_group_list(TDocumento* doc);
  // Costruisce la stringa chiave per raggruppamento
  void   build_group_key(TString& key, TDocumento* doc);
  // Costruisce la stringa chiave per documento
  void   build_doc_key(TToken_string& key, TDocumento* doc);
  // Setta i flags di raggruppamento opzionali in base alla tabella 
  void   set_options();
  void   generate();
public:
  TGenerazioneEffetti_app() {_msk = NULL; _num_sheet = NULL;} 
  virtual ~TGenerazioneEffetti_app() { }
};

inline TGenerazioneEffetti_app& app() { return (TGenerazioneEffetti_app&) main_app(); }

void TGenerazioneEffetti_app::open_files(int logicnum, ...)  
{  
  va_list marker;
  va_start(marker, logicnum);
  while (logicnum > 0)
  {
    CHECKD(_file.objptr(logicnum) == NULL, "File gia' aperto: ", logicnum);
    _file.add(new TLocalisamfile(logicnum), logicnum);
    logicnum = va_arg(marker, int);
  }
}

bool TGenerazioneEffetti_app::handle_data_range(TMask_field& f, KEY k)
{
  if (k==K_ENTER && f.dirty())
  {
    TMask& m = f.mask();
    TDate da(m.get_date(F_DATA_INI));
    TDate a(m.get_date(F_DATA_FIN));
    //m.field(F_DATA_REG).set_dirty();
    //if (a == botime || da == botime) return TRUE;
    if (a < da) 
    {
      f.error_box("La data di inizio deve essere minore della data di fine.");
      return FALSE;
    }
    //if ((a - da) > 15)
    //{
    //  f.error_box("L'intervallo tra le date non puo' eccedere i 15 giorni.");
    //  return FALSE;
    //}
  }
  return TRUE;
}

bool TGenerazioneEffetti_app::handle_cod_eld(TMask_field& f, KEY k)
{
  if (f.to_check(k) && k == K_TAB) // se e' cambiato ricostruisce anche lo sheet dei codici numerazione
  {
    app()._cod_el = f.get(); // aggiorna il codice elaborazione per la build_num_sheet()
    f.mask().disable(DLG_OK);
    app().build_num_sheet();
  }
  return TRUE;
}

bool TGenerazioneEffetti_app::handle_select(TMask_field& f, KEY k)
{
  if (k == K_SPACE)
  {
    TMask& m = f.mask();
    TArray_sheet* s = app().get_num_sheet();
    if (s->run())
    {
      if (s->checked() != 0) // Hai selezionato qualcosa ?
        m.enable(DLG_OK);    // allora abilita il pulsante di conferma 
      else
        m.disable(DLG_OK);
    }
  }
  return TRUE;
}

void TGenerazioneEffetti_app::build_num_sheet()
{
  _num_sheet->destroy();
  
  TTable eld("%ELD");
  TTable num("%NUM");
  TString s1,s2,s3;
  TString16 tipon1,tipon2,tipon3,tipon4,tipon5; // tipi documento validi per la numerazione
  long pos;
  
  eld.put("CODTAB",_cod_el);
  if (eld.read() == NOERR)
  {
    TToken_string t;
    s1.format("%-20s",(const char*)eld.get("S2"));
    s3 = eld.get("S7");
    _final_doc_status = eld.get("S4")[0];
    for (int i=0;i<5;i++)
    {
      t = s1.mid(i*4,4);     // Tipo documento
      if (t.trim().empty()) break;
      t.add(s3.mid(i,1));  // Stato iniziale
      _tipi_doc.add(t);    // Aggiunge questo tipo documento alla lista
    }
    for (pos=0,num.first();num.good();num.next(),pos++) // scorre tutte le numerazioni possibili
    {
      TToken_string t;
      t.add(" ");
      t.add(num.get("CODTAB"));
      t.add(num.get("S0"));
      _num_sheet->add(t);
      s2 = num.get("S2"); // reperisce i tipi documento validi per questa numerazione
      tipon1 = s2.mid(0,4);
      tipon2 = s2.mid(4,4);
      tipon3 = s2.mid(8,4);
      tipon4 = s2.mid(12,4);
      tipon5 = s2.mid(16,4);
      const int n1 = s1.find(tipon1);
      const int n2 = s1.find(tipon2);
      const int n3 = s1.find(tipon3);
      const int n4 = s1.find(tipon4);
      const int n5 = s1.find(tipon5);
      if ((tipon1.empty() || n1<0) && (tipon2.empty() || n2<0) && 
           (tipon3.empty() || n3<0) && (tipon4.empty() || n4<0) &&
           (tipon5.empty() ||  n5<0))
        _num_sheet->disable_row(pos);
      else
        _num_sheet->enable_row(pos);
    }
  }
}

bool TGenerazioneEffetti_app::create()
{
  TApplication::create();
  if (!has_module(EFAUT))
  {
    error_box("Impossibile eseguire il programma se il modulo Effetti non e' abilitato");
    return FALSE;
  }
  open_files(LF_TABCOM, LF_CLIFO, LF_CFVEN, LF_DOC, LF_RIGHEDOC, LF_OCCAS, 0);
  _msk = new TMask("ve6300a");
  _msk->set_handler(F_CODICE_ELAB,handle_cod_eld);
  _msk->set_handler(F_DATA_INI,handle_data_range);
  _msk->set_handler(F_DATA_FIN,handle_data_range);
  _msk->set_handler(DLG_USER,handle_select);
  _num_sheet = new TArray_sheet(-1,-1,-4,-4,"Codici numerazione",
               "@1|Cod. numerazione|Descrizione@50");
  dispatch_e_menu(BAR_ITEM(1));
  return TRUE;
}

bool TGenerazioneEffetti_app::destroy()
{
  if (_msk) delete _msk;
  if (_num_sheet) delete _num_sheet;
  return TApplication::destroy();
}

bool TGenerazioneEffetti_app::menu(MENU_TAG mt)
{
  while (_msk->run() == K_ENTER)
  {
    _cod_el = _msk->get(F_CODICE_ELAB);
    _data_ini = _msk->get_date(F_DATA_INI);
    _data_fine = _msk->get_date(F_DATA_FIN);
    _raggruppa = _msk->get_bool(F_RAGGRUPPA);
    generate();
  }
  return FALSE;
}

bool TGenerazioneEffetti_app::doc_tipo_stato_ok(TDocumento* doc)
// Verifica che il tipo documento corrente esista tra i tipi previsti dalla elaborazione
// differita selezionata
{
  const int items = _tipi_doc.items();
  bool found = FALSE;
  const TString16 tipo(doc->tipo().codice());
  const char stato = doc->stato();
  for (int i=0;i<items && !found;i++)
  {
    TToken_string& t = _tipi_doc.row(i);
    const TString16 tipox(t.get(0));
    const char statox = t.get(1)[0];
    if (tipo == tipox && stato == statox)
      found = TRUE;
  }
  return found;
}

int TGenerazioneEffetti_app::change_doc_status(TDocumento* doc)
// Cambia lo stato del documento
{
  doc->stato(_final_doc_status);
  return doc->rewrite();
}


// Criteri di raggruppamento effetti.
// Un documento puo' essere raggruppato con i seguenti criteri:
// - flag di raggruppamento effetti a TRUE (obbligatorio)
// - cliente                               (obbligatorio)
// - valuta                                (obbligatorio)
// - data scadenza                         (opzionale)
// - flag di sosp. d'imposta               (opzionale)
// - cambio valuta                         (opzionale)
// - cond di pagamento                     (opzionale)
// - banca                                 (opzionale)
// - tipo doc.                             (opzionale)
// - cod. numerazione                      (opzionale)
// - agente                                (opzionale)
// I parametri opzionali sono decisi nella tabella elaborazioni
// Spiegazione del raggruppamento:
// Il raggruppamento di documenti diversi in uno stesso effetto consiste nella creazione
// di piu' righe dello stesso effetto.
// Ad esempio supponiamo di avere il cliente 10 con 4 fatture ognuna con condizioni di pagamento diverse
// la fattura 1 e' suddivisa in 2 rate (10.000 + 30.000)
// la fattura 2 e' suddivisa in 4 rate (15.000 + 20.000 + 25.000 + 30.000)
// la fattura 3 e' suddivisa in 5 rate (20.000 + 40.000 + 80.000 + 160.000 + 320.000)
// la fattura 4 e' suddivisa in 3 rate (50.000 + 100.000 + 150.000)
// Il numero di effetti generati equivale al massimo numero di rate (5 in questo caso)
// quindi avremo 5 effetti:
// il primo avra' 4 righe (prima rata di tutte le fatture)
// il secondo avra' 4 righe (seconda rata di tutte le fatture)
// il terzo avra' 3 righe (terza rata delle fatture 2,3,4)
// il quarto avra' 2 righe (quarta rata delle fatture 2 e 3)
// il quinto avra' 1 riga (quinta rata della fattura 3)
// La testata di ogni effetto conterra' il totale (somma) dei singoli importi delle righe
// ovvero:
// tot. primo effetto:        95.000
// tot. secondo effetto:     190.000
// tot. terzo effetto:       255.000
// tot. quarto effetto:      190.000
// tot. quinto effetto:      320.000
// I dati della testata (soprattutto la data di scadenza) di ogni effetto vengono presi dal 
// primo documento valido per la generazione dell'effetto corrente:
// per i primi due effetti vale la fattura 1
// per gli effetti 3 e 4 vale la fattura 2
// per l'effetto 5 vale la fattura 3.
// Questo e' quanto ho appreso (Hope I'm right...) ;-)

void TGenerazioneEffetti_app::add_to_group_list(TDocumento* doc)
{  
  TString key;
  TToken_string t("",'$');
  build_group_key(key,doc);
  build_doc_key(t,doc);
  
  const bool is_key = _group_array.is_key(key);
  TToken_string tt(is_key ? (TToken_string&) _group_array[key]: "");
  tt.add(t);
  _group_array.add(key,tt, is_key ? TRUE : FALSE);
}

void TGenerazioneEffetti_app::build_group_key(TString& key, TDocumento* doc)
{
  long cli = doc->get_long(DOC_CODCF);
  TString16 val(doc->get(DOC_CODVAL));
  
  // campi obbligatori
  key.format("%7ld%3s",cli,(const char*)val);
  // campi opzionali
  if (_group_by_date)          
  {
    TString16 d(doc->get(DOC_DATAINSC));

    if (d.empty())
      d = doc->get(DOC_DATADOC);
    key << d;
  }
//  Qual'e' il flag di sospensione d'imposta del documento ??    
//  if (_group_by_sosp)
//    key << _doc->get(DOC_????);
  if (_group_by_change)
    key << doc->get(DOC_CAMBIO);
  if (_group_by_pag)
    key << doc->get(DOC_CODPAG);
  if (_group_by_bank)
  {
    key << doc->get(DOC_CODABIA); // banca cliente
    key << doc->get(DOC_CODCABA);
  }
  if (_group_by_type)
    key << doc->get(DOC_TIPODOC);
  if (_group_by_num)
    key << doc->get(DOC_CODNUM);
  if (_group_by_agent)
    key << doc->get(DOC_CODAG);    
}

void TGenerazioneEffetti_app::build_doc_key(TToken_string& key, TDocumento* doc)
{
  key.add(doc->get(DOC_PROVV));
  key.add(doc->get(DOC_ANNO));
  key.add(doc->get(DOC_CODNUM));
  key.add(doc->get(DOC_NDOC));
}

void TGenerazioneEffetti_app::set_options()
{
  TTable eld("%ELD");
  eld.put("CODTAB",_cod_el);
  if (eld.read() == NOERR)
  {
    TString s1;
    s1.format("%-20s",(const char*)eld.get("S1")); // Forzo la sua lunghezza a 20 per evitare subscript errors
    _group_by_date   = s1[12] == 'X';
    _group_by_sosp   = s1[13] == 'X';
    _group_by_change = s1[0] == 'X';
    _group_by_pag    = s1[4] == 'X';
    _group_by_bank   = s1[5] == 'X';
    _group_by_type   = s1[2] == 'X';
    _group_by_num    = s1[3] == 'X';
    _group_by_agent  = s1[7] == 'X';
  }
}

void TGenerazioneEffetti_app::generate()
{
  TRelation* doc_rel = new TRelation(LF_DOC);
  TRectype *da = new TRectype(LF_DOC);
  TRectype *a  = new TRectype(LF_DOC);
  const long items = _num_sheet->items();
  int year_from = _data_ini.year();
  int year_to = _data_fine.year();
  TString16 codnum;
  TString msg,filt_expr;
  TLista_documenti lista_in,lista_out;
  TGenerazione_effetti* gen_eff = new TGenerazione_effetti(_cod_el);
  TDate data;
  
  _group_array.destroy();
  set_options();
  da->put("DATADOC",_data_ini);
  da->put("PROVV","D");
  da->put("ANNO",year_from);
  a->put("DATADOC",_data_fine);
  a->put("PROVV","D");
  a->put("ANNO",year_to);
  for (long i=0L; i<items;i++)  // Scorre per tutte le numerazioni dello sheet
    if (_num_sheet->checked(i)) // Se la numerazione corrente e' stata selezionata
    {                           // istanzia un cursore per la numerazione corrente, con i limiti di data
      codnum = _num_sheet->row(i).get(1);
      filt_expr = "CODNUM=\"";
      filt_expr << codnum << "\"";
      TCursor doc_cur(doc_rel,filt_expr,3,da,a);
      const long cur_items = doc_cur.items(); // Scorre tutti i documenti che rientrano nell'intervallo selezionato
      if (cur_items == 0) 
      {
        warning_box("Non vi sono effetti da generare per il codice numerazione %s",(const char*)codnum);
        continue;
      }
      msg = "Selezione documenti ";
      msg << codnum << " dal ";
      msg << _data_ini.string() << " al ";
      msg << _data_fine.string();
#ifdef DBG      
      TProgind p(cur_items,msg,TRUE,TRUE,1);
#else
      TProgind p(cur_items,msg,FALSE,TRUE,1);
#endif
      long j = 0;
      // Comportamento:
      // - scorre i documenti della numerazione corrente.
      // - se e' possibile generare subito l'effetto (tipo di pagamento valido,
      //   stato documento valido e non e' abilitato il raggruppamento) lo fa,
      //   altrimenti compone una lista dei documenti da raggruppare
      // - alla fine del ciclo per numerazioni scorre la lista residua e genera gli
      //   effetti rimasti
#ifdef DBG      
      for (;j<cur_items && !p.iscancelled();j++)
#else      
      for (;j<cur_items;j++)
#endif      
      { 
        p.setstatus(j+1);
        doc_cur = j;
        TDocumento* doc = new TDocumento;
        if (doc->read(doc_cur.curr()) == NOERR && // legge il documento
            codnum == doc->get(DOC_CODNUM) && // patch del cazzo
            doc_tipo_stato_ok(doc))    // controlla che il tipo documento e lo stato siano coerenti con la ELD selezionata
        { 
          TPagamento & pag = doc->pagamento();
          if (pag.code().not_empty())
          {
            const bool raggruppabile = doc->get_bool(DOC_RAGGREFF);
            if (!_raggruppa || (_raggruppa && !raggruppabile))
              // Aggiunge alla lista degli effetti da generare singolarmente
              lista_in.add(doc);
            else
            {
              add_to_group_list(doc); // Aggiorna la lista degli effetti da raggruppare
              delete doc;
            }
          }
          else
          {
            int err = change_doc_status(doc); // Cambia lo stato al documento
            if (err != NOERR)
              warning_box("Errore %d tentando di cambiare lo stato del documento %s/%d",err,(const char*)doc->numerazione(),doc->numero());
            delete doc;
          }
        }
        else
          delete doc;
      }
#ifdef DBG      
      if (p.iscancelled()) break;
#endif
    }
  
  gen_eff->set_group(_group_array); // Setta l'elenco dei documenti per generare effetti raggruppati
  gen_eff->elabora(lista_in,lista_out,data); // La data non serve, cosi' come la lista documenti in uscita
  if (gen_eff->bills() > 0L)
    message_box("Totale effetti generati: %ld",gen_eff->bills());
  
  delete doc_rel;
  delete da;
  delete a;
  xvt_statbar_set("");  
}

int ve6300 (int argc, char **argv)
{
  TGenerazioneEffetti_app a;
  a.run(argc,argv,"Generazione effetti");
  return TRUE;
}