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

Cambiato il programma di eliminazione partite.

Browse Source 
git-svn-id: svn://10.65.10.50/trunk@1853 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
angelo 1995-09-20 08:38:10 +00:00
parent 72d8c15255
commit a9316db710
3 changed files with 390 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

489
sc/sc1100.cpp
View File

@ -1,38 +1,41 @@
#include <direct.h>
#include <applicat.h>
#include <archives.h>
#include <assoc.h>
#include <isam.h>
#include <relation.h>
#include <mask.h>
#include <progind.h>
#include <relation.h>
#include <urldefid.h>
#include <utility.h>
#include "../cg/saldacon.h"
#include <scadenze.h>
#include <partite.h>
#include <lffiles.h>
#include <assoc.h>
#include <partite.h>
#include <pagsca.h>
#include "sc1100.h"
class _BoolObj : public TObject
{
public:
bool _val;
int _count;
_BoolObj() { _val = FALSE; _count = 0; }
virtual ~_BoolObj() {}
};
#include "sc1100.h"
class TDeletepart_app : public TApplication
{
TDate _datalimite;
TArchive _arc;
TArray _to_zap; // Array contenente le chiavi delle partite da eliminare
TDate _datalimite;
TString _desc;
char _unit;
TFilename _tmp_dir;
TIsamtempfile *_tpart,*_tscad,*_tpagsca;
TLocalisamfile *_part,*_scad,*_pagsca;
protected:
void backup_delete_partite(); // Backup e cancellazione delle partite da eliminare
void restore_partite(); // Ripristino partite cancellate
void delete_partite_restored(); // Cancellazione partite ripristinate
void create_tmp_files(bool create=TRUE);
void delete_tmp_files(bool remove=TRUE);
virtual bool create();
virtual bool destroy();
virtual bool menu(MENU_TAG m);
static bool partchiuseal(const TRelation *r);
static TDeletepart_app& app() { return (TDeletepart_app&)main_app(); }
public:
@ -42,146 +45,347 @@ public:
~TDeletepart_app() {};
};
void TDeletepart_app::backup_delete_partite()
{
TPartita *partita;
TRecnotype total = 0;
int err;
err = _part->lock();
if (err != NOERR)
{
error_box("Il file partite non puo' essere bloccato in modo esclusivo."
" Nessuna partita cancellata. Errore %d.",err);
return;
}
create_tmp_files();
_part->zero();
// Scorre il file delle partite
{
TProgind p(10, "Ricerca e copia delle partite da eliminare...", TRUE, FALSE, 10);
for (_part->first();_part->good() && !p.iscancelled();_part->read(_isgreat))
{
const char tipocf = _part->get_char(PART_TIPOCF);
const long codcf = _part->get_long(PART_SOTTOCONTO);
const int anno = _part->get_int(PART_ANNO);
const TString16 num_part(_part->get(PART_NUMPART));
TBill conto(0,0,codcf,tipocf);
partita = new TPartita(conto,anno,num_part);
bool to_delete = TRUE;
// Scorre le righe di questa partita partendo dall'ultima
int r=partita->last();
if (r == 0) to_delete = FALSE;
for (;r>0 && to_delete && !p.iscancelled();r=partita->pred(r))
{
TRiga_partite& row = partita->riga(r);
// Passa alla prossima se trova almeno una riga di partita che non sia CHIUSA o
// che abbia la data di registrazione maggiore della data limite
// Ovvero: tutte le righe della partita in esame devono avere il flag
// CHIUSA settato a TRUE e DATAREG <= della data limite
if (!row.get_bool(PART_CHIUSA) ||
row.get_date(PART_DATAREG) > _datalimite)
to_delete = FALSE;
// Se TIPOMOV != 1 e' inutile controllare la partita.
// N.B. TIPOMOV = 1 quando la partita si riferisce alle scadenze di una fattura
if (to_delete && row.get_int(PART_TIPOMOV) == 1)
{
// Scorre le rate di scadenza per questa riga di partita
for (int n=row.rate();(n>0 && to_delete && !p.iscancelled()); n--)
{
if (row.rata(n).get_date(SCAD_DATASCAD) > _datalimite)
to_delete = FALSE;
}
}
}
if (to_delete && !p.iscancelled()) // Se TRUE la partita puo' essere eliminata!
{ // Memorizza la chiave della partita in un array
TToken_string id(30);
id = _part->get(PART_TIPOCF);
id.add(_part->get(PART_SOTTOCONTO));
id.add(_part->get(PART_ANNO));
id.add(_part->get(PART_NUMPART));
_to_zap.add(id);
// Memorizza le righe della partita, scadenze e pagsca sui file temporanei
// Scorre le righe di partita da eliminare e le scrive sul file temporaneo
for (int x=partita->last();x > 0 && err==NOERR;x=partita->pred(x))
{
TRiga_partite& row = partita->riga(x);
err = _tpart->write(row);
// Scorre le righe di scadenza per questa riga di partita e le scrive
for (int y=row.rate();y > 0 && err==NOERR; y--)
{
const TRiga_scadenze& r_scad = row.rata(y);
err=_tscad->write(r_scad);
// Scorre le righe dei pagamenti relativi alla scadenza e le scrive
for (int z=r_scad.last();z > 0 && err==NOERR;z=r_scad.pred(z))
{
TRectype pag(r_scad.row(z));
err=_tpagsca->write(pag);
}
}
}
total++;
}
delete partita;
_part->put(PART_NRIGA,9999); // Forza la rilettura della prossima partita
} // end of for
if (p.iscancelled()) total=0;
}
if (total != 0)
if (err==NOERR)
{
const char * dir = &_tmp_dir[1];
delete_tmp_files(FALSE); //Close tmp files only
bool rt = _arc.backup(dir,_unit,_desc,FALSE);// Backup delle partite da eliminare, prefix unnecessary
create_tmp_files(FALSE); // Reopen tmp files.
if (rt)
{
// Effettiva cancellazione delle partite
TString80 caption("Cancellazione di ");
caption.add_plural(total, "partita");
if (!yesno_box(caption))
_to_zap.destroy();
TProgind pi(total, caption, FALSE, TRUE, 10);
const int items = _to_zap.items();
for (int i = 0; i < items; i++)
{
TToken_string& id = (TToken_string&)_to_zap[i];
id.restart();
const char tipocf = id.get_char();
const long codcf = id.get_long();
const int anno = id.get_int();
const TString16 num=id.get();
TBill conto(0,0,codcf,tipocf);
partita = new TPartita(conto,anno,num);
partita->remove();
delete partita;
pi.addstatus(1);
}
}
}
else
error_box("Errore %d scrivendo sui files temporanei."
" La cancellazione delle partite chiuse non verra' effettuata.",err);
// Cerca scadenze e pagamenti senza partite: solo su richiesta
TString80 caption("Cancellazione scadenze e pagamenti senza partite");
if (err == NOERR && yesno_box(caption))
{
TString16 lastpart;
int lastanno;
TProgind p(10, caption, TRUE, FALSE, 10);
// Esamina le scadenze...
for (_scad->first(); !_scad->eof() && err == NOERR; _scad->next())
{
_part->zero();
_part->put(PART_TIPOCF, _scad->get(SCAD_TIPOCF));
_part->put(PART_GRUPPO, _scad->get(SCAD_GRUPPO));
_part->put(PART_CONTO, _scad->get(SCAD_CONTO));
_part->put(PART_SOTTOCONTO,_scad->get(SCAD_SOTTOCONTO));
lastanno = _scad->get_int(SCAD_ANNO);
_part->put(PART_ANNO, lastanno);
lastpart = _scad->get(SCAD_NUMPART);
_part->put(PART_NUMPART, lastpart);
_part->put(PART_NRIGA, _scad->get(SCAD_NRIGA));
if (_part->read(_isequal) != NOERR)
err = _scad->remove();
}
if (err != NOERR)
error_box("Errore %d nella cancellazione delle scadenze %d/%s",
err, lastanno, lastpart);
else
{
// ... e i pagamenti
for (_pagsca->first(); !_pagsca->eof() && err == NOERR; _pagsca->next())
{
_part->zero();
_part->put(PART_TIPOCF, _pagsca->get(PAGSCA_TIPOC));
_part->put(PART_GRUPPO, _pagsca->get(PAGSCA_GRUPPO));
_part->put(PART_CONTO, _pagsca->get(PAGSCA_CONTO));
_part->put(PART_SOTTOCONTO,_pagsca->get(PAGSCA_SOTTOCONTO));
lastanno = _pagsca->get_int(PAGSCA_ANNO);
_part->put(PART_ANNO, lastanno);
lastpart = _pagsca->get(PAGSCA_NUMPART);
_part->put(PART_NUMPART, lastpart);
_part->put(PART_NRIGA, _pagsca->get(PAGSCA_NRIGA));
if (_part->read(_isequal) != NOERR)
err = _pagsca->remove();
}
if (err != NOERR)
error_box("Errore %d nella cancellazione dei pagamenti %d/%s",
err, lastanno, lastpart);
}
}
delete_tmp_files(); // Physical remove of tmp files
_part->unlock();
}
void TDeletepart_app::restore_partite()
{
int err = _part->lock();
if (err != NOERR)
{
error_box("Il file partite non puo' essere bloccato in modo esclusivo."
" Nessuna partita ripristinata. Errore %d.",err);
return ;
}
const char* dir =& _tmp_dir[1]; // Cut out % sign
if (_arc.restore(dir,_unit,FALSE,FALSE))
{
create_tmp_files(FALSE); // In realta' ci sono gia'
// Credo di poter andare a colpo sicuro nel trasferimento
// di questi miserabili record, ovvero: se sono stati tolti prima
// non dovrebbero esserci piu'... (Colombo's Egg...). Al limite riscrive i record
// gia' presenti.
const TRecnotype items = _tpart->items() + _tscad->items() + _tpagsca->items();
TProgind pi(items, "Ripristino partite eliminate", FALSE, TRUE, 10);
for (_tpart->first();_tpart->good() && err==NOERR;_tpart->next())
{
_tpart->put(PART_RICARICATA,TRUE);
if ((err=_part->write(_tpart->curr())) == _isreinsert)
err=_part->rewrite(_tpart->curr());
pi.addstatus(1);
}
if (err != NOERR)
error_box("Errore %d ripristinando il file PARTITE.",err);
else
{
for (_tscad->first();_tscad->good() && err==NOERR;_tscad->next())
{
if ((err=_scad->write(_tscad->curr())) == _isreinsert)
err=_scad->rewrite(_tscad->curr());
pi.addstatus(1);
}
if (err != NOERR)
error_box("Errore %d ripristinando il file SCADENZE.",err);
else
{
for (_tpagsca->first();_tpagsca->good() && err==NOERR;_tpagsca->next())
{
if ((err=_pagsca->write(_tpagsca->curr())) == _isreinsert)
err=_pagsca->rewrite(_tpagsca->curr());
pi.addstatus(1);
}
if (err != NOERR) error_box("Errore %d ripristinando il file PAGSCA.",err);
}
}
delete_tmp_files(); // Removes tmp files!
}
else
error_box("Errore nel ripristino dei file da dischetto. Nessuna partita ripristinata.");
_part->unlock();
}
void TDeletepart_app::delete_partite_restored()
{
TRecnotype total = 0;
TPartita* partita;
int err = _part->lock();
if (err != NOERR)
{
error_box("Il file partite non puo' essere bloccato in modo esclusivo."
" Nessuna partita cancellata. Errore %d.",err);
return;
}
_part->zero();
TProgind p(10, "Eliminazione partite ricaricate...", TRUE, FALSE, 10);
for (_part->first();_part->good();_part->read(_isgreat))
{
if (_part->get_bool(PART_RICARICATA))
{
const char tipocf = _part->get_char(PART_TIPOCF);
const long codcf = _part->get_long(PART_SOTTOCONTO);
const int anno = _part->get_int(PART_ANNO);
const TString16 num_part(_part->get(PART_NUMPART));
TBill conto(0,0,codcf,tipocf);
partita = new TPartita(conto,anno,num_part);
partita->remove();
delete partita;
total++;
}
_part->put(PART_NRIGA,9999); // Forza la rilettura della prossima partita
}
if (total != 0) message_box("Eliminate %ld partite ricaricate.",total);
_part->unlock();
}
void TDeletepart_app::create_tmp_files(bool create)
{
TFilename tf(_tmp_dir);
tf << "/" << "f1";
_tpart = new TIsamtempfile(LF_PARTITE,tf,create);
tf.rtrim(1);tf << "2";
_tscad = new TIsamtempfile(LF_SCADENZE,tf,create);
tf.rtrim(1);tf << "3";
_tpagsca = new TIsamtempfile(LF_PAGSCA,tf,create);
}
void TDeletepart_app::delete_tmp_files(bool remove)
{
if (remove) // Cosi' posso forzare la cancellazione in chiusura
{
_tpart->set_autodel();
_tscad->set_autodel();
_tpagsca->set_autodel();
}
delete _tpart;
delete _tscad;
delete _tpagsca;
}
bool TDeletepart_app::create()
{
TApplication::create();
_tmp_dir.temp();
_tmp_dir = _tmp_dir.path();
_tmp_dir << "SC";
if (!fexist(_tmp_dir)) make_dir(_tmp_dir);
_tmp_dir.insert("%"); // Add % sign
_part = new TLocalisamfile(LF_PARTITE);
_scad = new TLocalisamfile(LF_SCADENZE);
_pagsca = new TLocalisamfile(LF_PAGSCA);
dispatch_e_menu(BAR_ITEM(1));
return TRUE;
}
bool TDeletepart_app::destroy()
{
{
_tmp_dir=_tmp_dir.sub(1); // Cut out % sign
if (fexist(_tmp_dir)) rmdir(_tmp_dir);
delete _part;
delete _scad;
delete _pagsca;
return TApplication::destroy();
}
bool TDeletepart_app::partchiuseal(const TRelation *r)
{
return (/* r->lfile().get_bool(PART_CHIUSA) && */
(app().datalimite() >= r->lfile().get_date(PART_DATAREG)));
}
bool TDeletepart_app::menu(MENU_TAG)
{
{
TMask m("sc1100a");
TRelation partite(LF_PARTITE);
TCursor cur(&partite);
TLocalisamfile scadenze(LF_SCADENZE);
TAssoc_array to_zap;
while (m.run() != K_QUIT)
{
_datalimite = m.get(F_DATE);
cur.set_filterfunction(partchiuseal);
TRecnotype last = cur.items()-1;
const TRecnotype first = cur.read();
TRecnotype total = 0;
int lastanno = -1;
TString16 lastpart = "";
TToken_string id(12);
for (cur = 0; cur.pos() <= last; ++cur)
{
// build key
id = cur.curr().get(PART_ANNO);
id.add(cur.curr().get(PART_NUMPART));
if (!to_zap.is_key(id))
to_zap.add(id, new _BoolObj);
_BoolObj& bobj = (_BoolObj&)to_zap[id];
bobj._count ++;
if (cur.curr().get_bool(PART_CHIUSA))
bobj._val = TRUE;
if (lastanno != cur.curr().get_int(PART_ANNO) ||
lastpart != cur.curr().get(PART_NUMPART));
{
total++;
lastanno = cur.curr().get_int(PART_ANNO);
lastpart = cur.curr().get(PART_NUMPART);
}
}
if (total == 0)
_datalimite = m.get(F_DATE);
_unit = m.get(F_UNIT)[0];
_desc = m.get(F_DESC);
int scelta = m.get_int(F_OPERAZIONE);
switch (scelta)
{
warning_box("Nessuna partita da cancellare");
return FALSE;
}
TString80 caption("Cancellazione di ");
caption.add_plural(total, "partita");
if (!yesno_box(caption) || total < 1)
continue;
TProgind pi(total, caption, FALSE, TRUE, 24);
cur.freeze();
lastanno = -1;
int err = NOERR;
for (cur = 0; cur.pos() <= last; ++cur)
{
const int anno = cur.curr().get_int(PART_ANNO);
const TString16 partita = cur.curr().get(PART_NUMPART);
id = cur.curr().get(PART_ANNO);
id.add(cur.curr().get(PART_NUMPART));
_BoolObj& bobj = (_BoolObj&)to_zap[id];
err = cur.lock();
if (err == NOERR && bobj._val == TRUE);
{
for (int rig = 1; err == NOERR; rig++)
{
scadenze.zero();
scadenze.put(SCAD_ANNO, anno);
scadenze.put(SCAD_NUMPART, partita);
scadenze.put(SCAD_NRATA, rig);
if ((err = scadenze.read(_isequal, _lock)) == NOERR)
if (scadenze.remove() != NOERR)
{
caption.format("riga scadenza %d", rig);
break;
}
}
pi.addstatus(1);
err = cur.file().remove();
if (err != NOERR)
caption = "riga partite";
}
} // eliminate partite e scadenze scelte
// cerca scadenze senza partita
TLocalisamfile& part = cur.file();
for (scadenze.first(); !scadenze.eof() && err == NOERR; scadenze.next())
{
part.zero();
part.put(PART_ANNO, scadenze.get(SCAD_ANNO));
part.put(PART_NUMPART, scadenze.get(SCAD_NUMPART));
// se non c'e'
if (part.read(_isgteq) != NOERR)
err = scadenze.remove();
if (err != NOERR)
caption = "riga scadenze";
}
if (err != NOERR)
{
error_box("Errore %d nella cancellazione della %s della partita %d/%s",
err, (const char*)caption, lastanno, lastpart);
case 1:
backup_delete_partite();
break;
}
cur.freeze(FALSE);
case 2:
restore_partite();
break;
case 3:
delete_partite_restored();
break;
default:
break;
}
}
return FALSE;
}
@ -189,6 +393,7 @@ bool TDeletepart_app::menu(MENU_TAG)
int sc1100(int argc, char** argv)
{
TDeletepart_app a;
a.run(argc, argv, "Eliminazione partite chiuse");
a.run(argc, argv, "Archiviazione partite pareggiate");
return 0;
}

8
sc/sc1100.h
View File

@ -1,2 +1,8 @@
#define F_DATE 101
#define F_DATE 101
#define F_UNIT 102
#define F_DESC 103
#define F_OPERAZIONE 104
#define F_UNITB 105
#define F_UNITR 106

49
sc/sc1100a.uml
View File

@ -1,21 +1,18 @@
#include "sc1100.h"
PAGE "Eliminazione Partite Chiuse" -1 -1 48 10
PAGE "Archiviazione partite pareggiate" -1 -1 48 12
TEXT DLG_NULL
BEGIN
PROMPT 2 1 " ATTENZIONE"
FLAGS "UM"
END
TEXT DLG_NULL
RADIOBUTTON F_OPERAZIONE 35
BEGIN
PROMPT 1 3 "La cancellazione della partite puo' richiedere"
END
TEXT DLG_NULL
BEGIN
PROMPT 1 4 " tempo. Siate certi di voler proseguire."
PROMPT 1 1 "Operazione da eseguire"
ITEM "1|Eliminazione partite chiuse"
MESSAGE SHOW,1@|HIDE,2@|SHOW,F_UNIT
ITEM "2|Ripristino partite eliminate"
MESSAGE SHOW,2@|HIDE,1@|SHOW,F_UNIT
ITEM "3|Eliminazione partite ripristinate"
MESSAGE HIDE,1@|HIDE,2@|HIDE,F_UNIT
HELP "Scegli l'operazione da eseguire"
END
DATE F_DATE
@ -25,6 +22,32 @@ BEGIN
CHECKTYPE REQUIRED
WARNING "Si deve specificare la data sino a cui eliminare le partite chiuse"
FLAGS "A"
GROUP 1
END
TEXT F_UNITB
BEGIN
PROMPT 2 7 "Unita' di backup "
GROUP 1
END
TEXT F_UNITR
BEGIN
PROMPT 2 7 "Unita' di restore "
GROUP 2
END
LIST F_UNIT 2
BEGIN
PROMPT 23 7 ""
ITEM "A|A:"
ITEM "B|B:"
END
STRING F_DESC 20
BEGIN
PROMPT 2 8 "Descrizione backup "
GROUP 1
END
BUTTON DLG_OK 10 2