campo-sirio/cg/cg4500.cpp

// Apertura nuovo esercizio
#include "cg4501.h"
#include "cg4500a.h"

class TAp_eser : public TApplication
{
  TTable* _esc, * _reg;
  int     _anno, _newanno;
  TDate   _dataini, _datafin, _datainp, _datafip;

protected:
  static bool mask_dataini   (TMask_field&, KEY);
  static bool mask_newanno   (TMask_field&, KEY);

public:
  virtual bool create();
  virtual bool destroy();
  virtual bool menu(MENU_TAG m);

  bool  set();
  bool  apertura_es();
  
  TAp_eser() {}
};

TDate InizioEsercizio(int anno)
{
  TTable TabEs ("ESC");
  TString codtab;
  TDate inizio_es;

  TabEs.zero();
  codtab.format ("%04d", anno);
  TabEs.put ("CODTAB", codtab);
  TabEs.read();
  if (TabEs.good())
    inizio_es= TabEs.get_date ("D0");

  return inizio_es;
}

TDate FineEsercizio(int anno)
{
  TTable TabEs ("ESC");
  TString codtab;
  TDate fine_es;

  TabEs.zero();
  codtab.format ("%04d", anno);
  TabEs.put ("CODTAB", codtab);
  TabEs.read();
  if (TabEs.good())
    fine_es= TabEs.get_date ("D1");

  return fine_es;
}

bool TAp_eser::mask_newanno (TMask_field& f, KEY k)
{ 
  TTable TabEs ("ESC");
  TString codtab; 

  //  if ( (k == K_TAB) && f.mask().is_running() )
  if ( (k == K_ENTER) && f.to_check(k) )
  {
    int newanno = f.mask().get_int(F_NUOVOANNO);
    int anno    = f.mask().get_int(F_ANNO);
    TabEs.zero();
    codtab.format ("%04d", newanno);
    TabEs.put ("CODTAB", codtab);
    TabEs.read();
    if ( TabEs.good() )
    {
      f.warning_box ("L'anno inserito e' gia' presente nella tabella degli esercizi!");
      return FALSE;
    }
    
    if (newanno != anno + 1)
    {
      f.warning_box ("L'anno del nuovo esercizio deve essere successivo all'anno esercizio precedente");
      return FALSE;
    }  
  }
  return TRUE;
}

bool TAp_eser::mask_dataini (TMask_field& f, KEY k)
{
  if ( (k == K_ENTER) && f.to_check(k) )
  {
    TDate data(f.mask().get(F_DATAINI));
    TDate fine(f.mask().get(F_DATAFINC)); 
    /*
       if ( data.year() != FineEsercizio(anno).year() + 1 )
       {
       warning_box ("L'anno del nuovo esercizio deve essere successivo a quello della fine dell'esercizio precedente");
       return FALSE; 
       }
       */
    if ( data <= fine )
    {
      f.warning_box ("La data di inizio del nuovo esercizio deve essere superiore alla data di fine esercizio precedente");
      return FALSE;
    }
  }
  return TRUE;
}

bool TAp_eser::create()
{
  _esc    = new TTable("ESC");
  _reg    = new TTable("REG");

  enable_menu_item(M_FILE_NEW, FALSE);

  dispatch_e_menu (BAR_ITEM(1));
  
  return TRUE;
}

bool TAp_eser::destroy()
{
  delete _esc;
  delete _reg;
  
  return TRUE;
}

bool TAp_eser::menu(MENU_TAG m)
{
  TTable TabEs ("ESC");
  TMask msk ("cg4500a");
  
  if (TabEs.last() != NOERR)
    return error_box("Non e' ancora stato aperto alcun esercizio!");
  
  int anno     = TabEs.get_int ("CODTAB");
  TDate inizio = TabEs.get_date("D0"); //data inizio es. in corso  
  TDate fine   = TabEs.get_date("D1"); //data fine es. in corso
  
  msk.set(F_ANNO, anno);
  msk.set(F_DATAINIC, inizio.string());
  msk.set(F_DATAFINC, fine.string());
  msk.set(F_NUOVOANNO, anno+1);
  
  msk.set_handler (F_NUOVOANNO, mask_newanno);
  msk.set_handler (F_DATAINI,   mask_dataini);
  
  if (msk.run() == K_ENTER)
  {
    _anno    = msk.get_int(F_ANNO);
    _datainp = msk.get(F_DATAINIC);
    _datafip = msk.get(F_DATAFINC);      
    _newanno = msk.get_int(F_NUOVOANNO);   //nuovo anno esercizio
    _dataini = msk.get(F_DATAINI);
    _datafin = msk.get(F_DATAFIN);
    
    apertura_es();
  }
  return FALSE;
}

bool TAp_eser::apertura_es()
{
  TTable   TabReg ("REG");
  TTable   TabEs  ("ESC"); 
  TString  anno   (4);
  TString  annonew(4);
  TDate    data;
  bool ok = FALSE; 

  //viene aggiornata la tabella dei registri. Se esisteva gia' un record relativo al nuovo esercizio, viene cancellato.
  //In ogni caso ne viene creato uno nuovo relativo al nuovo esercizio.
  TabReg.zero();
  annonew = format ("%04d", _newanno);
  TabReg.put ("CODTAB", annonew);
  
  TRectype r (TabReg.curr());
  
  TabReg.read(_isgteq);
  
  for (; !TabReg.eof(); TabReg.next())
  {
    if (TabReg.curr() != r) break;
    
    int tiporeg = TabReg.get_int("I0");
    if (tiporeg == 5)
      TabReg.remove();
  }

  TabReg.zero();
  TRectype nuovo (TabReg.curr());
  anno = format ("%04d", _anno);
  TabReg.put ("CODTAB", anno);
  
  TRectype rec (TabReg.curr());
  
  TabReg.read(_isgteq);
  
  for (; !TabReg.eof(); TabReg.next())
  { 
    if (TabReg.curr() != rec) break;
    
    int tiporeg = TabReg.get_int("I0");
    TString cod_reg = TabReg.get("CODTAB");
    cod_reg = cod_reg.mid(4,3);
    if (tiporeg == 5)
    {
      ok = TRUE;
      nuovo  = TabReg.curr();
      TString16 cod;
      cod << _newanno << cod_reg;
      nuovo.put("CODTAB", cod);
      nuovo.put("D2", data);
      nuovo.put("D3", data);
      nuovo.put("I6", 0L);
      nuovo.put("R1", real(0.0));
      nuovo.put("R2", real(0.0));
      
      TabReg.write(nuovo);
    }   
  }
  /*
     if (!ok)
     {
     error_box("Non esiste il registro libro giornale relativo all'es. precedente");
     return FALSE;
     }
     */
  //viene aggiornata la tabella degli esercizi  
  TabEs.zero();
  annonew = format ("%04d", _newanno);
  TabEs.put ("CODTAB", annonew);
  TabEs.put ("D0", _dataini);
  TabEs.put ("D1", _datafin);
  TabEs.write();  
  
  message_box("Apertura nuovo esercizio completata");
  return TRUE;
}

int cg4500 (int argc, char* argv[])
{
  switch (*argv[2])
  {
  case 'C':
  {
    TAp_eser a;
    a.run(argc, argv, "Apertura nuovo esercizio");
  }
  break;
 case 'I':
{
  TAp_iva a;      
  a.run(argc, argv, "Apertura nuovo esercizio IVA");
}
break;
default:
break;
}
return TRUE;
}