root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ba/baeur01.cpp
alex 3a17a5a00e Patch level : XX.218 
Files correlati     :
Ricompilazione Demo : [ ]
Commento            :
Riportata la versione AGA patch 218 sul main trunk


git-svn-id: svn://10.65.10.50/trunk@10087 c028cbd2-c16b-5b4b-a496-9718f37d4682
2002-02-26 16:20:19 +00:00

926 lines
25 KiB
C++
Executable File
Raw Blame History

#include <applicat.h>
#include <automask.h>
#include <dongle.h>
#include <execp.h>
#include <modaut.h>
#include <prefix.h>
#include <progind.h>
#include <relation.h>
#include <nditte.h>
#include <partite.h>
#include <scadenze.h>
#include <pagsca.h>
#include <saldi.h>
#include "baeur.h"
#include "baeur10.h"
#include "baeur11.h"
#include "../cg/cglib01.h"
#include "../mg/mag.h"
#include "../mg/movmag.h"
#include "../mg/rmovmag.h"
#include "../mg/mglib.h"
///////////////////////////////////////////////////////////
// Main app
///////////////////////////////////////////////////////////
class TEuro01_app : public TEuro_app
{
TAssoc_array _schede_passate;
protected:
void convert_saldi(const TDate& adozione, const TBill& arrotino);
void convert_partite();
virtual bool create();
public:
KEY convert_firm(long ditta);
bool has_mag() const;
bool has_percip() const;
TAssoc_array & passate() { return _schede_passate;}
virtual void main_loop();
};
inline TEuro01_app& app() { return (TEuro01_app&)main_app(); }
///////////////////////////////////////////////////////////
// Step 3
///////////////////////////////////////////////////////////
class TEuro03_mask : public TAutomask
{
void fill_ditte();
public:
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
TEuro03_mask() : TAutomask("baeur10") { }
};
void TEuro03_mask::fill_ditte()
{
TFilename lit, eur;
app().get_aree_dati(lit, eur);
TRelation rel(LF_NDITTE);
TCursor cur(&rel);
const TRectype& curr = rel.curr();
const long items = cur.items();
cur.freeze();
TSheet_field& ditte = sfield(F10_DITTE);
ditte.destroy();
for (cur = 0L; cur.pos() < items; ++cur)
{
const long ditta = curr.get_long(NDT_CODDITTA);
if (prefix().exist(ditta))
{
TToken_string& row = ditte.row(-1);
row.add(ditta);
row.add(curr.get(NDT_RAGSOC));
TFilename firm;
firm.format("%s/%05ldA", (const char*)eur, ditta);
COLOR col = COLOR_BLACK;
if (firm.exist())
{
firm.add("prassid.ini");
TConfig ini(firm, "Euro");
TString16 dde = ini.get("DataAdozione");
if (dde.empty())
{
row.add("Creata direttamente in Euro");
col = COLOR_RED;
}
else
{
TString str;
if (ini.get("ConversionOK").not_empty())
{
str << "Adotta l'Euro dal " << dde;
col = COLOR_GREEN;
}
else
{
str << "Conversione incompleta: ripetere l'operazione";
col = COLOR_CYAN;
}
row.add(str);
}
}
else
{
row.add("Non presente in Euro");
if (field(F10_DITTA).empty())
{
set(F10_DITTA, ditta);
set(F10_RAGSOC, row.get(1));
}
}
if (col != COLOR_BLACK)
{
int i = ditte.items()-1;
ditte.set_back_and_fore_color(col, -1, i);
}
}
}
ditte.force_update();
}
bool TEuro03_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
switch (o.dlg())
{
case F10_DITTA:
if (e == fe_modify || e == fe_close)
{
TSheet_field& s = sfield(F10_DITTE);
TEdit_field& f = efield(F10_DITTA);
const long ditta = atol(o.get());
for (int r = s.items()-1; r >= 0; r--)
{
TToken_string& row = s.row(r);
const long d = row.get_long(0);
if (d == ditta)
{
set(F10_RAGSOC, row.get());
break;
}
}
if (r < 0)
return error_box(f.get_warning());
}
break;
case F10_DITTE:
if (e == fe_init)
fill_ditte();
if (e == se_query_add || e == se_query_del)
return FALSE;
if (e == se_enter)
{
TSheet_field& s = sfield(F10_DITTE);
TToken_string& r = s.row((int)jolly);
set(F10_DITTA, r.get(0));
set(F10_RAGSOC, r.get());
}
break;
default:
break;
}
return TRUE;
}
///////////////////////////////////////////////////////////
// Step 4 - Conversione ditta
///////////////////////////////////////////////////////////
class TEuro11_mask : public TAutomask
{
public:
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
TEuro11_mask() : TAutomask("baeur11") { }
};
bool TEuro11_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
switch (o.dlg())
{
case F11_ADOZIONE:
if (e == fe_modify || e == fe_close)
{
TEsercizi_contabili esc;
TDate d = o.get();
if (!d.ok())
return error_box("E' necessario specificare la data di adozione dell'Euro");
const int codesc = esc.date2esc(d);
if (codesc <= 0)
return error_box("E' necessario aprire l'esercizio per l'anno %d", d.year());
if (d.day() != 1)
warning_box("Si consiglia di specificare una data di inizio mese/trimestre");
if (d != esc[codesc].inizio())
{
if (app().has_percip() && get_bool(F11_SOLOAPERTE))
return error_box("Se sono presenti percipienti e si convertono solo le schede aperte\nla conversione deve essere effettuata a inizio esercizio.");
if (d != esc[codesc].inizio() && app().has_mag())
{
const int prevesc = esc.date2prevesc(d);
if (prevesc > 0)
{
const TDate& cm = esc[prevesc].chiusura_mag();
if (!cm.ok())
return error_box("E' necessario chiudere il magazzino nell'esercizio %d", prevesc);
}
}
}
}
break;
case F11_DIFF_S:
if (e == fe_close && o.empty())
{
TLocalisamfile pcon(LF_PCON);
if (pcon.first() == NOERR)
return error_box("E' necessario specificare un conto per gli arrotondamenti");
}
break;
default: break;
}
return TRUE;
}
///////////////////////////////////////////////////////////
// Conversione ditta
///////////////////////////////////////////////////////////
struct TMag_data
{
int _annoesrif;
TString _fields;
TString _zero_fields;
};
struct TPerc_data
{
bool _soloaperte;
TDate _adozione;
};
static bool mag_handler(TRectype& rec, void* jolly)
{
TMag_data& mag = *(TMag_data*)jolly;
const int annoesrif = *((int *) jolly);
const int annoes = rec.get_int(MAG_ANNOES);
if (annoes >= mag._annoesrif)
zero_import(rec, mag._zero_fields);
else
convert_import(rec, mag._fields);
return TRUE;
}
static bool movmag_handler(TRectype& rec, void* jolly)
{
TMag_data& mag = *(TMag_data*)jolly;
const int annoesrif = *((int *) jolly);
const int annoes = rec.get_int(MOVMAG_ANNOES);
return annoes >= annoesrif;
}
static bool righemovmag_handler(TRectype& rec, void* jolly)
{
TMag_data& mag = *(TMag_data*)jolly;
const int annoesrif = *((int *) jolly);
TString16 key; key << rec.get_long(RMOVMAG_NUMREG);
const int annoes = atoi(cache().get(LF_MOVMAG, key, MOVMAG_ANNOES));
return annoes >= annoesrif;
}
struct TTab_data
{
int _codes_rif, _annoes_rif;
};
static bool perc_handler(TRectype& rec, void* jolly)
{
return app().get_firm() == rec.get_long("CODDITTA");
}
static bool sch_handler(TRectype& rec, void* jolly)
{
bool ok = perc_handler(rec, jolly);
if (ok)
{
TPerc_data & d = *(TPerc_data*)jolly;
if (d._soloaperte)
{
real pagato = ZERO;
TRectype keypag(LF_RPAG);
TLocalisamfile sch(LF_SCPERC);
TRectype recsch(rec);
recsch.read(sch);
real totale = recsch.get_real("COMPENSO");
totale += recsch.get_real("SPESE");
keypag.put("CODDITTA", rec.get("CODDITTA"));
keypag.put("TIPOA", rec.get("TIPOA"));
keypag.put("CODANAGR", rec.get("CODANAGR"));
keypag.put("NPROG", rec.get("NPROG"));
TRecord_array pag_scheda(keypag, "NRIGA");
const int rows = pag_scheda.rows();
TDate& adozione = d._adozione;
for (int i = 1 ; i <= rows; i++)
{
const TRectype & rpag = pag_scheda[i];
const TDate datapag = rpag.get_date("DATAPAG");
const int rver = rpag.get_int("NUMVERS");
if (datapag <= adozione && rver > 0)
{
pagato += rpag.get_real("COMPENSO");
pagato += rpag.get_real("SPESA");
}
}
ok = totale > pagato;
}
if (ok)
{
TString80 key(rec.get("CODDITTA"));
key << "|" << rec.get("TIPOA");
key << "|" << rec.get("CODANAGR");
key << "|" << rec.get("NPROG");
app().passate().add(key, key);
}
}
return ok;
}
static bool to_sch_handler(TRectype& rec, void* jolly)
{
bool ok = perc_handler(rec, jolly);
if (ok)
{
TString80 key(rec.get("CODDITTA"));
key << "|" << rec.get("TIPOA");
key << "|" << rec.get("CODANAGR");
key << "|" << rec.get("NPROG");
ok = app().passate().objptr(key) != NULL;
}
return ok;
}
static bool tab_handler(TRectype& rec, void* jolly)
{
const TString& cod = rec.get("COD");
if (cod == "CAM")
return FALSE;
if (cod == "REG")
{
TTab_data* data = (TTab_data*)jolly;
const int annoes = atoi(rec.get("CODTAB").left(4));
zero_import(rec, "R0|R1|R2");
return annoes >= data->_annoes_rif;
}
if (cod == "SPP" || cod == "PRS")
{
const TString16 val = rec.get("S4");
if (is_firm_value(val))
{
rec.zero("S4");
convert_import(rec, "R0");
}
else
{
if (is_euro_value(val))
rec.zero("S4");
}
return TRUE;
}
if (cod == "RFA")
{
zero_import(rec, "R1|R2");
return TRUE;
}
if (cod == "LAM" || cod == "LIM" || cod == "PIM" || cod == "PUM" || cod == "PAM" ||
cod == "POM" || cod == "PLM" || cod == "PPA" || cod == "PRM")
return FALSE;
return TRUE;
}
static bool conv_condv(TRectype& rec, void* jolly)
{
const TString16 val = rec.get("CODVAL");
if (is_firm_value(val) || is_euro_value(val))
{
rec.zero("CODVAL");
rec.zero("CAMBIO");
rec.zero("CONTROEURO");
}
else
if (!rec.get_bool("CONTROEURO"))
{
real contro_change = EURO / rec.get_real("CAMBIO");
rec.put("CAMBIO", contro_change);
rec.put("CONTROEURO", "X");
}
return TRUE;
}
static bool conv_rcondv(TRectype& rec, void* jolly)
{
TString80 key;
key << rec.get("TIPO");
key << "|" << rec.get("CATVEN");
key << "|" << rec.get("TIPOCF");
key << "|" << rec.get("CODCF");
key << "|" << rec.get("COD");
const TString16 val = cache().get(LF_CONDV, key, "CODVAL");
if (is_firm_value(val))
convert_import(rec, "PREZZO|PROMAGGIO", TRUE);
return TRUE;
}
bool TEuro01_app::has_mag() const
{
TConfig c(CONFIG_DITTA, "mg");
bool yes = c.get_bool("GESMAG") && dbf_exists(LF_MOVMAG);
if (yes)
{
TLocalisamfile mm(LF_MOVMAG);
yes = mm.first() == NOERR;
}
return yes;
}
bool TEuro01_app::has_percip() const
{
bool yes = dbf_exists(LF_SCPERC);
if (yes)
{
TLocalisamfile sp(LF_SCPERC);
yes = sp.first() == NOERR;
}
return yes;
}
KEY TEuro01_app::convert_firm(long ditta)
{
TFilename lit, eur;
get_aree_dati(lit, eur);
prefix().set_studio(lit, ditta);
TString16 firm; firm.format("%05ldA", ditta);
TFilename litf = lit; litf.add(firm);
TFilename eurf = eur; eurf.add(firm);
TFilename europrassid;
europrassid = eurf; europrassid.add("prassid.ini");
bool already_present = eurf.exist();
if (already_present)
{
TConfig prassid(europrassid, "Euro");
already_present = prassid.get("ConversionOK").not_empty();
}
bool do_copy = !already_present;
bool do_saldi = !already_present;
bool do_partite = !already_present;
bool do_vendite = !already_present;
bool do_magazzino = !already_present;
bool do_percip = !already_present;
bool solo_aperte = FALSE;
TDate adozione;
TBill arrotino;
KEY k = K_ENTER;
if (k == K_ENTER)
{
TEuro11_mask m;
m.set(F11_DITTA, ditta, TRUE);
m.set(F11_DATI, lit);
m.set(F11_DATIE, eur);
m.set(F11_COPY, do_copy ? "X" : "");
m.set(F11_SALDI, do_saldi ? "X" : "");
m.set(F11_PARTITE, do_partite ? "X" : "");
m.set(F11_VENDITE, do_vendite ? "X" : "");
m.set(F11_MAGAZZINO, do_magazzino ? "X" : "");
m.set(F11_PERCIPIENTI, do_percip ? "X" : "");
if (already_present)
{
TConfig prassid(europrassid, "Euro");
adozione = prassid.get("DataAdozione");
m.set(F11_ADOZIONE, adozione);
}
m.enable(-1, already_present); // Abilita i vari checkbox
if (load_round_bill(arrotino))
arrotino.set(m, F11_DIFF_G, F11_DIFF_C, F11_DIFF_S);
else
{
m.reset(F11_DIFF_G);
m.reset(F11_DIFF_C);
m.reset(F11_DIFF_S);
}
k = m.run();
adozione = m.get(F11_ADOZIONE);
arrotino.get(m, F11_DIFF_G, F11_DIFF_C, F11_DIFF_S);
do_copy = m.get_bool(F11_COPY);
do_saldi = m.get_bool(F11_SALDI);
do_partite = m.get_bool(F11_PARTITE);
do_vendite = m.get_bool(F11_VENDITE);
do_magazzino = m.get_bool(F11_MAGAZZINO);
do_percip = m.get_bool(F11_PERCIPIENTI);
solo_aperte = m.get_bool(F11_SOLOAPERTE);
}
if (k == K_ENTER)
{
if (already_present && !yesno_box("Si conferma la sovrascrittura della ditta %ld in Euro?", ditta))
return k;
TEsercizi_contabili esc;
const int codes_rif = esc.date2prevesc(adozione);
const int annoes_rif = adozione.year()-1;
TTab_data data;
data._codes_rif = codes_rif;
data._annoes_rif = annoes_rif;
if (do_copy)
{
TCurrency::force_cache_update(); // Chiude cache valute
prefix().set(NULL); // Chiude files ditta
copy_dir(litf, eurf);
if (adozione.ok()) // Dummy test
{
TFilename ini = eurf; ini.add("prassid.ini");
TConfig prassid(ini, "Euro");
prassid.set("DataAdozione", adozione.string());
}
save_round_bill(arrotino);
// prefix().set("."); // Riapre files ditta
set_firm(ditta);
convert_file(LF_TAB, NULL, NULL, NULL, tab_handler, (void*)&data);
if (is_firm_file(LF_CLIFO))
{
convert_file(LF_CLIFO, NULL, "FIDO", NULL, NULL);
convert_file(LF_CFVEN, "IMPMINEFF", "MINORD|MAXORD", NULL, NULL);
}
zap_file(LF_MOV, TRUE); // Cancella movimenti di prima nota dell'area euro
zap_file(LF_RMOV, TRUE); // Cancella righe di prima nota dell'area euro
zap_file(LF_RMOVIVA, TRUE); // Cancella righe iva dell'area euro
zap_file(LF_INTRA, TRUE);
zap_file(LF_RINTRA, TRUE);
zap_file(LF_RIEPRETT, TRUE);
}
if (do_saldi)
{
const int eser = esc.date2esc(adozione);
const TDate iniz_eser = esc[eser].inizio();
if (adozione == iniz_eser)
{
convert_saldi(adozione, arrotino); // Converti saldi anno precedente
}
else
{
zap_file(LF_SALDI, TRUE);
TString16 cmd; cmd.format("baeur -2 %ld", ditta);
TExternal_app app(cmd); // Conversione saldi infrannuale
app.run();
}
}
if (do_partite)
convert_partite(); // Converti partite
if (do_vendite)
{
zap_file(LF_REFFETTI, TRUE);
zap_file(LF_EFFETTI, TRUE);
zap_file(LF_CESS, TRUE);
zap_file(LF_PROVV, TRUE);
zap_file(LF_DOC, TRUE);
zap_file(LF_RIGHEDOC, TRUE);
convert_file(LF_ANAMAG, NULL, NULL, "COSTSTD|ULTCOS1|ULTCOS2|VALSTATUN");
convert_file(LF_UMART, NULL, NULL, "PREZZO");
// cvrt condv codval cambio
// cvrt rcondv prezzo
convert_file(LF_RCONDV, NULL, NULL, NULL, conv_rcondv);
convert_file(LF_CONDV, NULL, NULL, NULL, conv_condv);
convert_file(LF_SVRIEP, "VALORE");
}
if (do_magazzino)
{
TMag_data mag;
mag._annoesrif = esc.date2esc(adozione);
mag._zero_fields << "RIM|VALRIM|ACQ|VALACQ|ENT|VALENT|VEN|VALVEN|USC|VALUSC|GIAC|ORDF|VALORDF|";
mag._zero_fields << "ORDC|VALORDC|INCL|ACL|PRODCOMP|PRODFIN|NLABEL|NDIST|SCARTI|VALSCARTI|";
mag._zero_fields << "USER1|USERVAL1|USER2|USERVAL2|USER3|USERVAL3|";
mag._zero_fields << "USER4|USERVAL4|USER5|USERVAL5|USER6|USERVAL6";
mag._fields << "VALRIM|VALACQ|VALENT|VALVEN|VALUSC|VALORDF|VALORDC|VALSCARTI|";
mag._fields << "USERVAL1|USERVAL2|USERVAL3|USERVAL4|USERVAL5|USERVAL6";
convert_file(LF_MAG, "", "ORDC|VALORDC|ORDF|VALORDF", NULL, mag_handler, (void*)&mag);
convert_file(LF_MOVMAG, NULL, NULL, NULL, movmag_handler, (void*)&mag);
convert_file(LF_RMOVMAG, NULL, NULL, "PREZZO", righemovmag_handler, (void*)&mag);
convert_file(LF_STOMAG, NULL, NULL, "VALORE|ULTCOS1|ULTCOS2|COSTSTD|COSTOMEDIO|PRZLIST");
convert_file(LF_DIST, NULL, NULL, "PREZZO");
if (dbf_exists(LF_ANAMAG) && dbf_exists(LF_STOMAG) && dbf_exists(LF_MOVMAG))
{
TExternal_app app("baeur -6 S");
app.run();
}
}
if (do_percip)
{
TString16 filter;
filter << "CODDITTA=" << get_firm();
TLocalisamfile rp(LF_RPAG);
TPerc_data d;
d._soloaperte = solo_aperte;
d._adozione = adozione;
_schede_passate.destroy();
convert_file(LF_PERC, "FATTBIL", NULL, NULL, perc_handler, NULL, filter);
convert_file(LF_SCPERC,"COMPENSO|SPESE|IVA|TOTALE|TOTRIT|RITSOC|RITOPE|RITVER", NULL, NULL, sch_handler, (void*)&d, filter);
convert_file(LF_RVER, "RITENUTA", NULL, NULL, to_sch_handler, NULL, filter);
TString flds;
flds << "IMPONIBILE|RITENUTA|COMPENSO|NETTO|SPESA|CTSSNPERC|CTSSNCOMP|RITLORDA|CONTROBB|DETFAMIL|DETLAVDIP|TOTDET|";
flds << "IMPCPA|SOMREGCONV|UTPAGATI|UTSPETT|RITUTPAG|RITUTSPE|SOMNSRIT|AMMLORDO|QUOTAPROV|IMPNETTO|COMNETTO";
convert_file(LF_RPAG, flds, NULL, NULL, to_sch_handler, NULL, filter);
}
if (adozione.ok()) // Dummy test
{
TConfig prassid(europrassid, "Euro");
prassid.set("ConversionOK", "X");
}
}
return k;
}
///////////////////////////////////////////////////////////
// Conversione saldi
///////////////////////////////////////////////////////////
struct TSaldi_data
{
int _annoes;
TBill _arrot;
TImporto _sld;
};
static bool saldi_handler(TRectype& rec, void* jolly)
{
TSaldi_data& sld = *(TSaldi_data*)jolly;
const int annoes = rec.get_int(SLD_ANNOES);
if (annoes == sld._annoes)
{
const TImporto iniz(rec.get_char(SLD_FLAGSALINI), rec.get_real(SLD_SALDO));
const TImporto pdare('D', rec.get_real(SLD_PDARE));
const TImporto pavere('A', rec.get_real(SLD_PAVERE));
TImporto saldo = iniz; saldo += pdare; saldo += pavere;
if (!saldo.is_zero())
{
saldo.normalize();
rec.put(SLD_FLAGSALINI, saldo.sezione());
rec.put(SLD_SALDO, saldo.valore());
convert_import(rec, SLD_SALDO);
zero_import(rec, "PDARE|PAVERE|PDAREPRO|PAVEREPRO|FLAGSALFIN|SALDOFIN|DATAULMOV|NUMULTMOV");
sld._sld += TImporto(saldo.sezione(), rec.get_real(SLD_SALDO)); // Somma saldo in euro
return TRUE;
}
}
return FALSE;
}
void TEuro01_app::convert_saldi(const TDate& adozione, const TBill& arrotino)
{
TEsercizi_contabili esc;
TSaldi_data sld;
sld._annoes = esc.date2prevesc(adozione);
sld._arrot = arrotino;
convert_file(LF_SALDI, NULL, NULL, NULL, saldi_handler, &sld);
TImporto& saldo = sld._sld;
saldo.valore().round(2);
if (!saldo.is_zero())
{
TLocalisamfile saldi_lire(LF_SALDI); // Open trc
TEuroisamfile saldi(LF_SALDI, TRUE);
TRectype& curr = saldi.curr();
curr.zero();
curr.put(SLD_ANNOES, sld._annoes);
curr.put(SLD_GRUPPO, arrotino.gruppo());
curr.put(SLD_CONTO, arrotino.conto());
curr.put(SLD_SOTTOCONTO, arrotino.sottoconto());
saldo.normalize();
saldo.swap_section();
curr.put(SLD_FLAGSALINI, saldo.sezione());
curr.put(SLD_SALDO, saldo.valore());
saldi.write();
}
}
///////////////////////////////////////////////////////////
// Conversione partite
///////////////////////////////////////////////////////////
struct TSaldac_data
{
real _totrate;
};
bool partite_handler(TRectype& rec, void* jolly)
{
if (rec.get_bool(PART_CHIUSA) || rec.get_int(PART_NRIGA) == 9999)
return FALSE;
TSaldac_data* data = (TSaldac_data*)jolly;
const TString16 codval = rec.get(PART_CODVAL);
if (::is_firm_value(codval))
{
convert_import(rec, PART_ABBUONI);
zero_import(rec, "CODVAL|IMPORTOVAL|DIFFCAM");
} else
if (::is_euro_value(codval))
{
zero_import(rec, "CODVAL|IMPORTOVAL|DIFFCAM");
} else
if (::is_true_value(codval))
{
const real impval = rec.get(PART_IMPORTOVAL);
if (impval != ZERO)
{
const real impeur = rec.get(PART_IMPORTO);
const real old_cambio = rec.get(PART_CAMBIO);
real new_cambio = impval / impeur;
new_cambio.round(5);
if (abs(old_cambio - new_cambio) > 0.001) // Non era gi<67> contro euro
rec.put(PART_CAMBIO, new_cambio);
}
}
if (rec.get_int(PART_TIPOMOV) > 1)
{
// Riempe il campo totale documento per i pagamenti (In contabilit<69> viene lasciato vuoto)
rec.put(PART_IMPTOTDOC, rec.get(PART_IMPORTO));
}
rec.put(PART_INVIATA, "X");
return TRUE;
}
bool scadenze_handler(TRectype& rec, void* jolly)
{
TSaldac_data* sd = (TSaldac_data*)jolly;
// Controlla se la riga di partita corrispondente esiste in euro
TEuroisamfile part(LF_PARTITE, TRUE);
TRectype& curr = part.curr();
curr.zero();
curr.put(PART_TIPOCF, rec.get(SCAD_TIPOCF));
curr.put(PART_GRUPPO, rec.get(SCAD_GRUPPO));
curr.put(PART_CONTO, rec.get(SCAD_CONTO));
curr.put(PART_SOTTOCONTO, rec.get(SCAD_SOTTOCONTO));
curr.put(PART_ANNO, rec.get(SCAD_ANNO));
curr.put(PART_NUMPART, rec.get(SCAD_NUMPART));
curr.put(PART_NRIGA, rec.get(SCAD_NRIGA));
if (part.read() != NOERR)
return FALSE;
if (!rec.get_real(SCAD_IMPORTOVAL).is_zero())
{
const TString4 codval = part.get(PART_CODVAL);
if (::is_firm_value(codval) || ::is_euro_value(codval))
rec.zero(SCAD_IMPORTOVAL);
}
const int nrata = rec.get_int(SCAD_NRATA);
if (nrata == 1)
sd->_totrate = ZERO;
sd->_totrate += rec.get_real(SCAD_IMPORTO);
// I problemi di arrotondamento dovrei averli solo con tante rate
if (nrata > 1)
{
TLocalisamfile scad(LF_SCADENZE);
scad.curr() = rec;
scad.curr().put(SCAD_NRATA, nrata+1);
if (scad.read() != NOERR) // Sono l'ultima rata
{
const real toteur = part.get(PART_IMPTOTDOC);
const real diff = toteur - sd->_totrate;
if (diff != ZERO)
{
real rata = rec.get(SCAD_IMPORTO);
rata += diff;
rec.put(SCAD_IMPORTO, rata);
}
}
}
return TRUE;
}
bool pagamenti_handler(TRectype& rec, void* jolly)
{
TSaldac_data* sd = (TSaldac_data*)jolly;
// Controlla se la partita di appartenenza esiste in euro
TEuroisamfile part(LF_PARTITE, TRUE);
TRectype& curr = part.curr();
curr.zero();
curr.put(PART_TIPOCF, rec.get(PAGSCA_TIPOC));
curr.put(PART_GRUPPO, rec.get(PAGSCA_GRUPPO));
curr.put(PART_CONTO, rec.get(PAGSCA_CONTO));
curr.put(PART_SOTTOCONTO, rec.get(PAGSCA_SOTTOCONTO));
curr.put(PART_ANNO, rec.get(PAGSCA_ANNO));
curr.put(PART_NUMPART, rec.get(PAGSCA_NUMPART));
const TRectype sample(curr);
if (part.read(_isgteq) != NOERR || part.curr() != sample)
return FALSE;
// Ero in lire (ora sono in euro) devo convertire gli abbuoni a lire ad euro
// Se ero in valuta devo lasciar stare gli abbuoni
if (curr.get_real(PART_IMPORTOVAL) == ZERO)
convert_import(rec, PAGSCA_ABBUONI);
else
{
// Le differenze cambio sono gi<67> convertite sempre automaticamente in quanto erano sempre in lire
}
return TRUE;
}
void TEuro01_app::convert_partite()
{
TLocalisamfile partlit(LF_PARTITE); // Serve ad avere disponibile il tracciato record
TSaldac_data data;
convert_file(LF_PARTITE, "IMPTOTDOC|IMPORTO|IMPOSTA|SPESE|RITENUTE|DIFFCAM", PART_NREG, NULL, partite_handler, &data);
convert_file(LF_SCADENZE, "IMPORTO", NULL, NULL, scadenze_handler, &data);
convert_file(LF_PAGSCA, "IMPORTO|RITENUTE|DIFFCAM", NULL, NULL, pagamenti_handler, &data);
}
///////////////////////////////////////////////////////////
// Main
///////////////////////////////////////////////////////////
bool TEuro01_app::create()
{
TFilename lit, eur;
if (!app().get_aree_dati(lit, eur))
return error_box("Non esiste lo studio in Euro di destinazione");
return TEuro_app::create();
}
void TEuro01_app::main_loop()
{
long ditta = 0L;
if (goto_lire())
{
TEuro03_mask m;
if (m.run() == K_ENTER)
ditta = m.get_long(F10_DITTA);
}
if (ditta > 0L)
convert_firm(ditta);
}
int baeur01(int argc, char* argv[])
{
TEuro01_app ma;
ma.run(argc, argv, "Conversione Ditte Euro");
return 0;
}
Reference in New Issue View Git Blame Copy Permalink