campo-sirio/src/fp/fplib01.cpp

#include "fplib01.h"
#include <prefix.h>
#include <config.h>
#include <utility.h>
#include <scanner.h>
#include <xvt.h>
#include <diction.h>
#include "text.h"
#include <isam.h>
#include <tabutil.h>
#include <dongle.h>
#include <execp.h>

#include "../fe/felib.h"
#include "../cg/cglib03.h"

#include <anagiu.h>
#include <comuni.h>
#include <cfven.h>
#include <nditte.h>
#include <unloc.h>
#include <causali.h>
#include "../cg/cfban.h"
#include "modaut.h"

void set_connection(SSimple_query& s)
{
	if (s.sq_connect(
		TString() << ini_get_string(CONFIG_DITTA, "fp", "ip") << "@" << ini_get_string(CONFIG_DITTA, "fp", "db"),
		ini_get_string(CONFIG_DITTA, "fp", "usr"),
		decode(ini_get_string(CONFIG_DITTA, "fp", "psw")),
		TSDB_MSSQL) != NOERR)
		fatal_box("Impossibile connettersi al DB esterno");

}

SSimple_query& db()
{
	static SSimple_query* db = nullptr;

	if (db == nullptr)
	{
		db = new SSimple_query();
		set_connection(*db);
		// Non utilizzo l'autocommit, viene gestito manualmente
		db->sq_set_autocommit(false);
	}
	return *db;
}

string getline(ifstream& f)
{
	string app;
	getline(f, app);
	return app;
}

bool check_tables()
{
	/* 
	 * Da questo programma in poi verr<EFBFBD> utilizzato un sistema diverso per la creazione e aggiornamento delle tabelle
	 * Verranno utilizzati dei file.sql aggiornati con il numero di patch, leggermente scomodo durante la creazione ma facile per i controlli successivamente
	 */
	SLIST files = xvt_fsys_list_files(".sql", "sql/fp0/", false);
	TLocalisamfile tabmod(LF_TABMOD);
	tabmod.put("MOD", "FP");
	tabmod.put("COD", "SQL");
	tabmod.put("CODTAB", "VERSION");
	TString version;
	if (tabmod.read() == NOERR)
		version = tabmod.get("S0");
	for(SLIST_ELT file = xvt_slist_get_first(files); file; file = xvt_slist_get_next(files, file))
	{
		TString file_version = TFilename(file->str).name_only();
		file_version = file_version.mid(2, 4);
		if (file_version <= version)
			continue;
		ifstream f(file->str);
		if(f.is_open())
		{
			string s;
			while(!f.eof())
			{ 
				static string r; 
				r = getline(f);
				if (r[0] == '-' && r[1] == '-')
						continue;
				s += r;
				// Cerco un ;
				const int limiter = s.find(';') + 1;
				if(limiter > 0)
				{
					string query = s.substr(0, limiter);
					s.erase(0, limiter);
					if(!db().sq_set_exec(query) || !db().sq_commit())
					{
						fatal_box("Impossibile eseguire/salvare la query:\n%s\n%s", query.c_str(), db().sq_get_string_error());
					}
				}
			}
		}
		else
		{
			cantread_box(file->str);
			return false;
		}
		// Salvo su tabmod
		tabmod.zero();
		tabmod.put("MOD", "FP");
		tabmod.put("COD", "SQL");
		tabmod.put("CODTAB", "VERSION");
		tabmod.put("S0", file_version);
		if(tabmod.rewrite_write() != NOERR && !yesno_box("Attenzione! Errore di aggiornamento versione di Database in Campo, continuare? %s", file_version))
		{
			return false;
		}
	}
	return true;
}

/*
* HFATT: tipocf(1) + codcf(6)
* BFATT: datadoc(8) + tipodoc_SDI(4) + numdoc(7)
*/

// Crea la coppia di chiavi per il db PAF a partire da un documento vero e proprio
bool chiave_paf(const TDocumento& doc, TString& hfatt, TString& bfatt)
{
		hfatt.cut(0);
		if (doc.clifor().occasionale())
				hfatt << "O" << doc.get("OCFPI");
		else
				hfatt << doc.clifor().tipo() << doc.clifor().codice();
		CHECK(hfatt.full(), "Destinatario fattura P.A. non valido");

		const TCodice_numerazione& codnum = doc.codice_numerazione();
		const long                 ndoc = doc.numero();
		TString16                  fullnumdoc;
		codnum.complete_num(ndoc, fullnumdoc);

		bfatt.cut(0) << doc.get_date(DOC_DATADOC).date2ansi() << '/' << doc.tipo().tipo_doc_sdi() << '/' << fullnumdoc;
		return hfatt.full() && bfatt.full();
}

// Crea la coppia di chiavi per il db PAF a partire da un semplice record di testata documento
bool chiave_paf(const TRectype& doc, TString& hfatt, TString& bfatt)
{
		TDocumento d(doc);
		chiave_paf(d, hfatt, bfatt);
		return hfatt.full();
}

/***************************************************************************
 * TPaf_record
 ***************************************************************************/

// Imposta il valore di un campo variant
void TPaf_record::set(const char* fld, const TVariant& var)
{
		CHECK(fld && *fld, "Null field name");

		if (var.is_null())
		{
				_fields.remove(fld);
		}
		else
		{
				TVariant* obj = (TVariant*)_fields.objptr(fld);
				if (obj != NULL)
						*obj = var;
				else
						_fields.add(fld, new TVariant(var));
		}
}

// Imposta il valore di un campo intero
void TPaf_record::set(const char* fld, long val)
{
		const TVariant var(val);
		set(fld, var);
}

// Imposta il valore di un campo stringa
void TPaf_record::set(const char* fld, const char* val)
{
		if (val == NULL)
				set(fld, NULL_VARIANT);
		else
		{
				const TVariant var(val);
				set(fld, var);
		}
}

// Imposta il valore di un campo stringa
void TPaf_record::set(const char* fld, const TString& val)
{
		const TVariant var(val);
		set(fld, var);
}

// Imposta il valore di un campo numerico
void TPaf_record::set(const char* fld, const real& val)
{
		const TVariant var(val);
		set(fld, var);
}

// Imposta il valore di un campo data in formato ISO
void TPaf_record::set(const char* fld, const TDate& val)
{
		if (val.ok())
		{
				const TVariant var(val);
				set(fld, var);
		}
		else
				set(fld, "");
}

// Imposta il valore di un campo booleano
void TPaf_record::set(const char* fld, bool var)
{
		set(fld, var ? "SI" : "NO");
}

const TString TPaf_record::sq_get(const char* fld) const
{
		return db().sq_get(fld);
}

// Legge il valore di un campo variant
const TVariant& TPaf_record::get(const char* fld) const
{
		const TVariant* var = (const TVariant*)_fields.objptr(fld);
		return var ? *var : NULL_VARIANT;
}

// Converte un variant in una stringa valida per SQLite
const TString& TPaf_record::var2str(const TString& fldname, const TVariant& var) const
{
		const TFieldtypes vt = var.type();
		if (vt == _realfld)
		{
				const TCurrency v(var.as_real(), "", ZERO, fldname.find("PRZ") > 0 || fldname.find("PREZZO") > 0);
				TString&        tmp = get_tmp_string();
				tmp << '\'' << v.string() << '\'';
				tmp.replace(',', '.');
				return tmp;
		}
		if (vt == _datefld)
		{
				TString& tmp = get_tmp_string();
				tmp << '\'' << var.as_date().string(full, '-', full, full, amg_date) << '\'';
				return tmp;
		}

		const TString& str = var.as_string();

		bool apici = vt == _alfafld;
		if (apici && str[0] != '0' && real::is_natural(str))
				apici = false;

		if (!apici)
				return str;

		TString& tmp = get_tmp_string();
		tmp = str;
		for (int a = str.rfind('\''); a >= 0; a--)
		{
				if (tmp[a] == '\'')
						tmp.insert("'", a);
		}
		tmp.insert("'", 0);
		tmp << '\'';
		return tmp;
}

TString& TPaf_record::remove_string()
{
	TString& query = get_tmp_string().cut(0);
	query << "DELETE FROM " << _table << " WHERE ";
	int nkf = 0;
	FOR_EACH_TOKEN(_key, fld)
	{
		const TVariant& var = get(fld);
		if (!var.is_null())
		{
			if (nkf++ > 0)
				query << " AND ";
			query << fld << '=' << var2str(fld, var);
		}
	}
	CHECKS(nkf >= 2, "Can't remove partial key on table ", (const char*)_table);
	query << ';';
	return query;
}


// Elimina il record in base ai campi chiave
bool TPaf_record::remove()
{
		return db().sq_set_exec(remove_string());
}

// Carica un record in base ai campi chiave
bool TPaf_record::search()
{
		CHECKS(_fields.items() > 0, "Can't search with empty key on table ", static_cast<const char*>(_table));
		TString256 query;
		query << "SELECT * FROM " << _table << " WHERE ";
		FOR_EACH_TOKEN(_key, fld)
		{
				const TVariant& var = get(fld);
				if (!var.is_null())
						query << fld << '=' << var2str(fld, var) << " AND ";
		}
		query.rtrim(5);
		query << ';';

		//  return xvt_sql_execute(_db, query, paf_search_record, this) == 1;
		// TODO: Valutare
		return db().sq_set_exec(query);
}

// Carica un record in base ad un massimo di 3 campi chiave
bool TPaf_record::search(const char* k1, const char* k2, const char* k3)
{
		_fields.destroy();

		set(_key.get(0), k1);
		set(_key.get(1), k2);
		if (k3 && *k3)
				set(_key.get(2), k3);

		return search();
}

TString & TPaf_record::insert_string()
{
	CHECKS(_fields.items() >= _key.items(), "Can't insert empty record on table ", _table);

	TString& query = get_tmp_string().cut(0), values = get_tmp_string().cut(0);
	query << "INSERT INTO " << _table << "\n(";
	FOR_EACH_ASSOC_OBJECT(_fields, obj, fld, itm)
	{
		const TVariant& var = get(fld);
		if (!var.is_null())
		{
			query << fld << ',';
			values << var2str(fld, var) << ',';
		}
	}
	query.rtrim(1);
	values.rtrim(1);
	query << ")\nVALUES (" << values << ");";
	return query;
}

// Aggiunge un record al db
bool TPaf_record::insert()
{
		return db().sq_set_exec(insert_string());
}

// Crea un record della tabella data ed imposta i nomi dei campi chiave
TPaf_record::TPaf_record(const char* table) : _table(table), _key(15, ',')
{
		TString q;
		q << "SELECT col.[name] FROM sys.columns AS col \
			inner JOIN sys.index_columns AS idx on col.[object_id] = idx.[object_id] AND col.[column_id] = idx.[column_id] \
			inner join sys.indexes as K on idx.[index_id] = K.[index_id] \
			where  K.[name] = '" << table << "_KEY' \
			AND idx.[object_id] = object_id('" << table << "') \
			ORDER BY index_column_id ASC";
		for (bool ok = db().sq_set_exec(q); ok; ok = db().sq_next())
		{
				_key.add(db().sq_get("name"));
		}
		CHECKS(!_key.empty_items(), "Invalid primary key for table ", table);
}

/***************************************************************************
 * TAncestor
 ***************************************************************************/

struct TAncestor : public TObject
{
		TString20 _numdoc;
		TDate     _datadoc;

		TAncestor(const TRectype& rdoc);
};

TAncestor::TAncestor(const TRectype& rdoc)
{
		const int                  anno = rdoc.get_int(RDOC_ANNO);
		const TString4             codnum = rdoc.get(RDOC_CODNUM);
		const long                 ndoc = rdoc.get_long(RDOC_NDOC);
		const TCodice_numerazione& num = cached_numerazione(codnum);

		TToken_string kdoc;
		kdoc = rdoc.get(RDOC_PROVV);
		kdoc.add(anno);
		kdoc.add(codnum);
		kdoc.add(ndoc);
		const TRectype& doc = cache().get(LF_DOC, kdoc);

		TString16 numdoc;
		num.complete_num(ndoc, numdoc);
		_numdoc.format("%d/%s/%s", anno, static_cast<const char*>(codnum), static_cast<const char*>(numdoc));
		_datadoc = doc.get_date(DOC_DATADOC);
}

/***************************************************************************
 * TDoc_fp
 ***************************************************************************/

bool TDoc_fp::parse_sconto(const TString& formula, TToken_string& sconti) const
{
		sconti.cut(0);
		int      start = 0;
		for (int i = 0; ; i++)
		{
				const char c = formula[i];
				if (c == '+' || c == '-' || c < ' ')
				{
						if (i > 0)
						{
								TString8 tok = formula.sub(start, i);
								tok.replace(',', '.');
								const real perc = tok;
								if (!perc.is_zero())
										sconti.add(tok);
						}
						if (c < ' ')
								break;
						start = i;
				}
		}
		return sconti.full();
}

bool TDoc_fp::get_bnp_iban(const TString& abi, const TString& cab, int nprog, TString& iban)
{
		TTable    bnp("BNP");
		TString16 key;
		key << abi << cab;
		if (nprog > 0)
		{
				TString4 sprog;
				sprog.format("%02d", nprog);
				key << sprog;
		}
		bnp.put("CODTAB", key);
		int err = bnp.read(_isgteq);
		if (err == NOERR && !bnp.get("CODTAB").starts_with(abi))
				err = _iskeynotfound;
		if (err == NOERR)
				iban = bnp.get("S3");

		return err == NOERR;
}

bool TDoc_fp::get_bank(const TDocumento& doc, TString& iban, TString& abi, TString& cab, TString& istituto) const
{
		bool found = false;
		abi = doc.get(DOC_CODABIP);
		cab = doc.get(DOC_CODCABP);
		int prg = doc.get_int(DOC_PROGBNP);

		found = abi.full() && cab.full();
		if (found)
				get_bnp_iban(abi, cab, prg, iban);

		if (!found) // Se non trovo banca sul DOC la cerco su CFBAN
		{
				TToken_string key;
				key.add("C");
				key.add(doc.codcf());
				key.add("N");
				key.add(1);
				const TRectype& cfban = cache().get(LF_CFBAN, key);
				if (!cfban.empty())
				{
						abi = cfban.get(CFBAN_ABI);
						cab = cfban.get(CFBAN_CAB);
						prg = cfban.get_int(CFBAN_PROGPR);
						found = abi.full() && cab.full();
						iban = cfban.get(CFBAN_IBAN);
						if (found && iban.blank())
								get_bnp_iban(abi, cab, prg, iban);
				}
		}

		if (!found) // Se non trovo banca su CFBAN la cerco su CFVEN
		{
				const TRectype& cfven = doc.clifor().vendite();
				abi = cfven.get(CFV_CODABIPR);
				cab = cfven.get(CFV_CODCABPR);
				found = abi.full() && cab.full();
				if (found)
						get_bnp_iban(abi, cab, 0, iban);
		}

		if (found)
				istituto = cache().get("%BAN", abi, "S0");

		return found;
}

const char* TDoc_fp::descrizione(const TRiga_documento& rdoc) const
{
		if (rdoc.get_bool(RDOC_DESCLUNGA))
		{
				TString tmp;
				tmp << rdoc.get(RDOC_DESCR) << rdoc.get(RDOC_DESCEST);
				tmp.replace('\n', ' ');
				tmp.strip_double_spaces();
				tmp.trim();
				TParagraph_string para(tmp, 100);
				return para.get(0);
		}
		return rdoc.get(RDOC_DESCR);
}

const TRectype* TDoc_fp::find_parent_row(const TRectype& rdoc) const
{
		const long id = rdoc.get_long(RDOC_DAIDRIGA);
		if (id > 0L)
		{
				TToken_string key;
				key.add(rdoc.get(RDOC_DACODNUM));
				if (key.full())
				{
						key.add(rdoc.get(RDOC_DAANNO));
						key.add(rdoc.get(RDOC_DAPROVV));
						key.add(rdoc.get(RDOC_DANDOC));
						for (int r = 0; ; r++)
						{
								if (r == 0)
										key.add(id, 4);
								else
										key.add(r, 4);
								const TRectype& rec = cache().get(LF_RIGHEDOC, key);
								if (r > 0 && rec.empty())
										break;
								if (rec.get_long(RDOC_IDRIGA) == id)
										return &rec;
						}
				}
		}
		return NULL;
}

int TDoc_fp::find_ancestors(const TRiga_documento& rdoc, TArray& ancestors) const
{
		if (rdoc.is_articolo())
		{
				for (const TRectype* prdoc = find_parent_row(rdoc); prdoc != NULL; prdoc = find_parent_row(*prdoc))
				{
						const TCodice_numerazione& cn = cached_numerazione(prdoc->get(RDOC_CODNUM));
						const int                  td = cn.tipo();
						if (td > 0 && ancestors.objptr(td) == NULL)
								ancestors.add(new TAncestor(*prdoc), td);
				}
		}
		return ancestors.items();
}

bool TDoc_fp::insert(TPaf_record& p)
{
	bool ok;
	if(_cache_insert)
	{
		_query.push_back(p.insert_string());
		ok = true;
	}
	else
	{
		ok = p.insert();
	}
	return ok;
}

bool TDoc_fp::remove(TPaf_record& p)
{
	bool ok;
	if (_cache_insert)
	{
		_query.push_back(p.remove_string());
		ok = true;
	}
	else
	{
		ok = p.remove();
	}
	return ok;
}

bool TDoc_fp::save_paf()
{
	bool ok = true;
	if (_cache_insert)
	{
		string query;
		for (auto i = _query.begin(); i != _query.end(); ++i)
			query += *i;
		ok = db().sq_set_exec(query);
	}
	return ok;
}

const TRectype& TDoc_fp::cco(const TRectype& doc) const
{
		TString80      conkey;
		const TString& con = doc.get(DOC_CONTRATTO);
		if (con.full())
		{
				char tcon = doc.get_char(DOC_MODPAG);
				if (tcon < 'C') tcon = 'C';
				conkey.format("%c%6ld%s", tcon, doc.get_long(DOC_CODCF), (const char*)con);
		}
		return cache().get("&CON", conkey);
}

void TDoc_fp::log(int severity, const char* msg)
{
		if (severity < 0)
		{
				_logpaf = msg;
		}
		else if (_log == NULL)
		{
				_log = new TLog_report;
				if (_logpaf.full())
				{
						TString txt;
						txt << _logpaf << ": " << msg;
						_log->log(severity, txt);
				}
				else
						_log->log(severity, msg);
		}
}

bool TDoc_fp::show_log()
{
		if (_log)
		{
				_log->preview();
				delete _log;
				_log = NULL;
		}
		return true;
}

const int TDoc_fp::commit()
{
	int r = 0;
	if (_to_commit)
	{
		if(db().sq_set_exec("UPDATE PAF0100F SET P1_GESTIONE = 'P' WHERE P1_GESTIONE = 'D'") && db().sq_commit())
		{
			r = 1;
		}
		else
		{
			r = -1;
			log(3, db().sq_get_string_error());
		}
	}
	_to_commit = false;
	return r;
}


const char* TDoc_fp::natura(const TString& codiva) const
{
		return cache().get("%IVA", codiva, "S12");
}

void TDoc_fp::set_IVA(const TString& codiva, TPaf_record& paf)
{
		// <20> necessario il cast a real?
		paf.set("PI_ALIQUOTAIVA", static_cast<real>(cache().get("%IVA", codiva, "R0")));
		paf.set("PI_NATURA", cache().get("%IVA", codiva, "S12"));
}

void TDoc_fp::set_IVA(const TRiga_documento& rdoc, TPaf_record& paf)
{
		set_IVA(rdoc.get(RDOC_CODIVA), paf);
}

bool TDoc_fp::add_row_art(const TString codice_tipo, const TString& codice_valore, TPaf_record& paf)
{
		static long riga_art = 0;
		paf.set("PY_KEYNLINAR", ++riga_art);
		paf.set("PY_TIPOARTICOLO", codice_tipo);
		paf.set("PY_VALOREARTICOLO", codice_valore);
		const bool ok = insert(paf);
#ifdef DBG
		if (!ok)
				error_box("Allah al bar!");
#endif
		return ok;
}

bool TDoc_fp::add_row_alleg(TFilename& file, long& nprogr, TPaf_record& paf)
{
	static TString dest_path;
	static TString dest_usr_path;
	bool ok = false;

	dest_path.cut(0) << _def_fld << file.name();
	dest_usr_path.cut(0) << _def_usr_fld << file.name();
	if (!fcopy(file, dest_usr_path))
	{
		return yesno_box("Errore critico nel copiare il file %s, si desidera continuare?", file.name());
	}
	
	// Provo a copiare il file
	paf.set("PP_NUMEROLINEA", ++nprogr);
	paf.set("PP_NOMEATTACHMENT", file.name());
	paf.set("PP_ATTACHMENT", dest_path);
	file.upper(); // serve estensione maiuscola
	paf.set("PP_FMTATTACHMENT", file.ext());
	ok = insert(paf);
	
	return ok;
}


bool TDoc_fp::doc_to_paf(TDocumentoEsteso& doc)
{
	TString8  hfatt; // Codice univoco di 6 caratteri dell'ufficio P.A. o di 7 caratteri per un privato
	TString20 bfatt; // Codice univoco di 20 caratteri del documento

	TAnagrafica clifo(doc.clifor().tipo(), doc.clifor().codice());

	TString8 coddest = doc.clifor().vendite().get("PADESTIN");
	TString pec = doc.clifor().get("PEC");
	bool enapec = false;
	if (coddest.empty())
	{
			// Controllo se ha la pec
			if (pec.full())
			{
					coddest = "0000000";
					enapec = true;
			}
			// Controllo se <20> straniero
			else if (clifo.estero())
			{
					coddest = "XXXXXXX";
			}
			else
					return false;
	}

	const bool privato = coddest.len() != 6;
	bool ok = true;

	if (!chiave_paf(doc, hfatt, bfatt))
			return false;
	log(-1, bfatt);

	const TFirm&      firm = prefix().firm();
	const char* const paese = "IT";
	TCausale          caus = TCausale(doc.tipo().causale(), doc.anno());

	// <DatiTrassmissione>
	TPaf_record paf0100f("PAF0100F");
	paf0100f.set("P1_KEYHEADERFATT", hfatt);
	paf0100f.set("P1_KEYBODYFATT", bfatt);
	remove(paf0100f);

	paf0100f.set("P1_TRASMITTPAESE", paese);
	paf0100f.set("P1_TRASMITTCOD", _cofi);
	paf0100f.set("P1_FMTTRASMISS", privato ? "FPR12" : "FPA12"); // SDI11 si usa dal 2015 per lo split payment (prima era SDI10)

	paf0100f.set("P1_CODDEST", coddest);
	TString80 tel;
	tel << firm.get(NDT_PTEL) << firm.get(NDT_TEL);
	paf0100f.set("P1_TELEFONO", tel);
	paf0100f.set("P1_MAIL", firm.get(NDT_MAIL));
	paf0100f.set("P1_GESTIONE", "D");
	ok &= insert(paf0100f);
	// </DatiTrassmissione>

	if (enapec)
	{
			// <Datipec>
			TPaf_record paf3200f("PAF3200F");
			paf3200f.set("PU_KEYHEADERFATT", hfatt);
			paf3200f.set("PU_KEYBODYFATT", bfatt);
			remove(paf3200f);
			paf3200f.set("PU_PEC", pec);
			ok &= insert(paf3200f);
			// </Datipec>
	}

	// <CedentePrestatore>
	TPaf_record paf0200f("PAF0200F");
	paf0200f.set("P2_KEYHEADERFATT", hfatt);
	paf0200f.set("P2_KEYBODYFATT", bfatt);
	remove(paf0200f);

	if (_ditta.partita_IVA().full())
	{
			paf0200f.set("P2_FISCIVAPAESE", _ditta.stato_partita_IVA());
			paf0200f.set("P2_FISCIVACOD", _ditta.partita_IVA());
	}
	paf0200f.set("P2_CODFISCALE", _ditta.codice_fiscale());
	if (_ditta.fisica())
	{
			paf0200f.set("P2_ANANOME", _ditta.nome());
			paf0200f.set("P2_ANACOGNOME", _ditta.cognome());
	}
	else
	{
			paf0200f.set("P2_ANADENOMIN", _ditta.ragione_sociale());
	}

	paf0200f.set("P2_REGFISCALE", doc.tipo().reg_fisc());

	// DatiSede
	paf0200f.set("P2_SEDEIND", _ditta.via_residenza());
	paf0200f.set("P2_SEDENRCIVICO", _ditta.civico_residenza());
	paf0200f.set("P2_SEDECAP", _ditta.CAP_residenza());
	paf0200f.set("P2_SEDECOMUNE", _ditta.comune_residenza());
	paf0200f.set("P2_SEDEPROV", _ditta.provincia_residenza());
	paf0200f.set("P2_SEDENAZ", paese);
	paf0200f.set("P2_GESTIONE", "D");

	TAnagrafica cliente(doc.clifor());

	TString rifamm = cco(doc).get("S4");
	if (rifamm.blank())
			rifamm = doc.clifor().vendite().get(CFV_PARIFAMM);
	paf0200f.set("P2_RIFAMMINISTR", rifamm);

	paf0200f.set("P2_ISCRREASOCIOU", _ditta.sociounico() == 'S' ? "SU" : "SM");

	TISAM_recordset unloc("USE UNLOC\nJOIN COMUNI INTO COM==COMCCIAA\nFROM CODDITTA=#DITTA\nTO CODDITTA=#DITTA");
	unloc.set_var("#DITTA", firm.get(NDT_CODDITTA));
	if (unloc.move_first())
	{
			const TString& numrea = unloc.get(ULC_NUMCCIAA).as_string();
			if (numrea.full())
			{
					paf0200f.set("P2_ISCRREANUM", numrea);
					paf0200f.set("P2_ISCRREAUFF", unloc.get("13->" COM_PROVCOM));
			}
	}

	if (_ditta.giuridica())
	{
			TISAM_recordset anagiu("USE ANAGIU\nFROM CODANAGR=#CODICE\nTO CODANAGR=#CODICE");
			anagiu.set_var("#CODICE", firm.get(NDT_CODANAGR));
			if (anagiu.move_first())
			{
					paf0200f.set("P2_ISCRREACAP", anagiu.get(ANG_CAPSOC));
					const int ss = anagiu.get(ANG_STATOSOC).as_int();
					paf0200f.set("P2_ISCRREASLIQUID", (ss == 2 || ss == 3) ? "LS" : "LN");
			}
	}
	else
			paf0200f.set("P2_ISCRREASLIQUID", "LN");

	ok &= insert(paf0200f);

	// </CedentePrestatore>

	// <CessionarioCommittente>

	TPaf_record paf0400f("PAF0400F");
	paf0400f.set("P4_KEYHEADERFATT", hfatt);
	paf0400f.set("P4_KEYBODYFATT", bfatt);
	remove(paf0400f);

	if (cliente.partita_IVA().full())
	{
			paf0400f.set("P4_FISCIVAPAESE", cliente.stato_partita_IVA());
			paf0400f.set("P4_FISCIVACOD", cliente.partita_IVA());
	}
	paf0400f.set("P4_CODFISC", cliente.codice_fiscale());

	if (cliente.fisica())
	{
			paf0400f.set("P4_ANANOME", cliente.nome());
			paf0400f.set("P4_ANACOGNOME", cliente.cognome());
	}
	else
	{
			paf0400f.set("P4_ANADENOM", cliente.ragione_sociale());
	}

	// DatiSede
	paf0400f.set("P4_SEDEIND", cliente.via_residenza());
	paf0400f.set("P4_SEDENRCIVICO", cliente.civico_residenza());
	paf0400f.set("P4_SEDECAP", cliente.CAP_residenza());
	paf0400f.set("P4_SEDECOMUNE", cliente.comune_residenza());
	paf0400f.set("P4_SEDEPROV", cliente.provincia_residenza());
	paf0400f.set("P4_SEDENAZ", cliente.stato_residenza_ISO());
	paf0400f.set("P4_GESTIONE", "D");
	ok &= insert(paf0400f);
	// </CessionarioCommittente>

	// <DatiGenerali>
	TPaf_record paf0700f("PAF0700F");
	paf0700f.set("P7_KEYHEADERFATT", hfatt);
	paf0700f.set("P7_KEYBODYFATT", bfatt);
	remove(paf0700f);
	paf0700f.set("P7_TIPODOC", doc.tipo().tipo_doc_sdi());
	paf0700f.set("P7_DIVISA", "EUR"); // Aggiungere codice ISO 4217 a tabella divise (%VAL)
	paf0700f.set("P7_DATA", doc.data());

	const TCodice_numerazione& codnum = doc.codice_numerazione();
	TString20                  numdoc;
	codnum.complete_num(doc.numero(), numdoc);
	paf0700f.set("P7_NUMERO", numdoc);
	paf0700f.set("P7_GESTIONE", "D");

	// <DatiBollo>
	if (doc.get_real("BOLLI") > ZERO)
	{
			paf0700f.set("P7_IMPORTOBOLLO", doc.get("BOLLI"));
	}
	// </DatiBollo>

	// <DatiCassaPrevidenziale>
	// Non la mettiamo!
	// </DatiCassaPrevidenziale>

	// Non inserisco pi<70> adesso il paf0700f ma lo faccio alla fine (per inserire le ritenute)

	// <ScontoMaggiorazione>
	TPaf_record paf0900f("PAF0900F");
	paf0900f.set("P9_KEYHEADERFATT", hfatt);
	paf0900f.set("P9_KEYBODYFATT", bfatt);
	remove(paf0900f);

	TString80     sconto_expr = doc.get(DOC_SCONTOPERC);
	TToken_string sconti;
	if (parse_sconto(sconto_expr, sconti))
	{
			long nlin_sconto = 0;
			FOR_EACH_TOKEN(sconti, str)
			{
					const real sconto = str;
					if (!sconto.is_zero()) // Precauzione inutile
					{
							paf0900f.set("P9_RIFNUMLINEA", ++nlin_sconto);
							if (sconto > ZERO)
							{
									paf0900f.set("P9_TIPOSCONTO", "SC");
									paf0900f.set("P9_PERCSCONTO", sconto);
							}
							else
							{
									paf0900f.set("P9_TIPOSCONTO", "MG");
									paf0900f.set("P9_PERCSCONTO", -sconto);
							}
							paf0900f.set("P9_GESTIONE", "D");
							ok &= insert(paf0900f);
					}
			}
	}
	// </ScontoMaggiorazione>

	// <DatiGenerali>
	TPaf_record paf2700f("PAF2700F");
	paf2700f.set("PQ_KEYHEADERFATT", hfatt);
	paf2700f.set("PQ_KEYBODYFATT", bfatt);
	remove(paf2700f);
	paf2700f.set("PQ_IMPTOTDOC", doc.totale_doc());

	const TRectype& cont_conv_off = cco(doc);
	TString         causale = cont_conv_off.get("S1");
	if (causale.full())
	{
			causale << ' ' << cont_conv_off.get("S2");
			causale << ' ' << cont_conv_off.get("S3");
			causale.strip_double_spaces();
			causale.cut(200);
	}
	else
			causale = doc.tipo().descrizione();
	paf2700f.set("PQ_CAUSALE", causale);
	// paf2700f.set("PQ_ART73", true);
	paf2700f.set("PQ_GESTIONE", "D");
	ok &= insert(paf2700f);
	// </DatiGenerali>

	// Azzera DDT
	TPaf_record paf1600f("PAF1600F");
	paf1600f.set("PF_KEYHEADERFATT", hfatt);
	paf1600f.set("PF_KEYBODYFATT", bfatt);
	remove(paf1600f);

	// Fuori dallo scope per dopo
	const TString16 cup = doc.get(DOC_CUP);
	const TString16 cig = doc.get(DOC_CIG);
	const TString80 com = doc.get(DOC_CODCMS);

	if (!privato)
	{
			// Azzera contratti
			TPaf_record paf1000f("PAF1000F");
			paf1000f.set("P0_KEYHEADERFATT", hfatt);
			paf1000f.set("P0_KEYBODYFATT", bfatt);
			remove(paf1000f);

			// Azzera convenzioni
			TPaf_record paf1100f("PAF1100F");
			paf1100f.set("PA_KEYHEADERFATT", hfatt);
			paf1100f.set("PA_KEYBODYFATT", bfatt);
			remove(paf1100f);

			// Azzera ordini
			TPaf_record paf1200f("PAF1200F");
			paf1200f.set("PB_KEYHEADERFATT", hfatt);
			paf1200f.set("PB_KEYBODYFATT", bfatt);
			remove(paf1200f);

			TString80 con = doc.get(DOC_CONTRATTO);
			if (con.full() || cup.full() || cig.full())
			{
					char tcon = doc.get_char(DOC_MODPAG);
					if (tcon < 'C') tcon = 'C';

					TDate datadoc; // Data contratto non obbligatoria
					if (con.full())
					{
							datadoc = cco(doc).get_date("D0");
					}
					else
					{
							// IdDocumento obbligatorio
							con = cig;
							if (con.blank())
									con = cup;
					}

					if (tcon == 'O')
					{
							paf1000f.set("P0_RIFNUMLINEA", 0L);
							paf1000f.set("P0_IDDOC", con);
							paf1000f.set("P0_DATADOC", datadoc);
							paf1000f.set("P0_COMMCONVENZ", com);
							paf1000f.set("P0_CODCUP", cup);
							paf1000f.set("P0_CODCIG", cig);
							paf1000f.set("P0_GESTIONE", "D");
							ok &= insert(paf1000f);
					}
					else if (tcon == 'C')
					{
							paf1100f.set("PA_RIFNUMLINEA", 0L);
							paf1100f.set("PA_IDDOC", con);
							paf1100f.set("PA_DATADOCU", datadoc);
							paf1100f.set("PA_COMMCONVENZ", com);
							paf1100f.set("PA_CODCUP", cup);
							paf1100f.set("PA_CODCIG", cig);
							paf1000f.set("PA_GESTIONE", "D");
							ok &= insert(paf1100f);
					}
					else
					{
							paf1200f.set("PB_RIFNUMLINEA", 0L);
							paf1200f.set("PB_IDDOC", con);
							paf1200f.set("PB_DATADOCO", datadoc);
							paf1200f.set("PB_COMMCONVENZ", com);
							paf1200f.set("PB_CODCUP", cup);
							paf1200f.set("PB_CODCIG", cig);
							paf1200f.set("PB_GESTIONE", "D");
							ok &= insert(paf1200f);
					}
			}

			if (cup.blank() && cig.blank())
					log(1, "CIG e CUP assenti");
	}
	// <DatiBeniServizi>

	TPaf_record paf1800f("PAF1800F");
	paf1800f.set("PI_KEYHEADERFATT", hfatt);
	paf1800f.set("PI_KEYBODYFATT", bfatt);
	remove(paf1800f); // Cancella tutte le righe documento

	TPaf_record paf2000f("PAF2000F");
	paf2000f.set("PJ_KEYHEADERFATT", hfatt);
	paf2000f.set("PJ_KEYBODYFATT", bfatt);
	remove(paf2000f); // Cancella tutti gli sconti di riga

	TPaf_record paf1900f("PAF1900F");
	paf1900f.set("PY_KEYHEADERFATT", hfatt);
	paf1900f.set("PY_KEYBODYFATT", bfatt);
	remove(paf1900f); // Cancella tutte le righe articoli del documento


	long      riga = 0;
	TString16 codivadefault;
	{
			FOR_EACH_PHYSICAL_RDOC(doc, r, rdoc)
			{
					codivadefault = rdoc->get(RDOC_CODIVA);
					if (codivadefault.full())
							break;
			}
	}
	FOR_EACH_PHYSICAL_RDOC(doc, r, rdoc)
	{
			paf1800f.reset();
			paf1800f.set("PI_KEYHEADERFATT", hfatt);
			paf1800f.set("PI_KEYBODYFATT", bfatt);
			paf1800f.set("PI_NUMEROLINEA", ++riga);
			paf1800f.set("PI_DESCRIZIONE", descrizione(*rdoc));
			//    paf1800f.set("PI_ALIQUOTAIVA", "22.00"); // Altrimenti scarta le righe di descrizione

			// <CodiceArticolo>
			long riga_art = 0;
			TArticolo& art = rdoc->articolo();
			if (art.ok())
			{
					paf1900f.reset();
					paf1900f.set("PY_KEYHEADERFATT", hfatt);
					paf1900f.set("PY_KEYBODYFATT", bfatt);
					paf1900f.set("PY_KEYNLINEA", riga);

					TString& tmp = get_tmp_string();

					if (art.codice().full())
					{
							tmp.cut(0) << art.codice(); // Fixed_string di merda
							ok &= add_row_art("Codice interno", tmp, paf1900f);
					}
					if (rdoc->tipo().codice() == "14")
					{
							ok &= add_row_art("Codice cliente", rdoc->get("CODARTALT"), paf1900f);
					}
			}
			// </CodiceArticolo>


			set_IVA(codivadefault, paf1800f);

			if (rdoc->is_merce())
			{
					paf1800f.set("PI_UNITAMISURA", rdoc->get(RDOC_UMQTA));
					const real qta = rdoc->get(RDOC_QTA);
					if (qta.is_zero())
					{
							TString msg;
							msg.format("La riga merce %d ha quantit<69> nulla", riga);
							log(1, msg);
					}
					if (qta >= ZERO)
					{
							paf1800f.set("PI_QUANTITA", qta);
							paf1800f.set("PI_PREZZOUNIT", rdoc->prezzo(false, false));
					}
					else
					{
							paf1800f.set("PI_QUANTITA", -qta);
							paf1800f.set("PI_PREZZOUNIT", -rdoc->prezzo(true, false));
					}
					paf1800f.set("PI_PRZTOTALE", rdoc->importo(true, false));
					set_IVA(*rdoc, paf1800f);

					/*
					const TDate data = doc.get(DOC_DATADOC);
					paf1800f.set("PI_DTINIZIOPER", data);
					paf1800f.set("PI_DTFINEPER", data);
					*/

					// <ScontoMaggiorazione>

					sconto_expr = rdoc->get(RDOC_SCONTO);
					if (parse_sconto(sconto_expr, sconti))
					{
							long nlin_sconto = 0;
							FOR_EACH_TOKEN(sconti, str)
							{
									const real perc = str;
									if (!perc.is_zero())
									{
											paf2000f.set("PJ_KEYNLINEA", (long)r);
											paf2000f.set("PJ_KEYNLINAR", ++nlin_sconto);
											if (perc > ZERO)
											{
													paf2000f.set("PJ_TIPOSCONTO", "SC");
													paf2000f.set("PJ_PERCSCONTO", perc);
											}
											else
											{
													paf2000f.set("PJ_TIPOSCONTO", "MG");
													paf2000f.set("PJ_PERCSCONTO", -perc);
											}
											paf2000f.set("PJ_GESTIONE", "D");
											ok &= insert(paf2000f);
									}
							}
					}
					// </ScontoMaggiorazione>


					/*
					* Ogni riga si pu<EFBFBD> rifare a un DDT/Ordine diverso, per questo devo inserire i dati da qua e non in testata
					*/
					TArray ancestors;
					find_ancestors(*rdoc, ancestors);
					for (int i = ancestors.last(); i > 0; i = ancestors.pred(i))
					{
							const TAncestor& a = (const TAncestor&)ancestors[i];
							if (i == 1)
							{
									// <DatiDDT>
									TPaf_record paf1600f("PAF1600F");
									paf1600f.reset();
									paf1600f.set("PF_KEYHEADERFATT", hfatt);
									paf1600f.set("PF_KEYBODYFATT", bfatt);
									paf1600f.set("PF_RIFNUMLINEA", (long)r);
									paf1600f.set("PF_NUMDDDT", a._numdoc);
									paf1600f.set("PF_DATADDT", a._datadoc);
									paf1600f.set("PF_GESTIONE", "D");
									ok &= insert(paf1600f);
									// </DatiDDT>
							}
							else if (i == 3)
							{
									// <DatiOrdineAcquisto>
									TPaf_record paf1000f("PAF1000F");
									paf1000f.set("P0_KEYHEADERFATT", hfatt);
									paf1000f.set("P0_KEYBODYFATT", bfatt);
									paf1000f.set("P0_RIFNUMLINEA", (long)r);
									paf1000f.set("P0_IDDOC", a._numdoc);
									paf1000f.set("P0_DATADOC", a._datadoc);
									if (!privato)
									{
											paf1000f.set("P0_COMMCONVENZ", com);
											paf1000f.set("P0_CODCUP", cup);
											paf1000f.set("P0_CODCIG", cig);
									}
									paf1000f.set("P0_GESTIONE", "D");
									ok &= insert(paf1000f);
									// </DatiOrdineAcquisto>
							}
					}

			}
			else if (rdoc->is_spese())
			{
					const TSpesa_prest& sp = rdoc->spesa();
					const real          imp = rdoc->importo(true, false);
					real                qta = UNO;
					if (sp.is_tipo())
					{
							paf1800f.set("PI_UNITAMISURA", rdoc->get(RDOC_UMQTA));
							qta = rdoc->get_real(RDOC_QTA);
							if (qta.is_zero())
							{
									TString msg;
									msg.format("La riga spese a quantit<69> %d ha quantit<69> nulla (campo %s)", riga, (const char*)rdoc->field_qta());
									log(1, msg);
									qta = UNO;
							}
							paf1800f.set("PI_QUANTITA", qta);
					}
					real prz = imp;
					if (qta != UNO)
					{
							prz = rdoc->prezzo(true, false);
							if (prz.is_zero() && !imp.is_zero())
							{
									const TPrice price(imp / qta);
									prz = price.get_value();
							}
					}
					paf1800f.set("PI_PREZZOUNIT", prz);
					paf1800f.set("PI_PRZTOTALE", imp);
					set_IVA(*rdoc, paf1800f);

					// Controllo se <20> una ritenuta fiscale
					// <DatiRitenuta>
					if (sp.tipo_ritenuta() == 'F')
					{
							paf0700f.set("P7_TIPORITENUTA", cliente.fisica() ? "RT01" : "RT02");
							paf0700f.set("P7_IMPORTORIT", doc.imponibile() * sp.perc() / CENTO);
							paf0700f.set("P7_ALIQUOTARIT", TCodiceIVA(sp.cod_iva()).percentuale());
							paf0700f.set("P7_CAUSPAGAM", cache().get("CA7", to_tstring(sp.caus_770()), "S2"));
					}
					// </DatiRitenuta>
			}
			else if (rdoc->is_prestazione())
			{
					paf1800f.set("PI_UNITAMISURA", rdoc->get(RDOC_UMQTA));
					real qta = rdoc->get(RDOC_QTA);
					if (qta.is_zero()) qta = UNO;
					paf1800f.set("PI_QUANTITA", qta);
					paf1800f.set("PI_PREZZOUNIT", rdoc->prezzo(false, false));
					paf1800f.set("PI_PRZTOTALE", rdoc->importo(true, false));
					set_IVA(*rdoc, paf1800f);
			}

			paf1800f.set("PI_GESTIONE", "D");
			ok &= insert(paf1800f);
	}
	// </DatiBeniServizi>


	// <DatiTrasporto>
	/*
	* Non valorizziamo nulla al momento in quanto su Campo i dati obbligatori non ci sono/non sono obbligatori
	TString cod_vettore = doc.get("CODVETT1");
	// <20> una fattura accompagnatoria!
	if(cod_vettore.full())
	{
	}
	*/
	// </DatiTrasporto>

	// Salvo la testata
	ok &= insert(paf0700f);

	// <DatiRiepilogo>
	TPaf_record paf2200f("PAF2200F");
	paf2200f.set("PL_KEYHEADERFATT", hfatt);
	paf2200f.set("PL_KEYBODYFATT", bfatt);
	remove(paf2200f); // Cancella tutte le righe di riepilogo IVA

	const char* eiva = "I"; // Esigibilit<69> IVA: Immediata, Differita, Split payment
	if (doc.is_split_payment())
			eiva = "S";
	else if (doc.get_bool(DOC_LIQDIFF) || doc.get_bool(DOC_IVAXCASSA))
			eiva = "D";

	long          num_riep = 0;
	TAssoc_array& tiva = doc.tabella_iva(false);
	FOR_EACH_ASSOC_OBJECT(tiva, obj, key, itm)
	{
			const TRiepilogo_iva& riva = *(const TRiepilogo_iva*)itm;
			const real            aliquota = riva.cod_iva().percentuale();
			paf2200f.set("PL_ALIQUOTAIVA", aliquota);
			if (aliquota.is_zero())
					paf2200f.set("PL_NATURA", natura(riva.cod_iva().codice()));

			paf2200f.set("PL_IMPONIBILE", riva.imponibile());
			paf2200f.set("PL_IMPOSTA", riva.imposta());
			paf2200f.set("PL_ESIGIVA", eiva);
			if (*eiva == 'S')
					paf2200f.set("PL_RIFNORMATIVO", "Scissione pagamenti art.17-ter DPR 633/72");
			else
					paf2200f.set("PL_RIFNORMATIVO", riva.cod_iva().descrizione());
			paf2200f.set("PL_GESTIONE", "D");
			ok &= insert(paf2200f);
	}
	// </DatiRiepilogo>

	// <DatiPagamento>
	TPaf_record paf2400f("PAF2400F");
	paf2400f.set("PN_KEYHEADERFATT", hfatt);
	paf2400f.set("PN_KEYBODYFATT", bfatt);
	remove(paf2400f); // Cancella i dati pagamento

	TPagamento& pag = doc.pagamento();
	doc.scadenze_recalc(); // Ricalcola array delle rate
	TString_array& scad = doc.scadenze();
	const int      nrate = scad.items();                // Conta rate generate 
	const char*    rateazione = pag.cond_pag_sdi();		// A rate (TP01) o una soluzione(TP02)?
	paf2400f.set("PN_RIGA", ZERO);                              // Al momento non gestiamo pi<70> tipologie di pagamento per documento
	paf2400f.set("PN_CONDPAGAMENTO", rateazione);
	paf2400f.set("PN_GESTIONE", "D");
	ok &= insert(paf2400f);

	TPaf_record paf2500f("PAF2500F");
	paf2500f.set("PO_KEYHEADERFATT", hfatt);
	paf2500f.set("PO_KEYBODYFATT", bfatt);
	remove(paf2500f); // Cancella tutte le rate

										 // Imposto i campi uguali per tutte le rate
	paf2500f.set("PO_CONDPAGAMENTO", rateazione); // Condizione di pagamento PA
	paf2500f.set("PO_CODICEPAGAM", pag.code());   // Condizione di pagamento CAMPO   

	TString80 iban, istituto;
	TString8  abi, cab;
	if (get_bank(doc, iban, abi, cab, istituto))
	{
			paf2500f.set("PO_ISTFINANZ", istituto);
			paf2500f.set("PO_IBAN", iban);
			paf2500f.set("PO_ABI", abi);
			paf2500f.set("PO_CAB", cab);
	}

	if (cab.blank())
			log(2, TR("Non sono presenti ABI, CAB, IBAN per il pagamento"));
	else if (iban.blank())
			log(1, TR("Non <20> presente il codice IBAN per il pagamento"));

	for (int nr = 0; nr < nrate; nr++)
	{
			paf2500f.set("PO_RIGA", long(nr + 1)); // Numero rata
			int rp = nr < pag.n_rate() ? nr : 0;
			static TString key_class; key_class.cut(0) << pag.tipo_rata(rp) << pag.ulc_rata(rp);
#ifdef DBG
			bool tolla = true;
			TString pop = cache().get("%CLR", key_class, "S12");
			bool aaaa = true;
#endif
			paf2500f.set("PO_MODALITAPAGAM", cache().get("%CLR", key_class, "S12")); // Si assicura che il numero riga sia accettabile

			TToken_string& riga = scad.row(nr);                  // Data|Importo   
			paf2500f.set("PO_DATASCADENZA", TDate(riga.get(0))); // Data scadenza
			paf2500f.set("PO_IMPORTO", real(riga.get()));        // Importo rata 

			paf2500f.set("PO_GESTIONE", "D");
			ok &= insert(paf2500f);
	}

	if (_gestioneallegati)
	{
		TPaf_record paf2600f("PAF2600F");
		paf2600f.set("PP_KEYHEADERFATT", hfatt);
		paf2600f.set("PP_KEYBODYFATT", bfatt);
		remove(paf2600f); // Cancella eventuali allegati
		long      nprogr = 0; // Numero di file allegati
		// Se abilitato stampo il documento e lo allego
		TFilename rep;
		if (_allegafattura && dongle().active(RSAUT) && doc.tipo().main_print_profile(rep, 2))
		{
			//ve1 -2 {CODNUM} {ANNO} {PROVV} {NDOC}(-{ANDOC}) {TIPO_ELABORAZIONE} {TIPO_STAMPA}

			// Costruisco la chiamata
			static TString commandline;
			commandline.cut(0) << "ve1 -2 " << doc.get(DOC_CODNUM) << ' ' << doc.get(DOC_ANNO)
				<< ' ' << doc.get(DOC_PROVV) << ' ' << doc.get(DOC_NDOC) << " X P";	// X: stampa su disco, P: provvisorio
			TExternal_app interattivo(commandline);
			if (interattivo.run() != NOERR)
			{
				TString msgerr = "Fallita generazione PDF documento ";
				msgerr << doc.get(DOC_CODNUM) << ' ' << doc.get(DOC_ANNO)
					<< ' ' << doc.get(DOC_PROVV) << ' ' << doc.get(DOC_NDOC);
				error_box(msgerr);
			}
			else
			{
				TFilename pdf; pdf.tempdir();
				pdf << SLASH << doc.get(DOC_ANNO) << '_' << doc.get(DOC_CODNUM) << '_' << doc.get(DOC_NDOC) << ".pdf";
				if (!pdf.exist() && !yesno_box("Attenzione! Non <20> stato possibile creare il pdf, continuare?"))
				{
					return false;
				}
				if (!add_row_alleg(pdf, nprogr, paf2600f))
					return false;
			}
		}

		TToken_string allegati(doc.get("COLL_GOLEM"), '\n');
		bool load_allegati = true;
		if (allegati.full())
		{
			if (_def_fld.empty())
			{
				TString msgerr; msgerr << "Errore: il documento " << bfatt << " ha degli allegati ma nella configurazione non <20> stato impostato come trametterli\nCaricare il documento senza allegati?";
				load_allegati = false;
				if (!yesno_box(msgerr))
					return false;
			}
			else
			{

				TFilename fname;
				FOR_EACH_TOKEN(allegati, row)
				{
					const TToken_string entry(row);
					if (entry.get(0, fname) && fname.exist())
					{
						if (!add_row_alleg(fname, nprogr, paf2600f))
							return false;
					}
				}
			}
		}
	}
	// </DatiPagamento>

	// Tabella di non invio XML
	TPaf_record pafw300f("PAFW300F");
	pafw300f.set("PW_KEYHEADERFATT", hfatt);
	pafw300f.set("PW_KEYBODYFATT", bfatt);
	remove(pafw300f); // Cancella eventuali allegati
	const TTipo_documento& td = cached_tipodoc(doc.get(DOC_TIPODOC));
	const TString codsdi = !td.invio_xml() ? "**********" : (enapec ? pec : coddest);
	pafw300f.set("PW_CODSDI", codsdi);
	ok &= insert(pafw300f);

	return _to_commit = (ok && save_paf());
}

bool TDoc_fp::doc_to_paf(const TRectype& rec)
{
		TDocumentoEsteso doc;
		if (doc.read(rec) == NOERR)
		{
				return doc_to_paf(doc) ? db().sq_commit() : db().sq_rollback();
		}
		return false;
}

bool TDoc_fp::doc_to_paf(const TDoc_key& key)
{
		TRectype rec(LF_DOC);
		rec.put(DOC_PROVV, key.provv());
		rec.put(DOC_ANNO, key.anno());
		rec.put(DOC_CODNUM, key.codnum());
		rec.put(DOC_NDOC, key.ndoc());
		return doc_to_paf(rec);
}

bool TDoc_fp::doc_to_paf(const TFilename& ini)
{
		TConfig             cfg(ini, "33");
		const int           anno = cfg.get_int(DOC_ANNO);
		const long          ndoc = cfg.get_long(DOC_NDOC);
		const TFixed_string codnum(cfg.get(DOC_CODNUM)); // lascio sapientemente per ultima la get di una stringa
		const TDoc_key      key(anno, codnum, ndoc);
		return doc_to_paf(key);
}

TDoc_fp::TDoc_fp() : _log(nullptr), _cache_insert(false)
{
	_ditta.init(LF_NDITTE, prefix().get_codditta());
	_cofi = ini_get_string(CONFIG_DITTA, "fp", "cofitras");
	
	if (_cofi.blank())
		_cofi = _ditta.codice_fiscale();

	_gestioneallegati = ini_get_bool(CONFIG_DITTA, "fp", "gestioneallegati");
	_allegafattura = ini_get_bool(CONFIG_DITTA, "fp", "allegafatt");

	_def_fld = ini_get_string(CONFIG_DITTA, "fp", "flddest");
	if (!_def_fld.ends_with("\\"))
	{
		_def_fld << "\\";
	}

	_def_usr_fld = ini_get_string(CONFIG_DITTA, "fp", "fldusrdest", "");
	if (_def_usr_fld.empty())
	{
		_def_usr_fld = _def_fld;
	}
	else if (!_def_usr_fld.ends_with("\\"))
	{
		_def_usr_fld << "\\";
	}
}

TDoc_fp::~TDoc_fp()
{
	commit();
}