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

Patch level :4.0 628

Browse Source 
Files correlati     :
Ricompilazione Demo : [ ]
Commento            :corretto errore su causali senza tipomovimento nel rendiconto; committato nuova versione di bilancio commessa ca3800 e stampa ca3900


git-svn-id: svn://10.65.10.50/trunk@14936 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
luca 2007-02-20 15:10:44 +00:00
parent 4828c63331
commit ce008d2031
10 changed files with 606 additions and 777 deletions

13
ca/ca3700.cpp

@ -759,7 +759,7 @@ F=IMF*/
TImporto imp(sezione, rmovana.get_real(RMOVANA_IMPORTO));
TipoIVA tipoiva = caus.iva(); //tipo iva legato alla causale (codcaus e' letto ad inizio procedura)
char sezione_normale;
char sezione_normale = sezione; //inizializza la sezione normale a sezione per evitare vuoti
if (tipoiva == iva_vendite)
sezione_normale = 'A';
@ -769,10 +769,13 @@ F=IMF*/
else
if (tipoiva == nessuna_iva)
{
if (caus.sezione_clifo() == 'D')
sezione_normale = 'A';
else
sezione_normale = 'D';
if (caus.tipomov() > 0) //non e' stato specificato un tipo movimento nella causale (porcata)
{
if (caus.sezione_clifo() == 'D')
sezione_normale = 'A';
else
sezione_normale = 'D';
}
}
else
{ //iva errata -> non ha causali -> cerca di capire se cliente o fornitore

437
ca/ca3800.cpp

@ -1,20 +1,12 @@
#include <applicat.h>
#include <execp.h>
#include <progind.h>
#include <reprint.h>
#include "../cg/cglib01.h"
#include "ca3.h"
#include "ca3800.h"
#include "ca3883.h"
#include "ca3883a.h"
#include "calib01.h"
#include "calib02.h"
#include "commesse.h"
#include "fasi.h"
#include "panapdc.h"
#include "pconana.h"
#include "saldana.h"
////////////////////////////////////////////////////////
// MASCHERA
@ -145,438 +137,17 @@ TPrint_bilancio_cms_mask::TPrint_bilancio_cms_mask()
set_handlers();
}
const TFixed_string CMS_DEL_CAZZO("@@@@@@@@@@@@@@@@@@@@");
///////////////////////////////////////////////////////////////
// RECORDSET
///////////////////////////////////////////////////////////////
class TPrint_bilancio_cms_recordset : public TRecordset
class TPrint_bilancio_cms_recordset : public TPrint_saldana_recordset
{
TArray _righe;
TRecnotype _curr;
TArray _colonne;
TIndbil_cache _indicatori;
TEsercizi_contabili _esc;
private:
int _anno;
int _depth;
bool _vitaintera, _use_fasi;
char _tipostima;
protected:
virtual TRecnotype items() const { return _righe.items(); }
virtual bool move_to(TRecnotype pos);
virtual TRecnotype current_row() const { return _curr; }
virtual void requery();
virtual const TString& query_text() const { return EMPTY_STRING; }
virtual unsigned int columns() const { return _colonne.items(); }
virtual const TRecordset_column_info& column_info(unsigned int column) const { return (TRecordset_column_info&) _colonne[column]; }
virtual const TVariant& get(unsigned int column) const;
virtual const TVariant& get(const char* column_name) const;
void parse_bill(const TString& bill, TString& conto) const;
int estrai_saldi(const TRecordset& saldana, const int indbil,
TImporto& saldo, TImporto& saldop) const;
void aggiorna_importo(TAssoc_array& riga_array, const TString& livello,
const int indbil, const TRecordset& saldana, const bool inverti = false) const;
real calcola_avanzamento_tempo() const;
TAssoc_array& get_row(TAssoc_array& cms, const char* chiave,
const int indice, const TString& codcms, const TString& fase,
const TString& descrizione);
public:
virtual void set_filter(const TPrint_bilancio_cms_mask& msk);
TPrint_bilancio_cms_recordset() : TPrint_saldana_recordset(8) {}
};
bool TPrint_bilancio_cms_recordset::move_to(TRecnotype pos)
{
_curr = pos;
return pos >= 0 && pos < items();
}
void TPrint_bilancio_cms_recordset::parse_bill(const TString& bill, TString& conto) const
{
TConfig& cfg = ca_config();
const TMultilevel_code_info& pconana_info = ca_multilevel_code_info(LF_PCONANA);
const int pconana_levels = pconana_info.levels();
const int prefix = cfg.get_int("PdcPrefix")-1;
//lunghezza dell'eventuale prefisso di gruppo e conto
const int prefix_len = (prefix >= 0) ? pconana_info.total_len(prefix) : 0;
//quanto e' lungo il codice del conto da considerare? E' il livello - il prefisso
const int conto_end = pconana_info.total_len(_depth) - prefix_len;
//stringa con cio' che segue il prefisso ed e' richiesto
conto = bill.mid(prefix_len, conto_end);
}
int TPrint_bilancio_cms_recordset::estrai_saldi(const TRecordset& saldana, const int indbil,
TImporto& saldo, TImporto& saldop) const
{
int flag = 0;
if (_tipostima == 'C' && indbil == 3)
{
const TImporto imp_saldo(saldana.get(SALDANA_SEZIONE).as_string()[0],
saldana.get(SALDANA_SALDO).as_real());
saldo = imp_saldo;
flag |= saldo.is_zero() ? 0 : 1;
}
else
saldo.reset();
if (_tipostima == 'T' || (_tipostima == 'C' && indbil == 4)) //stima Tempo o (Costi e indbil=ricavo)
{
const TImporto imp_saldop(saldana.get(SALDANA_SEZIONEP).as_string()[0],
saldana.get(SALDANA_SALDOP).as_real());
const TImporto imp_saldov(saldana.get(SALDANA_SEZIONEV).as_string()[0],
saldana.get(SALDANA_SALDOV).as_real());
saldop = imp_saldop;
saldop += imp_saldov;
flag |= saldop.is_zero() ? 0 : 2;
}
else
saldop.reset();
return flag;
}
void TPrint_bilancio_cms_recordset::aggiorna_importo(TAssoc_array& riga_array,
const TString& livello, const int indbil, const TRecordset& saldana, const bool inverti) const
{
TString* str_imp = (TString*)riga_array.objptr(livello);
if (str_imp == NULL)
{
str_imp = new TString;
riga_array.add(livello, str_imp);
}
//dare o avere?
const char sezione = indbil == 3 ? 'D' : 'A';
TImporto imp(sezione, real(*str_imp));
//ci sono tutti i tipi di saldo, ma solo quelli che rientrano nei parametri iniziali..
//..verranno considerati (_tipostima,indbil)
TImporto imp_saldo, imp_saldop;
estrai_saldi(saldana, indbil, imp_saldo, imp_saldop);
if (inverti) // Devo sottrarre l'importo = gli scambio la sezione
{
imp_saldo.swap_section();
imp_saldop.swap_section();
}
imp += imp_saldo;
imp += imp_saldop;
imp.normalize(sezione);
*str_imp = imp.valore().string();
}
TAssoc_array& TPrint_bilancio_cms_recordset::get_row(TAssoc_array& cms, const char* chiave,
const int indice, const TString& codcms, const TString& fase,
const TString& descrizione)
{
//cerca se la commessa (e l'eventuale fase) esistono gia' nell'assocarray delle commesse
TAssoc_array* riga_array = (TAssoc_array*)cms.objptr(chiave);
//se non esiste la crea!
if (riga_array == NULL)
{
riga_array = new TAssoc_array;
TString4 str_indice; //l'indice va stringato per l'assoc_array
str_indice << indice;
riga_array->add("LEVEL", str_indice);
riga_array->add("CODCMS", codcms);
riga_array->add("FASE", fase);
riga_array->add("DESCRIZ", descrizione);
//inizializza i campi importo sicuramente presenti (modifica DECISIVA)
//senza questa inizializzazione, nel caso trovasse campi nulli (in realta' 0), il bastardo..
//..anziche' considerarli 0 ci mette l'ultimo valore != che ha in memoria nella stessa posizione..
//..facendo sballare tutti i conti!
riga_array->add("RICAVI", EMPTY_STRING);
riga_array->add("COSTI", EMPTY_STRING);
//aggiunge la riga all'array-one
cms.add(chiave, riga_array);
}
return *riga_array;
}
static int righe_compare(const TObject** o1, const TObject** o2)
{
TAssoc_array& a1 = *(TAssoc_array*)*o1;
TAssoc_array& a2 = *(TAssoc_array*)*o2;
int cmp = 0;
const int l1 = atoi(*(TString*)a1.objptr("LEVEL"));
const int l2 = atoi(*(TString*)a2.objptr("LEVEL"));
cmp = l1 - l2;
if (cmp == 0)
{
const TString& c1 = *(TString*)a1.objptr("CODCMS");
const TString& c2 = *(TString*)a2.objptr("CODCMS");
cmp = c1.compare(c2);
if (cmp == 0)
{
const TString& f1 = *(TString*)a1.objptr("FASE");
const TString& f2 = *(TString*)a2.objptr("FASE");
cmp = f1.compare(f2);
}
else
{
const int z1 = c1.starts_with("DETR_");
const int z2 = c2.starts_with("DETR_");
if (z1 || z2)
cmp = z1 - z2;
}
}
return cmp;
}
void TPrint_bilancio_cms_recordset::requery()
{
//prende le date di inizio e fine dell'eserizio selezionato sulla maschera
TEsercizi_contabili esc;
TDate datainiesc, datafinesc;
esc.code2range(_anno, datainiesc, datafinesc);
//deve procedere al confronto tra le date inizio-fine esercizio e quelle inizio-fine commessa..
//..per spostare il record in esame nell'array corretto
//Intanto crea l'arrayone che conterra' i record da sortare e stampare!
TAssoc_array cms[4];
TString query;
query = "USE SALDANA";
//stampa standard non a vita intera
if (!_vitaintera)
query << "\nTO ANNO=" << _anno;
TISAM_recordset saldana(query);
const long saldana_items = saldana.items();
TProgind pi(saldana_items, "Scansione saldi...", true, true);
for (bool ok = saldana.move_first(); ok; ok = saldana.move_next())
{
//progind tanto per gradire
pi.addstatus(1);
if (pi.iscancelled())
break;
const TString& codconto = saldana.get(SALDANA_CONTO).as_string();
//trova l'indicatore di bilancio
TString80 conto_anale;
const int indbil = _indicatori.get_indbil(codconto, conto_anale);
//solo i Costi(3) ed i Ricavi(4) devono essere considerati per la stampa
if (indbil == 3 || indbil == 4)
{
TImporto saldo, saldop;
const int flag = estrai_saldi(saldana, indbil, saldo, saldop);
if (flag != 0)
{
const TString& codcms = saldana.get(SALDANA_COMMESSA).as_string();
const TString& fase = saldana.get(SALDANA_FASE).as_string();
const TRectype& rec_commesse = cache().get(LF_COMMESSE, codcms);
const TDate dataini = rec_commesse.get(COMMESSE_DATAINIZIO);
const TDate datafine = rec_commesse.get(COMMESSE_DATAFINE);
//e' inutile considerare le commesse terminate prima dell'esercizio selezionato..
//..cioe' nel passato oppure che iniziano nel futuro!
if (datafine >= datainiesc && dataini <= datafinesc)
{
int indice = datafine <= datafinesc ? 0 : 2;
if (dataini >= datainiesc)
indice++;
TString80 chiave = codcms;
if (_use_fasi)
chiave << '|' << fase;
//riempie le righe degli array da mandare poi in stampa
//dapprima le righe normali..
TAssoc_array& riga_array = get_row(cms[indice], chiave, indice, codcms, fase,
rec_commesse.get(COMMESSE_DESCRIZ));
//aggiunge gli importi e normalizza
const char* gruppo = indbil == 3 ? "COSTI" : "RICAVI";
TString80 conto;
parse_bill(conto_anale, conto);
aggiorna_importo(riga_array, gruppo, indbil, saldana);
aggiorna_importo(riga_array, conto, indbil, saldana);
//..poi le righe speciali,che esistono solo se la commessa e' iniziata prima dell'anno
//selezionato,quindi se l'indice e' 0 o 2
if (indice %2 == 0)
{
//aggiorna il record speciale con la somma dei saldi con anno anteriore a quello..
//..selezionato sulla maschera (CRPA request)
const int anno = saldana.get(SALDANA_ANNO).as_int();
if (anno < _anno)
{
TString16 cazzo_cod; cazzo_cod.format("DETR_%04d", _anno - 1);
TString cazzo_descr = "DETRAZIONE PER COMPETENZA ";
cazzo_descr << (_anno - 1);
TAssoc_array& riga_array = get_row(cms[indice], CMS_DEL_CAZZO, indice, cazzo_cod,
EMPTY_STRING, cazzo_descr);
aggiorna_importo(riga_array, gruppo, indbil, saldana, true);
aggiorna_importo(riga_array, conto, indbil, saldana, true);
}
} //if(indice...
} //if (datafine >= datainiesc &&...
} //if (saldop != ZERO..
} //if (indbil == 3 ||...
}
//merging dei 4 arrayini cms nell'arrayone _righe da mandare in stampa
_righe.destroy();
for (int i = 0; i < 4; i++)
{
TAssoc_array& a = cms[i];
TObject* cazzo_cms = NULL;
FOR_EACH_ASSOC_OBJECT(a, h, k, r)
{
TObject* obj = h->remove_obj();
if (strcmp(k, CMS_DEL_CAZZO) == 0)
cazzo_cms = obj;
else
_righe.add(obj); // Copia nella destinazione la riga corrente e la toglie dall'originale
}
if (cazzo_cms != NULL)
_righe.add(cazzo_cms);
} //for(int...
_righe.sort(righe_compare); //sorting delle commesse
}
const TVariant& TPrint_bilancio_cms_recordset::get(unsigned int column) const
{
return NULL_VARIANT;
}
real TPrint_bilancio_cms_recordset::calcola_avanzamento_tempo() const
{
real avanzamento;
const TDate& datafinesc = _esc[_anno].fine();
TDate dataini, datafine;
const TString& codfase = get("FASE").as_string();
if (codfase.empty())
{
const TString& codcms = get("CODCMS").as_string();
const TRectype& rec_commesse = cache().get(LF_COMMESSE, codcms);
dataini = rec_commesse.get(COMMESSE_DATAINIZIO);
datafine = rec_commesse.get(COMMESSE_DATAFINE);
}
else
{
const TRectype& rec_fasi = cache().get(LF_FASI, codfase);
dataini = rec_fasi.get(FASI_DATAINIZIO);
datafine = rec_fasi.get(FASI_DATAFINE);
}
//Si prende SOLO la Fine Esercizio come riferimento di avanzamento (in realta' si..
//..potrebbe usare today al posto di datafinesc se si volesse la situazione ad oggi,..
//..ma i calcoli degli importi sarebbero da rivedere). Quindi:
//se la commessa finisce prima della fine dell'esercizio
if (datafine < datafinesc)
avanzamento = CENTO;
//se invece prosegue anche dopo la fine dell'esercizio...
else
{
const long time_gone = datafinesc - dataini;
const long durata = datafine - dataini;
avanzamento = ((real)(time_gone * CENTO) / durata);
}
return avanzamento;
}
const TVariant& TPrint_bilancio_cms_recordset::get(const char* column_name) const
{
if (_curr >= 0 && _curr < items())
{
if (*column_name == '#')
column_name++;
TVariant& var = get_tmp_var();
if (strcmp(column_name, "ANNO") == 0)
{
var.set(_anno);
}
else
if (strcmp(column_name, "TIPOSTIMA") == 0)
{
var.set(_tipostima == 'T' ? "T" : "C");
}
else
if (strcmp(column_name, "DEPTH") == 0)
{
var.set(_depth);
}
else
if (strcmp(column_name, "VITAINTERA") == 0)
{
var.set(_vitaintera == true ? "SI" : "NO");
}
else
if (strcmp(column_name, "STAMPAFASI") == 0)
{
var.set(_use_fasi == true ? "X" : "");
}
else
if (strcmp(column_name, "AVANZAMENTO") == 0)
{
//Calcola lo stato di avanzamento della commessa
real avanzamento;
if (_tipostima == 'T')
{
avanzamento = calcola_avanzamento_tempo();
}
else //se stima e' di tipo Costi...
{
}
var.set(avanzamento);
}
else //if(strcmp(column_name,AVANZAMENTO...
{
TAssoc_array& riga = (TAssoc_array&)_righe[_curr];
const TString* val = (TString*)riga.objptr(column_name);
if (val)
var.set(*val);
else
var.set_null();
}
return var;
}
return NULL_VARIANT;
}
void TPrint_bilancio_cms_recordset::set_filter(const TPrint_bilancio_cms_mask& msk)
{
//tira su un po' di parametri dalla maschera...
_anno = msk.get_int(F_ESERCIZIO);
_tipostima = msk.get(F_TIPOSTIMA)[0];
_vitaintera = msk.get_bool(F_VITAINTERA);
_use_fasi = msk.get_bool(F_FASI);
//prende anche il prefix
TString80 prefix;
for (short id = F_PRE1; id <= F_PRE3 && msk.id2pos(id) > 0; id++)
prefix << msk.get(id);
_indicatori.set_prefix(prefix);
_depth = msk.get_int(F_DEPTH);
}
////////////////////////////////////////////////////////
// REPORT
////////////////////////////////////////////////////////

2
ca/ca3800.uml

@ -1,4 +1,4 @@
#include "ca3800.h"
#include "ca3883a.h"
TOOLBAR "" 0 -3 0 2

4
ca/ca3800a.rep

@ -109,8 +109,6 @@
<condition>STAMPAFASI != ""</condition>
<groupby>CODCMS</groupby>
<font italic="1" face="Arial Narrow" bold="1" size="8" />
<prescript description="H4 PRESCRIPT">0 #CONTATORE !
</prescript>
<postscript description="H4 POSTSCRIPT">MESSAGE RESET,F4.169</postscript>
<field type="Stringa" width="1" id="1" pattern="1">
<source>STAMPAFASI</source>
@ -129,7 +127,7 @@
<field x="1" type="Stringa" width="20" pattern="1">
<source>CODCMS</source>
</field>
<field x="20" type="Stringa" width="25" pattern="1">
<field x="21" type="Stringa" width="25" pattern="1">
<font face="Arial Narrow" size="7" />
<source>IF(#H4.3=0;DESCRIZ;"")</source>
</field>

495
ca/ca3883.cpp

@ -1,9 +1,14 @@
#include <progind.h>
#include "calib01.h"
#include "calib02.h"
#include "ca3883.h"
#include "panapdc.h"
#include "pconana.h"
#include "commesse.h"
#include "fasi.h"
#include "saldana.h"
////////////////////////////////////////////////////////////////////////////////////////
// Classe per ricavare l'indicatore di bilancio dei conti analitici riclassificati e non
////////////////////////////////////////////////////////////////////////////////////////
@ -319,3 +324,491 @@ TCRPA_report::TCRPA_report (const char* rep_name, const TString& prefix, const i
//poi vanno generate le colonne del report corrispondenti alla struttura analizzata
generate_columns (codici, testate, 69);
}
///////////////////////////////////////////////////////////////////
// roba del recordset
///////////////////////////////////////////////////////////////////
const TFixed_string CMS_DEL_CAZZO("@@@@@@@@@@@@@@@@@@@@");
static int righe_compare(const TObject** o1, const TObject** o2)
{
TAssoc_array& a1 = *(TAssoc_array*)*o1;
TAssoc_array& a2 = *(TAssoc_array*)*o2;
int cmp = 0;
const int l1 = atoi(*(TString*)a1.objptr("LEVEL"));
const int l2 = atoi(*(TString*)a2.objptr("LEVEL"));
cmp = l1 - l2;
if (cmp == 0)
{
const TString& c1 = *(TString*)a1.objptr("CODCMS");
const TString& c2 = *(TString*)a2.objptr("CODCMS");
cmp = c1.compare(c2);
if (cmp == 0)
{
const TString& f1 = *(TString*)a1.objptr("FASE");
const TString& f2 = *(TString*)a2.objptr("FASE");
cmp = f1.compare(f2);
}
else
{
const int z1 = c1.starts_with("DETR_");
const int z2 = c2.starts_with("DETR_");
if (z1 || z2)
cmp = z1 - z2;
}
}
return cmp;
}
/////////////////////////////////////////////////////////////////////////////////
//Classe di recordset speciale per stampe con saldana (ca3800, ca3900)
/////////////////////////////////////////////////////////////////////////////////
bool TPrint_saldana_recordset::move_to(TRecnotype pos)
{
_curr = pos;
return pos >= 0 && pos < items();
}
void TPrint_saldana_recordset::parse_bill(const TString& bill, TString& conto) const
{
TConfig& cfg = ca_config();
const TMultilevel_code_info& pconana_info = ca_multilevel_code_info(LF_PCONANA);
const int pconana_levels = pconana_info.levels();
const int prefix = cfg.get_int("PdcPrefix")-1;
//lunghezza dell'eventuale prefisso di gruppo e conto
const int prefix_len = (prefix >= 0) ? pconana_info.total_len(prefix) : 0;
//quanto e' lungo il codice del conto da considerare? E' il livello - il prefisso
const int conto_end = pconana_info.total_len(_depth) - prefix_len;
//stringa con cio' che segue il prefisso ed e' richiesto
conto = bill.mid(prefix_len, conto_end);
}
int TPrint_saldana_recordset::estrai_saldi(const TRecordset& saldana, const int indbil,
TImporto& saldo, TImporto& saldop) const
{
int flag = 0;
if (_tipo == 8)
{
if (_tipostima == 'C' && indbil == 3)
{
const TImporto imp_saldo(saldana.get(SALDANA_SEZIONE).as_string()[0],
saldana.get(SALDANA_SALDO).as_real());
saldo = imp_saldo;
flag |= saldo.is_zero() ? 0 : 1;
}
else
saldo.reset();
if (_tipostima == 'T' || (_tipostima == 'C' && indbil == 4)) //stima Tempo o (Costi e indbil=ricavo)
{
const TImporto imp_saldop(saldana.get(SALDANA_SEZIONEP).as_string()[0],
saldana.get(SALDANA_SALDOP).as_real());
const TImporto imp_saldov(saldana.get(SALDANA_SEZIONEV).as_string()[0],
saldana.get(SALDANA_SALDOV).as_real());
saldop = imp_saldop;
saldop += imp_saldov;
flag |= saldop.is_zero() ? 0 : 2;
}
else
saldop.reset();
}
else
{
const TImporto imp_saldo(saldana.get(SALDANA_SEZIONE).as_string()[0],
saldana.get(SALDANA_SALDO).as_real());
saldo = imp_saldo;
flag |= saldo.is_zero() ? 0 : 1;
const TImporto imp_saldop(saldana.get(SALDANA_SEZIONEP).as_string()[0],
saldana.get(SALDANA_SALDOP).as_real());
const TImporto imp_saldov(saldana.get(SALDANA_SEZIONEV).as_string()[0],
saldana.get(SALDANA_SALDOV).as_real());
saldop = imp_saldop;
saldop += imp_saldov;
flag |= saldop.is_zero() ? 0 : 2;
}
return flag;
}
TAssoc_array& TPrint_saldana_recordset::get_row(TAssoc_array& cms, const char* chiave,
const int indice, const TString& codcms, const TString& fase,
const TString& descrizione)
{
//cerca se la commessa (e l'eventuale fase) esistono gia' nell'assocarray delle commesse
TAssoc_array* riga_array = (TAssoc_array*)cms.objptr(chiave);
//se non esiste la crea!
if (riga_array == NULL)
{
riga_array = new TAssoc_array;
TString4 str_indice; //l'indice va stringato per l'assoc_array
str_indice << indice;
riga_array->add("LEVEL", str_indice);
riga_array->add("CODCMS", codcms);
if (_tipo == 8)
riga_array->add("FASE", fase);
riga_array->add("DESCRIZ", descrizione);
//inizializza i campi importo sicuramente presenti (modifica DECISIVA)
//senza questa inizializzazione, nel caso trovasse campi nulli (in realta' 0), il bastardo..
//..anziche' considerarli 0 ci mette l'ultimo valore != che ha in memoria nella stessa posizione..
//..facendo sballare tutti i conti!
if (_tipo == 8)
{
riga_array->add("RICAVI", EMPTY_STRING);
riga_array->add("COSTI", EMPTY_STRING);
}
else
{
riga_array->add("COS_BDG", EMPTY_STRING);
riga_array->add("COS_MAT", EMPTY_STRING);
riga_array->add("RIC_BDG", EMPTY_STRING);
riga_array->add("RIC_MAT", EMPTY_STRING);
}
//aggiunge la riga all'array-one
cms.add(chiave, riga_array);
}
return *riga_array;
}
//for ca3800 only!
void TPrint_saldana_recordset::aggiorna_importo(TAssoc_array& riga_array,
const TString& livello, const int indbil, const TRecordset& saldana, const bool inverti) const
{
TString* str_imp = (TString*)riga_array.objptr(livello);
if (str_imp == NULL)
{
str_imp = new TString;
riga_array.add(livello, str_imp);
}
//dare o avere?
const char sezione = indbil == 3 ? 'D' : 'A';
TImporto imp(sezione, real(*str_imp));
//ci sono tutti i tipi di saldo, ma solo quelli che rientrano nei parametri iniziali..
//..verranno considerati (_tipostima,indbil)
TImporto imp_saldo, imp_saldop;
estrai_saldi(saldana, indbil, imp_saldo, imp_saldop);
if (inverti) // Devo sottrarre l'importo = gli scambio la sezione
{
imp_saldo.swap_section();
imp_saldop.swap_section();
}
imp += imp_saldo;
imp += imp_saldop;
imp.normalize(sezione);
*str_imp = imp.valore().string();
}
//for ca3800 only!
real TPrint_saldana_recordset::calcola_avanzamento_tempo() const
{
real avanzamento;
const TDate& datafinesc = _esc[_anno].fine();
TDate dataini, datafine;
const TString& codfase = get("FASE").as_string();
if (codfase.empty())
{
const TString& codcms = get("CODCMS").as_string();
const TRectype& rec_commesse = cache().get(LF_COMMESSE, codcms);
dataini = rec_commesse.get(COMMESSE_DATAINIZIO);
datafine = rec_commesse.get(COMMESSE_DATAFINE);
}
else
{
const TRectype& rec_fasi = cache().get(LF_FASI, codfase);
dataini = rec_fasi.get(FASI_DATAINIZIO);
datafine = rec_fasi.get(FASI_DATAFINE);
}
//Si prende SOLO la Fine Esercizio come riferimento di avanzamento (in realta' si..
//..potrebbe usare today al posto di datafinesc se si volesse la situazione ad oggi,..
//..ma i calcoli degli importi sarebbero da rivedere). Quindi:
//se la commessa finisce prima della fine dell'esercizio
if (datafine < datafinesc)
avanzamento = CENTO;
//se invece prosegue anche dopo la fine dell'esercizio...
else
{
const long time_gone = datafinesc - dataini;
const long durata = datafine - dataini;
avanzamento = ((real)(time_gone * CENTO) / durata);
}
return avanzamento;
}
//for ca3900 only!
void TPrint_saldana_recordset::incrementa_importo(TAssoc_array& riga_array,
const TString& livello, const int indbil, const TImporto& saldo, const bool inverti) const
{
TString* str_imp = (TString*)riga_array.objptr(livello);
if (str_imp == NULL)
{
str_imp = new TString;
riga_array.add(livello, str_imp);
}
//dare o avere?
const char sezione = indbil == 3 ? 'D' : 'A';
TImporto imp(sezione, real(*str_imp));
if (inverti) // Devo sottrarre l'importo = gli scambio la sezione
imp -= saldo;
else
imp += saldo;
imp.normalize(sezione);
*str_imp = imp.valore().string();
}
//for ca3900 only!
void TPrint_saldana_recordset::aggiorna_importi(TAssoc_array& riga_array,
const int indbil, const TRecordset& saldana, const bool inverti) const
{
TString8 livello;
TImporto imp_saldo, imp_saldop;
estrai_saldi(saldana, indbil, imp_saldo, imp_saldop);
//saldi normali:Maturato
if (!imp_saldo.is_zero())
{
livello.format("%s_MAT", indbil == 3 ? "COS" : "RIC");
incrementa_importo(riga_array, livello, indbil, imp_saldo, inverti);
}
//saldi preventivi:Budget
if (!imp_saldop.is_zero())
{
livello.format("%s_BDG", indbil == 3 ? "COS" : "RIC");
incrementa_importo(riga_array, livello, indbil, imp_saldop, inverti);
}
}
void TPrint_saldana_recordset::requery()
{
//prende le date di inizio e fine dell'eserizio selezionato sulla maschera
TEsercizi_contabili esc;
TDate datainiesc, datafinesc;
esc.code2range(_anno, datainiesc, datafinesc);
//deve procedere al confronto tra le date inizio-fine esercizio e quelle inizio-fine commessa..
//..per spostare il record in esame nell'array corretto
TAssoc_array cms[4];
TString query;
query = "USE SALDANA";
//stampa standard non a vita intera per la 3800
if (_tipo == 8 && !_vitaintera)
query << "\nTO ANNO=" << _anno;
TISAM_recordset saldana(query);
const long saldana_items = saldana.items();
TProgind pi(saldana_items, "Scansione saldi...", true, true);
for (bool ok = saldana.move_first(); ok; ok = saldana.move_next())
{
//progind tanto per gradire
pi.addstatus(1);
if (pi.iscancelled())
break;
const TString& codconto = saldana.get(SALDANA_CONTO).as_string();
//trova l'indicatore di bilancio
TString80 conto_anale;
const int indbil = _indicatori.get_indbil(codconto, conto_anale);
//solo i Costi(3) ed i Ricavi(4) devono essere considerati per la stampa
if (indbil == 3 || indbil == 4)
{
TImporto saldo, saldop;
const int flag = estrai_saldi(saldana, indbil, saldo, saldop);
if (flag != 0)
{
const TString& codcms = saldana.get(SALDANA_COMMESSA).as_string();
const TString& fase = saldana.get(SALDANA_FASE).as_string();
const TRectype& rec_commesse = cache().get(LF_COMMESSE, codcms);
const TDate dataini = rec_commesse.get(COMMESSE_DATAINIZIO);
const TDate datafine = rec_commesse.get(COMMESSE_DATAFINE);
//e' inutile considerare le commesse terminate prima dell'esercizio selezionato..
//..cioe' nel passato oppure che iniziano nel futuro!
if (datafine >= datainiesc && dataini <= datafinesc)
{
int indice = datafine <= datafinesc ? 0 : 2;
if (dataini >= datainiesc)
indice++;
TString80 chiave = codcms;
if (_tipo == 8 && _use_fasi)
chiave << '|' << fase;
//riempie le righe degli array da mandare poi in stampa
//dapprima le righe normali..
//gruppo e conto servono solo per il caso _tipo=8 ma vanno dichiarati e ricavati..
//..qui in modo che siano a disposizione delle commesse del cazzo poco sotto
const char* gruppo = indbil == 3 ? "COSTI" : "RICAVI";
TString80 conto;
parse_bill(conto_anale, conto);
if (_tipo == 8)
{
TAssoc_array& riga_array = get_row(cms[indice], chiave, indice, codcms, fase,
rec_commesse.get(COMMESSE_DESCRIZ));
//aggiunge gli importi e normalizza
aggiorna_importo(riga_array, gruppo, indbil, saldana);
aggiorna_importo(riga_array, conto, indbil, saldana);
}
else
{
TAssoc_array& riga_array = get_row(cms[indice], chiave, indice, codcms, EMPTY_STRING,
rec_commesse.get(COMMESSE_DESCRIZ));
//aggiunge gli importi e normalizza
aggiorna_importi(riga_array, indbil, saldana);
}
//..poi le righe speciali,che esistono solo se la commessa e' iniziata prima dell'anno
//selezionato,quindi se l'indice e' 0 o 2
if (indice %2 == 0)
{
//aggiorna il record speciale con la somma dei saldi con anno anteriore a quello..
//..selezionato sulla maschera (CRPA request)
const int anno = saldana.get(SALDANA_ANNO).as_int();
if (anno < _anno)
{
TString16 cazzo_cod; cazzo_cod.format("DETR_%04d", _anno - 1);
TString cazzo_descr = "DETRAZIONE PER COMPETENZA ";
cazzo_descr << (_anno - 1);
TAssoc_array& riga_array = get_row(cms[indice], CMS_DEL_CAZZO, indice, cazzo_cod,
EMPTY_STRING, cazzo_descr);
if (_tipo == 8)
{
aggiorna_importo(riga_array, gruppo, indbil, saldana, true);
aggiorna_importo(riga_array, conto, indbil, saldana, true);
}
else
{
aggiorna_importi(riga_array, indbil, saldana, true);
}
}
} //if(indice...
} //if (datafine >= datainiesc &&...
} //if (saldop != ZERO..
} //if (indbil == 3 ||...
}
//merging dei 4 arrayini cms nell'arrayone _righe da mandare in stampa
_righe.destroy();
for (int i = 0; i < 4; i++)
{
TAssoc_array& a = cms[i];
TObject* cazzo_cms = NULL;
FOR_EACH_ASSOC_OBJECT(a, h, k, r)
{
TObject* obj = h->remove_obj();
if (strcmp(k, CMS_DEL_CAZZO) == 0)
cazzo_cms = obj;
else
_righe.add(obj); // Copia nella destinazione la riga corrente e la toglie dall'originale
}
if (cazzo_cms != NULL)
_righe.add(cazzo_cms);
} //for(int...
_righe.sort(righe_compare); //sorting delle commesse
}
const TVariant& TPrint_saldana_recordset::get(unsigned int column) const
{
return NULL_VARIANT;
}
const TVariant& TPrint_saldana_recordset::get(const char* column_name) const
{
if (_curr >= 0 && _curr < items())
{
if (*column_name == '#')
column_name++;
TVariant& var = get_tmp_var();
if (strcmp(column_name, "ANNO") == 0)
{
var.set(_anno);
}
else
if (strcmp(column_name, "TIPOSTIMA") == 0)
{
var.set(_tipostima == 'T' ? "T" : "C");
}
else
if (strcmp(column_name, "DEPTH") == 0)
{
var.set(_depth);
}
else
if (strcmp(column_name, "VITAINTERA") == 0)
{
var.set(_vitaintera == true ? "SI" : "NO");
}
else
if (strcmp(column_name, "STAMPAFASI") == 0)
{
var.set(_use_fasi == true ? "X" : "");
}
else
if (strcmp(column_name, "AVANZAMENTO") == 0)
{
//Calcola lo stato di avanzamento della commessa
real avanzamento;
if (_tipostima == 'T')
{
avanzamento = calcola_avanzamento_tempo();
}
else //se stima e' di tipo Costi...
{
}
var.set(avanzamento);
}
else //if(strcmp(column_name,AVANZAMENTO...
{
TAssoc_array& riga = (TAssoc_array&)_righe[_curr];
const TString* val = (TString*)riga.objptr(column_name);
if (val)
var.set(*val);
else
var.set_null();
}
return var;
}
return NULL_VARIANT;
}
void TPrint_saldana_recordset::set_filter(const TMask& msk)
{
//tira su un po' di parametri dalla maschera...
_anno = msk.get_int(F_ESERCIZIO);
//prende anche il prefix
TString80 prefix;
for (short id = F_PRE1; id <= F_PRE3 && msk.id2pos(id) > 0; id++)
prefix << msk.get(id);
_indicatori.set_prefix(prefix);
if (_tipo == 8)
{
_tipostima = msk.get(F_TIPOSTIMA)[0];
_vitaintera = msk.get_bool(F_VITAINTERA);
_use_fasi = msk.get_bool(F_FASI);
_depth = msk.get_int(F_DEPTH);
}
}

63
ca/ca3883.h

@ -1,4 +1,13 @@
#ifndef __CA3883_H
#define __CA3883_H
#include <assoc.h>
#include <reprint.h>
#include "../cg/cglib01.h"
#include "ca3883a.h"
///////////////////////////////////////////////////////////////
// CACHE INDICATORI BILANCIO
///////////////////////////////////////////////////////////////
@ -38,3 +47,57 @@ protected:
public:
TCRPA_report (const char* rep_name, const TString& prefix, const int depth);
};
///////////////////////////////////////////////////////////////
// RECORDSET PER STAMPE DI SALDANA CA3800, CA3900
///////////////////////////////////////////////////////////////
class TPrint_saldana_recordset : public TRecordset
{
TArray _righe;
TRecnotype _curr;
TArray _colonne;
TIndbil_cache _indicatori;
TEsercizi_contabili _esc;
int _tipo;
int _anno;
int _depth;
bool _vitaintera, _use_fasi;
char _tipostima;
protected:
virtual int tipo() const { return _tipo; }
virtual TRecnotype items() const { return _righe.items(); }
virtual bool move_to(TRecnotype pos);
virtual TRecnotype current_row() const { return _curr; }
virtual void requery();
virtual const TString& query_text() const { return EMPTY_STRING; }
virtual unsigned int columns() const { return _colonne.items(); }
virtual const TRecordset_column_info& column_info(unsigned int column) const { return (TRecordset_column_info&) _colonne[column]; }
virtual const TVariant& get(unsigned int column) const;
virtual const TVariant& get(const char* column_name) const;
void parse_bill(const TString& bill, TString& conto) const;
int estrai_saldi(const TRecordset& saldana, const int indbil,
TImporto& saldo, TImporto& saldop) const;
//per il solo ca3800
void aggiorna_importo(TAssoc_array& riga_array, const TString& livello,
const int indbil, const TRecordset& saldana, const bool inverti = false) const;
real calcola_avanzamento_tempo() const;
//per il solo ca3900
void aggiorna_importi(TAssoc_array& riga_array, const int indbil, const TRecordset& saldana,
const bool inverti = false) const;
void incrementa_importo(TAssoc_array& riga_array, const TString& livello, const int indbil,
const TImporto& saldo, const bool inverti) const;
TAssoc_array& get_row(TAssoc_array& cms, const char* chiave,
const int indice, const TString& codcms, const TString& fase,
const TString& descrizione);
public:
virtual void set_filter(const TMask& msk);
TPrint_saldana_recordset(int tipo) : _tipo(tipo) { }
};
#endif

27
ca/ca3883a.h Executable file

@ -0,0 +1,27 @@
#ifndef __CA3883A_H
#define __CA3883A_H
#define F_DITTA 101
#define F_RAGSOC 102
#define F_DATASTAMPA 103
#define F_ESERCIZIO 104
#define F_REPORT 105
#define F_INIZIO_ES 106
#define F_FINE_ES 107
#define F_TIPOSTIMA 108
#define F_VITAINTERA 109
#define F_FASI 110
#define F_DEPTH 111
//campi generati dai piani dei conti
#define F_PRE0 320
#define F_PRE1 321
#define F_PRE2 322
#define F_PRE3 323
#define F_PREDES0 324
#define F_PREDES1 325
#define F_PREDES2 326
#define F_PREDES3 327
#endif // __CA3883A_H

335
ca/ca3900.cpp

@ -1,19 +1,12 @@
#include <applicat.h>
#include <execp.h>
#include <progind.h>
#include <reprint.h>
#include "../cg/cglib01.h"
#include "ca3.h"
#include "ca3883.h"
#include "ca3900.h"
#include "ca3883a.h"
#include "calib01.h"
#include "calib02.h"
#include "commesse.h"
#include "panapdc.h"
#include "pconana.h"
#include "saldana.h"
////////////////////////////////////////////////////////
// MASCHERA
@ -136,337 +129,17 @@ TPrint_stima_ricavi_mask::TPrint_stima_ricavi_mask()
set_handlers();
}
const TFixed_string CMS_DELLA_MINCHIA("@@@@@@@@@@@@@@@@@@@@");
///////////////////////////////////////////////////////////////
// RECORDSET
///////////////////////////////////////////////////////////////
class TPrint_stima_ricavi_recordset : public TRecordset
class TPrint_stima_ricavi_recordset : public TPrint_saldana_recordset
{
TArray _righe;
TRecnotype _curr;
TArray _colonne;
TIndbil_cache _indicatori;
private:
int _anno;
bool _vitaintera, _use_fasi;
char _tipostima;
protected:
virtual TRecnotype items() const { return _righe.items(); }
virtual bool move_to(TRecnotype pos);
virtual TRecnotype current_row() const { return _curr; }
virtual void requery();
virtual const TString& query_text() const { return EMPTY_STRING; }
virtual unsigned int columns() const { return _colonne.items(); }
virtual const TRecordset_column_info& column_info(unsigned int column) const { return (TRecordset_column_info&) _colonne[column]; }
virtual const TVariant& get(unsigned int column) const;
virtual const TVariant& get(const char* column_name) const;
int estrai_saldi(const TRecordset& saldana, const int indbil,
TImporto& saldo, TImporto& saldop) const;
void aggiorna_importi(TAssoc_array& riga_array, const int indbil, const TRecordset& saldana,
const bool inverti = false) const;
void incrementa_importo(TAssoc_array& riga_array, const TString& livello, const int indbil,
const TImporto& saldo, const bool inverti) const;
TAssoc_array& get_row(TAssoc_array& cms, const char* chiave,
const int indice, const TString& codcms, const TString& descrizione);
public:
virtual void set_filter(const TPrint_stima_ricavi_mask& msk);
TPrint_stima_ricavi_recordset() : TPrint_saldana_recordset(9) {}
};
bool TPrint_stima_ricavi_recordset::move_to(TRecnotype pos)
{
_curr = pos;
return pos >= 0 && pos < items();
}
int TPrint_stima_ricavi_recordset::estrai_saldi(const TRecordset& saldana, const int indbil,
TImporto& saldo, TImporto& saldop) const
{
int flag = 0;
const TImporto imp_saldo(saldana.get(SALDANA_SEZIONE).as_string()[0],
saldana.get(SALDANA_SALDO).as_real());
saldo = imp_saldo;
flag |= saldo.is_zero() ? 0 : 1;
const TImporto imp_saldop(saldana.get(SALDANA_SEZIONEP).as_string()[0],
saldana.get(SALDANA_SALDOP).as_real());
const TImporto imp_saldov(saldana.get(SALDANA_SEZIONEV).as_string()[0],
saldana.get(SALDANA_SALDOV).as_real());
saldop = imp_saldop;
saldop += imp_saldov;
flag |= saldop.is_zero() ? 0 : 2;
return flag;
}
void TPrint_stima_ricavi_recordset::incrementa_importo(TAssoc_array& riga_array,
const TString& livello, const int indbil, const TImporto& saldo, const bool inverti) const
{
TString* str_imp = (TString*)riga_array.objptr(livello);
if (str_imp == NULL)
{
str_imp = new TString;
riga_array.add(livello, str_imp);
}
//dare o avere?
const char sezione = indbil == 3 ? 'D' : 'A';
TImporto imp(sezione, real(*str_imp));
if (inverti) // Devo sottrarre l'importo = gli scambio la sezione
imp -= saldo;
else
imp += saldo;
imp.normalize(sezione);
*str_imp = imp.valore().string();
}
void TPrint_stima_ricavi_recordset::aggiorna_importi(TAssoc_array& riga_array,
const int indbil, const TRecordset& saldana, const bool inverti) const
{
TString8 livello;
TImporto imp_saldo, imp_saldop;
estrai_saldi(saldana, indbil, imp_saldo, imp_saldop);
//saldi normali:Maturato
if (!imp_saldo.is_zero())
{
livello.format("%s_MAT", indbil == 3 ? "COS" : "RIC");
incrementa_importo(riga_array, livello, indbil, imp_saldo, inverti);
}
//saldi preventivi:Budget
if (!imp_saldop.is_zero())
{
livello.format("%s_BDG", indbil == 3 ? "COS" : "RIC");
incrementa_importo(riga_array, livello, indbil, imp_saldop, inverti);
}
}
TAssoc_array& TPrint_stima_ricavi_recordset::get_row(TAssoc_array& cms, const char* chiave,
const int indice, const TString& codcms,
const TString& descrizione)
{
//cerca se la commessa (e l'eventuale fase) esistono gia' nell'assocarray delle commesse
TAssoc_array* riga_array = (TAssoc_array*)cms.objptr(chiave);
//se non esiste la crea!
if (riga_array == NULL)
{
riga_array = new TAssoc_array;
TString4 str_indice; //l'indice va stringato per l'assoc_array
str_indice << indice;
riga_array->add("LEVEL", str_indice);
riga_array->add("CODCMS", codcms);
riga_array->add("DESCRIZ", descrizione);
//inizializza i campi importo sicuramente presenti (modifica DECISIVA)
//senza questa inizializzazione, nel caso trovasse campi nulli (in realta' 0), il bastardo..
//..anziche' considerarli 0 ci mette l'ultimo valore != che ha in memoria nella stessa posizione..
//..facendo sballare tutti i conti!
riga_array->add("COS_BDG", EMPTY_STRING);
riga_array->add("COS_MAT", EMPTY_STRING);
riga_array->add("RIC_BDG", EMPTY_STRING);
riga_array->add("RIC_MAT", EMPTY_STRING);
//aggiunge la riga all'array-ino
cms.add(chiave, riga_array);
}
return *riga_array;
}
static int righe_compare(const TObject** o1, const TObject** o2)
{
TAssoc_array& a1 = *(TAssoc_array*)*o1;
TAssoc_array& a2 = *(TAssoc_array*)*o2;
int cmp = 0;
const int l1 = atoi(*(TString*)a1.objptr("LEVEL"));
const int l2 = atoi(*(TString*)a2.objptr("LEVEL"));
cmp = l1 - l2;
if (cmp == 0)
{
const TString& c1 = *(TString*)a1.objptr("CODCMS");
const TString& c2 = *(TString*)a2.objptr("CODCMS");
cmp = c1.compare(c2);
if (cmp == 0)
{
const TString& f1 = *(TString*)a1.objptr("FASE");
const TString& f2 = *(TString*)a2.objptr("FASE");
cmp = f1.compare(f2);
}
else
{
const int z1 = c1.starts_with("DETR_");
const int z2 = c2.starts_with("DETR_");
if (z1 || z2)
cmp = z1 - z2;
}
}
return cmp;
}
void TPrint_stima_ricavi_recordset::requery()
{
//prende le date di inizio e fine dell'eserizio selezionato sulla maschera
TEsercizi_contabili esc;
TDate datainiesc, datafinesc;
esc.code2range(_anno, datainiesc, datafinesc);
//deve procedere al confronto tra le date inizio-fine esercizio e quelle inizio-fine commessa..
//..per spostare il record in esame nell'array corretto
TAssoc_array cms[4];
TString query;
query = "USE SALDANA";
query << "\nTO ANNO=" << _anno;
TISAM_recordset saldana(query);
const long saldana_items = saldana.items();
TProgind pi(saldana_items, "Scansione saldi...", true, true);
for (bool ok = saldana.move_first(); ok; ok = saldana.move_next())
{
//progind tanto per gradire
pi.addstatus(1);
if (pi.iscancelled())
break;
const TString& codconto = saldana.get(SALDANA_CONTO).as_string();
//trova l'indicatore di bilancio
TString80 conto_anale;
const int indbil = _indicatori.get_indbil(codconto, conto_anale);
//solo i Costi(3) ed i Ricavi(4) devono essere considerati per la stampa
if (indbil == 3 || indbil == 4)
{
TImporto saldo, saldop;
//che tipo di saldi considera?
const int flag = estrai_saldi(saldana, indbil, saldo, saldop);
if (flag != 0)
{
const TString& codcms = saldana.get(SALDANA_COMMESSA).as_string();
const TRectype& rec_commesse = cache().get(LF_COMMESSE, codcms);
const TDate dataini = rec_commesse.get(COMMESSE_DATAINIZIO);
const TDate datafine = rec_commesse.get(COMMESSE_DATAFINE);
//e' inutile considerare le commesse terminate prima dell'esercizio selezionato..
//..cioe' nel passato oppure che iniziano nel futuro!
if (datafine >= datainiesc && dataini <= datafinesc)
{
int indice = datafine <= datafinesc ? 0 : 2;
if (dataini >= datainiesc)
indice++;
TString80 chiave = codcms;
//riempie le righe degli array da mandare poi in stampa
//dapprima le righe normali..
TAssoc_array& riga_array = get_row(cms[indice], chiave, indice, codcms,
rec_commesse.get(COMMESSE_DESCRIZ));
//aggiunge gli importi e normalizza
aggiorna_importi(riga_array, indbil, saldana);
//..poi le righe speciali,che esistono solo se la commessa e' iniziata prima dell'anno
//selezionato,quindi se l'indice e' 0 o 2
if (indice %2 == 0)
{
//aggiorna il record speciale con la somma dei saldi con anno anteriore a quello..
//..selezionato sulla maschera (CRPA request)
const int anno = saldana.get(SALDANA_ANNO).as_int();
if (anno < _anno)
{
TString cazzo_cod; cazzo_cod.format("DETR_%02d", _anno - 1);
TString cazzo_descr = "DETRAZIONE PER COMPETENZA ";
cazzo_descr << (_anno - 1);
TAssoc_array& riga_array = get_row(cms[indice], CMS_DELLA_MINCHIA, indice, cazzo_cod,
cazzo_descr);
aggiorna_importi(riga_array, indbil, saldana, true);
}
} //if(indice...
} //if (datafine >= datainiesc &&...
} //if (saldop != ZERO..
} //if (indbil == 3 ||...
}
//merging dei 4 arrayini cms nell'arrayone _righe da mandare in stampa
_righe.destroy();
for (int i = 0; i < 4; i++)
{
TAssoc_array& a = cms[i];
TObject* cazzo_cms = NULL;
FOR_EACH_ASSOC_OBJECT(a, h, k, r)
{
TObject* obj = h->remove_obj();
if (strcmp(k, CMS_DELLA_MINCHIA) == 0)
cazzo_cms = obj;
else
_righe.add(obj); // Copia nella destinazione la riga corrente e la toglie dall'originale
}
if (cazzo_cms != NULL)
_righe.add(cazzo_cms);
} //for(int...
_righe.sort(righe_compare); //sorting delle commesse
}
const TVariant& TPrint_stima_ricavi_recordset::get(unsigned int column) const
{
return NULL_VARIANT;
}
const TVariant& TPrint_stima_ricavi_recordset::get(const char* column_name) const
{
if (_curr >= 0 && _curr < items())
{
if (*column_name == '#')
column_name++;
TVariant& var = get_tmp_var();
if (strcmp(column_name, "ANNO") == 0)
{
var.set(_anno);
}
else
{
TAssoc_array& riga = (TAssoc_array&)_righe[_curr];
const TString* val = (TString*)riga.objptr(column_name);
if (val)
var.set(*val);
else
var.set_null();
}
return var;
}
return NULL_VARIANT;
}
void TPrint_stima_ricavi_recordset::set_filter(const TPrint_stima_ricavi_mask& msk)
{
//tira su un po' di parametri dalla maschera...
_anno = msk.get_int(F_ESERCIZIO);
//prende anche il prefix
TString80 prefix;
for (short id = F_PRE1; id <= F_PRE3 && msk.id2pos(id) > 0; id++)
prefix << msk.get(id);
_indicatori.set_prefix(prefix);
}
////////////////////////////////////////////////////////
// REPORT
////////////////////////////////////////////////////////

2
ca/ca3900.uml

@ -1,4 +1,4 @@
#include "ca3900.h"
#include "ca3883a.h"
TOOLBAR "" 0 -3 0 2

5
ca/ca3900a.rep

@ -103,10 +103,11 @@ MESSAGE RESET,F3.108</prescript>
</section>
<section type="Body" />
<section type="Body" level="1">
<field x="1" type="Stringa" width="16" pattern="1">
<field x="1" type="Stringa" width="20" pattern="1">
<source>CODCMS</source>
</field>
<field x="17" type="Stringa" dynamic_height="1" width="30" height="2" pattern="1">
<field x="21" type="Stringa" width="27" pattern="1">
<font face="Arial Narrow" size="7" />
<source>DESCRIZ</source>
</field>
<field x="86" type="Testo" align="center" width="2" pattern="1" text="%" />