Cominciato il ricalcolo del magazzino.

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

ve/ve4.cpp

@@ -0,0 +1,20 @@
+#include <xvt.h>
+
+#include <checks.h>
+
+#include "ve4.h"
+
+int main(int argc, char** argv)
+{                       
+  const int k = argc > 1 ? atoi(argv[1]+1) : 0;
+  switch(k)
+  { 
+  case 0: 
+    ve4100(argc, argv);
+    break;     
+  default:
+    error_box("Applicazione sconosciuta: %s %s.", argv[0], argv[1]);
+    break;
+  }
+  return 0;
+}

ve/ve4.h

@@ -0,0 +1 @@
+int ve4100(int argc, char* argv[]);

ve/ve4.url

@@ -0,0 +1,23 @@
+#include <default.url>
+
+/* ve4 */
+MENU TASK_MENUBAR
+  SUBMENU MENU_FILE   "~File"
+
+/* ve4 -1 */
+MENUBAR MENU_BAR(1)
+
+MENU MENU_BAR(1)
+  SUBMENU MENU_FILE   "~File"
+
+/* ve4 -2 */
+MENUBAR MENU_BAR(2)
+
+MENU MENU_BAR(2)
+  SUBMENU MENU_FILE    "~File"
+
+/* ve4 -3 */
+MENUBAR MENU_BAR(3)
+
+MENU MENU_BAR(3)
+  SUBMENU MENU_FILE    "~File"

ve/ve4100.cpp

@@ -0,0 +1,350 @@
+#include <applicat.h>
+#include <expr.h>
+#include <msksheet.h>
+#include <relation.h>
+#include <urldefid.h>
+#include <viswin.h>
+
+#include "ve4.h"
+#include "ve4100.h"
+
+///////////////////////////////////////////////////////////
+// Ciclo principale di elaborazione
+///////////////////////////////////////////////////////////
+
+
+bool elabora(TCursor& cur, TString_array& var)
+{
+  TViswin vw("ve4100.txt", "Ricalcolo valori", 
+             FALSE, TRUE, FALSE, 3, 3, -3, -3, FALSE);
+             
+  for (cur = 0; cur.ok(); ++cur)           
+  {
+  }
+             
+  return TRUE;           
+}    
+
+///////////////////////////////////////////////////////////
+// Maschera ricalcolo di magazzino
+///////////////////////////////////////////////////////////
+
+class TRicalcolo_mask : public TMask
+{              
+  TArray _rel, _des;
+  int _cur_file;  
+  TToken_string _key_expr;
+  
+protected:  
+  static bool file_handler  (TMask_field& f, KEY k);
+  static bool key_handler   (TMask_field& f, KEY k);
+  static bool filter_handler(TMask_field& f, KEY k);
+  static bool field_handler (TMask_field& f, KEY k);
+  static bool fromto_handler(TMask_field& f, KEY k);
+
+public:
+  TRelation&      get_rel() const;
+  const TRectype& get_rec() const;
+  const RecDes*   get_rec_des() const;
+  TToken_string&  get_key_expr(int k);
+
+  TRicalcolo_mask();
+  virtual ~TRicalcolo_mask() { }
+};
+
+TRicalcolo_mask::TRicalcolo_mask()
+               : TMask("ve4100"), _cur_file(0)
+{
+  const int lf[] = { LF_ANAMAG, LF_CODCORR, LF_UMART,
+                     LF_DESLIN, LF_CONDV, LF_RCONDV, 0 };
+  for (int i = 0; lf[i]; i++)                   
+  {                                   
+    TRelation* rel = new TRelation(lf[i]);
+    _rel.add(rel);
+    _des.add(new TRelation_description(*rel));
+  }     
+  
+  set_handler(F_FILE, file_handler);
+  set_handler(F_KEY, key_handler);
+  set_handler(F_FILTER, filter_handler);
+  
+  TSheet_field& fields = (TSheet_field&)field(F_FIELDS);
+  TMask& fsm = fields.sheet_mask();
+  fsm.set_handler(F_FIELD, field_handler);
+  fsm.set_handler(F_FROM, fromto_handler);
+  fsm.set_handler(F_TO, fromto_handler);
+  
+  TSheet_field& outputs = (TSheet_field&)field(F_OUTPUTS);
+  TMask& osm = outputs.sheet_mask();
+  osm.set_handler(F_FIELD, field_handler);
+  outputs.row(-1);    // Aggiunge comunque una riga vuota;
+  osm.force_update();
+} 
+
+TRelation& TRicalcolo_mask::get_rel() const
+{
+  return (TRelation&)_rel[_cur_file];
+}
+
+const TRectype& TRicalcolo_mask::get_rec() const
+{
+  return get_rel().lfile().curr();
+}
+
+const RecDes* TRicalcolo_mask::get_rec_des() const
+{     
+  return get_rec().rec_des();
+}
+
+TToken_string& TRicalcolo_mask::get_key_expr(int key)
+{    
+  _key_expr.cut(0);
+  if (key > 0)
+  {
+    const RecDes* rd = get_rec_des();
+    const KeyDes& kd = rd->Ky[key-1];
+    for (int i = 0; i < kd.NkFields; i++)
+    {
+      const int nf = kd.FieldSeq[i] % MaxFields;
+      const RecFieldDes& rf = rd->Fd[nf];  
+      _key_expr.add(rf.Name);
+    }
+  }  
+  return _key_expr;
+}
+
+bool TRicalcolo_mask::file_handler(TMask_field& f, KEY k)
+{
+  TRicalcolo_mask& m = (TRicalcolo_mask&)f.mask();
+  if (k == K_SPACE)
+  {
+    const int n = atoi(f.get());
+    if (n != m._cur_file || !m.is_running())
+    {
+      m._cur_file = n;
+      const RecDes* rd = m.get_rec_des();
+      const int keys = rd->NKeys;
+      
+      TToken_string codes(16);
+      TToken_string values(80);
+      TString16 tmp;
+      codes.add(0);
+      values.add("Nessuna");
+      for (int k = 1; k <= keys; k++)
+      { 
+        codes.add(k);
+        tmp.format("Chiave %d", k);
+        values.add(tmp);
+      }
+      TList_field& lk = (TList_field&)m.field(F_KEY);
+      lk.replace_items(codes, values);
+      if (atoi(lk.get()) != 0)
+        lk.reset();
+    }  
+  }
+  return TRUE;
+} 
+
+bool TRicalcolo_mask::key_handler(TMask_field& f, KEY k)
+{             
+  if (k == K_SPACE)
+  {                           
+    TRicalcolo_mask& m = (TRicalcolo_mask&)f.mask();
+    const int cur_key = atoi(f.get());
+    TToken_string& key_expr = m.get_key_expr(cur_key);
+    const bool empty = key_expr.empty_items();
+    
+    TSheet_field& sheet = (TSheet_field&)m.field(F_FIELDS);
+    TString_array& sa = sheet.rows_array();
+    sa.destroy();                     
+    if (empty)
+    {
+      for (int i = 4; i >= 0; i--)
+        sa.add("");
+    }  
+    else
+    {  
+      TRelation_description& des = (TRelation_description&)m._des[m._cur_file];
+      for (TString field = key_expr.get(0); field.not_empty(); field = key_expr.get())
+      {
+        const int r = sa.add(field);
+        sa.row(r).add(des.get_field_description(field), F_DESCR-F_FIELD);
+      }  
+    }    
+    sheet.force_update();
+  }
+  return TRUE;
+}
+
+bool TRicalcolo_mask::filter_handler(TMask_field& f, KEY k)
+{  
+  bool ok = TRUE;
+  if (f.to_check(k))
+  { 
+    TString filter(f.get()); filter.strip("\n");
+    TExpression expr(_strexpr);
+    ok = expr.set(filter, _strexpr);
+    if (ok)
+    {    
+      TRicalcolo_mask& m = (TRicalcolo_mask&)f.mask();
+      const TRectype& rec = m.get_rec();
+      TString var;
+      for (int v = expr.numvar()-1; v >= 0; v--)
+      {
+        var = expr.varname(v); var.upper();
+        ok = rec.exist(var);
+        if (!ok)
+        {       
+          f.error_box("Il campo '%s' non esiste!", (const char*)var);
+          break;
+        }
+      }
+    }
+    else
+      f.error_box("Simbolo non riconosciuto: '%s'", expr.last_compiled_token());
+  }
+  return ok;
+}
+
+bool TRicalcolo_mask::field_handler(TMask_field& f, KEY k)
+{     
+  bool ok = TRUE;      
+  switch (k)
+  {       
+  case K_TAB:
+  case K_ENTER:
+    if (!f.empty() && f.to_check(k))
+    {
+      TRicalcolo_mask& m = (TRicalcolo_mask&)f.mask().get_sheet()->mask();
+      const TRectype& rec = m.get_rec();        
+      const char* field = f.get();
+      if (!rec.exist(field))
+        ok = f.error_box("Il campo %s non esiste!", field);
+    }
+    break;
+  case K_F9:
+    {                                                      
+      TMask& m = f.mask();
+      TRicalcolo_mask& rm = (TRicalcolo_mask&)m.get_sheet()->mask();
+      TRelation_description& rd = (TRelation_description&)rm._des[rm._cur_file];
+      if (rd.choose_field(f.get()))
+      {
+        f.set(rd.field_name());
+        m.set(F_DESCR, rd.field_desc());
+      }  
+    }
+    break;
+  default:
+    break;
+  }
+  return ok;
+}
+
+bool TRicalcolo_mask::fromto_handler(TMask_field& f, KEY k)
+{
+  bool ok = TRUE;
+  if (f.to_check(k))
+  {                        
+    const TMask& m = f.mask();
+    const TString& field = m.get(F_FIELD);
+    if (field.not_empty())
+    {
+      TRicalcolo_mask& rm = (TRicalcolo_mask&)m.get_sheet()->mask();
+      const TRectype& rec = rm.get_rec();        
+      const int max = rec.length(field);
+      if (f.get().len() > max)
+      {
+        TString msg(32); msg = "Inserire al massimo ";
+        if (max > 1) msg << max; else msg << "un";
+        msg << " caratter" << (max > 1 ? 'i' : 'e') << '.';
+        ok = f.error_box(msg); 
+      }                   
+    }  
+  }
+  return ok;   
+}
+
+///////////////////////////////////////////////////////////
+// Ricalcolo di magazzino
+///////////////////////////////////////////////////////////
+
+class TRicalcola_application : public TApplication
+{ 
+  virtual bool menu(MENU_TAG);
+  virtual bool create();
+  
+public:
+  TRicalcola_application() { }
+  virtual ~TRicalcola_application() { }
+};
+
+bool TRicalcola_application::create()
+{
+  dispatch_e_menu(MENU_ITEM(1));
+  return TRUE;
+}
+
+bool TRicalcola_application::menu(MENU_TAG)
+{
+  TRicalcolo_mask m;
+  while (m.run() == K_ENTER)
+  {
+    TString filter = m.get(F_FILTER); filter.strip("\n");
+    
+    int key = m.get_int(F_KEY);
+    
+    TRectype start(m.get_rec()), stop(m.get_rec());
+    start.zero(); stop.zero(); 
+    
+    TToken_string& key_des = m.get_key_expr(key);
+    
+    TSheet_field& fs = (TSheet_field&)m.field(F_FIELDS);
+    TString field, val;
+    for (int r = 0; r < fs.items(); r++)
+    { 
+      TToken_string& row = fs.row(r);
+      field = row.get(0);
+      if (field.not_empty())
+      {
+        if (key > 0 && key_des.get_pos(field) >= 0)
+        {
+          val = row.get();
+          if (val.not_empty()) start.put(field, val);
+          val = row.get();
+          if (val.not_empty()) stop.put(field, val);
+        }
+        else
+        {
+          val = row.get();
+          if (val.not_empty()) 
+          {
+            if (filter.not_empty()) filter << "&&";
+            filter << '(' << field << ">=" <<  val << ')';
+          }  
+          val = row.get();
+          if (val.not_empty())
+          {
+            if (filter.not_empty()) filter << "&&";
+            filter << '(' << field << "<=" <<  val << ')';
+          }  
+        }
+      }  
+    }
+    
+    if (key <= 0) 
+      key = 1;   
+    
+    TSheet_field& osf = (TSheet_field&)m.field(F_OUTPUTS);
+    TCursor cur(&m.get_rel(), filter, key, 
+                start.empty() ? NULL : &start, stop.empty() ? NULL : &stop);
+    elabora(cur, osf.rows_array());
+  }
+  return FALSE;
+}
+
+int ve4100(int argc, char* argv[])
+{              
+  TRicalcola_application r;
+  r.run(argc, argv, "Ricalcolo valori");
+  return 0;
+}

ve/ve4100.h

@@ -0,0 +1,17 @@
+// Maschera principale
+#define F_FILE     101
+#define F_KEY      102
+#define F_FIELDS   103
+#define F_FILTER   104
+#define F_OUTPUTS  105
+#define F_SAVE     106
+ 
+// Primo sheet 
+#define F_FIELD    101
+#define F_FROM     102
+#define F_TO       103
+#define F_DESCR    104
+
+// Secondo sheet 
+#define F_CODFORM  102
+#define F_FORMULA  103

ve/ve4100.uml

@@ -0,0 +1,169 @@
+#include "ve4100.h"
+
+TOOLBAR "" 0 20 80 3
+
+BUTTON DLG_OK 10 2
+BEGIN
+  PROMPT -12 -11 ""
+END
+
+BUTTON DLG_QUIT 10 2
+BEGIN
+  PROMPT -22 -11 ""
+END
+
+ENDPAGE
+
+PAGE "Ricalcolo valori magazzino" -1 -1 78 16
+
+GROUPBOX DLG_NULL 76 12
+BEGIN
+  PROMPT 1 1 "Archivio da elaborare"
+END
+
+LIST F_FILE 32
+BEGIN
+  PROMPT 2 2 "File    "
+  ITEM "0|Anagrafica magazzino"
+  ITEM "1|Codici corrispondenti"
+  ITEM "2|Unita' di misura"
+  ITEM "3|Descrizioni in lingua"
+  ITEM "4|Condizioni di vendita"
+  ITEM "5|Righe condizioni di vendita"
+END         
+
+LIST F_KEY 10
+BEGIN
+  PROMPT 56 2 "Chiave "
+  ITEM "0|Nessuna"
+  ITEM "1|Chiave 1"
+END
+
+SPREADSHEET F_FIELDS 74 5
+BEGIN  
+  PROMPT 2 3 ""
+  ITEM "Campo@10"
+  ITEM "Da@30"
+  ITEM "A@30"
+  ITEM "Descrizione campo@50"
+END
+
+MEMO F_FILTER 74 3
+BEGIN
+  PROMPT 2 9 "Espressione del filtro:"
+END
+
+GROUPBOX DLG_NULL 76 7
+BEGIN
+  PROMPT 1 13 "Campi da calcolare"
+END
+
+SPREADSHEET F_OUTPUTS 74 4
+BEGIN
+  PROMPT 2 14 ""
+  ITEM "Campo@10"
+  ITEM "Codice"
+  ITEM "Formula@60"
+  ITEM "Descrizione campo@50"
+END
+
+RADIOBUTTON F_SAVE 74
+BEGIN
+  PROMPT 2 17 ""
+  ITEM " |Visualizza senza registrare"
+  ITEM "X|Registra risultati"
+  FLAGS "Z"
+END
+
+ENDPAGE
+
+ENDMASK
+
+PAGE "Fields" -1 -1 60 6
+
+STRING F_FIELD 10
+BEGIN
+  PROMPT 1 1 "Campo "
+  FLAGS "BU"
+END
+
+STRING F_DESCR 70 50
+BEGIN
+  PROMPT 6 2 ""
+  FLAGS "D"
+END
+
+
+STRING F_FROM 50
+BEGIN
+  PROMPT 1 3 "Da    "
+END
+
+STRING F_TO 50
+BEGIN
+  PROMPT 1 4 "A     "
+END           
+
+BUTTON DLG_OK 10 2
+BEGIN
+  PROMPT -12 -1 ""
+END
+
+BUTTON DLG_CANCEL 10 2
+BEGIN
+  PROMPT -22 -1 ""
+END
+
+ENDPAGE
+
+ENDMASK
+
+PAGE "Outputs" -1 -1 60 6
+
+STRING F_FIELD 10
+BEGIN
+  PROMPT 1 1 "Campo "
+  FLAGS "BU"
+END
+
+STRING F_DESCR 70 50
+BEGIN
+  PROMPT 6 2 ""
+  FLAGS "D"
+END
+
+STRING F_CODFORM 6
+BEGIN
+  PROMPT 1 3 "" 
+  USE %FRM
+  INPUT CODTAB F_CODFORM
+  DISPLAY "Codice" CODTAB
+  DISPLAY "Descrizione@50" S0
+  OUTPUT F_CODFORM CODTAB
+  OUTPUT F_FORMULA S1+S2
+  CHECKTYPE SEARCH
+END
+
+STRING F_FORMULA 120 50
+BEGIN
+  PROMPT 1 4 ""
+END
+
+BUTTON DLG_OK 10 2
+BEGIN
+  PROMPT -13 -1 ""
+END
+
+BUTTON DLG_DELREC 10 2
+BEGIN
+  PROMPT -23 -1 ""
+END
+
+BUTTON DLG_CANCEL 10 2
+BEGIN
+  PROMPT -33 -1 ""
+END
+
+ENDPAGE
+
+ENDMASK

ve/ve6200.cpp

@@ -1,5 +1,6 @@
 #include <applicat.h>
 #include <mask.h>
+#include <progind.h>
 #include <urldefid.h>
 
 #include "velib01.h" 
@@ -45,6 +46,8 @@ bool TFatturazione_bolle_app::menu(MENU_TAG)
   TMask m("ve6000");
   while (m.run() == K_ENTER)
   {                              
+    TIndwin iw(48, "Inizializzazione ...", TRUE, FALSE, 48);
+  
     begin_wait();
   
     const TDate data_elab = m.get(F_DATA_ELAB); 
@@ -67,22 +70,40 @@ bool TFatturazione_bolle_app::menu(MENU_TAG)
     
     TLista_clienti clienti;
     const int tot_cli = clienti.leggi(dc, ac, da, aa, dz, az);
-    for (int c = 0; c < tot_cli; c++)
+    
+    TString msg(80);
+    for (int c = 0; c < tot_cli && !iw.iscancelled(); c++)
     { 
-      TLista_documenti din, dout;
+      const long codcli = clienti[c];     // Codice cliente in esame
-      din.read('C', clienti[c], anno, dd, ad, codnum, dn, an);
+      msg = "Elaborazione dei documenti del cliente "; 
-      const bool ok = eld.elabora(din, dout, data_elab);
+      msg << codcli << " ...";
+      iw.set_text(msg);                   // Messaggio sul cliente
+      do_events();                        // Attende visualizzazione
+      
+      TLista_documenti din, dout;         // Legge tutti i documenti di input
+      din.read('C', codcli, anno, dd, ad, codnum, dn, an);
+      
+      // Crea documenti di output
+      bool ok = eld.elabora(din, dout, data_elab);
       if (ok) 
       {
-        din.rewrite();
+        int err = dout.write();     // Scrive documenti di output
-        dout.write();
+        if (err == NOERR)
+        {
+          err = din.rewrite();      // Aggiorna stato dei documenti di input
+          if (err != NOERR)
+            ok = error_box("Errore %d durante la scrittura dei documenti raggruppati!", err);
+        }
+        else
+          ok = error_box("Errore %d durante l'aggiornamento dei documenti da raggruppare!", err);
       }
       else
       {
-        error_box("I documenti relativi al cliente %ld non sono stati elaborati.",
+        ok = error_box("I documenti relativi al cliente %ld non sono stati elaborati.",
-                  clienti[c]);
+                       codcli);
-        break;
       }  
+      if (!ok)   // In case di errore ...
+        break;   // ... termina qui l'elaborazione.
     }
     end_wait();
   }

ve/velib01.cpp

@@ -160,6 +160,7 @@ bool TRiga_documento::sola_descrizione() const
 
 void TRiga_documento::forza_sola_descrizione() 
 {     
+  // In realta' il test serve anche a caricare la lista dei tipi riga!
   if (tipo().tipo() != 'D')
   {
     _tipi.restart();
@@ -352,7 +353,7 @@ int TDocumento::remove() const
 
 const bool TDocumento::in_valuta()
 {
-  TString16 val(valuta());
+  const TString& val = valuta();
   return (val.not_empty() && val != "LIT");
 }
 
@@ -540,16 +541,12 @@ bool TLista_clifo::TClifo::read(char tipo, long cod)
   return ok();  
 }
 
-TLista_clifo::TClifo::TClifo(const TRectype& rec, const TRectype& ven)
+TLista_clifo::TClifo::TClifo(const TRectype& rec)
 {
-  if (!ven.empty())
+  CHECK(rec.num() == LF_CLIFO, "Record non clienti");
-    init(rec, ven);
+  const char tipo = rec.get_char(CLI_TIPOCF);
-  else  
+  const long codice = rec.get_long(CLI_CODCF);
-  {
+  read(tipo, codice);
-    const char tipo = rec.get_char(CLI_TIPOCF);
-    const long codice = rec.get_long(CLI_CODCF);
-    read(tipo, codice);
-  }
 }
 
 int TLista_clifo::leggi(long dc, long ac, long da, long aa, long dz, long az)
@@ -587,9 +584,11 @@ int TLista_clifo::leggi(long dc, long ac, long da, long aa, long dz, long az)
   }  
   
   TCursor cur(&clifo, filter, 1, &start, &stop);
+  const TRectype& cli = cur.curr();
+  const TRectype& ven = cur.curr(LF_CFVEN);
   for (cur = 0; cur.ok(); ++cur)
   {
-    TClifo* c = new TClifo(cur.curr(), cur.curr(LF_CFVEN));
+    TClifo* c = new TClifo(cli, ven);
     _clifo.add(c);
   }
   

ve/velib01.h

@@ -118,7 +118,7 @@ public:
   long numero() const { return get_long("NDOC"); }
   TDate data() const { return get_date("DATADOC"); }
   const bool in_valuta();
-  const TString & valuta() { return get("CODVAL"); }
+  const TString& valuta() { return get("CODVAL"); }
   const real cambio() { return get_real("CAMBIO"); }
   const TTipo_documento& tipo() const;                  
   
@@ -184,7 +184,8 @@ class TLista_clifo : public TObject
   
     TClifo() { zero(); }
     TClifo(char tipo, long cod) { read(tipo, cod); }
-    TClifo(const TRectype& rec, const TRectype& ven);
+    TClifo(const TRectype& rec, const TRectype& ven) { init(rec, ven); }
+    TClifo(const TRectype& rec);
     virtual ~TClifo() { }
   };