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

Patch level :10.0 98

Browse Source 
Files correlati     :
Ricompilazione Demo : [ ]
Commento            :riporti dalla 5.0


git-svn-id: svn://10.65.10.50/trunk@16977 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
luca 2008-07-30 13:22:34 +00:00
parent a92dc5fb1d
commit 5bc66323bd
8 changed files with 409 additions and 3 deletions

2
ve/ve6.cpp

@ -20,6 +20,8 @@ int main( int argc, char** argv )
ve6600(argc, argv); break; // collegamento contabilita' industriosa
case 7:
ve6700(argc, argv); break; // copia documenti interattiva da ditta a ditta
case 8:
ve6800(argc, argv); break; // contabilizzazione analitica documenti
default:
ve6100(argc, argv); break; // contabilizzazione documenti
}

1
ve/ve6.h

@ -8,5 +8,6 @@ int ve6400 (int, char**);
int ve6500 (int, char**);
int ve6600 (int, char**);
int ve6700 (int, char**);
int ve6800 (int, char**);
#endif

314
ve/ve6800.cpp Executable file

@ -0,0 +1,314 @@
// ve6800.cpp: programma di contabilizzazione analitica documenti
// Orgiastica visione...
// L'oca del dubbio dalle labbra di Fernet.
//******************************************************************************
// \\\\\\\\ e *
// b \\\\\\\\ b *
// \\\\\\\\ e r d l *
// \\\\\\\\ *
// \\\\\\\\ i V o e h *
// L \\\\\\\\ *
// \\\\\\\\ b d *
// o \\\\\\\\ m a *
// +++++++++++++++++++++++++ b t *
// ++++++++++++++++++++++++++--------------------------------------------------|
// ++++++++++++++++++++++++++--------------------------------------------------|
// ++++++++++++++++++++++++ |---------------------------------------|
// u //////// u |---------------------------------------|
// ' //////// a | /\ /\ |
// //////// i | r / \ r / \ |
// a //////// \|/ / \ / \ l |
// ////////-----------------*---\ a / t \ / a \ /|
// //////// /|\ \ / \ / \ / |
// d //////// n | \ / \ / \ / |
// //////// l d | \/ a \/ l \/ |
//-----------------------------------------------------------------------------|
//
// Scared uh?
#include <automask.h>
#include <progind.h>
#include <relation.h>
#include <sheet.h>
#include <tabutil.h>
#include <urldefid.h>
#include "velib04.h"
#include "../cg/cgsaldac.h"
#include "ve6800a.h"
///////////////////////////////////////////////
// MASCHERA
///////////////////////////////////////////////
class TContabilizzazione_analitica_mask : public TAutomask
{
TArray_sheet* _num_sheet; // TArray_sheet contenente le selezioni sui codici numerazione
TString_array _tipi_doc; // Array di stringhe contenente i tipi documenti da elaborare
protected:
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
// Costruisce lo sheet dei codici numerazione
void build_num_sheet();
public:
// Controlla se lo stato ed il tipo del documento sono validi e rispettano la selezione
bool doc_tipo_stato_ok(const TRectype& doc);
// Restituisce lo sheet con le numerazioni da elaborare
TArray_sheet& num_sheet() const { return *_num_sheet; }
// Constructor and Distructor
TContabilizzazione_analitica_mask();
~TContabilizzazione_analitica_mask();
};
TContabilizzazione_analitica_mask::TContabilizzazione_analitica_mask() : TAutomask("ve6800a")
{
_num_sheet = new TArray_sheet(-1, -1, -4, -4, "Codici numerazione", "@1|Cod. numerazione|Descrizione@50");
}
TContabilizzazione_analitica_mask::~TContabilizzazione_analitica_mask()
{
delete _num_sheet;
}
bool TContabilizzazione_analitica_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
switch (o.dlg())
{
case F_CODICE_ELAB:
if (e == fe_modify)
{
if (o.empty())
disable(DLG_ELABORA);
else
build_num_sheet();
}
break;
case DLG_USER:
if (e == fe_button)
{
if (_num_sheet->run())
{
if (_num_sheet->checked() != 0) // Hai selezionato qualcosa ?
enable(DLG_ELABORA); // allora abilita il pulsante di conferma
else
disable(DLG_ELABORA);
}
}
break;
default:
break;
}
return true;
}
void TContabilizzazione_analitica_mask::build_num_sheet()
{
_num_sheet->destroy();
_tipi_doc.destroy();
TTable num("%NUM");
TString s1,s2,s3;
TContabilizzazione_analitica* contanal = new TContabilizzazione_analitica(get(F_CODICE_ELAB));
if (!contanal->empty())
{
TToken_string t;
TString16 tipo;
for (int i = 0; i < TElaborazione::_max_tipi_doc_elab; i++)
{
tipo = contanal->tipo_iniziale(i);
if (tipo.not_empty())
{
t = tipo;
t.add(contanal->stato_iniziale(i)); // Stato iniziale
_tipi_doc.add(t); // Aggiunge questo tipo documento alla lista
}
}
long pos = 0l;
for (num.first(); num.good(); num.next(), pos++) // scorre tutte le numerazioni possibili
{
TToken_string t,z;
t.add(" ");
t.add(num.get("CODTAB"));
t.add(num.get("S0"));
_num_sheet->add(t);
s2 = num.get("S2"); // reperisce i tipi documento validi per questa numerazione
for (int x = 0; x <= s2.len(); x += 4)
z.add(s2.mid(x,4));
bool found = FALSE;
for (int i = _tipi_doc.last(); !found && i >= 0; i--)
found |= (s2.find(((TToken_string &)_tipi_doc[i]).get(0)) >= 0);
if (found)
_num_sheet->enable_row(pos);
else
_num_sheet->disable_row(pos);
}
}
delete contanal;
}
bool TContabilizzazione_analitica_mask::doc_tipo_stato_ok(const TRectype& doc)
// Verifica che il tipo documento corrente esista tra i tipi previsti dalla elaborazione
// differita selezionata
{
bool found = false;
const TString16 tipo = doc.get(DOC_TIPODOC);
const char stato = doc.get_char(DOC_STATO);
const int items = _tipi_doc.items();
for (int i = 0; i < items && !found; i++)
{
TToken_string& t = _tipi_doc.row(i);
const TString16 tipox(t.get(0));
const char statox = t.get(1)[0];
if (tipo == tipox && stato == statox)
found = true;
}
return found;
}
//////////////////////////////////////////////
// APPLICAZIONE
/////////////////////////////////////////////
// TContabilizzazione_analitica
// Applicazione di contabilizzazione documenti
class TContabilizzazione_analitica_app : public TSkeleton_application
{
TContabilizzazione_analitica_mask* _msk;
protected: // TApplication
// Contabilizza i documenti
void contabilize();
public:
virtual bool create();
virtual bool destroy();
virtual void main_loop();
};
void TContabilizzazione_analitica_app::contabilize()
{
//Prende i dati dalla maschera (date,sheet numerazioni)
const TDate data_ini = _msk->get_date(F_DATA_INI);
int year_from = data_ini.year();
const TDate data_fine = _msk->get_date(F_DATA_FIN);
int year_to = data_fine.year();
const TDate data_reg = _msk->get_date(F_DATA_REG);
TArray_sheet& num_sheet = _msk->num_sheet();
const long items = num_sheet.items();
//Relazione su LF_DOC
TRelation doc_rel(LF_DOC);
TRectype da(LF_DOC);
TRectype a(LF_DOC);
TString16 codnum;
TString msg, filt_expr;
TToken_string nums;
// Compone la lista dei documenti da elaborare
for (long i = 0L; i < items; i++) // Scorre per tutte le numerazioni dello sheet
{
if (num_sheet.checked(i)) // Costruisce una espressione sul codice numerazione: "CODNUM="x0" || CODNUM="x1" || ..."
{
codnum = num_sheet.row(i).get(1);
filt_expr << "(CODNUM=\"";
filt_expr << codnum << "\")||";
nums.add(codnum);
}
}
filt_expr.rtrim(2);
da.put(DOC_DATADOC, data_ini);
da.put(DOC_PROVV, "D");
da.put(DOC_ANNO, year_from);
a.put(DOC_DATADOC, data_fine);
a.put(DOC_PROVV, "D");
a.put(DOC_ANNO, year_to);
// Se ho una sola numerazione ottimizzo la setregion!
if (nums.items() == 1)
{
da.put(DOC_CODNUM, nums);
a.put(DOC_CODNUM, nums);
//filt_expr.cut(0); // Il filtro diventa inutile
}
// Cursore complessivo con limiti di data (chiave 3). Viene sfruttata l'ottimizzazione
// sulla costruzione dei cursori nel caso i campi presenti nell'espressione siano campi
// chiave, nel nostro caso CODNUM soddisfa i requisiti.
TCursor doc_cur(&doc_rel, filt_expr, 3, &da, &a);
const TRecnotype cur_items = doc_cur.items();
if (cur_items > 0)
{
TLista_documenti lista_in, lista_out;
doc_cur.freeze();
msg = "Selezione documenti dal ";
msg << data_ini.string() << " al ";
msg << data_fine.string();
TProgind p(cur_items, msg, false, true);
const TRectype& cur_rec = doc_cur.curr();
// Scorre tutti i documenti che rientrano nell'intervallo selezionato
for (doc_cur = 0; doc_cur.pos() < cur_items; ++doc_cur)
{
p.addstatus(1);
// controlla che il tipo documento e lo stato siano coerenti con la ELD selezionata
if (nums.get_pos(cur_rec.get("CODNUM")) >= 0 && _msk->doc_tipo_stato_ok(cur_rec))
{
TDocumento* doc = new TDocumento;
if (doc->read(doc_cur.curr()) == NOERR) // legge il documento
lista_in.add(doc); // Viene aggiunto alla lista dei documenti
else
delete doc;
}
}
//E finalmente fa l'agognata elaborazione!!!!!
TString16 elaborazione = _msk->get(F_CODICE_ELAB);
TContabilizzazione_analitica contanal(elaborazione);
contanal.elabora(lista_in, lista_out, data_reg);
if (contanal.processed_docs() > 0L)
message_box(FR("Totale documenti contabilizzati: %ld"), contanal.processed_docs());
}
else
warning_box(TR("Non vi sono documenti da contabilizzare per le numerazioni selezionate."));
xvtil_statbar_set("");
}
bool TContabilizzazione_analitica_app::create()
{
_msk = new TContabilizzazione_analitica_mask();
return TSkeleton_application::create();
}
bool TContabilizzazione_analitica_app::destroy()
{
if (_msk) delete _msk;
return TSkeleton_application::destroy();
}
void TContabilizzazione_analitica_app::main_loop()
{
while (_msk->run() == K_ENTER)
{
contabilize();
}
}
int ve6800 (int argc, char **argv)
{
TContabilizzazione_analitica_app a;
a.run(argc,argv,"Contabilizzazione analitica documenti");
return true;
}

8
ve/ve6800a.h Executable file

@ -0,0 +1,8 @@
// Include file per ve6800a.uml
#define F_CODICE_ELAB 101
#define F_DESC_ELAB 102
#define F_DATA_INI 103
#define F_DATA_FIN 104
#define F_DATA_AUTO 105
#define F_DATA_REG 106

77
ve/ve6800a.uml Executable file

@ -0,0 +1,77 @@
#include "ve6800a.h"
PAGE "Contabilizzazione Analitica documenti" -1 -1 75 10
STRING F_CODICE_ELAB 8
BEGIN
PROMPT 1 1 "Codice "
FLAG "U"
USE %ELD SELECT I0 == 7
INPUT CODTAB F_CODICE_ELAB
DISPLAY "Codice@8" CODTAB
DISPLAY "Descrizione@50" S0
OUTPUT F_CODICE_ELAB CODTAB
OUTPUT F_DESC_ELAB S0
CHECKTYPE REQUIRED
WARNING "E' necessario specificare il codice elaborazione"
END
STRING F_DESC_ELAB 50
BEGIN
PROMPT 20 1 ""
USE %ELD KEY 2 SELECT I0 == 7
INPUT S0 F_DESC_ELAB
DISPLAY "Descrizione@50" S0
DISPLAY "Codice@8" CODTAB
COPY OUTPUT F_CODICE_ELAB
END
GROUPBOX DLG_NULL 26 4
BEGIN
PROMPT 1 2 "Date intervallo documenti"
END
DATE F_DATA_INI
BEGIN
PROMPT 2 3 "Inizio "
CHECKTYPE REQUIRED
WARNING "La data di inizio intervallo e' obbligatoria"
END
DATE F_DATA_FIN
BEGIN
PROMPT 2 4 "Fine "
CHECKTYPE REQUIRED
WARNING "La data di fine intervallo deve essere successiva a quella di inizio"
VALIDATE DATE_CMP_FUNC >= F_DATA_INI
END
DATE F_DATA_REG
BEGIN
PROMPT 2 6 "Data registrazione "
FLAGS "A"
CHECKTYPE REQUIRED
END
BUTTON DLG_USER 10 2
BEGIN
PROMPT -13 -1 "~Selezione"
PICTURE BMP_SELECT
END
BUTTON DLG_ELABORA 10 2
BEGIN
PROMPT -23 -1 "E~labora"
PICTURE BMP_ELABORA
MESSAGE EXIT,K_ENTER
FLAGS "D"
END
BUTTON DLG_QUIT 10 2
BEGIN
PROMPT -33 -1 ""
END
ENDPAGE
ENDMASK

5
ve/velib04.h

@ -573,6 +573,7 @@ public:
virtual ~TConsuntivazione_produzione() { }
};
class TCache_causali; // Internal use only
class TContabilizzazione_analitica : public TElaborazione // velib04f
@ -583,6 +584,7 @@ class TContabilizzazione_analitica : public TElaborazione // velib04f
TBill _sco_perc_bill_an, _sco_imp_bill_an;
TCache_causali* _caus;
TString16 _fld_cms_cont;
long _total_docs;// Numero di documenti contabilizzati
error_type _error; // Errore rilevato durante l'elaborazione
bool _usepdcc;
@ -599,12 +601,13 @@ protected:
public:
bool search_costo_ricavo(const TRiga_documento& riga, TBill& conto, bool riclassifica_fdr_fde);
const long processed_docs() const { return _total_docs; }
virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
const TDate& data_elab, bool interattivo = false);
bool elabora(TDocumento& doc, long numreg_cg, TViswin* viswin, bool can_write, TAnal_mov& mov,
bool riclassifica_fdr_fde = true);
TContabilizzazione_analitica();
TContabilizzazione_analitica(const char* cod = NULL);
TContabilizzazione_analitica(const TRectype& rec);
virtual ~TContabilizzazione_analitica();
};

4
ve/velib04f.cpp

@ -766,8 +766,8 @@ void TContabilizzazione_analitica::init()
_caus = new TCache_causali;
}
TContabilizzazione_analitica::TContabilizzazione_analitica()
: TElaborazione(NULL), _error(no_error), _caus(NULL)
TContabilizzazione_analitica::TContabilizzazione_analitica(const char* cod)
: TElaborazione(cod), _error(no_error), _caus(NULL)
{
init();
}

1
ve/vemenu.men

@ -18,6 +18,7 @@ Flags = ""
Item_01 = "Fatturazione bolle", "ve6 -2", "F"
Item_02 = "Contabilizzazione fatture", "ve6 -1", "F"
Item_03 = "Generazione effetti", "ve6 -3", "F"
Item_04 = "Contabilizzazione analitica", "ve6 -8", "F"
[VEMENU_051]
Caption = "Servizi"