root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/ps/pg0068100.cpp
luca d2d44d2c31 Patch level : 
Files correlati     :
Ricompilazione Demo : [ ]
Commento            :


git-svn-id: svn://10.65.10.50/trunk@19132 c028cbd2-c16b-5b4b-a496-9718f37d4682
2009-07-24 10:28:08 +00:00

564 lines
16 KiB
C++
Executable File
Raw Blame History

#include <automask.h>
#include <defmask.h>
#include <modaut.h>
#include <progind.h>
#include <relation.h>
#include <sheet.h>
#include <tabutil.h>
#include <viswin.h>
#include "../ca/movana.h"
#include "../ca/rmovana.h"
#include "../ve/velib04.h"
#include "../cg/cgsaldac.h"
#include "pg0068100a.h"
///////////////////////////////////////////////
// MASCHERA
///////////////////////////////////////////////
class TElabollazione_HK_mask : public TAutomask
{
TArray_sheet* _num_sheet;
TString_array _tipi_doc;
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
TElabollazione_HK_mask();
~TElabollazione_HK_mask();
};
TElabollazione_HK_mask::TElabollazione_HK_mask() : TAutomask("pg0068100a")
{
_num_sheet = new TArray_sheet(-1, -1, -4, -4, "Codici numerazione", "@1|Cod. numerazione|Descrizione@50");
}
TElabollazione_HK_mask::~TElabollazione_HK_mask()
{
delete _num_sheet;
}
bool TElabollazione_HK_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
switch (o.dlg())
{
case F_ELAB_COSTI:
case F_ELAB_PROVV:
if (e == fe_modify || e == fe_init)
{
const bool full = !o.empty();
if (full)
build_num_sheet();
enable(DLG_USER, full);
enable(DLG_OK, full && _num_sheet->one_checked());
}
break;
case DLG_USER:
if (e == fe_button && _num_sheet->run())
{
// Hai selezionato qualcosa ? allora abilita il pulsante di conferma
enable(DLG_OK, _num_sheet->one_checked());
}
break;
default:
break;
}
return true;
}
void TElabollazione_HK_mask::build_num_sheet() //(const short field)
{
_num_sheet->destroy();
_tipi_doc.destroy();
const TContabilizzazione_analitica contanal(get(F_ELAB_COSTI));
if (!contanal.empty())
{
TToken_string t;
TString4 tipo;
for (int i = 0; i < TElaborazione::_max_tipi_doc_elab; i++)
{
tipo = contanal.tipo_iniziale(i);
if (tipo.full())
{
t = tipo;
t.add(contanal.stato_iniziale(i)); // Stato iniziale
_tipi_doc.add(t); // Aggiunge questo tipo documento alla lista
}
}
TString s1,s2,s3;
TTable num("%NUM");
for (num.first(); num.good(); num.next()) // scorre tutte le numerazioni possibili
{
TToken_string t,z;
t.add(" ");
t.add(num.get("CODTAB"));
t.add(num.get("S0"));
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(_tipi_doc.row(i).get(0)) >= 0;
if (found)
_num_sheet->add(t);
}
if (_num_sheet->items() == 1)
_num_sheet->check(0);
}
}
bool TElabollazione_HK_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 TString4 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 TString4 tipox(t.get(0));
const char statox = t.get(1)[0];
if (tipo == tipox && stato == statox)
found = true;
}
return found;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
// CLASSI DERIVATE DALLA TContabilizzazione_analitica (con le modifiche per il caso in questione)
////////////////////////////////////////////////////////////////////////////////////////////////////
class TContabilizzazione_analitica_costi : public TContabilizzazione_analitica
{
TString4 _codcaus;
bool _costi;
TCausale * _caus;
public:
virtual bool elabora(TDocumento& doc, long numreg_cg, TViswin* viswin, bool can_write, TAnal_mov& mov,
bool riclassifica_fdr_fde = true);
virtual const TCausale& doc2caus(const TDocumento& doc);
TContabilizzazione_analitica_costi(const TString& codcaus, const char* cod = NULL, bool costi = true)
: TContabilizzazione_analitica(cod), _codcaus(codcaus), _costi(costi), _caus(NULL) {}
TContabilizzazione_analitica_costi(const TString& codcaus, const TRectype& rec, bool costi = true)
: TContabilizzazione_analitica(rec), _codcaus(codcaus), _costi(costi), _caus(NULL) {}
virtual ~TContabilizzazione_analitica_costi() {}
};
const TCausale& TContabilizzazione_analitica_costi::doc2caus(const TDocumento& doc)
{
if (_caus == NULL)
_caus = new TCausale(_codcaus);
return *_caus;
}
bool TContabilizzazione_analitica_costi::elabora(TDocumento& doc, long numreg_cg, TViswin* viswin, bool can_write,
TAnal_mov& mov, bool riclassifica_fdr_fde)
{
TDate datareg, datacomp, datadoc;
int annoes = 0;
TString descr, msg, codcaus;
TCausale caus(_codcaus);
datadoc = doc.get(DOC_DATADOC);
datareg = datacomp = datadoc;
annoes = esercizi().date2esc(datareg);
doc.riferimento(descr);
if (descr.empty())
descr = doc.tipo().descrizione();
const TString8 rif = doc.get(DOC_NUMDOCRIF);
codcaus = caus.codice();
const bool use_rif = caus.iva() == iva_acquisti && rif.not_empty();
if (use_rif)
{
descr << TR(" n. ") << rif;
descr << TR(" del ") << doc.get(DOC_DATADOCRIF);
}
else
{
descr << TR(" n. ") << doc.numero();
descr << TR(" del ") << datadoc;
}
//..e quindi dovrebbe sempre bastare sezione = 'D'
char sezione = 'D';
//questo non dovrebbe mai capitare!...
if (doc.is_nota_credito())
sezione = 'A';
const int decimals = TCurrency::get_firm_dec();
//in caso di righe doc di costo -> sul doc usa numregca, in caso di righe provvigione usa un campo virtuale..
//..NUMREGCAPR; questo <20> per poter avere i movimenti distinti (costi - provvigioni) e per poter collegare..
//..movana e doc di origine nei 2 versi
TString field_name(DOC_NUMREGCA);
if (!_costi)
field_name = "NUMREGCAPR";
long numreg_ca = doc.get_long(field_name);
if (numreg_ca > 0)
{
const int err = mov.read(numreg_ca);
if (err == NOERR)
{
if (viswin != NULL)
{
msg.format("--- Il documento verr<72> ricontabilizzato nel movimento analitico %ld", numreg_ca);
viswin->add_line(msg);
}
mov.body().destroy_rows();
}
else
mov.put(MOVANA_NUMREG, numreg_ca = 0);
}
mov.put(MOVANA_DATAREG, datareg);
mov.put(MOVANA_DATACOMP, datacomp);
mov.put(MOVANA_DATADOC, datadoc);
mov.put(MOVANA_ANNOES, annoes);
mov.put(MOVANA_DESCR, descr);
mov.put(MOVANA_NUMREGCG, numreg_cg);
mov.put(MOVANA_CODCAUS, caus.codice());
mov.put(MOVANA_DPROVV, doc.get(DOC_PROVV)); // Documento originale
mov.put(MOVANA_DANNO, doc.get(DOC_ANNO));
mov.put(MOVANA_DCODNUM, doc.get(DOC_CODNUM));
mov.put(MOVANA_DNDOC, doc.get(DOC_NDOC));
TImporto totdoc; // Totale movimento analitico
const TipoIVA tiva = caus.iva();
TBill bill; caus.bill(RIGA_IVA_NON_DETRAIBILE, bill);
// Scandisco le righe del documento,
int i;
for (i = 1; i <= doc.physical_rows(); i++)
{
const TRiga_documento& riga = doc[i];
bool pareggio = false;
// salto descrizioni, e omaggi
if (riga.is_descrizione() || riga.is_omaggio())
continue;
// salto valori nulli
const real qta = riga.get(RDOC_QTA);
const real costo = riga.articolo().get_real(ANAMAG_ULTCOS1);
real valore;
if (_costi)
valore = qta * costo;
else
valore = riga.provvigione();
if (valore.is_zero())
continue;
if (tiva != iva_vendite && !riga.is_sconto())
{
const TString4 tipodet = riga.get(RDOC_TIPODET);
int td;
const real pind = indetraibile_al(tipodet, caus, datareg.year(), td);
if (pind > ZERO)
{
const real imposta = riga.iva().imposta(valore);
const real ivaind = (imposta * pind) / CENTO;
if (bill.ok())
{
if (bill.is_analitico())
{
TString_array conti_ind;
const char tipomov = mov.get_char(MOVANA_TIPOMOV);
if (find_conti_iva_indetraibile(riga, bill, conti_ind, annoes, tipomov, pareggio)) //qui
{
TGeneric_distrib esso(ivaind, decimals);
init_distrib(conti_ind, esso, pareggio);
FOR_EACH_ARRAY_ROW(conti_ind, j, row_ind)
{
TRectype& rmov = mov.new_row();
rmov.put(RMOVANA_ANNOES, annoes);
rmov.put(RMOVANA_CODCONTO, row_ind->get(0));
rmov.put(RMOVANA_CODCCOSTO,row_ind->get());
rmov.put(RMOVANA_CODCMS, row_ind->get());
rmov.put(RMOVANA_CODFASE, row_ind->get());
rmov.put(RMOVANA_DESCR, riga.get(RDOC_DESCR));
const bool negative = pareggio && j > 0;
const bool totale = pareggio && j == 0;
TImporto imp(sezione, totale ? ivaind : real(esso.get()));
if (negative)
imp.swap_section();
imp.normalize();
rmov.put(RMOVANA_SEZIONE, imp.sezione());
rmov.put(RMOVANA_IMPORTO, imp.valore());
totdoc += imp;
}
}
}
}
else
valore += ivaind;
}
}
if (valore.is_zero())
continue;
TString_array conti;
const char tipomov = mov.get_char(MOVANA_TIPOMOV);
const bool ok = find_conti(riga, conti, annoes, riclassifica_fdr_fde, tipomov, pareggio);
if (!ok)
{
if (viswin != NULL)
{
TString msg;
msg.format(FR("*** Riga %d: Manca il conto analitico dell'articolo '%s'"), i, (const char*)riga.get(RDOC_CODART));
viswin->add_line(msg);
}
//_error = conto_error;
can_write = false;
continue;
}
TGeneric_distrib esso(valore, decimals);
init_distrib(conti, esso, pareggio);
FOR_EACH_ARRAY_ROW(conti, i, row)
{
TRectype& rmov = mov.new_row();
rmov.put(RMOVANA_ANNOES, annoes);
rmov.put(RMOVANA_CODCONTO, row->get(0));
rmov.put(RMOVANA_CODCCOSTO,row->get());
rmov.put(RMOVANA_CODCMS, row->get());
rmov.put(RMOVANA_CODFASE, row->get());
rmov.put(RMOVANA_DESCR, riga.get(RDOC_DESCR));
const bool negative = pareggio && i > 0;
const bool totale = pareggio && i == 0;
TImporto imp(sezione, totale ? valore : real(esso.get()));
if (negative)
imp.swap_section();
imp.normalize();
rmov.put(RMOVANA_SEZIONE, imp.sezione());
rmov.put(RMOVANA_IMPORTO, imp.valore());
totdoc += imp;
}
}
if (can_write && mov.rows() > 0)
{
totdoc.normalize();
mov.put(MOVANA_SEZIONE, totdoc.sezione());
mov.put(MOVANA_TOTDOC, totdoc.valore());
TLocalisamfile movana(LF_MOVANA);
if (numreg_ca > 0)
mov.rewrite(movana);
else
{
mov.write(movana);
numreg_ca = mov.get_long(MOVANA_NUMREG);
doc.put(field_name, numreg_ca);
}
if (viswin != NULL)
{
msg.format(FR("--- Movimento analitico $[r,w]%ld$[n,w] del %s"), numreg_ca, datacomp.string());
viswin->add_line(msg);
}
}
return can_write;
}
class TContabilizzazione_analitica_provvigioni : public TContabilizzazione_analitica_costi
{
public:
TContabilizzazione_analitica_provvigioni(const TString& codcaus, const char* cod = NULL)
: TContabilizzazione_analitica_costi(codcaus, cod, false) {}
TContabilizzazione_analitica_provvigioni(const TString& codcaus, const TRectype& rec)
: TContabilizzazione_analitica_costi(codcaus, rec, false) {}
virtual ~TContabilizzazione_analitica_provvigioni() {}
};
//////////////////////////////////////////////
// APPLICAZIONE
/////////////////////////////////////////////
// TElabollazione_HK
// Applicazione di contabilizzazione documenti
class TElabollazione_HK_app : public TSkeleton_application
{
TElabollazione_HK_mask* _msk;
virtual bool check_autorization() const {return false;}
virtual const char * extra_modules() const {return "ve";}
protected: // TApplication
// Contabilizza i documenti
void contabilize();
public:
virtual bool create();
virtual bool destroy();
virtual void main_loop();
};
void TElabollazione_HK_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(TODAY);
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);
}
// 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(DOC_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_costi = _msk->get(F_ELAB_COSTI);
TContabilizzazione_analitica_costi contanal_costi(_msk->get(F_CAUS_COSTI), elaborazione_costi);
contanal_costi.TContabilizzazione_analitica::elabora(lista_in, lista_out, data_reg);
if (contanal_costi.processed_docs() > 0L)
message_box(FR("Totale documenti di costo contabilizzati: %ld"), contanal_costi.processed_docs());
TString16 elaborazione_provv = _msk->get(F_ELAB_PROVV);
TContabilizzazione_analitica_provvigioni contanal_provv(_msk->get(F_CAUS_PROVV), elaborazione_provv);
contanal_provv.TContabilizzazione_analitica::elabora(lista_in, lista_out, data_reg);
if (contanal_provv.processed_docs() > 0L)
message_box(FR("Totale documenti di provvigione contabilizzati: %ld"), contanal_provv.processed_docs());
}
else
warning_box(TR("Non vi sono documenti da contabilizzare per le numerazioni selezionate."));
xvtil_statbar_set("");
}
bool TElabollazione_HK_app::create()
{
//se non ha le vendite e l'analitica <20> impossibile da utilizzare
if (!has_module(VEAUT) || !has_module(CAAUT))
return error_box(TR("Modulo non autorizzato"));
//open_files(LF_TABCOM, LF_TAB, LF_DOC, LF_RIGHEDOC, LF_MOVANA, LF_RMOVANA, 0);
_msk = new TElabollazione_HK_mask();
return TSkeleton_application::create();
}
bool TElabollazione_HK_app::destroy()
{
if (_msk) delete _msk;
return TSkeleton_application::destroy();
}
void TElabollazione_HK_app::main_loop()
{
while (_msk->run() == K_ENTER)
contabilize();
}
int pg0068100 (int argc, char **argv)
{
TElabollazione_HK_app a;
a.run(argc,argv, TR("Contabilizzazione Hair Kulture"));
return true;
}
Reference in New Issue View Git Blame Copy Permalink