campo-sirio/ce/ce2200.cpp

#include <applicat.h>
#include <automask.h>
#include <modaut.h>
#include <progind.h>
#include <recarray.h>
#include <relation.h>
#include <tabutil.h>

#include "celib.h"
#include "ce2200a.h"

#include "../cg/cglib01.h"

#include "ammce.h"
#include "catdi.h"
#include "cespi.h"
#include "salce.h"

class TOpenesc_mask : public TAutomask
{ 
  TDitta_cespiti& _dc;
  bool _has_cg;

protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
  bool check_oldes();

public:
  TOpenesc_mask();
};

TOpenesc_mask::TOpenesc_mask() 
             : TAutomask("ce2200a"), _dc(ditta_cespiti()) 
{ 
  _has_cg = main_app().has_module(CGAUT);
  field(F_NEWES).check_type(_has_cg ? CHECK_REQUIRED : CHECK_SEARCH);
}

// Controlla che siano stati stampati i bollati e chiuse le attivita
bool TOpenesc_mask::check_oldes()
{         
  bool ok = TRUE;
  TRelation rel("CCB");
  TRectype& ccb = rel.curr();
  ccb.put("CODTAB", get(F_OLDES));
  TCursor cur(&rel, "", 1, &ccb, &ccb);
  const long items = cur.items();
  cur.freeze();
  for (cur = 0L; cur.pos() < items; ++cur)
  {
    const bool b1 = ccb.get_bool("B1");
    const bool b2 = ccb.get_bool("B2");
    if (!b1 || b2)
    {
      TString msg;
      msg << TR("Non è possibile aprire il nuovo esercizio in quanto ");
      if (!b1)
        msg << TR("non è stato stampato il bollato");
      else  
        msg << TR("è già stata effettuata la chiusura");
      const TString8 codatt = ccb.get("CODTAB").mid(4);
      msg << TR("\ndell'attività ") << cache().get("%CAT", codatt, "S0");
      ok = error_box(msg); 
      break;
    }
  }
  return ok;  
}

bool TOpenesc_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{          
  switch (o.dlg())
  {
  case F_OLDES:
    if (e == fe_init)
    {
      TDate ies, fes;
      const int oes = _dc.esercizio_corrente(ies, fes);
      o.set(oes); set(F_OLDINIZIO, ies); set(F_OLDFINE, fes);
    }
    if (e == fe_init || e == fe_modify)
    {
      TEsercizi_contabili esc;
      const int nes = get_int(F_OLDES)+1;
      set(F_NEWES, nes, TRUE);
      if (esc.exist(nes))
      {
        set(F_NEWINIZIO, esc[nes].inizio());
        set(F_NEWFINE, esc[nes].fine());
        disable(-2);
      }
      else
      {
        TDate inizio = get_date(F_OLDFINE); ++inizio;
        TDate fine = get_date(F_OLDFINE); fine.addyear(1);
        set(F_NEWINIZIO, inizio);
        set(F_NEWFINE, fine);
        enable(-2);
      }
    }
    if (e == fe_modify || e == fe_close)
      return check_oldes();
    break;
  case F_NEWES:
    if (e == fe_close)
    {
      if (o.empty())
        return error_box(TR("È necessario specificare il codice del nuovo esercizio"));
    }
    break;
  default: 
    break;
  }
  return TRUE;
}

class TOpenesc : public TSkeleton_application
{ 
protected:
  virtual bool create();
  virtual void main_loop();
  
  void incr_riv(TRectype& rec, const char* riv, const char* anni) const;
  bool is_leap(int year) const;
  real calc_coeff(const TDate& ies, const TDate& fes) const;
  void incr_zero(TRectype& rec, const char* val, const char* valp) const;

public:   
  void crea_esercizio(int oldes, int newes, const TDate& ies, const TDate& fes) const;
  void crea_attivita(int oldes, int newes) const;
  void crea_registro(int oldes, int newes) const;
  void crea_categorie(int oldes, int newes) const;
  void crea_saldi(int oldes, int newes) const;
  void crea_ammortamenti(int oldes, int newes) const;
  void test_alien(const TRectype& salce, const TDate& fines) const;
};  

bool TOpenesc::create()
{
  open_files(LF_TABCOM, LF_TAB, LF_CESPI, LF_AMMCE, LF_SALCE, 0);
  return TSkeleton_application::create();
}

bool TOpenesc::is_leap(int year) const
{
  TDate d(28,2,year);
  ++d;
  return d.day() == 29;
}

real TOpenesc::calc_coeff(const TDate& ies, const TDate& fes) const
{
  const real tot_es = fes - ies + 1;
  real max_es = 365;
  const int im = ies.month();
  const int iy = ies.year();
  const int fm = fes.month();
  const int fy = fes.year();
  if ((im < 3 && (fm >= 3 || fy > iy) && is_leap(iy)) || 
      (fm >= 3 && (im < 3 || iy < fy) && is_leap(fy)))
    max_es += 1.0;
  real coeff = tot_es / max_es;
  coeff.round(9);
  return coeff;
}

void TOpenesc::crea_esercizio(int oldes, int newes, const TDate& ies, const TDate& fes) const
{ 
  // Crea l'esercizio contabile se necessario
  TTable esc("ESC");
  esc.put("CODTAB", newes);
  if (esc.read() != NOERR)
  {
    if (!has_module(CGAUT))
    {
      TTable esc("ESC");
      esc.put("CODTAB", newes);
      if (esc.read() != NOERR)
      {
        esc.zero();
        esc.put("CODTAB", newes);
        esc.put("D0", ies);
        esc.put("D1", fes);
        esc.write();
      }
    }
    else
      warning_box(TR("Attenzione: non esiste ancora l'esercizio contabile %04d"), newes);
  }
  
  // Crea l'esercizio cespiti se necessario
  TTable cce("CCE");
  TString8 key; key.format("%04d", oldes);
  const TRectype& oldrec = cache().get("CCE", key);
  cce.put("CODTAB", newes);
  const bool found = cce.read() == NOERR;
  if (!found)
  {
    cce.zero();
    cce.put("CODTAB", newes);
  }
  cce.put("S5", calc_coeff(ies, fes)); // Calcola coefficiente durata esercizio
  cce.put("S6", oldrec.get("S6"));     // Copia tipo arrotondamento
  cce.put("I0", oldrec.get("I0"));     // Copia tipo contabilità
  cce.put("I1", oldrec.get("I1"));     // Copia tipo riproporzionamento
  cce.put("I2", oldrec.get("I2"));     // Copia assoggettamento art.14 C.2 legge 449/97
  cce.put("I3", fes - ies + 1);        // Calcola durata esercizio
  cce.put("B0", oldrec.get("B0"));     // Copia ditta relativa a professionista
  cce.put("B3", oldrec.get("B3"));     // Copia ammortamento parti vendute
  cce.put("B4", oldrec.get("B4"));     // Ragguaglio parti vendute
  cce.put("B5", oldrec.get("B5"));     // Esposizione su libro cespiti
  if (found)    
    cce.rewrite();
  else
    cce.write();
}

void TOpenesc::crea_attivita(int oldes, int newes) const
{
  TRelation rel("CCB");
  TRectype& ccb = rel.curr();
  ccb.put("CODTAB", oldes);
  TCursor cur(&rel, "", 1, &ccb, &ccb);
  const long items = cur.items();
  cur.freeze();
  for (cur = 0L; cur.pos() < items; ++cur)
  {
    ccb.put("B2", TRUE);  // Setta flag di chiusa
    rel.rewrite();
    
    // Crea nuova attività
    TString16 codtab = ccb.get("CODTAB");
    TString8 str; str.format("%04d", newes);
    codtab.overwrite(str);
    const bool leasing = ccb.get_bool("B0");
    ccb.zero();
    ccb.put("CODTAB", codtab);
    ccb.put("B0", leasing);
    rel.write();
  }
}

void TOpenesc::crea_registro(int oldes, int newes) const
{
  TRelation rel("REG");
  TRectype& reg = rel.curr();
  reg.put("CODTAB", oldes);
  TCursor cur(&rel, "I0=6", 1, &reg, &reg);
  const long items = cur.items();    // Puo' succedere di averne più d'uno
  cur.freeze();
  for (cur = 0; cur.pos() < items; ++cur)
  {                    
    TString16 codtab;
    codtab.format("%04d", newes);
    codtab << reg.get("CODTAB").mid(4);
    reg.put("CODTAB", codtab);
    reg.zero("I1");  // Pagine stampate
    rel.write();
  }
}

void TOpenesc::crea_categorie(int oldes, int newes) const
{
  TRelation rel(LF_CATDI);
  TRectype& cat = rel.curr();
  cat.put(CATDI_CODES, oldes);
  TCursor cur(&rel, "", 1, &cat, &cat);
  const long items = cur.items();
  cur.freeze();
  for (cur = 0L; cur.pos() < items; ++cur)
  {
    cat.put(CATDI_CODES, newes);
    cat.zero(CATDI_DATE);
    cat.zero(CATDI_TPOP);
    rel.write();
  }
}

void TOpenesc::incr_riv(TRectype& rec, const char* riv, const char* anni) const
{
  if (rec.get_real(riv) != ZERO)
  {
    const int new_anni = rec.get_int(anni) + 1;
    rec.put(anni, new_anni);
  }
}

void TOpenesc::test_alien(const TRectype& salce, const TDate& fines) const
{ 
  if (null_fields(salce, SALCE_NUMELE, SALCE_CSTO, SALCE_RIV75, SALCE_RIV83, SALCE_RIV90, SALCE_RIV91, SALCE_RIVGF))
  {
    const TString16 idcespite = salce.get(SALCE_IDCESPITE);
    TLocalisamfile cespiti(LF_CESPI);
    cespiti.put(CESPI_IDCESPITE, idcespite);
    if (cespiti.read() == NOERR)
    {
      const TDate dtcomp = cespiti.get(CESPI_DTCOMP);
      if (dtcomp <= fines)
      {
        cespiti.put(CESPI_DTALIEN, fines);
        cespiti.rewrite();
      }
    }
  }
}

void TOpenesc::crea_saldi(int oldes, int newes) const
{
  TRelation rel(LF_SALCE);           
  rel.add(LF_AMMCE, "CODES==CODES|IDCESPITE==IDCESPITE|TPSALDO==2|TPAMM==1");
  TRectype& rec = rel.curr();
  TString str;
  str << '(' << SALCE_CODES << "==" << oldes << ")&&(" << SALCE_TPSALDO << "==2)";
  TCursor cur(&rel, str);
  const long items = cur.items();
  cur.freeze();
  
  // Calcola data fine esercizio per eventuali alienazioni
  TEsercizi_contabili esc;
  const TDate fines = esc[oldes].fine();
  
  TProgind pi(items,  "Apertura saldi", FALSE, TRUE);
  for (cur = 0; cur.pos() < items; ++cur)
  {
    pi.addstatus(1);
    rec.put(SALCE_CODES, newes); // Aggiorna anno di esercizio
    rec.put(SALCE_TPSALDO, 1);   // Aggiorna tipo saldo ad "iniziale"
    
    incr_riv(rec, SALCE_RIV90, SALCE_ANNIPOST90); // Incrementa anni post 90
    incr_riv(rec, SALCE_RIV91, SALCE_ANNIPOST91); // Incrementa anni post 91
    rec.zero(SALCE_VSPMANU);  // Azzera spese manutenzione
    rec.zero(SALCE_DTSTBOLL); // Azzera data stampa bollato

    // Incrementa gli anni di ammortamento
    const TRectype& ammce = rel.curr(LF_AMMCE);
    if (!null_fields(ammce, AMMCE_QNOR, AMMCE_QACC, AMMCE_QANT))
    {
      const int anniamm = rec.get_int(SALCE_ANNIAMM);
      rec.put(SALCE_ANNIAMM, anniamm+1);
    }
    
    // Controlla se cespite alienato
    test_alien(rec, fines);
    
    const int err = rel.write();
    if (err != NOERR)  // Should never happen!
      rel.rewrite();
  }  
}

void TOpenesc::incr_zero(TRectype& rec, const char* val, const char* valp) const
{
  real num = rec.get(val);
  num += rec.get_real(valp);
  rec.put(val, num);
  rec.zero(valp);
}

void TOpenesc::crea_ammortamenti(int oldes, int newes) const
{
  TRelation rel(LF_AMMCE);           
  rel.add(LF_AMMCE, "IDCESPITE==IDCESPITE|CODES==CODES|TPSALDO==1|TPAMM==TPAMM", 1, 0, 883);
  TRectype& rec = rel.curr();
  const TRectype& ammce1 = rel.curr(-883);
  TString str;
  str << '(' << SALCE_CODES << "==" << oldes << ")&&(" << SALCE_TPSALDO << "==2)";
  TCursor cur(&rel, str);
  const long items = cur.items();
  cur.freeze();

  TProgind pi(items,  TR("Creazione ammortamenti"), FALSE, TRUE);
  for (cur = 0; cur.pos() < items; ++cur)
  {
    pi.addstatus(1);
    rec.put(AMMCE_CODES, newes); // Aggiorna anno di esercizio
    rec.put(AMMCE_TPSALDO, 1);   // Aggiorna tipo saldo ad "iniziale"
    rec.zero(AMMCE_CSCEN);
    rec.zero(AMMCE_FZPER);
    rec.zero(AMMCE_FZQUO);
    rec.put(AMMCE_PNOR, ammce1.get(AMMCE_PNOR));
    rec.put(AMMCE_PACC, ammce1.get(AMMCE_PACC));
    rec.put(AMMCE_PANT, ammce1.get(AMMCE_PANT));
    incr_zero(rec, AMMCE_QNOR, AMMCE_QNORP);
    incr_zero(rec, AMMCE_QACC, AMMCE_QACCP);
    incr_zero(rec, AMMCE_QANT, AMMCE_QANTP);
    incr_zero(rec, AMMCE_QPERSE, AMMCE_QPERSEP);
    incr_zero(rec, AMMCE_FPRIVATO, AMMCE_FPRIVATOP);
    incr_zero(rec, AMMCE_QPPRIVATE, AMMCE_QPPRIVATEP);
    
    const int err = rel.write();
    if (err != NOERR)  // Should never happen!
      rel.rewrite();
  }
}

void TOpenesc::main_loop()
{
  TOpenesc_mask m;
  if (m.run() == K_ENTER)
  {
    const int oldes = m.get_int(F_OLDES);
    const int newes = m.get_int(F_NEWES);
    const TDate ies = m.get(F_NEWINIZIO);
    const TDate fes = m.get(F_NEWFINE);
    crea_esercizio(oldes, newes, ies, fes);
    crea_attivita(oldes, newes);
    crea_registro(oldes, newes);
    crea_categorie(oldes, newes);
    crea_saldi(oldes, newes);
    crea_ammortamenti(oldes, newes);
    ditta_cespiti().set_attivita(newes, 0, NULL);
  }
}

int ce2200(int argc, char* argv[])
{
  TOpenesc a;
  a.run(argc, argv, TR("Cambio esercizio"));
  return 0;
}