b3cd9c64a9
Files correlati : no patch Ricompilazione Demo : [ ] Commento : Riportata la versione 01.05 patch 888 sul main trunk git-svn-id: svn://10.65.10.50/trunk@9217 c028cbd2-c16b-5b4b-a496-9718f37d4682
285 lines
7.2 KiB
C++
Executable File
285 lines
7.2 KiB
C++
Executable File
#include "cg4501.h"
|
|
#include "cg4500a.h"
|
|
|
|
class TAp_eser : public TSkeleton_application
|
|
{
|
|
int _anno, _newanno;
|
|
TDate _dataini, _datafin, _datainp, _datafip;
|
|
TString _conserva;
|
|
|
|
protected:
|
|
|
|
bool check_esercizio(const TString& cod, TDate s1, TDate f1);
|
|
static bool mask_dataini (TMask_field&, KEY);
|
|
static bool mask_newanno (TMask_field&, KEY);
|
|
|
|
public:
|
|
virtual bool create();
|
|
virtual void main_loop();
|
|
|
|
bool set();
|
|
bool apertura_es();
|
|
};
|
|
|
|
bool TAp_eser::mask_newanno (TMask_field& f, KEY k)
|
|
{
|
|
if (k == K_ENTER)
|
|
{
|
|
int newanno = f.mask().get_int(F_NUOVOANNO);
|
|
TString16 codtab; codtab.format("%04d", newanno);
|
|
TTable TabEs("ESC");
|
|
TabEs.put ("CODTAB", codtab);
|
|
if (TabEs.read() == NOERR)
|
|
return f.warning_box ("Il codice %04d e' gia' presente nella tabella degli esercizi!",
|
|
newanno);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
bool TAp_eser::mask_dataini (TMask_field& f, KEY k)
|
|
{
|
|
if ( (k == K_ENTER) && f.to_check(k) )
|
|
{
|
|
TDate data(f.mask().get(F_DATAINI));
|
|
TDate fine(f.mask().get(F_DATAFINC));
|
|
if ( data <= fine )
|
|
{
|
|
f.warning_box ("La data di inizio del nuovo esercizio deve essere superiore alla data di fine esercizio precedente");
|
|
return FALSE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
bool TAp_eser::create()
|
|
{
|
|
open_files(LF_TAB, 0);
|
|
enable_menu_item(M_FILE_NEW, FALSE);
|
|
return TSkeleton_application::create();
|
|
}
|
|
|
|
void TAp_eser::main_loop()
|
|
{
|
|
TTable TabEs ("ESC");
|
|
TMask msk ("cg4500a");
|
|
|
|
if (TabEs.last() != NOERR)
|
|
{
|
|
error_box("Non e' ancora stato aperto alcun esercizio!");
|
|
return;
|
|
}
|
|
TabEs.first();
|
|
TRecnotype rn = TabEs.recno();
|
|
int anno = TabEs.get_int ("CODTAB");
|
|
TDate inizio = TabEs.get_date("D0"); //data inizio es. in corso
|
|
TDate fine = TabEs.get_date("D1"); //data fine es. in corso
|
|
|
|
// determina esercizio con data fine piu' alta
|
|
for ( ; !TabEs.eof(); TabEs.next())
|
|
if (TabEs.get_date("D1") > fine)
|
|
{
|
|
rn = TabEs.recno();
|
|
fine = TabEs.get_date("D1");
|
|
_conserva = TabEs.get("S1");
|
|
}
|
|
|
|
TabEs.readat(rn);
|
|
// rilegge dati
|
|
anno = TabEs.get_int ("CODTAB");
|
|
inizio = TabEs.get_date("D0"); //data inizio es. in corso
|
|
fine = TabEs.get_date("D1"); //data fine es. in corso
|
|
|
|
msk.set(F_ANNO, anno);
|
|
msk.set(F_DATAINIC, inizio.string());
|
|
msk.set(F_DATAFINC, fine.string());
|
|
|
|
msk.set_handler (F_NUOVOANNO, mask_newanno);
|
|
msk.set_handler (F_DATAINI, mask_dataini);
|
|
|
|
if (msk.run() == K_ENTER)
|
|
{
|
|
_anno = msk.get_int(F_ANNO);
|
|
_datainp = msk.get(F_DATAINIC);
|
|
_datafip = msk.get(F_DATAFINC);
|
|
_newanno = msk.get_int(F_NUOVOANNO); //nuovo anno esercizio
|
|
_dataini = msk.get(F_DATAINI);
|
|
_datafin = msk.get(F_DATAFIN);
|
|
|
|
apertura_es();
|
|
}
|
|
}
|
|
|
|
bool TAp_eser::apertura_es()
|
|
{
|
|
TTable TabReg ("REG");
|
|
TTable TabEs ("ESC");
|
|
TString anno (4);
|
|
TString annonew(4);
|
|
TDate data;
|
|
bool ok = FALSE;
|
|
|
|
//viene aggiornata la tabella dei registri. Se esisteva gia' un record relativo al nuovo esercizio, viene cancellato.
|
|
//In ogni caso ne viene creato uno nuovo relativo al nuovo esercizio.
|
|
TabReg.zero();
|
|
annonew.format("%04d", _datafin.year());
|
|
TabReg.put ("CODTAB", annonew);
|
|
|
|
TRectype r (TabReg.curr());
|
|
|
|
TabReg.read(_isgteq);
|
|
|
|
for (; !TabReg.eof(); TabReg.next())
|
|
{
|
|
if (TabReg.curr() != r) break;
|
|
|
|
int tiporeg = TabReg.get_int("I0");
|
|
if (tiporeg == 5)
|
|
TabReg.remove();
|
|
}
|
|
|
|
TabReg.zero();
|
|
TRectype nuovo (TabReg.curr());
|
|
anno.format ("%04d", _datafip.year());
|
|
TabReg.put ("CODTAB", anno);
|
|
|
|
TRectype rec (TabReg.curr());
|
|
|
|
TabReg.read(_isgteq);
|
|
|
|
for (; !TabReg.eof(); TabReg.next())
|
|
{
|
|
if (TabReg.curr() != rec) break;
|
|
|
|
int tiporeg = TabReg.get_int("I0");
|
|
TString cod_reg = TabReg.get("CODTAB");
|
|
cod_reg = cod_reg.mid(4,3);
|
|
if (tiporeg == 5)
|
|
{
|
|
ok = TRUE;
|
|
nuovo = TabReg.curr();
|
|
TString16 cod;
|
|
annonew.format ("%04d", _datafin.year());
|
|
cod << annonew << cod_reg;
|
|
nuovo.put("CODTAB", cod);
|
|
nuovo.put("D0", data);
|
|
nuovo.put("D2", data);
|
|
nuovo.put("D3", data);
|
|
nuovo.put("I6", 0L);
|
|
nuovo.put("I1", 0L);
|
|
nuovo.put("R1", real(0.0));
|
|
nuovo.put("R2", real(0.0));
|
|
|
|
TabReg.write(nuovo);
|
|
}
|
|
}
|
|
// se tutto ok viene aggiornata la tabella degli esercizi
|
|
annonew.format("%04d", _newanno);
|
|
if (check_esercizio(annonew, _dataini, _datafin))
|
|
{
|
|
TabEs.zero();
|
|
annonew.format ("%04d", _newanno);
|
|
TabEs.put ("CODTAB", annonew);
|
|
TabEs.put ("D0", _dataini);
|
|
TabEs.put ("D1", _datafin);
|
|
TabEs.put ("S1", _conserva);
|
|
TabEs.write();
|
|
message_box("Apertura nuovo esercizio completata");
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
bool TAp_eser::check_esercizio(const TString& cod, TDate s1, TDate f1)
|
|
{
|
|
// -----------------------------------------------------------------------------------------
|
|
// chiamata prima di registrare. Controlla:
|
|
// - se non ci sono altri esercizi, ok;
|
|
// - se ce ne sono altri:
|
|
// 1) controllo non sovrapposizione date
|
|
// 2) se ci sono es. con date inferiori, datainizio -1 deve essere = data fine altro es;
|
|
// 3) se ci sono es. con date superiori, datafine +1 deve essere = data inizio altro
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
byte err = 0x00; bool ret = TRUE;
|
|
TTable esc("ESC");
|
|
|
|
bool basta1 = FALSE, basta2 = FALSE;
|
|
|
|
for (esc.first(); !esc.eof(); esc.next())
|
|
{
|
|
if (esc.get("CODTAB") == cod)
|
|
continue;
|
|
|
|
TDate s2 = esc.get_date("D0");
|
|
TDate f2 = esc.get_date("D1");
|
|
TDate s1d = s1; --s1d;
|
|
TDate s2d = s2; --s2d;
|
|
|
|
// check sovrapposizione
|
|
if (s1 <= f2 && s2 <= f1)
|
|
err |= 0x01;
|
|
else
|
|
{
|
|
if (!basta1 && f1 < s2 && f1 != s2d)
|
|
err |= 0x02;
|
|
if (f1 < s2 && f1 == s2d)
|
|
{
|
|
err &= ~0x02;
|
|
basta1 = TRUE;
|
|
}
|
|
if (!basta2 && s1 > f2 && f2 != s1d)
|
|
err |= 0x04;
|
|
if (s1 > f2 && f2 == s1d)
|
|
{
|
|
err &= ~0x04;
|
|
basta2 = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (err)
|
|
{
|
|
ret = FALSE;
|
|
TString errstr(120);
|
|
errstr << "Date esercizio errate: \n";
|
|
// build error string
|
|
if (err & 0x01)
|
|
errstr << "\n - l'esercizio si sovrappone ad altro gia' esistente";
|
|
if (err & 0x02)
|
|
errstr << "\n - l'esercizio non e' contiguo ad esercizi successivi";
|
|
if (err & 0x04)
|
|
errstr << "\n - l'esercizio non e' contiguo ad esercizi precedenti";
|
|
|
|
if (!(err & 0x01))
|
|
{
|
|
errstr << "\nSi desidera registrare ugualmente?";
|
|
ret = yesno_box(errstr);
|
|
}
|
|
else error_box(errstr);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int cg4500 (int argc, char* argv[])
|
|
{
|
|
switch (toupper(*argv[2]))
|
|
{
|
|
case 'C':
|
|
{
|
|
TAp_eser a;
|
|
a.run(argc, argv, "Apertura nuovo esercizio");
|
|
}
|
|
break;
|
|
case 'I':
|
|
{
|
|
TAp_iva a;
|
|
a.run(argc, argv, "Apertura nuovo esercizio IVA");
|
|
}
|
|
break;
|
|
default:
|
|
error_box("Uso: cg4 -4 [C,I]");
|
|
break;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|