root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ve/ve0100.cpp
alex d8bb68b774 Patch level : 10.0 814 
Files correlati     : ve0.exe ve6.exe
Ricompilazione Demo : [ ]
Commento            :

Bug 0001703: Fatturazione Bolle (ve6)

Nella gestione dei riferimenti in testa non viene scritto il flagh descrizione lunga per cui non si vedono i riferimenti delle bolla dalla seconda in poi (seganalato da Servizi informatici (SIPAG))

Bug	0001702: Documenti interattivi (ve0)

Agguingere una elaborazione al tipodocumento in modo da poter effettuare delle operazioni all' atto della registrazione. (HABA)

Per utilizzarla correttamente chi la configura deve configurarei stati dell elaborazione perche' venga chiamata quand serve.

Modificata anche la lettura dell stato attivo per le provvigioni, da verificare ka genreazioe dell provvigioni.


git-svn-id: svn://10.65.10.50/branches/R_10_00@20959 c028cbd2-c16b-5b4b-a496-9718f37d4682
2010-10-07 00:35:55 +00:00

1109 lines
29 KiB
C++
Executable File
Raw Blame History

#include <colmask.h>
#include <execp.h>
#include <modaut.h>
#include <recset.h>
#include <tabutil.h>
#include <utility.h>
#include <urldefid.h>
#include "ve0100.h"
#include "veini.h"
#include "vepriv.h"
#include "veuml1.h"
#include "verig.h"
#include "velib04.h"
#include "sconti.h"
#include "../mg/anamag.h"
#include "../mg/mglib.h"
TCursor& TMotore_application::get_filtered_cursor() const
{
const TEdit_field& f = _msk->efield(F_NDOC);
return *f.browse()->cursor();
}
bool TMotore_application::save_and_new() const
{
bool new_doc = false;
TDocumento_mask & m = edit_mask();
if (m.insert_mode())
{
TDocumento& doc = m.doc();
new_doc = doc.codice_numerazione().save_and_new();
}
return new_doc;
}
void TMotore_application::init_query_mode( TMask& m )
{
disable_menu_item(M_FILE_PRINT);
disable_menu_item(M_FILE_PREVIEW);
disable_menu_item(MENU_ITEM_ID(1));
TEdit_field& cn = _msk->efield(F_CODNUM);
if (!lnflag() && cn.empty() && _codnum.full())
{
cn.set(_codnum);
if (_msk->field(F_TIPODOC).empty() && _tipodoc.full())
{
cn.set_focusdirty(TRUE);
cn.on_key(K_TAB);
cn.set_dirty(FALSE);
_msk->set(F_TIPODOC, _tipodoc, TRUE);
}
}
TEdit_field& n = m.efield(F_NDOC);
if (!n.empty())
{
if (find(0))
modify_mode();
}
}
void TMotore_application::init_insert_mode( TMask& m )
{
TDocumento_mask& dm = (TDocumento_mask&)m;
TString4 codnum(m.get(F_CODNUM));
enable_menu_item(MENU_ITEM_ID(1));
dm.reset_father_rows();
if (codnum.empty())
{
TMask * query_mask = get_mask(MODE_QUERY);
codnum = query_mask->get(F_CODNUM);
m.set(F_CODNUM, codnum);
m.set(F_TIPODOC, query_mask->get(F_TIPODOC));
m.set(F_ANNO, query_mask->get_int(F_ANNO));
m.set(F_PROVV, query_mask->get(F_PROVV));
}
const int anno = m.get_int(F_ANNO);
const char provv = m.get(F_PROVV)[0];
const long numdoc = m.get_long(F_NDOC);
TDocumento& curdo = dm.doc();
curdo.read(provv, anno, codnum, numdoc);
curdo.set_tipo(m.get(F_TIPODOC));
const TTipo_documento& tp = curdo.tipo();
const char stato = tp.stato_finale_inserimento();
curdo.stato(stato);
_codnum = codnum;
_tipodoc = m.get(F_TIPODOC);
m.field(F_CODNUM).set_focusdirty(TRUE);
m.field(F_CODNUM).on_key(K_TAB);
m.field(F_TIPODOC).set_focusdirty(TRUE);
m.field(F_TIPODOC).on_key(K_TAB);
m.set(F_ANNORIF, anno);
m.set(F_CODNUMRIF, codnum);
// Giro per supplire alla mancanza di una TMask::set(short id, char c);
char str_stato[2] = { stato, '\0' };
m.set(F_STATO, str_stato);
TDate data_doc(TODAY);
const bool magic_datadoc = m.field(F_DATADOC).automagic();
if (!magic_datadoc)
{
long ndoc = 0; // unused
last_doc(provv, anno, codnum, ndoc, data_doc);
}
m.set(F_DATADOC, data_doc, 0x1);
int pos = m.id2pos( F_DATACAMBIO1);
if (pos >= 0 && m.fld(pos).active() && !m.get(F_CODVAL).empty())
{
m.fld(pos).set(data_doc);
m.fld(pos).dirty();
}
pos = m.id2pos(F_CAUSMAG);
if (pos >= 0)
{
m.fld(pos).set(tp.caus_mov());
m.fld(pos).dirty();
}
tp.set_defaults(m);
if (!dm.field(F_CODCF).empty()) // Carica i dati dell'eventuale cliente
{
curdo.put(DOC_TIPOCF, dm.get(F_TIPOCF));
curdo.put(DOC_CODCF, dm.get(F_CODCF));
dm.cli2mask(true);
}
if (provv == 'P')
m.enable(DLG_CONFERMA);
else
m.disable(DLG_CONFERMA);
m.disable(DLG_PRINT);
m.disable(DLG_PREVIEW);
m.disable(DLG_EMAIL);
m.disable(DLG_ELABORA);
TSheet_field& ss = dm.sfield(F_SHEET);
if (curdo.tipo().auto_add())
{
for (int i = 0; i < 10; i++)
ss.insert(-1, false, true);
}
else
ss.destroy();
dm.mask2doc();
}
void TMotore_application::init_modify_mode( TMask& m )
{
TEdit_field& n = query_mask().efield(F_NDOC);
n.set("");
n.update_flags("R");
const bool enable_print = edit_mask().doc().tipo().printable();
const char provv = m.get(F_PROVV)[0];
enable_menu_item(MENU_ITEM_ID(1));
if (provv == 'P')
{
m.enable(DLG_CONFERMA);
m.disable(DLG_PRINT);
m.disable(DLG_EMAIL);
m.disable(DLG_PREVIEW);
enable_menu_item(M_FILE_PRINT, false);
enable_menu_item(M_FILE_PREVIEW, false);
}
else
{
m.disable(DLG_CONFERMA);
m.enable(DLG_PRINT, enable_print);
m.enable(DLG_EMAIL, enable_print);
m.enable(DLG_PREVIEW, enable_print);
enable_menu_item(M_FILE_PRINT, enable_print);
enable_menu_item(M_FILE_PREVIEW, enable_print);
}
m.enable(DLG_ELABORA);
m.disable(F_STATO);
if (m.id2pos(F_CURGIAC)>0 && m.efield(F_CURGIAC).shown())
{
cached_article_balances(NULL); // Azzera cache delle giacenze
edit_mask().update_giacenza(); // Aggiorna giacenza riga corrente
}
TString80 key;
key << m.get(F_CODNUM);
key << m.get(F_ANNO);
key << provv;
key << m.get(F_NDOC);
// Non dare messaggi inutili durante la cancellazione automatica
if (autodeleting() != 0x3)
{
const bool transaction = is_transaction();
const bool no_mod = !transaction && !doc().modificabile();
const bool no_del = !doc().cancellabile();
if (no_del || no_mod)
{
if (key != __last_key)
{
TString msg;
msg.format(FR("Documento non %s%s%s."), (no_mod ? TR("modificabile"):""),
(no_mod && no_del ? TR(" ne' "):""), (no_del ? TR("cancellabile"):""));
xvtil_statbar_set(msg);
}
}
if (no_mod)
m.disable(DLG_SAVEREC);
if (no_del)
m.disable(DLG_DELREC);
if (m.id2pos(F_IBAN_STATO) > 0)
m.efield(F_IBAN_STATO).validate(K_TAB); // Decodifica IBAN
}
__last_key = key;
}
int TMotore_application::user_function(int index)
{
switch(index)
{
case 1:
break;
default:
yesnofatal_box("Chiamata ad una procedura utente non definita: %d", index);
return NOERR;
break;
}
return NOERR;
}
bool TMotore_application::changing_mask( int mode )
{
static int lastmode = NO_MODE;
const bool change = ( mode != lastmode );
lastmode = mode;
return change;
}
TMask* TMotore_application::get_mask( int mode )
{
if (mode != MODE_INS && mode != MODE_MOD)
return _msk;
TString4 tipodoc = _msk->get(F_TIPODOC); // Prendo il tipo documento dalla maschera di query;
if (mode == MODE_MOD)
tipodoc = get_relation()->curr().get(DOC_TIPODOC); // Lo prendo dalla relazione (Gelai)
_docmsk = (TDocumento_mask*)_doc_masks.objptr(tipodoc);
if (_docmsk == NULL)
{
_docmsk = new TDocumento_mask(tipodoc);
_doc_masks.add(tipodoc, _docmsk);
}
return _docmsk;
}
// Cerca numero e data dell'ultimo documento di una numerazione di un anno
bool TMotore_application::last_doc(char provv, int anno, const char* codnum,
long& ndoc, TDate& ddoc) const
{
TRelation rel(LF_DOC);
TRectype& curr = rel.curr();
curr.put(DOC_PROVV, provv);
curr.put(DOC_ANNO, anno);
TString cod(codnum); cod.left_just(4, '~');
curr.put(DOC_CODNUM, cod);
TCursor cur(&rel, "", 1, &curr, &curr);
TRecnotype docs = cur.items();
bool found = docs > 0;
if (found)
{
cur = docs-1;
ndoc = curr.get_long(DOC_NDOC);
ddoc = curr.get_date(DOC_DATADOC);
}
else
{
ndoc = 0;
const TDate oggi(TODAY);
if (anno < oggi.year())
ddoc = TDate(31, 12, anno);
else
ddoc = oggi;
}
return found;
}
const char* TMotore_application::get_next_key( )
{
const TMask& m = curr_mask( );
const TCodice_numerazione& cod_num = cached_numerazione(m.get(F_CODNUM));
// Se per questa numerazione e' abilitata le numerazione automatica
if (cod_num.auto_num())
{
TDate ddoc; // unused
long ndoc = 1;
if (last_doc(m.get(F_PROVV)[0], m.get_int(F_ANNO), cod_num.codice(), ndoc, ddoc))
ndoc++;
else
ndoc = 1;
return format("%d|%ld", F_NDOC, ndoc);
}
return "";
}
int TMotore_application::read( TMask& m )
{
TDocumento_mask& mask = (TDocumento_mask&) m;
TRelation_application::read(m);
mask.reset_father_rows();
doc() = (TDocumento &)_rel->curr();
mask.update_father_rows(false);
_codnum = m.get(F_CODNUM);
_tipodoc = m.get(F_TIPODOC);
mask.doc2mask();
return NOERR;
}
bool TMotore_application::menu(MENU_TAG mt)
{
bool ok = true;
if (mt == MENU_ITEM_ID(1))
{
if (_docmsk != NULL)
_docmsk->sel_color();
}
else
ok = TRelation_application::menu(mt);
return ok;
}
void TMotore_application::do_elab( TDocumento& doc ) // C 90
{
const TString16 codelab = doc.tipo().elaborazione();
if (codelab.full())
{
TRectype eld = cache().get("%ELD", codelab);
if (!eld.empty())
{
TElaborazione * el = NULL;
switch (eld.get_int("I0"))
{
case _esterna :
el = new TElaborazione_esterna(eld);
break;
case _consegna_ordini:
el = new TConsegna_ordini(eld);
break;
case _fatturazione_bolle :
el = new TFatturazione_bolle(eld);
break;
case _contabilizzazione :
el = new TContabilizzazione(eld);
break;
case _copia_documento :
el = new TCopia_documento(eld);
break;
case _generazione_effetti :
el = new TGenerazione_effetti(eld);
break;
case _consuntivazione_produzione :
el = new TConsuntivazione_produzione(eld);
break;
case _contabilizzazione_analitica :
el = new TContabilizzazione_analitica(eld);
break;
default :
break;
}
TToken_string tipi;
TToken_string stati;
el->tipi_stati_iniziali(tipi, stati);
if (stati.find(doc.stato()) >= 0)
{
TDocumento newdoc(doc.get_char(DOC_PROVV), doc.get_int(DOC_ANNO), el->codice_numerazione_finale(), 0L);
TDocumento::copy_data(newdoc.head(), doc.head());
newdoc.put(DOC_TIPODOC, el->tipo_finale());
newdoc.put(DOC_STATO, el->stato_finale());
if (newdoc.tipo().mov_mag())
newdoc.put(DOC_CAUSMAG, newdoc.tipo().caus_mov());
else
newdoc.zero(DOC_CAUSMAG);
TLista_documenti in; in.add(doc);
TLista_documenti out; out.add(newdoc);
if (el->elabora(in, out, TDate(TODAY), true))
{
if (out[0] != newdoc)
out.rewrite();
if (doc != in[0])
doc = in[0];
}
}
}
}
}
int TMotore_application::write( const TMask& m ) // C 90
{
TDocumento_mask& mask = (TDocumento_mask&) m;
TDocumento& d = (TDocumento&)_rel->curr();
d = mask.doc(); // Trasferisce il documento da maschera a record
// Se ho attivato la creazione automatica delle righe allora cancello quelle vuote finali
if (d.tipo().auto_add())
{
for (int r = d.rows(); r > 0; r--)
{
const TRiga_documento& dr = d[r];
if (dr.get(RDOC_CODART).empty() && dr.get(RDOC_DESCR).empty())
d.destroy_row(r);
else
break;
}
}
do_elab(d);
const int err = TRelation_application::write(m);
if (err == NOERR)
{
mask.update_father_rows();
mask.save_father_rows();
// Stampa immediatamente dopo aver salvato se possibile
if (d.codice_numerazione().save_and_new() && d.tipo().printable())
{
const TString& sis = d.tipo().stati_iniziali_stampa();
if (sis.find(d.stato()) >= 0)
save_and_print(false, winprinter);
}
}
return err;
}
int TMotore_application::rewrite( const TMask& m ) // C 90
{
TDocumento& d = (TDocumento &) _rel->curr();
TDocumento_mask& mask = (TDocumento_mask&) m;
if (d.bloccato())
return NOERR;
d = ((TDocumento_mask&)m).doc(); // Trasferisce il documento da maschera a record
do_elab(d);
const int err = TRelation_application::rewrite(m);
if (err == NOERR)
{
mask.update_father_rows();
mask.save_father_rows();
}
return err;
}
bool TMotore_application::remove() // C 90
{
TDocumento& d = (TDocumento &) _rel->curr();
do_elab(d); // serve ??????
const bool ok = TRelation_application::remove();
if (ok)
edit_mask().save_father_rows();
return ok;
}
void TMotore_application::on_firm_change()
{
if (_config_ditta != NULL)
delete _config_ditta;
_config_ditta = new TConfig(CONFIG_DITTA);
_doc_masks.destroy();
load_auto_reopen_data();
TRelation_application::on_firm_change();
}
void TMotore_application::load_auto_reopen_data()
{
TAssoc_array & auto_reopen_nums = TDocumento_mask::auto_reopen_nums();
TAssoc_array & tipidoc_rels = TDocumento_mask::tipidoc_rels();
TTable num("%NUM");
TTable eld("%ELD");
auto_reopen_nums.destroy();
tipidoc_rels.destroy();
for (int err = num.first(); err == NOERR; err = num.next())
{
if (num.get_bool("B7"))
{
const TString4 codnum = num.get("CODTAB");
TCodice_numerazione numeraz(codnum);
const int ntipidoc = numeraz.ntipi_doc();
TString_array tipi;
for (int k = 0 ; k < ntipidoc; k++)
tipi.add(numeraz.tipo_doc(k));
auto_reopen_nums.add(codnum, codnum);
for (int err1 = eld.first(); err1 == NOERR; err1 = eld.next())
{
TCopia_documento e(eld.get("CODTAB"));
const TTipo_elaborazione tipo = e.tipo();
if (tipo == _consegna_ordini ||
tipo == _consuntivazione_produzione)
{
const TString4 dest_tipo_doc = e.tipo_finale();
const char stato_finale = e.stato_finale_doc_iniziale()[0];
for (int i = 0; i < 10; i++)
{
TToken_string key(e.tipo_iniziale(i));
if (key.blank())
break;
if (tipi.find(key) >= 0)
{
key.add(dest_tipo_doc);
tipidoc_rels.add(key, new TStati(e.stato_iniziale(i), stato_finale));
}
}
}
}
}
}
}
bool num_filter(const TRelation* r)
{
const TCodice_numerazione & cod_num = cached_numerazione(r->curr().get("CODTAB"));
const int last = cod_num.ntipi_doc();
for (int i = 0; i < last; i++ )
if (tipodoc_ok(cod_num.tipo_doc(i)))
return true;
return false;
}
bool TMotore_application::user_create( )
{
open_files(LF_DOC, LF_RIGHEDOC, LF_CONDV, LF_RCONDV, LF_ANAMAG, LF_SCONTI, LF_UMART, LF_DESLIN, LF_CODCORR,
LF_TAB, LF_TABCOM, LF_CLIFO, LF_CFVEN, LF_INDSP, LF_OCCAS, LF_PCON, LF_MOV, LF_STOMAG,
LF_MOVMAG, LF_RMOVMAG, LF_MAG, LF_SVRIEP, LF_AGENTI, LF_PERCPROV, LF_ATTIV, LF_CAUSALI, 0);
TISAM_recordset num("USE %NUM");
for (bool ok = num.move_first(); ok; ok = num.move_next())
const TCodice_numerazione & n = cached_numerazione(num.get("CODTAB").as_string());
TISAM_recordset tip("USE %TIP");
for (bool ok = tip.move_first(); ok; ok = tip.move_next())
const TTipo_documento & n = cached_tipodoc(tip.get("CODTAB").as_string());
_config_ditta = new TConfig(CONFIG_DITTA);
// Metto in relazione testata e righe
_rel = new TRelation( LF_DOC );
_rel->lfile().set_curr(new TDocumento);
_msk = new TMask(query_mask_name());
set_search_field(F_NDOC);
_msk->set_handler( F_ANNO, TDocumento_mask::anno_handler );
_msk->set_handler( F_CODNUM, TDocumento_mask::num_handler );
_msk->set_handler( F_NUMDOCRIF, TDocumento_mask::numdocrif_search_handler );
_msk->set_handler( F_RAGSOCSEARCH, TDocumento_mask::ragsoc_search_handler );
const int args = argc() ;
TEdit_field & e = _msk->efield(F_CODNUM);
TBrowse * b = e.browse();
TEdit_field & edes = _msk->efield(F_DESNUM);
TBrowse * bdes = edes.browse();
TCursor * cur = b->cursor();
TCursor * descur = bdes->cursor();
cur->set_filterfunction(num_filter);
descur->set_filterfunction(num_filter);
for (int i = 2; i < args; i++)
{
const TFixed_string arg(argv(i));
if (arg.starts_with("-def"))
{
TToken_string str(arg.mid(4), ',');
//attenzione: non ridefinire le TString16 in TString4 perch<63> il nome di variabile codnum non c'entra un benemerito..
//..cazzo con codnum, ma pu<70> essere una variabile qualunque (compliemti all'astuzia nella scelta del nome)
const TString16 codnum(str.get());
const TString16 tipodoc(str.get());
const TString16 paragraph(str.get());
if (paragraph.blank())
{
_codnum = codnum;
_tipodoc = tipodoc;
}
else
{
TConfig c(CONFIG_DITTA, paragraph);
_codnum = c.get(codnum);
_tipodoc = c.get(tipodoc);
}
}
else
if (arg.starts_with("-filt"))
{
if (b != NULL || bdes != NULL)
{
TString filter = b->get_filter();
if (filter.full())
{
filter.insert("(");
filter << ")&&(" << arg.mid(5) << ")";
if (b != NULL)
b->set_filter(filter);
if (bdes != NULL)
bdes->set_filter(filter);
}
else
{
const TString newfilter(arg.mid(5));
if (b != NULL)
b->set_filter(newfilter);
if (bdes != NULL)
bdes->set_filter(newfilter);
}
}
}
}
TConfig utente(CONFIG_GUI, app().name().left(2));
if (_codnum.blank())
_codnum = utente.get("CODNUM");
if (_tipodoc.blank())
_tipodoc = utente.get("TIPODOC");
_docmsk = NULL;
load_auto_reopen_data();
return true;
}
bool TMotore_application::user_destroy( )
{
// Registro l'ultimo tipo documento e l'ultima numerazione
TConfig utente( CONFIG_GUI, app().name().left(2) );
utente.set( "CODNUM", _codnum );
utente.set( "TIPODOC", _tipodoc );
if (_config_ditta != NULL)
delete _config_ditta;
// Distruggo la maschera di modifica
if ( _msk != NULL )
delete _msk;
// Distruggo la relazione
delete _rel;
// delete _condv;
return true;
}
int TMotore_application::stato_corrente( )
{
return edit_mask().get_int(F_STATO);
}
void TMotore_application::sheet2ini(TSheet_field &sheet,TConfig& ini)
{
// scrive le righe degli sheet associati
TString16 defpar;
TString str(80);
TDocumento_mask &m = (TDocumento_mask &)sheet.mask();
int r;
for (r = 1; r <= sheet.items(); r++)
{
defpar.format("%d,%d",LF_RIGHEDOC,r);
const TMask * sm = m.riga_mask(r-1);
const TToken_string rigar = sheet.row(r-1);
for (int sf = 0; sf < sm->fields(); sf++)
{
TMask_field& campo = sm->fld(sf);
if (campo.shown() && campo.field())
{
// str = sheet.row(r-1).get(sheet.cid2index(campo.dlg()));
const short id = campo.dlg();
rigar.get(sheet.cid2index(id), str);
if (str.empty())
str = " ";
const word field_class = campo.class_id();
if (field_class == CLASS_MEMO_FIELD ||
field_class == CLASS_ZOOM_FIELD)
{
int p;
while ((p = str.find('\n', 0)) >= 0)
{
str.overwrite("\\", p);
str.insert("n", p+1);
}
}
if (campo.field()->name() == RDOC_PREZZO)
{
TCodiceIVA c(sm->get(FR_CODIVA));
TFieldref l;
real prezzo(str);
real prezzol;
l = RDOC_PREZZOL;
if (m.doc().tipo().calcolo_lordo())
{
prezzol = prezzo;
c.scorpora(prezzo);
}
else
prezzol = c.lordo(prezzo);
l.write(ini, defpar, prezzol.string());
str = prezzo.string();
}
campo.field()->write(ini, defpar, str);
}
const TRiga_documento &rdoc = m.doc()[r];
TFieldref f;
f = RDOC_DACODNUM;
f.write(ini, defpar, rdoc.get(RDOC_DACODNUM));
f = RDOC_DAANNO;
f.write(ini, defpar, rdoc.get(RDOC_DAANNO));
f = RDOC_DAPROVV;
f.write(ini, defpar, rdoc.get(RDOC_DAPROVV));
f = RDOC_DANDOC;
f.write(ini, defpar, rdoc.get(RDOC_DANDOC));
f = RDOC_DAIDRIGA;
f.write(ini, defpar, rdoc.get(RDOC_DAIDRIGA));
}
}
for ( ; ; r++)
{
defpar.format("%d,%d",LF_RIGHEDOC,r);
if (ini.set_paragraph(defpar))
ini.remove_all();
else
break;
}
}
void TMotore_application::ini2mask(TConfig& ini, TMask& msk, bool query)
{
TRelation_application::ini2mask(ini, msk, query); // Default processing
if (query)
{
// Dobbiamo riempire il tipo documento per determinare il profilo corretto!
TMask_field& campo = msk.field(F_TIPODOC);
TString16 str = campo.field()->read(ini, format("%d", LF_DOC));
if (str.empty())
{
TToken_string key;
key.add(msk.get(F_PROVV));
key.add(msk.get(F_ANNO));
key.add(msk.get(F_CODNUM));
key.add(msk.get(F_NDOC));
str = cache().get(LF_DOC, key, DOC_TIPODOC);
}
campo.set(str);
}
else
{
TDocumento & d = doc();
d.put(DOC_TIPOCF, msk.get(F_TIPOCF));
d.put(DOC_CODCF, msk.get(F_CODCF));
const TCli_for & c = d.clifor();
const TRectype & ven_rec = c.vendite();
ini.set_paragraph("33");
if (!ini.exist(DOC_CODVAL))
{
const TString4 codval = c.get(CLI_CODVAL); // Attenzione: Non usare TString& qui!
msk.set(F_CODVAL, codval, true);
msk.set(F_CODVAL1, codval, true);
if (codval.blank())
msk.reset(F_CAMBIO);
}
if (!ini.exist(DOC_CODLIN))
msk.set(F_CODLIN, c.get(CLI_CODLIN), true);
if (!ini.exist(DOC_CODPAG))
msk.set(F_CODPAG, c.get(CLI_CODPAG), true);
if (!ini.exist(DOC_CODABIA))
msk.set(F_CODABIA, c.get(CLI_CODABI), true);
if (!ini.exist(DOC_CODCABA))
msk.set(F_CODCABA, c.get(CLI_CODCAB), true);
if (!ini.exist(DOC_IBAN))
{
const TString & iban = c.get(CLI_IBAN);
msk.set(F_IBAN, iban, true);
if (iban.not_empty())
{
msk.set(F_IBAN_STATO, iban.left(2));
msk.set(F_IBAN_CHECK, iban.mid(2,2));
msk.set(F_BBAN , iban.mid(4));
msk.set(F_BBAN_CIN , iban.mid(4,1));
msk.set(F_BBAN_ABI , iban.mid(5,5));
msk.set(F_BBAN_CAB , iban.mid(10,5));
msk.set(F_BBAN_CONTO, iban.mid(15,12));
}
}
// Setta i campi che appartengono al file LF_CFVEN
if (!ini.exist(DOC_CODABIP))
msk.set(F_CODABIP, ven_rec.get(CFV_CODABIPR), true);
if (!ini.exist(DOC_CODCABP))
msk.set(F_CODCABP, ven_rec.get(CFV_CODCABPR), true);
if (!ini.exist(DOC_RAGGR))
msk.set(F_RAGGR, ven_rec.get(CFV_RAGGDOC));
if (!ini.exist(DOC_RAGGREFF))
msk.set(F_RAGGREFF, ven_rec.get(CFV_RAGGEFF));
if (!ini.exist(DOC_CODINDSP))
msk.set(F_CODINDSP, ven_rec.get(CFV_CODINDSP), true);
if (!ini.exist(DOC_CODAG))
msk.set(F_CODAG, ven_rec.get(CFV_CODAG));
if (!ini.exist(DOC_CODAGVIS))
msk.set(F_CODAGVIS, ven_rec.get(CFV_CODAG1));
if (!ini.exist(DOC_CODSPMEZZO))
msk.set(F_CODSPMEZZO, ven_rec.get(CFV_CODSPMEZZO), true);
if (!ini.exist(DOC_CODPORTO))
msk.set(F_CODPORTO, ven_rec.get(CFV_CODPORTO), true);
if (!ini.exist(DOC_CODNOTESP1))
msk.set(F_CODNOTESP1, ven_rec.get(CFV_CODNOTESP1), true);
if (!ini.exist(DOC_CODNOTESP2))
msk.set(F_CODNOTESP2, ven_rec.get(CFV_CODNOTESP2), true);
if (!ini.exist(DOC_CODNOTE))
msk.set(F_CODNOTE, ven_rec.get(CFV_CODNOTE), true);
if (!ini.exist(DOC_CODVETT1))
msk.set(F_CODVETT1, ven_rec.get(CFV_CODVETT1), true);
if (!ini.exist(DOC_CODVETT2))
msk.set(F_CODVETT2, ven_rec.get(CFV_CODVETT2), true);
if (!ini.exist(DOC_CODVETT3))
msk.set(F_CODVETT3, ven_rec.get(CFV_CODVETT3), true);
if (!ini.exist(DOC_PERCSPINC))
msk.set(F_SPESEINC, ven_rec.get(CFV_PERCSPINC));
if (!ini.exist(DOC_ADDBOLLI))
msk.set(F_ADDBOLLI, ven_rec.get(CFV_ADDBOLLI));
if (!ini.exist(DOC_CATVEN))
msk.set(F_CATVEN, ven_rec.get(CFV_CATVEN), false);
if (!ini.exist(DOC_ZONA))
msk.set(F_CODZON, ven_rec.get(CFV_CODZONA), true);
if (!ini.exist(DOC_CODLIST))
{
const TString16 codlist = ven_rec.get(CFV_CODLIST);
msk.set(F_CODLIST, codlist, true);
msk.set(F_CODLIST1, codlist, true);
}
TSheet_field& f = msk.sfield(F_SHEET);
TTipo_riga_documento tr;
// Scorre tutti i paragrafi delle righe documento
const TMaskmode oldmode= (TMaskmode)msk.mode();
msk.set_mode(MODE_MOD);
for (int i = 1; ini.set_paragraph(format("%d,%d", LF_RIGHEDOC, i)); i++)
{
if (i == 1) // Se trovo almeno una riga allora cancello tutto, poi aggiungo le righe
{
f.destroy();
doc().destroy_rows();
}
// Considera solo i tipi riga validi
const TString16 tipo(ini.get(RDOC_TIPORIGA));
if (tr.read(tipo) == NOERR)
{
// Crea una nuova riga documento
TRiga_documento& rec = doc().new_row(tipo);
// Riempie i campi della nuova riga
TAssoc_array& var = ini.list_variables();
FOR_EACH_ASSOC_STRING(var, obj, key, val)
{
if (*val == '"' || *val == '\'')
{
const int len = strlen(val);
*(char*)(val+len-1) = '\0';
val++;
}
if (xvt_str_compare_ignoring_case(key, RDOC_DESCR) == 0) // Trattamento speciale per la descrizione qui verificare
{
TString s = esc(val); s.rtrim();
int split_pos = s.find('\n');
const int descr_len = rec.length(RDOC_DESCR);
if (split_pos < 0 && s.len() > descr_len)
split_pos = descr_len;
if (split_pos > descr_len)
split_pos = descr_len;
if (split_pos > 0)
{
rec.put(RDOC_DESCR, s.left(split_pos));
rec.put(RDOC_DESCLUNGA, "X");
rec.put(RDOC_DESCEST, s.mid(split_pos));
}
else
{
rec.put(RDOC_DESCR, s);
rec.zero(RDOC_DESCLUNGA);
rec.zero(RDOC_DESCEST);
}
}
else
if (xvt_str_compare_ignoring_case(key, RDOC_NRIGA) != 0) // Ignora il numero riga ..
if (xvt_str_compare_ignoring_case(key, RDOC_TIPORIGA) != 0) // ... ed il tipo riga
rec.put(key, val);
}
// solo la insert chiama la post_insert necessaria alla disabilitazione verifichiamo
// l'autoload ??
f.insert(-1, FALSE);
// Aggiunge la riga allo sheet
const bool checked = rec.get_bool(RDOC_CHECKED);
if (checked)
{
const TString& codart = rec.get(RDOC_CODARTMAG);
if (codart.full())
{
const TRectype& art = cache().get(LF_ANAMAG, codart);
if (art.empty())
{
error_box(FR("Articolo non valido sulla riga %d: %s"), i, (const char*)codart);
rec.zero(RDOC_CODARTMAG);
}
}
}
else
{
if (!ini.exist(RDOC_DESCR))
{
const TString& codart = rec.get(RDOC_CODARTMAG);
if (codart.full())
{
const TRectype& art = cache().get(LF_ANAMAG, codart);
rec.put(RDOC_DESCR, art.get(ANAMAG_DESCR));
rec.put(RDOC_CODIVA, art.get(ANAMAG_CODIVA));
}
rec.put(RDOC_CHECKED, "X");
}
}
if (!ini.exist(RDOC_CODIVA) && !(rec.is_descrizione() || rec.is_sconto() || rec.is_sconto_perc()))
{
const TString4 codiva = ((TDocumento_mask &) msk).doc().codesiva();
if (codiva.full())
rec.put(RDOC_CODIVA, codiva);
}
rec.autoload(f);
f.check_row(f.items() - 1, 0x2);
if (!checked) //se non e' checked, il record viene autosalvato (in modo che sia salvato completamente)
rec.autosave(f);
}
}
msk.set_mode(oldmode);
}
}
bool TMotore_application::save_and_print(bool savedoc, TPrtype mode)
{
if (savedoc)
{
if (save(false))
edit_mask().update_father_rows(false);
else
return false;
}
TDocumento& doc = (TDocumento&)get_relation()->curr();
const TTipo_documento& tipo = doc.tipo();
TFilename rep;
int filter = has_module(RSAUT) ? 2 : 1;
while (filter > 0 && !tipo.main_print_profile(rep, filter))
filter--;
if (filter > 0)
{
const bool da_stampare = doc.stampabile();
TString commandline;
commandline = "ve1 -";
if (filter == 2)
commandline << 2; // Esiste il nuovo report :-)
else
commandline << 0; // Esiste il vecchio form :-(
commandline << ' ' << doc.get(DOC_CODNUM) << ' ' << doc.get(DOC_ANNO)
<< ' ' << doc.get(DOC_PROVV) << ' ' << doc.get(DOC_NDOC) << ' ';
switch (mode)
{
case exportprinter: commandline << " E"; break;
case fileprinter : commandline << " P"; break;
case screenvis : commandline << " A"; break;
default : commandline << " S"; break;
}
commandline << ' ' << (da_stampare ? 'D' : 'P');
const int ncopie = tipo.ncopie();
if (ncopie > 0)
commandline << ' ' << ncopie;
TExternal_app interattivo( commandline );
if (interattivo.run() == NOERR)
{
if (da_stampare) // Aggiorna stato documento se necessario
{
TDocumento_mask& m = edit_mask();
TDocumento& maindoc = m.doc();
maindoc.read(); // Aggiorna STATO e MOVMAG generati da ve1
// Lo stato del documento vive di vita propria
const char sfs = maindoc.tipo().stato_finale_stampa();
maindoc.stato(sfs);
const char str_sfs[2] = { sfs, '\0' };
m.set(F_STATO, str_sfs, true);
init_modify_mode(m);
}
}
}
else
{
rep.ext("");
return error_box("Il profilo %s non esiste", (const char*)rep);
}
return true;
}
void TMotore_application::print()
{
if (edit_mask().id2pos(DLG_PREVIEW) < 0)
save_and_print(true, printer().printtype());
else
save_and_print(true, winprinter);
}
void TMotore_application::mailto()
{
save_and_print(true, exportprinter);
}
void TMotore_application::preview()
{
save_and_print(true, screenvis);
}
int ve0100( int argc, char* argv[])
{
TMotore_application a;
a.run( argc, argv, TR("Gestione documenti"));
return 0;
}
Reference in New Issue View Git Blame Copy Permalink