diff --git a/pe/pe0.h b/pe/pe0.h index 644498888..2f481ff99 100755 --- a/pe/pe0.h +++ b/pe/pe0.h @@ -1,8 +1,8 @@ -#ifndef __LV3_H -#define __LV3_H +#ifndef __PE0_H +#define __PE0_H int pe0400(int argc, char* argv[]); int pe0500(int argc, char* argv[]); int pe0600(int argc, char* argv[]); -#endif // __LV3_H +#endif // __PE0_H diff --git a/pe/pe0400.cpp b/pe/pe0400.cpp index b2f50bff6..830b9a9fd 100755 --- a/pe/pe0400.cpp +++ b/pe/pe0400.cpp @@ -108,8 +108,7 @@ public: inline TGestione_preventivo_app& peapp() { return (TGestione_preventivo_app &)main_app(); }; ////////////////////////////////////////// - //// CLASSE TGestione_preventivo_MSK //// - + //// CLASSE TGestione_preventivo_MSK //// ////////////////////////////////////////// const TString & TGestione_preventivo_msk::build_tree_string(int level) diff --git a/pe/pe1.cpp b/pe/pe1.cpp new file mode 100644 index 000000000..7e7cffc7b --- /dev/null +++ b/pe/pe1.cpp @@ -0,0 +1,14 @@ +#include + +#include "pe1.h" + +int main(int argc, char** argv) +{ + const int r = (argc > 1) ? argv[1][1] - '0' : 0; + switch (r) + { + case 3: + default: pe1400(argc, argv); break; // gestione preventivi + } + return 0; +} diff --git a/pe/pe1.h b/pe/pe1.h new file mode 100644 index 000000000..8694d73e6 --- /dev/null +++ b/pe/pe1.h @@ -0,0 +1,6 @@ +#ifndef __PE1_H +#define __PE1_H + +int pe1400(int argc, char* argv[]); // gestione preventivi + +#endif diff --git a/pe/pe1400.cpp b/pe/pe1400.cpp new file mode 100644 index 000000000..d1f75517d --- /dev/null +++ b/pe/pe1400.cpp @@ -0,0 +1,1411 @@ +#include +#include +#include +#include +#include +#include +#include + +#include "../ca/calib01.h" +#include "../mg/mglib.h" +#include "../ve/velib.h" + +#include "pe1400.h" +#include "pe1401.h" + +#include "../db/rdist.h" +#include "../mg/anamag.h" + +static real ricarico2perc(const TString& exp) +{ + real val_perc = UNO; + + if (exp.full()) + { + TString80 num; + bool dec = false; // Flag che indica se si attende l'inizio di un numero + bool startnum = true; // Flag che indica se siamo all'inizio di un numero + int errorchar = ' '; + bool valid = true; + // Flag che indica se sono nella parte decimale di un numero + for (const char* s = exp; *s && errorchar == ' '; s++) + { + const char c = *s; + switch(c) + { + case '+': + case '-': + // Se ero in in numero ... + if( !startnum ) + { + // Aggiunge il numero alla sequenza + const real val = num; + val_perc *= ( CENTO + val ) / CENTO; + } + // Inizia il nuovo numero + num = (c == '-') ? "-" : "+"; + startnum = true; + dec = false; + break; + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + num << c; + startnum = false; + break; + case '.': + case ',': + if(!dec) + { + if( startnum ) + num << '0'; // Se occorreva un numero ci metto lo 0 + num << '.'; // Interpreto la virgola come punto + dec = true; + startnum = true; + } + else + errorchar = c; // Se siamo gią nella parte decimale segnala un errore + break; + case ' ': + break; + default: + errorchar = c; + break; + } + } + // Controlla la validitą + valid = errorchar == ' '; + + if (valid) + { + // Aggiunge l'ultimo numero preso + const real val = num; + val_perc *= ( CENTO + val ) / CENTO; + } + } + + return val_perc; +} + + +/////////////////////////////////////////////////////////// +// TPreventivo_nmsk +/////////////////////////////////////////////////////////// + +class TPreventivo_nmsk : public TAutomask +{ + TString4 _codnum; + +protected: + virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly); + +public: + TPreventivo_nmsk(const TString& codnum); +}; + +bool TPreventivo_nmsk::on_field_event(TOperable_field& o, TField_event e, long jolly) +{ + switch(o.dlg()) + { + case F_ANNO: + if (e == fe_modify && !o.empty()) + on_field_event(efield(F_NDOC), fe_init, 0L); + break; + case F_NDOC: + if (e == fe_init) + { + long n = 1; + TString query; + query << "USE DOC" + << "\nFROM PROVV=D ANNO=#ANNO CODNUM=#CODNUM" + << "\nTO PROVV=D ANNO=#ANNO CODNUM=#CODNUM"; + TISAM_recordset recset(query); + recset.set_var("#ANNO", get(F_ANNO)); + recset.set_var("#CODNUM", _codnum); + if (recset.move_last()) + { + const TCodice_numerazione& num = cached_numerazione(_codnum); + const int revlen = num.revision_len(); + TString8 ndoc = recset.get(DOC_NDOC).as_string(); + if (revlen > 0) ndoc.rtrim(revlen); + n += atol(ndoc); + } + o.set(n); + } else + if (e == fe_modify || e == fe_close) + { + TString8 ndoc; + const TCodice_numerazione& num = cached_numerazione(_codnum); + const int revlen = num.revision_len(); + if (revlen > 0) + ndoc.format("%d%0*d", atoi(o.get()), revlen, 1); + else + ndoc = o.get(); + + TLocalisamfile doc(LF_DOC); + doc.put(DOC_PROVV, "D"); + doc.put(DOC_ANNO, get(F_ANNO)); + doc.put(DOC_CODNUM, _codnum); + doc.put(DOC_NDOC, ndoc); + if (doc.read() == NOERR) + return error_box("Preventivo gią esistente"); + } + break; + default: + break; + } + return true; +} + +TPreventivo_nmsk::TPreventivo_nmsk(const TString& codnum) : TAutomask(TR("Nuovo preventivo"), 1, 30, 6), _codnum(codnum) +{ + const TCodice_numerazione& num = cached_numerazione(_codnum); + const int revlen = num.revision_len(); + add_number(F_NDOC, 0, PR("Codice "), 13, 1, 7-revlen).check_type(CHECK_REQUIRED); + add_number(F_ANNO, 0, PR("Anno "), 1, 1, 4, "A").check_type(CHECK_REQUIRED); + add_button(DLG_OK, 0, "", -12, -1, 9, 2); + add_button(DLG_CANCEL, 0, "", -22, -1, 9, 2); + set_handlers(); +} + +/////////////////////////////////////////////////////////// +// TPreventivo_msk +/////////////////////////////////////////////////////////// + +// Classe di base per maschere preventivi (query ed edit) +class TPreventivo_msk : public TAutomask +{ +protected: + virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly); + virtual TMask_field* TPreventivo_msk::parse_field(TScanner& s); + +public: + int revision_length() const; + int split_ndoc(long ndoc, int& nprev, int& nrev) const; + int join_ndoc(int nprev, int nrev, long& ndoc) const; + + TPreventivo_msk(const char* name) { read_mask(name, 0, 8); set_handlers(); } +}; + +TMask_field* TPreventivo_msk::parse_field(TScanner& s) +{ + if (s.key() == "TL") + { + XI_OBJ* itf = xi_get_itf((XinWindow)page_win(1)); + xi_set_app_data2(itf, 0x1); // Full screen + } + return TAutomask::parse_field(s); +} + +int TPreventivo_msk::revision_length() const +{ + int rl = 0; + const TString& codnum = get(F_CODNUM); + if (codnum.full()) + { + const TCodice_numerazione& num = cached_numerazione(codnum); + rl = num.revision_len(); + } + return rl; +} + +int TPreventivo_msk::split_ndoc(long ndoc, int& nprev, int& nrev) const +{ + nprev = nrev = 0; + const int revlen = revision_length(); + if (revlen > 0) + { + TString8 sdoc; sdoc << ndoc; + if (sdoc.len() > revlen) + { + nrev = atoi(sdoc.right(revlen)); + nprev = atoi(sdoc.rtrim(revlen)); + } + } + else + nprev = ndoc; + + return revlen; +} + +int TPreventivo_msk::join_ndoc(int nprev, int nrev, long& ndoc) const +{ + ndoc = 0L; + const int revlen = revision_length(); + if (revlen > 0) + { + ndoc = nprev; + for (int i = 0; i < revlen; i++) + ndoc *= 10; + ndoc += nrev > 0 ? nrev : 1; + } + else + ndoc = nprev; + + return revlen; +} + + +bool TPreventivo_msk::on_field_event(TOperable_field& o, TField_event e, long jolly) +{ + switch (o.dlg()) + { + case F_CODNUM: + if (e == fe_init || e == fe_modify) + { + if (o.empty()) + { + TCursor& c = *((TEdit_field&)o).browse()->cursor(); + c = 0L; + o.set(c.curr().get("CODTAB")); + o.check(); + } + + int revlen = 0; + if (!o.empty()) + { + const TCodice_numerazione& num = cached_numerazione(o.get()); + revlen = num.revision_len(); + set(F_TIPODOC, num.tipo_doc(0), 0x3); + } + if (revlen > 0) + { + RCT rct; + + TEdit_field& prv = efield(F_NPREV); + prv.set_len(7-revlen); + prv.get_rect(rct); + rct.right = rct.left + CHARX * (8-revlen); + prv.set_rect(rct); + + TEdit_field& rev = efield(F_NREV); + rev.set_len(revlen); + rev.get_rect(rct); + rct.right = rct.left + CHARX * (revlen+1); + rev.set_rect(rct); + + show(F_NREV); + } + else + hide(F_NREV); + } + break; + case F_NDOC: + if (!o.empty() && (e == fe_init || e == fe_modify)) + { + const long ndoc = atol(o.get()); + int nprev = 0, nrev = 0; + const int revlen = split_ndoc(ndoc, nprev, nrev); + set(F_NPREV, nprev); + set(F_NREV, nrev); + if (revlen == 0) + reset(F_NPREV); + } + break; + default: break; + } + return true; +} + +/////////////////////////////////////////////////////////// +// TPreventivo_qmsk +/////////////////////////////////////////////////////////// + +class TPreventivo_qmsk : public TPreventivo_msk +{ +protected: + virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly); +public: + TPreventivo_qmsk() : TPreventivo_msk("pe1400a") {} +}; + +bool TPreventivo_qmsk::on_field_event(TOperable_field& o, TField_event e, long jolly) +{ + return TPreventivo_msk::on_field_event(o, e, jolly); +} + +/////////////////////////////////////////////////////////// +// TPreventivo_emsk +/////////////////////////////////////////////////////////// + +class TPreventivo_emsk : public TPreventivo_msk +{ + TPreventivo_tree* _tree; + TString _idfase, _iddist; + int _edit_dist, _edit_dett, _edit_misu; + int _curr_dist, _curr_dett, _curr_misu; + +private: + bool on_fasi_button(TOperable_field& btn, TField_event e, long jolly); + bool on_fasi_event(TTree_field& s, TField_event e, long jolly); + bool set_fase(const TString& idf); + bool set_dist(const TString& idd); + bool set_dist(int row); + + void update_dist(const real& val, int column); + void update_dist_qta(); + void update_dist_costo(); + + bool on_dett_event(TOperable_field& o, TField_event e, long jolly); + bool on_misu_event(TOperable_field& o, TField_event e, long jolly); + bool on_dist_event(TOperable_field& o, TField_event e, long jolly); + + real get_costo(const TString& codart) const; + +protected: + virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly); + void set_sheet_color(short id, COLOR col); + bool sync_tree(); + bool msk2rec(const TMask& msk, TRectype& rec) const; + +public: + TPreventivo_tree& tree(bool reset = false); + TPreventivo_emsk(); +}; + +TPreventivo_tree& TPreventivo_emsk::tree(bool reset) +{ + if (_tree == NULL) + { + _tree = new TPreventivo_tree(tfield(F_FASI)); + reset = true; + } + if (reset) + { + TRectype doc(LF_DOC); + doc.put(DOC_PROVV, 'D'); + doc.put(DOC_ANNO, get(F_ANNO)); + doc.put(DOC_CODNUM, get(F_CODNUM)); + doc.put(DOC_NDOC, get(F_NDOC)); + _tree->append_row(doc); + TTree_field& tf = tfield(F_FASI); + tf.set_tree(_tree); + tf.hide_leaves(); + } + return *_tree; +} + +// Riempie gli sheet di articoli e misure della distinta selezionata +bool TPreventivo_emsk::set_dist(const TString& idd) +{ + TPreventivo_tree& t = tree(); + + bool ok = idd.full(); + if (_iddist != idd) + { + _iddist = idd; + + // Svuota sheet articoli + TSheet_field& a = sfield(F_ARTICOLI); + a.hide(); + a.destroy(); + + // Svuota sheet misure + TSheet_field& m = sfield(F_MISURE); + m.hide(); + m.destroy(); + + // Scandisce i figli della distinta e li smista tra i due sheet + ok = idd.full() && t.goto_node(idd); + if (ok) + { + int n = 0; + for (bool ok = t.goto_firstson(); ok; ok = t.goto_rbrother()) + { + const TRectype& rec = *t.curr_row(); + TSheet_field& s = rec.get(RDOC_TIPORIGA) == t.tipo_dett() ? a : m; + TMask& m = s.sheet_row_mask(n); + FOR_EACH_MASK_FIELD(m, i, f) + { + const TFieldref* fr = f->field(); + if (fr != NULL) + { + f->set(fr->read(rec)); + f->check(STARTING_CHECK); + } + } + s.update_row(n++); + } + } + + // Visualizza nuovamente i due sheet eventualemente riempiti + a.force_update(); a.show(); + m.force_update(); m.show(); + } + + _curr_dist = -1; + if (ok && t.goto_node(idd)) + { + _curr_dist = 0; + while(t.goto_lbrother()) + _curr_dist++; + } + + return ok; +} + +bool TPreventivo_emsk::set_dist(int row) +{ + TPreventivo_tree& t = tree(); + bool ok = _idfase.full() && t.dist(_idfase, row) != NULL; + if (ok) + { + TString16 idd; t.curr_id(idd); + ok = set_dist(idd); + CHECK(ok && row == _curr_dist, "Distinta sospetta"); + } + return ok; +} + +// Riempie lo sheet delle distinte della fase selezionata +bool TPreventivo_emsk::set_fase(const TString& idfase) +{ + _idfase = idfase; + + // Svuota lo sheet delle distinte + TSheet_field& d = sfield(F_DISTINTE); + d.destroy(); + + TString idd; + TPreventivo_tree& t = tree(); + bool ok = idfase.full() && t.goto_node(idfase); + if (ok) + { + // Scandisce le distinte della fase corrente + if (t.goto_firstson()) + { + t.curr_id(idd); // Memorizza la prima distinta per dopo... + int n = 0; + do + { + const TRectype& rec = *t.curr_row(); + TMask& m = d.sheet_row_mask(n); + FOR_EACH_MASK_FIELD(m, i, f) + { + const TFieldref* fr = f->field(); + if (fr != NULL) + { + f->set(fr->read(rec)); + f->check(STARTING_CHECK); + } + } + d.update_row(n++); + } while (t.goto_rbrother()); + } + } + d.force_update(); + set_dist(idd); + + return ok; +} + +bool TPreventivo_emsk::msk2rec(const TMask& msk, TRectype& rec) const +{ + TRelation rel(rec.num()); + rel.curr() = rec; + msk.autosave(rel); + rec = rel.curr(); + return !rec.empty(); +} + +bool TPreventivo_emsk::on_fasi_button(TOperable_field& o, TField_event e, long jolly) +{ + TPreventivo_tree& t = tree(); + TTree_field& fasi = t.owner(); + + TPreventivo_level pl = pl_documento; + if (fasi.goto_selected()) + pl = t.level(); + else + return false; + + if (pl == pl_documento && o.dlg() == F_FASENEW) + pl = pl_fase1; + + if (pl < pl_fase1 || pl > pl_distinta) + return false; + + o.disable(); + switch (o.dlg()) + { + case F_FASENEW: + { + TMask m("Nuovo", 1, 46, 7); + m.add_string(S_CODART, 0, "Codice ", 1, 1, 20).check_type(CHECK_REQUIRED); + m.add_string(S_DESCR, 0, "Descrizione ", 1, 2, 50, "", 30).check_type(CHECK_REQUIRED); + m.add_button(DLG_OK, 0, "", -12, -1, 10, 2); + m.add_button(DLG_CANCEL, 0, "", -22, -1, 10, 2); + if (m.run() == K_ENTER) + { + TRectype* rec = t.new_row(pl); + rec->put(RDOC_CODART, m.get(S_CODART)); + rec->put(RDOC_DESCR, m.get(S_DESCR)); + if (tree().level() == pl) + t.add_rbrother(rec); + else + { + t.append_row(*rec); + delete rec; + } + } + } + break; + case F_FASEDIT: + { + TRectype& rec = *t.curr_row(); + TMask m("Modifica", 1, 46, 7); + m.add_string(S_CODART, 0, "Codice ", 1, 1, 20).check_type(CHECK_REQUIRED); + m.add_string(S_DESCR, 0, "Descrizione ", 1, 2, 50, "", 30).check_type(CHECK_REQUIRED); + m.add_button(DLG_OK, 0, "", -13, -1, 10, 2); + m.add_button(DLG_DELREC, 0, "", -23, -1, 10, 2); + m.add_button(DLG_CANCEL, 0, "", -33, -1, 10, 2); + m.set(S_CODART, rec.get(RDOC_CODART)); + m.set(S_DESCR, rec.get(RDOC_DESCR)); + switch (m.run()) + { + case K_ENTER: + rec.put(RDOC_CODART, m.get(S_CODART)); + rec.put(RDOC_DESCR, m.get(S_DESCR)); + break; + case K_DEL: + t.kill_node(); + break; + default: + break; + } + } + break; + case F_FASEUP: + t.swap_left(); + if (pl == pl_distinta) + { + TString16 id; t.curr_id(id); + set_fase(_idfase); + t.goto_node(id); + } + break; + case F_FASEDN: + t.swap_right(); + if (pl == pl_distinta) + { + TString16 id; t.curr_id(id); + set_fase(_idfase); + t.goto_node(id); + } + break; + case F_FASELT: + if (pl > pl_fase1 && pl < pl_distinta && t.push_up()) + t.curr_row()->put(RPRV_LEVEL, t.curr_depth()-1); + break; + case F_FASERT: + if (pl >= pl_fase1 && pl < t.last_fase_level() && t.push_down()) + t.curr_row()->put(RPRV_LEVEL, t.curr_depth()-1); + break; + default: + break; + } + o.enable(); + fasi.select_current(); + fasi.force_update(); + return true; +} + +bool TPreventivo_emsk::on_fasi_event(TTree_field& fasi, TField_event e, long jolly) +{ + bool modified = false; + bool can_edit = false; + bool can_goup = false; + bool can_godn = false; + bool can_golt = false; + bool can_gort = false; + + switch (e) + { + case fe_modify: + if (fasi.goto_selected()) + { + modified = true; + TPreventivo_tree& t = tree(); + TPreventivo_level td = t.level(); + if (td > pl_documento) + { + can_edit = true; + can_goup = t.has_lbrother(); + can_godn = t.has_rbrother(); + if (td >= pl_fase1 && td < pl_distinta) // Cambio fase + { + can_golt = td > pl_fase1; + can_gort = td < t.last_fase_level(); + TString16 id; + t.curr_id(id); + set_fase(id); + } + else + { + while (td > pl_distinta) + { + t.goto_father(); + td = t.level(); + } + TString idd; t.curr_id(idd); + if (t.goto_father()) + { + TString idf; t.curr_id(idf); + if (idf != _idfase) + set_fase(idf); + } + set_dist(idd); + } + } + } + break; + default: + break; + } + + if (modified) + { + enable(F_FASEDIT, can_edit); + enable(F_FASEUP, can_goup); + enable(F_FASEDN, can_godn); + enable(F_FASELT, can_golt); + enable(F_FASERT, can_gort); + } + + return true; +} + +bool TPreventivo_emsk::on_dist_event(TOperable_field& o, TField_event e, long jolly) +{ + switch (o.dlg()) + { + case S_CODART: + if (e == fe_modify && !o.empty()) + { + const TString& codart = o.get(); + TRecord_array rdist(codart, LF_RDIST); + if (rdist.rows() > 0 && sfield(F_ARTICOLI).empty()) + { + TPreventivo_tree& t = tree(); + while (t.dett(_iddist, 0)) + t.kill_node(); + + const int last = rdist.last_row(); + int n = 0; + for (int r = rdist.first_row(); r > 0 && r <= last; r = rdist.succ_row(r)) + { + const TRectype& rd = rdist.row(r); + TRectype* rec = t.dett(_iddist, n++, true); + rec->put(RDOC_CODART, rd.get(RDIST_CODCOMP)); + rec->put(RDOC_DESCR, rd.get(RDIST_DESCR)); + rec->put(RDOC_UMQTA, rd.get(RDIST_UM)); + rec->put(RDOC_QTA, rd.get(RDIST_EXPR)); + } + t.goto_node(_iddist); + sync_tree(); + // Forza aggiornamento dello sheet + const TString16 id = _iddist; + _iddist.cut(0); + set_dist(id); + } + + TToken_string tok; tok << codart << "|1"; + const TString& um = cache().get(LF_UMART, tok, "UM"); + if (um.full()) + o.mask().set(103, um); + } + break; + case 105: + if (e == fe_modify && !o.empty()) + { + const TString& ric = get(F_RICARICO); + if (ric.full()) + { + const real k = ricarico2perc(ric); + const real prezzo = real(o.get()) * k; + o.mask().set(o.dlg()+1, prezzo); + } + } + break; + case F_DISTINTE: + switch (e) + { + case se_enter: + _edit_dist = -1; + set_dist(_curr_dist = jolly); + break; + case se_query_add: + return _idfase.full(); + case se_notify_add: + { + TPreventivo_tree& t = tree(); + TRectype* rec = t.dist(_idfase, _curr_dist = jolly, true); + if (rec != NULL) + sync_tree(); + } + break; + case se_query_modify: + if (jolly != _curr_dist) + set_dist(jolly); + _edit_dist = _curr_dist = jolly; + break; + case se_leave: + case se_notify_modify: + if (_edit_dist >= 0) + { + TPreventivo_tree& t = tree(); + TRectype* rec = t.dist(_idfase, _edit_dist, true); + if (rec != NULL) + { + const TMask& m = ((TSheet_field&)o).sheet_row_mask(_edit_dist); + msk2rec(m, *rec); + sync_tree(); + } + _edit_dist = -1; + } + break; + case se_notify_del: + if (_curr_dist >= 0) + { + TPreventivo_tree& t = tree(); + TRectype* rec = t.dist(_idfase, _curr_dist); + if (rec != NULL) + { + t.kill_node(); + sync_tree(); + } + } + break; + default: break; + } + break; + default: break; + } + return true; +} + +real TPreventivo_emsk::get_costo(const TString& codart) const +{ + real costo = ZERO; + const int tc = get_int(F_TIPOCOSTO); + const TArticolo_giacenza& art = cached_article_balances(codart); + TEsercizi_contabili esc; + const int annoes = esc.date2esc(get_date(F_DATADOC)); + switch (tc) + { + case 1 : costo = art.ultimo_costo(annoes); break; + case 2 : costo = art.media_costi(annoes); break; + case 4 : costo = art.costo_standard(annoes); break; + case 5 : costo = art.costo_medio(annoes, "", ""); break; + case 6 : costo = art.costo_mediopond(annoes, "", ""); break; + default: break; + } + if (costo.is_zero()) + costo = art.get_real(ANAMAG_COSTSTD); + return costo; +} + +bool TPreventivo_emsk::on_dett_event(TOperable_field& o, TField_event e, long jolly) +{ + switch (o.dlg()) + { + case S_CODART: + if (e == fe_modify && !o.empty()) + { + const TString& codart = o.get(); + const TArticolo_giacenza& art = cached_article_balances(codart); + const real costo = get_costo(o.get()); + o.mask().set(105, costo, 0x3); + o.mask().set(104, art.first_um()); + } + break; + case F_ARTICOLI: + switch (e) + { + case se_query_add: + return _iddist.full(); + case se_notify_add: + { + TPreventivo_tree& t = tree(); + TRectype* rec = t.dett(_iddist, _curr_dett = jolly, true); + if (rec != NULL) + sync_tree(); + } + break; + case se_enter: + _edit_dett = -1; + _curr_dett = jolly; + break; + case se_query_modify: + _edit_dett = _curr_dett = jolly; + break; + case se_leave: + case se_notify_modify: + if (_edit_dett >= 0) + { + TPreventivo_tree& t = tree(); + TRectype* rec = t.dett(_iddist, _edit_dett, true); + if (rec != NULL) + { + const TMask& m = ((TSheet_field&)o).sheet_row_mask(_edit_dett); + msk2rec(m, *rec); + sync_tree(); + update_dist_costo(); + } + _edit_dett = -1; + } + break; + case se_notify_del: + if (_curr_dett >= 0) + { + TPreventivo_tree& t = tree(); + TRectype* rec = t.dett(_iddist, _curr_dett); + if (rec != NULL) + { + t.kill_node(); + update_dist_costo(); + sync_tree(); + } + } + break; + default: break; + } + break; + default: + break; + } + return true; +} + +bool TPreventivo_emsk::on_misu_event(TOperable_field& o, TField_event e, long jolly) +{ + switch (o.dlg()) + { + case 102: + case 103: + case 104: + case 105: + if (e == fe_modify && _curr_misu >= 0 && _curr_dist >= 0) + { + TSheet_field& misure = *o.mask().get_sheet(); + TEdit_field& tot = o.mask().efield(106); + tot.validate(K_TAB); + misure.row(_curr_misu).add(tot.get(), 5); + update_dist_qta(); + } + break; + case F_MISURE: + switch (e) + { + case se_query_add: + return _iddist.full() && !sfield(F_ARTICOLI).empty(); + case se_notify_add: + tree().misu(_iddist, _edit_misu = jolly, true); + break; + case se_enter: + _edit_misu = -1; + _curr_misu = jolly; + break; + case se_query_modify: + _edit_misu = _curr_misu = jolly; + break; + case se_leave: + case se_notify_modify: + if (_iddist.full() && _edit_misu >= 0) + { + TPreventivo_tree& t = tree(); + TRectype* rec = t.misu(_iddist, _edit_misu, true); + if (rec != NULL) + { + TSheet_field& sheet = ((TSheet_field&)o); + const TMask& m = sheet.sheet_row_mask(_edit_misu); + msk2rec(m, *rec); + update_dist_qta(); + } + _edit_misu = -1; + } + break; + case se_notify_del: + if (_curr_misu >= 0) + { + TPreventivo_tree& t = tree(); + TRectype* rec = t.misu(_iddist, _curr_misu); + if (rec != NULL) + { + t.kill_node(); + update_dist_qta(); + } + } + break; + default: break; + } + default: + break; + } + return true; +} + +void TPreventivo_emsk::update_dist(const real& val, int column) +{ + TSheet_field& dist = sfield(F_DISTINTE); + dist.row(_curr_dist).add(val.string(), column); + dist.update_mask(_curr_dist); + TOperable_field& o = dist.sheet_row_mask(_curr_dist).efield(105); + on_dist_event(o, fe_modify, 1); + dist.force_update(_curr_dist); + TRectype* rec = tree().dist(_idfase, _curr_dist); + if (rec) + msk2rec(dist.sheet_row_mask(_curr_dist), *rec); +} + +void TPreventivo_emsk::update_dist_costo() +{ + if (_curr_dist >= 0) + { + TSheet_field& sheet = sfield(F_ARTICOLI); + real costo; + FOR_EACH_SHEET_ROW(sheet, i, row) + { + const real q = row->get(3); + const real c = row->get(); + costo += q*c; + } + update_dist(costo, 4); + } +} + +void TPreventivo_emsk::update_dist_qta() +{ + if (_curr_dist >= 0) + { + TSheet_field& sheet = sfield(F_MISURE); + real tot; + FOR_EACH_SHEET_ROW(sheet, i, row) + tot += real(row->get(5)); + update_dist(tot, 3); + } +} + +bool TPreventivo_emsk::sync_tree() +{ + TPreventivo_tree& t = tree(); + TTree_field& tf = t.owner(); + tf.force_update(); + return true; +} + +static bool ricarica(TTree& tree, void* jolly, word) +{ + const TPreventivo_tree& t = (const TPreventivo_tree&)tree; + if (t.level() == pl_distinta) + { + TRectype* rec = t.curr_row(); + const real cos = rec->get(RPRV_COSTO); + const real k = *(real*)jolly; + rec->put(RDOC_PREZZO, cos * k); + } + return false; +} + +bool TPreventivo_emsk::on_field_event(TOperable_field& o, TField_event e, long jolly) +{ + switch (o.dlg()) + { + case F_STATO: + if ((e == fe_init || e == fe_close) && o.empty()) + o.set("1"); + break; + case F_FASI: + return on_fasi_event((TTree_field&)o, e, jolly); + case F_FASENEW: + case F_FASEDIT: + case F_FASEDEL: + case F_FASEUP: + case F_FASEDN: + case F_FASERT: + case F_FASELT: + if (e == fe_button) + return on_fasi_button(o, e, jolly); + break; + case F_DISTINTE: + return on_dist_event(o, e, jolly); + case F_ARTICOLI: + return on_dett_event(o, e, jolly); + case F_MISURE: + return on_misu_event(o, e, jolly); + case DLG_COPY: + if (e == fe_button && edit_mode()) + { + TPreventivo_nmsk m(get(F_CODNUM)); + if (m.run() == K_ENTER) + { + const int nprev = m.get_int(F_NDOC); + const int nrev = 1; + long ndoc = 0; join_ndoc(nprev, nrev, ndoc); + set(F_NPREV, nprev); + set(F_NREV, nrev); + set(F_NDOC, ndoc); + set(F_STATO, 1); + set(F_DATADOC, TDate(TODAY)); + set_mode(MODE_INS); + stop_run(K_SAVE); + } + return true; + } + break; + case DLG_PRINT: + if (e == fe_button) + main_app().print(); + break; + case DLG_PREVIEW: + if (e == fe_button) + main_app().preview(); + break; + case DLG_ELABORA: + if (e == fe_button) + { + // const TString& cod = trova_elaborazione(); + } + break; + case F_RICARICO: + if (e == fe_modify && !o.empty()) + { + TPreventivo_tree& t = tree(); + if (t.goto_root() && yesno_box(TR("Si desidera applicare il nuovo ricarico a tutte fasi?"))) + { + const real perc = ricarico2perc(o.get()); + t.scan_depth_first(ricarica, (void*)&perc); + sync_tree(); + set_fase(""); + } + } + break; + default: + if (jolly > 0 && o.dlg() >= 101 && o.dlg() < 200) // Sheet mask events + { + if (e == fe_modify) + { + switch (jolly) + { + case 1: return on_dist_event(o, e, jolly); + case 2: return on_dett_event(o, e, jolly); + case 3: return on_misu_event(o, e, jolly); + default: CHECK(false, "Unknown sheet field event"); break; + } + } + } + break; + } + return TPreventivo_msk::on_field_event(o, e, jolly); +} + +void TPreventivo_emsk::set_sheet_color(short id, COLOR col) +{ + const COLOR rgb = blend_colors(NORMAL_BACK_COLOR, col, 0.75); + TSheet_field& s = sfield(id); + s.set_back_and_fore_color(rgb, NORMAL_COLOR, -1); +} + +TPreventivo_emsk::TPreventivo_emsk() : TPreventivo_msk("pe1400b"), _tree(NULL) +{ + TMask_field& cdc0 = field(F_CDC0); + RCT rct0; cdc0.get_rect(rct0); + const int yca = rct0.top / ROWY + 1; // Riga del primo campo di analitica + short idcdc, idcms, idfase, idconto; + ca_create_fields_ext(*this, 0, 2, yca, F_CDC0+1, idcdc, idcms, idfase, idconto, + DOC_CODCOSTO, DOC_CODCMS, DOC_FASCMS); + + set_sheet_color(F_DISTINTE, COLOR_YELLOW); + set_sheet_color(F_ARTICOLI, COLOR_GREEN); + set_sheet_color(F_MISURE, COLOR_GRAY); +} + + +/////////////////////////////////////////////////////////// +// TPreventivo_app +/////////////////////////////////////////////////////////// + +class TPreventivo_app : public TRelation_application +{ + TMask* _qmsk; + TMask* _emsk; + TRelation* _rel; + bool _revisioning; + +protected: + int save_rows(const TMask& m, bool re); + virtual const char* extra_modules() const { return "ci"; } + bool save_and_print(TPrtype mode); + +public: + virtual bool user_create(); + virtual bool user_destroy(); + virtual bool changing_mask(int mode) { return !(_revisioning && mode == MODE_INS); } + virtual TMask* get_mask(int mode) { return mode == MODE_QUERY ? _qmsk : _emsk; } + virtual TRelation* get_relation() const { return _rel; } + virtual bool get_next_key(TToken_string& key); + virtual bool has_filtered_cursor() const { return true; } + virtual TCursor& get_filtered_cursor() const; + + virtual void init_insert_mode(TMask& m); + virtual void init_modify_mode(TMask& m); + + virtual int read(TMask& m); + virtual int write(const TMask& m); + virtual int rewrite(const TMask& m); + virtual bool remove(); + + virtual void print(); + virtual void preview(); +}; + +bool TPreventivo_app::user_create() +{ + _rel = new TRelation(LF_DOC); + _qmsk = new TPreventivo_qmsk; + _emsk = new TPreventivo_emsk; + return true; +} + +bool TPreventivo_app::user_destroy() +{ + delete _emsk; + delete _qmsk; + delete _rel; + return true; +} + +TCursor& TPreventivo_app::get_filtered_cursor() const +{ + TEdit_field& f = _qmsk->efield(F_NDOC); + TCursor& cur = *f.browse()->cursor(); + if (cur.items() == 0) // A volte deve scantarsi ... + f.check(); // ... forzo ricalcolo elementi + return cur; +} + +bool TPreventivo_app::get_next_key(TToken_string& key) +{ + TPreventivo_msk& m = (TPreventivo_msk&)curr_mask(); + + const TEdit_field& codnum = m.efield(F_CODNUM); + if (codnum.empty()) + return codnum.error_box(TR("Inserire un codice numerazione")); + + const int revlen = m.revision_length(); + + long ndoc = 0; + int nprev = 0, nrev = 0; + + if (m.query_mode() || revlen == 0) + { + TCursor& cur = get_filtered_cursor(); + const TRecnotype i = cur.items(); + if (i > 0) + { + cur = i-1; + ndoc = cur.curr().get_long(DOC_NDOC); + m.split_ndoc(ndoc, nprev, nrev); + } + nprev++; + nrev = 1; + m.join_ndoc(nprev, nrev, ndoc); + } + else + { + // Trucchi per evitare l'azzeramento della maschera + _revisioning = true; + m.set_mode(MODE_QUERY); + + ndoc = m.get_long(F_NDOC); + m.split_ndoc(ndoc, nprev, nrev); + nrev++; + m.join_ndoc(nprev, nrev, ndoc); + m.set(F_NDOC, ndoc, 0x3); + } + key.format("%d|%ld", F_NDOC, ndoc); + return true; +} + +int TPreventivo_app::read(TMask& m) +{ + int err = TRelation_application::read(m); + if (err == NOERR) + { + const TRectype& doc = get_relation()->curr(); + TToken_string keytok; + keytok.add(doc.get(DOC_CODNUM)); + keytok.add(doc.get(DOC_ANNO)); + keytok.add(doc.get(DOC_PROVV)); + keytok.add(doc.get(DOC_NDOC)); + TRecord_array rdoc(keytok, LF_RIGHEDOC); + + TPreventivo_tree& t = ((TPreventivo_emsk&)m).tree(); + t.append_row(doc); + const int last_row = rdoc.last_row(); + for (int r = rdoc.first_row(); r > 0 && r <= last_row; r = rdoc.succ_row(r)) + t.append_row(rdoc[r]); + + t.shrink_all(); + t.goto_root(); + t.expand(); + t.owner().force_update(); + } + return err; +} + +static bool tree_save_row(TTree& tree, void* jolly, word /*flags*/) +{ + TPreventivo_tree& t = (TPreventivo_tree&)tree; + const TRectype* rec = t.curr_row(); + if (rec && !rec->empty() && rec->num() == LF_RIGHEDOC) + { + const TString& descr = rec->get(RDOC_DESCR); + const real costo = rec->get(RPRV_COSTO); + const real price = rec->get(RDOC_PREZZO); + if (descr.full() || !costo.is_zero() || !price.is_zero()) + { + TRecord_array& righe = *(TRecord_array*)jolly; + TRectype& row = righe.row(-1, true); + row.put(RDOC_IDRIGA, row.get(RDOC_NRIGA)); + row.put(RDOC_TIPORIGA, rec->get(RDOC_TIPORIGA)); + row.put(RDOC_QTA, rec->get(RDOC_QTA)); + row.put(RDOC_DESCR, rec->get(RDOC_DESCR)); + row.put(RDOC_CODART, rec->get(RDOC_CODART)); + row.put(RDOC_UMQTA, rec->get(RDOC_UMQTA)); + row.put(RDOC_QTAGG1, rec->get(RDOC_QTAGG1)); + row.put(RDOC_QTAGG2, rec->get(RDOC_QTAGG2)); + row.put(RDOC_QTAGG3, rec->get(RDOC_QTAGG3)); + row.put(RDOC_QTAGG4, rec->get(RDOC_QTAGG4)); + row.put(RDOC_QTAGG5, rec->get(RDOC_QTAGG5)); + row.put(RDOC_PREZZO, rec->get(RDOC_PREZZO)); + + // Make sure of coherent level on final record + const TPreventivo_level pl = t.level(*rec); + if (pl > pl_fase1 && pl < pl_distinta) + row.put(RPRV_LEVEL, t.curr_depth()-1); + else + row.zero(RPRV_LEVEL); + } + } + return false; // Don't stop scan +} + +int TPreventivo_app::save_rows(const TMask& m, bool re) +{ + TPreventivo_tree& tree = ((TPreventivo_emsk&)m).tree(); + TRectype* rkey = tree.new_row(pl_fase1); + TRecord_array rdoc(LF_RIGHEDOC, RDOC_NRIGA); + rdoc.set_key(rkey); + if (tree.goto_root() && tree.goto_firstson()) + tree.scan_depth_first(tree_save_row, &rdoc); + return rdoc.write(re); +} + +int TPreventivo_app::write(const TMask& m) +{ + int err = TRelation_application::write(m); + if (err == NOERR) + err = save_rows(m, false); + return err; +} + +int TPreventivo_app::rewrite(const TMask& m) +{ + int err = TRelation_application::rewrite(m); + if (err == NOERR) + err = save_rows(m, true); + return err; +} + +bool TPreventivo_app::remove() +{ + bool done = TRelation_application::remove(); + if (done) + { + const TRectype& rec = get_relation()->curr(); + TToken_string keytok; + keytok.add(rec.get(DOC_CODNUM)); + keytok.add(rec.get(DOC_ANNO)); + keytok.add(rec.get(DOC_PROVV)); + keytok.add(rec.get(DOC_NDOC)); + TRecord_array rdoc(keytok, LF_RIGHEDOC); + rdoc.remove(); + } + return done; +} + +void TPreventivo_app::init_insert_mode(TMask& m) +{ + _revisioning = false; + TRelation_application::init_insert_mode(m); + m.set(F_DATADOC, TDate(TODAY)); + m.disable(DLG_COPY); + m.disable(DLG_NEWREC); + m.disable(DLG_ELABORA); +} + +void TPreventivo_app::init_modify_mode(TMask& m) +{ + _revisioning = false; + TRelation_application::init_modify_mode(m); + m.enable(DLG_COPY); + m.enable(DLG_NEWREC); + const TRectype& doc = get_relation()->curr(); + m.enable(DLG_ELABORA, trova_elaborazione(doc).full()); +} + +bool TPreventivo_app::save_and_print(TPrtype mode) +{ + static bool already_printing = false; + if (already_printing) + return false; + already_printing = true; + + if (rewrite(*_emsk) != NOERR) + return already_printing = false; + + TString commandline; + commandline << "ve1 -2" << ' ' << _emsk->get(F_CODNUM) << ' ' + << _emsk->get(F_ANNO) << " D " << _emsk->get(F_NDOC); + switch (mode) + { + case exportprinter: commandline << " E"; break; + case fileprinter : commandline << " P"; break; + case screenvis : commandline << " A"; break; + default : commandline << " S"; break; + } + commandline << " P"; + + TExternal_app interattivo( commandline ); + if (interattivo.run() == NOERR) + { + } + already_printing = false; + return true; +} + +void TPreventivo_app::print() +{ + save_and_print(winprinter); +} + +void TPreventivo_app::preview() +{ + save_and_print(screenvis); +} + +int pe1400(int argc, char* argv[]) +{ + TPreventivo_app a; + a.run(argc, argv, TR("Preventivi")); + return 0; +} + diff --git a/pe/pe1400.h b/pe/pe1400.h new file mode 100644 index 000000000..1fa6f424a --- /dev/null +++ b/pe/pe1400.h @@ -0,0 +1,50 @@ +#define F_PROVV 201 +#define F_ANNO 202 +#define F_CODNUM 203 +#define F_DESNUM 204 +#define F_TIPODOC 205 +#define F_DESTIPO 206 +#define F_NPREV 207 +#define F_NREV 208 +#define F_NDOC 209 +#define F_STATO 210 +#define F_DATADOC 211 + +#define F_CLIFO 220 +#define F_RAGSOC 221 +#define F_RICALT 222 +#define F_STATOPAIV 223 +#define F_PAIV 224 +#define F_COFI 225 +#define F_NOTE 226 +#define F_CODPAG 227 +#define F_DESPAG 228 +#define F_CODLIS 229 +#define F_DESLIS 230 +#define F_RICARICO 234 +#define F_TIPOCOSTO 235 +#define F_NUMDOCRIF 236 +#define F_DATADOCRIF 237 +#define F_OGGETTI 238 + +#define F_FASENEW 240 +#define F_FASEDIT 241 +#define F_FASEDEL 242 +#define F_FASEUP 244 +#define F_FASEDN 245 +#define F_FASELT 246 +#define F_FASERT 247 +#define F_FASEMAX 248 + +#define F_CDC0 250 + +#define F_FASI 400 +#define F_DISTINTE 401 +#define F_ARTICOLI 402 +#define F_MISURE 403 + +#define S_CODART 101 +#define S_DESCR 102 + +#define RPRV_COSTO "QTAGG5" +#define RPRV_LEVEL "PRIORITY" diff --git a/pe/pe1400.rep b/pe/pe1400.rep new file mode 100644 index 000000000..e6e2173a4 --- /dev/null +++ b/pe/pe1400.rep @@ -0,0 +1,570 @@ + + + preventivo standard + +
+ + + MESSAGE _PAGENO + + + + 33.DATADOC + + + + 33.NDOC + + + MESSAGE _CLIENTE,COFI + + + IF(33.CODVAL='','EURO',33.CODVAL) + + + 33.CODCF + + + MESSAGE _CLIENTE,PAIV + + + 201@.S0 + + + 208@.S0 + + + 208@.S0 + + + 71 + 204@.S0 + + + + MESSAGE _CLIENTE,!RAGSOC + + + MESSAGE _CLIENTE,!INDNUM + + + MESSAGE _CLIENTE,LOCALITACF + + + MESSAGE _CLIENTE,!CAP + + + + + + + MESSAGE _TABLEREAD,%STA,#27,S0 + + + + 210@.S0 + + + MESSAGE _CLIENTE,STATOPAIV + + + 212@.S0 + + + 210@.S0 + + + 211@.S0 + + + 70 + 213@.S3 + + + + 70 + + + 71 + 33.CODCABA + + + 71 + 33.CODABIA + + + 33.CODCMS + + + 71 + 33.IBAN[16,]+' CIN:'+33.IBAN[5,5] + + + + 71 + + + + 71 + + + + 71 + + + + + 70 + MESSAGE TABLEREAD,%BAN,#119,S0 + +
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 33.IVAXCASSA + +
  • +
  • + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    • +
    + 34.TIPORIGA='01' + + + MESSAGE _DESCRIGA + + + 34.UMQTA + MESSAGE _ALIGN,#52,BOTTOM + + + 30 + 34.QTA + MESSAGE _ALIGN,#52,BOTTOM + + + 29 + 34.PREZZO + MESSAGE _ALIGN,#52,BOTTOM + + + 29 + 34.IMPNS + MESSAGE _ALIGN,#52,BOTTOM + + + 34.CODIVA + MESSAGE _ALIGN,#52,BOTTOM + + + + +
    +
    + 34.TIPORIGA='05' + + 34.CODART + MON +1 +"34.PRIORITY" @ ++ +2 * +0 +#THIS_FIELD SET_POS + + + MESSAGE _DESCRIGA + +
    +
    +
    + + + + #DOC.LIQDIFF @ +EMPTY= +NEGATE +#CLI.ALLEG @ +7 +C; +AND +IF +"IVA a esigibilit&#E0; differita ai sensi dell'art. 6 comma 5, del dpr n.633F;2973 e dell' art.7 legge 2F;2009" +#THIS ! +THEN + + + + #DOC.LIQDIFF @ +EMPTY= +NEGATE +#CLI.ALLEG @ +7 +C; +AND +IF +"IVA a esigibilit&#E0; differita ai sensi dell'art. 6 comma 5, del dpr n.633F;2973 e dell' art.7 legge 2F;2009" +#THIS ! +THEN + + + 31 + TOTMER + + + 33.SCONTOPERC + + + + 31 + SPESTRA + + + 31 + SPESIMB + + + 31 + 33.IMPPAGATO + + + MESSAGE _RIEPILOGOIVA,1,COD,0 + + + 31 + MESSAGE _RIEPILOGOIVA,1,IMP,0 + + + MESSAGE _RIEPILOGOIVA,1,ALI,0 + + + 31 + MESSAGE _RIEPILOGOIVA,1,IVA,1 + + + MESSAGE _RIEPILOGOIVA,1,COD,0 + + + 31 + MESSAGE _RIEPILOGOIVA,1,IMP,0 + + + MESSAGE _RIEPILOGOIVA,1,ALI,0 + + + 31 + MESSAGE _RIEPILOGOIVA,1,IVA,1 + + + MESSAGE _RIEPILOGOIVA,1,COD,0 + + + 31 + MESSAGE _RIEPILOGOIVA,1,IMP,0 + + + MESSAGE _RIEPILOGOIVA,1,ALI,0 + + + 31 + MESSAGE _RIEPILOGOIVA,1,IVA,1 + + + 31 + MESSAGE _RIEPILOGOIVA,30,IMP,0 + + + MESSAGE _RIEPILOGOIVA,30,COD,0 + + + MESSAGE _RIEPILOGOIVA,30,DES,1 + + + 31 + MESSAGE _RIEPILOGOIVA,30,IMP,0 + + + MESSAGE _RIEPILOGOIVA,30,COD,0 + + + MESSAGE _RIEPILOGOIVA,30,DES,1 + + + 31 + IMPONIBILI + + + 31 + IMPOSTE + + + + + + + 31 + TOTDOC + + + 31 + 33.IMPPAGATO + MESSAGE SUB,138 + + + 31 + + + MESSAGE _SCADENZE,DATA,0 + + + 31 + MESSAGE _SCADENZE,IMPORTO,1 + + + MESSAGE _SCADENZE,DATA,0 + + + 31 + MESSAGE _SCADENZE,IMPORTO,1 + + + MESSAGE _SCADENZE,DATA,0 + + + 31 + MESSAGE _SCADENZE,IMPORTO,1 + + + MESSAGE _SCADENZE,DATA,0 + + + 31 + MESSAGE _SCADENZE,IMPORTO,1 + + + MESSAGE _SCADENZE,DATA,0 + + + 31 + MESSAGE _SCADENZE,IMPORTO,1 + +
    + USE 33 +JOIN 34 INTO CODNUM==CODNUM ANNO==ANNO PROVV==PROVV NDOC==NDOC +JOIN 17 TO 33 INTO TIPOCF==TIPOCF CODCF==CODCF +JOIN 20 TO 33 INTO TIPOCF==TIPOCF CODCF==CODCF +JOIN 16 TO 33 INTO TIPOCF==TIPOCF CODCF==CODCF CODIND==CODINDSP +JOIN 16 TO 17 ALIAS 116 INTO TIPOCF==TIPOCF CODCF==CODCF CODIND==CODINDSP +JOIN 47 TO 34 INTO CODART==CODART +JOIN %CPG TO 33 ALIAS 201 INTO CODTAB==CODPAG +JOIN 122 TO 33 INTO CODAGE==CODAG +JOIN %POR TO 33 ALIAS 203 INTO CODTAB==CODPORTO +JOIN %BAN TO 33 ALIAS 204 INTO CODTAB==CODABIA+CODCABA +JOIN %VET TO 33 ALIAS 205 INTO CODTAB==CODVETT1 +JOIN %ASP TO 33 ALIAS 206 INTO CODTAB==ASPBENI1 +JOIN %CTR TO 33 ALIAS 207 INTO CODTAB==CAUSTRASP +JOIN %BAN TO 33 ALIAS 208 INTO CODTAB==CODABIA +JOIN %VAL TO 33 ALIAS 209 INTO CODTAB==CODVAL +JOIN %TIP TO 33 ALIAS 210 INTO CODTAB==TIPODOC +JOIN %MSP TO 33 ALIAS 211 INTO CODTAB==CODSPMEZZO +JOIN CMS TO 33 ALIAS 212 INTO CODTAB==CODCMS +JOIN BNP TO 33 ALIAS 213 INTO CODTAB==CODABIP+CODCABP+PROGBNP + \ No newline at end of file diff --git a/pe/pe1400a.uml b/pe/pe1400a.uml new file mode 100644 index 000000000..8772f4568 --- /dev/null +++ b/pe/pe1400a.uml @@ -0,0 +1,143 @@ +#include "pe1400.h" + +TOOLBAR "topbar" 0 0 0 2 +#include +ENDPAGE + +PAGE "Preventivi" 0 0 0 0 + +GROUPBOX DLG_NULL 78 6 +BEGIN + PROMPT 1 0 "@bPreventivo" +END + +LIST F_PROVV 1 12 +BEGIN + PROMPT 69 69 "" + ITEM "D|Definitivi" + ITEM "P|Provvisori" + FIELD PROVV + FLAGS "D" + KEY 1 +END + +NUMBER F_ANNO 4 +BEGIN + PROMPT 2 1 "Anno " + FLAGS "AU" + CHECKTYPE REQUIRED + KEY 1 + FIELD ANNO +END + +STRING F_CODNUM 4 +BEGIN + PROMPT 2 2 "Numerazione " + USE %NUM SELECT I0>0 + FLAGS "UP" + INPUT CODTAB F_CODNUM + DISPLAY "Codice" CODTAB + DISPLAY "Descrizione@50" S0 + OUTPUT F_CODNUM CODTAB + OUTPUT F_DESNUM S0 + CHECKTYPE REQUIRED + FIELD CODNUM + KEY 1 +END + +STRING F_DESNUM 50 +BEGIN + PROMPT 24 2 "" + USE %NUM KEY 2 SELECT I0>0 + INPUT S0 F_DESNUM + DISPLAY "Descrizione@50" S0 + DISPLAY "Codice Num." CODTAB + COPY OUTPUT F_CODNUM + CHECKTYPE REQUIRED +END + +STRING F_TIPODOC 4 +BEGIN + PROMPT 2 3 "Tipo " + FLAGS "DG" + FIELD TIPODOC + USE %TIP + INPUT CODTAB F_TIPODOC + OUTPUT F_DESTIPO S0 + CHEKCTYPE NORMAL +END + +STRING F_DESTIPO 50 +BEGIN + PROMPT 24 3 "" + FLAGS "D" +END + +NUMBER F_NDOC 7 +BEGIN + PROMPT 2 4 "Numero " + USE LF_DOC + JOIN LF_CLIFO INTO TIPOCF=TIPOCF CODCF==CODCF + INPUT PROVV "D" + INPUT ANNO F_ANNO SELECT + INPUT CODNUM F_CODNUM SELECT + INPUT NDOC F_NDOC + DISPLAY "Anno" ANNO + DISPLAY "Numerazione" CODNUM + DISPLAY "Numero" NDOC + DISPLAY "Stato" STATO + DISPLAY "Cliente" CODCF + DISPLAY "Ragione Sociale@50" LF_CLIFO->RAGSOC + OUTPUT F_NDOC NDOC + CHECKTYPE REQUIRED + FIELD NDOC + KEY 1 +END + +NUMBER F_NPREV 7 +BEGIN + PROMPT 42 4 "Preventivo " + FLAGS "D" +END + +NUMBER F_NREV 3 +BEGIN + PROMPT 61 4 "Revisione " + FLAGS "DZ" +END + +NUMBER F_CLIFO 6 +BEGIN + PROMPT 2 6 "Cliente " + USE LF_DOC KEY 4 SELECT (CODNUM=#F_CODNUM)&&(BETWEEN(ANNO,#F_ANNO,#F_ANNO)) + JOIN LF_CLIFO INTO TIPOCF=TIPOCF CODCF==CODCF + INPUT TIPOCF "C" + INPUT CODCF F_CLIFO + INPUT ANNO F_ANNO + DISPLAY "Cliente" CODCF + DISPLAY "Ragione Sociale@50" LF_CLIFO->RAGSOC + DISPLAY "Anno" LF_DOC->ANNO + DISPLAY "Numerazione" LF_DOC->CODNUM + DISPLAY "Numero" LF_DOC->NDOC + DISPLAY "Stato" LF_DOC->STATO + OUTPUT F_CLIFO LF_CLIFO->CODCF + OUTPUT F_RAGSOC LF_CLIFO->RAGSOC + OUTPUT F_NDOC LF_DOC->NDOC + CHECKTYPE NORMAL +END + +STRING F_RAGSOC 50 +BEGIN + PROMPT 24 6 "" + USE LF_CLIFO KEY 2 SELECT (LF_DOC->NDOC!="")&&(LF_DOC->CODNUM=#F_CODNUM) + JOIN LF_DOC KEY 4 INTO TIPOCF=TIPOCF CODCF==CODCF PROVV=#F_PROVV ANNO=#F_ANNO CODNUM=#F_CODNUM + INPUT TIPOCF "C" + INPUT RAGSOC F_RAGSOC + COPY DISPLAY F_CLIFO + COPY OUTPUT F_CLIFO + CHECKTYPE NORMAL +END + +ENDPAGE + +ENDMASK diff --git a/pe/pe1400b.uml b/pe/pe1400b.uml new file mode 100644 index 000000000..1e269d7b0 --- /dev/null +++ b/pe/pe1400b.uml @@ -0,0 +1,709 @@ +#include "pe1400.h" + +TOOLBAR "topbar" 0 0 0 2 + +BUTTON DLG_NEWREC 2 2 +BEGIN + PROMPT 1 1 "~Nuovo" + MESSAGE EXIT,K_INS + PICTURE TOOL_NEWREC +END + +BUTTON DLG_COPY 2 2 +BEGIN + PROMPT 1 1 "Duplica" + PICTURE TOOL_COPY +END + +BUTTON DLG_SAVEREC 2 2 +BEGIN + PROMPT 2 1 "~Registra" + MESSAGE EXIT,K_SAVE + PICTURE TOOL_SAVEREC +END + +BUTTON DLG_DELREC 2 2 +BEGIN + PROMPT 3 1 "~Elimina" + MESSAGE EXIT,K_DEL + PICTURE TOOL_DELREC +END + +BUTTON DLG_NULL 2 2 +BEGIN + PROMPT -1 1 "" + PICTURE 0 +END + +BUTTON DLG_ELABORA 2 2 +BEGIN + PROMPT 1 2 "Elabora" + PICTURE TOOL_ELABORA +END + +BUTTON DLG_PRINT 2 2 +BEGIN + PROMPT 1 3 "Stampa" + PICTURE TOOL_PRINT +END + +BUTTON DLG_PREVIEW 2 2 +BEGIN + PROMPT 1 3 "Antepr." + PICTURE TOOL_PREVIEW +END + +BUTTON DLG_NULL 2 2 +BEGIN + PROMPT -1 1 "" + PICTURE 0 +END + +#include +#include + +ENDPAGE + +PAGE "Preventivi" 0 0 0 0 + +GROUPBOX DLG_NULL 78 6 +BEGIN + PROMPT 1 0 "@bPreventivo" +END + +LIST F_PROVV 1 12 +BEGIN + PROMPT 69 69 "" + ITEM "D|Definitivi" + ITEM "P|Provvisori" + FIELD PROVV + FLAGS "D" + KEY 1 +END + +NUMBER F_ANNO 4 +BEGIN + PROMPT 2 1 "Anno " + FLAGS "D" + CHECKTYPE REQUIRED + FIELD ANNO + KEY 1 +END + +STRING F_CODNUM 4 +BEGIN + PROMPT 2 2 "Numerazione " + USE %NUM + FLAGS "DGU" + INPUT CODTAB F_CODNUM + OUTPUT F_DESNUM S0 + CHECKTYPE REQUIRED + FIELD CODNUM + KEY 1 +END + +STRING F_DESNUM 50 +BEGIN + PROMPT 24 2 "" + FLAGS "D" +END + +NUMBER F_NDOC 7 +BEGIN + PROMPT 24 1 "Numero documento " + FLAGS "DG" + CHECKTYPE REQUIRED + FIELD NDOC + KEY 1 +END + +STRING F_STATO 1 +BEGIN + PROMPT 53 1 "Stato " + FIELD STATO + FLAGS "DG" +END + +STRING F_TIPODOC 4 +BEGIN + PROMPT 2 3 "Tipo " + FLAGS "H" + FIELD TIPODOC + USE %TIP + INPUT CODTAB F_TIPODOC + OUTPUT F_DESTIPO S0 + CHEKCTYPE NORMAL +END + +STRING F_DESTIPO 50 +BEGIN + PROMPT 24 3 "" + FLAGS "H" +END + +NUMBER F_NPREV 7 +BEGIN + PROMPT 2 3 "Preventivo " + FLAGS "D" +END + +NUMBER F_NREV 2 +BEGIN + PROMPT 24 3 "Revisione " + FLAGS "DZ" +END + +DATE F_DATADOC +BEGIN + PROMPT 46 3 "Data " + FLAGS "A" + FIELD DATADOC + CHECKTYPE REQUIRED +END + +STRING F_NUMDOCRIF 7 +BEGIN + PROMPT 2 4 "Documento di riferimento " + FIELD NUMDOCRIF +END + +DATE F_DATADOCRIF +BEGIN + PROMPT 36 4 "del " + FIELD DATADOCRIF +END + +GOLEM F_OGGETTI 10 2 +BEGIN + PROMPT 64 3 "" + FIELD COLL_GOLEM + FLAGS "M" +END + +GROUPBOX DLG_NULL 78 9 +BEGIN + PROMPT 1 6 "@bCliente" +END + +LIST DLG_NULL 1 7 +BEGIN + PROMPT 68 68 "Tipo " + ITEM "C|Cliente" + FLAGS "H" + FIELD TIPOCF +END + +NUMBER F_CLIFO 7 +BEGIN + PROMPT 2 7 "Cliente " + USE LF_CLIFO + INPUT TIPOCF "C" + INPUT CODCF F_CLIFO + DISPLAY "Cliente" CODCF + DISPLAY "Ragione Sociale@50" LF_CLIFO->RAGSOC + DISPLAY "Partita IVA@12" PAIV + DISPLAY "Codice Fiscale@16" COFI + DISPLAY "Sospeso@C" SOSPESO + OUTPUT F_CLIFO CODCF + OUTPUT F_RAGSOC RAGSOC + OUTPUT F_RICALT RICALT + OUTPUT F_STATOPAIV STATOPAIV + OUTPUT F_PAIV PAIV + OUTPUT F_COFI COFI + CHECKTYPE REQUIRED + FIELD CODCF +END + +STRING F_RAGSOC 50 +BEGIN + PROMPT 24 7 "" + USE LF_CLIFO KEY 2 + INPUT TIPOCF "C" + INPUT RAGSOC F_RAGSOC + DISPLAY "Ragione Sociale@50" RAGSOC + DISPLAY "Cliente" CODCF + DISPLAY "Partita IVA@12" PAIV + DISPLAY "Codice Fiscale@16" COFI + DISPLAY "Sospeso@C" SOSPESO + COPY OUTPUT F_CLIFO + CHECKTYPE REQUIRED +END + +STRING F_RICALT 30 +BEGIN + PROMPT 2 8 "Codice " + USE LF_CLIFO KEY 6 + INPUT TIPOCF "C" + INPUT RICALT F_RICALT + DISPLAY "Codice alt.@30" RICALT + DISPLAY "Cliente" CODCF + DISPLAY "Ragione sociale@50" RAGSOC + DISPLAY "Sospeso@C" SOSPESO + COPY OUTPUT F_CLIFO + HELP "Chiave di ricerca alternativa" +END + +STRING F_STATOPAIV 2 +BEGIN + PROMPT 52 8 "Stato CEE " + HELP "Codice ISO dello stato" + FLAGS "U" + USE %SCE + INPUT CODTAB F_STATOPAIV + DISPLAY "Codice" CODTAB + DISPLAY "Descrizione@50" S0 + OUTPUT F_STATOPAIV CODTAB + CHECKTYPE NORMAL +END + +STRING F_COFI 16 +BEGIN + PROMPT 2 9 "Codice fiscale " + FLAGS "U" + USE LF_CLIFO KEY 4 + INPUT TIPOCF "C" + INPUT COFI F_COFI + DISPLAY "Codice fiscale@16" COFI + DISPLAY "Cliente" CODCF + DISPLAY "Ragione sociale@50" RAGSOC + DISPLAY "Partita IVA@12" PAIV + DISPLAY "Sospeso@C" SOSPESO + COPY OUTPUT F_CLIFO + HELP "Codice fiscale del cliente/fornitore" +END + +STRING F_PAIV 12 +BEGIN + PROMPT 50 9 "Partita IVA " + KEY 5 + USE LF_CLIFO KEY 5 + INPUT TIPOCF "C" + INPUT STATOPAIV F_STATOPAIV + INPUT PAIV F_PAIV + DISPLAY "Partita IVA@11" PAIV + DISPLAY "Cliente" CODCF + DISPLAY "Ragione sociale@50" RAGSOC + DISPLAY "Codice fiscale@16" COFI + DISPLAY "Sospeso@C" SOSPESO + COPY OUTPUT F_CLIFO + HELP "Partita IVA del cliente/fornitore" + VALIDATE PI_FUNC F_STATOPAIV +END + +ZOOM F_NOTE 62 +BEGIN + PROMPT 2 10 "Note " + FIELD NOTE +END + +STRING F_CODPAG 4 +BEGIN + PROMPT 2 11 "Pagamento " + USE %CPG + INPUT CODTAB F_CODPAG + DISPLAY "Codice" CODTAB + DISPLAY "Descrizione@50" S0 + OUTPUT F_CODPAG CODTAB + OUTPUT F_DESPAG S0 + CHECKTYPE NORMAL + FIELD CODPAG +END + +STRING F_DESPAG 50 +BEGIN + PROMPT 24 11 "" + USE %CPG KEY 2 + INPUT S0 F_DESPAG + DISPLAY "Descrizione@50" S0 + DISPLAY "Codice" CODTAB + COPY OUTPUT F_CODPAG + CHECKTYPE NORMAL +END + +STRING F_CODLIS 4 +BEGIN + PROMPT 2 12 "Listino " + FLAGS "U" + USE LF_CONDV + INPUT TIPO "L" + INPUT CATVEN "" + INPUT COD F_CODLIS + DISPLAY "Codice" COD + DISPLAY "Descrizione@50" DESCR + DISPLAY "Inizio@10" VALIN + DISPLAY "Fine@10" VALFIN + OUTPUT F_CODLIS COD + OUTPUT F_DESLIS DESCR + ADD RUN ve2 -1 L + CHECKTYPE NORMAL + FIELD CODLIST +END + +STRING F_DESLIS 50 +BEGIN + PROMPT 24 12 "" + USE LF_CONDV KEY 2 + INPUT TIPO "L" + INPUT CATVEN "" + INPUT DESCR F_DESLIS + DISPLAY "Descrizione@50" DESCR + DISPLAY "Codice" COD + DISPLAY "Inizio@10" VALIN + DISPLAY "Fine@10" VALFIN + COPY OUTPUT F_CODLIS + CHECKTYPE NORMAL + ADD RUN ve2 -1 L +END + +STRING F_RICARICO 25 +BEGIN + PROMPT 2 13 "Ricarico " + FIELD SCONTOPERC +END + +LIST F_TIPOCOSTO 1 25 +BEGIN + PROMPT 43 13 "Costo " + ITEM "0|" + ITEM "1|Ultimo costo" + ITEM "2|Media costi" + ITEM "4|Costo standard" + ITEM "5|Costo medio" + ITEM "6|Costo medio ponderato" + FIELD CODNOTE +END + +GROUPBOX F_CDC0 78 6 +BEGIN + PROMPT 1 15 "@bAnalitica" +END + +ENDPAGE + +PAGE "Righe" 0 2 0 0 + +TLIST F_FASI 60 -1 +BEGIN + PROMPT 0 2 "" + DISPLAY "Fasi@15" CODART + DISPLAY "Costo@7R" QTAGG5 + DISPLAY "Prezzo@7R" PREZZO + DISPLAY "Descrizione@35" DESCR +END + +BUTTON F_FASENEW 8 2 +BEGIN + PROMPT 1 0 "Nuovo" + PICTURE BMP_NEWREC + PICTURE BMP_NEWRECDN +END + +BUTTON F_FASEDIT 8 2 +BEGIN + PROMPT 12 0 "Modifica" + PICTURE BMP_EDIT + FLAGS "D" +END + +BUTTON F_FASEUP 3 2 +BEGIN + PROMPT 23 0 "Su" + PICTURE BMP_DARROWU + FLAGS "D" +END + +BUTTON F_FASEDN 3 2 +BEGIN + PROMPT 29 0 "Gił" + PICTURE BMP_DARROWD + FLAGS "D" +END + +BUTTON F_FASELT 3 2 +BEGIN + PROMPT 35 0 "<<" + PICTURE BMP_DARROWL + FLAGS "D" +END + +BUTTON F_FASERT 3 2 +BEGIN + PROMPT 41 0 ">>" + PICTURE BMP_DARROWR + FLAGS "D" +END + +TEXT DLG_NULL +BEGIN + PROMPT 50 0 "Fase max:" +END + +LIST F_FASEMAX 1 9 +BEGIN + PROMPT 50 1 "" + ITEM "1|1 Livello" + ITEM "2|2 Livelli" + ITEM "3|3 Livelli" + ITEM "4|4 Livelli" + FIELD NCOLLI +END + +SPREADSHEET F_DISTINTE 0 11 +BEGIN + PROMPT 65 0 "" + ITEM "Distinta@20" + ITEM "Descrizione@50" + ITEM "U.M." + ITEM "Quantitą@9" + ITEM "Costo@9R" + ITEM "Prezzo@9R" +END + +SPREADSHEET F_ARTICOLI 0 7 +BEGIN + PROMPT 65 11 "" + ITEM "Articolo@20" + ITEM "Descrizione@50" + ITEM "U.M." + ITEM "Quantitą@9R" + ITEM "Costo@9R" +END + +SPREADSHEET F_MISURE +BEGIN + PROMPT 65 18 "" + ITEM "Descrizione@50" + ITEM "Numero@9" + ITEM "Lunghezza@9" + ITEM "Larghezza@9" + ITEM "Altezza@9" +END + +ENDPAGE + +ENDMASK + +PAGE "Distinta" -1 -1 60 6 + +STRING 101 20 +BEGIN + PROMPT 1 1 "Distinta " + USE LF_DIST + INPUT CODDIST 101 + DISPLAY "Codice@20" CODDIST + DISPLAY "Descrizione@50" DESCR + DISPLAY "U.M." UM + DISPLAY "Prezzo@V" PREZZO + OUTPUT 101 CODDIST + OUTPUT 102 DESCR + OUTPUT 103 UM + OUTPUT 105 PREZZO + CHEKTYPE SEARCH + ADD RUN db0 -4 + FIELD CODART +END + +STRING 102 50 45 +BEGIN + PROMPT 1 2 "Descriz. " + USE LF_DIST KEY 2 + INPUT DESCR 105 + DISPLAY "Descrizione@50" DESCR + DISPLAY "Codice@20" CODDIST + DISPLAY "U.M." UM + DISPLAY "Prezzo@V" PREZZO + COPY OUTPUT 101 + CHEKTYPE SEARCH + FIELD DESCR +END + +STRING 103 2 +BEGIN + PROMPT 1 3 "U.M. " + USE %UMS + INPUT CODTAB 103 + DISPLAY "Codice" CODTAB + DISPLAY "Descrizione@50" S0 + OUTPUT 103 CODTAB + CHECKTYPE NORMAL + FIELD UMQTA +END + +NUMBER 104 9 2 +BEGIN + PROMPT 11 3 "Quantitą " + FIELD QTA +END + +CURRENCY 105 9 +BEGIN + PROMPT 37 3 "Costo " + FIELD QTAGG5 +END + +CURRENCY 106 9 +BEGIN + PROMPT 37 4 "Prezzo " + FIELD PREZZO +END + +ENDPAGE + +TOOLBAR "" 0 0 0 2 + +BUTTON DLG_OK 2 2 +BEGIN + PROMPT 1 1 "" +END + +BUTTON DLG_DELREC 2 2 +BEGIN + PROMPT 2 1 "" +END + +BUTTON DLG_CANCEL 2 2 +BEGIN + PROMPT 3 1 "" +END + +ENDPAGE +ENDMASK + +PAGE "Riga" -1 -1 50 5 + +STRING 101 20 +BEGIN + PROMPT 1 1 "Articolo " + USE LF_ANAMAG + INPUT CODART 101 + DISPLAY "Codice@20" CODART + DISPLAY "Descrizione@50" DESCR + OUTPUT 101 CODART + OUTPUT 102 DESCR + CHEKTYPE NORMAL + FIELD CODART + ADD RUN ve2 -3 +END + +STRING 102 50 40 +BEGIN + PROMPT 1 2 "Descriz. " + USE LF_ANAMAG KEY 2 + INPUT DESCR 102 + DISPLAY "Descrizione@50" DESCR + DISPLAY "Codice@20" CODART + COPY OUTPUT 101 + FIELD DESCR + ADD RUN ve2 -3 +END + +STRING 103 2 +BEGIN + PROMPT 1 3 "U.M. " + USE LF_UMART KEY 2 + JOIN %UMS INTO CODTAB=UM + INPUT CODART 101 SELECT + INPUT UM 103 + DISPLAY "Codice" UM + DISPLAY "Descrizione@50" LF_TABCOM->S0 + OUTPUT 103 UM + CHECKTYPE NORMAL + FIELD UMQTA +END + +NUMBER 104 9 2 +BEGIN + PROMPT 11 3 "Quantitą " + FIELD QTA +END + +CURRENCY 105 9 +BEGIN + PROMPT 31 3 "Costo " + FIELD QTAGG5 +END + +ENDPAGE + +TOOLBAR "" 0 0 0 2 + +BUTTON DLG_OK 2 2 +BEGIN + PROMPT 1 1 "" +END + +BUTTON DLG_DELREC 2 2 +BEGIN + PROMPT 2 1 "" +END + +BUTTON DLG_CANCEL 2 2 +BEGIN + PROMPT 3 1 "" +END + +ENDPAGE +ENDMASK + +PAGE "Misura" -1 -1 60 8 + +STRING 101 50 45 +BEGIN + PROMPT 1 1 "Descriz. " + FIELD DESCR +END + +NUMBER 102 9 +BEGIN + PROMPT 1 2 "Numero " + FIELD QTA +END + +NUMBER 103 9 2 +BEGIN + PROMPT 1 3 "Lunghezza " + FIELD QTAGG1 +END + +NUMBER 104 9 2 +BEGIN + PROMPT 1 4 "Larghezza " + FIELD QTAGG2 +END + +NUMBER 105 9 2 +BEGIN + PROMPT 1 5 "Altezza " + FIELD QTAGG3 +END + +NUMBER 106 9 2 +BEGIN + PROMPT 1 6 "Totale " + FIELD QTA + FLAGS "DG" + DRIVENBY 102 103 104 105 + NUM_CALC #102*IF(#103,#103,1)*IF(#104,#104,1)*IF(#105,#105,1) +END + +ENDPAGE + +TOOLBAR "" 0 0 0 2 + +BUTTON DLG_OK 2 2 +BEGIN + PROMPT 1 1 "" +END + +BUTTON DLG_DELREC 2 2 +BEGIN + PROMPT 2 1 "" +END + +BUTTON DLG_CANCEL 2 2 +BEGIN + PROMPT 3 1 "" +END + +ENDPAGE +ENDMASK \ No newline at end of file diff --git a/pe/pe1401.cpp b/pe/pe1401.cpp new file mode 100644 index 000000000..5a5ad066e --- /dev/null +++ b/pe/pe1401.cpp @@ -0,0 +1,415 @@ +#include "pe1401.h" + +#include +#include +#include + +#include +#include +#include "pe1400.h" + +bool TPreventivo_tree::add_lastson(TObject* obj) +{ + CHECK(obj != NULL && obj->is_kind_of(CLASS_RECTYPE), "Record non valido per preventivo"); + CHECK(((TRectype*)obj)->get(RDOC_TIPORIGA).full(), "TIPORIGA vuoto"); + bool done = false; + if (goto_firstson()) // Se ha almeno un figlio ... + { + while (goto_rbrother()); // ... allora vai all'ultimo fratello + done = add_rbrother(obj); // ed aggiungi ultimo fratello + } + else + done = add_son(obj); // Aggiungi primogenito + return done; +} + +TPreventivo_level TPreventivo_tree::last_fase_level() const +{ + const int mf = owner().mask().get_int(F_FASEMAX); + return TPreventivo_level(pl_fase1 + mf - 1); +} + +bool TPreventivo_tree::goto_last_fase(TPreventivo_level sublevel) +{ + bool ok = goto_root() && goto_firstson(); + if (ok) + { + while (goto_rbrother()); // goto last son + + if (sublevel > pl_fase1) + { + const TPreventivo_level mf = last_fase_level(); + if (sublevel > mf) + sublevel = mf; + + while (level() < sublevel) + { + if (goto_firstson()) + while (goto_rbrother()); + else + break; + } + + ok = level() == sublevel; + } + } + return ok; +} + +bool TPreventivo_tree::goto_last_dist() +{ + bool ok = goto_last_fase(pl_distinta); // pl_distinta = dummy value for maximum depth + if (ok) + { + ok = goto_firstson(); + if (ok) + while (goto_rbrother()); + } + return ok; +} + +TRectype* TPreventivo_tree::new_row(TPreventivo_level level) const +{ + const TMask& m = owner().mask(); + TRectype* rec = new TRectype(level == pl_documento ? LF_DOC : LF_RIGHEDOC); + rec->put(RDOC_PROVV, 'D'); + rec->put(RDOC_ANNO, m.get(F_ANNO)); + rec->put(RDOC_CODNUM, m.get(F_CODNUM)); + rec->put(RDOC_NDOC, m.get(F_NDOC)); + switch (level) + { + case pl_distinta : rec->put(RDOC_TIPORIGA, tipo_dist()); rec->put(RDOC_DESCR, TR("Nuova distinta"));break; + case pl_dettaglio: rec->put(RDOC_TIPORIGA, tipo_dett()); rec->put(RDOC_DESCR, TR("Nuova riga"));break; + case pl_misura : rec->put(RDOC_TIPORIGA, tipo_misu()); rec->put(RDOC_DESCR, TR("Nuova misura"));break; + default : rec->put(RDOC_TIPORIGA, tipo_fasi()); rec->put(RDOC_DESCR, TR("Nuova fase")); rec->put(RPRV_LEVEL, level-pl_fase1); break; + } + + return rec; +} + +TRectype* TPreventivo_tree::dist(const TString& fase, int n, bool create) +{ + TRectype* rec = NULL; + if (goto_node(fase)) + { + if (goto_firstson()) + { + int i = 0; + for (; i < n && goto_rbrother(); i++); + if (i < n) + { + if (create) + add_rbrother(rec = new_row(pl_distinta)); + } + else + rec = curr_row(); + } + else + { + if (create) + add_son(rec = new_row(pl_distinta)); + } + } + return rec; +} + +TRectype* TPreventivo_tree::dett(const TString& dist, int n, bool create) +{ + TRectype* rec = NULL; + if (goto_node(dist)) + { + if (goto_firstson()) + { + if (level() == pl_dettaglio) + { + int i = 0; + for (; i < n && goto_rbrother() && level() == pl_dettaglio; i++); + if (i == n) + rec = curr_row(); + } + if (rec == NULL && create) + { + if (level() == pl_dettaglio) + add_rbrother(rec = new_row(pl_dettaglio)); + else + add_lbrother(rec = new_row(pl_dettaglio)); + } + } + else + { + if (create && n == 0) + add_son(rec = new_row(pl_dettaglio)); + } + } + return rec; +} + +TRectype* TPreventivo_tree::misu(const TString& dist, int n, bool create) +{ + TRectype* rec = NULL; + if (goto_node(dist)) + { + CHECKS(level() == pl_distinta, "Distinta non valida", (const char*)dist); + if (goto_firstson()) + { + int i = level() == pl_misura ? 0 : -1; + while (i < n && goto_rbrother()) + if (level() == pl_misura) i++; + if (i < n) + { + if (create) + add_rbrother(rec = new_row(pl_misura)); + } + else + rec = curr_row(); + } + else + { + if (create && n == 0) + add_son(rec = new_row(pl_misura)); + } + } + return rec; +} + +TPreventivo_level TPreventivo_tree::level(const TRectype& rec) const +{ + TPreventivo_level lev = pl_documento; + if (rec.num() == LF_RIGHEDOC) + { + const TString& t = rec.get(RDOC_TIPORIGA); + if (t.full()) + { + lev = pl_fase1; + if (t == _strFasi) + lev = TPreventivo_level(lev + rec.get_int(RPRV_LEVEL)); else + if (t == _strDist) + lev = pl_distinta; else + if (t == _strDett) + lev = pl_dettaglio; else + if (t == _strMisu) + lev = pl_misura; + } + } + return lev; +} + +TPreventivo_level TPreventivo_tree::level() const +{ + TPreventivo_level lev = pl_documento; + TRectype* rec = curr_row(); + if (rec != NULL) + lev = level(*rec); + return lev; +} + +bool TPreventivo_tree::could_have_son() const +{ return level() < pl_distinta; } + +bool TPreventivo_tree::get_description(TString& str) const +{ + const TRectype* rec = curr_row(); + bool ok = rec != NULL && !rec->empty(); + if (ok) + { + if (rec->num() == LF_DOC) + { + const TMask& m = owner().mask(); + str = m.get(F_NPREV); + if (m.field(F_NREV).shown()) + str << '.' << m.get(F_NREV); + str << TR(" del ") << m.get(F_DATADOC); + } else + if (rec->num() == LF_RIGHEDOC) + { + str = rec->get(RDOC_DESCR); + if (str.blank()) + str = rec->get(RDOC_CODART); + } + else + NFCHECK("Bad tree record"); + } + else + NFCHECK("NULL tree record"); + return ok; +} + +TFieldtypes TPreventivo_tree::get_var(const TString& name, TVariant& var) const +{ + TFieldtypes ft = _nullfld; + const TRectype* rec = curr_row(); + if (rec != NULL && !rec->empty()) + { + if (rec->num() == LF_DOC) + { + const TMask& m = owner().mask(); + if (name == RDOC_CODART) + { + TString16 str = m.get(F_NPREV); + if (m.field(F_NREV).shown()) + str << '.' << m.get(F_NREV); + var = str; + ft = _alfafld; + } else + if (name == RDOC_DESCR) + { + TString80 str = m.get(F_NOTE); + if (str.blank()) + get_description(str); + var = str; + ft = _alfafld; + } else + if (name == RDOC_PREZZO || name == RPRV_COSTO) + { + real c, p; ((TPreventivo_tree*)this)->ricalcola(c, p); + if (name == RDOC_PREZZO ) + var = p.stringa(0,2); + else + var = c.stringa(0,2); + ft = _realfld; + } + } + else + { + ft = rec->type(name); + if (ft > _nullfld) + { + if (ft == _realfld) + { + if ((name == RDOC_PREZZO || name == RPRV_COSTO) && level() == pl_distinta) + { + real c, p; ((TPreventivo_tree*)this)->ricalcola(c, p); + if (name == RDOC_PREZZO ) + var = p.stringa(0,2); + else + var = c.stringa(0,2); + } + else + var = rec->get_real(name).stringa(0, 2); + } + else + var = rec->get(name); + } + } + } + return ft; +} + + +TImage* TPreventivo_tree::image(bool sel) const +{ + const TPreventivo_level pl = level(); + if (pl <= pl_distinta) + { + const bool ex = expanded(); + if (has_son()) + return get_res_image(ex ? BMP_DIRDNSEL : BMP_DIRSEL); + else + return get_res_image(ex ? BMP_DIRDN : BMP_DIR); + } + return TObject_tree::image(sel); +} + +// Aggiunge un record alla fine dell'albero in base al tipo della riga (usato solo in lettura iniziale) +bool TPreventivo_tree::append_row(const TRectype& rec) +{ + const TPreventivo_level pl = level(rec); + if (pl == pl_documento) + { + // Se aggiungo un documento allora svuoto albero e ricreo radice + if (goto_root()) + kill_node(); + return add_son(rec); + } else + if (pl == pl_dettaglio) + { + // Le righe di dettaglio devono precedere quelle di misura + if (goto_last_dist()) + { + if (goto_firstson()) + { + while (level() == pl_dettaglio && goto_rbrother()); + if (level() == pl_dettaglio) + return add_rbrother(rec); + else + return add_lbrother(rec); + } + return add_son(rec); + } + } else + if (pl == pl_misura) + { + if (goto_last_dist()) + return add_lastson(rec); + } + else + { + goto_root(); + while (level() < pl) + { + if (goto_firstson()) + while (goto_rbrother()); + else + break; + } + if (level() < pl) + return add_lastson(rec); + else + return add_rbrother(rec); + } + + return false; +} + +bool TPreventivo_tree::ricalcola(real& costo, real& prezzo) +{ + bool ok = false; + const TPreventivo_level lev = level(); + costo = prezzo = ZERO; + if (lev < pl_distinta && has_son()) + { + TString16 id; curr_id(id); + for (bool go = goto_firstson(); go; go = goto_rbrother()) + { + real c, p; + if (ricalcola(c, p)) + { + costo += c; + prezzo += p; + } + } + ok = goto_node(id); + if (lev >= pl_fase1) + { + TRectype& rec = *curr_row(); + rec.put(RDOC_QTA, 1); + rec.put(RPRV_COSTO, costo); + rec.put(RDOC_PREZZO, prezzo); + } + } + else + { + ok = lev == pl_distinta; + if (ok) + { + const TRectype& rec = *curr_row(); + const real qta = rec.get_real(RDOC_QTA); + if (!qta.is_zero()) + { + costo = qta * rec.get_real(RPRV_COSTO); + prezzo = qta * rec.get_real(RDOC_PREZZO); + } + } + } + return ok; +} + +TPreventivo_tree::TPreventivo_tree(TTree_field& owner) : _owner(owner) +{ + // Legge i tipi riga standard per determinare i nodi dell'albero + _strFasi = ini_get_string(CONFIG_DITTA, "pe", "TipoRigaFase", "05"); + _strDist = ini_get_string(CONFIG_DITTA, "pe", "TipoRigaDist", "01"); + _strDett = ini_get_string(CONFIG_DITTA, "pe", "TipoRigaDett", "04"); + _strMisu = ini_get_string(CONFIG_DITTA, "pe", "TipoRigaMisu", "09"); +} + diff --git a/pe/pe1401.h b/pe/pe1401.h new file mode 100644 index 000000000..87d067de4 --- /dev/null +++ b/pe/pe1401.h @@ -0,0 +1,67 @@ +#ifndef __PE1401_H +#define __PE1401_H + +#ifndef __ISAM_H +#include +#endif + +#ifndef __TREE_H +#include +#endif + +#ifndef __TREECTRL_H +#include +#endif + +/////////////////////////////////////////////////////////// +// TPreventivo_tree +/////////////////////////////////////////////////////////// + +enum TPreventivo_level { pl_documento = 0, pl_fase1 = 1, pl_fase2, pl_fase3, pl_fase4, pl_distinta=10, pl_dettaglio, pl_misura }; + +class TPreventivo_tree : public TObject_tree +{ + TTree_field& _owner; + TString4 _strFasi, _strDist, _strDett, _strMisu; + +private: + bool add_lastson(TObject* obj); + bool add_lastson(const TObject& obj) { return add_lastson(obj.dup()); } + +protected: + bool goto_last_fase(TPreventivo_level level); + bool goto_last_dist(); + +public: + virtual bool could_have_son() const; + virtual bool get_description(TString& str) const; + virtual TFieldtypes get_var(const TString& name, TVariant& var) const; + + virtual TImage* image(bool sel) const; + + const TString& tipo_fasi() const { return _strFasi; } + const TString& tipo_dist() const { return _strDist; } + const TString& tipo_dett() const { return _strDett; } + const TString& tipo_misu() const { return _strMisu; } + + TPreventivo_level level(const TRectype& rec) const; + TPreventivo_level level() const; + TPreventivo_level last_fase_level() const; + + TRectype* new_row(TPreventivo_level level) const; + TRectype* curr_row() const { return (TRectype*)curr_node(); } + TTree_field& owner() const { return _owner; } + + TRectype* dist(const TString& fase, int n, bool create = false); + TRectype* dett(const TString& dist, int n, bool create = false); + TRectype* misu(const TString& dist, int n, bool create = false); + bool ricalcola(real& costo, real& prezzo); + + TPreventivo_tree(TTree_field& owner); + bool append_row(const TRectype& rec); +}; + +const TString& trova_elaborazione(const TRectype& doc); +bool genera_ordine(const TRectype& doc); + +#endif diff --git a/pe/pe1402.cpp b/pe/pe1402.cpp new file mode 100644 index 000000000..de3d3a1c6 --- /dev/null +++ b/pe/pe1402.cpp @@ -0,0 +1,86 @@ +#include "pe1401.h" +#include "../ve/velib04.h" + +class TPreventivazione : public TElaborazione +{ +public: + virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out, + const TDate& data_elab, bool interattivo = false); + TPreventivazione(const TString& cod) : TElaborazione(cod) { } +}; + +bool TPreventivazione::elabora(TLista_documenti& doc_in, TLista_documenti& doc_out, + const TDate& data_elab, bool interattivo) +{ + for (int i = 0; i < doc_in.items(); i++) + { + if (i >= doc_out.items()) + { + TDocumento* doc = new TDocumento('D', data_elab.year(), codice_numerazione_finale(), 0L); + doc->put(DOC_TIPODOC, tipo_finale()); + doc->put(DOC_STATO, stato_finale()); + doc_out.add(doc); + } + + TDocumento& din = doc_in[i]; + TDocumento& don = doc_out[i]; + + don.put(DOC_TIPOCF, din.get(DOC_TIPOCF)); + don.put(DOC_CODCF, din.get(DOC_CODCF)); + don.put(DOC_DATADOC, data_elab); + don.put(DOC_NOTE, din.get(DOC_NOTE)); + don.put(DOC_CODCMS, din.get(DOC_CODCMS)); + + FOR_EACH_PHYSICAL_RDOC(din, r, rdoc) + { + if (rdoc->is_descrizione()) + { + TRiga_documento& rout = don.new_row(rdoc->get(RDOC_TIPORIGA)); + TDocumento::copy_data(rout, *rdoc); + } else + if (rdoc->is_merce()) + { + TRiga_documento& rout = don.new_row(rdoc->get(RDOC_TIPORIGA)); + TDocumento::copy_data(rout, *rdoc); + } + } + } + return true; +} + +const TString& trova_elaborazione(const TRectype& doc) +{ + TString8 cod; + TISAM_recordset eld("USE %ELD SELECT (I0==0)||(I0=4)"); + const TString4 codnum = doc.get(DOC_CODNUM); + const TString4 tipodoc = doc.get(DOC_TIPODOC); + const TString4 stato = doc.get(DOC_STATO); + for (bool ok = eld.move_first(); ok; ok = eld.move_next()) + { + const TString4 c = eld.get("CODTAB").as_string(); + const TElaborazione e(c); + if (codnum != e.codice_numerazione_iniziale()) + continue; + if (tipodoc != e.tipo_iniziale(0)) + continue; + if (stato >= e.stato_finale_doc_iniziale()) + continue; + cod = c; + break; + } + return get_tmp_string() = cod; +} + +bool genera_ordine(const TRectype& doc) +{ + const TString& codelab = trova_elaborazione(doc); + if (codelab.empty()) + return false; + + const TDate oggi(TODAY); + TLista_documenti doc_in, doc_out; + doc_in.add(new TDocumento(doc)); + + TPreventivazione prev(codelab); + return prev.elabora(doc_in, doc_out, oggi); +}