Patch level :2.2 nopatch

Files correlati     :cacnv and friends
Ricompilazione Demo : [ ]
Commento            :
Aggiunta conversione da MOV RMOV a MOVANA RMOVANA


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

ca/cacnv.cpp

@@ -4,124 +4,145 @@
 #include <tabutil.h>
 #include <utility.h>
 
-#define usage "Errore - uso : cacnv [1|2|3] ditta"
+#include <mov.h>
+#include <rmov.h>
 
+#include "../cg/cg2101.h"
+#include "calib01.h"
 
+#include "movana.h"
+#include "rmovana.h"
+
+#include "cacnva.h"
+
+#define usage "Errore - uso : cacnv [0|1]"
+
+//--------------------------------------------------------------
+//    IMPORTO DESCRITTO (utilizzato nella conversione movimenti)
+//--------------------------------------------------------------
+class TImporto_descritto : public TImporto
+{
+  TString _descr;
+public:
+  const TString& descrizione() const {return _descr;}
+  TImporto_descritto(const char* descr) : _descr(descr) {}
+};
+
+//----------------------------------------------------------
+//    MASCHERA COVERSIONE MOVIMENTI
+//----------------------------------------------------------
+class TConversione_anal_msk : public TAutomask
+{
+protected:
+  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
+
+public:
+  TConversione_anal_msk() : TAutomask("cacnva") {}
+};
+
+bool TConversione_anal_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
+{ 
+//  switch (o.dlg())
+//  {
+//  default: break;
+//  }  
+  return TRUE;
+}
 //----------------------------------------------------------
 //    APPLICAZIONE
 //----------------------------------------------------------
 
 class TConversione_cm2ca : public TSkeleton_application
 {
-
   int _nconv;
-  long _codditta;
-  long _oldditta;
 
 protected:
   virtual void main_loop();
+  void create_new_movana(long numreg_cg);
 
 public:
   bool convert_clerks();
   bool convert_phases();
   bool set_anal();
+  bool convert_movs();
 
-  TConversione_cm2ca() : _oldditta(0), _codditta(0) {}
+  TConversione_cm2ca() {}
   ~TConversione_cm2ca() {}
 };
 
 //gestione del menu (vari tipi di conversione)
 void TConversione_cm2ca::main_loop()
 {
-  _nconv = 0;
+  _nconv = abs(atoi(argv(1)));
-  if (argc() > 2)
-  {
-    _nconv = abs(atoi(argv(1)));
-    if (_nconv > 0) //se ha una chiamata valida di menu...
-    {
-      _oldditta = get_firm();
-      _codditta = atol(argv(2));
-      if (_codditta != _oldditta) 
-      {
-        if (_codditta == 0) 
-          error_box(TR("Selezionare una ditta"));
-        else 
-          set_firm(_codditta);
-      }
-    }
-  }
 
   switch (_nconv)
   {
-  case 1:
+  case 0:
     {
-      if (_codditta > 0)
+        if (set_anal()) //setta il flag anal nel pcon
-        convert_clerks(); //da tabella cms a commesse
+        {
+          convert_clerks(); //da tabella cms a commesse
+          convert_phases(); //da tabella fsc a fasi
+        }
     }
     break;
-  case 2:
+  case 1:
     {
-      if (_codditta > 0)
+      convert_movs(); //converte i movimenti di contabilita' (da CG a CA)
-        convert_phases(); //da tabella fsc a fasi
-      break;
-    }
-  case 3:
-    {
-      if (_codditta > 0)
-        set_anal(); //setta il flag anal nel pcon
       break;
     }
   default:
     break;
   }
-
-  if (_nconv > 1 && _codditta != _oldditta)
-  {
-    if (_oldditta == 0) 
-      prefix().set("com");
-    else 
-      set_firm(_oldditta);
-  }
 }
 
 bool TConversione_cm2ca::convert_clerks()
 {
   TLocalisamfile commesse(LF_COMMESSE); //la conversione blocca in automatico gli altri utenti
-                                        //non e' necessario un TSystemisamfile con _excllock
+                                      //non e' necessario un TSystemisamfile con _excllock
   const long items = commesse.items();
   //trasferimento dati possibile solo se il file di destinazione e' vuoto
   if (items > 0)
-    return error_box(TR("File delle commesse non vuoto!"));
-  else
   {
-    TRelation relcms("CMS");
+    if (yesno_box(TR("File delle commesse non vuoto!\nSi desidera azzerarlo?")))
-    TCursor curcms(&relcms);
+      if (yesno_box(TR("File delle commesse non vuoto!\nSi desidera veramente azzerarlo?")))
-    const TRectype& cms = relcms.curr();
+      {
-    const long nrectab = curcms.items();
+        TSystemisamfile cms(LF_COMMESSE); //sono zappabili solo i Systemisamfiles
-    curcms.freeze();
+        cms.zap();
-    TRectype& commesse_rec = commesse.curr();
+      }
-    TProgind pi(nrectab, "Conversione tabella commesse");
+      else
-    for (curcms = 0; curcms.pos() < nrectab; ++curcms)
+        return true;
-    {
+    else
-      pi.addstatus(1);
+      return true;
-      commesse_rec.zero();  //azzerare il record prima di cominciare...
-      commesse_rec.put("CODCMS", cms.get("CODTAB"));
-      commesse_rec.put("DESCRIZ", cms.get("S0"));
-      commesse_rec.put("CODCF", cms.get("I0"));
-      commesse_rec.put("REGIVA", cms.get("S7"));
-      commesse_rec.put("PRORATA", cms.get("B4"));
-      commesse_rec.put("PUBBLICA", cms.get("B0"));
-      commesse_rec.put("RENDIC", cms.get("B1"));
-      commesse_rec.put("DATAINIZIO", cms.get("D0"));
-      commesse_rec.put("DATAFINE", cms.get("D1"));
-      commesse_rec.put("CHIUSA", cms.get("B3"));
-      commesse_rec.put("PROROGA", cms.get("B2"));
-      commesse_rec.put("CODRESP", cms.get("S4"));
-
-      commesse.write();
-    }
-    return true;
   }
+
+  TRelation relcms("CMS");
+  TCursor curcms(&relcms);
+  const TRectype& cms = relcms.curr();
+  const long nrectab = curcms.items();
+  curcms.freeze();
+  TRectype& commesse_rec = commesse.curr();
+  TProgind pi(nrectab, "Conversione tabella commesse");
+  for (curcms = 0; curcms.pos() < nrectab; ++curcms)
+  {
+    pi.addstatus(1);
+    commesse_rec.zero();  //azzerare il record prima di cominciare...
+    commesse_rec.put("CODCMS", cms.get("CODTAB"));
+    commesse_rec.put("DESCRIZ", cms.get("S0"));
+    commesse_rec.put("CODCF", cms.get("I0"));
+    commesse_rec.put("REGIVA", cms.get("S7"));
+    commesse_rec.put("PRORATA", cms.get("B4"));
+    commesse_rec.put("PUBBLICA", cms.get("B0"));
+    commesse_rec.put("RENDIC", cms.get("B1"));
+    commesse_rec.put("DATAINIZIO", cms.get("D0"));
+    commesse_rec.put("DATAFINE", cms.get("D1"));
+    commesse_rec.put("CHIUSA", cms.get("B3"));
+    commesse_rec.put("PROROGA", cms.get("B2"));
+    commesse_rec.put("CODRESP", cms.get("S4"));
+
+    commesse.write();
+   }
+   return true;
 }
 
 bool TConversione_cm2ca::convert_phases()
@@ -129,26 +150,36 @@ bool TConversione_cm2ca::convert_phases()
   TLocalisamfile fasi(LF_FASI);
   const long items = fasi.items();
   if (items > 0)
-    return error_box(TR("File delle fasi non vuoto!"));
-  else
   {
-    TRelation relfsc("FSC");
+    if (yesno_box(TR("File delle fasi non vuoto!\nSi desidera azzerarlo?")))
-    TCursor curfsc(&relfsc);
+      if (yesno_box(TR("File delle fasi non vuoto!\nSi desidera veramente azzerarlo?")))
-    const TRectype& fsc = relfsc.curr();
+      {
-    const long nrectab = curfsc.items();
+        TSystemisamfile fsc(LF_FASI);
-    curfsc.freeze();
+        fsc.zap();
-    TRectype& fasi_rec = fasi.curr();
+      }
-    TProgind pi(nrectab, "Conversione tabella fasi");
+      else
-    for (curfsc = 0; curfsc.pos() < nrectab; ++curfsc)
+        return true;
-    {
+    else
-      pi.addstatus(1);
+      return true;
-      fasi_rec.zero();
-      fasi_rec.put("CODFASE", fsc.get("CODTAB"));
-      fasi_rec.put("DESCRIZ", fsc.get("S0"));
-      fasi.write();
-    }
-    return true;
   }
+
+  TRelation relfsc("FSC");
+  TCursor curfsc(&relfsc);
+  const TRectype& fsc = relfsc.curr();
+  const long nrectab = curfsc.items();
+  curfsc.freeze();
+  TRectype& fasi_rec = fasi.curr();
+  TProgind pi(nrectab, "Conversione tabella fasi");
+  for (curfsc = 0; curfsc.pos() < nrectab; ++curfsc)
+  {
+    pi.addstatus(1);
+    fasi_rec.zero();
+    fasi_rec.put("CODFASE", fsc.get("CODTAB"));
+    fasi_rec.put("DESCRIZ", fsc.get("S0"));
+    fasi.write();
+  }
+  return true;
+
 }
 
 bool TConversione_cm2ca::set_anal()
@@ -177,6 +208,131 @@ bool TConversione_cm2ca::set_anal()
   }
 }
 
+void TConversione_cm2ca::create_new_movana(long numreg_cg)
+{
+  TAnal_mov analmov;
+  //riempie le righe di testata
+  TMovimentoPN mov;
+  TRectype& mov_head = mov.curr();
+  mov_head.put(MOV_NUMREG, numreg_cg);
+  mov.read();
+
+  analmov.put(MOVANA_ANNOES, mov_head.get(MOV_ANNOES));
+  analmov.put(MOVANA_DATAREG, mov_head.get(MOV_DATAREG));
+  analmov.put(MOVANA_DATACOMP, mov_head.get(MOV_DATACOMP));
+  analmov.put(MOVANA_DATADOC, mov_head.get(MOV_DATADOC));
+  analmov.put(MOVANA_NUMREGCG, mov_head.get(MOV_NUMREG));
+  analmov.put(MOVANA_NUMDOC, mov_head.get(MOV_NUMDOC));
+  analmov.put(MOVANA_TIPODOC, mov_head.get(MOV_TIPODOC));
+  analmov.put(MOVANA_DESCR, mov_head.get(MOV_DESCR));
+  analmov.put(MOVANA_CODCAUS, mov_head.get(MOV_CODCAUS));
+  analmov.put(MOVANA_TIPOMOV, ""); //deve mettere sempre 0
+  //MOVANA_TOTDOC e' il totale di tutte le sue righe;ancora non si conosce
+
+  //deve scorrere tutte le righe del movimento e sommare gli importi di quelle che hanno la
+  //stessa chiave CODCMS+CODFSC
+  TAssoc_array righe_cms;
+  TToken_string chiave;
+  //scansione righe movimentoPN 
+  for (int l = 0;  l < mov.cg_items(); l++)
+  {
+    const TRectype& rmov = mov.cg(l);
+    chiave = "";
+    chiave.add(rmov.get(RMV_CODCMS));
+    chiave.add(rmov.get(RMV_FASCMS));
+    if (!chiave.empty_items() && rmov.get(RMV_ROWTYPE) != "T")
+    {
+      //alla chiave va aggiunto il vecchio gr/co/stc
+      TString16 conto_cg;
+      conto_cg.format("%03d%03d%06ld", rmov.get_int(RMV_GRUPPO), rmov.get_int(RMV_CONTO), rmov.get_long(RMV_SOTTOCONTO));
+      chiave.add(conto_cg);
+      TImporto_descritto* importo = (TImporto_descritto*)righe_cms.objptr(chiave);
+      if (importo == NULL)  //la chiave non esisteva nell'assoc
+      {
+        importo = new TImporto_descritto(rmov.get(RMV_DESCR)) ;
+        righe_cms.add(chiave, importo);
+      }
+      const char sezione = rmov.get_char(RMV_SEZIONE);
+      const real valore = rmov.get(RMV_IMPORTO);
+      *importo += TImporto(sezione, valore);  //crea un importo e lo somma a quello dell'array
+    }
+  }
+  //scansione dell Assoc_array che adesso contiene le nuove righe del movimento di analitica
+  TImporto importone;
+  FOR_EACH_ASSOC_OBJECT(righe_cms, h, k, a)
+  {
+    TRectype& analriga = analmov.new_row();
+    analriga.put(RMOVANA_ANNOES, analmov.get(MOVANA_ANNOES));
+    analriga.put(RMOVANA_DATAREG, analmov.get(MOVANA_DATAREG));
+
+    //deve prendere la sezione dell'importo di ogni riga
+    TImporto_descritto* importo = (TImporto_descritto*)a;
+    importo->normalize();
+    analriga.put(RMOVANA_SEZIONE, importo->sezione());
+    analriga.put(RMOVANA_IMPORTO, importo->valore());
+    analriga.put(RMOVANA_DESCR, importo->descrizione());
+
+    importone += *importo;
+    
+    chiave = k;
+    analriga.put(RMOVANA_CODCMS, chiave.get(0));
+    analriga.put(RMOVANA_CODFASE, chiave.get(1));
+    analriga.put(RMOVANA_CODCONTO, chiave.get(2));
+
+  }
+  //e alla fine riesce a mettere anche l'importone in testata
+  importone.normalize();  //x evitare problemi di segno...
+  analmov.put(MOVANA_SEZIONE, importone.sezione());
+  analmov.put(MOVANA_TOTDOC, importone.valore());
+
+  analmov.write();
+}
+
+bool TConversione_cm2ca::convert_movs()
+{
+  TConversione_anal_msk msk;
+  msk.run();
+  //scandisce il file RMOV,alla ricerca dei record con codice fase o codice commessa compilato
+  TRelation rel_rmov(LF_RMOV);
+  //costruzione filtro con date (in caso di conversione provvisoria)
+  TString filtro;
+  filtro << "((CODCMS!='')||(FASCMS!=''))&&(ROWTYPE!='T')";
+  if (msk.get_int(F_TIPOCONV) == 0)
+  {
+    const TDate dataini = msk.get_date(F_DATAINI);
+    if (dataini.ok())
+      filtro << "&&(ANSI(DATAREG)>=" << dataini.string(ANSI) << ")";
+    const TDate datafin = msk.get_date(F_DATAFIN);
+    if (datafin.ok())
+      filtro << "&&(ANSI(DATAREG)<=" << datafin.string(ANSI) << ")";
+  }
+  
+  TCursor cur_rmov(&rel_rmov, filtro);
+  TRectype& rec_rmov = rel_rmov.curr();
+  const long rmov_items = cur_rmov.items();
+  if (rmov_items > 0)
+  {
+    cur_rmov.freeze();
+    TProgind pi(rmov_items, "Trasferimento righe movimenti", false);
+
+    long last_numreg_cg = 0;  //numero registrazione originaria
+    for (cur_rmov = 0; cur_rmov.pos() < rmov_items; ++cur_rmov)
+    {
+      pi.addstatus(1);
+      const long curr_numreg_cg = rec_rmov.get_long(RMV_NUMREG);
+      if (curr_numreg_cg != last_numreg_cg)
+      {
+        //se il numreg di questa riga e' nuovo -> crea un nuovo movimento di analitica (testata)
+        create_new_movana(curr_numreg_cg);
+        last_numreg_cg = curr_numreg_cg;
+      }
+
+    }
+  }
+
+  return true;
+}
+
 ///////////////////////////////////////////////////////////
 // Programma di conversione da CM a CA
 ///////////////////////////////////////////////////////////
@@ -184,7 +340,7 @@ bool TConversione_cm2ca::set_anal()
 int main(int argc,char** argv)
 {
   TConversione_cm2ca a;
-  a.run(argc,argv, "Trasferimento dati tabelle CM");
+  a.run(argc,argv, "Trasferimento dati da CG a CA");
 
   return 0;
 }

ca/cacnva.h

@@ -0,0 +1,4 @@
+// campi maschera cacnva.uml
+#define F_TIPOCONV    101
+#define F_DATAINI     102
+#define F_DATAFIN     103

ca/cacnva.uml

@@ -0,0 +1,41 @@
+#include "cacnva.h"
+
+TOOLBAR "" 0 -3 0 3
+
+BUTTON DLG_OK 10 2
+BEGIN
+  PROMPT -12 -11 ""
+END
+
+BUTTON DLG_QUIT 10 2
+BEGIN
+  PROMPT -22 -11 ""
+END
+
+ENDPAGE    
+
+PAGE "Conversione movimenti contabili" 0 0 64 12
+
+RADIOBUTTON F_TIPOCONV 36
+BEGIN
+  PROMPT 1 2 "@bTipo conversione"
+  ITEM "0|Provvisoria"
+  MESSAGE ENABLE,F_DATAINI|ENABLE,F_DATAFIN
+  ITEM "1|Definitiva"
+  MESSAGE CLEAR,F_DATAINI|CLEAR,F_DATAFIN
+  FLAGS "Z"
+END
+
+DATA F_DATAINI
+BEGIN
+  PROMPT 2 6 "Da data "
+END
+
+DATA F_DATAFIN
+BEGIN
+  PROMPT 2 7 "A data  "
+END 
+
+ENDPAGE
+
+ENDMASK

ca/calib01.cpp

@@ -914,3 +914,21 @@ bool TAnal_app::user_destroy()
     delete _rel;
   return true;
 }
+
+
+///////////////////////////////////////////////////////////
+// TAnal_mov
+///////////////////////////////////////////////////////////
+
+int TAnal_mov::read(long numreg, word lock)
+{
+  put("NUMREG", numreg);
+  return TMultiple_rectype::read(_isequal, lock);
+}
+
+TAnal_mov::TAnal_mov(long numreg) : TMultiple_rectype(LF_MOVANA)
+{
+  add_file(LF_RMOVANA, "NUMRIG");
+  if (numreg > 0)
+    read (numreg);
+}

ca/calib01.h

@@ -5,6 +5,10 @@
 #include <automask.h>
 #endif
 
+#ifndef __MULTIREC_H
+#include <multirec.h>
+#endif
+
 #ifndef __RELAPP_H
 #include <relapp.h>
 #endif
@@ -99,4 +103,18 @@ protected:
   virtual TRelation* create_relation() const;
 };
 
+
+///////////////////////////////////////////////////////////
+// TAnal_mov
+///////////////////////////////////////////////////////////
+
+class TAnal_mov : public TMultiple_rectype
+{
+public:
+  int read(long numreg, word lockop = _nolock);
+
+  //costruttore
+  TAnal_mov(long numreg = 0);
+};
+
 #endif

ca/f107.dir

@@ -1,3 +1,3 @@
 107
 0
-$movana|0|0|168|0|Movimenti di Analitica|||
+$movana|0|0|125|0|Movimenti di Analitica|||

ca/f107.trr

@@ -1,5 +1,5 @@
 107
-16
+13
 ANNOES|9|4|0|Codice esercizio
 NUMREG|3|7|0|Numero di operazione
 DATAREG|5|8|0|Data operazione
@@ -11,11 +11,8 @@ TIPODOC|1|2|0|Tipo documento
 DESCR|1|50|0|Descrizione
 CODCAUS|1|3|0|Codice causale contabile
 TIPOMOV|1|1|0|Tipo movimento < >Normale, <P>reventivo, <V>ariazione preventivo
-CODVAL|1|3|0|Codice valuta
+SEZIONE|1|1|0|Sezione
-DATACAM|5|8|0|Data del cambio
-CAMBIO|4|15|6|Cambio della valuta
 TOTDOC|4|18|3|Totale documento
-TOTDOCVAL|4|18|3|Totale documento in valuta
 2
 NUMREG| 
 DATAREG+NUMREG|X

ca/f108.dir

@@ -1,3 +1,3 @@
 108
 0
-$rmovana|0|0|163|0|Righe Movimenti di Analitica|||
+$rmovana|0|0|233|0|Righe Movimenti di Analitica|||

ca/f108.trr

@@ -1,17 +1,21 @@
 108
-12
+16
 ANNOES|9|4|0|Anno di Esercizio
 NUMREG|3|7|0|Numero di Registrazione
 NUMRIG|2|3|0|Numero riga
 SEZIONE|1|1|0|Sezione
 DATAREG|5|8|0|Data di registrazione
-CODCCOSTO|1|20|0|Codice cetro di costo
+CODCCOSTO|1|20|0|Codice centro di costo
 CODCMS|1|20|0|Codice commessa
-CODFASE|1|10|0|Codice Fase
+CODFASE|1|10|0|Codice fase
 CODCONTO|1|20|0|Codice Conto Analitica
 DESCR|1|50|0|Descrizione
 IMPORTO|4|18|3|Importo della riga
-ROWTYPE|1|1|0|Tipo Riga ??
+ROWTYPE|1|1|0|Tipo Riga
+CODCCORI|1|20|0|Codice centro di costo originario
+CODCMSORI|1|20|0|Codice commessa originario
+CODFASEORI|1|10|0|Codice fase originario
+CODCONTORI|1|20|0|Codice conto originario
 2
 NUMREG+NUMRIG| 
-CODCCOSTO+CODCMS+GRUPPOC+DATAREG+NUMREG+NUMRIG|X
+CODCCOSTO+CODCMS+DATAREG+NUMREG+NUMRIG|X

ca/movana.h

@@ -0,0 +1,18 @@
+#ifndef __MOVANA_H
+#define __MOVANA_H
+
+#define MOVANA_ANNOES   "ANNOES"
+#define MOVANA_NUMREG   "NUMREG"
+#define MOVANA_DATAREG  "DATAREG"
+#define MOVANA_DATACOMP "DATACOMP"
+#define MOVANA_DATADOC  "DATADOC"
+#define MOVANA_NUMREGCG "NUMREGCG"
+#define MOVANA_NUMDOC   "NUMDOC"
+#define MOVANA_TIPODOC  "TIPODOC"
+#define MOVANA_DESCR    "DESCR"
+#define MOVANA_CODCAUS  "CODCAUS"
+#define MOVANA_TIPOMOV  "TIPOMOV"
+#define MOVANA_SEZIONE  "SEZIONE"
+#define MOVANA_TOTDOC   "TOTDOC"
+
+#endif

ca/rmovana.h

@@ -0,0 +1,21 @@
+#ifndef __RMOVANA_H
+#define __RMOVANA_H
+
+#define RMOVANA_ANNOES      "ANNOES"
+#define RMOVANA_NUMREG      "NUMREG"
+#define RMOVANA_NUMRIG      "NUMRIG"
+#define RMOVANA_SEZIONE     "SEZIONE"
+#define RMOVANA_DATAREG     "DATAREG"
+#define RMOVANA_CODCCOSTO   "CODCCOSTO"
+#define RMOVANA_CODCMS      "CODCMS"
+#define RMOVANA_CODFASE     "CODFASE"
+#define RMOVANA_CODCONTO    "CODCONTO"
+#define RMOVANA_DESCR       "DESCR"
+#define RMOVANA_IMPORTO     "IMPORTO"
+#define RMOVANA_ROWTYPE     "ROWTYPE"
+#define RMOVANA_CODCCORI    "CODCCORI"
+#define RMOVANA_CODCMSORI   "CODCMSORI"
+#define RMOVANA_CODFASEORI  "CODFASEORI"
+#define RMOVANA_CODCONTORI  "CODCONTORI"
+
+#endif