campo-sirio/vd/vdlib.cpp

#include <automask.h>
#include <diction.h>
#include <recset.h>
#include <relation.h>
#include <recarray.h>
#include <reprint.h>
#include <utility.h>

#include "turni.h"
#include "../include/user.h"
#include "vdlib.h"
#include "vdmask.h"
#include "../cg/cgpagame.h"
#include "../ve/velib.h"


class TApri_mask : public TAutomask
{ 
	const TTurno_vendita & _turno;
public:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

  TApri_mask(const TTurno_vendita & t) : TAutomask("vdlib01"), _turno(t) {}
  virtual ~TApri_mask() { }
};

bool TApri_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
		case F_USERNAME:
			if (e == fe_modify)
				set(F_TURNO, "", 0x3);
			break;
		case F_TURNO:
		case F_PASSWORD:
			if (e == fe_modify)
			{
				const TString & user = get(F_USERNAME);
				const TRectype & rec = cache().get(LF_USER, user);
				const TString & pwd = rec.get(USR_PASSWORD);
				const TString pass = get(F_PASSWORD);
				const bool ok = !rec.empty() && pass == decode(pwd);
				const bool old_turno = get(F_TURNO).full();
				enable(-1, ok && !old_turno);
				enable(DLG_OK, ok);
				if (old_turno)
					clear(-1);
			}
		break;
		case F_SINIZIO:
			if (e == fe_close)
			{
				const TDate & ultima_data = _turno.ultima_data();

				if (ultima_data == get_date(F_DATA))
				{
					const long ora_fine = _turno.ora_fine();
					const long ora_inizio = get_int(F_HINIZIO) * 10000 + get_int(F_MINIZIO) * 100 + get_int(F_SINIZIO);

					if (ora_inizio < ora_fine)
						return error_box("Ora inizio %02d:%02d:%02d antecedente alla fine del turno precedente (%02d:%02d:%02d)",
															get_int(F_HINIZIO), get_int(F_MINIZIO), get_int(F_SINIZIO),
															ora_fine / 10000, (ora_fine / 100) % 100, ora_fine % 100);
				}
			}
		break;
		default:
		break;  
 }

  return true;
}

class TChiudi_mask : public TAutomask
{ 
	TBit_array _rim;
	TTurno_vendita & _turno;

public:
	real calcola_differenza();
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

  TChiudi_mask(TTurno_vendita & t);
  virtual ~TChiudi_mask() {}
};

TChiudi_mask::TChiudi_mask(TTurno_vendita & t)
						: TAutomask("vdlib02"), _turno(t)
{
	TConfig d(CONFIG_DITTA);

	for (int i = 1; i <= 8; i++)
	{
		const TString & codpag = d.get("CODPAG", NULL, i);
		TReport_field * label = _turno.report().section('B', 1).find_field(100 + i);
		TReport_field * value = _turno.report().section('B', 1).find_field(200 + i);

		if (codpag.full())
		{
			TPagamento p(codpag);
			TTipo_pag t = p.tipo_rata(0);

			_rim.set(i, t == _rim_dir);
			
			const TString & desc = d.get("LABPAG", NULL, i);
			
			field(F_INC01 +i -1).set_prompt(desc);
			if (label != NULL)
				label->set(desc);
			if (value != NULL)
				value->show(true);
		}
		else
		{
			field(F_INC01 + i - 1).hide();
			if (label != NULL)
				label->hide();
			if (value != NULL)
				value->hide();
		}
	}
}

real TChiudi_mask::calcola_differenza()
{
	real diff =  get_real(F_CASSAFIN) - get_real(F_CASSAINI) + get_real(F_RESTI);

	for (short id = F_INC01; id <= F_INC08; id++)
	{
		const int i = id - F_INC01 + 1;

		if (_rim[i])
			diff -= get_real(id);
	}
	return diff;
}

bool TChiudi_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
	case F_PASSWORD:
		if (e == fe_modify)
		{
			const TString & user = get(F_USERNAME);
			const TRectype & rec = cache().get(LF_USER, user);
			const TString & pwd = rec.get(USR_PASSWORD);
			const TString pass = get(F_PASSWORD);
			const bool on = !rec.empty() && pass == decode(pwd);
			enable(-1, on && !_turno.riaperto());
			enable(DLG_OK, on);
		}
		break;
	case F_SFINE:
		if (e == fe_close)
		{
			const long ora_inizio = _turno.ora_inizio();
			const long ora_fine = get_int(F_HFINE) * 10000 + get_int(F_MFINE) * 100 + get_int(F_SFINE);

			if (ora_fine <= ora_inizio)
				return error_box("Ora fine %02d:%02d:%02d antecedente alla inizio del turno (%02d:%02d:%02d)",
													get_int(F_HFINE), get_int(F_MFINE), get_int(F_SFINE),
													ora_inizio / 10000, (ora_inizio / 100) % 100, ora_inizio % 100);
		}
		break;
	case F_INC01:
	case F_INC02:
	case F_INC03:
	case F_INC04:
	case F_INC05:
	case F_INC06:
	case F_INC07:
	case F_INC08:
	case F_CASSAFIN:
		{
			const real diff = calcola_differenza();
			set(F_DIFF, diff);
		}
		break;
	default:
		break;  
 }

  return true;
}

void TTurno_vendita::leggi(long progr)
{
	bool aperto = false;
	
	const TString use  = format("USE %d\nFROM CODCASSA=%d ANNO=%d\nTO CODCASSA=%d ANNO=%d\n", LF_TURNI, _cassa, _anno, _cassa, _anno);
	TISAM_recordset r(use);

	if (progr > 0L)
	{
		TRectype & rec = r.cursor()->curr();

		rec.zero();
		rec.put(TRN_CODCASSA, _cassa);
		rec.put(TRN_ANNO, _anno);
		rec.put(TRN_PROGR, progr);
		r.cursor()->read();
		_rec = rec;
		return;
	}
	if (r.items() > 0L)
	{
		r.move_last();
		_rec = r.cursor()->curr();
		const long fine = _rec.get_long(TRN_FINE);

		progr = _rec.get_long(TRN_PROGR);
		aperto = fine == 0L;
	}
	if (!aperto)
	{
		_datafine = _rec.get(TRN_DATA);
		_orafine = _rec.get_long(TRN_FINE);
		progr++;
		_rec.zero();
		_rec.put(TRN_CODCASSA, _cassa);
		_rec.put(TRN_ANNO, _anno);
		_rec.put(TRN_PROGR, progr);
	}
	else
	{
		_datafine = TDate(TODAY);
		_orafine = 0L;
	}
}

const long TTurno_vendita::ora_inizio() const
{
	return _rec.get_long(TRN_INIZIO);
}

bool TTurno_vendita::apri(const bool select_prev)
{
	leggi();
	if (aperto())
		return error_box(FR("Turno aperto dall'Utente %s"), (const char *) _rec.get(TRN_USERNAME));

	TApri_mask m(*this);
	TDocumento d('D', _anno, _codnum, 0L);
	const long fndoc = d.renum_ndoc();
	const long ora = daytime();
	
	m.show(F_TURNO, select_prev);
	m.set(F_CASSA, _cassa);
	m.set(F_USERNAME, user());
	m.set(F_HINIZIO, ora / 10000);
	m.set(F_MINIZIO, (ora / 100) % 100);
	m.set(F_SINIZIO, ora % 100);
	if (m.run() == K_ENTER)
	{
		const long idturno = m.get_long(F_TURNO);
		
		if (idturno > 0L)
		{
			leggi(idturno);
			riapri();
			return true;
		}
		else
		{
			const real cassa_ini = m.get_real(F_CASSAINI);
			const long ora_inizio = m.get_int(F_HINIZIO) * 10000 + m.get_int(F_MINIZIO) * 100 + m.get_int(F_SINIZIO);
			TLocalisamfile f(LF_TURNI);

			_rec.put(TRN_USERNAME, m.get(F_USERNAME));
			_rec.put(TRN_CASSAINI, cassa_ini);
			_rec.put(TRN_CASSAFIN, cassa_ini);
			_rec.put(TRN_DATA, m.get_date(F_DATA));
			_rec.put(TRN_INIZIO, ora_inizio);
			_rec.put(TRN_FNDOC, fndoc);
			_err = _rec.write(f);
		}
		return _err == NOERR;
	}
	return false;
}

// @ cmember riapri il turno
bool TTurno_vendita::riapri()
{
	_rec.zero(TRN_CHIUSO);
	return true;
}

// @ cmember chiudi il turno
bool TTurno_vendita::chiudi()
{
	if (!riaperto())
		leggi();
	if (chiuso())
		return error_box(FR("Turno chiuso"));

	TChiudi_mask m(*this);
	TArray inc;
	real resti, sospesi;
	const TString user = _rec.get(TRN_USERNAME);
	const long fndoc = _rec.get_long(TRN_FNDOC);
	const long lndoc = _rec.get_long(TRN_LNDOC);
	const long ora = daytime();
	int numscontr = 0;
	
	m.set(F_CASSA, _cassa);
	m.set(F_DATA, _rec.get(TRN_DATA));
	m.set(F_USERNAME, user);
  m.set(F_CASSAINI, _rec.get(TRN_CASSAINI));
	m.set(F_HFINE, ora / 10000);
	m.set(F_MFINE, (ora / 100) % 100);
	m.set(F_SFINE, ora % 100);
	m.set(F_CASSAFIN, _rec.get(TRN_CASSAFIN));
	m.set(F_DIFF, _rec.get(TRN_DIFF));

	for (int i = 0; i <= 8; i++)
	  inc.add(ZERO);

	for (long ndoc = fndoc; ndoc <= lndoc; ndoc++)
	{
		TDocumento d('D', _anno, _codnum, ndoc);

		if (user == d.get(TRN_USERNAME))
		{
			if (d.chiuso())
			{
				(real &) inc[1] += d.get_real(TRN_INC01);
				(real &) inc[2] += d.get_real(TRN_INC02);
				(real &) inc[3] += d.get_real(TRN_INC03);
				(real &) inc[4] += d.get_real(TRN_INC04);
				(real &) inc[5] += d.get_real(TRN_INC05);
				(real &) inc[6] += d.get_real(TRN_INC06);
				(real &) inc[7] += d.get_real(TRN_INC07);
				(real &) inc[8] += d.get_real(TRN_INC08);
			}
			else
				sospesi = d.totale_doc();
			resti += d.get_real(TRN_RESTI);
			numscontr++;
		}
	}
	m.set(F_INC01, (real &) inc[1]);
	m.set(F_INC02, (real &) inc[2]);
	m.set(F_INC03, (real &) inc[3]);
	m.set(F_INC04, (real &) inc[4]);
	m.set(F_INC05, (real &) inc[5]);
	m.set(F_INC06, (real &) inc[6]);
	m.set(F_INC07, (real &) inc[7]);
	m.set(F_INC08, (real &) inc[8]);
	m.set(F_SOSPESI, sospesi);
	m.set(F_RESTI, resti);

	const real diff = m.calcola_differenza();

	m.set(F_DIFF, diff);

	if (m.run() == K_ENTER)
	{
		TLocalisamfile f(LF_TURNI);

		if (_rec.get(TRN_FINE).blank())
		{
			const long ora_fine = m.get_int(F_HFINE) * 10000 + m.get_int(F_MFINE) * 100 + m.get_int(F_SFINE);
			_rec.put(TRN_FINE, ora_fine);
		}
		_rec.put(TRN_CHIUSO, (bool) true);
		_rec.put(TRN_INC01, m.get_real(F_INC01));
		_rec.put(TRN_INC02, m.get_real(F_INC02));
		_rec.put(TRN_INC03, m.get_real(F_INC03));
		_rec.put(TRN_INC04, m.get_real(F_INC04));
		_rec.put(TRN_INC05, m.get_real(F_INC05));
		_rec.put(TRN_INC06, m.get_real(F_INC06));
		_rec.put(TRN_INC07, m.get_real(F_INC07));
		_rec.put(TRN_INC08, m.get_real(F_INC08));
		_rec.put(TRN_SOSPESI, m.get_real(F_SOSPESI));
		_rec.put(TRN_CASSAFIN, m.get_real(F_CASSAFIN));
		_rec.put(TRN_DIFF, m.get_real(F_DIFF));
		_rec.put(TRN_LNDOC, ndoc);
		_rec.put(TRN_NUMSCONTR, numscontr);
		_err = _rec.rewrite(f);
		if (_err == NOERR)
		{
			TReport & rep = report();
			TReport_book book;
			TVariant var;

			var = _rec.get(TRN_CODCASSA);
			rep.recordset()->set_var("#CODCASSA", var);
			var =  _rec.get(TRN_ANNO);
			rep.recordset()->set_var("#ANNO", var);
			var =  _rec.get(TRN_PROGR);
			rep.recordset()->set_var("#PROGR", var);
		
			book.add(rep);
			book.print();
			return true;
		}
		else
			return error_box(FR("Errore di scrittura turno %d"), _err);
	}
	return false;
}

const real TTurno_vendita::cassa_attuale()
{
	if (!riaperto())
		leggi();
	return _rec.get_real(TRN_CASSAFIN);
}

bool TTurno_vendita::aggiorna(const long ndoc, const real & saldo)
{
	if (!riaperto())
		leggi();
	if (chiuso())
		return error_box(FR("Turno chiuso"));

	TLocalisamfile f(LF_TURNI);
	const long fndoc = _rec.get_long(TRN_FNDOC);
	const long lndoc = _rec.get_long(TRN_LNDOC);

	if (ndoc < fndoc)
		_rec.put(TRN_FNDOC, ndoc);
	if (ndoc > lndoc)
		_rec.put(TRN_LNDOC, ndoc);
	_rec.put(TRN_CASSAFIN, saldo);

	_err = _rec.rewrite(f);
		if (_err != NOERR)
			return error_box(FR("Errore di scrittura turno %d"), _err);
	return true;
}

bool TTurno_vendita::aperto() const 
{
	return _rec.get_long(TRN_INIZIO) > 0L && !_rec.get_bool(TRN_CHIUSO);
}

const TString & TTurno_vendita::user() const
{
	return _rec.get(TRN_USERNAME);
}

int TTurno_vendita::nturno() const
{
	return _rec.get_int(TRN_PROGR);
}

TTurno_vendita::TTurno_vendita() : _rec(LF_TURNI)
{
	{
		TConfig w(CONFIG_WST);
	
		_cassa = w.get_int("NCASSA");
	}

	_anno = TDate(TODAY).year();
	TConfig d(CONFIG_DITTA);
	
	_codnum = d.get("CODNUM");
	if (_codnum.empty())
		fatal_box(TR("E' necessario configurare il modulo prima di utilizzare questo programma!"));
	_rep.load("vdlib02r");
	leggi();
}

TOperatore::TOperatore(const char * user) : _rec(LF_TAB)
{
	_rec = cache().get("OPD", user);
}