campo-sirio/ci/ci1200.cpp

#include <applicat.h>
#include <automask.h>
#include <reprint.h>

#include "ci1200.h"

#include "../ca/calib01.h"
#include "../ca/rmovana.h"

#include "../include/doc.h"
#include "../include/rdoc.h"


///////////////////////////////////////////////////////////
// TMask_rdoc
///////////////////////////////////////////////////////////

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

  int create_sheet_fields(int lf, int& y, short& dlg, bool required);
  void create_sheet();

public:
  TMask_rdoc();
};

int TMask_rdoc::create_sheet_fields(int lf, int& y, short& dlg, bool required)
{
	TSheet_field& sf = sfield(F_COMMESSE);
  TMask& sm = sf.sheet_mask();

  const int h = ca_create_fields(sm, 0, lf, 1, y, dlg, dlg+50);

  for (int i = 0; i < h; i++)
  {
    TEdit_field& fld = sm.efield(dlg+i);
    int logic = lf;
    if (logic == LF_FASI)
    {
      const TMultilevel_code_info& fasinfo = ca_multilevel_code_info(LF_FASI);
      if (fasinfo.parent() != 0)
      {
        const TMultilevel_code_info& parinfo = ca_multilevel_code_info(fasinfo.parent());
        if (i < parinfo.levels())
          logic = fasinfo.parent();
      }
    }

    fld.check_type(required ? CHECK_REQUIRED : CHECK_NORMAL);

    TEdit_field& dfld = sm.efield(dlg+50+i);
    dfld.set_field(EMPTY_STRING); // Toglie campi che fan saltare gli output!
  }

  y += h+1;
  dlg += h;

  return h;
}

void TMask_rdoc::create_sheet()
{
	TSheet_field& sf = sfield(F_COMMESSE);
  TMask& sm = sf.sheet_mask();
  sm.hide(-1);

  const TMultilevel_code_info& fasinfo = ca_multilevel_code_info(LF_FASI);

  TConfig_anal ini;
  const bool fsc_req = ini.get_bool("FscRequired");

  int y = 1;
  short dlg = S_CDC1 + 100; // id del primo campo da generare

  for (int i = 0; i < 2; i++)
  {
    const TString& level = ini.get("Level", NULL, i+1);  // Legge il livello 1 o 2
    if (level == "CDC")                                  // Crea centro di costo 
    {
      if (fasinfo.parent() == LF_CDC)
        create_sheet_fields(LF_FASI, y, dlg, fsc_req);
      else
      {
        const bool cdc_req = ini.get_bool("CdcRequired");
        create_sheet_fields(LF_CDC, y, dlg, cdc_req);
      }
    } else
    if (level == "CMS")                                   // Crea commessa
    {
      if (fasinfo.parent() == LF_COMMESSE)
        create_sheet_fields(LF_FASI, y, dlg, fsc_req);
      else
      {
        const bool cms_req = ini.get_bool("CmsRequired");
        create_sheet_fields(LF_COMMESSE, y, dlg, cms_req);
      }
    }
  }

  if (fasinfo.levels() > 0 && fasinfo.parent() <= 0)
    create_sheet_fields(LF_FASI, y, dlg, fsc_req);

	for (short id = S_CDC12; id >= S_CDC1; id--)
  {
    const int pos = sm.id2pos(id+100);
    if (pos >= 0)
    {
      TMask_field& f = sm.fld(pos);
      const int size = f.size();
      const TString& prompt = f.prompt();
      sf.set_column_header(id, prompt);
      sf.set_column_justify(id, f.is_kind_of(CLASS_REAL_FIELD));
      sf.set_column_width(id, (max(3+size, prompt.len()+1)) * CHARX);
    }
    else
      sf.delete_column(id);
    sm.hide(id); // Nasconde il campo "segnaposto"
	}
}

bool TMask_rdoc::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  return true;
}

TMask_rdoc::TMask_rdoc() :  TAutomask("ci1200") 
{ 
  create_sheet();
}

///////////////////////////////////////////////////////////
// TRecordset_rdoc
///////////////////////////////////////////////////////////

class TRecordset_rdoc : public TISAM_recordset
{
  TDate _da_data, _a_data;
  long _da_clifo, _a_clifo;
  TString _da_codart, _a_codart;
  TString _codcosto, _codcms, _codfas;
  TString_array _tipidoc;

protected:
  static bool rdoc_filter(const TRelation* rel);
  bool valid_record(const TRelation& rel) const;

  virtual void set_custom_filter(TCursor& cur) const;

public:
  void set_filter(const TMask_rdoc& msk, int cms_row);
  TRecordset_rdoc(const TString& sql) : TISAM_recordset(sql) { }
};

static const TRecordset_rdoc* myself = NULL;

bool TRecordset_rdoc::valid_record(const TRelation& rel) const
{
  const TRectype& doc = rel.curr(LF_DOC);
  
  const TDate data = doc.get(DOC_DATADOC);
  if (data < _da_data || (_a_data.ok() && data > _a_data))
    return false;

  const long clifo = doc.get_long(DOC_CODCF);
  if (clifo < _da_clifo || (_a_clifo > 0 && clifo > _a_clifo))
    return false;
    
  const TRectype& rdoc = rel.curr(LF_RIGHEDOC);
  const TString& codart = rdoc.get(RDOC_CODART);
  if (codart < _da_codart || (_a_codart.not_empty() && codart.compare(_a_codart, _a_codart.len()) > 0))
    return false;

  if (_tipidoc.items() > 0)
  {
    const TString4 codnum = doc.get(DOC_CODNUM);
    const TString4 tipodoc = doc.get(DOC_TIPODOC);
    bool found = false;
    FOR_EACH_ARRAY_ROW(_tipidoc, i, row)
    {
      const TString4 cn = row->get(0);
      const TString4 td = row->get();
      if ((cn.blank() || cn == codnum) && (td.blank() || td == tipodoc))
      {
        found = true;
        break;
      }
    }
    if (!found)
      return false;
  }

  if (_codcosto.not_empty())
  {
    const TString& cos = rdoc.get(RDOC_CODCOSTO);
    if (cos != _codcosto)
      return false;
  }
  if (_codcms.not_empty())
  {
    const TString& cms = rdoc.get(RDOC_CODCMS);
    if (cms != _codcms)
      return false;
  }
  if (_codfas.not_empty())
  {
    const TString& fas = rdoc.get(RDOC_FASCMS);
    if (fas != _codfas)
      return false;
  }

  return true;
}

bool TRecordset_rdoc::rdoc_filter(const TRelation* rel)
{
  return myself->valid_record(*rel);
}

void TRecordset_rdoc::set_custom_filter(TCursor& cur) const
{
  myself = this;
  cur.set_filterfunction(rdoc_filter, true);
}

void TRecordset_rdoc::set_filter(const TMask_rdoc& msk, int cms_row)
{
  _codcosto = _codcms = _codfas = "";
  if (cms_row >= 0)
  {
    TSheet_field& sf = msk.sfield(F_COMMESSE);
    TMask& sm = sf.sheet_mask();
    sf.update_mask(cms_row);
    TRelation rel(LF_RMOVANA);
    sm.autosave(rel);
    _codcosto = rel.curr().get(RMOVANA_CODCCOSTO);
    _codcms = rel.curr().get(RMOVANA_CODCMS);
    _codfas = rel.curr().get(RMOVANA_CODFASE);
  } 
  set_var("#S_CMS", TVariant(_codcms), true);

  _tipidoc.destroy();
  TSheet_field& sf = msk.sfield(F_TIPI);
  FOR_EACH_SHEET_ROW(sf, i, row)
  {
    TToken_string str;
    str.add(row->get(0), 0);
    str.add(row->get(2), 1);
    _tipidoc.add(str);
  }

  _da_data = msk.get_date(F_DA_DATA);
  _a_data = msk.get_date(F_A_DATA);
  set_var("#S_DATEFROM", _da_data, true);
  set_var("#S_DATETO", _a_data, true);

  _da_clifo = msk.get_long(F_DA_CLIFO);
  _a_clifo = msk.get_long(F_A_CLIFO);

  _da_codart = msk.get(F_DA_CODART);
  _a_codart = msk.get(F_A_CODART);
}

///////////////////////////////////////////////////////////
// TReport_rdoc
///////////////////////////////////////////////////////////

class TReport_rdoc : public TReport
{
protected:
  virtual bool set_recordset(const TString& sql);

public:
  void set_filter(const TMask_rdoc& msk, int cms_row);
  TReport_rdoc() { }
};

bool TReport_rdoc::set_recordset(const TString& sql)
{
  TRecordset_rdoc* rs = new TRecordset_rdoc(sql);
  return TReport::set_recordset(rs);
}

void TReport_rdoc::set_filter(const TMask_rdoc& msk, int cms_row)
{
  TRecordset_rdoc* rs = (TRecordset_rdoc*)recordset();
  rs->set_filter(msk, cms_row);
}



///////////////////////////////////////////////////////////
// TStampa_rdoc
///////////////////////////////////////////////////////////

class TStampa_rdoc : public TSkeleton_application
{
protected:
  virtual void main_loop();
};

void TStampa_rdoc::main_loop()
{
  TMask_rdoc m;
  while (m.run() != K_QUIT)
  {
    TReport_book book;
    TReport_rdoc rep;
    const TString& repname = m.get(F_REPORT);
    rep.load(repname);

    TSheet_field& sf = m.sfield(F_COMMESSE);
    if (sf.items() == 0)
      sf.row(-1);
    for (int i = 0; i < sf.items(); i++)
    {
      rep.set_filter(m, i);
      book.add(rep);
    }

    book.print_or_preview();
  }
}

int ci1200(int argc, char* argv[])
{
  TStampa_rdoc sd;
  sd.run(argc, argv, "Stampa documenti");
  return 0;
}