campo-sirio/ps/pn0001100.cpp

#include "pn0001.h"
#include "pn0001100.h"
#include <automask.h>
#include <progind.h>
#include <reprint.h>
#include <tabutil.h>

#include "../mg/anamag.h"
#include "../mg/mag.h"
#include "../mg/codcorr.h"
#include "../mg/umart.h"
#include "../ve/condv.h"
#include "../ve/rcondv.h"
#include <clifo.h>
#include <cfven.h>

#include <applicat.h>
#include <recarray.h>
#include <relation.h>
#include <reputils.h>
#include <textset.h>

#include "../cg/cglib01.h"


///////////////////////////////////////////////////////////
// TDettaglio_mask
///////////////////////////////////////////////////////////

class TDettaglio_mask : public TAutomask
{

private:
  void serialize(bool bSave);

protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

public:
  TDettaglio_mask();
  ~TDettaglio_mask();
};

bool TDettaglio_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  bool ok = true;
  switch (o.dlg())
  {
  case F_PATH:
    break;
  default:
    break;
  }
  return ok;
}

void TDettaglio_mask::serialize(bool bSave)
{
  const char* defpar = "tc";
  TConfig ini(CONFIG_DITTA, 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));
    }
  }
}

TDettaglio_mask::TDettaglio_mask() 
         : TAutomask("pn0001100")
{
  serialize(false);
}

TDettaglio_mask::~TDettaglio_mask()
{
  serialize(true);
}

///////////////////////////////////////////////////////////
// TDettaglio_receiver
///////////////////////////////////////////////////////////
class TDettaglio_receiver : public TSkeleton_application
{
	int _len;
	
protected:
	void load_clifo(const TDettaglio_mask & m);
	void load_classi(const TDettaglio_mask & m);
	void load_marche(const TDettaglio_mask & m);
	void load_articoli(const TDettaglio_mask & m);
	void load_barcode(const TDettaglio_mask & m);
	void load_listino(const TDettaglio_mask & m);
	void load_giacenze(const TDettaglio_mask & m);
	void load_costi(const TDettaglio_mask & m);
	void add_to_tab(const TString & codtab, const TString & cod, const char * desc = "");
	const TString & build_codart(const TString & gruppo, const long codice);
	virtual const char * extra_modules() const {return "vd";}

public:
	virtual bool create();
  virtual void main_loop();
	virtual bool destroy();
  TDettaglio_receiver() : _len(5) {}
};

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

///////////////////////////////////////////////////////////
// TClifo_textset
///////////////////////////////////////////////////////////

class TClifo_textset : public TAS400_recordset
{

protected:

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

public:
  TClifo_textset(const char* query = "");
};

void TClifo_textset::add_field(const char* name, int len, 
														char tipo, int from, const char* def)
{
	const bool required = false;
  TString80 fname(name);

  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(fname, pos, len, t, required, var);
  }
  else
    create_field(fname, pos, len, t, required);
}

TClifo_textset::TClifo_textset(const char* query)
             :  TAS400_recordset(TString("AS400(1947,0,0)\n") << query)
{
  const char an = 'a';
  const char n = 'n';

	add_field("VALICF", 1, an, 1);		//	MFANCF00
	add_field("ATIPCF", 1, an, 2);
	add_field("ACODCF", 22, an, 3);
	add_field("AFIGIU", 1, an, 25);
	add_field("ARAGSO", 40, an, 26);
	add_field("AINDIR", 40, an, 66);
	add_field("ALOCAL", 30, an, 106);
	add_field("ACAP", 5, an, 136);
	add_field("APROVI", 2, an, 141);
	add_field("ANAZIO", 3, an, 143);
	add_field("APOSCN", 6, an, 146);
	add_field("APECOT", 30, an, 152);
	add_field("ACOSPE", 22, an, 182);
	add_field("APARIV", 11, an, 204);
	add_field("ACODFI", 16, an, 215);
	add_field("ANUTE1", 20, an, 231);
	add_field("ANUTE2", 20, an, 251);
	add_field("ANUFAX", 20, an, 271);
	add_field("ACOPAG", 2, an, 291);
	add_field("ACOIVA", 6, an, 293);
	add_field("ACOABI", 22, an, 299);
	add_field("ACOCAB", 22, an, 321);
	add_field("ACODCC", 15, an, 343);
	add_field("ACOPOR", 2, an, 358);
	add_field("ACOSTA", 4, an, 360);
	add_field("ACOST2", 4, an, 364);
	add_field("ACOST3", 4, an, 368);
	add_field("ACOTRA", 3, an, 372);
	add_field("ACOZON", 4, an, 375);
	add_field("ACOITI", 6, an, 379);
	add_field("ACOVAL", 3, an, 385);
	add_field("ATIFAT", 2, an, 388);
	add_field("FIDO", 22, an, 390);
	add_field("ASCOT1", 22, an, 412);
	add_field("ASCOT2", 22, an, 434);
	add_field("ASCOD1", 22, an, 456);
	add_field("ASCOD2", 22, an, 478);
	add_field("ASCOD3", 22, an, 500);
	add_field("ASCOD4", 22, an, 522);
	add_field("ACOAGE", 6, an, 544);
	add_field("ACOISP", 6, an, 550);
	add_field("ARITSC", 6, an, 556);
	add_field("APETRA", 22, an, 562);
	add_field("AAGEIV", 1, an, 584);
	add_field("ARAGBO", 2, an, 585);
	add_field("ACAINC", 1, an, 587);
	add_field("ACABOL", 1, an, 588);
	add_field("AAGPRA", 1, an, 589);
	add_field("ATRASF", 1, an, 590);
	add_field("ATRATE", 1, an, 591);
	add_field("ANOCPR", 1, an, 592);
	add_field("ASTSOL", 1, an, 593);
	add_field("ADATSO", 22, an, 594);
	add_field("ACOVET", 2, an, 616);
	add_field("ADIPRE", 1, an, 618);
	add_field("AGEPRE", 1, an, 619);
	add_field("AINSPE", 22, an, 620);
	add_field("AARBCO", 1, an, 642);
	add_field("AGRUCO", 6, an, 643);
	add_field("ACONTO", 6, an, 649);
	add_field("ASOTCO", 22, an, 655);
	add_field("AGRCON", 6, an, 677);
	add_field("ACOCON", 6, an, 683);
	add_field("AALLEG", 6, an, 689);
	add_field("ADAGI1", 6, an, 695);
	add_field("ADAME1", 6, an, 701);
	add_field("AALGI1", 6, an, 707);
	add_field("AALME1", 6, an, 713);
	add_field("ADAGI2", 6, an, 719);
	add_field("ADAME2", 6, an, 725);
	add_field("AALGI2", 6, an, 731);
	add_field("AALME2", 6, an, 737);
	add_field("ALISCF", 1, an, 743);
	add_field("AGIOCH", 9, an, 744);
	add_field("AORACO", 15, an, 753);
	add_field("ACALPR", 6, an, 768);
	add_field("APERPR", 22, an, 774);
	add_field("APROAR", 6, an, 796);
	add_field("ANULIN", 6, an, 802);
	add_field("ADALIN", 22, an, 808);
	add_field("ADAINL", 22, an, 830);
	add_field("ADAFIL", 22, an, 852);
	add_field("ATABLI", 6, an, 874);
	add_field("ALISIP", 6, an, 880);
	add_field("ALISIS", 6, an, 886);
	add_field("ACODCO", 5, an, 892);
	add_field("ALINGU", 1, an, 897);
	add_field("ACDTAR", 3, an, 898);
	add_field("AKMTRA", 6, an, 901);
	add_field("AMARCA", 6, an, 907);
	add_field("ACOCOM", 4, an, 913);
	add_field("AIMP01", 6, an, 917);
	add_field("AIMP02", 22, an, 923);
	add_field("AIMP03", 22, an, 945);
	add_field("ABLOFO", 1, an, 967);
	add_field("AFLA01", 1, an, 968);
	add_field("AFLA02", 1, an, 969);
	add_field("AFLA03", 1, an, 970);
	add_field("AFLA04", 1, an, 971);
	add_field("AFLA05", 1, an, 972);
	add_field("AFLA06", 1, an, 973);
	add_field("AFLA07", 1, an, 974);
	add_field("AFLA08", 1, an, 975);
	add_field("AFLA09", 1, an, 976);
	add_field("AFLA10", 1, an, 977);
	add_field("ACFTER", 10, an, 978);
	add_field("AUTECR", 2, an, 988);
	add_field("ADATCR", 22, an, 990);
	add_field("AUTEVA", 2, an, 1012);
	add_field("ADATVA", 22, an, 1014);
	add_field("ATAVET", 3, an, 1036);
	add_field("AORDEV", 1, an, 1039);
	add_field("ABLOOR", 1, an, 1040);
	add_field("AGESIN", 1, an, 1041);
	add_field("AORFAX", 1, an, 1042);;
	add_field("ACOREG", 6, an, 1043);
	add_field("ACOSP1", 2, an, 1049);
	add_field("ACOSP2", 2, an, 1051);
	add_field("ACOSP3", 2, an, 1053);
	add_field("FOTO1", 50, an, 1055);
	add_field("FOTO2", 50, an, 1105);
	add_field("WEB", 50, an, 1155);
	add_field("NOTE", 512, an, 1205);
	add_field("KEY_U", 10, an, 1717);
	add_field("APRBAN", 5, an, 1727);
	add_field("ASTEUR", 1, an, 1732);
	add_field("AGERGO", 1, an, 1733);
	add_field("ARITME", 22, an, 1734);
	add_field("ASPIN1", 22, an, 1756);
	add_field("ASPIN2", 22, an, 1778);
	add_field("ASPIN3", 22, an, 1800);
	add_field("ASPIN4", 22, an, 1822);
	add_field("ASPIN5", 22, an, 1844);
	add_field("AINDIR2", 40, an, 1866);
	add_field("AINDIR3", 40, an, 1906);

}

///////////////////////////////////////////////////////////
// TAnamag_textset
///////////////////////////////////////////////////////////

class TAnamag_textset : public TAS400_recordset
{

protected:

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

public:
  TAnamag_textset(const char* query = "");
};

void TAnamag_textset::add_field(const char* name, int len, 
														char tipo, int from, const char* def)
{
	const bool required = false;
  TString80 fname(name);

  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(fname, pos, len, t, required, var);
  }
  else
    create_field(fname, pos, len, t, required);
}

TAnamag_textset::TAnamag_textset(const char* query)
              :  TAS400_recordset(TString("AS400(2550,0,0)\n") << query)
{
  const char an = 'a';
  const char n = 'n';

	add_field("AVALAN", 1, an, 1);		//    MFARTI00
	add_field("AGRUPP", 2, an, 2);
	add_field("ACODAR", 22, an, 4);
	add_field("ADESAR", 40, an, 26);
	add_field("AUNMVE", 2, an, 66);
	add_field("AUNMAC", 2, an, 68);
	add_field("ACOEFF", 22, an, 70);
	add_field("ACODIV", 6, an, 92);
	add_field("AIVAAG", 6, an, 98);
	add_field("ACLASS", 2, an, 104);
	add_field("ACATEG", 2, an, 106);
	add_field("ALINEA", 4, an, 108);
	add_field("ALINAQ", 4, an, 112);
	add_field("ACOMAR", 6, an, 116);
	add_field("ADTVAL", 22, an, 122);
	add_field("ACONFE", 22, an, 144);
	add_field("AQTAIM", 22, an, 166);
	add_field("APESOA", 22, an, 188);
	add_field("APESOC", 22, an, 210);
	add_field("APESOI", 22, an, 232);
	add_field("AVOLUA", 22, an, 254);
	add_field("AVOLUC", 22, an, 276);
	add_field("AVOLUI", 22, an, 298);
	add_field("ACAMPR", 8, an, 320);
	add_field("AFASCO", 2, an, 328);
	add_field("AASPES", 2, an, 330);
	add_field("ACOMPO", 2, an, 332);
	add_field("ACODST", 4, an, 334);
	add_field("ACODSG", 4, an, 338);
	add_field("AGRURA", 2, an, 342);
	add_field("ACODRA", 22, an, 344);
	add_field("APROV1", 22, an, 366);
	add_field("APROV2", 22, an, 388);
	add_field("APROV3", 22, an, 410);
	add_field("APROV4", 22, an, 432);
	add_field("APROV5", 22, an, 454);
	add_field("ATRASR", 1, an, 476);
	add_field("ATRTER", 1, an, 477);
	add_field("ANOLIS", 1, an, 478);
	add_field("ARIDES", 1, an, 479);
	add_field("ATAGCO", 4, an, 480);
	add_field("APOSCU", 1, an, 484);
	add_field("ATIPRO", 1, an, 485);
	add_field("ACDCAL", 1, an, 486);
	add_field("AGESCO", 8, an, 487);
	add_field("ACDREP", 3, an, 495);
	add_field("ACDNOM", 12, an, 498);
	add_field("AUNMAL", 2, an, 510);
	add_field("ACOEFA", 22, an, 512);
	add_field("ANOINV", 1, an, 534);
	add_field("AGEMAT", 1, an, 535);
	add_field("AGEVUO", 1, an, 536);
	add_field("AGECOL", 1, an, 537);
	add_field("AGELOT", 1, an, 538);
	add_field("AFLG01", 1, an, 539);
	add_field("AFLG02", 1, an, 540);
	add_field("AFLG03", 1, an, 541);
	add_field("AFLG04", 1, an, 542);
	add_field("AFLG05", 1, an, 543);
	add_field("AFLG06", 1, an, 544);
	add_field("AFLG07", 1, an, 545);
	add_field("AFLG08", 1, an, 546);
	add_field("AFLG09", 1, an, 547);
	add_field("AFLG10", 1, an, 548);
	add_field("ALISGR", 3, an, 549);
	add_field("ALISSQ", 22, an, 552);
	add_field("AIDTER", 10, an, 574);
	add_field("ARUTCR", 2, an, 584);
	add_field("ARDTCR", 19, an, 586);
	add_field("ARUTVA", 2, an, 605);
	add_field("ARDTVA", 19, an, 607);
	add_field("FOTO", 250, an, 626);
	add_field("KEY_U", 10, an, 876);
	add_field("INVMAG", 8, an, 886);
	add_field("ADTSOS", 19, an, 894);
	add_field("AFLSOS", 1, an, 913);
	add_field("AGEMIS", 1, an, 914);
	add_field("AMISMM", 6, an, 915);
	add_field("AMISMF", 22, an, 921);
	add_field("AECOM1", 5, an, 943);
	add_field("AECOM2", 5, an, 948);
	add_field("AECOM3", 5, an, 953);
	add_field("AECOM4", 5, an, 958);
	add_field("ATRACA", 1, an, 963);
	add_field("ATRACA1", 1, an, 964);
	add_field("AFLG11", 1, an, 965);
	add_field("AFLG12", 1, an, 966);
	add_field("AFLG13", 1, an, 967);
	add_field("AFLG14", 1, an, 968);
	add_field("AFLG15", 1, an, 969);
	add_field("AFLG16", 1, an, 970);
	add_field("AFLG17", 1, an, 971);
	add_field("AFLG18", 1, an, 972);
	add_field("AFLG19", 1, an, 973);
	add_field("AFLG20", 1, an, 974);
	add_field("AANNOP", 6, an, 975);
	add_field("ANUMPA", 6, an, 981);
	add_field("ADESAR2", 40, an, 987);
	add_field("FOTO2", 250, an, 1027);
	add_field("FOTO3", 250, an, 1277);
	add_field("FOTO4", 250, an, 1527);
	add_field("FOTO5", 250, an, 1777);
	add_field("FOTO6", 250, an, 2027);
	add_field("FOTO7", 250, an, 2277);
	add_field("ACODOFF", 22, an, 2527);
}

///////////////////////////////////////////////////////////
// TBarcoode_textset
///////////////////////////////////////////////////////////

class TBarcode_textset : public TAS400_recordset
{

protected:

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

public:
  TBarcode_textset(const char* query = "");
};

void TBarcode_textset::add_field(const char* name, int len, 
														char tipo, int from, const char* def)
{
	const bool required = false;
  TString80 fname(name);

  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(fname, pos, len, t, required, var);
  }
  else
    create_field(fname, pos, len, t, required);
}

TBarcode_textset::TBarcode_textset(const char* query)
                : TAS400_recordset(TString("AS400(320,0,0)\n") << query)
{
  const char an = 'a';
  const char n = 'n';

	add_field("BVALAR", 1, an, 1);		//  MFARB00
	add_field("BGRUPP", 2, an, 2);
	add_field("BCODAR", 22, an, 4);
	add_field("BTIPRE", 1, an, 26);
	add_field("BBARCO", 20, an, 27);
	add_field("BTIPCF", 1, an, 47);
	add_field("BCODCL", 22, an, 48);
	add_field("BCOPRI", 1, an, 70);
	add_field("BQTAMO", 22, an, 71);
	add_field("BCONFE", 22, an, 93);
	add_field("BQTAIM", 22, an, 115);
	add_field("BNOT40", 40, an, 137);
	add_field("BBLORI", 1, an, 177);
	add_field("BRIFRI", 6, an, 178);
	add_field("BRIFCO", 6, an, 184);
	add_field("BLISTI", 22, an, 190);
	add_field("BTIPMA", 1, an, 212);
	add_field("BPERMA", 22, an, 213);
	add_field("KEY_U", 40, an, 235);
	add_field("KEYB", 40, an, 275);
	add_field("BPESO", 1, an, 315);
	add_field("BCODBIL", 3, an, 316);
}

///////////////////////////////////////////////////////////
// TListino_textset
///////////////////////////////////////////////////////////

class TListino_textset : public TAS400_recordset
{

protected:

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

public:
  TListino_textset(const char* query = "");
};

void TListino_textset::add_field(const char* name, int len, 
														char tipo, int from, const char* def)
{
	const bool required = false;
  TString80 fname(name);

  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(fname, pos, len, t, required, var);
  }
  else
    create_field(fname, pos, len, t, required);
}

TListino_textset::TListino_textset(const char* query)
                : TAS400_recordset(TString("AS400(626,0,0)\n") << query)
{
  const char an = 'a';
  const char n = 'n';

	add_field("LVALAR", 1, an, 1);	//	MFARLI00
	add_field("LGRUPP", 2, an, 2);
	add_field("LCODAR", 22, an, 4);
	add_field("LCODLI", 6, an, 26);
	add_field("LTIPCF", 1, an, 32);
	add_field("LCFTAB", 6, an, 33);
	add_field("LCOPRI", 1, an, 39);
	add_field("LDESAR", 40, an, 40);
	add_field("LLISTI", 22, an, 80);
	add_field("LCOSTO", 22, an, 102);
	add_field("LLIFVE", 22, an, 124);
	add_field("LDTSCA", 19, an, 146);
	add_field("LSCOD1", 22, an, 165);
	add_field("LSCOD2", 22, an, 187);
	add_field("LSCOD3", 22, an, 209);
	add_field("LSCOD4", 22, an, 231);
	add_field("LPROVV", 22, an, 253);
	add_field("LNOMOD", 1, an, 275);
	add_field("LNOSCO", 1, an, 276);
	add_field("LCOFAM", 5, an, 277);
	add_field("LGGAPR", 6, an, 282);
	add_field("LMAGFO", 22, an, 288);
	add_field("LNOTE", 20, an, 310);
	add_field("LRINOT", 1, an, 330);
	add_field("LLISTG", 22, an, 331);
	add_field("LCOSTG", 22, an, 353);
	add_field("LLIFVG", 22, an, 375);
	add_field("LSCO1G", 22, an, 397);
	add_field("LSCO2G", 22, an, 419);
	add_field("LSCO3G", 22, an, 441);
	add_field("LSCO4G", 22, an, 463);
	add_field("LIDTER", 10, an, 485);
	add_field("LUTECR", 2, an, 495);
	add_field("LDATCR", 19, an, 497);
	add_field("LUTEVA", 2, an, 516);
	add_field("LDATVA", 19, an, 518);
	add_field("KEY_U", 20, an, 537);
	add_field("KEYB", 20, an, 557);
	add_field("KEYFORART", 20, an, 577);
	add_field("KEYART", 20, an, 597);
	add_field("INVMAG", 8, an, 617);
}

///////////////////////////////////////////////////////////
// TGiacenze_textset
///////////////////////////////////////////////////////////

class TGiacenze_textset : public TAS400_recordset
{

protected:

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

public:
  TGiacenze_textset(const char* query = "");
};

void TGiacenze_textset::add_field(const char* name, int len, 
														char tipo, int from, const char* def)
{
	const bool required = false;
  TString80 fname(name);

  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(fname, pos, len, t, required, var);
  }
  else
    create_field(fname, pos, len, t, required);
}

TGiacenze_textset::TGiacenze_textset(const char* query)
                 : TAS400_recordset(TString("AS400(1416,0,0)\n") << query)
{
  const char an = 'a';
  const char n = 'n';

	add_field("SVALAN", 1, an, 1);     //  MFARSA00
	add_field("SGRUPP", 2, an, 2);
	add_field("SCODAR", 22, an, 4);
	add_field("SCODDE", 6, an, 26);
	add_field("SSCMIN", 22, an, 32);
	add_field("SSCMAX", 22, an, 54);
	add_field("SCODUB", 5, an, 76);
	add_field("SLOTRI", 22, an, 81);
	add_field("SQTAOC", 22, an, 103);
	add_field("SQTAOF", 22, an, 125);
	add_field("SQTAIM", 22, an, 147);
	add_field("SQTPRO", 22, an, 169);
	add_field("SQTAPR", 22, an, 191);
	add_field("SCOSPR", 22, an, 213);
	add_field("SESINI", 22, an, 235);
	add_field("SESIDI", 22, an, 257);
	add_field("SESICO", 22, an, 279);
	add_field("SESVIS", 22, an, 301);
	add_field("SDAULA", 22, an, 323);
	add_field("SDAENT", 19, an, 345);
	add_field("SDAUSC", 19, an, 364);
	add_field("STVACD", 22, an, 383);
	add_field("STVACC", 22, an, 405);
	add_field("STVASD", 22, an, 427);
	add_field("STVASC", 22, an, 449);
	add_field("SQTD01", 22, an, 471);
	add_field("SQTD02", 22, an, 493);
	add_field("SQTD03", 22, an, 515);
	add_field("SQTD04", 22, an, 537);
	add_field("SQTD05", 22, an, 559);
	add_field("SQTD06", 22, an, 581);
	add_field("SQTD07", 22, an, 603);
	add_field("SQTD08", 22, an, 625);
	add_field("SQTD09", 22, an, 647);
	add_field("SQTD10", 22, an, 669);
	add_field("SQTD11", 22, an, 691);
	add_field("SQTD12", 22, an, 713);
	add_field("SQTD13", 22, an, 735);
	add_field("SQTD14", 22, an, 757);
	add_field("SQTD15", 22, an, 779);
	add_field("SQTD16", 22, an, 801);
	add_field("SQTD17", 22, an, 823);
	add_field("SQTD18", 22, an, 845);
	add_field("SQTC01", 22, an, 867);
	add_field("SQTC02", 22, an, 889);
	add_field("SQTC03", 22, an, 911);
	add_field("SQTC04", 22, an, 933);
	add_field("SQTC05", 22, an, 955);
	add_field("SQTC06", 22, an, 977);
	add_field("SQTC07", 22, an, 999);
	add_field("SQTC08", 22, an, 1021);
	add_field("SQTC09", 22, an, 1043);
	add_field("SQTC10", 22, an, 1065);
	add_field("SQTC11", 22, an, 1087);
	add_field("SQTC12", 22, an, 1109);
	add_field("SQTC13", 22, an, 1131);
	add_field("SQTC14", 22, an, 1153);
	add_field("SQTC15", 22, an, 1175);
	add_field("SQTC16", 22, an, 1197);
	add_field("SQTC17", 22, an, 1219);
	add_field("SQTC18", 22, an, 1241);
	add_field("SQTULC", 22, an, 1263);
	add_field("SQTULS", 22, an, 1285);
	add_field("STIPDE", 1, an, 1307);
	add_field("SIDTER", 10, an, 1308);
	add_field("SUTECR", 2, an, 1318);
	add_field("SDATCR", 22, an, 1320);
	add_field("SUTEVA", 2, an, 1342);
	add_field("SDATVA", 22, an, 1344);
	add_field("SDESDE", 30, an, 1366);
	add_field("KEY_U", 10, an, 1396);
	add_field("INVMAG", 8, an, 1406);
	add_field("SINVEN", 1, an, 1414);
}

///////////////////////////////////////////////////////////
// TCosti_textset
///////////////////////////////////////////////////////////

class TCosti_textset : public TAS400_recordset
{

protected:

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

public:
  TCosti_textset(const char* query = "");
};

void TCosti_textset::add_field(const char* name, int len, 
														char tipo, int from, const char* def)
{
	const bool required = false;
  TString80 fname(name);

  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(fname, pos, len, t, required, var);
  }
  else
    create_field(fname, pos, len, t, required);
}

TCosti_textset::TCosti_textset(const char* query)
              : TAS400_recordset(TString("AS400(390,0,0)\n") << query)
{
  const char an = 'a';
  const char n = 'n';

	add_field("SVALAN", 1, an, 1);		//	MFARC00
	add_field("SGRUPP", 2, an, 2);
	add_field("SCODAR", 22, an, 4);
	add_field("STIPDE", 1, an, 26);
	add_field("SCUFIA", 22, an, 27);
	add_field("SQTACD", 22, an, 49);
	add_field("SVALCD", 22, an, 71);
	add_field("SQTACC", 22, an, 93);
	add_field("SVALCC", 22, an, 115);
	add_field("SCOULD", 22, an, 137);
	add_field("SCOULC", 22, an, 159);
	add_field("SPRULD", 22, an, 181);
	add_field("SPRULC", 22, an, 203);
	add_field("SQTAVD", 22, an, 225);
	add_field("SVAAVD", 22, an, 247);
	add_field("SQTAVC", 22, an, 269);
	add_field("SVAAVC", 22, an, 291);
	add_field("SIDTER", 10, an, 313);
	add_field("SUTECR", 2, an, 323);
	add_field("SDATCR", 22, an, 325);
	add_field("SUTEVA", 2, an, 347);
	add_field("SDATVA", 22, an, 349);
	add_field("KEY_U", 10, an, 371);
	add_field("INVMAG", 8, an, 381);
}

///////////////////////////////////////////////////////////
// TClasse_textset
///////////////////////////////////////////////////////////

class TClasse_textset : public TAS400_recordset
{

protected:

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

public:
  TClasse_textset(const char* query = "");
};

void TClasse_textset::add_field(const char* name, int len, 
														char tipo, int from, const char* def)
{
	const bool required = false;
  TString80 fname(name);

  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(fname, pos, len, t, required, var);
  }
  else
    create_field(fname, pos, len, t, required);
}

TClasse_textset::TClasse_textset(const char* query)
               : TAS400_recordset(TString("AS400(47,0,0)\n") << query)
{
  const char an = 'a';
  const char n = 'n';

	add_field("CODCLA", 2, an, 1);
	add_field("DESCLA", 20, an, 3);
	add_field("TRASF", 1, an, 23);
	add_field("PERCENT", 22, an, 24);
}

///////////////////////////////////////////////////////////
// TMarca_textset
///////////////////////////////////////////////////////////

class TMarca_textset : public TAS400_recordset
{

protected:

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

public:
  TMarca_textset(const char* query = "");
};

void TMarca_textset::add_field(const char* name, int len, 
					    								 char tipo, int from, const char* def)
{
	const bool required = false;
  TString80 fname(name);

  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(fname, pos, len, t, required, var);
  }
  else
    create_field(fname, pos, len, t, required);
}

TMarca_textset::TMarca_textset(const char* query)
               : TAS400_recordset(TString("AS400(29,0,0)\n") << query)
{
  const char an = 'a';
  const char n = 'n';

	add_field("CODMAR", 6, an, 1);
	add_field("DESMAR", 20, an, 7);
	add_field("TRASF", 1, an, 27);
}

///////////////////////////////////////////////////////////
// TDettaglio_receiver
///////////////////////////////////////////////////////////

bool TDettaglio_receiver::create()
{
	return TSkeleton_application::create();
}

bool TDettaglio_receiver::destroy()
{
	return TSkeleton_application::destroy();
}

const TString & TDettaglio_receiver::build_codart(const TString & gruppo, const long codice)
{
	TString & tmp = get_tmp_string(80);

	tmp.format("%ld", codice);
	tmp.right_just(_len, '0');
	tmp.insert(gruppo);
	return tmp;
}

void TDettaglio_receiver::add_to_tab(const TString & codtab, const TString & cod, const char * desc)
{
	if (cod.full())
	{
		TTable tab(codtab);
		TString d(desc);
		tab.put("CODTAB", cod);
		d.trim();
		if (tab.read() != NOERR)
		{
			tab.zero();
			tab.put("CODTAB", cod);
			tab.put("S0", desc);
			tab.write();
		}
		else
			if (d.full())
			{
				tab.put("S0", d);
				tab.rewrite();
			}
	}
}

void TDettaglio_receiver::load_classi(const TDettaglio_mask & m)
{
	TString query("SELECT * FROM ");
	TFilename name = m.get(F_PATH);

	name.add("tab_cla.txt");
	query << name;

	TClasse_textset inputfile(query);
  TProgind pi(inputfile.items(), TR("Importazione classi "), true, true);
  for (bool ok = inputfile.move_first(); ok; ok = inputfile.move_next())
	{
		const TString & cod = inputfile.get("CODCLA").as_string();

		add_to_tab("GMC", cod, inputfile.get("DESCLA").as_string());
	}
}

void TDettaglio_receiver::load_marche(const TDettaglio_mask & m)
{
	TString query("SELECT * FROM ");
	TFilename name = m.get(F_PATH);

	name.add("tab_mar.txt");
	query << name;

	TMarca_textset inputfile(query);
  TProgind pi(inputfile.items(), TR("Importazione marche "), true, true);
  for (bool ok = inputfile.move_first(); ok; ok = inputfile.move_next())
	{
		const TString & cod = inputfile.get("CODMAR").as_string();

		add_to_tab("RFA", cod, inputfile.get("DESMAR").as_string());
	}
}

void TDettaglio_receiver::load_articoli(const TDettaglio_mask & m)
{
	TString query("SELECT * FROM ");
	TFilename name = m.get(F_PATH);

	name.add("mfarti00.txt");
	query << name;

	TAnamag_textset inputfile(query);
  TProgind pi(inputfile.items(), TR("Importazione Articoli "), true, true);
  TSystemisamfile anamag(LF_ANAMAG);
  TSystemisamfile umart(LF_UMART);
  TSystemisamfile deslin(LF_DESLIN);

	anamag.zap();
	umart.zap();
	deslin.zap();
	anamag.open();
	umart.open();
	deslin.open();
  for (bool ok = inputfile.move_first(); ok; ok = inputfile.move_next())
	{
		if (inputfile.get("AVALAN").as_string().blank())
		{
			anamag.zero();
			const TString & codart = build_codart (inputfile.get("AGRUPP").as_string(), inputfile.get("ACODAR").as_int());
			anamag.put(ANAMAG_CODART, codart);

			anamag.put(ANAMAG_DESCR, inputfile.get("ADESAR").as_string());
			anamag.put(ANAMAG_CODIVA, inputfile.get("ACODIV").as_string());

			const TString & marca = inputfile.get("ACOMAR").as_string();    
			anamag.put(ANAMAG_RAGGFIS, marca);   
			add_to_tab("RFA", marca);

			const TString & classe = inputfile.get("ACLASS").as_string();

			anamag.put(ANAMAG_GRMERC, classe);
			add_to_tab("GMC", classe);

			const TString & categ = inputfile.get("ACATEG").as_string();     
			
			anamag.put(ANAMAG_CLASSEFIS, categ);   
			add_to_tab("ASF", categ);
			
			anamag.put(ANAMAG_PPCONF, inputfile.get("ACONFE").as_string());
			anamag.write();
			
			int nr = 0;
			const TString & umve = inputfile.get("AUNMVE").as_string();

			if (umve.full())
			{
				umart.zero();
				umart.put(UMART_CODART, codart);
				umart.put(UMART_NRIGA, ++nr);
				umart.put(UMART_UM, umve);
				add_to_tab("%UMS", umve);
				umart.put(UMART_FC, "1.0");
				umart.write();
			}

			const TString & umacq = inputfile.get("AUNMAC").as_string();

			if (umacq.full() && umacq != umve)
			{
				umart.zero();
				umart.put(UMART_CODART, codart);
				umart.put(UMART_NRIGA, ++nr);
				umart.put(UMART_UM, umacq);
				add_to_tab("%UMS", umacq);
				umart.put(UMART_FC, "1.0");
				umart.write();
			}
		}
		pi.addstatus(1L);;
		if (pi.iscancelled())
			break;
	}
	anamag.close();
	umart.close();
	deslin.close();
}

void TDettaglio_receiver::load_barcode(const TDettaglio_mask & m)
{
	TString query("SELECT * FROM ");
	TFilename name = m.get(F_PATH);

	name.add("mfarbc00.txt");
	query << name;

	TBarcode_textset inputfile(query);
  TProgind pi(inputfile.items(), TR("Importazione Barcode "), true, true);
  TSystemisamfile codcorr(LF_CODCORR);
  TLocalisamfile umart(LF_UMART);

	codcorr.zap();
	codcorr.open();
  for (bool ok = inputfile.move_first(); ok; ok = inputfile.move_next())
	{
		if (inputfile.get("BVALAR").as_string().blank())
		{
			const TString & codart = build_codart (inputfile.get("BGRUPP").as_string(), inputfile.get("BCODAR").as_int());

			codcorr.zero();
			codcorr.put(CODCORR_CODART, codart);

			const TRectype comp(codcorr.curr());
			int nriga = 0;

			codcorr.put(CODCORR_NRIGA, 999);
			if (codcorr.read(_isgteq) == NOERR)
				codcorr.prev();
			if (codcorr.curr() == comp)
				nriga = codcorr.get_int(CODCORR_NRIGA);
			nriga++;
			codcorr.zero();
			codcorr.put(CODCORR_CODART, codart);
			codcorr.put(CODCORR_NRIGA, nriga);
			codcorr.put(CODCORR_CODART, codart);
			
			const bool barcode = (inputfile.get("BTIPRE").as_string() == "B");
			TString barcodeart(inputfile.get("BBARCO").as_string());
			barcodeart.trim();
			int len = barcodeart.len();

			if (barcode)
				codcorr.put(CODCORR_TIPO, len == 13 ? "1" : (len == 8 ? "8" : "3"));
			else
				codcorr.put(CODCORR_TIPO, "N");
			codcorr.put(ANAMAG_CODARTALT, barcodeart);
			const real conf =	inputfile.get("BCONFE").as_real();

			if (conf != UNO && conf != ZERO)
			{
				codcorr.put(CODCORR_UM, "CF");
				umart.zero();
				umart.setkey(2);
				umart.put(UMART_CODART, codart);
				umart.put(UMART_UM, "CF");
				add_to_tab("%UMS", "CF");

				if (umart.read() == NOERR)
				{
					umart.put(UMART_FC, inputfile.get("BCONFE").as_string());
					umart.rewrite();
				}
				else
				{
					umart.zero();
					umart.put(UMART_CODART, codart);
					const TRectype compum(codcorr.curr());
					int nriga = 0;

					umart.put(UMART_NRIGA, 999);
					if (umart.read(_isgteq) == NOERR)
						umart.prev();
					if (umart.curr() == compum)
						nriga = umart.get_int(UMART_NRIGA);
					nriga++;

					umart.zero();
					umart.put(UMART_CODART, codart);
					umart.put(UMART_NRIGA, nriga);
					umart.put(UMART_UM, "CF");
					umart.put(UMART_FC, inputfile.get("BCONFE").as_real());
					umart.write();
				}
			}
			codcorr.write();
		}
		pi.addstatus(1L);;
		if (pi.iscancelled())
			break;
	}
	codcorr.close();
}

void TDettaglio_receiver::load_listino(const TDettaglio_mask & m)
{
	TString query("SELECT * FROM ");
	TFilename name = m.get(F_PATH);

	name.add("mfarli00.txt");
	query << name;

	TListino_textset inputfile(query);
  TProgind pi(inputfile.items(), TR("Importazione Listino "), true, true);
  TSystemisamfile rcondv(LF_RCONDV);
  TSystemisamfile condv(LF_CONDV);
	TLocalisamfile anamag(LF_ANAMAG);
	TString4 codlist;

	condv.zap();
	rcondv.zap();
	condv.open();
	rcondv.open();
  for (bool ok = inputfile.move_first(); ok; ok = inputfile.move_next())
	{
		if (inputfile.get("LVALAR").as_string().blank())
		{
			const TString80 codart(build_codart(inputfile.get("LGRUPP").as_string(), inputfile.get("LCODAR").as_int()));
			const int tipocf = inputfile.get("LTIPCF").as_int();
			const int list =  inputfile.get("LCODLI").as_int();

			if (list == 0)
			{
				if (tipocf == 2)
				{
					long codforn = inputfile.get("LCFTAB").as_int();

					anamag.zero();
					anamag.put(ANAMAG_CODART, codart);
					if (anamag.read() == NOERR)
					{
						anamag.put(ANAMAG_CODFORN, codforn);
						anamag.rewrite();
					}
				}
			}
			else
			{
				codlist.format("%01d%02d", tipocf, list);
				rcondv.zero();
				rcondv.put(RCONDV_TIPO, "L");
				rcondv.put(RCONDV_COD, codlist);
				rcondv.put(RCONDV_TIPORIGA, "A");
				rcondv.put(RCONDV_CODRIGA, codart);
				real prezzo;

				if (tipocf == 2)
					prezzo = inputfile.get("LCOSTO").as_real();
				else
					prezzo = inputfile.get("LLISTI").as_real();
				if (prezzo != ZERO)
				{
					rcondv.put(RCONDV_PREZZO, prezzo);
					rcondv.write();
					condv.zero();
					condv.put(CONDV_TIPO, "L");
					condv.put(CONDV_COD, codlist);

					if (condv.read() != NOERR)
					{
						condv.zero();
						condv.put(CONDV_TIPO, "L");
						condv.put(CONDV_COD, codlist);
						condv.write();
					}
				}
			}
		}
		pi.addstatus(1L);;
		if (pi.iscancelled())
			break;
	}
	condv.close();
	rcondv.close();
}

void TDettaglio_receiver::load_giacenze(const TDettaglio_mask & m)
{
	TString query("SELECT * FROM ");
	TFilename name = m.get(F_PATH);

	name.add("mfarsa00.txt");

	TEsercizi_contabili es;
	const int codes	 = es.pred(es.last());

	query << name;

	TGiacenze_textset inputfile(query);
  TProgind pi(inputfile.items(), TR("Importazione Giacenze"), true, true);
  TSystemisamfile mag(LF_MAG);

	mag.zap();
	mag.open();
  for (bool ok = inputfile.move_first(); ok; ok = inputfile.move_next())
	{
		if (inputfile.get("SVALAR").as_string().blank())
		{
			const TString & codart = build_codart(inputfile.get("SGRUPP").as_string(), inputfile.get("SCODAR").as_int());
			const TString8 codmag(inputfile.get("SCODDE").as_string());

			mag.zero();
			mag.put(MAG_ANNOES, codes);
			mag.put(MAG_CODART, codart);

			const TRectype comp(mag.curr());
			int nriga = 0;

			mag.put(MAG_NRIGA, 999);
			if (mag.read(_isgteq) == NOERR)
				mag.prev();
			if (mag.curr() == comp)
				nriga = mag.get_int(MAG_NRIGA);
			nriga++;
			mag.zero();
			mag.put(MAG_ANNOES, codes);
			mag.put(MAG_CODART, codart);
			mag.put(MAG_NRIGA, nriga);

			const real & rim_ini = inputfile.get("SESINI").as_real();
			const real & giac = inputfile.get("SESIDI").as_real();
			if (rim_ini != ZERO || giac != ZERO)
			{
				mag.put(MAG_RIM, rim_ini);
				mag.put(MAG_GIAC, giac);
				if (rim_ini > giac)
					mag.put(MAG_VEN, rim_ini - giac);
				else
					mag.put(MAG_ACQ, giac - rim_ini);

				mag.write();
			}
		}
		pi.addstatus(1L);;
		if (pi.iscancelled())
			break;
	}
	mag.close();
}

void TDettaglio_receiver::load_costi(const TDettaglio_mask & m)
{
	TString query("SELECT * FROM ");
	TFilename name = m.get(F_PATH);
	TEsercizi_contabili es;
	const TDate oggi(TODAY);
	const TDate inizio = es.esercizio(es.last()).inizio();

	name.add("mfarco00.txt");
	query << name;

	TCosti_textset inputfile(query);
  TProgind pi(inputfile.items(), TR("Importazione Costi "), true, true);
  TLocalisamfile anamag(LF_ANAMAG);
  
	for (bool ok = inputfile.move_first(); ok; ok = inputfile.move_next())
	{
		if (inputfile.get("SVALAR").as_string().blank())
		{
			const real ultcos1 =  inputfile.get("SCOULD").as_real();
			const real ultcos2 = inputfile.get("SCUFIA").as_real();

			if (ultcos1 != ZERO || ultcos2 != ZERO)
			{
				anamag.zero();
				const TString & codart = build_codart (inputfile.get("SGRUPP").as_string(), inputfile.get("SCODAR").as_int());
				anamag.put(ANAMAG_CODART, codart);

				if (anamag.read() == NOERR)
				{
					if (ultcos1 != ZERO)
					{
						anamag.put(ANAMAG_ULTCOS1, ultcos1);
						anamag.put(ANAMAG_DULTCOS1, oggi);
					}
					if (ultcos2 != ZERO)
					{
						anamag.put(ANAMAG_ULTCOS2, ultcos2);
						anamag.put(ANAMAG_DULTCOS2, inizio);
					}
					anamag.rewrite();
				}
			}
		}
		pi.addstatus(1L);;
		if (pi.iscancelled())
			break;
	}
}

void TDettaglio_receiver::load_clifo(const TDettaglio_mask & m)
{
	TString query("SELECT * FROM ");
	TFilename name = m.get(F_PATH);

	name.add("mfancf00.txt");
	query << name;

	TClifo_textset inputfile(query);
  TProgind pi(inputfile.items(), TR("importazione Clienti/Fornitori "), true, true);
  TSystemisamfile clifo(LF_CLIFO);
  TSystemisamfile cfven(LF_CFVEN);

	clifo.zap();
	cfven.zap();
	clifo.open();
	cfven.open();
  for (bool ok = inputfile.move_first(); ok; ok = inputfile.move_next())
	{
		clifo.zero();

		if (inputfile.get("VALICF").as_string().blank())
		{
			clifo.put(CLI_TIPOCF, inputfile.get("ATIPCF").as_int() == 1 ? "C" : "F");
			clifo.put(CLI_CODCF, inputfile.get("ACODCF").as_int());
			clifo.put(CLI_TIPOAPER, inputfile.get("AFIGIU").as_int() == 1 ? "G" : "F");
			clifo.put(CLI_RAGSOC, inputfile.get("ARAGSO").as_string());
			clifo.put(CLI_INDCF, inputfile.get("AINDIR").as_string());

			TString localita(inputfile.get("ALOCAL").as_string());
			TString cap(inputfile.get("ACAP").as_string());

			localita.trim();
			const TString & com = cap2comune(cap, localita);

			if (com.full())
				clifo.put(CLI_COMCF, com);
			else
			{
				TString prov(inputfile.get("APROVI").as_string());

				if (prov.full())
					localita << "(" << prov.upper() << ")";
				clifo.put(CLI_LOCCF, localita);
			}
			clifo.put(CLI_CAPCF, cap);
			clifo.put(CLI_STATOCF, inputfile.get("ANAZIO").as_string());
			clifo.put(CLI_PAIV, inputfile.get("APARIV").as_string());
			clifo.put(CLI_COFI, inputfile.get("ACODFI").as_string());
			
			const TString & codpag = inputfile.get("ACOPAG").as_string();
			
			clifo.put(CLI_CODPAG, codpag);
			add_to_tab("%CPG", codpag);
			clifo.put(CLI_TEL, inputfile.get("ANUTE1").as_string());
			clifo.put(CLI_FAX, inputfile.get("ANUFAX").as_string());

			TString8 abi;
			TString8 cab;
			
			abi.format("%05ld", inputfile.get("ACOABI").as_int());

			if (abi != "00000")
			{
				clifo.put(CLI_CODABI, abi);
				add_to_tab("%BAN", abi);
				if (cab != "0000000000")
				{
					cab.format("%s%05ld",(const char *) abi, inputfile.get("ACOCAB").as_int());
					clifo.put(CLI_CODCAB, cab);
					add_to_tab("%BAN", cab);
				}
			}
			clifo.write();
			cfven.zero();
			cfven.put(CFV_TIPOCF, inputfile.get("ATIPCF").as_int() == 1 ? "C" : "F");
			cfven.put(CFV_CODCF, inputfile.get("ACODCF").as_int());

			const TString & codiva = inputfile.get("ACOIVA").as_string();
			
			cfven.put(CFV_ASSFIS, codiva);
			add_to_tab("%IVA", codiva);
			cfven.write();
		}
		pi.addstatus(1L);;
		if (pi.iscancelled())
			break;
	}
	clifo.close();
	cfven.close();
}

void TDettaglio_receiver::main_loop()
{
	TDettaglio_mask m;
  while (m.run() != K_QUIT)
  {

		_len = m.get_int(F_LEN);
		if (m.get_bool(F_TB))
		{
			load_classi(m);
			load_marche(m);
		}
		if (m.get_bool(F_CF))
			load_clifo(m);
		if (m.get_bool(F_AM))
			load_articoli(m);
		if (m.get_bool(F_BC))
			load_barcode(m);
		if (m.get_bool(F_LI))
			load_listino(m);
		if (m.get_bool(F_GI))
			load_giacenze(m);
		if (m.get_bool(F_CS))
			load_costi(m);
  }
}

int pn0001100(int argc, char* argv[])
{
  TDettaglio_receiver a;
  a.run(argc, argv, TR("Importazione vendite al dettaglio"));
  return 0;
}

// Tabella Pagamenti
// Tabella UM
// Tabella Cat mefc
// Tabella raggfis (gruppo)
// Tabella classfis (classe)