campo-sirio/sc/sc1100.cpp

#include <applicat.h>
#include <isam.h>
#include <relation.h>
#include <mask.h>    
#include <progind.h>
#include <urldefid.h>
#include <scadenze.h>
#include <partite.h>  
#include <lffiles.h>  
#include <assoc.h>

#include "sc1100.h"

class _BoolObj : public TObject
{
public:
  
  bool _val;
  int  _count;
  
  _BoolObj() { _val = FALSE; _count = 0; }
  virtual ~_BoolObj() {}
};

class TDeletepart_app : public TApplication
{                                     
  TDate _datalimite;

protected:

  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:

  TDate& datalimite() { return _datalimite; }

  TDeletepart_app() {};  
  ~TDeletepart_app() {};  
};

bool TDeletepart_app::create()
{
  TApplication::create();
  dispatch_e_menu(BAR_ITEM(1));
  return TRUE;
}

bool TDeletepart_app::destroy()
{
  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)
    {
      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);
      break;
    }  

    cur.freeze(FALSE);                    
  }
  
  return FALSE;
}


int sc1100(int argc, char** argv)
{
  TDeletepart_app a;
  a.run(argc, argv, "Eliminazione partite chiuse");
  return 0;
}