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

Continua senza posa lo sviluppo del saldaconto

Browse Source 
git-svn-id: svn://10.65.10.50/trunk@1224 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
guy 1995-04-10 15:24:57 +00:00
parent 2db49dce54
commit 5ef3de0323
12 changed files with 526 additions and 294 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
cg/Attic/cg1400.cpp
View File

@ -133,6 +133,8 @@ int TStampa_deleghe_IVA::select()
TToken_string d(80);
_ditte->destroy();
begin_wait();
for (_nditte->first(); _nditte->good(); _nditte->next())
{
TLocalisamfile& anag = _nditte->lfile(LF_ANAG);
@ -166,6 +168,7 @@ int TStampa_deleghe_IVA::select()
}
}
}
end_wait();
int res = 1;
if (_ditte->items() > 0)

3
cg/cg1400.cpp
View File

@ -133,6 +133,8 @@ int TStampa_deleghe_IVA::select()
TToken_string d(80);
_ditte->destroy();
begin_wait();
for (_nditte->first(); _nditte->good(); _nditte->next())
{
TLocalisamfile& anag = _nditte->lfile(LF_ANAG);
@ -166,6 +168,7 @@ int TStampa_deleghe_IVA::select()
}
}
}
end_wait();
int res = 1;
if (_ditte->items() > 0)

10
cg/cg2100.cpp
View File

@ -161,6 +161,7 @@ bool TPrimanota_application::user_create()
_comuni = new TLocalisamfile(LF_COMUNI);
_occas = new TLocalisamfile(LF_OCCAS);
_nditte = new TLocalisamfile(LF_NDITTE);
_scadenze = new TLocalisamfile(LF_SCADENZE);
_rel = new TMovimentoPN;
_rel->add(LF_PARTITE, "NREG=NUMREG", 2);
@ -194,6 +195,8 @@ bool TPrimanota_application::user_destroy()
delete _giornale;
delete _causale;
delete _rel;
delete _scadenze;
delete _nditte;
delete _occas;
delete _comuni;
@ -544,6 +547,8 @@ void TPrimanota_application::init_insert_mode(TMask& m)
set_pagamento(NULL,dt);
set_scadenze(m);
}
else
_partite.destroy();
_saldi.reset(); // Inizializza saldi
}
@ -555,6 +560,8 @@ void TPrimanota_application::init_modify_mode(TMask& m)
calcola_saldo(); // Verifica eventuali sbilanci contabili
if (iva() != nessuna_iva)
calcola_imp(); // Calcola totale imponibile ed imposte
else
_partite.destroy();
}
// Controlla sulla causale se il segno del totale documento (ritsoc=FALSE)
@ -662,7 +669,6 @@ int TPrimanota_application::read(TMask& m)
riga.add(r.get("CODIVA")); // IVA 102
riga.add(r.get("TIPODET")); // Detrazione 103
real imposta(r.get("IMPOSTA"));
if (to_swap) imposta = -imposta;
if (imponibile.sign() * imposta.sign() < 0)
@ -680,7 +686,7 @@ int TPrimanota_application::read(TMask& m)
}
TString16 dt(m.get(F_DATAREG));
set_pagamento(m.get(F_CODPAG),dt);
set_pagamento(m.get(F_CODPAG), dt);
if (!read_scadenze(m))
set_scadenze(m);

2
cg/cg2100s.uml
View File

@ -124,7 +124,7 @@ BEGIN
WARNING "Inserire un importo inferiore al residuo"
END
NUMBER S_IMPORTOPAG 15
NUMBER S_RITENUTE 15
BEGIN
PROMPT 38 8 "Ritenute professionali "
PICTURE "."

2
cg/cg2102.cpp
View File

@ -803,7 +803,7 @@ bool TPrimanota_application::imposta_handler(TMask_field& f, KEY key)
if (val != imposta)
{
f.warning_box("L'imposta dovrebbe essere %s", (const char*)imposta.string("."));
if (val.is_zero()) f.set(imposta.string());
if (imposta.is_zero()) f.reset();
}
} else
if (key == K_F8)

18
cg/cg2102.h
View File

@ -1,14 +1,14 @@
#ifndef __CG2102_H
#define __CG2102_H
#ifndef __MSKSHEET_H
#include <msksheet.h>
#endif
#ifndef __RELAPP_H
#include <relapp.h>
#endif
#ifndef __PAGAMENT_H
#include "pagament.h"
#endif
#ifndef __CGLIB_H
#include "cglib.h"
#endif
@ -21,8 +21,6 @@
#include "cg2103.h"
#endif
class TPagamento;
class TPrimanota_application : public TRelation_application
{
TMovimentoPN* _rel;
@ -37,6 +35,8 @@ class TPrimanota_application : public TRelation_application
TLocalisamfile* _comuni;
TLocalisamfile* _occas;
TLocalisamfile* _nditte;
TLocalisamfile* _scadenze;
TPagamento* _pag;
TCausale* _causale; // Causale corrente
@ -56,6 +56,7 @@ class TPrimanota_application : public TRelation_application
bool _is_saldaconto; // saldaconto si/no (vede parametri e causale)
TSaldo_agg _saldi; // Saldi da aggiornare
TPartite_array _partite; // Partite coinvolte
TMask* _msk[4]; // Maschere di query, cg, iva
long _lastreg; // Numero ultima registrazione
@ -210,8 +211,9 @@ protected:
void write_scadenze(const TMask& m);
bool edit_partite(int riga);
bool edit_scadenze(int riga, const TBill& b, int anno, const char* num);
bool edit_pagamento(TRectype& parbas, TRectype& scaden, TRectype& part);
bool edit_scadenze(int anno, const char* num);
int nuovo_pagamento(TPartita& partita, int rata, int rmov, TRectype& part);
bool edit_pagamento(TPartita& partita, TRectype& part);
static TPrimanota_application& app() { return (TPrimanota_application&)main_app(); }

8
cg/cg2103.cpp
View File

@ -483,15 +483,15 @@ TCodiceIVA::TCodiceIVA(const char* cod) : TRectype(LF_TABCOM)
bool TCodiceIVA::read(const char* cod)
{
int err = ~NOERR;
TTable iva("%IVA");
if (cod && *cod)
{
iva.setkey(1);
TTable iva("%IVA");
iva.put("CODTAB", cod);
err = iva.read();
TRectype::operator=(iva.curr());
}
TRectype::operator=(iva.curr());
if (err != NOERR) zero();
if (err != NOERR)
zero();
return err == NOERR;
}

2
cg/cg2103.h
View File

@ -137,7 +137,7 @@ public:
bool read(const char* codice);
bool ok() const { return !empty(); }
const TString& codice() const { return get("CODTAB"); }
real percentuale() const { return get_real("R0"); }
const real& percentuale() const { return get_real("R0"); }
const TString& tipo() const { return get("S1"); }
};

476
cg/cg2104.cpp
View File

@ -270,10 +270,6 @@ bool TPrimanota_application::read_scadenze(const TMask& m)
int nriga = 1;
int numrig = 1;
// partita.put("TIPOCF", tipocf);
// partita.put("GRUPPO", gruppo);
// partita.put("CONTO", conto);
// partita.put("SOTTOCONTO", sottoconto);
partita.put(PART_ANNO, anno);
partita.put(PART_NUMPART, numpart);
partita.put(PART_NRIGA, nriga);
@ -307,10 +303,6 @@ bool TPrimanota_application::read_scadenze(const TMask& m)
{
// cerca rata
scadenza.zero();
// scadenza.put("TIPOCF", tipocf);
// scadenza.put("GRUPPO", gruppo);
// scadenza.put("CONTO", conto);
// scadenza.put("SOTTOCONTO", sottoconto);
scadenza.put(PART_ANNO, anno);
scadenza.put(PART_NUMPART, numpart);
scadenza.put(PART_NRATA, i+1);
@ -378,10 +370,6 @@ void TPrimanota_application::write_scadenze(const TMask& m)
int nriga = 1;
int numrig = 1;
// partita.put("TIPOCF", tipocf);
// partita.put("GRUPPO", gruppo);
// partita.put("CONTO", conto);
// partita.put("SOTTOCONTO", sottoconto);
partita.put("ANNO", anno);
partita.put("NUMPART", numpart);
partita.put("NRIGA", nriga);
@ -439,10 +427,6 @@ void TPrimanota_application::write_scadenze(const TMask& m)
{
new_scad = FALSE;
scadenza.zero();
// scadenza.put("TIPOCF", tipocf);
// scadenza.put("GRUPPO", gruppo);
// scadenza.put("CONTO", conto);
// scadenza.put("SOTTOCONTO", sottoconto);
scadenza.put("ANNO", anno);
scadenza.put("NUMPART", numpart);
scadenza.put("NRATA", i+1);
@ -475,10 +459,6 @@ void TPrimanota_application::write_scadenze(const TMask& m)
for (; !new_scad ; i++)
{
scadenza.zero();
// scadenza.put("TIPOCF", tipocf);
// scadenza.put("GRUPPO", gruppo);
// scadenza.put("CONTO", conto);
// scadenza.put("SOTTOCONTO", sottoconto);
scadenza.put("ANNO", anno);
scadenza.put("NUMPART", numpart);
scadenza.put("NRATA", i+1);
@ -494,6 +474,9 @@ void TPrimanota_application::write_scadenze(const TMask& m)
// Sheet partite
///////////////////////////////////////////////////////////
HIDDEN int _riga;
HIDDEN TImporto _soldi, _max;
bool TPrimanota_application::edit_partite(int riga)
{
begin_wait();
@ -503,7 +486,8 @@ 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
TImporto soldi; soldi = cgr; // Importo della riga selezionata
_riga = riga; // Riga correntemente in gestione
_soldi = cgr; // Importo della riga selezionata
TString80 caption("Partite aperte del conto ");
caption << b.gruppo() << ' ' << b.conto() << ' ' << b.sottoconto();
@ -545,7 +529,7 @@ bool TPrimanota_application::edit_partite(int riga)
{
const int numrig = partita.get_int(PART_NUMRIG);
if (numrig == (riga+1))
soldi -= i;
_soldi -= i;
}
}
else
@ -582,251 +566,212 @@ bool TPrimanota_application::edit_partite(int riga)
{
const int anno = a.row().get_int(0);
const TString16 num = a.row().get(1);
edit_scadenze(riga, b, anno, num); // Edita pagamenti
edit_scadenze(anno, num); // Edita pagamenti
}
}
return TRUE;
}
int TPrimanota_application::nuovo_pagamento(TPartita& partita, int rata, int rmov, TRectype& part)
{
CHECKD(rata >= 1 && rata <= partita.rate(), "Rata errata ", rata);
CHECKD(!partita.rata_pagata(rata), "Rata pagata ", rata);
const int nriga = partita.righe();
CHECKD(nriga > 0, "Riga partita errata ", nriga);
part = partita.riga(nriga);
// PART_ANNO viene preso dalla partita base
// PART_NUMPART viene preso dalla partita base
part.put(PART_NRIGA, nriga+1); // Riga di partita
part.put(PART_TIPOMOV, causale().tipomov()); // Dati causale corrente
part.put(PART_CODCAUS, causale().codice());
part.put(PART_NREG, curr_mask().get(F_NUMREG)); // Numero operazione
part.put(PART_NUMRIG, rmov+1); // Riga su cui ho cliccato
// Copia dati movimento corrente
part.put(PART_DATAREG, curr_mask().get(F_DATAREG));
part.put(PART_DATADOC, curr_mask().get(F_DATADOC));
part.put(PART_NUMDOC, curr_mask().get(F_NUMDOC));
part.put(PART_DESCR, curr_mask().get(F_DESCR));
part.zero(PART_REG);
part.zero(PART_PROTIVA);
part.put(PART_SEZ, (partita.totale().sezione() == 'D') ? 'A' : 'D');
part.zero(PART_IMPORTO); // Azzera importi vari
part.zero(PART_IMPOSTA);
part.zero(PART_SPESE);
TString80 tmp;
part.zero(PART_CODVAL);
part.zero(PART_CAMBIO);
part.zero(PART_IMPORTOVAL);
part.zero(PART_DATACAM);
const TRectype& scadenza = partita.rata(rata);
tmp = scadenza.get(SCAD_CODPAG);
part.put(PART_CODPAG, tmp);
tmp = scadenza.get(SCAD_TIPOPAG);
part.put(PART_TIPOPAG, tmp);
int caus = 2; // Calcola riga causale per la contropartita in base al tipo pagamento
switch (atoi(tmp))
{
case 2: // Tratta
case 7: // Tratta accettata
caus = 3; break;
case 3: // Ricevuta bancaria
caus = 4; break;
case 4: // Cessione
caus = 5; break;
case 5: // Paghero'
caus = 6; break;
case 6: // Fattura di credito
caus = 7; break;
case 1: // Rimessa
case 8: // Rapporti interbancari diretti
case 9: // Bonifico
default:
caus = 2; break;
}
TBill bill; causale().bill(caus, bill);
if (bill.empty()) causale().bill(caus = 1, bill);
bill.put(part);
TBill b; b.get(partita.riga(1));
if (b.tipo() > ' ') // Se cliente o fornitore cerca sua banca
{
TRelation cliforel(LF_CLIFO);
cliforel.add(LF_CFVEN, "TIPOCF=TIPOCF|CODCF=CODCF");
TRectype& clifo = cliforel.lfile().curr();
clifo.put(CLI_TIPOCF, b.tipo());
clifo.put(CLI_CODCF, b.codclifo());
const int err = cliforel.read();
CHECK(err == NOERR, "Chiss'e' fregato il clifo");
tmp = clifo.get(CLI_CODABI);
part.put(PART_CODABI, tmp);
tmp = clifo.get(CLI_CODCAB);
part.put(PART_CODCAB, tmp);
tmp = cliforel.lfile(LF_CFVEN).get(CLI_CODAG);
part.put(PART_CODAG, tmp);
}
else
{
part.zero(PART_CODABI);
part.zero(PART_CODCAB);
part.zero(PART_CODAG);
}
part.zero(PART_IMPTOTPAG);
part.zero(PART_SALACC);
part.zero(PART_RITENUTE);
part.zero(PART_DATARIFPAG);
part.zero(PART_NUMRIFPAG);
part.zero(PART_CHIUSA);
tmp = scadenza.get(SCAD_NRATA);
part.put(PART_NRATA, tmp);
tmp = scadenza.get(SCAD_CODABIPR);
part.put(PART_CODABIPR, tmp);
tmp = scadenza.get(SCAD_CODCABPR);
part.put(PART_CODCABPR, tmp);
return nriga+1;
}
// Edit scadenze relative all'anno/numero partita specificati
bool TPrimanota_application::edit_scadenze(int currig, const TBill& b, int anno, const char* num)
bool TPrimanota_application::edit_scadenze(int anno, const char* num)
{
TString caption; caption.format("Pagamenti della partita %s dell'anno %d", num, anno);
TArray_sheet a(-1, -1, 0, 0, caption, "Rata|Data@10|Importo@15|Descrizione@50|Tipo", 0x8);
TArray_sheet a(-1, -1, 0, 0, caption, "Rata|Data@10|Importo@15|Descrizione@50|Riga", 0x8);
TLocalisamfile scadenza(LF_SCADENZE);
scadenza.zero(); scadenza.put(SCAD_ANNO, anno); scadenza.put(SCAD_NUMPART, num);
const TRectype recsca(scadenza.curr()); // Filtra scadenze su anno partita
TToken_string r(80);
for (int err = scadenza.read(_isgteq);
err == NOERR && scadenza.curr() == recsca;
err = scadenza.next())
TPartita* game = _partite.partita(anno, num);
if (game == NULL)
{
r.cut(0);
r.add(scadenza.get(SCAD_NRATA)); // Numero rata
r.add(scadenza.get(SCAD_DATASCAD)); // Data scadenza rata
r.add(scadenza.get(SCAD_IMPORTO)); // Importo rata
r.add(""); // Descrizione movimento
r.add(""); // Tipo movimento
a.add(r);
game = new TPartita(anno, num);
_partite.add(game);
}
TPartita& partita = *game;
TLocalisamfile partita(LF_PARTITE);
partita.setkey(1);
partita.zero(); partita.put(PART_ANNO, anno); partita.put(PART_NUMPART, num);
const TRectype recpar(partita.curr());
const long curreg = curr_mask().get_long(F_NUMREG); // Numero registrazione corrente
const TString16 curreg(curr_mask().get(F_NUMREG)); // Numero registrazione corrente
TString desc; // Descrizione di default
TToken_string r(80); // Work string
TRectype parbas(recpar); // Partita base
KEY k = K_ENTER;
bool dirty = TRUE;
for (err = partita.read(_isgteq); err == NOERR && partita.curr() == recpar; err = partita.next())
{
const int rata = partita.get_int(PART_NRATA); // Legge eventuale numero rata
if (desc.empty())
{
parbas = partita.curr(); // Memorizza parita base
desc = partita.get(PART_DESCR); // Aggiorna descrizione scadenze
for (int i = 0; i < a.items(); i++)
{
TToken_string& t = a.row(i);
const TFixed_string d(t.get(3));
if (d.blank()) t.add(desc, 3);
}
}
if (rata < 1 || partita.get(PART_REG).not_empty())
continue; // Ignora chi non e' un pagamento
for (long i = a.items()-1; i >= 0; i--) // Cerca scadenza corrispondente
if (a.row(i).get_int(0) == rata) break;
if (i < 0)
error_box("Non esiste una scadenza per la rata %d", rata);
r.cut(0);
r.add(rata);
r.add(partita.get(PART_DATADOC));
r.add(partita.get(PART_IMPORTO));
r.add(desc);
r.add(partita.get(PART_NRIGA));
i = a.insert(r, i >= 0 ? i+1 : -1);
// Disabilita la righe che non riguardano la riga cliccata
if (partita.get(PART_NREG) != curreg || partita.get_int(PART_NUMRIG) != (currig+1))
a.disable(i);
}
KEY k = a.items() > 0 ? K_ENTER : K_ESC; // Esce se non ci sono righe
while (k == K_ENTER)
{
k = a.run();
long pos;
if (k == K_ENTER)
if (dirty)
{
const int rata = a.row().get_int(0);
scadenza.zero();
scadenza.put(SCAD_ANNO, anno);
scadenza.put(SCAD_NUMPART, num);
scadenza.put(SCAD_NRATA, rata);
err = scadenza.read();
CHECKD(err == NOERR, "Non ritrovo piu' la scadenza della rata ", rata);
const TString desc(partita.descrizione());
int urig = 1;
int nrig = a.row().get_int(4);
if (nrig == 0) // Ho cliccato su una scadenza
a.destroy();
long nr;
for (int s = 1; s <= partita.rate(); s++)
{
for (pos = a.selected()+1; pos < a.items(); pos++) // Cerca pagamento
const TRectype& rata = partita.rata(s);
r.cut(0);
r.add(rata.get(SCAD_NRATA));
r.add(rata.get(SCAD_DATASCAD));
r.add(rata.get(SCAD_IMPORTO));
r.add(desc);
r.add("S");
nr = a.add(r);
if (partita.rata_pagata(s))
a.disable(nr);
for (int p = 1; p <= partita.righe(); p++)
{
const int nr = a.row(pos).get_int(4);
if (nr) urig = nr;
if (nr == 0 || a.enabled(pos))
const TRectype& paga = partita.riga(p);
if (paga.get_int(PART_NRATA) == s)
{
nrig = nr;
break;
r.cut(0);
r.add(s);
r.add(paga.get(PART_DATAREG));
r.add(paga.get(PART_IMPORTO));
r.add(paga.get(PART_DESCR));
r.add(paga.get(PART_NRIGA));
nr = a.add(r);
if (paga.get_long(PART_NREG) != curreg || paga.get_int(PART_NUMRIG) != _riga+1)
a.disable(nr);
}
}
}
const bool nuovo = nrig == 0;
TRectype part(parbas);
if (nuovo) // Inserimento di un nuovo pagamento
{
// PART_ANNO viene preso dalla partita base
// PART_NUMPART viene preso dalla partita base
nrig = urig+1;
part.put(PART_NRIGA, nrig); // Riga di partita
part.put(PART_TIPOMOV, causale().tipomov()); // Dati causale corrente
part.put(PART_CODCAUS, causale().codice());
part.put(PART_NREG, curreg); // Numero operazione
part.put(PART_NUMRIG, currig+1); // Riga su cui ho cliccato
// Copia dati movimento corrente
part.put(PART_DATAREG, curr_mask().get(F_DATAREG));
part.put(PART_DATADOC, curr_mask().get(F_DATADOC));
part.put(PART_NUMDOC, curr_mask().get(F_NUMDOC));
part.put(PART_DESCR, curr_mask().get(F_DESCR));
part.zero(PART_REG);
part.zero(PART_PROTIVA);
TImporto imp; imp = cgs().row(currig);
part.put(PART_SEZ, imp.sezione()); // Sezione della riga cliccata
part.zero(PART_IMPOSTA);
part.zero(PART_IMPORTO);
part.zero(PART_SPESE);
TString80 tmp;
tmp = scadenza.get(SCAD_CODPAG);
part.put(PART_CODPAG, tmp);
tmp = scadenza.get(SCAD_TIPOPAG);
part.put(PART_TIPOPAG, tmp);
part.zero(PART_CODVAL);
part.zero(PART_CAMBIO);
part.zero(PART_IMPORTOVAL);
part.zero(PART_DATACAM);
int caus = 2; // Calcola riga causale per la contropartita
switch (atoi(tmp))
{
case 2: // Tratta
case 7: // Tratta accettata
caus = 3; break;
case 3: // Ricevuta bancaria
caus = 4; break;
case 4: // Cessione
caus = 5; break;
case 5: // Paghero'
caus = 6; break;
case 6: // Fattura di credito
caus = 7; break;
case 1: // Rimessa
case 8: // Rapporti interbancari diretti
case 9: // Bonifico
default:
caus = 2; break;
}
TBill bill; causale().bill(caus, bill);
if (bill.empty()) causale().bill(caus = 1, bill);
bill.put(part);
if (b.tipo() > ' ') // Se cliente o fornitore cerca sua banca
{
TRelation cliforel(LF_CLIFO);
cliforel.add(LF_CFVEN, "TIPOCF=TIPOCF|CODCF=CODCF");
TRectype& clifo = cliforel.lfile().curr();
clifo.put(CLI_TIPOCF, b.tipo());
clifo.put(CLI_CODCF, b.codclifo());
const int err = cliforel.read();
CHECK(err == NOERR, "Chiss'e' fregato il clifo");
tmp = clifo.get(CLI_CODABI);
part.put(PART_CODABI, tmp);
tmp = clifo.get(CLI_CODCAB);
part.put(PART_CODCAB, tmp);
tmp = cliforel.lfile(LF_CFVEN).get(CLI_CODAG);
part.put(PART_CODAG, tmp);
}
else
{
part.zero(PART_CODABI);
part.zero(PART_CODCAB);
part.zero(PART_CODAG);
}
part.zero(PART_IMPTOTPAG);
part.zero(PART_RITENUTE);
part.zero(PART_DATARIFPAG);
part.zero(PART_NUMRIFPAG);
part.zero(PART_CHIUSA);
tmp = scadenza.get(SCAD_NRATA);
part.put(PART_NRATA, tmp);
tmp = scadenza.get(SCAD_CODABIPR);
part.put(PART_CODABIPR, tmp);
tmp = scadenza.get(SCAD_CODCABPR);
part.put(PART_CODCABPR, tmp);
}
else
{
}
if (edit_pagamento(parbas, scadenza.curr(), part))
{
err = nuovo ? partita.write(part) : partita.rewrite(part);
if (nuovo && err == NOERR)
{
r.cut(0);
r.add(part.get(PART_NRATA));
r.add(part.get(PART_DATADOC));
r.add(part.get(PART_IMPORTO));
r.add(part.get(PART_DESCR));
r.add(part.get(PART_NRIGA));
a.insert(r, pos);
}
}
}
}
k = a.run();
if (k == K_ENTER)
{
const int rata = a.row().get_int(0);
int nrig = a.row().get_int(4); // Numero riga pagamento corrente
TRectype part(LF_PARTITE);
if (nrig == 0) // Se ho cliccato su una scadenza ...
nrig = nuovo_pagamento(partita, rata, _riga, part);
else
part = partita.riga(nrig);
dirty = edit_pagamento(partita, part);
} // if k == K_ENTER
} // while k == K_ENTER
return TRUE;
}
@ -847,6 +792,12 @@ static bool importopag_handler(TMask_field& f, KEY k)
i = r;
f.set(i.string());
}
if (i > _max.valore())
{
const TFixed_string val(_max.valore().string("."));
warning_box("La riga contabile ha un residuo di %s", (const char*)val);
f.set(val);
}
if (i == r)
{
m.set(S_SALDOACC, "X");
@ -855,11 +806,17 @@ static bool importopag_handler(TMask_field& f, KEY k)
else
m.enable(S_SALDOACC);
}
else
if (k == K_F8)
{
const TString& val = f.mask().get(S_RESIDUO);
f.set(val);
}
return TRUE;
}
bool TPrimanota_application::edit_pagamento(TRectype& parbas, TRectype& scaden, TRectype& part)
bool TPrimanota_application::edit_pagamento(TPartita& p, TRectype& part)
{
TMask m("cg2100s");
m.set_handler(S_IMPORTOPAG, importopag_handler);
@ -869,6 +826,10 @@ bool TPrimanota_application::edit_pagamento(TRectype& parbas, TRectype& scaden,
partita.curr() = part;
m.autoload(&rel); // Load current record on mask
const TRectype& parbas = p.riga(1);
const int rata = part.get_int(PART_NRATA);
const TRectype& scaden = p.rata(rata);
const real dapagare(scaden.get(SCAD_IMPORTO));
const real pagato(scaden.get(SCAD_IMPORTOPAG));
const real residuo = dapagare - pagato;
@ -890,8 +851,7 @@ bool TPrimanota_application::edit_pagamento(TRectype& parbas, TRectype& scaden,
const real importo(part.get(PART_IMPORTO));
const real ritenute(part.get(PART_RITENUTE));
if (importo.is_zero())
m.set(S_IMPORTOPAG, residuo.string());
_max.set(_soldi.sezione(), _soldi.valore() + importo); // Importo massimo del campo S_IMPORTOPAG
const KEY key = m.run();
if (key == K_ENTER)
@ -899,8 +859,36 @@ bool TPrimanota_application::edit_pagamento(TRectype& parbas, TRectype& scaden,
m.autosave(&rel);
part = partita.curr();
const char sez = _soldi.sezione() == 'D' ? 'A' : 'D';
const real imp(m.get(S_IMPORTOPAG));
scaden.put(SCAD_IMPORTOPAG, pagato-importo+imp);
const TImporto impg(sez, imp-importo);
if (!impg.is_zero())
{
_soldi += impg; // Sottrai soldi spesi qui
TBill conto(m.get_int(S_GRUPPO), m.get_int(S_CONTO), m.get_long(S_SOTTOCONTO));
const int riga = bill2pos(conto, 'I');
if (riga < 0)
set_cgs_row(riga, impg, conto, m.get(S_DESCAGG), 'I');
else
add_cgs_imp(riga, impg);
}
const real rit(m.get(S_RITENUTE));
const TImporto ritg(sez, rit-ritenute);
if (!ritg.is_zero())
{
const riga = type2pos('F');
if (riga < 0)
{
TBill conto_rit; causale().bill(11, conto_rit);
set_cgs_row(riga, ritg, conto_rit, "", 'F');
}
else add_cgs_imp(riga, ritg);
}
p.add_riga(part);
}
return key == K_ENTER;

6
cg/conto.cpp
View File

@ -324,6 +324,9 @@ const TImporto& TImporto::set(char s, const real& v)
const TImporto& TImporto::operator += (const TImporto& i)
{
if (_valore.is_zero())
_sezione = i._sezione;
if (_sezione == i._sezione)
_valore += i._valore;
else
@ -334,6 +337,9 @@ const TImporto& TImporto::operator += (const TImporto& i)
const TImporto& TImporto::operator -= (const TImporto& i)
{
if (_valore.is_zero())
_sezione = i._sezione;
if (_sezione == i._sezione)
_valore -= i._valore;
else

198
cg/pagament.cpp
View File

@ -1,6 +1,10 @@
#include "pagament.h"
#include <utility.h>
#include "pagament.h"
#include <scadenze.h>
int TPagamento::_rata_ifield(int n, int f) const
{
TToken_string& t = (TToken_string&)_rate[n];
@ -905,14 +909,13 @@ void TPagamento::set_sheet(TSheet_field& sf, int sscad)
// si istanzia uno sheet di primanota
for (int i = 0; i < n_rate(); i++)
{
TToken_string* ts = new TToken_string(36);
TToken_string& ts = sf.row(-1);
// istanzia, o stronzo
ts->add((const char*)data_rata(i));
ts->add(perc_rata(i).string());
ts->add(tpay_rata(i).string());
ts->add(tipo_rata(i));
ts->add(desc_tipo(tipo_rata(i)));
sf.row(-1) = (*ts);
ts.add((const char*)data_rata(i));
ts.add(perc_rata(i).string());
ts.add(tpay_rata(i).string());
ts.add(tipo_rata(i));
ts.add(desc_tipo(tipo_rata(i)));
if (ratapagata(i))
{
sf.disable_cell(1,1); // percentuale
@ -924,14 +927,13 @@ void TPagamento::set_sheet(TSheet_field& sf, int sscad)
{
for (int i = 0, scr = 0; i < n_rate(); i++)
{
TToken_string* s = new TToken_string(32);
TToken_string& s = sf.row(-1);
scr += scad_rata(i);
s->add(format("%d",scr));
s->add(perc_rata(i).string());
s->add(format("%d",tipo_rata(i)));
s->add(desc_tipo(tipo_rata(i)));
s->add(ulc_rata(i));
sf.row(-1) = *s;
s.add(scr);
s.add(perc_rata(i).string());
s.add(tipo_rata(i));
s.add(desc_tipo(tipo_rata(i)));
s.add(ulc_rata(i));
}
}
else // new: set with 1 or 2 rates according to tpr
@ -944,14 +946,13 @@ void TPagamento::set_sheet(TSheet_field& sf, int sscad)
for (int i = 0, scr = 0; i < n_rate(); i++)
{
TToken_string* s = new TToken_string(32);
TToken_string& s = sf.row(-1);
scr += scad_rata(i);
s->add(format("%d",scr));
s->add(perc_rata(i).string());
s->add(format("%d",tipo_rata(i)));
s->add(desc_tipo(tipo_rata(i)));
s->add(ulc_rata(i));
sf.row(-1) = *s;
s.add(format("%d",scr));
s.add(perc_rata(i).string());
s.add(format("%d",tipo_rata(i)));
s.add(desc_tipo(tipo_rata(i)));
s.add(ulc_rata(i));
}
}
if (_tpr > 0)
@ -980,3 +981,156 @@ _spese(0.0), _code(codtab), _dirty(FALSE), _inited(FALSE)
_new = TRUE;
// if (_new && data != NULL) error_box("Modalita' pagamento inesistente");
}
///////////////////////////////////////////////////////////
// TPartita
///////////////////////////////////////////////////////////
TPartita::TPartita(int anno, const char* num)
: _scad(LF_SCADENZE, SCAD_NRATA), _part(LF_PARTITE, PART_NRIGA)
{
read(anno, num);
}
int TPartita::add_riga(const TRectype& r)
{
const char sez = r.get_char(PART_SEZ);
const real val = r.get_real(PART_IMPORTO);
const TImporto imp(sez, val);
TImporto grow(imp);
const int n = r.get_int(PART_NRIGA);
CHECK(n > 0, "Numero riga nullo");
if (n <= righe())
{
const TRectype& oldrow = riga(n);
const char osez = oldrow.get_char(PART_SEZ);
const real oval = oldrow.get_real(PART_IMPORTO);
const TImporto old(osez, oval);
grow -= old;
}
_totale += grow;
if (rate() > 0) // Se sono in aggiornamento (non nella read!)
{
const int nr = r.get_int(PART_NRATA);
TRectype scad = rata(nr);
real ip(scad.get(SCAD_IMPORTOPAG));
ip += grow.valore();
scad.put(SCAD_IMPORTOPAG, ip);
add_rata(scad);
}
return _part.add_row(r);
}
int TPartita::add_rata(const TRectype& r)
{
return _scad.add_row(r);
}
// Costruisce le righe della partita a partire da 1
bool TPartita::read(int anno, const char* num)
{
TRectype partita(LF_PARTITE); partita.zero();
partita.put(PART_ANNO, anno); partita.put(PART_NUMPART, num);
_part.read(partita);
TRectype scadenza(LF_SCADENZE); scadenza.zero();
scadenza.put(SCAD_ANNO, anno); scadenza.put(SCAD_NUMPART, num);
_scad.read(scadenza);
_totale.set('D', ZERO); // Azzera totale partita
for (int i = 1; i <= righe(); i++)
{
const TRectype& r = riga(i);
const char sez = r.get_char(PART_SEZ);
const real val = r.get_real(PART_IMPORTO);
const TImporto imp(sez, val);
_totale += imp;
}
return ok();
}
bool TPartita::reread()
{
const int year = anno();
const TString16 num = numero();
return read(year, num);
}
bool TPartita::write(bool re)
{
const bool ok = _part.write(re) && _scad.write(re);
return ok;
}
int TPartita::ultimo_pagamento(int rata) const
{
int ultimo = 1;
for (int p = 1; p <= righe(); p++)
{
const TRectype& paga = riga(p);
if (paga.get_int(PART_NRATA) == rata)
{
int u = paga.get_int(PART_NRIGA); // Non pretende che siano in ordine
if (u > ultimo) ultimo = u;
}
}
return ultimo;
}
// Controlla se la rata r e' stata completamente pagata
bool TPartita::rata_pagata(int r) const
{
const TRectype& scad = rata(r);
real importo(scad.get(SCAD_IMPORTO));
importo -= scad.get_real(SCAD_IMPORTOPAG);
const bool pagata = importo.is_zero();
return pagata;
}
///////////////////////////////////////////////////////////
// TPartite_array
///////////////////////////////////////////////////////////
// Certified 99%
const TString& TPartite_array::key(int anno, const char* num)
{
_key.format("%4d%s", anno, num);
return _key;
}
// Certified 99%
void TPartite_array::add(TPartita* p)
{
const TString& k = key(p->anno(), p->numero());
TAssoc_array::add(k, p);
}
TPartita* TPartite_array::partita(int anno, const char* num)
{
const TString& k = key(anno, num);
TPartita* p = (TPartita*)objptr(k);
return p;
}
bool TPartite_array::write(bool re)
{
int err = NOERR;
restart();
TPartita* p;
while ((p = (TPartita*)get()) != NULL)
{
err = p->write(re);
if (err != NOERR) // L'errore viene gia' segnalato dalla partita
break;
}
return err == NOERR;
}

70
cg/pagament.h
View File

@ -1,6 +1,10 @@
#ifndef __PAGAMENT_H
#define __PAGAMENT_H
#ifndef __ASSOC_H
#include <assoc.h>
#endif
#ifndef __MSKSHEET_H
#include <msksheet.h>
#endif
@ -9,6 +13,14 @@
#include <tabutil.h>
#endif
#ifndef __RELATION_H
#include <relation.h>
#endif
#ifndef __CONTO_H
#include "conto.h"
#endif
// Error codes for pagation
const word P_OK = 0x0000; // ok
const word P_RSUM = 0x0001; // percentages do not sum up to 100
@ -136,4 +148,62 @@ public:
virtual ~TPagamento() {}
};
#ifndef __PARTITE_H
#include <partite.h>
#endif
class TPartita : public TObject
{
TRecord_array _scad, _part;
TImporto _totale;
public: // TObject
virtual bool ok() const { return rate() > 0; }
public:
int add_riga(const TRectype& r);
const TRectype& riga(int r) const { return _part.row(r); }
int righe() const { return _part.rows(); }
bool rata_pagata(int r) const;
int add_rata(const TRectype& r);
const TRectype& rata(int r) const { return _scad.row(r); }
int rate() const { return _scad.rows(); }
int ultimo_pagamento(int rata) const;
bool reread();
bool read(int anno, const char* num);
bool write(bool re = FALSE);
bool rewrite() { return write(TRUE); }
int anno() const { return riga(1).get_int(PART_ANNO); }
const TString& numero() const { return riga(1).get(PART_NUMPART); }
const TString& descrizione() const { return riga(1).get(PART_DESCR); }
const TImporto& totale() const { return _totale; }
TPartita(int anno, const char* num);
};
class TPartite_array : private TAssoc_array
{
TString16 _key;
protected:
const TString& key(int anno, const char* num);
public: // TAssoc_array
virtual void destroy() { TAssoc_array::destroy(); }
public:
TPartita* partita(int anno, const char* numero);
void add(TPartita* p);
bool write(bool re = FALSE);
bool rewrite() { return write(TRUE); }
TPartite_array() {}
};
#endif