root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/mg/mg1100.cpp
guy e0981f3fba Corretta gestione data di registrazione 
git-svn-id: svn://10.65.10.50/branches/R_10_00@23141 c028cbd2-c16b-5b4b-a496-9718f37d4682
2015-11-30 16:22:27 +00:00

1018 lines
29 KiB
C++
Executable File
Raw Blame History

#include "mglib.h"
#include "../cg/cglib01.h"
#include "../db/dblib.h"
#include "../ve/veconf.h"
#include <defmask.h>
#include <relapp.h>
#include <msksheet.h>
#include "anamag.h"
#include "rmovmag.h"
#include "mg1100.h"
#include <cfven.h>
// maschera dell'applicazione "Gestione interattiva movimenti di magazzino"
//
class TMask_movmag : public TMask
{
TMov_mag * _mov_mag;
TCodice_articolo _price_codart;
real price_quant;
bool price_proposed;
real proposed_price(const char * codart, real quant,const char * causrig);
int _autorows;
TArray _old_qta;
int _check_giac_neg;
bool _shift_f12;
TMagazzini _magazzini;
protected:
virtual bool on_key(KEY key);
protected:
// aggiorna la riga di magazzino aggiungendo righe automatiche o esplosioni
bool update_rigamov(int r, const char * old_codcaus, const char * old_codart, const real & old_quant);
bool add_autorows(int r, const char * old_codcaus, const char * old_codart, const real & old_quant);
bool add_explrows(int r);
void qta_inventory(real & qta);
static bool notify_righe(TSheet_field & fld_righe, int item, KEY k); // notify delle righe di sheet
static bool handle_righe(TMask_field &f, KEY k); // handler delle righe
static bool handle_righeprezzo1(TMask_field &f, KEY k); // handler del prezzo delle righe
static bool handle_righeprezzo2(TMask_field &f, KEY k); // handler del prezzo delle righe
static bool handle_codcaus(TMask_field &fld, KEY k); // handler della causale
static bool handle_datacomp(TMask_field &, KEY k); // handler data competenza
static bool handle_datareg(TMask_field &, KEY k); // handler data di registrazione
static bool handle_checksosp(TMask_field &fld, KEY k); // handler
static bool handle_codarticolo(TMask_field &fld, KEY k); // handler
static bool handle_causrig(TMask_field &fld, KEY k); // handler
static bool handle_giacattuale(TMask_field &fld, KEY k); // handler della giacenza attuale
static bool codgrp_handler(TMask_field &fld, KEY k); // handler del codice gruppo
static void sheetrighe_put(TSheet_field &fld_righe, int item);
static void sheetrighe_get(TSheet_field &fld_righe, int item);
public:
TArticolo_giacenza& curr_art();
TArray& old_qta() { return _old_qta; }
const TMagazzini& magazzini() const { return _magazzini; }
int autorows() const { return _autorows; }
void update_tot();
bool get_shift_f12() const { return _shift_f12; }
void set_shift_f12(bool s12 = true) { _shift_f12 = s12; }
TMask_movmag(TMov_mag* m_m);
virtual ~TMask_movmag();
};
// HANDLER DEL CODICE LIVELLO anagrafica
bool TMask_movmag::codgrp_handler(TMask_field& f, KEY k)
{
if ((k == K_TAB && f.focusdirty() ||k == K_ENTER ) && !f.empty())
{
if (!livelli_giacenza().enabled())
{
f.error_box(TR("Livelli del codice non abilitati"));
return false;
}
const int levnum=1+f.dlg()-F_LIV1;
return livelli_giacenza().autoinsert(levnum,f);
}
return true;
}
bool TMask_movmag::on_key(KEY key)
{
if (key == K_SHIFT+K_F12 && edit_mode())
{
_shift_f12 = true;
enable(DLG_SAVEREC);
enable(DLG_DELREC);
TSheet_field& ss = sfield(F_RIGHE);
FOR_EACH_SHEET_ROW(ss, i, row)
{
const char tipo = row->get_char(0);
if (tipo > ' ')
ss.enable_row(i);
}
ss.force_update();
return true;
}
return TMask::on_key(key);
}
// costruttore della maschera anagrafica di magazzino
//TMask_movmag::TMask_movmag() :
TMask_movmag::TMask_movmag(TMov_mag * m_m) : TMask("mg1100")
{
_mov_mag = m_m;
// setta handler e notify
set_handler(F_DATACOMP, handle_datacomp);
set_handler(F_DATAREG, handle_datareg);
set_handler(F_CODCAUS, handle_codcaus);
TSheet_field& ss = sfield(F_RIGHE);
ss.set_line_number_width(4);
ss.set_notify(notify_righe);
ss.set_handler(handle_righe);
ss.set_userget(sheetrighe_get);
ss.set_userput(sheetrighe_put);
ss.set_lines_record(m_m->body());
TMask& sm = ss.sheet_mask();
sm.field(F_QUANT).set_handler(handle_righeprezzo1);
sm.field(F_CAUSRIG).set_handler(handle_causrig);
sm.field(F_CODART).set_handler(handle_codarticolo);
sm.field(F_GIAC).set_handler(handle_giacattuale);
// setta i campi della maschera per la pagina giacenze
// setta le colonne in base all'abilitazione dei livelli di giacenza
livelli_giacenza().set_sheet_columns(ss, F_LIV1);
// abilita i controlli
for (int l=0; l<4; l++) if (livelli_giacenza().autoinsert(1+l))
{
sm.efield(F_LIV1+l).check_type(CHECK_SEARCH);
sm.field(F_LIV1+l).set_handler(codgrp_handler);
}
TConfig prassid(CONFIG_DITTA, "ve"); // apre il file di configurazione della ditta corrente
if (prassid.get_bool("GES", NULL, A_LISTINI))
field(F_CATVEN).show(prassid.get_bool("GESLISCV"));
else
field(F_CATVEN).hide();
const bool gmm = magazzini().gestmultimag();
sm.field(F_DESMAG).enable(gmm);
ss.enable_column(ss.cid2index(F_CODMAG),gmm);
const bool gd = magazzini().gestdep();
sm.field(F_DESDEP).enable(gd);
ss.enable_column(ss.cid2index(F_CODDEP),gd);
_autorows = prassid.get_int("AUTOROWS", "mg");
_check_giac_neg = prassid.get_int("CHECK_GIAC", "mg");
if (!prassid.get_bool("MOV_INDSPED", "mg"))
{
hide(F_INDSPED);
hide(F_INDIR);
}
}
TMask_movmag::~TMask_movmag()
{
}
// item varies from 1 to items()
void TMask_movmag::sheetrighe_get(TSheet_field &fld_righe, int item)
{
// 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( livelli_giacenza().unpack_grpcode(rec.get("LIVGIAC") ,1),fld_righe.cid2index(F_LIV1) );
row.add( livelli_giacenza().unpack_grpcode(rec.get("LIVGIAC") ,2),fld_righe.cid2index(F_LIV2) );
row.add( livelli_giacenza().unpack_grpcode(rec.get("LIVGIAC") ,3),fld_righe.cid2index(F_LIV3) );
row.add( livelli_giacenza().unpack_grpcode(rec.get("LIVGIAC") ,4),fld_righe.cid2index(F_LIV4) );
}
// item varies from 1 to items()
void TMask_movmag::sheetrighe_put(TSheet_field &fld_righe, int item)
{
TToken_string &row= fld_righe.row(item-1);
TRectype &recrighe= fld_righe.record()->row(item, true);
// codici livello
if (livelli_giacenza().enabled())
{
TString16 packedcode;
livelli_giacenza().pack_grpcode(packedcode,row.get(fld_righe.cid2index(F_LIV1)),1);
livelli_giacenza().pack_grpcode(packedcode,row.get(fld_righe.cid2index(F_LIV2)),2);
livelli_giacenza().pack_grpcode(packedcode,row.get(fld_righe.cid2index(F_LIV3)),3);
livelli_giacenza().pack_grpcode(packedcode,row.get(fld_righe.cid2index(F_LIV4)),4);
recrighe.put("LIVGIAC", packedcode);
}
}
bool TMask_movmag::handle_righe(TMask_field &f, KEY k)
{
if (k == K_ENTER)
{
TSheet_field& ss = (TSheet_field&)f;
const int idx_codart = ss.cid2index(F_CODART);
for (int i = ss.items()-1; i >= 0; i--)
{
if (*ss.cell(i,idx_codart) <= ' ') // Riga senza codice articolo = vuota
ss.destroy(i);
}
const int idx_codmag = ss.cid2index(F_CODMAG);
if (ss.column_enabled(idx_codmag))
{
for (int i = 0; i < ss.items(); i++)
{
if (*ss.cell(i,idx_codmag) <= ' ')
return f.error_box(FR("Nella riga %d manca l'indicazione del magazzino"),i+1);
}
}
}
return true;
}
void TMask_movmag::update_tot()
{
TSheet_field& ss = sfield(F_RIGHE);
const int idx_val = ss.cid2index(F_VALORE); // Posizione del valore
const int idx_qta = ss.cid2index(F_QUANT); // Posizione della quantita'
const int idx_caus = ss.cid2index(F_CAUSRIG); // Posizione della causale di riga
const bool start = !is_running();
real valore, tot, qta;
const TString8 causmov = get(F_CODCAUS);
TString8 codcaus;
if (start)
_old_qta.destroy();
FOR_EACH_SHEET_ROW(ss, i, row)
{
row->get(idx_val, valore);
tot += valore;
if (start)
{
row->get(idx_qta, qta);
row->get(idx_caus, codcaus);
if (codcaus.blank())
codcaus = causmov;
const TCausale_magazzino cau(codcaus);
if (cau.sgn(s_giac) == -1)
qta = -qta;
_old_qta.add(qta, i);
}
}
set(F_VALORE_TOT, tot);
}
bool TMask_movmag::notify_righe(TSheet_field& ss, int r, KEY key)
{
static TString8 old_codcaus;
static TCodice_articolo old_codart;
static real old_quant;
static bool selecting = false;
TMask_movmag& m= (TMask_movmag&)ss.mask();
if ( key == K_DEL ) // Cancellazione
{
if (*ss.cell(r,ss.cid2index( F_AUTOMATICA))==riga_automatica)
return false; // can't remove auto lines directly
while (r < ss.items()-1 && *ss.cell(r+1,ss.cid2index( F_AUTOMATICA))==riga_automatica)
{
// autoremove automatic lines along with the original one
ss.destroy(r+1);
}
m._old_qta.destroy(r, true);
} else
if ( key == K_CTRL + K_DEL ) // Cancellazione
{
m.update_tot();
} else if (key == K_INS) { // Inserimento
if (r < ss.items() && *ss.cell(r,ss.cid2index( F_AUTOMATICA)) == riga_automatica)
{
ss.select(r);
m.send_key(K_CTRL + '+', 0);
return false; // cannot insert between a row and its generated one
}
} else
if (key == K_CTRL + K_INS) { // Inserimento accordato
// Magazzino e Deposito di default: controlla prima quelli della causale,
// quindi se non sono settati, prende quelli di default
TToken_string key;
key.add(m.get(F_TIPOCF));
key.add(m.get(F_CODCF));
TString4 stdmag = cache().get(LF_CFVEN, key, CFV_CODMAG);
TString4 stddep;
if (stdmag.full())
stddep = cache().get(LF_CFVEN, key, CFV_CODDEP);
else
{
const TCausale_magazzino cau(m.get(F_CODCAUS));
if (cau.default_magdep().full())
{
stdmag = cau.default_mag();
stddep = cau.default_dep();
}
else
{
stdmag = m.magazzini().standardmag();
stddep = m.magazzini().standarddep();
}
m._old_qta.insert(new real, r);
}
if (stdmag.full())
{
TToken_string& row = ss.row(r);
row.add(stdmag, ss.cid2index(F_CODMAG));
row.add(stddep, ss.cid2index(F_CODDEP));
}
ss.select(r);
} else
if (key == K_SPACE)
{
old_codcaus = ss.sheet_mask().get(F_CAUSRIG);
if (old_codcaus.blank())
old_codcaus = ss.mask().get(F_CODCAUS);
old_quant = ss.sheet_mask().get_real(F_QUANT);
m.qta_inventory(old_quant);
old_codart = ss.sheet_mask().get(F_CODART);
} else
if (key == K_ENTER)
{
real diff = ss.sheet_mask().get_real(F_QUANT) ;
m.qta_inventory(diff);
if (m.get_bool(F_INVENTORYMODE))
{
if (diff != old_quant)
{
ss.sheet_mask().set(F_QUANT, diff);
ss.row(r).add(diff.string(), ss.cid2index(F_QUANT));
}
}
const TCodice_articolo codart = ss.sheet_mask().get(F_CODART);
if (codart.full())
{
TString8 codcaus = ss.sheet_mask().get(F_CAUSRIG);
if (codcaus.blank())
codcaus = ss.mask().get(F_CODCAUS);
const TCausale_magazzino cau(codcaus);
const int check_giac_neg = cau.get_int("I4");
if (check_giac_neg)
{
real giac = ss.sheet_mask().get_real(F_GIAC);
real* old_qta = (real*)m._old_qta.objptr(r);
if (cau.sgn(s_giac) < 0)
diff = -diff;
if (old_qta != NULL)
diff -= *old_qta;
giac += diff;
if (giac < ZERO)
{
TString msg;
msg.format(FR("Attenzione giacenza negativa per l'articolo %s"), (const char*)codart);
switch (check_giac_neg)
{
case 1: warning_box(msg); break;
case 2: msg << TR("\nSi desidera continuare ugualmente?");
if (!yesno_box(msg))
return false;
break;
default: return error_box(msg); break;
}
}
}
}
if (m.update_rigamov(r,old_codcaus,old_codart,old_quant))
ss.select(r);
m.update_tot();
} else
if (key == K_TAB && !selecting)
{
selecting = true;
ss.select(r, 1);
selecting = false;
}
return true;
}
void TMask_movmag::qta_inventory(real & qta)
{
if (get_bool(F_INVENTORYMODE))
{
const TMask & sm = sfield(F_RIGHE).sheet_mask();
qta -= sm.get_real(F_GIAC);
TString8 codcau(sm.get(F_CAUSRIG));
if (codcau.blank())
codcau = get(F_CODCAUS);
if (codcau.blank())
{
error_box(TR("La causale non e' indicata"));
return;
}
const TCausale_magazzino cau(codcau);
switch (cau.sgn(s_giac))
{
case 1: break;
case -1: qta = -qta; break;
default: break;
}
}
}
// proposta soft: solo se il prezzo <20> non nullo (gi<67> impostato)
bool TMask_movmag::handle_righeprezzo1(TMask_field &f, KEY k)
{
if (f.mask().get(F_PREZZO).blank())
return handle_righeprezzo2(f, k);
return true;
}
// proposta hard: propone il prezzo in ogni caso
bool TMask_movmag::handle_righeprezzo2(TMask_field &f, KEY k)
{
if (k == K_TAB)
{
TMask& m = f.mask();
TMask_movmag& mmm = (TMask_movmag&)m.get_sheet()->mask();
const TString& codart = m.get(F_CODART);
if (f.focusdirty())
{
// propone il prezzo in base alla causale
if (codart.full() && codart != mmm._price_codart)
{
const real prz = mmm.proposed_price(codart, m.get_real(F_QUANT), m.get(F_CAUSRIG));
m.set(F_PREZZO, prz);
}
}
mmm._price_codart = codart;
}
return true;
}
bool TMask_movmag::handle_checksosp(TMask_field &f, KEY k)
{
if (k==K_TAB && f.focusdirty())
{
TMask_movmag& mov_mask = (TMask_movmag &)f.mask().get_sheet()->mask();
TMask & row_mask = f.mask();
TString8 caus(row_mask.get(F_CAUSRIG));
if (caus.empty())
caus = mov_mask.get(F_CODCAUS);
const TCausale_magazzino & c = cached_causale_magazzino(caus);
if (!c.movimenta_sospesi())
{
const bool sospeso = cached_article(row_mask.get(F_CODART)).get_bool(ANAMAG_SOSPESO);
if (sospeso)
return error_box(FR("Articolo %s sospeso, quindi non movimentabile"), (const char *)f.get());
}
}
return true;
}
bool TMask_movmag::handle_codarticolo(TMask_field &f, KEY k)
{
bool ok = true;
if (k==K_TAB && f.focusdirty())
{
TSheet_field * s = f.mask().get_sheet();
TMask_movmag& mov_mask = (TMask_movmag &)s->mask();
TMask & row_mask = f.mask();
TCodice_articolo codart(row_mask.get(F_CODART));
TRectype anamag = cache().get(LF_ANAMAG, codart); // anamag puo' cambiare
if (anamag.empty())
{
TLocalisamfile codalt(LF_CODCORR);
codalt.setkey(2);
codalt.put(CODCORR_CODARTALT, codart);
if (codalt.read() == NOERR)
{
codart = codalt.get(CODCORR_CODART);
anamag = cache().get(LF_ANAMAG, codart);
if (!anamag.empty())
row_mask.set(F_CODART, codart, 0x2);
else
return error_box(TR("Articolo assente"));
}
}
f.check_type(CHECK_REQUIRED);
ok = f.check(STARTING_CHECK);
f.check_type(CHECK_SEARCH);
if (ok)
{
ok = handle_checksosp(f, k);
if (ok)
handle_righeprezzo1(f, k);
}
else
error_box(TR("Articolo assente"));
}
return ok;
}
bool TMask_movmag::handle_causrig(TMask_field &f, KEY k)
{
if (k==K_TAB && f.focusdirty())
{
if (!handle_checksosp(f, k))
return false;
handle_righeprezzo1(f, k);
}
return true;
}
// proposta hard: propone il prezzo in ogni caso
bool TMask_movmag::handle_giacattuale(TMask_field &f, KEY k)
{
TMask & maskrighe =f.mask();
TMask_movmag &maskmov=(TMask_movmag &)maskrighe.get_sheet()->mask();
if (k==K_TAB && (!maskmov.is_running() || f.focusdirty()))
{
TString codliv;
// codici livello
if (livelli_giacenza().enabled())
{
livelli_giacenza().pack_maskgrpcodes(codliv,maskrighe,F_LIV1,4);
codliv.rtrim();
}
TString8 codmag(maskrighe.get(F_CODMAG));
codmag.insert(maskrighe.get(F_CODDEP),3);
const TString& um = maskrighe.get(F_UM);
if (um.not_empty())
{
TArticolo_giacenza & art = cached_article_balances(maskrighe.get(F_CODART));
real disp = art.disponibilita(maskmov.get(F_ANNOES),codmag,codliv,true);
disp = art.convert_to_um(disp, um, NULL, false);
f.set(disp.string());
}
}
return true;
}
bool TMask_movmag::update_rigamov (int r, const char * old_codcaus, const char * old_codart, const real & old_quant)
{
bool added_some=add_autorows(r, old_codcaus, old_codart, old_quant);
if (added_some)
add_explrows(r+1);
added_some |=add_explrows(r);
return added_some;
}
bool TMask_movmag::add_autorows (int r, const char * old_codcaus, const char * old_codart, const real & old_quant)
{
bool added_some=false;
TSheet_field & ss= sfield(F_RIGHE);
real new_factor(ss.cell(r,ss.cid2index(F_QUANT)));
new_factor = old_quant.is_zero() ? ZERO : new_factor / old_quant;
TString8 new_codcaus(ss.cell(r,ss.cid2index(F_CAUSRIG)));
if (new_codcaus.blank())
new_codcaus=get(F_CODCAUS);
const TCausale_magazzino oldcau(old_codcaus);
const TCausale_magazzino cau(new_codcaus);
bool rimuovi_righe_coll=false;
bool inserisci_righe_coll= *cau.caus_collegata()!='\0' && *ss.cell(r,ss.cid2index(F_ESPLOSA)) == ' ';
if (inserisci_righe_coll)
{
// *******************************
// deve esserci una riga collegata
const TCausale_magazzino cau_coll(cau.caus_collegata());
if (old_codcaus != new_codcaus)
{
rimuovi_righe_coll = true;
}
else
if ((r < ss.items()-1 && *ss.cell(r+1,ss.cid2index( F_AUTOMATICA)) == riga_automatica)
&& cau_coll.esplodente())
{
if (strcmp(old_codart,ss.cell(r,ss.cid2index( F_CODART)))!=0 )
// ho cambiato il codice articolo del finito: rimuovo le righe automatiche esplose
rimuovi_righe_coll = true;
else
inserisci_righe_coll=false;
}
}
else
if (*oldcau.caus_collegata()!='\0') // ho cambiato causale, passando ad una che non ha collegamenti
rimuovi_righe_coll=true;
// ******************
if (rimuovi_righe_coll)
{
while (r < ss.items()-1
&& *ss.cell(r+1,ss.cid2index( F_AUTOMATICA)) == riga_automatica)
ss.destroy(r + 1);
}
// ******************
if (inserisci_righe_coll)
{
const TCausale_magazzino cau_coll(cau.caus_collegata());
TString8 mag, dep;
mag = cau_coll.default_mag();
dep = cau_coll.default_dep();
TString tmpstr;
int offset=1;
const int items = ss.items();
#define COPIA_SU_AUTO(colnum) {tmpstr=(ss.row(r).get(ss.cid2index(colnum))); ss.row(r+offset).add(tmpstr,ss.cid2index(colnum));}
if ((r == ss.items()-1 || r < ss.items()-1 && *ss.cell(r+1,ss.cid2index( F_AUTOMATICA)) != riga_automatica))
{
const int row_to_add = r + offset;
// manca, la inserisco
TToken_string & newrow = ss.row(row_to_add);
newrow = ss.row(r);
ss.disable_row(row_to_add);
ss.enable_cell(row_to_add, ss.cid2index(F_CODMAG));
ss.enable_cell(row_to_add, ss.cid2index(F_CODDEP));
newrow.add(TString(1,riga_automatica),ss.cid2index(F_AUTOMATICA));
if (cau_coll.has_default_mag())
newrow.add(mag,ss.cid2index(F_CODMAG));
if (cau_coll.has_default_dep())
newrow.add(dep,ss.cid2index(F_CODDEP));
newrow.add(cau.caus_collegata(),ss.cid2index(F_CAUSRIG));
COPIA_SU_AUTO(F_PREZZO);
return true;
} \
while (r+offset < ss.items() && *ss.cell(r+offset,ss.cid2index( F_AUTOMATICA))==riga_automatica)
{
// riporta eventuali cambiamenti della riga "Master" sulle righe automatice
if (*ss.cell(r+offset,ss.cid2index( F_ESPLOSA)) <=' ')
{
COPIA_SU_AUTO(F_CODART);
COPIA_SU_AUTO(F_LIV1);
COPIA_SU_AUTO(F_LIV2);
COPIA_SU_AUTO(F_LIV3);
COPIA_SU_AUTO(F_LIV4);
COPIA_SU_AUTO(F_UM);
COPIA_SU_AUTO(F_QUANT);
ss.row(r+offset).add(cau.caus_collegata(),ss.cid2index(F_CAUSRIG));
ss.check_row(r+offset);
ss.force_update(r+offset);
} else {
if (new_factor != 1.0)
{
real q(ss.row(r+offset).get(ss.cid2index(F_QUANT)));
q*=new_factor;
tmpstr=q.string();
ss.row(r+offset).add(tmpstr,ss.cid2index(F_QUANT));
ss.force_update(r+offset);
}
}
offset++;
}
}
return added_some;
}
bool TMask_movmag::add_explrows(int r)
{
TSheet_field& sheet = sfield(F_RIGHE);
TString8 new_codcaus(sheet.cell(r,sheet.cid2index(F_CAUSRIG)));
if (new_codcaus.blank())
new_codcaus=get(F_CODCAUS);
bool added_some=false;
const TCausale_magazzino cau(new_codcaus);
TArticolo articolo;
if (cau.esplodente() && *sheet.cell(r,sheet.cid2index(F_ESPLOSA)) == ' ')
{
TDistinta_tree distinta;
TArticolo articolo;
TArray boom;
// *******************************
// c'e' una riga di movimento esplodente non ancora esplosa:
// va sostituita con n righe esplose
real prezzo,quant;
const char tipo_costo = cau.get_char("S11");
const int livello = cau.get_int("I0");
const TString codart = sheet.cell(r,sheet.cid2index(F_CODART));
bool ok = distinta.set_root(codart);
const int rigaprec = r - 1;
const bool is_coll = rigaprec >= 0 && *sheet.cell(r, sheet.cid2index(F_AUTOMATICA)) == riga_automatica;
if (ok)
{
distinta.explode(boom, true, RAGGR_EXP_NONE, livello, "A");
for (int newrow=0; newrow < boom.items() ; newrow++)
{
TRiga_esplosione & riga_esp=(TRiga_esplosione & )(boom[newrow]);
sheet.insert(r+newrow+1);
TToken_string & nuova_riga=sheet.row(r+newrow+1);
nuova_riga=sheet.row(r);
nuova_riga.add(riga_esp.articolo() ,sheet.cid2index(F_CODART));
nuova_riga.add(riga_esp.um() , sheet.cid2index(F_UM));
quant=sheet.row(r).get(sheet.cid2index(F_QUANT));
quant*=riga_esp.val();
nuova_riga.add(quant.string() , sheet.cid2index(F_QUANT));
articolo.read(riga_esp.articolo());
char coll_type = articolo.get_char(ANAMAG_COLLTYPE);
TString16 codmag;
if (coll_type == 'M')
{
if (is_coll)
codmag = *sheet.cell(rigaprec, sheet.cid2index(F_CODMAG));
}
else
if (coll_type == 'F')
{
TString key("F|");
key << articolo.get(ANAMAG_CODFORN);
codmag = cache().get(LF_CFVEN, key, CFV_CODMAG);
}
else
if (coll_type == 'A')
codmag = articolo.get(ANAMAG_CODMAG);
if (codmag.not_empty())
{
const TString8 mag(codmag.left(3));
const TString8 dep(codmag.mid(3));
nuova_riga.add(mag ,sheet.cid2index(F_CODMAG));
nuova_riga.add(dep ,sheet.cid2index(F_CODDEP));
}
articolo.read(riga_esp.articolo());
if (tipo_costo == 'U')
prezzo = articolo.get_real(ANAMAG_ULTCOS1);
else
if (tipo_costo == 'S')
prezzo = articolo.get_real(ANAMAG_COSTSTD);
if (!prezzo.is_zero())
nuova_riga.add(prezzo.string(),sheet.cid2index(F_PREZZO));
nuova_riga.add("X",sheet.cid2index(F_ESPLOSA));
sheet.check_row(r+1+newrow);
sheet.force_update(r+1+newrow);
added_some=true;
}
// elimino la riga "padre"
if (boom.items() > 0)
{
if (boom.items() == 1 && codart == ((TRiga_esplosione &)boom[0]).articolo())
error_box(TR("Distinta %s ciclica"), (const char *)codart);
sheet.destroy(r);
}
else
message_box(FR("Impossibile esplodere l'articolo %s"), (const char *)codart);
}
}
return added_some;
}
real TMask_movmag::proposed_price(const char *codart, real quant, const char *causrig)
{
real rv;
const TCausale_magazzino cau(causrig && *causrig ? causrig : (const char *)get(F_CODCAUS));
const char tipoprz = cau.tipoprz();
if (tipoprz == 'P' || tipoprz == 'C') // Se e' Libero non devo far nulla
{
TLocalisamfile anamag(LF_ANAMAG);
anamag.put("CODART",codart);
anamag.read();
TConfig cfgditta(CONFIG_DITTA);
TLocalisamfile umart(LF_UMART);
TCondizione_vendita cv(&cfgditta,&anamag,&umart);
cv.put_listino(get(F_CODLIST),get(F_CATVEN));
switch (tipoprz)
{
// prezzo
case 'P':
cv.ricerca(codart,quant,false); // Considera UMART
rv=cv.get_prezzo();
break;
// costo
case 'C':
cv.ricerca(codart,quant,true); // Ignora UMART
rv=cv.get_prezzo();
if (rv.is_zero())
rv=anamag.get_real("ULTCOS1");
break;
default:
break;
}
}
return rv;
}
bool TMask_movmag::handle_codcaus(TMask_field &fld, KEY k)
{
static TString8 old_codcaus;
if (k == K_TAB && fld.focusdirty() && old_codcaus!="")
{
// aggiorna le righe di sheet
TMask_movmag &m=(TMask_movmag &)fld.mask();
TSheet_field & ss=(TSheet_field & )m.field(F_RIGHE);
bool added_some = false;
// aggiorna le righe che dipendono dalla causale movimento
for (int i=0; i< ss.items(); i++)
{
if (*ss.cell(i,ss.cid2index(F_CAUSRIG)) ==' ')
added_some &=(m.update_rigamov(i,old_codcaus,ss.cell(i,ss.cid2index(F_CODART)), real(ss.cell(i,ss.cid2index(F_QUANT)))));
}
if (added_some)
{
ss.dirty();
ss.set_focus();
}
}
if (k == K_TAB)
old_codcaus=fld.get();
return true;
}
bool TMask_movmag::handle_datacomp(TMask_field &fld, KEY k)
{
if (k == K_TAB)
{
TMask& m = fld.mask();
const TDate dt = fld.get();
const int codes = esercizi().date2esc(dt);
if (codes > 0)
{
m.set(F_ANNOES, codes);
m.set(H_ANNOES, codes);
}
else
return fld.error_box(TR("La data di competenza non appartiene a nessun esercizio contabile")) ;
}
return true;
}
bool TMask_movmag::handle_datareg(TMask_field &fld, KEY k)
{
if (k == K_TAB || k == K_ENTER)
{
const TMask& m = fld.mask();
const TDate dt = fld.get();
const int codes = esercizi().date2esc(dt);
if (codes <= 0)
return fld.error_box(TR("La data di registrazione non appartiene a nessun esercizio contabile")) ;
const TDate dc = m.get(F_DATACOMP);
if (dt < dc)
return fld.error_box(TR("La data di registrazione non puo' precedere quella di competenza")) ;
}
return true;
}
class TApp_movmag: public TRelation_application
{
TMask_movmag *_msk; // maschera principale
TRelation * _rel; // relazione contenente il file movimenti
protected:
virtual bool user_create();
virtual bool user_destroy();
virtual TMask *get_mask(int) { return _msk; }
virtual void init_query_mode(TMask&) ;
virtual void init_insert_mode(TMask&) ;
virtual void init_modify_mode(TMask&) ;
virtual bool changing_mask(int) { return false; }
virtual TRelation *get_relation() const { return _rel; }
virtual bool get_next_key(TToken_string& key);
virtual int read(TMask& m);
virtual bool protected_record(TRectype& rec);
};
inline TApp_movmag& app() { return (TApp_movmag&) main_app(); }
int TApp_movmag::read(TMask& m)
{
const int err = TRelation_application::read(m);
if (err == NOERR)
((TMask_movmag&)m).update_tot();
return err;
}
void TApp_movmag::init_query_mode(TMask& m)
{
_msk->set_shift_f12(false);
m.enable(F_INVENTORYMODE);
TRelation_application::init_query_mode(m);
}
void TApp_movmag::init_modify_mode(TMask& m)
{
m.disable(F_INVENTORYMODE);
const bool inventory = m.get_bool(F_INVENTORYMODE);
TSheet_field& ss = m.sfield(F_RIGHE);
ss.sheet_mask().field(F_QUANT).check_type(inventory ? CHECK_NONE : CHECK_REQUIRED);
TRelation_application::init_modify_mode(m);
FOR_EACH_SHEET_ROW(ss, i, row)
{
if (row->get_char(0) > ' ') // Tipo riga automatico
{
ss.disable_row(i);
ss.enable_cell(i, ss.cid2index(F_CODMAG));
ss.enable_cell(i, ss.cid2index(F_CODDEP));
}
}
}
void TApp_movmag::init_insert_mode(TMask& m)
{
m.disable(F_INVENTORYMODE);
const bool inventory = m.get_bool(F_INVENTORYMODE);
TSheet_field& ss = m.sfield(F_RIGHE);
ss.sheet_mask().field(F_QUANT).check_type(inventory ? CHECK_NONE : CHECK_REQUIRED);
((TMask_movmag&)m).old_qta().destroy();
for (int i = ((TMask_movmag&)m).autorows(); i > 0; i--)
ss.insert(-1, false, true);
TRelation_application::init_insert_mode(m);
}
bool TApp_movmag::user_create()
{
open_files(LF_ANAMAG, LF_UMART, LF_CODCORR, LF_DESLIN, LF_MOVMAG,LF_RMOVMAG, LF_MAG, LF_STOMAG, LF_TABCOM, 0);
TMov_mag* m_m = new TMov_mag(); // record del movimento di magazzino
m_m->enable_autoload(LF_RMOVMAG);
// maschera specifica con gli handler dei movimenti
_msk= new TMask_movmag(m_m);
// relazione con un solo file (LF_MOVMAG) ma col record Head_Body
_rel= new TRelation(LF_MOVMAG);
_rel->lfile().set_curr(m_m);
return true;
}
bool TApp_movmag::user_destroy()
{
delete _rel;
delete _msk;
return true;
}
// autonumerazione
bool TApp_movmag::get_next_key(TToken_string& nextcod)
{
const char* nk = ((TMov_mag &)_rel->curr()).get_next_key();
nextcod.format("%d|%s", F_NUMREG, nk);
return true;
}
bool TApp_movmag::protected_record(TRectype& rec)
{
bool prot = false;
if (!_msk->get_shift_f12())
{
TLocalisamfile rmov(LF_RMOVMAG);
rmov.put(RMOVMAG_NUMREG, rec.get(RMOVMAG_NUMREG));
rmov.put(RMOVMAG_NRIG, 1);
if (rmov.read() == NOERR)
prot = rmov.get_char(RMOVMAG_TIPORIGA) == riga_dadocumento;
}
return prot;
}
int mg1100(int argc, char* argv[])
{
TApp_movmag a;
a.run(argc, argv, TR("Movimenti di magazzino"));
return 0;
}
Reference in New Issue View Git Blame Copy Permalink