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 "..\cg\cglib01.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(2138)\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("FLD006",	a,	30,	54); 	// 	indirizzo
	add_field("FLD007",	a,	25,	84); 	// 	Comune di residenza
	add_field("FLD008",	a,	2,	109); // 	Provincia di residenza
	add_field("FLD009",	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(CLI_INDCF,	a,	30,	394); // 	Indirizzo sede legale
	add_field(CLI_COMCF,	a,	25,	424); // 	comune sede legale
	add_field("FLD029",	a,	2,	449); // 	provincia sede legale
	add_field(CLI_CAPCF,	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,	1642,	495); //	Domicilio fiscale diverso da legale se c'è 1 è diverso 0 è uguale}
}

// 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();
  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")
			{
				bool found = false;

				if (cf.full())
				{
					clifo.setkey(4);
					clifo.put(CLI_COFI, cf);
					found = clifo.read(_isequal) == NOERR;
				}
				if (!found && paiv.full())
				{
					clifo.setkey(5);
					clifo.put(CLI_PAIV, paiv);
					found = clifo.read(_isequal) == NOERR;
				}
				clifo.setkey(1);
				if (!found)
				{
					long codcf = 1L;
  
					clifo.zero();
					clifo.put(CLI_TIPOCF, "F");
					if (clifo.read(_isgteq) == NOERR)
						clifo.prev() ;
					if (clifo.get(CLI_TIPOCF) == "C")
						codcf += clifo.get_long(CLI_CODCF);
					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.rewrite();
				}
				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::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
  if (_m->run() == K_ENTER)
  {
    const char* const title = TR("Importazione clienti");

    _log = new TLog_report(title);
		load_cli();
    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;
}