#include #include #include "lvlib.h" #include "../ve/velib.h" #include "lvcondv.h" #include "lvrcondv.h" #include "lvrconsplan.h" #include "lv2400a.h" /////////////////////////////////////////////////////////// // TGestione_planning maschera /////////////////////////////////////////////////////////// class TGenera_documenti_mask : public TAutomask { public: virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly); TGenera_documenti_mask (const char* name) : TAutomask(name) {} }; //questa funzione gestisce i vari eenti che si verificano sui campi della maschera bool TGenera_documenti_mask::on_field_event(TOperable_field& o, TField_event e, long jolly) { return true; } /////////////////////////////////////////////////////////// // TGestione_planning applicazione /////////////////////////////////////////////////////////// class TGenera_documenti_app : public TSkeleton_application { TGenera_documenti_mask* _msk; TAssoc_array _quantita; TAssoc_array _quantita_ritirata; TConfig* _configlv; private: //Metodi per la generazione dei documenti bool crea_documento(const TISAM_recordset& plan); void crea_riga(const TString& codart, const char modpas, const int tplis, const bool tmp, const bool prinbo,TDocumento& doc); //Metodi per il recupero di codnum, tpdoc, stato bool numerazione_ddt(TString& codnum, TString& tpdoc, TString& statoi, TString& statof) const; bool numerazione_drit(const int cod, TString& codnum, TString& tpdoc, TString& statoi, TString& statof) const; bool numerazione_dant(const int cod, TString& codnum, TString& tpdoc, TString& statoi, TString& statof) const; //Metodi per l'eliminazione dei documenti void cambia_stato(const long codcli, const long codind, const char ritoant); void elimina_bolle(const long codcli, const long codind); //Metodi per la scansione dei documenti void scansione_ritiri_anticipi(const long codcli, const long codind, const char ritoant); void scansione_consegne(const long codcli, const long codind); //Metodo per il calcolo delle quantità in bolla void calcolo_quantita(const TDocumento& doc, const char ritoant); //Metodi aggiornare il conguaglio sui contratti void aggiorna_conguaglio(const long codcli, const long codcont, const TString& codart, const real arr) const; protected: virtual bool create(); virtual void on_config_change(); virtual bool destroy(); public: bool transfer(); virtual void main_loop(); }; //////////////////////////////// //// Metodi Protected //// //////////////////////////////// bool TGenera_documenti_app::create() { _msk = new TGenera_documenti_mask("lv2400a"); _configlv = new TConfig(CONFIG_DITTA,"lv"); return TSkeleton_application::create(); } void TGenera_documenti_app::on_config_change() { if (_configlv != NULL) delete _configlv; _configlv = new TConfig(CONFIG_DITTA,"lv"); } bool TGenera_documenti_app::destroy() { delete _configlv; delete _msk; return TApplication::destroy(); } ////////////////////////////////////////////////////////////// //// Metodi per la generazione dei documenti //// ////////////////////////////////////////////////////////////// //CREA_DOCUMENTO: questa funzione crea un nuovo documento di trasporto dai dati salvati bool TGenera_documenti_app::crea_documento(const TISAM_recordset& plan) { //recupero i dati di interesse dalla maschera const TDate datadoc = _msk->get_date(F_DTDOC); //per ogni planning recupero i dati di interesse dal planning const long codcli = plan.get(LVRCONSPLAN_CODCF).as_int(); const long codcont = plan.get(LVRCONSPLAN_CODCONT).as_int(); const TDate dtcons = plan.get(LVRCONSPLAN_DTCONS).as_date(); const char modpas = plan.get(LVRCONSPLAN_MODPASS).as_string()[0]; const int anno = datadoc.year(); //preparo la chiave per la tabella contratti TToken_string keycont; keycont.add(codcli); keycont.add(codcont); //instanzio una cache sulla tabella dei contratti const TRectype& tcont = cache().get(LF_LVCONDV,keycont); //estraggo i dati di interesse dalla cache const long codind = tcont.get_long(LVCONDV_CODINDSP); //codice dell'indirizzo di spedizione const int tplis = tcont.get_int(LVCONDV_TIPOLIS); //tipo listino const bool prinbo = tcont.get_bool(LVCONDV_STPRZBOL); //prezzo in bolla //elimina eventuali documenti di consegna che sono ancora in stato iniziale //...e riporta in stato iniziale i documenti di ritiro e di anticipo che concorrono //...a calcolare le quantità da riportare sulla bolla cambia_stato(codcli, codind, 'R'); cambia_stato(codcli, codind, 'A'); elimina_bolle(codcli, codind); //calcola tutte le quantità riportate sui documenti di ritiro, sui documenti di anticipo e sulle bolle di consegna //...eventualmente modificate a mano scansione_ritiri_anticipi(codcli,codind,'R'); scansione_ritiri_anticipi(codcli,codind,'A'); scansione_consegne(codcli,codind); //variabili che conterranno i parametri dei documenti che devo generare... //...settati dalla funzione numerazione_ddt() TString4 codnum; TString4 tpdoc; TString4 statoi; TString4 statof; //se non trovo quale documento generare, evito il resto dell'elaborazione if (!numerazione_ddt(codnum, tpdoc, statoi, statof)) return NOERR; //creo il documento corretto riempiendo i campi che già conosco TDocumento doc('D',anno,codnum,0); doc.put(DOC_STATO, statoi); doc.put(DOC_TIPODOC, tpdoc); doc.put(DOC_DATADOC, datadoc); doc.put(DOC_TIPOCF, 'C'); doc.put(DOC_CODCF, codcli); doc.put(DOC_CODCONT, codcont); doc.put(DOC_CODINDSP, codind); const long ndoc = doc.get_long(DOC_NDOC); //preparo la chiave per la tabella righe contratti TToken_string keyrcont; keycont.add(codcli); keycont.add(codcont); FOR_EACH_ASSOC_OBJECT(_quantita,h,codart,obj) { crea_riga(codart, modpas, tplis, false, prinbo ,doc); /*const TDate dadata = rcont.get(LVRCONDV_INDTTMP).as_date(); const TDate adata = rcont.get(LVRCONDV_FIDTTMP).as_date(); if (dadata.ok() && dtcons >= dadata && dtcons <= adata) crea_riga(rcont, modpas, true, doc);*/ } int err = doc.write(); //scrivo sul planning il riferimento alla bolla che lo accompagna if (err == NOERR) { TLocalisamfile& f = plan.cursor()->file(); f.put(LVRCONSPLAN_ANNO, anno); f.put(LVRCONSPLAN_CODNUM, codnum); f.put(LVRCONSPLAN_NDOC, ndoc); f.rewrite(); } return err == NOERR; } //CREA_RIGA: questa funzione crea una riga merce per una bolla di consegna void TGenera_documenti_app::crea_riga(const TString& codart, const char modpas, const int tplis, const bool tmp, const bool prinbo,TDocumento& doc) { const int perarr = _configlv->get_int("Perarr"); //creo la nuova riga TRiga_documento& rdoc = doc.new_row("21"); const long codcli = doc.get_long(DOC_CODCF); const long codcont = doc.get_long(DOC_CODCONT); //calcolo della quantità che va sulla bolla //preparo la chiave per la tabella righe contratti TToken_string keyrcont; keyrcont.add(codcli); keyrcont.add(codcont); keyrcont.add(codart); //instanzio una cache sulla tabella delle righe contratti const TRectype& rcont = cache().get(LF_LVRCONDV,keyrcont); //recupero i dati di interesse dalla riga del contratto const bool arrot = rcont.get_bool(LVRCONDV_ARROT); const real conguaglio = rcont.get_real(LVRCONDV_QTACONG); const real& qta = *(real*)_quantita.objptr(codart); const real& qta1 = *(real*)_quantita_ritirata.objptr(codart); //instanzio una cache sulla tabella del magazzino const TRectype& anamag = cache().get(LF_ANAMAG,codart); //recupero i dati di interesse dall'anagrafica di magazzino const real ppconf = anamag.get_real(ANAMAG_PPCONF); const real quantita_noarr = qta - conguaglio; real quantita_arr = quantita_noarr > ZERO ? quantita_noarr : ZERO; //se devo arrotondare if (quantita_arr > ZERO && arrot) { //calcolo di quanti pezzi sforo long arr = quantita_arr.integer() % ppconf.integer(); //se sforo (arr > 0) allora calcolo quanti pezzi in più gli devo dare e aggiorno la quantità if (arr > 0) if (arr > ppconf.integer() * perarr / 100) //arr <= ppconf*perarr/100 -> formula calcolo congualgio di Tassan { arr = ppconf.integer() - arr; quantita_arr += arr; } else quantita_arr -= arr; } //scrivo le quantità rdoc.put(RDOC_QTA, quantita_arr); //quantità consegnata eventualmente arrotondata rdoc.put(RDOC_QTAGG1, qta1); //quantità ritirata rdoc.put(RDOC_QTAGG2, conguaglio); //conguaglio rdoc.put(RDOC_QTAGG3, quantita_arr); //copia della quantità consegnata rdoc.put(RDOC_QTAGG4, quantita_noarr); //quantità che avrei consegnato se non arrotondavo (qta ritirata) rdoc.put(RDOC_GENERATA, true); //aggiorno il conguaglio sulla riga del contratto aggiorna_conguaglio(codcli, codcont, codart, quantita_arr - quantita_noarr); //elaborazione sul prezzo da utilizzare real prezzo; //elaborazione per il prezzo: o lo prendo dalle righe contratto, o dall'anagrafica magazzino if (tplis == 0) prezzo = rcont.get_real(LVRCONDV_PREZZO); else prezzo = anamag.get_real(ANAMAG_COSTSTD); rdoc.put(RDOC_CODART,codart); rdoc.put(RDOC_CODARTMAG,codart); rdoc.put(RDOC_CHECKED,'X'); if (prinbo) { if (!tmp) rdoc.put(RDOC_PREZZO,rcont.get_real(LVRCONDV_PREZZO)); else //per adesso per questo ramo non ci passa mai, perchè non sappiamo come gestire le dotazioni temporanee rdoc.put(RDOC_PREZZO,rcont.get_real(LVRCONDV_PRZDTTMP)); rdoc.put(RDOC_SCONTO,rcont.get(LVRCONDV_SCONTPERC)); //sconto } } ////////////////////////////////////////////////////////////// //// Metodi per il recupero di codnum, tpdoc, stato //// ////////////////////////////////////////////////////////////// //NUMERAZIONE_DDT: questa funzione cerca quali sono i codnum e i tpdoc che devo generare bool TGenera_documenti_app::numerazione_ddt(TString& codnum, TString& tpdoc, TString& statoi, TString& statof) const { codnum = _configlv->get("NUM_GEN"); tpdoc = _configlv->get("TIPODOC_GEN"); //instanzio una cache sulla tabella delle righe contratti (cerco lo stato iniziale) statoi = cache().get("%TIP",tpdoc,"S2").left(1); statof = cache().get("%TIP",tpdoc,"S2").mid(2,1); return codnum.full() && tpdoc.full(); } //NUMERAZIONE_DRIT: questa funzione cerca quali sono i codnum e i tpdoc dei documenti di ritiro bool TGenera_documenti_app::numerazione_drit(const int cod, TString& codnum, TString& tpdoc, TString& statoi, TString& statof) const { codnum = _configlv->get("NUM_RIT",NULL,cod); tpdoc = _configlv->get("TIPODOC_RIT",NULL,cod); statof = _configlv->get("STATO_RIT",NULL,cod); //è lo stato finale //instanzio una cache sulla tabella delle righe contratti (cerco lo stato iniziale) statoi = cache().get("%TIP",tpdoc,"S2").left(1); return codnum.full() && tpdoc.full(); } //NUMERAZIONE_DANT: questa funzione cerca quali sono i codnum e i tpdoc dei documenti di anticipo bool TGenera_documenti_app::numerazione_dant(const int cod, TString& codnum, TString& tpdoc, TString& statoi, TString& statof) const { codnum = _configlv->get("NUM_ANT",NULL,cod); tpdoc = _configlv->get("TIPODOC_ANT",NULL,cod); statof = _configlv->get("STATO_ANT",NULL,cod); //è lo stato finale //instanzio una cache sulla tabella delle righe contratti (cerco lo stato iniziale) statoi = cache().get("%TIP",tpdoc,"S2").left(1); return codnum.full() && tpdoc.full(); } ////////////////////////////////////////////////////////////// //// Metodi per l'eliminazione dei documenti //// ////////////////////////////////////////////////////////////// //CAMBIA_STATO: questa funzione cerca tutte le bolle di ritiro e anticipo relative a un certo cliente... //in un certo intervallo di date, e gli cambia stato void TGenera_documenti_app::cambia_stato(const long codcli, const long codind, const char ritoant) { //recupero dalla maschera i campi di interesse const TDate dadatabolla = _msk->get_date(F_DADTBOLLE); const TDate adatabolla = _msk->get_date(F_ADTBOLLE); const long daanno = dadatabolla.year(); const long aanno = adatabolla.year(); //per ogni paragrafo scritto in ditta.ini... //recupero numerazione, tipo documento e stato tramite la funzione apposita for (int i = 0; ; i++) { TString4 codnum; TString4 tpdoc; TString4 statoi; TString4 statof; bool err; //distinguo se sto scandendo i documenti di ritiro o i documenti di anticipo switch (ritoant) { case 'R': err = numerazione_drit(i, codnum, tpdoc, statoi, statof); break; case 'A': err = numerazione_dant(i, codnum, tpdoc, statoi, statof); break; default: break; } //se non trovo la numerazione richiesta, interrompo il ciclo if (!err) break; //instanzio un recordset che contiene tutti i documenti di interesse TISAM_recordset docritiri ("USE DOC KEY 2 SELECT (STATO=#STATO)&&(TIPODOC=#TIPODOC)&&(CODINDSP=#CODINDSP)\nFROM TIPOCF=#TIPOCF CODCF=#CODCF PROVV=#PROVV ANNO=#DAANNO DATADOC=#DADATABOLLA CODNUM=#CODNUM\nTO TIPOCF=#TIPOCF CODCF=#CODCF PROVV=#PROVV ANNO=#AANNO DATADOC=#ADATABOLLA CODNUM=#CODNUM"); docritiri.set_var("#STATO",TVariant(statof)); //lo stato va preso dallo sheet docritiri.set_var("#TIPODOC",TVariant(tpdoc)); docritiri.set_var("#CODINDSP",codind); docritiri.set_var("#TIPOCF","C"); docritiri.set_var("#CODCF",codcli); docritiri.set_var("#PROVV","D"); docritiri.set_var("#DAANNO",daanno); docritiri.set_var("#DADATABOLLA",dadatabolla); docritiri.set_var("#CODNUM",TVariant(codnum)); docritiri.set_var("#AANNO",aanno); docritiri.set_var("#ADATABOLLA",adatabolla); //per ogni documento che trovo, cambio stato al documento for (bool ok = docritiri.move_first(); ok; ok = docritiri.move_next()) { TDocumento doc(docritiri.cursor()->curr()); //instanzio il documento doc.put(DOC_STATO,statoi); //stato iniziale } } return; } //ELIMINA_BOLLE: questa funzione cerca tutte le bolle di consegna relative a un certo cliente ancora... //nello stato iniziale in un certo intervallo di date e le elimina void TGenera_documenti_app::elimina_bolle(const long codcli, const long codind) { //recupero dalla maschera i campi di interesse const TDate dadatabolla = _msk->get_date(F_DADTBOLLE); const TDate adatabolla = _msk->get_date(F_ADTBOLLE); const long daanno = dadatabolla.year(); const long aanno = adatabolla.year(); //recupero numerazione, tipo documento e stato tramite la funzione apposita TString4 codnum; TString4 tpdoc; TString4 statoi; TString4 statof; //se non trovo la numerazione richiesta, interrompo la funzione if (!numerazione_ddt(codnum, tpdoc, statoi, statof)) return; //instanzio un recordset che contiene tutti i documenti di interesse TISAM_recordset docritiri ("USE DOC KEY 2 SELECT (STATO=#STATO)&&(TIPODOC=#TIPODOC)&&(CODINDSP=#CODINDSP)\nFROM TIPOCF=#TIPOCF CODCF=#CODCF PROVV=#PROVV ANNO=#DAANNO DATADOC=#DADATABOLLA CODNUM=#CODNUM\nTO TIPOCF=#TIPOCF CODCF=#CODCF PROVV=#PROVV ANNO=#AANNO DATADOC=#ADATABOLLA CODNUM=#CODNUM"); docritiri.set_var("#STATO",TVariant(statof)); docritiri.set_var("#TIPODOC",TVariant(tpdoc)); docritiri.set_var("#CODINDSP",codind); docritiri.set_var("#TIPOCF","C"); docritiri.set_var("#CODCF",codcli); docritiri.set_var("#PROVV","D"); docritiri.set_var("#DAANNO",daanno); docritiri.set_var("#DADATABOLLA",dadatabolla); docritiri.set_var("#CODNUM",TVariant(codnum)); docritiri.set_var("#AANNO",aanno); docritiri.set_var("#ADATABOLLA",adatabolla); //per ogni documento che trovo, aggiorno la quantità e gli cambio stato for (bool ok = docritiri.move_first(); ok; ok = docritiri.move_next()) { TDocumento doc(docritiri.cursor()->curr()); //instanzio il documento doc.remove(); //stato di bloccato } return; } ////////////////////////////////////////////////////////////// //// Metodi per la scansione dei documenti //// ////////////////////////////////////////////////////////////// //SCANSIONE_RITIRI_ANTICIPI: questa funzione cerca tutte le bolle di ritiro relative a un certo cliente non ancora evase... //in un certo intervallo di date, e, dopo l'elaborazione, gli cambia stato void TGenera_documenti_app::scansione_ritiri_anticipi(const long codcli, const long codind, const char ritoant) { //recupero dalla maschera i campi di interesse const TDate dadatabolla = _msk->get_date(F_DADTBOLLE); const TDate adatabolla = _msk->get_date(F_ADTBOLLE); const long daanno = dadatabolla.year(); const long aanno = adatabolla.year(); //per ogni paragrafo scritto in ditta.ini... //recupero numerazione, tipo documento e stato tramite la funzione apposita for (int i = 0; ; i++) { TString4 codnum; TString4 tpdoc; TString4 statoi; TString4 statof; bool err; //distinguo se sto scandendo i documenti di ritiro o i documenti di anticipo switch (ritoant) { case 'R': err = numerazione_drit(i, codnum, tpdoc, statoi, statof); break; case 'A': err = numerazione_dant(i, codnum, tpdoc, statoi, statof); break; default: break; } //se non trovo la numerazione richiesta, interrompo il ciclo if (!err) break; //instanzio un recordset che contiene tutti i documenti di interesse TISAM_recordset docritiri ("USE DOC KEY 2 SELECT (STATO!=#STATO)&&(TIPODOC=#TIPODOC)&&(CODINDSP=#CODINDSP)\nFROM TIPOCF=#TIPOCF CODCF=#CODCF PROVV=#PROVV ANNO=#DAANNO DATADOC=#DADATABOLLA CODNUM=#CODNUM\nTO TIPOCF=#TIPOCF CODCF=#CODCF PROVV=#PROVV ANNO=#AANNO DATADOC=#ADATABOLLA CODNUM=#CODNUM"); docritiri.set_var("#STATO",TVariant(statof)); //lo stato va preso dallo sheet docritiri.set_var("#TIPODOC",TVariant(tpdoc)); docritiri.set_var("#CODINDSP",codind); docritiri.set_var("#TIPOCF","C"); docritiri.set_var("#CODCF",codcli); docritiri.set_var("#PROVV","D"); docritiri.set_var("#DAANNO",daanno); docritiri.set_var("#DADATABOLLA",dadatabolla); docritiri.set_var("#CODNUM",TVariant(codnum)); docritiri.set_var("#AANNO",aanno); docritiri.set_var("#ADATABOLLA",adatabolla); //per ogni documento che trovo, aggiorno la quantità, e poi cambio stato al documento for (bool ok = docritiri.move_first(); ok; ok = docritiri.move_next()) { TDocumento doc(docritiri.cursor()->curr()); //instanzio il documento calcolo_quantita(doc,ritoant); doc.put(DOC_STATO,statof); //stato di elaborato, preso dallo sheet } } return; } //SCANSIONE_CONSEGNE: questa funzione cerca tutte le bolle di consegna relative a un certo cliente ancora... //nello stato iniziale in un certo intervallo di date void TGenera_documenti_app::scansione_consegne(const long codcli, const long codind) { //recupero dalla maschera i campi di interesse const TDate dadatabolla = _msk->get_date(F_DADTBOLLE); const TDate adatabolla = _msk->get_date(F_ADTBOLLE); const long daanno = dadatabolla.year(); const long aanno = adatabolla.year(); //recupero numerazione, tipo documento e stato tramite la funzione apposita TString4 codnum; TString4 tpdoc; TString4 statoi; TString4 statof; //se non trovo la numerazione richiesta, interrompo la funzione if (!numerazione_ddt(codnum, tpdoc, statoi, statof)) return; //instanzio un recordset che contiene tutti i documenti di interesse TISAM_recordset docritiri ("USE DOC KEY 2 SELECT (STATO!=#STATO)&&(TIPODOC=#TIPODOC)&&(CODINDSP=#CODINDSP)\nFROM TIPOCF=#TIPOCF CODCF=#CODCF PROVV=#PROVV ANNO=#DAANNO DATADOC=#DADATABOLLA CODNUM=#CODNUM\nTO TIPOCF=#TIPOCF CODCF=#CODCF PROVV=#PROVV ANNO=#AANNO DATADOC=#ADATABOLLA CODNUM=#CODNUM"); docritiri.set_var("#STATO",TVariant(statof)); docritiri.set_var("#TIPODOC",TVariant(tpdoc)); docritiri.set_var("#CODINDSP",codind); docritiri.set_var("#TIPOCF","C"); docritiri.set_var("#CODCF",codcli); docritiri.set_var("#PROVV","D"); docritiri.set_var("#DAANNO",daanno); docritiri.set_var("#DADATABOLLA",dadatabolla); docritiri.set_var("#CODNUM",TVariant(codnum)); docritiri.set_var("#AANNO",aanno); docritiri.set_var("#ADATABOLLA",adatabolla); //per ogni documento che trovo, aggiorno la quantità e gli cambio stato for (bool ok = docritiri.move_first(); ok; ok = docritiri.move_next()) { TDocumento doc(docritiri.cursor()->curr()); //instanzio il documento calcolo_quantita(doc,'B'); doc.put(DOC_STATO,statof); //stato di bloccato } return; } ////////////////////////////////////////////////////////////// //// Metodo per il calcolo delle quantità in bolla //// ////////////////////////////////////////////////////////////// //CALCOLO_QUANTITA: questa funzione scorre tutte le righe documento di una bolla di ritiro, riempiendo un... //TAssoc_array con le quantità ritirate per ogni articolo, sommando le diverse righe con lo stesso articolo... //Questa funzione viene richiamata per ogni documento valido individuato dalla SCANSIONE_RITIRI void TGenera_documenti_app::calcolo_quantita(const TDocumento& doc, const char ritoant) { //scorro le righe documento for (long i = 1; i <= doc.rows(); i++) { //instanzio la riga corrente const TRiga_documento& rdoc = doc[i]; //estraggo i dati di interesse const TString80 codart = rdoc.get(RDOC_CODARTMAG); const real qtardoc = rdoc.get_real(RDOC_QTA); //se è una riga che riguarda un articolo e se la quantità su questa riga non è nulla, allora la elaboro if (codart.full() && !qtardoc.is_zero()) { TArticolo& art = rdoc.articolo(); //leggo se esiste già nel TAssoc_array real *qta = (real*)_quantita.objptr(codart); real *qta1 = (real*)_quantita_ritirata.objptr(codart); //se non esiste if (qta == NULL) { //per ora memorizzo zero qta = new real; _quantita.add(codart,qta); } if (qta1 == NULL) { //per ora memorizzo zero qta1 = new real; _quantita_ritirata.add(codart,qta1); } //aggiorno la quantità convertendola all'unità di misura di base, aggiungendola o sottraendola //...se si tratta di un ritiro o di un anticipo rispettivamente; nel caso della scansione delle //...bolle di consegna modificate a mano (caso 'B'), devo modificare la quantità da consegnare //...tenendo conto delle modifiche manuali switch (ritoant) { case 'R': *qta += art.convert_to_um(qtardoc, NULL, rdoc.get(RDOC_UMQTA)); *qta1 += art.convert_to_um(qtardoc, NULL, rdoc.get(RDOC_UMQTA)); break; case 'A': *qta -= art.convert_to_um(qtardoc, NULL, rdoc.get(RDOC_UMQTA)); break; case 'B': { const real qtagg3 = rdoc.get_real(RDOC_QTAGG3); real modifica = qtardoc - qtagg3; *qta -= art.convert_to_um(modifica, NULL, rdoc.get(RDOC_UMQTA)); } break; default: break; } } } return; } ////////////////////////////////////////////////////////////// //// Metodi aggiornare il conguaglio sui contratti //// ////////////////////////////////////////////////////////////// //AGGIORNA_CONGUAGLIO: questa funzione aggiorna il parametro conguaglio sulla riga del contratto void TGenera_documenti_app::aggiorna_conguaglio(const long codcli, const long codcont, const TString& codart, const real arr) const { TLocalisamfile rcondv(LF_LVRCONDV); rcondv.put(LVRCONDV_CODCF,codcli); rcondv.put(LVRCONDV_CODCONT,codcont); rcondv.put(LVRCONDV_CODART,codart); if (rcondv.read() == NOERR) { rcondv.put(LVRCONDV_QTACONG,arr); rcondv.rewrite(); } } //////////////////////////////// //// Metodi Pubblic //// //////////////////////////////// bool TGenera_documenti_app::transfer() { //leggo i campi dalla maschera const TDate datacons = _msk->get_date(F_DTCONS); const long coditi = _msk->get_long(F_CODITI); long codcli = _msk->get_long(F_CODCF); //preparo un recordset che contiene tutti planning per cui voglio creare i documenti relativi TString query = "USE LVRCONSPLAN KEY 2"; if (coditi || codcli) { query << " SELECT "; if (codcli > 0) query << "(CODCF=" << codcli << ')'; if (coditi > 0) { if (codcli > 0) query << "&&"; query << "(CODITI=" << coditi << ')'; } } query << "\n"; query << "FROM DTCONS=" << datacons << "\n"; query << "TO DTCONS=" << datacons << "\n"; TISAM_recordset plan(query); TProgind pi(plan.items(), TR("Generazione documenti in corso..."), true, true); for (bool ok = plan.move_first(); ok; ok = plan.move_next()) { if (!pi.addstatus(1)) break; crea_documento(plan); } return true; } void TGenera_documenti_app::main_loop() { while (_msk->run() == K_ENTER) transfer(); } int lv2400(int argc, char* argv[]) { TGenera_documenti_app app; app.run(argc, argv, TR("Generazione documenti")); return 0; }