Prima versione funzionante con il raggruppamento effetti.
Da fare: controllo sul massimo importo in lire di un effetto: 999.999.999 git-svn-id: svn://10.65.10.50/trunk@4155 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
angelo
parent
1649bc4287
commit
047b12b554
566
ve/ve6300.cpp
566
ve/ve6300.cpp
@ -31,11 +31,16 @@
|
||||
|
||||
#include <doc.h>
|
||||
#include <rdoc.h>
|
||||
#include <effetti.h>
|
||||
#include <reffetti.h>
|
||||
|
||||
#include "../cg/saldacon.h"
|
||||
#include "../ef/ef0101.h"
|
||||
#include "velib01.h"
|
||||
#include "ve6300a.h"
|
||||
|
||||
// Enum di possibili errori
|
||||
|
||||
enum error_type {
|
||||
no_error,
|
||||
elaboration_error,
|
||||
@ -43,6 +48,8 @@ enum error_type {
|
||||
chg_stat_error,
|
||||
datadoc_error,
|
||||
codpag_error,
|
||||
scadenze_error,
|
||||
write_error,
|
||||
generic_error
|
||||
};
|
||||
|
||||
@ -54,22 +61,40 @@ class TGenerazioneEffetti_app : public TApplication
|
||||
TDate _data_reg; // data di registrazione immessa
|
||||
TDate _data_ini; // data di inizio intervallo
|
||||
TDate _data_fine; // data di fine intervallo
|
||||
bool _raggruppa; // se TRUE raggruppa gli effetti secondo i criteri
|
||||
TMask *_msk; // maschera di selezione dati
|
||||
TRelation *_clifo; // relazione dei clienti e fornitori + cfven
|
||||
TLocalisamfile *_docfile, // file dei documenti (per far funzionare TDocumento)
|
||||
*_rdocfile; // file delle righe documento (per far funzionare TDocumento)
|
||||
*_rdocfile, // file delle righe documento (per far funzionare TDocumento)
|
||||
*_efffile, // file effetti
|
||||
*_refffile, // file righe di effetti
|
||||
*_cessfile, // file righe di cessionari
|
||||
*_tab; // tabella di ditta
|
||||
TTable *_cpg; // tabella condizioni di pagamento
|
||||
TDocumento *_doc; // documento corrente
|
||||
TPagamento *_pagamento; // pagamento corrente, ricalcolato prima di scrivere le scadenze
|
||||
TBit_array _valid_array; // array dei tipi di pagamento validi per la generazione di effetti
|
||||
TArray_sheet *_num_sheet; // Array sheet selezionabile dei codici numerazione
|
||||
TString_array _tipi_doc; // Array di stringhe contenente i tipi documenti da elaborare
|
||||
TArray _effetti_array;//Array di effetti (TEffetto) da scrivere
|
||||
TAssoc_array _group_array; // Assoc_array dei documenti da raggruppare. La chiave di ogni elemento
|
||||
// e composta dagli stessi criteri di raggruppamento (vedi sotto)
|
||||
// Ogni elemento e una TToken_string. Ogni elemento della TToken_string contiene
|
||||
// la chiave per identificare il documento che fa parte di quel raggruppamento
|
||||
error_type _error; // Errore rilevato durante l'elaborazione
|
||||
long _total_bills; // Totale effetti generati
|
||||
bool _can_write; // se TRUE e' abilitata la scrittura. Non appena rileva un errore rimane a FALSE for this instance
|
||||
char _final_doc_status; // Valore per lo stato finale del documento
|
||||
// Flags di raggruppamento opzionali (%ELD->S1):
|
||||
bool _group_by_date, // raggruppa per data di scadenza
|
||||
_group_by_sosp, // raggruppa per flag sosp. d'imposta
|
||||
_group_by_change, // raggruppa per cambio
|
||||
_group_by_pag, // raggruppa per cond. di pagamento
|
||||
_group_by_bank, // raggruppa per banca (ABI-CAB)
|
||||
_group_by_type, // raggruppa per tipo di documento
|
||||
_group_by_num, // raggruppa per cod. numerazione
|
||||
_group_by_agent; // raggruppa per agente
|
||||
protected: // TApplication
|
||||
// scrive il movimento e le scadenze
|
||||
error_type write_all() { return no_error; }
|
||||
// Cambia lo stato del documento
|
||||
error_type change_doc_status();
|
||||
// Coontrolla se lo stato ed il tipo del documento sono validi e rispettano la selezione
|
||||
@ -94,11 +119,27 @@ protected: // TApplication
|
||||
TArray_sheet* get_num_sheet() const { return _num_sheet; }
|
||||
// Costruisce lo sheet dei codici numerazione
|
||||
void build_num_sheet();
|
||||
// Restituisce TRUE se il tipo di pagamento passato e' valido per generare l'effetto
|
||||
bool valid_type(int tipo_pag) const ;
|
||||
// Aggiunge il documento corrente alla lista dei documenti raggruppabili
|
||||
void add_to_group_list();
|
||||
// Costruisce la stringa chiave per raggruppamento
|
||||
void build_group_key(TString& key);
|
||||
// Costruisce la stringa chiave per documento
|
||||
void build_doc_key(TToken_string& key);
|
||||
// Setta i flags di raggruppamento opzionali in base alla tabella
|
||||
void set_options();
|
||||
// Effettua il raggruppamento vero e proprio degli effetti (solo se ci sono elementi nell'assoc_array
|
||||
void group_bills();
|
||||
// Istanzia il pagamento corrente
|
||||
void calc_pagamento(TString16& codpag, const real& totale_fatt, TString16& data, const bool valuta, const real& change);
|
||||
// Scrive i record array degli effetti raggruppati
|
||||
error_type write_groups();
|
||||
// Cambia lo stato dei gruppi di documenti raggruppati in effetti
|
||||
error_type change_group_status();
|
||||
public:
|
||||
// Verifica se non ci sono stati errori
|
||||
bool good() const { return _error == no_error;}
|
||||
error_type status() { return _error; }
|
||||
void set_status(error_type e) { _error = e; }
|
||||
TGenerazioneEffetti_app() {_msk = NULL; _num_sheet = NULL;}
|
||||
virtual ~TGenerazioneEffetti_app() { }
|
||||
};
|
||||
@ -208,9 +249,19 @@ void TGenerazioneEffetti_app::build_num_sheet()
|
||||
}
|
||||
}
|
||||
|
||||
bool TGenerazioneEffetti_app::valid_type(int pag) const
|
||||
{
|
||||
return _valid_array[pag];
|
||||
}
|
||||
|
||||
bool TGenerazioneEffetti_app::create()
|
||||
{
|
||||
TApplication::create();
|
||||
if (!has_module(EFAUT))
|
||||
{
|
||||
error_box("Impossibile eseguire il programma se il modulo Effetti non e' abilitato");
|
||||
return FALSE;
|
||||
}
|
||||
_error = no_error;
|
||||
_can_write = TRUE;
|
||||
_pagamento = NULL;
|
||||
@ -223,10 +274,21 @@ bool TGenerazioneEffetti_app::create()
|
||||
"@1|Cod. numerazione|Descrizione@50");
|
||||
_docfile = new TLocalisamfile(LF_DOC);
|
||||
_rdocfile = new TLocalisamfile(LF_RIGHEDOC);
|
||||
_efffile = new TLocalisamfile(LF_EFFETTI);
|
||||
_refffile = new TLocalisamfile(LF_REFFETTI);
|
||||
_cessfile = new TLocalisamfile(LF_CESS);
|
||||
_doc = new TDocumento;
|
||||
_cpg = new TTable("%CPG");
|
||||
_tab = new TLocalisamfile(LF_TAB);
|
||||
_clifo = new TRelation(LF_CLIFO);
|
||||
_clifo->add(LF_CFVEN,"TIPOCF=TIPOCF|CODCF=CODCF");
|
||||
// Settaggio dell'array dei tipi documento che possono generare effetti
|
||||
_valid_array.set(2); // tratta
|
||||
_valid_array.set(3); // riba
|
||||
_valid_array.set(5); // paghero'
|
||||
_valid_array.set(7); // tratta accettata
|
||||
_valid_array.set(8); // rapporti interbancari diretti (rid)
|
||||
_valid_array.reset(9); // bonifici
|
||||
dispatch_e_menu(BAR_ITEM(1));
|
||||
return TRUE;
|
||||
}
|
||||
@ -237,8 +299,12 @@ bool TGenerazioneEffetti_app::destroy()
|
||||
if (_num_sheet) delete _num_sheet;
|
||||
if (_docfile) delete _docfile;
|
||||
if (_rdocfile) delete _rdocfile;
|
||||
if (_efffile) delete _efffile;
|
||||
if (_refffile) delete _refffile;
|
||||
if (_cessfile) delete _cessfile;
|
||||
if (_doc) delete _doc;
|
||||
if (_cpg) delete _cpg;
|
||||
if (_tab) delete _tab;
|
||||
if (_clifo) delete _clifo;
|
||||
return TApplication::destroy();
|
||||
}
|
||||
@ -250,6 +316,7 @@ bool TGenerazioneEffetti_app::menu(MENU_TAG mt)
|
||||
_cod_el = _msk->get(F_CODICE_ELAB);
|
||||
_data_ini = _msk->get_date(F_DATA_INI);
|
||||
_data_fine = _msk->get_date(F_DATA_FIN);
|
||||
_raggruppa = _msk->get_bool(F_RAGGRUPPA);
|
||||
generate();
|
||||
}
|
||||
return FALSE;
|
||||
@ -277,13 +344,48 @@ bool TGenerazioneEffetti_app::doc_tipo_stato_ok()
|
||||
error_type TGenerazioneEffetti_app::change_doc_status()
|
||||
// Cambia lo stato del documento
|
||||
{
|
||||
TLocalisamfile d(LF_DOC);
|
||||
_doc->stato(_final_doc_status);
|
||||
if (_doc->head().rewrite(d) != NOERR)
|
||||
if (_doc->head().rewrite(*_docfile) != NOERR)
|
||||
_error = chg_stat_error;
|
||||
return _error;
|
||||
}
|
||||
|
||||
error_type TGenerazioneEffetti_app::change_group_status()
|
||||
// Cambia lo stato dei documenti raggruppati
|
||||
{
|
||||
const int items = _group_array.items();
|
||||
if (items > 0)
|
||||
{
|
||||
_error = no_error;
|
||||
TToken_string * group_element;
|
||||
int i=0;
|
||||
// Ciclo sugli elementi dell'assoc_array
|
||||
for (group_element = (TToken_string *) _group_array.first_item(); group_element != NULL && i < items; i++,group_element = (TToken_string*)_group_array.succ_item())
|
||||
{
|
||||
group_element->restart();
|
||||
const int doc_items = group_element->items();
|
||||
for (int j=0;j<doc_items;j++)
|
||||
{
|
||||
TToken_string t(group_element->get(j),'$');
|
||||
char provv = t.get_char(0);
|
||||
int anno = t.get_int(1);
|
||||
TString codnum(t.get(2));
|
||||
long numdoc = t.get_long(3);
|
||||
_docfile->put(DOC_PROVV,provv);
|
||||
_docfile->put(DOC_ANNO,anno);
|
||||
_docfile->put(DOC_CODNUM,codnum);
|
||||
_docfile->put(DOC_NDOC,numdoc);
|
||||
if (_docfile->read() == NOERR) // Legge il documento
|
||||
{
|
||||
_docfile->put(DOC_STATO,_final_doc_status);
|
||||
_docfile->rewrite();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return _error;
|
||||
}
|
||||
|
||||
void TGenerazioneEffetti_app::display_error()
|
||||
{
|
||||
TString msg;
|
||||
@ -312,6 +414,18 @@ void TGenerazioneEffetti_app::display_error()
|
||||
msg.format("Rilevato un codice pagamento non esistente relativamente al documento %s/%ld."
|
||||
"Verificare l'esistenza del codice pagamento inserito.",(const char*)numerazione,numero);
|
||||
break;
|
||||
case scadenze_error:
|
||||
msg.format("Calcolate 0 scadenze relativamente al documento %s/%ld."
|
||||
"Verificare la correttezza del codice pagamento inserito.",(const char*)numerazione,numero);
|
||||
break;
|
||||
case write_error:
|
||||
if (_efffile->status() != NOERR)
|
||||
msg.format("Si e' verificato l' errore %d in scrittura sul file effetti relativamente al documento %s/%ld"
|
||||
"Verificare la consistenza del file.",_efffile->status(),(const char*)numerazione,numero);
|
||||
else
|
||||
msg.format("Si e' verificato l' errore %d in scrittura sul file righe effetti relativamente al documento %s/%ld"
|
||||
"Verificare la consistenza del file.",_refffile->status(),(const char*)numerazione,numero);
|
||||
break;
|
||||
default:
|
||||
msg.format("E' stato rilevato un errore generico contabilizzando il documento %s/%ld.",
|
||||
(const char*)numerazione,numero);
|
||||
@ -322,20 +436,415 @@ void TGenerazioneEffetti_app::display_error()
|
||||
_can_write = FALSE; // But from now on u cannot write anymore. U must exit this program and repair errors occurred.
|
||||
}
|
||||
|
||||
// Criteri di raggruppamento effetti.
|
||||
// Un documento puo' essere raggruppato con i seguenti criteri:
|
||||
// - flag di raggruppamento effetti a TRUE (obbligatorio)
|
||||
// - cliente (obbligatorio)
|
||||
// - valuta (obbligatorio)
|
||||
// - data scadenza (opzionale)
|
||||
// - flag di sosp. d'imposta (opzionale)
|
||||
// - cambio valuta (opzionale)
|
||||
// - cond di pagamento (opzionale)
|
||||
// - banca (opzionale)
|
||||
// - tipo doc. (opzionale)
|
||||
// - cod. numerazione (opzionale)
|
||||
// - agente (opzionale)
|
||||
// I parametri opzionali sono decisi nella tabella elaborazioni
|
||||
// Spiegazione del raggruppamento:
|
||||
// Il raggruppamento di documenti diversi in uno stesso effetto consiste nella creazione
|
||||
// di piu' righe dello stesso effetto.
|
||||
// Ad esempio supponiamo di avere il cliente 10 con 4 fatture ognuna con condizioni di pagamento diverse
|
||||
// la fattura 1 e' suddivisa in 2 rate (10.000 + 30.000)
|
||||
// la fattura 2 e' suddivisa in 4 rate (15.000 + 20.000 + 25.000 + 30.000)
|
||||
// la fattura 3 e' suddivisa in 5 rate (20.000 + 40.000 + 80.000 + 160.000 + 320.000)
|
||||
// la fattura 4 e' suddivisa in 3 rate (50.000 + 100.000 + 150.000)
|
||||
// Il numero di effetti generati equivale al massimo numero di rate (5 in questo caso)
|
||||
// quindi avremo 5 effetti:
|
||||
// il primo avra' 4 righe (prima rata di tutte le fatture)
|
||||
// il secondo avra' 4 righe (seconda rata di tutte le fatture)
|
||||
// il terzo avra' 3 righe (terza rata delle fatture 2,3,4)
|
||||
// il quarto avra' 2 righe (quarta rata delle fatture 2 e 3)
|
||||
// il quinto avra' 1 riga (quinta rata della fattura 3)
|
||||
// La testata di ogni effetto conterra' il totale (somma) dei singoli importi delle righe
|
||||
// ovvero:
|
||||
// tot. primo effetto: 95.000
|
||||
// tot. secondo effetto: 190.000
|
||||
// tot. terzo effetto: 255.000
|
||||
// tot. quarto effetto: 190.000
|
||||
// tot. quinto effetto: 320.000
|
||||
// I dati della testata (soprattutto la data di scadenza) di ogni effetto vengono presi dal
|
||||
// primo documento valido per la generazione dell'effetto corrente:
|
||||
// per i primi due effetti vale la fattura 1
|
||||
// per gli effetti 3 e 4 vale la fattura 2
|
||||
// per l'effetto 5 vale la fattura 3.
|
||||
// Questo e' quanto ho appreso (Hope I'm right...) ;-)
|
||||
|
||||
void TGenerazioneEffetti_app::add_to_group_list()
|
||||
{
|
||||
TString key;
|
||||
TToken_string t("",'$');
|
||||
build_group_key(key);
|
||||
build_doc_key(t);
|
||||
|
||||
const bool is_key = _group_array.is_key(key);
|
||||
TToken_string tt(is_key ? (TToken_string&) _group_array[key]: "");
|
||||
tt.add(t);
|
||||
_group_array.add(key,tt, is_key ? TRUE : FALSE);
|
||||
}
|
||||
|
||||
void TGenerazioneEffetti_app::build_group_key(TString& key)
|
||||
{
|
||||
long cli = _doc->get_long(DOC_CODCF);
|
||||
TString16 val(_doc->get(DOC_CODVAL));
|
||||
|
||||
// campi obbligatori
|
||||
key.format("%7ld%3s",cli,(const char*)val);
|
||||
// campi opzionali
|
||||
if (_group_by_date)
|
||||
key << _doc->get(DOC_DATAINSC);
|
||||
// Qual'e' il flag di sospensione d'imposta del documento ??
|
||||
// if (_group_by_sosp)
|
||||
// key << _doc->get(DOC_????);
|
||||
if (_group_by_change)
|
||||
key << _doc->get(DOC_CAMBIO);
|
||||
if (_group_by_pag)
|
||||
key << _doc->get(DOC_CODPAG);
|
||||
if (_group_by_bank)
|
||||
{
|
||||
key << _doc->get(DOC_CODABIA); // banca cliente
|
||||
key << _doc->get(DOC_CODCABA);
|
||||
}
|
||||
if (_group_by_type)
|
||||
key << _doc->get(DOC_TIPODOC);
|
||||
if (_group_by_num)
|
||||
key << _doc->get(DOC_CODNUM);
|
||||
if (_group_by_agent)
|
||||
key << _doc->get(DOC_CODAG);
|
||||
}
|
||||
|
||||
void TGenerazioneEffetti_app::build_doc_key(TToken_string& key)
|
||||
{
|
||||
key.add(_doc->get(DOC_PROVV));
|
||||
key.add(_doc->get(DOC_ANNO));
|
||||
key.add(_doc->get(DOC_CODNUM));
|
||||
key.add(_doc->get(DOC_NDOC));
|
||||
}
|
||||
|
||||
void TGenerazioneEffetti_app::set_options()
|
||||
{
|
||||
TTable eld("%ELD");
|
||||
eld.put("CODTAB",_cod_el);
|
||||
if (eld.read() == NOERR)
|
||||
{
|
||||
TString s1;
|
||||
s1.format("%-20s",(const char*)eld.get("S1")); // Forzo la sua lunghezza a 20 per evitare subscript errors
|
||||
_group_by_date = s1[12] == 'X';
|
||||
_group_by_sosp = s1[13] == 'X';
|
||||
_group_by_change = s1[0] == 'X';
|
||||
_group_by_pag = s1[4] == 'X';
|
||||
_group_by_bank = s1[5] == 'X';
|
||||
_group_by_type = s1[2] == 'X';
|
||||
_group_by_num = s1[3] == 'X';
|
||||
_group_by_agent = s1[7] == 'X';
|
||||
}
|
||||
}
|
||||
|
||||
void TGenerazioneEffetti_app::calc_pagamento(TString16& codpag,const real& totale_fatt, TString16& data, const bool valuta, const real& change)
|
||||
{
|
||||
_pagamento = new TPagamento(codpag, data);
|
||||
real totspese = _doc->spese();
|
||||
real totimposte = _doc->imposta();
|
||||
real totimponibili = totale_fatt - totimposte - totspese;
|
||||
if (valuta)
|
||||
{
|
||||
real val1 = totimponibili * change;
|
||||
real val2 = totimposte * change;
|
||||
real val3 = totspese * change;
|
||||
_pagamento->set_total_valuta( totimponibili, totimposte, totspese, change, val1, val2 ,val3);
|
||||
}
|
||||
else
|
||||
_pagamento->set_total( totimponibili, totimposte, totspese );
|
||||
_pagamento->set_rate_auto( );
|
||||
}
|
||||
|
||||
error_type TGenerazioneEffetti_app::write_groups()
|
||||
{
|
||||
const int items = _effetti_array.items();
|
||||
int err = NOERR;
|
||||
_error = no_error;
|
||||
for (int i = 0; i<items && err == NOERR; i++) // scorre gli effetti generati e li scrive su file
|
||||
{
|
||||
TEffetto& effetto = (TEffetto&)_effetti_array[i];
|
||||
err = effetto.write(*_efffile); // Pensa a tutto lui per rinumerare...
|
||||
}
|
||||
if (err != NOERR)
|
||||
{
|
||||
i--;
|
||||
for (int j = 0; j<i; j++) // rimuove gli effetti raggruppati, per non lasciare documenti raggruppati parzialmente
|
||||
{
|
||||
TEffetto& effetto = (TEffetto&)_effetti_array[j];
|
||||
// posso fare tranquillamente la remove, visto che la numerazione dell'effetto e' gia' stata effettuata
|
||||
effetto.remove(*_efffile);
|
||||
}
|
||||
error_box("Errore %d nella scrittura gruppi di effetti. Nessun raggruppamento effettuato.",err);
|
||||
}
|
||||
return _error;
|
||||
}
|
||||
|
||||
void TGenerazioneEffetti_app::generate_bill() // bill in inglese significa anche effetto eheheh ;-)
|
||||
{
|
||||
if (good() && _can_write)
|
||||
if (write_all() == no_error) // Se la scrittura e' andata ok...
|
||||
// That's my JOB!
|
||||
// Ogni fattura rata della fattura (si parla di effetti attivi per ora) genera 1 effetto.
|
||||
// con almeno una riga.
|
||||
// Ad es. Se ho una fattura suddivisa in 3 rate essa generera' 3 effetti con una riga.
|
||||
// Nel caso si decida di raggruppare gli effetti (vedi criteri di raggruppamento)
|
||||
// avro' un effetto con tante righe quante scadenze di fattura sono raggruppabili
|
||||
// Le fatture possono generare effetti solo per i seguenti tipi di pagamento:
|
||||
// 2 - Tratta
|
||||
// 3 - Ri.Ba.
|
||||
// 5 - Paghero'
|
||||
// 7 - Tratta accettata
|
||||
// 8 - Rapporti interbancari diretti
|
||||
// Caso mai tale insieme risultasse incompleto od errato basta solo modificare l'enum posto all'inizio del programma
|
||||
|
||||
TString16 codpag(_doc->get(DOC_CODPAG));
|
||||
|
||||
_cpg->put("CODTAB",codpag);
|
||||
if (_cpg->read()!= NOERR)
|
||||
{
|
||||
_error = codpag_error;
|
||||
return;
|
||||
}
|
||||
TString16 data(_doc->get(DOC_DATAINSC));
|
||||
const real totale_fatt = _doc->totale_doc(); // Importo in valuta
|
||||
const bool valuta = _doc->in_valuta();
|
||||
const real change = _doc->cambio();
|
||||
|
||||
// calcolo delle scadenze
|
||||
calc_pagamento(codpag,totale_fatt,data,valuta,change);
|
||||
|
||||
CHECK(_pagamento,"Failed to create a TPagamento");
|
||||
const int numrate = _pagamento->n_rate( );
|
||||
if (numrate < 1)
|
||||
{
|
||||
_error = scadenze_error;
|
||||
return;
|
||||
}
|
||||
|
||||
_efffile->last();
|
||||
// Variabili per la scrittura dell'effetto
|
||||
long nprog = _efffile->get_long(EFF_NPROGTR)+1;
|
||||
const long codcf = _doc->get_long(DOC_CODCF);
|
||||
const TString16 codval(_doc->get(DOC_CODVAL));
|
||||
const TDate data_cambio = _doc->get_date(DOC_DATACAMBIO);
|
||||
const long codabi = _doc->get_long(DOC_CODABIA);
|
||||
const long codcab = _doc->get_long(DOC_CODCABA);
|
||||
const TString16 provv(_doc->get(DOC_PROVV));
|
||||
const int anno = _doc->get_int(DOC_ANNO);
|
||||
const TString16 codnum(_doc->get(DOC_CODNUM));
|
||||
const long nfatt = _doc->get_long(DOC_NDOC);
|
||||
const TDate datafatt = _doc->get_date(DOC_DATADOC);
|
||||
TRectype& effetto = _efffile->curr();
|
||||
TRectype& reffetto = _refffile->curr();
|
||||
real importo;
|
||||
for (int i = 0; i < numrate && good(); i++)
|
||||
{
|
||||
effetto.zero();
|
||||
reffetto.zero();
|
||||
effetto.put(EFF_NPROGTR,nprog);
|
||||
effetto.put(EFF_DATASCAD, _pagamento->data_rata(i));
|
||||
effetto.put(EFF_TIPOPAG,_pagamento->tipo_rata(i));
|
||||
effetto.put(EFF_ULTCLASS,_pagamento->ulc_rata(i));
|
||||
effetto.put(EFF_CODCF, codcf);
|
||||
effetto.put(EFF_CODVAL, codval);
|
||||
if (valuta)
|
||||
{
|
||||
effetto.put(EFF_CAMBIO, change);
|
||||
effetto.put(EFF_DATACAMBIO,data_cambio);
|
||||
}
|
||||
effetto.put(EFF_CODABI,codabi);
|
||||
effetto.put(EFF_CODCAB,codcab);
|
||||
effetto.put(EFF_EFFCOMP,TRUE);
|
||||
if (i == numrate - 1) effetto.put(EFF_ULTRATA,TRUE);
|
||||
// Put sulla riga dell'effetto
|
||||
reffetto.put(REFF_NPROGTR,nprog);
|
||||
reffetto.put(REFF_NRIGATR,1);
|
||||
reffetto.put(REFF_DATAFATT, datafatt);
|
||||
reffetto.put(REFF_PROVV,provv);
|
||||
reffetto.put(REFF_ANNODOC,anno);
|
||||
reffetto.put(REFF_CODNUM,codnum);
|
||||
reffetto.put(REFF_NFATT,nfatt);
|
||||
importo = _pagamento->importo_rata(i,FALSE);
|
||||
effetto.put(EFF_IMPORTO,importo);
|
||||
reffetto.put(REFF_IMPFATT,totale_fatt);
|
||||
reffetto.put(REFF_IMPORTO,importo);
|
||||
if (valuta)
|
||||
{
|
||||
importo = _pagamento->importo_rata(i,TRUE); // Importo in valuta
|
||||
real totfatlit = totale_fatt*change; //Not sure about this...
|
||||
effetto.put(EFF_IMPORTOVAL,importo);
|
||||
reffetto.put(REFF_IMPFATTVAL,totale_fatt);
|
||||
reffetto.put(REFF_IMPFATT,totfatlit);
|
||||
reffetto.put(REFF_IMPORTOVAL,importo);
|
||||
}
|
||||
|
||||
if (_efffile->write() == NOERR && _refffile->write() == NOERR)
|
||||
{
|
||||
_total_bills++;
|
||||
change_doc_status();
|
||||
nprog++;
|
||||
}
|
||||
else _error = write_error;
|
||||
}
|
||||
|
||||
if (_pagamento) delete _pagamento;
|
||||
if (good() && _can_write)
|
||||
change_doc_status();
|
||||
}
|
||||
|
||||
void TGenerazioneEffetti_app::group_bills()
|
||||
{
|
||||
// Bail out if there aren't items...
|
||||
_error = no_error;
|
||||
const int items = _group_array.items();
|
||||
if (items == 0) return;
|
||||
|
||||
int i=0,j,n,offset=0;
|
||||
TString msg1,msg2;
|
||||
TString16 codpag;
|
||||
real imprata, imprataval, importo, importoval;
|
||||
msg1 = "Raggruppamento effetti ";
|
||||
msg1 << "dal ";
|
||||
msg1 << _data_ini.string() << " al ";
|
||||
msg1 << _data_fine.string();
|
||||
|
||||
#ifdef DBG
|
||||
TProgind p(items,msg1,TRUE,TRUE,1);
|
||||
#else
|
||||
TProgind p(items,msg1,FALSE,TRUE,1);
|
||||
#endif
|
||||
TToken_string * group_element;
|
||||
// Ciclo sugli elementi dell'assoc_array
|
||||
for (group_element = (TToken_string *) _group_array.first_item(); group_element != NULL && i < items; i++,group_element = (TToken_string*)_group_array.succ_item())
|
||||
{
|
||||
#ifdef DBG
|
||||
if (p.iscancelled()) break;
|
||||
#endif
|
||||
p.setstatus(i+1);
|
||||
// Ciclo sui documenti da raggruppare
|
||||
group_element->restart();
|
||||
const int doc_items = group_element->items();
|
||||
for (j=0;j<doc_items;j++)
|
||||
{
|
||||
#ifdef DBG
|
||||
if (p.iscancelled()) break;
|
||||
#endif
|
||||
TToken_string t(group_element->get(j),'$');
|
||||
char provv = t.get_char(0);
|
||||
int anno = t.get_int(1);
|
||||
TString codnum(t.get(2));
|
||||
long numdoc = t.get_long(3);
|
||||
if (_doc->read(provv,anno,codnum,numdoc) != NOERR) continue; // Legge il documento (giusto saltare e proseguire se non lo trova?)
|
||||
|
||||
msg2 = "Documento: ";
|
||||
msg2 << codnum << "/" << numdoc;
|
||||
xvt_statbar_set(msg2);
|
||||
do_events();
|
||||
// Ricalcola le scadenze
|
||||
codpag = _doc->get(DOC_CODPAG);
|
||||
|
||||
_cpg->put("CODTAB",codpag);
|
||||
if (_cpg->read()!= NOERR)
|
||||
{
|
||||
_error = codpag_error;
|
||||
return;
|
||||
}
|
||||
TString16 data(_doc->get(DOC_DATAINSC));
|
||||
const real totale_fatt = _doc->totale_doc();
|
||||
const bool valuta = _doc->in_valuta();
|
||||
const real change = _doc->cambio();
|
||||
const TDate datafatt = _doc->get_date(DOC_DATADOC);
|
||||
|
||||
calc_pagamento(codpag,totale_fatt,data,valuta,change);
|
||||
CHECK(_pagamento,"Failed to create a TPagamento");
|
||||
const int numrate = _pagamento->n_rate( );
|
||||
if (numrate < 1)
|
||||
{
|
||||
_error = scadenze_error;
|
||||
return;
|
||||
}
|
||||
|
||||
// Scorre le scadenze
|
||||
for (n = 1; n <= numrate && good(); n++)
|
||||
{
|
||||
// Se non esiste effetto n-esimo (corrisponde al numero di rata corrente+offset)
|
||||
// lo genera con la relativa riga. Se esiste vi somma gli importi ed accoda la riga
|
||||
const bool is_new = n+offset > _effetti_array.items();
|
||||
if (is_new) // Nuovo effetto: crea effetto con i dati di questo documento (e' il primo che incontro nella scansione)
|
||||
{
|
||||
TEffetto effetto;
|
||||
// Setta i dati della testata;
|
||||
effetto.put(EFF_DATASCAD, _pagamento->data_rata(n-1));
|
||||
effetto.put(EFF_TIPOPAG,_pagamento->tipo_rata(n-1));
|
||||
effetto.put(EFF_ULTCLASS,_pagamento->ulc_rata(n-1));
|
||||
effetto.put(EFF_CODCF, _doc->get_long(DOC_CODCF));
|
||||
effetto.put(EFF_CODVAL, _doc->get(DOC_CODVAL));
|
||||
effetto.put(EFF_CAMBIO, change);
|
||||
effetto.put(EFF_DATACAMBIO,_doc->get_date(DOC_DATACAMBIO));
|
||||
effetto.put(EFF_CODABI,_doc->get(DOC_CODABIA));
|
||||
effetto.put(EFF_CODCAB,_doc->get(DOC_CODCABA));
|
||||
effetto.put(EFF_EFFCOMP,TRUE);
|
||||
_effetti_array.add(effetto);
|
||||
}
|
||||
// aggiorna totale effetto (testata)
|
||||
TEffetto& effetto=(TEffetto&)_effetti_array[n+offset-1];
|
||||
importo = effetto.get_real(EFF_IMPORTO);
|
||||
imprata = _pagamento->importo_rata(n-1,FALSE);
|
||||
importo += imprata;
|
||||
effetto.put(EFF_IMPORTO,importo);
|
||||
if (valuta)
|
||||
{
|
||||
importoval = effetto.get_real(EFF_IMPORTOVAL);
|
||||
imprataval = _pagamento->importo_rata(n-1,TRUE);
|
||||
importoval += imprataval;
|
||||
effetto.put(EFF_IMPORTOVAL,importoval);
|
||||
}
|
||||
// Crea la nuova riga di questo effetto
|
||||
const int rows = effetto.rows_r();
|
||||
TRectype& riga = effetto.row_r(rows+1,TRUE);
|
||||
// reffetto.put(REFF_NPROGTR,nprog);
|
||||
riga.put(REFF_NRIGATR,rows+1);
|
||||
riga.put(REFF_DATAFATT, datafatt);
|
||||
riga.put(REFF_PROVV,provv);
|
||||
riga.put(REFF_ANNODOC,anno);
|
||||
riga.put(REFF_CODNUM,codnum);
|
||||
riga.put(REFF_NFATT,numdoc);
|
||||
riga.put(REFF_IMPFATT,totale_fatt);
|
||||
riga.put(REFF_IMPORTO,imprata);
|
||||
if (valuta)
|
||||
{
|
||||
riga.put(REFF_IMPFATTVAL,totale_fatt);
|
||||
real totfatlit = totale_fatt*change;
|
||||
riga.put(REFF_IMPFATT,totfatlit);
|
||||
riga.put(REFF_IMPORTOVAL,imprataval);
|
||||
}
|
||||
} // Ciclo sulle scadenze
|
||||
if (_pagamento) delete _pagamento;
|
||||
} // Ciclo sui documenti di questo gruppo
|
||||
offset=_effetti_array.items();
|
||||
} // Ciclo sui gruppi
|
||||
|
||||
// Cambia lo stato a tutti i documenti raggruppati
|
||||
if (good())
|
||||
if (write_groups() == no_error)
|
||||
{
|
||||
_total_bills += _effetti_array.items();
|
||||
change_group_status();
|
||||
}
|
||||
}
|
||||
|
||||
void TGenerazioneEffetti_app::generate()
|
||||
{
|
||||
TRelation doc_rel(LF_DOC);
|
||||
TLocalisamfile righe_doc(LF_RIGHEDOC);
|
||||
TRectype da(LF_DOC),a(LF_DOC);
|
||||
const long items = _num_sheet->items();
|
||||
int year_from = _data_ini.year();
|
||||
@ -345,6 +854,9 @@ void TGenerazioneEffetti_app::generate()
|
||||
|
||||
|
||||
_total_bills = 0;
|
||||
_group_array.destroy();
|
||||
_effetti_array.destroy();
|
||||
set_options();
|
||||
da.put("DATADOC",_data_ini);
|
||||
da.put("PROVV","D");
|
||||
da.put("ANNO",year_from);
|
||||
@ -374,6 +886,13 @@ void TGenerazioneEffetti_app::generate()
|
||||
TProgind p(cur_items,msg,FALSE,TRUE,1);
|
||||
#endif
|
||||
long j = 0;
|
||||
// Comportamento:
|
||||
// - scorre i documenti della numerazione corrente.
|
||||
// - se e' possibile generare subito l'effetto (tipo di pagamento valido,
|
||||
// stato documento valido e non e' abilitato il raggruppamento) lo fa,
|
||||
// altrimenti compone una lista dei documenti da raggruppare
|
||||
// - alla fine del ciclo per numerazioni scorre la lista residua e genera gli
|
||||
// effetti rimasti
|
||||
#ifdef DBG
|
||||
for (;j<cur_items && !p.iscancelled();j++)
|
||||
#else
|
||||
@ -382,13 +901,22 @@ void TGenerazioneEffetti_app::generate()
|
||||
{
|
||||
p.setstatus(j+1);
|
||||
doc_cur = j;
|
||||
_doc->read(doc_cur.curr()); // legge il documento
|
||||
if (_doc->read(doc_cur.curr()) != NOERR) continue;// legge il documento
|
||||
if (codnum != _doc->get(DOC_CODNUM)) continue; // patch del cazzo
|
||||
if (doc_tipo_stato_ok()) // controlla che il tipo documento e lo stato siano coerenti con la ELD selezionata
|
||||
generate_bill();
|
||||
{
|
||||
if (valid_type(_doc->pagamento().tipo_rata(0))) // il tipo di pagamento puo' generare effetti ?
|
||||
{
|
||||
const bool raggruppabile = _doc->get_bool(DOC_RAGGREFF);
|
||||
if (!_raggruppa || (_raggruppa && !raggruppabile))
|
||||
generate_bill();
|
||||
else
|
||||
add_to_group_list();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// ATTENZIONE!: se non ha ancora cominciato a contabilizzare, eventuali
|
||||
// ATTENZIONE!: se non ha ancora cominciato a generare effetti, eventuali
|
||||
// documenti con tipo o stato differenti vengono semplicemente scartati
|
||||
// senza segnalare errori
|
||||
if (_total_bills > 0)
|
||||
@ -401,9 +929,17 @@ void TGenerazioneEffetti_app::generate()
|
||||
if (p.iscancelled()) break;
|
||||
#endif
|
||||
}
|
||||
// Effettua il raggruppamento di eventuali documenti rimasti
|
||||
if (good())
|
||||
group_bills();
|
||||
|
||||
// Mostra eventuali errori residui
|
||||
if (!good())
|
||||
display_error();
|
||||
|
||||
if (_total_bills > 0)
|
||||
message_box("Totale effetti generati: %ld",_total_bills);
|
||||
|
||||
xvt_statbar_set("");
|
||||
}
|
||||
|
||||
int ve6300 (int argc, char **argv)
|
||||
|
||||
@ -4,4 +4,4 @@
|
||||
#define F_DESC_ELAB 102
|
||||
#define F_DATA_INI 103
|
||||
#define F_DATA_FIN 104
|
||||
|
||||
#define F_RAGGRUPPA 105
|
||||
|
||||
@ -45,6 +45,11 @@ BEGIN
|
||||
WARNING "La data di fine intervallo e' obbligatoria"
|
||||
END
|
||||
|
||||
BOOLEAN F_RAGGRUPPA
|
||||
BEGIN
|
||||
PROMPT 35 6 "Raggruppa effetti"
|
||||
END
|
||||
|
||||
BUTTON DLG_OK 10 2
|
||||
BEGIN
|
||||
PROMPT -13 -1 ""
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user