campo-sirio/sc/sc1300.cpp

#include <applicat.h>
#include <mask.h>
#include <config.h>
#include <progind.h>
#include <recarray.h>
#include <recset.h>
#include <relation.h>
#include <reputils.h>

#include "sc1300.h"

#include "partite.h"

class TAllinea_partite : public TSkeleton_application
{ 
  char _cli_align, _for_align;

protected:  // Applicat
  virtual void on_config_change();
  virtual void main_loop();  

public:
  void allinea(int logicnum, TLog_report& log, bool& can_write);
  void compatta(int logicnum, TLog_report& log, bool& can_write);
  void allinea_e_compatta(int logicnum, TLog_report& log, bool& can_write);
};

void TAllinea_partite::on_config_change()
{
  TConfig cd(CONFIG_DITTA, "cg");
  _cli_align = cd.get_bool("NrCliDx") ? 'R' : 'L';
  _for_align = cd.get_bool("NrForDx") ? 'R' : 'L';
  xvtil_statbar_set("", true);
}

void TAllinea_partite::allinea(int logicnum, TLog_report& log, bool& can_write)
{
  TFast_isamfile fast(logicnum);
  TString query;
  query << "USE " << logicnum;
  TISAM_recordset recset(query);
  TLocalisamfile& file = recset.cursor()->file();
  TRectype& curr = file.curr();

  TString8 last;

  TString msg; 
  msg = can_write ? TR("Allineamento") : TR("Controllo");
  msg << ' ' << file.description() << " : " << recset.items() << ' ' << TR("righe");
  log.log(0, "");
  log.log(1, msg);
  log.log(0, "");

  const int partlen = curr.length(PART_NUMPART);

  TRecnotype nl = 0, na = 0;

  TProgind pi(recset.items(), msg);
  for (bool go = recset.move_first(); go; go = recset.move_next())
  {
    if (!pi.addstatus(1))
    {
      log.log(1, TR("Elaborazione interrotta dall'utente"));
      can_write = false;
      break;
    }
    nl++;
    
    const TString8 numpart = curr.get(PART_NUMPART);
    // Codice partita allineabile in quanto piu' corto della lunghezza massima
    if (numpart[0] == ' ' || numpart.len() < partlen) 
    {
      const char tipocf = curr.get_char(PART_TIPOCF);
      const char richiesto = tipocf == 'F' ? _for_align : _cli_align;
      const char attuale = numpart[0] > ' ' ? 'L' : 'R';
      if (attuale == richiesto)
        continue;

      TString8 newpart = numpart;
      if (richiesto == 'R')
        newpart.right_just(partlen);
      else
        newpart.trim();

      if (numpart != last)
      {
        msg.cut(0);
        if (tipocf > ' ')
          msg << tipocf;
        else
          msg << curr.get(PART_GRUPPO) << ' ' << curr.get(PART_CONTO);
        msg << ' ' << curr.get(PART_SOTTOCONTO) << ' ' << curr.get(PART_ANNO) 
            << " '" << numpart << "' => '"  << newpart << "'";
        log.log(0, msg);
        last = numpart;
      }

      if (can_write)
      {
        const char richiesto = tipocf == 'F' ? _for_align : _cli_align;
        const char attuale = numpart.len() < partlen ? 'L' : 'R';
        if (attuale != richiesto)
        {
          TString8 newpart = curr.get(PART_NUMPART);
          if (richiesto == 'R')
            newpart.right_just(partlen);
          else
            newpart.trim();
          curr.put(PART_NUMPART, newpart);
          
          const TRecnotype recno = file.recno();
          const int err = file.rewriteat(curr, recno);
          if (err == NOERR)
            na++;
          else
          {
            msg = TR("Errore di aggiornamento del file ");
            msg << file.description() << " : " << err;
            log.log(2, msg);
            can_write = false;
          }
        }
      }
    }
  }

  if (nl > 0)
  {
    msg.cut(0) << TR("Righe lette") << " : " << nl;
    log.log(1, msg);
  }
  if (na > 0)
  {
    msg.cut(0) << TR("Righe aggiornate") << " : " << na;
    log.log(1, msg);
  }
}

void TAllinea_partite::compatta(int logicnum, TLog_report& log, bool& can_write)
{
  if (can_write)
  {
    safely_close_closeable_isamfiles();
    TSystemisamfile sysfile(logicnum);

    TString msg;
    msg << TR("Compattamento") << ' ' << sysfile.description();
    log.log(1, msg);
    int err = sysfile.pack(true);
    if (err != NOERR)
    {
      msg = TR("Errore di compattamento del file ");
      msg << sysfile.description() << " : " << err;
      log.log(2, msg);
      can_write = false;
    }
  }
}

void TAllinea_partite::allinea_e_compatta(int logicnum, TLog_report& log, bool& can_write)
{
  allinea(logicnum, log, can_write);
  compatta(logicnum, log, can_write);
}

void TAllinea_partite::main_loop()
{
  TMask msk("sc1300a");
  msk.set(F_ALLINEAMENTO_CLI, _cli_align == 'R' ? "R" : "L");
  msk.set(F_ALLINEAMENTO_FOR, _for_align == 'R' ? "R" : "L");
  msk.set(F_ALLINEAMENTO_CON, _cli_align == 'R' ? "R" : "L");
  while (msk.run() == K_ENTER)
  {
    bool can_write = msk.get_bool(F_SCRITTURA);
    TLog_report log(title());
    allinea_e_compatta(LF_PARTITE,  log, can_write);
    allinea_e_compatta(LF_SCADENZE, log, can_write);
    allinea_e_compatta(LF_PAGSCA,   log, can_write);
    log.preview();
  }
}

int sc1300(int argc, char** argv)
{
  TAllinea_partite a;
  a.run(argc, argv, TR("Allineamento partite"));
  return 0;
}