campo-sirio/mg/mg4300.cpp

#include <applicat.h>
#include <tabutil.h>
#include <printapp.h>

#include "anamag.h"
#include "mag.h"
#include "stomag.h"
#include "umart.h"

#include "..\ve\veconf.h"
#include "mglib.h"
#include "mg4300.h"
#include "mg4frm.h"

class TRegistro_giornalemag : public TRegistro_std
{           
public:
  int freq_stampa() const { return get_int("I3"); } 
  bool raggruppato() const { return get_int("B1"); }
  bool ragg_mag() const { return get_int("B2"); }
  bool ragg_giac() const { return get_int("B3"); }
  bool ragg_clafis() const { return get_int("B4"); }
  bool ragg_grpfis() const { return get_int("B5"); }
  bool ragg_caus() const { return get_int("B6"); }

  int last_numreg() const { return get_int("I4"); }
  void set_last_numreg(long n) { put("I4",n); }
  // data ultima stampa esercizio precedente
  TDate last_print_prec() const { return get_date("D4"); }
  // pagina ultima stampa esercizio precedente
  int pag_stampate_prec() const{ return get_int("I6"); }

  TRegistro_giornalemag(const char* code = "", int year = 0);  
  virtual ~TRegistro_giornalemag() {}
};


// ************************************************
// TEMP!!!!!!!!!!!!!!!!
TRegistro_giornalemag::
  TRegistro_giornalemag(const char* cod, int year) 
    :TRegistro_std(cod,year)
{
  if (tipo()!=TIPOREG_GIOMAG)
    fatal_box("Il registro richiesto non è relativo ad un libro giornale di magazzino");
}


class TGiornalemag : public TForm_stampemg
{
  static TDate dadata;
  static TDate adata;
  static int freq_stampa;
  static bool stampa_def;
  static bool ragg_mag;
  static bool ragg_articoli;
  static bool ragg_classi;
  static bool ragg_raggart;
  static bool ragg_caus;
  static TCursor * cur;
  static TAssoc_array _cod_magazzini;
  static int _annoes;

  long last_num_reg;
  word last_pag_stampata;
  TConfig *conf_ditta;
  TArticolo_giacenza * _curr_art;
  TString16 _codlist,_catven;
  TRegistro_giornalemag *_reg_giorn;

private:
  TArticolo_giacenza &curr_art();

static const char * get_fiscfield(TVariable_rectype & r);
static const char * get_cronofield(TVariable_rectype & r);
static bool filter_func(const TRelation* r);

protected:
  void add_mag(TRectype & magrec,const char * codreg);
public:
  void set_parametri(TMask & m);
  bool can_be_printed();

  bool validate(TForm_item &cf, TToken_string &s);

  TGiornalemag(const char *name,const char *code) ;
  ~TGiornalemag();
};

TArticolo_giacenza &TGiornalemag::curr_art()
{
  TRectype & magrec=relation()->lfile(LF_MAG).curr();
  if (_curr_art==NULL || _curr_art->codice()!=magrec.get(MAG_CODART) ) {
    if (_curr_art) delete _curr_art;
    _curr_art=new TArticolo_giacenza(magrec.get(MAG_CODART));
  }
  return *_curr_art;
}

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

  if (code=="_USER") {
    subcode=s.get();

    if (subcode== "INTEST_REG")   {
      cf.set(_reg_giorn->intest());
      return TRUE;
    
    } else if (subcode== "INTEST_DITTA")  {
      if (!_reg_giorn->stampa_intditta()) return TRUE;
      s="_DITTA,!RAGSOC";

    } else if (subcode== "PAGENO")  {
      valore << (int)(last_pag_stampata+printer().getcurrentpage());
      cf.set(valore);
      return TRUE;

    } else if (subcode== "NUMREGST")  {
      valore << last_num_reg;
      cf.set(valore);
      return TRUE;

    } else if (subcode=="INCNUMREGST")    {
      last_num_reg=max(last_num_reg,_reg_giorn->last_numreg())+1;
      if (stampa_def)
      {
        _reg_giorn->set_last_numreg(last_num_reg);
        _reg_giorn->rewrite();
      }
      return TRUE;

    } else if (subcode== "REGISTRASTAMPA") {
      TRectype & movr=cursor()->relation()->lfile(LF_MOVMAG).curr();
      if ((1 || movr.get_long("NUMREGST")<=last_num_reg )&& stampa_def)
      {
        // movimento ancora da registrare
        movr.put("NUMREGST",last_num_reg+1);
        cursor()->relation()->lfile(LF_MOVMAG).rewrite();

        _reg_giorn->set_pag_stampate(last_pag_stampata+printer().getcurrentpage());
        _reg_giorn->set_last_print(TDate(TODAY));
        _reg_giorn->rewrite();
      } 

    } else if (subcode== "INFO_CRONO") {
      TDate datamov(cursor()->relation()->lfile(LF_MOVMAG).get_date("DATAREG"));
      switch (freq_stampa ) {
        case 0:
          valore.format("%7g Movimento del %s ",  (double)last_num_reg+1, (const char *)datamov.string());
          valore << cursor()->relation()->lfile(LF_MOVMAG).get("DESCR");
        break;
        default:
          valore.format("%7g Movimenti di %s, dal %d al %d", (double)last_num_reg+1, 
            (const char *)itom(datamov.month()),
            (int)((datamov.day()-1)/freq_stampa)*freq_stampa+1,
            (int)min(((datamov.day()-1)/freq_stampa+1)*freq_stampa,TDate::last_day(datamov.month(),datamov.year()))  );
        break;
      }
      cf.set(valore);
      return TRUE;

    } else if (subcode== "INFO_FISC") {
      valore.cut(0);
      if (!ragg_mag)
      {
        vv=cursor()->relation()->lfile(LF_RMOVMAG).get("CODMAG");
        valore << "Mag." << vv.mid(0,3);
        vv=vv.mid(3,2);
        if (vv.not_empty())
          valore << '-' << vv ;
        else
          valore << "   " ;
        valore  << ' ';
      } 
      if (ragg_articoli)
      {
        valore << "Art." << cursor()->relation()->lfile(LF_ANAMAG).get(ANAMAG_CODART) << ' ';
      } else {
        if (ragg_classi)
        {
          valore << "Classe fiscale " << cursor()->relation()->lfile(LF_ANAMAG).get(ANAMAG_CLASSEFIS) << ' ';
          if (ragg_raggart)
          {
            valore << " ragg. " << cursor()->relation()->lfile(LF_ANAMAG).get(ANAMAG_RAGGFIS) << ' ';
          }
        } else {
          vv.cut(0);
          if (!ragg_caus && freq_stampa==0)
          {
            //valore << "Mov." << cursor()->relation()->lfile(LF_RMOVMAG).get("NUMREG") << "/";
            //valore << cursor()->relation()->lfile(LF_RMOVMAG).get("NRIG");
          } 
          vv << "Art. " << cursor()->relation()->lfile(LF_ANAMAG).get(ANAMAG_CODART);
          vv << ' ' << cursor()->relation()->lfile(LF_RMOVMAG).get("LIVGIAC") << ' ';
        }
      }
      if (ragg_caus)
      {
        TString16 raggcau(cur->relation()->lfile(-ALIAS_CAUSALI).get("S8"));
        if (raggcau.blank())
          valore << "Causali varie " ;
        else
          valore << "Causali gruppo " << raggcau << ' ';
      }
      valore << vv;
      cf.set(valore);
      return TRUE;
    }
  }
  return TForm_stampemg::validate(cf, s);
}


const char * TGiornalemag::get_cronofield(TVariable_rectype & r)
{
  static TString80 valore;
  TDate datamov(cur->relation()->lfile(LF_MOVMAG).get_date("DATAREG"));
  long numreg=cur->relation()->lfile(LF_MOVMAG).get_int("NUMREG");
    
  // gestione frequenza
  valore.cut(0);
  switch (freq_stampa ) {
    case 0:
      valore.format("%4d%2d%2d%7d",datamov.year(),
        datamov.month(),
        datamov.day(),
        numreg);
    break;
    default:
      valore.format("%4d%2d%2d",datamov.year(),
        datamov.month(),
        (int)(datamov.day()/freq_stampa));
  }
  return valore;
}

const char * TGiornalemag::get_fiscfield(TVariable_rectype & r)
{
  static TString80 valore;
  TString vv;

  valore.cut(0);
  // gestione ragruppamenti
  if (!ragg_mag)
  {
    valore.format("%-15s",(const char *)cur->relation()->lfile(LF_RMOVMAG).get("CODMAG"));
  }
  if (ragg_articoli)
  {
    valore << cur->relation()->lfile(LF_ANAMAG).get(ANAMAG_CODART);
  } else {
    if (ragg_classi)
    {
      valore << cur->relation()->lfile(LF_ANAMAG).get(ANAMAG_CLASSEFIS);
      if (ragg_raggart)
      {
        valore << cur->relation()->lfile(LF_ANAMAG).get(ANAMAG_RAGGFIS);
      }
    } else {
      if (!ragg_caus && freq_stampa==0) {
        vv.format("%4d",cur->relation()->lfile(LF_RMOVMAG).get_int("NRIG"));
      } else {
        TString c1(cur->relation()->lfile(LF_ANAMAG).get(ANAMAG_CODART));
        TString c2(cur->relation()->lfile(LF_RMOVMAG).get("LIVGIAC"));
        vv.format("%-20s%-15s", (const char *)c1,(const char *)c2 );
      }
    }
  }
  if (ragg_caus)
  {
    valore << cur->relation()->lfile(-ALIAS_CAUSALI).get("S8");
  }
  valore << vv;
  return valore;
}



void TGiornalemag::set_parametri(TMask & m)
{
  // set static variables
  dadata=m.get_date(F_DATAIN);
  adata=m.get_date(F_DATAFIN);
  freq_stampa = m.get_int(F_FREQ);
  stampa_def = (*m.get(F_DEFINITIVA) == 'D');
  ragg_mag = m.get_bool(F_RAGGMAG);
  ragg_articoli = m.get_bool(F_RAGGARTICOLI );
  ragg_classi = m.get_bool(F_CLASSEFISART );
  ragg_raggart = m.get_bool(F_RAGGFISART );
  ragg_caus = m.get_bool(F_RAGGCAUS );
  _annoes=m.get_int(F_ANNOES);
  cur=cursor();
  // load Tregistro
  if (_reg_giorn) delete _reg_giorn;
  _reg_giorn= new TRegistro_giornalemag(m.get(F_CODREG),m.get_int(F_ANNOES));
  last_pag_stampata=_reg_giorn->pag_stampate();
  last_num_reg=_reg_giorn->last_numreg();

  // show/hide sections
  find_field('B',odd_page,"HEADER_RAGG_FISC").show(
    ragg_articoli || ragg_classi || ragg_caus);
  find_field('B',odd_page,"HEADER_MOV").show(freq_stampa==0);


  TVariable_rectype *vrec_rmov= new TVariable_rectype(LF_RMOVMAG);
  vrec_rmov->add_field(new TVariable_field ("CRONO_FIELD",get_cronofield,32));
  vrec_rmov->add_field(new TVariable_field ("FISC_FIELD",get_fiscfield,48));
    
  cursor()->relation()->lfile().set_curr(vrec_rmov);

  // inserisce tutti i magazzini collegati
  TTable mag("MAG"); 
  _cod_magazzini.destroy();
  mag.first();
  while (!mag.eof())
  {
    TString16 codmag(mag.get("CODTAB").left(3));
    if (mag.get("CODTAB")==codmag)
      if (mag.get("S8")==m.get(F_CODREG))
        _cod_magazzini.add(codmag);
    mag.next();
  }

  // setta il filtro sui magazzini di questo giornale
  cursor()->set_filterfunction(filter_func,TRUE);
}


// unused : ora i magazzini hanno l'indicazione esplicita del registro
// aggiungeva in un array i vari codici di giornale mag usati
void TGiornalemag::add_mag(TRectype & magrec,const char * codreg)
{
  TString16 codmag(magrec.get("CODTAB").left(3));
  if (magrec.get("CODTAB")==codmag)
  {
    if (_cod_magazzini.is_key(codmag)) return;
    if (magrec.get_int("I2")==1) 
    {
      // Indicazione di magazzino
      TTable mag("MAG"); 
      mag.put("CODTAB",magrec.get("S6"));
      mag.read();
      add_mag(mag.curr(),codreg);           
    } else {                  
      // Indicazione di libro giornale
      if (magrec.get("S8")==codreg)
        _cod_magazzini.add(codmag);
    }
  }
}


bool TGiornalemag::filter_func(const TRelation* r)
{
  bool rval;
  TCausale_magazzino & causmov=(TCausale_magazzino & )r->lfile(-ALIAS_CAUSALI).curr();
  TCausale_magazzino & causrig=(TCausale_magazzino & )r->lfile(-ALIAS_CAUSALIR).curr();
  rval = r->lfile(LF_MOVMAG).get_date("DATAREG").year()==_annoes;
  rval &=_cod_magazzini.is_key(r->lfile(LF_RMOVMAG).get("CODMAG").left(3));
  if (!dadata.empty()) rval &=r->lfile(LF_MOVMAG).get_date("DATAREG")>=dadata;
  if (!adata.empty()) rval &=r->lfile(LF_MOVMAG).get_date("DATAREG")<=adata;
  // considera solo le causali "fiscali"
  rval &=causrig.codice().not_empty() ? 
    causrig.is_fiscale(): causmov.is_fiscale();
  return rval;
}

bool TGiornalemag::can_be_printed()
{
  if (stampa_def) 
  {
    TLocalisamfile mov(LF_MOVMAG);
    mov.setkey(3);
    mov.put("DATAREG",dadata);
    mov.read();
    mov.prev();
    if (!mov.eof() || mov.get("NUMREGST")!=_reg_giorn->last_numreg())
      return FALSE;
  }
  return TRUE;
}


TGiornalemag::TGiornalemag(const char *name,const char *code) :
  TForm_stampemg(name,code),_curr_art(NULL),
  last_pag_stampata(0),last_num_reg(0),_reg_giorn(NULL)
{
}


TGiornalemag::~TGiornalemag()
{
  if (_curr_art) delete _curr_art;
  if (_reg_giorn) delete _reg_giorn;

}

// dichiarazioni degli static
TDate TGiornalemag::dadata;
TDate TGiornalemag::adata;
int   TGiornalemag::freq_stampa;
bool TGiornalemag::ragg_mag;
bool TGiornalemag::stampa_def;
bool TGiornalemag::ragg_articoli;
bool TGiornalemag::ragg_classi;
bool TGiornalemag::ragg_raggart;
bool TGiornalemag::ragg_caus;
TCursor * TGiornalemag::cur;
TAssoc_array TGiornalemag::_cod_magazzini;
int TGiornalemag::_annoes;


// STAMPA giornale
class TStampa_giornalemag : public TSkeleton_application
{

  TArray * _files;
  TStampemg_mask * _mask;
  TGiornalemag * _giorn_mag; // to be moved into TPrint_application
  TCursor * _cur;

protected:
  virtual bool create();
  virtual bool destroy();
  virtual void main_loop();

public:
  TStampa_giornalemag() {}
};



bool TStampa_giornalemag::create()
{
  _mask = new TStampemg_mask("mg4300");
  _files = new TArray();
  _files->add(new TLocalisamfile(LF_RMOVMAG));
  _files->add(new TLocalisamfile(LF_MOVMAG));
  return TSkeleton_application::create();
}
bool TStampa_giornalemag::destroy()
{
  delete _mask;
  delete _files;
  return TRUE;
}


void TStampa_giornalemag::main_loop()
{
  while (_mask->run() == K_ENTER ) 
  {
    if (_mask->magazz_ini().gestmag(TRUE)) 
    {
      _giorn_mag = new TGiornalemag("mg4300", "");
      _giorn_mag->set_parametri(*_mask);
      if (_giorn_mag->can_be_printed())
        _giorn_mag->print();
      else
        error_box("Impossibile stampare il giornale dalla data indicata");
      delete _giorn_mag;
    } 
  } // while true  
  return ;
}


int mg4300(int argc, char* argv[])
{
  TStampa_giornalemag a;
  a.run(argc,argv,"Stampa giornale di magazzino");
  return 0;
}