From 137797e17cf3d24c2bf2db99a5ab60ae6d356d0f Mon Sep 17 00:00:00 2001 From: alex Date: Thu, 15 Jul 2004 08:45:25 +0000 Subject: [PATCH] Patch level : 2.1 nopatch Files correlati : Ricompilazione Demo : [ ] Commento : Personalizzazione CRPA git-svn-id: svn://10.65.10.50/trunk@12246 c028cbd2-c16b-5b4b-a496-9718f37d4682 --- crpa/crpa.cpp | 164 +++++++ crpa/crpa.dsp | 103 +++++ crpa/crpa.dsw | 29 ++ crpa/crpa.ini | 103 +++++ crpa/crpa0.cpp | 1081 +++++++++++++++++++++++++++++++++++++++++++++ crpa/pmc.sql | 613 +++++++++++++++++++++++++ crpa/search.cpp | 204 +++++++++ crpa/ts_pmc.sql | 4 + crpa/user_pmc.sql | 8 + 9 files changed, 2309 insertions(+) create mode 100755 crpa/crpa.cpp create mode 100755 crpa/crpa.dsp create mode 100755 crpa/crpa.dsw create mode 100755 crpa/crpa.ini create mode 100755 crpa/crpa0.cpp create mode 100755 crpa/pmc.sql create mode 100755 crpa/search.cpp create mode 100755 crpa/ts_pmc.sql create mode 100755 crpa/user_pmc.sql diff --git a/crpa/crpa.cpp b/crpa/crpa.cpp new file mode 100755 index 000000000..f06196100 --- /dev/null +++ b/crpa/crpa.cpp @@ -0,0 +1,164 @@ +#include +#include + +#include + +#define WINDOWS_EXTRA_LEAN +#include + +#pragma warning(disable : 4786) +#define WIN32COMMON +#include + +using namespace oracle::occi; +using namespace std; + +class campo2pmc +{ + private: + Environment* env; + Connection* conn; + + public: + int executeCommand(const char* command); + int readCommands(const char* filename); + void writeResult(const char* resultfile, int error); + void writeLog(const char* message); + bool getIniParam(const char* name, string& value); + + campo2pmc(); + ~campo2pmc(); +}; + +campo2pmc::campo2pmc(): env(NULL), conn(NULL) +{ + string username, password, connect; + getIniParam("Username", username); + getIniParam("Password", password); + getIniParam("Connect", connect); + try + { + env = Environment::createEnvironment(Environment::DEFAULT); + conn = env->createConnection(username, password, connect); + } + catch (...) + { + conn = NULL; + } +} + +campo2pmc::~campo2pmc() +{ + if (conn != NULL) + env->terminateConnection(conn); + Environment::terminateEnvironment(env); +} + +void campo2pmc::writeLog(const char* message) +{ + ofstream logfile("crpa.log", ios::app); + + char date[128]; + char time[128]; + _strtime(time); + _strdate(date); + logfile << date << ' ' << time << ' ' << message << endl; +} + +void campo2pmc::writeResult(const char* resultfile, int error) +{ + char stringerr[16]; + sprintf(stringerr, "%d", error); + ::WritePrivateProfileString("Transaction", "Error", stringerr, resultfile); + ::WritePrivateProfileString("Transaction", "Result", error ? "ERROR": "OK", resultfile); +} + +bool campo2pmc::getIniParam(const char* name, string& value) +{ + char val[256]; + bool ok = ::GetPrivateProfileString("Oracle", name, "", val, + sizeof(val), "./crpa.ini") != 0; + if (ok) value = val; + return ok; +} + + +int campo2pmc::executeCommand(const char* command) +{ + int err = 0; + if (conn != NULL) + { + Statement* stmt = conn->createStatement(command); + if (stmt != NULL) + { + try + { + stmt->executeUpdate(); + } + catch(SQLException ex) + { + err = ex.getErrorCode(); + OCCI_STD_NAMESPACE::string mess = ex.getMessage(); + char message[1024]; + sprintf(message, "Errore %d: %s nel comando %s", err, mess.c_str(), command); + writeLog(message); + } + conn->terminateStatement(stmt); + } + else + { + char message[1024]; + sprintf(message, "Statement non valido: %s", command); + writeLog(message); + err = -2; + } + } + else + { + writeLog("Connessione non valida"); + err = -1; + } + return err; +} + +int campo2pmc::readCommands(const char* filename) +{ + int err = 0; + ifstream fin(filename); + while ((!fin.eof()) && (err==0)) + { + char line[4096]; + fin.getline(line, sizeof(line), 'æ'); + if (!fin.eof()) + { + strcat(line,"\n"); + err = executeCommand(line); + } + } + if (err != 0) + conn->rollback(); + return err; +} + +void wake_up_caller() +{ + const unsigned int WM_WAKEUP = RegisterWindowMessage("WAKEUP"); + const HANDLE ht = 0; // GetCurrentProcess(); + PostMessage(HWND_BROADCAST, WM_WAKEUP, (WPARAM)ht, 0L); +} + + +int main(int argc, char* argv[]) +{ + const char* commandfile = "crpa.sql"; + const char* resultfile = "./crpasql.ini"; + if (argc > 1) + commandfile = argv[1]; + if (argc > 2) + resultfile = argv[2]; + campo2pmc passa; + int err = passa.readCommands(commandfile); + passa.writeResult(resultfile, err); + wake_up_caller(); + return err; +} \ No newline at end of file diff --git a/crpa/crpa.dsp b/crpa/crpa.dsp new file mode 100755 index 000000000..0e6702092 --- /dev/null +++ b/crpa/crpa.dsp @@ -0,0 +1,103 @@ +# Microsoft Developer Studio Project File - Name="crpa" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Console Application" 0x0103 + +CFG=crpa - Win32 Debug +!MESSAGE This is not a valid makefile. To build this project using NMAKE, +!MESSAGE use the Export Makefile command and run +!MESSAGE +!MESSAGE NMAKE /f "crpa.mak". +!MESSAGE +!MESSAGE You can specify a configuration when running NMAKE +!MESSAGE by defining the macro CFG on the command line. For example: +!MESSAGE +!MESSAGE NMAKE /f "crpa.mak" CFG="crpa - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "crpa - Win32 Release" (based on "Win32 (x86) Console Application") +!MESSAGE "crpa - Win32 Debug" (based on "Win32 (x86) Console Application") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe +RSC=rc.exe + +!IF "$(CFG)" == "crpa - Win32 Release" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "Release" +# PROP Intermediate_Dir "Release" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c +# ADD CPP /nologo /W3 /GX /O2 /I "c:\oracle\ora90\oci\include" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c +# SUBTRACT CPP /YX /Yc /Yu +# ADD BASE RSC /l 0x410 /d "NDEBUG" +# ADD RSC /l 0x410 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 + +!ELSEIF "$(CFG)" == "crpa - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "Debug" +# PROP BASE Intermediate_Dir "Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "Debug" +# PROP Intermediate_Dir "Debug" +# PROP Ignore_Export_Lib 0 +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c +# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "c:\oracle\ora90\oci\include" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FR /FD /GZ /c +# SUBTRACT CPP /X /YX /Yc /Yu +# ADD BASE RSC /l 0x410 /d "_DEBUG" +# ADD RSC /l 0x410 /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib c:\oracle\ora90\oci\lib\msvc\oraocci9.lib /nologo /subsystem:console /debug /machine:I386 /out:"d:\u\cris\v17.aga\exe\crpa.exe" /pdbtype:sept + +!ENDIF + +# Begin Target + +# Name "crpa - Win32 Release" +# Name "crpa - Win32 Debug" +# Begin Group "Source Files" + +# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" +# Begin Source File + +SOURCE=.\Crpa.cpp +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h;hpp;hxx;hm;inl" +# End Group +# Begin Group "Resource Files" + +# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" +# End Group +# End Target +# End Project diff --git a/crpa/crpa.dsw b/crpa/crpa.dsw new file mode 100755 index 000000000..aa06d302b --- /dev/null +++ b/crpa/crpa.dsw @@ -0,0 +1,29 @@ +Microsoft Developer Studio Workspace File, Format Version 6.00 +# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! + +############################################################################### + +Project: "crpa"=.\crpa.dsp - Package Owner=<4> + +Package=<5> +{{{ +}}} + +Package=<4> +{{{ +}}} + +############################################################################### + +Global: + +Package=<5> +{{{ +}}} + +Package=<3> +{{{ +}}} + +############################################################################### + diff --git a/crpa/crpa.ini b/crpa/crpa.ini new file mode 100755 index 000000000..133a172ac --- /dev/null +++ b/crpa/crpa.ini @@ -0,0 +1,103 @@ +[Oracle] +Username=pmc +Password=pmc +Connect=zen1 +Run= + +[23] +TABLE=AGA_PRJDOC_T146_P +UNICO= +ARCH=!_FIRM,_MOV +UNICARCH=!_UNICMOV +DTATRASF=!_DATAORA +TIPDOC=:PN +DESDOC=!_DESMOV +NUMDOC= +DTADOC=!_D,DATAREG +NUMDOCFIS=NUMDOC +DTADOCFIS=!_D,DATADOC +DTAPERT=!_D,DATACOMP +AZIENDA=!_FIRM +TIPANA=TIPOCF +CODCF=CODCF +CODVAL=!_CODVAL + +[24] +TABLE=AGA_PRJDET_T147_P +UNICO= +ARCH=!_FIRM,_MOV +UNICARCH=!_UNICMOV +UNICRIGA=NUMRIG +CODART=!_CODART +DESART=!_DESRMOV +QUANT=1 +UNMIS= +CONSAL= +IMPVAL=IMPORTO +NUMCOMM=CODCMS +CODATTCM= +ELSPESA=!_ELSPESAMOV +CENTCOST=FASCMS +DTACONS= +RIFRICH= +RIFORD= +RIFBOL= +CODVAL=!_CODVAL +STATO_IMP= +SEGNO=SEZIONE + +[33] +TABLE=AGA_PRJDOC_T146_P +UNICO= +ARCH=!_FIRM,_DOC +UNICARCH=!_UNICDOC +DTATRASF=!_DATAORA +TIPDOC=!_TIPODOC +DESDOC=!_DESDOC +NUMDOC=NDOC +DTADOC=!_D,DATADOC +NUMDOCFIS=NUMDOCRIF +DTADOCFIS=!_D,DATADOCRIF +DTAPERT=!_D,DATADOC +AZIENDA=!_FIRM +TIPANA=TIPOCF +CODCF=CODCF +CODVAL=!_CODVAL + +[34] +TABLE=AGA_PRJDET_T147_P +UNICO= +ARCH=!_FIRM,_DOC +UNICARCH=!_UNICDOC +UNICRIGA=#RDOC,NRIGA +CODART=CODART +QUANT=#!_,QTA +DESART=!_T,70,DESCR +UNMIS=UMQTA +CONSAL= +IMPVAL=#!_,IMPORTO +NUMCOMM=#!_,COMMESSA +CODATTCM= +ELSPESA=!_ELSPESADOC +CENTCOST=#!_,FASE +DTACONS=#!_,DATACONS +RIFRICH= +RIFORD=!_RIFORD +RIFBOL=!_RIFBOL +CODVAL=!_CODVAL +STATO_IMP= +SEGNO= + +[Tipo documento] +O=I** +B=IM* +BO=*M* +FB=**F +FO=*MF +F=IMF + +[Codice valuta] +EUR=EU + +[Descrizioni] +F01=Percentuale,QTAGG1|Giorni,QTAGG2 diff --git a/crpa/crpa0.cpp b/crpa/crpa0.cpp new file mode 100755 index 000000000..a97c75c4a --- /dev/null +++ b/crpa/crpa0.cpp @@ -0,0 +1,1081 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "..\ve\velib.h" +#include "..\cg\cg2103.h" + +class TIni2Sql: public TSkeleton_application +{ + TRelation* _clifo; + TConfig* _configfile; + TConfig* _inputfile; + ofstream* _sqlfile; + TLocalisamfile* _anamag; + TLocalisamfile* _fcaus; + TLocalisamfile* _frcaus; + TCausale * _caus; + long _firm; + TDocumento* _doc; + TDocumento* _dadoc; + TRiga_documento* _rigadoc; + TFilename _inputfilename; + TBill _conto; + TToken_string* _search_seq; + // Sequenza di ricerca del conto costo/ricavo la correttezza dell'ordinamento + // va controllata nel programma di modifica parametri: + // "" = fine ordinamento + // CF = cliente fornitore + // CA = causale + // AR = articolo (costo/ricavo) + // GM = gruppo merceologico + // SM = sottogruppo merceologico + // RF = raggruppamento fiscale + // CV = categoria di vendita + // CC = categoria contabile + // Gli utlimi 6 fanno parte della ricerca per costi ricavi, in particolare AR,GM,SM e RF + // non possono essere interrotti da CV o CC. Ad es. CA|CF|AR|CV|GM|CC|RF non e' valida come stringa + // di ricerca. + + +protected: + virtual bool create(void); + virtual void main_loop(); + virtual bool destroy(void); + virtual const char * extra_modules() const { return "BA"; } + void process_field(const TString& inputfield, TString& outputstr, int len = -1, const bool apici = TRUE); + void validate(const TString& elabfield, TString& outputstr); + void leggidadoc(const TString& elabfield, TString& outputstr); + void build_paragraph(const TString& paragrafo, TString& outputstr); + int build_nriga(const TString& paragrafo); + int get_tipo_dadoc(const TDocumento& doc) const; + long get_protiva(const TDocumento& doc) const; + bool search_costo_ricavo(TBill& conto, const TRiga_documento& r); + bool test_swap() const; + bool test_swap_conto(const int gr, const int co, const char sezione) const; + +public: + void write_sqlinsert(); + void write_sqldelete(); + TIni2Sql() {} + virtual ~TIni2Sql() {} +}; + +// restituisce un riferimento all' applicazione +inline TIni2Sql& app() { return (TIni2Sql&) main_app();} + +// creazione dell'applicazione +bool TIni2Sql::create() +{ + if (argc() > 1) + { + _inputfilename = argv()[1]; + if (_inputfilename[0] == '/' || _inputfilename[0] == '-') + _inputfilename.ltrim(2); + if (_inputfilename.exist()) + { + open_files(LF_MOV, LF_RMOV, LF_RMOVIVA, LF_DOC, LF_RIGHEDOC, LF_CLIFO, LF_PCON, LF_ABPCON, LF_CFVEN, LF_TABCOM, LF_TAB, 0); + _inputfile = new TConfig(_inputfilename); + _configfile = new TConfig("crpa.ini"); + _sqlfile = NULL; + _doc = NULL; + _dadoc = NULL; + _rigadoc = NULL; + _clifo = new TRelation(LF_CLIFO); + _clifo->add(LF_CFVEN,"TIPOCF=TIPOCF|CODCF=CODCF"); + _anamag = new TLocalisamfile(LF_ANAMAG); + _fcaus = new TLocalisamfile(LF_CAUSALI); + _frcaus = new TLocalisamfile(LF_RCAUSALI);// Per far andare TCausale + return TSkeleton_application::create(); + } + else + error_box("Il file %s non esiste", (const char*) _inputfilename); + } + else + error_box("Usage: CRPA0 -i"); + return FALSE; +} + +bool TIni2Sql::test_swap_conto(const int gr, const int co, const char sezione) const +{ + TToken_string key; + key.format("%d|%d", gr, co); + const int indbil = atoi(cache().get(LF_PCON, key, "INDBIL")); + return ((indbil == 3) && (sezione == 'A')) || ((indbil == 4) && (sezione == 'D')); +} + +bool TIni2Sql::test_swap() const +{ + bool s = FALSE; + if (*_caus->codice() > ' ') // esiste la causale + { + const char sez = _caus->sezione_clifo(); + const TipoIVA iva = _caus->iva(); + const bool vendite = iva == nessuna_iva ? _doc->tipocf() == 'C' : iva == iva_vendite; + s = vendite ^ (sez == 'D'); + } + return s; +} + +// legge da documento o da riga il campo indicato (primo carattere = #) +// se occorre usare una funzione dei doc. o delle righe si fa seguire al carattere # la stringa +// ?? !_, +void TIni2Sql::leggidadoc(const TString& elabfield, TString& tmpstr) +{ + tmpstr=""; + TToken_string s(elabfield, ',') ; + const TString code(s.get(0)); + const TString field(s.get(1)); + if (code == "!_") + { + if (field == "IMPORTO") + { + if (_rigadoc != NULL) + { + real importo; + if (_doc->tipocf() == 'F') + { + TString80 codcms = _rigadoc->codice_commessa(); + bool lordo = cache().get("CMS", codcms, "S7") == "NR"; + const TTipo_riga_documento tiporig = _rigadoc->tipo(); + real perc_ind = tiporig.perc_indetraibilita(); + if (lordo) + perc_ind = 100.0; + if (perc_ind != ZERO) + { + importo = _rigadoc->importo(TRUE, FALSE); + real imposta = _rigadoc->imposta(); + importo = importo + (imposta*perc_ind)/100.0; + } + else + importo = _rigadoc->importo(TRUE, lordo); + } + else + importo = _rigadoc->importo(TRUE, FALSE); + if (test_swap()) + importo = importo * (-1); + tmpstr = importo.string(); + } + } + else if (field == "QTA") + { + if (_rigadoc != NULL) + { + real qta; + if (_doc->is_evaso()) + qta = _rigadoc->qtaevasa(); + else + qta = _rigadoc->quantita(); + tmpstr = qta.string(); + } + } + else if (field == "COMMESSA") + { + if (_rigadoc != NULL) + { + tmpstr = _rigadoc->codice_commessa(); + tmpstr.upper(); + tmpstr.replace('/','_'); + } + } + else if (field == "FASE") + { + if (_rigadoc != NULL) + { + tmpstr = _rigadoc->fase_commessa(); + tmpstr.upper(); + tmpstr.replace('/','_'); + } + } + else if (field == "DATACONS") + { + if (_rigadoc != NULL) + { + TString str = _rigadoc->get(field); + TDate datactrl(str); + if (!datactrl.ok()) + { + str = _doc->get(field); + datactrl = TDate(str); + } + if (datactrl.ok()) + tmpstr.format("TO_DATE('%s','dd-mm-yyyy')", (const char*) str); + } + } + } + else if (code == "DRDOC") + { + if (_rigadoc != NULL) + { + TString str = _rigadoc->get(field); + TDate datactrl(str); + if (datactrl.ok()) + tmpstr.format("TO_DATE('%s','dd-mm-yyyy')", (const char*) str); + } + } + else if (code == "DOC") + { + if (_doc != NULL) + tmpstr = _doc->get(field); + } + else if (code == "RDOC") + { + if (_rigadoc != NULL) + tmpstr = _rigadoc->get(field); + } +} + +bool TIni2Sql::search_costo_ricavo(TBill& conto, const TRiga_documento& r) +{ + TConfig conf(CONFIG_DITTA, "ve"); + _search_seq = new TToken_string((const char*)conf.get("RICERCACR","ve")); + // costruisce la stringa che controlla la ricerca del conto costo/ricavo + // Attenzione! non esegue alcun controllo di consistenza sulla corretta sequenza + // presuppone che il programma di configurazione abbia generato correttamente + // il tutto. + if (_search_seq->items() == 0) + { + error_box("Non e' abilitata alcuna ricerca per il conto di costo/ricavo in configurazione."); + return FALSE; + } + const int items = _search_seq->items(); + TLocalisamfile& cli_file = _clifo->lfile(); // YES, arriva qui dentro quando la relazione e' gia' posizionata + const bool is_cli = cli_file.get(CLI_TIPOCF) == "C"; + bool skip_art_related = FALSE; + bool skip_clifo = _clifo->bad(); + TCodiceIVA codiva(r.get(RDOC_CODIVA)); + const char t = r.tipo().tipo(); + + // Istanzia la causale del documento corrente... + const TTipo_documento& tipo = _doc->tipo(); + TString16 codcaus(tipo.causale()); + + TToken_string key; + key.add(_doc->get(DOC_TIPOCF)); + key.add(_doc->get(DOC_CODCF)); + + const TRectype & cfven = cache().get(LF_CFVEN, key); + const TString16 caus_cli(cfven.get(CFV_CODCAUS)); + + if (caus_cli.not_empty()) + codcaus = caus_cli; + TDate data = _doc->data(); + _caus = new TCausale(codcaus, data.year()); + + int gr,co; + long so; + + switch (t) + { + case 'O': // righe omaggio come articoli spiaccicato identico (avranno imponibile 0) + case 'M': // righe di merce + { + // posiziona l'anagrafica sull'articolo specificato sulla ..iga + TString80 codart = r.get(RDOC_CODARTMAG); + if (codart.blank()) + codart = r.get(RDOC_CODART); + _anamag->put(ANAMAG_CODART, codart); + if (_anamag->read() != NOERR) // se non trova l'articolo saltera' anche gmc,smc,rfa. + skip_art_related = TRUE; + + TString16 tok; + // Scorre la stringa di ricerca + for (int i=0;iget(i); + if (tok == "CF") + { + if (skip_clifo) continue; + gr = cli_file.get_int(CLI_GRUPPORIC); + co = cli_file.get_int(CLI_CONTORIC); + so = cli_file.get_long(CLI_SOTTOCRIC); + conto.set(gr,co,so); + if (conto.ok()) break; // se lo trova esce (tutti != 0) + } + else + if (tok == "CA") + { + + CHECK(_caus,"Causale documento non valida"); + if (_caus->IVA2bill(codiva,conto)) break; // se lo trova esce + } + else + if (tok == "AR") + { + if (skip_art_related) continue; + gr = _anamag->get_int(is_cli ? ANAMAG_GRUPPOV : ANAMAG_GRUPPOA); + co = _anamag->get_int(is_cli ? ANAMAG_CONTOV : ANAMAG_CONTOA); + so = _anamag->get_long(is_cli ? ANAMAG_SOTTOCV : ANAMAG_SOTTOCA); + conto.set(gr,co,so); + if (!conto.ok()) // se il conto non c'e' guarda la categoria acquisti/vendite + { + TTable *t = is_cli ? new TTable("CRA") : new TTable("CAA"); + + t->put("CODTAB",_anamag->get(is_cli ? ANAMAG_CATCONV : ANAMAG_CATCONA)); + if (t->read() == NOERR) + { + gr = atoi(t->get("S1")); + co = atoi(t->get("S2")); + so = atol(t->get("S3")); + conto.set(gr,co,so); + } + } + if (conto.ok()) break; + } + else + if (tok == "GM" || tok == "SM" || tok == "RF") + { + if (skip_art_related) continue; + const bool is_fis = tok == "RF"; + TTable * tab = is_fis ? new TTable("RFA") : new TTable("GMC"); + TString16 codtab(_anamag->get(is_fis ? ANAMAG_RAGGFIS : ANAMAG_GRMERC)); + if (tok == "GM" && codtab.len() > 3) + codtab.cut(3); // gli ultimi 2 si riferiscono al sottogruppo. + tab->put("CODTAB",codtab); + if (tab->read() == NOERR) + { + gr = tab->get_int(is_cli ? "I3" : "I0"); + co = tab->get_int(is_cli ? "I4" : "I1"); + so = tab->get_long(is_cli ? "I5" : "I2"); + conto.set(gr,co,so); + } + if (conto.ok()) break; + } + else + if (tok == "CV" || tok == "CC") + { + const bool is_cve = tok == "CV"; + if (is_cve && !is_cli) continue; // se e' un fornitore salta questa condizione + TTable* t = is_cve ? new TTable("CVE") : new TTable("CCO"); + TString16 cod(is_cve ? r.doc().get(DOC_CATVEN) : EMPTY_STRING); + if (cod.empty()) + { + if (skip_clifo) continue; // se non aveva trovato il cliente salta al prossimo + cod = _clifo->lfile(LF_CFVEN).get(is_cve ? CFV_CATVEN : CFV_CODCATC); + } + t->put("CODTAB",cod); + if (t->read() == NOERR) + { + const bool x =(is_cve || is_cli); + gr = t->get_int(x ? "I3" : "I0"); + co = t->get_int(x ? "I4" : "I1"); + so = t->get_long(x ? "I5": "I2"); + conto.set(gr,co,so); + } + if (conto.ok()) break; + } + } + break; // case 'M' + } + case 'P': // righe prestazione + case 'S': // righe spese + { + TTable* tab = t == 'P' ? new TTable("PRS") : new TTable("SPP"); + tab->put("CODTAB",r.get(RDOC_CODART)); + if (tab->read()==NOERR) + { + gr = tab->get_int(is_cli ? "I0" : "I3"); + co = tab->get_int(is_cli ? "I1" : "I4"); + so = tab->get_long(is_cli ? "I2" : "I5"); + conto.set(gr,co,so); + if (!is_cli && !conto.ok()) + { + gr = r.get_int("QTAGG1"); + co = r.get_int("QTAGG2"); + so = r.get_long("QTAGG3"); + conto.set(gr,co,so); + } + } + + if (!conto.find() && t == 'P') // Cerca il conto nella stringa di ricerca (solo per prestazioni) + { + TString16 tok; + // Scorre la stringa di ricerca ma solo per causale o CLI/FO + for (int i=0;iget(i); + if (tok == "CF") + { + if (skip_clifo) continue; + gr = cli_file.get_int(CLI_GRUPPORIC); + co = cli_file.get_int(CLI_CONTORIC); + so = cli_file.get_long(CLI_SOTTOCRIC); + conto.set(gr,co,so); + if (conto.ok()) break; + } + else + if (tok == "CA") + { + CHECK(_caus,"Causale documento non valida"); + if (_caus->IVA2bill(codiva,conto)) break; + } + } + } + break; // case 'P','S' + } + case 'C': + // righe sconti: vengono considerate in adjust_sconto_rows() + case 'D': // righe descrizioni (saltare) + default : + break; + } // end of switch + return (conto.ok()); +} + +long TIni2Sql::get_protiva(const TDocumento& doc) const +{ + long protiva = 0; + // solo se é un documento di spesa (chiedere??) + // e solo se é stato contabilizzato + if (!doc.tipo().is_generic()) + { + // creo un cursore con + // tipocf, codcf, datareg = datadoc + TRelation relmov(LF_MOV); + TRectype da(LF_MOV); + da.put(MOV_TIPO, doc.tipocf()); + da.put(MOV_CODCF, doc.codcf()); + da.put(MOV_DATAREG, doc.data()); + TCursor curmov(&relmov, "", 3, &da, &da); + TString str; + const TString& rif = doc.riferimento(str); + long count = curmov.items(); + curmov = 0; + while ((curmov.pos() < count) && (protiva == 0)) + { + TString desmov = curmov.curr().get(MOV_DESCR); + if (desmov.find(rif) >= 0) + protiva = curmov.curr().get_long(MOV_PROTIVA); + ++curmov; + } + } + return protiva; +} + +int TIni2Sql::get_tipo_dadoc(const TDocumento& doc) const +{ + int datipo = 0; + for (int r = 1; r <= doc.rows(); r++) + { + const TRiga_documento& rdoc = doc[r]; + const TString8 dacodnum = rdoc.get(RDOC_DACODNUM); + if (dacodnum.not_empty()) + { + datipo = atoi(cache().get("%NUM", dacodnum, "I1")); + break; + } + } + return datipo; +} + +// esegue l'elaborazione indicata +void TIni2Sql::validate(const TString& elabfield, TString& str) +{ + TString tmpstr = ""; + str=""; + TToken_string s(elabfield, ',') ; + const TString code(s.get(0)); + if (code == "_D") // campo da trasformare in data + { + tmpstr = _inputfile->get((s.get())); + TDate datactrl(tmpstr); + if (datactrl.ok()) + str.format("TO_DATE('%s','dd-mm-yyyy')", (const char*) tmpstr); + } + else if (code == "_T") // campo da tagliare alla lunghezza indicata + { + int len = atoi(s.get(1)); + tmpstr = s.get(2); + process_field(tmpstr, str, len, FALSE); + + } + else if (code == "_DATAORA") // campo che contiene data e ora del momento + { + TDate today(TODAY); + char time[128]; + _strtime(time); + str.format("TO_DATE('%s %s','dd-mm-yyyy hh24:mi:ss')", today.string(), time); + + } + else if (code == "_FIRM") // campo ditta (01, 02, ...) + { + tmpstr = s.get(); + if (tmpstr.empty()) + str.format("%02ld", _firm); + else + str.format("%02ld%s", _firm, (const char*) tmpstr); + } + else if (code == "_UNICMOV") // campo UNICARCH nel caso di movimenti + str.format("%s-%s-%ld", (const char*) _inputfile->get("CODCAUS","23"), (const char*) _inputfile->get("ANNOES", "23"), _inputfile->get_long("NUMREG", "23")); + else if (code == "_UNICDOC") // campo UNICARCH nel caso di documenti + str.format("%s-%s-%s", (const char*) _inputfile->get("CODNUM", "33"), (const char*) _inputfile->get("ANNO", "33"), (const char*) _inputfile->get("NDOC", "33")); + else if (code == "_CODVAL") // campo codice valuta + { + tmpstr = _inputfile->get("CODVAL"); + if ((tmpstr[0] == '"') || (tmpstr.empty())) + { + TExchange e; + tmpstr = e.get_value(); + } + str = _configfile->get(tmpstr, "Codice valuta"); + } + else if (code == "_ELSPESAMOV" || code == "_ELSPESADOC") // campo ELSPESA + { + TToken_string key; + if (code == "_ELSPESAMOV") // per righe movimenti + { + key = _inputfile->get("GRUPPO"); + key.add(_inputfile->get("CONTO")); + key.add(_inputfile->get("SOTTOCONTO")); + } + else // per righe documenti + key.format("%d|%d|%ld", _conto.gruppo(), _conto.conto(), _conto.sottoconto()); + if (!key.empty_items()) + { + key = cache().get(LF_PCON, key, "CODCBL"); + str = cache().get(LF_ABPCON, key, "DESCRIZ").left(6); + str.upper(); + } + else + str.cut(0); + } + else if (code == "_DESRMOV") // campo DESART per righe movimenti + { + process_field("DESCR", tmpstr, -1, FALSE); + str.format("%s-%s", (const char*) _inputfile->get("CODCAUS","23"), (const char*) tmpstr); + } + else if (code == "_DESMOV") // campo DESART per movimenti + { + process_field("DESCR", tmpstr, -1, FALSE); + str.format("%s (%s)", (const char*) tmpstr, (const char*) _inputfile->get("PROTIVA")); + } + else if (code == "_CODART") // campo CODART per movimenti + str.format("%s-%s-%s", (const char*) _inputfile->get("GRUPPO"), (const char*) _inputfile->get("CONTO"), (const char*) _inputfile->get("SOTTOCONTO")); + else if (code == "_IMPORTORMOV") // campo importo per righe movimenti + { + real importo(_inputfile->get("IMPORTO")); + const int gruppo = atoi(_inputfile->get("GRUPPO")); + const int conto = atoi(_inputfile->get("CONTO")); + str = _inputfile->get("SEZIONE"); + const char sezione = str[0]; + if (test_swap_conto(gruppo, conto, sezione)) + importo = importo * (-1); + str = importo.string(); + } + else if (code == "_SEZIONERMOV") // campo sezione per righe movimenti + { + const int gruppo = atoi(_inputfile->get("GRUPPO")); + const int conto = atoi(_inputfile->get("CONTO")); + str = _inputfile->get("SEZIONE"); + const char sezione = str[0]; + if (test_swap_conto(gruppo, conto, sezione)) + { + if (sezione == 'D') + str = "A"; + else if (sezione == 'A') + str = "D"; + } + } + else if (code == "_DESDOC") // campo DESDOC per documenti + { + TString16 key = _doc->numerazione(); + TString desnum = cache().get("%NUM", key, "S0"); + key = _inputfile->get("TIPOCF"); + key << '|' << _inputfile->get("CODCF"); + TString ragsoc = cache().get(LF_CLIFO, key, "RAGSOC"); + long protiva = get_protiva(*_doc); + str.format("%s-%s",(const char*) desnum, (const char*) ragsoc); + if (protiva != 0) + str << '(' << protiva << ')'; + TString16 tipodoc = _doc->tipo().codice(); + TToken_string descrizioni = _configfile->get(tipodoc, "Descrizioni"); + TString16 separatore = _configfile->get("SEPARATORE", "Descrizioni"); + TString80 cod; + FOR_EACH_TOKEN(descrizioni,tok) + { + cod = tok; + int virgola = cod.find(','); + if (virgola > -1) + { + TString80 prompt = cod.sub(0,virgola); + TString80 campo = cod.sub(virgola+1); + str << separatore; + str << prompt; + str << _doc->get(campo); + } + } + } + else if (code == "_TIPODOC") // campo TIPDOC + { + if (_doc != NULL) + { + const int tipodoc = atoi(cache().get("%NUM", _doc->numerazione(), "I1")); + if (tipodoc == 3) // ordine + tmpstr = "O"; + else if (tipodoc == 1) // bolla + { + // restituisce il tipo documento origine della prima riga che ha un doc. di origine + const int datipodoc = get_tipo_dadoc(*_doc); // si assume che sia il tipo documento di origine per tutto il documento + tmpstr = (datipodoc == 3) ? "BO" : "B"; + } + else if (tipodoc == 2) // fattura + { + const int datipodoc = get_tipo_dadoc(*_doc); + if (datipodoc == 1) + tmpstr = "FB"; + else if (datipodoc == 3) + tmpstr = "FO"; + else + tmpstr = "F"; + } + str = _configfile->get(tmpstr, "Tipo documento"); + } + } + else if ((code == "_RIFORD") || (code == "_RIFBOL")) // campi RIFORD e RIFBOL + { + if (_dadoc != NULL) + { + const int ord_bol = atoi(cache().get("%NUM", _dadoc->numerazione(), "I1")); + if (((ord_bol == 3) && (code == "_RIFORD")) || ((ord_bol == 1) && (code == "_RIFBOL"))) + { + str << _dadoc->numerazione() << '-'; + str << _dadoc->anno() << '-'; + str << _dadoc->numero(); + } + if ((ord_bol == 1) && (code == "_RIFORD")) + { + } + } + } +} + +// prende nome campo di input indicato nel file crpa.ini (puo' essere un campo o una elaborazione) +// e mi restituisce il valore da inserire in VALUES +void TIni2Sql::process_field(const TString& inputfield, TString& tmpstr, int len, const bool apici) +{ + tmpstr.cut(0); + if (inputfield.not_empty()) + { + // campo elaborato + if (inputfield[0] == '!') + validate(inputfield.sub(1), tmpstr); + // valore fisso + else if (inputfield[0] == ':') + tmpstr = inputfield.sub(1); + // il campo va letto dai documenti o dalle righe + else if (inputfield[0] == '#') + leggidadoc(inputfield.sub(1), tmpstr); + // campo da leggere dal file di input + else if (inputfield == "CODVAL") + { + tmpstr = _inputfile->get(inputfield); + if ((tmpstr[0] == '"') || (tmpstr.empty())) + { + TExchange e; + tmpstr = e.get_value(); + tmpstr = tmpstr.sub(0,2); + } + } + else if (inputfield == "CODCMS") + { + tmpstr = _inputfile->get(inputfield); + tmpstr.upper(); + tmpstr.replace('/','_'); + } + else if (inputfield == "FASCMS") + { + tmpstr = _inputfile->get(inputfield); + tmpstr.upper(); + tmpstr.replace('/','_'); + } + else if (inputfield == "CODCF") + { + long codcf = _inputfile->get_long(inputfield); + if (codcf != 0) + { + if (_firm == 2) + codcf+=100000; + tmpstr.format("%ld", codcf); + } + } + else + tmpstr = _inputfile->get(inputfield); + tmpstr.trim(); + if (tmpstr.not_empty()) + { + if ((tmpstr.sub(0,7) != "TO_DATE") && apici) + { + int l = tmpstr.find("'"); + while (l >= 0) + { + tmpstr.insert("'",l); + l = tmpstr.find("'",l+2); + } + } + int l = tmpstr.len(); + if ((tmpstr[0] == '"') && (tmpstr[l-1] == '"')) + tmpstr = tmpstr.sub(1,l-1); + tmpstr.trim(); + if (len >= 0) + tmpstr.cut(len); + if (apici && tmpstr.not_empty() && (tmpstr.sub(0,7) != "TO_DATE")) + { + tmpstr.insert("'"); tmpstr << '\''; + } + } + } +} + +// distruzione dell'applicazione +bool TIni2Sql::destroy() +{ + delete _fcaus; + delete _frcaus; + delete _anamag; + delete _clifo; + delete _inputfile; + delete _configfile; + if (_sqlfile != NULL) + delete _sqlfile; + if (_doc != NULL) + delete _doc; + if (_dadoc != NULL) + delete _doc; + if (_rigadoc != NULL) + delete _doc; + return TSkeleton_application::destroy(); +} + +void TIni2Sql::build_paragraph(const TString& paragrafo, TString& output) +{ + output = paragrafo; + const int posvirgola = output.find(','); + if (posvirgola > 0) + output.cut(posvirgola); +} + +int TIni2Sql::build_nriga(const TString& paragrafo) +{ + int nriga = 0; + const int posvirgola = paragrafo.find(','); + if (posvirgola > 0) + nriga = atoi(paragrafo.sub(posvirgola+1)); + return nriga; +} + + +// scrive il file che contiene il comando insert completo dei record da inserire +void TIni2Sql::write_sqlinsert() +{ + TString_array lp; + if (_inputfile->list_paragraphs(lp) > 0) + { + bool almenounariga = FALSE; + TString insert, colonne, valori; + _firm = _inputfile->get_int("Firm", "Transaction"); + TString16 firm = ""; + firm.format("%ld", _firm); + if (_configfile->get((const char*)firm, "Ditte")[0] == 'S') + { + if (_firm != get_firm()) + set_firm(_firm); + FOR_EACH_ARRAY_ROW(lp, p, paragrafo) + { + if (*paragrafo == "Transaction") + { + } + else + { + TString strpar; + build_paragraph(*paragrafo, strpar); + insert.format("INSERT INTO %s", (const char*) _configfile->get("TABLE", strpar)); + colonne = NULL; + valori = NULL; + _inputfile->set_paragraph(*paragrafo); + bool ok = TRUE; // se e' una riga va passata solo ad alcune condizioni + if (strpar == "33") // creo subito il TDocumento per usare tutti i metodi offerti gratis + { + if (_doc == NULL) + { + const TString16 codnum = _inputfile->get("CODNUM"); + const char provv = _inputfile->get("PROVV")[0]; + const int anno = atoi(_inputfile->get("ANNO")); + const long numdoc = atol(_inputfile->get("NDOC")); + _doc = new TDocumento(provv, anno, codnum, numdoc); + _clifo->lfile().put(CLI_TIPOCF, _doc->tipocf()); + _clifo->lfile().put(CLI_CODCF, _doc->codcf()); + _clifo->read(); + } + } + // se riga movimento deve avere gruppo inserito nel pragrafo gruppi di crpa.ini + if (strpar == "24") + { + const TString8 gruppo = _inputfile->get("GRUPPO"); + ok = _configfile->get_bool(gruppo, "Gruppi"); + } + // vecchia condizione: se riga documento deve avere codice iva oppure essere tipo riga spesa e avere gruppo 4 o 5 (andare su anamag con codart o ) + // se riga documento preocedo come la contabilizzazione per cercare il gruppo-conto-sottoconto, che deve essere presente in crpa.ini + if (strpar == "34") + { + const TString8 codiva = _inputfile->get("CODIVA"); + const TString8 tiporiga = _inputfile->get("TIPORIGA"); + const char tiporigatab = cache().get("%TRI", tiporiga, "S7")[0]; + ok = (codiva.not_empty()) || (tiporigatab == 'S'); + if (ok) + { + const int nriga = build_nriga(*paragrafo); + if (nriga <= _doc->rows()) + { + _rigadoc = new TRiga_documento((*_doc)[nriga]); + /* + TString8 gruppoa = ""; + TString8 gruppov = ""; + + TString80 codart; + if (tiporigatab == 'M') + codart = _inputfile->get(RDOC_CODARTMAG); + if (codart.blank()) + codart = _inputfile->get(RDOC_CODART); + + switch (tiporigatab) + { + case 'P': + { + const TRectype& prs = cache().get("PRS", codart); + gruppov = prs.get("I0"); + gruppoa = prs.get("I3"); + } + break; + case 'S': + { + const TRectype& spp = cache().get("SPP", codart); + gruppov = spp.get("I0"); + gruppoa = spp.get("I3"); + } + break; + default: + { + const TRectype& anamag = cache().get(LF_ANAMAG, codart); + gruppoa = anamag.get("GRUPPOA"); + gruppov = anamag.get("GRUPPOV"); + } + break; + } + */ + ok = search_costo_ricavo(_conto, (*_rigadoc)); + if (ok) + { + TString8 gruppos; + int gruppo = _conto.gruppo(); + gruppos.format("%d", _conto.gruppo()); + ok = (_configfile->get_bool(gruppos, "Gruppi")); + } + //ok = (_configfile->get_bool(gruppoa, "Gruppi")) || (_configfile->get_bool(gruppov, "Gruppi")); + } + } + } + // verifico che la riga abbia una commessa + if ((ok) && (strpar == "24" || strpar == "34")) + { + TString80 codcms; + if (strpar == "24") + codcms = _inputfile->get("CODCMS"); + if (strpar == "34") + { + if (_rigadoc != NULL) + codcms = _rigadoc->codice_commessa(); + } + ok = codcms.not_empty(); + } + if (ok) + { + if ((strpar=="24") || (strpar=="34")) + almenounariga =TRUE; + if ((strpar== "34") && (_rigadoc != NULL)) + { + TString16 codnum = _rigadoc->get("DACODNUM"); + const char provv = _rigadoc->get("DAPROVV")[0]; + const int anno = _rigadoc->get_int("DAANNO"); + const long numdoc = _rigadoc->get_long("DANDOC"); + if (codnum.not_empty()) + _dadoc = new TDocumento(provv, anno, (const char*) codnum, numdoc); + } + TString_array lv; + _configfile->list_variables(lv, TRUE, strpar); + TString16 key; + TString str; + TString risultato; + FOR_EACH_ARRAY_ROW(lv, r, row) + { + _inputfile->set_paragraph(*paragrafo); + key = row->get(0); + str = row->get(); + if (strcmp(key,"TABLE") == 0) + { + } + else + { + process_field(str, risultato); + if (risultato.not_empty()) + { + if (colonne.len()>0) + colonne << ", "; + colonne << key; + if (valori.len()>0) + valori << ", "; + valori << risultato; + } + } + } + if (_rigadoc != NULL) + _rigadoc =NULL; + if (_dadoc != NULL) + _dadoc = NULL; + } + } + if (colonne.len() > 0) + { + colonne.insert(" ("); colonne << ") "; + valori.insert(" VALUES ("); valori << ") "; + + _sqlfile->write(insert, insert.len()); + *_sqlfile << endl; + _sqlfile->write(colonne, colonne.len()); + *_sqlfile << endl; + _sqlfile->write(valori, valori.len()); + *_sqlfile << endl; + _sqlfile->put('æ'); + *_sqlfile << endl; + } + } + if (!almenounariga) + { + if (_sqlfile != NULL) + delete _sqlfile; + _sqlfile = new ofstream("crpa.sql"); + _sqlfile->write("",0); + write_sqldelete(); + } + } + } +} + +// scrive il file che contiene il comando delete completo dei record da cancellare +void TIni2Sql::write_sqldelete() +{ + TString_array lp; + if (_inputfile->list_paragraphs(lp) > 0) + { + TString cancella, condizione; + _firm = _inputfile->get_int("Firm", "Transaction"); + + TString strpar, risultato; + + // Vado all'indietro per cancellare prima le righe e poi la testata + FOR_EACH_ARRAY_ROW_BACK(lp, p, paragrafo) + { + build_paragraph(*paragrafo, strpar); + const int numpar = atoi(strpar); + const int numrig = build_nriga(*paragrafo); + + condizione.cut(0); + if ( + (numpar == 23 || numpar == 33) || // Inizialmente era richiesto di cancellare solo le testate ... + ((numpar == 24 || numpar == 34) && numrig == 1) // ... ovviamente ora non più + ) + { + cancella.format("DELETE FROM %s", (const char*) _configfile->get("TABLE", strpar)); + _inputfile->set_paragraph(*paragrafo); + + process_field(_configfile->get("ARCH"), risultato); + if (risultato.not_empty()) + condizione << "(ARCH=" << risultato << ')'; + + process_field(_configfile->get("UNICARCH"), risultato); + if (risultato.not_empty()) + { + if (condizione.not_empty()) + condizione << " AND "; + condizione << "(UNICARCH=" << risultato << ')'; + } + } + + if (condizione.not_empty()) + { + condizione.insert(" WHERE ("); condizione << ") "; + + _sqlfile->write(cancella, cancella.len()); + _sqlfile->write(condizione, condizione.len()); + *_sqlfile << endl; + _sqlfile->put('æ'); + *_sqlfile << endl; + } + } + } +} + +// carica la maschera +void TIni2Sql::main_loop() +{ + _sqlfile = new ofstream("crpa.sql"); + _sqlfile->write("",0); + + TString16 action = _inputfile->get("Action", "Transaction"); + action.upper(); + switch (action[0]) + { + case 'I': + write_sqlinsert(); + break; + case 'D': + write_sqldelete(); + break; + case 'M': + { + write_sqldelete(); + write_sqlinsert(); + } + break; + + } + if (_sqlfile != NULL) + { + _sqlfile->flush(); + delete _sqlfile; + _sqlfile = NULL; + if (_configfile->get("Run", "Oracle") == "OK") + { + + TString rigapar; + if ((_inputfilename[0] != '.') && (_inputfilename[1] != ':')) + _inputfilename.insert("./", 0); + rigapar << "crpa.exe crpa.sql " << _inputfilename; + TExternal_app esegui_sql(rigapar); + esegui_sql.run(); + } + } + // non devo scrivere niente nelle tavole oracle + // ma devo comunque segnalare come eseguita la transazione altrimenti rimane nel postino + else + { + _inputfile->set("Result", "OK", "Transaction"); + _inputfile->set("Error", "0", "Transaction"); + } +} + +int main(int argc, char** argv) +{ + TIni2Sql a; + a.run(argc, argv, "Trasferimento dati da EuroCampo"); + return 0; +} diff --git a/crpa/pmc.sql b/crpa/pmc.sql new file mode 100755 index 000000000..d77668a3a --- /dev/null +++ b/crpa/pmc.sql @@ -0,0 +1,613 @@ +CREATE TABLE PRACTOR_LOG ( + LOG_ID NUMBER (10) NOT NULL, + TIPO VARCHAR2 (25) NOT NULL, + DATA DATE NOT NULL, + UTENTE VARCHAR2 (240) NOT NULL, + TESTO VARCHAR2 (240), + CONSTRAINT PRACTOR_LOGXP + PRIMARY KEY ( LOG_ID ) ) +/ + +CREATE OR REPLACE PROCEDURE prcLog (vMessage PRACTOR_LOG.testo%TYPE) IS vErrMsg VARCHAR2(100); +BEGIN + INSERT INTO PRACTOR_LOG VALUES (note_seq.NEXTVAL, '-', SYSDATE, USER, vMessage); +-- dbms_output.put_line(vMessage); + EXCEPTION + WHEN OTHERS THEN + vErrMsg := SQLERRM(SQLCODE); + INSERT INTO PRACTOR_LOG VALUES (note_seq.NEXTVAL, '-', SYSDATE, USER, vErrMsg); +END prcLog; +/ + +CREATE TABLE SMC_PRJDOC_T146 ( + UNICO NUMBER, + ARCH VARCHAR2 (10) NOT NULL, + UNICARCH NUMBER NOT NULL, + DTATRASF DATE, + TIPDOC VARCHAR2 (2), + DESDOC VARCHAR2 (100), + NUMDOC VARCHAR2 (20), + DTADOC DATE, + NUMDOCFIS VARCHAR2 (20), + DTADOCFIS DATE, + DTAPERT DATE, + AZIENDA VARCHAR2 (3), + TIPANA VARCHAR2 (1), + CODCF VARCHAR2 (10), + CODVAL VARCHAR2 (3), + CONSTRAINT T146XP + PRIMARY KEY ( ARCH, UNICARCH ) ) +/ + +ALTER TABLE SMC_PRJDOC_T146 ADD CONSTRAINT R011146 + FOREIGN KEY (CODVAL) + REFERENCES PMC.VL_T011 (C_VL) + / + + CREATE TABLE SMC_PRJDET_T147 ( + UNICO NUMBER, + ARCH VARCHAR2 (10) NOT NULL, + UNICARCH NUMBER NOT NULL, + UNICRIGA NUMBER NOT NULL, + CODART VARCHAR2 (15), + DESART VARCHAR2 (70), + QUANT NUMBER, + UNMIS VARCHAR2 (3), + CONSAL VARCHAR2 (1), + IMPVAL NUMBER, + NUMCOMM VARCHAR2 (15), + CODATTCM VARCHAR2 (10), + ELSPESA VARCHAR2 (10), + CENTCOST VARCHAR2 (6), + DTACONS DATE, + RIFRICH VARCHAR2 (20), + RIFORD VARCHAR2 (20), + RIFBOL VARCHAR2 (20), + CODVAL VARCHAR2 (3), + STATO_IMP VARCHAR2 (1), + SEGNO VARCHAR2 (1), + CONSTRAINT T147XP + PRIMARY KEY ( ARCH, UNICARCH, UNICRIGA ) ) + +/ + + ALTER TABLE SMC_PRJDET_T147 ADD CONSTRAINT C146147 + FOREIGN KEY (ARCH, UNICARCH) + REFERENCES PMC.SMC_PRJDOC_T146 (ARCH, UNICARCH) ON DELETE CASCADE + +/ + +ALTER TABLE SMC_PRJDET_T147 ADD CONSTRAINT R011147 + FOREIGN KEY (CODVAL) + REFERENCES PMC.VL_T011 (C_VL) + + / + +CREATE OR REPLACE TRIGGER SMC_PRJDET_G147_01 BEFORE INSERT ON SMC_PRJDET_T147 FOR EACH ROW +DECLARE +TIPO SMC_PRJDOC_T146.TIPDOC%TYPE; +ATTIVITA SMC_PRJDET_T147.CODATTCM%TYPE; +PROJ PROG_T056.C_PROG%TYPE; +COSTO COSTO_AGRT_T022.P_COSTO%TYPE; +CAMBIORIF VL_T011.I_CB_CONS%TYPE; +CAMBIOPRJ VL_T011.I_CB_CONS%TYPE; +VALPRJ VL_T011.C_VL%TYPE; +ERRMSG PRACTOR_LOG.TESTO%TYPE; +baseERRMSG PRACTOR_LOG.TESTO%TYPE; +TCLASSE COSTO_AGRT_T022.T_CLASSE%TYPE; +numcosti NUMERIC; +CODCURVA CRV_DSBN_T013.C_CRV%TYPE; + +DESSPESA CLASSE_DI_COSTO_T043.S_CLASSE%TYPE; +BASEINI DATE; +BASEFIN DATE; +FORINI DATE; +FORFIN DATE; +PELMNT STRU_T087.P_ELMNT%TYPE; +CBS PROG_T056.C_STRU%TYPE; +STIMA COSTO_AGRT_T022.I_STIMA_CMPL%TYPE; +BDG_REV COSTO_AGRT_T022.I_BDG_REV%TYPE; +COMM COSTO_AGRT_T022.I_COMM%TYPE; +ACEM COSTO_AGRT_T022.I_ACEM%TYPE; +CONS COSTO_AGRT_T022.I_CONS%TYPE; +CNTBZ COSTO_AGRT_T022.I_CNTBZ%TYPE; + +BEGIN +Prclog('-- Nuovo documento -----------------------------------------------------------------------------------'); +Prclog('-- ARCH: '||:NEW.ARCH); +Prclog('-- UNICARCH: '||:NEW.UNICARCH); +Prclog('-- RIGA: '||:NEW.UNICRIGA); +-- Tipo documento +SELECT NVL(TIPDOC,'XX') INTO TIPO FROM SMC_PRJDOC_T146 +WHERE + ARCH = :NEW.ARCH +AND UNICARCH = :NEW.UNICARCH; +Prclog('Tipo documento: '||TIPO); + +IF TIPO <> 'XX' THEN + -- Ottengo il codice interno del progetto, il codice della valuta e il codice della + -- CBS di progetto. Il campo NUMCOMM del documento contiene il nome + -- del progetto (campo S_PROG_NOM della tabella PROG_T056). + -- Il nome Š univoco. + SELECT + C_PROG, NVL(C_VL, 'EUR'), C_STRU + INTO + PROJ, VALPRJ, CBS + FROM + PROG_T056 + WHERE + S_PROG_NOM = :NEW.NUMCOMM; + -- log + Prclog('Codice progetto: '||PROJ); + Prclog('Codice valuta: '||VALPRJ); + Prclog('Codice CBS: '||CBS); + + IF PROJ >= 0 THEN + -- CODICE COSTO + -- Controllo l'esistenza di un costo che abbia l'incrocio + -- corretto fra voce di spesa e attivit… + -- ELSPESA <--> S_NOME (voce dispesa ovvero nome del costo) + -- CODATTCM <--> TASK_UID (codice attivit…) + SELECT + NVL(COUNT(*),0) + INTO + NUMCOSTI + FROM + COSTO_AGRT_T022 + WHERE + C_PROG = PROJ + AND S_NOME = :NEW.ELSPESA + AND TASK_UID = :NEW.CODATTCM; + -- 'SELECT NVL(P_COSTO,-1) INTO COSTO FROM COSTO_AGRT_T022 WHERE C_PROG = '||PROJ||' AND S_NOME = '||:NEW.ELSPESA||' AND TASK_UID = '||:NEW.CODATTCM||';'; + + IF NUMCOSTI = 0 THEN + -- Valori del costo + STIMA := 0; + BDG_REV := 0; + COMM := 0; + ACEM := 0; + CONS := 0; + CNTBZ := 0; + Prclog('Manca il costo ('||:NEW.ELSPESA||'), procedo all''inserimento.'); + -- Codice costo + SELECT S022_P_COSTO.NEXTVAL INTO COSTO FROM dual; + Prclog('Nuovo codice costo: '||COSTO); + -- CODICE CURVA LINEARE (di default uso la curva lineare del progetto) + -- Il campo A_CRV_SIS indica il tipo di curva di sistema. + SELECT NVL(C_CRV, -1) INTO CODCURVA FROM CRV_DSBN_T013 + WHERE + C_PROG = PROJ + AND A_CRV_SIS = 4; + Prclog('Codice curva lineare: '||CODCURVA); + -- DESCRIZIONE VOCE DI COSTO + -- Il campo nome contiene il codice della classe di costo, + -- Il campo descrizione contiene la descrizione della classe di costo + SELECT + NVL(S_CLASSE,'') INTO DESSPESA + FROM + CLASSE_DI_COSTO_T043 + WHERE + C_CLASSE = :NEW.elspesa; + Prclog('Descrizione classe di costo: '||DESSPESA); + -- DATE RELATIVI ALL'ATTIVITA DI PROJECT + SELECT + NVL(TASK_BASE_START, SYSDATE()), NVL(TASK_BASE_FINISH, SYSDATE()), NVL(TASK_START_DATE, SYSDATE()), NVL(TASK_FINISH_DATE, SYSDATE()) + INTO + BASEINI, BASEFIN, FORINI, FORFIN + FROM + MSP_TASKS + WHERE + PROJ_ID = PROJ + AND TASK_UID = :NEW.CODATTCM; + Prclog('Inizio: '||BASEINI||' Fine: '||BASEFIN||' Inizio forecast: '||FORINI||' Fine forecast: '||FORFIN); + -- CAMBIO DEL PROGETTO + SELECT NVL(I_CB_CONS, 1) INTO CAMBIOPRJ FROM VL_T011 WHERE C_VL = VALPRJ; + Prclog('Cambio: '||CAMBIOPRJ); + + -- NODO CBS + -- Seleziono il nodo della CBS a cui associare il costo. + -- I nodi della CBS sono stati strutturati in modo che + -- rappresentino le voci di spesa del piano dei costi. + -- I primi due caratteri del nome del costo coincidono + -- con il nome della classe di costo inserita nella CBS. + -- es. voce di spesa (ELSPESA): 211 -- Emolumenti amministratori + -- Nella CBS andr… agganciata al nodo (C_ELMNT) 21 -- Stipendi + -- Si suppone che C_ELMNT sia univoco nella CBS. Non esiste per• + -- un indice nel database. + SELECT NVL(P_ELMNT,-1), NVL(T_CLASSE, 'C') INTO PELMNT, TCLASSE FROM + STRU_T087 + WHERE + C_PROG = PROJ + AND C_STRU = CBS + AND C_ELMNT = SUBSTR(:NEW.ELSPESA,1,2); + --PRCLOG('SELECT NVL(P_ELMNT,-1) INTO PELMNT FROM STRU_T087 WHERE C_PROG = '||PROJ||' AND C_STRU = '''||CBS||''' AND C_ELMNT = SUBSTR('''||:NEW.ELSPESA||''',1,2);'); + Prclog('Nodo ('||SUBSTR(:NEW.ELSPESA,1,2)||'): '||PELMNT); + IF PELMNT = -1 THEN + -- ATTACCO IL COSTO ALLA ROOT + SELECT NVL(P_ELMNT,-1) INTO PELMNT FROM + STRU_T087 + WHERE + C_PROG = PROJ + AND C_STRU = CBS + AND P_ELMNT_PDR IS NULL; + TCLASSE := 'C'; + Prclog('Nodo ('||SUBSTR(:NEW.ELSPESA,1,2)||') non trovato. Root: '||PELMNT); + + END IF; + IF PELMNT >= 0 THEN + -- Inserimento + INSERT INTO COSTO_AGRT_T022 + (C_PROG, P_COSTO, S_DES, C_VL, C_CRV, D_INI_ORIG, D_FIN_ORIG, D_INI_REVIS, D_FIN_REVIS, PROJ_UID, TASK_UID, F_EARNED, S_NOME, T_CLASSE) + VALUES + (PROJ, COSTO, DESSPESA, VALPRJ, CODCURVA, BASEINI, BASEFIN, FORINI, FORFIN, PROJ, :NEW.CODATTCM, 0, :NEW.ELSPESA, TCLASSE); + -- ASSOCIAZIONE ALLA CBS + INSERT INTO ASCN_STRU_T021 + (C_PROG, P_ELMNT, P_COSTO) + VALUES + (PROJ, PELMNT, COSTO); + ELSE + Prclog('Impossibile trovare un nodo nella CBS per il costo ('||SUBSTR(:NEW.ELSPESA,1,2)||').'); + END IF; -- pelmnt >= 0 + + ELSE -- NUMCOSTI = 0 + + -- il costo esiste: ottengo il codice, il tipo e la stima a completamento + SELECT + NVL(P_COSTO, -1), NVL(T_CLASSE,'C'), NVL(I_STIMA_CMPL, 0), NVL(I_BDG_REV, 0), + NVL(I_COMM, 0), NVL(I_ACEM, 0), NVL(I_CONS, 0), NVL(CNTBZ, 0) + INTO + COSTO, TCLASSE, STIMA, BDG_REV, + COMM, ACEM, CONS, CNTBZ + FROM + COSTO_AGRT_T022 + WHERE + C_PROG = PROJ + AND S_NOME = :NEW.ELSPESA + AND TASK_UID = :NEW.CODATTCM; + Prclog('Codice costo: '||COSTO); + END IF; + + IF COSTO >= 0 THEN + Prclog('Aggiornamento valori del costo ('||COSTO||').'); + -- CAMBIO DEL PROGETTO + SELECT NVL(I_CB_CONS, 0) INTO CAMBIOPRJ FROM VL_T011 WHERE C_VL = VALPRJ; + Prclog('Valore cambio: '||CAMBIOPRJ ); + IF CAMBIOPRJ > 0 THEN + -- ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** + -- ORDINE DI ACQUISTO + -- ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** + IF TIPO = 'OA' THEN + Prclog ('Tipo documento: OA'); + Prclog ('Importo: '||NVL(:NEW.IMPVAL, 0)); + + UPDATE COSTO_AGRT_T022 + SET + I_COMM = NVL(I_COMM,0) + NVL(:NEW.IMPVAL, 0), + I_COMM_VL = NVL(I_COMM_VL,0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + I_COMM_CURR = NVL(I_COMM_CURR,0) + NVL(:NEW.IMPVAL, 0), + I_COMM_CURR_VL = NVL(I_COMM_CURR_VL,0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ + WHERE + C_PROG = PROJ + AND P_COSTO = COSTO; + + COMM := COMM + NVL(:NEW.IMPVAL, 0); + Prclog('Impeganto: '||COMM||' Budget: '||BDG_REV||' Stima a completamento: '||STIMA ); + + -- Se l'impegnato supera il budget aumento la stima a finire + IF COMM > STIMA THEN + Prclog('Aggiorno la stima a completamento.'); + UPDATE COSTO_AGRT_T022 + SET + I_STIMA_CMPL = COMM, + I_STIMA_CMPL_VL = COMM * CAMBIOPRJ + WHERE + C_PROG = PROJ + AND P_COSTO = COSTO; + END IF; + + :NEW.STATO_IMP := 'I'; + END IF; + -- ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** + -- BOLLA DI ENTRATA + -- ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** + IF TIPO = 'BA' THEN + Prclog ('Tipo documento: BA'); + Prclog ('Importo: '||NVL(:NEW.IMPVAL, 0)); + + UPDATE COSTO_AGRT_T022 + SET + I_ACEM = NVL(I_ACEM, 0) + NVL(:NEW.IMPVAL, 0), + I_ACEM_VL = NVL(I_ACEM_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + I_ACEM_CURR = NVL(I_ACEM_CURR, 0) + NVL(:NEW.IMPVAL, 0), + I_ACEM_CURR_VL = NVL(I_ACEM_CURR_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ + WHERE + C_PROG = PROJ + AND P_COSTO = COSTO; + + ACEM := ACEM + NVL(:NEW.IMPVAL, 0); + Prclog('Maturato: '||ACEM||' Budget: '||BDG_REV||' Stima a completamento: '||STIMA ); + + -- Se l'impegnato supera il budget aumento la stima a finire + IF ACEM > STIMA THEN + Prclog('Aggiorno la stima a completamento.'); + UPDATE COSTO_AGRT_T022 + SET + I_STIMA_CMPL = ACEM, + I_STIMA_CMPL_VL = ACEM * CAMBIOPRJ + WHERE + C_PROG = PROJ + AND P_COSTO = COSTO; + END IF; + + :NEW.STATO_IMP := 'I'; + END IF; + -- ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** + -- FATTURA DI ACQUISTO + -- ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** + IF TIPO = 'FA' THEN + Prclog ('FA'); + Prclog ('IMPORTO: '||NVL(:NEW.IMPVAL, 0)); + + UPDATE COSTO_AGRT_T022 + SET + I_CONS = NVL(I_CONS, 0) + NVL(:NEW.IMPVAL, 0), + I_CONS_VL = NVL(I_CONS_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + I_CONS_CURR = NVL(I_CONS_CURR, 0) + NVL(:NEW.IMPVAL, 0), + I_CONS_CURR_VL = NVL(I_CONS_CURR_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ + WHERE + C_PROG = PROJ + AND P_COSTO = COSTO; + + CONS := CONS + NVL(:NEW.IMPVAL, 0); + Prclog('Fatturato: '||CONS||' Budget: '||BDG_REV||' Stima a completamento: '||STIMA ); + + -- Se l'impegnato supera il budget aumento la stima a finire + IF CONS > STIMA THEN + Prclog('Aggiorno la stima a completamento.'); + UPDATE COSTO_AGRT_T022 + SET + I_STIMA_CMPL = CONS, + I_STIMA_CMPL_VL = CONS * CAMBIOPRJ + WHERE + C_PROG = PROJ + AND P_COSTO = COSTO; + END IF; + + :NEW.STATO_IMP := 'I'; + END IF; + -- ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** + -- Movimento dalla contabilit… analitica + -- ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** + IF TIPO = 'AN' THEN + Prclog ('Movimento dalla contabilit… analitica.'); + Prclog ('Importo: '||NVL(:NEW.IMPVAL, 0)); + Prclog ('Segno: '||NVL(:NEW.IMPVAL, 0)); + Prclog ('Classe: '||TCLASSE); + IF TCLASSE = 'C' THEN + -- Costo + IF NVL(:NEW.SEGNO, 'D') = 'D' THEN + -- Dare + Prclog ('Operazione: sommo contabilizzato e maturato.'); + UPDATE COSTO_AGRT_T022 + SET + I_CNTBZ = NVL(I_CNTBZ, 0) + NVL(:NEW.IMPVAL, 0), + I_CNTBZ_VL = NVL(I_CNTBZ_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + I_CNTBZ_CURR = NVL(I_CNTBZ_CURR, 0) + NVL(:NEW.IMPVAL, 0), + I_CNTBZ_CURR_VL = NVL(I_CNTBZ_CURR_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + + I_ACEM = NVL(I_ACEM, 0) + NVL(:NEW.IMPVAL, 0), + I_ACEM_VL = NVL(I_ACEM_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + I_ACEM_CURR = NVL(I_ACEM_CURR, 0) + NVL(:NEW.IMPVAL, 0), + I_ACEM_CURR_VL = NVL(I_ACEM_CURR_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + + I_STIMA_CMPL = NVL(I_STIMA_CMPL, 0) + NVL(:NEW.IMPVAL, 0), + I_STIMA_CMPL_VL = NVL(I_STIMA_CMPL_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ + + WHERE + C_PROG = PROJ + AND P_COSTO = COSTO; + ELSE + -- Avere + Prclog ('Operazione: sottraggo contabilizzato e maturato.'); + UPDATE COSTO_AGRT_T022 + SET + I_CNTBZ = NVL(I_CNTBZ, 0) - NVL(:NEW.IMPVAL, 0), + I_CNTBZ_VL = NVL(I_CNTBZ_VL, 0) - NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + I_CNTBZ_CURR = NVL(I_CNTBZ_CURR, 0) - NVL(:NEW.IMPVAL, 0), + I_CNTBZ_CURR_VL = NVL(I_CNTBZ_CURR_VL, 0) - NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + + I_ACEM = NVL(I_ACEM, 0) + NVL(:NEW.IMPVAL, 0), + I_ACEM_VL = NVL(I_ACEM_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + I_ACEM_CURR = NVL(I_ACEM_CURR, 0) + NVL(:NEW.IMPVAL, 0), + I_ACEM_CURR_VL = NVL(I_ACEM_CURR_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + + I_STIMA_CMPL = NVL(I_STIMA_CMPL, 0) + NVL(:NEW.IMPVAL, 0), + I_STIMA_CMPL_VL = NVL(I_STIMA_CMPL_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ + + + WHERE + C_PROG = PROJ + AND P_COSTO = COSTO; + END IF; + ELSE + -- Ricavo + IF NVL(:NEW.SEGNO, 'D') = 'D' THEN + -- Dare + Prclog ('Operazione: sottraggo contabilizzato e maturato.'); + UPDATE COSTO_AGRT_T022 + SET + I_CNTBZ = NVL(I_CNTBZ, 0) - NVL(:NEW.IMPVAL, 0), + I_CNTBZ_VL = NVL(I_CNTBZ_VL, 0) - NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + I_CNTBZ_CURR = NVL(I_CNTBZ_CURR, 0) - NVL(:NEW.IMPVAL, 0), + I_CNTBZ_CURR_VL = NVL(I_CNTBZ_CURR_VL, 0) - NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + + I_ACEM = NVL(I_ACEM, 0) - NVL(:NEW.IMPVAL, 0), + I_ACEM_VL = NVL(I_ACEM_VL, 0) - NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + I_ACEM_CURR = NVL(I_ACEM_CURR, 0) - NVL(:NEW.IMPVAL, 0), + I_ACEM_CURR_VL = NVL(I_ACEM_CURR_VL, 0) - NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + + I_STIMA_CMPL = NVL(I_STIMA_CMPL, 0) - NVL(:NEW.IMPVAL, 0), + I_STIMA_CMPL_VL = NVL(I_STIMA_CMPL_VL, 0) - NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ + + WHERE + C_PROG = PROJ + AND P_COSTO = COSTO; + ELSE + -- Avere + Prclog ('Operazione: sommo contabilizzato e maturato.'); + UPDATE COSTO_AGRT_T022 + SET + I_CNTBZ = NVL(I_CNTBZ, 0) + NVL(:NEW.IMPVAL, 0), + I_CNTBZ_VL = NVL(I_CNTBZ_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + I_CNTBZ_CURR = NVL(I_CNTBZ_CURR, 0) + NVL(:NEW.IMPVAL, 0), + I_CNTBZ_CURR_VL = NVL(I_CNTBZ_CURR_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + + I_ACEM = NVL(I_ACEM, 0) + NVL(:NEW.IMPVAL, 0), + I_ACEM_VL = NVL(I_ACEM_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + I_ACEM_CURR = NVL(I_ACEM_CURR, 0) + NVL(:NEW.IMPVAL, 0), + I_ACEM_CURR_VL = NVL(I_ACEM_CURR_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + + I_STIMA_CMPL = NVL(I_STIMA_CMPL, 0) + NVL(:NEW.IMPVAL, 0), + I_STIMA_CMPL_VL = NVL(I_STIMA_CMPL_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ + + WHERE + C_PROG = PROJ + AND P_COSTO = COSTO; + END IF; + END IF; -- T_CLASSE = 'C' + +-- CNTBZ := CNTBZ + NVL(:NEW.IMPVAL, 0); +-- ACEM := ACEM + NVL(:NEW.IMPVAL, 0); +-- Prclog('Contabilizzato: '||CNTBZ||' Maturato: '||ACEM||' Budget: '||BDG_REV||' Stima a completamento: '||STIMA ); +-- -- Se il maturato o il contabilizzato superano il budget aumento la stima a finire +-- IF CNTBZ < ACEM THEN +-- CNTBZ := ACEM; +-- END IF; +-- IF (CNTBZ > STIMA) THEN +-- Prclog('Aggiorno la stima a completamento.'); +-- UPDATE COSTO_AGRT_T022 +-- SET +-- I_STIMA_CMPL = CNTBZ, +-- I_STIMA_CMPL_VL = CNTBZ * CAMBIOPRJ +-- WHERE +-- C_PROG = PROJ +-- AND P_COSTO = COSTO; +-- END IF; + + :NEW.STATO_IMP := 'I'; + + END IF; + -- ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** + -- Movimento dalla contabilit… analitica derivante da un documento. + -- ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** ***** + IF TIPO = 'FM' THEN + Prclog ('Movimento dalla contabilit… analitica derivante da un documento.'); + Prclog ('Importo: '||NVL(:NEW.IMPVAL, 0)); + Prclog ('Segno: '||NVL(:NEW.IMPVAL, 0)); + Prclog ('Classe: '||TCLASSE); + + IF TCLASSE = 'C' THEN + -- Costo + IF NVL(:NEW.SEGNO, 'D') = 'D' THEN + -- Dare + Prclog ('Contabilit… analitica, Costo, Dare (+).'); + UPDATE COSTO_AGRT_T022 + SET + I_CNTBZ = NVL(I_CNTBZ, 0) + NVL(:NEW.IMPVAL, 0), + I_CNTBZ_VL = NVL(I_CNTBZ_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + I_CNTBZ_CURR = NVL(I_CNTBZ_CURR, 0) + NVL(:NEW.IMPVAL, 0), + I_CNTBZ_CURR_VL = NVL(I_CNTBZ_CURR_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + + I_STIMA_CMPL = NVL(I_STIMA_CMPL, 0) + NVL(:NEW.IMPVAL, 0), + I_STIMA_CMPL_VL = NVL(I_STIMA_CMPL_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ + + WHERE + C_PROG = PROJ + AND P_COSTO = COSTO; + ELSE + -- Avere + Prclog ('Contabilit… analitica, Costo, Avere (-).'); + UPDATE COSTO_AGRT_T022 + SET + I_CNTBZ = NVL(I_CNTBZ, 0) - NVL(:NEW.IMPVAL, 0), + I_CNTBZ_VL = NVL(I_CNTBZ_VL, 0) - NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + I_CNTBZ_CURR = NVL(I_CNTBZ_CURR, 0) - NVL(:NEW.IMPVAL, 0), + I_CNTBZ_CURR_VL = NVL(I_CNTBZ_CURR_VL, 0) - NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + + I_STIMA_CMPL = NVL(I_STIMA_CMPL, 0) + NVL(:NEW.IMPVAL, 0), + I_STIMA_CMPL_VL = NVL(I_STIMA_CMPL_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ + + WHERE + C_PROG = PROJ + AND P_COSTO = COSTO; + END IF; + ELSE + -- Ricavo + IF NVL(:NEW.SEGNO, 'D') = 'D' THEN + -- Dare + Prclog ('Contabilit… analitica, Ricavo, Dare (-).'); + UPDATE COSTO_AGRT_T022 + SET + I_CNTBZ = NVL(I_CNTBZ, 0) - NVL(:NEW.IMPVAL, 0), + I_CNTBZ_VL = NVL(I_CNTBZ_VL, 0) - NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + I_CNTBZ_CURR = NVL(I_CNTBZ_CURR, 0) - NVL(:NEW.IMPVAL, 0), + I_CNTBZ_CURR_VL = NVL(I_CNTBZ_CURR_VL, 0) - NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + + I_STIMA_CMPL = NVL(I_STIMA_CMPL, 0) - NVL(:NEW.IMPVAL, 0), + I_STIMA_CMPL_VL = NVL(I_STIMA_CMPL_VL, 0) - NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ + + WHERE + C_PROG = PROJ + AND P_COSTO = COSTO; + ELSE + -- Avere + Prclog ('Contabilit… analitica, Ricavo, Avere (+).'); + UPDATE COSTO_AGRT_T022 + SET + I_CNTBZ = NVL(I_CNTBZ, 0) + NVL(:NEW.IMPVAL, 0), + I_CNTBZ_VL = NVL(I_CNTBZ_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + I_CNTBZ_CURR = NVL(I_CNTBZ_CURR, 0) + NVL(:NEW.IMPVAL, 0), + I_CNTBZ_CURR_VL = NVL(I_CNTBZ_CURR_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ, + + I_STIMA_CMPL = NVL(I_STIMA_CMPL, 0) + NVL(:NEW.IMPVAL, 0), + I_STIMA_CMPL_VL = NVL(I_STIMA_CMPL_VL, 0) + NVL(:NEW.IMPVAL, 0) * CAMBIOPRJ + + WHERE + C_PROG = PROJ + AND P_COSTO = COSTO; + END IF; + END IF; -- T_CLASSE = 'C' + +-- CNTBZ := CNTBZ + NVL(:NEW.IMPVAL, 0); +-- +-- Prclog('Contabilizzato: '||CNTBZ||' Budget: '||BDG_REV||' Stima a completamento: '||STIMA ); +-- -- Se il maturato o il contabilizzato superano il budget aumento la stima a finire +-- IF (CNTBZ > STIMA) THEN +-- Prclog('Aggiorno la stima a completamento.'); +-- UPDATE COSTO_AGRT_T022 +-- SET +-- I_STIMA_CMPL = CNTBZ, +-- I_STIMA_CMPL_VL = CNTBZ * CAMBIOPRJ +-- WHERE +-- C_PROG = PROJ +-- AND P_COSTO = COSTO; +-- END IF; + + :NEW.STATO_IMP := 'I'; + END IF; -- TIPO = 'FM + ELSE + PrcLog('Cambio non trovato ('||VALPRJ||').'); + END IF; -- CAMBIOPRJ > 0 + END IF; + ELSE + Prclog ('Il nome del progetto ('||:NEW.NUMCOMM||') non Š stato trovato.'); + END IF; -- PROJ > 0 +else -- Tipo documento + Prclog ('Manca il tipo documento.'); +END IF; -- Tipo documento +EXCEPTION + WHEN OTHERS THEN + Prclog ('ERRORE: '|| SQLERRM(SQLCODE)); + +END; +/ diff --git a/crpa/search.cpp b/crpa/search.cpp new file mode 100755 index 000000000..116c897bb --- /dev/null +++ b/crpa/search.cpp @@ -0,0 +1,204 @@ +error_type TContabilizzazione::search_costo_ricavo(TBill& conto, const TRiga_documento& r) +{ + TConfig conf(CONFIG_DITTA, "ve"); + _search_seq = new TToken_string((const char*)conf.get("RICERCACR","ve")); + // costruisce la stringa che controlla la ricerca del conto costo/ricavo + // Attenzione! non esegue alcun controllo di consistenza sulla corretta sequenza + // presuppone che il programma di configurazione abbia generato correttamente + // il tutto. + if (_search_seq->items() == 0) + { + error_box("Non e' abilitata alcuna ricerca per il conto di costo/ricavo in configurazione."); + return FALSE; + } + const int items = _search_seq->items(); + TLocalisamfile& cli_file = _clifo->lfile(); // YES, arriva qui dentro quando la relazione e' gia' posizionata + const bool is_cli = cli_file.get(CLI_TIPOCF) == "C"; + bool skip_art_related = FALSE; + bool skip_clifo = _clifo->bad(); + TCodiceIVA codiva(r.get(RDOC_CODIVA)); + const char t = r.tipo().tipo(); + + // Istanzia la causale del documento corrente... + const TTipo_documento& tipo = _doc->tipo(); + TString16 codcaus(tipo.causale()); + + TToken_string key; + key.add(_doc->get(DOC_TIPOCF)); + key.add(_doc->get(DOC_CODCF)); + + const TRectype & cfven = cache().get(LF_CFVEN, key); + const TString16 caus_cli(cfven.get(CFV_CODCAUS)); + + if (caus_cli.not_empty()) + codcaus = caus_cli; + _caus = new TCausale(codcaus,data_reg.year()); + + int gr,co; + long so; + + switch (t) + { + case 'O': // righe omaggio come articoli spiaccicato identico (avranno imponibile 0) + case 'M': // righe di merce + { + // posiziona l'anagrafica sull'articolo specificato sulla ..iga + TString80 codart = r.get(RDOC_CODARTMAG); + if codart.blank() + codart = r.get(RDOC_CODART); + _anamag->put(ANAMAG_CODART, codart); + if (_anamag->read() != NOERR) // se non trova l'articolo saltera' anche gmc,smc,rfa. + skip_art_related = TRUE; + + TString16 tok; + // Scorre la stringa di ricerca + for (int i=0;iget(i); + if (tok == "CF") + { + if (skip_clifo) continue; + gr = cli_file.get_int(CLI_GRUPPORIC); + co = cli_file.get_int(CLI_CONTORIC); + so = cli_file.get_long(CLI_SOTTOCRIC); + conto.set(gr,co,so); + if (conto.ok()) break; // se lo trova esce (tutti != 0) + } + else + if (tok == "CA") + { + + CHECK(_caus,"Causale documento non valida"); + if (_caus->IVA2bill(codiva,conto)) break; // se lo trova esce + } + else + if (tok == "AR") + { + if (skip_art_related) continue; + gr = _anamag->get_int(is_cli ? ANAMAG_GRUPPOV : ANAMAG_GRUPPOA); + co = _anamag->get_int(is_cli ? ANAMAG_CONTOV : ANAMAG_CONTOA); + so = _anamag->get_long(is_cli ? ANAMAG_SOTTOCV : ANAMAG_SOTTOCA); + conto.set(gr,co,so); + if (!conto.ok()) // se il conto non c'e' guarda la categoria acquisti/vendite + { + TTable *t = is_cli ? _cra : _caa; + + t->put("CODTAB",_anamag->get(is_cli ? ANAMAG_CATCONV : ANAMAG_CATCONA)); + if (t->read() == NOERR) + { + gr = atoi(t->get("S1")); + co = atoi(t->get("S2")); + so = atol(t->get("S3")); + conto.set(gr,co,so); + } + } + if (conto.ok()) break; + } + else + if (tok == "GM" || tok == "SM" || tok == "RF") + { + if (skip_art_related) continue; + const bool is_fis = tok == "RF"; + TTable * tab = is_fis ? _rfa : _gmc; + TString16 codtab(_anamag->get(is_fis ? ANAMAG_RAGGFIS : ANAMAG_GRMERC)); + if (tok == "GM" && codtab.len() > 3) + codtab.cut(3); // gli ultimi 2 si riferiscono al sottogruppo. + tab->put("CODTAB",codtab); + if (tab->read() == NOERR) + { + gr = tab->get_int(is_cli ? "I3" : "I0"); + co = tab->get_int(is_cli ? "I4" : "I1"); + so = tab->get_long(is_cli ? "I5" : "I2"); + conto.set(gr,co,so); + } + if (conto.ok()) break; + } + else + if (tok == "CV" || tok == "CC") + { + const bool is_cve = tok == "CV"; + if (is_cve && !is_cli) continue; // se e' un fornitore salta questa condizione + TTable* t = is_cve ? _cve : _cco; + TString16 cod(is_cve ? r.doc().get(DOC_CATVEN) : EMPTY_STRING); + if (cod.empty()) + { + if (skip_clifo) continue; // se non aveva trovato il cliente salta al prossimo + cod = _clifo->lfile(LF_CFVEN).get(is_cve ? CFV_CATVEN : CFV_CODCATC); + } + t->put("CODTAB",cod); + if (t->read() == NOERR) + { + const bool x =(is_cve || is_cli); + gr = t->get_int(x ? "I3" : "I0"); + co = t->get_int(x ? "I4" : "I1"); + so = t->get_long(x ? "I5": "I2"); + conto.set(gr,co,so); + } + if (conto.ok()) break; + } + } + break; // case 'M' + } + case 'P': // righe prestazione + case 'S': // righe spese + { + TTable* tab = t == 'P' ? _prs : _spp; + tab->put("CODTAB",r.get(RDOC_CODART)); + if (tab->read()==NOERR) + { + gr = tab->get_int(is_cli ? "I0" : "I3"); + co = tab->get_int(is_cli ? "I1" : "I4"); + so = tab->get_long(is_cli ? "I2" : "I5"); + conto.set(gr,co,so); + if (!is_cli && !conto.ok()) + { + gr = r.get_int("QTAGG1"); + co = r.get_int("QTAGG2"); + so = r.get_long("QTAGG3"); + conto.set(gr,co,so); + } + } + + if (!conto.find() && t == 'P') // Cerca il conto nella stringa di ricerca (solo per prestazioni) + { + TString16 tok; + // Scorre la stringa di ricerca ma solo per causale o CLI/FO + for (int i=0;iget(i); + if (tok == "CF") + { + if (skip_clifo) continue; + gr = cli_file.get_int(CLI_GRUPPORIC); + co = cli_file.get_int(CLI_CONTORIC); + so = cli_file.get_long(CLI_SOTTOCRIC); + conto.set(gr,co,so); + if (conto.ok()) break; + } + else + if (tok == "CA") + { + CHECK(_caus,"Causale documento non valida"); + if (_caus->IVA2bill(codiva,conto)) break; + } + } + } + break; // case 'P','S' + } + case 'C': + // righe sconti: vengono considerate in adjust_sconto_rows() + case 'D': // righe descrizioni (saltare) + default : + break; + } // end of switch + if (good()) + { + if (conto.ok() == 0 || !conto.find()) + { + _conto_errato = conto; + _error = conto_error; + } + } + return _error; +} + diff --git a/crpa/ts_pmc.sql b/crpa/ts_pmc.sql new file mode 100755 index 000000000..99603e3bf --- /dev/null +++ b/crpa/ts_pmc.sql @@ -0,0 +1,4 @@ +create tablespace pmc001td +datafile 'g:\oracle\appdata\crpa\pmc001td.dbf' size 32M; +create tablespace pmc001ti +datafile 'g:\oracle\appdata\crpa\pmc001ti.dbf' size 10M; diff --git a/crpa/user_pmc.sql b/crpa/user_pmc.sql new file mode 100755 index 000000000..1fddb1ede --- /dev/null +++ b/crpa/user_pmc.sql @@ -0,0 +1,8 @@ +create user pmc +identified by pmc +default tablespace pmc001td +quota unlimited on pmc001td +temporary tablespace temp; +alter user pmc +quota unlimited on pmc001ti; +grant connect, resource to pmc;