Patch level :10.0 98

Files correlati     :
Ricompilazione Demo : [ ]
Commento            :riporti dalla 5.0


git-svn-id: svn://10.65.10.50/trunk@16977 c028cbd2-c16b-5b4b-a496-9718f37d4682

ve/ve6.cpp

@@ -20,6 +20,8 @@ int main( int argc, char** argv )
     ve6600(argc, argv); break;         // collegamento contabilita' industriosa
   case 7:
     ve6700(argc, argv); break;         // copia documenti interattiva da ditta a ditta
+  case 8:
+    ve6800(argc, argv); break;         // contabilizzazione analitica documenti
   default:
     ve6100(argc, argv); break;         // contabilizzazione documenti
   }

ve/ve6.h

@@ -8,5 +8,6 @@ int ve6400 (int, char**);
 int ve6500 (int, char**);
 int ve6600 (int, char**);
 int ve6700 (int, char**);
+int ve6800 (int, char**);
 
 #endif

ve/ve6800.cpp

@@ -0,0 +1,314 @@
+// ve6800.cpp: programma di contabilizzazione analitica documenti
+// Orgiastica visione...
+//      L'oca del dubbio dalle labbra di Fernet.
+//******************************************************************************
+//          \\\\\\\\                 e                                         *
+//     b     \\\\\\\\                          b                               *
+//            \\\\\\\\   e                            r          d        l    *
+//             \\\\\\\\                                                        *
+//              \\\\\\\\    i       V              o             e      h      *
+//      L        \\\\\\\\                                                      *
+//                \\\\\\\\     b        d                                      *
+//              o  \\\\\\\\                      m         a                   *
+// +++++++++++++++++++++++++            b                              t       *
+// ++++++++++++++++++++++++++--------------------------------------------------|
+// ++++++++++++++++++++++++++--------------------------------------------------|
+// ++++++++++++++++++++++++            |---------------------------------------|
+//    u           ////////          u  |---------------------------------------|
+//       '       ////////    a         |             /\            /\          |
+//              ////////           i   |  r         /  \  r       /  \         |
+//         a   ////////               \|/          /    \        /    \  l     |
+//            ////////-----------------*---\  a   /  t   \      /   a  \      /|
+//           ////////                 /|\   \    /        \    /        \    / |
+//   d      ////////          n        |     \  /          \  /          \  /  |
+//         ////////    l          d    |      \/     a      \/     l      \/   |
+//-----------------------------------------------------------------------------|
+//
+// Scared uh?
+
+#include <automask.h>
+#include <progind.h>
+#include <relation.h>
+#include <sheet.h>
+#include <tabutil.h>
+#include <urldefid.h>
+
+#include "velib04.h"
+#include "../cg/cgsaldac.h"
+
+#include "ve6800a.h"
+
+
+///////////////////////////////////////////////
+//  MASCHERA
+///////////////////////////////////////////////
+class TContabilizzazione_analitica_mask : public TAutomask
+{
+  TArray_sheet*   _num_sheet;  // TArray_sheet contenente le selezioni sui codici numerazione
+  TString_array   _tipi_doc;   // Array di stringhe contenente i tipi documenti da elaborare
+
+protected:
+  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
+  // Costruisce lo sheet dei codici numerazione
+  void build_num_sheet();
+
+public:
+  // Controlla se lo stato ed il tipo del documento sono validi e rispettano la selezione
+  bool doc_tipo_stato_ok(const TRectype& doc);
+  // Restituisce lo sheet con le numerazioni da elaborare
+  TArray_sheet& num_sheet() const { return *_num_sheet; }
+  // Constructor and Distructor
+  TContabilizzazione_analitica_mask();
+  ~TContabilizzazione_analitica_mask();
+};
+
+TContabilizzazione_analitica_mask::TContabilizzazione_analitica_mask()  : TAutomask("ve6800a")
+{
+  _num_sheet = new TArray_sheet(-1, -1, -4, -4, "Codici numerazione", "@1|Cod. numerazione|Descrizione@50");
+}
+
+TContabilizzazione_analitica_mask::~TContabilizzazione_analitica_mask()
+{ 
+  delete _num_sheet; 
+}
+
+bool TContabilizzazione_analitica_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
+{
+  switch (o.dlg())
+  {
+  case F_CODICE_ELAB:
+    if (e == fe_modify)
+    {
+      if (o.empty())
+        disable(DLG_ELABORA);
+      else
+        build_num_sheet();
+    }
+    break;
+  case DLG_USER:
+    if (e == fe_button)
+    {
+      if (_num_sheet->run())
+      {
+        if (_num_sheet->checked() != 0) // Hai selezionato qualcosa ?
+          enable(DLG_ELABORA);    // allora abilita il pulsante di conferma 
+        else
+          disable(DLG_ELABORA);
+      }
+    }
+    break;
+  default:
+    break;
+  }
+  return true;
+}
+
+void TContabilizzazione_analitica_mask::build_num_sheet()
+{
+  _num_sheet->destroy();
+  _tipi_doc.destroy();
+  
+  TTable num("%NUM");
+  TString s1,s2,s3;
+  
+  TContabilizzazione_analitica* contanal = new TContabilizzazione_analitica(get(F_CODICE_ELAB));
+  if (!contanal->empty())
+  {
+    TToken_string t;
+    TString16 tipo;
+    for (int i = 0; i < TElaborazione::_max_tipi_doc_elab; i++)
+    {
+      tipo = contanal->tipo_iniziale(i);
+      if (tipo.not_empty())
+      { 
+        t = tipo;
+        t.add(contanal->stato_iniziale(i));   // Stato iniziale
+        _tipi_doc.add(t);                     // Aggiunge questo tipo documento alla lista
+      }
+    }
+    
+    long pos = 0l;
+    
+    for (num.first(); num.good(); num.next(), pos++) // scorre tutte le numerazioni possibili
+    {
+      TToken_string t,z;
+      t.add(" ");
+      t.add(num.get("CODTAB"));
+      t.add(num.get("S0"));
+      _num_sheet->add(t);
+      s2 = num.get("S2"); // reperisce i tipi documento validi per questa numerazione
+
+      for (int x = 0; x <= s2.len(); x += 4)
+        z.add(s2.mid(x,4));
+
+      bool found = FALSE;  
+      for  (int i = _tipi_doc.last(); !found && i >= 0; i--)
+        found |= (s2.find(((TToken_string &)_tipi_doc[i]).get(0)) >= 0);
+      if (found)
+        _num_sheet->enable_row(pos);
+      else
+        _num_sheet->disable_row(pos);
+    }
+  }
+  delete contanal;
+}
+
+bool TContabilizzazione_analitica_mask::doc_tipo_stato_ok(const TRectype& doc)
+// Verifica che il tipo documento corrente esista tra i tipi previsti dalla elaborazione
+// differita selezionata
+{
+  bool found = false;
+  const TString16 tipo = doc.get(DOC_TIPODOC);
+  const char stato = doc.get_char(DOC_STATO);
+  const int items = _tipi_doc.items();
+  for (int i = 0; i < items && !found; i++)
+  {
+    TToken_string& t = _tipi_doc.row(i);
+    const TString16 tipox(t.get(0));
+    const char statox = t.get(1)[0];
+    if (tipo == tipox && stato == statox)
+      found = true;
+  }
+  return found;
+}
+
+//////////////////////////////////////////////
+//  APPLICAZIONE
+/////////////////////////////////////////////
+
+// TContabilizzazione_analitica
+// Applicazione di contabilizzazione documenti
+class TContabilizzazione_analitica_app : public TSkeleton_application
+{
+  TContabilizzazione_analitica_mask*  _msk;
+
+protected: // TApplication
+  // Contabilizza i documenti
+  void contabilize();
+
+public:
+  virtual bool create();
+  virtual bool destroy();
+  virtual void main_loop();
+};
+
+
+void TContabilizzazione_analitica_app::contabilize()
+{
+  //Prende i dati dalla maschera (date,sheet numerazioni)
+  const TDate data_ini = _msk->get_date(F_DATA_INI);
+  int year_from = data_ini.year();
+  const TDate data_fine = _msk->get_date(F_DATA_FIN);
+  int year_to = data_fine.year();
+  const TDate data_reg = _msk->get_date(F_DATA_REG);
+  TArray_sheet& num_sheet = _msk->num_sheet();
+  const long items = num_sheet.items();
+
+  //Relazione su LF_DOC
+  TRelation doc_rel(LF_DOC);
+  TRectype da(LF_DOC);
+  TRectype a(LF_DOC);
+ 
+  TString16 codnum;
+  TString msg, filt_expr;
+  TToken_string nums;
+  
+  // Compone la lista dei documenti da elaborare
+  for (long i = 0L; i < items; i++)  // Scorre per tutte le numerazioni dello sheet
+  {
+    if (num_sheet.checked(i)) // Costruisce una espressione sul codice numerazione: "CODNUM="x0" || CODNUM="x1" || ..."
+    {
+      codnum = num_sheet.row(i).get(1);
+      filt_expr << "(CODNUM=\"";
+      filt_expr << codnum << "\")||";
+      nums.add(codnum);
+    }
+  }
+  filt_expr.rtrim(2);  
+
+  da.put(DOC_DATADOC, data_ini);
+  da.put(DOC_PROVV, "D");
+  da.put(DOC_ANNO, year_from);
+  a.put(DOC_DATADOC, data_fine);
+  a.put(DOC_PROVV, "D");
+  a.put(DOC_ANNO, year_to);
+
+  // Se ho una sola numerazione ottimizzo la setregion!
+  if (nums.items() == 1)
+  {
+    da.put(DOC_CODNUM, nums);
+    a.put(DOC_CODNUM, nums);
+    //filt_expr.cut(0); // Il filtro diventa inutile
+  }
+
+  // Cursore complessivo con limiti di data (chiave 3). Viene sfruttata l'ottimizzazione
+  // sulla costruzione dei cursori nel caso i campi presenti nell'espressione siano campi
+  // chiave, nel nostro caso CODNUM soddisfa i requisiti. 
+  TCursor doc_cur(&doc_rel, filt_expr, 3, &da, &a);
+  const TRecnotype cur_items = doc_cur.items(); 
+  if (cur_items > 0)
+  {
+    TLista_documenti lista_in, lista_out;
+  
+    doc_cur.freeze();
+    msg = "Selezione documenti dal ";
+    msg << data_ini.string() << " al ";
+    msg << data_fine.string();
+    TProgind p(cur_items, msg, false, true);
+    const TRectype& cur_rec = doc_cur.curr();
+
+    // Scorre tutti i documenti che rientrano nell'intervallo selezionato
+    for (doc_cur = 0; doc_cur.pos() < cur_items; ++doc_cur)
+    { 
+      p.addstatus(1); 
+      // controlla che il tipo documento e lo stato siano coerenti con la ELD selezionata
+      if (nums.get_pos(cur_rec.get("CODNUM")) >= 0 && _msk->doc_tipo_stato_ok(cur_rec)) 
+      {   
+        TDocumento* doc = new TDocumento;
+        if (doc->read(doc_cur.curr()) == NOERR) // legge il documento
+          lista_in.add(doc); // Viene aggiunto alla lista dei documenti
+        else
+          delete doc;
+      }
+    }
+    //E finalmente fa l'agognata elaborazione!!!!!
+    TString16 elaborazione = _msk->get(F_CODICE_ELAB);
+    TContabilizzazione_analitica contanal(elaborazione);
+    contanal.elabora(lista_in, lista_out, data_reg);
+
+    if (contanal.processed_docs() > 0L)
+      message_box(FR("Totale documenti contabilizzati: %ld"), contanal.processed_docs());
+  }
+  else
+    warning_box(TR("Non vi sono documenti da contabilizzare per le numerazioni selezionate."));
+
+  xvtil_statbar_set("");  
+}
+
+
+bool TContabilizzazione_analitica_app::create()
+{
+  _msk = new TContabilizzazione_analitica_mask();
+  return TSkeleton_application::create();
+}
+
+bool TContabilizzazione_analitica_app::destroy()
+{
+  if (_msk) delete _msk;
+  return TSkeleton_application::destroy();
+}
+
+void TContabilizzazione_analitica_app::main_loop()
+{
+  while (_msk->run() == K_ENTER)
+  {
+    contabilize();
+  }
+}
+
+int ve6800 (int argc, char **argv)
+{
+  TContabilizzazione_analitica_app a;
+  a.run(argc,argv,"Contabilizzazione analitica documenti");
+  return true;
+}

ve/ve6800a.h

@@ -0,0 +1,8 @@
+// Include file per ve6800a.uml
+
+#define F_CODICE_ELAB           101
+#define F_DESC_ELAB             102
+#define F_DATA_INI              103
+#define F_DATA_FIN              104
+#define F_DATA_AUTO             105
+#define F_DATA_REG              106

ve/ve6800a.uml

@@ -0,0 +1,77 @@
+#include "ve6800a.h"
+
+PAGE "Contabilizzazione Analitica documenti" -1 -1 75 10
+
+STRING F_CODICE_ELAB 8
+BEGIN
+  PROMPT 1 1 "Codice "
+  FLAG "U"
+  USE %ELD SELECT I0 == 7
+  INPUT CODTAB F_CODICE_ELAB
+  DISPLAY "Codice@8" CODTAB
+  DISPLAY "Descrizione@50" S0
+  OUTPUT F_CODICE_ELAB CODTAB
+  OUTPUT F_DESC_ELAB S0
+  CHECKTYPE REQUIRED
+  WARNING "E' necessario specificare il codice elaborazione"
+END
+
+STRING F_DESC_ELAB 50
+BEGIN
+  PROMPT 20 1 ""
+  USE %ELD KEY 2 SELECT I0 == 7
+  INPUT S0 F_DESC_ELAB
+  DISPLAY "Descrizione@50" S0
+  DISPLAY "Codice@8" CODTAB
+  COPY OUTPUT F_CODICE_ELAB
+END
+
+GROUPBOX DLG_NULL 26 4
+BEGIN
+  PROMPT 1 2 "Date intervallo documenti"
+END
+
+DATE F_DATA_INI
+BEGIN
+  PROMPT 2 3 "Inizio "
+  CHECKTYPE REQUIRED
+  WARNING "La data di inizio intervallo e' obbligatoria"
+END
+
+DATE F_DATA_FIN
+BEGIN
+  PROMPT 2 4 "Fine   "
+  CHECKTYPE REQUIRED
+  WARNING "La data di fine intervallo deve essere successiva a quella di inizio"
+  VALIDATE DATE_CMP_FUNC >= F_DATA_INI
+END
+
+DATE F_DATA_REG
+BEGIN
+  PROMPT 2 6 "Data registrazione "
+  FLAGS "A"
+  CHECKTYPE REQUIRED
+END
+
+BUTTON DLG_USER 10 2
+BEGIN
+  PROMPT -13 -1 "~Selezione"
+  PICTURE BMP_SELECT
+END
+
+BUTTON DLG_ELABORA 10 2
+BEGIN
+  PROMPT -23 -1 "E~labora"
+  PICTURE BMP_ELABORA
+  MESSAGE EXIT,K_ENTER
+  FLAGS "D"
+END
+
+BUTTON DLG_QUIT 10 2
+BEGIN
+  PROMPT -33 -1 ""
+END
+
+ENDPAGE
+
+ENDMASK

ve/velib04.h

@@ -573,6 +573,7 @@ public:
   virtual ~TConsuntivazione_produzione() { }
 };
 
+
 class TCache_causali;  // Internal use only
 
 class TContabilizzazione_analitica : public TElaborazione  // velib04f
@@ -583,6 +584,7 @@ class TContabilizzazione_analitica : public TElaborazione  // velib04f
   TBill _sco_perc_bill_an, _sco_imp_bill_an;
   TCache_causali* _caus;
 	TString16 _fld_cms_cont;
+  long _total_docs;// Numero di documenti contabilizzati
 
   error_type _error;       // Errore rilevato durante l'elaborazione
 	bool _usepdcc;
@@ -599,12 +601,13 @@ protected:
 
 public:
 	bool search_costo_ricavo(const TRiga_documento& riga, TBill& conto, bool riclassifica_fdr_fde);
+  const long processed_docs() const { return _total_docs; }
   virtual bool elabora(TLista_documenti& doc_in, TLista_documenti& doc_out,
                        const TDate& data_elab, bool interattivo = false);
   bool elabora(TDocumento& doc, long numreg_cg, TViswin* viswin, bool can_write, TAnal_mov& mov, 
                bool riclassifica_fdr_fde = true);
 
-  TContabilizzazione_analitica();
+  TContabilizzazione_analitica(const char* cod = NULL);
   TContabilizzazione_analitica(const TRectype& rec);
   virtual ~TContabilizzazione_analitica();
 };

ve/velib04f.cpp

@@ -766,8 +766,8 @@ void TContabilizzazione_analitica::init()
   _caus = new TCache_causali;
 }
 
-TContabilizzazione_analitica::TContabilizzazione_analitica() 
+TContabilizzazione_analitica::TContabilizzazione_analitica(const char* cod) 
-                            : TElaborazione(NULL), _error(no_error), _caus(NULL)
+                            : TElaborazione(cod), _error(no_error), _caus(NULL)
 {
 	init();
 }

ve/vemenu.men

@@ -18,6 +18,7 @@ Flags   = ""
 Item_01 = "Fatturazione bolle", "ve6 -2", "F"
 Item_02 = "Contabilizzazione fatture", "ve6 -1", "F"
 Item_03 = "Generazione effetti", "ve6 -3", "F"
+Item_04 = "Contabilizzazione analitica", "ve6 -8", "F"
 
 [VEMENU_051]
 Caption = "Servizi"