root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/src/cg/cg2100.cpp
bonazzi ead18cd8f5 Patch level : 12.0 488 
Files correlati     : cg0.exe cg0500a.msk cg2.exe cg4.exe

Reverse charge :
Implemetata la possibilità di mettere il fornitore sulla regolarizzazione.
Nelle causali di sola iva si può mettere un fornitore anche se identificano un registro delle vendite.
Il movimento di regolarizzazione viene creato come prima se inserisco un cliente corrispondente altrimenti viene usato il codice del fornitore stesso.
Fatture in ritardo :
implementata la gestione delle fatture in ritardo (con data documento anno precedente). Fino ad aprile le fatture non vengono detratte e vengono poi detratte a Maggio come credito. Da maggio in poi sono indetraibili.
Sul registro le fatture vengono identificate con tipo documento e "CD" quelle fino ad aprile e con tipo documento e "CI" quelle fino da maggio in poi.



git-svn-id: svn://10.65.10.50/branches/R_10_00@24241 c028cbd2-c16b-5b4b-a496-9718f37d4682
2017-12-19 23:31:20 +00:00

2597 lines
77 KiB
C++
Executable File
Raw Blame History

#include "cg2102.h"
#include "cg21sld.h"
#include "cgpagame.h"
#include "../ca/movana.h"
#include "../in/inlib01.h"
#include <dongle.h>
#include <execp.h>
#include <mailbox.h>
#include <modaut.h>
#include <recset.h>
#include <urldefid.h>
#include <utility.h>
// Campi su file
#include <clifo.h>
#include <cfven.h>
#include <causali.h>
#include <rcausali.h>
// Campi su maschera
#include "cg2100.h"
///////////////////////////////////////////////////////////
// Dati incasso immediato
///////////////////////////////////////////////////////////
class TDati_mov_auto : public TObject
{
public:
int _tipo, _step;
TString4 _causale, _codiva;
TBill _clifo;
TDate _datadoc, _datareg;
TString8 _numdoc;
real _totale;
TString4 _causale_originale;
TipoIVA _iva_originale;
};
///////////////////////////////////////////////////////////
// Applicazione principale
///////////////////////////////////////////////////////////
TPrimanota_application::TPrimanota_application()
: _rel(NULL), _mode(0), _iva(nessuna_iva), _causale(NULL), _giornale(NULL),
_lastreg(0), _last_dreg(TODAY), _last_dcom(TODAY), _automatico(NULL), _swap_mask(false)
{
memset(_msk, 0, sizeof(_msk));
}
TMask* TPrimanota_application::load_mask(int n)
{
if (_msk[n] != NULL)
return _msk[n];
TString8 name = "cg2100"; name << char(n == 3 ? 'o' : 'a'+n);
TMask* m = new TMask(name);
switch (n)
{
case 0:
if (m)
{
m->set_handler(F_NUMREG, num_handler);
m->set_handler(F_CODCAUS, caus_query_handler);
m->set_handler(F_DATAREG, datareg_handler);
m->set_handler(DLG_CONFIG, colors_handler);
TConfig c(CONFIG_STUDIO, "cg");
// Scelta primo campo col focus
_firstfocus = c.get_bool("PoCuDr") ? F_DATAREG : F_CODCAUS;
m->first_focus(_firstfocus);
// Registra e inserisci immediatamente un nuovo movimento
_savenew = !c.get_bool("Cg21SN");
}
break;
case 2: // 2100c
if (m)
{
m->set_handler(F_DATA74TER, data74ter_handler);
m->set_handler(F_PROTIVA, protiva_handler);
m->set_handler(F_CLIENTE, clifo_handler);
m->set_handler(F_FORNITORE, clifo_handler);
m->set_handler(F_RITFIS, ritfis_handler);
m->set_handler(F_RITSOC, ritsoc_handler);
m->set_handler(F_CORRISPETTIVO, corrlire_handler);
m->set_handler(F_CORRVALUTA, corrvaluta_handler);
m->set_handler(F_DATAINTRA, dataintra_handler);
m->set_handler(F_CODIVA, main_codiva_handler);
if (_liqdiff)
m->set_handler(F_LIQDIFF, liqdiff_handler);
m->set_handler(F_IVAXCASSA, ivaxcassa_handler);
m->set_handler(F_OCCASEDIT, occas_handler);
m->set_handler(F_SOLAIVA, solaiva_handler);
m->set_handler(F_REVCHARGE, revcharge_handler);
m->set_handler(F_SHEETIVA, iva_handler);
m->show(F_LIQDIFF, _liqdiff);
m->set_handler(F_NUMDOCEXT, ndocext_handler);
TSheet_field& is = m->sfield(F_SHEETIVA);
is.set_notify(iva_notify);
TMask& ism = is.sheet_mask();
ism.set_handler(101, imponibile_handler);
ism.set_handler(102, codiva_handler);
ism.set_handler(103, detrazione_handler);
ism.set_handler(104, imposta_handler);
ism.set_handler(107, cg_gruppo_handler);
ism.set_handler(109, iva_sottoconto_handler);
ism.set_handler(110, iva_sottoconto_handler);
ism.set_handler(209, sheet_clifo_handler);
ism.set_handler(309, sheet_clifo_handler);
ism.set_handler(CG_RATEO, sheet_rateo_handler);
ism.set_handler(CG_RISCONTO, sheet_risconto_handler);
if (_quadratura)
m->set_handler(F_ADJUST_IVA, quadratura_handler);
}
case 1: // 2100b
if (m)
{
m->first_focus(_firstfocus);
m->set_handler(F_DATAREG, datareg_handler);
m->set_handler(F_DATACOMP, datacomp_handler);
m->set_handler(F_DATADOC, datadoc_handler);
m->set_handler(F_NUMDOC, numdoc_handler);
m->set_handler(F_DESCR, descr_handler);
m->set_handler(F_CODCAUS, caus_modify_handler);
m->set_handler(F_TOTALE, totdoc_handler);
m->set_handler(F_SHEETCG, cg_handler);
m->set_handler(SK_VALUTA, valuta_handler);
m->set_handler(SK_DATACAMBIO, datacambio_handler);
m->set_handler(SK_CAMBIO, cambio_handler);
m->set_handler(SK_TOTDOCVAL, totdocval_handler);
m->set_handler(F_CODPAG, codpag_handler);
m->set_handler(F_LINKDOC, linkdoc_handler);
m->set_handler(F_MASTRINO, mastrino_handler);
m->enable(F_MASTRINO, !is_transaction());
m->set_handler(F_NUMDOCEXT, ndocext_handler);
TSheet_field& cg = m->sfield(F_SHEETCG);
cg.set_notify(cg_notify);
TMask& cgm = cg.sheet_mask();
cgm.set_handler(CG_DARE, dareavere_handler);
cgm.set_handler(CG_AVERE, dareavere_handler);
// cgm.set_handler(CG_TIPO, cg_tipo_handler);
cgm.set_handler(CG_GRUPPO, cg_gruppo_handler);
cgm.set_handler(CG_CONTO, cg_conto_handler);
cgm.set_handler(CG_SOTTOCONTO, cg_sottoconto_handler);
cgm.set_handler(CG_SOTTOCONTO + 100, sheet_clifo_handler);
cgm.set_handler(CG_SOTTOCONTO + 200, sheet_clifo_handler);
cgm.set_handler(113, suspended_handler); // Contropartita
cgm.set_handler(213, sheet_clifo_handler);
cgm.set_handler(313, sheet_clifo_handler);
cgm.set_handler(CG_MASTRINO, sheet_mastrino_handler);
cgm.set_handler(CG_RATEO, sheet_rateo_handler);
cgm.set_handler(CG_RISCONTO, sheet_risconto_handler);
// Se esiste lo sheet delle rate
if (is_fattura())
{
TSheet_field& ps = m->sfield(FS_RATESHEET);
ps.set_notify(pag_notify);
m->set_handler(FS_RATESHEET, pag_sheet_handler);
m->set_handler(F_ANNORIF, annorif_handler);
m->set_handler(F_NUMRIF, numrif_handler);
m->set_handler(FS_RESET, reset_handler);
m->set_handler(FS_NRATE, nrate_handler);
m->set_handler(FS_RECALC, recalc_handler);
m->set_handler(FS_NSCAB, codcab_handler);
m->set_handler(FS_VSCAB, codcab_handler);
TMask& sm = ps.sheet_mask();
sm.set_handler(102, rataeur_handler);
sm.set_handler(103, rataval_handler);
sm.set_handler(105, tipopag_handler);
sm.set_handler(106, tipopag_handler);
}
if (ini_get_bool(CONFIG_DITTA, "cg", "GesContSep"))
{
m->show(NP_CONTSEP);
m->show(NP_DESCONTSEP);
}
else
{
m->hide(NP_CONTSEP);
m->hide(NP_DESCONTSEP);
}
}
break;
case 3:
m->set_handler(O_CODICE, occas_code_handler);
m->set_handler(O_COFI, occas_cfpi_handler);
m->set_handler(O_PAIV, occas_cfpi_handler);
break;
default:
CHECKD(0, "Che ca$$o di maschera <20> la ", n);
break;
}
_msk[n] = m;
return m;
}
bool TPrimanota_application::user_create()
{
open_files(LF_TABCOM, LF_TAB, LF_CAUSALI, LF_RCAUSALI, LF_CLIFO, LF_PCON, 0);
open_files(LF_ATTIV, LF_COMUNI, LF_OCCAS, LF_NDITTE, 0);
open_files(LF_MOV, LF_RMOV, LF_RMOVIVA, LF_SALDI, 0);
open_files(LF_PARTITE, LF_SCADENZE, LF_PAGSCA, LF_AGENTI, 0);
_automatico = new TDati_mov_auto;
_rel = new TMovimentoPN;
_rel->add(LF_PARTITE, "NREG=NUMREG", 2); // Collega la partita aperta dalla fattura
_causale = new TCausale();
_giornale = new TLibro_giornale();
set_search_field(F_NUMREG); // Set field for default search
_pag = NULL;
_is_saldaconto = false;
TFilename tmp;
if (get_mask_swap_file(tmp))
tmp.fremove();
load_mask(0);
load_colors();
return true;
}
bool TPrimanota_application::save_and_new() const
{
return _savenew || _automatico->_step == 1; // Rimane in inserimento del reverse charge
}
bool TPrimanota_application::save_and_quit() const
{
bool quit = TRelation_application::save_and_quit();
if (quit && _automatico->_step == 1)
{
if (TRelation_application::is_transaction())
app().edit_mask2ini(); // Fool const
quit = false; // Impedisce di uscire durante il reverse charge
}
return quit;
}
bool TPrimanota_application::is_transaction() const
{
bool trans = TRelation_application::is_transaction();
if (trans && _automatico->_step > 0)
trans = false; // Non devo considerare come facenti parte della transazione i movimenti automatici
return trans;
}
bool TPrimanota_application::user_destroy()
{
for (int m = 3; m >= 0; m--)
if (_msk[m] != NULL) delete _msk[m];
if (_pag) delete _pag;
delete _giornale;
delete _causale;
delete _rel;
delete _automatico;
return true;
}
// Legge la causale di codice cod ed il relativo registro dell'anno year
// Certified 99%
bool TPrimanota_application::read_caus(const char* cod, int year)
{
bool ok = true;
if (cod != NULL)
{
ok = causale().read(cod, year);
_iva = causale().iva();
}
bool nob = false, dob = false;
_is_saldaconto = false;
const TipoIVA iva = ok ? causale().iva() : nessuna_iva;
TMask* m = _msk[iva == nessuna_iva ? 1 : 2];
const TDate datareg = m ? m->get(F_DATAREG) : _rel->curr().get(MOV_DATAREG);
if (ok)
{
_is_saldaconto = gestione_saldaconto() && causale().saldaconto(datareg);
dob = is_fattura() || causale().data_doc();
nob = is_fattura() || causale().num_doc();
}
// Se sono chiamato dai campi di query ho belle che finito
if (_mode == MODE_QUERY || m == NULL)
return true;
const bool ins = check_insert_mode();
m->efield(F_NUMDOC).check_type(nob ? CHECK_REQUIRED : CHECK_NORMAL); // Num. doc. obbligatorio
m->efield(F_DATADOC).check_type(dob ? CHECK_REQUIRED : CHECK_NORMAL); // Data doc. obbligatoria
const bool nota_credito = is_nota_credito();
const bool show_games = is_pagamento() || nota_credito;
TSheet_field& cgsheet = m->sfield(F_SHEETCG);
TMask& cgm = cgsheet.sheet_mask();
cgm.set_handler(DLG_USER, show_games ? showpartite_handler : NULL); // bottoncino riga
cgm.enable(DLG_USER, show_games);
if (iva == nessuna_iva)
{
m->enable(F_PROVVISORIO, !_is_saldaconto); // Il saldaconto vieta i movimenti provvisori
m->show(SK_TIPORIGA, is_pagamento()); // Abilita scelta tipo riga
m->enable(SK_TIPORIGA);
activate_numrif(*m, false);
}
else
{
m->efield(F_CODPAG).enable(!nota_credito);
m->efield(F_DESPAG).enable(!nota_credito);
TEdit_field& numrif = m->efield(F_NUMRIF);
numrif.set_justify(iva == iva_acquisti ? _num_for : _num_cli);
numrif.set_trim(!numrif.right_justified());
activate_numrif(*m, false);
TCausale& c = causale();
const bool av = c.reg().agenzia_viaggi();
m->show(F_DATA74TER, av);
if (!av) m->reset(F_DATA74TER);
TRegistro& r = c.reg();
const bool reg_vendite = r.iva() == iva_vendite && !r.corrispettivi();
const bool show_notevar = iva == iva_vendite || iva == iva_acquisti;
TSheet_field& ivasheet = m->sfield(F_SHEETIVA);
ivasheet.enable_column(IVA_NOTAVARECF, show_notevar);
ivasheet.sheet_mask().enable(IVA_NOTAVARECF, show_notevar);
}
if (ins && !ci_sono_importi(cgsheet))
{
cgsheet.reset();
for (int i = 1; i < causale().size(); i++)
{
const TRectype* rcaus = (TRectype*)causale().objptr(i);
if (rcaus == NULL) continue; // Evita eventuali righe nulle
const int nriga = rcaus->get_int(RCA_NRIGA);
if (nriga <= 0) continue; // Considera solo righe reali (non riempimenti)
TBill tc; causale().bill(nriga, tc);
if (tc.gruppo() <= 0) continue; // Considera solo gruppi validi
if (tc.tipo() > ' ' && tc.ok())
{
TBill clifo(0, 0, tc.sottoconto(), tc.tipo());
if (clifo.find() && clifo.conto() != 0) // Legge gruppo e conto
tc = clifo;
}
int err = 0;
if (tc.descrizione() == TR("Sconosciuto"))
err = 1; else
if (tc.sospeso())
err = 2;
if (err)
{
error_box(FR("Il conto della riga %d della causale <20> %s"),
i, err == 1 ? TR("sconosciuto") : TR("sospeso"));
}
const char sezione = rcaus->get_char(RCA_SEZIONE);
const TImporto zero('D', ZERO);
const TString80 desc(causale().desc_agg(i));
if (nriga == 1) m->set(F_DESCR, desc);
if (iva == nessuna_iva)
{
char tipr = ' ';
if (is_pagamento())
{
if (nriga <= RIGA_PAG_RITSOC && nriga != RIGA_SPESE)
continue; // Si considerano solo le spese
tipr = 'G';
}
const int pos = set_cgs_row(-1, zero, tc, desc, tipr);
if (sezione > ' ')
cgsheet.disable_cell(pos, sezione == 'A' ? 0 : 1);
}
else
{
if (nriga >= 2 && nriga <= RIGA_REVERSE_CHARGE)
continue; // Conti per IVA detraibile e non, ritenute sociali e fiscali
const char tipo = nriga == 1 ? 'T' : ' ';
if (nriga == 1 && tc.tipo() > ' ' && tc.ok())
{
m->set(tc.tipo() == 'C' ? F_CLIENTE : F_FORNITORE, tc.sottoconto());
}
set_cgs_row(-1,zero,tc,desc,tipo);
}
}
fill_sheet(*m);
}
return ok;
}
// Certified 100%
void TPrimanota_application::print()
{
TExternal_app stampa("cg3 -0");
stampa.run();
}
bool TPrimanota_application::changing_mask(int mode)
{
if (mode == MODE_QUERY)
{
const bool flag = _mode != MODE_QUERY;
return flag;
}
_iva = iva_errata;
return true;
}
TMask* TPrimanota_application::get_mask(int mode)
{
int annoiva = 0;
TString4 caus;
_mode = mode;
switch (mode)
{
case MODE_INS:
annoiva = _msk[0]->get_int(F_ANNOIVA);
caus = _msk[0]->get(F_CODCAUS);
break;
case MODE_MOD:
annoiva = _rel->curr().get_int(MOV_ANNOIVA);
caus = _rel->curr().get(MOV_CODCAUS);
break;
default:
return load_mask(0);
}
if (giornale().year() != annoiva)
giornale().read(annoiva);
const TCausale& c = causale();
if (caus != c.codice() || (c.iva() != nessuna_iva && c.reg().year() != annoiva))
read_caus(caus, annoiva);
_iva = c.iva();
return load_mask(_iva == nessuna_iva ? 1 : 2);
}
bool TPrimanota_application::get_mask_swap_file(TFilename& name) const
{
name.tempdir(); name.add("cg2100.ini");
return name.exist();
}
bool TPrimanota_application::force_mask_swap(const TCausale& old_caus, const TCausale& new_caus)
{
TMask& old = curr_mask();
// Resetto il flag di dirty per non chiedere di salvare cose inutili
for (int i = old.fields()-1; i >= 0; i--)
{
TMask_field& f = old.fld(i);
f.set_dirty(false);
}
if (old.dirty())
return false;
// Salvo la maschera corrente in un apposito file temporaneo "cg2100.ini"
TFilename tmp; get_mask_swap_file(tmp);
TConfig ini(tmp);
TRelation_application::mask2ini(old, ini); // Non devo salvare le righe degli sheet
ini.set_paragraph("23");
ini.remove(MOV_NUMREG); // Tolgo numero di registrazione provvisorio
if (old_caus.iva() != nessuna_iva && new_caus.iva() != nessuna_iva)
{
// Salvo un campo virtuale col codice IVA
ini.set("CODIVA", old.get(F_CODIVA)); // Campo virtuale non presente in testata
}
if (old_caus.iva() != new_caus.iva() || old_caus.corrispettivi() != new_caus.corrispettivi())
{
ini.remove(MOV_CODCF); // Tolgo il codice cliente, che potrebbe infornitorirsi
}
ini.remove(MOV_PROVVIS);
_swap_mask = true;
old.stop_run(K_ESC);
return true;
}
void TPrimanota_application::on_firm_change()
{
TRelation_application::on_firm_change(); // May be useful, who knows?
_lastreg = 0;
TLocalisamfile& m = _rel->lfile();
TWait_cursor hourglass;
int err = m.last();
if (err != _isemptyfile)
{
while (err == _islocked)
{
xvt_sys_sleep(1000);
err = m.last();
}
_lastreg = m.get_long(MOV_NUMREG); // Init last registration number
}
_esercizi.update(); // Init exercises
}
void TPrimanota_application::on_config_change()
{
TConfig cnf(CONFIG_DITTA, "cg");
_ges_val = cnf.get_bool("GesVal");
_ges_sal = cnf.get_bool("GesSal");
_easy_sal = _ges_sal && cnf.get_bool("EasySal", NULL, -1, false) && xvt_vobj_get_attr(NULL_WIN, ATTR_APPL_VERSION_YEAR) > 2101;
_npart_is_prot = cnf.get_bool("RifPro");
_npart_is_month = cnf.get_bool("RifMonth");
_liqdiff = cnf.get_bool("GesLiqDiff");
_num_cli = cnf.get_bool("NrCliDx");
_num_for = cnf.get_bool("NrForDx");
_quadratura = cnf.get_bool("QuadraturaIVA"); // Accende bottone di quadratura
_perc_attesa_fld = cnf.get("PercAttField");
TPartita::carica_allineamento();
}
void TPrimanota_application::init_mask(TMask& m)
{
disable_menu_item(M_FILE_PRINT);
disable_menu_item(M_FONT);
read_caus(NULL, 0); // Setta campi obbligatori
if (_iva == nessuna_iva)
{
m.show(-5, _is_saldaconto); // Abilita campi saldaconto
m.show(-6, _is_saldaconto && is_fattura()); // Abilita gestione rate
m.show(K_RESIDUO, _is_saldaconto && !is_fattura());
}
else
{
const TCausale& cc = causale();
const bool corrisp = cc.corrispettivi();
bool clig = false, forg = false;
if (_iva == iva_acquisti)
forg = true;
else
clig = corrisp ? false : true;
// Mostra i gruppo clienti ed eventualmente quello fornitori
if (clig)
{
m.show(-2, forg);
m.show(-1, clig);
}
else
{
m.show(-1, clig);
m.show(-2, forg);
}
m.hide(-7); // Nascondi tutti i campi del modulo FE
if (corrisp)
m.hide(F_STATOPAIV);
// Show/Hide campi valuta: F_VALUTAINTRA, F_CAMBIOINTRA, F_CORRISPETTIVO, F_CORRVAL (GROUP 4)
m.show(-4, cc.valintra());
m.show(F_DATAINTRA, cc.intra());
m.show(F_CODIVA, m.insert_mode()); // Codice IVA standard
TSheet_field& is = ivas();
is.enable_column(2, _iva == iva_acquisti); // Tipo detrazione
is.enable_column(4, !m.insert_mode()); // Tipo costo ricavo
if (is_fattura())
{
const TPartita* game = partite().first();
_scad_free = game == NULL || !game->esistono_abbuoni_diffcam(m.get_long(F_NUMREG));
if (m.edit_mode() && !_scad_free)
m.enable(DLG_DELREC, _scad_free); // Disabilita tasto elimina
m.enable(-1, _scad_free); // Disabilita cliente
m.enable(-2, _scad_free);
m.enable(F_ANNORIF, _scad_free); // Disabilita anno e numero partita
m.enable(F_NUMRIF, _scad_free);
m.enable(F_SOLAIVA, _scad_free); // Disabilita movimenti di sola IVA
m.enable(F_CODPAG, _scad_free); // Disabilita codice pagamento
m.enable(F_DESPAG, _scad_free); // Disabilita descrizione pagamento
m.enable(FS_RESET, _scad_free); // Disabilita tasto di reset
if (!_scad_free)
m.set(FS_RECALC, "", true); // Disabilita ricalcolo automatico
m.enable(FS_RECALC, _scad_free);
}
m.show(F_ADJUST_IVA, _quadratura);
TMask_field* ixc = m.find_by_id(F_IVAXCASSA);
if (ixc)
{
const TDate dr = m.get(F_DATAREG);
ixc->enable(gestione_IVAxCassa(dr));
}
TEdit_field& rc = m.efield(F_REVCHARGE);
rc.show(cc.iva() == iva_acquisti && cc.reverse_charge());
activate_split_payment(m);
}
// Show/Hide campi valuta: F_VALUTA, F_CAMBIO, F_DATACAMBIO (GROUP 3)
const bool valuta = _ges_val && is_saldaconto() && causale().valuta();
m.show(-3, valuta);
_sal_dirty = false; // Azzero il flag di modifica del saldaconto
fill_sheet(m); // Riempe righe contabili coi conti della causale
m.hide(F_LINKDOC);
}
void TPrimanota_application::init_query_mode(TMask& m)
{
disable_menu_item(M_FILE_PREVIEW);
enable_menu_item(M_FILE_PRINT);
enable_menu_item(M_FONT);
if (lnflag())
{
m.field(F_NUMREG).on_hit(); // Aggiorna opportunamente le date
}
else
{
if (!_last_dreg.ok())
{
_last_dreg = TDate(TODAY);
TLocalisamfile mov(LF_MOV); mov.setkey(2);
if (mov.last() == NOERR)
{
const TDate dr = mov.get(MOV_DATAREG);
if (dr.year() < _last_dreg.year())
_last_dreg = dr;
}
}
m.set(F_DATAREG, _last_dreg);
}
_automatico->_step = 0; // Azzera flag di incasso immediato
TFilename tmp;
if (get_mask_swap_file(tmp))
{
TConfig ini(tmp, "23");
m.set(F_DATAREG, ini.get(MOV_DATAREG));
m.set(F_CODCAUS, ini.get(MOV_CODCAUS));
m.send_key(K_SPACE, DLG_NEWREC);
}
}
void TPrimanota_application::fill_sheet(TMask& m) const
{
const int filler = 16;
const int cgpos = m.id2pos(F_SHEETCG);
const int ivpos = m.id2pos(F_SHEETIVA);
if (cgpos > 0 && (ivpos > 0 || !is_saldaconto()))
{
main_app().disable_menu_item(M_FILE_PREVIEW); // qui ???
TSheet_field& cgs = (TSheet_field&)m.fld(cgpos);
for (int r = cgs.items(); r < filler; r++)
{
cgs.row(r);
cgs.check_row(r);
}
}
if (ivpos > 0)
{
TSheet_field& ivas = (TSheet_field&)m.fld(ivpos);
for (int r = ivas.items(); r < filler; r++)
ivas.row(r);
}
}
bool TPrimanota_application::can_I_write(const TRelation* rel) const
{
/*
static int err = -1;
if (err < 0)
{
Tdninst dninst;
err = dninst.check_customer();
if (err != 0)
{
TString html;
html << "<html><body>"
<< "<h5>Attenzione: chiave " << dongle().number() << " non riconosciuta.</h5>\n"
<< "<p align=justify>Al fine di poter riattivare la chiave <b>" << dongle().product().before(" ")
<< "</b> in oggetto e poter quindi effettuare registrazioni, "
<< "La preghiamo di contattare Sirio informatica e sistemi ai seguenti riferimenti:</p><br/>"
<< "<ul><li>Sara Coppini, segreteria commerciale: <br />"
<< "<a href=mailto:scoppini@sirio-is.it>scoppini@sirio-is.it</a> Tel. 348-9897249</li>"
<< "<li>Casella vocale Hotline Campo: <br />"
<< "<a href=mailto:hotlinecampo@sirio-is.it>hotlinecampo@sirio-is.it</a> Tel. 0236583540</li></ul>"
<< "</body></html>";
warning_box(html);
}
}
bool yes = TRelation_application::can_I_write(rel);
if (yes && err > 0)
{
yes = rel != NULL && _rel->cg_items() > 0; // Posso registrare ma non inserire
}
return yes;
*/
return TRelation_application::can_I_write(rel);
}
const char* TPrimanota_application::record_description(const TRelation& rel) const
{
const TString& desc = cache().get(LF_CAUSALI, rel.curr().get(MOV_CODCAUS), CAU_DESCR);
if (desc.full())
return desc;
return TR("Movimento");
}
// Ritorna il prossimo numero di registrazione libero
// Certified 100%
bool TPrimanota_application::get_next_key(TToken_string& tmp)
{
tmp.add(F_NUMREG); tmp.add(_lastreg+1);
if (_rel->good()) // Not reinsert
{
TMask& m = curr_mask();
if (m.insert_mode())
{
tmp.add(F_CODCAUS); // Ricopia causale
switch (_automatico->_step)
{
case 1:
tmp.add(_automatico->_causale);
_msk[0]->set(F_CODCAUS, _automatico->_causale); // Joke get_mask
if (_automatico->_tipo == 3)
{
TCausale c(_automatico->_causale);
_iva = c.iva();
}
else
_iva = nessuna_iva; // Impedisce incremento del numero documento
break;
case 2:
tmp.add(_automatico->_causale_originale);
_msk[0]->set(F_CODCAUS, _automatico->_causale_originale); // Joke get_mask
_iva = _automatico->_iva_originale; // Provoca incremento del numero documento
break;
default:
tmp.add(m.get(F_CODCAUS)); // Ultima causale usata
_msk[0]->set(F_CODCAUS, m.get(F_CODCAUS));
break;
}
tmp.add(F_DATAREG); // Ricopia data operazione
tmp.add(m.get(F_DATAREG));
tmp.add(F_DATACOMP); // Ricopia data competenza
if (m.field(F_DATACOMP).empty())
tmp.add(m.get(F_DATAREG));
else
tmp.add(m.get(F_DATACOMP));
if (_iva == iva_vendite)
{
tmp.add(F_DATADOC); tmp.add(m.get(F_DATADOC)); // Ricopia data documento
const long n = m.get_long(F_NUMDOC);
if (n > 0)
{ tmp.add(F_NUMDOC); tmp.add(n+1); } // incrementa numero documento
}
}
}
return true;
}
void TPrimanota_application::init_insert_mode(TMask& m)
{
init_mask(m);
m.first_focus(_firstfocus);
if (causale().reg().agenzia_viaggi())
m.set(F_DATA74TER, m.get(F_DATAREG));
if (iva() != nessuna_iva)
{
occas_mask().reset();
m.hide(F_OCCASEDIT);
const TString& tipo = clifo();
m.set(F_CLIFO, tipo);
m.show(F_CLIENTE, tipo == "C");
m.show(F_RAGSOCCLIENTE, tipo == "C");
m.show(F_FORNITORE, tipo == "F");
m.show(F_RAGSOCFORNITORE, tipo == "F");
#ifdef PRORATA100
m.hide(F_ADJUST_PRORATA); // In inserimento non puo' esistere un pro-rata errato!
#endif
if (causale().soloiva())
m.set(F_SOLAIVA, "X", true); // Propone movimento di sola iva
if (iva() == iva_acquisti && causale().intra())
m.field(F_RITFIS).set_prompt(PR("IVA intracomun. "));
else
m.field(F_RITFIS).set_prompt(PR("Ritenute fiscali "));
}
else
{
if (*causale().codice())
{
TString4 provv; provv << causale().provvisorio();
m.set(F_PROVVISORIO, provv, true); // Propone movimento di provvisorio
}
}
partite().destroy(); // Elimina tutte le partite in memoria
if (is_fattura())
{
activate_numrif(m, false);
const TString& dt = m.get(F_DATADOC);
set_pagamento(NULL,dt);
set_scadenze(m);
}
else
{
set_pagamento(NULL,NULL); // Annulla gestione rate
}
_saldi.reset(); // Inizializza saldi
if (_automatico->_step == 1)
genera_automatico(_automatico->_tipo, NULL);
else
m.reset(F_DATACOMP); // Azzera quasi sempre la data di competenza
// La preservo solo per l'incasso immediato
_as400 = false; // Un movimento nuovo non puo' essere trasferito da AS400
TFilename tmp;
if (get_mask_swap_file(tmp))
{
TConfig ini(tmp, "23");
ini2mask(ini, m, false);
// Controllo se <20> stato salvato il campo virtuale col codice IVA
if (m.id2pos(F_CODIVA) > 0)
{
const TString& codiva = ini.get("CODIVA", "23");
if (codiva.full())
m.set(F_CODIVA, codiva, 3);
}
// Devo ricalcolare il numero di protocollo nel caso di cambio causale al volo
if (m.id2pos(F_PROTIVA) > 0)
{
if (causale().iva() != nessuna_iva)
{
const long protiva = causale().reg().protocol() + 1;
m.set(F_PROTIVA, protiva, true); // Aggiorna protocollo IVA
}
else
m.reset(F_PROTIVA);
}
tmp.fremove();
}
if (iva() != nessuna_iva)
{
TRegistro& reg = causale().reg();
const TString4 codreg = reg.name();
const int regyear = reg.year();
reg.force_read(codreg, regyear);
const long protiva = reg.protocol() + 1;
m.set(F_PROTIVA, protiva, true); // Aggiorna protocollo IVA
}
// Controllo se abilitare il fornitore per bolla doganale
if(m.find_by_id(F_BOLLACODCLI) != NULL)
{
m.enable(F_BOLLACODCLI, causale().tipo_doc() == "BD");
m.enable(F_BOLLARAGCLI, causale().tipo_doc() == "BD");
}
}
void TPrimanota_application::init_modify_mode(TMask& m)
{
init_mask(m); // Inizializzazione standard
calcola_saldo(); // Verifica eventuali sbilanci contabili
TSheet_field& cg = cgs();
// Determina se il movimento <20> stato trasferito da AS/400:
// praticamente controlla che non ci sia nessun tipo movimento sulle righe contabili.
_as400 = false;
if (iva() != nessuna_iva)
{
const TString& tipo = clifo();
m.set(F_CLIFO, tipo);
m.show(F_CLIENTE, tipo == "C");
m.show(F_RAGSOCCLIENTE, tipo == "C");
m.show(F_FORNITORE, tipo == "F");
m.show(F_RAGSOCFORNITORE, tipo == "F");
}
if (is_saldaconto() || iva() != nessuna_iva)
{
if (cg.items() > 0)
{
_as400 = true;
for (int i = cg.items()-1; i >= 0 && _as400; i--)
{
const char rt = row_type(cg.row(i));
_as400 = rt <= ' ';
}
}
}
if (iva() == iva_acquisti)
{
if (causale().intra())
m.field(F_RITFIS).set_prompt("IVA intracomun. ");
else
m.field(F_RITFIS).set_prompt("Ritenute fiscali ");
}
if (_as400 && is_pagamento())
{
m.set(SK_TIPORIGA, "A"); // Forza il tipo riga normale
m.disable(SK_TIPORIGA); // Disabilita la sua modifica
}
#ifdef PRORATA100
// Non controllare il prorata durante la cancellazione automatica
if (autodeleting() != 0x3)
{
if (!test_prorata()) // Controlla prorata
{
m.show(F_ADJUST_PRORATA);
m.set_handler(F_ADJUST_PRORATA, prorata_handler);
warning_box(TR("Questo movimento <20> stato registrato con una percentuale\n"
"prorata non compatibile con quella corrente:\n"
"Premere il bottone di correzione automatica delle righe."));
}
else
{
// Nascondi il bottone del prorata se esiste
if (m.id2pos(F_ADJUST_PRORATA) >= 0)
{
m.set_handler(F_ADJUST_PRORATA, NULL);
m.hide(F_ADJUST_PRORATA);
}
}
}
#endif
const TRectype& mov = get_relation()->curr();
if (!mov.empty())
{
if (navigating())
{
TString msg;
if (mov.get_bool(MOV_STAMPATO))
msg << '\n' << TR("Il movimento <20> gi<67> stato stampato sul libro giornale.");
if (mov.get_bool(MOV_REGST))
msg << '\n' << TR("Il movimento <20> gi<67> stato stampato sul bollato.");
if (mov.get_bool(MOV_INVIATO))
msg << '\n' << TR("Il movimento <20> stato inviato ad un'altra contabilit<69>.");
if (msg.not_empty())
{
msg.insert(TR("ATTENZIONE!"));
warning_box(msg);
}
}
// Abilito il bottone di collegamento ai documenti se possibile
const long numdoc = mov.get_long(MOV_DNDOC);
m.show(F_LINKDOC, numdoc > 0 && has_module(VEAUT));
activate_split_payment(m);
}
// Controllo se abilitare il fornitore per bolla doganale
if(m.find_by_id(F_BOLLACODCLI) != NULL)
{
m.enable(F_BOLLACODCLI, causale().tipo_doc() == "BD");
m.enable(F_BOLLARAGCLI, causale().tipo_doc() == "BD");
}
}
// Controlla sulla causale se il segno del totale documento (ritsoc=false)
// o quello delle ritenute sociali (ritsoc=true) <20> invertito rispetto al normale
bool TPrimanota_application::test_swap(bool ritsoc)
{
const char sez = ritsoc ? causale().sezione_ritsoc() : causale().sezione_clifo();
const bool s = (iva() == iva_vendite) ^ (sez == 'D');
return s;
}
void TPrimanota_application::add_cup_or_cig(short id, const TRectype& rec, TToken_string& riga) const
{
const bool cup = id == CG_CUP;
const TString& cod = rec.get(cup ? RMV_CUP : RMV_CIG);
if (cod.full())
{
riga.add(cod, id-FIRST_FIELD); // Tipo di riga 115 o 117
const TString& desc = cache().get(cup ? "%CUP" : "%CIG", cod, "S0");
riga.add(desc, (cup ? CG_DCUP : CG_DCIG) - FIRST_FIELD);
}
}
void TPrimanota_application::add_cup_or_cig(short id, TConfig& ini, TToken_string& riga) const
{
const bool cup = id == CG_CUP;
const TString& cod = ini.get(cup ? RMV_CUP : RMV_CIG);
if (cod.full())
{
riga.add(cod, id-FIRST_FIELD); // Tipo di riga 115 o 117
const TString& desc = cache().get(cup ? "%CUP" : "%CIG", cod, "S0");
riga.add(desc, (cup ? CG_DCUP : CG_DCIG) - FIRST_FIELD);
}
}
int TPrimanota_application::read(TMask& m)
{
m.reset(); // Azzera campi e relativi dirty = 3
m.autoload(*_rel); // Carica testata
const long numreg = _rel->curr().get_long(MOV_NUMREG);
partite().destroy(); // Azzera tutte le partite
if (gestione_saldaconto() && causale().tipomov() != 0)
partite().add_numreg(numreg); // Carica le partite interessate
cgs().reset(); // Azzera tutte le righe contabili
if (iva() != nessuna_iva)
{
ivas().reset(); // Azzera tutte le righe iva
occas_mask().reset();
const TString16 occode(_rel->curr().get(MOV_OCFPI));
occas_mask().set(O_CODICE, occode, true);
}
_saldi.reset(); // Azzera saldi
_saldi.set_movprovv(_rel->curr().get_char(MOV_PROVVIS) > ' ');
tiposal tsal = causale().apertura() ? apertura :
(causale().chiusura() ? chiusura : normale);
_saldi.set_tipo_saldo(tsal);
_saldi.set_anno_es(m.get_int(F_ANNOES));
_saldi.set_num_ulmov(numreg);
_saldi.set_data_ulmov((TDate)m.get(F_DATAREG));
_saldi.set_movimentato(true);
int i;
for (i = 0; i < _rel->cg_items(); i++)
{
const TRectype& r = _rel->cg(i);
TToken_string& riga = cgs().row(i); // Vuota la riga
TImporto import(r.get_char(RMV_SEZIONE), r.get_real(RMV_IMPORTO));
import.add_to(riga, 0); // Dare/Avere 101-102
TBill conto; conto.get(r);
riga.add(conto.string(0x3)); // Conto 103-107
_saldi.aggiorna(conto, import, false);
riga.add(""); // Codice descrizione 108
riga.add(r.get(RMV_DESCR)); // Descrizione riga 109
conto.get(r, true);
riga.add(conto.string(0x3)); // Contropartita 110-114
add_cup_or_cig(CG_CUP, r, riga); // CUP 115-116
add_cup_or_cig(CG_CIG, r, riga); // CIG 117-118
const char tipo = r.get_char(RMV_ROWTYPE);
riga.add(tipo, CG_ROWTYPE-FIRST_FIELD); // Tipo di riga 119
disable_cgs_cells(i, tipo);
//cgs().check_row(i); // Fare le decodifche a mano: NON USARE!
}
if (_iva == nessuna_iva && is_fattura()) // Ci dovrebbero essere delle scadenze
{
pags().reset(); // Azzera sheet rate
if (!read_scadenze(m)) // Se non esiste fattura
{
const TString& dd = m.get(F_DATADOC);
set_pagamento(NULL, dd); // Ignora codice pagamento in testata
}
}
if (_iva == nessuna_iva)
return _rel->status();
TMask_field& solaiva = m.field(F_SOLAIVA);
solaiva.set(i == 0 ? "X" : " ");
solaiva.on_key(K_TAB);
const int mese_liq = _rel->curr().get_int(MOV_MESELIQ);
if (mese_liq != 0)
{
const TDate data_reg = m.get_date(F_DATAREG);
const TDate data_liq(1, mese_liq, data_reg.year());
if (_rel->date2liq(data_reg) != _rel->date2liq(data_liq))
m.set(F_DIFFERITA, "X");
}
const bool to_swap = test_swap(false);
if (to_swap)
{
real totdoc(m.get(F_TOTALE));
totdoc = -totdoc;
m.set(F_TOTALE, totdoc);
}
for (i = 0; i < _rel->iva_items(); i++)
{
TRectype& r = _rel->iva(i);
TToken_string& riga = ivas().row(i);
real imponibile(r.get(RMI_IMPONIBILE));
if (to_swap) imponibile = -imponibile;
riga.add(imponibile.string()); // Imponibile 101
riga.add(r.get(RMI_CODIVA)); // IVA 102
riga.add(r.get(RMI_TIPODET)); // Detrazione 103
real imposta(r.get(RMI_IMPOSTA));
if (to_swap) imposta = -imposta;
if (imponibile.sign() * imposta.sign() < 0)
{
error_box(TR("Registrazione con imponibile e imposta con segni discordi:\n"
"assegnato il segno dell'imponibile"));
imposta = -imposta;
}
riga.add(imposta.string()); // Imposta 104
TBill c; c.get(r);
c.add_to(riga, 4, 0x7); // Conto 105-110
riga.add(r.get(RMI_NAVP));
}
calcola_imp(); // Calcola totale imponibile ed imposte
if (is_fattura()) // Ci dovrebbero essere delle scadenze
{
pags().reset(); // Azzera sheet rate
if (!read_scadenze(m)) // Se non esiste fattura
{
const TString& dd = m.get(F_DATADOC);
set_pagamento(NULL, dd); // Ignora codice pagamento in testata
}
}
return _rel->status();
}
// Trasferisce i dati da maschera a movimento di prima nota
void TPrimanota_application::mask2rel(const TMask& m)
{
m.autosave(*_rel);
TRectype& rec = _rel->curr(); // Record della testata
const long numreg = m.get_long(F_NUMREG);
const TDate datareg(m.get(F_DATAREG));
const int annoes = m.get_int(F_ANNOES);
_saldi.set_movprovv(m.get(F_PROVVISORIO)[0] > ' ');
tiposal tsal = causale().apertura() ? apertura :
(causale().chiusura() ? chiusura : normale);
_saldi.set_tipo_saldo(tsal);
_saldi.set_anno_es(annoes);
_saldi.set_num_ulmov(numreg);
_saldi.set_data_ulmov((TDate)m.get(F_DATAREG));
_saldi.set_movimentato(true);
const int tm = causale().tipomov();
char s[2];
if (tm > 0)
{
s[0] = tm+'0';
s[1] = '\0';
}
else
s[0] = '\0';
rec.put(MOV_TIPOMOV, s); // Tolto dalla maschera (su file <20> alfanumerico)!
_rel->destroy_rows(numreg); // Destroy all records
cgs_pack(); // Destroy all null rows
// Controlla se <20> un movimento con righe contabili
if (iva() == nessuna_iva || !m.get_bool(F_SOLAIVA))
{
TString_array& rows = cgs().rows_array();
for (int i = 0; i < rows.items(); i++)
{
TToken_string& row = rows.row(i);
TImporto n; n = row;
const TBill conto(row, 2, 0x3);
_saldi.aggiorna(conto, n, true);
TRectype &r = _rel->cg(i);
r.zero();
r.put(RMV_NUMREG, numreg); // Numero registrazione
r.put(RMV_ANNOES, annoes); // Anno esercizio
r.put(RMV_DATAREG, datareg); // Data di registrazione
r.put(RMV_NUMRIG, i+1); // Numero riga
r.put(RMV_SEZIONE, n.sezione()); // Sezione
r.put(RMV_IMPORTO, n.valore()); // Importo
conto.put(r); // Conto
row.get(); // Codice descrizione (ignorato)
const char* descr = row.get(); // Descrizione aggiuntiva
if (i > 0 || m.get(F_DESCR) != descr) // Salva la prima descrizione se diversa da testata
r.put(RMV_DESCR, descr); // Descrizione riga
r.put(RMV_TIPOCC, row.get()); // Contropartita
r.put(RMV_GRUPPOC, row.get());
r.put(RMV_CONTOC, row.get());
r.put(RMV_SOTTOCONTOC, row.get());
r.put(RMV_CUP, row.get(CG_CUP-FIRST_FIELD)); // CUP
r.put(RMV_CIG, row.get(CG_CIG-FIRST_FIELD)); // CIG
r.put(RMV_ROWTYPE, row.get(CG_ROWTYPE-FIRST_FIELD)); // Tipo riga
}
}
if (_iva == nessuna_iva) return;
// Calcola mese di liquidazione precedente
int mese_liq = 0;
if (m.get_bool(F_DIFFERITA))
{
TDate data_liq(m.get(F_DATAREG));
const int curr_liq = _rel->date2liq(data_liq);
data_liq.set_day(1); // Evita problemi coi mesi corti!
for (mese_liq = curr_liq-1; mese_liq > 0; mese_liq--)
{
data_liq.set_month(mese_liq);
if (_rel->date2liq(data_liq) != curr_liq)
break;
}
if (mese_liq <= 0)
mese_liq = 12;
}
rec.put(MOV_MESELIQ, mese_liq);
if (causale().corrispettivi())
{
rec.zero(MOV_TIPO);
rec.zero(MOV_CODCF); // Azzera il cliente nei movimenti dei corrispettivi
}
else
{
rec.put(MOV_TIPO, clifo());
if (m.field(F_OCCASEDIT).active()) // Se <20> un occasionale
{
const TMask& om = occas_mask();
TRelation occas(LF_OCCAS);
om.autosave(occas); // Salva i dati anagrafici
int err = occas.write();
if (err == _isreinsert)
err = occas.rewrite();
if (err == NOERR)
rec.put(MOV_OCFPI, om.get(O_CODICE));
else
error_box(FR("Errore di scrittura sul file dei clienti/fornitori occasionali: %d"), err);
}
else
rec.zero(MOV_OCFPI);
}
const bool to_swap = test_swap(false);
if (to_swap)
{
real totale = rec.get_real(MOV_TOTDOC);
totale = -totale;
rec.put(MOV_TOTDOC, totale);
}
const bool intra = causale().intra();
ivas_pack();
TString_array& irows = ivas().rows_array();
for (int i = 0; i < irows.items(); i++)
{
TToken_string& row = irows.row(i);
TRectype &r = _rel->iva(i);
r.zero();
r.put(RMI_NUMREG, numreg);
r.put(RMI_NUMRIG, i+1);
r.put(RMI_ANNOES, annoes); // Anno d'esercizio della testata (che ca$$ata!)
r.put(RMI_INTRA, intra); // Causale intra (che ca$$ata!)
real imponibile(row.get(0));
if (to_swap) imponibile = -imponibile;
r.put(RMI_IMPONIBILE, imponibile);
r.put(RMI_CODIVA, row.get());
r.put(RMI_TIPODET, row.get());
real imposta(row.get());
if (to_swap) imposta = -imposta;
r.put(RMI_IMPOSTA, imposta);
r.put(RMI_TIPOCR, row.get());
// Roba obsoleta allo stato brado
const TBill c(row, 6);
const int rimp = bill2pos(c, 'I')+1;
r.put(RMI_RIGAIMP, rimp);
c.put(r);
r.put(RMI_NAVP, row.get(10));
}
}
void TPrimanota_application::check_saldi()
{
const int anno = _rel->curr().get_int(MOV_ANNOES);
TString_array& rows = cgs().rows_array();
FOR_EACH_ARRAY_ROW(rows, i, row)
{
TBill conto(*row, 2, 0x3);
conto.find();
const char sez = conto.sezione();
if (sez > ' ')
{
const TConto* c = _saldi.find(conto, anno);
if (c && !c->saldo_finale().is_zero() && c->saldo_finale().sezione() != sez)
warning_box(FR("Il conto della riga %i ha un saldo finale in %s, "
"contrariamente a quanto indicato sul piano dei conti"),
i+1, sez == 'A' ? TR("dare") : TR("avere"));
}
}
}
int TPrimanota_application::write(const TMask& m)
{
static int lasterr = NOERR;
const long numreg = m.get_long(F_NUMREG);
if (numreg > _lastreg) _lastreg = numreg; // Aggiorna ultima registrazione libera
if (lasterr == NOERR)
mask2rel(m); // Altrimenti raddoppia i saldi!
_last_dreg = m.get(F_DATAREG);
_last_dcom = m.get(F_DATACOMP);
//l'handler della datacomp non viene chiamato quando il campo <20> read_only (vedi crpa e dinamica)
//si <20> quindi costretti a salvarlo "a mano" sul file delle testate movimento (04-04-2011)
if (!_last_dcom.ok())
{
_last_dcom = _last_dreg;
get_relation()->curr().put(MOV_DATACOMP, _last_dcom);
}
const int err = _rel->write(true);
if (err == NOERR)
{
_saldi.registra();
check_saldi();
bool salvaconto = false;
const long old_nreg = NUMREG_PROVVISORIO;
if (iva() == nessuna_iva)
{
if (is_fattura())
write_scadenze(m); // Salva fattura
salvaconto = is_pagamento();
}
int tipauto = 0; // Tipo movimento automatico
TString4 causauto; // Possibile causale per incasso immediato
causale().reg().reread(); // Aggiorna protocollo IVA
if (is_saldaconto())
{
switch (causale().tipomov())
{
case tm_fattura:
write_scadenze(m); // Salva fattura
break;
case tm_nota_credito:
salvaconto = true; // Salva nota credito
break;
default:
break;
}
}
else
{
if (iva() != nessuna_iva && !m.get_bool(F_SOLAIVA))
{
causauto = causale().causale_collegata();
if (causauto.full())
{
TCausale c(causauto);
if ((!gestione_saldaconto() || c.tipomov() == 0) && c.iva() == nessuna_iva)
tipauto = 1;
}
}
}
if (iva() == iva_acquisti && tipauto <= 0)
{
// Genera regolarizzazione IVA acquisti
causauto = causale().causale_reg_iva();
tipauto = causauto.full() ? 2 : 0;
}
if (tipauto <= 1)
{
causauto = causale().causale_collegata();
if (cached_causale(causauto, causale().reg().year()).ril_fat_em_ric())
tipauto = 4;
}
if (tipauto <= 0)
{
causauto = causale().causale_collegata();
tipauto = causauto.full() ? 3 : 0;
}
if (tipauto > 0 && causauto.full())
genera_automatico(tipauto, causauto);
if (salvaconto)
{
partite().update_reg(_rel->curr(), old_nreg);
partite().write();
}
link_m770();
link_cesp (m, "Insert");
link_intra(m, "Insert");
link_anal (m, "Insert");
}
lasterr = err;
return err;
}
int TPrimanota_application::rewrite(const TMask& m)
{
mask2rel(m);
const int err = _rel->rewrite(true);
if (err == NOERR)
{
_saldi.registra();
check_saldi();
if (is_saldaconto())
{
bool salvaconto = false;
if (iva() != nessuna_iva)
{
if (causale().tipomov() == tm_nota_credito)
salvaconto = true;
else
{
partite().update_reg(_rel->curr());
write_scadenze(m);
}
}
else
{
if (is_fattura())
write_scadenze(m); // Salva fattura
salvaconto = is_pagamento();
}
if (salvaconto)
{
partite().update_reg(_rel->curr());
partite().rewrite();
}
}
link_m770();
link_cesp (m, "Modify");
link_intra(m, "Modify");
link_anal (m, "Modify");
}
return err;
}
bool TPrimanota_application::remove()
{
const bool ok = TRelation_application::remove();
if (ok)
{
_saldi.registra();
check_saldi();
TMask& m = curr_mask();
if (is_saldaconto())
{
if (is_fattura())
{
m.reset(F_ANNORIF);
m.reset(F_NUMRIF);
write_scadenze(m);
}
else
{
notify_cgline_deletion(-1); // Notify deletion of all cg lines
partite().rewrite();
}
}
link_cesp (m, "Remove");
link_intra(m, "Remove");
link_anal (m, "Remove");
}
return ok;
}
///////////////////////////////////////////////////////////
// Gestione incasso immediato
///////////////////////////////////////////////////////////
void TPrimanota_application::genera_automatico(int tipo, const char* causimm)
{
const TCausale& caus = causale();
TMask& m = curr_mask();
if (causimm && *causimm) // Step 0
{
if (tipo > 0)
{
// Parte comune a tutti i movimenti automatici
_automatico->_tipo = tipo;
_automatico->_causale = causimm;
_automatico->_causale_originale = m.get(F_CODCAUS);
_automatico->_iva_originale = caus.iva();
if (tipo != 3)
{
_automatico->_datadoc = m.get(F_DATADOC);
_automatico->_numdoc = m.get(F_NUMDOC);
_automatico->_clifo.get(_rel->cg(0));
_automatico->_totale = m.get_real(F_TOTALE);
}
// Solo regolarizzazioni IVA
if (_automatico->_tipo == 2)
{
_automatico->_totale += m.get_real(F_REVCHARGE) + m.get_real(F_RITFIS);
_automatico->_codiva = m.get(F_CODIVA);
if (_automatico->_codiva.blank() && _rel->iva_items() > 0)
_automatico->_codiva = _rel->iva(0).get(RMI_CODIVA);
}
else
if (_automatico->_tipo == 4)
{
const int esercizio = m.get_int(F_ANNOES);
const int esprec = esercizi().pred(esercizio);
TEsercizio e = esercizi().esercizio(esprec);
TDate last(e.fine());
_automatico->_datadoc = last;
if (cached_causale(causimm, caus.reg().year()).datareg_prec())
_automatico->_datareg = last;
else
_automatico->_datareg = m.get(F_DATAREG);
const int nrows = _rel->iva_items();
_automatico->_totale = ZERO;
for (int i = 0; i < nrows; i++)
_automatico->_totale += _rel->iva(i).get_real(RMI_IMPONIBILE);
}
_automatico->_step = 1;
}
}
else // Step 1
{
if (_automatico->_tipo != 3)
{
m.set(F_DATADOC, _automatico->_datadoc);
m.set(F_NUMDOC, _automatico->_numdoc);
}
switch (_automatico->_tipo)
{
case 1:
{ // Incasso Immediato
TBill contro; caus.bill(2, contro);
cgs().reset();
TToken_string& row1 = cgs().row(0);
TImporto imp(caus.sezione_clifo(), _automatico->_totale);
imp.add_to(row1, 0);
row1.add(_automatico->_clifo.string(0x3));
row1.add(" ");
row1.add(" ");
row1.add(contro.string(0x3));
TToken_string& row2 = cgs().row(1);
imp.swap_section();
imp.add_to(row2, 0);
row2.add(contro.string(0x3));
row2.add(" ");
row2.add(caus.desc_agg(2));
row2.add(_automatico->_clifo.string(0x3));
fill_sheet(m);
if (TRelation_application::is_transaction())
m.send_key(K_CTRL+'R', 0);
}
break;
case 2: // Regolarizzazione IVA
{
TCausale caus_reg(_automatico->_causale);
TBill contocf; caus_reg.bill(1, contocf);
char tcf_reg = contocf.tipo();
// Reperisce l'eventuale cliente associato al fornitore e lo propone
if (tcf_reg == 'F')
m.set(F_FORNITORE, _automatico->_clifo.codclifo());
else
{
TString8 forn; forn.format("F|%ld", _automatico->_clifo.codclifo());
const TString& clnt = cache().get(LF_CLIFO, forn, CLI_CODCFASS);
m.set(F_CLIENTE, clnt);
}
m.set(F_TOTALE, _automatico->_totale); // Imposta il totale documento e ...
m.set(F_CODIVA, _automatico->_codiva, true); // ... scatena creazione prima riga IVA
if (TRelation_application::is_transaction())
m.send_key(K_CTRL+'R', 0);
}
break;
case 4: // Rilevazione fatture da emettere/ricevere
{
m.set(F_DATAREG, _automatico->_datareg);
m.set(F_DATACOMP, _automatico->_datadoc);
TBill conto; caus.bill(1, conto);
TBill contro; caus.bill(2, contro);
cgs().reset();
TToken_string& row1 = cgs().row(0);
TImporto imp(caus.sezione_clifo(), _automatico->_totale);
imp.add_to(row1, 0);
row1.add(conto.string(0x3));
row1.add(" ");
row1.add(" ");
row1.add(contro.string(0x3));
TToken_string& row2 = cgs().row(1);
imp.swap_section();
imp.add_to(row2, 0);
row2.add(contro.string(0x3));
row2.add(" ");
row2.add(caus.desc_agg(2));
row2.add(conto.string(0x3));
fill_sheet(m);
if (TRelation_application::is_transaction())
m.send_key(K_CTRL+'R', 0);
}
default:
break;
}
_automatico->_step = 2;
}
}
///////////////////////////////////////////////////////////
// Gestione collegamento 770
///////////////////////////////////////////////////////////
bool TPrimanota_application::is_percipient(long forn, char& tipper, long& codper) const
{
TString8 key; key.format("F|%ld", forn);
const TRectype& fornitore = cache().get(LF_CLIFO, key);
tipper = fornitore.get_char(CLI_TIPOAPER);
codper = fornitore.get_long(CLI_CODANAGPER);
return codper > 0;
}
long TPrimanota_application::calcola_m770(int tipo_coll, real& spese, real& compenso,
real& iva, real& ritfis)
{
const int m770 = causale().link_m770();
long forn = 0;
if (tipo_coll == 1)
{
TString_array& riva = ivas().rows_array();
TCodiceIVA codiva;
int i;
for (i = 0; i < riva.items(); i++)
{
TToken_string& row = riva.row(i);
codiva.read(row.get(1));
const TString& tipoiva = codiva.tipo();
const real imponibile(row.get(0));
if ((tipoiva == "ES" || tipoiva == "NI" ||tipoiva == "NS") && riva.items() > 1)
{
if (m770 != 5)
spese += imponibile;
else
compenso += imponibile; // MM000025
}
else
compenso += imponibile;
const real imposta(row.get(3));
iva += imposta;
}
i = type2pos('F');
if (i >= 0)
{
TImporto imp; imp = cgs().row(i);
ritfis = imp.valore();
}
i = type2pos('S');
if (i >= 0)
{
TImporto imp; imp = cgs().row(i);
ritfis += imp.valore();
}
}
if (tipo_coll == 3 || tipo_coll == 7)
{
TImporto imp;
TString_array& rcg = cgs().rows_array();
for (int i = 0; i < rcg.items(); i++)
{
TToken_string& row = rcg.row(i);
imp = row;
const char cf = row.get_char(2);
if (cf == 'F') // Evviva, <20> un fornitore!
{
const long cod = row.get_long(5);
char tipper;
long codper;
if (!is_percipient(cod, tipper, codper))
continue; // Se non <20> percipente ignoralo
if (forn == 0 && tipo_coll == 3)
{
forn = cod; // <20> il primo che trovo!
}
else // Fine ricerca.
{
forn = 0;
compenso = ZERO;
break;
}
compenso = imp.valore();
}
}
}
if (tipo_coll == 4)
{
TBill zio; causale().bill(2, zio);
TString_array& rcg = cgs().rows_array();
for (int i = 0; i < rcg.items(); i++)
{
TToken_string& r = rcg.row(i);
const TBill bill(r, 3, 0x0);
if (zio == bill)
{
TImporto imp; imp = r;
ritfis = imp.valore();
break;
}
}
}
if (tipo_coll == 6)
{
TString_array& rcg = cgs().rows_array();
TToken_string& row = rcg.row(0);
TImporto imp;
imp = row;
if (imp.sezione() == 'D')
compenso = imp.valore();
else
compenso = ZERO;
}
return forn;
}
bool TPrimanota_application::link_m770()
{
const int m770 = causale().link_m770();
if (!has_module(M77AUT) || iva() == iva_vendite || m770 == 0)
return false;
const TMask& cm = curr_mask();
int tipo_coll = 0;
char tipper = ' ';
long codper = 0;
real spese, compenso, imposte, ritenute;
if (iva() == iva_acquisti)
{
if (m770 == 1 || m770 == 5)
{
const long forn = cm.get_long(F_FORNITORE);
if (is_percipient(forn, tipper, codper))
calcola_m770(tipo_coll = 1, spese, compenso, imposte, ritenute);
}
}
else // Movimento puramente contabile
{
switch (m770)
{
case 1:
{
tipo_coll = is_saldaconto() ? 7 : 3;
const long forn = calcola_m770(tipo_coll, spese, compenso, imposte, ritenute);
if (forn != 0)
is_percipient(forn, tipper, codper);
else
tipo_coll = 7;
}
break;
case 2:
calcola_m770(tipo_coll = 4, spese, compenso, imposte, ritenute);
break;
case 6:
calcola_m770(tipo_coll = 6, spese, compenso, imposte, ritenute);
break;
default:
break;
}
}
if (tipo_coll > 0)
{
TToken_string s(80);
s.add(tipo_coll);
s.add(cm.insert_mode() ? "I" : "M");
s.add(tipper);
s.add(codper);
s.add(cm.get(F_NUMREG));
s.add(cm.get(F_NUMDOC));
s.add(cm.get(F_DATADOC));
if (iva() == iva_acquisti)
s.add(cm.get(F_TOTALE));
else
s.add("");
s.add(spese.string());
s.add(compenso.string());
s.add(imposte.string());
s.add(ritenute.string());
const char* const name = (tipo_coll == 4) ? "770 -1" : "770 -0";
TMessage m(name, "LINK770", s);
m.send();
TExternal_app a(name);
a.run();
}
return tipo_coll > 0;
}
HIDDEN void ini2bill(TConfig& ini, TBill& bil, bool contro)
{
const char tipo = ini.get_char(contro ? RMV_TIPOCC : RMV_TIPOC);
const int gruppo = ini.get_int(contro ? RMV_GRUPPOC : RMV_GRUPPO);
const int conto = ini.get_int(contro ? RMV_CONTOC : RMV_CONTO);
const long sottoconto = ini.get_long(contro ? RMV_SOTTOCONTOC : RMV_SOTTOCONTO);
bil.set(gruppo, conto, sottoconto, tipo);
}
HIDDEN bool set_not_empty(TMask& msk, int id, TConfig& ini, const char* var)
{
TString val = ini.get(var);
if (val.starts_with("\""))
val.strip("\"");
bool ok = val.full();
if (ok)
msk.set(id, val);
return ok;
}
HIDDEN bool add_not_empty(TToken_string& str, int pos, TConfig& ini, const char* var)
{
TString val = ini.get(var);
if (val.starts_with("\""))
val.strip("\"");
bool ok = val.full();
if (ok)
str.add(val, pos);
return ok;
}
void TPrimanota_application::ini2mask(TConfig& ini, TMask& msk, bool query)
{
TRelation_application::ini2mask(ini, msk, query);
if (query)
{
set_not_empty(msk, F_CODCAUS, ini, MOV_CODCAUS);
TString16 val = ini.get(MOV_DATAREG);
if (val.blank())
{
const long numreg = ini.get_long(MOV_NUMREG);
if (numreg > 0)
{
TLocalisamfile& mov = _rel->file();
mov.put(MOV_NUMREG, numreg);
if (mov.read() == NOERR)
val = mov.get(MOV_DATAREG); // Serve ad evitare segnalazioni su esercizi non esistenti
}
if (val.blank())
val = TDate(TODAY).string();
}
msk.set(F_DATAREG, val);
}
else
{
_as400 = false;
if (ini.set_paragraph("24,1"))
_as400 = !ini.exist(RMV_ROWTYPE) && ini.get_int(RMV_NUMRIG) == 1;
if (msk.id2pos(F_ANNORIF) > 0)
set_not_empty(msk, F_ANNORIF, ini, PART_ANNO);
if (msk.id2pos(F_NUMRIF) > 0)
set_not_empty(msk, F_NUMRIF, ini, PART_NUMPART);
if (iva() != nessuna_iva)
{
if (msk.id2pos(F_SOLAIVA) >= 0 && ini.exist("SOLAIVA"))
msk.set(F_SOLAIVA, ini.get("SOLAIVA"));
if (msk.id2pos(F_CODIVA) >= 0)
msk.set(F_CODIVA, ini.get("CODIVA"));
add_cgs_tot(msk);
TSheet_field& is = ivas();
for (int i = 0; ini.set_paragraph(LF_RMOVIVA, i+1); i++)
{
TToken_string& riga = is.row(i);
iva_notify(is, i, K_SPACE);
add_not_empty(riga, 0, ini, RMI_IMPONIBILE); // Imponibile 101
add_not_empty(riga, 1, ini, RMI_CODIVA); // IVA 102
add_not_empty(riga, 2, ini, RMI_TIPODET); // Detrazione 103
add_not_empty(riga, 3, ini, RMI_IMPOSTA); // Imposta 104
TBill c; ini2bill(ini, c, false);
if (c.gruppo() > 0)
c.add_to(riga, 4, 0x7); // Conto 105-110
iva_notify(is, i, K_ENTER);
}
// Genera eventuali righe per ritenute fiscali e sociali
const short frit[4] = { F_RITFIS, F_RITSOC, F_REVCHARGE, 0 };
const char trit[4] = { 'F', 'S', 'V', '\0' };
for (int i = 0; frit[i]; i++)
{
TEdit_field& ritfld = msk.efield(frit[i]);
if (!ritfld.empty() && ritfld.active())
add_cgs_ritenute(trit[i]);
}
calcola_imp(); // Calcola totale imponibile ed imposte
}
TSheet_field& cg = cgs();
for (int i = 0; ini.set_paragraph(format("%d,%d", LF_RMOV, i+1)); i++)
{
char tipo = ini.get_char(RMV_ROWTYPE);
if (tipo < ' ') tipo = ' ';
TBill conto; ini2bill(ini, conto, false);
if (_as400 && conto.tipo() <= ' ')
conto.find();
int numrig = ini.get_int(RMV_NUMRIG)-1;
if (numrig != i) // Controllo se ho un numero riga valido
{
numrig = -1; // Normalmente aggiungi la riga in fondo
// Cerca una riga che abbia gi<67> il tipo ed il conto richiesto
if (strchr(" DINT", tipo) != NULL)
{
int nr = -1;
if (tipo == 'I' || tipo == ' ')
nr = bill2pos(conto, tipo);
else
nr = type2pos(tipo);
if (nr < 0)
tipo = ' ';
else
if (get_cgs_imp(nr).is_zero() || tipo == 'T')
numrig = nr;
}
}
TToken_string& riga = cg.row(numrig);
if (numrig < 0 || _as400 || !(cg.cell_disabled(numrig, 0) && cg.cell_disabled(numrig, 1)))
{
TString4 sez = ini.get(RMV_SEZIONE); sez.strip("\"");
if (sez == "A" || sez == "D")
{
TImporto import(sez[0], real(ini.get(RMV_IMPORTO)));
if (!import.is_zero())
import.add_to(riga, 0); // Dare/Avere 101-102
}
}
if (numrig < 0 || !cg.cell_disabled(numrig, 3))
{
if (conto.gruppo() > 0)
conto.add_to(riga, 2, 0x3); // Conto 103-107
}
riga.add("", 7); // Codice descrizione 108
add_not_empty(riga, 8, ini, RMV_DESCR); // Descrizione riga 109
ini2bill(ini, conto, true);
if (conto.gruppo() > 0)
conto.add_to(riga, 9, 0x3); // Contropartita 110-114
add_cup_or_cig(CG_CUP, ini, riga); // CUP 115-116
add_cup_or_cig(CG_CIG, ini, riga); // CIG 117-118
riga.add(tipo, cg.cid2index(CG_ROWTYPE)); // Tipo di riga 119
}
if (is_fattura())
{
if (msk.insert_mode())
{
// Propone condizioni di pagamento e banche
TEdit_field& clifo = msk.efield(iva() == iva_vendite ? F_CLIENTE : F_FORNITORE);
if (!clifo.empty() && clifo.active())
{
clifo.set_focusdirty();
clifo.on_hit(); // was clifo_handler(clifo, K_TAB);
}
}
TSheet_field& pag = pags();
const int start_items = pag.items();
msk.reset(FS_RECALC); // Disabilita ricalcolo automatico
for (int i = 0; ini.set_paragraph(format("%d,%d", LF_SCADENZE, i+1)); i++)
{
TToken_string& row = pag.row(i);
if (i >= start_items)
pag_notify(pag, i, K_CTRL+K_INS);
pag_notify(pag, i, K_SPACE);
add_not_empty(row, 0, ini, SCAD_DATASCAD);
add_not_empty(row, 1, ini, SCAD_IMPORTO);
add_not_empty(row, 2, ini, SCAD_IMPORTOVAL);
// pag_notify(pag, i, K_ENTER);
}
int i;
for (i = 0; i < pag.items(); i++)
{
TToken_string& row = pag.row(i);
row.add(msk.get(FS_NSABI), 7);
row.add(msk.get(FS_NSCAB), 8);
row.add(msk.get(FS_VSABI), 9);
row.add(msk.get(FS_VSCAB), 10);
pag_notify(pag, i, K_ENTER);
}
// In inserimento tento di riempire anche le scadenze
if (msk.insert_mode() && (i == 0 || real::is_null(pag.row(0).get(1))))
{
TString4 codpag = msk.get(F_CODPAG);
if (codpag.empty())
{
TToken_string key;
key = iva() == iva_acquisti ? "F" : "C";
key.add(ini.get(MOV_CODCF, "23"));
codpag = cache().get(LF_CLIFO, key, CLI_CODPAG);
}
if (codpag.full())
{
msk.set(FS_RECALC, "X"); // Forza ricalcolo automatico
msk.set(F_CODPAG, codpag);
set_scadenze(msk);
}
}
pagamento().set_sheet(pag);
}
}
}
bool TPrimanota_application::save(bool check_dirty)
{
if (_swap_mask == true)
{
_swap_mask = false;
return true;
}
return TRelation_application::save(check_dirty);
}
void TPrimanota_application::dump_rec(TConfig & ini, const TRectype & rec, int row, int pref)
{
if (pref > 0)
ini.set_paragraph(format("%d,%d,%d", rec.num(), row, pref));
else
if (row > 0)
ini.set_paragraph(format("%d,%d", rec.num(), row));
else
ini.set_paragraph(format("%d", rec.num()));
for (int f = rec.items()-1; f >= 0; f--)
{
const char* name = rec.fieldname(f);
ini.set(name, rec.get(name));
}
}
void TPrimanota_application::dump_fatt(TConfig& ini, TPartita & game, int rigafatt, int pref)
{
CHECKD(rigafatt > 0 && rigafatt < 9999, "Riga fattura errata ", rigafatt);
const TRiga_partite& riga = game.riga(rigafatt);
int r;
for (r = 1; r <= riga.rate(); r++)
{
TRiga_scadenze& rec = riga.rata(r);
rec.fill_array();
const int lastrow = rec.last();
dump_rec(ini, rec, r, pref);
for (int rp = rec.first(); rp <= lastrow; rp = rec.succ(rp))
{
const TRectype & recpag = rec.row(rp);
dump_rec(ini, recpag, rp, pref);
}
}
for ( ; ; r++)
{
if (ini.set_paragraph(format("%d,%d", LF_SCADENZE, r+1)))
ini.remove_all();
else
break;
}
}
void TPrimanota_application::mask2ini(const TMask& msk, TConfig& ini)
{
TRelation_application::mask2ini(msk, ini);
int i;
for (i = 0; i < _rel->cg_items(); i++)
{
const TRectype& rec = _rel->cg(i);
dump_rec(ini, rec, i + 1);
}
for ( ; ini.set_paragraph(format("%d,%d", LF_RMOV, i+1)); i++)
ini.remove_all();
for (i = 0; i < _rel->iva_items(); i++)
{
const TRectype& rec = _rel->iva(i);
dump_rec(ini, rec, i + 1);
}
for ( ; ini.set_paragraph(format("%d,%d", LF_RMOVIVA, i+1)); i++)
ini.remove_all();
TPartite_array p;
const long numreg = _rel->lfile().get_long(MOV_NUMREG);
p.add_numreg(numreg);
if (is_fattura())
{
TPartita* game = p.first();
if (game)
{
const int rigafatt = game->prima_fattura(numreg);
if (rigafatt > 0 && rigafatt < 9999)
dump_fatt(ini, *game, rigafatt);
}
}
else
{
int pref = 1;
for (TPartita* game = p.first(); game != NULL; game = p.next())
{
const int lastrow = game->last();
for (int r = game->first(); r <= lastrow; r = game->succ(r))
{
dump_rec(ini, game->riga(r), r, pref);
if (game->riga(r).tipo() == tm_fattura)
dump_fatt(ini, *game, r, pref);
}
TRecord_array uns = game->unassigned();
const int rows = uns.rows();
const int last = uns.last_row();
if (rows > 0)
{
pref++;
for (int r = uns.first_row(); r <= last; r = uns.succ_row(r))
dump_rec(ini, uns.row(r), r, pref);
}
pref++;
}
}
}
bool TPrimanota_application::link_cesp(const TMask& msk, const char* action)
{
// Controlla autorizzazione
if (!has_module(CEAUT))
return false;
// Controlla flag sulla causale
if (causale().link_cespiti() <= ' ')
return false;
// Controlla l'esistenza del programma cespiti
if (!fexist("ce1.exe"))
return false;
// Cerca una riga con tipo costo/ricavo 2,3,4
int i;
for (i = _rel->cg_items()-1; i >= 0; i--)
{
const TRectype& rec = _rel->cg(i);
const TBill zio(rec);
char tipo_cr = char('0' + zio.tipo_cr());
if (strchr("234", tipo_cr))
break;
}
if (i < 0)
return false;
TFilename cespini;
cespini.tempdir();
cespini.add("ActCsp.ini");
if (action && *action) // Dummy test
{
TConfig cespo(cespini, "Transaction");
cespo.set("Action", action);
mask2ini(msk, cespo);
}
TString appname;
appname << "ce1 -4 /c" << cespini;
TExternal_app app(appname);
bool ok = app.run() != 0;
return ok;
}
bool TPrimanota_application::link_intra(const TMask& m, const char* action)
{
// Controlla autorizzazione
if (!has_module(INAUT))
return false;
// Controlla flag sulla causale
if (!causale().intra())
return false;
// Controlla l'esistenza del programma intra
if (!fexist("in0.exe"))
return false;
const BOOLEAN bModify = xvt_str_same(action, "Modify");
TFilename intrini;
intrini.tempdir();
intrini.add("ActIntra.ini");
TString appname;
TConfig intro(intrini, "Transaction");
bool call_rettifiche = false;
const TDate datareg = m.get(F_DATAREG);
const TDate dataint = m.get(F_DATAINTRA);
if (dataint < datareg)
{
const TIntra_frequency freq;
const char tipo = iva() == iva_acquisti ? 'A' : 'C';
call_rettifiche = freq.compare_periodo(dataint, datareg, tipo) < 0;
}
if (call_rettifiche)
{
const TIntra_frequency freq;
const char tipo = iva() == iva_acquisti ? 'B' : 'D';
TRelation rel(LF_RIEPRETT);
TRectype& curr = rel.curr();
curr.put("TIPO", tipo);
curr.put("ANNO", datareg.year());
curr.put("PERIODO", freq.date2periodo(datareg, tipo));
TCursor cur(&rel, "", 1, &curr, &curr);
const TRecnotype items = cur.items();
cur.freeze();
long last_rett = 0;
for (cur = 0; cur.pos() < items; ++cur)
{
const long n = curr.get_long("NUMRIG");
if (n > last_rett)
last_rett = n;
if (curr.get_long("NUMREG") == m.get_long(F_NUMREG))
return curr.edit(0, NULL, "in0 -6");
}
intro.set("Action", "Insert");
TString4 str; str.format("%d", LF_RIEPRETT);
intro.set_paragraph(str);
intro.set("TIPO", tipo == 'B' ? "B" : "D");
intro.set("ANNO", datareg.year());
intro.set("PERIODO", freq.date2periodo(datareg, tipo));
intro.set("NUMRIG", last_rett+1);
intro.set("ANNORETT", dataint.year());
intro.set("PERETT", freq.date2periodo(dataint, tipo));
intro.set("STATO", m.get(F_STATOPAIV));
intro.set("PIVA", tipo == 'B' ? m.get(F_PIVAFORNITORE) : m.get(F_PIVACLIENTE));
intro.set("NUMREG", m.get(F_NUMREG));
appname << "in0 -6 /i" << intrini;
}
else
{
if (bModify)
{
TString16 key;
key << m.get(F_NUMREG);
const TRectype & intra = cache().get(LF_INTRA, key);
if (intra.empty())
action = "Insert";
}
intro.set("Action", action);
TString str; // Stringa jolly di lavoro
str.format("%d", LF_INTRA);
intro.set_paragraph(str);
intro.set(MOV_NUMREG, m.get(F_NUMREG));
intro.set(MOV_DATAREG, m.get(F_DATAREG));
if (m.field(F_CLIENTE).shown())
{
intro.set(MOV_TIPOMOV, "C"); // Cessione
intro.set("TIPOCF", "C"); // Cliente
intro.set(MOV_CODCF, m.get(F_CLIENTE));
}
else
{
intro.set(MOV_TIPOMOV, "A"); // Acquisto
intro.set("TIPOCF", "F"); // Fornitore
intro.set(MOV_CODCF, m.get(F_FORNITORE));
}
// Controlla flag sulla causale
const bool valintra = causale().valintra();
if (valintra)
{
intro.set(MOV_CODVAL, m.get(F_VALUTAINTRA));
intro.set(MOV_CAMBIO, m.get(F_CAMBIOINTRA));
}
// Inserisci il totale documento solo in inserimento!
if (xvt_str_same(action, "Insert"))
{
real totdoc = m.get_real(valintra ? F_CORRISPETTIVO : F_IMPONIBILI);
if (test_swap(false))
totdoc = -totdoc;
intro.set(MOV_TOTDOC, totdoc.string());
}
else
intro.remove(MOV_TOTDOC); // Evita di cambiare il valore preesistente
appname << "in0 -4 /i" << intrini;
}
bool ok = false;
if (!appname.empty())
{
intro.set_paragraph(""); // Flush pending writes
TExternal_app app(appname);
ok = app.run() == 0;
}
::remove(intrini);
return ok;
}
bool TPrimanota_application::link_anal(const TMask& msk, const char* action)
{
// Controlla autorizzazione
if (!(has_module(CMAUT) || has_module(CAAUT) || has_module(CIAUT)))
return false;
// Controlla flag sulla causale
if (!(causale().link_analitica() || causale().link_industriale()))
return false;
// Controlla l'esistenza del programma dei movimenti analitici
if (!fexist("ca2.exe"))
return false;
const TDate data_att = ini_get_string(CONFIG_DITTA, "ca", "DtAttCa");
if (data_att.ok())
{
// la data competenza puo' essere vuota nel caso l'utonto non abbia i permessi per compilarla...
// ...ovvero lavora a Dinamica
TDate data_cmp = msk.get_date(F_DATACOMP);
if(!data_cmp.ok())
data_cmp = msk.get_date(F_DATAREG);
if (data_cmp < data_att) // La data di competenza precede la data di attivazione analitica
return false;
}
// Cerco se c'e' almeno un conto interessato all'analitica
bool bAnalBill = false;
TSheet_field& sheet = msk.sfield(F_SHEETCG);
FOR_EACH_SHEET_ROW(sheet, i, row)
{
const TBill bill(*row, 3, 0x0);
bAnalBill = bill.is_analitico();
if (bAnalBill)
break;
}
if (action[0] == 'I')
{
// Se non ci sono conti analitici <20> inutile inserire
if (!bAnalBill)
return false;
}
// Controllo se esiste gi<67> il movimento
long nExist = 0L;
TLocalisamfile movana(LF_MOVANA);
movana.setkey(3);
movana.put(MOVANA_NUMREGCG, msk.get(F_NUMREG));
if (movana.read() == NOERR)
nExist = movana.get_long(MOVANA_NUMREG);
if (!nExist)
{
if (action[0] == 'R') // Nulla da cancellare
return false;
if (!bAnalBill) // Non c'erano e non ci sono tuttora conti analitici
return false;
action = "Insert"; // Il movimento <20> andato perduto!
}
else
{
if (action[0] == 'I')
action = "Modify"; // Il movimento <20> stato inserito preventivamente
}
TFilename ini; ini.tempdir();
ini.add("ActAnal.ini");
ini.fremove(); // Azzera l'eventuale copia precedente
// Parentesi strategiche per salvare il config
{
TConfig config(ini, "Transaction");
config.set("Action", action);
/* Attualmente genera solo problemi al Cigno che ha CI e CM ma non ha CA
if (has_module(CIAUT) && !has_module(CAAUT))
config.set("Mode", "A"); // Salva automaticamente i movimenti di sola industriale
*/
TString4 para; para << LF_MOVANA;
config.set_paragraph(para);
config.remove_all();
config.set(MOVANA_NUMREG, nExist);
config.set(MOVANA_NUMREGCG, msk.get(F_NUMREG));
}
TString cmd; cmd << "ca2 -0 /i" << ini;
TExternal_app app(cmd);
app.run();
return true;
}
bool TPrimanota_application::protected_record(TRectype& mov)
{
bool ok = !TRelation_application::protected_record(mov);
if (ok && autodeleting() == 0x3)
{
static long last_checked_numreg = 0L;
const long numreg = mov.get_long(MOV_NUMREG);
if (last_checked_numreg != numreg)
{
if (mov.get_bool(MOV_STAMPATO))
{
ok = delete_box(FR("Il movimento %ld <20> gi<67> stato stampato sul libro giornale:\n"
"si desidera eliminarlo ugualmente?"), numreg);
}
if (ok && mov.get_bool(MOV_REGST))
{
ok = delete_box(FR("Il movimento %ld <20> gi<67> stato stampato sul bollato:\n"
"si desidera eliminarlo ugualmente?"), numreg);
}
if (ok && mov.get_bool(MOV_INVIATO))
{
ok = delete_box(FR("Il movimento %ld <20> stato inviato ad un'altra contabilit<69>:\n"
"si desidera eliminarlo ugualmente?"), numreg);
}
if (ok)
last_checked_numreg = numreg;
}
}
return !ok;
}
int cg2100 (int argc, char** argv)
{
TPrimanota_application* a = new TPrimanota_application;
a->run(argc, argv, TR("Prima nota"));
delete a;
return 0;
}
Reference in New Issue View Git Blame Copy Permalink