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

Aggiunta Chiusura Apertura magazzino.

Browse Source 
git-svn-id: svn://10.65.10.50/trunk@5733 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
angelo 1997-12-15 09:21:43 +00:00
parent 0e4f20e083
commit eb2b598985
8 changed files with 619 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
mg/mg1.cpp
View File

@ -4,7 +4,7 @@
// Modulo di gestione movimenti
#include "mg1.h"
#define usage "Error - usage : %s -{0|1|2}"
#define usage "Error - usage : %s -{0|1|2|3 [A|C]}"
int main(int argc, char** argv)
{
@ -20,10 +20,11 @@ int main(int argc, char** argv)
case 2:
//rt = mg1300(argc,argv) ; break; // gestione movimenti DA DOCUMENTI
case 3:
//rt = mg1400(argc,argv) ; break; // gestione aperture/chiusure
rt = mg1400(argc,argv) ; break; // gestione aperture/chiusure
default:
error_box(usage, argv[0]) ; break;
}
exit(0);
return rt ;
}

1
mg/mg1.h
View File

@ -3,5 +3,6 @@
int mg1100(int argc, char* argv[]);
int mg1200(int argc, char* argv[]);
int mg1400(int argc, char* argv[]);
#endif // __MG1_H

2
mg/mg1200.cpp
View File

@ -104,7 +104,7 @@ void TApp_rebuildbalances::main_loop()
TMask_buildmov m;
while (m.run()==K_ENTER)
{
if (!rebuild_balances(m.get(F_ANNOES), TRUE))
if (!rebuild_balances(m.get(F_ANNOES)/*, TRUE*/))
error_box("Ricostruzione saldi incompleta o errata. Ripetere");
}
}

410
mg/mg1400.cpp Executable file
View File

@ -0,0 +1,410 @@
// mg1400.cpp : Chiusura/Apertura esercizi di magazzino
#include <applicat.h>
#include <mask.h>
#include <progind.h>
#include <tabutil.h>
#include <modaut.h>
#include <progind.h>
#include "mglib.h"
#include "..\cg\cglib01.h"
#include "mg1400.h"
#include "movmag.h"
#define MAX_ROWS 500
enum action
{
provvisoria,
definitiva
};
enum method
{
costomedio,
ultimocosto,
mediacosti,
prezzolistino,
prezzostd,
lifoannuale,
fifoannuale,
liforagionieristico,
fiforagionieristico
};
class TMask_openclose: public TMask
{
TEsercizi_contabili esercizi;
static bool handle_close(TMask_field &, KEY);
static bool handle_open(TMask_field &, KEY);
public:
TEsercizi_contabili& exercise() { return (TEsercizi_contabili&) esercizi; }
TMask_openclose();
virtual ~TMask_openclose() {}
};
TMask_openclose::TMask_openclose()
: TMask("mg1400")
{
set_handler(F_DATECLOSE, handle_close);
set_handler(F_DATEOPEN, handle_open);
}
bool TMask_openclose::handle_close(TMask_field &fld, KEY k)
{
TMask_openclose& mask = (TMask_openclose&)fld.mask();
if (k == K_ENTER || fld.to_check(k))
{
TEsercizi_contabili& ex = mask.esercizi;
TDate d(fld.get());
const int es_close = ex.date2esc(d);
if (es_close == 0)
return fld.error_box("La data indicata non appartiene a nessun esercizio.");
if (k == K_ENTER && ex.esercizio(es_close).chiusura_mag() != TDate(NULLDATE))
return fld.error_box("L'esercizio risulta gia' chiuso. Selezionare"
" un altro esercizio o togliere il flag di chiusura.");
else
{
int pred = ex.pred(es_close);
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;
}
bool TMask_openclose::handle_open(TMask_field &fld, KEY k)
{
TMask_openclose& mask = (TMask_openclose&)fld.mask();
if (k == K_ENTER || fld.to_check(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");
const int es_open = mask.esercizi.date2esc(in);
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)
return fld.error_box("Non esiste l'esercizio precedente per la data indicata.");
// Setta data ed esercizio di chiusura
mask.set(F_ESTOCLOSE,es_close);
mask.set(F_DATECLOSE, mask.esercizi.esercizio(es_close).fine());
}
return TRUE;
}
class TApp_openclose : public TSkeleton_application
{
TLocalisamfile *_anamag,
*_mag,
*_movmag,
*_rmovmag,
*_stomag;
TMask_openclose *_msk;
TArray _movimenti; // Array di movimenti di TMov_mag
TString_array _causali; // Array delle causali per i movimenti d'apertura (7)
TString _es_to_close;
TString _es_to_open;
TDate _date_to_close;
TDate _date_to_open;
action _what;
method _calctype;
protected:
virtual bool create();
virtual bool destroy();
virtual void main_loop();
void scrivi_movimenti();
void chiudi_esercizio();
public:
TApp_openclose(action w) { _what = w; };
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
_anamag = new TLocalisamfile(LF_ANAMAG);
_mag = new TLocalisamfile(LF_MAG);
_movmag = new TLocalisamfile(LF_MOVMAG);
_rmovmag = new TLocalisamfile(LF_RMOVMAG);
_stomag = new TLocalisamfile(LF_RMOVMAG);
return TSkeleton_application::create();
}
bool TApp_openclose::destroy()
{
delete _msk;
delete _anamag;
delete _mag;
delete _movmag;
delete _rmovmag;
delete _stomag;
return TSkeleton_application::destroy();
}
void TApp_openclose::scrivi_movimenti()
{
// 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++)
{
_movimenti.add(new TMov_mag);
indici[j] = j;
}
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)
{
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)
{
_movimenti.add(new TMov_mag);
last++;
indici[i] = last;
}
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);
}
}
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 && i<items;i++)
{
prog->addstatus(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)
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");
int err = NOERR;
// 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);
}
void TApp_openclose::main_loop()
{
//Preimposta valori di apertura e chiusura esercizio
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);
const int es_close = ex.pred(es_open);
_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);
_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;
for (short xx = F_CAURIM; xx <= F_CAUORC; xx++) // legge le causali impostate
_causali.add(_msk->get(xx));
chiudi_esercizio(); // Chiusura esercizio
}
}
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);
a.run(argc, argv, msg);
return 0;
}

16
mg/mg1400.h Executable file
View File

@ -0,0 +1,16 @@
#define F_DATEOPEN 101
#define F_ESTOOPEN 102
#define F_DATECLOSE 103
#define F_ESTOCLOSE 104
#define F_VALORIZZAZIONE 105
#define F_METODO 106
#define F_CAURIM 107
#define F_CAUICL 108
#define F_CAUACL 109
#define F_CAUPRF 110
#define F_CAUPRC 111
#define F_CAUORF 112
#define F_CAUORC 113
#define F_CATVEN 114
#define F_LIST 115

180
mg/mg1400.uml Executable file
View File

@ -0,0 +1,180 @@
#include "mg1400.h"
PAGE "Chiusura esercizi" -1 -1 75 15
DATE F_DATEOPEN
BEGIN
PROMPT 2 2 "Data di apertura "
END
NUMBER F_ESTOOPEN 4
BEGIN
PROMPT 38 2 "Esercizio "
FLAGS "DRZ"
END
DATE F_DATECLOSE
BEGIN
PROMPT 2 3 "Data di chiusura "
END
NUMBER F_ESTOCLOSE 4
BEGIN
PROMPT 38 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@
END
RADIOBUTTON F_METODO 22
BEGIN
PROMPT 50 4 "Metodo"
ITEM "1|Annuale e storico"
ITEM "2|Ragionieristico"
END
GROUPBOX DLG_NULL 22 4
BEGIN
PROMPT 50 4 "Listino"
GROUP 2
END
STRING F_CATVEN 2
BEGIN
PROMPT 51 5 "Categoria ven. "
USE CVE
INPUT CODTAB F_CATVEN
DISPLAY "Codice" CODTAB
DISPLAY "Descrizione @50" S0
DISPLAY "Provvigione" R0
DISPLAY "Gruppo" I1
DISPLAY "Conto" I2
OUTPUT F_CATVEN CODTAB
CHECKTYPE REQUIRED
GROUP 2
END
STRING F_LIST 3
BEGIN
PROMPT 51 6 "Codice listino "
USE LF_CONDV SELECT TIPO=="L"
INPUT TIPO "L"
INPUT CATVEN F_CATVEN
INPUT COD F_LIST
DISPLAY "Cat. vendita" CATVEN
DISPLAY "Listino"COD
DISPLAY "Descrizione @50" DESCR
DISPLAY "Inizio validita" VALIN
DISPLAY "Fine validita" VALFIN
OUTPUT F_LIST COD
CHECKTYPE REQUIRED
GROUP 2
END
GROUPBOX DLG_NULL 70 6
BEGIN
PROMPT 2 7 "Causali d'apertura "
END
STRING F_CAURIM 6
BEGIN
PROMPT 3 8 "Rimanenze iniziali "
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
END
STRING F_CAUICL 6
BEGIN
PROMPT 3 9 "In conto lavoraz. "
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
END
STRING F_CAUACL 6
BEGIN
PROMPT 43 9 "A conto lavoraz. "
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
END
STRING F_CAUPRF 6
BEGIN
PROMPT 3 10 "In prod. finiti "
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
END
STRING F_CAUPRC 6
BEGIN
PROMPT 43 10 "In prod. comp. "
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
END
STRING F_CAUORF 6
BEGIN
PROMPT 3 11 "Ordinato fornitori "
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
END
STRING F_CAUORC 6
BEGIN
PROMPT 43 11 "Ordinato clienti "
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
END
BUTTON DLG_OK 10 2
BEGIN
PROMPT -12 -1 ""
END
BUTTON DLG_CANCEL 10 2
BEGIN
PROMPT -22 -1 ""
END
ENDPAGE
ENDMASK

2
mg/mglib.h
View File

@ -410,7 +410,7 @@ public:
};
bool rebuild_balances(const TString16 annoes, bool reset_giac=FALSE);
bool rebuild_balances(const TString16 annoes/*, bool reset_giac=FALSE*/);
#define FORM_MAXGIACLEV 4 // numero di livelli giacenza nel form
#define FORM_MAXARTLEV 8 // numero di livelli codice nel form

8
mg/mglib02.cpp
View File

@ -1371,7 +1371,7 @@ int TMov_mag::codice_esercizio(TDate &d)
}
//**********************
bool rebuild_balances(const TString16 annoes, bool reset_giac)
bool rebuild_balances(const TString16 annoes/*, bool reset_giac*/)
{
TArray used_files;
used_files.add(new TLocalisamfile(LF_RMOVMAG),LF_RMOVMAG);
@ -1384,6 +1384,10 @@ bool rebuild_balances(const TString16 annoes, bool reset_giac)
rel.lfile().set_curr(m_m);
int ok=TRUE;
TLocalisamfile mag(LF_MAG);
// Il flag di reset delle giacenze viene impostato in base alla chiusura dell'esercizio
// precedente
const int pred_es = _esercizi.pred(atoi(annoes));
const bool reset_giac = pred_es != 0 ? _esercizi.esercizio(pred_es).chiusura_mag() != TDate(NULLDATE) : TRUE;
if (reset_giac) {
// azzera tutte giacenze (ciclo sulle giacenze)
mag.put("ANNOES",annoes);
@ -1432,7 +1436,7 @@ bool rebuild_balances(const TString16 annoes, bool reset_giac)
TProgind barra_mov(cur.items(),"Ricostruzione saldi", TRUE, TRUE, 60);
for (int i=0; i<cur.objects(); i++)
for (long i=0; i<cur.objects(); i++)
{
barra_mov.addstatus(1);
cur=i;