root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Patch level : nopatch

Browse Source 
Files correlati     : vearea.men ve4.exe
Ricompilazione Demo : [ ]
Commento            :
Aggiunto programma aggiornamento codici IVA


git-svn-id: svn://10.65.10.50/branches/R_10_00@22416 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
guy 2011-09-13 15:10:16 +00:00
parent f23edc9ee7
commit c70d24c617
9 changed files with 344 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
ve/ve4.cpp
View File

@ -9,12 +9,8 @@ int main(int argc, char** argv)
const int k = argc > 1 ? atoi(argv[1]+1) : 0; const int k = argc > 1 ? atoi(argv[1]+1) : 0;
switch(k) switch(k)
{ {
case 0: case 1: ve4200(argc, argv); break; // Aggiorna IVA
ve4100(argc, argv); default: ve4100(argc, argv); break; // Modifica Valori
break;
default:
error_box("Applicazione sconosciuta: %s %s.", argv[0], argv[1]);
break;
} }
return 0; return 0;
} }

1
ve/ve4.h
View File

@ -1 +1,2 @@
int ve4100(int argc, char* argv[]); int ve4100(int argc, char* argv[]);
int ve4200(int argc, char* argv[]);

88
ve/ve4100.cpp
View File

@ -38,10 +38,10 @@ protected:
int name2index(const char* name) const; int name2index(const char* name) const;
public: public:
static void load_table(bool force = FALSE); static void load_table(bool force = false);
static void set_relation(const TRelation* rel) { _rel = rel; load_table(); } static void set_relation(const TRelation* rel) { _rel = rel; load_table(); }
static void set_window(TViswin* win) { _win = win; } static void set_window(TViswin* win) { _win = win; }
static void reset_errors() { _errors = FALSE; } static void reset_errors() { _errors = false; }
static bool errors_found() { return _errors; } static bool errors_found() { return _errors; }
int str2file(const TString& s) const; int str2file(const TString& s) const;
@ -55,7 +55,7 @@ public:
TArray TTable_expression::_expr; TArray TTable_expression::_expr;
const TRelation* TTable_expression::_rel = NULL; const TRelation* TTable_expression::_rel = NULL;
TViswin* TTable_expression::_win = NULL; TViswin* TTable_expression::_win = NULL;
bool TTable_expression::_errors = FALSE; bool TTable_expression::_errors = false;
void TTable_expression::load_table(bool force) void TTable_expression::load_table(bool force)
{ {
@ -75,7 +75,7 @@ void TTable_expression::load_table(bool force)
const int index = _expr.add(o); const int index = _expr.add(o);
if (!te->set(e, t)) if (!te->set(e, t))
{ {
te->error_box("La funzione %s contiene un simbolo errato: %s", te->error_box(FR("La funzione %s contiene un simbolo errato: %s"),
(const char*)n, te->last_token()); (const char*)n, te->last_token());
te->set("", t); te->set("", t);
} }
@ -98,7 +98,7 @@ bool TTable_expression::print_error(const char* msg) const
} }
else else
::error_box("%s", msg); ::error_box("%s", msg);
return _errors = TRUE; return _errors = true;
} }
bool TTable_expression::error_box(const char* fmt, ...) const bool TTable_expression::error_box(const char* fmt, ...) const
@ -144,7 +144,7 @@ TRectype* TTable_expression::field2rec(TString& var) const
if (logicnum >= 0 && get_relation().exist(logicnum)) if (logicnum >= 0 && get_relation().exist(logicnum))
rec = &get_relation().curr(logicnum); rec = &get_relation().curr(logicnum);
else else
error_box("Il campo '%s' non appartiene alla relazione.", (const char*)var); error_box(FR("Il campo '%s' non appartiene alla relazione."), (const char*)var);
return rec; return rec;
} }
@ -158,7 +158,7 @@ const char* TTable_expression::get_field(const char* f) const
if (rec->exist(var)) if (rec->exist(var))
val = rec->get(var); val = rec->get(var);
else else
error_box("Il campo '%s' non appartiene al file %d.", (const char*)var, rec->num()); error_box(FR("Il campo '%s' non appartiene al file %d."), (const char*)var, rec->num());
} }
return val; return val;
} }
@ -217,10 +217,10 @@ int TTable_expression::parse_user_func(const char* name, int nparms) const
switch(index) switch(index)
{ {
case -1: case -1:
error_box("Funzione non riconosciuta: %s.", name); error_box(FR("Funzione non riconosciuta: %s."), name);
break; break;
case -2: case -2:
error_box("La funzione %s contiene un simbolo errato: %s.", error_box(FR("La funzione %s contiene un simbolo errato: %s."),
name, last_token()); name, last_token());
break; break;
default: default:
@ -329,13 +329,13 @@ TRicalcolo_mask::TRicalcolo_mask()
set_handler(F_KEY, key_handler); set_handler(F_KEY, key_handler);
set_handler(F_FILTER, filter_handler); set_handler(F_FILTER, filter_handler);
TSheet_field& fields = (TSheet_field&)field(F_FIELDS); TSheet_field& fields = sfield(F_FIELDS);
TMask& fsm = fields.sheet_mask(); TMask& fsm = fields.sheet_mask();
fsm.set_handler(F_FIELD, field_handler); fsm.set_handler(F_FIELD, field_handler);
fsm.set_handler(F_FROM, fromto_handler); fsm.set_handler(F_FROM, fromto_handler);
fsm.set_handler(F_TO, fromto_handler); fsm.set_handler(F_TO, fromto_handler);
TSheet_field& outputs = (TSheet_field&)field(F_OUTPUTS); TSheet_field& outputs = sfield(F_OUTPUTS);
TMask& osm = outputs.sheet_mask(); TMask& osm = outputs.sheet_mask();
osm.set_handler(F_FIELD, field_handler); osm.set_handler(F_FIELD, field_handler);
osm.set_handler(F_FORMULA, formula_handler); osm.set_handler(F_FORMULA, formula_handler);
@ -537,7 +537,7 @@ TCursor& TRicalcolo_mask::create_cursor()
TToken_string& key_des = get_key_expr(key); TToken_string& key_des = get_key_expr(key);
TSheet_field& fs = (TSheet_field&)field(F_FIELDS); TSheet_field& fs = sfield(F_FIELDS);
TString16 field; TString16 field;
TString val; TString val;
@ -558,13 +558,13 @@ TCursor& TRicalcolo_mask::create_cursor()
start.put(field, val); start.put(field, val);
else else
{ {
key_seq_from = FALSE; key_seq_from = false;
if (filter.not_empty()) filter << "&&"; if (filter.not_empty()) filter << "&&";
filter << '(' << field << ">=\"" << val << "\")"; filter << '(' << field << ">=\"" << val << "\")";
} }
} }
else else
key_seq_from = FALSE; key_seq_from = false;
val = row.get(); // Limite superiore val = row.get(); // Limite superiore
if (!val.blank()) if (!val.blank())
@ -573,16 +573,16 @@ TCursor& TRicalcolo_mask::create_cursor()
stop.put(field, val); stop.put(field, val);
else else
{ {
key_seq_to = FALSE; key_seq_to = false;
if (filter.not_empty()) filter << "&&"; if (filter.not_empty()) filter << "&&";
filter << '(' << field << "<=\"" << val << "\")"; filter << '(' << field << "<=\"" << val << "\")";
} }
} }
else else
key_seq_to = FALSE; key_seq_to = false;
} }
else else
key_seq_from = key_seq_to = FALSE; key_seq_from = key_seq_to = false;
} }
if (key <= 0) if (key <= 0)
@ -611,11 +611,11 @@ bool TRicalcolo_mask::file_handler(TMask_field& f, KEY k)
TToken_string values(80); TToken_string values(80);
TString16 tmp; TString16 tmp;
codes.add(0); codes.add(0);
values.add("Nessuna"); values.add(TR("Nessuna"));
for (int k = 1; k <= keys; k++) for (int k = 1; k <= keys; k++)
{ {
codes.add(k); codes.add(k);
tmp.format("Chiave %d", k); tmp.format(FR("Chiave %d"), k);
values.add(tmp); values.add(tmp);
} }
@ -623,7 +623,7 @@ bool TRicalcolo_mask::file_handler(TMask_field& f, KEY k)
lk.replace_items(codes, values); lk.replace_items(codes, values);
} }
} }
return TRUE; return true;
} }
bool TRicalcolo_mask::key_handler(TMask_field& f, KEY k) bool TRicalcolo_mask::key_handler(TMask_field& f, KEY k)
@ -631,7 +631,7 @@ bool TRicalcolo_mask::key_handler(TMask_field& f, KEY k)
if (k == K_SPACE) if (k == K_SPACE)
{ {
TRicalcolo_mask& m = (TRicalcolo_mask&)f.mask(); TRicalcolo_mask& m = (TRicalcolo_mask&)f.mask();
TSheet_field& sheet = (TSheet_field&)m.field(F_FIELDS); TSheet_field& sheet = m.sfield(F_FIELDS);
if (m.is_running() || sheet.items() == 0) if (m.is_running() || sheet.items() == 0)
{ {
const int cur_key = atoi(f.get()); const int cur_key = atoi(f.get());
@ -670,7 +670,7 @@ bool TRicalcolo_mask::key_handler(TMask_field& f, KEY k)
sheet.force_update(); sheet.force_update();
} }
} }
return TRUE; return true;
} }
bool TRicalcolo_mask::test_formula(TMask_field& f) const bool TRicalcolo_mask::test_formula(TMask_field& f) const
@ -702,7 +702,7 @@ bool TRicalcolo_mask::test_formula(TMask_field& f) const
} }
} }
else else
ok = FALSE; ok = false;
if (!ok) if (!ok)
{ {
f.error_box("Il campo '%s' non esiste!", (const char*)expr.varname(v)); f.error_box("Il campo '%s' non esiste!", (const char*)expr.varname(v));
@ -717,7 +717,7 @@ bool TRicalcolo_mask::test_formula(TMask_field& f) const
bool TRicalcolo_mask::filter_handler(TMask_field& f, KEY k) bool TRicalcolo_mask::filter_handler(TMask_field& f, KEY k)
{ {
bool ok = TRUE; bool ok = true;
if (f.to_check(k)) if (f.to_check(k))
{ {
TRicalcolo_mask& m = (TRicalcolo_mask&)f.mask(); TRicalcolo_mask& m = (TRicalcolo_mask&)f.mask();
@ -728,7 +728,7 @@ bool TRicalcolo_mask::filter_handler(TMask_field& f, KEY k)
bool TRicalcolo_mask::field_handler(TMask_field& f, KEY k) bool TRicalcolo_mask::field_handler(TMask_field& f, KEY k)
{ {
bool ok = TRUE; bool ok = true;
switch (k) switch (k)
{ {
case K_TAB: case K_TAB:
@ -777,7 +777,7 @@ HIDDEN void swap_tokens(TToken_string& str, int p1, int p2)
bool TRicalcolo_mask::fromto_handler(TMask_field& f, KEY k) bool TRicalcolo_mask::fromto_handler(TMask_field& f, KEY k)
{ {
bool ok = TRUE; bool ok = true;
if (f.to_check(k)) if (f.to_check(k))
{ {
const TMask& m = f.mask(); const TMask& m = f.mask();
@ -817,7 +817,7 @@ bool TRicalcolo_mask::fromto_handler(TMask_field& f, KEY k)
fields.add(tmp); fields.add(tmp);
int lun = rec.length(tmp); int lun = rec.length(tmp);
bool right = FALSE; bool right = false;
switch(rec.type(tmp)) switch(rec.type(tmp))
{ {
case _alfafld: case _alfafld:
@ -831,7 +831,7 @@ bool TRicalcolo_mask::fromto_handler(TMask_field& f, KEY k)
lun = 10; lun = 10;
break; break;
default: default:
right = TRUE; right = true;
break; break;
} }
tmp.lower(); tmp[0] = toupper(tmp[0]); tmp.lower(); tmp[0] = toupper(tmp[0]);
@ -899,7 +899,7 @@ bool TRicalcolo_mask::fromto_handler(TMask_field& f, KEY k)
bool TRicalcolo_mask::formula_handler(TMask_field& f, KEY k) bool TRicalcolo_mask::formula_handler(TMask_field& f, KEY k)
{ {
bool ok = TRUE; bool ok = true;
if (f.to_check(k)) if (f.to_check(k))
{ {
TRicalcolo_mask& m = (TRicalcolo_mask&)f.mask().get_sheet()->mask(); TRicalcolo_mask& m = (TRicalcolo_mask&)f.mask().get_sheet()->mask();
@ -931,12 +931,12 @@ bool TRicalcolo_mask::elabora()
TString val(80); // Valore di campo TString val(80); // Valore di campo
TString line(128); // Linea di testo TString line(128); // Linea di testo
TIndwin iw(48, "Inizializzazione ...", TRUE, FALSE, 48); TIndwin iw(48, "Inizializzazione ...", true, false, 48);
begin_wait(); begin_wait();
TCursor& cur = create_cursor(); // Crea e filtra il cursore principale TCursor& cur = create_cursor(); // Crea e filtra il cursore principale
TSheet_field& osf = (TSheet_field&)field(F_OUTPUTS); TSheet_field& osf = sfield(F_OUTPUTS);
TArray expr; TArray expr;
for (int r = 0; r < osf.items(); r++) for (int r = 0; r < osf.items(); r++)
{ {
@ -964,13 +964,13 @@ bool TRicalcolo_mask::elabora()
} }
TToken_string& key_expr = get_key_expr(cur.key()); TToken_string& key_expr = get_key_expr(cur.key());
TViswin vw(NULL, "Ricalcolo valori", FALSE, TRUE, FALSE, 0, 0, 0, 0, FALSE); TViswin vw(NULL, TR("Ricalcolo valori"), false, true, false, 0, 0, 0, 0, false);
iw.close_modal(); iw.close_modal();
end_wait(); end_wait();
if (iw.iscancelled()) if (iw.iscancelled())
return FALSE; return false;
TTable_expression::set_relation(cur.relation()); TTable_expression::set_relation(cur.relation());
TTable_expression::set_window(&vw); TTable_expression::set_window(&vw);
@ -979,7 +979,7 @@ bool TRicalcolo_mask::elabora()
vw.maximize(); vw.maximize();
vw.open_modal(); vw.open_modal();
bool ok = TRUE; bool ok = true;
const TRecnotype items = cur.items(); const TRecnotype items = cur.items();
cur.freeze(); cur.freeze();
@ -1010,7 +1010,7 @@ bool TRicalcolo_mask::elabora()
val = e; val = e;
if (e.errors_found()) if (e.errors_found())
ok = FALSE; ok = false;
else else
cur.curr().put(var, val); cur.curr().put(var, val);
@ -1038,9 +1038,9 @@ bool TRicalcolo_mask::elabora()
{ {
TTextfile& txt = vw.text(); TTextfile& txt = vw.text();
TProgind piw(txt.lines(), "Aggiornamento archivio", FALSE, TRUE, 48); TProgind piw(txt.lines(), "Aggiornamento archivio", false, true, 48);
bool do_rewrite = FALSE; bool do_rewrite = false;
long pos = 0; long pos = 0;
cur = 0L; cur = 0L;
for (long r = 0; r < txt.lines(); r++) for (long r = 0; r < txt.lines(); r++)
@ -1052,7 +1052,7 @@ bool TRicalcolo_mask::elabora()
if (do_rewrite) if (do_rewrite)
{ {
rewrite_cursor(cur); rewrite_cursor(cur);
do_rewrite = FALSE; do_rewrite = false;
} }
cur = pos-1; // pos a video = 1 -> pos cursore = pos-1 = 0) cur = pos-1; // pos a video = 1 -> pos cursore = pos-1 = 0)
} }
@ -1065,7 +1065,7 @@ bool TRicalcolo_mask::elabora()
{ {
val = equal+2; val = equal+2;
cur.curr().put(var, val); cur.curr().put(var, val);
do_rewrite = TRUE; do_rewrite = true;
} }
} }
} }
@ -1074,9 +1074,9 @@ bool TRicalcolo_mask::elabora()
rewrite_cursor(cur); rewrite_cursor(cur);
} }
} }
cur.freeze(FALSE); cur.freeze(false);
return TRUE; return true;
} }
@ -1093,7 +1093,7 @@ protected:
public: public:
// @cmember Disabilita la verifica del modulo in chiave // @cmember Disabilita la verifica del modulo in chiave
virtual bool check_autorization() const virtual bool check_autorization() const
{return FALSE;} {return false;}
TRicalcola_application() { } TRicalcola_application() { }
virtual ~TRicalcola_application() { } virtual ~TRicalcola_application() { }
}; };
@ -1101,7 +1101,7 @@ public:
bool TRicalcola_application::create() bool TRicalcola_application::create()
{ {
dispatch_e_menu(MENU_ITEM_ID(1)); dispatch_e_menu(MENU_ITEM_ID(1));
return TRUE; return true;
} }
bool TRicalcola_application::menu(MENU_TAG) bool TRicalcola_application::menu(MENU_TAG)
@ -1112,7 +1112,7 @@ bool TRicalcola_application::menu(MENU_TAG)
m.elabora(); m.elabora();
m.close(); m.close();
return FALSE; return false;
} }
int ve4100(int argc, char* argv[]) int ve4100(int argc, char* argv[])

185
ve/ve4200.cpp Normal file
View File

@ -0,0 +1,185 @@
#include <applicat.h>
#include <automask.h>
#include <dongle.h>
#include <lffiles.h>
#include <progind.h>
#include <recset.h>
#include <relation.h>
#include "ve4.h"
#include "ve4200a.h"
#include "condv.h"
#include "rcondv.h"
#include "doc.h"
#include "rdoc.h"
#include "../mg/anamag.h"
class TAggiornaIVA_msk : public TAutomask
{
private:
bool anteprima(TISAM_recordset& recset) const;
bool aggiorna(TISAM_recordset& recset) const;
protected:
virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public:
bool elabora(int logicnum) const;
TAggiornaIVA_msk() : TAutomask("ve4200a") {}
};
bool TAggiornaIVA_msk::anteprima(TISAM_recordset& recset) const
{
const TRecnotype tot = recset.items();
if (tot == 0)
return warning_box(TR("Non ci sono record da elaborare"));
TCursor* cur = recset.cursor();
TLocalisamfile& arc = cur->file();
const char *fields = RDOC_CODIVA;
const char* head = "IVA@4";
switch(arc.num())
{
case LF_RIGHEDOC:
fields = RDOC_ANNO"|"RDOC_CODNUM"|"RDOC_NDOC"|33->"DOC_DATADOC"|33->"DOC_STATO"|"RDOC_CODART"|"RDOC_CODIVA;
head = "Anno|Num.|Doc.@7|Data@10|Stato|Articolo@20|IVA@4";
break;
case LF_ANAMAG:
fields = ANAMAG_CODART"|"ANAMAG_DESCR"|"ANAMAG_CODIVA;
head = "Articolo@20|Descrizione@50|IVA@4";
break;
case LF_RCONDV:
fields = RCONDV_TIPO"|"RCONDV_CODCF"|"RCONDV_COD"|52->"CONDV_VALFIN"|"RCONDV_CODRIGA"|"RCONDV_CODIVA;
head = "Tipo|Cliente|Cod.|Data Fine@10|Articolo@20|IVA@4";
break;
default: break;
}
TCursor_sheet sheet(cur, fields, arc.description(), head, 0, 1);
return sheet.run() == K_ENTER;
}
bool TAggiornaIVA_msk::aggiorna(TISAM_recordset& recset) const
{
const TRecnotype tot = recset.items();
if (tot == 0 || !yesno_box(FR("Si conferma l'aggiornamento di %ld record?"), tot))
return false;
TLocalisamfile& arc = recset.cursor()->file();
TRectype& rec = arc.curr();
const TString& newiva = get(F_NEWCODIVA);
TProgind pi(tot, TR("Aggiornamento codice IVA"));
for (bool ok = recset.move_first(); ok; ok = recset.move_next())
{
if (!pi.addstatus(1))
return false;
rec.put("CODIVA", newiva);
if (arc.rewrite() != NOERR)
return cantwrite_box(arc.name());
}
return true;
}
bool TAggiornaIVA_msk::elabora(int logicnum) const
{
const TString& oldiva = get(F_OLDCODIVA);
const TDate dal = get(F_DAL);
const TDate al(31,12,dal.year());
const TString& codnum = get(F_CODNUM);
const TString& stato = get(F_STATO);
TString query;
query << "USE " << logicnum << " SELECT (CODIVA==\"" << oldiva << "\")";
switch (logicnum)
{
case LF_RIGHEDOC:
{
query << "&&(BETWEEN(33->DATADOC," << dal.date2ansi() << "," << al.date2ansi() << "))"
<< "&&(33->STATO==\"" << stato << "\")";
query << "\nJOIN DOC INTO PROVV=PROVV ANNO=ANNO CODNUM==CODNUM NDOC==NDOC";
TString range;
range << "PROVV=D ANNO=" << dal.year() << " CODNUM=" << codnum;
query << "\nFROM " << range << "\nTO " << range;
}
break;
case LF_RCONDV:
{
query << "&&(STR((ANSI(52->VALFIN)==0)||(ANSI(52->VALFIN)>=" << dal.date2ansi() <<")))";
query << "\nJOIN CONDV INTO TIPO=TIPO CATVEN==CATVEN TIPOCF=TIPOCF CODCF==CODCF COD==COD";
}
break;
default:
break;
}
TISAM_recordset recset(query);
if (!anteprima(recset))
return false;
return aggiorna(recset);
}
bool TAggiornaIVA_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
return true;
}
class TAggiornaIVA_app : public TSkeleton_application
{
protected:
virtual bool create();
virtual void main_loop();
};
bool TAggiornaIVA_app::create()
{
Tdninst dninst;
bool good = dninst.find_serno();
if (good)
{
TString msg;
good = dninst.test_cmdline("MustCall", false, msg) == 0;
}
if (!good)
return error_box(FR("Chiave %d non abilitata all'utilizzo di questa procedura"), dongle().number());
return TSkeleton_application::create();
}
void TAggiornaIVA_app::main_loop()
{
TAggiornaIVA_msk m;
while (m.run() == K_ENTER)
{
const int file = m.get_int(F_FILE);
switch (file)
{
case LF_DOC:
case LF_RIGHEDOC:
m.elabora(LF_RIGHEDOC);
break;
case LF_ANAMAG:
m.elabora(LF_ANAMAG);
break;
case LF_CONDV:
case LF_RCONDV:
m.elabora(LF_RCONDV);
break;
default: break;
}
}
}
int ve4200(int argc, char* argv[])
{
TAggiornaIVA_app r;
r.run(argc, argv, TR("Aggiornamento codici IVA"));
return 0;
}

7
ve/ve4200a.h Normal file
View File

@ -0,0 +1,7 @@
#define F_FILE 101
#define F_DAL 102
#define F_CODNUM 103
#define F_STATO 104
#define F_OLDCODIVA 111
#define F_NEWCODIVA 112

95
ve/ve4200a.uml Normal file
View File

@ -0,0 +1,95 @@
#include "ve4200a.h"
PAGE "Aggiornamento codice IVA" -1 -1 37 13
RADIOBUTTON F_FILE 2 34
BEGIN
PROMPT 1 0 "@bArchivio da elaborare"
ITEM "47|Anagrafica di magazzino"
ITEM "53|Condizioni di vendita"
ITEM "33|Documenti"
END
GROUPBOX DLG_NULL 34 5
BEGIN
PROMPT 1 5 "@bParametri di selezione"
END
DATE F_DAL
BEGIN
PROMPT 2 6 "Data iniziale "
CHEKCTYPE REQUIRED
FLAGS "A"
END
STRING F_CODNUM 4
BEGIN
PROMPT 2 7 "Numerazione "
FLAGS "U"
USE %NUM
INPUT CODTAB F_CODNUM
DISPLAY "Codice" CODTAB
DISPLAY "Descrizione@60" S0
OUTPUT F_CODNUM CODTAB
CHECKTYPE REQUIRED
END
STRING F_STATO 1
BEGIN
PROMPT 2 8 "Stato "
FLAGS "U"
USE %STD
INPUT CODTAB F_STATO
DISPLAY "Codice" CODTAB
DISPLAY "Descrizione@60" S0
OUTPUT F_STATO CODTAB
CHECKTYPE REQUIRED
END
GROUPBOX DLG_NULL 34 4
BEGIN
PROMPT 1 10 "@bParametri di elaborazione"
END
STRING F_OLDCODIVA 4
BEGIN
PROMPT 2 11 "Vecchio codice IVA "
FLAGS "U"
USE %IVA
INPUT CODTAB F_OLDCODIVA
DISPLAY "Codice" CODTAB
DISPLAY "Descrizione@60" S0
OUTPUT F_OLDCODIVA CODTAB
CHECKTYPE REQUIRED
END
STRING F_NEWCODIVA 4
BEGIN
PROMPT 2 12 "Nuovo codice IVA "
FLAGS "U"
COPY USE F_OLDCODIVA
INPUT CODTAB F_NEWCODIVA
COPY DISPLAY F_OLDCODIVA
OUTPUT F_NEWCODIVA CODTAB
CHECKTYPE REQUIRED
STR_EXPR #F_NECODIVA!=#F_OLDCODIVA
WARNING "Inserire un codice diverso dal precedente"
END
STRING DLG_PROFILE 256 24
BEGIN
PROMPT 1 -1 "Profilo "
PSELECT
FLAGS "H"
END
ENDPAGE
TOOLBAR "" 0 0 0 2
#include <elabar.h>
ENDPAGE
ENDMASK

2
ve/ve8.cpp
View File

@ -5,13 +5,11 @@
int main( int argc, char** argv ) int main( int argc, char** argv )
{ {
const int r = (argc > 1) ? argv[1][1]-'0' : -1; const int r = (argc > 1) ? argv[1][1]-'0' : -1;
switch (r) switch (r)
{ {
case 0: case 0:
default: default:
ve8100(argc, argv); break; // lista ritenute fiscali ve8100(argc, argv); break; // lista ritenute fiscali
} }
exit(0);
return 0; return 0;
} }

21
ve/ve8100.cpp
View File

@ -2,21 +2,16 @@
#include <automask.h> #include <automask.h>
#include <execp.h> #include <execp.h>
#include <progind.h> #include <progind.h>
#include <recset.h>
#include <relation.h>
#include <reprint.h>
#include <tabutil.h> #include <tabutil.h>
#include "../cg/cg2103.h"
#include "../gv/gvlib.h"
#include "velib.h"
#include "velib07.h" #include "velib07.h"
#include <nditte.h>
#include "ve8.h" #include "ve8.h"
#include "ve8100a.h" #include "ve8100a.h"
#include "../gv/gvlib.h"
#include <nditte.h>
//////////////////////////////////////////////////////// ////////////////////////////////////////////////////////
// MASCHERA // MASCHERA
//////////////////////////////////////////////////////// ////////////////////////////////////////////////////////
@ -131,23 +126,19 @@ void TListaRitFisc::main_loop()
break; break;
case K_ENTER: case K_ENTER:
{ {
//report e book dei report
TDocument_report rep; TDocument_report rep;
rep.load("ve8100a"); rep.load("ve8100a");
TRecordset * r = rep.recordset(); TRecordset * r = rep.recordset();
if (r != NULL) if (r != NULL)
{ {
TVariant var; TVariant var = m.get(F_NUMINI);
var = m.get(F_NUMINI);
r->set_var("#DANUM", var); r->set_var("#DANUM", var);
var = m.get(F_NUMFIN); var = m.get(F_NUMFIN);
r->set_var("#ANUM", var); r->set_var("#ANUM", var);
var = m.get(F_CODNUM); var = m.get(F_CODNUM);
r->set_var("#NUM", var); r->set_var("#NUM", var);
} }
TReport_book book; rep.print_or_preview(); //stampa il book dei report
book.add(rep);
book.print_or_preview(); //stampa il book dei report
} }
} }
} }

6
ve/vearea.men
View File

@ -220,8 +220,10 @@ Picture = <ve00>
Module = 0 Module = 0
Flags = "" Flags = ""
Item_01 = "Modifica valori", "ve4 -0", "F" Item_01 = "Modifica valori", "ve4 -0", "F"
Item_02 = "Invio", [ACQVEN_025] Item_02 = "Aggiornamento Codici IVA", "ve4 -1", "FP"
Item_03 = "Ricezione", [ACQVEN_026] Item_03 = "Invio", [ACQVEN_025]
Item_04 = "Ricezione", [ACQVEN_026]
[ACQVEN_022] [ACQVEN_022]
Caption = "Configurazione magazzino" Caption = "Configurazione magazzino"