root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Gestione saldaconto

Browse Source 
git-svn-id: svn://10.65.10.50/trunk@1756 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
guy 1995-08-30 12:14:19 +00:00
parent feb78cbfab
commit f51c6e9eeb
4 changed files with 206 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
cg/cg2100.cpp
View File

@ -547,7 +547,7 @@ void TPrimanota_application::init_insert_mode(TMask& m)
set_scadenze(m);
}
else
_partite.destroy();
partite().destroy();
_saldi.reset(); // Inizializza saldi
}
@ -557,8 +557,13 @@ void TPrimanota_application::init_modify_mode(TMask& m)
{
init_mask(m);
calcola_saldo(); // Verifica eventuali sbilanci contabili
if (iva() == nessuna_iva)
_partite.destroy();
partite().destroy();
if (iva() == nessuna_iva && is_saldaconto())
{
const long numreg = m.get_long(F_NUMREG);
partite().add_numreg(numreg);
}
}
// Controlla sulla causale se il segno del totale documento (ritsoc=FALSE)
@ -854,7 +859,7 @@ int TPrimanota_application::write(const TMask& m)
if (iva() != nessuna_iva)
{
causale().reg().reread(); // Aggiorna protocollo IVA
if (_is_saldaconto)
if (is_saldaconto())
{
if (m.page_enabled(2))
write_scadenze(m);
@ -871,11 +876,11 @@ int TPrimanota_application::write(const TMask& m)
}
else
{
if (_is_saldaconto)
if (is_saldaconto())
{
const long nreg = numreg - (lasterr == _isreinsert ? 1 : 0);
_partite.update_reg_num(nreg, _rel->lfile().curr());
_partite.write();
const long old_nreg = numreg - (lasterr == _isreinsert ? 1 : 0);
partite().update_reg(_rel->lfile().curr(), old_nreg);
partite().rewrite();
}
}
@ -899,9 +904,14 @@ int TPrimanota_application::rewrite(const TMask& m)
if (_is_saldaconto)
{
if (iva() != nessuna_iva)
{
write_scadenze(m);
}
else
{
_partite.update_reg(_rel->lfile().curr());
_partite.rewrite();
}
}
link_m770();

198
cg/cg2105.cpp
View File

@ -1,12 +1,15 @@
#include <defmask.h> // Serve per DLG_NEWREC
#include "cg2102.h" // Applicazione di prima nota
#include "cg2100.h" // Campi maschere prima nota
#include "cg2100p.h" // Campi maschere partite e pagamenti
#include <clifo.h> // Archivio clienti/fornitori
#include <mov.h> // Archivio movimenti di prima nota
#include <pagsca.h> // Archivio pagamenti
#include <partite.h> // Archivio partite
#include <scadenze.h> // Archivio scadenze
#include <pagsca.h> // Archivio pagamenti
///////////////////////////////////////////////////////////
// Maschera partite
@ -14,9 +17,9 @@
class TGame_mask : public TMask
{
const TBill _conto; // Conto fisso
int _riga_partite;
const TBill _conto; // Conto fisso del cliente/fornitore
int _riga_partite; // Riga corrente delle partite
protected:
static bool annopart_handler(TMask_field& f, KEY k);
static bool numpart_handler(TMask_field& f, KEY k);
@ -24,6 +27,7 @@ protected:
static bool show_all_handler(TMask_field& f, KEY k);
static bool scambio_handler(TMask_field& f, KEY k);
static bool edit_scadenza_handler(TMask_field& f, KEY k);
static bool nuovo_handler(TMask_field& f, KEY k);
void add_importo(TToken_string& s, const TImporto& i) const;
TImporto get_importo(TToken_string& s, int pos) const;
@ -43,20 +47,20 @@ public:
virtual ~TGame_mask() {}
};
TGame_mask::TGame_mask(const TBill& bill)
: TMask("cg2100p"), _conto(bill)
TGame_mask::TGame_mask(const TBill& bill) : TMask("cg2100p"), _conto(bill)
{
const char tipocf[2] = { bill.tipo(), '\0' };
const char tipocf[2] = { _conto.tipo(), '\0' };
set(P_TIPOC, tipocf);
set(P_GRUPPO, bill.gruppo());
set(P_CONTO, bill.conto());
set(P_SOTTOCONTO, bill.sottoconto());
set(P_DESCR, ((TBill&)bill).descrizione());
set(P_GRUPPO, _conto.gruppo());
set(P_CONTO, _conto.conto());
set(P_SOTTOCONTO, _conto.sottoconto());
set(P_DESCR, ((TBill&)_conto).descrizione());
set_handler(P_ANNO, annopart_handler);
set_handler(P_NUMERO, numpart_handler);
set_handler(P_SHOWALL, show_all_handler);
set_handler(P_SCAMBIO, scambio_handler);
set_handler(P_ANNO, annopart_handler);
set_handler(P_NUMERO, numpart_handler);
set_handler(P_SHOWALL, show_all_handler);
set_handler(P_SCAMBIO, scambio_handler);
set_handler(DLG_NEWREC, nuovo_handler);
partite().set_notify(partite_notify);
scadenze().sheet_mask().set_handler(100, edit_scadenza_handler);
@ -64,6 +68,10 @@ TGame_mask::TGame_mask(const TBill& bill)
aggiorna_residuo();
}
///////////////////////////////////////////////////////////
// Handlers dei campi e della maschera principale
///////////////////////////////////////////////////////////
bool TGame_mask::annopart_handler(TMask_field& f, KEY k)
{
if (k == K_TAB && f.focusdirty() && f.get().not_empty())
@ -283,6 +291,35 @@ bool TGame_mask::edit_scadenza_handler(TMask_field& f, KEY k)
}
bool TGame_mask::nuovo_handler(TMask_field& f, KEY k)
{
if (k == K_SPACE)
{
TMask new_game("Nuova partita", 1, 24, 6);
new_game.add_number(101, 0, "Anno ", 1, 1, 4);
new_game.add_string(102, 0, "Partita ", 1, 2, 7);
new_game.add_button(DLG_OK, 0, "", -12, -1, 8);
new_game.add_button(DLG_CANCEL, 0, "", -22, -1, 8);
new_game.set(101, TDate(TODAY).year());
if (new_game.run() == K_ENTER)
{
const TGame_mask& gm = (TGame_mask&)f.mask();
const int anno = new_game.get_int(101);
const TString16 numero(new_game.get(102));
TPartita& game = app().partite().partita(gm.conto(), anno, numero);
if (game.ok())
return error_box("La partita %d %s esiste gia'.", anno, (const char*)numero);
}
}
return TRUE;
}
///////////////////////////////////////////////////////////
// Metodi della maschera delle partite
///////////////////////////////////////////////////////////
void TGame_mask::add_importo(TToken_string& s, const TImporto& i) const
{
if (i.is_zero())
@ -426,6 +463,77 @@ void TGame_mask::fill_partite(bool all) const
app().end_wait();
}
///////////////////////////////////////////////////////////
// Paymask
///////////////////////////////////////////////////////////
class TPay_mask : public TMask
{
bool _in_valuta;
real _residuo, _residuo_val;
protected:
static bool importo_handler(TMask_field& f, KEY k);
public:
void set_scad(const TRiga_scadenze& scad);
TPay_mask();
virtual ~TPay_mask() {}
};
TPay_mask::TPay_mask() : TMask("cg2100p")
{
set_handler(S_IMPORTO, importo_handler);
set_handler(S_IMPORTOVAL, importo_handler);
}
void TPay_mask::set_scad(const TRiga_scadenze& scad)
{
set(S_DATASCAD, scad.get(SCAD_DATASCAD)); // Data della scadenza
set(S_SEZIONE_SCAD, scad.riga().sezione()); // Sezione della rata
set(S_RATA, scad.get(SCAD_NRATA));
set(S_IMPORTO_SCAD, scad.get(SCAD_IMPORTO)); // Importo della rata
set(S_IMPORTOVAL_SCAD, scad.get(SCAD_IMPORTOVAL)); // Importo in valuta
_in_valuta = scad.in_valuta();
_residuo = scad.residuo(FALSE);
_residuo_val = scad.residuo(TRUE);
TReal_field& res = (TReal_field&)field(S_RESIDUO);
res.set_decimals(_in_valuta ? 2 : 0);
res.set(_in_valuta ? _residuo_val.string() : _residuo.string());
}
bool TPay_mask::importo_handler(TMask_field& f, KEY k)
{
TPay_mask& m = (TPay_mask&)f.mask();
if (k == K_F8)
{
m.set(S_IMPORTO, m._residuo.string());
if (m._in_valuta)
m.set(S_IMPORTOVAL, m._residuo_val.string(), f.dlg() == S_IMPORTO);
k = K_TAB;
}
if (k == K_TAB && f.focusdirty())
{
if (!m._in_valuta || f.dlg() == S_IMPORTOVAL)
{
const real& res = (f.dlg() == S_IMPORTO) ? m._residuo : m._residuo_val;
const real i(f.get());
if (i >= res)
m.set(S_SALDOACC, "S");
const real residuo(res-i);
m.set(S_RESIDUO, residuo.string());
}
}
return TRUE;
}
///////////////////////////////////////////////////////////
// Metodi di prima nota
///////////////////////////////////////////////////////////
@ -471,13 +579,17 @@ bool TPrimanota_application::showpartite_handler(TMask_field& f, KEY k)
bool TPrimanota_application::edit_partite(int riga)
{
TToken_string& cgr = cgs().row(riga);
const TBill b(cgr, 2, 0x3); // Legge il conto della riga selezionata
const TBill b(cgr, 2, 0x3); // Legge il conto della riga selezionata
if (row_type(cgr) != 'K' || !b.ok())
return FALSE;
return FALSE; // Esci se il conto della riga cliente non e' valido
TGame_mask mask(b); // Inizializzazione maschera di selezione partite
curr_mask().autosave(get_relation()); // Aggiorna i dati della testata sulle partite
const TRectype& mov = get_relation()->curr();
partite().update_reg(mov);
TGame_mask mask(b); // Esecuzione maschera di selezione partite
mask.run();
cgs().force_update();
cgs().force_update(); // Aggiornamento righe contabili
return TRUE;
}
@ -510,9 +622,9 @@ int TPrimanota_application::nuovo_pagamento(TPartita& partita, int nriga, int ra
part.put(PART_NUMDOC, curr_mask().get(F_NUMDOC));
part.put(PART_DESCR, curr_mask().get(F_DESCR));
part.put(PART_CODVAL, riga_part.get(PART_CODVAL)); // Meglio prendere il cambio dalle scadenze
part.put(PART_CAMBIO, riga_part.get(PART_CAMBIO)); // piuttosto che dal cangiante mondo delle
part.put(PART_DATACAM, riga_part.get(PART_DATACAM)); // maschere interattive
part.put(PART_CODVAL, curr_mask().get(S_VALUTA));
part.put(PART_CAMBIO, curr_mask().get(S_CAMBIO));
part.put(PART_DATACAM, curr_mask().get(S_DATACAMBIO));
// Copia dati causale corrente
const int tipomov = causale().tipomov();
@ -599,28 +711,6 @@ int TPrimanota_application::nuovo_pagamento(TPartita& partita, int nriga, int ra
return nrigp;
}
HIDDEN bool importo_handler(TMask_field& f, KEY k)
{
TMask& m = f.mask();
if (k == K_F8)
{
f.set(m.get(S_RESIDUO));
k = K_TAB;
}
if (k == K_TAB && f.focusdirty())
{
const real i(f.get());
const real res(m.get(S_RESIDUO));
if (i >= res)
m.set(S_SALDOACC, "S");
}
return TRUE;
}
bool TPrimanota_application::notify_edit_pagamento(TPartita& p, TRectype& new_pag, int deleting)
{
if (deleting != 0)
@ -763,8 +853,7 @@ bool TPrimanota_application::notify_edit_pagamento(TPartita& p, TRectype& new_pa
bool TPrimanota_application::edit_pagamento(TPartita& p, int nriga, int nrata, int nrigp)
{
TMask m("cg2100s");
m.set_handler(S_IMPORTO, importo_handler);
TPay_mask m;
const TRiga_partite& parbas = p.riga(nriga);
const TRiga_scadenze& scaden = parbas.rata(nrata);
@ -788,20 +877,7 @@ bool TPrimanota_application::edit_pagamento(TPartita& p, int nriga, int nrata, i
m.set(S_DESCR, parbas.get(PART_DESCR)); // Descrizione documento
// Dati della scadenza che ha generato la partita
TReal_field& residuo = (TReal_field&)m.field(S_RESIDUO);
residuo.set_decimals(in_valuta ? 2 : 0);
real res = scaden.residuo(TRUE);
if (parbas.in_valuta())
res += oldpag.get_real(PAGSCA_IMPORTOVAL);
else
res += oldpag.get_real(PAGSCA_IMPORTO);
residuo.set(res.string()); // Residuo da pagare
m.set(S_DATASCAD, scaden.get(SCAD_DATASCAD)); // Data della scadenza
m.set(S_SEZIONE_SCAD, parbas.get(PART_SEZ)); // Sezione della rata
m.set(S_RATA, scaden.get(SCAD_NRATA));
m.set(S_IMPORTO_SCAD, scaden.get(SCAD_IMPORTO)); // Importo della rata
m.set(S_IMPORTOVAL_SCAD, scaden.get(SCAD_IMPORTOVAL)); // Importo in valuta
m.set_scad(scaden);
const KEY key = m.run();
if (key == K_ENTER || key == K_DEL)
@ -870,7 +946,7 @@ bool TPrimanota_application::notify_cgline_deletion(int numrig)
{
bool found = FALSE;
const long nreg = curr_mask().get_long(F_NUMREG);
_partite.add_reg_num(nreg, 0); // Carica tutte le partite interessate
partite().add_numreg(nreg); // Carica tutte le partite interessate
for (TPartita* game = _partite.first(); game; game = _partite.next())
found |= notify_cgline_deletion(*game, nreg, numrig);

73
cg/saldacon.cpp
View File

@ -529,19 +529,24 @@ TImporto TPartita::importo_speso(long nreg, int numrig, bool extra) const
}
void TPartita::update_reg_num(long nreg, const TRectype& mov)
{
void TPartita::update_reg(long nreg, const TRectype& mov)
{
for (int r = last(); r > 0; r = pred(r))
{
TRectype& pag = _part.row(r, FALSE);
const long reg = pag.get_long(PART_NREG);
if (reg == nreg)
{
pag.put(PART_NREG, mov.get(MOV_NUMREG));
pag.put(PART_DATAREG, mov.get(MOV_DATAREG));
pag.put(PART_NUMDOC, mov.get(MOV_NUMDOC));
pag.put(PART_DATADOC, mov.get(MOV_DATADOC));
pag.put(PART_NUMDOC, mov.get(MOV_NUMDOC));
pag.put(PART_REG, mov.get(MOV_REG));
pag.put(PART_PROTIVA, mov.get(MOV_PROTIVA));
pag.put(PART_CODCAUS, mov.get(MOV_CODCAUS));
pag.put(PART_CODVAL, mov.get(MOV_CODVAL));
pag.put(PART_CAMBIO, mov.get(MOV_CAMBIO));
pag.put(PART_DATACAM, mov.get(MOV_DATACAM));
}
}
}
@ -814,44 +819,56 @@ bool TPartite_array::write(bool re)
return err == NOERR;
}
// Aggiunge all'array tutte le partite che si riferiscono alla registrazione nreg
int TPartite_array::add_reg_num(long nreg, int numrig)
{
TRelation rel(LF_PARTITE);
TRectype& part = rel.lfile().curr();
// Costruzione filtro del cursore
part.zero();
part.put(PART_NREG, nreg);
if (numrig > 0)
part.put(PART_NUMRIG, numrig);
const TRectype filter(part);
void TPartite_array::destroy()
{
TAssoc_array::destroy();
_numreg = 0;
}
TCursor cur(&rel, "", 2, &filter, &filter);
for (cur = 0; cur.ok(); ++cur)
// Aggiunge all'array tutte le partite che si riferiscono alla registrazione nreg
int TPartite_array::add_numreg(long nreg)
{
if (nreg != _numreg)
{
TPartita& p = partita(part); // Aggiungi partita se non esiste gia'
p.remove_unassigned(nreg); // Togli righe non assegnate
}
TRelation rel(LF_PARTITE);
TRectype& part = rel.lfile().curr();
// Costruzione filtro del cursore
part.zero();
part.put(PART_NREG, nreg);
const TRectype filter(part);
TCursor cur(&rel, "", 2, &filter, &filter);
for (cur = 0; cur.ok(); ++cur)
{
TPartita& p = partita(part); // Aggiungi partita se non esiste gia'
p.remove_unassigned(nreg); // Togli righe non assegnate
}
_numreg = nreg;
}
return (int)cur.items();
return items();
}
TImporto TPartite_array::importo_speso(long nreg, int numrig, bool extra)
{
TImporto imp;
add_reg_num(nreg, numrig);
add_numreg(nreg);
for (TPartita* game = first(); game; game = next())
imp += game->importo_speso(nreg, numrig, extra);
return imp;
}
void TPartite_array::update_reg_num(long nreg, const TRectype& mov)
void TPartite_array::update_reg(const TRectype& mov, long old_nreg)
{
add_reg_num(nreg, 0);
if (old_nreg <= 0)
old_nreg = mov.get_long(MOV_NUMREG);
add_numreg(old_nreg);
for (TPartita* game = first(); game; game = next())
game->update_reg_num(nreg, mov);
game->update_reg(old_nreg, mov);
}

11
cg/saldacon.h
View File

@ -161,7 +161,7 @@ public:
const TString& descrizione() const { return _part.key().get(PART_DESCR); }
TImporto importo_speso(long numreg, int numrig, bool extra) const;
void update_reg_num(long nreg, const TRectype& mov);
void update_reg(long nreg, const TRectype& mov);
void calcola_saldo(TImporto& saldo, TImporto& doc, TImporto& pag, TImporto& imp) const;
bool modifica_pagamento(const TRectype& new_pag,
@ -177,6 +177,7 @@ public:
class TPartite_array : private TAssoc_array
{
TString80 _key; // Work string
long _numreg; // Last registration loaded
protected:
const TString& key(const TBill& clifo, int anno, const char* num); // Build key for TAssoc_array
@ -184,7 +185,7 @@ protected:
TPartita* find(const TRectype& part, bool create);
public: // TAssoc_array
virtual void destroy() { TAssoc_array::destroy(); }
virtual void destroy();
public:
TPartita& partita(const TBill& clifo, int anno, const char* numero);
@ -199,14 +200,14 @@ public:
bool write(bool re = FALSE);
bool rewrite() { return write(TRUE); }
int add_reg_num(long numreg, int numrig);
int add_numreg(long numreg); // Carica tutte le partite relative alla registrazione numreg
TImporto importo_speso(long numreg, int numrig, bool extra);
void update_reg_num(long nreg, const TRectype& mov);
void update_reg(const TRectype& mov, long old_reg = 0);
TPartita* first() { restart(); return next(); }
TPartita* next() { return (TPartita*)get(); }
TPartite_array() {}
TPartite_array() : _numreg(0) {}
virtual ~TPartite_array() {}
};