campo-sirio/sc/sc0101.cpp

#include <execp.h>
#include <mailbox.h>
#include <real.h>

#include "../cg/conto.h"
#include "../cg/pagament.h"
#include "../cg/saldacon.h"
#include "../cg/cg21sld.h"

#include "sc0100.h"
#include "sc0100a.h"

#define __EXTRA__
#include "../cg/cg2105.cpp"

///////////////////////////////////////////////////////////
// Maschera gestione rate
///////////////////////////////////////////////////////////

class TFattura_mask : public TMask
{
  TRiga_partite& _fattura;
  TPagamento* _pag;
  TString_array _pag_rows;
  
protected:        
  static bool totdoc_handler(TMask_field& f, KEY k);
  static bool totval_handler(TMask_field& f, KEY k);
  static bool valuta_handler(TMask_field& f, KEY key);
  static bool cambio_handler(TMask_field& f, KEY k);
  static bool pag_notify(TSheet_field& ps, int r, KEY k);
  static bool pag_handler(TMask_field& f, KEY key);
  static bool reset_handler(TMask_field& f, KEY key);
  static bool recalc_handler(TMask_field& f, KEY key);
  static bool nrate_handler(TMask_field& f, KEY key);
  static bool tipopag_handler(TMask_field& f, KEY key);
  static bool codcab_handler(TMask_field& f, KEY key);

  TPagamento& pagamento() const { return *_pag; }
  TSheet_field& pag_sheet() const { return (TSheet_field&)field(FS_RATESHEET); }
  void pag2sheet();
  
  void read_scadenze();
  
public:
  void write_scadenze() const;

  TFattura_mask(TRiga_partite& fattura, const TString& codpag);
  virtual ~TFattura_mask();
};

TFattura_mask::TFattura_mask(TRiga_partite& fattura, const TString& codpag) 
             : TMask("sc0100b"), _fattura(fattura), _pag(NULL)
{             
  hide(FS_IMPOSTE);        // Elimina le imposte (non gestite in extra-contabile)
  
  set_handler(FS_CAMBIO, cambio_handler);

  set_handler(FS_RESET, reset_handler);
  set_handler(FS_RECALC, recalc_handler);
  set_handler(FS_NRATE, nrate_handler);
  set_handler(FS_NSCAB, codcab_handler);
  set_handler(FS_VSCAB, codcab_handler);
  
  TSheet_field& sf = pag_sheet();
  sf.set_notify(pag_notify);
  sf.set_handler(pag_handler);
  
  TMask& sm = sf.sheet_mask();
  sm.set_handler(105, tipopag_handler);
  sm.set_handler(106, tipopag_handler);
  
  const TRiga_partite& partita = _fattura;
  const TString datadoc = partita.get(PART_DATADOC);
  _pag = new TPagamento(codpag, datadoc);
  
  read_scadenze();
} 
                            
TFattura_mask::~TFattura_mask()
{
  delete _pag;
}
                            
void TFattura_mask::pag2sheet()
{
  TPagamento& pag = pagamento();
  TSheet_field& ps = pag_sheet();
  pag.set_sheet(ps);
  _pag_rows = ps.rows_array();
}

bool TFattura_mask::pag_notify(TSheet_field& ps, int r, KEY k)
{       
  TFattura_mask& fm = (TFattura_mask&)ps.mask();
  TPagamento&    pag = *fm._pag;
  TString_array& rws = fm._pag_rows;                                
  
  bool recalc = fm.get_bool(FS_RECALC);       // Ricalcolo automatico attivo
  
  bool doit = TRUE;

  TToken_string& ns = ps.row(r);                // Nuova riga
  switch (k)                                             
  {
  case K_SPACE:
    {                                         
      // Le rate possono essere cancellate solo quando non c'e' ricalcolo automatico,
      // ce ne sono almeno due e non sono protette dalla presenza di abbuoni.
      const bool can_delete = !recalc && pag.n_rate() > 1 && ns.get_char(13) != 'X';   
      ps.sheet_mask().enable(DLG_DELREC, can_delete);
    }  
    break;
  case K_ENTER:
    {        
      const bool in_valuta = pag.in_valuta(); 
      const int impos      = in_valuta ? 2 : 1;
      
      bool mod = FALSE,    m_imp  = FALSE, m_perc = FALSE, m_pag = FALSE;
      bool m_scad = FALSE, m_tipo = FALSE, m_ulc = FALSE, m_implit = FALSE;
      word ahiahi = P_OK;                                

      TToken_string& ts = rws.row(r);     // Vecchia riga
      TString news = ns.get(0);           // Data scadenza
      TString newp = ns.get(3);           // Percentuale
      TString newt = ns.get(4);           // Tipo pagamento                                 
      TString newu = ns.get(5);           // Ulteriore classificazione 
      TString newi = ns.get(impos);       // Importo (lire o valuta)
      TString newil;                      // Importo in lire
      if (in_valuta)      
      {
        newil = ns.get(1);                
        m_implit = real(newil) != real(ts.get(1));
      }
      if (news != ts.get(0))              // modificata data scadenza
        mod = m_scad = TRUE;        
      if (real(newp) != real(ts.get(3)))  // modificata percentuale
        mod = m_perc = TRUE;        
      if (real(newi) != real(ts.get(impos)))  // modificato importo
      {          
        // se si modifica la percentuale l'importo non viene cagato
        if ((recalc && !m_perc) || (!recalc)) 
          mod = m_imp = TRUE;   
      }
      if (newt != ts.get(4))  // modificato tipo pagamento
        mod = m_tipo = m_ulc = TRUE;      
    
      if (newu != ts.get(5))  // modificata ulteriore classificazione
        mod = m_ulc  = TRUE;
      else if (m_tipo) 
      {
        // forza reset di ulc se si e' modificato il tipo rata
        m_ulc = TRUE;
        newu = "";                                             
      }                                                        
      
      // settato da recalc_rate se occorre ridefinire lo sheet
      // aggiungendo o togliendo righe
      bool need_recalc = FALSE;      
      
      if (mod && recalc)
      {                          
        const bool rdiff = fm.get_bool(FS_RDIFFER);
        const bool mcomm = fm.get_bool(FS_MCOMM);

        // ricalcola sheet come sai fare tu
        ahiahi = pag.recalc_rate(r, m_perc, 
                                 ((m_perc || m_imp) ? 
                                  (m_perc ? (const char*)newp : (const char*)newi) : 
                                  NULL), 
                                 (m_scad ? (const char*)news : NULL),
                                 (m_tipo ? (const char*)newt : NULL),
                                 (m_ulc  ? (const char*)newu : NULL), 
                                 rdiff, mcomm, need_recalc);
        // see if rdiff changed                          
        fm.set(FS_RDIFFER, pag.rate_differenziate() ? "1" : "2");
        fm.set(FS_NRATE, pag.n_rate());
      } 
      if (!recalc)
      {                              
        ahiahi = P_OK;
        // put data as they are
        TToken_string& trw = pag.rata(r);
        TToken_string  srw = trw;
        if (m_tipo) trw.add(newt,2);
        if (m_scad)
        {
          trw.add(news,3);
          if (r > 0)
          {             
            TDate d(news);   
            int scd = (int)(d - pag.data_rata(r-1));
            if (pag.mese_commerciale() && (scd % 30) != 0) 
                 scd = 30 * ((scd/30)+1);
            trw.add(scd, 0);
          }
        }
        if (m_imp)  
        {
          trw.add(newi,4);
          const real p = pag.recalc_percrata(r);
          ps.row(r).add(p.string(), 3);
          ps.force_update(r); 
        }  
        if (mod) 
          rws.row(r) = ps.row(r);
      }    
      if (in_valuta && m_implit)
      {         
        pag.set_implit(r, real(newil));
        rws.row(r) = ps.row(r);
      }
        
      if (ahiahi)  // any error? Rimetti le righe com'erano prima
      {         
        if (recalc)
        {            
          TString err(80); pag.strerr(ahiahi,err);
          warning_box(err);
          ps.row(r) = rws.row(r); 
          ps.force_update(r); 
        }  
      } 
      else if (recalc && mod && need_recalc) 
      {                                   
        // ridefinisci lo sheet sulla base delle nuove rate
        fm.pag2sheet();
      } 
    } 
    break;
  case K_DEL: 
    doit = !recalc && pag.n_rate() > 1 && ps.row(r).get_char(13) != 'X';   
    if (doit)
    {
      pag.remove_rata(r);
      fm.set(FS_NRATE, pag.n_rate());
    }  
    break;
  
  case K_INS:   
    // permette aggiunta e cancellazione solo se non c'e' ricalcolo automatico
    doit = !recalc;
    break;
  case K_CTRL+K_INS:                 // Post inserimento
    {                   
      const int prev = r - 1;
      const int gio_scad = pag.scad_rata(prev); 
      TDate data_scad(pag.data_rata(prev));

      pag.add_rata(ZERO, gio_scad, pag.tipo_rata(prev), pag.ulc_rata(prev));
      pag.next_scad(data_scad, gio_scad, pag.mese_commerciale(), r);
      pag.set_datarata(r, data_scad);
      pag.adjust_fixed_scad();
      fm.pag2sheet();
    }
    break;
  default:
    break;
  }          

  
  return doit;
}                            


bool TFattura_mask::totdoc_handler(TMask_field& f, KEY k)
{
  if (k == K_TAB && f.focusdirty())
  {                        
    TFattura_mask& fm = (TFattura_mask&)f.mask();
    const bool valuta = fm.get(FS_VALUTA).not_empty();
    
    if (valuta)
    {          
      if (fm.get(FS_TOTVAL).empty())
      {
        const real cambio(fm.get(FS_CAMBIO));
        if (!cambio.is_zero())
        {
          real tot(f.get());
          tot /= cambio;
          fm.set(FS_TOTVAL, tot, TRUE);
        }
      }  
    }
    else
    {
      TPagamento& pag = fm.pagamento();
      const real tot(f.get());
      pag.set_total(tot, ZERO, ZERO);                              
      pag.set_rate_auto();      
      fm.pag2sheet();    
    }  
  }
  return TRUE;
} 

bool TFattura_mask::totval_handler(TMask_field& f, KEY key)
{
  if (key == K_TAB && f.focusdirty())
  {  
    TFattura_mask& fm = (TFattura_mask&)f.mask();

    real totval(f.get());
    real cambio(fm.get(FS_CAMBIO));
    real totale(fm.get(FS_IMPONIBILI));
    if (totale.is_zero())
    {
      totale = totval * cambio;
      fm.set(FS_IMPONIBILI, totale, TRUE);
    }
    else
    {
      if (cambio.is_zero() && !totval.is_zero())
      {
        cambio = totale / totval;
        fm.set(FS_CAMBIO, cambio, TRUE);
      }  
      
      TPagamento& pag = fm.pagamento();
      pag.set_total(totval, ZERO, ZERO);                              
      pag.set_rate_auto();      
      fm.pag2sheet();    
    }  
  }
  return TRUE;
}   

bool TFattura_mask::valuta_handler(TMask_field& f, KEY key)
{
  if (key == K_TAB && f.to_check(key, TRUE))
  {           
    TMask& m = f.mask();
    const TString val = f.get();
    const bool full = val.not_empty();
    
    if (full)
    {   
      TMask_field& dc = m.field(FS_DATACAMBIO);
/*      
      if (dc.get().empty())      // Inizializza data cambio se assente
        m.set(FS_DATACAMBIO, m.get(F_DATADOC), TRUE);
      else 
*/        
      if (f.focusdirty())
      {
        dc.set_dirty(); 
        dc.check(RUNNING_CHECK); // Forza ricerca cambio
        dc.on_hit();             // Forza messaggi (eventuale copia a pag. 3)
      }  
    }
    else
    {
      m.set(FS_CAMBIO, "", TRUE); 
      m.set(FS_TOTVAL, "", TRUE);
    }  
    m.enable(FS_CAMBIO, full); 
    m.enable(FS_TOTVAL, full);
  }
  return TRUE;
}

bool TFattura_mask::cambio_handler(TMask_field& f, KEY key)
{
  if (key == K_TAB && f.focusdirty())
  {  
    TFattura_mask& fm = (TFattura_mask&)f.mask();
    TPagamento& pag = fm.pagamento();
    const real cambio(f.get());
    pag.set_cambio(cambio, fm.get_bool(FS_RECALC));
  }
  return TRUE;
}


bool TFattura_mask::pag_handler(TMask_field& f, KEY key)
{           
  if (key == K_TAB || key == K_ENTER)
  {                  
    TFattura_mask& fm = (TFattura_mask&)f.mask();
    TPagamento& pag = *fm._pag;
    const word err = pag.validate();
    if (err != P_OK)
    {
      TString256 s;
      pag.strerr(err, s);
      return error_box(s); 
    }
  }
  return TRUE;
}

bool TFattura_mask::reset_handler(TMask_field& f, KEY key)
{                                 
  if (key == K_SPACE)
  {
    TFattura_mask& fm = (TFattura_mask&)f.mask();
    if (fm._fattura.rate() == 0)
      fm._pag->read();
    fm.read_scadenze();
  }
  return TRUE;
}

bool TFattura_mask::recalc_handler(TMask_field& f, KEY key)
{
  if (key == K_SPACE)
  {
    const bool on = f.get().not_empty();
    const TMask& m = f.mask();
    TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
    ps.enable_column(3, on);
  }
  
  return TRUE;
}

bool TFattura_mask::nrate_handler(TMask_field& f, KEY key)
{                                 
  if (key == K_TAB && f.focusdirty())
  {
    TFattura_mask& fm = (TFattura_mask&)f.mask();
    TPagamento& pag = *fm._pag;
    pag.set_numero_rate(atoi(f.get()));
    if (pag.dirty())
      fm.pag2sheet();
  }
  return TRUE;
}

bool TFattura_mask::codcab_handler(TMask_field& f, KEY key)
{
  if (key == K_TAB && f.focusdirty())
  {
    const TMask& m = f.mask();
    const short id = f.dlg() == FS_NSCAB ? FS_NSABI : FS_VSABI;
    const int pos = id == FS_NSABI ? 7 : 9;
    const TString16 abi = m.get(id);
    const TString16 cab = m.get(id+1);
    TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET);
    for (int i = ps.items()-1; i >= 0; i--)
    {
      TToken_string& row = ps.row(i);
      row.add(abi, pos);
      row.add(cab, pos+1);
    }
    ps.force_update();
  }
  
  return TRUE;
}

void TFattura_mask::read_scadenze()
{              
  TRiga_partite& partita = _fattura;                  
  TPagamento& pag = *_pag;        
  TSheet_field& ps = pag_sheet();

  real imponibile, imposte, spese, cambio;
  
  if (partita.in_valuta())
  {                       
    imponibile = partita.get_real(PART_IMPORTOVAL);
    cambio = partita.get_real(PART_CAMBIO);
    
    real imp = imponibile;
    imp *= cambio;
    imp.round();
    set(FS_IMPONIBILI, imp);
  }
  else
  {
    imponibile = partita.get_real(PART_IMPORTO);
    set(FS_IMPONIBILI, imponibile);
  }
  
  pag.set_total(imponibile, imposte, spese);
  pag.set_cambio(cambio, FALSE);
  
  if (partita.rate() > 0)
  {
    pag.zap_rate();
    for (int i = 1; i <= partita.rate(); i++)
    { 
      const TRiga_scadenze& scadenza = partita.rata(i);
      real  importo     = scadenza.get(SCAD_IMPORTO); 
      const TDate scad  = scadenza.get(SCAD_DATASCAD);
      const int tipop   = scadenza.get_int(SCAD_TIPOPAG);     
      const bool paid   = scadenza.get_bool(SCAD_PAGATA);
      const TString ulc = scadenza.get(SCAD_ULTCLASS);                       
      if (scadenza.in_valuta())
      {                                                        
        const real impval(scadenza.get(SCAD_IMPORTOVAL));
        pag.set_rata(i-1, impval, importo, scad, tipop, ulc, paid);
      }
      else
        pag.set_rata(i-1, importo, ZERO, scad, tipop, ulc, paid);
          
      TToken_string& str = ps.row(i-1);
      str.add(scadenza.get(SCAD_CODABIPR), 7);
      str.add(scadenza.get(SCAD_CODCABPR), 8);
      str.add(scadenza.get(SCAD_CODABI),   9);
      str.add(scadenza.get(SCAD_CODCAB),   10);    
      if (i == 1)
      {
        set(FS_NSABI, str.get(7));
        set(FS_NSCAB, str.get(8));
        set(FS_VSABI, str.get(9));
        set(FS_VSCAB, str.get(10));
        set(FS_AGENTE, scadenza.get(SCAD_CODAG));
      }
    } 
  }
  else
  {
    pag.set_rate_auto();
  }
    
  set(FS_RDIFFER, pag.rate_differenziate() ? "1" : "2");
  set(FS_NAMEPAG, pag.name());
  set(FS_TIPOPR,  pag.desc_tpr());
  set(FS_MCOMM,   pag.mese_commerciale() ? "X" : "");
  set(FS_RECALC,  "X", TRUE);
  set(FS_NRATE,   pag.n_rate());
                        
  // se la prima rata e' fissa non si tocca
  if (pag.tipo_prima_rata() > 3)
    ps.disable_cell(0,-1);

  pag2sheet();                      
} 

bool TFattura_mask::tipopag_handler(TMask_field& f, KEY key)
{
  if ((key == K_TAB || key == K_ENTER) && f.dirty())
  {                
    TFattura_mask& m = (TFattura_mask&)f.mask();
    int t = m.get_int(105); 
    if (t <= 0)
    {
      t = 1;  
      f.set("1");
    }
    const char u = m.get(106)[0];
    const TPagamento& pag = m.pagamento();  
    bool ok;
    const char* s = pag.desc_tipo(t, u, &ok);  
    if (!ok) m.reset(106);
    m.set(107, s);
  }
  
  return TRUE;
}


void TFattura_mask::write_scadenze() const
{                                   
  CHECK(_pag, "Null pagament");
  const TPagamento& pag = *_pag;          
  TSheet_field& ps = pag_sheet();
                                         
  _fattura.put(PART_IMPORTO,    get(FS_IMPONIBILI));
  _fattura.put(PART_CODVAL,     get(FS_VALUTA));
  _fattura.put(PART_DATACAM,    get(FS_DATACAMBIO));
  _fattura.put(PART_CAMBIO,     get(FS_CAMBIO));
  _fattura.put(PART_IMPORTOVAL, get(FS_TOTVAL));
  
  const TString agente = get(FS_AGENTE);
  
  const int old_rate = _fattura.rate();
  for (int i = 0; i < pag.n_rate(); i++)
  {    
    TToken_string& row = ps.row(i);
    
    TRiga_scadenze& scadenza = i >= old_rate ? _fattura.new_row() : _fattura.rata(i+1); 
    scadenza.put(SCAD_CODPAG,   pag.code());
    scadenza.put(SCAD_TIPOPAG,  pag.tipo_rata(i));
    scadenza.put(SCAD_ULTCLASS, pag.ulc_rata(i));
    if (_fattura.in_valuta())    
    {
      scadenza.put(SCAD_IMPORTO, pag.tlit_rata(i));
      scadenza.put(SCAD_IMPORTOVAL, pag.tpay_rata(i));
    }
    else
    {
      scadenza.put(SCAD_IMPORTO, pag.tpay_rata(i));
      scadenza.zero(SCAD_IMPORTOVAL);
    }  
    scadenza.put(SCAD_DATASCAD, pag.data_rata(i));
    scadenza.put(SCAD_CODABIPR, row.get(7));    
    scadenza.put(SCAD_CODCABPR, row.get(8));    
    scadenza.put(SCAD_CODABI,   row.get(9));    
    scadenza.put(SCAD_CODCAB,   row.get(10));    
    scadenza.put(SCAD_CODAG,    agente);
    scadenza.put(SCAD_PAGATA,   scadenza.chiusa(TRUE));
  }
  
  TPartita& game = _fattura.partita();
  if (i < old_rate)
  {
    const int riga = _fattura.get_int(PART_NRIGA);
    for (int r = old_rate; r > i; r--)
    {
      game.scollega_pagamenti(riga, r);
      _fattura.elimina_rata(r);
    }
  }  

  game.chiusa(TRUE);
}


///////////////////////////////////////////////////////////
// Addendum alla maschera gestione partite
///////////////////////////////////////////////////////////

bool TGame_mask::edit_fattura(TPartita& p, int nriga)
{                                       
  const bool nuova = nriga <= 0;          
  if (nuova)
    nriga = nuova_riga(p);
  
  TRiga_partite& f = p.riga(nriga);
  if (f.rate() > 0)
    _codpag = f.rata(1).get(SCAD_CODPAG);

  TFattura_mask fm(f, _codpag);
  const KEY k = fm.run();

  if (k == K_ENTER)  
  {
    fm.write_scadenze();
  }
  else
  {
    if (nuova || k == K_DEL)
      p.rimuovi_riga(nriga);
  }  
  
  return k != K_ESC;
}              

bool TGame_mask::prima_nota(const long nreg)
{   
  bool ok = FALSE;
  bool can_run = TRUE;
  if (_changed)
  {
    can_run = yesno_box("Salvare le parite modificate?");
    if (can_run)
    {
      app().partite().rewrite(); 
      _changed = FALSE;             // Resetta flag di cambiato
    }  
  }
  if (can_run)
  {
    app().partite().destroy();       // Distrugge tutte le partite in memoria

    const char* const pn = "cg2 -0";
    TExternal_app prima_nota(pn);
    TString16 numreg; numreg << "1|" << nreg;
    TMessage msg(pn, MSG_LN, numreg);
    msg.send();                      // Messaggio di collegamento al movimento nreg
    ok = prima_nota.run() == 0;      // Lancia la prima nota

    fill_partite();                  // Rilegge partite
  }
  
  return ok;
}

///////////////////////////////////////////////////////////
// Gestione partite extra-contabili
///////////////////////////////////////////////////////////

void TSaldaconto_app::edit_partite(const TMask& m)
{                                           
  const char t = m.get(F_TIPO)[0];
  const int g  = m.get_int(F_GRUPPO);
  const int c  = m.get_int(F_CONTO);
  const long s = m.get_long(F_SOTTOCONTO);
  const TBill b(g, c, s, t);                                // Legge il conto della riga selezionata
  TGame_mask gm(b, 0, 0);                
  gm.run();
  if (gm.changed() && yesno_box("Si vogliono salvare le partite modificate?"))
    partite().rewrite();
  partite().destroy();                
}