2092 lines
63 KiB
C++
Executable File
2092 lines
63 KiB
C++
Executable File
#include "velib.h"
|
||
#include "ve2400.h"
|
||
#include "ve2401.h"
|
||
|
||
#include "../ca/calib01.h"
|
||
|
||
#include <defmask.h>
|
||
#include <modaut.h>
|
||
#include <tabutil.h>
|
||
|
||
//---------------------------------------------------
|
||
// MASCHERA ANAGRAFICA MAGAZZINO
|
||
//---------------------------------------------------
|
||
class TMask_anamag: public TMask
|
||
{
|
||
TRelation* _rel; // relazione principale
|
||
|
||
TCodgiac_livelli* livelli_giac;// oggetto handler per i livelli di giacenza
|
||
TCodart_livelli* livelli_art;// oggetto handler per i livelli di anagraficca
|
||
int last_annogiac, last_annosto;
|
||
int _disabled_user_page;
|
||
|
||
int _type_cod, _altype_cod;
|
||
TString4 _ean8_pref;
|
||
TString8 _ean13_pref;
|
||
bool _ean8_cin;
|
||
TString16 _generated_code;
|
||
|
||
TMagazzini *_magazzini;
|
||
|
||
static bool handle_codice(TMask_field &, KEY); // handler del campo codice articolo
|
||
static bool handle_anno(TMask_field &, KEY); // handler del campo anno delle giacenze
|
||
static bool handle_stoanno(TMask_field &, KEY); // handler del campo anno delle giacenze
|
||
static bool handle_stoanno_row(TMask_field &, KEY); // handler del campo anno delle giacenze sulle righe
|
||
static bool handle_sheet_um(TMask_field &, KEY); // handler dello sheet delle unità di misura
|
||
static bool notify_sheet_um(TSheet_field & s, int r, KEY k); // notify dello sheet delle unità di misura
|
||
static bool handle_sheet_deslin(TMask_field &, KEY); // handler dello sheet delle descrizioni in lingua
|
||
static bool handle_sheet_cod(TMask_field &, KEY); // handler dello sheet dei codici alternativi
|
||
static bool notify_sheet_cod(TSheet_field & s, int r, KEY k); // notify dello sheet delle unità di misura
|
||
static bool handle_codcorr(TMask_field &, KEY); // handler dello sheet dei codici alternativi
|
||
static bool notify_sheet_giac(TSheet_field & s, int r, KEY k); // notify delle giacenze
|
||
static bool handle_sheetgiac(TMask_field &, KEY); // handler dello sheet giacenze
|
||
static bool notify_sheet_sto(TSheet_field & s, int r, KEY k); // notify dello storico
|
||
static bool handle_sheetstomag(TMask_field &, KEY); // handler dello sheet storico giacenze
|
||
static bool handle_sheet_um_um(TMask_field &, KEY); // handler del campo UM dello sheet delle unità di misura
|
||
static bool handle_sheet_um_price(TMask_field &, KEY); // handler del campo PREZZO e PREZZO_LORDO dello sheet delle unità di misura
|
||
static bool handle_sheet_giac_codmag(TMask_field &, KEY); // handler
|
||
static bool handle_sheet_giac_valgiac(TMask_field &, KEY); // handler
|
||
static bool handle_sheet_stomag_stoval(TMask_field &, KEY); // handler
|
||
static bool handle_autoinsert_livgiac(TMask_field &, KEY); // handler del campo
|
||
|
||
static void sheetgiac_get(TSheet_field &fld_righe, int item);
|
||
static void sheetgiac_put(TSheet_field &fld_righe, int item);
|
||
static void sheetsto_get(TSheet_field &fld_righe, int item);
|
||
static void sheetsto_put(TSheet_field &fld_righe, int item);
|
||
|
||
void clear_info_sto();
|
||
bool info_sto_dirty();
|
||
int add_totali_storico(TString &codmag);
|
||
bool remove_totali_storico(TString & codmag);
|
||
void update_totali_storico(TString & codmag);
|
||
bool check_totali_storico();
|
||
void create_user_fields();
|
||
|
||
public:
|
||
bool generate_code(int _type = 0, const char * codart = NULL);
|
||
void update_ordc_ordf();
|
||
void set_parametered_fields();
|
||
void ricalcola_giacenze();
|
||
void disable_user_page() { disable_page(_disabled_user_page);}
|
||
TCodart_livelli * get_livelli_art() const { return livelli_art; }
|
||
|
||
const TString& generated_code() const { return _generated_code; }
|
||
const TString& um_principale() const;
|
||
void set_um_principale(const char* ump);
|
||
TMagazzini& magazzini() { return *_magazzini; }
|
||
|
||
TMask_anamag(TRelation * rel);
|
||
virtual ~TMask_anamag();
|
||
};
|
||
|
||
//--------------------------------------------
|
||
// APPLICAZIONE
|
||
//--------------------------------------------
|
||
class TAnagrafica_magazzino : public TRelation_application
|
||
{
|
||
TMask_anamag *_msk; // maschera principale
|
||
TRelation *_rel; // relazione principale di un solo file (anagrafiche di magazzino)
|
||
|
||
protected:
|
||
virtual bool user_create();
|
||
virtual bool user_destroy();
|
||
virtual TMask *get_mask(int) { return _msk; }
|
||
virtual bool changing_mask(int) { return false; }
|
||
virtual void init_query_mode(TMask&);
|
||
virtual void init_insert_mode(TMask&);
|
||
virtual void init_modify_mode(TMask&);
|
||
|
||
virtual void on_firm_change();
|
||
bool search_on_file(const char * key, int file, int nkey, const char * field);
|
||
virtual bool protected_record(TRectype&);
|
||
|
||
virtual int read(TMask& m);
|
||
void load_um(TMask& m);
|
||
virtual bool remove();
|
||
virtual int write(const TMask& m);
|
||
virtual int rewrite(const TMask& m);
|
||
|
||
virtual void ini2sheet(TConfig& ini, TSheet_field &sheet);
|
||
virtual void sheet2ini(TSheet_field &sheet,TConfig& ini);
|
||
|
||
static bool handle_copia(TMask_field &, KEY); // handler della copia articolo
|
||
|
||
public:
|
||
virtual TRelation *get_relation() const { return _rel; }
|
||
// @cmember Disabilita la verifica del modulo : essendo una anagrafica, va sempre abilitata
|
||
virtual bool check_autorization() const { return false; }
|
||
TAnagrafica_magazzino() { _rel = NULL; _msk = NULL;}
|
||
virtual ~TAnagrafica_magazzino() {}
|
||
};
|
||
|
||
inline TAnagrafica_magazzino& app() { return (TAnagrafica_magazzino&) main_app(); }
|
||
|
||
//-------------------------------------------------------------------------------------------------
|
||
// METODI DELLA MASCHERA
|
||
//-------------------------------------------------------------------------------------------------
|
||
//------------------------------------------
|
||
//gestione codice articolo multilivello
|
||
//------------------------------------------
|
||
static bool handle_subcodice(TMask_field &fld, KEY k)
|
||
{
|
||
TMask &mask=fld.mask();
|
||
if (k == K_TAB && (fld.focusdirty()||!mask.is_running())) //c'e' qualcosa nel campo
|
||
{
|
||
//quale e' l'ultimo campo valido per codart in multilevel?
|
||
short id_last = fld.dlg();
|
||
while (id_last <= F_LIVART9 && mask.id2pos(id_last+1) > 0)
|
||
id_last++;
|
||
|
||
if (fld.empty())
|
||
{
|
||
//gira su tutti i campi di livart esistenti e successivi al livello corrente
|
||
for(short id = fld.dlg()+1; id <= id_last; id++)
|
||
{
|
||
mask.set(id, "");
|
||
mask.disable(id);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
const int pos = mask.id2pos(fld.dlg()+1);
|
||
if (pos > 0)
|
||
{
|
||
TMask_field& next_fld = mask.fld(pos);
|
||
next_fld.enable();
|
||
}
|
||
}
|
||
//riempie in automatico il campo codice complessivo
|
||
TString80 stringone;
|
||
bool completo = true;
|
||
for(short id = F_LIVART1; id <= id_last; id++)
|
||
{
|
||
const TString& val = mask.get(id);
|
||
if (val.blank())
|
||
{
|
||
completo = false;
|
||
break;
|
||
}
|
||
stringone << val;
|
||
}
|
||
|
||
mask.set(F_CODART, stringone, fld.dlg()==id_last ? 0x3 : 0x0);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
void create_browse1(TEdit_field& kfld, int level, short key_id, short des_id, const TCodart_livelli &cal, const bool chktyp)
|
||
{
|
||
TFilename tmp; tmp.temp();
|
||
ofstream out(tmp);
|
||
|
||
out << "USE GCA" << endl; //usa la tabella dei livelli articolo
|
||
|
||
const short id = key_id + level - 1;
|
||
const TString& prompt = cal.name(level);
|
||
const TString& picture = cal.picture(level);
|
||
out << "IN CODTAB[1,1] \"" << level << "\"" << endl;
|
||
out << "IN CODTAB[2,0] " << id << endl;
|
||
out << "DI \"" << prompt;
|
||
const int length = cal.code_length(level);
|
||
if (length > prompt.len())
|
||
out << '@' << length;
|
||
out << "\" CODTAB[2,0]" << endl;
|
||
out << "DI \"" << TR("Descrizione") << "@50\" S0" << endl;
|
||
out << "OU " << id << " CODTAB[2,0]" << endl;
|
||
out << "OU " << (des_id + level -1) << " S0" << endl;
|
||
|
||
if (chktyp)
|
||
{
|
||
if (level == 1)
|
||
out << "CH RE" << endl;
|
||
else
|
||
out << "CH NO" << endl;
|
||
}
|
||
out << "EN" << endl;
|
||
out.close();
|
||
|
||
TScanner scan(tmp);
|
||
while (scan.pop() != "EN")
|
||
kfld.parse_item(scan);
|
||
|
||
xvt_fsys_remove_file(tmp);
|
||
}
|
||
|
||
void create_browse2(TEdit_field& kfld, int level, short key_id, short des_id, const TCodart_livelli &cal, const bool chktyp)
|
||
{
|
||
TFilename tmp; tmp.temp();
|
||
ofstream out(tmp);
|
||
|
||
out << "USE GCA KE 2 SELECT CODTAB[1,1]=='" << level << "'" << endl; //cerca per descrizione
|
||
|
||
const short id = des_id + level - 1;
|
||
out << "IN S0 " << id << endl;
|
||
out << "DI \"" << TR("Descrizione") << "@50\" S0" << endl;
|
||
|
||
const TString& prompt = cal.name(level);
|
||
out << "DI \"" << prompt;
|
||
const int length = cal.code_length(level);
|
||
if (length > prompt.len())
|
||
out << '@' << length;
|
||
out << "\" CODTAB[2,0]" << endl;
|
||
|
||
out << "CO OU " << (key_id + level -1) << endl;
|
||
if (chktyp)
|
||
out << "CH NO" << endl;
|
||
out << "EN" << endl;
|
||
out.close();
|
||
|
||
TScanner scan(tmp);
|
||
while (scan.pop() != "EN")
|
||
kfld.parse_item(scan);
|
||
|
||
xvt_fsys_remove_file(tmp);
|
||
}
|
||
|
||
int create_fields(TMask& msk, int x, int y, short key_id, short des_id, const TCodart_livelli &cal, const bool chktyp)
|
||
{
|
||
const int last_level = cal.last_level();
|
||
|
||
int tab0 = x;
|
||
int i;
|
||
for (i = 1; i <= last_level; i++) //cicla su tutti i livelli del codart abilitati
|
||
{
|
||
// codice livello articolo
|
||
const short kid = key_id+i-1;
|
||
const TString& picture = cal.picture(i);
|
||
|
||
TString4 flags = "BU";
|
||
if (picture[0] == '0')
|
||
flags << 'Z';
|
||
|
||
TEdit_field& kfld = msk.add_string(kid, 0, "", tab0, y, picture.len(), flags);
|
||
kfld.set_key(1);
|
||
create_browse1(kfld, i, key_id, des_id, cal, chktyp);
|
||
|
||
kfld.set_handler(handle_subcodice);
|
||
tab0 += picture.len()+3;
|
||
}
|
||
for (i = 1; i <= last_level; i++)
|
||
{
|
||
// descrizione livello articolo
|
||
const short did = des_id+i-1;
|
||
TEdit_field& dfld = msk.add_string(did, 0, "", 200, y, 50, "", 50);
|
||
dfld.set_key(1);
|
||
create_browse2(dfld, i, key_id, des_id, cal, chktyp);
|
||
}
|
||
|
||
return cal.last_level();
|
||
}
|
||
|
||
void TMask_anamag::set_parametered_fields()
|
||
{
|
||
// abilitazioni parametriche
|
||
|
||
if (livelli_giac)
|
||
delete livelli_giac;
|
||
if (livelli_art)
|
||
delete livelli_art;
|
||
if (_magazzini)
|
||
delete _magazzini;
|
||
|
||
_magazzini = new TMagazzini;
|
||
|
||
// imposta il puntatore al gestore livelli giacenze
|
||
livelli_giac= new TCodgiac_livelli();
|
||
livelli_art= new TCodart_livelli();
|
||
// imposta il valore dell'anno per le giacenze
|
||
last_annogiac=-1;
|
||
last_annosto=-1;
|
||
|
||
// Abilita la pagina delle giacenze
|
||
const bool gestmag = app().has_module(MGAUT) && magazzini().gestmag();
|
||
|
||
if (gestmag)
|
||
{
|
||
// sheet giacenze
|
||
set_handler(F_ANNO, handle_anno );
|
||
set_handler(F_SHEETGIAC, handle_sheetgiac);
|
||
|
||
TSheet_field& sgiac = sfield(F_SHEETGIAC);
|
||
sgiac.set_userget(sheetgiac_get);
|
||
sgiac.set_userput(sheetgiac_put);
|
||
sgiac.sheet_mask().set_handler(F_CODMAG, handle_sheet_giac_codmag);
|
||
sgiac.sheet_mask().set_handler(F_VALGIAC, handle_sheet_giac_valgiac);
|
||
// sheet storico
|
||
set_handler(F_SHEETSTOMAG, handle_sheetstomag);
|
||
sfield(F_SHEETSTOMAG).set_notify(notify_sheet_sto);
|
||
sfield(F_SHEETSTOMAG).set_userget(sheetsto_get);
|
||
sfield(F_SHEETSTOMAG).set_userput(sheetsto_put);
|
||
TMask& stomask = sfield(F_SHEETSTOMAG).sheet_mask();
|
||
|
||
stomask.set_handler(F_STOVAL, handle_sheet_stomag_stoval);
|
||
stomask.set_handler(F_STOANNOES, handle_stoanno_row);
|
||
|
||
set_handler(F_STOANNO, handle_stoanno);
|
||
}
|
||
|
||
// setta i campi della maschera per la pagina giacenze
|
||
TSheet_field &fld_stomag = sfield(F_SHEETSTOMAG);
|
||
TSheet_field &fld_giac = sfield(F_SHEETGIAC);
|
||
fld_giac.set_notify(notify_sheet_giac);
|
||
TSheet_field &fld_cod = sfield(F_SHEETCOD);
|
||
|
||
// disabilita le colonne quando non sono utilizzati i livelli di giacenza
|
||
for (int i=0; i < 4; i++)
|
||
{
|
||
livelli_giac->set_sheetcolumn(fld_giac,F_LIV1+i,i+1);
|
||
livelli_giac->set_sheetcolumn(fld_cod,FS_LIV1+i,i+1);
|
||
if (livelli_giac->autoinsert(i+1))
|
||
{
|
||
// codice autoinseribile
|
||
TMask_field & campo_liv = fld_giac.sheet_mask().field(F_LIV1+i);
|
||
|
||
campo_liv.check_type(CHECK_SEARCH);
|
||
campo_liv.set_handler(gestmag ? handle_autoinsert_livgiac : NULL);
|
||
|
||
TMask_field & campo_liv_cod = fld_cod.sheet_mask().field(FS_LIV1+i);
|
||
|
||
campo_liv_cod.check_type(CHECK_SEARCH);
|
||
}
|
||
}
|
||
|
||
/*
|
||
// disabilita la colonna numero distinte
|
||
if (FALSE)
|
||
{
|
||
fld_giac.delete_column(fld_giac.cid2index(F_NDIST));
|
||
fld_giac.sheet_mask().field(F_NDIST).enable(FALSE);
|
||
}
|
||
*/
|
||
// abilita la gestione delle ubicazioni (manuale/su tabella)
|
||
const bool ubi = gestmag && magazzini().gestubi_man();
|
||
fld_giac.sheet_mask().field(F_UBICAZ).show(!ubi);
|
||
fld_giac.sheet_mask().field(F_UBICAZD).show(!ubi);
|
||
fld_giac.sheet_mask().field(F_UBICAZ2).show(ubi);
|
||
|
||
// abilita la gestione del monomagazzino
|
||
const bool mm = gestmag && magazzini().gestmultimag();
|
||
fld_giac.sheet_mask().field(F_DESMAG).enable(mm);
|
||
fld_giac.enable_column(fld_giac.cid2index(F_CODMAG),mm);
|
||
fld_giac.enable_column(fld_giac.cid2index(F_CODDEP),gestmag && magazzini().gestdep());
|
||
fld_stomag.enable_column(fld_stomag.cid2index(F_STOCODMAG),mm);
|
||
|
||
enable_page(PAGE_GIACENZE,gestmag);
|
||
enable_page(PAGE_STORICO,gestmag);
|
||
|
||
/* Obsoleto
|
||
// abilita la visualizzazione dei campi per la vendita al dettaglio
|
||
const bool dettaglio = app().has_module(VDAUT);
|
||
show(-G_VD, dettaglio);
|
||
*/
|
||
|
||
// abilita la visualizzazione dei campi distinti per i livelli articolo
|
||
set_handler(F_CODART, handle_codice);
|
||
}
|
||
|
||
void TMask_anamag::create_user_fields()
|
||
{
|
||
TConfig c(CONFIG_DITTA, "ve");
|
||
|
||
_type_cod = c.get_int("GEN_EAN");
|
||
_altype_cod = c.get_int("ALT_EAN");
|
||
_ean8_pref = c.get("EAN8");
|
||
_ean13_pref = c.get("EAN13");
|
||
_ean8_cin = c.get_bool("EAN8CIN");
|
||
_ean13_pref = c.get("EAN13");
|
||
|
||
TString80 prompt;
|
||
int page = PAGE_USER;
|
||
int row = 4;
|
||
int col = 0;
|
||
int user_fields = 0;
|
||
|
||
//si suppone 20 campi user; sarebbe meglio definire una costante
|
||
for (int i = 1; i <= 20; i++)
|
||
{
|
||
if (c.get_bool("CHK_USER", "ve", i))
|
||
{
|
||
TEditable_field * f = NULL;
|
||
prompt = c.get("PROMPT_USER", "ve", i);
|
||
//se il prompt fosse più lungo di 18 caratteri...
|
||
prompt.rpad(18);
|
||
prompt.cut(18);
|
||
|
||
const char type = c.get_char("TYPE_USER", "ve", i);
|
||
|
||
//visto che lo switch funziona con i char...
|
||
switch (type)
|
||
{
|
||
case 'S':
|
||
f = &add_string(F_USER1 + i - 1, page, prompt, col, row, c.get_int("LEN_USER", "ve", i));
|
||
break;
|
||
case 'N':
|
||
f = &add_number(F_USER1 + i - 1, page, prompt, col, row, c.get_int("LEN_USER", "ve", i));
|
||
((TReal_field *) f)->set_decimals(c.get_int("DEC_USER", "ve", i));
|
||
break;
|
||
case 'D':
|
||
f = &add_date(F_USER1 + i - 1, page, prompt, col, row);
|
||
break;
|
||
case 'I':
|
||
f = &add_currency(F_USER1 + i - 1, page, prompt, col, row, c.get_int("LEN_USER", "ve", i));
|
||
break;
|
||
case 'X':
|
||
f = &add_boolean(F_USER1 + i - 1, page, prompt, col, row);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
//se esiste il campo utente...
|
||
if (f != NULL)
|
||
{
|
||
TString8 u; u.format("USER%d", i);
|
||
f->set_field(u);
|
||
user_fields++;
|
||
row ++;
|
||
if (row > 19)
|
||
{
|
||
col = 40;
|
||
row = 4;
|
||
}
|
||
}
|
||
} //if(c.get_bool...
|
||
} //for(int i...
|
||
|
||
if (user_fields == 0 && !ini_get_bool(CONFIG_DITTA, "ve", "Magic"))
|
||
_disabled_user_page = PAGE_USER;
|
||
}
|
||
|
||
const TString& TMask_anamag::um_principale() const
|
||
{ return edit_mode() ? get(F_UMPRINCIPALE) : EMPTY_STRING; }
|
||
|
||
void TMask_anamag::set_um_principale(const char* ump)
|
||
{
|
||
set(F_UMPRINCIPALE, ump);
|
||
set(F_UMPRINCIPALE2, ump);
|
||
}
|
||
|
||
|
||
// costruttore della maschera anagrafica di magazzino
|
||
TMask_anamag::TMask_anamag(TRelation * rel) : TMask("ve2400")
|
||
{
|
||
_rel=rel;
|
||
|
||
// sheet unità di misura
|
||
set_handler(F_SHEETUM, handle_sheet_um);
|
||
TSheet_field &f= sfield(F_SHEETUM);
|
||
f.set_notify(notify_sheet_um);
|
||
TMask &fm= f.sheet_mask();
|
||
fm.set_handler(FS_CODUM, handle_sheet_um_um);
|
||
fm.set_handler(FS_PREZZO, handle_sheet_um_price);
|
||
fm.set_handler(FS_PREZZO_LORDO, handle_sheet_um_price);
|
||
|
||
TRecord_array* um = new TRecord_array(LF_UMART, "NRIGA");
|
||
f.set_lines_record(*um);
|
||
|
||
// sheet descrizioni in lingua
|
||
set_handler(F_SHEETDESLIN, handle_sheet_deslin);
|
||
// sheet codici corrispondenti
|
||
set_handler(F_SHEETCOD, handle_sheet_cod);
|
||
TSheet_field &fc= sfield(F_SHEETCOD);
|
||
TMask &fmc = fc.sheet_mask();
|
||
fmc.set_handler(FS_CODARTALT, handle_codcorr);
|
||
|
||
livelli_giac = NULL;
|
||
livelli_art = NULL;
|
||
_magazzini = NULL;
|
||
|
||
set_parametered_fields();
|
||
|
||
if (!ca_config().get_bool("UsePdcc")) // Creo campi analitici solo se uso vero piano conti analitico
|
||
{
|
||
ca_create_fields(*this, 6, LF_PCONANA, 1, 9, F_CONTOPCIA, F_DESCRCONTOPCIA, 0, ANAMAG_CONTOINDA);
|
||
ca_create_fields(*this, 6, LF_PCONANA, 1,15, F_CONTOPCIV, F_DESCRCONTOPCIV, 0, ANAMAG_CONTOINDV);
|
||
}
|
||
|
||
create_user_fields();
|
||
|
||
if (livelli_art->enabled())
|
||
{
|
||
create_fields(*this, 1, 1, F_LIVART1, F_DESLIVART1, *livelli_art, true);
|
||
first_focus(F_LIVART1);
|
||
}
|
||
else
|
||
{
|
||
if (advanced_codart_enabled())
|
||
{
|
||
TButton_field& bu = add_button(F_ADVANCED, 0, PR("Codice guidato"), 1, 1, 20);
|
||
bu.set_handler(advanced_codart_handler);
|
||
}
|
||
if (!app().has_module(LVAUT, CHK_DONGLE))
|
||
hide(-G_LV);
|
||
TConfig c(CONFIG_DITTA, "ve");
|
||
|
||
field(F_CODIVA).check_type(c.get_bool("IVA_OBBL", "ve") && app().has_module(VEAUT, CHK_DONGLE) ? CHECK_REQUIRED : CHECK_NORMAL);
|
||
|
||
if (c.get_bool("Magic", "ve"))
|
||
{
|
||
show(F_ECMAGIC1);
|
||
show(F_ECMAGIC2);
|
||
show(F_ECMAGIC3);
|
||
show(F_ECMAGIC4);
|
||
show(F_ECMAGIC_DESCR);
|
||
enable(F_ECMAGIC1);
|
||
enable(F_ECMAGIC2);
|
||
enable(F_ECMAGIC3);
|
||
enable(F_ECMAGIC4);
|
||
enable(F_ECMAGIC_DESCR);
|
||
}
|
||
|
||
first_focus(F_CODART);
|
||
}
|
||
}
|
||
|
||
void TMask_anamag::sheetsto_put(TSheet_field &sheet_sto, int item)
|
||
{
|
||
if (item>1) return;
|
||
TMask_anamag & m=(TMask_anamag & )sheet_sto.mask();
|
||
TRectype & first_rec=sheet_sto.record()->row(1,TRUE);
|
||
first_rec.put(STOMAG_ULTCOS1,m.get_real(F_STOULTCOS1 ));
|
||
first_rec.put(STOMAG_ULTCOS2,m.get_real(F_STOULTCOS2 ));
|
||
first_rec.put(STOMAG_COSTSTD,m.get_real(F_STOCOSTOSTD ));
|
||
first_rec.put(STOMAG_COSTOMEDIO,m.get_real(F_STOCOSTOMEDIO ));
|
||
first_rec.put(STOMAG_CATVEN,m.get(F_STOCATVEN ));
|
||
first_rec.put(STOMAG_CODLISTINO,m.get(F_STOCODLIST));
|
||
first_rec.put(STOMAG_PRZLIST,m.get(F_STOPREZZOLIST ));
|
||
}
|
||
|
||
void TMask_anamag::sheetsto_get(TSheet_field &sheet_sto, int item)
|
||
{
|
||
TMask_anamag & m=(TMask_anamag &) sheet_sto.mask();
|
||
|
||
if (item>1) return;
|
||
TRectype & first_rec=sheet_sto.record()->row(1,TRUE);
|
||
m.set(F_STOULTCOS1, first_rec.get_real(STOMAG_ULTCOS1));
|
||
m.set(F_STOULTCOS2, first_rec.get_real(STOMAG_ULTCOS2 ));
|
||
m.set(F_STOCOSTOSTD, first_rec.get_real( STOMAG_COSTSTD ));
|
||
m.set(F_STOCOSTOMEDIO, first_rec.get_real(STOMAG_COSTOMEDIO));
|
||
m.set(F_STOCATVEN , first_rec.get(STOMAG_CATVEN));
|
||
m.set(F_STOCODLIST , first_rec.get(STOMAG_CODLISTINO));
|
||
m.set(F_STOPREZZOLIST ,first_rec.get(STOMAG_PRZLIST));
|
||
}
|
||
|
||
bool TMask_anamag::info_sto_dirty()
|
||
{
|
||
return
|
||
field(F_STOULTCOS1).focusdirty() ||
|
||
field(F_STOULTCOS2).focusdirty() ||
|
||
field(F_STOCOSTOSTD).focusdirty() ||
|
||
field(F_STOCOSTOMEDIO).focusdirty()||
|
||
field(F_STOCATVEN ).focusdirty()||
|
||
field(F_STOCODLIST).focusdirty()||
|
||
field(F_STOPREZZOLIST).focusdirty();
|
||
}
|
||
|
||
|
||
void TMask_anamag::clear_info_sto()
|
||
{
|
||
reset(F_STOULTCOS1);
|
||
reset(F_STOULTCOS2);
|
||
reset(F_STOCOSTOSTD);
|
||
reset(F_STOCOSTOMEDIO);
|
||
reset(F_STOCATVEN );
|
||
reset(F_STOCODLIST);
|
||
reset(F_STOPREZZOLIST);
|
||
}
|
||
|
||
|
||
TMask_anamag::~TMask_anamag()
|
||
{
|
||
if (livelli_art)
|
||
delete livelli_art;
|
||
if (livelli_giac)
|
||
delete livelli_giac;
|
||
if (_magazzini)
|
||
delete _magazzini;
|
||
}
|
||
|
||
|
||
bool TMask_anamag::handle_autoinsert_livgiac(TMask_field &fld, KEY k)
|
||
{
|
||
if (k == K_TAB && fld.focusdirty() && !fld.empty())
|
||
{
|
||
TMask_anamag & mask=(TMask_anamag &) fld.mask().get_sheet()->mask();
|
||
const int levnum=fld.dlg()-F_LIV1+1;
|
||
return mask.livelli_giac->autoinsert(levnum, fld);
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
// HANDLER DEL CODICE: controlla la corrispondenza al formato previsto
|
||
bool TMask_anamag::generate_code(int type, const char * codart)
|
||
{
|
||
_generated_code.cut(0);
|
||
if (type <= 0)
|
||
type = _type_cod;
|
||
//if (type <= 0)
|
||
// return false;
|
||
|
||
TString cod(20);
|
||
long progr = 0;
|
||
|
||
if (type == 8)
|
||
{
|
||
if (_ean8_pref.empty())
|
||
return false;
|
||
cod = _ean8_pref;
|
||
cod << "999";
|
||
if (_type_cod != 0)
|
||
{
|
||
TLocalisamfile anamag(LF_ANAMAG);
|
||
anamag.put(ANAMAG_CODART, cod);
|
||
|
||
if (anamag.read(_isgteq) != _isemptyfile)
|
||
{
|
||
cod = anamag.get(ANAMAG_CODART);
|
||
|
||
if (_ean8_pref < cod.left(4))
|
||
{
|
||
anamag.prev();
|
||
cod = anamag.get(ANAMAG_CODART);
|
||
}
|
||
if (_ean8_pref == cod.left(4))
|
||
progr = atol(cod.right(3));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
TLocalisamfile codcorr(LF_CODCORR);
|
||
codcorr.setkey(2);
|
||
codcorr.put(CODCORR_CODARTALT, cod);
|
||
|
||
if (codcorr.read(_isgteq) != _isemptyfile)
|
||
{
|
||
cod = codcorr.get(CODCORR_CODARTALT);
|
||
|
||
if (_ean8_pref < cod.left(4))
|
||
{
|
||
codcorr.prev();
|
||
cod = codcorr.get(CODCORR_CODARTALT);
|
||
}
|
||
if (_ean8_pref == cod.left(4))
|
||
{
|
||
if (_ean8_cin)
|
||
progr = atol(cod.mid(4, 3));
|
||
else
|
||
progr = atol(cod.right(3));
|
||
}
|
||
}
|
||
}
|
||
progr++;
|
||
if (progr < 1000)
|
||
{
|
||
_generated_code.format("%4s%03ld", (const char*)_ean8_pref, progr);
|
||
if (_ean8_cin)
|
||
{
|
||
int icin = (_generated_code[6]+_generated_code[4]+_generated_code[2]+_generated_code[0] - 4*'0')*3;
|
||
icin += _generated_code[5]+_generated_code[3]+_generated_code[1] - 3*'0';
|
||
const char cin = '0' + (10-(icin % 10))%10;
|
||
_generated_code << cin;
|
||
}
|
||
}
|
||
else
|
||
return error_box(FR("Sono gia' stati generati 1000 codici sul prefisso %s"), (const char*)_ean8_pref);
|
||
}
|
||
else
|
||
if (_ean13_pref.full())
|
||
{
|
||
cod = _ean13_pref;
|
||
cod << "999999";
|
||
if (_type_cod != 0)
|
||
{
|
||
TLocalisamfile anamag(LF_ANAMAG);
|
||
anamag.put(ANAMAG_CODART, cod);
|
||
|
||
if (anamag.read(_isgteq) != _isemptyfile)
|
||
{
|
||
cod = anamag.get(ANAMAG_CODART);
|
||
|
||
if (_ean13_pref < cod.left(6))
|
||
{
|
||
anamag.prev();
|
||
cod = anamag.get(ANAMAG_CODART);
|
||
}
|
||
if (_ean13_pref == cod.left(6))
|
||
progr = atol(cod.right(6));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
TLocalisamfile codcorr(LF_CODCORR);
|
||
codcorr.setkey(2);
|
||
codcorr.put(CODCORR_CODARTALT, cod);
|
||
|
||
if (codcorr.read(_isgteq) != _isemptyfile)
|
||
{
|
||
cod = codcorr.get(CODCORR_CODARTALT);
|
||
|
||
if (_ean13_pref < cod.left(6))
|
||
{
|
||
codcorr.prev();
|
||
cod = codcorr.get(CODCORR_CODARTALT);
|
||
}
|
||
if (_ean13_pref == cod.left(6))
|
||
progr = atol(cod.right(6));
|
||
}
|
||
}
|
||
progr++;
|
||
_generated_code.format("%s%06ld", (const char *)_ean13_pref, progr);
|
||
}
|
||
if (_generated_code.blank() && codart != NULL)
|
||
{
|
||
TString scod(codart);
|
||
cod = scod;
|
||
const int len = scod.len();
|
||
cod << "999999";
|
||
TLocalisamfile anamag(LF_ANAMAG);
|
||
anamag.put(ANAMAG_CODART, cod);
|
||
TString code;
|
||
|
||
if (anamag.read(_isgteq) != _isemptyfile)
|
||
{
|
||
code = anamag.get(ANAMAG_CODART);
|
||
|
||
if (cod < code.left(len) || (scod == code.left(len) && !isdigit(code[len])))
|
||
{
|
||
anamag.prev();
|
||
code = anamag.get(ANAMAG_CODART);
|
||
}
|
||
if (scod == code.left(len))
|
||
progr = atol(code.mid(len));
|
||
else
|
||
return false;
|
||
}
|
||
progr++;
|
||
TString fmt;
|
||
fmt.format("%%s%%0%dld", code.len() - len);
|
||
_generated_code.format(fmt, (const char *)scod, progr);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool TMask_anamag::handle_codice(TMask_field &fld, KEY k)
|
||
{
|
||
TMask_anamag &mask=(TMask_anamag &)fld.mask();
|
||
|
||
if (k == K_TAB && !fld.get().blank() && mask.livelli_art->enabled())
|
||
{
|
||
TString80 codepart;
|
||
|
||
int l;
|
||
//ciclo di riempimento dei sottocodici articolo nella maschera
|
||
for (l=1; l <= mask.livelli_art->last_level(); l++)
|
||
{
|
||
const TString pezzo_di_codice = mask.livelli_art->unpack_grpcode(fld.get(),l);
|
||
mask.set(F_LIVART1+l-1, pezzo_di_codice); //scrive nei campi del codice a livelli i pezzi
|
||
//del codart completo
|
||
}
|
||
//ciclo di controllo dei sottocodici (devono esistere nella tabella GCA, tutti tranne l'ultimo)
|
||
for (l=1; l<mask.livelli_art->last_level(); l++)
|
||
{
|
||
const TString pezzo_di_codice = mask.livelli_art->unpack_grpcode(fld.get(),l);
|
||
mask.set(F_LIVART1+l-1, pezzo_di_codice);
|
||
codepart.cut(0) << l << pezzo_di_codice;
|
||
if (cache().get("GCA", codepart).empty())
|
||
{
|
||
fld.error_box("'%s' non appartiene a '%s'",(const char *)codepart.mid(1),(const char *)mask.livelli_art->name(l));
|
||
return(FALSE);
|
||
}
|
||
}
|
||
codepart=mask.livelli_art->unpack_grpcode(fld.get(),mask.livelli_art->last_level());
|
||
if (codepart.blank())
|
||
{
|
||
/* Controllo casuale che va migliorato per gestire i sottocodici opzionali
|
||
fld.error_box("Il codice articolo non può essere vuoto");
|
||
return(FALSE);
|
||
*/
|
||
return true;
|
||
}
|
||
|
||
if (!mask.livelli_art->fit_to_format(codepart))
|
||
{
|
||
fld.error_box("Il codice articolo non corrisponde al formato previsto \n('%s' ?? '%s')",(const char *)codepart,(const char *)mask.livelli_art->code_format());
|
||
return(FALSE);
|
||
}
|
||
}
|
||
if (k == K_F8)
|
||
{
|
||
if (mask.generate_code(0, ((TEditable_field&)fld).get_window_data()))
|
||
{
|
||
fld.set(mask.generated_code());
|
||
mask.stop_run(K_INS);
|
||
}
|
||
}
|
||
return(TRUE);
|
||
}
|
||
|
||
bool TMask_anamag::handle_anno(TMask_field &fld, KEY k)
|
||
{
|
||
if (k == K_TAB)
|
||
{
|
||
TMask_anamag &mask=(TMask_anamag &)fld.mask();
|
||
TSheet_field& fld_giac = mask.sfield(F_SHEETGIAC);
|
||
|
||
if (mask.get(F_ANNO).empty())
|
||
{
|
||
mask.set(F_ANNORIF, esercizi().last()) ;
|
||
mask.set(F_ANNO, mask.get(F_ANNORIF));
|
||
}
|
||
if (mask.last_annogiac>0 && mask.last_annogiac!=fld.mask().get_int(F_ANNO))
|
||
{
|
||
if (fld_giac.dirty() && handle_sheetgiac(fld_giac,K_ENTER))
|
||
{
|
||
if (fld.yesno_box("Salvare le righe di giacenza per l'anno %d",mask.last_annogiac ))
|
||
{
|
||
fld_giac.autosave(*mask._rel);
|
||
fld_giac.record()->rewrite();
|
||
}
|
||
}
|
||
mask.field(F_ANNORIF).set(fld.get());
|
||
// rilegge le giacenze relative a quell'anno ed aggiorna il layout
|
||
fld_giac.record()->read(*fld_giac.putkey(*mask._rel));
|
||
fld_giac.autoload(*mask._rel);
|
||
fld_giac.force_update();
|
||
|
||
mask.update_ordc_ordf(); //chiamata del metodo successivo
|
||
}
|
||
mask.last_annogiac=mask.get_int(F_ANNO);
|
||
}
|
||
return(TRUE);
|
||
}
|
||
|
||
|
||
void TMask_anamag::update_ordc_ordf()
|
||
{
|
||
real ordc,ordf;
|
||
const TDate oggi(TODAY);
|
||
int es_corr = esercizi().date2esc(oggi); // setta l'esercizio corrente (data come intero)
|
||
int es_pred = esercizi().pred(es_corr); // " " precedente "
|
||
|
||
TRecord_array arr(LF_MAG, MAG_NRIGA);
|
||
TRectype rec(LF_MAG); // crea un record vuoto di LF_MAG
|
||
|
||
for (int j = 0; j < 2; j++)
|
||
{
|
||
const int anno = j != 0 ? es_pred : es_corr;
|
||
if (anno == get_int(F_ANNORIF))
|
||
{
|
||
TSheet_field &fld_giac = sfield(F_SHEETGIAC);
|
||
const int pos_ordc = fld_giac.cid2index(F_ORDC);
|
||
const int pos_ordf = fld_giac.cid2index(F_ORDF);
|
||
|
||
FOR_EACH_SHEET_ROW(fld_giac,i,row)
|
||
{
|
||
ordc += real (row->get(pos_ordc));
|
||
ordf += real (row->get(pos_ordf));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
rec.put(MAG_ANNOES, anno); // riempio il record campione
|
||
rec.put(MAG_CODART, get(F_CODART));
|
||
arr.read(rec);
|
||
for (int i = arr.last_row(); i > 0; i = arr.pred_row(i))
|
||
{
|
||
ordc += arr[i].get_real(MAG_ORDC);
|
||
ordf += arr[i].get_real(MAG_ORDF);
|
||
}
|
||
}
|
||
}
|
||
|
||
set(F_TOT_ORD_CLI, ordc);
|
||
set(F_TOT_ORD_FOR, ordf);
|
||
}
|
||
|
||
bool TMask_anamag::handle_stoanno(TMask_field &fld, KEY k)
|
||
{
|
||
static bool in_handler = FALSE;
|
||
if (k == K_TAB && fld.focusdirty() && !in_handler)
|
||
{
|
||
in_handler = TRUE;
|
||
TMask_anamag &mask=(TMask_anamag &)fld.mask();
|
||
TSheet_field &fld_stomag= mask.sfield(F_SHEETSTOMAG);
|
||
|
||
if (mask.last_annosto>0 && mask.last_annosto!=fld.mask().get_int(F_STOANNO))
|
||
{
|
||
if ((fld_stomag.dirty() || mask.info_sto_dirty()) &&
|
||
fld_stomag.items()>0 )
|
||
{
|
||
if (fld.yesno_box("Salvare lo storico per l'anno %d",mask.last_annosto) &&
|
||
handle_sheetstomag(fld_stomag,K_ENTER))
|
||
{
|
||
fld_stomag.autosave(*mask._rel);
|
||
fld_stomag.record()->write(TRUE);
|
||
}
|
||
}
|
||
}
|
||
// rilegge lo storico relativo a quell'anno ed aggiorna il layout
|
||
mask.field(F_STOANNORIF).set(fld.get());
|
||
mask.clear_info_sto();
|
||
fld_stomag.record()->read(*fld_stomag.putkey(*mask._rel));
|
||
fld_stomag.autoload(*mask._rel);
|
||
handle_sheetstomag(fld_stomag,K_SPACE);
|
||
fld_stomag.force_update();
|
||
mask.last_annosto=mask.get_int(F_STOANNORIF);
|
||
if (fld.focusdirty())
|
||
esercizi().update();
|
||
in_handler = FALSE;
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
bool TMask_anamag::handle_stoanno_row(TMask_field &fld, KEY k)
|
||
{
|
||
if (k == K_TAB && fld.focusdirty())
|
||
esercizi().update();
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
bool TMask_anamag::handle_sheet_um(TMask_field &fld, KEY k)
|
||
{
|
||
TSheet_field &f= (TSheet_field &)fld; // typecast del campo al suo sheet corrispondente
|
||
TMask_anamag & m= (TMask_anamag &)(fld.mask());
|
||
if (k == K_ENTER && !m.query_mode())
|
||
{
|
||
const int items = f.items();
|
||
if (items > 0)
|
||
{
|
||
const char *codum=f.cell(0,f.cid2index(FS_CODUM));
|
||
if (*codum<=' ')
|
||
return error_box("La prima unità di misura deve essere specificata");
|
||
TAssoc_array v; // istanzia l'hash table per il controllo di univocità
|
||
for (int i= 0; i<items; i++)
|
||
{
|
||
const TString4 um = f.cell(i,f.cid2index(FS_CODUM));
|
||
// aggiunge all'hash table l'elemento della riga corrente e controlla che non esista già
|
||
if (v.add(um))
|
||
return error_box("Le unità di misura devono essere diverse tra loro");
|
||
}
|
||
}
|
||
|
||
if (m.edit_mode())
|
||
{
|
||
const TString4 old_um = m.um_principale();
|
||
const TString4 new_um = f.cell(0,f.cid2index(FS_CODUM));
|
||
if (old_um.full() && old_um != new_um)
|
||
{
|
||
int i;
|
||
for (i = 0; i<items; i++)
|
||
{
|
||
if (old_um==f.cell(i,f.cid2index(FS_CODUM)))
|
||
break;
|
||
}
|
||
if (i>=items)
|
||
return error_box(FR("L'unità di misura '%s' deve essere presente in tabella"),(const char*)m.um_principale());
|
||
}
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
bool TMask_anamag::notify_sheet_um(TSheet_field &fld_um, int r, KEY k)
|
||
{
|
||
if (k == K_TAB)
|
||
{
|
||
fld_um.sheet_mask().enable(DLG_DELREC, r > 0);
|
||
if (r == 0)
|
||
{
|
||
if (fld_um.items() == 0)
|
||
fld_um.row(0) = " |1"; // aggiunge una riga allo sheet
|
||
else
|
||
fld_um.row(0).add("1",fld_um.cid2index(FS_FCUM)); // forza la prima unita' di misura a 1
|
||
fld_um.disable_cell(0, fld_um.cid2index(FS_FCUM)); // mette in sola lettura il secondo campo della prima riga (il fattore di conversione della prima U.M. è fisso a 1)
|
||
fld_um.force_update(0);
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
bool TMask_anamag::handle_sheet_deslin(TMask_field &fld, KEY k)
|
||
{
|
||
if (k == K_ENTER)
|
||
{
|
||
TSheet_field &f= (TSheet_field &)fld; // typecast del campo al suo sheet corrispondente
|
||
const int items = f.items();
|
||
|
||
if (items > 0)
|
||
{
|
||
TAssoc_array v; // istanzia l'hash table per il controllo di univocità
|
||
|
||
for (int i= 0; i < items; i++)
|
||
{
|
||
const TString16 codlin(f.cell(i,0));
|
||
|
||
if (codlin.blank())
|
||
return error_box("I codici lingua non possono essere vuoti");
|
||
if (v.add(codlin))
|
||
return error_box("I codici lingua devono essere diversi tra loro"); // aggiunge all'hash table l'elemento 0 (primo) della riga corrente e controlla che non esista già
|
||
}
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool TMask_anamag::handle_sheet_cod(TMask_field &fld, KEY k)
|
||
{
|
||
if (k==K_ENTER)
|
||
{
|
||
TSheet_field &f= (TSheet_field &)fld; // typecast del campo al suo sheet corrispondente
|
||
const int items = f.items();
|
||
|
||
if (items > 0)
|
||
{
|
||
TMask &m= fld.mask(); // prende la maschere d'origine del campo
|
||
TAssoc_array v; // istanzia l'hash table per il controllo di univocità
|
||
|
||
TString80 codart;
|
||
for (int i= 0; i< items; i++)
|
||
{
|
||
codart = f.cell(i,0);
|
||
if (codart.blank())
|
||
return error_box("I codici alternativi non possono essere vuoti");
|
||
if (codart == m.get(F_CODART))
|
||
return error_box("I codici alternativi devono essere diversi tra loro e dal codice dell'articolo"); // aggiunge all'hash table l'elemento 0 (primo) della riga corrente e controlla che non esista già
|
||
if (v.add(codart) && !yesno_box("I codici alternativi devono essere diversi tra loro, si desidera continuare ?"))
|
||
return false; // aggiunge all'hash table l'elemento 0 (primo) della riga corrente e controlla che non esista già
|
||
}
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool TMask_anamag::handle_codcorr(TMask_field &fld, KEY k)
|
||
{
|
||
if (k == K_F8)
|
||
{
|
||
TMask &m = fld.mask(); // prende la maschere d'origine del campo
|
||
TMask_anamag & mask = (TMask_anamag &) m.get_sheet()->mask();
|
||
char val = fld.mask().get(FS_TIPO)[0];
|
||
int type = val == '8' ? 8 : (val == '1' ? 13 : 0);
|
||
|
||
if (type > 0 && mask.generate_code(type))
|
||
fld.set(mask.generated_code());
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool TMask_anamag::notify_sheet_cod(TSheet_field & s, int r, KEY k)
|
||
{
|
||
switch (k)
|
||
{
|
||
case K_CTRL + K_INS:
|
||
{
|
||
TMask_anamag& mask = (TMask_anamag&)s.mask();
|
||
|
||
if (s.items() == 1) // Genero la prima riga in base ai parametri dei codici alternativi
|
||
{
|
||
if (mask._altype_cod > 0 && mask.generate_code(mask._altype_cod))
|
||
{
|
||
TToken_string& row = s.row(0);
|
||
row = mask.generated_code();
|
||
row.add(mask._altype_cod);
|
||
}
|
||
}
|
||
TToken_string & rw = s.row(r);
|
||
TSheet_field & um = mask.sfield(F_SHEETUM);
|
||
if (um.items() > 0)
|
||
rw.add(um.row(0).get(s.cid2index(FS_CODUM)), s.cid2index(FS_CODUMCORR));
|
||
}
|
||
break;
|
||
case K_ENTER:
|
||
{
|
||
const TString & codice = s.row(s.selected()).get(s.cid2index(FS_CODARTALT));
|
||
const TRectype &anamag = cache().get(LF_ANAMAG, codice);
|
||
const TMask_anamag& mask = (TMask_anamag&)s.mask();
|
||
const TString80 codart(mask.get(F_CODART));
|
||
|
||
if (!anamag.empty())
|
||
return s.error_box("Il codice %s è già un articolo di magazzino", (const char *) codice);
|
||
else
|
||
{
|
||
TLocalisamfile codcorr(LF_CODCORR);
|
||
|
||
codcorr.setkey(2);
|
||
codcorr.put(CODCORR_CODARTALT, codice);
|
||
|
||
if (codcorr.read(_isgteq) == NOERR && codcorr.get(CODCORR_CODARTALT) == codice)
|
||
{
|
||
if (codcorr.get(CODCORR_CODART) != codart)
|
||
return s.yesno_box("Il codice %s è già un codice corrispondente", (const char *) codice);
|
||
}
|
||
}
|
||
|
||
TSheet_field & f = mask.sfield(F_SHEETUM);
|
||
|
||
const int items = f.items();
|
||
const TString4 um(s.row(s.selected()).get(s.cid2index(FS_CODUMCORR)));
|
||
bool um_ok = false;
|
||
|
||
if (items > 0)
|
||
{
|
||
for (int i= 0; !um_ok && i < items; i++)
|
||
{
|
||
const TString4 umrow(f.cell(i, f.cid2index(FS_CODUM)));
|
||
|
||
um_ok = (um == umrow);
|
||
}
|
||
}
|
||
if (!um_ok)
|
||
return s.error_box("L'unità di misura '%s' non e' prevista per l'articolo %s",(const char *) um, (const char *) codart);
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool TMask_anamag::handle_sheetgiac(TMask_field &fld, KEY k)
|
||
{
|
||
if (k == K_ENTER)
|
||
{
|
||
TSheet_field &f=(TSheet_field &)fld;
|
||
TMask_anamag &m= (TMask_anamag&)f.mask(); // prende la maschere d'origine del campo
|
||
const int items = f.items();
|
||
|
||
if (items > 0 && m.magazzini().gestmultimag())
|
||
{
|
||
TAssoc_array v; // istanzia l'hash table per il controllo di univocità
|
||
|
||
for (int i= 0; i< items; i++)
|
||
{
|
||
TString codgiac;
|
||
m.livelli_giac->pack_grpcode(codgiac, f.cell(i,F_LIV1-FIRST_FIELD),1);
|
||
m.livelli_giac->pack_grpcode(codgiac, f.cell(i,F_LIV2-FIRST_FIELD),2);
|
||
m.livelli_giac->pack_grpcode(codgiac, f.cell(i,F_LIV3-FIRST_FIELD),3);
|
||
m.livelli_giac->pack_grpcode(codgiac, f.cell(i,F_LIV4-FIRST_FIELD),4);
|
||
|
||
codgiac << f.cell(i,F_CODMAG-FIRST_FIELD);
|
||
codgiac << f.cell(i,F_CODDEP-FIRST_FIELD);
|
||
if (codgiac.blank())
|
||
return error_box("I codici delle giacenze non possono essere vuoti");
|
||
// aggiunge all'hash table l'elemento 0 (primo) della riga corrente e controlla che non esista già
|
||
if (v.add(codgiac))
|
||
return error_box("Esistono due righe con lo stesso codice di giacenza");
|
||
if (!notify_sheet_giac(f, i, K_ENTER))
|
||
return FALSE;
|
||
}
|
||
// ordina le righe per livello+codmag
|
||
// f.rows_array().sort();
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
int TMask_anamag::add_totali_storico(TString & codmag)
|
||
{
|
||
TSheet_field &s =(TSheet_field &)field(F_SHEETSTOMAG);
|
||
bool need_rigatotali(TRUE);
|
||
int r;
|
||
|
||
for (r=0 ; r < s.items() && codmag>=s.cell(r,s.cid2index(F_STOCODMAG)); r++)
|
||
{
|
||
if (*s.cell(r,s.cid2index(F_STOTIPORIGA))==SIMBOLO_TOTALI
|
||
&& codmag==s.cell(r,s.cid2index(F_STOCODMAG)))
|
||
need_rigatotali=FALSE;
|
||
}
|
||
if (need_rigatotali )
|
||
{
|
||
real totq,totval;
|
||
TLocalisamfile mag(LF_MAG);
|
||
mag.setkey(2);
|
||
mag.put(MAG_ANNOES,get(F_STOANNORIF));
|
||
//mag.put(MAG_CODART,get(F_CODART));
|
||
mag.put(MAG_CODMAG,codmag);
|
||
mag.read();
|
||
while (!mag.eof()
|
||
&& get_int(F_STOANNORIF)==mag.get_int(MAG_ANNOES)
|
||
&& strncmp((const char *)codmag,mag.get(MAG_CODMAG),3)==0)
|
||
{
|
||
if (get(F_CODART)==mag.get(MAG_CODART))
|
||
{
|
||
totq+=mag.get_real(MAG_RIM);
|
||
totval+=mag.get_real(MAG_VALRIM);
|
||
}
|
||
mag.next();
|
||
}
|
||
s.insert(r,FALSE);
|
||
s.row(r ).add(SIMBOLO_TOTALI,s.cid2index(F_STOTIPORIGA));
|
||
s.row(r ).add(codmag,s.cid2index(F_STOCODMAG));
|
||
s.row(r ).add("Totale",s.cid2index(F_STOANNOES));
|
||
s.disable_cell(r,-1);
|
||
|
||
s.insert(r+1,FALSE);
|
||
s.row(r+1).add(SIMBOLO_TOTALI,s.cid2index(F_STOTIPORIGA));
|
||
s.row(r+1).add(codmag,s.cid2index(F_STOCODMAG));
|
||
s.row(r+1).add("Rim.in",s.cid2index(F_STOANNOES));
|
||
s.row(r+1).add(totq.string(),s.cid2index(F_STOQUANT));
|
||
s.row(r+1).add(totval.string(),s.cid2index(F_STOVAL));
|
||
s.disable_cell(r+1,-1);
|
||
}
|
||
update_totali_storico(codmag);
|
||
return r;
|
||
}
|
||
|
||
void TMask_anamag::update_totali_storico(TString & codmag)
|
||
{
|
||
TSheet_field &s =sfield(F_SHEETSTOMAG);
|
||
real tot1,tot2;
|
||
// find first occourrence..
|
||
int i=0 ;
|
||
while (i< s.items() && codmag>s.cell(i,s.cid2index(F_STOCODMAG)))
|
||
i++;
|
||
// ...sum...
|
||
for (; i< s.items() && *s.cell(i,s.cid2index(F_STOTIPORIGA))!=SIMBOLO_TOTALI ; i++)
|
||
{
|
||
tot1+=real(s.cell(i,s.cid2index(F_STOQUANT)));
|
||
tot2+=real(s.cell(i,s.cid2index(F_STOVAL)));
|
||
}
|
||
//... display
|
||
if (i< s.items())
|
||
{
|
||
s.row(i).add(tot1.string(),s.cid2index(F_STOQUANT));
|
||
s.row(i).add(tot2.string(),s.cid2index(F_STOVAL));
|
||
s.force_update(i);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
bool TMask_anamag::remove_totali_storico(TString & codmag)
|
||
{
|
||
if (codmag.blank())
|
||
return FALSE;
|
||
|
||
TSheet_field &s =(TSheet_field &)field(F_SHEETSTOMAG);
|
||
bool found_some(FALSE);
|
||
int r;
|
||
|
||
for (r=0 ; !found_some && r< s.items()-1 && !(*s.cell(r,s.cid2index(F_STOTIPORIGA))==SIMBOLO_TOTALI
|
||
&& codmag==s.cell(r,s.cid2index(F_STOCODMAG))); r++)
|
||
{
|
||
if (*s.cell(r,s.cid2index(F_STOTIPORIGA))!=SIMBOLO_TOTALI
|
||
&& codmag==s.cell(r,s.cid2index(F_STOCODMAG)))
|
||
found_some=TRUE;
|
||
}
|
||
if (!found_some)
|
||
{
|
||
// ultima riga
|
||
s.destroy(r,FALSE);
|
||
s.destroy(r,FALSE);
|
||
}
|
||
return !found_some;
|
||
}
|
||
|
||
|
||
bool TMask_anamag::check_totali_storico()
|
||
{
|
||
TSheet_field& s = sfield(F_SHEETSTOMAG);
|
||
const int annogiac = get_int(F_ANNO);
|
||
if (annogiac != last_annosto)
|
||
return true;
|
||
|
||
for (int r=0 ; r< s.items() ; r++)
|
||
{
|
||
// rintraccia il totale
|
||
for (; r< s.items() && *s.cell(r,s.cid2index(F_STOTIPORIGA))!=SIMBOLO_TOTALI; r++) ;
|
||
real totq1(s.cell(r,s.cid2index(F_STOQUANT))),totq2(s.cell(r+1,s.cid2index(F_STOQUANT)));
|
||
if (totq1!=totq2)
|
||
if (!yesno_box("La somma delle composizioni dello storico \nper il magazzino %s non corrisponde \nalla rimanenza iniziale.\n Proseguo ugualmente ?",
|
||
(const char *)s.cell(r,s.cid2index(F_STOCODMAG))))
|
||
return FALSE;
|
||
TCurrency totval1(real(s.cell(r,s.cid2index(F_STOVAL)))),
|
||
totval2(real(s.cell(r+1,s.cid2index(F_STOVAL))));
|
||
if (totval1!=totval2)
|
||
return yesno_box("La somma del valore delle composizioni dello storico \n per il magazzino %s non corrisponde \nal valore della rimanenza iniziale.\n Proseguo ugualmente ?",
|
||
s.cell(r,s.cid2index(F_STOCODMAG)));
|
||
r++;
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
bool TMask_anamag::notify_sheet_giac(TSheet_field &f, int i, KEY k)
|
||
{
|
||
TMask_anamag& m = (TMask_anamag&)f.mask();
|
||
|
||
const bool gestmag = app().has_module(MGAUT) && m.magazzini().gestmag();
|
||
if (gestmag)
|
||
{
|
||
switch (k)
|
||
{
|
||
case (K_ENTER): // fine modifica
|
||
{
|
||
real ck(f.cell(i,f.cid2index(F_RIM)));
|
||
ck+=real(f.cell(i,f.cid2index(F_ACQ)));
|
||
ck+=real(f.cell(i,f.cid2index(F_ENTR)));
|
||
ck-=real(f.cell(i,f.cid2index(F_VEN)));
|
||
ck-=real(f.cell(i,f.cid2index(F_USC)));
|
||
ck-=real(f.cell(i,f.cid2index(F_ACL)));
|
||
ck+=real(f.cell(i,f.cid2index(F_INCL)));
|
||
ck-=real(f.cell(i,f.cid2index(F_INPRODF)));
|
||
ck+=real(f.cell(i,f.cid2index(F_INPRODC)));
|
||
ck-=real(f.cell(i,f.cid2index(F_SCARTI)));
|
||
ck-=real(f.cell(i,f.cid2index(F_GIAC)));
|
||
|
||
if (!ck.is_zero())
|
||
return f.error_box("La giacenza deve essere pari a RIM+(ACQ+ENTR)-(VEN+USC)-(ACL-INCL)-(PRODF-PRODC) - SCARTI)");
|
||
|
||
m.update_ordc_ordf(); //chiama la funzione che calcola i totali degli ordinati
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
} //if(gestmag...
|
||
|
||
//campi presi da altri campi della maschera per..
|
||
//..essere visualizzati nella pag. giacenze
|
||
if (k == K_TAB)
|
||
{
|
||
TMask& sm = f.sheet_mask(); //maschera delle giacenze
|
||
|
||
if (sm.field(F_LIV1).hidden()) //l'articolo appare solo se mancano i livelli di giacenza senno'..
|
||
{ //..si sovrappongono
|
||
sm.show(F_CODARTR);
|
||
sm.show(F_DESCRR);
|
||
sm.set(F_CODARTR, m.get(F_CODART));
|
||
sm.set(F_DESCRR, m.get(F_DESCR));
|
||
}
|
||
else
|
||
{
|
||
sm.hide(F_CODARTR);
|
||
sm.hide(F_DESCRR);
|
||
}
|
||
sm.set(F_ULC1R, m.get_real(F_ULC1));
|
||
sm.set(F_DATAULC1R, m.get_date(F_DATAULC1));
|
||
sm.set(F_ULC2R, m.get_real(F_ULC1));
|
||
sm.set(F_DATAULC2R, m.get_date(F_DATAULC2));
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool TMask_anamag::handle_sheet_giac_codmag(TMask_field &f, KEY k)
|
||
{
|
||
if (k==K_TAB && f.dirty())
|
||
{
|
||
TMask& m = f.mask();
|
||
const TRectype& mag = ((TEdit_field&)f).browse()->cursor()->curr();
|
||
const bool gesdep = mag.get_bool("B0");
|
||
|
||
m.enable(F_CODDEP, gesdep);
|
||
m.show(F_DESDEP, gesdep);
|
||
if (gesdep)
|
||
m.field(F_CODDEP).check();
|
||
else
|
||
{
|
||
m.set(F_CODDEP, "");
|
||
m.set(F_DESDEP, "");
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
bool TMask_anamag::handle_sheet_giac_valgiac(TMask_field &f, KEY k)
|
||
{
|
||
if (k==K_TAB && f.dirty())
|
||
{
|
||
TMask& m = f.mask();
|
||
real q=m.get_real(F_RIM)+m.get_real(F_ACQ);
|
||
if (q.is_zero())
|
||
f.set(q.string());
|
||
else
|
||
{
|
||
q=(m.get_real(F_VRIM)+m.get_real(F_VACQ))/q;
|
||
TPrice r(q);
|
||
f.set(r.get_num().string());
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool TMask_anamag::handle_sheet_stomag_stoval(TMask_field &f, KEY k)
|
||
{
|
||
if (k == K_TAB && f.dirty())
|
||
{
|
||
TMask& m = f.mask();
|
||
const real val = m.get_real(F_STOQUANT) * m.get_real(F_STOVALUN);
|
||
const TCurrency c(val);
|
||
m.set(F_STOVAL, c);
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool TMask_anamag::notify_sheet_sto(TSheet_field &s, int r, KEY k)
|
||
{
|
||
static TString16 oldcodmag,newcodmag,oldanno,newanno;
|
||
TMask_anamag & m=(TMask_anamag &)s.mask();
|
||
|
||
switch (k)
|
||
{
|
||
case K_DEL:
|
||
if (*s.cell(r,s.cid2index(F_STOTIPORIGA))==SIMBOLO_TOTALI)
|
||
return FALSE;
|
||
break;
|
||
|
||
case (K_CTRL+K_DEL):
|
||
if (m.remove_totali_storico(oldcodmag))
|
||
s.force_update();
|
||
break;
|
||
|
||
case K_TAB: // posizionamento sulla riga
|
||
oldcodmag=s.cell(r,s.cid2index(F_STOCODMAG));
|
||
oldanno=s.cell(r,s.cid2index(F_STOANNOES));
|
||
break;
|
||
|
||
case (K_ENTER): // fine modifica
|
||
|
||
newanno=(s.cell(r,s.cid2index(F_STOANNOES)));
|
||
newcodmag=(s.cell(r,s.cid2index(F_STOCODMAG)));
|
||
|
||
if (esercizi()[atoi(newanno)].inizio() >= esercizi()[m.get_int(F_STOANNO)].inizio())
|
||
{
|
||
s.row(r).add(oldanno,s.cid2index(F_STOANNOES));
|
||
s.error_box("La rimanenza iniziale di un esercizio deve essere composta da parti provenienti da esercizi precedenti");
|
||
return FALSE;
|
||
}
|
||
// modifica
|
||
m.update_totali_storico(newcodmag);
|
||
if (oldcodmag==s.cell(r,s.cid2index(F_STOCODMAG)))
|
||
{
|
||
if (oldanno==s.cell(r,s.cid2index(F_STOANNOES)) )
|
||
break;
|
||
} else {
|
||
m.remove_totali_storico(oldcodmag);
|
||
}
|
||
case (K_CTRL + K_INS ): // fine inserimento
|
||
if (*s.cell(r,s.cid2index(F_STOCODMAG))==' ' && m.magazzini().standardmag().not_empty())
|
||
{
|
||
// new line
|
||
s.row(r).add(m.magazzini().standardmag(),s.cid2index(F_STOCODMAG));
|
||
}
|
||
|
||
newcodmag=(s.cell(r,s.cid2index(F_STOCODMAG)));
|
||
newanno=(s.cell(r,s.cid2index(F_STOANNOES)));
|
||
if (newcodmag != " ")
|
||
{
|
||
// ordina
|
||
while (r< s.items()-1 && (newcodmag > s.cell(r+1,s.cid2index(F_STOCODMAG)) ||
|
||
(newcodmag == s.cell(r+1,s.cid2index(F_STOCODMAG)) &&
|
||
(newanno > s.cell(r+1,s.cid2index(F_STOANNOES)) && *s.cell(r+1,s.cid2index(F_STOTIPORIGA))!=SIMBOLO_TOTALI)) ))
|
||
{
|
||
s.swap_rows(r,r+1);
|
||
r++;
|
||
}
|
||
while (r>0 && (newcodmag < s.cell(r-1,s.cid2index(F_STOCODMAG)) ||
|
||
(newcodmag == s.cell(r-1,s.cid2index(F_STOCODMAG)) &&
|
||
(newanno < s.cell(r-1,s.cid2index(F_STOANNOES)) || *s.cell(r-1,s.cid2index(F_STOTIPORIGA))==SIMBOLO_TOTALI )) ))
|
||
{
|
||
s.swap_rows(r,r-1);
|
||
r--;
|
||
}
|
||
m.add_totali_storico(newcodmag);
|
||
// TSheet_field & s_um=(TSheet_field & )s.mask().field(F_SHEETUM); // qui verificare
|
||
s.force_update();
|
||
}
|
||
break;
|
||
|
||
case (K_INS): // richiesta di inserimento
|
||
break;
|
||
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
|
||
bool TMask_anamag::handle_sheetstomag(TMask_field &fld, KEY k)
|
||
{
|
||
TSheet_field & f=(TSheet_field &)fld;
|
||
TMask_anamag &m=(TMask_anamag &) f.mask(); // prende la maschere d'origine del campo
|
||
if (k==K_ENTER)
|
||
{
|
||
const int items = f.items();
|
||
real totrim,totvalrim;
|
||
|
||
if (items > 0)
|
||
{
|
||
if (!m.check_totali_storico())
|
||
return FALSE;
|
||
TAssoc_array v; // istanzia l'hash table per il controllo di univocitˆ
|
||
int i;
|
||
|
||
for (i= 0; i< items; i++)
|
||
{
|
||
if (*f.cell(i,f.cid2index(F_STOTIPORIGA))!=SIMBOLO_TOTALI)
|
||
{
|
||
TString codmg(f.cell(i,f.cid2index(F_STOCODMAG)));
|
||
TString codeser(f.cell(i,f.cid2index(F_STOANNOES)));
|
||
if (codmg.blank())
|
||
return error_box("Il codice del magazzino non può essere vuoto");
|
||
if (codeser.blank())
|
||
return error_box("I codici degli esercizi non possono essere vuoti");
|
||
// aggiunge all'hash table l'elemento 0 (primo) della riga corrente e controlla che non esista già
|
||
codmg.overwrite(codeser,3);
|
||
if (v.add(codmg))
|
||
return error_box("La composizione delle rimanenze deve far riferimento a esercizi tutti diversi tra loro");
|
||
TLocalisamfile stor_aux(LF_STOMAG);
|
||
|
||
stor_aux.put(STOMAG_CODART,fld.mask().get(F_CODART));
|
||
stor_aux.put(STOMAG_ANNOESRIF,fld.mask().get(F_STOANNO));
|
||
stor_aux.put(STOMAG_ANNOES,codeser);
|
||
|
||
totrim=totrim+(real)f.cell(i,f.cid2index(F_STOQUANT));
|
||
totvalrim=totvalrim+(real)f.cell(i,f.cid2index(F_STOVAL));
|
||
}
|
||
}
|
||
for (i= 0; i< items;)
|
||
{
|
||
if (*f.cell(i,f.cid2index(F_STOTIPORIGA))==SIMBOLO_TOTALI)
|
||
f.rows_array().remove(i,TRUE);
|
||
else
|
||
i++;
|
||
}
|
||
// ordina le righe per ANNO
|
||
//f.rows_array().sort();
|
||
if ( m.get(F_STOANNO)<f.cell(f.items()-1,F_STOANNOES-FIRST_FIELD))
|
||
return error_box("La composizione delle rimanenze non puo' comprendere anni seguenti");
|
||
}
|
||
|
||
} else
|
||
if (k==K_SPACE)
|
||
{
|
||
for (int i=0; i< f.items();)
|
||
{
|
||
TString16 codmag(f.cell(i,f.cid2index(F_STOCODMAG)));
|
||
i=m.add_totali_storico(codmag)+2;
|
||
}
|
||
f.force_update();
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool TMask_anamag::handle_sheet_um_um(TMask_field &fld, KEY k)
|
||
{
|
||
if (fld.focusdirty() && k == K_TAB)
|
||
{
|
||
TMask &m = fld.mask(); // prende la maschera d'origine del campo (maschera dello sheet)
|
||
const TString4 curr_um(fld.get()); // prende il contenuto del campo corrente (unità di misura corrente)
|
||
|
||
if (curr_um.full()) // se il codice dell'unità di misura è vuoto non viene fatto alcun calcolo
|
||
{
|
||
TSheet_field *f= m.get_sheet(); // prende lo sheet d'origine della maschera del campo
|
||
|
||
CHECK(f != NULL, "Il puntatore allo sheet è nullo");
|
||
if (f->selected() > 0)
|
||
{
|
||
|
||
// ALGORITMO DI PRECALCOLO DEL RAPPORTO DELLE UNITA' DI MISURA NELLO SHEET
|
||
//
|
||
// SHEET:
|
||
// -----
|
||
// riga u.m. f.c.
|
||
// 1) KM 1 -> kilometri (you), riferiti al metro (your) con f.c. 1000 (your_fc)
|
||
// ... ... ...
|
||
// ...) MM X -> millimetri (me), riferiti al metro (my) con f.c. 0,001 (my_fc)
|
||
//
|
||
// se (your==my) allora X=(my_fc/your_fc) ...chiaro, no!? :-)
|
||
|
||
TTable t("%UMS");
|
||
real x; // fattore di conversione dell'unità di misura corrente
|
||
const TString16 first_um(f->row(0).get(0)); // prende l'unità di misura di rapporto (dalla prima linea dello sheet)
|
||
|
||
t.zero();
|
||
t.put("CODTAB", curr_um);
|
||
if (t.read() == NOERR)
|
||
{
|
||
const TString16 rif_um(t.get("S7")); // prende l'unità di misura di riferimento dell'unità di misura corrente
|
||
x = t.get_real("R10"); // prende il suo fattore di conversione
|
||
|
||
if (rif_um != first_um)
|
||
{
|
||
t.zero();
|
||
t.put("CODTAB", first_um);
|
||
if (t.read() == NOERR)
|
||
{
|
||
TString16 rif_first_um(t.get("S7")); // prende l'unità di misura di riferimento dell'unità di misura di rapporto
|
||
real rif_fc_first_um(t.get_real("R10")); // prende il suo fattore di conversione
|
||
rif_fc_first_um = rif_fc_first_um.is_zero() ? 1 : rif_fc_first_um;
|
||
|
||
if (rif_first_um == rif_um)
|
||
{
|
||
x /= rif_fc_first_um; // calcola il rapporto tra i fattori di conversione
|
||
x.round(5); // arrotonda il risultato a 5 decimali
|
||
} else {
|
||
if (rif_first_um == curr_um) {
|
||
x= 1/rif_fc_first_um;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (x == ZERO)
|
||
x = 1.00;
|
||
m.set(FS_FCUM, x); // il risultato viene scritto nel campo del fattore di conversione
|
||
}
|
||
else
|
||
{
|
||
TMask_anamag& m = (TMask_anamag&)f->mask();
|
||
if (m.um_principale().blank())
|
||
m.set_um_principale(curr_um);
|
||
}
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
bool TMask_anamag::handle_sheet_um_price(TMask_field &f, KEY k)
|
||
{
|
||
if (f.to_check(k,TRUE))
|
||
{
|
||
TMask& m = f.mask();
|
||
TString codiva= m.get_sheet()->mask().get(F_CODIVA);// recuper il codice IVA dalla maschera principale
|
||
real netto = 0.0;
|
||
real lordo = 0.0;
|
||
TCodiceIVA iva(codiva);
|
||
|
||
if (f.dlg() == FS_PREZZO)
|
||
{
|
||
netto = real(m.get(FS_PREZZO));
|
||
lordo = iva.lordo(netto, AUTO_PRICES_DECIMALS, TCurrency::get_firm_val());
|
||
m.set(FS_PREZZO_LORDO,lordo.string());
|
||
}
|
||
else
|
||
{
|
||
lordo = real(m.get(FS_PREZZO_LORDO));
|
||
real prec_lordo = lordo;
|
||
const real imposta = iva.scorpora(lordo, AUTO_PRICES_DECIMALS, TCurrency::get_firm_val());
|
||
netto = lordo;
|
||
lordo += imposta;
|
||
if (lordo != prec_lordo)
|
||
{
|
||
warning_box("Scorporando l'iva dal prezzo lordo si e' dovuto\n"
|
||
"correggere quest'ultimo a causa di arrotondamenti.");
|
||
m.set(FS_PREZZO_LORDO,lordo.string());
|
||
}
|
||
m.set(FS_PREZZO,netto.string());
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
|
||
void TMask_anamag::sheetgiac_get(TSheet_field &fld_righe, int item)
|
||
{
|
||
TMask_anamag &m=(TMask_anamag &)fld_righe.mask();
|
||
// prende il record della riga corrente dal record array
|
||
TRectype &rec= fld_righe.record()->row(item, TRUE);
|
||
TToken_string &row= fld_righe.row(item-1);
|
||
// codici di livello
|
||
row.add( m.livelli_giac->unpack_grpcode(rec.get("LIVELLO") ,1),fld_righe.cid2index(F_LIV1) );
|
||
row.add( m.livelli_giac->unpack_grpcode(rec.get("LIVELLO") ,2),fld_righe.cid2index(F_LIV2) );
|
||
row.add( m.livelli_giac->unpack_grpcode(rec.get("LIVELLO") ,3),fld_righe.cid2index(F_LIV3) );
|
||
row.add( m.livelli_giac->unpack_grpcode(rec.get("LIVELLO") ,4),fld_righe.cid2index(F_LIV4) );
|
||
}
|
||
|
||
|
||
// item varies from 1 to items()
|
||
void TMask_anamag::sheetgiac_put(TSheet_field &fld_righe, int item)
|
||
{
|
||
TMask_anamag &m=(TMask_anamag &)fld_righe.mask();
|
||
TToken_string &row= fld_righe.row(item-1);
|
||
|
||
TRectype &recrighe= fld_righe.record()->row(item, TRUE);
|
||
// codici livello
|
||
if (m.livelli_giac->enabled()) {
|
||
TString16 packedcode;
|
||
m.livelli_giac->pack_grpcode(packedcode,row.get(fld_righe.cid2index(F_LIV1)),1);
|
||
m.livelli_giac->pack_grpcode(packedcode,row.get(fld_righe.cid2index(F_LIV2)),2);
|
||
m.livelli_giac->pack_grpcode(packedcode,row.get(fld_righe.cid2index(F_LIV3)),3);
|
||
m.livelli_giac->pack_grpcode(packedcode,row.get(fld_righe.cid2index(F_LIV4)),4);
|
||
recrighe.put("LIVELLO", packedcode);
|
||
}
|
||
}
|
||
|
||
// Aggiorna il valore delle giacenze in base al cambiamento dell'unità di misura principale
|
||
void TMask_anamag::ricalcola_giacenze()
|
||
{
|
||
real fc(UNO);
|
||
TSheet_field& f= sfield(F_SHEETUM);
|
||
if (um_principale().full() && um_principale()!=f.cell(0,f.cid2index(FS_CODUM)))
|
||
{
|
||
int i;
|
||
|
||
for (i= 0; i<f.items(); i++)
|
||
{
|
||
if (um_principale()==f.cell(i,f.cid2index(FS_CODUM)))
|
||
break;
|
||
}
|
||
fc=f.cell(i,f.cid2index(FS_FCUM));
|
||
}
|
||
if (fc != UNO)
|
||
{
|
||
TLocalisamfile mag(LF_MAG),stomag(LF_STOMAG);
|
||
int annoes = esercizi().first();
|
||
|
||
// ciclo sugli esercizi
|
||
do
|
||
{
|
||
mag.zero();
|
||
mag.put(MAG_ANNOES,annoes);
|
||
mag.put(MAG_CODART,get(F_CODART));
|
||
mag.read(_isgteq);
|
||
// ciclo per le giacenze di questo esercizio
|
||
while (!mag.eof() && get(F_CODART)==mag.get(MAG_CODART) && annoes==mag.get_int(MAG_ANNOES))
|
||
{
|
||
mag.put(MAG_LIVRIOR,mag.get_real(MAG_LIVRIOR)*fc); // update ..
|
||
mag.put(MAG_LOTTORIOR,mag.get_real(MAG_LOTTORIOR)*fc);
|
||
// saldi
|
||
mag.put(MAG_GIAC,mag.get_real(MAG_GIAC)*fc); // update ..
|
||
mag.put(MAG_ACQ,mag.get_real(MAG_ACQ)*fc);
|
||
mag.put(MAG_ENT,mag.get_real(MAG_ENT)*fc);
|
||
mag.put(MAG_VEN,mag.get_real(MAG_VEN)*fc);
|
||
mag.put(MAG_USC,mag.get_real(MAG_USC)*fc);
|
||
mag.put(MAG_ORDC,mag.get_real(MAG_ORDC)*fc);
|
||
mag.put(MAG_ORDF,mag.get_real(MAG_ORDF)*fc);
|
||
mag.put(MAG_RIM,mag.get_real(MAG_RIM)*fc);
|
||
mag.put(MAG_SCARTI,mag.get_real(MAG_SCARTI)*fc);
|
||
mag.put(MAG_INCL,mag.get_real(MAG_INCL)*fc);
|
||
mag.put(MAG_ACL,mag.get_real(MAG_ACL)*fc);
|
||
mag.put(MAG_PRODCOMP,mag.get_real(MAG_PRODCOMP)*fc);
|
||
mag.put(MAG_PRODFIN,mag.get_real(MAG_PRODFIN)*fc);
|
||
mag.put(MAG_SCORTAMIN,mag.get_real(MAG_SCORTAMIN)*fc);
|
||
mag.rewrite();
|
||
mag.next();
|
||
}
|
||
stomag.zero();
|
||
stomag.put(STOMAG_ANNOESRIF,annoes);
|
||
stomag.put(STOMAG_CODART,get(F_CODART));
|
||
stomag.read(_isgteq);
|
||
// ciclo per lo storico di questo esercizio
|
||
while (!stomag.eof() && get(F_CODART)==stomag.get(STOMAG_CODART) && annoes==stomag.get_int(STOMAG_ANNOESRIF))
|
||
{
|
||
stomag.put(STOMAG_QUANT,stomag.get_real(STOMAG_QUANT)*fc); // update ..
|
||
|
||
stomag.rewrite();
|
||
stomag.next();
|
||
}
|
||
}
|
||
while ((annoes = esercizi().next(annoes)) > 0); // qui verificare
|
||
}
|
||
return;
|
||
}
|
||
|
||
//---------------------------------------
|
||
//fine gestione articolo multilivello
|
||
//---------------------------------------
|
||
|
||
//-------------------------------------------------------------------------------------------------
|
||
// METODI DELL'APPLICAZIONE
|
||
//-------------------------------------------------------------------------------------------------
|
||
void TAnagrafica_magazzino::on_firm_change()
|
||
{
|
||
if (_msk)
|
||
_msk->set_parametered_fields();
|
||
}
|
||
|
||
bool TAnagrafica_magazzino::search_on_file(const char * key, int file, int nkey, const char * field)
|
||
{
|
||
TLocalisamfile f(file);
|
||
|
||
if (f.empty())
|
||
return FALSE;
|
||
else
|
||
{
|
||
f.setkey(nkey);
|
||
f.put(field, key);
|
||
f.read();
|
||
return f.get(field) == key;
|
||
}
|
||
}
|
||
|
||
bool TAnagrafica_magazzino::protected_record(TRectype& rec)
|
||
{
|
||
const TString art(rec.get(ANAMAG_CODART));
|
||
const TRectype & dist = cache().get(LF_DIST, art);
|
||
|
||
if (!dist.empty())
|
||
return TRUE;
|
||
else
|
||
if (search_on_file(art, LF_RDIST, 2, "CODCOMP"))
|
||
return TRUE;
|
||
else
|
||
return search_on_file(art, LF_RMOVMAG, 2, "CODART");
|
||
}
|
||
|
||
bool TAnagrafica_magazzino::user_create()
|
||
{
|
||
open_files(LF_TAB, LF_TABCOM, LF_ANAMAG, LF_MAG, LF_STOMAG,
|
||
LF_UMART, LF_CODCORR, LF_DESLIN, LF_DIST, LF_RDIST, LF_RMOVMAG,
|
||
LF_CLIFO, LF_PCON, 0);
|
||
|
||
// crea l'oggetto per i parametri di livello giacenza
|
||
// apre la maschera e dispone gli sheet
|
||
_rel= new TRelation(LF_ANAMAG);
|
||
if (ini_get_bool(CONFIG_DITTA, "ve", "Magic"))
|
||
_rel->add("&ATM","CODTAB==" ANAMAG_CODART, 1, LF_ANAMAG, ECAUT);
|
||
|
||
//gestisce i campi salvati sulla tabella di modulo lv047 (lvanamag)
|
||
_rel->add("&LV047" ,"CODTAB==" ANAMAG_CODART, 1, LF_ANAMAG, LVAUT);
|
||
_rel->write_enable(-LVAUT); //abilita la lettura / scrittura sul record collegato
|
||
|
||
_msk= new TMask_anamag(_rel);
|
||
|
||
set_search_field(F_CODART); //serve per avere come campo di ricerca il codice articolo intero
|
||
//invece che l'ultimo campo del codice multilivello (se c'e')
|
||
return TRUE;
|
||
}
|
||
|
||
bool TAnagrafica_magazzino::user_destroy()
|
||
{
|
||
delete _rel;
|
||
delete _msk;
|
||
return true;
|
||
}
|
||
|
||
int TAnagrafica_magazzino::read(TMask& m)
|
||
{
|
||
int err= TRelation_application::read(m);
|
||
if (err == NOERR)
|
||
{
|
||
// LETTURA SHEET STORICO MAGAZZINO IN AUTOMATICO
|
||
TSheet_field &fld_stomag= m.sfield(F_SHEETSTOMAG);
|
||
fld_stomag.sheet_mask().field(F_STOCODART).set(m.field(F_CODART).get()); // necessario se lo sheet è vuoto
|
||
|
||
// *****************************
|
||
// LETTURA SHEET UNITA' DI MISURA
|
||
load_um(m);
|
||
((TMask_anamag&) m).update_ordc_ordf(); //chiama la funzione che calcola i totali degli ordinati
|
||
}
|
||
return err;
|
||
}
|
||
|
||
void TAnagrafica_magazzino::load_um(TMask& m)
|
||
{
|
||
// *****************************
|
||
// LETTURA SHEET UNITA' DI MISURA
|
||
TSheet_field &fld_um= m.sfield(F_SHEETUM); // prende lo sheet delle unità di misura
|
||
get_relation()->curr().put(ANAMAG_CODART,m.get(F_CODART));
|
||
fld_um.record()->read(*fld_um.putkey(*get_relation()));
|
||
fld_um.autoload(*get_relation());
|
||
// else
|
||
// ((TToken_string &)fld_um.row(0)).add("1",fld_um.cid2index(FS_FCUM)); // forza la prima unita' di misura a 1
|
||
// fld_um.disable_cell(0, fld_um.cid2index(FS_FCUM)); // mette in sola lettura il secondo campo della prima riga (il fattore di conversione della prima U.M. è fisso a 1)
|
||
// fld_um.force_update(0); // aggiorna lo stato della riga 0
|
||
|
||
TString4 um_principale;
|
||
if (m.edit_mode())
|
||
um_principale = fld_um.cell(0, fld_um.cid2index(FS_CODUM));
|
||
((TMask_anamag&)m).set_um_principale(um_principale);
|
||
}
|
||
|
||
bool TAnagrafica_magazzino::remove()
|
||
{
|
||
bool ok = TRelation_application::remove();
|
||
if (ok)
|
||
{
|
||
TMask& m = curr_mask();
|
||
TSheet_field& f = m.sfield(F_SHEETUM); // prende lo sheet delle unità di misura
|
||
TLocalisamfile distinte(LF_DIST);
|
||
distinte.put("CODDIST", m.get(F_CODART));
|
||
int err = distinte.read();// esiste la distinta ?
|
||
switch(err)
|
||
{
|
||
case _iskeynotfound :
|
||
case _isemptyfile :
|
||
case _iseof:
|
||
ok &= (f.record()->remove() == NOERR);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
return ok;
|
||
}
|
||
|
||
int TAnagrafica_magazzino::write(const TMask& m)
|
||
{
|
||
int err = TRelation_application::write(m);
|
||
if (err == NOERR)
|
||
{
|
||
TSheet_field& f = m.sfield(F_SHEETUM); // prende lo sheet delle unità di misura
|
||
err = f.record()->write(FALSE);
|
||
}
|
||
return err;
|
||
}
|
||
|
||
int TAnagrafica_magazzino::rewrite(const TMask& m)
|
||
{
|
||
int err =TRelation_application::rewrite(m);
|
||
if (err==NOERR)
|
||
{
|
||
TSheet_field& f= m.sfield(F_SHEETUM); // prende lo sheet delle unità di misura
|
||
err|=f.record()->write(TRUE);
|
||
}
|
||
((TMask_anamag &)m).ricalcola_giacenze();
|
||
return err;
|
||
}
|
||
|
||
static bool non_esiste_handler(TMask_field& f, KEY k)
|
||
{
|
||
switch (k)
|
||
{
|
||
case K_TAB:
|
||
if (!f.mask().is_running())
|
||
f.reset();
|
||
break;
|
||
case K_ENTER:
|
||
if (!cache().get(LF_ANAMAG, f.mask().get(F_CODART)).empty())
|
||
return f.error_box(TR("Il codice articolo selezionato esiste già"));
|
||
default:
|
||
break;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool TAnagrafica_magazzino::handle_copia(TMask_field &fld, KEY k)
|
||
{
|
||
if (k == K_SPACE)
|
||
{
|
||
TMask_anamag & m = (TMask_anamag &) fld.mask();
|
||
const TString oldart = m.get(F_CODART);
|
||
|
||
TString codart, descart, descagg;
|
||
if (advanced_codart_enabled())
|
||
{
|
||
codart = oldart;
|
||
if (!advanced_codart_ask(codart, descart))
|
||
codart.cut(0);
|
||
else
|
||
{
|
||
descagg = descart.mid(50);
|
||
descart = descart.left(50);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
const TCodart_livelli* liv_art = m.get_livelli_art();
|
||
|
||
TMask ask("ve2400k");
|
||
ask.set_handler(F_CODART, non_esiste_handler);
|
||
if(liv_art && liv_art->enabled())
|
||
{
|
||
create_fields(ask, 1, 1, F_LIVART1, F_DESLIVART1, *liv_art, false);
|
||
for (int i = liv_art->last_level(); i > 0; i--)
|
||
{
|
||
const short id = F_LIVART1+i-1;
|
||
ask.set(id, m.get(id));
|
||
}
|
||
ask.reset(F_CODART);
|
||
}
|
||
if (ask.run() == K_ENTER)
|
||
codart = ask.get(F_CODART);
|
||
}
|
||
|
||
if (codart.full() && codart != oldart)
|
||
{
|
||
if (descart.full())
|
||
m.set(F_DESCR, descart);
|
||
if (descagg.full())
|
||
m.set(F_DESCRAGG, descagg);
|
||
|
||
|
||
m.set(F_CODART, codart, TRUE);
|
||
|
||
m.sfield(F_SHEETGIAC).destroy();
|
||
m.sfield(F_SHEETSTOMAG).destroy();
|
||
|
||
m.load_profile(0, FALSE);
|
||
|
||
m.set_mode(MODE_INS);
|
||
xvtil_statbar_set(TR("Inserimento"), TRUE);
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
void TAnagrafica_magazzino::init_query_mode(TMask &m)
|
||
{
|
||
m.hide(F_COPY);
|
||
|
||
if (advanced_codart_enabled())
|
||
m.show(F_ADVANCED);
|
||
|
||
((TMask_anamag&)m).set_um_principale("");
|
||
}
|
||
|
||
void TAnagrafica_magazzino::init_insert_mode(TMask &m)
|
||
{
|
||
load_um(m);
|
||
TSheet_field& f = m.sfield(F_SHEETUM);
|
||
if (f.items() == 0)
|
||
f.row(0) = " |1"; // aggiunge una riga allo sheet
|
||
|
||
if (advanced_codart_enabled())
|
||
m.hide(F_ADVANCED);
|
||
((TMask_anamag&)m).disable_user_page();
|
||
}
|
||
|
||
void TAnagrafica_magazzino::init_modify_mode(TMask &m)
|
||
{
|
||
m.set_handler(F_COPY, handle_copia);
|
||
m.show(F_COPY);
|
||
|
||
if (advanced_codart_enabled())
|
||
m.hide(F_ADVANCED);
|
||
((TMask_anamag&)m).disable_user_page();
|
||
}
|
||
|
||
void TAnagrafica_magazzino::ini2sheet(TConfig& ini, TSheet_field &sheet)
|
||
{
|
||
switch(sheet.dlg())
|
||
{
|
||
case F_SHEETGIAC:
|
||
case F_SHEETSTOMAG:
|
||
break; // do nothing
|
||
default:
|
||
TRelation_application::ini2sheet(ini, sheet);
|
||
}
|
||
}
|
||
|
||
void TAnagrafica_magazzino::sheet2ini(TSheet_field &sheet,TConfig& ini)
|
||
{
|
||
switch(sheet.dlg())
|
||
{
|
||
case F_SHEETGIAC:
|
||
case F_SHEETSTOMAG:
|
||
break; // do nothing
|
||
default:
|
||
TRelation_application::sheet2ini(sheet, ini);
|
||
}
|
||
}
|
||
|
||
// ************************
|
||
//
|
||
int ve2400(int argc, char* argv[])
|
||
{
|
||
TAnagrafica_magazzino a;
|
||
|
||
a.run(argc, argv, TR("Anagrafica di magazzino"));
|
||
return 0;
|
||
}
|
||
|
||
|
||
|