campo-sirio/src/ca/calib01.h

#ifndef __CALIB01_H
#define __CALIB01_H

#ifndef __AUTOMASK_H
#include <automask.h>
#endif

#ifndef __MULTIREC_H
#include <multirec.h>
#endif

#ifndef __RELAPP_H
#include <relapp.h>
#endif

#ifndef __CGLIB03_H
class TBill;
#endif

class TRecordset ;

typedef TString20 TCodice_con;
typedef TString20 TCodice_cdc;
typedef TString20 TCodice_cms;
typedef TString16 TCodice_fas;

///////////////////////////////////////////////////////////
//  TConfig_anal
///////////////////////////////////////////////////////////

TConfig& ca_config(bool force = false);
 //il bool=true serve in caso di cambio di configurazione al volo nel programma di importazione da CM a CA, in modo da..
//..rilevare subito la configurazione cambiata senza dover uscire e rientrare dal programma

///////////////////////////////////////////////////////////
//  TConfig_anal
///////////////////////////////////////////////////////////

class TMultilevel_code_info : public TObject
{
  int _logicnum;               // Logic number of main file
  TString_array _prompt;       // Prompts of mask fields
  TString_array _picture;      // Pictures of mask fields
  TArray _key1_fields;         // TFieldrefs of key 1 mask fields
  TArray _key2_fields;         // TFieldrefs of key 2 mask fields
  int _parentnum;              // Logic number of parent file (LF_FASI only)
  TString8 _editor;            // Riga di comando del programma gestore

protected:
  bool get_cfg_vars(TString& key, TString& des) const;
  const char* get_key_fieldname(int k = 1) const;
  void add_fieldref(int k, int from, int to);

public:
  int levels() const;
  int len(int level) const;
  int total_len(int level) const;
  const TString& picture(int level) const;
  bool is_numeric_picture(int level) const;
  bool is_required(int level) const;
  const TString& prompt(int level) const;
  const TFieldref& fieldref(int level, int key = 1) const;
	int logic() const { return _logicnum; }
  int parent() const { return _parentnum; }
  const TString& editor() const { return _editor; }
  int pack(TString& code) const;    // Toglie i pipe
  int unpack(TString& code) const;  // Aggiunge i pipe
  int parent_levels() const; // Numero di livelli del padre di LF_FASI (puo' essere 0)

  TMultilevel_code_info(int logicnum);
  virtual ~TMultilevel_code_info() { }
};

const TMultilevel_code_info& ca_multilevel_code_info(int logicnum);
const TMultilevel_code_info* ca_multilevel_code_info_by_index(int level);
bool ca_test_multilevel_field(TEdit_field& fld, int level);

//metodi di filtraggio avanzato anche in base ai permessi utente
const char* ca_dollar2fieldname(int logic, const char* dollar);
void ca_append_and(TString& query, const TString& clause);
const TString& ca_create_user_select_clause(int logic);
bool ca_filter_record(const TRectype& rec);
bool ca_filter_function(const TRelation* rel);

int ca_create_fields(TMask& msk, int page, int logicnum, int x, int y, short key_id, short des_id, 
                     unsigned int mode = 0x0, const char* fieldname = NULL, int from = 0, bool desc_in_sh = false);
int ca_create_fields_compact(TMask& msk, int page, int logicnum, int x, int y, 
														 short key_id, short des_id, unsigned int mode = 0x0, const char* fieldname = NULL, int from = 0);

//CA_CREATE_FIELDS_EXT: crea tutti i campi dell'analitica desiderati in base alla configurazione della contabilit<69> analitica
int ca_create_fields_ext(TMask& m, int page, int x, int y, short first_id,
                         short& first_cdc, short& first_cms, short& first_fase, short& first_conto,
                         const char* cdc_fld = NULL, const char* cms_fld = NULL, const char* fase_fld = NULL, const char* conto_fld = NULL);

//CA_GET_FIELDS: getta tutti i campi dell'analitica che sono stati generati in base alla configurazione della contabilit<69> analitica
void ca_get_fields(TMask& m,
                   TString& cdc,               TString& cms,               TString& fase,               TString& conto,
                   const short first_cdc,      const short first_cms,      const short first_fase,      const short first_conto,
                   const char* cdc_fld = NULL, const char* cms_fld = NULL, const char* fase_fld = NULL, const char* conto_fld = NULL);

//CA_GET_ROW_FIELDS: getta tutti i campi dell'analitica che sono stati generati in base alla configurazione della contabilit<69> analitica su una maschera di riga
void ca_get_row_fields(TSheet_field& sheet, const int selected_row,
                       TString& cdc,               TString& cms,               TString& fase,               TString& conto,
                       const short first_cdc,      const short first_cms,      const short first_fase,      const short first_conto,
                       const char* cdc_fld = NULL, const char* cms_fld = NULL, const char* fase_fld = NULL, const char* conto_fld = NULL);

//CA_PUT_ROW_FIELDS: setta tutti i campi dell'analitica che sono stati generati in base alla configurazione della contabilit<69> analitica su una maschera di riga
void ca_put_row_fields(TSheet_field& sheet, const int selected_row,
                       TString& cdc,          TString& cms,          TString& fase,          TString& conto,
                       const short first_cdc, const short first_cms, const short first_fase, const short first_conto,
                       const char* cdc_fld,   const char* cms_fld,   const char* fase_fld,   const char* conto_fld);

///////////////////////////////////////////////////////////
// TSimple_anal_msk
///////////////////////////////////////////////////////////

class TSimple_anal_msk : public TAutomask
{
protected:
  bool test_key_field(short id);
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
  virtual void read(const char* msk);
    
  void append_select_clause(ostream& out, int level) const;
  void create_key_browse(TEdit_field& kfld, int level);
  void create_des_browse(TEdit_field& kfld, int level);
  virtual int create_key_fields();

  virtual short create_tree_field();
  int compute_offset() const;

protected:
  TSimple_anal_msk() { }

public:
  void update_tree_field();

  const TFieldref& fieldref(int n, int key = 1) const;
  int fieldrefs(int key = 1) const;
  
  virtual int get_logicnum() const pure;
  virtual short get_field_id(int n, int key = 1) const;
  
  virtual const TToken_string& get_key_value(const TRectype& rec, int k = 1) const;
  virtual const TToken_string& get_key_value(int k = 1) const;
  virtual const char * get_curr_key() const ;
};

///////////////////////////////////////////////////////////
// TAnal_app
///////////////////////////////////////////////////////////

class TAnal_app : public TRelation_application
{
  TRelation* _rel;
  TSimple_anal_msk* _msk;

protected:
  virtual TMask* get_mask(int) { return _msk; }
  virtual TRelation* get_relation() const { return _rel; }
  virtual bool user_create();
  virtual bool user_destroy();
  virtual int write(const TMask& m);
  virtual int rewrite(const TMask& m);
  virtual bool remove();

  void init_key_fields(TSimple_anal_msk & m) const;
  virtual void init_query_insert_mode(TMask& mask) { return init_query_mode(mask);}
  virtual void init_query_mode(TMask& mask);
  virtual void init_modify_mode(TMask& mask);
  virtual void init_insert_mode(TMask& mask);

protected:
  virtual TSimple_anal_msk* create_mask() const pure;
  virtual TRelation* create_relation() const;
  virtual const char* extra_modules() const { return "ci|cm"; }
};


///////////////////////////////////////////////////////////
// TAnal_mov
///////////////////////////////////////////////////////////

class TAnal_mov : public TMultiple_rectype
{
  TAssoc_array _saldi;
  TAssoc_array _saldind;

protected:
  void saldo_set_reset(const TRectype& row, bool reset);
  void load_saldi(bool reset);
  void kill_saldi() { _saldi.destroy(); }
  void update_saldi(bool kill);
  bool save_saldi(const int anno = 0);
  void update_datacomp() const;

public:
  virtual int readat(TBaseisamfile& f, TRecnotype nrec, word lockop);
  virtual int read(TBaseisamfile& f, word op, word lockop);
  virtual int write(TBaseisamfile& f) const;
  virtual int rewrite(TBaseisamfile& f) const;
  virtual int remove(TBaseisamfile& f) const;
	virtual void zero(char c = '\0');

public:
  int read(long numreg, word lockop = _nolock); // Funzione read di comodo
  int read_cgnum(long numreg, word lockop = _nolock); // Funzione read per leggere con il numero di registrazione contabile
  void update_totdoc();
	const char * row_anal_code(int logicnum, int i) const;
	const char * row_code(int i) const;
  int remove_rmov_comp() const;
	int save_rmov_comp() const;

	TAnal_mov(long numreg = 0);
	TAnal_mov(const TRectype& rec);	//accetta LF_MOVANA,LF_RMOVANA,LF_MOV
};

///////////////////////////////////////////////////////////
//  TAnal_ripartizioni_batch (ahi!)
///////////////////////////////////////////////////////////
class TAnal_bill;

class TAnal_ripartizioni_batch : public TRecord_array
{
  TRectype _rip;
  bool _multirip;
  
private:
  int read_rip_3(TLocalisamfile& rip, const char tiporip, const int gr, const int co, const long sot, 
                 const int annoes, const int indbil, const int classe_mov) const;
  int read_rip_4(TLocalisamfile& rip, const char* codcosto, const char* commessa, const char* fase,
                 const int annoes, const int indbil, const int classe_mov) const;
public:
  const TRectype& head() const { return _rip; }
  int indbil() const;
  char tiporip() const;
  int modorip() const;
  int read(const char tiporip, const char* codice);
  int read(const char* codcosto, const char* commessa, const char* fase, const int annoes, const int indbil, const int classe_mov);
  int read(const char tiporip, const int gr, const int co, const long sot, const int annoes, const int indbil, const int classe_mov);
  bool has_multirip() const { return _multirip; }
  int find_sister_rips(TString_array& lista_rips) const;

  TAnal_ripartizioni_batch();
};

///////////////////////////////////////////////////////////
//  TCache_ripartizioni
///////////////////////////////////////////////////////////

class TCache_ripartizioni : public TCache
{
  int _codes;
	TDate _dal, _al;

protected:
  virtual TObject* key2obj(const char* key);

public:
	void set_esercizio(const int codes);
  //batch
  const TAnal_ripartizioni_batch& righe(const char* costo, const char* commessa, const char* fase,
                                        const int annoes, const int indbil, const char tipomov);
  //pareggio
  const TAnal_ripartizioni_batch& righe(const TBill& bill, const int annoes, const char tipomov);
  //batch
  const TAnal_ripartizioni_batch& righe(const TAnal_bill& bill, const int annoes, const int indbil, const char tipomov);
  //interattive per conversione e contabilizzazione (usate da cacnv e da contabilizzazione analitica docs)
  const TAnal_ripartizioni_batch& righe_interattive(const TBill& bill, const int annoes, const char tipomov = ' ');
  
  TCache_ripartizioni();
};

// metodi di implosione movimenti ripartiti!! Serve nel ribaltamento movimenti, stampa rendiconto...
bool ca_implode_rows(const TRecord_array& input_rows, TRecord_array& compact_rows);
bool ca_ori_present(const TRectype& rec);
bool ca_ori_present(const TRecordset & rec);
bool ca_can_merge_rows(const TRectype& compact_rec, const TRectype& rec);
bool ca_can_pack_rows(const TRectype& compact_rec, const TRectype& rec);
void ca_taglia_campo(TRectype& src, const char* campo_src, TRectype& dst, const char* campo_dst);
void ca_copia_campo(const TRectype& src, const char* campo_src, TRectype& dst, const char* campo_dst);


//metodi per ricavare informazioni sulla configurazione (usati per ora nel rendiconto)
//metodo per ricavare la stringa dei codici dai campi dello sheet (decisivissima !!!)
bool ca_extract_sheet_field(const TSheet_field& sheet, const int row, const int logicnum, TString& codice);

//metodo per ricavare la durata di una commessa
long ca_durata_commessa(const TRectype& rec_commesse, TDate& dataini, TDate& datafine);
bool ca_commessa_attiva(const TRectype& rec_commesse, const TDate & from, const TDate & to);

#endif