campo-sirio/ef/ef0500.cpp

#include <applicat.h> 
#include <form.h>
#include <mask.h>   
#include <relation.h>
#include <utility.h>
#include <urldefid.h>
#include <printer.h>
#include <progind.h>
#include <lffiles.h>
#include <effetti.h>
#include <reffetti.h>
#include "ef0.h"   
#include "ef0301.h"
#include "ef0500.h"

class TRiba_form;
class TDistinta_form;

///////////////////////////////////////////////////////////////////////////////////////////////
// Classe per l'emissione di effetti e distinte su carta o su floppy  // 
///////////////////////////////////////////////////////////////////////////////////////////////
class TEmissione: public TApplication
{
  TMask* _msk;
  TRelation* _firmrel;               // relazione di gestione dei dati della ditta corrente
  TLocalisamfile *_eff, *_reff, *_cession;  
  TRiba_form *_formrb;
  TDistinta_form *_formdse;
  int _base_page_no;                 // numero della pagina base per la stampa del numero di pagina
protected:
  virtual bool create(void);                        
  virtual bool destroy(void) ;                        
  virtual void on_firm_change(void); 
  virtual bool menu(MENU_TAG); 
  void conferma(void);               
  virtual void print_rb(char tipost, int ndist, char tipodist, int ncopie, const bool is_vis);                             
  virtual void print_dse(char tipost, int ndist, char tipodist, int ncopie, const bool is_vis); 
  virtual void print(void); 
  void floppy(void);                 
  void aggiorna_rb(TCursor*);        
  void aggiorna_dist(TCursor*);      
  static bool annulla_handler(TMask_field& f, KEY k);  
public:                                              
  int base_no() { return _base_page_no;}
  TEmissione() {};
  virtual ~TEmissione() {};
};

// restituisce un riferimento all' applicazione
inline TEmissione& app() { return (TEmissione&) main_app();}

/////////////////////////////////////////////////////////////////////////////////////////
// Classe TRiba_form customizzata dalla Form per le Ri.Ba.// 
////////////////////////////////////////////////////////////////////////////////////////
class TRiba_form: public TForm
{ 
protected:  
  virtual bool validate(TForm_item &, TToken_string &); 
public:
  TRiba_form(const char *);
  virtual ~TRiba_form(){};
};

/////////////////////////////////////////////////////////////////////////////////////////////////
// Classe TDistinta_form customizzata dalla Form per le Distinte  //
////////////////////////////////////////////////////////////////////////////////////////////////

class TDistinta_form: public TForm
{ 
  TRelation *_firmrel;               // relazione di gestione dei dati della ditta corrente
  TSorted_cursor *_cursor;           // curosore che permette l'ordinamento degli effetti nella distinta
protected:                           // per data scadenza o per dati fattura
  virtual bool validate(TForm_item &, TToken_string &);   
public:
  void set_order(const char tipo);   // setta l'ordinamento del cursore
  virtual TCursor* cursor() const { return (TCursor*)_cursor;} // restituisce il cursore
  TDistinta_form(const char*, TRelation *);
  virtual ~TDistinta_form();
};
                                
// creazione dell'applicazione
bool TEmissione::create()
{
  TApplication::create();            
  _formrb = NULL;                      // l'inizializzazione avviene nel metodo print()
  _formdse = NULL;                     // a seconda che si stampino le riba o la distinta
  _msk = new TMask("ef0500a");  
  _firmrel= new TRelation(LF_NDITTE);
  _firmrel->add(LF_ANAG, "TIPOA=TIPOA|CODANAGR=CODANAGR");
  _firmrel->add(LF_UNLOC,"CODDITTA=CODDITTA"); // si posiziona sulla prima unita' locale della ditta
  _eff = new TLocalisamfile(LF_EFFETTI);   
  _reff = new TLocalisamfile(LF_REFFETTI);
  _cession = new TLocalisamfile(LF_CESS);
  _msk->set_handler(DLG_CANCEL, annulla_handler); 
  dispatch_e_menu(BAR_ITEM(1)); 
  return TRUE;
}

// distruzione dell'applicazione
bool TEmissione::destroy()
{                      
  if (_formrb) delete _formrb;
  if (_formdse) delete _formdse;      
  delete _msk;  
  delete _firmrel;
  delete _eff;                               
  delete _reff;
  delete _cession;     
  return TApplication::destroy();
}

// carica la ditta corrente
void TEmissione::on_firm_change() 
{
  TLocalisamfile &firmfile= _firmrel->lfile();
  firmfile.put("CODDITTA", get_firm());
  _firmrel->read();
}

// carica la maschera per emissione effetti e  distinte 
bool  TEmissione::menu(MENU_TAG)
{
  KEY key = K_ENTER;                 
  while (key != K_QUIT)              // rimane in esecuzione finch<63> non si chiude la maschera
  {  
    key = _msk->run();               
    if (key == K_ENTER)              // se si confermano i dati inseriti
      conferma();
  }
  return FALSE;
}                              

// gestisce la scelta fra le due possibili emissioni
void TEmissione::conferma()
{
  int tipoemis = _msk->get_int(F_TIPOEMIS);
  if (tipoemis == 1)                 // emissione su floppy      
     floppy();
  else
     print();                        // emissione su carta  
}  
  
// gestione emissione su floppy
void TEmissione::floppy() 
{
}                              

// aggiorna, su file, numero e data di emissione ed il flag di stampa
// su tutti gli effetti nel cursore
void TEmissione::aggiorna_rb(TCursor* cur)  
{                           
  TLocalisamfile &eff = cur->file(LF_EFFETTI);
  for (*cur = 0; cur->pos() < cur->items(); ++(*cur))
  {  
     TEffetto effetto = eff.curr();          
     long numero = effetto.numero();
     effetto.put("NUMEMISS", numero);
     TDate data = _msk->get_date(F_DATAEMIS);
     effetto.put("DATAEMISS", data);
     bool cond = TRUE;
     effetto.put("EFFSTAMP", cond);  
     effetto.rewrite(eff);
  } 
}

// aggiorna, su file, il flag di stampa della distinta   
// su tutti gli effetti nel cursore
void TEmissione::aggiorna_dist(TCursor* cur)
{    
  TLocalisamfile &eff = cur->file(LF_EFFETTI);
  for (*cur = 0; cur->pos() < cur->items(); ++(*cur))
  {  
     TEffetto effetto = eff.curr();          
     bool cond = TRUE;
     effetto.put("DISTSTAM", cond);  
     effetto.rewrite(eff);
  } 
}

// gestione emissione su carta delle riba
void TEmissione::print_rb(char tipost, int ndist, char tipodist, int ncopie, const bool is_vis)
{
  TCursor* fcur = _formrb->cursor();  
  TLocalisamfile &eff = fcur->file(LF_EFFETTI);                     
  TString16 filter;
  if (tipost == 'D')                 // se stampa definitiva effetti
    if (!_msk->get_bool(F_RIST))     // se non deve ristampare le riba
       filter = "EFFSTAMP=\" \"";    // setta il filtro del cursore per ...
  fcur->setfilter(filter,TRUE);      // ... stampare solo gli effetti non ancora stampati
// setta la chiave 4 per il cursore per poter leggere tutti gli effetti della distinta
  fcur->setkey(4);
  TRectype darec(eff.curr());        // fissa  i dati per la scelta degli ...
  darec.zero();                      // ... effetti nel primo e nell'ultimo record del cursore
  darec.put("NDIST", ndist);         
  darec.put("TIPODIST", tipodist);
  TRectype arec(darec);
  fcur->setregion(darec, arec);      
  long n = fcur->items();            
  fcur->freeze();                    // congela lo stato del cursore
// se la stampa non si fa a video istanzia puntatore per la gestione della barra di attesa 
  for (int j=0; j < ncopie; j++)
  {
    TProgind* pi;                       
    if (!is_vis)                      
      pi = new TProgind(n,"Stampa Effetti/Distinte...",FALSE,TRUE,10);
    for (*fcur = 0; fcur->pos() < n; ++(*fcur)) // ciclo sugli elementi del cursore di stampa
    {
      if (!is_vis)
      pi->addstatus(1L);             // aggiorna la barra d'attesa
      _formrb->print();              // stampa il form  
    } 
  }  
  if (tipost == 'D')                 // se emetto riba in definitiva ...
    aggiorna_rb(fcur);               // ... devo aggiornare data, numero emissine e flag di stampa effetto
}

// gestione emissione su carta delle distinte
void TEmissione::print_dse(char tipost, int ndist, char tipodist, int ncopie, const bool is_vis)
{
  TCursor* fcur = _formdse->cursor();   
  TLocalisamfile &eff = fcur->file(LF_EFFETTI); 
// setta la chiave 4 per il cursore per poter leggere tutti gli effetti della distinta    
  TString16 filter;
  fcur->setfilter(filter,TRUE);       
  fcur->setkey(4);
  TRectype darec(eff.curr());        // fissa  i dati per la scelta degli ...
  darec.zero();                      // ... effetti nel primo e nell'ultimo record del cursore
  darec.put("NDIST", ndist);         
  darec.put("TIPODIST", tipodist);
  TRectype arec(darec);
  fcur->setregion(darec, arec);
  long n = fcur->items();   
  fcur->freeze();           // congela lo stato del cursore
// se la stampa non si fa a video istanzia puntatore per la gestione della barra di attesa 
  for (int j=0; j < ncopie; j++)
  {
    TProgind* pi;                       
    if (!is_vis)                      
      pi = new TProgind(n,"Stampa Effetti/Distinte...",FALSE,TRUE,10);
    _base_page_no = 0; 
    if (!is_vis)
      pi->addstatus(1L);             // aggiorna la barra d'attesa
    _formdse->print();              // stampa il form  
    _base_page_no = printer().getcurrentpage() -1; // stampa numero di pagina (solo nella distinta) 
  }  
  if (tipost == 'D')                 // se emetto distinta in definitiva ...
    aggiorna_dist(fcur);             // ... devo aggiornare  flag di stampa distinta 
}                               

// gestione emissione su carta
void TEmissione::print()
{
  int ncopie = _msk->get_int(F_NCOPIE);
  if (ncopie == 0) ncopie = 1;           
  printer().open();                  // apre la stampante
  const bool is_vis = printer().printtype() == screenvis; // TRUE se si stampa a video
  int emis = _msk->get_int(F_EMIS);
  int ndist = _msk->get_int(F_NUMBER);
  char tipodist = _msk->get(F_TIPODIST)[0];
  _eff->put("TIPODIST",tipodist);
  _eff->put("NDIST",ndist);   
  _eff->put("NRIGADIST",1);
  _eff->setkey(4);
  _eff->read();
  long codabi = _eff->get_long("CODABIP");     
  char tipost = _msk->get(F_TIPOST)[0];
  char tipord = _msk->get(F_TIPORD)[0];
// se emetto riba istanzio il form per le riba 
// se emetto distinta istanzio il form per le distinte  
  if (emis == 1)                     // emetto riba 
  {                                  
    TString16 nomeform;
    nomeform.format("rb%05ld.frm",codabi);// compongo il nome del form
    if (!fexist(nomeform))                // ne controllo l'esistenza
       nomeform = "rb.frm";               // se non esiste utilizzo il form generico
    _formrb = new TRiba_form(nomeform);     
    print_rb(tipost,ndist,tipodist,ncopie,is_vis);
  }
  else                               // emetto distinta
  {  
   TString16 nomeform;
    nomeform.format("dse%05ld.frm",codabi);// compongo il nome del form
    if (!fexist(nomeform))                 // ne controllo l'esistenza
       nomeform = "dse.frm";               // se non esiste utilizzo il form generico
    _formdse = new TDistinta_form(nomeform, _firmrel);
    _formdse->set_order(tipord);
    print_dse(tipost,ndist,tipodist,ncopie,is_vis);
  }
  printer().close();                 // chiude la stampante  
}

// handler per gestire la conferma dell'annullamento dei dati inseriti nella maschera       
bool TEmissione::annulla_handler(TMask_field& f, KEY k)
{ 
  TMask &m = f.mask(); 
  if (k == K_SPACE)
  {  
    if (yesno_box("Vuoi veramete annullare i dati inseriti"))
       m.reset(); 
  }       
  return TRUE;
}

// costruttore classe TRiba_form
TRiba_form::TRiba_form(const char* name): TForm()
{
  read(name);
}

// gestione dei messaggi estesi nei campi
bool TRiba_form::validate(TForm_item &cf, TToken_string &s)
{
  const TString code(s.get(0));      // prende il primo parametro, il codice del messaggio
  TString valore;                 
  if (code == "_FATT")     
  {
  // gestione dei campi relativi alle/a fatture/a a cui si riferisce un effetto
  // sintassi: _FATT,<macro>
  // dove: <macro> <20> uno delle macro seguenti:
  //       "!A"         fattura o fatture
  //       "!DATI"      numero e data fattura 
  //       "!IMPFATT"   importo fattura
    TCursor* fcur = cursor(); 
    TLocalisamfile &eff = fcur->file(LF_EFFETTI);                  
    TEffetto effetto = eff.curr();
    long num = effetto.numero();
    bool condition = (effetto.fatt(num));
    TToken_string* dati = effetto.dati_fatt(num);
    TString in(s.get());
    if (in[0]=='!')
    {
      in.ltrim(1);         
  // "!A" se 1 sola fattura stampa 'a' altrimenti stampa 'e'
      if (in == "A") 
      {
        if (condition)
          cf.set("a");
        else           
          cf.set("e");
      }
  // "!DATIFATT" stampa numero e data fattura delle fatture a cui si riferisce l'effetto     
      if (in == "DATIFATT") 
      {
        int elem = dati->items();
        TString descfatt;
        for (int i = 0; i < elem; i+=3)
        {
            descfatt << dati->get(i);
            descfatt << "  ";         
            descfatt << dati->get(i+1);
            descfatt << "  ";
            cf.set(descfatt);
        }  
      }
  // "!IMPFATT" se 1 sola fattura ne stampa l' importo       
      if (in == "IMPFATT") 
      {
        if (condition) 
          cf.set(dati->get(2));
      }
    } 
    valore = cf.get();
    cf.put_paragraph(valore);
    cf.set(""); 
    return (TRUE);
  } // fine _FATT      
  return TForm::validate(cf, s);
}

// costruttore classe TDistinta_form
TDistinta_form::TDistinta_form(const char* name, TRelation *rel): TForm(), _firmrel(rel)
{
  read(name);
  _cursor = NULL;
}

// setta l'ordinamento del TSordet_cursor del form 
void TDistinta_form::set_order(const char tipo)
{
  TString ordine;
  // ordinamento secondo la data di scadenza dell'effetto  
  if (tipo == 'S') ordine  = "DATASCAD|TIPODIST|NDIST|NRIGADIST";
  // ordinamento seconda il numero e la data della fattura  
  else if (tipo == 'F') ordine = "14->NFATT|TIPODIST|NDIST|NRIGADIST";
  
  _cursor = new TSorted_cursor(relation(),ordine);
}

// distruttore classe TDistinta_form
TDistinta_form::~TDistinta_form()
{
  if (_cursor) delete _cursor;
}

// gestione dei messaggi estesi nei campi
bool TDistinta_form::validate(TForm_item &cf, TToken_string &s)
{
  const TString code(s.get(0));      // prende il primo parametro, il codice del messaggio
  TString valore;
  if (code == "_DITTA")
  { 
  // gestione di campi della ditta corrente
  // sintassi: _DITTA,<macro>
  // dove: <macro> <20> uno delle macro seguenti:
  //       "!RAGSOC"     ragione sociale
    TString in(s.get());
    if (in[0]=='!')
    {
      in.ltrim(1);
  // "!RAGSOC" prende la ragione sociale della ditta corrente    
      if (in=="RAGSOC") cf.set(_firmrel->lfile().get("RAGSOC"));
    }
    valore = cf.get();
    cf.put_paragraph(valore);
    cf.set("");
    return (TRUE);
  } // fine _DITTA
  if (code == "_FATT")
  { 
  // gestione dei campi relativi alle fatture a cui si riferisce un effetto
  // sintassi: _FATT,<macro>
  // dove: <macro> <20> uno delle macro seguenti:
  //       "!DATI"      numero e data fattura 
    TCursor* fcur = cursor(); 
    TLocalisamfile &eff = fcur->file(LF_EFFETTI);                  
    TEffetto effetto = eff.curr();
    long num = effetto.numero();
    TToken_string* dati = effetto.dati_fatt(num);
    int elem = dati->items();
    TString descfatt;
    TString in(s.get());  // prende il primo parametro, il codice del messaggio
    if (in[0]=='!')
    {
      in.ltrim(1);
  // "!DATIFATT"  stampa numero e data fattura delle fatture a cui si riferisce l'effetto           
      if (in == "DATIFATT") 
      {
        for (int i = 0; i < elem; i+=3)
        {
           descfatt << dati->get(i);
           descfatt << "  ";         
           descfatt << dati->get(i+1);
           descfatt << "  ";
           cf.set(descfatt);
        }  
      }
    }  
    valore = cf.get();
    cf.put_paragraph(valore);
    cf.set(""); // resetta il campo per la prossima stampa di questo item
    return (TRUE);
  } // fine _FATT
  if (code == "_FOOTER")
  { 
  // gestione dei campi del fondo pagina della distinta
  // sintassi: _FOOTER,<macro>
  // dove: <macro> <20> uno delle macro seguenti:
  //       "!NDOC"     numero riba nella distinta
  //       "!TOTALE"   totale presentato 
    TString in(s.get());             // prende il primo parametro, il codice del messaggio
    if (in[0]=='!')
    {
      in.ltrim(1);
      TCursor* fcur = cursor();
      long i = fcur->items(); 
  //"!NDOC" prende il numero riba nella distinta guardando quanti elementi ha il cursore di  stampa     
      if (in == "NDOC")
        cf.set(format("%ld",i));
  //"!TOTALE" calcola il totale presentato prendendo i totale degli effetti  nel cursore di  stampa           
      if (in == "TOTALE")
      {
        long totale = 0;        
        TLocalisamfile &eff = fcur->file(LF_EFFETTI);
        for (*fcur = 0; fcur->pos() < i; ++(*fcur))
        {  
          TEffetto effetto = eff.curr();
          long imp = effetto.importo(); 
          totale +=imp;
        } 
        cf.set(format("%ld",totale));
      }
    }
    valore = cf.get();
    cf.put_paragraph(valore);
    cf.set(""); 
    return (TRUE);
  } // fine _FOOTER
  if (code== "_PAGENO")
  {  
  // messaggio per stampare il numero di pagina corrente
    TString16 pg; pg << int(printer().getcurrentpage() - app().base_no());
    cf.set(pg); cf.put_paragraph(pg);
    cf.set("");
  }
  return TForm::validate(cf, s);
}

int ef0500(int argc, char* argv[])
{
  TEmissione a ;
  a.run(argc, argv, "Emissione Effetti e Distinte");
  return 0;
}