campo-sirio/ps/pg0001600.cpp

#include <applicat.h>
#include <automask.h>
#include <execp.h>
#include <progind.h>
#include <reprint.h>
#include <reputils.h>
#include <utility.h>

#include "pg0001.h"
#include "pg0001600a.h"

#include "textset.h"


#include <clifo.h>
#include <cfven.h>
#include <comuni.h>
#include <doc.h>
#include <rdoc.h>
#include <causali.h>
#include <mov.h>
#include <rmov.h>
#include <rmoviva.h>

#include "..\cg\cglib01.h"
#include "..\cg\cg2101.h"
#include "..\ve\velib.h"


///////////////////////////////////////////////////////////
// TCLienti_textset
///////////////////////////////////////////////////////////

class TClienti_recset : public TAS400_recordset
{
	TAssoc_array _index;

protected:
  void add_field(const char* name = "Filler", char tipo = 'a', int len = 0, int from = -1, 
								 const char* def = NULL);

public:
  TClienti_recset(const char * query);
};

void TClienti_recset::add_field(const char* name, char tipo, int len, int from, 
								 const char* def)
{
	const bool required = false;
  const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
  const int pos = from - 1;
  if (def && *def)
  {
    CHECKS(def == NULL || (int)strlen(def) <= len, "Invalid default value ", def);
    TVariant var(def); var.convert_to(t);
    create_field(name, pos, len, t, required, var);
  }
  else
    create_field(name, pos, len, t, required);
}


TClienti_recset::TClienti_recset(const char * query)
             : TAS400_recordset(TString("AS400(3002)\n") << query)
{
  const char a = 'a';
  const char n = 'n';
  const bool o = true;
  const bool f = false;
  
	add_field("FLD001",	n,	4,	1); 	// 	codice azienda
	add_field("FLD002",	a,	2,	5); 	// 	filiale
	add_field("FLD003",	a,	1,	7); 	// 	stato record se A annullata
	add_field(CLI_TIPOPERS,	n,	1,	8); 	// 	società = 2 persona fisica = 1
	add_field(CLI_RAGSOC,	a,	45,	9); 	// 	Ragione sociale
	add_field(CLI_INDCF,	a,	30,	54); 	// 	indirizzo
	add_field(CLI_COMCF,	a,	25,	84); 	// 	Comune di residenza
	add_field("FLD008",	a,	2,	109); // 	Provincia di residenza
	add_field(CLI_CAPCF,	a,	5,	121); // 	C.a.p.
	add_field(CLI_COFI,	a,	16,	126); // 	Codice fiscale o partita I.v.a
	add_field(CLI_PAIV,	a,	11,	142); // 	Partita I.v.a.
	add_field("FLD012",	a,	30,	153); // 	Indirizzo domicilio fiscale
	add_field("FLD013",	a,	25,	183); // 	Comune domicilio fiscale
	add_field("FLD014",	a,	2,	208); // 	Provincia domicilio fiscale
	add_field("FLD015",	a,	5,	220); // 	C.a.p. domicilio fiscale
	add_field("FLD016",	a,	1,	241); // 	Sesso
	add_field("FLD017",	a,	4,	242); //	anno di nascita 	o costituzione
	add_field("FLD018",	a,	2,	246); //	mese di nascita 	o costituzione
	add_field("FLD019",	a,	2,	248); //	giorno di nascita 	o costituzione
	add_field("FLD020",	a,	25,	250); //	comune di nascita 	o costituzione
	add_field("FLD021",	a,	2,	275); //	provincia di nascita 	o costituzione
	add_field("FLD022",	a,	20,	277); // 	Cognome ditta individuale
	add_field("FLD023",	a,	15,	297); // 	Nome ditta individuale
	add_field("FLD024",	a,	30,	312); // 	Indirizzo domicilio fiscale
	add_field("FLD025",	a,	23,	342); // 	Comune domicilio fiscale
	add_field("FLD026",	a,	5,	375); // 	C.a.p. domicilio fiscale
	add_field("FLD027",	a,	30,	394); // 	Indirizzo sede legale
	add_field("FLD028",	a,	25,	424); // 	comune sede legale
	add_field("FLD029",	a,	2,	449); // 	provincia sede legale
	add_field("FLD030",	a,	5,	461); // 	c..a.p. sede legale
	add_field(CLI_PTEL,	a,	4,	466); // 	prefisso telefonico sede legale
	add_field(CLI_TEL,	a,	10,	470); // 	numero telefonico sede legale
	add_field("FLD033",	a,	2,	480); // 	provincia costituzione
	add_field("FLD034",	n,	1,	494); //	Domicilio fiscale diverso da legale se c'è 1 è diverso 0 è uguale}
	add_field("FILLER",	n,	2501,	495); 
	add_field(CLI_CODCF,	n,	5,	2996); // 	codice cliente
}

///////////////////////////////////////////////////////////
// TMov_textset
///////////////////////////////////////////////////////////

class TMov_recset : public TAS400_recordset
{
	TAssoc_array _index;

protected:
  void add_field(const char* name = "Filler", char tipo = 'a', int len = 0, int from = -1, 
								 const char* def = NULL);

public:
  TMov_recset(const char * query);
};

void TMov_recset::add_field(const char* name, char tipo, int len, int from, 
								 const char* def)
{
	const bool required = false;
  const TFieldtypes t = tipo == 'n' ? _longzerofld : _alfafld;
  const int pos = from - 1;
  if (def && *def)
  {
    CHECKS(def == NULL || (int)strlen(def) <= len, "Invalid default value ", def);
    TVariant var(def); var.convert_to(t);
    create_field(name, pos, len, t, required, var);
  }
  else
    create_field(name, pos, len, t, required);
}


TMov_recset::TMov_recset(const char * query)
             : TAS400_recordset(TString("AS400(285)\n") << query)
{
  const char a = 'a';
  const char n = 'n';
  const bool o = true;
  const bool f = false;

	add_field(MOV_NUMDOC, a, 5, 1);	//	NUMERO DOCUMENTO,
	add_field(MOV_CODCAUS, a, 2, 6);	//	CAUSALE FATTURA
	add_field("ANNOD", n, 4, 8);	//	ANNO DATA DOCUMENTO
	add_field("MESED", n, 2, 12);	//	MEDE DATA DOCUMENTO	
	add_field("GIORNOD", n, 2, 14);	//	GIORNO DATA DOCUMENTO
	add_field(MOV_CODCF, n,	4, 16);	//	CODICE CLIENTE								??????
	add_field("Filler", n, 20,	2);	//	CODICE FILIALE
	add_field("IMPONIBILE1", n,	15, 22);	//	PRIMO IMPONIBILE IVA
	add_field("IMPONIBILE2", n,	15, 37);	//	SECONDO IMPONIBILE IVA
	add_field("IMPONIBILE3", n,	15, 52);	//	TERZO IMPONIBILE IVA	
	add_field("IMPONIBILE4", n,	15, 67);	//	QUARTO IMPONIBILE IVA
	add_field("CODIVA1", n,	2, 82);	//	PRIMA ALIQUOTA IVA
	add_field("CODIVA2", n,	2, 84);	//	SECCONDA ALIQUOTA IVA,
	add_field("CODIVA3", n,	2, 86);	//	TERZA ALIQUOTA IVA
	add_field("CODIVA4", n,	3, 88);	//	QUARTA ALIQUOTA IVA
	add_field("IMPOSTA1", n,	15, 90);	//	IVA SU PRIMO IMPONIBILE
	add_field("IMPOSTA2", n, 15, 105);	//	IVA SU SECONDO IMPONIBILE
	add_field("IMPOSTA3", n, 15, 120);	//	IVA SU TERZO IMPONIBILE
	add_field("IMPOSTA4", n, 15, 135);	//	IVA SU QUARTO IMPONIBILE
	add_field("FLD019", n, 15, 150);	//	TOTALE SPESE
	add_field("FLD020", n, 15, 165);	//	TOTALE COMPETENZE				????? i conti ?
	add_field("FLD021", n, 15, 180);	//	TOTALE ANTICIPO
	add_field(MOV_RITFIS, n, 15, 195);	//	TOTALE RITENUTA ACCONTO		
	add_field("IMPOSTA", n, 15, 210);	//	TOTALE IVA
	add_field(MOV_TOTDOC, n, 15, 225);	//	TOTALE FATTURA	
	add_field("MESEC", n, 2, 240);	//	MESE DI COMPETENZA		
	add_field("ANNOC", n, 4, 242);	//	ANNO DI COMPETENZA		
	add_field("FLSEZ", a, 1, 246);	//	DARE / AVERE = D o A	
	add_field("FLD028", a, 1, 247);	//	RISERVATO FLAG PAGAMENTO		???
	add_field("FLD029", a, 1, 248);	//	RISERVATO,		
	add_field("FLD030", a, 1, 249);	//	RISERVATO TIPO FATTURAZIONE,	???
	add_field(MOV_CODPAG, a, 3, 250);	//	CODICE PAGAMENTO
	add_field("FLD032", n, 15, 252);	//	CDA 2% PER AVVOCATI					???
	add_field("FLD033", a, 1, 267);	//	SOGGETTO RITENUTA							???
	add_field("FLD034", a, 1, 268);	//	MODALITA' PAGAMENTO
	add_field("FLD035", a, 1, 269);	//	PASSATO A COMPENSI A TERZI		???
	add_field("FLD036", a, 7, 270);	//	RISERVATO
	add_field("FLD037", n, 5, 277);	//	CODICE AZIENDA CONTABILITA'
	add_field("FLD038", a, 1);	//	DELEGA												???
	add_field("STATO", a, 1, 283);	//	STATO MOVIMENTO								??? 
}

// TAutomask

class TPaghe2mov_mask : public TAutomask
{
  void serialize(bool bSave);
protected:
  bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public:
  TPaghe2mov_mask();
  virtual ~TPaghe2mov_mask();
};

TPaghe2mov_mask::TPaghe2mov_mask() : TAutomask("pg0001600a")
{
  serialize(false);
}

TPaghe2mov_mask::~TPaghe2mov_mask()
{
  serialize(true);
}
  
bool TPaghe2mov_mask::on_field_event(TOperable_field& f, TField_event e, long jolly)
{ 
  return TRUE;
}

void TPaghe2mov_mask::serialize(bool bSave)
{
  const char* defpar = "MAIN";
  TConfig ini("pg0001conf.ini", defpar);
  for (int i = fields()-1; i >= 0; i--)
  {
    TMask_field& f = fld(i);
    const TFieldref* fr = f.field();
    if (fr != NULL)
    {
      if (bSave)
        fr->write(ini, defpar, f.get());
      else
        f.set(fr->read(ini, defpar));
    }
  }
}

HIDDEN bool browse_file_handler(TMask_field& f, KEY k)
{
  if (k == K_F9)
  {  
    FILE_SPEC fs; memset(&fs, 0, sizeof(FILE_SPEC));
    strcpy(fs.type, "");
    strcpy(fs.name, f.get());
    xvt_fsys_get_default_dir(&fs.dir);
    xvt_fsys_save_dir();
    if (xvt_dm_post_file_open(&fs, TR("Selezione file")) == FL_OK)
    {       
      TFilename n;
      xvt_fsys_convert_dir_to_str(&fs.dir, n.get_buffer(n.size()), n.size());
      n.add(fs.name);
      f.set(n);
    }
    xvt_fsys_restore_dir();
    f.set_focus();
  }
  
  return TRUE;
}

///////////////////////////////////////////////////////////
// TPaghe2mov application
///////////////////////////////////////////////////////////

class TPaghe2mov : public TSkeleton_application
{
	TPaghe2mov_mask*	_m;
  TLog_report*			_log;

protected:
  virtual const char * extra_modules() const {return "ba";}

public:           
	virtual bool create();
  virtual bool destroy();
  virtual void main_loop();
	void load_cli();
	void load_mov();
  TPaghe2mov() {}
};

TPaghe2mov& app() { return (TPaghe2mov&) main_app(); }

                                
bool TPaghe2mov::create()
{
  _m = new TPaghe2mov_mask();
	_m->set_handler(F_INPATH, browse_file_handler);
	return TSkeleton_application::create ();
}

bool TPaghe2mov::destroy()
{
	delete _m;
  return TApplication::destroy();
}



void TPaghe2mov::load_cli()
{
	TString query("SELECT * FROM ");
	TFilename name = _m->get(F_INPATH);
	const bool aggcli = _m->get_bool(F_AGGCLI);
	
	name.add("utenti.txt");
	if (name.exist())
	{
		TLocalisamfile clifo(LF_CLIFO);
		TLocalisamfile cfven(LF_CFVEN);

		query << name;
	
		TClienti_recset clienti(query);
    TProgind pi(clienti.items(), TR("Scansione clienti"), true, true);

    for (bool ok = clienti.move_first(); ok; ok = clienti.move_next())
    {
      if (!pi.addstatus(1))
        break;
	
			clifo.zero();
			clifo.put(CLI_TIPOCF, "C");

			TString cf(clienti.get(CLI_COFI).as_string());
			TString paiv(clienti.get(CLI_PAIV).as_string());

			cf.trim();
			paiv.trim();

			if (clienti.get("FLD003").as_string() != "A")
			{
				long codcf = clienti.get(CLI_CODCF).as_int();

				clifo.zero();
				clifo.put(CLI_TIPOCF, "C");
				clifo.put(CLI_CODCF, codcf);

				const bool found = clifo.read(_isequal) == NOERR;

				if (!found)
				{
					clifo.zero();
					clifo.put(CLI_TIPOCF, "C");
					clifo.put(CLI_CODCF, codcf);
					cfven.zero();
					cfven.put(CFV_TIPOCF, "C");
					cfven.put(CFV_CODCF, codcf);
					cfven.write();
				}
				else
					if (!aggcli)
						continue;

				clifo.put(CLI_TIPOPERS, clienti.get(CLI_TIPOPERS).as_string());
				clifo.put(CLI_RAGSOC, clienti.get(CLI_RAGSOC).as_string());
				clifo.put(CLI_INDCF, clienti.get(CLI_INDCF).as_string());
				clifo.put(CLI_CAPCF, clienti.get(CLI_CAPCF).as_string());
				
				const TString8 cap(clienti.get(CLI_CAPCF).as_string());
				TString80 comune(clienti.get(CLI_COMCF).as_string());

				comune.trim();

				const TString& codcom = cap2comune(cap, comune);

				clifo.put(CLI_COMCF, cap);
				if (codcom.full())
					comune.cut(0);
				clifo.put(CLI_LOCCF, comune);
				clifo.put(CLI_COMCF, codcom);
				clifo.put(CLI_COFI, cf);
				clifo.put(CLI_PAIV, paiv);
				if (found)
				{
					const int err = clifo.rewrite();
					TString msg("Aggiornamento cliente ");

					msg << clifo.get(CLI_CODCF) << " - " << clienti.get(CLI_RAGSOC).as_string();
					if (err == NOERR)
						_log->log(0, msg);
					else
					{
						msg << " - errore n. " << err;
						_log->log(2, msg);
					}
				}
				else
				{
					const int err = clifo.write();
					TString msg("Inserimento cliente ");

					msg << clifo.get(CLI_CODCF) << " - " << clienti.get(CLI_RAGSOC).as_string();
					if (err == NOERR)
						_log->log(0, msg);
					else
					{
						msg << " - errore n. " << err;
						_log->log(2, msg);
					}
				}
			}
    }
  }                 
}

void TPaghe2mov::load_mov()
{
	TString query("SELECT * FROM ");
	TFilename name = _m->get(F_INPATH);
	
	name.add("arfat.txt");
	if (name.exist())
	{
		TLocalisamfile movf(LF_MOV);

		query << name;
	
		TMov_recset movim(query);
    TProgind pi(movim.items(), TR("Scansione movimenti"), true, true);
		const TDate datareg(_m->get_date(F_DATAREG));
		const TDate from(_m->get_date(F_DATAFROM));
		const TDate to(_m->get_date(F_DATATO));
		long numreg = 0L;
		TEsercizi_contabili esc;
		const int annoes = esc.date2esc(datareg);
		TLocalisamfile movimenti(LF_MOV);

		if (movimenti.last() == NOERR)
			numreg = movimenti.get_long(MOV_NUMREG);
    for (bool ok = movim.move_first(); ok; ok = movim.move_next())
    {
      if (!pi.addstatus(1))
        break;

			const TDate datadoc(movim.get("GIORNOD").as_int(),
													movim.get("MESED").as_int(),
													movim.get("ANNOD").as_int());

			if (from.ok() && datadoc < from)
				continue;
			if (to.ok() && datadoc > to)
				continue;

			TMovimentoPN mov;
	
			int cg_rows = 0;

			TString8 codcaus(movim.get(MOV_CODCAUS).as_string());

			codcaus.insert("0");

			const TRectype & rec = cache().get(LF_CAUSALI, codcaus);

			if (rec.empty())
			{
				TString msg("Causale ");

				msg << movim.get(MOV_CODCAUS).as_string() << " assente";
				_log->log(2, msg);
				continue;
			}

			const TCausale caus(codcaus, datareg.year());
			const TString8 codreg = rec.get(CAU_REG);
			TRegistro & reg = caus.reg();

			mov.lfile().put(MOV_NUMREG, ++numreg);
			mov.lfile().put(MOV_ANNOES, annoes);
			mov.lfile().put(MOV_DATAREG, datareg);
			mov.lfile().put(MOV_ANNOIVA, datareg.year());
			mov.lfile().put(MOV_TIPO, "C");
			mov.lfile().put(MOV_CODCF, movim.get(MOV_CODCF).as_int());

			mov.lfile().put(MOV_DATADOC, datadoc);
			const TString16 numdoc = movim.get(MOV_NUMDOC).as_string();
			mov.lfile().put(MOV_NUMDOC, numdoc);
			mov.lfile().put(MOV_TIPODOC, caus.tipo_doc());
			const real totdoc = movim.get(MOV_TOTDOC).as_real();
			TRectype & rowtot = mov.cg(cg_rows++);
			
			mov.lfile().put(MOV_TOTDOC, totdoc);
			rowtot.put(RMV_SEZIONE, caus.sezione(1));
			TBill c;
			caus.bill(1, c);
			rowtot.put(RMV_GRUPPO, c.gruppo());
			rowtot.put(RMV_CONTO, c.conto());
			rowtot.put(RMV_SOTTOCONTO, movim.get(MOV_CODCF).as_int());
			rowtot.put(RMV_IMPORTO, totdoc);
			rowtot.put(RMV_ROWTYPE, "T");
			
			TRectype & rowric = mov.cg(cg_rows++);
			
			rowric.put(RMV_SEZIONE, caus.sezione(2));
			TBill r;
			caus.bill(2, r);
			rowric.put(RMV_GRUPPO, r.gruppo());
			rowric.put(RMV_CONTO, r.conto());
			rowric.put(RMV_SOTTOCONTO, r.sottoconto());
			rowric.put(RMV_ROWTYPE, "I");

			const real ritfis = movim.get(MOV_RITFIS).as_real();
			
			if (ritfis != ZERO)
			{
				TBill c;
				TRectype & row = mov.cg(cg_rows++);
			
				mov.lfile().put(MOV_RITFIS,	ritfis);
				row.put(RMV_SEZIONE, caus.sezione(7));
				caus.bill(7, c);
				row.put(RMV_GRUPPO, c.gruppo());
				row.put(RMV_CONTO, c.conto());
				row.put(RMV_SOTTOCONTO, c.sottoconto());
				row.put(RMV_IMPORTO, ritfis);
				row.put(RMV_ROWTYPE, "F");
			}

			const real imposta = movim.get("IMPOSTA").as_real();

			if (imposta != ZERO)
			{
				TBill c;
				TRectype & row = mov.cg(cg_rows++);
			
				row.put(RMV_SEZIONE, caus.sezione(3));
				caus.bill(3, c);
				row.put(RMV_GRUPPO, c.gruppo());
				row.put(RMV_CONTO, c.conto());
				row.put(RMV_SOTTOCONTO, c.sottoconto());
				row.put(RMV_IMPORTO, imposta);
				row.put(RMV_ROWTYPE, "D");
			}
			mov.lfile().put(MOV_CODCAUS, codcaus);
			
			TString descr("Fattura n.ro ");

			descr << numdoc << " del " << datadoc;
			mov.lfile().put(MOV_DESCR, descr);
			mov.lfile().put(MOV_REG, codreg);
			int protiva = reg.protocol() + 1;
			mov.lfile().put(MOV_PROTIVA, protiva);
			
			TString8 codpag(movim.get(MOV_CODPAG).as_string());

			if (codpag == "000")
				codpag.cut(0);
			mov.lfile().put(MOV_CODPAG, codpag);

			const int annoc = movim.get("ANNOC").as_int();
			const int mesec = movim.get("MESEC").as_int();

			if (annoc != 0 && (annoc != datareg.year() || mesec != datareg.month()))
				mov.lfile().put(MOV_DATACOMP, TDate(1, mesec, annoc));
			else
				mov.lfile().put(MOV_DATACOMP, datareg);

			real totric;
			for (int i= 1; i <= 4 ; i++)
			{
				TString16 fname("IMPONIBILE");
				
				fname << i;

				const real imp = movim.get(fname).as_real();
				if (imp != ZERO)
				{
					TRectype & iva = mov.iva(i - 1);
					bool swap = caus.sezione(2) == 'D';
					
					totric += imp;
					iva.put(RMI_IMPONIBILE, imp);
					fname = "CODIVA";
					fname << i;
					iva.put(RMI_CODIVA, movim.get(fname).as_string());
					fname = "IMPOSTA";
					fname << i;

					const real imposta = movim.get(fname).as_real();
					
					iva.put(RMI_IMPOSTA, imposta);
					iva.put(RMI_GRUPPO, r.gruppo());
					iva.put(RMI_CONTO, r.conto());
					iva.put(RMI_SOTTOCONTO, r.sottoconto());
					iva.put(RMI_RIGAIMP, 2);
					if (imposta != ZERO)
						iva.put(RMI_RIGAIVA, 3);
				}
			}
			rowric.put(RMV_IMPORTO, totric);
			mov.adjust_rowtypes();

			const int err = mov.write();
			TString msg("Movimento n.ro ");

			msg << numreg;
			if (err == NOERR)
			{
				reg.update(protiva, datareg);
				_log->log(0, msg);
			}
			else
			{
				msg << " - errore n. " << err;
				_log->log(2, msg);
			}
		}
  }                 
}

void TPaghe2mov::main_loop()
{
	// eliminazione files delle elaborazioni precedenti
  TString_array transactions;
	TFilename pgfiles; pgfiles.tempdir();
	pgfiles.add("conde*.ini");
  list_files(pgfiles, transactions);
  FOR_EACH_ARRAY_ROW(transactions, row, name)
    remove_file(*name);
	// main
  while (_m->run() == K_ENTER)
  {
    const char* const title = TR("Importazione clienti");

    _log = new TLog_report(title);
		load_cli();
		load_mov();
    TReport_book book;
    book.add(*_log);
    book.preview();
  }
}


int pg0001600(int argc, char* argv[])
{
  TPaghe2mov app;
  app.run(argc, argv, TR("Ricezione clienti e fatture da paghe"));
  return TRUE;
}