/**************************************************
 * File: ve6900.cpp																*
 * Programma per il controllo degli ordini evasi	*
 * Authors: Alessandro Bonazzi, Mattia Tollari		*
 **************************************************/

#include <automask.h>
#include <progind.h>
#include <relation.h>
#include <sheet.h>
#include <tabutil.h>
#include <defmask.h>

#include "velib04.h"
#include "../cg/cgsaldac.h"

#include "ve6900a.h"


///////////////////////////////////////////////
//  MASCHERA																 //
///////////////////////////////////////////////
class TControllo_ordini_mask : public TAutomask
{
  TString_array   _tipi_doc;   // Array di stringhe contenente i tipi documenti da elaborare

protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

public:
  // Controlla se lo stato ed il tipo del documento sono validi e rispettano la selezione
  bool doc_tipo_stato_ok(const TRectype& doc);
  // Constructor and Distructor
	TControllo_ordini_mask(): TAutomask("ve6900a") {}
	~TControllo_ordini_mask() {}
};

bool TControllo_ordini_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
  case DLG_USER:
    if (e == fe_button)
    {
    }
    break;
  default:
    break;
  }
  return true;
}

bool TControllo_ordini_mask::doc_tipo_stato_ok(const TRectype& doc)
// Verifica che il tipo documento corrente esista tra i tipi previsti dalla elaborazione
// differita selezionata
{
  bool found = false;
  const TString4 tipo = doc.get(DOC_TIPODOC);
  const char stato = doc.get_char(DOC_STATO);
  const int items = _tipi_doc.items();
  for (int i = 0; i < items && !found; i++)
  {
    TToken_string& t = _tipi_doc.row(i);
    const TString4 tipox(t.get(0));
    const char statox = t.get(1)[0];
    if (tipo == tipox && stato == statox)
      found = true;
  }
  return found;
}

/////////////////////////////////////////////
//  APPLICAZIONE													 //
/////////////////////////////////////////////

// TControllo_ordini
// Applicazione per il controllo degli ordini evasi
class TControllo_ordini_app : public TSkeleton_application
{
  TControllo_ordini_mask*  _msk;

protected: // TApplication
  // Controlla gli ordini
  void check();

public:
  virtual bool create();
  virtual bool destroy();
  virtual void main_loop();
};


void TControllo_ordini_app::check() 
{
	// Creo la relazione alla tabella del Db
	TRelation rel(LF_DOC);
  // Definisco i due TRecType di inizio e fine per lo scorrimento
  TRectype recini(rel.curr());
  TRectype recfin(rel.curr());
	// Imposto il cursore
  rel.lfile().set_curr(new TDocumento);
	// Aggiungo dei filtri, in questo caso utilizzando la KEY 1 ho bisogno di
	// PROVV+ANNO+CODNUM
	// Inizio
	recini.put(DOC_PROVV, _msk->get(F_PROVV));
  recini.put(DOC_ANNO, _msk->get(F_DA_ANNO));
	recini.put(DOC_CODNUM, _msk->get(F_CODNUM));
	// Fine
	recfin.put(DOC_PROVV, _msk->get(F_PROVV));
  recfin.put(DOC_ANNO, _msk->get(F_A_ANNO));
	recfin.put(DOC_CODNUM, _msk->get(F_CODNUM));
	// Salviamo lo stato da impostare
	const TString4 stato = _msk->get(F_STATO);
	TString filter("");
	if(stato != "")
	{
	// Filtro sullo stato del documento
	filter << "STATO<" << stato;
	}

	// Istanzio il cursore
  TCursor cur(&rel, filter, 1, &recini, &recfin);
  const long total = cur.items();
	// Se esistono righe
  if (total > 0)
  {
    TString msg = TR("Confermare l'aggiornamento di ");
    msg.add_plural(total, TR("documento"));
    if (yesno_box(msg))
    {
      TProgress_monitor pi(total, title());
			// Blocco il cursore per garantire l'integrità dei dati
      cur.freeze();
      for (cur = 0; cur.pos() < total; ++cur)
      {
				if (!pi.add_status())
            break;
				TDocumento& doc = (TDocumento&) cur.curr();
				bool save = false;
				if(doc.numero() == 46)
					int num = 1;
				bool docEvaso = true;
				// Controllo che il documento sia completamente evadibile e non già segnato evaso
				for (int i = doc.physical_rows(); i > 0; i--)
					{
						TRiga_documento& r = doc[i];
						if(r.get(RDOC_RIGAEVASA) != "X" && r.is_evadibile() && r.is_evasa())
						{
							r.put(RDOC_RIGAEVASA, "X");
							save = true;
						}

						docEvaso &= (!r.is_evadibile() || r.is_evasa());             
					}
				// Imposto il nuovo stato
				if(docEvaso && stato != "")
				{
					doc.put(DOC_STATO, stato);
					save = true;
				}
				if (save)
					int err = doc.rewrite();
      }
    }
  }
}


bool TControllo_ordini_app::create()
{
  open_files(LF_TABCOM, LF_TAB, LF_DOC, LF_RIGHEDOC, LF_MOVANA, LF_RMOVANA, 0);
  _msk = new TControllo_ordini_mask();
  return TSkeleton_application::create();
}

bool TControllo_ordini_app::destroy()
{
  if (_msk) delete _msk;
  return TSkeleton_application::destroy();
}

void TControllo_ordini_app::main_loop()
{
  while (_msk->run() == K_ENTER)
    check();
}

int ve6900 (int argc, char **argv)
{
  TControllo_ordini_app a;
  a.run(argc,argv, TR("Controllo ordini evasi"));
  return true;
}