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

Patch level : 2.2

Browse Source 
Files correlati     :
Ricompilazione Demo : [ ]
Commento            :

Implementata richiesta
0000450

Implementare un meccanismo per avere movimenti che in automatico portino a 0
il totale documento con centri di costo, commesee, fasi predefinite


git-svn-id: svn://10.65.10.50/trunk@13403 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
guy 2005-10-10 11:26:19 +00:00
parent aef979d285
commit 065ce112d4
12 changed files with 497 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
ca/ca0300.cpp
View File

@ -5,12 +5,11 @@
#include "ca0.h" #include "ca0.h"
#include "ca0300a.h" #include "ca0300a.h"
//-----AUTOMASK---------------------------------------------------------------------------------// // TConf_mask
class TConf_mask : public TAutomask class TConf_mask : public TAutomask
{ {
protected: protected:
bool on_field_event(TOperable_field& o, TField_event e, long jolly); virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public: public:
void config_loader(TSheet_field& sf, const char* paragrafo); void config_loader(TSheet_field& sf, const char* paragrafo);
@ -20,10 +19,6 @@ public:
virtual ~TConf_mask(){}; virtual ~TConf_mask(){};
}; };
TConf_mask::TConf_mask(const TFilename& f) :TAutomask (f)
{
}
bool TConf_mask::on_field_event(TOperable_field& o, TField_event e, long jolly) bool TConf_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{ {
switch (o.dlg()) switch (o.dlg())
@ -53,15 +48,12 @@ bool TConf_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
break; break;
case F_FATHER_FASI : case F_FATHER_FASI :
if (e == fe_close) if (e == fe_close && !o.empty())
{ {
const TString& lev1 = get(F_LEVEL_1); const TString& lev1 = get(F_LEVEL_1);
const TString& lev2 = get(F_LEVEL_2); const TString& lev2 = get(F_LEVEL_2);
if (lev2.blank()) if (o.get() != lev1 && o.get() != lev2)
{ return error_box(TR("Livello superiore di fase non valido"));
if (o.get() != lev1 && o.get() != lev2)
return error_box(TR("Livello superiore di fase non valido"));
}
} }
default: break; default: break;
@ -69,15 +61,16 @@ bool TConf_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
return true; return true;
} }
TConf_mask::TConf_mask(const TFilename& f) : TAutomask (f)
{
}
//-----CONFIG APPLICATION------------------------------------------------------------------------------------------// //-----CONFIG APPLICATION------------------------------------------------------------------------------------------//
class TConf_Analitica : public TConfig_application class TConf_Analitica : public TConfig_application
{ {
TMask* _cm; TMask* _cm;
virtual const char * extra_modules() const {return "cm";} //funziona anche con autorizzazione CM virtual const char* extra_modules() const { return "cm"; } //funziona anche con autorizzazione CM
protected: protected:
virtual TMask* create_mask(const TFilename& f); virtual TMask* create_mask(const TFilename& f);
@ -95,8 +88,8 @@ public:
void config_loader(TSheet_field& sf, TConfig& config); void config_loader(TSheet_field& sf, TConfig& config);
void config_setter(TSheet_field& sf, TConfig& config); void config_setter(TSheet_field& sf, TConfig& config);
TConf_Analitica() : TConfig_application( CONFIG_DITTA ), _cm(NULL) { } TConf_Analitica() : TConfig_application(CONFIG_DITTA), _cm(NULL) { }
virtual ~TConf_Analitica( ){ } virtual ~TConf_Analitica() { }
}; };
TMask* TConf_Analitica::get_mask() TMask* TConf_Analitica::get_mask()
@ -104,7 +97,6 @@ TMask* TConf_Analitica::get_mask()
return _cm; return _cm;
} }
TMask* TConf_Analitica::create_mask(const TFilename& f) TMask* TConf_Analitica::create_mask(const TFilename& f)
{ {
if (_cm == NULL) if (_cm == NULL)
@ -132,13 +124,11 @@ void TConf_Analitica::config_loader(TSheet_field& sf, TConfig& config)
void TConf_Analitica::config_setter(TSheet_field& sf, TConfig& config) void TConf_Analitica::config_setter(TSheet_field& sf, TConfig& config)
{ {
const int items = sf.items(); const int items = sf.items();
for (int i = items;;i++) for (int i = items; ;i++)
{ {
TToken_string num_doc(config.get("ND", NULL, i)); TToken_string num_doc(config.get("ND", NULL, i));
if (num_doc.blank()) if (num_doc.blank())
break; break;
config.remove("ND", i); config.remove("ND", i);
} }
@ -149,7 +139,7 @@ void TConf_Analitica::config_setter(TSheet_field& sf, TConfig& config)
num_doc.add(row->get(2)); num_doc.add(row->get(2));
num_doc.add(row->get(3)); num_doc.add(row->get(3));
num_doc.add(row->get(4)); num_doc.add(row->get(4));
config.set("ND", (const char*) num_doc, NULL, true, j); //setta i valori nel config config.set("ND", num_doc, NULL, true, j); //setta i valori nel config
} }
} }
@ -167,8 +157,8 @@ bool TConf_Analitica::postprocess_config (TMask& mask, TConfig& config)
bool TConf_Analitica::user_create( ) bool TConf_Analitica::user_create( )
{ {
TConfig& cfg = ca_config(); TConfig cfg(CONFIG_DITTA, "ca");
cfg.set( "EdMask", "ca0300a"); cfg.set("EdMask", "ca0300a");
return true; return true;
} }
@ -184,4 +174,4 @@ int ca0300(int argc, char* argv[])
TConf_Analitica app; TConf_Analitica app;
app.run(argc, argv, TR("Parametri Contabilita' Analitica")); app.run(argc, argv, TR("Parametri Contabilita' Analitica"));
return 0; return 0;
} }

2
ca/ca0300a.h
View File

@ -48,8 +48,8 @@
#define F_FSCREQ 142 #define F_FSCREQ 142
#define F_PDCREQ 143 #define F_PDCREQ 143
//sheet delle numerazioni documenti
#define F_RIGHE_NUM 170 #define F_RIGHE_NUM 170
#define F_RIGHE_CMS 171
//elementi dello sheet dei documenti //elementi dello sheet dei documenti
#define SN_CODNUM 101 #define SN_CODNUM 101

9
ca/ca0300a.uml
View File

@ -406,11 +406,11 @@ END
ENDPAGE ENDPAGE
PAGE "Regole num. doc." -1 -1 78 20 PAGE "Regole" -1 -1 78 20
SPREADSHEET F_RIGHE_NUM -1 -2 SPREADSHEET F_RIGHE_NUM
BEGIN BEGIN
PROMPT 1 2 "" PROMPT 1 1 ""
ITEM "Numerazione" ITEM "Numerazione"
ITEM "Descrizione@50" ITEM "Descrizione@50"
ITEM "Da escludere" ITEM "Da escludere"
@ -418,6 +418,8 @@ BEGIN
ITEM "A stato" ITEM "A stato"
END END
END
ENDPAGE ENDPAGE
ENDMASK ENDMASK
@ -489,3 +491,4 @@ END
ENDPAGE ENDPAGE
ENDMASK ENDMASK

3
ca/ca2.cpp
View File

@ -9,8 +9,7 @@ int main(int argc, char** argv)
{ {
case 1: ca2200(argc, argv); break; // ribaltamenti movimenti analitica case 1: ca2200(argc, argv); break; // ribaltamenti movimenti analitica
case 2: ca2300(argc, argv); break; // ricalcolo saldi case 2: ca2300(argc, argv); break; // ricalcolo saldi
default: ca2100(argc,argv); break; // gestione movimenti default: ca2100(argc, argv); break; // gestione movimenti
} }
exit(0);
return 0; return 0;
} }

281
ca/ca2200.cpp
View File

@ -1,10 +1,12 @@
#include <applicat.h> #include <applicat.h>
#include <automask.h> #include <automask.h>
#include <progind.h> #include <defmask.h>
#include <recarray.h> #include <recarray.h>
#include <relation.h> #include <relation.h>
#include "calib01.h" #include "calib01.h"
#include "calib02.h"
#include "ca2.h" #include "ca2.h"
#include "ca2200a.h" #include "ca2200a.h"
@ -16,45 +18,88 @@
//-------------------------------------------------------------------- //--------------------------------------------------------------------
// MASCHERA // MASCHERA
//-------------------------------------------------------------------- //--------------------------------------------------------------------
class TRib_movanal_msk : public TAutomask class TRib_movanal_msk : public TAnal_report_mask
{ {
protected: protected:
virtual bool on_field_event(TOperable_field& o, TField_event fe, long jolly); virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
void save_to_ini();
void load_from_ini();
public: public:
TRib_movanal_msk(); TRib_movanal_msk();
virtual ~TRib_movanal_msk(){};
}; };
TRib_movanal_msk::TRib_movanal_msk() :TAutomask ("ca2200a") { } void TRib_movanal_msk::save_to_ini()
{
bool TRib_movanal_msk::on_field_event(TOperable_field& o, TField_event e, long jolly) TConfig ini(CONFIG_DITTA, "ca");
{
/* switch (o.dlg()) // Cancella tutte le variabili di pareggio
int j;
for (j = 1; ini.remove("Pareggio", j); j++);
TSheet_field& sf = sfield(F_RIGHE);
const int idx = sf.cid2index(F_CODCAUS);
// Salva tutte le righe dello sheet nel formato
// Pareggio(1) = Causale|Costo|Commessa|Fase
j = 0;
FOR_EACH_SHEET_ROW(sf, i, row)
{ {
case : TToken_string par = row->get(idx); // Codice causale
break; if (!par.blank())
default: break; {
}*/ TAnal_bill bill;
return true; const int flags = get_row_bill(sf, i, bill);
if (flags != 0)
{
if (flags & 1) par.add(bill.costo(), 1);
if (flags & 2) par.add(bill.commessa(), 2);
if (flags & 4) par.add(bill.fase(), 3);
ini.set("Pareggio", par, NULL, true, ++j);
}
}
}
} }
void TRib_movanal_msk::load_from_ini()
//--------------------------------------------------------------------
// CLASSE PER RIPARTIZIONI RIGHE E TESTATE
//--------------------------------------------------------------------
class TRipartizione : public TMultiple_rectype
{ {
public: // Svuota lo sheet
TRipartizione(TString16 codice); TSheet_field& sf = sfield(F_RIGHE);
}; sf.destroy();
// Carica tutte le variabili di pareggio nello sheet
TConfig ini(CONFIG_DITTA, "ca");
TToken_string par;
for (int j = 1; ; j++)
{
par = ini.get("Pareggio", NULL, j);
if (par.empty_items())
break;
const TAnal_bill bill("", par.get(1), par.get(2), par.get(3));
set_row_bill(sf, -1, bill);
}
}
TRipartizione::TRipartizione(TString16 codice) : TMultiple_rectype(LF_RIP) bool TRib_movanal_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{ {
add_file(LF_RRIP, RRIP_CODICE); switch (o.dlg())
if (codice.not_empty()) {
read(); case DLG_OK:
case DLG_SAVEREC:
if (e == fe_button)
save_to_ini();
break;
default:
break;
}
return TAnal_report_mask::on_field_event(o, e, jolly);
}
TRib_movanal_msk::TRib_movanal_msk() : TAnal_report_mask("ca2200a")
{
create_sheet(F_RIGHE);
load_from_ini();
} }
//-------------------------------------------------------------------- //--------------------------------------------------------------------
@ -62,69 +107,59 @@ TRipartizione::TRipartizione(TString16 codice) : TMultiple_rectype(LF_RIP)
//-------------------------------------------------------------------- //--------------------------------------------------------------------
class TRib_movanal_app : public TSkeleton_application class TRib_movanal_app : public TSkeleton_application
{ {
TRib_movanal_msk * _mask;
TCache_ripartizioni _cache_rip; TCache_ripartizioni _cache_rip;
bool _definitivo; bool _definitivo;
TAssoc_array _caus_cms;
virtual const char * extra_modules() const {return "cm";} //deve funzionare anche per le commesse virtual const char* extra_modules() const { return "cm"; } //deve funzionare anche per le commesse
protected: protected:
virtual bool create();
virtual bool destroy();
virtual void main_loop(); virtual void main_loop();
static bool cappotta_movimento(const TRelation& rel, void* pJolly); void implode_rows(const TRecord_array& input_rows, TRecord_array& compact_rows) const;
void implode_rows(const TRecord_array& input_rows, TRecord_array& compact_rows);
bool explode_rows(const TRecord_array& input_rows, TRecord_array& output_rows); bool explode_rows(const TRecord_array& input_rows, TRecord_array& output_rows);
bool can_merge_rows(const TRectype& compact_rec, const TRectype& rec); bool ori_present(const TRectype& rec) const;
bool ori_present(const TRectype& rec);
void copia_campo(const TRectype& src, const char* campo_src, TRectype& dst, const char* campo_dst) const;
void taglia_campo(TRectype& src, const char* campo_src, TRectype& dst, const char* campo_dst) const;
bool can_merge_rows(const TRectype& compact_rec, const TRectype& rec) const;
bool pareggia_commessa(TAnal_mov& anal_mov);
public: public:
TRib_movanal_app() {} bool cappotta_movimento(TAnal_mov& anal_mov);
}; };
bool TRib_movanal_app::create() void TRib_movanal_app::copia_campo(const TRectype& src, const char* campo_src,
{ TRectype& dst, const char* campo_dst) const
_mask = new TRib_movanal_msk;
return TSkeleton_application::create();
}
bool TRib_movanal_app::destroy()
{
delete _mask;
return TSkeleton_application::destroy();
}
static void copia_campo (const TRectype& src, const char* campo_src,
TRectype& dst, const char* campo_dst)
{ {
const TString& valore = src.get(campo_src); const TString& valore = src.get(campo_src);
if (!valore.blank()) if (!valore.blank())
dst.put(campo_dst, valore); dst.put(campo_dst, valore);
} }
static void taglia_campo (TRectype& src, const char* campo_src, void TRib_movanal_app::taglia_campo(TRectype& src, const char* campo_src,
TRectype& dst, const char* campo_dst) TRectype& dst, const char* campo_dst) const
{ {
copia_campo(src, campo_src, dst, campo_dst); copia_campo(src, campo_src, dst, campo_dst);
src.zero(campo_src); src.zero(campo_src);
} }
bool TRib_movanal_app::can_merge_rows(const TRectype& compact_rec, const TRectype& rec) bool TRib_movanal_app::can_merge_rows(const TRectype& compact_rec, const TRectype& rec) const
{ {
return (compact_rec.get(RMOVANA_CODCCORI) == rec.get(RMOVANA_CODCCORI) && return compact_rec.get(RMOVANA_CODCCORI) == rec.get(RMOVANA_CODCCORI) &&
compact_rec.get(RMOVANA_CODCMSORI) == rec.get(RMOVANA_CODCMSORI) && compact_rec.get(RMOVANA_CODCMSORI) == rec.get(RMOVANA_CODCMSORI) &&
compact_rec.get(RMOVANA_CODFASEORI) == rec.get(RMOVANA_CODFASEORI) && compact_rec.get(RMOVANA_CODFASEORI) == rec.get(RMOVANA_CODFASEORI) &&
compact_rec.get(RMOVANA_CODCONTORI) == rec.get(RMOVANA_CODCONTORI) ); compact_rec.get(RMOVANA_CODCONTORI) == rec.get(RMOVANA_CODCONTORI);
} }
bool TRib_movanal_app::ori_present(const TRectype& rec) bool TRib_movanal_app::ori_present(const TRectype& rec) const
{ {
return (rec.get(RMOVANA_CODCCORI).not_empty() || rec.get(RMOVANA_CODCMSORI).not_empty() || return (rec.get(RMOVANA_CODCCORI).not_empty() || rec.get(RMOVANA_CODCMSORI).not_empty() ||
rec.get(RMOVANA_CODFASEORI).not_empty() || rec.get(RMOVANA_CODCONTORI).not_empty()); rec.get(RMOVANA_CODFASEORI).not_empty() || rec.get(RMOVANA_CODCONTORI).not_empty());
} }
void TRib_movanal_app::implode_rows(const TRecord_array& input_rows, TRecord_array& compact_rows) void TRib_movanal_app::implode_rows(const TRecord_array& input_rows, TRecord_array& compact_rows) const
{ {
for (int r = 1; r <= input_rows.rows(); r++) for (int r = 1; r <= input_rows.rows(); r++)
{ {
@ -132,7 +167,7 @@ void TRib_movanal_app::implode_rows(const TRecord_array& input_rows, TRecord_arr
//se esiste almeno un campo origine compilato puo' implodere, senno' lascia perdere //se esiste almeno un campo origine compilato puo' implodere, senno' lascia perdere
if (ori_present(rec)) if (ori_present(rec))
{ {
int i; int i = 0;
for (i = compact_rows.rows(); i > 0; i--) //giro sulle righe gia' compattate per scoprire se for (i = compact_rows.rows(); i > 0; i--) //giro sulle righe gia' compattate per scoprire se
{ //il nostro record esiste gia' o e' da aggiungere { //il nostro record esiste gia' o e' da aggiungere
const TRectype& nuovo_rec = compact_rows.row(i); // const TRectype& nuovo_rec = compact_rows.row(i); //
@ -156,7 +191,6 @@ void TRib_movanal_app::implode_rows(const TRecord_array& input_rows, TRecord_arr
newrec->put(RMOVANA_NUMRIG, compact_rows.rows() + 1); newrec->put(RMOVANA_NUMRIG, compact_rows.rows() + 1);
compact_rows.add_row(newrec); compact_rows.add_row(newrec);
} }
} }
else else
{ {
@ -212,14 +246,13 @@ bool TRib_movanal_app::explode_rows(const TRecord_array& input_rows, TRecord_arr
copia_campo(rec, RMOVANA_CODCONTO, *newrec, RMOVANA_CODCONTORI); copia_campo(rec, RMOVANA_CODCONTO, *newrec, RMOVANA_CODCONTORI);
//e mette nei campi std i valori che trova nelle righe ripartizione //e mette nei campi std i valori che trova nelle righe ripartizione
copia_campo(rrip[i], RRIP_CODCOSTO, *newrec, RMOVANA_CODCCOSTO); copia_campo(rrip[i], RRIP_CODCOSTO, *newrec, RMOVANA_CODCCOSTO);
copia_campo(rrip[i], RRIP_CODCMS, *newrec, RMOVANA_CODCMS); copia_campo(rrip[i], RRIP_CODCMS, *newrec, RMOVANA_CODCMS);
copia_campo(rrip[i], RRIP_CODFASE, *newrec, RMOVANA_CODFASE); copia_campo(rrip[i], RRIP_CODFASE, *newrec, RMOVANA_CODFASE);
copia_campo(rrip[i], RRIP_CODCONTO, *newrec, RMOVANA_CODCONTO); copia_campo(rrip[i], RRIP_CODCONTO, *newrec, RMOVANA_CODCONTO);
output_rows.add_row(newrec); output_rows.add_row(newrec);
ho_cambiato_qualchecosa = true; ho_cambiato_qualchecosa = true;
} }
} }
else //nessuna riga di ripartizione->aggiungo la riga input all'output else //nessuna riga di ripartizione->aggiungo la riga input all'output
{ {
@ -231,20 +264,64 @@ bool TRib_movanal_app::explode_rows(const TRecord_array& input_rows, TRecord_arr
return ho_cambiato_qualchecosa; return ho_cambiato_qualchecosa;
} }
bool TRib_movanal_app::pareggia_commessa(TAnal_mov& anal_mov)
bool TRib_movanal_app::cappotta_movimento(const TRelation& rel, void* pJolly)
{ {
TRib_movanal_app& app = *(TRib_movanal_app*)pJolly; bool ho_cambiato_qualchecosa = false;
TAnal_mov& anal_mov = (TAnal_mov&)rel.curr(); //movimento analitica const TString& codcaus = anal_mov.get(MOVANA_CODCAUS);
const TAnal_bill* cms = (const TAnal_bill*)_caus_cms.objptr(codcaus);
if (cms != NULL) // La causale del movimento e' tra quelle da pareggiare
{
const TImporto totdoc(anal_mov.get_char(MOVANA_SEZIONE), anal_mov.get_real(MOVANA_TOTDOC));
if (!totdoc.is_zero()) // Movimento da pareggiare
{
TRecord_array& body = anal_mov.body();
// Cerco la commessa/fase/costo tra le righe esistenti
for (int i = body.last_row(); i > 0; i--)
{
const TRectype& row = body[i];
if ((cms->costo().blank() || row.get(RMOVANA_CODCCOSTO) == cms->costo()) &&
(cms->commessa().blank() || row.get(RMOVANA_CODCMS) == cms->commessa()) &&
(cms->fase().blank() || row.get(RMOVANA_CODFASE) == cms->fase()))
break;
}
// Se non trovo nessuna riga compatibile, me la creo
if (i <= 0)
{
TRectype& rmovana = anal_mov.new_row();
rmovana.put(RMOVANA_DESCR, TR("Pareggio commessa"));
rmovana.put(RMOVANA_CODCCOSTO, cms->costo());
rmovana.put(RMOVANA_CODCMS, cms->commessa());
rmovana.put(RMOVANA_CODFASE, cms->fase());
i = rmovana.get_int(RMOVANA_NUMRIG);
}
// Sottraggo all'importo della riga il totale documento,
// il quale verra' quindi azzerato
TRectype& rmovana = body[i];
TImporto importo(rmovana.get_char(RMOVANA_SEZIONE), rmovana.get_real(RMOVANA_IMPORTO));
importo -= totdoc;
importo.normalize();
rmovana.put(RMOVANA_SEZIONE, importo.sezione());
rmovana.put(RMOVANA_IMPORTO, importo.valore());
anal_mov.put(MOVANA_TOTDOC, ZERO);
ho_cambiato_qualchecosa = true;
}
}
return ho_cambiato_qualchecosa;
}
bool TRib_movanal_app::cappotta_movimento(TAnal_mov& anal_mov)
{
TRecord_array& input_rows = anal_mov.body(); //record_array con le righe del mov_anal (INPUT) TRecord_array& input_rows = anal_mov.body(); //record_array con le righe del mov_anal (INPUT)
//Per prima cosa prende le righe del movimento su RMOVANA e le ricompatta.. //Per prima cosa prende le righe del movimento su RMOVANA e le ricompatta..
TRecord_array compact_rows = input_rows; //record array con le righe compattate da creare con la TRecord_array compact_rows = input_rows; //record array con le righe compattate da creare con la
compact_rows.destroy_rows(); //implode_rows() compact_rows.destroy_rows(); //implode_rows()
//Imploditore //Imploditore
app.implode_rows(input_rows, compact_rows); implode_rows(input_rows, compact_rows);
//..poi lo riesplode in tutte le righe che possono nascere secondo le regole delle ripartizioni! //..poi lo riesplode in tutte le righe che possono nascere secondo le regole delle ripartizioni!
TRecord_array output_rows = input_rows; //crea il record_array di output come copia dell'INPUT.. TRecord_array output_rows = input_rows; //crea il record_array di output come copia dell'INPUT..
@ -252,60 +329,84 @@ bool TRib_movanal_app::cappotta_movimento(const TRelation& rel, void* pJolly)
bool do_rewrite = false; bool do_rewrite = false;
//Esploditore //Esploditore
if (app.explode_rows(compact_rows, output_rows)) if (explode_rows(compact_rows, output_rows))
{ {
input_rows = output_rows; //rimette i record elaborati negli originali input_rows = output_rows; //rimette i record elaborati negli originali
do_rewrite = true; do_rewrite = true;
} }
if (app._definitivo) //se l'elaborazione e' definitiva... if (pareggia_commessa(anal_mov))
do_rewrite = true;
if (_definitivo) //se l'elaborazione e' definitiva...
{ {
anal_mov.put(MOVANA_BLOCCATO, 'X'); //..mette bloccato = X nella testata del movimento anal_mov.put(MOVANA_BLOCCATO, 'X'); //..mette bloccato = X nella testata del movimento
do_rewrite = true; do_rewrite = true;
} }
if (do_rewrite) //se ha elaborato delle righe e/o e' una elaborazione definitiva, riscrive la..
anal_mov.rewrite(rel.lfile()); //testata ed aggiorna i saldi return do_rewrite; //se ha elaborato delle righe e/o e' una elaborazione definitiva, riscrive la..
}
static bool cappotta_callback(const TRelation& rel, void* pJolly)
{
TRib_movanal_app& app = *(TRib_movanal_app*)pJolly;
const long numreg = rel.curr().get_long(MOVANA_NUMREG);
TAnal_mov anal_mov(numreg);
if (app.cappotta_movimento(anal_mov))
anal_mov.rewrite(rel.lfile());
return true; return true;
} }
void TRib_movanal_app::main_loop() void TRib_movanal_app::main_loop()
{ {
while (_mask->run() == K_ENTER) TRib_movanal_msk mask;
while (mask.run() == K_ENTER)
{ {
//avvisa l'utente scapestrato che se fa una elaborazione definitiva blocchera' i movimenti // avvisa l'utente scapestrato che se fa una elaborazione definitiva
//che processa // blocchera' i movimenti che processa
_definitivo = _mask->get_bool(F_DEFINITIVO); _definitivo = mask.get_bool(F_DEFINITIVO);
//deve scandire il file MOVANA con chiave 2 (per data e numero di registrazione) //deve scandire il file MOVANA con chiave 2 (per data e numero di registrazione)
TRelation rel_movana(LF_MOVANA); TRelation rel_movana(LF_MOVANA);
TRectype darec(LF_MOVANA), arec(LF_MOVANA); TRectype darec(LF_MOVANA), arec(LF_MOVANA);
darec.put(MOVANA_DATAREG, _mask->get_date(F_DATAINI)); darec.put(MOVANA_DATAREG, mask.get_date(F_DATAINI));
arec.put(MOVANA_DATAREG, _mask->get_date(F_DATAFIN)); arec.put(MOVANA_DATAREG, mask.get_date(F_DATAFIN));
TString filtro;
filtro << "BLOCCATO!=\"X\"";
TCursor cur_movana(&rel_movana, filtro, 2, &darec, &arec); TCursor cur_movana(&rel_movana, "BLOCCATO!=\"X\"", 2, &darec, &arec);
const long items = cur_movana.items(); const long items = cur_movana.items();
//usa la scan dei TCursor,quindi niente progind e for,x' gia' nel metodo
if (items > 0) if (items > 0)
{ {
bool run = yesno_box(FR("Si desidera elaborare %ld movimenti?"), items); bool run = yesno_box(FR("Si desidera elaborare %ld movimenti?"), items);
if (run && _definitivo) if (run && _definitivo)
run = yesno_box(FR("Selezionata l'elaborazione definitiva\nSi desidera proseguire?")); run = yesno_box(TR("E' stata selezionata l'elaborazione definitiva\nSi desidera proseguire?"));
if (run) if (run)
{ {
rel_movana.lfile().set_curr(new TAnal_mov); //il record principale della rel e' un TMov_anal!! // Riempie la lista della causali dei movimenti da pareggiare
cur_movana.scan(cappotta_movimento, this, "Ribaltamento movimenti..."); _caus_cms.destroy();
TSheet_field& sf = mask.sfield(F_RIGHE);
FOR_EACH_SHEET_ROW(sf, i, row)
{
const TString4 codcaus = row->get(0);
if (!codcaus.blank())
{
TAnal_bill* bill = new TAnal_bill;
if (mask.get_row_bill(sf, i, *bill) != 0)
_caus_cms.add(codcaus, bill);
else
delete bill;
}
}
cur_movana.scan(cappotta_callback, this, TR("Ribaltamento movimenti..."));
} }
} }
else else
message_box(TR("Non ci sono movimenti da elaborare nel periodo selezionato")); message_box(TR("Non ci sono movimenti da elaborare nel periodo selezionato"));
} }
} }
int ca2200(int argc, char* argv[]) int ca2200(int argc, char* argv[])
{ {
TRib_movanal_app app; TRib_movanal_app app;
app.run(argc, argv, "Ribaltamento movimenti di analitica"); app.run(argc, argv, TR("Ribaltamento movimenti di analitica"));
return 0; return 0;
} }

10
ca/ca2200a.h
View File

@ -1,5 +1,9 @@
// campi maschera ca2200a.uml // campi maschera ca2200a.uml
#define F_DATAINI 102 #define F_DATAINI 201
#define F_DATAFIN 103 #define F_DATAFIN 202
#define F_DEFINITIVO 104 #define F_DEFINITIVO 203
#define F_RIGHE 300
#define F_CODCAUS 113
#define F_DESCAUS 114

161
ca/ca2200a.uml
View File

@ -1,44 +1,189 @@
#include "ca2200a.h" #include "ca2200a.h"
#include "camask.h"
TOOLBAR "" 0 -3 0 3 TOOLBAR "" 0 -3 0 3
BUTTON DLG_OK 10 2 BUTTON DLG_OK 10 2
BEGIN BEGIN
PROMPT -12 -11 "~Elabora" PROMPT -13 -11 "~Elabora"
PICTURE BMP_ELABORA PICTURE BMP_ELABORA
END END
BUTTON DLG_SAVEREC 10 2
BEGIN
PROMPT -23 -11 ""
PICTURE BMP_SAVEREC
PICTURE BMP_SAVERECDN
END
BUTTON DLG_QUIT 10 2 BUTTON DLG_QUIT 10 2
BEGIN BEGIN
PROMPT -22 -11 "" PROMPT -33 -11 ""
END END
ENDPAGE ENDPAGE
PAGE "Ribaltamento movimenti di contabilita' analitica" 0 0 64 12 PAGE "Ribaltamento movimenti" 0 0 64 12
GROUPBOX DLG_NULL 78 4 GROUPBOX DLG_NULL 78 4
BEGIN BEGIN
PROMPT 1 1 "@bIntervallo date" PROMPT 1 1 "@bParametri di elaborazione"
END END
DATA F_DATAINI DATA F_DATAINI
BEGIN BEGIN
PROMPT 2 2 "Da data " PROMPT 2 2 "Dalla data "
CHECKTYPE REQUIRED CHECKTYPE REQUIRED
END END
DATA F_DATAFIN DATA F_DATAFIN
BEGIN BEGIN
PROMPT 2 3 "A data " PROMPT 2 3 "Alla data "
CHECKTYPE REQUIRED CHECKTYPE REQUIRED
END END
BOOLEAN F_DEFINITIVO BOOLEAN F_DEFINITIVO
BEGIN BEGIN
PROMPT 2 5 "Blocca movimenti elaborati" PROMPT 42 2 "Blocca movimenti elaborati"
END
SPREADSHEET F_RIGHE
BEGIN
PROMPT 0 5 ""
ITEM "Cms 1"
ITEM "Cms 2"
ITEM "Cms 3"
ITEM "Cms 4"
ITEM "Cms 5"
ITEM "Cms 6"
ITEM "Cms 7"
ITEM "Cms 8"
ITEM "Cms 9"
ITEM "Cms 10"
ITEM "Cms 11"
ITEM "Cms 12"
ITEM "Causale "
ITEM "Descrizione@50"
END
ENDPAGE
ENDMASK
PAGE "Riga Commesse" -1 -1 78 15
STRING F_CODCAUS 3
BEGIN
PROMPT 1 1 "Causale "
USE LF_CAUSALI SELECT MOVIND!=""
CHECKTYPE REQUIRED
INPUT CODCAUS F_CODCAUS
DISPLAY "Codice" CODCAUS
DISPLAY "Descrizione@50" DESCR
OUTPUT F_CODCAUS CODCAUS
OUTPUT F_DESCAUS DESCR
ADD RUN cg0 -4
FLAGS "U"
END
STRING F_DESCAUS 50
BEGIN
PROMPT 17 1 ""
USE LF_CAUSALI KEY 2 SELECT MOVIND!=""
INPUT DESCR F_DESCAUS
DISPLAY "Descrizione@50" DESCR
DISPLAY "Codice" CODCAUS
COPY OUTPUT F_CODCAUS
ADD RUN cg0 -4
END
STRING S_CDC1 20
BEGIN
PROMPT 1 2 "Cms1 "
FLAGS "B"
END
STRING S_CDC2 20
BEGIN
PROMPT 1 3 "Cms2 "
FLAGS "B"
END
STRING S_CDC3 20
BEGIN
PROMPT 1 4 "Cms3 "
FLAGS "B"
END
STRING S_CDC4 20
BEGIN
PROMPT 1 5 "Cms4 "
FLAGS "B"
END
STRING S_CDC5 20
BEGIN
PROMPT 1 6 "Cms5 "
FLAGS "B"
END
STRING S_CDC6 20
BEGIN
PROMPT 1 7 "Cms6 "
FLAGS "B"
END
STRING S_CDC7 20
BEGIN
PROMPT 1 8 "Cms7 "
FLAGS "B"
END
STRING S_CDC8 20
BEGIN
PROMPT 1 9 "Cms8 "
FLAGS "B"
END
STRING S_CDC9 20
BEGIN
PROMPT 1 10 "Cms9 "
FLAGS "B"
END
STRING S_CDC10 20
BEGIN
PROMPT 1 11 "Cms10 "
FLAGS "B"
END
STRING S_CDC11 20
BEGIN
PROMPT 1 12 "Cms11 "
FLAGS "B"
END
STRING S_CDC12 20
BEGIN
PROMPT 1 13 "Cms12 "
FLAGS "B"
END
BUTTON DLG_OK 10 2
BEGIN
PROMPT -13 -1 ""
END
BUTTON DLG_DELREC 10 2
BEGIN
PROMPT -23 -1 ""
END
BUTTON DLG_CANCEL 10 2
BEGIN
PROMPT -33 -1 ""
END END
ENDPAGE ENDPAGE
ENDMASK ENDMASK

33
ca/ca3200.cpp
View File

@ -545,37 +545,10 @@ void TPrint_mastrini_ca_rep::set_filter(const TPrint_mastrini_ca_mask& msk, int
//////////////////////////////////////////////////////// ////////////////////////////////////////////////////////
class TPrint_mastrini_ca : public TSkeleton_application class TPrint_mastrini_ca : public TSkeleton_application
{ {
TPrint_mastrini_ca_mask * _mask;
protected: protected:
bool create();
bool destroy();
public:
const TMultilevel_code_info& get_first_level() const;
virtual void main_loop(); virtual void main_loop();
}; };
bool TPrint_mastrini_ca::create()
{
_mask = new TPrint_mastrini_ca_mask;
return TSkeleton_application::create();
}
bool TPrint_mastrini_ca::destroy()
{
delete _mask;
return TSkeleton_application::destroy();
}
//metodo per accattarsi o' primo livello della configurazione CA
const TMultilevel_code_info& TPrint_mastrini_ca::get_first_level() const
{
TConfig& cfg = ca_config();
const TString& first_lev = cfg.get("Level(1)");
const int logic = first_lev == "CDC" ? LF_CDC : LF_COMMESSE;
return ca_multilevel_code_info(logic);
}
void TPrint_mastrini_ca::main_loop() void TPrint_mastrini_ca::main_loop()
{ {
@ -596,7 +569,8 @@ void TPrint_mastrini_ca::main_loop()
{ {
TToken_string& row = sheet.row(-1); //crea la prima riga dello sheet TToken_string& row = sheet.row(-1); //crea la prima riga dello sheet
const TMultilevel_code_info& liv1 = get_first_level(); //stabilisce quale è il primo livello (tra CDC e CMS).. //stabilisce quale è il primo livello (tra CDC e CMS)..
const TMultilevel_code_info& liv1 = *ca_multilevel_code_info_by_index(0);
TISAM_recordset set(liv1.logic() == LF_CDC ? "USE CDC" : "USE COMMESSE"); //..e di conseguenza scrive la use giusta TISAM_recordset set(liv1.logic() == LF_CDC ? "USE CDC" : "USE COMMESSE"); //..e di conseguenza scrive la use giusta
TProgind pi(set.items(), video_string, true, true); TProgind pi(set.items(), video_string, true, true);
@ -623,8 +597,7 @@ void TPrint_mastrini_ca::main_loop()
{ {
FOR_EACH_SHEET_ROW(sheet, r, row) FOR_EACH_SHEET_ROW(sheet, r, row)
{ {
rep.set_filter(*_mask, r); rep.set_filter(mask, r);
book.add(rep); book.add(rep);
} }
} }

57
ca/calib01.cpp
View File

@ -168,6 +168,23 @@ void TMultilevel_code_info::add_fieldref(int k, int from, int to)
a.add(fr); a.add(fr);
} }
int TMultilevel_code_info::pack(TString& code) const
{
code.strip("|");
return levels();
}
int TMultilevel_code_info::unpack(TString& code) const
{
const int lev = levels();
if (lev > 1)
{
for (int i = lev-2; i >= 0; i--)
code.insert("|", total_len(i));
}
return lev;
}
TMultilevel_code_info::TMultilevel_code_info(int logicnum) : _logicnum(logicnum), _parentnum(0) TMultilevel_code_info::TMultilevel_code_info(int logicnum) : _logicnum(logicnum), _parentnum(0)
{ {
if (_logicnum == LF_PCON) if (_logicnum == LF_PCON)
@ -251,6 +268,45 @@ const TMultilevel_code_info& ca_multilevel_code_info(int logicnum)
return *info; return *info;
} }
const TMultilevel_code_info* ca_multilevel_code_info_by_index(int level)
{
static _logicnum[3] = { -1, -1, -1 };
int logic = 0;
if (level >= 0 && level < 3)
{
// Riempie lista dei livelli, ad esempio:
// LF_COMMESSE, LF_FASI, LF_CDC oppure LF_COMMESSE, LF_CDC, ecc...
if (_logicnum[0] < 0)
{
TConfig& cfg = ca_config();
const TString& lev1 = cfg.get("Level", NULL, 1);
if (!lev1.blank())
{
const TMultilevel_code_info& fasi = ca_multilevel_code_info(LF_FASI);
int k = 0;
_logicnum[k] = lev1 == "CDC" ? LF_CDC : LF_COMMESSE;
if (fasi.parent() == _logicnum[k])
_logicnum[++k] = LF_FASI;
const TString& lev2 = cfg.get("Level", NULL, 2);
if (!lev2.blank())
{
_logicnum[k] = _logicnum[0] == LF_COMMESSE ? LF_CDC : LF_COMMESSE;
if (fasi.parent() == _logicnum[k])
_logicnum[++k] = LF_FASI;
}
}
else
memset(_logicnum, 0, sizeof(_logicnum));
}
logic = _logicnum[level];
}
return logic > 0 ? &ca_multilevel_code_info(logic) : NULL;
}
bool ca_test_multilevel_field(TEdit_field& fld, int level) bool ca_test_multilevel_field(TEdit_field& fld, int level)
{ {
const int logic = fld.browse()->cursor()->curr().num(); const int logic = fld.browse()->cursor()->curr().num();
@ -1314,7 +1370,6 @@ TAnal_rip::TAnal_rip() : TMultiple_rectype(LF_RIP)
add_file(LF_RRIP, RRIP_NRIGA); add_file(LF_RRIP, RRIP_NRIGA);
} }
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// TCache_ripartizioni // TCache_ripartizioni
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////

3
ca/calib01.h
View File

@ -54,12 +54,15 @@ public:
int logic() const { return _logicnum; } int logic() const { return _logicnum; }
int parent() const { return _parentnum; } int parent() const { return _parentnum; }
const TString& editor() const { return _editor; } const TString& editor() const { return _editor; }
int pack(TString& code) const; // Toglie i pipe
int unpack(TString& code) const; // Aggiunge i pipe
TMultilevel_code_info(int logicnum); TMultilevel_code_info(int logicnum);
virtual ~TMultilevel_code_info() { } virtual ~TMultilevel_code_info() { }
}; };
const TMultilevel_code_info& ca_multilevel_code_info(int logicnum); const TMultilevel_code_info& ca_multilevel_code_info(int logicnum);
const TMultilevel_code_info* ca_multilevel_code_info_by_index(int level);
bool ca_test_multilevel_field(TEdit_field& fld, int level); bool ca_test_multilevel_field(TEdit_field& fld, int level);
int ca_create_fields(TMask& msk, int page, int logicnum, int x, int y, short key_id, short des_id, int ca_create_fields(TMask& msk, int page, int logicnum, int x, int y, short key_id, short des_id,
unsigned int mode = 0x0, const char* fieldname = NULL); unsigned int mode = 0x0, const char* fieldname = NULL);

55
ca/calib02.cpp
View File

@ -1,5 +1,3 @@
#include <xvt.h>
#include "calib01.h" #include "calib01.h"
#include "calib02.h" #include "calib02.h"
#include "camask.h" #include "camask.h"
@ -1042,3 +1040,56 @@ void TAnal_report_mask::create_sheet(short sheet_id)
} }
} }
int TAnal_report_mask::get_row_bill(TSheet_field& sf, int r, TAnal_bill& bill)
{
int flag = 0;
if (r >= 0 && r < sf.items())
{
int idx = sf.cid2index(S_CDC1);
TToken_string& row = sf.row(r);
for (int level = 0; level <= 2; level++)
{
const TMultilevel_code_info* info = ca_multilevel_code_info_by_index(level);
if (info == NULL)
break;
TString80 code;
for (int i = 0; i < info->levels(); i++)
code << row.get(idx++);
switch (info->logic())
{
case LF_CDC : bill.set_costo(code); flag |= 1; break;
case LF_COMMESSE: bill.set_commessa(code); flag |= 2; break;
case LF_FASI : bill.set_fase(code); flag |= 4; break;
default: break;
}
}
}
return flag;
}
int TAnal_report_mask::set_row_bill(TSheet_field& sf, int r, const TAnal_bill& bill)
{
int flag = 0;
int idx = sf.cid2index(S_CDC1);
TToken_string& row = sf.row(r);
for (int level = 0; level <= 2; level++)
{
const TMultilevel_code_info* info = ca_multilevel_code_info_by_index(level);
if (info == NULL)
break;
TToken_string code;
switch (info->logic())
{
case LF_CDC : code = bill.costo(); flag |= 1; break;
case LF_COMMESSE: code = bill.commessa(); flag |= 2; break;
case LF_FASI : code = bill.fase(); flag |= 4; break;
default: break;
}
info->unpack(code);
FOR_EACH_TOKEN(code, tok)
row.add(tok, idx++);
}
return flag;
}

9
ca/calib02.h
View File

@ -119,9 +119,9 @@ class TAnal_report : public TReport
protected: // protected is safer protected: // protected is safer
virtual size_t get_usr_words(TString_array& words) const; virtual size_t get_usr_words(TString_array& words) const;
virtual bool execute_usr_word(unsigned int opcode, TVariant_stack& stack); virtual bool execute_usr_word(unsigned int opcode, TVariant_stack& stack);
virtual bool use_mask() { return false;} virtual bool use_mask() { return false; }
virtual void msg_format(int logicnum, TVariant_stack& stack); virtual void msg_format(int logicnum, TVariant_stack& stack);
virtual void msg_format_costo (TVariant_stack& stack); virtual void msg_format_costo (TVariant_stack& stack);
virtual void msg_format_commessa (TVariant_stack& stack); virtual void msg_format_commessa (TVariant_stack& stack);
virtual void msg_format_fase (TVariant_stack& stack); virtual void msg_format_fase (TVariant_stack& stack);
@ -145,7 +145,10 @@ protected:
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly); virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public: public:
TAnal_report_mask(const char* name) : TAutomask(name) {} int get_row_bill(TSheet_field& sf, int r, TAnal_bill& bill);
int set_row_bill(TSheet_field& sf, int r, const TAnal_bill& bill);
TAnal_report_mask(const char* name) : TAutomask(name) {}
}; };
#endif #endif