campo-sirio/ve/ve1100.cpp

#include <applicat.h>
#include <config.h>
#include <form.h>
#include <mask.h>   
#include <printer.h>
#include <relation.h>
#include <strings.h>
#include <expr.h>
#include <tabutil.h>
#include <urldefid.h>
#include <utility.h>

// !! fatto (in ordine d'esecuzione):
// !! ------------------------------
// !! - lettura parametri linea di comando per eventuale esecuzione batch
// !! - impostazione di flag di interattivit<69> posto a true se non ci sono parametri sulla linea
// !!   di comando; influisce su:
// !!   - apertura maschera richiesta dati
// !!   - richiesta di stampa definitiva
// !!   - richiesta d'interruzione in caso di stato non valido durante stampa definitiva
// !!   - interruzione forzata in caso di impossibilit<69> di rinumerazione definitiva
// !! - impostazione di flag di stampa definitiva (da linea di comando o richiesta con box);
// !!   influisce su:
// !!   - controllo stati durante la stampa
// !!   - lancio della procedura di rinumerazione definitiva
// !! - lettura tabelle codice numerazione e tipo documento
// !! - lancio batch della stampa se sono presenti i parametri sulla linea di comando
// !! - creazione e apertura della maschera e lettura dati
// !! - impostazione della regione del cursore del form
// !! - ciclo di lettura del form con stampa della posizione corrente e lancio (eventuale)
// !!   della rinumerazione
// !! - intercettazione dei seguenti messaggi custom nel form:
// !!   - _ISAMREAD per letture generiche dal database
// !!   - _TABLEREAD per lettura generiche da tabelle del database
// !!   - _DITTA per ottenere dati di configurazione sulla ditta in uso
// !!   - _CIFRELETTERE per la conversione di un valore in lettere
// !! - chiusura applicazione

// !! da fare:                                       
// !! -------
// !! - verificare le messaggistiche verso l'utente e il controllo dell'interattivit<69>
// !! - aggiungere lettura del tipo di modulo dal form (quando sar<61> fatto)
// !! - completare routine di scelta di cosa fare al cambio del modulo
// !! - aggiungere tutti gli altri messaggi di gestione dei documenti di vendita (clienti,
// !!   totalizzatori, calcoli, ecc.)
// !! - tutto il resto!



#include "ve1100.h"
#include "ve0100b.h"



////////////////////////////////////////////////////////////////////////////
// classe TDocVen_Form customizzata dalla Form per i documenti di vendita
////////////////////////////////////////////////////////////////////////////

class TDocVen_Form: public TForm { 
  TRelation &_firmrel; // relazione di gestione dei dati della ditta corrente
protected:
  virtual bool validate(TForm_item &, TToken_string &);
public:
  TDocVen_Form(const char *, TRelation &);
};



TDocVen_Form::TDocVen_Form(const char* name, TRelation &rel): TForm(name), _firmrel(rel) {}

bool TDocVen_Form::validate(TForm_item &cf, TToken_string &s) {
  const TString code(s.get(0)); // prende il primo parametro, il codice del messaggio

  if (code== "_ISAMREAD") {
    // lettura generica di un file del database
    // sintassi: _ISAMREAD <file> <espressione input>,<espressione input>,... <espressione output>,<espressione output>,...
    // dove: <file> <20> il numero logico del file o il nome della tabella
    //       <espressione input> <20> un'espressione del tipo <campo file>=<espressione campi form>
    //       <espressione campi form> <20> un'espressione di costanti numeriche, stringhe e valori di campi della form (indicati con il loro numero preceduto da #)
    //       <espressione output> <20> un'espressione del tipo <campo form o gruppo>=<campo file> (se <20> un gruppo deve essere seguito da @) oppure solo <campo file> (il campo della form <20> quello corrente)
    int i, j, poseq, posrv, itms;
    pagetype pt;
    char sec;
    TLocalisamfile *file;
    TString f_code(s.get()); // prende il codice del file da leggere
    if (atoi(f_code) != 0) file= new TLocalisamfile(atoi(f_code)); // se il codice <20> numerico allora <20> un file
    else file= new TTable(f_code); // altrimenti <20> una tabella
    TToken_string in(s.get(), ',');
    for (i=0; i<in.items(); i++) { // scansione sugli elementi dell'input
      TString curr(in.get(i));
      poseq= curr.find("=="); // divide la stringa corrente in lvalue e rvalue
      if (poseq== -1) {
        poseq= curr.find('=');
        if (poseq != -1) posrv= poseq+1;
      } else posrv= poseq+2;
      const TString &fld= curr.left(poseq); // preleva il nome del campo del file alla sinistra dell'uguale
      const TString &expr= curr.mid(posrv); // preleva l'espressione di assegnamento alla destra dell'uguale
      TExpression rval(expr, _strexpr);
      for (j=0; j<rval.numvar(); j++) { // scansione delle variabili dell'espressione di rvalue
        TString var= rval.varname(j);
        if (var[0]=='#') var.ltrim(1); // rimuove dalla stringa il primo carattere
        TForm_item &fi= cf.find_field(var);
        rval.setvar(j, fi.get()); // il valore corrente del campo viene settato nell'espressione
      }
      file->put(fld, (const char *)rval); // scrive il risultato dell'espressione nel campo del file
    }
    if (file->read()== NOERR) { // tenta una lettura del file
      TToken_string out(s.get(), ',');
      for (i=0; i<out.items(); i++) { // scansione sugli elementi dell'output
        TString curr(out.get(i));
        poseq= curr.find("=="); // divide la stringa corrente in lvalue e rvalue
        if (poseq== -1) {
          poseq= curr.find('=');
          if (poseq != -1) posrv= poseq+1;
        } else posrv= poseq+2;
        if (poseq== -1) {
          const TString &dat= file->get(curr); // preleva il nome del campo del file e lo legge dal record
          cf.set(dat); // setta il campo letto dal file nel campo corrente della form   
        } else {
          TString fld= curr.left(poseq); // preleva il nome del campo del form alla sinistra dell'uguale
          const TString &dat= file->get(curr.mid(posrv)); // preleva il nome del campo del file alla destra dell'uguale e lo legge dal record
          if (fld[0]=='#') fld.ltrim(1);
          if (fld.right(1)== "@") { // se c'<27> la a-commerciale <20> un gruppo
            if (fld.find("->") != -1) { // se nel gruppo c'<27> la freccia si riferisce ad un'altra sezione
              sec= fld[0];
              if (fld[1] != '-') pt= char2page(fld[1]);
              else pt= even_page;
              itms= section(sec, pt).fields();
            } else { // altrimenti si riferisce alla sezione corrente
              sec= cf.section().section_type();
              pt= cf.section().page_type();
              itms= cf.section().fields();
            }
            for (j=0; j<itms; j++) { // per ogni campo della sezione specificata (o sottointesa)...
              TForm_item &fi= section(sec, pt).field(j);
              fi.set(dat); // ...il contenuto viene settato al valore del file
            }
          } else {
            TForm_item &fi= cf.find_field(fld);
            fi.set(dat);
          }
        }
      }
    }
    delete file;
    return (TRUE);
  } // fine _ISAMREAD

  if (code== "_TABLEREAD") {
    // lettura generica di un campo di una tabella
    // sintassi: _TABLEREAD <tabella> <chiave> <campo file>
    // dove: <tabella> nome tabella da leggere
    //       <chiave> costante stringa o riferimento a campo della form (preceduto da '#') da usare come chiave di ricerca
    //       <campo file> identificativo del campo da leggere dalla tabella
    TTable tab(s.get()); // prende il nome della tabella
    TString in(s.get()); // prende il valore o il campo da usare come codice di ricerca
    if (in.left(1)== '#') {
      in.ltrim(1);
      TForm_item &fi= cf.find_field(in);
      in= fi.get();
    }
    tab.put("CODTAB", in); // setta la chiave nella tabella
    if (tab.read()== NOERR) {
      const TString &fld= s.get(); // prende il nome del campo da leggere...
      cf.set(tab.get(fld)); // ...e lo scrive nel campo del form
    }
    return (TRUE);
  } // fine _TABLEREAD

  if (code== "_DITTA") {
    // lettura dei dati della ditta
    // sintassi: _DITTA {<campo relazione>|<macro>}
    // dove: <campo relazione> <20> un riferimento alla relazione di gestione dei dati della ditta (es. 113@->DENCOM <20> la denominazione del comune di residenza della ditta)
    //       <macro> <20> uno delle macro seguenti:
    //         &RAGSOC  ragione sociale
    //         &IND     indirizzo (fiscale se c'<27>, oppure di residenza)
    //         &NUM     numero civico (fiscale se c'<27>, oppure di residenza)
    //         &CAP     CAP (fiscale se c'<27>, oppure di residenza)
    //         &COM     comune (fiscale se c'<27>, oppure di residenza)
    //         &IVA     partita iva
    //         &CF      codice fiscale
    //         &TEL     numero di telefono (con prefisso)
    //         &FAX     numero di fax (con prefisso)
    // nota: la relazione di della ditta <20> cos<6F> strutturata:
    //       %NDITTE (9) Dati ditte
    //       + %ANAGR (6) Anagrafica generale (indirizzo, ecc.)
    //          + %COMUNI (113@) Comune di residenza
    //          + %COMUNI (213@) Comune di residenza fiscale
    TString in(s.get());
    if (in[0]=='&') {
      in.ltrim(1);
      bool _fisc= _firmrel.lfile(6).get("INDRF").not_empty();
      if (in=="RAGSOC") cf.set(_firmrel.lfile().get("RAGSOC"));
      if (in=="IND") {
        if (_fisc) cf.set(_firmrel.lfile(6).get("INDRF"));
        else cf.set(_firmrel.lfile(6).get("INDRES"));
      }
      if (in=="NUM") {
        if (_fisc) cf.set(_firmrel.lfile(6).get("CIVRF"));
        else cf.set(_firmrel.lfile(6).get("CIVRES"));
      }
      if (in=="CAP") {
        if (_fisc) cf.set(_firmrel.lfile(6).get("CAPRF"));
        else cf.set(_firmrel.lfile(6).get("CAPRES"));
      }
      if (in=="COM") {
        if (_fisc) cf.set(_firmrel.lfile(-213).get("DENCOM"));
        else cf.set(_firmrel.lfile(-113).get("DENCOM"));
      }
      if (in=="IVA") cf.set(_firmrel.lfile(6).get("PAIV"));
      if (in=="CF") cf.set(_firmrel.lfile(6).get("COFI"));
      if (in=="TEL") {
        TString tel(_firmrel.lfile().get("PTEL"));
        tel << "/" << _firmrel.lfile().get("TEL");
        cf.set(tel);
      }
      if (in=="FAX") {
        TString tel(_firmrel.lfile().get("PFAX"));
        tel << "/" << _firmrel.lfile().get("FAX");
        cf.set(tel);
      }
    } else {
      TFieldref fref(s.get(), 0);
      cf.set(fref.read(&_firmrel));
    }
    return (TRUE);
  } // fine _DITTA

  if (code== "_CIFRELETTERE") {
    // conversione di un reale da cifre a lettere
    // sintassi: _CIFRELETTERE [<campo form>]
    // dove: <campo form> <20> il campo della form (preceduto da '#') da cui prendere il valore, se non <20> specificato <20> sottointeso il campo corrente
    // nota: prende il valore del campo specificato e scrive la sua conversione in lettere nel campo corrente
    TString in;
    if (s.items()==2) {
      in= s.get();
      if (in.left(1)== '#') in.ltrim(1);
      TForm_item &fi= cf.find_field(in);
      in= fi.get();
    } else in= cf.get();
    real n(in);
    cf.set(n.string("LETTERE"));
    return (TRUE);
  } // fine _CIFRELETTERE

  return TForm::validate(cf, s); // se il codice del messaggio non <20> identificato viene passato alla funzione standard
}



//////////////////////////////////////////////////////////////////////////////////////////////
// classe TStampa_Doc_Vendita customizzata dalla TApplication per l'applicazione principale
//////////////////////////////////////////////////////////////////////////////////////////////

enum behaviour {
  skip,
  go,
  cancel
  };



class TStampa_Doc_Vendita: public TApplication {
  TString _codnum; // codice di numerazione
  TString _provv; // stampa provvisioria
  int _anno; // anno della documentazione
  long _dalnum, _alnum; // estremi di numerazione dei documenti
  bool _interattivo; // flag che indica se il prog. funziona in interattivo o in batch
  bool _definitiva; // flag che indica se la stampa <20> definitiva o no
  TRelation *_firmrel; // puntatore alla relazione che gestisce i dati della ditta corrente
protected:
  virtual bool create(void);
  virtual bool destroy(void);
  virtual bool menu(MENU_TAG);
  int select(void);
  virtual void print(void);
  virtual void on_firm_change(void);
  virtual behaviour on_module_change(const TString &); // funzione chiamata ad ogni cambio modulo durante la stampa
  virtual bool query_final_print(void); // funzione chiamata all'inizializzazione per sapere se la stampa <20> definitiva
};



bool TStampa_Doc_Vendita::create() {
  TApplication::create();
  _firmrel= new TRelation(LF_NDITTE); // istanziamento e impostazione della relazione di gestione della ditta corrente
  _firmrel->add(LF_ANAG, "TIPOA=TIPOA|CODANAGR=CODANAGR");
  _firmrel->add(LF_COMUNI, "COM=COMRES", 1, LF_ANAG, 100+LF_COMUNI);
  _firmrel->add(LF_COMUNI, "COM=COMRF", 1, LF_ANAG, 200+LF_COMUNI);
  if (argc()>2) { // lettura dei parametri iniziali dalla linea di comando
    _codnum= argv(2); // il primo parametro <20> il codice di numerazione
    _anno= atoi(argv(3)); // il secondo <20> l'anno
    _provv= argv(4); // il terzo <20> il flag di numerazione provvisoria
    _dalnum= atol(argv(5)); // il quarto <20> il numero di documento di partenza
    _alnum= atol(argv(6)); // il quinto <20> il numero di documento di fine
    _interattivo= FALSE;
    print();
  } else { // oppure lancio della maschera
    _interattivo= TRUE;
    dispatch_e_menu(BAR_ITEM(1));
  }
  return TRUE;
}

bool TStampa_Doc_Vendita::destroy() {
  delete _firmrel; // distruzione della relazione di gestione della ditta corrente
  return TApplication::destroy();
}

void TStampa_Doc_Vendita::on_firm_change() {
  TLocalisamfile &firmfile= _firmrel->lfile();
  firmfile.put("CODDITTA", get_firm());
  _firmrel->read();
}

int TStampa_Doc_Vendita::select() {
  TMask m("ve1100a");
  if (m.run() == K_ENTER) {
    _codnum= m.get(F_CODNUM); // lettura dei dati dalla maschera
    _anno= m.get_int(F_ANNO);
    //_provv= (m.get_bool(F_PROVV))?("P"):("D");
    _provv = m.get(F_PROVV);
    _dalnum= m.get_long(F_DA_NDOC);
    _alnum= m.get_long(F_A_NDOC);
    return 1;
  } else return 0; // 0 indica che non si <20> usciti con "Conferma" dalla maschera
}

bool TStampa_Doc_Vendita::menu(MENU_TAG) { // procedura di dispatch dei menu
  int s;
  while ((s= select()) != 0) if (s==1) print(); // se la selezione della maschera ritorna 1 viene lanciata la stampa
  return FALSE;
}

void TStampa_Doc_Vendita::print() {
    _definitiva= query_final_print();     // legge il flag di stampa definitiva
  printer().open();                                     // apre la stampante
  TFilename nomeform, profilo;          // istanzia le stringhe per il nome del form di stampa e del profilo di configurazione
  TString modulo, modulo_prec;          // istanzia le stringhe per l'inseguimento del modulo di carta
  //TToken_string stati("",',');                // token string con gli stati validi dei documenti
  TTable tip("%TIP");                           // istanzia la tabella dei tipi di documento per i profili
  TRelation rel(LF_DOC);                        // istanzia la relazione sul file principale
  TLocalisamfile &doc= rel.lfile();     // prende il riferimento al file principale
  TCursor cur(&rel);                            // crea il cursore principale dalla relazione
  doc.put("CODNUM", _codnum);           // compone la chiave per il record di inizio cursore
  doc.put("ANNO", _anno);
  doc.put("PROVV", _provv);
  doc.put("NDOC", _dalnum);
  doc.read();                                           // posiziona il file sul record
  TRectype darec= doc.curr();           // copia il record di inizio cursore
  doc.put("NDOC", _alnum);                      // compone la chiave per il record di fine cursore
  doc.read();                                           // posiziona il file sul record
  TRectype arec= doc.curr();            // copia il record di fine cursore
  cur.setregion(darec, arec);           // imposta il filtro sul cursore di stampa
  for (int i= 0; i<cur.items(); i++)// ciclo sugli elementi del cursore di stampa
  {
    cur= i;                     // posiziona il cursore
    tip.put("CODTAB", doc.get("TIPODOC")); // posiziona la tabella dei tipi di documento
    int err=tip.read();
    if (err==NOERR)                     // legge la tabella
    {
      nomeform= tip.get("S5");          // legge il nome del form di stampa
      profilo= tip.get("S4");           // legge il nome del profilo di configurazione
      profilo.ext("ini");
      TConfig config(profilo, "STAMPA"); // apre il file di configurazione del profilo
      TToken_string stati ((const char*)config.get("STATIVALIDI"), ','); // legge gli stati validi di questo tipo di documento
      if (_definitiva && (stati.get_pos(doc.get("STATO"))== -1))        // se lo stato del doc. corrente non <20> valido...
      {
        if (_interattivo) error_box("Non <20> possibile stampare un documento con stato non valido"); // ...viene mostrato un messaggio (solo in modo interattivo)...
        break; // ...e la stampa viene interrotta
              }
              behaviour whattodo= go; // istanzia la variabile di comportamento
            TDocVen_Form f(nomeform, *_firmrel); // istanzia il form
            // !! modulo= f.get_module_code(); // legge dal form il codice del modulo di carta per la stampa
            if (modulo_prec.empty()) modulo_prec= modulo; // se siamo al primo passaggio la variabile di modulo precedente viene riempita
            if (modulo != modulo_prec) whattodo= on_module_change(modulo); // se il modulo <20> cambiato dalla stampa precedente interroga la funzione per sapere che comportamento tenere
            if (whattodo==cancel)             // se non si pu<70> procedere la stampa viene interrotta
              break;
            else if (whattodo==go)            // altrimenti prosegue
            {
              TCursor &fcur= *(f.cursor()); // ricava il riferimento al cursore originale del form
              darec= arec= doc.curr(); // prepara i record per il filtro
              fcur.setregion(darec, arec); // setta il filtro sul form (solo il record corrente)
              f.print(0,0); // stampa il record corrente del form
              if (_definitiva && (numerazione_definitiva(doc) != NOERR))      // se la stampa <20> definitiva viene lanciata la procedura di rinumerazione
              {
                if (_interattivo) error_box("Non <20> possibile completare la procedura di numerazione definitiva dei documenti");
                break;
              }
                }
              }
            else
            {
              // error_box("Il documento corrente non pu<70> essere trovato nella tabella dei tipi di documento");
              error_box ("Errore %d leggendo da %TIP.", err);
              break;
            }
          }
        printer().close(); // chiude la stampante
      }

      behaviour TStampa_Doc_Vendita::on_module_change(const TString &modulo) {
        // !! qui va messa la reazione al cambio di modulo
        // !! - se non si <20> in interattivo bisogna, immagino, ritornare sempre "skip"
        // !! - se si <20> in interattivo bisogna chiedere all'utente il da farsi, eventualmente
        // !!   fornendo il nome esteso del modulo da inserire facendo una seek sulla tabella
        return skip;
      }

      bool TStampa_Doc_Vendita::query_final_print() {
        if (_interattivo) { // se siamo in interattivo viene richiesto all'utente se la stampa <20> definitiva o meno
          if (yesno_box("E' una stampa definitiva?")) return TRUE;
          else return FALSE;
        } else return (strcmp(argv(7), "D")==0); // altrimenti lo legge dalla linea di comando
      }



      int ve1100(int argc, char* argv[]) {
        TStampa_Doc_Vendita a;
        a.run(argc, argv, "Stampa documenti di vendita");
        return (0);
      }