campo-sirio/lv/lv3200.cpp

#include <applicat.h>
#include <automask.h>
#include <defmask.h>
#include <execp.h>
#include <reputils.h>
#include <reprint.h>
#include <utility.h>

#include "lvlib.h"
#include "../mg/clifogiac.h"
#include "../ve/velib.h"

#include "clifo.h"
#include "lvcondv.h"
#include "lvrcondv.h"
#include "lvrconsplan.h"

#include  "lv3200a.h"

                                 ////////////////////////////////
                                 ////    TPOSIZIONE_ARRAY    ////
                                 ////////////////////////////////

//classe TPosizione_array
class TPosizione_array: public TObject
{
  TAssoc_array  _pos;
public:
  void aggiungi(const char* key, int pos);
  int posizione(const char* key);  

  TPosizione_array(){};
};

//AGGIUNGI: metodo che aggiunge una coppia di valori all'array
void TPosizione_array::aggiungi(const char* key, const int pos)
{
  real tmp = pos;  
  _pos.add(key, tmp);
}

//POSIZIONE: metodo che data una chiave restituisce la posizione (-1 se non esiste)
int TPosizione_array::posizione(const char* key)
{
  long posizione = -1;
  if (_pos.is_key(key))
  {
    real& tmp = *(real*)_pos.objptr(key);
    posizione = tmp.integer();    
  }
  return posizione;
}

                                 /////////////////////////////
                                 ////    TEVASIONE_MSK    ////
                                 /////////////////////////////

//classe TEvasione_msk
class TEvasione_msk: public TAutomask
{
  TDocumento        _buonori;
  TPosizione_array  _posizioni;
  int               _ndoc;
  TString4          _tpev;

  TAssoc_array      _pacchi;

protected:
  void setta_campi_data();
  void setta_campi_cliente();

  void carica_righe();
  void riordina_righe();
  void genera_documento();
  void evadi_tutto();
  void spezza_riga();
  void salva();
  void annulla_operazioni();
  bool controlla();

  void sistema_quantita();
  void sistema_pacchi();

  void evadi_da_barcode();

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

public:
  TEvasione_msk();
};


//SORT_BY_QTA_EVASA: <20> la rows_comapre_function, cio<69> la funzione che viene utilizzata
//dal metodo sort degli sheet per riordinare le righe secondo le quantit<69> evase
static int sort_by_qta_evasa(TSheet_field& sheet, int r1, int r2)
{
  TToken_string& row1 = sheet.row(r1);
  TToken_string& row2 = sheet.row(r2);

  const int qta1 = row1.get_int(6);
  const int qta2 = row2.get_int(6);

  int dif = qta1 - qta2;

  if (dif == 0)
  {
    const TString& codart1 = row1.get(1);
    const TString& codart2 = row2.get(1);

    dif = codart1.compare(codart2);
  }  
  return dif;
}

//SORT_BY_CODART: <20> la rows_comapre_function, cio<69> la funzione che viene utilizzata
//dal metodo sort degli sheet per riordinare le righe secondo i codart e le qta evase
static int sort_by_codart(TSheet_field& sheet, int r1, int r2)
{
  TToken_string& row1 = sheet.row(r1);
  TToken_string& row2 = sheet.row(r2);

  const TString& codart1 = row1.get(1);
  const TString& codart2 = row2.get(1);

  int dif = codart1.compare(codart2);

  if (dif == 0)
  {
    const int qta1 = row1.get_int(6);
    const int qta2 = row2.get_int(6);

    dif = qta2 - qta1;
  }
  
  return dif;
}

//SETTA_CAMPI_DATA: metodo che compila tutti i campi legati alla data
void TEvasione_msk::setta_campi_data()
{
  TDate data = get_date(F_DATADOC);

  if (data.ok())
  {
    TDate primo = data;
    primo.set_day(1);
    
    TEsercizi_contabili es;  
    int annoes = es.date2esc(data);
    set(F_ANNO, annoes);

    //decodifica del giorno della settimana
    set(F_GIORNO, itow(data.wday()));  
    //settimana del mese = settimana(oggi) - settimana(primo del mese) + 1
    long tmp = data.week() - primo.week() + 1;
    TString4 settimana;
    settimana << tmp;
    set(F_SETTIMANA, settimana);
  }
  else
  {
    TString8 str = data.string();
    if (str.empty())
    {
      reset(F_GIORNO);
      reset(F_SETTIMANA);
    }
    else
      warning_box(TR("Data non valida!"));
  }
}

//SETTA_CAMPI_CLIENTE: metodo che compila tutti i campi legati al cliente
void TEvasione_msk::setta_campi_cliente()
{
  const long codcf = get_int(F_CODCF);
  const TDate data = get_date(F_DATADOC);

  if (codcf > 0)
  {
    TLaundry_contract cont(codcf, 0, data);

    //se trovo un contratto, allora scrivo il codice contratto e cerco itinerario e data di prevista consegna
    //se no avviso che non c'<27> neanche un contratto valido e svuoto i campi interassati
    if(!cont.empty())
    {
      set(F_CODCONT, cont.get_int(LVCONDV_CODCONT));
      
      TDate adata = data;
      adata.addmonth(1);

      TString query = "USE LVRCONSPLAN KEY 3\n";
      query << "FROM CODCF=" << get(F_CODCF) << " CODCONT=" << get(F_CODCONT) << " DTCONS=" << data << "\n";
      query << "TO CODCF="   << get(F_CODCF) << " CODCONT=" << get(F_CODCONT) << " DTCONS=" << adata   << "\n";
      TISAM_recordset consegne(query);

      if (consegne.items() >= 2)
      {
        consegne.move_to(1);
        set(F_DATAPRCO, consegne.get(LVRCONSPLAN_DTCONS).as_date());
        set(F_CODITI, consegne.get(LVRCONSPLAN_CODITI).as_int());
      }
      else
      {
        reset(F_DATAPRCO);
        reset(F_CODITI);
      }

      if (get(F_RAGSOC).empty())
      {
        TToken_string key;
        key.add('C');
        key.add(codcf);
        const TRectype& clifo = cache().get(LF_CLIFO, key);
        set(F_RAGSOC, clifo.get(CLI_RAGSOC));
        set(F_RICALT, clifo.get(CLI_RICALT));
      }
    }
    else
    {
      TString msg;
      msg << "ATTENZIONE: nessun contratto in essere per il cliente " << codcf << " alla data " << data;
      warning_box(msg);

      reset(F_CODCONT);
      reset(F_DATAPRCO);
      reset(F_CODITI);
    }
  }
  else
  {
    reset(F_RICALT);
    reset(F_RAGSOC);
    reset(F_CODCONT);
    reset(F_DATAPRCO);
    reset(F_CODITI);
  }
}

//CARICA_RIGHE: metodo che carica sullo sheet le righe di un documento selezionato
void TEvasione_msk::carica_righe()
{  
  TDoc_key kdoc(get_int(F_ANNO), get(F_CODNUM), get_long(F_NDOC));
  TBuono_prelievo doc(kdoc);

  const TString4 stato = doc.get(DOC_STATO);

  set(F_STATO, stato);
  disable(F_STATO);

  set(F_DATADOC, doc.get_date(DOC_DATADOC));  setta_campi_data();
  set(F_CODCF, doc.get_long(DOC_CODCF));      setta_campi_cliente(); field(F_CODCF).set_dirty();

  _buonori = doc;
  _pacchi.destroy();

  if(doc.rows() > 0)
  {
    enable(DLG_SELECT);
    enable(DLG_PREVIEW);
    
    if(stato == "1")
      enable(DLG_ELABORA);

    enable(DLG_SAVEREC);
    enable(DLG_CANCEL);
    show(F_RIGHE);
  }

  TSheet_field& sheet = sfield(F_RIGHE);
  sheet.row(-1);
  //preparo l'array delle posizioni dei campi nello sheet  
  _posizioni.aggiungi("evaso",      sheet.cid2index(S_EVASO));
  _posizioni.aggiungi("codart",     sheet.cid2index(S_CODART));
  _posizioni.aggiungi("desrart",    sheet.cid2index(S_ARTDESCR));
  _posizioni.aggiungi("causale",    sheet.cid2index(S_CAUSALE));
  _posizioni.aggiungi("ritirato",   sheet.cid2index(S_RITIRATO));
  _posizioni.aggiungi("dacons",     sheet.cid2index(S_DACONS));
  _posizioni.aggiungi("consegnato", sheet.cid2index(S_CONSEGNATO));
  _posizioni.aggiungi("pacchi",     sheet.cid2index(S_PACCHI));
  _posizioni.aggiungi("congpre",    sheet.cid2index(S_CONGPRE));
  _posizioni.aggiungi("congatt",    sheet.cid2index(S_CONGATT));
  _posizioni.aggiungi("rifbcon",    sheet.cid2index(S_RIFBCON));
  _posizioni.aggiungi("rifbrit",    sheet.cid2index(S_RIFBRIT));
  sheet.destroy();

  for(int i = 1; i <= doc.rows(); i++)
  {
    TRiga_documento& row = doc[i];
    TBuono_prelievo_row rdoc(row);

    if (rdoc.qta_dacons() > 0)
    {
      TToken_string& riga =  sheet.row(-1);
      riga.add(rdoc.evaso() ? "X" : "", _posizioni.posizione("evaso"));
      riga.add(rdoc.codart(),           _posizioni.posizione("codart"));
      riga.add(rdoc.desart(),           _posizioni.posizione("artdescr"));
      riga.add(rdoc.causale(),          _posizioni.posizione("causale"));
      riga.add(rdoc.qta_ritirata(),     _posizioni.posizione("ritirato"));
      riga.add(rdoc.qta_dacons(),       _posizioni.posizione("dacons"));
      riga.add(rdoc.qta_consegnata(),   _posizioni.posizione("consegnato"));

      const TRectype& anamag = cache().get(LF_ANAMAG, rdoc.codart());
      //recupero i dati di interesse dall'anagrafica di magazzino
      const long ppconf = anamag.get_long(ANAMAG_PPCONF);
      if (ppconf > 0)
        riga.add(rdoc.num_pacchi(), _posizioni.posizione("pacchi"));
      else
      {
        riga.add(0, _posizioni.posizione("pacchi"));
        sheet.disable_cell(i, _posizioni.posizione("pacchi"));
      }

      riga.add(rdoc.cong_pre(), _posizioni.posizione("congpre"));
      riga.add(rdoc.cong_att(), _posizioni.posizione("congatt"));
      riga.add(rdoc.rifbcon(),  _posizioni.posizione("rifbcon"));
      riga.add(rdoc.rifbrit(),  _posizioni.posizione("rifbrit"));
    }
    else
      rdoc.set_evaso(true);
  }

  doc.rewrite();
  sheet.sort(sort_by_codart);
  sheet.force_update();
}

//RIORDINA_RIGHE: metodo che riordina le righe dello sheet in base alle quota di evasione
void TEvasione_msk::riordina_righe()
{
  TSheet_field& sheet = sfield(F_RIGHE);
  sheet.sort(sort_by_qta_evasa);
  sheet.force_update();
}

//GENERA_DOCUMENTO: metodo che genera il buono di consegna partendo dal buono di ritiro
void TEvasione_msk::genera_documento()
{
  //per prima cosa salva il buono di prelievo
  salva();

  TDoc_key kdoc(get_int(F_ANNO), get(F_CODNUM), get_long(F_NDOC));
  TBuono_prelievo bpre(kdoc);
  const long codcf = bpre.codcf();
  const int codcont = bpre.codcont();

  TLaundry_contract cont(codcf, codcont);
  //leggo se devo scrivere il prezzo sulla bolla
  //const bool prinbo = cont.get_bool(LVCONDV_STPRZBOL);
  const bool prinbo = true; //sempre a true; verr<72> gestita a video in futuro (27/10/2009)

  //dati documento da generare
  TString4 codnum  = ini_get_string(CONFIG_DITTA, "lv", "NUM_GEN");
  TString4 tipodoc = ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_GEN");
  char stato = cache().get("%TIP", tipodoc, "S2").left(1)[0];

  const TDate databpre = bpre.datadoc();
  const TDate databolla = get_date(F_DATABOLLA);
  const TDate datagen(TODAY);
  TDate dadata = databpre;
  TDate adata = datagen;
  adata.addmonth();

  if(_ndoc == 0)
  {
    TString query2;
    query2 << "USE DOC\n"
           << "FROM PROVV=\"D\" ANNO=" << datagen.year() << " CODNUM=\"" << codnum << "\"\n"
           << "TO PROVV=\"D\" ANNO="   << datagen.year() << " CODNUM=\"" << codnum << "\"";
    TISAM_recordset bolle(query2);
    bolle.move_last();
    _ndoc = bolle.get(DOC_NDOC).as_int();
  }

  TString query1 = "USE LVRCONSPLAN KEY 3\n";
  query1 << "FROM CODCF=" << codcf << " CODCONT=" << codcont << " DTCONS=#DADATA\n";
  query1 << "TO CODCF="   << codcf << " CODCONT=" << codcont << " DTCONS=#ADATA\n";
  TISAM_recordset consegne(query1);
  consegne.set_var("#DADATA", ++dadata);
  consegne.set_var("#ADATA", adata);
  consegne.move_first();
  const TDate dataprco = consegne.get(LVRCONSPLAN_DTCONS).as_date();
  const int coditi = consegne.get(LVRCONSPLAN_CODITI).as_int();
  
  //preparo la testata del documento  
  TDocumento doc('D', kdoc.anno(), codnum, ++_ndoc);
  doc.put(DOC_TIPODOC, tipodoc);
  doc.put(DOC_STATO, stato);
  doc.put(DOC_DATADOC, databolla);
  doc.put(DOC_TIPOCF, 'C');
  doc.put(DOC_CODCF, codcf);
  doc.put(DOC_CODCONT, codcont);
  doc.put("DATAGEN", datagen);   //data generazione del documento 
  doc.put("DATAPRCO", dataprco); //data prevista consegna    
  doc.put("CODITI", coditi);     //codice itinerario

  for (int i = 1; i <= bpre.rows(); i++)
  {
    TRiga_documento& row = bpre[i];
    TBuono_prelievo_row rbpre(row);    

    //nella bolla ci vanno solo le righe evase e non associate
    if (!rbpre.evaso())
      continue;

    TDoc_key kbuono = rbpre.rifbcon();
    if (kbuono.full())
      continue;

    const TString80 codart = rbpre.codart();
    TString descr = rbpre.desart();

    const TRectype& rcont = cont.row(codart);    
    
    //recupero i valori delle dotazione temporanea dal magazzino del cliente
    TLocalisamfile magcli(LF_CLIFOGIAC);
    magcli.put(CLIFOGIAC_ANNOES,  datagen.year());
    magcli.put(CLIFOGIAC_TIPOCF,  'C');
    magcli.put(CLIFOGIAC_CODCF,   codcf);
    magcli.put(CLIFOGIAC_INDSPED, 0); //in realt<6C> <20> da leggere dal contratto
    magcli.put(CLIFOGIAC_CODART,  codart);
    magcli.put(CLIFOGIAC_NRIGA,   1);
    //leggo il record corrispondente
    magcli.read();
    long dottmp = magcli.get_long(CLIFOGIAC_DOTTM);
    long dotod  = magcli.get_long(CLIFOGIAC_DOTOD);

    TRiga_documento& rdoc = doc.new_row("21");
    rdoc.put(RDOC_CODART, codart);
    rdoc.put(RDOC_CODARTMAG,codart);
    rdoc.put(RDOC_CHECKED,'X');
    rdoc.put(RDOC_GENERATA, true);

    if(descr.len() <= 50)
      rdoc.put(RDOC_DESCR, descr);
    else
    {
      rdoc.put(RDOC_DESCR, descr.left(50));
      rdoc.put(RDOC_DESCEST, descr.sub(50));
      rdoc.put(RDOC_DESCLUNGA, true);
    }

    rdoc.put(RDOC_QTA, rbpre.qta_consegnata());   //consegnato
    rdoc.put(RDOC_QTAGG1, rbpre.qta_ritirata());  //ritirato

    rdoc.put("DOTOD", dotod);
    rdoc.add("DOTOD", rbpre.qta_consegnata());

    bool dtmp = false;
    if (datagen >= rcont.get_date(LVRCONDV_INDTTMP) && datagen <= rcont.get_date(LVRCONDV_FIDTTMP))
      dtmp = true;

    if(dtmp)
    {
      rdoc.put("DOTMP", dottmp);
      rdoc.add("DOTMP", rbpre.qta_consegnata());
    }
    
    rdoc.put(RDOC_CODAGG1, rbpre.causale());

    const TRectype& anamag = cache().get(LF_ANAMAG, codart);
    //gestione prezzo
    if (prinbo) 
    {
      real prezzo;
      if (cont.get_int(LVCONDV_TIPOLIS) == 0)
        prezzo = rcont.get_real(LVRCONDV_PREZZO);
      else
        prezzo = anamag.get_real(ANAMAG_COSTSTD);

      rdoc.put(RDOC_PREZZO, prezzo);
      rdoc.put(RDOC_SCONTO, rcont.get(LVRCONDV_SCONTPERC)); //sconto
    }
  
    //scrivo il magazzino
    TString8 magazzino;
    TString8 magazzinoc;
    
    magazzino  << ini_get_string(CONFIG_DITTA, "lv", "CODMAG") << ini_get_string(CONFIG_DITTA, "lv", "CODMAGN");
    magazzinoc << ini_get_string(CONFIG_DITTA, "lv", "CODMAG") << ini_get_string(CONFIG_DITTA, "lv", "CODMAGC");

    rdoc.put(RDOC_CODMAG,  magazzino);
    rdoc.put(RDOC_CODMAGC, magazzinoc);

    //salvo i riferimenti
    TDoc_key rifbcon(datagen.year(), codnum, _ndoc);
    rbpre.set_rifbcon(rifbcon);
  }

  //salva la bolla solo se ha almeno una riga
  int err = 1;
  if (doc.rows() > 0)
  {
    err = doc.write();
    const TString4 stato = cache().get("%TIP", ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_PRE", NULL, 0), "S2").mid(1,1);
    bpre.put(DOC_STATO, stato);
    bpre.write();
    set(F_STATO, stato);
  }

  if (err == NOERR)
  {
    if (yesno_box(TR("Il documento <20> stato generato; si desiderla stamparlo?")))
    {
      //stampa automatica
      TString80 str;
      str << "ve1 -2 " << codnum << ' ' << datagen.year() << " D " << _ndoc << " S"; 
      TExternal_app stampa(str);
      stampa.run();
    }
  }
  else
    warning_box(TR("Non <20> stato possibile generare nessun documento"));  

  reset(F_NDOC);
  send_key(K_ENTER, F_NDOC);
}

//EVADI_TUTTO: metodo che forza a "evaso" tutte le righe e lancia la generazione del buono di consegna associato
void TEvasione_msk::evadi_tutto()
{
  const int posevaso = _posizioni.posizione("evaso");
  TSheet_field& sheet = sfield(F_RIGHE);
  
  FOR_EACH_SHEET_ROW(sheet, r, riga)
  {
    riga->add("X", posevaso);
  }
  genera_documento();
}

//SPEZZA_RIGA: metodo che spezza una riga del buono in due righe, una per la quota evasa e una per la quota da evadere
void TEvasione_msk::spezza_riga()
{
  TSheet_field& sheet = sfield(F_RIGHE);

  FOR_EACH_SHEET_ROW_BACK(sheet, r, riga1)
  {
    char flgev = riga1->get_char(_posizioni.posizione("evaso"));
    if (flgev != 'X')
    {
      TToken_string& riga2 = sheet.row(-1);
      riga2 = *riga1;

      const int dacons2 = riga2.get_int(_posizioni.posizione("ritirato")) - riga2.get_int(_posizioni.posizione("consegnato"));
      riga2.add(dacons2, _posizioni.posizione("dacons"));
      riga2.add(0L, _posizioni.posizione("consegnato"));
      riga2.add(0L, _posizioni.posizione("pacchi"));

      const int dacons1 = riga1->get_int(_posizioni.posizione("ritirato")) - riga1->get_int(_posizioni.posizione("consegnato"));
      riga1->add(dacons1, _posizioni.posizione("dacons"));
      riga1->add("X", _posizioni.posizione("evaso"));
    }
  }
  sheet.sort(sort_by_codart);
  sheet.force_update();
}

//SALVA: metodo che salva il buono di prelievo cos<6F> com'<27>, senza compiere altre operazioni
void TEvasione_msk::salva()
{
  TDoc_key kdoc(get_int(F_ANNO), get(F_CODNUM), get_long(F_NDOC));
  TBuono_prelievo doc(kdoc);

  //nel caso avessi spezzato le righe, risrcivendole da capo mi vengono ordinate per codice
  //ATTENZIONE: devo eliminare le sole righe che sono sullo sheet, cio<69> quelle che hanno 
  //quantit<69> da consegnare maggiore di zero
  for (int i = doc.rows(); i > 0; i--)
  {
    TRiga_documento& row = doc[i];
    TBuono_prelievo_row rdoc(row);

    if (rdoc.qta_dacons() > 0)
      doc.destroy_row(i, true);
  }

  TSheet_field& sheet = sfield(F_RIGHE);
  //riordino lo sheet
  sheet.sort(sort_by_codart);
  sheet.force_update();
   
  //per ogni riga dello sheet genero una riga documento
  FOR_EACH_SHEET_ROW(sheet, r, riga)  
  {
    TRiga_documento& row = doc.new_row("21");
    TBuono_prelievo_row rdoc(row);

    const char flgev = riga->get(_posizioni.posizione("evaso"))[0];
    bool flag;
    if (flgev == 'X')
      flag = true;
    else
      flag = false;

    rdoc.set_evaso(flag);
    rdoc.set_codart(riga->get(_posizioni.posizione("codart")));
    rdoc.set_desart(riga->get(_posizioni.posizione("artdescr")));
    rdoc.set_causale(riga->get(_posizioni.posizione("causale")));
    rdoc.set_qta_ritirata(riga->get_int(_posizioni.posizione("ritirato")));
    rdoc.set_qta_dacons(riga->get_int(_posizioni.posizione("dacons")));
    rdoc.set_qta_consegnata(riga->get_int(_posizioni.posizione("consegnato")));
    rdoc.set_num_pacchi(riga->get_int(_posizioni.posizione("pacchi")));
    rdoc.set_cong_att(riga->get_int(_posizioni.posizione("congpre")));
    rdoc.set_cong_pre(riga->get_int(_posizioni.posizione("congatt")));
    rdoc.set_rifbcon(riga->get(_posizioni.posizione("rifbcon")));
    rdoc.set_rifbrit(riga->get(_posizioni.posizione("rifbrit")));
  }
  doc.rewrite();
}

//ANNULLA_OPERAZIONI: metodo elimina tutte le quantit<69> scritte durante l'ultima evasione
//e libera i pacchi eventualmente allocati
void TEvasione_msk::annulla_operazioni()
{
  //ANNULLA PACCHI

  //elimino lo sheet senza salvarlo
  TSheet_field& sheet = sfield(F_RIGHE);
  sheet.destroy();

  for(int i = 1; i <= _buonori.rows(); i++)
  {
    TRiga_documento& row = _buonori[i];
    TBuono_prelievo_row rdoc(row);

    TToken_string& riga =  sheet.row(-1);
    riga.add(rdoc.evaso() ? "X" : "", _posizioni.posizione("evaso"));
    riga.add(rdoc.codart(),           _posizioni.posizione("codart"));
    riga.add(rdoc.desart(),           _posizioni.posizione("artdescr"));
    riga.add(rdoc.causale(),          _posizioni.posizione("causale"));
    riga.add(rdoc.qta_ritirata(),     _posizioni.posizione("ritirato"));
    riga.add(rdoc.qta_dacons(),       _posizioni.posizione("dacons"));
    riga.add(rdoc.qta_consegnata(),   _posizioni.posizione("consegnato"));

    const TRectype& anamag = cache().get(LF_ANAMAG, rdoc.codart());
    //recupero i dati di interesse dall'anagrafica di magazzino
    const long ppconf = anamag.get_long(ANAMAG_PPCONF);
    if (ppconf > 0)
      riga.add(rdoc.num_pacchi(), _posizioni.posizione("pacchi"));
    else
    {
      riga.add(0, _posizioni.posizione("pacchi"));
      sheet.disable_cell(i, _posizioni.posizione("pacchi"));
    }

    riga.add(rdoc.cong_pre(),       _posizioni.posizione("congpre"));
    riga.add(rdoc.cong_att(),       _posizioni.posizione("congatt"));
    riga.add(rdoc.rifbcon(),        _posizioni.posizione("rifbcon"));
    riga.add(rdoc.rifbrit(),        _posizioni.posizione("rifbrit"));
  }
  sheet.force_update();
}

//CONTROLLA: metodo che controlla se tutte le righe sono evase
bool TEvasione_msk::controlla()
{
  TSheet_field& sheet = sfield(F_RIGHE);

  bool evaso = true;

  FOR_EACH_SHEET_ROW(sheet, r, row)
  {
    const char flgev = row->get(_posizioni.posizione("evaso"))[0];
    if (flgev != 'X')
      evaso = false;
  }
  return evaso;
}

//SISTEMA_QUANTITA: metodo che mantiene allineate le quantita consegnate e il numero
//dei pacchi, moltiplicando il numero dei pacchi per i pezzi per pacco; se scrivo una quantit<69>
//a mano ed <20> prevista una evasione a pacchi, allora aggiorno il numero dei pacchi
void TEvasione_msk::sistema_quantita()
{
  TMask& msk = sfield(F_RIGHE).sheet_mask();
  TString80 codart = msk.get(S_CODART);

  const TRectype& anamag = cache().get(LF_ANAMAG,codart);
  //recupero i dati di interesse dall'anagrafica di magazzino
  const long ppconf = anamag.get_long(ANAMAG_PPCONF);

  if (ppconf > 0)
  {
    int pacchi = msk.get_int(S_PACCHI);
    
    int qta_consegnata = pacchi * ppconf;    
    msk.set(S_CONSEGNATO, qta_consegnata);
  }
}

void TEvasione_msk::sistema_pacchi()
{
  TMask& msk = sfield(F_RIGHE).sheet_mask();
  TString80 codart = msk.get(S_CODART);

  const TRectype& anamag = cache().get(LF_ANAMAG,codart);
  //recupero i dati di interesse dall'anagrafica di magazzino
  const long ppconf = anamag.get_long(ANAMAG_PPCONF);

  if (ppconf > 0)
  {
    int qta_consegnata = msk.get_int(S_CONSEGNATO);
    
    int pacchi = qta_consegnata / ppconf;
    
    if (qta_consegnata % ppconf > 0)
      pacchi += 1;

    msk.set(S_PACCHI, pacchi);    
  }
}

//EVADI_DA_BARCODE: metodo che somma alla riga corretta un pacco (quello pistolato) e lo assegna a un cliente,
//sottraendolo dal magazzino del pulito
void TEvasione_msk::evadi_da_barcode()
{
  TString80 codpacco = get(F_BARCODE);

  if (codpacco.full())
  {
    TSheet_field& sheet = sfield(F_RIGHE);

    TDoc_key kdoc(get_int(F_ANNO), get(F_CODNUM), get_int(F_NDOC));    
    
    TRiga_pacco rp(codpacco);    
    TString80 codart = rp.articolo();
    int qtapacco = rp.quantita().integer();

    bool trovato = false;

    //cerco la prima riga non evasa di quell'articolo
    FOR_EACH_SHEET_ROW(sheet, r, riga)
    {
      if (riga->get(_posizioni.posizione("codart")) == codart && riga->get(_posizioni.posizione("evaso")) != "X")
      {
        int pacchi = riga->get_int(_posizioni.posizione("pacchi"));     pacchi += 1;
        int qtacon = riga->get_int(_posizioni.posizione("consegnato")); qtacon += qtapacco;

        riga->add(pacchi, _posizioni.posizione("pacchi"));
        riga->add(qtacon, _posizioni.posizione("consegnato"));

        trovato = true;

        if (_pacchi.is_key(codpacco))
          _pacchi.remove(codpacco);
        else  
          _pacchi.add(codpacco, kdoc);
      }
    }

    if (!trovato)
    {
      if(yesno_box(TR("Si desidera provare a sommare il pacco a una riga gi<67> evasa?")))
      {
        FOR_EACH_SHEET_ROW(sheet, r, riga)
        {
          if (riga->get(_posizioni.posizione("codart")) == codart)
          {
            int pacchi = riga->get_int(_posizioni.posizione("pacchi"));     pacchi += 1;
            int qtacon = riga->get_int(_posizioni.posizione("consegnato")); qtacon += qtapacco;

            riga->add(pacchi, _posizioni.posizione("pacchi"));
            riga->add(qtacon, _posizioni.posizione("consegnato"));

            trovato = true;
            if (_pacchi.is_key(codpacco))
              _pacchi.remove(codpacco);
            else  
              _pacchi.add(codpacco, kdoc);

          }
        }
      }
    }

    if (!trovato)
      warning_box(TR("Non <20> stato possibile sommare il pacco a nessuna riga del buono"));
  }
}

//ON_FIELD_EVENT: metodo che gestisce gli eventi sui campi della maschera
bool TEvasione_msk::on_field_event(TOperable_field& f, TField_event e, long jolly)
{
  //a seconda del bottone premuto esegui un metodo diverso
  switch (f.dlg())
  {
  case DLG_SELECT:
    {
      if (e == fe_button)
        evadi_tutto();
    }
    break;
  case DLG_PREVIEW:
    {
      riordina_righe();
    }
    break;
  case DLG_ELABORA:
    {
      if (e == fe_button)
        if (controlla())
          genera_documento();
        else
        {
          if(yesno_box(TR("ATTENZIONE: non tutte le righe sono evase. Si desidera continuare ugualmente?")))
          {
            if(yesno_box(TR("Si desidera considerare evase tutte le righe?"
                            "(in caso contrario le righe evase parzialmente verranno spezzate su due righe)")))
              evadi_tutto();
            else
            {
              spezza_riga();
              genera_documento();
            }
          }
          else
            riordina_righe();
        }
    }
    break;
  case DLG_SAVEREC:
    {
      if (e == fe_button)
        salva();
    }
    break;
  case DLG_CANCEL:
    {
      if (e ==  fe_button && jolly == 0)
      {
        annulla_operazioni();
        return false;
      }
    }
    break;
  case F_NDOC:    
    {
      if (e == fe_modify)
        if (f.get_long() > 0)
          carica_righe();        
        else
        {
          sfield(F_RIGHE).destroy();
          disable(DLG_SELECT);
          disable(DLG_PREVIEW);
          disable(DLG_ELABORA);
          disable(DLG_SAVEREC);
          disable(DLG_CANCEL);
          reset(F_STATO);
          reset(F_DATADOC);  setta_campi_data();
          reset(F_CODCF);    setta_campi_cliente();
          hide(F_RIGHE);
        }         
    }
    break;
  case F_DATADOC:
    {
      if (e == fe_modify)
        setta_campi_data();      
    }
    break;
  case F_CODCF:
    {
      if (e == fe_modify)
        setta_campi_cliente();
    }
    break;  
  case S_CONSEGNATO:
    {
      if (e == fe_modify)
      {
        TMask& msk = sfield(F_RIGHE).sheet_mask();
        //la riga risulta evasa se la quantit<69> consegnata <20> maggiore o uguale alla quantit<69> da consegnare
        if(msk.get_long(S_CONSEGNATO) > msk.get_long(S_DACONS))
        {
          warning_box(TR("ATTENZIONE: stai consegnando un quantitativo maggiore al dovuto"));
          msk.set(S_EVASO, "X");
        }
        else if (msk.get_long(S_CONSEGNATO) == msk.get_long(S_DACONS))
          msk.set(S_EVASO, "X");
        sistema_pacchi();
      }
    }
    break;
  case S_PACCHI:
    {
      if (e == fe_modify)
        sistema_quantita();
    }
    break;
  default:break;
  }

  return true;
}

//metodo costruttore che precarica i campi di interesse sulla maschera
TEvasione_msk::TEvasione_msk():TAutomask("lv3200a") 
{
  //precarico i campi fissi
  set(F_CODNUM, ini_get_string(CONFIG_DITTA, "lv", "NUM_PRE", NULL, 0));
  set(F_TPDOC,  ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_PRE", NULL, 0));

  const TRectype& tpdoc = cache().get("%NUM", ini_get_string(CONFIG_DITTA, "lv", "TIPODOC_PRE", NULL, 0));  
  set(F_DESCR, tpdoc.get("S0"));

  TDate data(TODAY);
  TEsercizi_contabili es;
  int annoes = es.date2esc(data);
  set(F_ANNO, annoes);

  _tpev = main_app().argv(2);

  if (_tpev == "B")
    show(F_BARCODE);
  else
    hide(F_BARCODE);

  hide(F_RIGHE);
  disable(DLG_SELECT);
  disable(DLG_PREVIEW);
  disable(DLG_ELABORA);
  disable(DLG_SAVEREC);
  disable(DLG_CANCEL);

  _ndoc = 0;
}

                                 /////////////////////////////
                                 ////    TEVASIONE_APP    ////
                                 /////////////////////////////

//classe TEvasione_app
class TEvasione_app : public TSkeleton_application
{ 
  TEvasione_msk*  _msk;

protected:
  virtual bool create();
  virtual bool destroy();

public:
  bool transfer();
  virtual void main_loop();  
};

//CREATE: metodo costruttore
bool TEvasione_app::create()
{
  _msk = new TEvasione_msk();
  open_files(LF_DOC, LF_RIGHEDOC);
  return TSkeleton_application::create();
}

//DESTROY: metodo distruttore
bool TEvasione_app::destroy()
{	
  delete _msk;
  return TApplication::destroy();
}

//TRANSFER: metodo che scorre i campi nome e, se sono pieni, richiama il metodo
//ELABORA_FILE(), che effettivamente fa l'elaborazione
bool TEvasione_app::transfer()
{   
  return true;
}

void TEvasione_app::main_loop()
{
  while (_msk->run() == K_ENTER)
		transfer();
}

int lv3200(int argc, char *argv[])
{
  TEvasione_app a;
  a.run (argc, argv, "Evasione Buoni di Prelievo");
  return TRUE;
}