campo-sirio/pr/pr0800.cpp

// Programma di gestione provvigioni
#include <applicat.h>
#include <automask.h>
#include <msksheet.h>
#include <recset.h>

#include "../cg/cgsaldac.h"
#include "../ve/velib.h"
#include "prlib.h"
#include <modaut.h>
#include <mov.h>
#include <doc.h>
#include "provv.h"
#include "pr0800a.h"
#include "pr0.h"

class TAggiornamento_maturato_mask : public TAutomask
{ 
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

public:
  void load_params();
  void save_params();

  TAggiornamento_maturato_mask() : TAutomask("pr0800a") {}
  virtual ~TAggiornamento_maturato_mask() {}
};

bool TAggiornamento_maturato_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{ 
  switch (o.dlg())
  {         
	case F_A_CODAGE:
		if (e == fe_close)
		{
			const long a_cod = atol(o.get());
			const long da_cod = get_long(F_DA_CODAGE);
			if (a_cod > 0L && da_cod > a_cod)
				return error_box("Codice agente finale minore del codice agente iniziale");
		}
		break;
  default:
    break;
  }            
  return true;
}

class TAggiornamento_maturato_app : public TSkeleton_application
{

protected:
  virtual bool create();
  virtual bool destroy();
  void aggiorna_maturato(TAggiornamento_maturato_mask &m);
  virtual void main_loop();

};

static inline TAggiornamento_maturato_app& app() { return (TAggiornamento_maturato_app&) main_app(); }

////////////////////////////////////////////////////////////////////////////////////////
// Da fare :
// - Quando si elimina l'ultima riga dello spreadsheet si posiziona sulla prima senza 
//   mandare un K_TAB per aggiornare le rate
// - Browse dei documenti in ricerca, quando si seleziona setta giustamente focusdirty() e manda
//   un K_TAB. Quando si tenta di uscire dal campo si ha ancora il campo focusdirty()
// - Cercare di implementare scarico/saldo righe provvigionali per agente in base ad una 
//   impostata
// - Ultimo ma non meno importante (da ritenersi visualmente valido) lo riempimento fisso
//   degli sheet (documenti e rate) in modo da evitare il fastidiosissimo sfarfallio in
//   inserimento righe con elementi vuoti
////////////////////////////////////////////////////////////////////////////////////////

bool TAggiornamento_maturato_app::create()
{
	const bool saldaconto = has_module(SCAUT, CHK_DONGLE);

	if (!saldaconto)
		return error_box("Questo programma necessita del saldaconto");

  open_files(LF_PROVV, LF_TABCOM, LF_DOC, LF_PARTITE, LF_SCADENZE, LF_PAGSCA, LF_TAB, 0);

  return TSkeleton_application::create();
}

bool TAggiornamento_maturato_app::destroy()
{
  return TSkeleton_application::destroy();
}

bool filter_func(const TRelation* rel)
{
	const real importo_rata = rel->curr().get(PROV_IMPRATA);
	const real importo_pagato = rel->curr().get(PROV_PAGATO);

	if ((importo_rata > ZERO) && (importo_rata <= importo_pagato))
		return false;
	else
		return true;
}
bool scan_func(const TRelation& rel, void* pJolly)
{
	TAggiornamento_maturato_mask * m = (TAggiornamento_maturato_mask *) pJolly;
	const TDate data_scad(m->get(F_DATA_SCAD));
	TDate data_rischio(data_scad); data_rischio -= m->get_long(F_GIORNI_RISCHIO);
	bool sbf = false;
	TRectype & rec = rel.curr();
const int anno = rec.get_int(PROV_ANNO);
	const TString16 codnum(rec.get(PROV_CODNUM)) ;
	const long ndoc = rec.get_long(PROV_NDOC);
	TString key;

	key.format("D|%d|%s|%ld", anno, (const char *) codnum, ndoc);
	const long nreg = atol(cache().get(LF_DOC, key, DOC_NUMREG));

	if (nreg > 0)
	{
		TPartite_array p;
		p.add_numreg(nreg);
		if (p.items() > 0)
		{
			const TPartita & part = *(p.first());
			const int nriga = part.prima_fattura(nreg);
			if (nriga >= 0)
			{
				bool changed_record = false;
				TRiga_partite & r = part.riga(nriga);
				const int nrata = rec.get_int(PROV_NRATA);
				const real importo_rata(rec.get_real(PROV_IMPRATA));
				const real importo_pagato(rec.get_real(PROV_PAGATO));
				const real provvigione_rata(rec.get_real(PROV_IMPPROVV));
				const real provvigione_pagata(rec.get_real(PROV_PROVVPAG));

				if (nrata > 0)
				{
					TRiga_scadenze & s = r.rata(nrata);
					TImporto pagato(s.importo_pagato(false));
					
					pagato	-= s.esposto(false, data_scad, data_rischio, sbf);
					pagato.normalize('A');
					if (pagato.valore() >= importo_rata)
					{
						const real importo_maturato = importo_rata - importo_pagato;
						const real provvigione_maturata = provvigione_rata - provvigione_pagata;

						rec.put(PROV_SALDATA, "X");
						rec.put(PROV_PAGMAT, importo_maturato);
						rec.put(PROV_PROVVMAT, provvigione_maturata);

						changed_record = true;
					}	
					else
					{
						const real importo_maturato = pagato.valore() - importo_pagato;

						if (importo_maturato > ZERO)
						{
							real provvigione_maturata = provvigione_rata * (importo_maturato / importo_rata);

							rec.put(PROV_PAGMAT, importo_maturato);
							rec.put(PROV_PROVVMAT, provvigione_maturata);
							changed_record = true;
						}
					}
				}
				else
				{
					const TDate data_mat = rec.get_date(PROV_DATASCAD);

					if (data_mat <= data_scad)
					{
						changed_record = true;
						rec.put(PROV_SALDATA, "X");
						rec.put(PROV_PAGMAT, importo_rata);
						rec.put(PROV_PROVVMAT, provvigione_rata);
					}
				}

				if (changed_record)
				{
					TLocalisamfile provv(LF_PROVV);
					provv.curr() = rec;
					int err = provv.read(_isequal, _lock);
					if (err == NOERR)
						err = rec.rewrite(provv);
					if (err != NOERR)
						return yesno_box("Errore %d nell' aggioramento agente %ld, Continuare ugualmente", err, rec.get_long(PROV_CODAGE));
				}
			}
		}
	}
	return true;
}

void TAggiornamento_maturato_app::aggiorna_maturato(TAggiornamento_maturato_mask &m)
{
	TCursor c(new TRelation(LF_PROVV), "(ANNO!=\"\")&&(CODNUM!=\"\")&&(NDOC!=\"\")&&(SALDATA!=\"X\")");
	TRectype from(LF_PROVV);
	TRectype to(LF_PROVV);
	const TString16 da_cod(m.get(F_DA_CODAGE));
	const TString16 a_cod(m.get(F_A_CODAGE));

	if (da_cod > 0)
		from.put(PROV_CODAGE, da_cod);
	if (a_cod > 0)
		to.put(PROV_CODAGE, a_cod);
	c.setregion(from, to);
	c.set_filterfunction(filter_func);
	c.scan(scan_func, &m, TR("Aggiornamento provvigioni maturate"));
}

void TAggiornamento_maturato_app::main_loop()
{
  TAggiornamento_maturato_mask m;
  while (m.run() == K_ENTER)
		aggiorna_maturato(m);
}

int pr0800(int argc, char** argv)
{
  TAggiornamento_maturato_app  a;
  a.run(argc, argv, TR("Aggiornamento provvigioni maturate"));
  return 0;
}