campo-sirio/lv/lv2400.cpp

#include <automask.h>
#include <progind.h>

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

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

#include "lv2400a.h"

                                 //////////////////////////////////////
                                 ////    TGENERA_DOCUMENTI_MASK    ////
                                 //////////////////////////////////////

//classe TGenera_documenti_mask
class TGenera_documenti_mask : public TAutomask
{
public:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
  TGenera_documenti_mask (const char* name) : TAutomask(name) {}
};

//ON_FIELD_EVENT: questo metodo gestisce i vari eventi che si verificano sui campi della maschera
bool TGenera_documenti_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{  
  return true;
}

                                 //////////////////////////////////////
                                 ////    TGENERA_DOCUMENTI_APP     ////
                                 //////////////////////////////////////

//classe TGenera_documenti_app
class TGenera_documenti_app : public TSkeleton_application
{
  TGenera_documenti_mask*		_msk;
  TAssoc_array              _quantita;
  TAssoc_array              _quantita_ritirata;
  TConfig*                  _configlv;

private:
  //Metodi per la generazione dei documenti
  bool crea_documento(const TISAM_recordset& plan);
  void crea_riga(const TString& codart, const char modpas, const int tplis, const bool tmp, const bool prinbo,TDocumento& doc);
  //Metodi per il recupero di codnum, tpdoc, stato
  bool numerazione_ddt(TString& codnum, TString& tpdoc, TString& statoi, TString& statof) const;
  bool numerazione_drit(const int cod, TString& codnum, TString& tpdoc, TString& statoi, TString& statof) const;
  bool numerazione_dant(const int cod, TString& codnum, TString& tpdoc, TString& statoi, TString& statof) const;
  //Metodi per l'eliminazione dei documenti
  void cambia_stato(const long codcli, const long codind, const char ritoant);
  void elimina_bolle(const long codcli, const long codind);
  //Metodi per la scansione dei documenti
  void scansione_ritiri_anticipi(const long codcli, const long codind, const char ritoant);
  void scansione_consegne(const long codcli, const long codind);
  //Metodo per il calcolo delle quantit<69> in bolla
  void calcolo_quantita(const TDocumento& doc, const char ritoant);
  //Metodi aggiornare il conguaglio sui contratti
  void aggiorna_conguaglio(const long codcli, const long codcont, const TString& codart, const real arr) const;  

protected:
  virtual bool create();
  virtual void on_config_change();
  virtual bool destroy();
  
public:
  bool transfer();
  virtual void main_loop();  
};

////////////////////////////////
////    Metodi Protected    ////
////////////////////////////////

//CREATE: metodo costruttore
bool TGenera_documenti_app::create()
{
  _msk = new TGenera_documenti_mask("lv2400a");
  _configlv = new TConfig(CONFIG_DITTA,"lv");
  return TSkeleton_application::create();
}

//ON_CONFIG_CHANGE: metodo che aggiorna la variabile TConfig ogni volta
//che faccio un cambiamento al file fisico
void TGenera_documenti_app::on_config_change()
{
  if (_configlv != NULL)
    delete _configlv;
  _configlv = new TConfig(CONFIG_DITTA,"lv");  
}

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

///////////////////////////////////////////////////////
////    Metodi per la generazione dei documenti    ////  
///////////////////////////////////////////////////////

//CREA_DOCUMENTO: metodo che crea un nuovo documento di trasporto dai dati salvati
bool TGenera_documenti_app::crea_documento(const TISAM_recordset& plan)
{
  //recupero i dati di interesse dalla maschera
  const TDate datadoc = _msk->get_date(F_DTDOC);

  //per ogni planning recupero i dati di interesse dal planning
  const long codcli = plan.get(LVRCONSPLAN_CODCF).as_int();
  const long codcont = plan.get(LVRCONSPLAN_CODCONT).as_int();
  const TDate dtcons = plan.get(LVRCONSPLAN_DTCONS).as_date();
  const char modpas = plan.get(LVRCONSPLAN_MODPASS).as_string()[0];
  
  const int anno = datadoc.year();
      
  //preparo la chiave per la tabella contratti
  TToken_string keycont;
  keycont.add(codcli);
  keycont.add(codcont);  
  //instanzio una cache sulla tabella dei contratti
  const TRectype& tcont = cache().get(LF_LVCONDV,keycont);
  //estraggo i dati di interesse dalla cache
  const long codind = tcont.get_long(LVCONDV_CODINDSP);  //codice dell'indirizzo di spedizione
  const int tplis = tcont.get_int(LVCONDV_TIPOLIS);      //tipo listino
  const bool prinbo = tcont.get_bool(LVCONDV_STPRZBOL);  //prezzo in bolla

  //elimina eventuali documenti di consegna che sono ancora in stato iniziale
  //...e riporta in stato iniziale i documenti di ritiro e di anticipo che concorrono
  //...a calcolare le quantit<69> da riportare sulla bolla
  cambia_stato(codcli, codind, 'R');
  cambia_stato(codcli, codind, 'A');
  elimina_bolle(codcli, codind);

  //calcola tutte le quantit<69> riportate sui documenti di ritiro, sui documenti di anticipo e sulle bolle di consegna
  //...eventualmente modificate a mano
  scansione_ritiri_anticipi(codcli,codind,'R');
  scansione_ritiri_anticipi(codcli,codind,'A');
  scansione_consegne(codcli,codind);

  //variabili che conterranno i parametri dei documenti che devo generare...
  //...settati dalla funzione numerazione_ddt()
  TString4 codnum;
  TString4 tpdoc;
  TString4 statoi;
  TString4 statof;

  //se non trovo quale documento generare, evito il resto dell'elaborazione
  if (!numerazione_ddt(codnum, tpdoc, statoi, statof))
    return NOERR;  
  
  //creo il documento corretto riempiendo i campi che gi<67> conosco
  TDocumento doc('D',anno,codnum,0);
  
  doc.put(DOC_STATO, statoi);
  doc.put(DOC_TIPODOC, tpdoc);
  doc.put(DOC_DATADOC, datadoc);
  doc.put(DOC_TIPOCF, 'C');
  doc.put(DOC_CODCF, codcli);
  doc.put(DOC_CODCONT, codcont);
  doc.put(DOC_CODINDSP, codind);

  const long ndoc = doc.get_long(DOC_NDOC);

  //preparo la chiave per la tabella righe contratti
  TToken_string keyrcont;
  keycont.add(codcli);
  keycont.add(codcont);  
  
  FOR_EACH_ASSOC_OBJECT(_quantita,h,codart,obj)
  {
    crea_riga(codart, modpas, tplis, false, prinbo ,doc);

    /*const TDate dadata = rcont.get(LVRCONDV_INDTTMP).as_date();
    const TDate adata = rcont.get(LVRCONDV_FIDTTMP).as_date();
    if (dadata.ok() && dtcons >= dadata && dtcons <= adata)
      crea_riga(rcont, modpas, true, doc);*/
  }

  int err = doc.write();

  //scrivo sul planning il riferimento alla bolla che lo accompagna
  if (err == NOERR)
  {
    TLocalisamfile& f = plan.cursor()->file();
    f.put(LVRCONSPLAN_ANNO, anno);
    f.put(LVRCONSPLAN_CODNUM, codnum);
    f.put(LVRCONSPLAN_NDOC, ndoc);
    f.rewrite();
  }

  return err == NOERR;
}

//CREA_RIGA: questa funzione crea una riga merce per una bolla di consegna
void TGenera_documenti_app::crea_riga(const TString& codart, const char modpas, const int tplis, const bool tmp, const bool prinbo,TDocumento& doc)
{
  const int perarr = _configlv->get_int("Perarr");
  
  //creo la nuova riga
  TRiga_documento& rdoc = doc.new_row("21");

  const long codcli = doc.get_long(DOC_CODCF);
  const long codcont = doc.get_long(DOC_CODCONT);

  //calcolo della quantit<69> che va sulla bolla
  
  //preparo la chiave per la tabella righe contratti
  TToken_string keyrcont;  
  keyrcont.add(codcli);
  keyrcont.add(codcont);
  keyrcont.add(codart);
  //instanzio una cache sulla tabella delle righe contratti
  const TRectype& rcont = cache().get(LF_LVRCONDV,keyrcont);
  //recupero i dati di interesse dalla riga del contratto
  bool arrot;
  if (rcont.get_int(LVRCONDV_CALCCONS) == 1)
    arrot = true;
  else
    arrot = false;

  const real conguaglio = rcont.get_real(LVRCONDV_QTACONG);  
  const real& qta = *(real*)_quantita.objptr(codart);
  const real& qta1 = *(real*)_quantita_ritirata.objptr(codart);
  
  //instanzio una cache sulla tabella del magazzino
  const TRectype& anamag = cache().get(LF_ANAMAG,codart);
  //recupero i dati di interesse dall'anagrafica di magazzino
  const real ppconf = anamag.get_real(ANAMAG_PPCONF);

  const real quantita_noarr = qta - conguaglio;
  real quantita_arr = quantita_noarr > ZERO ? quantita_noarr : ZERO;
  //se devo arrotondare
  if (quantita_arr > ZERO && arrot)
  {
    //calcolo di quanti pezzi sforo
    long arr = quantita_arr.integer() % ppconf.integer();
    //se sforo (arr > 0) allora calcolo quanti pezzi in pi<70> gli devo dare e aggiorno la quantit<69>
    if (arr > 0)
      if (arr > ppconf.integer() * perarr / 100)  //arr <= ppconf*perarr/100 -> formula calcolo congualgio di Tassan
      {
        arr = ppconf.integer() - arr;
        quantita_arr += arr;      
      }
      else
        quantita_arr -= arr;    
  }

  //scrivo le quantit<69>
  rdoc.put(RDOC_QTA, quantita_arr);       //quantit<69> consegnata eventualmente arrotondata
  rdoc.put(RDOC_QTAGG1, qta1);            //quantit<69> ritirata 
  rdoc.put(RDOC_QTAGG2, conguaglio);      //conguaglio
  rdoc.put(RDOC_QTAGG3, quantita_arr);    //copia della quantit<69> consegnata
  rdoc.put(RDOC_QTAGG4, quantita_noarr);  //quantit<69> che avrei consegnato se non arrotondavo (qta ritirata)
  rdoc.put(RDOC_GENERATA, true);

  //aggiorno il conguaglio sulla riga del contratto
  aggiorna_conguaglio(codcli, codcont, codart, quantita_arr - quantita_noarr);
  
  //elaborazione sul prezzo da utilizzare
  real prezzo;
  //elaborazione per il prezzo: o lo prendo dalle righe contratto, o dall'anagrafica magazzino
  if (tplis == 0)
    prezzo = rcont.get_real(LVRCONDV_PREZZO);
  else
    prezzo = anamag.get_real(ANAMAG_COSTSTD);

  rdoc.put(RDOC_CODART,codart);
  rdoc.put(RDOC_CODARTMAG,codart);
  rdoc.put(RDOC_CHECKED,'X'); 
  if (prinbo) 
  {
    if (!tmp)
      rdoc.put(RDOC_PREZZO,rcont.get_real(LVRCONDV_PREZZO));
    else //per adesso per questo ramo non ci passa mai, perch<63> non sappiamo come gestire le dotazioni temporanee
      rdoc.put(RDOC_PREZZO,rcont.get_real(LVRCONDV_PRZDTTMP));    
    rdoc.put(RDOC_SCONTO,rcont.get(LVRCONDV_SCONTPERC)); //sconto
  }
}

                                      //////////////////////////////////////////////////////////////
                                      ////   Metodi per il recupero di codnum, tpdoc, stato     ////  
                                      //////////////////////////////////////////////////////////////

//NUMERAZIONE_DDT: questa funzione cerca quali sono i codnum e i tpdoc che devo generare
bool TGenera_documenti_app::numerazione_ddt(TString& codnum, TString& tpdoc, TString& statoi, TString& statof) const
{
  codnum = _configlv->get("NUM_GEN");
  tpdoc = _configlv->get("TIPODOC_GEN");
  //instanzio una cache sulla tabella delle righe contratti (cerco lo stato iniziale)
  statoi = cache().get("%TIP",tpdoc,"S2").left(1);
  statof = cache().get("%TIP",tpdoc,"S2").mid(2,1);
  
  return codnum.full() && tpdoc.full();
}

//NUMERAZIONE_DRIT: questa funzione cerca quali sono i codnum e i tpdoc dei documenti di ritiro
bool TGenera_documenti_app::numerazione_drit(const int cod, TString& codnum, TString& tpdoc, TString& statoi, TString& statof) const
{
  codnum = _configlv->get("NUM_RIT",NULL,cod);
  tpdoc = _configlv->get("TIPODOC_RIT",NULL,cod);
  statof = _configlv->get("STATO_RIT",NULL,cod);  //<2F> lo stato finale
  //instanzio una cache sulla tabella delle righe contratti (cerco lo stato iniziale)
  statoi = cache().get("%TIP",tpdoc,"S2").left(1);

  return codnum.full() && tpdoc.full();
}

//NUMERAZIONE_DANT: questa funzione cerca quali sono i codnum e i tpdoc dei documenti di anticipo
bool TGenera_documenti_app::numerazione_dant(const int cod, TString& codnum, TString& tpdoc, TString& statoi, TString& statof) const
{
  codnum = _configlv->get("NUM_ANT",NULL,cod);
  tpdoc = _configlv->get("TIPODOC_ANT",NULL,cod);
  statof = _configlv->get("STATO_ANT",NULL,cod);  //<2F> lo stato finale
  //instanzio una cache sulla tabella delle righe contratti (cerco lo stato iniziale)
  statoi = cache().get("%TIP",tpdoc,"S2").left(1);

  return codnum.full() && tpdoc.full();
}

                                      //////////////////////////////////////////////////////////////
                                      ////       Metodi per l'eliminazione dei documenti        ////
                                      //////////////////////////////////////////////////////////////

//CAMBIA_STATO: questa funzione cerca tutte le bolle di ritiro e anticipo relative a un certo cliente...
//in un certo intervallo di date, e gli cambia stato
void TGenera_documenti_app::cambia_stato(const long codcli, const long codind, const char ritoant)
{
  //recupero dalla maschera i campi di interesse
  const TDate dadatabolla = _msk->get_date(F_DADTBOLLE);
  const TDate adatabolla = _msk->get_date(F_ADTBOLLE);
  
  const long daanno = dadatabolla.year();
  const long aanno = adatabolla.year();

  //per ogni paragrafo scritto in ditta.ini...
  //recupero numerazione, tipo documento e stato tramite la funzione apposita
  for (int i = 0; ; i++)
  {
    TString4 codnum;
    TString4 tpdoc;
    TString4 statoi;
    TString4 statof;
    bool err;

    //distinguo se sto scandendo i documenti di ritiro o i documenti di anticipo
    switch (ritoant)
    {
    case 'R':
      err = numerazione_drit(i, codnum, tpdoc, statoi, statof); 
      break;
    case 'A':
      err = numerazione_dant(i, codnum, tpdoc, statoi, statof); 
      break; 
    default:
      break;
    }

    //se non trovo la numerazione richiesta, interrompo il ciclo
    if (!err)
      break;

    //instanzio un recordset che contiene tutti i documenti di interesse
    TISAM_recordset docritiri ("USE DOC KEY 2 SELECT (STATO=#STATO)&&(TIPODOC=#TIPODOC)&&(CODINDSP=#CODINDSP)\nFROM TIPOCF=#TIPOCF CODCF=#CODCF PROVV=#PROVV ANNO=#DAANNO DATADOC=#DADATABOLLA CODNUM=#CODNUM\nTO TIPOCF=#TIPOCF CODCF=#CODCF PROVV=#PROVV ANNO=#AANNO DATADOC=#ADATABOLLA CODNUM=#CODNUM");
    docritiri.set_var("#STATO",TVariant(statof));  //lo stato va preso dallo sheet
    docritiri.set_var("#TIPODOC",TVariant(tpdoc));
    docritiri.set_var("#CODINDSP",codind);
    docritiri.set_var("#TIPOCF","C");
    docritiri.set_var("#CODCF",codcli);
    docritiri.set_var("#PROVV","D");
    docritiri.set_var("#DAANNO",daanno);
    docritiri.set_var("#DADATABOLLA",dadatabolla);
    docritiri.set_var("#CODNUM",TVariant(codnum));
    docritiri.set_var("#AANNO",aanno);
    docritiri.set_var("#ADATABOLLA",adatabolla);

    //per ogni documento che trovo, cambio stato al documento
    for (bool ok = docritiri.move_first(); ok; ok = docritiri.move_next())
    {
      TDocumento doc(docritiri.cursor()->curr()); //instanzio il documento
      doc.put(DOC_STATO,statoi);  //stato iniziale
    }
  }
  return;
}

//ELIMINA_BOLLE: questa funzione cerca tutte le bolle di consegna relative a un certo cliente ancora...
//nello stato iniziale in un certo intervallo di date e le elimina
void TGenera_documenti_app::elimina_bolle(const long codcli, const long codind)
{
  //recupero dalla maschera i campi di interesse
  const TDate dadatabolla = _msk->get_date(F_DADTBOLLE);
  const TDate adatabolla = _msk->get_date(F_ADTBOLLE);
  
  const long daanno = dadatabolla.year();
  const long aanno = adatabolla.year();
  
  //recupero numerazione, tipo documento e stato tramite la funzione apposita
  TString4 codnum;
  TString4 tpdoc;
  TString4 statoi;
  TString4 statof;

  //se non trovo la numerazione richiesta, interrompo la funzione
  if (!numerazione_ddt(codnum, tpdoc, statoi, statof))
    return;

  //instanzio un recordset che contiene tutti i documenti di interesse
  TISAM_recordset docritiri ("USE DOC KEY 2 SELECT (STATO=#STATO)&&(TIPODOC=#TIPODOC)&&(CODINDSP=#CODINDSP)\nFROM TIPOCF=#TIPOCF CODCF=#CODCF PROVV=#PROVV ANNO=#DAANNO DATADOC=#DADATABOLLA CODNUM=#CODNUM\nTO TIPOCF=#TIPOCF CODCF=#CODCF PROVV=#PROVV ANNO=#AANNO DATADOC=#ADATABOLLA CODNUM=#CODNUM");
  docritiri.set_var("#STATO",TVariant(statof));
  docritiri.set_var("#TIPODOC",TVariant(tpdoc));
  docritiri.set_var("#CODINDSP",codind);
  docritiri.set_var("#TIPOCF","C");
  docritiri.set_var("#CODCF",codcli);
  docritiri.set_var("#PROVV","D");
  docritiri.set_var("#DAANNO",daanno);
  docritiri.set_var("#DADATABOLLA",dadatabolla);
  docritiri.set_var("#CODNUM",TVariant(codnum));
  docritiri.set_var("#AANNO",aanno);
  docritiri.set_var("#ADATABOLLA",adatabolla);

  //per ogni documento che trovo, aggiorno la quantit<69> e gli cambio stato
  for (bool ok = docritiri.move_first(); ok; ok = docritiri.move_next())
  {
    TDocumento doc(docritiri.cursor()->curr()); //instanzio il documento
    doc.remove();  //stato di bloccato
  }
  return;
}

                                      //////////////////////////////////////////////////////////////
                                      ////        Metodi per la scansione dei documenti         ////
                                      //////////////////////////////////////////////////////////////

//SCANSIONE_RITIRI_ANTICIPI: questa funzione cerca tutte le bolle di ritiro relative a un certo cliente non ancora evase...
//in un certo intervallo di date, e, dopo l'elaborazione, gli cambia stato
void TGenera_documenti_app::scansione_ritiri_anticipi(const long codcli, const long codind, const char ritoant)
{
  //recupero dalla maschera i campi di interesse
  const TDate dadatabolla = _msk->get_date(F_DADTBOLLE);
  const TDate adatabolla = _msk->get_date(F_ADTBOLLE);
  
  const long daanno = dadatabolla.year();
  const long aanno = adatabolla.year();

  //per ogni paragrafo scritto in ditta.ini...
  //recupero numerazione, tipo documento e stato tramite la funzione apposita
  for (int i = 0; ; i++)
  {
    TString4 codnum;
    TString4 tpdoc;
    TString4 statoi;
    TString4 statof;
    bool err;

    //distinguo se sto scandendo i documenti di ritiro o i documenti di anticipo
    switch (ritoant)
    {
    case 'R':
      err = numerazione_drit(i, codnum, tpdoc, statoi, statof); 
      break;
    case 'A':
      err = numerazione_dant(i, codnum, tpdoc, statoi, statof); 
      break; 
    default:
      break;
    }

    //se non trovo la numerazione richiesta, interrompo il ciclo
    if (!err)
      break;

    //instanzio un recordset che contiene tutti i documenti di interesse
    TISAM_recordset docritiri ("USE DOC KEY 2 SELECT (STATO!=#STATO)&&(TIPODOC=#TIPODOC)&&(CODINDSP=#CODINDSP)\nFROM TIPOCF=#TIPOCF CODCF=#CODCF PROVV=#PROVV ANNO=#DAANNO DATADOC=#DADATABOLLA CODNUM=#CODNUM\nTO TIPOCF=#TIPOCF CODCF=#CODCF PROVV=#PROVV ANNO=#AANNO DATADOC=#ADATABOLLA CODNUM=#CODNUM");
    docritiri.set_var("#STATO",TVariant(statof));  //lo stato va preso dallo sheet
    docritiri.set_var("#TIPODOC",TVariant(tpdoc));
    docritiri.set_var("#CODINDSP",codind);
    docritiri.set_var("#TIPOCF","C");
    docritiri.set_var("#CODCF",codcli);
    docritiri.set_var("#PROVV","D");
    docritiri.set_var("#DAANNO",daanno);
    docritiri.set_var("#DADATABOLLA",dadatabolla);
    docritiri.set_var("#CODNUM",TVariant(codnum));
    docritiri.set_var("#AANNO",aanno);
    docritiri.set_var("#ADATABOLLA",adatabolla);

    //per ogni documento che trovo, aggiorno la quantit<69>, e poi cambio stato al documento
    for (bool ok = docritiri.move_first(); ok; ok = docritiri.move_next())
    {
      TDocumento doc(docritiri.cursor()->curr()); //instanzio il documento
      calcolo_quantita(doc,ritoant);
      doc.put(DOC_STATO,statof);  //stato di elaborato, preso dallo sheet  
    }
  }
  return;
}

//SCANSIONE_CONSEGNE: questa funzione cerca tutte le bolle di consegna relative a un certo cliente ancora...
//nello stato iniziale in un certo intervallo di date
void TGenera_documenti_app::scansione_consegne(const long codcli, const long codind)
{
  //recupero dalla maschera i campi di interesse
  const TDate dadatabolla = _msk->get_date(F_DADTBOLLE);
  const TDate adatabolla = _msk->get_date(F_ADTBOLLE);
  
  const long daanno = dadatabolla.year();
  const long aanno = adatabolla.year();
  
  //recupero numerazione, tipo documento e stato tramite la funzione apposita
  TString4 codnum;
  TString4 tpdoc;
  TString4 statoi;
  TString4 statof;

  //se non trovo la numerazione richiesta, interrompo la funzione
  if (!numerazione_ddt(codnum, tpdoc, statoi, statof))
    return;

  //instanzio un recordset che contiene tutti i documenti di interesse
  TISAM_recordset docritiri ("USE DOC KEY 2 SELECT (STATO!=#STATO)&&(TIPODOC=#TIPODOC)&&(CODINDSP=#CODINDSP)\nFROM TIPOCF=#TIPOCF CODCF=#CODCF PROVV=#PROVV ANNO=#DAANNO DATADOC=#DADATABOLLA CODNUM=#CODNUM\nTO TIPOCF=#TIPOCF CODCF=#CODCF PROVV=#PROVV ANNO=#AANNO DATADOC=#ADATABOLLA CODNUM=#CODNUM");
  docritiri.set_var("#STATO",TVariant(statof));
  docritiri.set_var("#TIPODOC",TVariant(tpdoc));
  docritiri.set_var("#CODINDSP",codind);
  docritiri.set_var("#TIPOCF","C");
  docritiri.set_var("#CODCF",codcli);
  docritiri.set_var("#PROVV","D");
  docritiri.set_var("#DAANNO",daanno);
  docritiri.set_var("#DADATABOLLA",dadatabolla);
  docritiri.set_var("#CODNUM",TVariant(codnum));
  docritiri.set_var("#AANNO",aanno);
  docritiri.set_var("#ADATABOLLA",adatabolla);

  //per ogni documento che trovo, aggiorno la quantit<69> e gli cambio stato
  for (bool ok = docritiri.move_first(); ok; ok = docritiri.move_next())
  {
    TDocumento doc(docritiri.cursor()->curr()); //instanzio il documento
    calcolo_quantita(doc,'B');
    doc.put(DOC_STATO,statof);  //stato di bloccato
  }
  return;
}

                                      //////////////////////////////////////////////////////////////
                                      ////    Metodo per il calcolo delle quantit<69> in bolla     ////
                                      //////////////////////////////////////////////////////////////

//CALCOLO_QUANTITA: questa funzione scorre tutte le righe documento di una bolla di ritiro, riempiendo un...
//TAssoc_array con le quantit<69> ritirate per ogni articolo, sommando le diverse righe con lo stesso articolo...
//Questa funzione viene richiamata per ogni documento valido individuato dalla SCANSIONE_RITIRI
void TGenera_documenti_app::calcolo_quantita(const TDocumento& doc, const char ritoant)
{
  //scorro le righe documento
  for (long i = 1; i <= doc.rows(); i++)
  {
    //instanzio la riga corrente
    const TRiga_documento& rdoc = doc[i];
    //estraggo i dati di interesse
    const TString80 codart = rdoc.get(RDOC_CODARTMAG);
    const real qtardoc = rdoc.get_real(RDOC_QTA);
    //se <20> una riga che riguarda un articolo e se la quantit<69> su questa riga non <20> nulla, allora la elaboro
    if (codart.full() && !qtardoc.is_zero())
    {
      TArticolo& art = rdoc.articolo();
      //leggo se esiste gi<67> nel TAssoc_array
      real *qta = (real*)_quantita.objptr(codart);
      real *qta1 = (real*)_quantita_ritirata.objptr(codart);
      //se non esiste
      if (qta == NULL)
      {
        //per ora memorizzo zero
        qta = new real;
        _quantita.add(codart,qta);
      }
      if (qta1 == NULL)
      {
        //per ora memorizzo zero
        qta1 = new real;
        _quantita_ritirata.add(codart,qta1);
      }
      //aggiorno la quantit<69> convertendola all'unit<69> di misura di base, aggiungendola o sottraendola
      //...se si tratta di un ritiro o di un anticipo rispettivamente; nel caso della scansione delle
      //...bolle di consegna modificate a mano (caso 'B'), devo modificare la quantit<69> da consegnare
      //...tenendo conto delle modifiche manuali
      switch (ritoant)
      {
      case 'R':
        *qta +=  art.convert_to_um(qtardoc, NULL, rdoc.get(RDOC_UMQTA));
        *qta1 += art.convert_to_um(qtardoc, NULL, rdoc.get(RDOC_UMQTA));
        break;
      case 'A':
        *qta -=  art.convert_to_um(qtardoc, NULL, rdoc.get(RDOC_UMQTA));
        break;
      case 'B':
        {
          const real qtagg3 = rdoc.get_real(RDOC_QTAGG3);
          real modifica = qtardoc - qtagg3;
          *qta -=  art.convert_to_um(modifica, NULL, rdoc.get(RDOC_UMQTA));
        }
        break;
      default:
        break;
      }          
    }
  }
  return;
}

                                      //////////////////////////////////////////////////////////////
                                      ////    Metodi aggiornare il conguaglio sui contratti     ////  
                                      //////////////////////////////////////////////////////////////

//AGGIORNA_CONGUAGLIO: questa funzione aggiorna il parametro conguaglio sulla riga del contratto
void TGenera_documenti_app::aggiorna_conguaglio(const long codcli, const long codcont, const TString& codart, const real arr) const
{
  TLocalisamfile rcondv(LF_LVRCONDV);
  rcondv.put(LVRCONDV_CODCF,codcli);
  rcondv.put(LVRCONDV_CODCONT,codcont);
  rcondv.put(LVRCONDV_CODART,codart);
  if (rcondv.read() == NOERR)
  {
    rcondv.put(LVRCONDV_QTACONG,arr);
    rcondv.rewrite();
  }
}

                                      ////////////////////////////////
                                      ////     Metodi Pubblic     ////
                                      ////////////////////////////////

bool TGenera_documenti_app::transfer()
{
  //leggo i campi dalla maschera
  const TDate datacons = _msk->get_date(F_DTCONS);  
  const long coditi = _msk->get_long(F_CODITI);
  long codcli = _msk->get_long(F_CODCF);

  //preparo un recordset che contiene tutti planning per cui voglio creare i documenti relativi
  TString query = "USE LVRCONSPLAN KEY 2";  
  
  if (coditi || codcli)
  {
    query << " SELECT ";
    if (codcli > 0)
      query << "(CODCF=" << codcli << ')';
    if (coditi > 0)    
    {
      if (codcli > 0)
        query << "&&";
      query << "(CODITI=" << coditi << ')';
    }
  }
  query << "\n";
  query << "FROM DTCONS=" << datacons << "\n";
  query << "TO DTCONS=" << datacons << "\n";

  TISAM_recordset plan(query);

  TProgind pi(plan.items(), TR("Generazione documenti in corso..."), true, true);

  for (bool ok = plan.move_first(); ok; ok = plan.move_next())
	{
	  if (!pi.addstatus(1))
		  break;

    crea_documento(plan);
  }

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

int lv2400(int argc, char* argv[])
{
  TGenera_documenti_app app;
  app.run(argc, argv, TR("Generazione documenti"));
  return 0;
}