root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/src/ve/ve6200.cpp
Alessandro Bonazzi d74548ab04 Patch level : 12.0 982 
Files correlati     : ve0.exe ve1.exe ve5.exe ve6.exe ve0200b.msk
Commento            :

Ristrutturato modulo li
2020-07-27 08:52:10 +02:00

634 lines
20 KiB
C++
Executable File
Raw Blame History

//#include <recset.h>
#include <reputils.h>
#include <dongle.h>
#include <utility.h>
#include "velib04.h"
#include "ve6200.h"
#include "ve6200a.h"
#include "../li/lilib01.h"
#include "../li/lilib01.cpp"
#include <doc.h>
///////////////////////////////////////////////////////////
// TFatturazione_bolle_app
///////////////////////////////////////////////////////////
bool TFatturazione_bolle_app::create()
{
open_files(LF_TABCOM, LF_TAB, LF_CLIFO, LF_OCCAS, LF_INDSP, LF_CFVEN,
LF_DOC, LF_RIGHEDOC, LF_ANAMAG, LF_MOVMAG, LF_RMOVMAG, LF_CONDV, LF_SVRIEP,
LF_AGENTI, LF_PERCPROV, LF_CAUSALI, 0);
_default_selection = ini_get_string(CONFIG_DITTA, "ve", "FATBOLSEL");
return TSkeleton_application::create();
}
bool TFatturazione_bolle_app::process(TProgress_monitor& iw, TElaborazione & eld,
TLista_documenti& din, const TDate& data_elab, TLog_report & log)
{
// Crea documenti di output
TLista_documenti dout;
bool ok = true;
if (eld.elabora(din, dout, data_elab))
{
TString msg;
msg << din.items() << TR(" documenti raggruppati in ") << dout.items();
log.log(0, msg);
iw.set_text(msg); // Messaggio sul cliente
do_events(); // Attende visualizzazione
lint_batch(true);
lint_reset_msg();
int err = dout.write(); // Scrive documenti di output
lint_batch(false);
if (err == NOERR)
{
err = din.rewrite(); // Aggiorna stato dei documenti di input
if (err != NOERR)
ok = error_box("Errore %d durante la scrittura dei documenti raggruppati!", err);
}
else
ok = error_box("Errore %d durante l'aggiornamento dei documenti da raggruppare!", err);
const TString & str = lint_get_msg();
if (str.full())
{
TToken_string errmsg(str, '\n');
const int items = errmsg.items();
for (int i = 0; i < items; i++)
log.log(0, errmsg.get());
}
}
return ok;
}
void TFatturazione_bolle_app::process_by_cli(const TMask& m)
{
TLog_report log;
{
TProgress_monitor iw(0, "Inizializzazione...\n ");
const TDate data_elab = m.get_date(F_DATA_ELAB);
const int anno = data_elab.year();
const long dc = m.get_long(F_CODICE_CLIFO_DA);
const long ac = m.get_long(F_CODICE_CLIFO_A);
const int da = m.get_int(F_CODICE_AGENTE_DA);
const int aa = m.get_int(F_CODICE_AGENTE_A);
const TString16 dz(m.get(F_CODICE_ZONA_DA));
const TString16 az(m.get(F_CODICE_ZONA_A));
const TDate dd = m.get_date(F_DATA_DOCUMENTO_DA);
TString st_da = m.get(F_DATA_DOCUMENTO_A); // qui verificare
const TDate ad = st_da.not_empty() ? (TDate)(const char*)st_da : data_elab;
const TString& codnum = m.get(F_CODICE_NUMERAZIONE);
const long dn = m.get_long(F_NUMERO_DOCUMENTO_DA);
const long an = m.get_long(F_NUMERO_DOCUMENTO_A);
TElaborazione& eld = *elab(m.get(F_CODICE_ELAB));
TToken_string tipidoc(24), statidoc(10);
eld.tipi_stati_iniziali(tipidoc, statidoc);
TTipo_documento t(eld.tipo_iniziale(0));
char tipocf(t.tipocf());
TLista_cf clienti(tipocf);
const int tot_cli = clienti.leggi_doc(eld, dd, ad, dc, ac, da, aa, dz, az);
TString msg(80);
iw.set_max(tot_cli);
for (int c = 0; c < tot_cli; c++)
{
const long codcli = clienti[c]; // Codice cliente in esame
msg = TR("Elaborazione documenti del cliente ");
msg << codcli << " ...";
log.log(0, msg);
iw.set_text(msg); // Messaggio sul cliente
do_events(); // Attende visualizzazione
TLista_documenti din; // Legge tutti i documenti di input
din.read('D', tipocf, codcli, anno, tipidoc, statidoc, dd, ad, codnum, dn, an);
if (din.items() > 0)
{
if (m.get(F_ORDINAMENTO) == "Z")
din.sort(DOC_ZONA "|" DOC_DATADOC "|" DOC_NDOC);
bool ok = process(iw, eld, din, data_elab, log);
if (!ok) // In caso di errore termina qui l'elaborazione.
break;
}
if (!iw.add_status())
break;
}
delete &eld;
}
log.print_or_preview();
}
void TFatturazione_bolle_app::process_by_ragsoc(const TMask& m)
{
TLog_report log;
{
TProgress_monitor iw(0, "Inizializzazione...\n ");
const TDate data_elab = m.get_date(F_DATA_ELAB);
const int anno = data_elab.year();
const TString dr = m.get(F_RAGSOC_CLIFO_DA);
const TString ar = m.get(F_RAGSOC_CLIFO_A);
const int da = m.get_int(F_CODICE_AGENTE_DA);
const int aa = m.get_int(F_CODICE_AGENTE_A);
const TString16 dz(m.get(F_CODICE_ZONA_DA));
const TString16 az(m.get(F_CODICE_ZONA_A));
const TDate dd = m.get_date(F_DATA_DOCUMENTO_DA);
TString st_da = m.get(F_DATA_DOCUMENTO_A); // qui verificare
const TDate ad = st_da.not_empty() ? (TDate)(const char*)st_da : data_elab;
const TString& codnum = m.get(F_CODICE_NUMERAZIONE);
const long dn = m.get_long(F_NUMERO_DOCUMENTO_DA);
const long an = m.get_long(F_NUMERO_DOCUMENTO_A);
TElaborazione * e = elab(m.get(F_CODICE_ELAB));
TElaborazione & eld = *e;
TToken_string tipidoc(24), statidoc(10);
eld.tipi_stati_iniziali(tipidoc, statidoc);
TTipo_documento t(eld.tipo_iniziale(0));
char tipocf(t.tipocf());
TLista_cf clienti(tipocf);
const int tot_cli = clienti.leggi_ragsoc(dr, ar, da, aa, dz, az);
TString msg(80);
iw.set_max(tot_cli);
for (int c = 0; c < tot_cli; c++)
{
const long codcli = clienti[c]; // Codice cliente in esame
msg = TR("Elaborazione documenti del cliente ");
msg << codcli << " ...";
log.log(0, msg);
iw.set_text(msg); // Messaggio sul cliente
do_events(); // Attende visualizzazione
TLista_documenti din; // Legge tutti i documenti di input
din.read('D', tipocf, codcli, anno, tipidoc, statidoc, dd, ad, codnum, dn, an);
if (din.items() > 0)
{
if (m.get(F_ORDINAMENTO) == "Z")
din.sort(DOC_ZONA "|" DOC_DATADOC "|" DOC_NDOC);
bool ok = process(iw, eld, din, data_elab, log);
if (!ok) // In caso di errore termina qui l'elaborazione.
break;
}
if (!iw.add_status())
break;
}
delete e;
}
log.print_or_preview();
}
void TFatturazione_bolle_app::process_by_doc(const TMask& m)
{
TLog_report log;
{
TProgress_monitor iw(0, TR("Inizializzazione...\n "));
const TDate data_elab = m.get_date(F_DATA_ELAB);
const int anno = data_elab.year();
long dc = m.get_long(F_CODICE_CLIFO_DA);
long ac = m.get_long(F_CODICE_CLIFO_A);
const int da = m.get_int(F_CODICE_AGENTE_DA);
const int aa = m.get_int(F_CODICE_AGENTE_A);
const TString8 dz(m.get(F_CODICE_ZONA_DA));
const TString8 az(m.get(F_CODICE_ZONA_A));
const TDate dd = m.get_date(F_DATA_DOCUMENTO_DA);
TDate ad = m.get_date(F_DATA_DOCUMENTO_A);
if (!ad.ok()) ad = data_elab;
const TString& codnum = m.get(F_CODICE_NUMERAZIONE);
const long dn = m.get_long(F_NUMERO_DOCUMENTO_DA);
const long an = m.get_long(F_NUMERO_DOCUMENTO_A);
TElaborazione * e = elab(m.get(F_CODICE_ELAB));
TElaborazione & eld = *e;
TToken_string tipidoc(24), statidoc(10);
eld.tipi_stati_iniziali(tipidoc, statidoc);
TTipo_documento t(eld.tipo_iniziale(0));
char tipocf(t.tipocf());
TLista_cf clienti(tipocf);
const int tot_cli = clienti.leggi(dc, ac);
TLista_documenti din, dout; // Legge tutti i documenti di input
TString msg(80);
iw.set_max(tot_cli);
for (int c = 0; c < tot_cli; c++)
{
const long codcli = clienti[c]; // Codice cliente in esame
msg = TR("Elaborazione documenti del cliente");
msg << ' ' << codcli << "...";
log.log(0, msg);
iw.set_text(msg); // Messaggio sul cliente
do_events(); // Attende visualizzazione
TLista_documenti list;
list.read('D', tipocf, codcli, anno, tipidoc, statidoc, dd, ad, codnum, dn, an);
for (int i = list.items() - 1; i >= 0; i--)
{
const TDocumento& doc = list[i];
bool to_del = FALSE;
const int agente = doc.get_int(DOC_CODAG);
if (agente > 0)
{
if (da > 0 && agente < da) to_del = true;
if (aa > 0 && agente > aa) to_del = true;
}
const TString8 zona = doc.get(DOC_ZONA);
if (zona.full())
{
if (dz.not_empty() && zona < dz) to_del = true;
if (az.not_empty() && zona > az) to_del = true;
}
if (to_del)
list.destroy(i);
}
const int items = list.items();
for (int j = 0; j < items; j++)
din.add(list[j]);
if (!iw.add_status())
break;
}
if (din.items() > 0 && !iw.is_cancelled())
{
if (m.get(F_ORDINAMENTO) == "Z")
din.sort(DOC_ZONA "|" DOC_DATADOC "|" DOC_NDOC);
process(iw, eld, din, data_elab, log);
}
delete e;
}
log.print_or_preview();
}
void TFatturazione_bolle_app::process_by_fatt(const TMask& m)
{
TLog_report log;
{
TWait_cursor hourglass;
TElaborazione* e = elab(m.get(F_CODICE_ELAB));
TElaborazione& eld = *e;
TToken_string tipidoc(24), statidoc(10);
eld.tipi_stati_iniziali(tipidoc, statidoc);
const TTipo_documento t(eld.tipo_iniziale(0));
const char tipocffatt = t.tipocf() == 'C' ? 'F' : 'C';
const TDate data_elab = m.get_date(F_DATA_ELAB);
const int anno = data_elab.year();
long dc = m.get_long(F_CODICE_CLIFO_DA);
long ac = m.get_long(F_CODICE_CLIFO_A);
const int da = m.get_int(F_CODICE_AGENTE_DA);
const int aa = m.get_int(F_CODICE_AGENTE_A);
const TString& dz = m.get(F_CODICE_ZONA_DA);
const TString& az = m.get(F_CODICE_ZONA_A);
const TString& codnum = m.get(F_CODICE_NUMERAZIONE);
const long dn = codnum.full() ? m.get_long(F_NUMERO_DOCUMENTO_DA) : 0;
const long an = codnum.full() ? m.get_long(F_NUMERO_DOCUMENTO_A) : 0;
TDate dd = m.get_date(F_DATA_DOCUMENTO_DA);
if (!dd.ok())
dd = TDate(1, 1, anno);
TDate ad = m.get_date(F_DATA_DOCUMENTO_A);
if (!ad.ok())
ad = data_elab;
const int nkey = (dn > 0 || an > 0) ? 1 : 3;
TString query;
query << "USE DOC KEY " << nkey << " SELECT (TIPOCFFATT=\"" << tipocffatt << "\")";
if (dc > 0 || ac > 0)
query << "&&(BETWEEN(CODCFFATT," << dc << ',' << ac << "))";
query << "&&(BETWEEN(DATADOC," << dd.date2ansi() << ',' << ad.date2ansi() << "))";
if (da > 0 || aa > 0)
query << "&&(BETWEEN(CODAG," << da << "," << aa << "))";
if (dz.full() || az.full())
query << "&&(BETWEEN(ZONA,\"" << dz << "\",\"" << az << "\"))";
if (nkey == 3 && codnum.full())
query << "&&(CODNUM=\"" << codnum << "\")";
query << "\nBY " << DOC_CODCFFATT;
if (eld.usa_doc_rif())
query << ' ' << DOC_DATADOCRIF;
if (nkey == 1)
{
query << "\nFROM PROVV=D ANNO=" << anno << " CODNUM=" << codnum << " NDOC=" << dn;
query << "\nTO PROVV=D ANNO=" << anno << " CODNUM=" << codnum << " NDOC=" << an;
}
else
{
query << "\nFROM DATADOC=" << dd.date2ansi();
query << "\nTO DATADOC=" << ad.date2ansi();
}
TISAM_recordset docs(query);
const TRectype& head = docs.cursor()->curr();
TProgress_monitor iw(docs.items(), TR("Elaborazione documenti da fatturare"), true);
long last_clifo = 0; // Ultimo cliente elaborato
TLista_documenti din; // Lista dei documenti dell'ultimo cliente
for (bool ok = docs.move_first(); ok; ok = docs.move_next())
{
const long clifo = docs.get(DOC_CODCFFATT).as_int();
if (clifo > 0 && clifo >= dc && (clifo <= ac || ac <= 0)) // Cliente da fatturare non nullo e valido
{
if (clifo != last_clifo) // Cambio cliente
{
if (din.items() > 0) // Ci sono documenti da elaborare?
{
process(iw, eld, din, data_elab, log); // Elaborali ...
din.destroy(-1); // ... e poi buttali
}
last_clifo = clifo;
}
if (!iw.add_status(1))
break;
// Controlla se il documento e' in uno stato valido per l'elaborazione
const TString4 tipodoc = head.get(DOC_TIPODOC);
const char statodoc = head.get_char(DOC_STATO);
for (int i = tipidoc.items() - 1; i >= 0; i--)
{
if (tipodoc == tipidoc.get(i) && statodoc == statidoc.get_char(i))
{
din.add(head);
break;
}
}
}
}
// Termina l'elaborazione dei documenti dell'ultimo cliente
if (din.items() > 0 && !iw.is_cancelled())
process(iw, eld, din, data_elab, log);
safe_delete(e);
}
log.print_or_preview();
}
// Effettuo un test per i clienti che hanno un plafond attivo, se trovo delle bolle che fuoriescono chiedo se continuare
bool TFatturazione_bolle_app::test_dicint(const TMask& m)
{
bool ok = true;
if (has_module(LIAUT, CHK_DONGLE))
{
const TDate data_elab = m.get_date(F_DATA_ELAB);
const int anno = data_elab.year();
const long dc = m.get_long(F_CODICE_CLIFO_DA);
const long ac = m.get_long(F_CODICE_CLIFO_A);
const int da = m.get_int(F_CODICE_AGENTE_DA);
const int aa = m.get_int(F_CODICE_AGENTE_A);
const TString16 dz(m.get(F_CODICE_ZONA_DA));
const TString16 az(m.get(F_CODICE_ZONA_A));
const TDate dd = m.get_date(F_DATA_DOCUMENTO_DA);
TString st_da = m.get(F_DATA_DOCUMENTO_A); // qui verificare
const TDate ad = st_da.not_empty() ? (TDate)(const char*)st_da : data_elab;
const TString& codnum = m.get(F_CODICE_NUMERAZIONE);
const long dn = m.get_long(F_NUMERO_DOCUMENTO_DA);
const long an = m.get_long(F_NUMERO_DOCUMENTO_A);
TElaborazione * eld = elab(m.get(F_CODICE_ELAB));
TToken_string tipidoc(24), statidoc(10);
eld->tipi_stati_iniziali(tipidoc, statidoc);
TTipo_documento t(eld->tipo_iniziale(0));
char tipocf(t.tipocf());
TLista_cf clienti(tipocf);
const int tot_cli = clienti.leggi_doc(*eld, dd, ad, dc, ac, da, aa, dz, az);
TLog_report lerr(TR("Errori controllo plafond"));
lerr.log(0, "\n");
for (int c = 0; c < tot_cli; c++)
{
const long codcli = clienti[c]; // Codice cliente in esame
TLi_manager cli('C', codcli, data_elab.year()); // Inizializzo l'oggetto per la gestione del plafond
if (cli.has_valid_plafond())
{
real plafond, res_plafond, utilizzo;
TLista_documenti din; // Legge tutti i documenti di input
din.read('D', tipocf, codcli, anno, tipidoc, statidoc, dd, ad, codnum, dn, an);
bool cli_ok = true;
lint_batch(true);
lint_reset_msg();
plafond = cli.get_plafond();
res_plafond = cli.get_residuo();
for (int i = 0; i < din.items(); i++)
{
const real importo_utilizzato = din[i].importo_plafond();
TToken_string plafs(din[i].get(DOC_PLAFOND), ',');
const TDate datadoc = din[i].get_date(DOC_DATADOC);
utilizzo += importo_utilizzato;
cli_ok = cli.utilizza_plafond(din[i], plafs, importo_utilizzato);
}
cli.set_dirty(false);
lint_batch(false);
if (!cli_ok || utilizzo > res_plafond)
{
bool plur = din.items() > 1;
TString msg;
const TString & str = lint_get_msg();
msg << TR("Errore durante la generazione del plafond:") << '\n';
msg << (plur ? TR("I documenti da elaborare superano") : TR("Il documento da elaborare supera"));
msg << TR(" il plafond del cliente.") << ' ' << codcli << '\n';
msg << TR("Plafond rimanente: ") << res_plafond << '\n';
msg << TR("Totale plafond in fattura : ") << utilizzo << '\n';
msg << (plur ? TR("Le fatture non sono state create.") : TR("La fattura non e' stata creata.")) << '\n';
lerr.log(0, msg);
ok = false;
}
}
}
safe_delete(eld);
if (!ok)
lerr.print_or_preview();
}
return ok;
}
// Effettuo un test per i clienti che hanno un plafond attivo, se trovo delle bolle che fuoriescono chiedo se continuare
bool TFatturazione_bolle_app::test_CONAI(const TMask& m)
{
const TDate data_elab = m.get_date(F_DATA_ELAB);
const int anno = data_elab.year();
const long dc = m.get_long(F_CODICE_CLIFO_DA);
const long ac = m.get_long(F_CODICE_CLIFO_A);
const int da = m.get_int(F_CODICE_AGENTE_DA);
const int aa = m.get_int(F_CODICE_AGENTE_A);
const TString16 dz(m.get(F_CODICE_ZONA_DA));
const TString16 az(m.get(F_CODICE_ZONA_A));
const TDate dd = m.get_date(F_DATA_DOCUMENTO_DA);
TString st_da = m.get(F_DATA_DOCUMENTO_A); // qui verificare
const TDate ad = st_da.not_empty() ? (TDate)(const char*)st_da : data_elab;
const TString& codnum = m.get(F_CODICE_NUMERAZIONE);
const long dn = m.get_long(F_NUMERO_DOCUMENTO_DA);
const long an = m.get_long(F_NUMERO_DOCUMENTO_A);
TElaborazione& eld = *elab(m.get(F_CODICE_ELAB));
TToken_string tipidoc(24), statidoc(10);
eld.tipi_stati_iniziali(tipidoc, statidoc);
TTipo_documento t(eld.tipo_iniziale(0));
char tipocf(t.tipocf());
TLista_cf clienti(tipocf);
const int tot_cli = clienti.leggi_doc(eld, dd, ad, dc, ac, da, aa, dz, az);
TString msg(80);
TLog_report lerr(TR("Errori controllo CONAI"));
lerr.log(0, "\n");
bool err = false;
for (int c = 0; c < tot_cli; c++)
{
const long codcli = clienti[c]; // Codice cliente in esame
TConai conai;
{
TLista_documenti din; // Legge tutti i documenti di input
din.read('D', tipocf, codcli, anno, tipidoc, statidoc, dd, ad, codnum, dn, an);
const int nbolle = din.items();
for (int b = 0; b < nbolle; b++)
{
TDocumento & bolla = din[b];
const int nrows = bolla.physical_rows();
for (int r = 1; r <= nrows; r++)
{
TRiga_documento & row = bolla[r];
msg.format("Cliente %ld Bolla %ld Riga %d - ",
bolla.get_long(DOC_CODCF),
bolla.get_long(DOC_NDOC),
row.get_int(RDOC_NRIGA));
for (int i = 1; i <= FR_CMAX; i++)
{
const TString8 sottocat = row.get(conai_sottocat_name(i));
if (sottocat.full())
{
if (!conai.exist_sottocat(sottocat))
{
err = true;
TString msgerr(msg);
msgerr << format("Sottocategoria CONAI %s assente", (const char *)sottocat);
lerr.log(2, msgerr);
continue;
}
TSpesa_prest sp = conai.get_spesa(sottocat);
if (!sp.valid())
{
err = true;
TString msgerr(msg);
msgerr << sp.err_msg();
lerr.log(2, msgerr);
}
}
}
}
}
}
}
delete &eld;
if (err)
{
lerr.print_or_preview();
return false;
}
return true;
}
bool TFatturazione_bolle_app::clifo_da_fatt(const TMask& m) const
{
TElaborazione* e = elab(m.get(F_CODICE_ELAB));
TFatturazione_bolle& eld = *(TFatturazione_bolle*)e;
const bool yes = eld.change_clifo();
delete e;
return yes;
}
void TFatturazione_bolle_app::main_loop()
{
TMask m("ve6200a");
m.set(F_SELEZIONE, _default_selection);
while (m.run() == K_ENTER)
{
if (test_dicint(m) && test_CONAI(m))
{
const TString& select_from = m.get(F_SELEZIONE);
const TString& orderby = m.get(F_ORDINAMENTO);
if (select_from != _default_selection)
ini_set_string(CONFIG_DITTA, "ve", "FATBOLSEL", _default_selection = select_from);
if (orderby == "R")
process_by_ragsoc(m);
else
{
if (clifo_da_fatt(m))
{
process_by_fatt(m);
}
else
{
if (select_from == "D")
process_by_doc(m);
else
process_by_cli(m);
}
}
}
}
}
int ve6200 (int argc, char **argv)
{
TFatturazione_bolle_app a;
a.run (argc, argv, TR("Fatturazione Bolle"));
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink