932 lines
29 KiB
C++
932 lines
29 KiB
C++
#include <string.h>
|
|
#include <applicat.h>
|
|
#include <automask.h>
|
|
#include <tsdb.h>
|
|
#include <progind.h>
|
|
#include <relation.h>
|
|
|
|
#include "ps6215.h"
|
|
#include "ps6215100a.h"
|
|
#include "utility.h"
|
|
#include "clifo.h"
|
|
#include "comuni.h"
|
|
#include "cfven.h"
|
|
#include "sqlset.h"
|
|
#include <vector>
|
|
#include "ps6215partite.h"
|
|
#include <map>
|
|
#include "scadenze.h"
|
|
#include "clifo.h"
|
|
|
|
#define CLIFO_RECLEN 730
|
|
|
|
struct part
|
|
{
|
|
char _tipocf;
|
|
int _anno;
|
|
TString _numpart;
|
|
part(const char tipocf, const int anno, const TString numpart) : _tipocf(tipocf), _anno(anno), _numpart(numpart) { }
|
|
};
|
|
|
|
//namespace Elem {
|
|
//
|
|
//struct mov_t
|
|
//{
|
|
// // Keys
|
|
// int n_reg;
|
|
// TDate data_reg;
|
|
// // Attributes
|
|
// int tipo_mov;
|
|
// real importo;
|
|
//};
|
|
//
|
|
//struct part_t
|
|
//{
|
|
// // Keys
|
|
// int year;
|
|
// TString num;
|
|
// // Attributes
|
|
// mov_t capo_part;
|
|
// vector<mov_t> movs;
|
|
//};
|
|
//
|
|
//}
|
|
//
|
|
//class TPartite_aperte
|
|
//{
|
|
//
|
|
// /* Uso la chiave della partita stessa */
|
|
// std::map<std::pair<TString, int>, Elem::part_t> _parts;
|
|
//
|
|
//public:
|
|
// TPartite_aperte();
|
|
//};
|
|
//
|
|
//
|
|
///* Vogliono esportare solo le partite aperte al 31.12.2019. Quindi devo controllare
|
|
// * che le partite che risultano chiuse non abbiano delle registrazioni superiori al 31.12.2019
|
|
// * altrimenti non devo tener conto di quel pagamento, e controllare poi se veramente chiusa.
|
|
// * Ma se semplicemente controllassi i movimenti senza prenderli copiarmeli??
|
|
// */
|
|
//TPartite_aperte::TPartite_aperte()
|
|
//{
|
|
// TLocalisamfile part(LF_PARTITE);
|
|
// part.read();
|
|
// for(bool ok = part.first(); ok; ok = part.next())
|
|
// {
|
|
// if (part.get(PART_NUMPART) == "9999") // Salto la riga di saldo
|
|
// continue;
|
|
//
|
|
// Elem::part_t p;
|
|
// p.num = part.get(PART_NUMPART);
|
|
// p.year = part.get_int(PART_ANNO);
|
|
//
|
|
// std::pair<TString, int> key = { p.num, p.year };
|
|
// auto it = _parts.find(key);
|
|
// // Se non esiste gia' la partita vuol dire che non ho ancora iniziato a caricarla
|
|
// if(it == _parts.end())
|
|
// {
|
|
// _parts.insert({ key, p });
|
|
//
|
|
// if ((it = _parts.find(key)) == _parts.end())
|
|
// fatal_box("ERROR IN %s, %s", __FILE__, __LINE__);
|
|
//
|
|
// Elem::part_t& pa = it->second;
|
|
// // Leggo il capo partita (se c'e')
|
|
// const int tipo = part.get_int(PART_TIPOMOV);
|
|
// if (tipo == 1 || tipo == 2) // Fattura o NC
|
|
// {
|
|
// const Elem::mov_t m = { part.get_int(PART_NREG), part.get_int(PART_DATAREG), tipo, part.get_real(PART_IMPORTO) };
|
|
// pa.capo_part = m;
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// Elem::part_t& pa = it->second;
|
|
// const int tipo = part.get_int(PART_TIPOMOV);
|
|
// const Elem::mov_t m = { part.get_int(PART_NREG), part.get_int(PART_DATAREG), tipo, part.get_real(PART_IMPORTO) };
|
|
//
|
|
// pa.movs.insert(pa.movs.end(), m);
|
|
// }
|
|
// }
|
|
//
|
|
//
|
|
//}
|
|
|
|
class TFixed_record
|
|
{
|
|
int* _dims; /**< Array of the elements dimension. */
|
|
const char** _fields_name;
|
|
int _items;
|
|
char* _str; /**< Full record. */
|
|
int _tot_len; /**< \a _str dimension. */
|
|
|
|
/** Semplice controllo dell'indice degli elementi. */
|
|
bool check_index(int _Idx) const;
|
|
/** \returns la posizione reale nel record del campo all'indice \a _Idx. */
|
|
int pos(int _Idx) const;
|
|
|
|
public:
|
|
/** \returns la posizione dell'elemento che corrisponde alla colonna con il nome passato, se i nomi sono stati passati. */
|
|
int find_column(const char* field_name) const;
|
|
/** \returns il record per intero. */
|
|
const char* get_line() const { return (const char*)_str; }
|
|
/** \returns the name of the field at the given index. */
|
|
const char* get_name_field(int _Idx = 0) const;
|
|
/** Set the string \a _Str in the given position \a _Idx. */
|
|
void set_str(int _Idx, const char* _Str) const;
|
|
|
|
/** \returns a fixed string of the element at the index. */
|
|
TFixed_string operator[](int _Idx) const;
|
|
/** \returns a fixed string of the element of specified column name \a field_name. */
|
|
TFixed_string operator[](const char* field_name) const;
|
|
|
|
TFixed_record(int items, const int dims[]);
|
|
TFixed_record() : TFixed_record(0, nullptr) { }
|
|
TFixed_record(int items, const int dims[], const char* fields_name[]);
|
|
~TFixed_record();
|
|
};
|
|
|
|
bool TFixed_record::check_index(int _Idx) const
|
|
{
|
|
return _Idx >= 0 && _Idx <= _items;
|
|
}
|
|
|
|
int TFixed_record::pos(int _Idx) const
|
|
{
|
|
int real_idx = 0;
|
|
if (check_index(_Idx))
|
|
{
|
|
for (int i = 0; i < _Idx; ++i)
|
|
real_idx += _dims[i];
|
|
}
|
|
return real_idx;
|
|
}
|
|
|
|
int TFixed_record::find_column(const char* field_name) const
|
|
{
|
|
if (!_fields_name)
|
|
return -1;
|
|
for (int i = 0; i < _items; ++i)
|
|
if(strcmp(get_name_field(i), field_name) == 0)
|
|
return i;
|
|
return -1;
|
|
}
|
|
|
|
void TFixed_record::set_str(int _Idx, const char* _Str) const
|
|
{
|
|
const int p = pos(_Idx);
|
|
for (int i = p; i < p + _dims[_Idx] && i < (int)strlen(_Str) + p; ++i)
|
|
_str[i] = _Str[i - p];
|
|
}
|
|
|
|
const char* TFixed_record::get_name_field(int _Idx) const
|
|
{
|
|
return check_index(_Idx) && _fields_name ? _fields_name[_Idx] : "";
|
|
}
|
|
|
|
TFixed_string TFixed_record::operator[](int _Idx) const
|
|
{
|
|
static TFixed_string* f_str = nullptr;
|
|
delete f_str;
|
|
if (check_index(_Idx))
|
|
{
|
|
const int p = pos(_Idx);
|
|
TString appo(_str);
|
|
appo = appo.sub(p, p + _dims[_Idx]);
|
|
const TFixed_string str(appo, _dims[_Idx] + 1);
|
|
f_str = new TFixed_string(str);
|
|
}
|
|
else
|
|
f_str = new TFixed_string("");
|
|
return *f_str;
|
|
}
|
|
|
|
TFixed_string TFixed_record::operator[](const char* field_name) const
|
|
{
|
|
return operator[](find_column(field_name));
|
|
}
|
|
|
|
TFixed_record::TFixed_record(const int items, const int dims[]) : _fields_name(nullptr), _items(items), _tot_len(0)
|
|
{
|
|
_dims = new int[items];
|
|
for (int i = 0; i < items; ++i)
|
|
{
|
|
_dims[i] = dims[i];
|
|
_tot_len += dims[i];
|
|
}
|
|
_str = new char[++_tot_len];
|
|
memset(_str, ' ', _tot_len);
|
|
_str[_tot_len - 1] = '\0';
|
|
}
|
|
|
|
TFixed_record::TFixed_record(int items, const int dims[], const char* fields_name[]) : TFixed_record(items, dims)
|
|
{
|
|
_fields_name = new const char*[_items];
|
|
for(int i = 0; i < _items; ++i)
|
|
_fields_name[i] = fields_name[i];
|
|
}
|
|
|
|
TFixed_record::~TFixed_record()
|
|
{
|
|
delete[] _dims;
|
|
delete[] _fields_name;
|
|
delete[] _str;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Utilities
|
|
///////////////////////////////////////////////////////////
|
|
|
|
void copy_wzero(char* dest, const int size, const char* source)
|
|
{
|
|
for(int i = 0; i < size; ++i)
|
|
{
|
|
const char c = source[i];
|
|
if (c == '\0')
|
|
break;
|
|
dest[i] = c;
|
|
}
|
|
}
|
|
|
|
TString& trim_n(TString& str, const int max)
|
|
{
|
|
if(str.len() > max)
|
|
str.rtrim(str.len() - max);
|
|
return str;
|
|
}
|
|
|
|
TString to_escape(const TString& val)
|
|
{
|
|
TString& app = get_tmp_string();
|
|
for (int k = 0; k < val.len(); k++)
|
|
{
|
|
switch (val[k])
|
|
{
|
|
case '\'':
|
|
app << "''";
|
|
break;
|
|
default:
|
|
app << val[k];
|
|
break;
|
|
}
|
|
}
|
|
return app;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Main Mask
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TComariExport_mask final : public TAutomask
|
|
{
|
|
protected:
|
|
bool on_field_event(TOperable_field& o, TField_event e, long jolly) override;
|
|
void load_all();
|
|
public:
|
|
void save_all() const;
|
|
TComariExport_mask();
|
|
~TComariExport_mask() { save_all(); }
|
|
};
|
|
|
|
bool TComariExport_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
TComariExport_mask::TComariExport_mask() : TAutomask("ps6215100a")
|
|
{
|
|
load_all();
|
|
}
|
|
|
|
void TComariExport_mask::save_all() const
|
|
{
|
|
ini_set_string(CONFIG_DITTA, "ps6215", "flddest", get(F_FLDDEST));
|
|
ini_set_string(CONFIG_DITTA, "ps6215", "clifor_bool", get(F_CLIFOR));
|
|
ini_set_string(CONFIG_DITTA, "ps6215", "partopen_bool", get(F_PARTOPEN));
|
|
}
|
|
|
|
void TComariExport_mask::load_all()
|
|
{
|
|
TFilename temp;
|
|
temp.tempdir();
|
|
set(F_FLDDEST, ini_get_string(CONFIG_DITTA, "ps6215", "flddest", temp));
|
|
set(F_CLIFOR, ini_get_string(CONFIG_DITTA, "ps6215", "clifor_bool", "X"));
|
|
set(F_PARTOPEN, ini_get_string(CONFIG_DITTA, "ps6215", "partopen_bool", "X"));
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Main Program
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TComariExport_app : public TSkeleton_application
|
|
{
|
|
TString _fld_dest;
|
|
std::vector<std::shared_ptr<TFixed_record>> _exported;
|
|
std::vector<part> _chiuse;
|
|
|
|
bool export_all();
|
|
static void add_to_record(char* record, TString& str, int len, int& index);
|
|
static void export_clifo(ofstream& fout);
|
|
static void create_rec(int items, TLocalisamfile& part_rec, const char** fields, std::shared_ptr<TFixed_record>& rec);
|
|
void write_chiuse(ofstream& fout, int items, const int* dim_fields, const char** fields);
|
|
void add_chiusa(const TISAM_recordset& part_rec);
|
|
void export_parti(ofstream& fout);
|
|
void export_scadenze(ofstream& fout);
|
|
bool export_table(short id);
|
|
public:
|
|
bool create() override;
|
|
void main_loop() override;
|
|
TComariExport_app() = default;
|
|
};
|
|
|
|
bool TComariExport_app::export_all()
|
|
{
|
|
return
|
|
export_table(F_CLIFOR) &&
|
|
export_table(F_PARTOPEN) &&
|
|
export_table(F_PIANOCONTI) &&
|
|
export_table(F_MASTRI);
|
|
}
|
|
|
|
void TComariExport_app::add_to_record(char* record, TString& str, int len, int& index)
|
|
{
|
|
trim_n(str, len);
|
|
copy_wzero(record + index, CLIFO_RECLEN - index, str);
|
|
index += len;
|
|
}
|
|
|
|
void TComariExport_app::export_clifo(ofstream& fout)
|
|
{
|
|
int index = 0;
|
|
TLocalisamfile clifo(LF_CLIFO);
|
|
bool ok = clifo.read(_isfirst) == NOERR;
|
|
int items = clifo.items();
|
|
TProgress_monitor bar(items, "Esportazione Tabella Clienti Fornitori");
|
|
for(; ok; ok = clifo.next() == NOERR)
|
|
{
|
|
if (!bar.add_status())
|
|
break;
|
|
|
|
char record[CLIFO_RECLEN]; memset(record, ' ', CLIFO_RECLEN);
|
|
index = 0;
|
|
TLocalisamfile comuni(LF_COMUNI), cfven(LF_CFVEN);
|
|
comuni.put(COM_STATO, clifo.get(CLI_STATOCF));
|
|
comuni.put(COM_COM, clifo.get(CLI_COMCF));
|
|
comuni.read();
|
|
cfven.put(CFV_CODCF, clifo.get(CLI_CODCF));
|
|
cfven.put(CFV_TIPOCF, clifo.get(CLI_TIPOCF));
|
|
cfven.read();
|
|
|
|
// Tipo:
|
|
TString a = clifo.get(CLI_TIPOCF);
|
|
if(a[0] != 'C' && a != 'F')
|
|
a[0] = 'C';
|
|
add_to_record(record, a, 1, index);
|
|
// Codcf:
|
|
a = clifo.get(CLI_CODCF);
|
|
add_to_record(record, a, 15, index);
|
|
// Descrizione:
|
|
a = clifo.get(CLI_RAGSOC);
|
|
a.rpad(50);
|
|
TString b = a.sleft(30);
|
|
add_to_record(record, b, 40, index);
|
|
// Descrizione2:
|
|
b = a.sright(20);
|
|
add_to_record(record, b, 40, index);
|
|
// Indirizzo:
|
|
a = clifo.get(CLI_INDCF);
|
|
a << ", " << clifo.get(CLI_CIVCF);
|
|
add_to_record(record, a, 35, index);
|
|
// Indirizzo2:
|
|
a = "";
|
|
add_to_record(record, a, 35, index);
|
|
// CAP:
|
|
a = clifo.get(CLI_CAPCF);
|
|
add_to_record(record, a, 5, index);
|
|
// Localita':
|
|
a = clifo.get(CLI_LOCCF);
|
|
add_to_record(record, a, 30, index);
|
|
// Provincia:
|
|
a = comuni.get(COM_PROVCOM);
|
|
add_to_record(record, a, 2, index);
|
|
// Telefono:
|
|
a = clifo.get(CLI_PTEL);
|
|
a << clifo.get(CLI_TEL);
|
|
add_to_record(record, a, 18, index);
|
|
// Cellulare:
|
|
a = clifo.get(CLI_PTEL2);
|
|
a << clifo.get(CLI_TEL2);
|
|
add_to_record(record, a, 18, index);
|
|
// Fax:
|
|
a = clifo.get(CLI_PFAX);
|
|
a << clifo.get(CLI_FAX);
|
|
add_to_record(record, a, 18, index);
|
|
// Persona fisica:
|
|
a = clifo.get(CLI_TIPOPERS)[0] == 'F' ? "S" : "N";
|
|
add_to_record(record, a, 1, index);
|
|
// Sesso:
|
|
a = clifo.get(CLI_SESSO);
|
|
add_to_record(record, a, 1, index);
|
|
// Nascita:
|
|
a = clifo.get_date(CLI_DATANASC).date2ansi();
|
|
add_to_record(record, a, 8, index);
|
|
// Luogo di nascita:
|
|
comuni.zero();
|
|
comuni.put(COM_STATO, clifo.get(CLI_STATONASC));
|
|
comuni.put(COM_COM, clifo.get(CLI_COMNASC));
|
|
comuni.read();
|
|
a = comuni.get(COM_DENCOM);
|
|
add_to_record(record, a, 30, index);
|
|
// Provincia Nascita:
|
|
a = comuni.get(COM_PROVCOM);
|
|
add_to_record(record, a, 2, index);
|
|
// Codice fiscale:
|
|
a = clifo.get(CLI_COFI);
|
|
add_to_record(record, a, 16, index);
|
|
// Partita IVA:
|
|
a = clifo.get(CLI_PAIV);
|
|
add_to_record(record, a, 12, index);
|
|
// Mastro:
|
|
a = clifo.get(CLI_GRUPPO);
|
|
a << clifo.get(CLI_CONTO);
|
|
add_to_record(record, a, 20, index);
|
|
// Partite:
|
|
a = " ";
|
|
add_to_record(record, a, 1, index);
|
|
// Codice pagamento:
|
|
a = clifo.get(CLI_CODPAG);
|
|
add_to_record(record, a, 5, index);
|
|
// Codice zona:
|
|
a = cfven.get(CFV_CODZONA);
|
|
add_to_record(record, a, 5, index);
|
|
// Codice agente1:
|
|
a = cfven.get(CFV_CODAG1);
|
|
add_to_record(record, a, 5, index);
|
|
// Codice Iva:
|
|
a = cfven.get(CFV_ASSFIS);
|
|
add_to_record(record, a, 5, index);
|
|
// Codice Valuta:
|
|
a = clifo.get(CLI_CODVAL);
|
|
add_to_record(record, a, 5, index);
|
|
// Codice Banca:
|
|
a = clifo.get(CLI_CODABI);
|
|
a << clifo.get(CLI_CODCAB);
|
|
add_to_record(record, a, 10, index);
|
|
// Primo mese:
|
|
a = " ";
|
|
add_to_record(record, a, 2, index);
|
|
// Secondo mese:
|
|
a = " ";
|
|
add_to_record(record, a, 2, index);
|
|
// Primo gg scadenze:
|
|
a = " ";
|
|
add_to_record(record, a, 2, index);
|
|
// Secondo gg:
|
|
a = " ";
|
|
add_to_record(record, a, 2, index);
|
|
// Codice Lingua:
|
|
a = clifo.get(CLI_CODLIN);
|
|
add_to_record(record, a, 5, index);
|
|
// Conto corrente:
|
|
a = clifo.get(CLI_NUMCC);
|
|
add_to_record(record, a, 15, index);
|
|
// Indirizzo e-mail:
|
|
a = clifo.get(CLI_DOCMAIL);
|
|
add_to_record(record, a, 50, index);
|
|
// Ritenute:
|
|
a = "N";
|
|
add_to_record(record, a, 1, index);
|
|
// Codice tributo:
|
|
a = " ";
|
|
add_to_record(record, a, 4, index);
|
|
// Codice tributo:
|
|
a = " ";
|
|
add_to_record(record, a, 4, index);
|
|
// Categoria contabile :
|
|
a = " ";
|
|
add_to_record(record, a, 5, index);
|
|
// Annotazioni:
|
|
a = " ";
|
|
add_to_record(record, a, 255, index);
|
|
|
|
fout << record << '\n';
|
|
}
|
|
}
|
|
|
|
void TComariExport_app::create_rec(int items, TLocalisamfile& part_rec, const char** fields, std::shared_ptr<TFixed_record>& rec)
|
|
{
|
|
for (int _Idx = 0; _Idx < items; ++_Idx)
|
|
{
|
|
if (_Idx >= I_DATAREG && _Idx <= I_DATAPAG)
|
|
{
|
|
TDate date(part_rec.get(part_rec.get_date(fields[_Idx])));
|
|
rec->set_str(_Idx, TString(date.date2ansi()));
|
|
}
|
|
else if (_Idx >= I_IMPORTO && _Idx <= I_RITSOC || _Idx == I_ABBUONI || _Idx == I_DIFFCAM)
|
|
rec->set_str(_Idx, part_rec.get_real(fields[_Idx]).string());
|
|
else
|
|
rec->set_str(_Idx, part_rec.get(fields[_Idx]));
|
|
}
|
|
}
|
|
|
|
void TComariExport_app::write_chiuse(ofstream& fout, int items, const int* dim_fields, const char** fields)
|
|
{
|
|
std::shared_ptr<TFixed_record> rec = std::make_shared<TFixed_record>(items, dim_fields, fields);
|
|
for(auto& it : _chiuse)
|
|
{
|
|
TLocalisamfile part(LF_PARTITE);
|
|
part.setkey(1);
|
|
part.put(PART_TIPOCF, it._tipocf);
|
|
part.put(PART_ANNO, it._anno);
|
|
part.put(PART_NUMPART, it._numpart);
|
|
part.read();
|
|
for(bool ok = true; ok; ok = part.next() == NOERR)
|
|
{
|
|
if(part.get_date(PART_DATAREG) > TDate(31, 12, 2019) ||
|
|
part.get_int(PART_NRIGA) == 9999) // Per sicurezza :'(
|
|
break;
|
|
create_rec(items, part, fields, rec);
|
|
|
|
fout << rec->get_line() << endl;
|
|
_exported.insert(_exported.end(), rec);
|
|
}
|
|
}
|
|
}
|
|
|
|
void TComariExport_app::add_chiusa(const TISAM_recordset& part_rec)
|
|
{
|
|
const int anno = part_rec.get(part_rec.find_column(PART_ANNO)).as_int();
|
|
const TString npart = part_rec.get(part_rec.find_column(PART_NUMPART)).as_string();
|
|
const char tipocf = part_rec.get(part_rec.find_column(PART_TIPOCF)).as_string()[0];
|
|
_chiuse.insert(_chiuse.end(), part(tipocf, anno, npart));
|
|
}
|
|
|
|
void TComariExport_app::export_parti(ofstream& fout)
|
|
{
|
|
const char* fields[] = {
|
|
PART_ANNO, PART_NUMPART, PART_NRIGA, PART_TIPOCF, PART_SOTTOCONTO,
|
|
PART_TIPOMOV, PART_TIPOPAG, PART_NREG, PART_NUMRIG, PART_DATAREG, PART_DATADOC,
|
|
PART_DATAPAG, PART_NUMDOC, PART_REG, PART_PROTIVA, PART_CODCAUS, PART_SEZ, PART_IMPORTO, PART_IMPOSTA, PART_SPESE, PART_IMPTOTDOC, PART_RITENUTE,
|
|
PART_RITSOC, PART_SEZABB, PART_ABBUONI, PART_SEZDIFCAM, PART_DIFFCAM, PART_GRUPPOCL, PART_CONTOCL,
|
|
CLI_COFI, CLI_STATOPAIV, CLI_PAIV
|
|
};
|
|
const int dim_fields[] = {
|
|
D_ANNO, D_NUMPART, D_NRIGA, D_TIPOC, D_SOTTOCONTO,
|
|
D_TIPOMOV, D_TIPOPAG, D_NREG, D_NUMRIG, D_DATAREG, D_DATADOC,
|
|
D_DATAPAG, D_NUMDOC, D_REG, D_PROTIVA, D_CODCAUS, D_SEZ, D_IMPORTO, D_IMPOSTA, D_SPESE, D_IMPTOTDOC, D_RITENUTE,
|
|
D_RITSOC, D_SEZABB, D_ABBUONI, D_SEZDIFCAM, D_DIFFCAM, D_GRUPPOCL, D_CONTOCL,
|
|
D_COFI, D_STATOPAIV, D_PAIV
|
|
};
|
|
|
|
TString4 last_game = ini_get_string(CONFIG_DITTA, "ps6215", "last_year_open_game", "2019");
|
|
const string year((const char*)last_game);
|
|
const int y = stol(year);
|
|
if (y < 2000 || y > 2029)
|
|
last_game = "2019";
|
|
ini_set_string(CONFIG_DITTA, "ps6215", "last_game", last_game);
|
|
|
|
const int items = (int)(sizeof dim_fields / sizeof *dim_fields);
|
|
//TString sql; sql << "SELECT ";
|
|
//for (int i = 0; i < items - 1 + 1; ++i) // +1 perche' c'e' anche la colonna CHIUSA in fields
|
|
// sql << fields[i] << ", ";
|
|
//sql << fields[items - 1 +1] << '\n';
|
|
//sql << "FROM part WHERE ANNO <=" << last_game << ";";
|
|
//TSQL_recordset openpart(sql);
|
|
TISAM_recordset part_rec(R"(USE PART SELECT (ANNO<=2019)&&((CHIUSA!="X")||((CHIUSA=="X")&&(DATAREG>"31-12-2019")))&&(NRIGA!=9999))");
|
|
|
|
const int part_items = part_rec.items();
|
|
|
|
if (!part_items)
|
|
message_box("Non ci sono partite aperte al %s da esportare.", (const char*)last_game);
|
|
else if (part_rec.move_first())
|
|
{
|
|
TProgress_monitor bar(part_items, "Esportazione Partite Aperte");
|
|
std::vector<std::shared_ptr<TFixed_record>> saved;
|
|
for (bool ok = true; ok; ok = part_rec.move_next())
|
|
{
|
|
if (!bar.add_status())
|
|
break;
|
|
auto rec = std::make_shared<TFixed_record>(items, dim_fields, fields);
|
|
for (int idx = 0; idx < items; ++idx)
|
|
{
|
|
if (idx >= I_DATAREG && idx <= I_DATAPAG)
|
|
{
|
|
TDate date(part_rec.get(part_rec.find_column(fields[idx])).as_date());
|
|
rec->set_str(idx, TString(date.date2ansi()));
|
|
}
|
|
else if (idx >= I_IMPORTO && idx <= I_RITSOC || idx == I_ABBUONI || idx == I_DIFFCAM)
|
|
rec->set_str(idx, part_rec.get(part_rec.find_column(fields[idx])).as_real().string());
|
|
else if(idx <= I_CONTOCL)
|
|
rec->set_str(idx, part_rec.get(part_rec.find_column(fields[idx])).as_string());
|
|
else
|
|
{
|
|
TLocalisamfile clifo(LF_CLIFO);
|
|
TString c = part_rec.get(part_rec.find_column(PART_TIPOCF)).as_string();
|
|
TString s = part_rec.get(part_rec.find_column(PART_SOTTOCONTO)).as_string();
|
|
clifo.put(CLI_TIPOCF, part_rec.get(part_rec.find_column(PART_TIPOCF)).as_string());
|
|
clifo.put(CLI_CODCF, part_rec.get(part_rec.find_column(PART_SOTTOCONTO)).as_string());
|
|
clifo.read();
|
|
|
|
rec->set_str(idx, clifo.get(CLI_COFI));
|
|
rec->set_str(idx, clifo.get(CLI_STATOPAIV));
|
|
rec->set_str(idx, clifo.get(CLI_PAIV));
|
|
break; // Setto ed esco tanto sono gli ultimi
|
|
}
|
|
}
|
|
|
|
if(!part_rec.get(part_rec.find_column(PART_CHIUSA)).as_bool())
|
|
{
|
|
fout << rec->get_line() << endl; // Caso normale in cui e' aperta
|
|
_exported.insert(_exported.end(), rec);
|
|
}
|
|
else
|
|
add_chiusa(part_rec);
|
|
|
|
//if (part_rec.get(PART_CHIUSA).as_bool()) // se partita chiusa controllo che la riga non superi il limite
|
|
//{
|
|
// if (part_rec.get(PART_DATAREG).as_date() > TDate(31, 12, 2019))
|
|
// {
|
|
// // La partita in realta' e' aperta
|
|
// // Non salvo questa ma scrivo tutte le altre;
|
|
// for (auto it = saved.begin(); it != saved.end(); ++it)
|
|
// fout << (*it)->get_line() << endl;
|
|
// _exported.insert(_exported.end(), saved.begin(), saved.end());
|
|
// saved.clear(); // Svuoto il vettore temporaneo.
|
|
// // Mi sposto avanti finche' non trovo la riga di saldo.
|
|
// part_rec.move_next();
|
|
// if (!bar.add_status())
|
|
// break;
|
|
// while (part_rec.get(PART_NRIGA).as_int() != 9999)
|
|
// {
|
|
// part_rec.move_next();
|
|
// if (!bar.add_status())
|
|
// break;
|
|
// }
|
|
// continue;
|
|
// }
|
|
// if (part_rec.get(PART_NRIGA).as_int() == 9999) // Balzo, purtoppo puo' capitare di finire in questo caso...
|
|
// saved.clear(); // Svuoto il vettore temporaneo.
|
|
// else
|
|
// {
|
|
// // Quando e' chiusa e non supera il limite invece me le salvo momentaneamente
|
|
// saved.insert(saved.end(), rec); // Verranno scritte solo se in realta' e' aperta
|
|
// continue;
|
|
// }
|
|
//}
|
|
//if (part_rec.get(PART_NRIGA).as_int() == 9999) // Balzo
|
|
// continue;
|
|
|
|
//if (part_rec.get(PART_DATAREG).as_date() <= TDate(31, 12, 2019))
|
|
//{
|
|
// fout << rec->get_line() << endl; // Caso normale in cui e' aperta
|
|
// _exported.insert(_exported.end(), rec);
|
|
//}
|
|
}
|
|
write_chiuse(fout, items, dim_fields, fields);
|
|
}
|
|
else
|
|
warning_box(TR("Impossibile leggere file partite aperte."));
|
|
|
|
//if (!openpart.items())
|
|
// message_box("Non ci sono partite aperte al %s da esportare.", (const char*)last_game);
|
|
//else if(openpart.move_first())
|
|
//{
|
|
// TProgress_monitor bar(openpart.items(), "Esportazione Partite Aperte");
|
|
// std::vector<std::shared_ptr<TFixed_record>> saved;
|
|
// for (bool ok = true; ok; ok = openpart.move_next())
|
|
// {
|
|
// if (!bar.add_status())
|
|
// break;
|
|
// /*if (openpart.get(openpart.find_column(PART_CHIUSA)).as_bool() &&
|
|
// openpart.get(openpart.find_column(PART_DATAREG)).as_date() > TDate(31, 12, 2019))
|
|
// bool simo = true;*/
|
|
// /* Esporto solo le righe che non sono registrazioni con datareg superiore al limite
|
|
// * e che non sono righe di saldo
|
|
// */
|
|
// // Uso uno shared ptr altrimenti non potrei salvare nulla nel vector perche' a ogni ciclo il record verrebbe distrutto con tutti i suoi puntatori
|
|
// // in questo modo se ne occupa lo smart pointer di distruggerlo quando non ci sono piu' riferimenti.
|
|
// std::shared_ptr<TFixed_record> rec = std::make_shared<TFixed_record>(items, dim_fields, fields);
|
|
|
|
// for (int i = 0; i < items; ++i)
|
|
// {
|
|
// if (openpart.column_info(i)._type == _datefld)
|
|
// {
|
|
// TString ansi; ansi << TDate(openpart.get(i).as_date()).date2ansi();
|
|
// if (ansi != "0") // Butto le date "vuote"
|
|
// rec->set_str(i, ansi);
|
|
// }
|
|
// else if (i >= I_IMPORTO && i <= I_RITSOC || i == I_ABBUONI || i == I_DIFFCAM) // reali (non so perche' ma becca come reali anche gli interi...)
|
|
// rec->set_str(i, TString(openpart.get(i).as_real().string(18, 3, ' ')));
|
|
// else
|
|
// rec->set_str(i, openpart.get(i).as_string());
|
|
// }
|
|
// if (openpart.get(openpart.find_column(PART_CHIUSA)).as_bool()) // se partita chiusa controllo che la riga non superi il limite
|
|
// {
|
|
// if (openpart.get(openpart.find_column(PART_DATAREG)).as_date() > TDate(31, 12, 2019))
|
|
// {
|
|
// // La partita in realta' e' aperta
|
|
// // Non salvo questa ma scrivo tutte le altre;
|
|
// for(auto it = saved.begin(); it != saved.end(); ++it)
|
|
// fout << (*it)->get_line() << endl;
|
|
// _exported.insert(_exported.end(), saved.begin(), saved.end());
|
|
// saved.clear(); // Svuoto il vettore temporaneo.
|
|
// // Mi sposto avanti finche' non trovo la riga di saldo.
|
|
// ok = openpart.move_next();
|
|
// if (!bar.add_status())
|
|
// break;
|
|
// while (ok && openpart.get(openpart.find_column(PART_NRIGA)).as_int() != 9999)
|
|
// {
|
|
// ok = openpart.move_next();
|
|
// if (!bar.add_status())
|
|
// break;
|
|
// }
|
|
// continue;
|
|
// }
|
|
// if (openpart.get(openpart.find_column(PART_NRIGA)).as_int() == 9999) // Balzo, purtoppo puo' capitare di finire in questo caso...
|
|
// saved.clear(); // Svuoto il vettore temporaneo.
|
|
// else
|
|
// {
|
|
// // Quando e' chiusa e non supera il limite invece me le salvo momentaneamente
|
|
// saved.insert(saved.end(), rec); // Verranno scritte solo se in realta' e' aperta
|
|
// continue;
|
|
// }
|
|
// }
|
|
// if (openpart.get(openpart.find_column(PART_NRIGA)).as_int() == 9999) // Balzo
|
|
// continue;
|
|
|
|
// if (openpart.get(openpart.find_column(PART_DATAREG)).as_date() <= TDate(31, 12, 2019))
|
|
// {
|
|
// fout << rec->get_line() << endl; // Caso normale in cui e' aperta
|
|
// _exported.insert(_exported.end(), rec);
|
|
// }
|
|
// }
|
|
//}
|
|
//else
|
|
// warning_box(TR("Impossibile leggere file partite aperte."));
|
|
}
|
|
|
|
void TComariExport_app::export_scadenze(ofstream& fout)
|
|
{
|
|
const char* fields[] = {
|
|
SCAD_ANNO, SCAD_NUMPART, SCAD_NRIGA, SCAD_NRATA, SCAD_CODPAG, SCAD_TIPOPAG, SCAD_IMPORTO, SCAD_DATASCAD, SCAD_TIPOCF,
|
|
SCAD_SOTTOCONTO, SCAD_GGRIT, SCAD_PAGATA, SCAD_IMPORTOPAG, SCAD_IMPORTOANT, SCAD_CODABIPR, SCAD_CODCABPR, SCAD_CODABI, SCAD_CODCAB
|
|
};
|
|
const int dim_fields[] = {
|
|
DS_ANNO, DS_NUMPART, DS_NRIGA, DS_NRATA, DS_CODPAG, DS_TIPOPAG, DS_IMPORTO, DS_DATASCAD, DS_TIPOCF,
|
|
DS_SOTTOCONTO, DS_GGRIT, DS_PAGATA, DS_IMPORTOPAG, DS_IMPORTOANT, DS_CODABIPR, DS_CODCABPR, DS_CODABI, DS_CODCAB
|
|
};
|
|
// Esporto le scadenze per i documenti che ho esportato dalle partite
|
|
if(!_exported.empty())
|
|
{
|
|
const int items = (int)(sizeof dim_fields / sizeof *dim_fields);
|
|
TProgress_monitor bar(_exported.size(), "Esportazione Scadenze");
|
|
TString sql_fields;
|
|
for (int i = 0; i < items - 1; ++i)
|
|
sql_fields << fields[i] << ", ";
|
|
sql_fields << fields[items - 1] << '\n';
|
|
for (auto it = _exported.begin(); it != _exported.end(); ++it)
|
|
{
|
|
if (!bar.add_status())
|
|
break;
|
|
TFixed_record& part = *(*it);
|
|
const TFixed_string& tipocf = part[3];
|
|
const TFixed_string& anno = part[0];
|
|
TString numpart = (const char*)part[1];
|
|
numpart.trim();
|
|
const TFixed_string& nriga = part[2];
|
|
TString sql; sql << "SELECT " << sql_fields <<
|
|
"FROM scad WHERE TIPOC = '" << tipocf << "' AND ANNO = " << anno << " AND NRIGA = " << nriga << ";";
|
|
TSQL_recordset scad(sql);
|
|
bool found = false;
|
|
for(bool ok = scad.move_first(); ok; ok = scad.move_next())
|
|
{
|
|
if (scad.get(1).as_string() == numpart)
|
|
{
|
|
found = true;
|
|
TFixed_record rec(items, dim_fields, fields);
|
|
for (int i = 0; i < items; ++i)
|
|
{
|
|
if (scad.column_info(i)._type == _datefld)
|
|
{
|
|
TString ansi; ansi << TDate(scad.get(i).as_date()).date2ansi();
|
|
if (ansi != "0") // Butto le date "vuote"
|
|
rec.set_str(i, ansi);
|
|
}
|
|
else if (i == IS_IMPORTO || i == IS_IMPORTOPAG || i == IS_IMPORTOANT) // reali (non so perche' ma becca come reali anche gli interi...)
|
|
rec.set_str(i, TString(scad.get(i).as_real().string(18, 3, ' ')));
|
|
else
|
|
rec.set_str(i, scad.get(i).as_string());
|
|
}
|
|
fout << rec.get_line() << std::endl;
|
|
}
|
|
else
|
|
{
|
|
if (found)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool TComariExport_app::export_table(const short id)
|
|
{
|
|
bool ok = false;
|
|
ofstream fout;
|
|
TString path = _fld_dest;
|
|
const char* name, *name_file;
|
|
switch (id)
|
|
{
|
|
default:
|
|
case F_CLIFOR:
|
|
name_file = "clifo.txt";
|
|
path << "\\" << name_file;
|
|
fout.open(path, ios_base::out);
|
|
if ((ok = fout.is_open()))
|
|
{
|
|
export_clifo(fout);
|
|
fout.close();
|
|
}
|
|
name = "Clienti Fornitori";
|
|
break;
|
|
case F_PARTOPEN:
|
|
name_file = "partiteaperte.txt";
|
|
path << "\\" << name_file;
|
|
fout.open(path, ios_base::out);
|
|
if ((ok = fout.is_open()))
|
|
{
|
|
export_parti(fout);
|
|
fout.close();
|
|
}
|
|
name_file = "scadenze.txt";
|
|
path = _fld_dest;
|
|
path << "\\" << name_file;
|
|
fout.open(path, ios_base::out);
|
|
if ((ok = fout.is_open()))
|
|
{
|
|
export_scadenze(fout);
|
|
fout.close();
|
|
}
|
|
name = "Partite aperte";
|
|
break;
|
|
case F_PIANOCONTI: // Not implemented
|
|
name_file = "pianoconti.txt";
|
|
path << "\\" << name_file;
|
|
ok = true;
|
|
name = "Piano dei Conti";
|
|
break;
|
|
case F_MASTRI: // Not implemented
|
|
name_file = "mastri.txt";
|
|
path << "\\" << name_file;
|
|
ok = true;
|
|
name = "Mastri";
|
|
break;
|
|
}
|
|
TString msg; msg << "Esportazione " << name << (ok ? " " : " non ") << "completata.";
|
|
if (ok)
|
|
message_box(msg);
|
|
else
|
|
warning_box(msg);
|
|
return ok;
|
|
}
|
|
|
|
bool TComariExport_app::create()
|
|
{
|
|
open_files(LF_CLIFO, LF_CFVEN, LF_COMUNI, 0);
|
|
return TSkeleton_application::create();
|
|
}
|
|
|
|
void TComariExport_app::main_loop()
|
|
{
|
|
const TFixed_string arg = argv(2);
|
|
if(arg.starts_with("-a") || arg.starts_with("-A"))
|
|
{
|
|
const WINDOW task = TASK_WIN;
|
|
xvt_vobj_set_visible(task, FALSE);
|
|
export_all();
|
|
}
|
|
else
|
|
{
|
|
TComariExport_mask msk;
|
|
while (msk.run() == K_ENTER)
|
|
{
|
|
bool ok = false;
|
|
_fld_dest = msk.get(F_FLDDEST);
|
|
|
|
for (short i = F_CLIFOR; i <= F_MASTRI; ++i)
|
|
{
|
|
if (msk.get_bool(i))
|
|
export_table(i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int ps6215100(const int argc, char* argv[])
|
|
{
|
|
TComariExport_app pe;
|
|
pe.run(argc, argv, TR("Esportazione CO.MA.RI."));
|
|
return 0;
|
|
}
|