campo-sirio/src/f9/f90300.cpp

#include "f90.h"

#include <Windows.h>
#include <set>
#include <map>


#include "annessif9.h"
#include "applicat.h"
#include "automask.h"
#include "docf9.h"
#include "sheet.h"
#include "urldefid.h"
#include "utility.h"
#include "mov.h"
#include "isam.h"
#include "f9lib01.h"
#include "f90300a.h"
#include "f90300b.h"

#define TABMOD_CARTDIR  "S0"

///////////////////////////////////////////////////////////////////////////////
// TImport_msk

class TImport_msk : public TAutomask
{
  friend class TGestione_doc_cartacei_f9_msk;

  std::shared_ptr<TArray_sheet>           _catdocs;
  map<TString, unique_ptr<TArray_sheet>>  _annessi;

  bool on_field_event(TOperable_field& o, TField_event e, long jolly) override;

  static bool catdocann_handler(TMask_field& field, KEY key);
  static bool catannpadre_handler(TMask_field& field, KEY key);
  static bool ok_handler(TMask_field& field, KEY key);

  const char* select_catdoc();

public:
  TImport_msk();
};

bool TImport_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  case F_ISANNESSO:
    if (e == fe_modify)
    {
      const bool on = o.mask().get_bool(F_ISANNESSO);
      o.mask().enable(F_CATANNPADRE, on);
      o.mask().enable(F_CATDOCANN, on);
    }
  default: break;
  }
  return true;
}

bool TImport_msk::catdocann_handler(TMask_field& field, KEY key)
{
  static const char* msg_notexist = "Non esistono tipologie di annessi per questa categoria documentale.";
  static const char* msg_inspadre = "Inserire prima la cat. doc. padre.";
  TImport_msk& msk = (TImport_msk&)field.mask();
  if (key == K_TAB && field.dirty() && field.full())
  {
    if (msk.get(F_CATANNPADRE).full())
    {
      const TString_array names_ann = categorie_doc().get_array_ann(msk.get(F_CATANNPADRE));
      if (names_ann.items() > 0)
      {
        bool ok = false;
        FOR_EACH_ARRAY_ITEM(names_ann, nr, ann)
        {
          if (field.get() == (*(TToken_string*)ann).get(0))
            ok = true;
        }
        if (!ok)
        {
          msk.error_box("La categoria inserita e' inesistente");
          field.set("");
        }
      }
      else
        warning_box(msg_notexist);
    }
    else
    {
      warning_box(msg_inspadre);
      field.set("");
    }
  }
  if (key == K_F9)
  {
    if (msk.get(F_CATANNPADRE).full())
    {
      TArray_sheet* annessi = categorie_doc().get_sheet_ann(msk.get(F_CATANNPADRE)).get();

      if (annessi && annessi->items() > 0)
      {
        if (annessi->run() == K_ENTER)
          msk.set(F_CATDOCANN, annessi->row(annessi->selected()).get(0));
      }
      else
        warning_box(msg_notexist);
    }
    else
      warning_box(msg_inspadre);
  }
  return true;
}

bool TImport_msk::catannpadre_handler(TMask_field& field, KEY key)
{
  TImport_msk& msk = (TImport_msk&)field.mask();
  if (key == K_TAB && field.dirty() && field.full())
  {
    std::set<TString>& name_cats = categorie_doc().get_name_catdocs();
    
    const bool ok = name_cats.find(field.get()) != name_cats.end();
    if (!ok)
    {
      msk.error_box("La categoria inserita e' inesistente");
      field.set("");
    }
  }
  if (key == K_F9)
  {
    field.set(msk.select_catdoc());
    msk.set(F_CATDOCANN, "");
  }
    
  return true;
}

bool TImport_msk::ok_handler(TMask_field& field, KEY key)
{
  field.mask().send_key(K_ENTER, DLG_OK);
  return true;
}

const char* TImport_msk::select_catdoc()
{
  if(_catdocs == nullptr)
    _catdocs = categorie_doc().get_sheet_catdocs();
  if (_catdocs->run() == K_ENTER)
    return _catdocs->row().get(0);
  return "";
}

TImport_msk::TImport_msk(): TAutomask("f90300b")
{
  TMask::set_handler(F_CATANNPADRE, catannpadre_handler);
  TMask::set_handler(F_CATDOCANN, catdocann_handler);
}




///////////////////////////////////////////////////////////////////////////////
// TGestione_doc_cartacei_f9_msk
///////////////////////////////////////////////////////////////////////////////

class TGestione_doc_cartacei_f9_msk : public TAutomask
{
  struct doc_cart_t
  {
    TString filename;
    TString loaddate;
    TString numreg;
    TString user;
  };
  const TString&                      _addr_cart;   // Indirizzo cartella doc. cartacei F9
  std::unique_ptr<std::set<TString>>  _extensions;  // todo: controllare che con TString funzioni l'ordinamento, quindi la find
  std::unique_ptr<TImport_msk>        _import_msk;
  std::map<TString, doc_cart_t>       _list_file;

  bool on_field_event(TOperable_field& o, TField_event e, long jolly) override;

  void                  check_addr_cart() const;
  static void           check_deleted();
  bool                  check_file_exist(const TString& file) const;
  void                  delete_file();
  void                  fill();
  void                  fill_annessi() const;
  void                  fill_docs();
  static TToken_string& get_valid_extensions();
  void                  load_extensions();
  bool                  load_file(const TFilename& file, const TString& numreg, bool is_annesso, const TString& catannpadre, const TString& catdocann);
  void                  open_config_win() const;
  void                  open_import_win();
  static void           remove_file_from_f9cart(const std::set<TString>& files);
  bool                  verify_extension(const TFilename& file);

public:
  TGestione_doc_cartacei_f9_msk();
};

bool TGestione_doc_cartacei_f9_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  if(e == se_query_add || e == se_query_del || e == se_query_modify)
    return false;

  switch (o.dlg())
  {
  case B_IMPORT:
    if (e == fe_button)
      open_import_win();
    break;
  case B_DELETE:
    if (e == fe_button)
      delete_file();
    break;
  case B_CONFIG:
    if (e == fe_button)
      open_config_win();
  default: break;
  }
  return true;
}

void TGestione_doc_cartacei_f9_msk::check_addr_cart() const
{
  const TFilename f(_addr_cart);
  if (f.full() && !f.exist())
  {
    warning_box("Cartella documenti cartacei non trovata.\nSalvare nuovamente le impostazioni.");
    open_config_win();
  }
}

void TGestione_doc_cartacei_f9_msk::check_deleted()
{
  // Controllo che non ci siano file nella cartella eliminati da piu' di un mese, altrimenti li elimino
  TString_array result;
  TFilename s; s << TFilename(F9CONF.get_addr_cart()).slash_terminate() << "eliminati\\";
  if (s.exist())
  {
    list_files(s, result);
    FOR_EACH_ARRAY_ITEM(result, nr, file)
    {
      const char* deletedfile = *(TString*)(file);
      HANDLE      h_file = CreateFile(deletedfile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
      FILETIME    last_access_time;
      SYSTEMTIME  time;
      bool flag = false;
      if (h_file != INVALID_HANDLE_VALUE)
      {
        if (GetFileTime(h_file, NULL, &last_access_time, NULL))
        {
          FileTimeToSystemTime(&last_access_time, &time);
          TDate today = TDate(TODAY);
          if (time.wMonth < (unsigned short)today.month() - 1 ||
            time.wMonth == (unsigned short)today.month() - 1 && time.wDay <= (unsigned short)today.day())
          {
            flag = true;
            CloseHandle(h_file);
            DeleteFile(deletedfile);
          }
        }
      }
      if (!flag)
        CloseHandle(h_file);
    }
  }
}

bool TGestione_doc_cartacei_f9_msk::check_file_exist(const TString& file) const
{
  TFilename path(_addr_cart);
  path.slash_terminate() << file;
  return path.exist();
}

void TGestione_doc_cartacei_f9_msk::delete_file()
{
  int p = curr_page();
  TSheet_field& sf = p == 0 ? sfield(S_IMPORTED) : sfield(S_ANNESSI);
  FOR_EACH_SHEET_ROW(sf, nr, row)
  {
    if (row->starts_with("X"))
    {
      TLocalisamfile f9cart(LF_F9DOCS);
      TLocalisamfile f9annessi(LF_F9ANNESSI);
      const char* filename  = row->get(cid2index(F_FILENAME));
      const char* numreg    = row->get(p == 0 ? cid2index(F_NUMREG) : cid2index(F_ANUMREG));

      if (p == 0)
      {
        f9cart.put(F9C_FILENAME, filename);
        f9cart.put(F9C_NUMREG, numreg);
        f9cart.read();
      }
      else
      {
        f9annessi.put(F9A_NUMREG, numreg);
        f9annessi.put(F9A_FILENAME, filename);
        f9annessi.read();
      }
      TFilename filecart(F9CONF.get_addr_cart());
      filecart.slash_terminate();
      TFilename deleted(filecart);
      filecart << filename;
      deleted  << "eliminati" << SLASH;
      if (!deleted.exist())
        make_dir(deleted);
      deleted << filename;
      if (deleted.exist())
        DeleteFile(deleted);
      if (!MoveFile(filecart, deleted))
        warning_box(TString("Attenzione:") << " non e' stato possibile rimuovere questo file: " << filecart);
      else
      {
        if (p == 0)
          f9cart.remove();
        else
          f9annessi.remove();
      }
    }
  }
  fill();
}

void TGestione_doc_cartacei_f9_msk::fill()
{
  fill_docs();
  fill_annessi();
}

void TGestione_doc_cartacei_f9_msk::fill_annessi() const
{
  TLocalisamfile ann(LF_F9ANNESSI);
  if(ann.first() == NOERR)
  {
    TLocalisamfile mov(LF_MOV);
    TSheet_field& sf = sfield(S_ANNESSI);
    sf.hide();
    sf.destroy();
    do
    {
      TToken_string&  row     = sf.row(-1);
      const TString&  numreg  = ann.get(F9A_NUMREG);

      mov.put(MOV_NUMREG, numreg);
      mov.read();

      row.add(ann.get(F9A_FILENAME), 1);  // ITEM "Nome File@25"
      row.add(ann.get(F9A_CATDOCPAD));    // ITEM "Categoria di\nappartenenza@7"
      row.add(ann.get(F9A_CATDOCANN));    // ITEM "Classe doc.\nannesso@7"
      row.add(numreg);                    // ITEM "Movimento\nContabile N.@7"
      row.add(mov.get(MOV_DATAREG));      // ITEM "Data\nMovimento@10"
      row.add(mov.get(MOV_CODCAUS));      // ITEM "Causale@7"
      row.add(mov.get(MOV_NUMDOC));       // ITEM "Num. Doc.@7"
      row.add(TString(mov.get(MOV_REG)) << "/" << mov.get(MOV_PROTIVA));  // ITEM "Reg./Prot. IVA@10"
      row.add(mov.get(MOV_DESCR));        // ITEM "Descrizione@20"
      row.add(ann.get(F9A_LOADDATE));     // ITEM "Data\nCaricamento@10"
      // todo: row.add("")                // ITEM "Info (Errori)@25"
    } while (ann.next() == NOERR);
    sf.force_update();
    sf.show();
  }
}

void TGestione_doc_cartacei_f9_msk::fill_docs()
{
  TLocalisamfile  files(LF_F9DOCS);
  TLocalisamfile  mov(LF_MOV);
  TSheet_field&   sf = sfield(S_IMPORTED);
  sf.hide();
  sf.destroy();
  _list_file.clear();
  std::set<TString> file_err;
  if (files.first() == NOERR)
  {
    do
    {
      const TString&  namefile  = files.get(F9C_FILENAME);
      const bool      not_exist = !check_file_exist(namefile);
      if (not_exist)
        file_err.insert(namefile);
      const TString& numreg = files.get(F9C_NUMREG);
      TString datamov, caus, numdoc, nprot, descrmov;
      mov.zero();
      mov.put(MOV_NUMREG, numreg);
      if (mov.read() == NOERR)
      {
        datamov = mov.get(MOV_DATAREG);
        caus    = mov.get(MOV_CODCAUS);
        numdoc  = mov.get(MOV_NUMDOCEXT);
        if (numdoc.empty()) numdoc = mov.get(MOV_NUMDOC);
        nprot << mov.get(MOV_REG) << "/" << mov.get(MOV_PROTIVA);
        descrmov = mov.get(MOV_DESCR);
      }
      TToken_string& r = sf.row(-1);
      r.add(" ", 0);                                                  // F_SEL
      r.add(namefile);                                                // F_FILENAME
      r.add(numreg);                                                  // F_NUMREG
      r.add(datamov);                                                 // F_DATAMOV
      r.add(caus);                                                    // F_CAUS
      r.add(numdoc);                                                  // F_NUMDOC
      r.add(nprot);                                                   // F_NPROTOCOL
      r.add(descrmov);                                                // F_DESCRMOV
      r.add(files.get(F9C_LOADDATE));                                 // F_DATACARIC
      r.add(not_exist ? "IL FILE NON E' PRESENTE IN ARCHIVIO." : ""); // F_INFO

      _list_file.insert({ namefile, { namefile, files.get(F9C_LOADDATE), numreg, files.get(F9C_USER) } });
    } while (files.next() == NOERR);
    sf.force_update();
  }
  sf.show();
  if (!file_err.empty())
  {
    int count = 0;
    const bool m = (int)file_err.size() == 1;
    const char p = m ? 'o' : 'i';
    TString msg; msg << (int)file_err.size() << " file non " << (m ? "e'" : "sono") << " stat" << p <<
      " trovat" << p << ".\nSi prega di rimuoverl" << p << " dall'elenco\n\nFile non trovat" << p << ":";

    for (auto it = file_err.begin(); it != file_err.end(); ++it)
    {
      if (count++ == 10)
      {
        msg << "\n" << "...";
        break;
      }
      msg << "\n" << *it << " [Num. Reg.: " << _list_file.find(*it)->second.numreg << "]";
      }
#ifndef DBG
    const bool del = warning_box(msg);
#else
    if (yesno_box(msg))
    {
      remove_file_from_f9cart(file_err);
      fill();
    }
#endif
    }
}

TToken_string& TGestione_doc_cartacei_f9_msk::get_valid_extensions()
{
  static TToken_string ext(F9CONF.get_estensioni(), ',');
  if (ext.items() == 0)
  {
    ext = ".pdf, .doc, .docx, .xls, .xlsx, .jpg, .jpeg, .png";
    F9CONF.set_estensioni(ext);
  }
  ext.replace(" ", "");
  return ext;
}

void TGestione_doc_cartacei_f9_msk::load_extensions()
{
  if (_extensions == nullptr)
  {
    _extensions = std::make_unique<std::set<TString>>();
    TToken_string& ext = get_valid_extensions();
    for (int i = 0; i < ext.items(); ++i)
    {
      TString e = ext.get(i);
      if (!e.empty())
      {
        if (e.starts_with("."))
          e.ltrim(1);
        _extensions->insert(e);
      }
    }
  }
}

bool TGestione_doc_cartacei_f9_msk::load_file(const TFilename& file, const TString& numreg, const bool is_annesso,
                                              const TString& catannpadre, const TString& catdocann)
{
  TString         numreg_old;
  bool            annesso;
  TF9_doccart     f9cart;
  TLocalisamfile  f9docs(LF_F9DOCS);
  TLocalisamfile  f9annessi(LF_F9ANNESSI);
  if(f9cart.doc_already_exists(file, numreg_old, annesso))
  {
    warning_box("Attenzione: esiste gia' un %s con questo nome associato al num. di registrazione %s", annesso ? "annesso" : "documento", (const char*)numreg_old);
    return false;
  }

  if(!is_annesso)
  {
    TFilename doc;
    if (f9cart.mov2doc(numreg, doc) && !doc.empty())
    {
      warning_box("Attenzione: la registrazione num. %s ha gia' un documento associato: %s.\n"
        "Se si tratta di un annesso inserire le informazioni per la cat. documentale.", (const char*)numreg, (const char*)doc);
      return false;
    }

    f9docs.zero();
    f9docs.put(F9C_FILENAME, file.name());
    f9docs.put(F9C_NUMREG,   numreg);
    f9docs.put(F9C_LOADDATE, TDate(TODAY));
    f9docs.put(F9C_USER,     user());
  }
  else
  {
    f9annessi.zero();
    f9annessi.put(F9A_NUMREG,     numreg);
    f9annessi.put(F9A_FILENAME,   file.name());
    f9annessi.put(F9A_CATDOCPAD,  catannpadre);
    f9annessi.put(F9A_CATDOCANN,  catdocann);
    f9annessi.put(F9C_LOADDATE,   TDate(TODAY));
    f9annessi.put(F9C_USER,       user());
  }
  TFilename     fdestin   = F9CONF.get_addr_cart();
  const TString filename  = file.name();
  fdestin << filename;
  const bool ok = CopyFile(file, fdestin, true);
  if (!ok)
  {
    if (fdestin.exist())
      warning_box("Errore nel copiare il file nella cartella di destinazione.\nEsiste gia' un file con questo nome.");
    else
      warning_box("Errore nel copiare il file nella cartella di destinazione. Ritentare.");
    f9docs.zero();
    return false;
  }
  if (!is_annesso)
  {
    f9docs.write();
    f9docs.rewrite();
  }
  else
  {
    f9annessi.write();
    f9annessi.rewrite();
  }
  return true;
}

void TGestione_doc_cartacei_f9_msk::open_config_win() const
{
  static std::unique_ptr<TMask> msk;
  if(msk == nullptr)
  {
    msk = std::make_unique<TMask>("Configurazione", 1, 78, 14);
    msk->add_button_tool(DLG_OK, "Conferma", TOOL_OK);
    msk->add_button_tool(DLG_NULL, "", 0);
    msk->add_button_tool(DLG_QUIT, "Esci", TOOL_QUIT);

    msk->add_groupbox(DLG_NULL, 0, "", 1, 0, 76, 4, "");
    msk->add_static  (DLG_NULL, 0, "@BInserire estensioni file riconosciute, separate da virgola.", 2, 1);
    msk->add_string  (101, 0, "Estensioni:", 2, 2, 255, "", 60);
    msk->add_groupbox(DLG_NULL, 0, "@BCartella documenti cartacei", 1, 4, 76, 4);
    msk->add_static  (DLG_NULL, 0, "@BInserire nome cartella, all'interno della area dati della ditta", 2, 5);
    msk->add_string  (102, 0, "", 2, 6, 64, "", 30);

    msk->set(101, F9CONF.get_estensioni());
    TString s = F9CONF.get_addr_cart();
    s.rtrim(1);
    s.ltrim(s.rfind('\\') + 1);
    msk->set(102, s);
  }

  while (true)
  {
    if (msk->run() != K_ENTER)
    {
      if (msk->get(102).empty())
      {
        warning_box("Si prega di inserire il nome della cartella per i documenti cartacei.");
        continue;
      }
      break;
    }
    F9CONF.set_estensioni(msk->get(101));
    TString dir = msk->get(102);
    if (dir.empty())
    {
      if(yesno_box("Nome cartella vuoto.\nCreare cartella con nome 'Cartacei_F9'?"))
        msk->set(102, dir = "Cartacei_F9");
      else continue;
    }

    TFilename path(prefix().get_studio());
    path.slash_terminate() << dir;
    path.slash_terminate();
    if (!path.exist())
    {
      if (dir == "Cartacei_F9" || yesno_box("Il percorso indicato e' inesistente.\nCreare la cartella con questo nome?"))
      {
        if (!make_dir(path))
        {
          warning_box("Impossibile creare il percorso specificato.");
          continue;
        }
      }
      else continue;
    }
    F9CONF.set_addr_cart(path);
    break;
  }
}

void TGestione_doc_cartacei_f9_msk::open_import_win()
{
  if(_import_msk == nullptr)
    _import_msk = make_unique<TImport_msk>();
  while(_import_msk->run() == K_ENTER)
  {
    const TString&  file        = _import_msk->get(F_IMPADDRESS);
    const TString&  numreg      = _import_msk->get(F_IMPNUMREG);
    const bool      is_annesso  = _import_msk->get_bool(F_ISANNESSO);
    const TString&  catannpadre = _import_msk->get(F_CATANNPADRE);
    const TString&  catdocann   = _import_msk->get(F_CATDOCANN);
    if (!file.empty())
    {
      TFilename f(file);
      if (verify_extension(f))
      {
        if(!numreg.empty())
        {
          if (!is_annesso || catannpadre.full() && catdocann.full())
          {
            if (load_file(f, numreg, is_annesso, catannpadre, catdocann))
              message_box("File caricato.");
          }
          else
            warning_box("Se il documento e' un annesso, si prega di inserire le\ninformazioni per la categoria documentale dell'annesso.");
        }
        else
          warning_box("Si prega di inserire il numero di registrazione.");
      }
      else
        warning_box("Questo file e' in un formato non accettato.");
    }
    else
      warning_box("Si prega di inserire il nome del file.");
  }
  fill();
}

void TGestione_doc_cartacei_f9_msk::remove_file_from_f9cart(const std::set<TString>& files)
{
  TLocalisamfile f9cart(LF_F9DOCS);
  for(auto it = files.begin(); it != files.end(); ++it)
  {
    f9cart.zero();
    f9cart.put(F9C_FILENAME, *it);
    f9cart.read();
    f9cart.remove();
  }
}

bool TGestione_doc_cartacei_f9_msk::verify_extension(const TFilename& file)
{
  load_extensions();
  return _extensions->find(file.ext()) != _extensions->end();
}

TGestione_doc_cartacei_f9_msk::TGestione_doc_cartacei_f9_msk(): TAutomask("f90300a"), _addr_cart(F9CONF.get_addr_cart())
{
  if (_addr_cart.empty())
  {
    message_box("Inserire nome cartella documenti cartacei.");
    open_config_win();
  }
  else
    check_addr_cart();
  check_deleted();
  fill();
}




///////////////////////////////////////////////////////////////////////////////
// TGestione_doc_cartacei_f9_app
///////////////////////////////////////////////////////////////////////////////

class TGestione_doc_cartacei_f9_app : public TSkeleton_application
{
  void main_loop() override
  {
    TGestione_doc_cartacei_f9_msk msk;
    while (msk.run() == K_ENTER)
    {  }
  }
};




int f90300(const int argc, char* argv[])
{
  TGestione_doc_cartacei_f9_app app;
  app.run(argc, argv, "Gestione documenti cartacei");
  return 0;
}