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

Solleciti via mail

Browse Source 
git-svn-id: svn://10.65.10.50/branches/R_10_00@22854 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
guy 2013-05-06 08:54:56 +00:00
parent 930208fa9f
commit 0e28e89c9f
11 changed files with 563 additions and 472 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
sc/sc0100a.uml
View File

@ -150,4 +150,29 @@ BEGIN
ADD RUN cg0 -1 F ADD RUN cg0 -1 F
END END
NUMBER F_NUMERO 7
BEGIN
PROMPT 1 4 "Registrazione "
USE LF_PARTITE SELECT (TIPOC=#F_TIPO)&&(NREG!="")
JOIN LF_CLIFO INTO TIPOCF=TIPOC CODCF==SOTTOCONTO
INPUT NREG F_NUMERO
DISPLAY "Numero" NREG
DISPLAY "Data@10" DATAREG
DISPLAY "Tipo" TIPOMOV
DISPLAY "C/F" TIPOC
DISPLAY "Gruppo" GRUPPOCL
DISPLAY "Conto" CONTOCL
DISPLAY "Sottonto" SOTTOCONTO
DISPLAY "Ragione sociale@50" LF_CLIFO->RAGSOC
DISPLAY "Descrizione@50" DESCR
OUTPUT F_NUMERO NREG
OUTPUT F_GRUPPO GRUPPOCL
OUTPUT F_CONTO CONTOCL
OUTPUT F_SOTTOCONTO SOTTOCONTO
OUTPUT F_CLIENTE SOTTOCONTO
OUTPUT F_FORNITORE SOTTOCONTO
CHECKTYPE SEARCH
END
ENDMASK ENDMASK

2
sc/sc1.cpp
View File

@ -2,7 +2,7 @@
#include "sc1.h" #include "sc1.h"
int main(int argc,char** argv) int main(int argc, char** argv)
{ {
const int n = (argc > 1) ? (atoi(&argv[1][1])) : 0; const int n = (argc > 1) ? (atoi(&argv[1][1])) : 0;
switch(n) switch(n)

2
sc/sc1300.cpp
View File

@ -2,6 +2,7 @@
#include <mask.h> #include <mask.h>
#include <config.h> #include <config.h>
#include <progind.h> #include <progind.h>
#include <recarray.h>
#include <recset.h> #include <recset.h>
#include <relation.h> #include <relation.h>
#include <reputils.h> #include <reputils.h>
@ -34,6 +35,7 @@ void TAllinea_partite::on_config_change()
void TAllinea_partite::allinea(int logicnum, TLog_report& log, bool& can_write) void TAllinea_partite::allinea(int logicnum, TLog_report& log, bool& can_write)
{ {
TFast_isamfile fast(logicnum);
TString query; TString query;
query << "USE " << logicnum; query << "USE " << logicnum;
TISAM_recordset recset(query); TISAM_recordset recset(query);

9
sc/sc1400.cpp
View File

@ -183,12 +183,14 @@ void TAbbuona_partite::fill_sheet(const char tipocf, const TCurrency& imp_min, T
row.add(scad.get(SCAD_NUMPART)); row.add(scad.get(SCAD_NUMPART));
row.add(scad.get(SCAD_NRIGA)); row.add(scad.get(SCAD_NRIGA));
const TRectype& game_rec = cache().get(LF_PARTITE, row); const TRectype& game_rec = cache().get(LF_PARTITE, row);
if (game_rec.empty())
continue;
// Ignora partite con la valuta incompatibile // Ignora partite con la valuta incompatibile
const TString& game_val = game_rec.get(PART_CODVAL); const TString& game_val = game_rec.get(PART_CODVAL);
if (in_valuta) if (in_valuta)
{ {
if (game_val != cod_val) if (!same_values(game_val, cod_val))
continue; continue;
} }
else else
@ -200,7 +202,10 @@ void TAbbuona_partite::fill_sheet(const char tipocf, const TCurrency& imp_min, T
TPartita partita(game_rec); TPartita partita(game_rec);
const int nriga = scad.get_int(SCAD_NRIGA); const int nriga = scad.get_int(SCAD_NRIGA);
const int nrata = scad.get_int(SCAD_NRATA); const int nrata = scad.get_int(SCAD_NRATA);
TRiga_scadenze& rata = partita.riga(nriga).rata(nrata); if (!partita.esiste(nriga, nrata))
continue;
TRiga_scadenze& rata = partita.rata(nriga, nrata);
TImporto imp_res = rata.residuo(in_valuta); TImporto imp_res = rata.residuo(in_valuta);
imp_res.normalize(tipocf == 'C' ? 'D' : 'A'); imp_res.normalize(tipocf == 'C' ? 'D' : 'A');
const TCurrency residuo(imp_res.valore(), cod_val); const TCurrency residuo(imp_res.valore(), cod_val);

923
sc/sc2400.cpp
View File

@ -1,433 +1,490 @@
#include "sc2.h" #include "sc2.h"
#include "sc2402.h" #include "sc2402.h"
#include "sc2102.h" #include "sc2102.h"
#include "sc2400a.h" #include "sc2400a.h"
#include <applicat.h> #include <applicat.h>
#include <progind.h> #include <progind.h>
#include <printer.h> #include <printer.h>
#include <reputils.h> #include <reputils.h>
#include <clifo.h> #include <clifo.h>
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// Stampa solleciti // Stampa solleciti
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
class TStampaSol_application: public TSkeleton_application class TStampaSol_application: public TSkeleton_application
{ {
TString _lingua_ditta; TString _lingua_ditta;
TSol_mask *_msk; TSol_mask *_msk;
bool _gesval; bool _gesval;
TSol_form *_form; TSol_form *_form;
protected: protected:
virtual bool create(); virtual bool create();
virtual bool destroy(); virtual bool destroy();
virtual void main_loop(); virtual void main_loop();
virtual void on_firm_change(); virtual void on_firm_change();
bool get_mail_address(TToken_string& to, TToken_string& cc) const; bool get_mail_address(TToken_string& to, TToken_string& cc) const;
virtual bool get_next_mail(TToken_string& to, TToken_string& cc, TToken_string& ccn, virtual bool get_next_mail(TToken_string& to, TToken_string& cc, TToken_string& ccn,
TString& subj, TString& text, TToken_string& attach, short& ui) const; TString& subj, TString& text, TToken_string& attach, short& ui) const;
int print_sol(); // stampa l'elemento corrente const TString& game_key(const TRectype& part) const; // Costruisce chiave univoca per TAssoc_array partite
bool ci_sono_scadenze_aperte(const TPartita& game, const TDate& dal, const TDate& al) const;
public: int print_sol(); // stampa l'elemento corrente
TSol_mask &mask() const { return *_msk; }
TSol_form &form() const { return *_form; } public:
TCursor_sheet &sheet() { return _msk->cur_sheet(); } TSol_mask &mask() const { return *_msk; }
TSol_form &form() const { return *_form; }
bool print_selected(); // cicla la stampa sugli elementi selezionati TCursor_sheet &sheet() { return _msk->cur_sheet(); }
bool mail_selected(); // manda email agli elementi selezionati
bool print_selected(); // cicla la stampa sugli elementi selezionati
TStampaSol_application(); bool mail_selected(); // manda email agli elementi selezionati
virtual ~TStampaSol_application() {}
}; TStampaSol_application();
virtual ~TStampaSol_application() {}
bool TStampaSol_application::print_selected() };
{
TCursor_sheet &s = sheet(); bool TStampaSol_application::print_selected()
TCursor &c = *s.cursor(); {
TCursor_sheet &s = sheet();
const char who = mask().get_who(); TCursor &c = *s.cursor();
const int key = mask().get_key();
const char who = mask().get_who();
// Attiva la stampa del saldo partita const int key = mask().get_key();
form().stampa_saldo(mask().stampa_saldo());
// Attiva la stampa del saldo partita
// filtra il cursore del form in modo che diventi uguale al cursor_sheet corrente form().stampa_saldo(mask().stampa_saldo());
// Qui sarebbe bello copiarsi l'indice dell'altro cursore
TCursor &fc = *form().cursor(); // filtra il cursore del form in modo che diventi uguale al cursor_sheet corrente
fc.setkey(key); // Qui sarebbe bello copiarsi l'indice dell'altro cursore
TRectype filter(LF_CLIFO); TCursor &fc = *form().cursor();
filter.put(CLI_TIPOCF, who); fc.setkey(key);
fc.setregion(filter, filter); TRectype filter(LF_CLIFO);
filter.put(CLI_TIPOCF, who);
const long print_all = !s.one_checked(); // se non ho selezionato nulla allora li stampo tutti fc.setregion(filter, filter);
long analfabeti = 0; // persone non stampate in quanto aventi lingua errata
const long print_all = !s.one_checked(); // se non ho selezionato nulla allora li stampo tutti
printer().open(); long analfabeti = 0; // persone non stampate in quanto aventi lingua errata
const long items = c.items(); printer().open();
for (long i=0; i < items; i++)
{ const long items = c.items();
if (print_all || s.checked(i)) for (long i=0; i < items; i++)
{ {
fc = i; // muove il cursore alla posizione corrente if (print_all || s.checked(i))
const int ret = print_sol(); {
if (ret < 0) fc = i; // muove il cursore alla posizione corrente
analfabeti++; const int ret = print_sol();
} if (ret < 0)
analfabeti++;
if (printer().frozen()) }
break;
} if (printer().frozen())
printer().close(); break;
}
if (analfabeti > 0) printer().close();
warning_box(FR("%ld clienti non sono stati stampati in quanto "
"il codice lingua non corrispondeva al profilo di stampa"), analfabeti); if (analfabeti > 0)
warning_box(FR("%ld clienti non sono stati stampati in quanto "
return TRUE; "il codice lingua non corrispondeva al profilo di stampa"), analfabeti);
}
return TRUE;
int TStampaSol_application::print_sol() }
{
TSol_form& f = form(); bool TStampaSol_application::ci_sono_scadenze_aperte(const TPartita& game, const TDate& dal, const TDate& al) const
{
// preparazione variabili per controllo lingua bool found = false;
const TRectype &clf= f.cursor()->file().curr(); const int ultima = game.last();
const TString lincf(clf.get(CLI_CODLIN)); if (ultima > 0 && !game.chiusa(true))
bool ok= TRUE; {
for (int r = ultima; r > 0; r = game.pred(r))
// controllo lingua ditta corrente {
if ((f.lingua() == _lingua_ditta && !lincf.empty()) || f.lingua() != _lingua_ditta) ok= (lincf == f.lingua()); const TRiga_partite& row = game.riga(r);
if (!ok) return -1; // cliente analfabeta if (row.is_fattura() && row.get_date(PART_DATAREG) <= al)
{
f.azzera_totali(); for (int s = row.rate(); s > 0 ;s--)
// filtra solo le partite del cliente selezionato {
TLocalisamfile partite(LF_PARTITE); const TRiga_scadenze& rata = row.rata(s);
partite.zero(); if (!rata.chiusa(true))
partite.put(PART_TIPOCF, clf.get(CLI_TIPOCF)); {
partite.put(PART_SOTTOCONTO, clf.get(CLI_CODCF)); const TDate data = rata.get(SCAD_DATASCAD);
const TRectype filter(partite.curr()); if (data >= dal && data <= al)
found = true;
bool one_printed = FALSE; // booleano di controllo di riuscita della stampa }
const bool sel_tot_saldo = f.get_sel_tot_saldo(); // selezione sul saldo totale cliente }
const real sel_importo(f.get_sel_importo()); // importo di selezione }
const TDate data_limite_soll(f.data_limite_operazione()); }
const TDate data_limite_scad(f.data_limite_scaduto()); }
return found;
if (sel_tot_saldo && sel_importo > ZERO) }
{
real saldo;
for (int err = partite.read(_isgteq); const TString& TStampaSol_application::game_key(const TRectype& part) const
err == NOERR && partite.curr() == filter; {
err = partite.read(_isgreat)) TToken_string& tok = get_tmp_string();
{ tok = part.get(PART_ANNO);
TPartita game(partite.curr()); tok.add(part.get(PART_NUMPART));
saldo += game.calcola_scaduto_al(FALSE, data_limite_soll); // Era data_limite_scad! return tok;
partite.put(PART_NRIGA, 9999); }
}
if (saldo < sel_importo) int TStampaSol_application::print_sol()
return 0; {
partite.curr() = filter; TSol_form& f = form();
}
for (int err = partite.read(_isgteq); // preparazione variabili per controllo lingua
err == NOERR && partite.curr() == filter; const TRectype &clf= f.cursor()->file().curr();
err = partite.read(_isgreat)) const TString lincf(clf.get(CLI_CODLIN));
{ bool ok = true;
TPartita game(partite.curr());
const real saldo = game.calcola_scaduto_al(FALSE, data_limite_scad); // controllo lingua ditta corrente
if ((f.lingua() == _lingua_ditta && !lincf.empty()) || f.lingua() != _lingua_ditta) ok= (lincf == f.lingua());
TImporto unreferenced; //Totale non assegnati per questa partita. if (!ok) return -1; // cliente analfabeta
{
// E' giusto calcolare il saldo, comprendente i non assegnati. f.azzera_totali();
// se il saldo della partita chiude in avere va sommato ad unreferenced // filtra solo le partite del cliente selezionato
const TRiga_partite& sum = game.riga(game.first()); TLocalisamfile partite(LF_PARTITE);
unreferenced = game.calcola_saldo_al(game.in_valuta() && f.in_valuta(),data_limite_soll, data_limite_scad, data_limite_scad); partite.zero();
if (unreferenced.valore() > ZERO && unreferenced.sezione() == 'A') partite.put(PART_TIPOCF, clf.get(CLI_TIPOCF));
{ partite.put(PART_SOTTOCONTO, clf.get(CLI_CODCF));
unreferenced.normalize('A'); //per i non assegnati/anticipi c'e' solo la colonna AVERE const TRectype filter(partite.curr());
const TString8 valuta = sum.get(PART_CODVAL);
form().totali().add(unreferenced,valuta); bool one_printed = false; // booleano di controllo di riuscita della stampa
} const bool sel_tot_saldo = f.get_sel_tot_saldo(); // selezione sul saldo totale cliente
} const real sel_importo(f.get_sel_importo()); // importo di selezione
const TDate data_inizio_soll = _msk->get(F_DATAINISCAD);
if (sel_tot_saldo || (saldo > ZERO && saldo >= sel_importo )) const TDate data_limite_soll = f.data_limite_operazione();
{ const TDate data_limite_scaduto = f.data_limite_scaduto();
const bool printed = form().print_game(game);
one_printed |= printed; TAssoc_array games_in_range;
}
if ((sel_tot_saldo && sel_importo > ZERO) || data_inizio_soll.ok())
partite.put(PART_NRIGA, 9999); {
real saldo;
if (printer().frozen()) for (int err = partite.read(_isgteq);
break; err == NOERR && partite.curr() == filter;
} err = partite.read(_isgreat))
{
if (one_printed) const TPartita game(partite.curr());
{ const real sld = game.calcola_scaduto_al(false, data_limite_soll);
f.ultima_pagina();
printer().formfeed(); if (sld > ZERO && data_inizio_soll.ok() &&
} ci_sono_scadenze_aperte(game, data_inizio_soll, data_limite_soll))
games_in_range.add(game_key(partite.curr()));
return one_printed ? 1 : 0;
} saldo += sld;
partite.put(PART_NRIGA, 9999);
bool TStampaSol_application::get_mail_address(TToken_string& to, TToken_string& cc) const }
{
const TRectype& fc = form().cursor()->curr(); if (sel_tot_saldo && sel_importo > ZERO && saldo < sel_importo)
const long codcf = fc.get_long(CLI_CODCF); return 0;
TString8 clifo; clifo.format("C%06ld", codcf); if (data_inizio_soll.ok() && games_in_range.empty())
TISAM_recordset contacts("USE MULTIREL\nFROM COD=BACON FIRST=#CLIFO\nTO COD=BACON FIRST=#CLIFO"); return 0;
contacts.set_var("#CLIFO", clifo);
partite.curr() = filter;
TToken_string data; }
for (bool ok = contacts.move_first(); ok; ok = contacts.move_next()) for (int err = partite.read(_isgteq);
{ err == NOERR && partite.curr() == filter;
data = contacts.get("DATA").as_string(); err = partite.read(_isgreat))
FOR_EACH_TOKEN(data, tok) {
{ if (data_inizio_soll.ok() && !games_in_range.is_key(game_key(partite.curr())))
const TFixed_string doc(tok); continue; // Scarta parite fuori range di date
if (doc.starts_with("sc2400", true) || doc.starts_with("sollec", true))
{ const TPartita game(partite.curr());
const TRectype& rub = cache().get(LF_CONTACT, contacts.get("SECOND").as_int()); const real saldo = game.calcola_scaduto_al(false, data_limite_scaduto);
TString80 mail = rub.get("MAIL");
if (mail.blank()) TImporto unreferenced; //Totale non assegnati per questa partita.
mail = rub.get("MAIL2"); {
if (mail.full()) // E' giusto calcolare il saldo, comprendente i non assegnati.
{ // se il saldo della partita chiude in avere va sommato ad unreferenced
if (to.blank()) const TRiga_partite& sum = game.riga(game.first());
to = mail; unreferenced = game.calcola_saldo_al(game.in_valuta() && f.in_valuta(),data_limite_soll, data_limite_scaduto, data_limite_scaduto);
else if (unreferenced.valore() > ZERO && unreferenced.sezione() == 'A')
cc.add(mail); {
break; unreferenced.normalize('A'); //per i non assegnati/anticipi c'e' solo la colonna AVERE
} const TString8 valuta = sum.get(PART_CODVAL);
} form().totali().add(unreferenced,valuta);
} }
} }
if (to.blank()) if (sel_tot_saldo || (saldo > ZERO && saldo >= sel_importo ))
{ {
TString8 key; key << "C|" << codcf; const bool printed = form().print_game(game);
to = cache().get(LF_CLIFO, key, CLI_DOCMAIL); one_printed |= printed;
} }
return to.full(); partite.put(PART_NRIGA, 9999);
}
if (printer().frozen())
break;
bool TStampaSol_application::get_next_mail(TToken_string& to, TToken_string& cc, TToken_string& ccn, }
TString& subj, TString& text, TToken_string& attach, short& ui) const
{ if (one_printed)
bool ok = TApplication::get_next_mail(to, cc, ccn, subj, text, attach, ui) && get_mail_address(to, cc); {
f.ultima_pagina();
if (ok) printer().formfeed();
{ }
const TRectype& clifo = form().cursor()->curr();
const TDate oggi = mask().get(F_DATASEND); return one_printed ? 1 : 0;
}
subj << TR("Sollecito ") << prefix().firm().ragione_sociale();
text << "Spett. " << clifo.get(CLI_RAGSOC) << '\n'; bool TStampaSol_application::get_mail_address(TToken_string& to, TToken_string& cc) const
text << TR("Si sollecita il rispetto delle scadenze aperte al ") << oggi << TR(" riepilogate nel file ") << attach {
<< "\n" << prefix().firm().ragione_sociale(); const TRectype& fc = form().cursor()->curr();
if (to.full()) const long codcf = fc.get_long(CLI_CODCF);
ui &= ~0x1; // No user interface TString8 clifo; clifo.format("C%06ld", codcf);
ui |= 0x2; // Query receipt TISAM_recordset contacts("USE MULTIREL\nFROM COD=BACON FIRST=#CLIFO\nTO COD=BACON FIRST=#CLIFO");
contacts.set_var("#CLIFO", clifo);
const long codcf = clifo.get_long(CLI_CODCF);
TFilename pdf; TToken_string data;
ok = get_next_pdf(oggi.year(), -1, "SOLL", oggi.date2ansi(), codcf, pdf); for (bool ok = contacts.move_first(); ok; ok = contacts.move_next())
attach = pdf; {
} data = contacts.get("DATA").as_string();
FOR_EACH_TOKEN(data, tok)
return ok; {
} const TFixed_string doc(tok);
if (doc.starts_with("sc2400", true) || doc.starts_with("sollec", true))
struct TMail_message : public TObject {
{ const TRectype& rub = cache().get(LF_CONTACT, contacts.get("SECOND").as_int());
TToken_string _to, _cc, _ccn; TString80 mail = rub.get("MAIL");
TString _subj, _text; if (mail.blank())
TToken_string _attach; mail = rub.get("MAIL2");
short _ui; if (mail.full())
}; {
if (to.blank())
bool TStampaSol_application::mail_selected() to = mail;
{ else
TCursor_sheet &s = sheet(); cc.add(mail);
TCursor &c = *s.cursor(); break;
}
const char who = mask().get_who(); }
const int key = mask().get_key(); }
}
// Attiva la stampa del saldo partita
form().stampa_saldo(mask().stampa_saldo()); if (to.blank())
{
// filtra il cursore del form in modo che diventi uguale al cursor_sheet corrente TString8 key; key << "C|" << codcf;
// Qui sarebbe bello copiarsi l'indice dell'altro cursore to = cache().get(LF_CLIFO, key, CLI_DOCMAIL);
TCursor &fc = *form().cursor(); }
fc.setkey(key);
TRectype filter(LF_CLIFO); return to.full();
filter.put(CLI_TIPOCF, who); }
fc.setregion(filter, filter);
const long print_all = !s.one_checked(); // se non ho selezionato nulla allora li stampo tutti bool TStampaSol_application::get_next_mail(TToken_string& to, TToken_string& cc, TToken_string& ccn,
TString& subj, TString& text, TToken_string& attach, short& ui) const
TLog_report log; {
bool ok = TApplication::get_next_mail(to, cc, ccn, subj, text, attach, ui) && get_mail_address(to, cc);
TArray mail;
if (ok)
const long items = c.items(); {
if (items > 0) const TRectype& clifo = form().cursor()->curr();
{ TDate oggi = mask().get(F_DATALIMSOL);
const TDate oggi(TODAY); if (!oggi.ok())
TProgind pi(items); oggi = mask().get_date(F_DATASEND);
for (long i=0; i < items; i++)
{ subj << TR("Sollecito ") << prefix().firm().ragione_sociale();
if (!pi.addstatus(1)) TString ragsoc = clifo.get(CLI_RAGSOC); ragsoc.strip_double_spaces();
break; text << "Spett. " << ragsoc << '\n';
if (print_all || s.checked(i)) text << TR("Si sollecita il rispetto delle scadenze aperte al ") << oggi << TR(" riepilogate nel file ") << attach
{ << "\n" << prefix().firm().ragione_sociale();
fc = i; // muove il cursore alla posizione corrente if (to.full())
ui &= ~0x1; // No user interface
printer().set_printtype(exportprinter); ui |= 0x2; // Query receipt
printer().open();
const int ret = print_sol(); const long codcf = clifo.get_long(CLI_CODCF);
printer().close(); TFilename pdf;
ok = get_next_pdf(oggi.year(), -1, "SOLL", oggi.date2ansi(), codcf, pdf);
if (ret > 0) attach = pdf;
{ }
TString msg;
msg << fc.curr().get(CLI_RAGSOC) << ": "; return ok;
msg.strip_double_spaces(); }
TMail_message* m = new TMail_message; struct TMail_message : public TObject
bool done = false; {
if (get_next_mail(m->_to, m->_cc, m->_ccn, m->_subj, m->_text, m->_attach, m->_ui)) TToken_string _to, _cc, _ccn;
{ TString _subj, _text;
const TFilename fn = m->_attach; TToken_string _attach;
done = printer().print_pdf(printer().get_txt(), fn); short _ui;
if (done) };
{
msg << TR("invio ") << fn.name() << TR(" a ") << m->_to; bool TStampaSol_application::mail_selected()
log.log(0, msg); {
mail.add(m); TCursor_sheet &s = sheet();
} TCursor &c = *s.cursor();
else
{ const char who = mask().get_who();
msg << TR("Impossibile genereare ") << fn; const int key = mask().get_key();
log.log(2, msg);
} // Attiva la stampa del saldo partita
} form().stampa_saldo(mask().stampa_saldo());
else
{ // filtra il cursore del form in modo che diventi uguale al cursor_sheet corrente
msg << TR("Impossibile trovare un indirizzo e-mail valido"); // Qui sarebbe bello copiarsi l'indice dell'altro cursore
log.log(2, msg); TCursor &fc = *form().cursor();
} fc.setkey(key);
TRectype filter(LF_CLIFO);
if (!done) filter.put(CLI_TIPOCF, who);
delete m; fc.setregion(filter, filter);
}
} const long print_all = !s.one_checked(); // se non ho selezionato nulla allora li stampo tutti
}
printer().read_configuration(); TLog_report log;
}
TArray mail;
log.preview();
const long items = c.items();
if (!mail.empty()) if (items > 0)
{ {
TArray_sheet sheet(-1, -1, 78, 20, TR("Mail"), HR("@1|Destinatario@32|Messaggio@50"), 0, 1); const TDate oggi(TODAY);
FOR_EACH_ARRAY_ITEM(mail, r, obj) TProgind pi(items);
{ for (long i=0; i < items; i++)
const TMail_message& m = *(TMail_message*)obj; {
TToken_string* row = new TToken_string; if (!pi.addstatus(1))
*row = "X"; break;
row->add(m._to); if (print_all || s.checked(i))
row->add(m._text.before('\n')); {
sheet.add(row); fc = i; // muove il cursore alla posizione corrente
}
if (sheet.run() == K_ENTER) printer().set_export_file("soll.pdf", true);
{ printer().open();
const long m = sheet.checked(); const int ret = print_sol();
if (m > 0 && yesno_box(FR("Confermare l'invio di %ld mail?"), m)) printer().close();
{
FOR_EACH_CHECKED_ROW(sheet, r, row) if (ret > 0)
{ {
const TMail_message& m = (const TMail_message&)mail[r]; TString msg;
xvt_mail_send(m._to, m._cc, m._ccn, m._subj, m._text, m._attach, m._ui); msg << fc.curr().get(CLI_RAGSOC) << ": ";
} msg.strip_double_spaces();
}
} TMail_message* m = new TMail_message;
} bool done = false;
if (get_next_mail(m->_to, m->_cc, m->_ccn, m->_subj, m->_text, m->_attach, m->_ui))
return true; {
} const TFilename fn = m->_attach;
done = printer().print_pdf(printer().get_txt(), fn);
if (done)
bool TStampaSol_application::create() {
{ msg << TR("invio ") << fn.name() << TR(" a ") << m->_to;
TApplication::create(); log.log(0, msg);
mail.add(m);
open_files(LF_TABCOM, LF_TAB, LF_CAUSALI, LF_MOV, LF_RMOV, 0); }
open_files(LF_NDITTE, LF_ANAG, LF_COMUNI, LF_RFORM, 0); else
open_files(LF_CLIFO, LF_PARTITE, LF_SCADENZE, LF_PAGSCA ,0); {
msg << TR("Impossibile genereare ") << fn;
_msk = new TSol_mask("sc2400a"); log.log(2, msg);
}
return TSkeleton_application::create(); }
} else
{
bool TStampaSol_application::destroy() msg << TR("Impossibile trovare un indirizzo e-mail valido");
{ log.log(2, msg);
delete _msk; }
return TSkeleton_application::destroy();
} if (!done)
delete m;
void TStampaSol_application::on_firm_change() }
{ }
mask().reset(); }
mask().set(F_STAMPSALDO, "X"); printer().read_configuration();
}
TApplication::on_firm_change();
TConfig c(CONFIG_DITTA, "cg"); log.preview();
_lingua_ditta= c.get("CodLin");
_gesval= c.get_bool("GesVal"); if (!mail.empty())
} {
TArray_sheet sheet(-1, -1, 78, 20, TR("Mail"), HR("@1|Destinatario@32|Messaggio@50"), 0, 1);
void TStampaSol_application::main_loop() FOR_EACH_ARRAY_ITEM(mail, r, obj)
{ {
TSol_mask& m = mask(); const TMail_message& m = *(TMail_message*)obj;
for(;;) TToken_string* row = new TToken_string;
{ *row = "X";
const KEY key = m.run(); row->add(m._to);
if (key == K_QUIT) row->add(m._text.before('\n'));
break; sheet.add(row);
}
const TDate dlimsol(m.get(F_DATALIMSOL)); if (sheet.run() == K_ENTER)
const TDate dsped(m.get(F_DATASEND)); {
if (dlimsol >= dsped) const long m = sheet.checked();
{ if (m > 0 && yesno_box(FR("Confermare l'invio di %ld mail?"), m))
_form= new TSol_form(m, _gesval, F_DATALIMOP, F_DATALIMSOL); {
if (key == 'M') FOR_EACH_CHECKED_ROW(sheet, r, row)
mail_selected(); {
else const TMail_message& m = (const TMail_message&)mail[r];
print_selected(); xvt_mail_send(m._to, m._cc, m._ccn, m._subj, m._text, m._attach, m._ui);
delete _form; }
_form= NULL; }
} }
else }
error_box(TR("La data limite sollecito deve essere specificata e non puo' essere superiore alla data di invio"));
} return true;
} }
TStampaSol_application::TStampaSol_application(): _lingua_ditta(1), _msk(NULL), _form(NULL) {}
bool TStampaSol_application::create()
int sc2400(int argc, char** argv) {
{ TApplication::create();
TStampaSol_application app;
app.run(argc, argv, TR("Stampa solleciti")); open_files(LF_TABCOM, LF_TAB, LF_CAUSALI, LF_MOV, LF_RMOV, 0);
return 0; open_files(LF_NDITTE, LF_ANAG, LF_COMUNI, LF_RFORM, 0);
} open_files(LF_CLIFO, LF_PARTITE, LF_SCADENZE, LF_PAGSCA ,0);
_msk = new TSol_mask("sc2400a");
return TSkeleton_application::create();
}
bool TStampaSol_application::destroy()
{
delete _msk;
return TSkeleton_application::destroy();
}
void TStampaSol_application::on_firm_change()
{
mask().reset();
mask().set(F_STAMPSALDO, "X");
TApplication::on_firm_change();
TConfig c(CONFIG_DITTA, "cg");
_lingua_ditta= c.get("CodLin");
_gesval= c.get_bool("GesVal");
}
void TStampaSol_application::main_loop()
{
TSol_mask& m = mask();
for(;;)
{
const KEY key = m.run();
if (key == K_QUIT)
break;
const TDate dlimsol(m.get(F_DATALIMSOL));
const TDate dsped(m.get(F_DATASEND));
if (dlimsol >= dsped)
{
_form= new TSol_form(m, _gesval, F_DATALIMOP, F_DATALIMSOL);
if (key == 'M')
mail_selected();
else
print_selected();
delete _form;
_form= NULL;
}
else
error_box(TR("La data limite sollecito deve essere specificata e non puo' essere superiore alla data di invio"));
}
}
TStampaSol_application::TStampaSol_application(): _lingua_ditta(1), _msk(NULL), _form(NULL) {}
int sc2400(int argc, char** argv)
{
TStampaSol_application app;
app.run(argc, argv, TR("Stampa solleciti"));
return 0;
}

9
sc/sc2400a.h
View File

@ -5,9 +5,10 @@
#include "sc2100a.h" #include "sc2100a.h"
#endif #endif
#define F_DATALIMSOL 106 #define F_DATAINISCAD 130
#define F_STAMPESP 107 #define F_DATALIMSOL 131
#define F_IMPORMIN 108 #define F_STAMPESP 132
#define F_RIFIMPMIN 109 #define F_IMPORMIN 133
#define F_RIFIMPMIN 134
#endif #endif

12
sc/sc2400a.uml
View File

@ -97,16 +97,20 @@ BEGIN
PROMPT 2 4 "Data limite operazione " PROMPT 2 4 "Data limite operazione "
END END
DATE F_DATALIMSOL DATE F_DATALIMSOL
BEGIN BEGIN
PROMPT 2 5 "Data limite sollecito " PROMPT 2 5 "Data limite solleciti "
FLAGS "A" FLAGS "A"
// VALIDATE DATE_CMP_FUNC <= F_DATASEND
// WARNING "La data limite sollecito deve essere specificata e non puo' essere superiore alla data di invio"
CHECKTYPE REQUIRED CHECKTYPE REQUIRED
END END
DATE F_DATAINISCAD
BEGIN
PROMPT 42 5 "Dal "
VALIDATE DATE_CMP_FUNC <= F_DATALIMSOL
WARNING "Inserire una data precedente a quella limite"
END
CURRENCY F_IMPORMIN 18 CURRENCY F_IMPORMIN 18
BEGIN BEGIN
PROMPT 2 6 "Importo minimo " PROMPT 2 6 "Importo minimo "

33
sc/sc2401.cpp
View File

@ -230,8 +230,8 @@ void TESSL_row::print_on(TPrint_section& body)
dare.set(""); dare.set("");
} }
TForm_item& importo_in_lire = body.find_field(PEC_IMPEURO); TForm_item& importo_in_euro = body.find_field(PEC_IMPEURO);
set_imp(importo_in_lire, _importo_lire, ""); // In generale va espresso nella valuta della ditta set_imp(importo_in_euro, _importo_euro, ""); // In generale va espresso nella valuta della ditta
TForm_item& scaduto = body.find_field(PEC_SCADUTO); TForm_item& scaduto = body.find_field(PEC_SCADUTO);
set_imp(scaduto, _scaduto, cod_valuta); set_imp(scaduto, _scaduto, cod_valuta);
@ -429,7 +429,7 @@ void TESSL_array::add_row(const TRiga_partite& row)
real importo_in_lire; real importo_in_lire;
const char sezione = form().sezione_normale(); const char sezione = form().sezione_normale();
const TDate data_op(row.get(PART_DATAREG)); const TDate data_op = row.get(PART_DATAREG);
if (data_op <= form().data_limite_operazione()) if (data_op <= form().data_limite_operazione())
{ {
if (row.is_fattura()) if (row.is_fattura())
@ -437,14 +437,13 @@ void TESSL_array::add_row(const TRiga_partite& row)
for (int r = 1; r <= row.rate(); r++) for (int r = 1; r <= row.rate(); r++)
{ {
const TRiga_scadenze& rata = row.rata(r); const TRiga_scadenze& rata = row.rata(r);
const TDate data_scad(rata.get(SCAD_DATASCAD)); const TDate data_scad = rata.get(SCAD_DATASCAD);
TESSL_row& rec = new_row(row, data_scad, rata.importo(in_valuta), r); TESSL_row& rec = new_row(row, data_scad, rata.importo(in_valuta), r);
if (in_valuta) if (in_valuta)
{ {
TImporto il(rata.importo(FALSE)); TImporto il(rata.importo(false));
il.normalize(sezione); il.normalize(sezione);
rec.importo_in_lire(il.valore()); rec.importo_in_euro(il.valore());
} }
if (data_scad <= form().data_limite_scaduto()) if (data_scad <= form().data_limite_scaduto())
{ {
@ -462,7 +461,7 @@ void TESSL_array::add_row(const TRiga_partite& row)
{ {
TImporto i(row.importo(FALSE, 0x1)); TImporto i(row.importo(FALSE, 0x1));
i.normalize(sezione); i.normalize(sezione);
riga.importo_in_lire(i.valore()); riga.importo_in_euro(i.valore());
} }
const int tipo_pag = row.get_int(PART_TIPOPAG); const int tipo_pag = row.get_int(PART_TIPOPAG);
@ -496,7 +495,7 @@ void TESSL_array::add_row(const TRiga_partite& row)
if (in_valuta) if (in_valuta)
{ {
ritenute.normalize(sezione); ritenute.normalize(sezione);
r.importo_in_lire(ritenute.valore()); r.importo_in_euro(ritenute.valore());
} }
else else
r.importo(ritenute); r.importo(ritenute);
@ -511,7 +510,7 @@ void TESSL_array::add_row(const TRiga_partite& row)
{ {
TImporto il(row.importo(FALSE, 0x2)); TImporto il(row.importo(FALSE, 0x2));
il.normalize(sezione == 'D' ? 'A' : 'D'); il.normalize(sezione == 'D' ? 'A' : 'D');
r.importo_in_lire(il.valore()); r.importo_in_euro(il.valore());
} }
} }
@ -670,7 +669,7 @@ void TESSL_form::stampa_riporti(TPrinter& pr)
TESSL_row rip(desc, t.importo().normalize(),val); TESSL_row rip(desc, t.importo().normalize(),val);
rip.scaduto(t.scaduto()); rip.scaduto(t.scaduto());
rip.esposto(t.esposto()); rip.esposto(t.esposto());
rip.importo_in_lire(t.importo_euro()); rip.importo_in_euro(t.importo_euro());
rip.print_on(body); rip.print_on(body);
pr.setfooterline(j + 1, body.row(0)); pr.setfooterline(j + 1, body.row(0));
} }
@ -932,7 +931,7 @@ bool TESSL_form::print_game(const TPartita& game)
TPrint_section& body = section('B'); TPrint_section& body = section('B');
TImporto saldo; TImporto saldo;
real scaduto, esposto, implire; real scaduto, esposto, impeuro;
// Stampa le righe di partita // Stampa le righe di partita
@ -964,12 +963,12 @@ bool TESSL_form::print_game(const TPartita& game)
pr.print(body.row(0)); pr.print(body.row(0));
totali().add(riga.importo(), riga.scaduto(), riga.esposto(), totali().add(riga.importo(), riga.scaduto(), riga.esposto(),
riga.importo_in_lire(), riga.valuta().codice()); riga.importo_in_euro(), riga.valuta().codice());
saldo += riga.importo(); saldo += riga.importo();
scaduto += riga.scaduto(); scaduto += riga.scaduto();
esposto += riga.esposto(); esposto += riga.esposto();
implire += riga.importo_in_lire(); impeuro += riga.importo_in_euro();
ok = TRUE; ok = TRUE;
} }
@ -990,7 +989,7 @@ bool TESSL_form::print_game(const TPartita& game)
sld.scaduto(scaduto); sld.scaduto(scaduto);
sld.esposto(esposto); sld.esposto(esposto);
sld.importo_in_lire(implire); sld.importo_in_euro(impeuro);
sld.print_on(body); sld.print_on(body);
pr.print(body.row(0)); pr.print(body.row(0));
} }
@ -1051,10 +1050,10 @@ TESSL_form::TESSL_form(const TESSL_mask& m, bool gesval, short id_datalim, short
TCursor_sheet& cs = m.cur_sheet(); TCursor_sheet& cs = m.cur_sheet();
_cursore = cs.cursor(); _cursore = cs.cursor();
_dlo = id_datalim > 0 ? TDate(m.get(id_datalim)) : eotime; _dlo = id_datalim > 0 ? m.get_date(id_datalim) : eotime;
if (!_dlo.ok()) if (!_dlo.ok())
_dlo = eotime; _dlo = eotime;
_dls = id_datascad > 0 ? TDate(m.get(id_datascad)) : eotime; _dls = id_datascad > 0 ? m.get_date(id_datascad) : eotime;
if (id_giorni_rischio > 0) if (id_giorni_rischio > 0)
_giorni_rischio = m.get_int(id_giorni_rischio); _giorni_rischio = m.get_int(id_giorni_rischio);

15
sc/sc2401.h
View File

@ -57,12 +57,12 @@ public:
}; };
class TESSL_form; class TESSL_form;
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// TESSL_row // TESSL_row
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
class TESSL_row : public TSortable class TESSL_row : public TSortable
{ {
TDate _data; // Data scadenza o pagamento TDate _data; // Data scadenza o pagamento
int _riga; // Riga della fattura int _riga; // Riga della fattura
@ -76,7 +76,7 @@ class TESSL_row : public TSortable
long _num_prot; // Protocollo IVA long _num_prot; // Protocollo IVA
long _num_reg; // Numero registrazione long _num_reg; // Numero registrazione
TImporto _importo; // Importo in valuta TImporto _importo; // Importo in valuta
real _importo_lire; // Importo in lire real _importo_euro; // Importo in euro
real _scaduto; // Importo scaduto real _scaduto; // Importo scaduto
real _esposto; // Importo esposto real _esposto; // Importo esposto
bool _salvo_buon_fine; // Importo esposto salvo buon fine bool _salvo_buon_fine; // Importo esposto salvo buon fine
@ -98,7 +98,7 @@ public:
void importo(const TImporto& i) { _importo = i; } void importo(const TImporto& i) { _importo = i; }
void scaduto(const real& s) { _scaduto = s; } void scaduto(const real& s) { _scaduto = s; }
void esposto(const real& e) { _esposto = e; } void esposto(const real& e) { _esposto = e; }
void importo_in_lire(const real& il) { _importo_lire = il; } void importo_in_euro(const real& imp) { _importo_euro = imp; }
void salvo_buon_fine(bool sbf) { _salvo_buon_fine = sbf; } void salvo_buon_fine(bool sbf) { _salvo_buon_fine = sbf; }
const TString& causale() const { return _causale; } const TString& causale() const { return _causale; }
@ -106,9 +106,9 @@ public:
long num_reg() const { return _num_reg; } long num_reg() const { return _num_reg; }
const TValuta& valuta() const { return _valuta; } const TValuta& valuta() const { return _valuta; }
const TImporto& importo() const { return _importo; } const TImporto& importo() const { return _importo; }
real importo_in_lire() const { return _importo_lire; } const real& importo_in_euro() const { return _importo_euro; }
real scaduto() const { return _scaduto; } const real& scaduto() const { return _scaduto; }
real esposto() const { return _esposto; } const real& esposto() const { return _esposto; }
const TDate& data() const { return _data; } const TDate& data() const { return _data; }
bool in_valuta() const { return _valuta.in_valuta(); } bool in_valuta() const { return _valuta.in_valuta(); }
@ -134,7 +134,6 @@ class TESSL_form : public TForm
TCursor* _cursore; TCursor* _cursore;
TTotalizer _totali; TTotalizer _totali;
TString _lingua; TString _lingua;
TDate _dlo, _dls, _dir; TDate _dlo, _dls, _dir;
@ -193,7 +192,7 @@ public:
void ultima_pagina(); void ultima_pagina();
virtual bool print_game(const TPartita& game); virtual bool print_game(const TPartita& game);
TESSL_form(const TESSL_mask& m, bool gesval, short id_datalim = 0 , short id_datascad = 0, short id_giorni_rischio = 0); TESSL_form(const TESSL_mask& m, bool gesval, short id_datalim = 0 , short id_datascad = 0, short id_giorni_rischio = 0);
virtual ~TESSL_form(); virtual ~TESSL_form();
}; };

2
sc/sc2402.cpp
View File

@ -41,7 +41,7 @@ TSol_row::TSol_row(const char* desc, const TImporto& imp, const TValuta& val)
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
TSol_form::TSol_form(const TSol_mask& m, bool gesval, short id_datalim, short id_datascad) TSol_form::TSol_form(const TSol_mask& m, bool gesval, short id_datalim, short id_datascad)
:TESSL_form(m, gesval, id_datalim, id_datascad) : TESSL_form(m, gesval, id_datalim, id_datascad)
{ {
_sel_tot_saldo = m.get_sel_tot_saldo(); _sel_tot_saldo = m.get_sel_tot_saldo();
_sel_importo = m.get_sel_importo(); _sel_importo = m.get_sel_importo();

3
sc/sc2402.h
View File

@ -44,8 +44,7 @@ protected:
public: public:
bool get_sel_tot_saldo() const { return _sel_tot_saldo;} bool get_sel_tot_saldo() const { return _sel_tot_saldo;}
const real & get_sel_importo() const { return _sel_importo; } const real & get_sel_importo() const { return _sel_importo; }
TSol_form(const TSol_mask& m, bool gesval, short id_datalim, short id_datascad); TSol_form(const TSol_mask& m, bool gesval, short id_datalim, short id_datascad);
virtual ~TSol_form() {}
}; };
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////