root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/sc/sc0300.cpp
guy e9b0bd5311 Integrate modifiche a pareggio partite e aggiunta voce di menu 
git-svn-id: svn://10.65.10.50/branches/R_10_00@22646 c028cbd2-c16b-5b4b-a496-9718f37d4682
2012-04-24 10:23:55 +00:00

643 lines
17 KiB
C++
Raw Blame History

#include "sc0300a.h"
#include "../cg/cgsalda3.h"
#include <applicat.h>
#include <automask.h>
#include <progind.h>
#include <recset.h>
#include <relation.h>
#include <treectrl.h>
#include <causali.h>
#include <mov.h>
class TPareggio_tree : public TObject_tree
{
TPartite_array _games;
protected:
virtual TFieldtypes get_var(const TString& name, TVariant& var) const;
public:
bool init(const TBill& bill, const TString& valuta, bool nc, int stato); // Stato: 1=aperte; 2=chiuse; 0 o 3 = tutte
TPartita& partita(const TRectype& rec) const;
const TRectype* node2rec(const TString& id);
};
TPartita& TPareggio_tree::partita(const TRectype& rec) const
{
return ((TPartite_array&)_games).partita(rec);
}
const TRectype* TPareggio_tree::node2rec(const TString& id)
{
const TRectype* rec = NULL;
if (id.blank() || goto_node(id))
{
const TObject* obj = curr_node();
if (obj != NULL && obj->is_kind_of(CLASS_RECTYPE))
rec = (const TRectype*)obj;
}
return rec;
}
TFieldtypes TPareggio_tree::get_var(const TString& name, TVariant& var) const
{
TFieldtypes ft = _nullfld;
const TObject* obj = curr_node();
if (obj != NULL)
{
if (obj->is_kind_of(CLASS_RECTYPE))
{
const TRectype& rec = *(const TRectype*)obj;
ft = rec.type(name);
if (ft != _nullfld)
{
if (ft == _realfld)
{
var = rec.get_real(name).stringa(0, 2);
ft = _alfafld;
}
else
var = rec.get(name);
}
else
{
if (name.starts_with("PART.", true))
{
const TString& fld = name.after(".");
if (rec.num() == LF_SCADENZE)
{
const int nriga = rec.get_int(SCAD_NRIGA);
const TPartita& game = partita(rec);
var = game.riga(nriga).get(fld);
ft = _alfafld;
}
else
{
var = rec.get(fld);
ft = _alfafld;
}
} else
if (name == "RESIDUO")
{
TImporto saldo;
switch (rec.num())
{
case LF_SCADENZE:
if (!rec.get_bool(SCAD_PAGATA))
{
const TPartita& game = partita(rec);
const TRiga_scadenze& s = game.rata(rec.get_int(SCAD_NRIGA), rec.get_int(SCAD_NRATA));
saldo = s.residuo(true);
}
break;
case LF_PARTITE:
if (!rec.get_bool(PART_CHIUSA))
{
const TPartita& game = partita(rec);
saldo = game.calcola_saldo(true);
}
break;
default:
break;
}
var = saldo.valore().stringa(0, 2);
ft = _alfafld;
}
}
}
else
{
if (name == PART_NUMPART)
{
const real& year = *(real*)obj;
var = year.integer();
ft = _intfld;
}
}
}
return ft;
}
bool TPareggio_tree::init(const TBill& bill, const TString& valuta, bool nc, int stato)
{
_games.destroy();
goto_root();
kill_node();
TString filter;
if (bill.tipo() > ' ')
filter << PART_TIPOCF << '=' << bill.tipo();
else
{
filter << PART_GRUPPO << '=' << bill.gruppo() << ' ';
filter << PART_CONTO << '=' << bill.conto();
}
filter << ' ' << PART_SOTTOCONTO << '=' << bill.sottoconto();
TString query;
query << "USE PART SELECT (NRIGA<9999)&&(TIPOMOV<=" << (nc ? tm_nota_credito : tm_fattura) << ')'
<< "\nFROM " << filter << "\nTO " << filter;
TISAM_recordset games(query);
const TRectype& rec = games.cursor()->curr();
int last_year = 0;
TString80 id_year, id_rec;
TProgind pi(games.items(), nc ? TR("Caricamento note di credito") : TR("Caricamento fatture"));
for (bool ok = games.move_first(); ok; ok = games.move_next())
{
if (!pi.addstatus(1))
break;
const TString& codval = rec.get(PART_CODVAL);
if (!same_values(codval, valuta))
continue;
const tipo_movimento tm = (tipo_movimento)rec.get_int(PART_TIPOMOV);
bool add_riga = true;
if (nc)
{
add_riga = !rec.get_bool(PART_CHIUSA);
if (add_riga)
{
// Se filtro le note di credito cerco di riconoscere le fatture negative
if (tm == tm_fattura)
{
const char sezione_positiva = bill.tipo() == 'C' ? 'D' : 'A';
TImporto importo(rec.get_char(PART_SEZ), rec.get_real(PART_IMPORTO));
importo.normalize();
add_riga = sezione_positiva != importo.sezione(); // Ignora fattura positiva
}
else
{
const int nriga = rec.get_int(PART_NRIGA);
const TPartita& game = partita(rec);
add_riga = ((TPartita&)game).unassigned().exist(nriga);
}
}
}
else
{
if (stato == 1 || stato == 2)
{
const bool chiusa = rec.get_bool(PART_CHIUSA);
if (chiusa)
add_riga = stato == 2;
else
add_riga = stato == 1;
}
if (add_riga)
{
const char sezione_positiva = bill.tipo() == 'C' ? 'D' : 'A';
TImporto importo(rec.get_char(PART_SEZ), rec.get_real(PART_IMPORTO));
importo.normalize();
add_riga = sezione_positiva == importo.sezione(); // Ignora fattura negativa
}
}
if (!add_riga)
continue;
const int year = rec.get_int(PART_ANNO);
if (year != last_year)
{
goto_root();
while(goto_rbrother());
add_rbrother(real(year));
last_year = year;
curr_id(id_year);
id_rec.cut(0);
}
if (nc)
{
if (id_rec.full())
{
goto_node(id_rec);
add_rbrother(rec);
}
else
add_son(rec);
curr_id(id_rec);
}
else
{
TPartita& game = partita(rec);
const TRiga_partite& riga = game.riga(rec.get_int(PART_NRIGA));
for (int rata = 1; rata <= riga.rate(); rata++)
{
const TRiga_scadenze& s = riga.rata(rata);
bool add_rata = true;
if (stato == 1 || stato == 2)
{
const bool chiusa = s.get_bool(SCAD_PAGATA);
if (chiusa)
add_rata = stato == 2;
else
add_rata = stato == 1;
}
if (add_rata)
{
if (id_rec.full())
add_rbrother(s);
else
add_son(s);
curr_id(id_rec);
}
}
}
}
if (goto_node(id_year))
expand();
return goto_root();
}
///////////////////////////////////////////////////////////
// TScad_mask
///////////////////////////////////////////////////////////
class TScad_mask : public TAutomask
{
protected:
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public:
TScad_mask() : TAutomask("sc0300b") {}
};
bool TScad_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
switch (o.dlg())
{
case F_TUTTE:
if (e == se_query_add || e == se_query_del)
return false;
if (e = fe_close)
{
TSheet_field& s = (TSheet_field&)o;
real tot, imp = get_real(F_IMPORTO);
FOR_EACH_SHEET_ROW(s, r, row)
tot += real(row->get(0));
if (tot > imp)
return error_box(FR("Il totale degli importi (%s) supera la cifra disponibile (%s)"),
tot.stringa(), imp.stringa());
}
break;
default: break;
}
return true;
}
///////////////////////////////////////////////////////////
// TPareggio_mask
///////////////////////////////////////////////////////////
class TPareggio_mask : public TAutomask
{
TPareggio_tree _nc, _ft;
long _numreg;
protected:
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
const TString& reg2caus(const TString& reg) const;
bool ft2nc(const TRectype& rec);
bool abbuona_rata(const real& imp, const TRectype& nota, TRiga_scadenze& scad);
bool elabora(const TRectype& nota, TPointer_array& scadenze);
void refill();
public:
TPareggio_mask();
};
// Cerca una causale di nota di credito compatibile col registro reg
const TString& TPareggio_mask::reg2caus(const TString& reg) const
{
if (reg.full())
{
const char tipocf = get(F_TIPO)[0];
const TString& codcaus = get(tipocf == 'F' ? F_CODCAUS_F : F_CODCAUS_C);
const TString& cod = cache().get(LF_CAUSALI, codcaus, CAU_REG);
if (cod == reg)
return codcaus; // Siamo fortunati: va bene la causale standard
TISAM_recordset recset("USE CAUS SELECT (REG=#CODREG)&&(TIPOMOV=2)");
recset.set_var("#CODREG", reg);
if (recset.move_first())
return recset.get(CAU_CODCAUS).as_string();
}
return EMPTY_STRING;
}
// Trasforma una fattura negativa in nota di credito
bool TPareggio_mask::ft2nc(const TRectype& rec)
{
CHECK(rec.num() == LF_PARTITE, "Solo partite, grazie!");
const long numreg = rec.get_long(PART_NREG);
const TString4 codreg = rec.get(PART_REG);
const TString4 codcau = reg2caus(codreg);
if (codcau.blank())
return error_box(FR("E' necessario creare una causale di nota di credito sul registro %s"), (const char*)codreg);
TString msg;
msg << TR("Si desidera trasformare la fattura in nota di credito con causale ")
<< codcau << '\n' << cache().get(LF_CAUSALI, codcau, CAU_DESCR);
if (!yesno_box(msg))
return false;
int err = NOERR;
if (numreg > 0)
{
TLocalisamfile mov(LF_MOV);
mov.curr().put(MOV_NUMREG, numreg);
err = mov.read(_isequal, _lock);
if (err == NOERR)
{
mov.put(MOV_CODCAUS, codcau);
mov.put(MOV_TIPOMOV, tm_nota_credito);
err = mov.rewrite();
}
if (err != NOERR)
return error_box(FR("Impossibile modificare il movimento %ld: errore %d"), numreg, err);
}
if (err == NOERR)
{
TPartita& game = _nc.partita(rec);
const int nriga = game.prima_fattura(numreg);
if (nriga > 0)
{
TRiga_partite& fatt = game.riga(nriga);
fatt.put(PART_CODCAUS, codcau);
fatt.put(PART_TIPOMOV, tm_nota_credito);
TRectype& pag = game.unassigned().row(nriga, true);
pag.put(PAGSCA_IMPORTO, fatt.get(PART_IMPORTO));
err = game.rewrite() ? NOERR : _islocked;
}
else
err = _iskeynotfound;
}
if (err != NOERR)
return error_box(FR("Impossibile modificare la partita associata la movimento %ld: errore %d"), numreg, err);
return true;
}
bool TPareggio_mask::abbuona_rata(const real& imp, const TRectype& nota, TRiga_scadenze& scad)
{
const TValuta valuta(scad.riga());
const char* imp_field = valuta.in_valuta() ? PAGSCA_IMPORTOVAL : PAGSCA_IMPORTO;
TPartita& nc = _nc.partita(nota);
TPartita& ft = scad.partita();
TRiga_partite& new_nc = ft.new_row();
new_nc.put(PART_SEZ, scad.riga().get_char(PART_SEZ) == 'D' ? 'A' : 'D');
new_nc.put(PART_TIPOMOV, tm_nota_credito);
new_nc.put(PART_NREG, nota.get(PART_NREG));
new_nc.put(PART_CODCAUS, nota.get(PART_CODCAUS));
new_nc.put(PART_REG, nota.get(PART_REG));
new_nc.put(PART_NUMDOC, nota.get(PART_NUMDOC));
new_nc.put(PART_DATADOC, nota.get(PART_DATADOC));
TRectype new_pag = scad.new_row(new_nc.get_int(PART_NRIGA));
new_pag.put(imp_field, imp);
ft.modifica_pagamento(new_pag, valuta, true);
ft.write(true);
TRectype unass = nc.unassigned().row(nota.get_int(PART_NRIGA));
if (new_nc.get(PART_SEZ) == nota.get(PART_SEZ))
unass.add(imp_field, -imp);
else
unass.add(imp_field, imp);
nc.modifica_pagamento(unass, valuta, true);
nc.write(true);
return true;
}
bool TPareggio_mask::elabora(const TRectype& nota, TPointer_array& scadenze)
{
CHECK(nota.num() == LF_PARTITE, "Solo partite, grazie!");
const tipo_movimento tm = (tipo_movimento)nota.get_int(PART_TIPOMOV);
if (tm == tm_fattura && !ft2nc(nota))
return false;
TScad_mask ass;
const TString& codval = get(F_CODVAL);
ass.set(F_CODVAL, codval);
real residuo_nc = abs(nota.get_real(is_true_value(codval) ? PART_IMPORTOVAL : PART_IMPORTO));
ass.set(F_IMPORTO, residuo_nc);
TSheet_field& sheet = ass.sfield(F_TUTTE);
TString_array rate;
FOR_EACH_ARRAY_ITEM(scadenze, i, s)
{
const TRiga_scadenze& scad = *(TRiga_scadenze*)s;
TToken_string& row = sheet.row(-1);
const real residuo_scad = scad.residuo(true).valore();
real imp = residuo_nc;
if (imp > residuo_scad)
imp = residuo_scad;
row.add(imp.string());
residuo_nc -= imp;
row.add(scad.get(SCAD_DATASCAD));
row.add(residuo_scad.string());
row.add(scad.importo(true).valore().string());
}
if (ass.run() == K_ENTER)
{
FOR_EACH_SHEET_ROW(sheet, r, row)
{
const real imp = row->get(0);
if (imp > ZERO)
{
TRiga_scadenze& scad = (TRiga_scadenze&)scadenze[r];
abbuona_rata(imp, nota, scad);
}
}
}
return true;
}
void TPareggio_mask::refill()
{
TWait_cursor hourglass;
const short id = efield(F_FORNITORE).active() ? F_FORNITORE :
(efield(F_SOTTOCONTO).active() ? F_SOTTOCONTO : F_CLIENTE);
TBill bill; bill.get(*this, F_GRUPPO, F_CONTO, id, F_TIPO);
const int tipo = get_int(F_TUTTE);
const TString& codval = get(F_CODVAL);
_nc.init(bill, codval, true, 1); // Solo aperte
_ft.init(bill, codval, false, tipo);
tfield(F_NC_TREE).set_tree(&_nc);
tfield(F_FT_TREE).set_tree(&_ft);
_numreg = 0;
disable(DLG_LINK);
disable(DLG_RECALC);
}
bool TPareggio_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
switch (o.dlg())
{
//case F_SOTTOCONTO:
case F_CLIENTE:
case F_FORNITORE:
if (e == fe_modify && !o.empty())
refill();
break;
case F_CODVAL:
case F_TUTTE:
if (e == fe_modify)
refill();
break;
case F_CODCAUS_C:
case F_CODCAUS_F:
if (e == fe_init)
{
TEdit_field& e = (TEdit_field&)o;
TCursor& cur = *e.browse()->cursor();
cur = 0L;
e.set(cur.curr().get(CAU_CODCAUS));
}
break;
case F_NC_TREE:
case F_FT_TREE:
if (e == fe_button || e == fe_modify || e == fe_init)
{
_numreg = 0L;
TTree_field& tf = (TTree_field&)o;
if (tf.tree() != NULL)
{
TVariant var;
if (tf.tree()->get_var("PART.NREG", var))
_numreg = var.as_int();
}
enable(DLG_LINK, _numreg > 0);
bool can_conv = false;
if (_numreg > 0 && o.dlg() == F_NC_TREE)
{
TLocalisamfile mov(LF_MOV);
mov.put(MOV_NUMREG, _numreg);
can_conv = mov.read() == NOERR && mov.get_int(MOV_TIPOMOV) == tm_fattura;
}
enable(DLG_RECALC, can_conv);
const bool can_work = _nc.has_root() && _ft.has_root();
enable(DLG_ELABORA, can_work);
}
break;
case DLG_LINK:
if (_numreg > 0)
{
TRectype mov(LF_MOV);
mov.put(MOV_NUMREG, _numreg);
if (mov.edit())
refill();
}
break;
case DLG_RECALC:
if (e == fe_button)
{
const TRectype* nota = _nc.node2rec(EMPTY_STRING);
if (nota != NULL && ft2nc(*nota))
refill();
}
break;
case DLG_ELABORA:
if (e == fe_button)
{
const TRectype* nota = _nc.node2rec(EMPTY_STRING);
if (nota == NULL)
return error_box(TR("Selezionare una nota di credito nel pannello di sinistra"));
const TTree_field& ft = tfield(F_FT_TREE);
TPointer_array rate;
TString_array a;
if (ft.selection(a) > 0)
{
FOR_EACH_ARRAY_ROW(a, r, riga)
{
const TRectype* rec = _ft.node2rec(*riga);
if (rec)
rate.add((TRectype*)rec);
}
}
if (rate.items() > 0)
{
if (elabora(*nota, rate))
refill();
}
else
return error_box(TR("Selezionare almeno una rata nel pannello di destra"));
}
break;
default: break;
}
return true;
}
TPareggio_mask::TPareggio_mask() : TAutomask("sc0300a"), _numreg(0L)
{
TTree_field& nc = tfield(F_NC_TREE);
TTree_field& ft = tfield(F_FT_TREE);
RCT rct_nc; nc.get_rect(rct_nc);
RCT rct_ft; ft.get_rect(rct_ft);
RCT rct_ms; xvt_vobj_get_client_rect(nc.parent(), &rct_ms);
const int b = rct_nc.left;
rct_nc.right = rct_ft.left-b;
rct_ft.right = rct_ms.right - b;
nc.set_rect(rct_nc);
ft.set_rect(rct_ft);
}
///////////////////////////////////////////////////////////
// TPareggio_partite
///////////////////////////////////////////////////////////
class TPareggio_partite : public TSkeleton_application
{
protected:
virtual void main_loop();
};
void TPareggio_partite::main_loop()
{
const int anno = xvt_vobj_get_attr(NULL_WIN, ATTR_APPL_VERSION_YEAR);
if (anno >= 2121)
{
TPareggio_mask pm;
pm.run();
}
else
error_box(TR("Versione non supportata: %d"), anno);
}
///////////////////////////////////////////////////////////
// Main
///////////////////////////////////////////////////////////
int sc0300(int argc, char* argv[])
{
TPareggio_partite pp;
pp.run(argc, argv, TR("Pareggio Partite"));
return 0;
}
Reference in New Issue View Git Blame Copy Permalink