From 67efe69bfc27edb018027775022a27207ff26524 Mon Sep 17 00:00:00 2001 From: angelo Date: Thu, 18 Dec 1997 17:34:10 +0000 Subject: [PATCH] Corretto programma di apertura/chiusura. Effettua la scrittura dei movimenti in modo un poco piu' coerente ed efficiente. git-svn-id: svn://10.65.10.50/trunk@5770 c028cbd2-c16b-5b4b-a496-9718f37d4682 --- mg/mg1400.cpp | 511 ++++++++++++++++++++++++++++---------------------- mg/mg1400.h | 3 +- mg/mg1400.uml | 70 +++++-- 3 files changed, 338 insertions(+), 246 deletions(-) diff --git a/mg/mg1400.cpp b/mg/mg1400.cpp index fb25c6050..1b21b786c 100755 --- a/mg/mg1400.cpp +++ b/mg/mg1400.cpp @@ -19,35 +19,30 @@ enum action definitiva }; -enum method -{ - costomedio, - ultimocosto, - mediacosti, - prezzolistino, - prezzostd, - lifoannuale, - fifoannuale, - liforagionieristico, - fiforagionieristico -}; +class TApp_openclose; class TMask_openclose: public TMask { + bool ordaut; TEsercizi_contabili esercizi; static bool handle_close(TMask_field &, KEY); static bool handle_open(TMask_field &, KEY); + static bool handle_what(TMask_field &, KEY); public: TEsercizi_contabili& exercise() { return (TEsercizi_contabili&) esercizi; } - TMask_openclose(); + TMask_openclose(const bool ord) ; virtual ~TMask_openclose() {} }; -TMask_openclose::TMask_openclose() +TMask_openclose::TMask_openclose(const bool ord) : TMask("mg1400") { + ordaut = ord; + if (ordaut) + disable(-1); set_handler(F_DATECLOSE, handle_close); set_handler(F_DATEOPEN, handle_open); + set_handler(F_WHAT, handle_what); } bool TMask_openclose::handle_close(TMask_field &fld, KEY k) @@ -59,6 +54,7 @@ bool TMask_openclose::handle_close(TMask_field &fld, KEY k) TDate d(fld.get()); const int es_close = ex.date2esc(d); + mask.set(F_ESTOCLOSE, es_close); if (es_close == 0) return fld.error_box("La data indicata non appartiene a nessun esercizio."); @@ -71,7 +67,6 @@ bool TMask_openclose::handle_close(TMask_field &fld, KEY k) if (k == K_ENTER && pred != 0 && ex.esercizio(pred).chiusura_mag() == TDate(NULLDATE)) return fld.error_box("L'esercizio precedente a quello indicato non e' ancora stato chiuso."); } - mask.set(F_ESTOCLOSE, es_close); } return TRUE; } @@ -84,12 +79,12 @@ bool TMask_openclose::handle_open(TMask_field &fld, KEY k) TDate in(mask.get(F_DATEOPEN)); TDate fi(mask.get(F_DATECLOSE)); if (k == K_ENTER && in <= fi ) - return fld.warning_box ("La data di inizio del nuovo esercizio deve essere superiore alla data di fine esercizio precedente"); + return fld.warning_box ("La data di apertura del nuovo esercizio deve essere superiore alla data di chiusura dell'esercizio precedente"); const int es_open = mask.esercizi.date2esc(in); + mask.set(F_ESTOOPEN, es_open); if (es_open == 0) return fld.error_box("La data indicata non appartiene a nessun esercizio"); - mask.set(F_ESTOOPEN, es_open); const int es_close = mask.esercizi.pred(es_open); if (es_close == 0) @@ -102,9 +97,36 @@ bool TMask_openclose::handle_open(TMask_field &fld, KEY k) return TRUE; } +bool TMask_openclose::handle_what(TMask_field &fld, KEY k) +{ + if (k == K_SPACE) + { + TMask_openclose& mask = (TMask_openclose&)fld.mask(); + const int x = atoi(fld.get()); + const action w = (action) x; + mask.enable(-4, w == definitiva); // Se oper. provv. disabilita tutte le causali + // Le causali degli ordini sono abilitate solo se NON c'e' il modulo ordini + if (mask.ordaut) + mask.disable(-1); + } + return TRUE; +} + +// Corrispondenza elementi di _movimenti: +/* elemento 0 : movimento con causale di rimanenze iniziali + elemento 1 : " " " In conto lav. + elemento 2 : " " " A conto lav. + elemento 3 : " " " In prod. fin. + elemento 4 : " " " In prod. comp. + elemento 5 : " " " Ordinato fornitori + elemento 6 : " " " Ordinato clienti + elemento 7 e successivi: tutte le righe in eccesso a MAX_ROWS +*/ + class TApp_openclose : public TSkeleton_application { TLocalisamfile *_anamag, + *_umart, *_mag, *_movmag, *_rmovmag, @@ -114,34 +136,36 @@ class TApp_openclose : public TSkeleton_application TString_array _causali; // Array delle causali per i movimenti d'apertura (7) TString _es_to_close; TString _es_to_open; + TString _catven; + TString _codlis; TDate _date_to_close; TDate _date_to_open; action _what; - method _calctype; + TTipo_valorizz _calctype, _stotype; // Stotype sta per sto-cazzo protected: virtual bool create(); virtual bool destroy(); virtual void main_loop(); - void scrivi_movimenti(); + //void scrivi_movimenti(TCursor&); + //void aggiorna_saldi(); + void compila_movimento(TMov_mag& currmov, TArticolo_giacenza& art, TRectype& rec, const int caus); void chiudi_esercizio(); public: - TApp_openclose(action w) { _what = w; }; + TApp_openclose() {}; virtual ~TApp_openclose() {}; }; bool TApp_openclose::create() { - _msk = new TMask_openclose; - _msk->set_caption(_what == definitiva ? "Chiusura definitiva esercizio" : "Chiusura provvisoria esercizio"); - if (has_module(ORAUT)) - _msk->disable(-1); // Se il modulo ordini e' abilitato disabilita l'inserimento delle rispettive causali d'apertura + _msk = new TMask_openclose(has_module(ORAUT)); _anamag = new TLocalisamfile(LF_ANAMAG); + _umart = new TLocalisamfile(LF_UMART); _mag = new TLocalisamfile(LF_MAG); _movmag = new TLocalisamfile(LF_MOVMAG); _rmovmag = new TLocalisamfile(LF_RMOVMAG); - _stomag = new TLocalisamfile(LF_RMOVMAG); + _stomag = new TLocalisamfile(LF_STOMAG); return TSkeleton_application::create(); } @@ -149,6 +173,7 @@ bool TApp_openclose::destroy() { delete _msk; delete _anamag; + delete _umart; delete _mag; delete _movmag; delete _rmovmag; @@ -156,215 +181,242 @@ bool TApp_openclose::destroy() return TSkeleton_application::destroy(); } -void TApp_openclose::scrivi_movimenti() +void TApp_openclose::compila_movimento(TMov_mag& currmov, TArticolo_giacenza& art, TRectype& rec, const int caus) { - // Scorre i saldi del vecchio esercizio, compilando un array di almeno 7 TMov_mag - // Almeno 7 perche' fissiamo il limite di righe per movimento a 500 - TRelation saldi_rel(_mag); - TRectype rec_from(LF_MAG), rec_to(LF_MAG); - rec_from.put(MAG_ANNOES, _es_to_close); - rec_to = rec_from; - TCursor saldi_cur(&saldi_rel,"",2,&rec_from,&rec_to); - - // Repersice l'ultimo movimento di magazzino per il numero di registrazione - _movmag->last(); - long numreg = _movmag->get_long(MOVMAG_NUMREG) +1; - - // La chiave 1 dei saldi di magazzino e' anno esercizio+codice articolo+numero riga - // Mi chiedo : che ci faccio col numero riga? Raggruppo o creo un'altra riga per quel - // movimento? - // Corrispondenza elementi: - /* elemento 0 : movimento con causale di rimanenze iniziali - elemento 1 : " " " In conto lav. - elemento 2 : " " " A conto lav. - elemento 3 : " " " In prod. fin. - elemento 4 : " " " In prod. comp. - elemento 5 : " " " Ordinato fornitori - elemento 6 : " " " Ordinato clienti - */ - real val,qta,prezzo; - TString descrizione, codmag, codart, livello, catven, codlis; - // Richiede in input catven, codlist... per valorizzazione prezzo di listino - descrizione.format("Apertura esercizio %s", (const char*)_es_to_open); - // Indici per i movimenti. Crea i movimenti di base (uno per ogni causale) - int indici[7]; - int last = 6; - for (int j=0; j < 7; j++) + // Aggiorna la testata se il movimento e' nuovo (non ha righe) + if (currmov.rows() == 0) { - _movimenti.add(new TMov_mag); - indici[j] = j; - } + TRectype& head = currmov.head(); + head.put(MOVMAG_ANNOES, _es_to_open); + head.put(MOVMAG_DATAREG, _date_to_open); + head.put(MOVMAG_DATACOMP, _date_to_open); + head.put(MOVMAG_CODCAUS, _causali.row(caus)); + } - TLocalisamfile& saldi = saldi_cur.file(); - const long saldi_items = saldi_cur.items(); - TProgind *prog; - prog = new TProgind(saldi_items, descrizione,FALSE,TRUE,10); - for (saldi_cur = 0L; saldi_cur.ok(); saldi_cur +=1) + // Aggiunge una nuova riga al movimento corrente + TString codmag(rec.get(MAG_CODMAG)); + TString codart(rec.get(MAG_CODART)); + TString livello(rec.get(MAG_LIVELLO)); + + real qta, prezzo, val; + // switch sul tipo di causale per settare quantita' e prezzo: + switch (caus) { - prog->addstatus(1L); - codmag = saldi.get(MAG_CODMAG); - codart = saldi.get(MAG_CODART); - livello= saldi.get(MAG_LIVELLO); - // Ciclo per i tipi di movimento - for (int i=0; i<7; i++) - { - if (_causali.row(i).empty()) - continue; // Salta eventuali causali vuote - // se il numero di righe di questo movimento eccede le 500 ne crea uno nuovo e - // setta il nuovo indice - const int rows = ((TMov_mag&) _movimenti[indici[i]]).rows() ; - if (rows > MAX_ROWS) + case 0: // Rimanenze iniziali { - _movimenti.add(new TMov_mag); - last++; - indici[i] = last; + qta = rec.get_real(MAG_GIAC) + rec.get_real(MAG_PRODFIN)-rec.get_real(MAG_PRODCOMP) + + rec.get_real(MAG_ACL) - rec.get_real(MAG_INCL); // ??corretta da AcL, IncL e InProdF ?? + switch (_calctype) + { + case valorizz_costmedio: + val = art.costo_medio(_es_to_close, codmag, livello); + break; + case valorizz_ultcos: + val = art.ultimo_costo(_es_to_close); + break; + case valorizz_mediacos: + val = art.media_costi(_es_to_close); + break; + case valorizz_przlist: + val = art.prezzo_listino(_es_to_close, _catven, _codlis); + break; + case valorizz_coststd: + val = art.costo_standard(_es_to_close); + break; + case valorizz_LIFOa: + val = art.LIFO_annuale(_es_to_close, codmag, livello); + break; + case valorizz_FIFOa: + val = art.FIFO_annuale(_es_to_close, codmag, livello); + break; + case valorizz_LIFO: + val = art.LIFO(_es_to_close, codmag, livello); + break; + case valorizz_FIFO: + val = art.FIFO(_es_to_close, codmag, livello); + break; + case valorizz_LIFOr: + val = art.LIFO_ragionieristico(_es_to_close, codmag, livello); + break; + case valorizz_FIFOr: + val = art.FIFO_ragionieristico(_es_to_close, codmag, livello); + break; + default: + break; + } + prezzo = val/qta; } - TMov_mag& currmov = (TMov_mag&) _movimenti[indici[i]]; - // Se il movimento non ha righe, compila la testata - if (currmov.rows() == 0) - { - TRectype& head = currmov.head(); - head.put(MOVMAG_NUMREG, numreg); - head.put(MOVMAG_ANNOES, _es_to_open); - head.put(MOVMAG_DATAREG, _date_to_open); - head.put(MOVMAG_DATACOMP, _date_to_open); - head.put(MOVMAG_CODCAUS, _causali.row(i)); - head.put(MOVMAG_DESCR, descrizione); - } - // Aggiunge una nuova riga al movimento corrente - TRectype& riga = currmov.new_row(); - riga.put(RMOVMAG_NUMREG, numreg); - riga.put(RMOVMAG_CODMAG, codmag); - riga.put(RMOVMAG_CODART, codart); - riga.put(RMOVMAG_LIVGIAC, livello); - riga.put(RMOVMAG_CODCAUS, _causali.row(i)); - qta = 0.0; - prezzo = 0.0; - // switch sul tipo per settare quantita' e prezzo: - switch (i) - { - case 0: // Rimanenze iniziali - { - qta = saldi.get_real(MAG_GIAC)+ saldi.get_real(MAG_PRODFIN)-saldi.get_real(MAG_PRODCOMP) - + saldi.get_real(MAG_ACL) - saldi.get_real(MAG_INCL); // ??corretta da AcL, IncL e InProdF ?? - TArticolo_giacenza artgiac(codart); - switch (_calctype) - { - case costomedio: - val = artgiac.costo_medio(_es_to_close, codmag, livello); - break; - case ultimocosto: - val = artgiac.ultimo_costo(_es_to_close); - break; - case mediacosti: - val = artgiac.media_costi(_es_to_close); - break; - case prezzolistino: - val = artgiac.prezzo_listino(_es_to_close, catven, codlis); - break; - case prezzostd: - val = artgiac.costo_standard(_es_to_close); - break; - case lifoannuale: - val = artgiac.LIFO_annuale(_es_to_close, codmag, livello); - break; - case fifoannuale: - val = artgiac.FIFO_annuale(_es_to_close, codmag, livello); - break; - case liforagionieristico: - val = artgiac.LIFO_ragionieristico(_es_to_close, codmag, livello); - break; - case fiforagionieristico: - val = artgiac.FIFO_ragionieristico(_es_to_close, codmag, livello); - break; - default: - break; - } - prezzo = val/qta; - } - break; - case 1: // In conto lav. - qta = saldi.get_real(MAG_INCL); - break; - case 2: // A conto lav. - qta = saldi.get_real(MAG_ACL); - break; - case 3: // In prod. fin. - qta = saldi.get_real(MAG_PRODFIN); - break; - case 4: // In prod. com. - qta = saldi.get_real(MAG_PRODCOMP); - break; - case 5: // Ord. forn. - qta = saldi.get_real(MAG_ORDF); - val = saldi.get_real(MAG_VALORDF); - prezzo = val/qta; - break; - case 6: // Ord. cli. - qta = saldi.get_real(MAG_ORDC); - val = saldi.get_real(MAG_VALORDC); - prezzo = val/qta; - break; - default: - break; - } - riga.put(RMOVMAG_QUANT, qta); - riga.put(RMOVMAG_PREZZO, prezzo); - } + break; + case 1: // In conto lav. + qta = rec.get_real(MAG_INCL); + break; + case 2: // A conto lav. + qta = rec.get_real(MAG_ACL); + break; + case 3: // In prod. fin. + qta = rec.get_real(MAG_PRODFIN); + break; + case 4: // In prod. com. + qta = rec.get_real(MAG_PRODCOMP); + break; + case 5: // Ord. forn. + qta = rec.get_real(MAG_ORDF); + val = rec.get_real(MAG_VALORDF); + prezzo = val/qta; + break; + case 6: // Ord. cli. + qta = rec.get_real(MAG_ORDC); + val = rec.get_real(MAG_VALORDC); + prezzo = val/qta; + break; + default: + break; } - delete prog; - - // Scorre i movimenti generati ed effettua la scrittura - const int items = _movimenti.items(); - int err = NOERR; - prog = new TProgind(items, "Scrittura movimenti in corso...",FALSE,TRUE,10); - for (int i=0; err == NOERR && iaddstatus(1L); - TMov_mag& mov = (TMov_mag&) _movimenti[i]; - if (mov.rows() == 0) - continue; // Salta eventuali movimenti senza righe (OrdC e OrdF) - // Effettua la rinumerazione del movimento se esso esiste gia'? - err = mov.write(*_movmag); + TRectype& riga = currmov.new_row(); + TRecord_array& ums = art.um(); + const int r = ums.first_row(); + if (r > 0) + riga.put(RMOVMAG_UM, (ums[r]).get(UMART_UM)); + riga.put(RMOVMAG_CODMAG, codmag); + riga.put(RMOVMAG_CODART, codart); + riga.put(RMOVMAG_LIVGIAC, livello); + // La causale di riga va messa solo se e' diversa da quella di testata! + riga.put(RMOVMAG_QUANT, qta); + riga.put(RMOVMAG_PREZZO, prezzo); } - delete prog; - - if (err != NOERR) - error_box("Errore %d durante la scrittura dei movimenti.",err); - _movimenti.destroy(); } // Chiude l'esercizio selezionato (in base al flag lo fa provvisoriamente o definitivamente) // L'unica differenza sta nella creazione dei movimenti d'apertura nel caso di chiusura definitiva void TApp_openclose::chiudi_esercizio() { - TEsercizi_contabili& esercizi = _msk->exercise(); - TTable esc("ESC"); + TArticolo_giacenza artgiac; + TRelation rel(LF_ANAMAG); + TCursor cur(&rel); + TString descr1, descr2; int err = NOERR; + TTable esc("ESC"); + + rel.lfile().set_curr((TRectype*)&artgiac); + const long items = cur.items(); + + rebuild_balances(_es_to_close); // Cosi' ci assicuriamo che i saldi dell'esercizio vecchio siano a posto + descr1.format(_what == definitiva ? "Apertura esercizio %s" : "Aggiornamento saldi esercizio %s", (const char*) _es_to_open); + descr2 << descr1 << " in corso..."; + + TProgind *prog = new TProgind(items, descr2, FALSE, TRUE, 10); + + // cose specifiche per chiusura definitiva... + // Reperisce l'ultimo movimento di magazzino per il numero di registrazione + _movmag->last(); + long numreg = _movmag->get_long(MOVMAG_NUMREG) +1; + // Indici per i movimenti. Crea i movimenti di base (uno per ogni causale) + int indici[7], last = 6; + if (_what == definitiva) + for (int j=0; j < 7; j++) + { + _movimenti.add(new TMov_mag); + TRectype& h = ((TMov_mag&) _movimenti[j]).head(); + h.put(MOVMAG_NUMREG, numreg++); + h.put(MOVMAG_DESCR, descr1); + indici[j] = j; + } + + // Ciclo per i fottuti articoli + for (cur = 0L; cur.ok(); cur +=1) + { + if (_what == definitiva) + { + // Scorre i saldi del vecchio esercizio per questo TArticolo_giacenza + // compilando un array di almeno 7 TMov_mag + // Almeno 7 perche' 7 sono le causali; fissiamo il limite di righe per movimento a 500 (MAXROWS) + // quindi i movimenti possono essere di piu'. + + // I saldi per questo articolo + TArticolo_giacenza& art = (TArticolo_giacenza&)cur.curr(); + TRecord_array& rec_arr = art.mag(_es_to_close); + // Scorriamo le righe... + const int lastrow = rec_arr.last_row(); + for (int r = lastrow; r > 0; r = rec_arr.pred_row(r)) + { + TRectype& rec = rec_arr[r]; + for (int i = 0; i < 7; i++) + { + if (_causali.row(i).empty()) + continue; // Salta eventuali causali vuote + // se il numero di righe di questo movimento eccede le 500 ne crea uno nuovo e + // setta il nuovo indice + const int rows = ((TMov_mag&) _movimenti[indici[i]]).rows() ; + if (rows > MAX_ROWS) + { + _movimenti.add(new TMov_mag); + last++; + indici[i] = last; + TRectype& h = ((TMov_mag&) _movimenti[last]).head(); + h.put(MOVMAG_NUMREG, numreg++); // Aggiorna il nr. reg per il prossimo movimento + h.put(MOVMAG_DESCR, descr1); + } + TMov_mag& currmov = (TMov_mag&) _movimenti[indici[i]]; + compila_movimento(currmov, art, rec, i); + } + } + } + else + { + // calcola il valore delle rimanenze finali dell'esercizio vecchio + // e riporta il record con l'anno esercizio nuovo. + ((TArticolo_giacenza&)cur.curr()).riporta_saldi(_es_to_close, _es_to_open, _calctype, _catven, _codlis); + } + // Aggiornamento storico.... + prog->addstatus(1L); + } + delete prog; + + // Vi sarebbe l'azzeramento saldi dell'esercizio nuovo, (in caso di chiusura definitiva) + // ma e' gia' fatta alla fine perche' dopo la ricostruzione movimenti l'esercizio vecchio + // e' marcato come chiuso. + + if (_what == definitiva) + { + // Scorre i movimenti generati ed effettua la scrittura + const int items = _movimenti.items(); + prog = new TProgind(items, "Scrittura movimenti in corso...",FALSE,TRUE,10); + for (int i=0; err == NOERR && iaddstatus(1L); + TMov_mag& mov = (TMov_mag&) _movimenti[i]; + if (mov.rows() == 0) + continue; // Salta eventuali movimenti senza righe (OrdC e OrdF) + // Effettua la rinumerazione del movimento se esso esiste gia'? + err = mov.write(*_movmag); + } + delete prog; + + if (err == NOERR) + { + // Marca l'esercizio come chiuso + esc.put("CODTAB", _es_to_close); + err = esc.read(); + if (err == NOERR) + { + esc.put("D4", _date_to_close); + err = esc.rewrite(); + if (err != NOERR) + error_box("Errore %d in fase di chiusura esercizio %s.", err, (const char*) _es_to_close); + } + else + error_box("Error %d in fase di lettura esercizio %s.", err, (const char*) _es_to_close); + } + else + error_box("Errore %d durante la scrittura dei movimenti.",err); + _movimenti.destroy(); + } // La ricostruzione dei saldi e' comune in entrambi i casi (definitiva o provvisoria) // la rebuild_balances() deve sapere da sola se azzerare o meno le giacenze // a seconda che l'esercizio precedente sia chiuso (AZZERA) o no (NON AZZERARE). - // Pertanto il flag NON dovra' piu' essere passato - - // Valorizza e scrive sullo storico di magazzino in base al metodo scelto - - if (definitiva) - { - // Vi sarebbe l'azzeramento saldi dell'esercizio nuovo, ma e' gia' fatta alla fine - // perche' dopo la ricostruzione movimenti l'esercizio vecchio e' marcato come chiuso. - - // Scrive movimenti d'apertura - scrivi_movimenti(); - - // Marca l'esercizio come chiuso - esc.put("CODTAB", _es_to_close); - if (esc.read() == NOERR) - { - esc.put("D4", _date_to_close); - esc.rewrite(); - } - } rebuild_balances(_es_to_open); } @@ -375,24 +427,31 @@ void TApp_openclose::main_loop() TDate d(TODAY); TEsercizi_contabili& ex = _msk->exercise(); const int es_open = ex.date2esc(d); - _msk->set(F_DATEOPEN,ex.esercizio(es_open).inizio()); - _msk->set(F_ESTOOPEN,es_open); + if (es_open != 0) + { + _msk->set(F_DATEOPEN,ex.esercizio(es_open).inizio()); + _msk->set(F_ESTOOPEN,es_open); + } const int es_close = ex.pred(es_open); - _msk->set(F_DATECLOSE,ex.esercizio(es_close).fine()); - _msk->set(F_ESTOCLOSE,es_close); + if (es_close != 0) + { + _msk->set(F_DATECLOSE,ex.esercizio(es_close).fine()); + _msk->set(F_ESTOCLOSE,es_close); + } while (_msk->run() == K_ENTER) { // Here is _causali.destroy(); _date_to_close = _msk->get_date(F_DATECLOSE); - _date_to_close = _msk->get_date(F_DATEOPEN); + _date_to_open = _msk->get_date(F_DATEOPEN); _es_to_close = _msk->get(F_ESTOCLOSE); _es_to_open = _msk->get(F_ESTOOPEN); - _calctype = (method) _msk->get_int(F_VALORIZZAZIONE); - if (_calctype == fifoannuale || _calctype == lifoannuale) - if (_msk->get_int(F_METODO) == 2) - _calctype = _calctype == fifoannuale ? fiforagionieristico : liforagionieristico; + _calctype = (TTipo_valorizz) _msk->get_int(F_VALORIZZAZIONE); + _stotype = (TTipo_valorizz) _msk->get_int(F_STOMET); + _what = (action) _msk->get_int(F_WHAT); //Provvisoria o definitiva? + _codlis = _msk->get(F_LIST); + _catven = _msk->get(F_CATVEN); for (short xx = F_CAURIM; xx <= F_CAUORC; xx++) // legge le causali impostate _causali.add(_msk->get(xx)); chiudi_esercizio(); // Chiusura esercizio @@ -401,10 +460,8 @@ void TApp_openclose::main_loop() int mg1400(int argc, char* argv[]) { - const bool is_c = argc > 3 && *argv[2] == 'D'; - const char* msg = is_c ? "Chiusura definitiva esercizio" : "Chiusura provvisoria esercizio"; - TApp_openclose a(is_c ? definitiva : provvisoria); + TApp_openclose a; - a.run(argc, argv, msg); + a.run(argc, argv, "Apertura/Chiusura esercizio"); return 0; } diff --git a/mg/mg1400.h b/mg/mg1400.h index 2f9c4f8e5..52868b288 100755 --- a/mg/mg1400.h +++ b/mg/mg1400.h @@ -3,7 +3,7 @@ #define F_DATECLOSE 103 #define F_ESTOCLOSE 104 #define F_VALORIZZAZIONE 105 -#define F_METODO 106 +#define F_STOMET 106 #define F_CAURIM 107 #define F_CAUICL 108 #define F_CAUACL 109 @@ -13,4 +13,5 @@ #define F_CAUORC 113 #define F_CATVEN 114 #define F_LIST 115 +#define F_WHAT 116 diff --git a/mg/mg1400.uml b/mg/mg1400.uml index 75026dfda..e694dadf8 100755 --- a/mg/mg1400.uml +++ b/mg/mg1400.uml @@ -1,46 +1,68 @@ #include "mg1400.h" -PAGE "Chiusura esercizi" -1 -1 75 15 +PAGE "Chiusura/Apertura esercizio" -1 -1 75 15 + +RADIOBUTTON F_WHAT 20 +BEGIN + PROMPT 2 1 "Tipo" + ITEM "0|Provvisoria" + ITEM "1|Definitiva" +END DATE F_DATEOPEN BEGIN - PROMPT 2 2 "Data di apertura " + PROMPT 25 2 "Data di apertura " END NUMBER F_ESTOOPEN 4 BEGIN - PROMPT 38 2 "Esercizio " + PROMPT 58 2 "Esercizio " FLAGS "DRZ" END DATE F_DATECLOSE BEGIN - PROMPT 2 3 "Data di chiusura " + PROMPT 25 3 "Data di chiusura " END NUMBER F_ESTOCLOSE 4 BEGIN - PROMPT 38 3 "Esercizio " + PROMPT 58 3 "Esercizio " FLAGS "DRZ" END LISTBOX F_VALORIZZAZIONE 20 BEGIN PROMPT 2 5 "Valorizzazione " - ITEM "1|Al costo medio" MESSAGE HIDE,F_METODO|HIDE,2@ - ITEM "2|All'ultimo costo" MESSAGE HIDE,F_METODO|HIDE,2@ - ITEM "3|Alla media dei costi" MESSAGE HIDE,F_METODO|HIDE,2@ - ITEM "4|Al prezzo di listino" MESSAGE HIDE,F_METODO|SHOW,2@ - ITEM "5|Al costo standard" MESSAGE HIDE,F_METODO|HIDE,2@ - ITEM "6|Metodo L.I.F.O." MESSAGE SHOW,F_METODO|HIDE,2@ - ITEM "7|Metodo F.I.F.O." MESSAGE SHOW,F_METODO|HIDE,2@ + ITEM "0|Al costo medio" MESSAGE HIDE,2@|ENABLE,3@ + ITEM "1|All'ultimo costo" MESSAGE HIDE,2@|ENABLE,3@ + ITEM "2|Alla media dei costi" MESSAGE HIDE,2@|ENABLE,3@ + ITEM "3|Al prezzo di listino" MESSAGE SHOW,2@|ENABLE,3@ + ITEM "4|Al costo standard" MESSAGE HIDE,2@|ENABLE,3@ + ITEM "5|L.I.F.O. annuale" MESSAGE HIDE,2@|DISABLE,3@|COPY,F_STOMET + ITEM "6|F.I.F.O. annuale" MESSAGE HIDE,2@|DISABLE,3@|COPY,F_STOMET + ITEM "7|L.I.F.O. storico" MESSAGE HIDE,2@|DISABLE,3@|COPY,F_STOMET + ITEM "8|F.I.F.O. storico" MESSAGE HIDE,2@|DISABLE,3@|COPY,F_STOMET + /* + TBI LIFO/FIFO ragionieristico + ITEM "9|L.I.F.O. ragionieristico" MESSAGE HIDE,2@|DISABLE,3@|COPY,F_STOMET + ITEM "10|F.I.F.O. ragionieristico" MESSAGE HIDE,2@|DISABLE,3@|COPY,F_STOMET + */ END -RADIOBUTTON F_METODO 22 +LISTBOX F_STOMET 20 BEGIN - PROMPT 50 4 "Metodo" - ITEM "1|Annuale e storico" - ITEM "2|Ragionieristico" + PROMPT 2 6 "Storico " + ITEM "5|L.I.F.O. annuale" + ITEM "6|F.I.F.O. annuale" + ITEM "7|L.I.F.O. storico" + ITEM "8|F.I.F.O. storico" + /* + TBI LIFO/FIFO ragionieristico + ITEM "9|L.I.F.O. ragionieristico" + ITEM "10|F.I.F.O. ragionieristico" + */ + GROUP 3 END GROUPBOX DLG_NULL 22 4 @@ -89,80 +111,92 @@ END STRING F_CAURIM 6 BEGIN PROMPT 3 8 "Rimanenze iniziali " + FLAGS "U" USE %CAU SELECT (S2[23,23] == "+")&&(S2[1,1] == "+") INPUT CODTAB F_CAURIM DISPLAY "Codice" CODTAB DISPLAY "Descrizione@50" S0 OUTPUT F_CAURIM CODTAB CHECKTYPE REQUIRED + GROUP 4 END STRING F_CAUICL 6 BEGIN PROMPT 3 9 "In conto lavoraz. " + FLAGS "U" USE %CAU SELECT (S2[15,15] == "+")&&(S2[1,1] == "+") INPUT CODTAB F_CAUICL DISPLAY "Codice" CODTAB DISPLAY "Descrizione@50" S0 OUTPUT F_CAUICL CODTAB CHECKTYPE REQUIRED + GROUP 4 END STRING F_CAUACL 6 BEGIN PROMPT 43 9 "A conto lavoraz. " + FLAGS "U" USE %CAU SELECT (S2[17,17] == "+")&&(S2[1,1] == "-") INPUT CODTAB F_CAUACL DISPLAY "Codice" CODTAB DISPLAY "Descrizione@50" S0 OUTPUT F_CAUACL CODTAB CHECKTYPE REQUIRED + GROUP 4 END STRING F_CAUPRF 6 BEGIN PROMPT 3 10 "In prod. finiti " + FLAGS "U" USE %CAU SELECT (S2[21,21] == "+")&&(S2[1,1] == "-") INPUT CODTAB F_CAUPRF DISPLAY "Codice" CODTAB DISPLAY "Descrizione@50" S0 OUTPUT F_CAUPRF CODTAB CHECKTYPE REQUIRED + GROUP 4 END STRING F_CAUPRC 6 BEGIN PROMPT 43 10 "In prod. comp. " + FLAGS "U" USE %CAU SELECT (S2[19,19] == "+")&&(S2[1,1] == "+") INPUT CODTAB F_CAUPRC DISPLAY "Codice" CODTAB DISPLAY "Descrizione@50" S0 OUTPUT F_CAUPRC CODTAB CHECKTYPE REQUIRED + GROUP 4 END STRING F_CAUORF 6 BEGIN PROMPT 3 11 "Ordinato fornitori " + FLAGS "U" USE %CAU SELECT (S2[13,13] == "+") INPUT CODTAB F_CAUORF DISPLAY "Codice" CODTAB DISPLAY "Descrizione@50" S0 OUTPUT F_CAUORF CODTAB CHECKTYPE REQUIRED - GROUP 1 + GROUP 1 4 END STRING F_CAUORC 6 BEGIN PROMPT 43 11 "Ordinato clienti " + FLAGS "U" USE %CAU SELECT (S2[11,11] == "+") INPUT CODTAB F_CAUORC DISPLAY "Codice" CODTAB DISPLAY "Descrizione@50" S0 OUTPUT F_CAUORC CODTAB CHECKTYPE REQUIRED - GROUP 1 + GROUP 1 4 END BUTTON DLG_OK 10 2