Patch level : 10.0 NO PATCH

Files correlati     : tc2 e tabelle
Ricompilazione Demo : [ ]
Commento            :
Aggiunti i programmi tc2 - Trasefrimento ipsoa


git-svn-id: svn://10.65.10.50/branches/R_10_00@21107 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
luca83 2010-11-05 11:40:58 +00:00
parent 7cc06c1ce1
commit 96cd5b4c1b
21 changed files with 4906 additions and 0 deletions

27
tc/tc2.cpp Executable file
View File

@ -0,0 +1,27 @@
#include <xvt.h>
#include "tc2.h"
int main(int argc, char** argv)
{
const int op = argc < 2 ? 0 : argv[1][1]-'0';
switch (op)
{
// case 1: tc2200(argc,argv); break;
case 2: tc2300(argc,argv); break; // parametri ditta
// case 3: tc2400(argc,argv); break;
case 4: tc2500(argc,argv); break; //gestore tabelle multirel
case 5: tc2600(argc,argv); break; //importazione PCon, Cuas, CodIVA
case 6: tc2700(argc,argv); break; //esportazione contabilita' a TeamSystem
case 7: tc2800(argc,argv); break; // Riclassificazione conti TeamSystem
case 8: tc2900(argc,argv); break; // COnverione archivi CAMPO
default: ; tc2100(argc,argv); break;
}
exit(0);
return 0;
}

26
tc/tc2.h Executable file
View File

@ -0,0 +1,26 @@
#ifndef __tc2_H
#define __tc2_H
int tc2100(int argc, char* argv[]);
int tc2300(int argc, char* argv[]);
int tc2500(int argc, char* argv[]);
int tc2600(int argc, char* argv[]);
int tc2700(int argc, char* argv[]);
int tc2800(int argc, char* argv[]);
int tc2900(int argc, char* argv[]);
#endif // __tc2_H

55
tc/tc2100.cpp Executable file
View File

@ -0,0 +1,55 @@
#include "tc2.h"
// gestione tabelle Zucchetti
#include <modaut.h>
#include <modtbapp.h>
#include <tabutil.h>
// applicazione per la gestione delle tabelle di magazzino
class Tab_app_teamsystem : public TTable_module_application
{
protected: // TRelation_application
virtual bool user_create() ;
public:
Tab_app_teamsystem() {}
virtual ~Tab_app_teamsystem() {}
};
HIDDEN inline Tab_app_teamsystem& app() { return (Tab_app_teamsystem&)main_app(); }
bool Tab_app_teamsystem::user_create()
{
/*
la Tab_application::user_create() apre la maschera TMask in modo automatico
basandosi sul parametro passato sulla linea di comando e sulla convenzione
nome = "BATB"+parametro;
ORA:
- questa convenzione cambierà per separare i programmi (e le maschere)
dei vari pacchetti
In tal caso ridefinire il metodo virtual mask_name()
- secondo il nuovo stile, gli handler vanno posti in maschere derivate
dalla TMask (TMask_tabzucc, TMask_tabcau, ecc), pertanto occorre che
la maschera aperta sia del tipo corretto
per questo motivo la maschera viene creata dalla user_create()
*/
bool ok = TTable_module_application::user_create();
if (ok)
{
//TMask& mask = *set_mask();
}
return ok;
}
int tc2100(int argc, char **argv)
{
Tab_app_teamsystem a;
a.run(argc, argv, TR("Tabella"));
return 0;
}

265
tc/tc2300.cpp Executable file
View File

@ -0,0 +1,265 @@
#include <confapp.h>
#include <msksheet.h>
#include <progind.h>
#include <recset.h>
#include <recarray.h>
#include <relation.h>
#include "../include/attiv.h"
#include "../include/mov.h"
#include "../cg/cglib01.h"
#include "tcconf.h"
class TTS_confditta : public TConfig_application
{
char _current;
static bool check_fields(TMask_field& f, KEY k);
// @cmember:(INTERNAL) Salva i parametri dalla maschera
virtual void save_mask(bool tosave);
virtual void load_mask();
public:
// @cmember Disabilita la verifica del modulo in chiave
virtual bool check_autorization() const { return FALSE; }
virtual bool preprocess_config (TMask& mask, TConfig& config);
virtual bool postprocess_config (TMask& mask, TConfig& config);
virtual bool user_create( );
virtual bool user_destroy( );
TTS_confditta() : TConfig_application( CONFIG_DITTA ){ }
virtual ~TTS_confditta( ){ }
};
bool sh_notify(TSheet_field& s, int r, KEY k)
{
if (k == K_TAB)
{
TMask& m = s.mask();
const bool use_pcn = m.get_bool(F_USECMPCN);
const int r = s.selected();
TMask & mr = s.sheet_mask();
TToken_string & row = s.row(r);
row.add(use_pcn ? "X" : " ", 4);
s.check_row(r);
}
return true;
}
bool TTS_confditta::check_fields(TMask_field& f, KEY k)
{
return true;
}
void TTS_confditta::load_mask()
{
TMask* mask = get_mask();
if (mask != NULL)
{
TConfig_application::load_mask();
TConfig& config = *get_config();
TSheet_field& sa = mask->sfield(F_SHEET_ATTIV);
TAssoc_array ditte;
const bool use_pcn = config.get_bool("TSUSECMPCN");
int i = 0;
for (i = 0; config.exist("TSDATT", i); i++)
{
const TString8 att(config.get("TSDATT", NULL, i));
const TString8 ditta(config.get("TSDDITTA", NULL, i));
if (att.full())
ditte.add(att, ditta);
TToken_string& row = sa.row(i);
row.add(att);
const TString & descr = cache().get("%AIS", att, "S0");
row.add(descr);
row.add(ditta);
sa.check_row(i);
}
TString query;
const long firm = mask->get_long(F_CODDITTA);
query.format("USE %d SELECT ATTPREV!=\"X\"\nFROM CODDITTA=%ld\nTO CODDITTA=%ld\n", LF_ATTIV, firm, firm);
TISAM_recordset attrec(query);
for (bool ok = attrec.move_first(); ok; ok = attrec.move_next())
{
const TString8 codatt = attrec.get(ATT_CODATT).as_string();
if (ditte.objptr(codatt) == NULL)
{
TToken_string& row = sa.row(i);
row.add(codatt);
const TString & descr = cache().get("%AIS", codatt, "S0");
row.add(descr);
row.add("");
sa.check_row(i);
}
}
TSheet_field& si = mask->sfield(F_SHEET_IVA);
si.set_notify(sh_notify);
for (i = 0; config.exist("TSGIVA", i); i++)
{
TToken_string& row = si.row(i);
row.add(config.get("TSGIVA", NULL, i));
row.add(config.get("TSCIVA", NULL, i));
row.add(config.get("TSSIVA", NULL, i));
row.add(use_pcn ? "X" : " ", 4);
si.check_row(i);
}
TSheet_field& sr = mask->sfield(F_SHEET_RIT);
sr.set_notify(sh_notify);
for (i = 0; config.exist("TSGRIT", i); i++)
{
TToken_string& row = sr.row(i);
row.add(config.get("TSGRIT", NULL, i));
row.add(config.get("TSCRIT", NULL, i));
row.add(config.get("TSSRIT", NULL, i));
row.add(use_pcn ? "X" : " ", 4);
sr.check_row(i);
}
}
}
void TTS_confditta::save_mask(bool tosave)
{
if (tosave)
{
const TMask & m = *get_mask();
if (m.get_bool(F_RIPRISTINO))
{
const TDate from(m.get(F_ULTINVIO));
TEsercizi_contabili esc;
const TEsercizio & e = esc.esercizio(esc.date2esc(from));
const TDate to(e.fine());
TString query = "USE MOV KEY 2 SELECT INVIATO==\"X\"";
query << "\nFROM DATAREG=#DATA_DA";
query << "\nTO DATAREG=#DATA_AL";
TISAM_recordset mov(query);
mov.set_var("#DATA_DA", TVariant(from));
mov.set_var("#DATA_AL", TVariant(to));
if (mov.items() >0L)
{
TProgind pi(mov.items(), TR("Ripristino movimenti"), true, true);
TLocalisamfile cgmov(LF_MOV);
for (bool ok = mov.move_first(); ok; ok = mov.move_next())
{
if (!pi.addstatus(1))
break;
const long numreg = mov.get(MOV_NUMREG).as_int();
cgmov.put(MOV_NUMREG, numreg);
if (cgmov.read(_isequal, _lock) == NOERR)
{
cgmov.zero(MOV_INVIATO);
cgmov.rewrite();
}
}
}
}
TConfig& config = *get_config();
int i = 0;
for (i = 0; config.exist("TSGIVA", i); i++)
{
config.remove("TSDATT", i);
config.remove("TSDITTA", i);
}
TSheet_field& sa = m.sfield(F_SHEET_ATTIV);
FOR_EACH_SHEET_ROW(sa, jd, rowd)
{
config.set("TSDATT", rowd->get(0), NULL, true, jd);
config.set("TSDDITTA", rowd->get(2), NULL, true, jd);
}
for (i = 0; config.exist("TSGIVA", i); i++)
{
config.remove("TSGIVA", i);
config.remove("TSCIVA", i);
config.remove("TSSIVA", i);
}
TSheet_field& si = m.sfield(F_SHEET_IVA);
FOR_EACH_SHEET_ROW(si, j, row)
{
config.set("TSGIVA", row->get(0), NULL, true, j);
config.set("TSCIVA", row->get(1), NULL, true, j);
config.set("TSSIVA", row->get(2), NULL, true, j);
}
for (i = 0; config.exist("TSGRIT", i); i++)
{
config.remove("TSGRIT", i);
config.remove("TSCRIT", i);
config.remove("TSSRIT", i);
}
TSheet_field& sr = m.sfield(F_SHEET_RIT);
FOR_EACH_SHEET_ROW(sr, jr, rowr)
{
config.set("TSGRIT", rowr->get(0), NULL, true, jr);
config.set("TSCRIT", rowr->get(1), NULL, true, jr);
config.set("TSSRIT", rowr->get(2), NULL, true, jr);
}
}
TConfig_application::save_mask(tosave);
}
bool TTS_confditta::preprocess_config (TMask& mask, TConfig& config)
{
return true;
}
bool TTS_confditta::postprocess_config (TMask& mask, TConfig& config)
{
return true;
}
bool TTS_confditta::user_create( )
{
TConfig conf(CONFIG_DITTA);
conf.set( "EdMask", "tc2300a", "tc");
return true;
}
bool TTS_confditta::user_destroy( )
{
return true;
}
int tc2300(int argc, char* argv[])
{
TTS_confditta appc;
appc.run(argc, argv, TR("Parametri ditta TeamSystem"));
return 0;
}

93
tc/tc2500.cpp Executable file
View File

@ -0,0 +1,93 @@
#include <tabapp.h>
#include "tc2.h"
#include "tcts.h"
class TTeamSystem_multirel_app : public TMultirel_application
{
bool _use_tab;
protected:
virtual void set_descr(TMask & m, const TString & desc);
virtual void get_mask_name(TString& tabname) const;
//magico metodo per impedire la navigazione su tabelle diverse da quella corrente del cursore
virtual bool has_filtered_cursor() const { return true; }
virtual void init_query_mode(TMask& m);
virtual void init_query_insert_mode(TMask& m);
virtual void init_modify_mode(TMask& m);
virtual void init_insert_mode(TMask& m);
virtual bool user_create();
public:
TTeamSystem_multirel_app() : _use_tab(true) {}
virtual ~TTeamSystem_multirel_app() {}
};
void TTeamSystem_multirel_app::set_descr(TMask & m, const TString & desc)
{
m.set(F_DESC, desc);
}
void TTeamSystem_multirel_app::get_mask_name(TString& tabname) const
{
TMultirel_application::get_mask_name(tabname);
tabname.overwrite("ts", 2);
}
void TTeamSystem_multirel_app::init_query_mode(TMask& m)
{
TMultirel_application::init_query_mode(m);
m.show(-1);
m.hide(-2);
m.enable(-3, _use_tab);
}
void TTeamSystem_multirel_app::init_query_insert_mode(TMask& m)
{
TMultirel_application::init_query_insert_mode(m);
m.show(-1, !_use_tab);
m.show(-2, _use_tab);
m.enable(-3, _use_tab);
}
void TTeamSystem_multirel_app::init_modify_mode(TMask& m)
{
TMultirel_application::init_modify_mode(m);
m.show(-1);
m.disable(-1);
m.hide(-2);
m.disable(-3);
}
void TTeamSystem_multirel_app::init_insert_mode(TMask& m)
{
TMultirel_application::init_insert_mode(m);
m.show(-1);
m.disable(-1);
m.hide(-2);
m.disable(-3);
}
bool TTeamSystem_multirel_app::user_create()
{
bool ok = TMultirel_application::user_create();
if (ok)
{
TConfig config(CONFIG_DITTA);
_use_tab = config.get_bool("TSUSECMTAB");
TMask & m = *get_mask();
m.show(-10, _use_tab);
m.show(-20, !_use_tab);
set_search_field(F_CODTAB);
}
return ok;
}
int tc2500(int argc, char* argv[])
{
TTeamSystem_multirel_app a;
a.run(argc, argv, TR("Tabella"));
return 0;
}

375
tc/tc2600.cpp Executable file
View File

@ -0,0 +1,375 @@
#include <applicat.h>
#include <automask.h>
#include <progind.h>
#include <reputils.h>
#include <utility.h>
#include <textset.h>
#include <reprint.h>
#include <scanner.h>
#include "tc2.h"
#include "tc2600a.h"
#include "tabmod.h"
///////////////////////////////////////////////
//// CLASSI DERIVATE PER IMPORTAZIONE DATI ////
///////////////////////////////////////////////
/////////////////////////////////////////////////////////////
// Recordset specifici per i dati da trasferire
/////////////////////////////////////////////////////////////
//Piano dei conti
class TImporta_pconto_recordset : public TCSV_recordset
{
public:
TImporta_pconto_recordset(const char * fileName);
};
TImporta_pconto_recordset::TImporta_pconto_recordset(const char * fileName)
: TCSV_recordset("CSV(\"|\")")
{
load_file(fileName);
}
///////////////////////////////////////////////
//// DEFINIZIONE CLASSE TAutomask ////
///////////////////////////////////////////////
class TImportaTS_mask : public TAutomask
{
protected:
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public:
TImportaTS_mask();
};
TImportaTS_mask::TImportaTS_mask() :TAutomask ("tc2600a")
{
}
bool TImportaTS_mask::on_field_event(TOperable_field& f, TField_event e, long jolly)
{
switch (f.dlg())
{
//giochetto per avere la lista dei files validi nella directory di trasferimento!
case F_PCONTI:
if (e == fe_button)
{
TArray_sheet as(-1, -1, 72, 20, TR("Selezione file"),
"File@32");
TFilename path = get(F_PATH);
path.add("*.txt"); //files delle testate
list_files(path, as.rows_array());
TFilename name;
FOR_EACH_ARRAY_ROW(as.rows_array(), i, row)
{
name = *row;
*row = name.name();
}
if (as.run() == K_ENTER)
{
f.set(as.row(as.selected()));
}
}
break;
case F_CAUSALI:
if (e == fe_button)
{
TArray_sheet as(-1, -1, 72, 20, TR("Selezione file"),
"File@32");
TFilename path = get(F_PATH);
path.add("*.txt"); //files delle testate
list_files(path, as.rows_array());
TFilename name;
FOR_EACH_ARRAY_ROW(as.rows_array(), i, row)
{
name = *row;
*row = name.name();
}
if (as.run() == K_ENTER)
{
f.set(as.row(as.selected()));
}
}
break;
case F_CODIVA:
if (e == fe_button)
{
TArray_sheet as(-1, -1, 72, 20, TR("Selezione file"),
"File@32");
TFilename path = get(F_PATH);
path.add("*.txt"); //files delle testate
list_files(path, as.rows_array());
TFilename name;
FOR_EACH_ARRAY_ROW(as.rows_array(), i, row)
{
name = *row;
*row = name.name();
}
if (as.run() == K_ENTER)
{
f.set(as.row(as.selected()));
}
}
break;
default:
break;
}
return true;
}
///////////////////////////////////////
// TSkeleton_application
///////////////////////////////////////
class TDocTS : public TSkeleton_application
{
TImportaTS_mask* _msk;
protected:
//metodi che fanno gli inserimenti sulle tabelle di campo
void upload_pconti (const TFilename& file, TLog_report& log) const;
void upload_causali(const TFilename& file, TLog_report& log) const;
void upload_codiva (const TFilename& file, TLog_report& log) const;
public:
virtual bool create();
virtual bool destroy();
virtual void main_loop();
bool transfer();
TDocTS() {};
};
TDocTS& app() { return (TDocTS&) main_app(); }
//funzione che importa il piano dei conto sulla tabella corretta
void TDocTS::upload_pconti (const TFilename& file, TLog_report& log) const
{
TImporta_pconto_recordset s(file); //crea un recordset con struttura predefinita come indicato nella classe opportuna
TModule_table pconti("TCO");
TProgind pi(s.items(),"Importazione Piano dei Conti in Corso...",true,true);
for (bool ok=s.move_first();ok;ok=s.move_next())
{
if (!pi.addstatus(1))
break;
//salto le righe di testata del file
//per farlo leggo il gruppo e controllo che sia numerico
TString dconto = s.get(1).as_string();
if (dconto.blank() || !isdigit(dconto[1]))
continue;
pconti.zero();
TString4 gr = dconto.left(2); //leggo il gruppo
TString4 co = dconto.mid(3,2); //leggo il conto
TString4 sc = dconto.mid(6,3); //leggo il sottoconto
TString conto = gr; //leggo il gruppo
TString desc = s.get(2).as_string(); //leggo la descrizione
conto << ((co.blank() || co == "**") ? "00" : co);
conto << ((sc.blank() || sc == "***") ? "000" : sc);
pconti.put("CODTAB", conto); //put del gruppo
pconti.put("S0", desc); //put del conto
int err = pconti.write_rewrite(); //Tenta di aggiungere un record ma se esiste gia' lo aggiorna
TString str = "Il Conto ";
str << conto;
if (err == NOERR)
{
str << " è stato inserito";
log.log(0,str);
}
else
{
str << " non è stato inserito, errore " << err;
log.log(2,str);
}
}
return;
}
void TDocTS::upload_causali(const TFilename& file, TLog_report& log) const
{
TScanner s(file); //legge il file che gli passo riga per riga
TString curr = s.line();
TModule_table causa("TCA");
TProgind pi(fsize(file),"Importazione Causali in Corso...",true,true);
while (s.ok())
{
if (!pi.addstatus(s.tellg()))
break;
causa.zero();
curr = s.line();
TString8 cod = curr.mid(1,6);
TString desc = curr.mid(7,16);
//salto le righe di testata del file
cod.trim();
if (cod.blank() || !real::is_natural(cod))
continue;
cod.lpad(3, '0');
if (cod.len() > 3)
{
TString errore = "ERRORE:";
errore <<" la causale con codice " << cod << " non può essere inserita (codice max 3 caratteri)";
log.log(2,errore);
}
causa.put("CODTAB",cod);
causa.put("S0",desc);
int err = causa.write_rewrite(); //Tenta di aggiungere un record ma se esiste gia' lo aggiorna
TString str = "La Causale con codice ";
str << cod;
if (err == NOERR)
{
str << " è stata inserita";
log.log(0,str);
}
else
{
str << " non è stata inserita, errore " << err;
log.log(2,str);
}
}
return;
};
//funzione che importa i codici IVA sulla tabella corretta
void TDocTS::upload_codiva(const TFilename& file, TLog_report& log) const
{
TScanner s(file); //crea un recordset con struttura predefinita come indicato nella classe opportuna
TModule_table iva("TIV"); //instanzio l'ISAM file che lavota sulla tabella IVA
TProgind pi(fsize(file),"Importazione Dati IVA in Corso...",true,true);
while(s.ok())
{
if (!pi.addstatus(s.tellg()))
break;
//salto le righe di testata del file
iva.zero();
TString curr = s.line();
TString8 cod = curr.mid(1,8);
TString desc = curr.mid(9,18);
//salto le righe di testata del file
cod.trim();
if (cod.blank() || !real::is_natural(cod))
continue;
cod.lpad(3, '0');
if (cod.len() > 3)
{
TString errore = "ERRORE:";
errore <<" i dati IVA con codice " << cod << " non possono essere inseriti (codice max 3 caratteri)";
log.log(2,errore);
}
iva.put("CODTAB",cod);
iva.put("S0",desc);
int err = iva.write_rewrite(); //Tenta di aggiungere un record ma se esiste gia' lo aggiorna
TString str = "I dati IVA con codice ";
str << cod;
if (err == NOERR)
{
str << " sono stati inseriti";
log.log(0,str);
}
else
{
str << " non sono stati inseriti, errore " << err;
log.log(2,str);
}
}
return;
};
bool TDocTS::transfer()
{
TLog_report log("Importazione documenti da TeamSystem");
//prelevo il path dei file da caricare dalla maschera
TFilename path = _msk->get(F_PATH);
const short ids [] = {F_PCONTI,F_CAUSALI,F_CODIVA,0};
//eseguo tutte le importazioni (una alla volta)
for (int i = 0; ids[i]; i++)
{
//prelevo di volta in volta il nome del file giusto dalla maschera:
//prima il file Anagrafiche, poi quello delle fatture e poi quello delle ricevute
TFilename name = _msk->get(ids[i]);
//se sono riuscito a prelevare un nome di file, allora:
if (name.full())
{
//costruisco il nome del file
TFilename full = path;
full.add(name);
//se eiste il file, esegui l'elaborazione corretta
if (full.exist())
{
switch (i)
{
case 0: upload_pconti (full, log); break;
case 1: upload_causali(full, log); break;
case 2: upload_codiva (full, log); break;
default: break;
}
}
}
}
TReport_book buc;
buc.add(log);
if (buc.pages()>0)
buc.preview(); //visualizzo il log di importazione dei documenti
return true;
}
bool TDocTS::create()
{
_msk = new TImportaTS_mask();
return TSkeleton_application::create();
}
bool TDocTS::destroy()
{
delete _msk;
return TApplication::destroy();
}
void TDocTS::main_loop()
{
KEY tasto;
tasto = _msk->run();
if (tasto == K_ENTER)
{
if (transfer())
{
message_box(TR("Importazione documenti completata"));
}
}
}
int tc2600 (int argc, char* argv[])
{
TDocTS main_app;
main_app.run(argc, argv, TR("Importazione Tabelle"));
return true;
}

83
tc/tc2600a.uml Executable file
View File

@ -0,0 +1,83 @@
#include "tc2600a.h"
TOOLBAR "topbar" 0 0 0 2
BUTTON DLG_ELABORA 10 2
BEGIN
PROMPT -12 -11 "~Elabora"
PICTURE BMP_ELABORA
MESSAGE EXIT,K_ENTER
END
#include <helpbar.h>
ENDPAGE
TOOLBAR "" 0 -2 0 2
STRING DLG_PROFILE 50
BEGIN
PROMPT 9 0 "Profilo "
PSELECT
FLAGS "H"
END
ENDPAGE
PAGE "Importazione dati da TeamSystem" 0 2 0 0
GROUPBOX DLG_NULL 76 3
BEGIN
PROMPT 2 1 "@bDitta corrente"
END
NUMBER F_CODDITTA 5
BEGIN
PROMPT 3 2 "Codice "
FLAGS "FD"
USE LF_NDITTE
INPUT CODDITTA F_CODDITTA
OUTPUT F_RAGSOC RAGSOC
CHECKTYPE REQUIRED
END
STRING F_RAGSOC 50
BEGIN
PROMPT 23 2 ""
FLAGS "D"
END
GROUPBOX DLG_NULL 76 6
BEGIN
PROMPT 2 4 "@bSorgente"
END
STRING F_PATH 256 50
BEGIN
PROMPT 3 5 "Cartella "
DSELECT
CHECKTYPE REQUIRED
FIELD FileInPath
END
STRING F_PCONTI 25
BEGIN
PROMPT 3 6 "Piano dei Conti "
FIELD PCONTI
END
STRING F_CAUSALI 25
BEGIN
PROMPT 3 7 "Causali "
FIELD CAUSALI
END
STRING F_CODIVA 25
BEGIN
PROMPT 3 8 "Codici IVA "
FIELD CODIVA
END
ENDPAGE
ENDMASK

393
tc/tc2700.cpp Executable file
View File

@ -0,0 +1,393 @@
#include "tc2.h"
#include "tc2700.h"
#include "tc2700a.h"
#include <progind.h>
#include <reprint.h>
#include <utility.h>
#include <anagr.h>
#include <anafis.h>
#include <clifo.h>
#include <comuni.h>
#include <causali.h>
#include <nditte.h>
#include <attiv.h>
#include <mov.h>
#include <pconti.h>
#include <rmov.h>
#include <rmoviva.h>
#include <multirel.h>
#include "../cg/cglib01.h"
#include "../cg/cg2103.h"
bool TTS_mask::apply_filter(const TRecordset& righe) const
{
const TDate dal = get(F_DATA_DA);
const TDate al = get(F_DATA_AL);
if (dal.ok() || al.ok())
{
const TDate scad = righe.get("DATASCAD").as_date();
if ((dal.ok() && scad < dal) || (al.ok() && scad > al))
return false;
}
return true;
}
bool TTS_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
bool ok = true;
switch (o.dlg())
{
case F_DATA_DA:
case F_DATA_AL:
break;
default:
break;
}
return ok;
}
void TTS_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));
}
}
}
TTS_mask::TTS_mask(const char * maskname)
: TAutomask(maskname), _updating(false), _next_update(0)
{
serialize(false);
}
TTS_mask::~TTS_mask()
{
serialize(true);
}
bool TTS_campo_sender::destroy()
{
delete _mask;
return TTS_sender::destroy();
}
TRecordset & TTS_campo_sender::movrecset()
{
const TMask & m = get_mask();
const TDate from = m.get_date(F_DATA_DA);
const TDate to = m.get_date(F_DATA_AL);
TRecordset * mov = get_recset(LF_MOV);
if (mov == NULL)
{
TString query = "USE MOV KEY 2 SELECT INVIATO!=\"X\"";
query << "\nFROM DATAREG=#DATA_DA";
query << "\nTO DATAREG=#DATA_AL";
mov = set_recset(LF_MOV, ::create_recordset(query));
}
mov->set_var("#DATA_DA", TVariant(from));
mov->set_var("#DATA_AL", TVariant(to));
return *mov;
}
TRecordset & TTS_campo_sender::rmovrecset(const TRecordset & mov)
{
TRecordset * rmov = get_recset(LF_RMOV);
if (rmov == NULL)
rmov = set_recset(LF_RMOV, ::create_recordset("USE RMOV\nFROM NUMREG=#NUMREG\nTO NUMREG=#NUMREG"));
const TVariant & numreg = mov.get(MOV_NUMREG);
if (numreg != rmov->get("#NUMREG"))
rmov->set_var("#NUMREG", numreg);
return *rmov;
}
TRecordset & TTS_campo_sender::rivarecset(const TRecordset & mov)
{
TRecordset * rmoviva = get_recset(LF_RMOVIVA);
if (rmoviva == NULL)
rmoviva = set_recset(LF_RMOVIVA, ::create_recordset("USE RMOVIVA\nFROM NUMREG=#NUMREG\nTO NUMREG=#NUMREG"));
const TVariant & numreg = mov.get(MOV_NUMREG);
if (numreg != rmoviva->get("#NUMREG"))
rmoviva->set_var("#NUMREG", numreg);
return *rmoviva;
}
const TRecordset& TTS_campo_sender::clirecset(const char tipocf, const long codcf)
{
TRecordset * clifo = get_recset(LF_CLIFO);
if (clifo == NULL)
clifo = set_recset(LF_CLIFO, ::create_recordset("USE CLIFO\nFROM TIPOCF=#TIPOCF CODCF=#CODCF\nTO TIPOCF=#TIPOCF CODCF=#CODCF"));
TString4 w; w << tipocf;
TVariant t(w);
clifo->set_var("#TIPOCF", t);
clifo->set_var("#CODCF", codcf);
clifo->move_first();
return *clifo;
}
bool TTS_campo_sender::test_swap(const TRecordset& mov)
{
TRecordset & rmov = rmovrecset(mov);
const int anno = mov.get(MOV_ANNOIVA).as_int();
TCausale caus(mov.get(MOV_CODCAUS).as_string(), anno);
char sez = caus.sezione_clifo();
const bool vendite = mov.get(MOV_TIPO).as_string()[0] != 'F';
const bool s = vendite ^ (sez == 'D');
return s;
}
bool TTS_campo_sender::swap_ritsoc(const TRecordset& mov)
{
TRecordset & rmov = rmovrecset(mov);
bool ok = rmov.move_first();
const char sez = rmov.get(RMV_SEZIONE).as_string()[0];
char sezrit = sez;
for (; ok; ok = rmov.move_next())
{
const char tiporiga = rmov.get(RMV_ROWTYPE).as_string()[0];
if (tiporiga =='S')
{
sezrit = rmov.get(RMV_SEZIONE).as_string()[0];
break;
}
}
const bool s = sez != sezrit;
return s;
}
bool TTS_campo_sender::mov_regolarizzazione(const TRecordset& mov)
{
const TString& codcaus = mov.get(MOV_CODCAUS).as_string();
return _caus_regolarizzazione.objptr(codcaus) != NULL;
}
bool TTS_campo_sender::mov_intra(const TRecordset& mov)
{
const TRectype& caus = cache().get(LF_CAUSALI, mov.get(MOV_CODCAUS).as_string());
return caus.get_bool(CAU_INTRACOM);
}
bool TTS_campo_sender::mov_reverse_charge(const TRecordset& mov)
{
const TRectype& caus = cache().get(LF_CAUSALI, mov.get(MOV_CODCAUS).as_string());
const int regsp = caus.get_int(CAU_REGSPIVA);
return regsp == 13 || regsp == 50 || regsp == 51;
}
bool TTS_campo_sender::regime_agricolo(const TRecordset& mov) const
{
TToken_string key;
key.format("%04d%s", mov.get(MOV_ANNOIVA).as_int(), (const char *) mov.get(MOV_REG).as_string());
const TRectype& reg = cache().get("REG", key);
key.cut(0);
key.add(prefix().get_codditta());
key.add(reg.get("S8"));
const TRectype& attiv = cache().get(LF_ATTIV, key);
return attiv.get_bool(ATT_REGAGR);
}
TMask & TTS_campo_sender::get_mask()
{
if (_mask == NULL)
{
_mask = new TTS_mask(mask_name());
TDate to(TODAY);
TConfig configtc(CONFIG_DITTA, "tc");
const TDate from(configtc.get("TSULTINV"));
if (from.ok())
to.addmonth(-1);
to.set_end_month();
if (to <= from)
{
to = from;
to.addmonth(1);
to.set_end_month();
}
_mask->set(F_DATA_DA, from);
_mask->set(F_DATA_AL, to);
}
return * _mask;
}
bool TTS_campo_sender::find_regolarizzazione(TRecordset& mov)
{
bool found = false;
const TRectype& caus = cache().get(LF_CAUSALI, mov.get(MOV_CODCAUS).as_string());
const TString4 causreg = caus.get(CAU_CODCAUREG);
real totdoc = mov.get(MOV_TOTDOC).as_real();
const real ritfis = mov.get(MOV_RITFIS).as_real();
const real ritsoc = mov.get(MOV_RITSOC).as_real();
if (ritfis != ZERO)
totdoc += ritfis;
if (ritsoc != ZERO)
{
if (swap_ritsoc(mov)) // Somma ritenute sociali con segno
totdoc -= ritsoc;
else
totdoc += ritsoc;
}
if (test_swap(mov))
totdoc = -totdoc;
TToken_string key(mov.get(MOV_TIPO).as_string());
key.add(mov.get(MOV_CODCF).as_int());
const TRectype & cli = cache().get(LF_CLIFO, key);
const TString16 paiv = cli.get(CLI_PAIV);
const TString16 cf = cli.get(CLI_COFI);
TEsercizi_contabili esc;
const TEsercizio & e = esc.esercizio(esc.date2esc(mov.get(MOV_DATAREG).as_date()));
const TDate to(e.fine());
for (bool ok = mov.move_next(); ok && ! found; ok = mov.move_next())
{
const TDate dreg = mov.get(MOV_DATAREG).as_date();
if (dreg >to)
break;
const TRectype& caus = cache().get(LF_CAUSALI, mov.get(MOV_CODCAUS).as_string());
const TString4 cod = caus.get(CAU_CODCAUS);
found = (causreg.full() && cod == causreg) || (causreg.blank() && (_caus_regolarizzazione.objptr(cod) || caus.get_bool(CAU_SOLOIVA)));
found &= (totdoc == mov.get(MOV_TOTDOC).as_real());
key = mov.get(MOV_TIPO).as_string();
key.add(mov.get(MOV_CODCF).as_int());
const TRectype & clireg = cache().get(LF_CLIFO, key);
const TString16 paivreg = clireg.get(CLI_PAIV);
const TString16 cfreg = clireg.get(CLI_COFI);
found &= ((paiv.full() && paiv == paivreg) || (paiv.blank() && cf == cfreg));
if (found)
break;
}
return found;
}
long TTS_campo_sender::iva11_reverse(const TRecordset & mov)
{
const TRectype& caus = cache().get(LF_CAUSALI, mov.get(MOV_CODCAUS).as_string());
return caus.get_int(CAU_REGSPIVA);
}
const char * TTS_campo_sender::decode_causale(const TRecordset& mov)
{
const TRectype& caus = cache().get(LF_CAUSALI, mov.get(MOV_CODCAUS).as_string());
return caus.get(CAU_DESCR);
}
void TTS_campo_sender::postprocess_movs(TRecordset & mov)
{
if (yesno_box(TR("Confermare il traferimento")))
{
TConfig configtc(CONFIG_DITTA);
TMask & m = get_mask();
configtc.set("TSULTINV", m.get_date(F_DATA_AL));
if (mov.items() > 0L)
{
TProgind pi(mov.items(), TR("Conferma movimenti"), true, true);
TLocalisamfile cgmov(LF_MOV);
for (bool ok = mov.move_first(); ok; ok = mov.move_next())
{
if (!pi.addstatus(1))
break;
const long numreg = mov.get(MOV_NUMREG).as_int();
cgmov.put(MOV_NUMREG, numreg);
if (cgmov.read(_isequal, _lock) == NOERR)
{
cgmov.put(MOV_INVIATO, true);
cgmov.rewrite();
}
}
}
}
}
bool search_reg(const TRelation& rel, void* pJolly)
{
TAssoc_array * _caus_regolarizzazione = (TAssoc_array *) pJolly;
const bool solaiva = rel.lfile().get_bool(CAU_SOLOIVA);
const TString codcaus = rel.lfile().get(CAU_CODCAUREG);
if (codcaus.full())
_caus_regolarizzazione->add(codcaus, codcaus);
return true;
}
bool TTS_campo_sender::create()
{
TRelation rel(LF_CAUSALI);
TCursor c(&rel);
bool ok = c.scan(search_reg, &_caus_regolarizzazione, "Ricerca causali di regolarizzazione");
TLocalisamfile clifo(LF_CLIFO);
bool big_cli_code = false;
clifo.put(CLI_TIPOCF, "C");
clifo.put(CLI_CODCF, 100000L);
if (!((clifo.read(_isgteq) == _iseof) || (clifo.get(CLI_TIPOCF) == "F")))
big_cli_code = true;
if (!big_cli_code)
{
clifo.put(CLI_TIPOCF, "F");
clifo.put(CLI_CODCF, 100000L);;
if (clifo.read(_isgteq) != _iseof)
big_cli_code = true;
}
if (big_cli_code)
riclassifica().add("TSNOHCLI", EMPTY_STRING);
return ok && TTS_sender::create();
}
int tc2700(int argc, char* argv[])
{
TTS_campo_sender app;
app.run(argc, argv, TR("Invio a TeamSystem"));
return 0;
}

82
tc/tc2700a.uml Executable file
View File

@ -0,0 +1,82 @@
#include "tc2700a.h"
TOOLBAR "topbar" 0 0 0 2
BUTTON DLG_ELABORA 10 2
BEGIN
PROMPT -12 -11 "~Elabora"
PICTURE BMP_ELABORA
MESSAGE EXIT,K_ENTER
END
#include <helpbar.h>
ENDPAGE
PAGE "Esportazione movimenti contabilita'" 0 2 0 0
GROUPBOX DLG_NULL 76 3
BEGIN
PROMPT 2 1 "@bDitta corrente"
END
NUMBER F_CODDITTA 5
BEGIN
PROMPT 3 2 "Codice "
FLAGS "FD"
USE LF_NDITTE
INPUT CODDITTA F_CODDITTA
OUTPUT F_RAGSOC RAGSOC
CHECKTYPE REQUIRED
END
STRING F_RAGSOC 50
BEGIN
PROMPT 23 2 ""
FLAGS "D"
END
GROUPBOX DLG_NULL 76 4
BEGIN
PROMPT 2 4 "Dati da inviare"
END
BOOLEAN F_MOVIMENTI
BEGIN
PROMPT 3 5 "Movimenti contabili"
END
BOOLEAN F_INTRASTAT
BEGIN
PROMPT 3 6 "Intrastat"
END
STRING F_PATH 256 39
BEGIN
PROMPT 2 8 "Cartella "
DSELECT
CHECKTYPE REQUIRED
FIELD TSDestPath
END
STRING F_FILE 18
BEGIN
PROMPT 54 8 "File "
FIELD TSDestFile
END
DATE F_DATA_DA
BEGIN
PROMPT 2 10 "Data iniz. "
END
DATE F_DATA_AL
BEGIN
PROMPT 30 10 "Data fin. "
END
ENDPAGE
ENDMASK

1529
tc/tc2701.cpp Executable file

File diff suppressed because it is too large Load Diff

180
tc/tc2800.cpp Executable file
View File

@ -0,0 +1,180 @@
// gestione files Contabilita' Analitica: CENTRI DI COSTO
#include <automask.h>
#include <execp.h>
#include <relapp.h>
#include <pconti.h>
#include <recarray.h>
#include "tc2800a.h"
////////////////////////////////////////////////////////////////////////
//MASCHERA
////////////////////////////////////////////////////////////////////////
class TTS_ricl_msk : public TAutomask
{
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public:
TTS_ricl_msk() : TAutomask("tc2800a") {}
};
bool TTS_ricl_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
switch (o.dlg())
{
case F_CONTO:
break;
default:
break;
}
return true;
}
class TTSRiclass_application : public TRelation_application
// @author:(INTERNAL) Vari
// @access:(INTERNAL) Private Member
{
// @cmember:(INTERNAL) Maschera corrente dell'applicazione
TMask* _msk;
// @cmember:(INTERNAL) Relazione corrente dell'applicazione
TRelation* _rel;
bool _use_pcn;
// @access Protected Member
protected:
virtual TMask* get_mask(int mode = MODE_QUERY) { CHECK(_msk, "Null mask"); return _msk; }
// @cmember Indica se la futura <mf Tab_application::get_mask> ritornera' una maschera diversa
// dalla corrente.
virtual bool changing_mask(int mode) { return false; }
// @cmember Ritorna la relazione da modificare
virtual TRelation* get_relation() const { CHECK(_rel, "Null relation"); return _rel; }
// @cmember Inizializza la maschera per il modo ricerca
virtual void init_query_mode(TMask& m);
// @cmember Inizializza la maschera per il modo ricerca ed inserimento (chiama <mf TRelation_application::init_query_mode>)
virtual void init_query_insert_mode(TMask& m) ;
// @cmember Inizializza la maschera per il modo inserimento
virtual void init_insert_mode(TMask& m);
// @cmember Inizializza la maschera per il modo modifica
virtual void init_modify_mode(TMask& m);
// @cmember Inizializzazione dei dati dell'utente
virtual bool user_create() ;
// @cmember Distruzione dei dati dell'utente
virtual bool user_destroy() ;
// @cmember Chiama il programma di stampa
virtual void print();
// @access Public Member
public:
// @cmember Costruttore
TTSRiclass_application() : _msk(NULL), _rel(NULL) { }
// @cmember Distruttore
virtual ~TTSRiclass_application() {}
};
void TTSRiclass_application::print()
{
TFilename rep("tctsricl.rep");
TString cmd;
rep.custom_path();
cmd << "ba8 -4 "<< rep;
TExternal_app stampa(cmd);
stampa.run();
}
void TTSRiclass_application::init_query_mode(TMask& m)
{
TRelation_application::init_query_mode(m);
m.show(-1, _use_pcn);
m.enable(-1, _use_pcn);
m.show(-20, !_use_pcn);
m.hide(-2);
m.disable(-2);
m.disable(-10);
}
void TTSRiclass_application::init_query_insert_mode(TMask& m)
{
TRelation_application::init_query_insert_mode(m);
m.hide(-1);
m.disable(-1);
m.show(-20, !_use_pcn);
m.show(-2, _use_pcn);
m.enable(-2, _use_pcn);
m.enable(-10, _use_pcn);
}
void TTSRiclass_application::init_modify_mode(TMask& m)
{
TRelation_application::init_modify_mode(m);
m.show(-1, _use_pcn);
m.show(-20, !_use_pcn);
m.disable(-1);
m.hide(-2);
m.disable(-10);
}
void TTSRiclass_application::init_insert_mode(TMask& m)
{
TRelation_application::init_insert_mode(m);
m.show(-1, _use_pcn);
m.show(-20, !_use_pcn);
m.disable(-1);
m.hide(-2);
m.disable(-2);
m.disable(-10);
}
bool TTSRiclass_application::user_create()
{
_rel = new TRelation(LF_RICLPDC);
_msk = new TTS_ricl_msk;
TConfig config(CONFIG_DITTA);
_use_pcn = config.get_bool("TSUSECMPCN");
_msk->show(-10, _use_pcn);
_msk->show(-20, !_use_pcn);
set_search_field(_use_pcn ? F_SOTTOCONTO : F_SOTTOCONTO1);
TFilename rep("tctsricl.rep");
if (rep.custom_path())
enable_menu_item(M_FILE_PRINT);
TString title;
_msk->get_caption(title);
set_title(title);
return true;
}
bool TTSRiclass_application::user_destroy()
{
if (_msk)
delete _msk;
if (_rel)
delete _rel;
return true;
}
int tc2800(int argc, char* argv[])
{
TTSRiclass_application a;
a.run(argc, argv, TR("Riclassificazione piano dei conti Team System"));
return 0;
}

1357
tc/tc2900.cpp Executable file

File diff suppressed because it is too large Load Diff

77
tc/tc2900a.uml Executable file
View File

@ -0,0 +1,77 @@
#include "tc2900a.h"
PAGE "Invio a TeamSystem da transfer AS400" -1 -1 78 20
GROUPBOX DLG_NULL 76 3
BEGIN
PROMPT 2 1 "@bDitta corrente"
END
NUMBER F_CODDITTA 5
BEGIN
PROMPT 3 2 "Codice "
FLAGS "FD"
USE LF_NDITTE
INPUT CODDITTA F_CODDITTA
OUTPUT F_RAGSOC RAGSOC
CHECKTYPE REQUIRED
END
STRING F_RAGSOC 50
BEGIN
PROMPT 23 2 ""
FLAGS "D"
END
GROUPBOX DLG_NULL 76 4
BEGIN
PROMPT 2 4 "Sorgente"
END
STRING F_INPATH 256 39
BEGIN
PROMPT 3 5 "Cartella "
DSELECT
CHECKTYPE REQUIRED
FIELD TSTAInPath
END
STRING F_INFILET 18
BEGIN
PROMPT 3 6 "File transfer "
FIELD TSTAInFile
END
GROUPBOX DLG_NULL 76 4
BEGIN
PROMPT 2 8 "Destinazione"
END
STRING F_PATH 256 39
BEGIN
PROMPT 3 9 "Cartella "
DSELECT
CHECKTYPE REQUIRED
FIELD TSTADestPath
END
STRING F_FILE 18
BEGIN
PROMPT 3 10 "File "
FIELD TSTADestFile
CHECKTYPE REQUIRED
END
BUTTON DLG_OK 10 2
BEGIN
PROMPT -12 -1 ""
END
BUTTON DLG_QUIT 10 2
BEGIN
PROMPT -22 -1 ""
END
ENDPAGE
ENDMASK

44
tc/tctbi11.uml Executable file
View File

@ -0,0 +1,44 @@
#include "tctbi11.h"
TOOLBAR "topbar" 0 0 0 2
#include <relapbar.h>
ENDPAGE
PAGE "IVA 11" 0 2 0 0
GROUPBOX DLG_NULL 78 3
BEGIN
PROMPT 1 1 "Codice IVA 11 TeamSystem"
END
NUMBER F_CODTAB 2
BEGIN
PROMPT 2 2 "Codice "
USE &T11
INPUT CODTAB F_CODTAB
DISPLAY "Codice" CODTAB
DISPLAY "Descrizione@60" S0
OUTPUT F_CODTAB CODTAB
OUTPUT F_DESC S0
CHECKTYPE REQUIRED
FIELD CODTAB
FLAGS "Z"
KEY 1
END
STRING F_DESC 50
BEGIN
PROMPT 2 5 "Descrizione "
USE &T11 KEY 2
INPUT S0 F_DESC
DISPLAY "Descrizione@60" S0
DISPLAY "Codice" CODTAB
COPY OUTPUT F_CODTAB
FIELD S0
KEY 2
CHECKTYPE REQUIRED
END
ENDPAGE
ENDMASK

45
tc/tctbica.uml Executable file
View File

@ -0,0 +1,45 @@
#include "tctbica.h"
TOOLBAR "topbar" 0 0 0 2
#include <relapbar.h>
ENDPAGE
PAGE "Causali" 0 2 0 0
GROUPBOX DLG_NULL 78 3
BEGIN
PROMPT 1 1 "Codice Causale TeamSystem"
END
NUMBER F_CODTAB 3
BEGIN
PROMPT 2 2 "Codice "
USE &TCA
INPUT CODTAB F_CODTAB
DISPLAY "Codice" CODTAB
DISPLAY "Descrizione@60" S0
OUTPUT F_CODTAB CODTAB
OUTPUT F_DESC S0
CHECKTYPE REQUIRED
FIELD CODTAB
FLAGS "Z"
VALIDATE FIXLEN_FUNC 3
KEY 1
END
STRING F_DESC 50
BEGIN
PROMPT 2 5 "Descrizione "
USE &TCA KEY 2
INPUT S0 F_DESC
DISPLAY "Descrizione@60" S0
DISPLAY "Codice" CODTAB
COPY OUTPUT F_CODTAB
FIELD S0
KEY 2
CHECKTYPE REQUIRED
END
ENDPAGE
ENDMASK

5
tc/tctbico.h Executable file
View File

@ -0,0 +1,5 @@
#define F_CODTAB 102
#define F_CODTAB1 103
#define F_CODTAB2 104
#define F_DESC 105
#define F_INDBIL 106

82
tc/tctbico.uml Executable file
View File

@ -0,0 +1,82 @@
#include "tctbico.h"
TOOLBAR "topbar" 0 0 0 2
#include <relapbar.h>
ENDPAGE
PAGE "Conti" 0 2 0 0
GROUPBOX DLG_NULL 78 3
BEGIN
PROMPT 1 1 "Codice Conto TeamSystem"
END
STRING F_CODTAB 2
BEGIN
PROMPT 2 2 "Gruppo "
USE &TCO
INPUT CODTAB[1,2] F_CODTAB
INPUT CODTAB[3,4] F_CODTAB1
INPUT CODTAB[5,7] F_CODTAB2
DISPLAY "Gruppo" CODTAB[1,2]
DISPLAY "Conto" CODTAB[3,4]
DISPLAY "Sottoconto" CODTAB[5,7]
DISPLAY "Descrizione@60" S0
OUTPUT F_CODTAB CODTAB[1,2]
OUTPUT F_CODTAB1 CODTAB[3,4]
OUTPUT F_CODTAB2 CODTAB[5,7]
OUTPUT F_DESC S0
CHECKTYPE REQUIRED
FIELD CODTAB[1,2]
VALIDATE FIXLEN_FUNC 2
KEY 1
END
STRING F_CODTAB1 2
BEGIN
PROMPT 20 2 "Conto "
COPY ALL F_CODTAB
CHECKTYPE SEARCH
FIELD CODTAB[3,4]
VALIDATE FIXLEN_FUNC 2
KEY 1
END
STRING F_CODTAB2 3
BEGIN
PROMPT 30 2 "Sottoconto "
COPY ALL F_CODTAB
CHECKTYPE SEARCH
FIELD CODTAB[5,7]
VALIDATE FIXLEN_FUNC 3
KEY 1
END
STRING F_DESC 50
BEGIN
PROMPT 2 5 "Descrizione "
USE &TCO KEY 2
INPUT S0 F_DESC
DISPLAY "Descrizione@60" S0
DISPLAY "Codice" CODTAB
COPY OUTPUT F_CODTAB
FIELD S0
KEY 2
CHECKTYPE REQUIRED
END
LIST F_INDBIL 15
BEGIN
PROMPT 2 7 "Indicatore di bilancio"
FIELD I0
ITEM "1|Attivita'"
ITEM "2|Passivita'"
ITEM "3|Costi"
ITEM "4|Ricavi"
ITEM "5|Conti d'ordine"
ITEM "9|Varie"
END
ENDPAGE
ENDMASK

44
tc/tctbiiva.uml Executable file
View File

@ -0,0 +1,44 @@
#include "tctbi11.h"
TOOLBAR "topbar" 0 0 0 2
#include <relapbar.h>
ENDPAGE
PAGE "Valute" 0 2 0 0
GROUPBOX DLG_NULL 78 3
BEGIN
PROMPT 1 1 "Codice Valuta TeamSystem"
END
STRING F_CODTAB 3
BEGIN
PROMPT 2 2 "Codice "
USE &TVA
INPUT CODTAB F_CODTAB
DISPLAY "Codice" CODTAB
DISPLAY "Descrizione@60" S0
OUTPUT F_CODTAB CODTAB
OUTPUT F_DESC S0
CHECKTYPE REQUIRED
FIELD CODTAB
VALIDATE FIXLEN_FUNC 3
KEY 1
END
STRING F_DESC 50
BEGIN
PROMPT 2 5 "Descrizione "
USE &TVA KEY 2
INPUT S0 F_DESC
DISPLAY "Descrizione@60" S0
DISPLAY "Codice" CODTAB
COPY OUTPUT F_CODTAB
FIELD S0
KEY 2
CHECKTYPE REQUIRED
END
ENDPAGE
ENDMASK

44
tc/tctbina.uml Executable file
View File

@ -0,0 +1,44 @@
#include "tctbipg.h"
TOOLBAR "topbar" 0 0 0 2
#include <relapbar.h>
ENDPAGE
PAGE "Nazioni" 0 2 0 0
GROUPBOX DLG_NULL 78 3
BEGIN
PROMPT 1 1 "Codice Nazione TeamSystem"
END
NUMBER F_CODTAB 4
BEGIN
PROMPT 2 2 "Codice "
USE &TNA
INPUT CODTAB F_CODTAB
DISPLAY "Codice" CODTAB
DISPLAY "Descrizione@60" S0
OUTPUT F_CODTAB CODTAB
OUTPUT F_DESC S0
CHECKTYPE REQUIRED
FIELD CODTAB
FLAGS "Z"
KEY 1
END
STRING F_DESC 50
BEGIN
PROMPT 2 5 "Descrizione "
USE &TNA KEY 2
INPUT S0 F_DESC
DISPLAY "Descrizione@60" S0
DISPLAY "Codice" CODTAB
COPY OUTPUT F_CODTAB
FIELD S0
KEY 2
CHECKTYPE REQUIRED
END
ENDPAGE
ENDMASK

44
tc/tctbipg.uml Executable file
View File

@ -0,0 +1,44 @@
#include "tctbipg.h"
TOOLBAR "topbar" 0 0 0 2
#include <relapbar.h>
ENDPAGE
PAGE "Condizioni di pagamento" 0 2 0 0
GROUPBOX DLG_NULL 78 3
BEGIN
PROMPT 1 1 "Codice Pagamento TeamSystem"
END
NUMBER F_CODTAB 4
BEGIN
PROMPT 2 2 "Codice "
USE &TPG
INPUT CODTAB F_CODTAB
DISPLAY "Codice" CODTAB
DISPLAY "Descrizione@60" S0
OUTPUT F_CODTAB CODTAB
OUTPUT F_DESC S0
CHECKTYPE REQUIRED
FIELD CODTAB
FLAGS "Z"
KEY 1
END
STRING F_DESC 50
BEGIN
PROMPT 2 5 "Descrizione "
USE &TPG KEY 2
INPUT S0 F_DESC
DISPLAY "Descrizione@60" S0
DISPLAY "Codice" CODTAB
COPY OUTPUT F_CODTAB
FIELD S0
KEY 2
CHECKTYPE REQUIRED
END
ENDPAGE
ENDMASK

56
tc/tctbire.uml Executable file
View File

@ -0,0 +1,56 @@
#include "tctbire.h"
TOOLBAR "topbar" 0 0 0 2
#include <relapbar.h>
ENDPAGE
PAGE "Registri" 0 2 0 0
GROUPBOX DLG_NULL 78 3
BEGIN
PROMPT 1 1 "Codice Registro TeamSystem"
END
LIST F_TIPO 1 13
BEGIN
PROMPT 2 2 "Tipo "
ITEM "A|Acquisti"
ITEM "C|Corrispettivi"
ITEM "V|Vendite"
FIELD CODTAB[1,1]
END
STRING F_CODTAB 2
BEGIN
PROMPT 25 2 "Codice "
USE &TRE
INPUT CODTAB[1,1] F_TIPO
INPUT CODTAB[2,3] F_CODTAB
DISPLAY "Tipo" CODTAB[1,1]
DISPLAY "Codice" CODTAB[2,3]
DISPLAY "Descrizione@60" S0
OUTPUT F_TIPO CODTAB[1,1]
OUTPUT F_CODTAB CODTAB[2,3]
OUTPUT F_DESC S0
CHECKTYPE REQUIRED
FIELD CODTAB[2,3]
VALIDATE FIXLEN_FUNC 2
KEY 1
END
STRING F_DESC 50
BEGIN
PROMPT 2 5 "Descrizione "
USE &TRE KEY 2
INPUT S0 F_DESC
DISPLAY "Descrizione@60" S0
DISPLAY "Codice" CODTAB
COPY OUTPUT F_CODTAB
FIELD S0
KEY 2
CHECKTYPE REQUIRED
END
ENDPAGE
ENDMASK