From 8810a5c3ed533d2d4f4c763f13022eb3ed8a0207 Mon Sep 17 00:00:00 2001 From: luca Date: Tue, 15 Jan 2008 16:35:22 +0000 Subject: [PATCH] Patch level :10.0 Files correlati : Ricompilazione Demo : [ ] Commento :contabilizzazione cespiti : aggiunta la parte su movimenti di vendita ed eliminazioni git-svn-id: svn://10.65.10.50/trunk@15983 c028cbd2-c16b-5b4b-a496-9718f37d4682 --- ce/ce0400a.h | 16 +-- ce/ce0400a.uml | 246 +++++----------------------------- ce/ce2101.cpp | 18 ++- ce/ce2101.h | 8 ++ ce/ce4400.cpp | 352 +++++++++++++++++++++++++++++++++++++++++++------ 5 files changed, 372 insertions(+), 268 deletions(-) diff --git a/ce/ce0400a.h b/ce/ce0400a.h index 06addda68..5aab2b0d8 100755 --- a/ce/ce0400a.h +++ b/ce/ce0400a.h @@ -33,27 +33,15 @@ #define F_ELIMCESP 306 #define F_D_ELIMCESP 307 -#define F_RIL_DIFF 308 -#define F_D_RIL_DIFF 309 +#define F_CHIUCESP 308 +#define F_D_CHIUCESP 309 #define F_RIL_QUOT 310 #define F_D_RIL_QUOT 311 -#define F_RIL_PLUS 312 -#define F_D_RIL_PLUS 313 -#define F_RIL_MIN 314 -#define F_D_RIL_MIN 315 #define F_SOPR_PAS_GR 316 #define F_SOPR_PAS_CO 317 #define F_SOPR_PAS_SO 318 #define F_SOPR_PAS_D 319 -#define F_DIFF_QUO_GR 320 -#define F_DIFF_QUO_CO 321 -#define F_DIFF_QUO_SO 322 -#define F_DIFF_QUO_D 323 -#define F_DIFF_FON_GR 324 -#define F_DIFF_FON_CO 325 -#define F_DIFF_FON_SO 326 -#define F_DIFF_FON_D 327 #define F_PLUSVAL_GR 328 #define F_PLUSVAL_CO 329 #define F_PLUSVAL_SO 330 diff --git a/ce/ce0400a.uml b/ce/ce0400a.uml index 19c35e891..6aea77786 100755 --- a/ce/ce0400a.uml +++ b/ce/ce0400a.uml @@ -167,8 +167,8 @@ END BOOLEAN F_PLUSMIN BEGIN PROMPT 2 1 "Genera anche movimenti plus/minusvalenza" - MESSAGE TRUE ENABLE,F_RIL_PLUS|ENABLE,F_D_RIL_PLUS|ENABLE,F_RIL_MIN|ENABLE,F_D_RIL_MIN|ENABLE,F_TIPOSCRIT|"",F_TIPOSCRIT|ENABLE,F_PLUSVAL_GR|ENABLE,F_PLUSVAL_CO|ENABLE,F_PLUSVAL_SO|ENABLE,F_PLUSVAL_D|REQUIRED,F_PLUSVAL_SO|ENABLE,F_MINUSVAL_GR|ENABLE,F_MINUSVAL_CO|ENABLE,F_MINUSVAL_SO|ENABLE,F_MINUSVAL_D|REQUIRED,F_MINUSVAL_SO - MESSAGE FALSE CLEAR,F_RIL_PLUS|CLEAR,F_D_RIL_PLUS|CLEAR,F_RIL_MIN|CLEAR,F_D_RIL_MIN|DISABLE,F_TIPOSCRIT|"X",F_TIPOSCRIT|CLEAR,F_PLUSVAL_GR|CLEAR,F_PLUSVAL_CO|CLEAR,F_PLUSVAL_SO|CLEAR,F_PLUSVAL_D|CLEAR,F_MINUSVAL_GR|CLEAR,F_MINUSVAL_CO|CLEAR,F_MINUSVAL_SO|CLEAR,F_MINUSVAL_D + MESSAGE TRUE ENABLE,F_TIPOSCRIT|"",F_TIPOSCRIT|ENABLE,F_PLUSVAL_GR|ENABLE,F_PLUSVAL_CO|ENABLE,F_PLUSVAL_SO|ENABLE,F_PLUSVAL_D|REQUIRED,F_PLUSVAL_SO|ENABLE,F_MINUSVAL_GR|ENABLE,F_MINUSVAL_CO|ENABLE,F_MINUSVAL_SO|ENABLE,F_MINUSVAL_D|REQUIRED,F_MINUSVAL_SO + MESSAGE FALSE DISABLE,F_TIPOSCRIT|"X",F_TIPOSCRIT|CLEAR,F_PLUSVAL_GR|CLEAR,F_PLUSVAL_CO|CLEAR,F_PLUSVAL_SO|CLEAR,F_PLUSVAL_D|CLEAR,F_MINUSVAL_GR|CLEAR,F_MINUSVAL_CO|CLEAR,F_MINUSVAL_SO|CLEAR,F_MINUSVAL_D FIELD COPLMN GROUP 9 END @@ -204,7 +204,7 @@ BEGIN GROUP 9 END -GROUPBOX DLG_NULL 78 8 +GROUPBOX DLG_NULL 78 6 BEGIN PROMPT 1 7 "" FLAGS "R" @@ -248,27 +248,27 @@ BEGIN GROUP 9 END -STRING F_RIL_DIFF 3 +STRING F_CHIUCESP 3 BEGIN - PROMPT 2 10 "Rilevazione differenze " - FIELD COAUDI + PROMPT 2 10 "Chiusura cespite " + FIELD COAUCH COPY USE F_ELIMCESP - INPUT CODCAUS F_RIL_DIFF + INPUT CODCAUS F_CHIUCESP COPY DISPLAY F_ELIMCESP - OUTPUT F_RIL_DIFF CODCAUS - OUTPUT F_D_RIL_DIFF DESCR + OUTPUT F_CHIUCESP CODCAUS + OUTPUT F_D_CHIUCESP DESCR ADD RUN CG0 -4 CHECKTYPE REQUIRED GROUP 9 END -STRING F_D_RIL_DIFF 50 35 +STRING F_D_CHIUCESP 50 35 BEGIN PROMPT 40 10 "" COPY USE F_D_ELIMCESP - INPUT DESCR F_D_RIL_DIFF + INPUT DESCR F_D_CHIUCESP COPY DISPLAY F_D_ELIMCESP - COPY OUTPUT F_RIL_DIFF + COPY OUTPUT F_CHIUCESP ADD RUN CG0 -4 CHECKTYPE REQUIRED GROUP 9 @@ -300,87 +300,35 @@ BEGIN GROUP 9 END -STRING F_RIL_PLUS 3 +GROUPBOX DLG_NULL 78 7 BEGIN - PROMPT 2 12 "Rilevazione plusvalenze " - FIELD COAUPL - COPY USE F_ELIMCESP - INPUT CODCAUS F_RIL_PLUS - COPY DISPLAY F_ELIMCESP - OUTPUT F_RIL_PLUS CODCAUS - OUTPUT F_D_RIL_PLUS DESCR - ADD RUN CG0 -4 - CHECKTYPE REQUIRED - GROUP 9 -END - -STRING F_D_RIL_PLUS 50 35 -BEGIN - PROMPT 40 12 "" - COPY USE F_D_ELIMCESP - INPUT DESCR F_D_RIL_PLUS - COPY DISPLAY F_D_ELIMCESP - COPY OUTPUT F_RIL_PLUS - ADD RUN CG0 -4 - CHECKTYPE REQUIRED - GROUP 9 -END - -STRING F_RIL_MIN 3 -BEGIN - PROMPT 2 13 "Rilevazione minusvalenze " - FIELD COAUM - COPY USE F_ELIMCESP - INPUT CODCAUS F_RIL_MIN - COPY DISPLAY F_ELIMCESP - OUTPUT F_RIL_MIN CODCAUS - OUTPUT F_D_RIL_MIN DESCR - ADD RUN CG0 -4 - CHECKTYPE REQUIRED - GROUP 9 -END - -STRING F_D_RIL_MIN 50 35 -BEGIN - PROMPT 40 13 "" - COPY USE F_D_ELIMCESP - INPUT DESCR F_D_RIL_MIN - COPY DISPLAY F_D_ELIMCESP - COPY OUTPUT F_RIL_MIN - ADD RUN CG0 -4 - CHECKTYPE REQUIRED - GROUP 9 -END - -GROUPBOX DLG_NULL 78 9 -BEGIN - PROMPT 1 14 "" + PROMPT 1 12 "" FLAGS "R" END TEXT -1 BEGIN - PROMPT 25 15 "@BGr." + PROMPT 25 13 "@BGr." END TEXT -1 BEGIN - PROMPT 31 15 "@BCo." + PROMPT 31 13 "@BCo." END TEXT -1 BEGIN - PROMPT 37 15 "@BSottoc." + PROMPT 37 13 "@BSottoc." END TEXT -1 BEGIN - PROMPT 46 15 "@BDescrizione" + PROMPT 46 13 "@BDescrizione" END NUMBER F_SOPR_PAS_GR 3 BEGIN - PROMPT 2 16 "Sopravvenienze passive " + PROMPT 2 14 "Sopravvenienze passive " FIELD GRCOTELI FLAGS "R" USE LF_PCON KEY 1 SELECT CONTO="" @@ -395,7 +343,7 @@ END NUMBER F_SOPR_PAS_CO 3 BEGIN - PROMPT 31 16 "" + PROMPT 31 14 "" FIELD COCOTELI FLAGS "R" USE LF_PCON KEY 1 SELECT ((CONTO!="")&&(SOTTOCONTO="")) @@ -415,7 +363,7 @@ END NUMBER F_SOPR_PAS_SO 6 BEGIN - PROMPT 37 16 "" + PROMPT 37 14 "" FIELD SOCOTELI FLAGS "R" USE LF_PCON KEY 1 SELECT SOTTOCONTO!="" @@ -437,7 +385,7 @@ END STRING F_SOPR_PAS_D 50 29 BEGIN - PROMPT 46 16 "" + PROMPT 46 14 "" USE LF_PCON KEY 2 SELECT SOTTOCONTO!="" INPUT DESCR F_SOPR_PAS_D DISPLAY "Descrizione@50" DESCR @@ -452,135 +400,9 @@ BEGIN GROUP 9 END -NUMBER F_DIFF_QUO_GR 3 -BEGIN - PROMPT 2 17 "Differenze su quote " - FIELD GRCOTDIQ - FLAGS "R" - COPY USE F_SOPR_PAS_GR - INPUT GRUPPO F_DIFF_QUO_GR - COPY DISPLAY F_SOPR_PAS_GR - OUTPUT F_DIFF_QUO_GR GRUPPO - ADD RUN CG0 -0 - CHECKTYPE REQUIRED - GROUP 9 -END - -NUMBER F_DIFF_QUO_CO 3 -BEGIN - PROMPT 31 17 "" - FIELD COCOTDIQ - FLAGS "R" - COPY USE F_SOPR_PAS_CO - COPY INPUT F_DIFF_QUO_GR - INPUT CONTO F_DIFF_QUO_CO - COPY DISPLAY F_SOPR_PAS_CO - OUTPUT F_DIFF_QUO_GR GRUPPO - OUTPUT F_DIFF_QUO_CO CONTO - ADD RUN CG0 -0 - CHECKTYPE REQUIRED - VALIDATE REQIF_FUNC 1 F_DIFF_QUO_SO - WARNING "Manca il conto" - GROUP 9 -END - -NUMBER F_DIFF_QUO_SO 6 -BEGIN - PROMPT 37 17 "" - FIELD SOCOTDIQ - FLAGS "R" - COPY USE F_SOPR_PAS_SO - COPY INPUT F_DIFF_QUO_CO - INPUT SOTTOCONTO F_DIFF_QUO_SO - COPY DISPLAY F_SOPR_PAS_SO - OUTPUT F_DIFF_QUO_SO SOTTOCONTO - OUTPUT F_DIFF_QUO_GR GRUPPO - OUTPUT F_DIFF_QUO_CO CONTO - OUTPUT F_DIFF_QUO_D DESCR - ADD RUN CG0 -0 - CHECKTYPE REQUIRED - GROUP 9 -END - -STRING F_DIFF_QUO_D 50 29 -BEGIN - PROMPT 46 17 "" - USE LF_PCON KEY 2 - INPUT DESCR F_DIFF_QUO_D - COPY DISPLAY F_SOPR_PAS_D - COPY OUTPUT F_DIFF_QUO_SO - ADD RUN CG0 -0 - CHECKTYPE REQUIRED - WARNING "Manca la descrizione" - GROUP 9 -END - -NUMBER F_DIFF_FON_GR 3 -BEGIN - PROMPT 2 18 "Differenze su fondi " - FIELD GRCOTDIF - FLAGS "R" - COPY USE F_SOPR_PAS_GR - INPUT GRUPPO F_DIFF_FON_GR - COPY DISPLAY F_SOPR_PAS_GR - OUTPUT F_DIFF_FON_GR GRUPPO - ADD RUN CG0 -0 - CHECKTYPE REQUIRED - GROUP 9 -END - -NUMBER F_DIFF_FON_CO 3 -BEGIN - PROMPT 31 18 "" - FIELD COCOTDIF - FLAGS "R" - COPY USE F_SOPR_PAS_CO - COPY INPUT F_DIFF_FON_GR - INPUT CONTO F_DIFF_FON_CO - COPY DISPLAY F_SOPR_PAS_CO - OUTPUT F_DIFF_FON_GR GRUPPO - OUTPUT F_DIFF_FON_CO CONTO - ADD RUN CG0 -0 - CHECKTYPE REQUIRED - VALIDATE REQIF_FUNC 1 F_DIFF_FON_SO - WARNING "Manca il conto" - GROUP 9 -END - -NUMBER F_DIFF_FON_SO 6 -BEGIN - PROMPT 37 18 "" - FIELD SOCOTDIF - FLAGS "R" - COPY USE F_SOPR_PAS_SO - COPY INPUT F_DIFF_FON_CO - INPUT SOTTOCONTO F_DIFF_FON_SO - COPY DISPLAY F_SOPR_PAS_SO - OUTPUT F_DIFF_FON_SO SOTTOCONTO - OUTPUT F_DIFF_FON_GR GRUPPO - OUTPUT F_DIFF_FON_CO CONTO - OUTPUT F_DIFF_FON_D DESCR - ADD RUN CG0 -0 - CHECKTYPE REQUIRED - GROUP 9 -END - -STRING F_DIFF_FON_D 50 29 -BEGIN - PROMPT 46 18 "" - USE LF_PCON KEY 2 - INPUT DESCR F_DIFF_FON_D - COPY DISPLAY F_SOPR_PAS_D - COPY OUTPUT F_DIFF_FON_SO - ADD RUN CG0 -0 - CHECKTYPE REQUIRED - WARNING "Manca la descrizione" - GROUP 9 -END - NUMBER F_PLUSVAL_GR 3 BEGIN - PROMPT 2 19 "Plusvalenze " + PROMPT 2 15 "Plusvalenze " FIELD GRCOTPLU FLAGS "R" COPY USE F_SOPR_PAS_GR @@ -594,7 +416,7 @@ END NUMBER F_PLUSVAL_CO 3 BEGIN - PROMPT 31 19 "" + PROMPT 31 15 "" FIELD COCOTPLU FLAGS "R" USE LF_PCON KEY 1 SELECT ((CONTO!="")&&(SOTTOCONTO="")&&(INDBIL==4)) @@ -612,7 +434,7 @@ END NUMBER F_PLUSVAL_SO 6 BEGIN - PROMPT 37 19 "" + PROMPT 37 15 "" FIELD SOCOTPLU FLAGS "R" COPY USE F_SOPR_PAS_SO @@ -631,7 +453,7 @@ END STRING F_PLUSVAL_D 50 29 BEGIN - PROMPT 46 19 "" + PROMPT 46 15 "" USE LF_PCON KEY 2 INPUT DESCR F_PLUSVAL_D COPY DISPLAY F_SOPR_PAS_D @@ -644,7 +466,7 @@ END NUMBER F_MINUSVAL_GR 3 BEGIN - PROMPT 2 20 "Minusvalenze " + PROMPT 2 16 "Minusvalenze " FIELD GRCOTMIN FLAGS "R" COPY USE F_SOPR_PAS_GR @@ -658,7 +480,7 @@ END NUMBER F_MINUSVAL_CO 3 BEGIN - PROMPT 31 20 "" + PROMPT 31 16 "" FIELD COCOTMIN FLAGS "R" USE LF_PCON KEY 1 SELECT ((CONTO!="")&&(SOTTOCONTO="")&&(INDBIL==3)) @@ -676,7 +498,7 @@ END NUMBER F_MINUSVAL_SO 6 BEGIN - PROMPT 37 20 "" + PROMPT 37 16 "" FIELD SOCOTMIN FLAGS "R" COPY USE F_SOPR_PAS_SO @@ -695,7 +517,7 @@ END STRING F_MINUSVAL_D 50 29 BEGIN - PROMPT 46 20 "" + PROMPT 46 16 "" USE LF_PCON KEY 2 INPUT DESCR F_MINUSVAL_D COPY DISPLAY F_SOPR_PAS_D @@ -708,7 +530,7 @@ END NUMBER F_VEND_CESP_GR 3 BEGIN - PROMPT 2 21 "Vendite cespiti " + PROMPT 2 17 "Vendite cespiti " FIELD GRCOTVEN FLAGS "R" COPY USE F_SOPR_PAS_GR @@ -722,7 +544,7 @@ END NUMBER F_VEND_CESP_CO 3 BEGIN - PROMPT 31 21 "" + PROMPT 31 17 "" FIELD COCOTVEN FLAGS "R" COPY USE F_SOPR_PAS_CO @@ -740,7 +562,7 @@ END NUMBER F_VEND_CESP_SO 6 BEGIN - PROMPT 37 21 "" + PROMPT 37 17 "" FIELD SOCOTVEN FLAGS "R" COPY USE F_SOPR_PAS_SO @@ -758,7 +580,7 @@ END STRING F_VEND_CESP_D 50 29 BEGIN - PROMPT 46 21 "" + PROMPT 46 17 "" USE LF_PCON KEY 2 INPUT DESCR F_VEND_CESP_D COPY DISPLAY F_SOPR_PAS_D diff --git a/ce/ce2101.cpp b/ce/ce2101.cpp index d2e3af562..3dc7158f8 100755 --- a/ce/ce2101.cpp +++ b/ce/ce2101.cpp @@ -1501,12 +1501,23 @@ void TCespite::elabora_mov_neg(TRelation& rel, TRectype& tmv, TRectype& tmvam) if (!apv) // Se non ho calcolato allora azzero zero_fields(ammmv, AMMMV_PNOR, AMMMV_PACC, AMMMV_PANT, AMMMV_QNOR, AMMMV_QACC, AMMMV_QANT, AMMMV_QPERSE, AMMMV_FPRIVATO, AMMMV_QPPRIVATE, NULL); - - if (tmc.get_bool("B5")) // Calcolo plus/minus valenza + + const bool cpm = tmc.get_bool("B5"); + if (cpm) // Calcolo plus/minus valenza cal_valenza(tmv, tmvam, ammmv); if (!_in_memory) rel.lfile(LF_AMMMV).rewrite(); + else //se e' _in_memory deve aggiornare il record _ammmv che sara' passato al programma di collegamento... + //..cespiti con contabilita' + { + if (apv || cpm) + { + _movce.add(tmv); + _movam.add(tmvam); + _ammmv.add(ammmv); + } + } } // Scandisce tutti i movimenti del cespite fino alla data_limite @@ -2059,6 +2070,9 @@ int TCespite::read(const char* id) zero(); _salini.zero(); _salpro.zero(); _ammini.zero(); _ammpro.zero(); + _ammmv.destroy(); + _movam.destroy(); + _movce.destroy(); return err; } diff --git a/ce/ce2101.h b/ce/ce2101.h index 933020ef2..e2b032206 100755 --- a/ce/ce2101.h +++ b/ce/ce2101.h @@ -14,7 +14,10 @@ class TCespite : public TRectype int _tipo_sit; TRectype _salini, _salpro; TRectype _ammini, _ammpro; + + //parametri per il calcolo in memoria utilizzato per proiezioni contabili bool _in_memory; + TArray _movce, _movam, _ammmv; real _fraction; protected: @@ -92,6 +95,11 @@ public: real val_amm() const; real res_amm() const; + //metodi per collegamento contabilita' + const TArray& movce() const { return _movce; } + const TArray& ammmv() const { return _ammmv; } + const TArray& movam() const { return _movam; } + int read(const char* id); void load_saldi(const int tiposit, const int esercizio); TCespite(); diff --git a/ce/ce4400.cpp b/ce/ce4400.cpp index b117c3fd5..ee368387e 100755 --- a/ce/ce4400.cpp +++ b/ce/ce4400.cpp @@ -14,6 +14,8 @@ #include "ammce.h" #include "cespi.h" +#include "movam.h" +#include "movce.h" //=============================================================================================== //maschera @@ -56,6 +58,32 @@ bool TTrasf_mov_ce_cg_mask::on_field_event(TOperable_field& o, TField_event e, l } +//============================================================================================== +// Metodi static che servono in giro + +static long get_new_numreg() +{ + TLocalisamfile mov(LF_MOV); + mov.last(); + //primo numero libero da usare come numreg + return mov.curr().get_long(MOV_NUMREG) + 1; +} + +static void fill_head(TRectype& head, const TDate& datacomp, const TDate& datareg, + const long numreg, const TString& codcaus, const bool definitivo) +{ + TEsercizi_contabili esc; + const int codes = esc.date2esc(datacomp); + head.put(MOV_ANNOES, codes); + head.put(MOV_NUMREG, numreg); + head.put(MOV_DATAREG, datareg); + head.put(MOV_DATACOMP, datacomp); + head.put(MOV_CODCAUS, codcaus); + if (!definitivo) + head.put(MOV_PROVVIS, 'C'); +} + + //=============================================================================================== //Rectype da utilizzare per la creazione delle righe movimento contabili. Deriva da LF_RMOV ma ha.. //..3 valori in piu' (gruppo,specie,categoria) che servono per gli ordinamenti in fase di generazione.. @@ -81,7 +109,10 @@ const TRectype& TRigamov::categoria() const const TString& TRigamov::descr_categoria() const { - return ditta_cespiti().categoria(_grp, _spc, _cat, false).get("S0"); + TString& wrkstring = get_tmp_string(); + wrkstring << _grp << ' ' << _spc << ' ' << _cat << ' ' ; + wrkstring << ditta_cespiti().categoria(_grp, _spc, _cat, false).get("S0"); + return wrkstring; } //confrontatore di saldi_per_codice @@ -113,6 +144,8 @@ struct TSaldo_per_codice :public TSortable virtual int compare(const TSortable& s) const; const TRectype& categoria() const; + const TString& descr_categoria() const; + int compila_rmov(const int tipo, const int riga_nor, TArray& righe_mov, TLog_report& log, const int movdett) const; int genera_righe(TArray& righe_mov, TLog_report& log, const int movdett) const; @@ -177,7 +210,6 @@ int TSaldo_per_codice::compila_rmov(const int tipo, const int riga_nor, TArray& case 1: quota = _qnor; pos = 24; break; case 2: quota = _qant; pos = 36; break; case 3: quota = _qacc; pos = 48; break; -// case 4: quota = _qperse; pos = 0; field = "S2"; break; default: break; } if (quota <= ZERO) @@ -192,8 +224,7 @@ int TSaldo_per_codice::compila_rmov(const int tipo, const int riga_nor, TArray& if (tipo == 1 || !str2bill(stringona, pos, zio)) { TString msg; - msg << TR("Manca il conto per le quote ammortamento normali della categoria ") - << _grp << " " << _spc << " " << _cat; + msg << TR("Manca il conto per le quote ammortamento normali della categoria ") << descr_categoria(); log.log(2, msg); return -1; } @@ -273,6 +304,13 @@ const TRectype& TSaldo_per_codice::categoria() const return ditta_cespiti().categoria(_grp, _spc, _cat, true); } +const TString& TSaldo_per_codice::descr_categoria() const +{ + TString& wrkstring = get_tmp_string(); + wrkstring << _grp << ' ' << _spc << ' ' << _cat << ' ' ; + wrkstring << ditta_cespiti().categoria(_grp, _spc, _cat, false).get("S0"); + return wrkstring; +} //=============================================================================================== //TMovimentoPN_CE @@ -382,6 +420,231 @@ TRectype& TMovimentoPN_CE::nuova_riga(const TRectype& row) return riga; } + +//=============================================================================================== +//TAmmortamento_per_cespite + +class TPlus_minus : public TSaldo_per_codice +{ + TArray _ammmv, _movam, _movce; + +public: + void genera_mov_elim_ven(TConfig& config_ditta_ce, const TDate& datacomp, const TDate& datareg, + const bool definitivo, TLog_report& log) const; + TPlus_minus(const int gruppo, const TString& specie, const int categoria, + const TArray& ammmv, const TArray& movam, const TArray& movce) + : TSaldo_per_codice(gruppo, specie, categoria), _ammmv(ammmv), _movam(movam), _movce(movce) {} +}; + +//metodo per la generazione dei movimenti dovuti a plus/minus +void TPlus_minus::genera_mov_elim_ven(TConfig& config_ditta_ce, const TDate& datacomp, const TDate& datareg, + const bool definitivo, TLog_report& log) const +{ + //parametri da utilizzare piu' volte + TString4 codcaus; + //conti fondo, immobilizzo, sopravenienza passiva, plusvalenza, minusvalenza cespite + const TString& stringona = categoria().get("S1"); + + TBill zio_fondo; + str2bill(stringona, 12, zio_fondo); + if (!zio_fondo.find()) + { + TString msg; + msg << TR("Conto del fondo errato o mancante per la categoria ") << descr_categoria(); + log.log(2, msg); + return; + } + TBill zio_immobilizzo; + str2bill(stringona, 0, zio_immobilizzo); + if (!zio_immobilizzo.find()) + { + TString msg; + msg << TR("Conto di immobilizzo errato o mancante per la categoria ") << descr_categoria(); + log.log(2, msg); + return; + } + + //Riempie i campi della testata movimento + long numreg = get_new_numreg(); + + //attenzione!! ci possono essere piu' movimenti per lo stesso cespite!!! -> ciclo sui movce.items() + for (int i = 0; i < _movce.items(); i++) + { + const TRectype& movce = (const TRectype&)_movce[i]; + const TRectype& movam = (const TRectype&)_movam[i]; + + //causale movimento + const real impven = movce.get_real(MOVCE_IMPVEN); + const bool eliminazione = impven == ZERO; + + if (eliminazione) + codcaus = config_ditta_ce.get("COAUEL"); + else + codcaus = config_ditta_ce.get("COAUCH"); + + if (codcaus.empty()) + { + TString msg; + msg << TR("Causale di vendita o eliminazione mancante"); + log.log(2, msg); + return; + } + + //movimento contabile + TMovimentoPN_CE pn; + TRectype& head = pn.curr(); + + fill_head(head, datacomp, datareg, numreg, codcaus, definitivo); + head.put(MOV_DESCR, movce.get(MOVCE_DESC)); + numreg ++; //incrementa il numreg per l'eventuale testata successiva + + //Aggiunge le righe + //le prime 2 righe sono comuni a tutti i tipi di movimento (esistono solo con importo non nullo) + + //riga 1: fondo + const real val_fondo_cesp = movam.get_real(MOVAM_QNOR) + movam.get_real(MOVAM_QANT) + movam.get_real(MOVAM_QACC); + if (!val_fondo_cesp.is_zero()) + { + TRectype& riga_fondo = pn.nuova_riga(); + riga_fondo.put(RMV_SEZIONE, 'D'); + riga_fondo.put(RMV_IMPORTO, val_fondo_cesp); //somma qnor+qant+qacc in movam); + zio_fondo.put(riga_fondo); + riga_fondo.put(RMV_DESCR, TR("Fondo")); + } + + //riga 2: immobilizzo + const real val_imm_cesp = movce.get_real(MOVCE_CSTO); + if (!val_imm_cesp.is_zero()) + { + TRectype& riga_immobilizzo = pn.nuova_riga(); + riga_immobilizzo.put(RMV_SEZIONE, 'A'); + riga_immobilizzo.put(RMV_IMPORTO, val_imm_cesp); + zio_immobilizzo.put(riga_immobilizzo); + riga_immobilizzo.put(RMV_DESCR, TR("Immobilizzo")); + } + + //le successive righe dipendono dai parametri del config_ditta_ce e dalla differenza di importi riga2-riga1 + const real val_sopravv_pass = val_imm_cesp - val_fondo_cesp; + if (eliminazione) //caso di ELIMINAZIONE cespite: + { + //riga 3: sopravenienza passiva (SOLO se movimento sbilanciato!) + if (!val_sopravv_pass.is_zero()) + { + TRectype& riga_sopravv = pn.nuova_riga(); + riga_sopravv.put(RMV_SEZIONE, 'D'); + riga_sopravv.put(RMV_IMPORTO, val_sopravv_pass); + TBill zio_sopravv(config_ditta_ce.get_int("GRCOTELI"), config_ditta_ce.get_int("COCOTELI"), + config_ditta_ce.get_long("SOCOTELI")); + if (!zio_sopravv.find()) + { + TString msg; + msg << TR("Conto di sopravvenienza errato o mancante"); + log.log(2, msg); + return; + } + zio_sopravv.put(riga_sopravv); + riga_sopravv.put(RMV_DESCR, TR("Sopravenienza passiva")); + } + } + else //caso di VENDITA cespite: + { + //riga 3: vendita; parte comune (anche questa, come le altre, deve avere importo non nullo) + if (!impven.is_zero()) + { + TRectype& riga_ven = pn.nuova_riga(); + riga_ven.put(RMV_SEZIONE, 'D'); + riga_ven.put(RMV_IMPORTO, impven); + + const bool tiposcrit = config_ditta_ce.get_bool("COR5PM"); + if (tiposcrit) //tipo scrittura per vendita: su conto cespite (conto in categoria CCC) + { + zio_immobilizzo.put(riga_ven); + riga_ven.put(RMV_DESCR, TR("Vendita su conto cespite")); + } + else //tipo scrittura per vendita: su conto vendita (conto in configurazione ditta) + { + TBill zio_vendita(config_ditta_ce.get_int("GRCOTVEN"), config_ditta_ce.get_int("COCOTVEN"), + config_ditta_ce.get_long("SOCOTVEN")); + if (!zio_vendita.find()) + { + TString msg; + msg << TR("Conto di vendita cespite errato o mancante"); + log.log(2, msg); + return; + } + zio_vendita.put(riga_ven); + riga_ven.put(RMV_DESCR, TR("Vendita su conto vendita")); + } + } //if(!impven.is_zero... + + //riga 4: plus/minus-valenza + TImporto imp_fondo('D', val_fondo_cesp); + TImporto imp_immobilizzo('A', val_imm_cesp); + TImporto imp_ven('D', impven); + TImporto imp_valenza = imp_fondo; + imp_valenza += imp_immobilizzo; + imp_valenza += imp_ven; + + if (!imp_valenza.is_zero()) //SOLO se movimento sbilanciato dopo le prime 3 righe, ovvero come le precedenti + { + imp_valenza.swap_section(); + imp_valenza.normalize(); + + TRectype& riga_valenza = pn.nuova_riga(); + const char sezione_valenza = imp_valenza.sezione(); + riga_valenza.put(RMV_SEZIONE, sezione_valenza); + riga_valenza.put(RMV_IMPORTO, imp_valenza.valore()); + + if (sezione_valenza == 'A') //plusvalenza + { + TBill zio_plus(config_ditta_ce.get_int("GRCOTPLU"), config_ditta_ce.get_int("COCOTPLU"), + config_ditta_ce.get_long("SOCOTPLU")); + if (!zio_plus.find()) + { + TString msg; + msg << TR("Conto di plusvalenza errato o mancante"); + log.log(2, msg); + return; + } + zio_plus.put(riga_valenza); + riga_valenza.put(RMV_DESCR, TR("Plusvalenza")); + } + else //minusvalenza + { + TBill zio_minus(config_ditta_ce.get_int("GRCOTMIN"), config_ditta_ce.get_int("COCOTMIN"), + config_ditta_ce.get_long("SOCOTMIN")); + if (!zio_minus.find()) + { + TString msg; + msg << TR("Conto di minusvalenza errato o mancante"); + log.log(2, msg); + return; + } + zio_minus.put(riga_valenza); + riga_valenza.put(RMV_DESCR, TR("Minusvalenza")); + } + } //if(!imp_valenza.is_zero... + } //else di if(eliminazione... + + //finalmente scrive sul file qesti movimenti... + int err = pn.write(); + if (err != NOERR) + { + TString msg; + msg << TR("Impossibile registrare il movimento ") << numreg << "\n"; + log.log(2, msg); + } + else + { + TString msg; + msg << TR("Registrato movimento ") << numreg << TR(" da movimento cespite ") << movce.get_long(MOVCE_IDMOV) << "\n"; + log.log(0, msg); + } + + } //for(int i=0;... (ciclo sui movimenti di un cespite) +} + + //=============================================================================================== //Applicazione @@ -398,9 +661,6 @@ protected: void genera_mov(TArray& righe_mov, const TDate& datareg, const TDate& datacomp, const TString& codcaus, const int movdett, const bool definitivo, TLog_report& log); void delete_old_movs(const TDate& ini_es); - long get_new_numreg() const; - void fill_head(TRectype& head, const TDate& datacomp, const TDate& datareg, - const long numreg, const TString& codcaus, const bool definitivo); public: @@ -431,27 +691,7 @@ void TTrasf_mov_ce_cg::delete_old_movs(const TDate& ini_es) } -long TTrasf_mov_ce_cg::get_new_numreg() const -{ - TLocalisamfile mov(LF_MOV); - mov.last(); - //primo numero libero da usare come numreg - return mov.curr().get_long(MOV_NUMREG) + 1; -} -void TTrasf_mov_ce_cg::fill_head(TRectype& head, const TDate& datacomp, const TDate& datareg, - const long numreg, const TString& codcaus, const bool definitivo) -{ - TEsercizi_contabili esc; - const int codes = esc.date2esc(datacomp); - head.put(MOV_ANNOES, codes); - head.put(MOV_NUMREG, numreg); - head.put(MOV_DATAREG, datareg); - head.put(MOV_DATACOMP, datacomp); - head.put(MOV_CODCAUS, codcaus); - if (!definitivo) - head.put(MOV_PROVVIS, 'C'); -} //metodo per la generazione di movimenti con righe per categoria (chiamata se movdett=0) void TTrasf_mov_ce_cg::genera_mov(TArray& righe_mov, const TDate& datareg, const TDate& datacomp, const TString& codcaus, @@ -499,7 +739,7 @@ void TTrasf_mov_ce_cg::genera_mov(TArray& righe_mov, const TDate& datareg, const riga_fondo.put(RMV_GRUPPO, stringone.mid(12,3)); riga_fondo.put(RMV_CONTO, stringone.mid(15,3)); riga_fondo.put(RMV_SOTTOCONTO, stringone.mid(18,6)); - const TString& descat = prev_riga_mov.descr_categoria(); + const TString descat = prev_riga_mov.descr_categoria(); riga_fondo.put(RMV_DESCR, descat); //se il movimento supera le 95 righe va salvato sul file MOV, poi distrutto per poter costruirne uno nuovo.. @@ -568,10 +808,6 @@ void TTrasf_mov_ce_cg::elabora() else datacalc = _mask->get_date(F_DATACALC); - //programma vero e proprio (calcolo ammortamenti, selezione cespiti validi, trasferimento) - TISAM_recordset cespiti("USE CESPI"); - const TRecnotype nrec = cespiti.items(); - //report con log errori TLog_report cont_cesp_log(TR("Contabilizzazione cespiti")); cont_cesp_log.kill_duplicates(); @@ -584,9 +820,19 @@ void TTrasf_mov_ce_cg::elabora() const int movdett = config_ditta_ce.get_int("MOVDETT"); //Codice causale da mettere nei movimenti generati const TString4 codcaus = config_ditta_ce.get("COAUQU"); + //Genera movimenti plus/minus? Parametro decisivo per poter generare movimenti cg da movimenti ce + const bool mov_plusmin = config_ditta_ce.get_bool("COPLMN"); + +//********************************************************************************** +// 1) Generazione movimenti CG da ammortamenti +//********************************************************************************** + //programma vero e proprio (calcolo ammortamenti, selezione cespiti validi, trasferimento) + TISAM_recordset cespiti("USE CESPI"); + const TRecnotype nrec = cespiti.items(); //Assoc_array Categoria-QammTot TAssoc_array quote_per_codice; + TArray ammo_plus_minus; TProgind pi(nrec, TR("Ricalcolo ammortamenti in corso..."), true, true); for (int i = 0; cespiti.move_to(i); i++) @@ -626,6 +872,19 @@ void TTrasf_mov_ce_cg::elabora() } //..e poi somma i valori comunque sc->add(rec_ammce); + + //Parte relativa ad AMMMV (per generazione movimenti cg da movim. cespiti) + if (mov_plusmin) + { + const TArray& ammmv = cespite.ammmv(); + const TArray& movam = cespite.movam(); + const TArray& movce = cespite.movce(); + + TPlus_minus* pm = new TPlus_minus(gruppo, specie, codcat, ammmv, movam, movce); + ammo_plus_minus.add(pm); + + } + } } //for(int i... @@ -653,20 +912,33 @@ void TTrasf_mov_ce_cg::elabora() //a questo punto ha l'array con le righe movimento CG completo (righe_mov); da queste righe deve costruire.. //..uno o piu' movimenti di prima nota //In base al movdett li creera' con righe per categoria o per cespite ma con fondi per categoria - //E' un metodo semimagico + //E' un metodo semimagico! genera_mov(righe_mov, datareg, datacomp, codcaus, movdett, definitivo, cont_cesp_log); - - //stampa il log degli errori +//********************************************************************************** +// 2) Generazione movimenti CG da movimenti cespiti di vendita/eliminazione +//********************************************************************************** + //solo se in configurazione ditta cespiti e' attivo il flag di generazione movimenti plus/minus... + if (mov_plusmin) + { + //controllo sul numero righe dell'array (serve solo per controllo al sagace programmatore...) + const int nrigheammo = ammo_plus_minus.items(); + + //scandisce l'array con i valori per i movimenti di plus/minus creando un movimento cg per ognuno + FOR_EACH_ARRAY_ITEM(ammo_plus_minus, riga, pmobj) + { + const TPlus_minus& pm = *(const TPlus_minus*)pmobj; + pm.genera_mov_elim_ven(config_ditta_ce, datacomp, datareg, definitivo, cont_cesp_log); + } + } + +//*************************************** +// 3) stampa il log degli errori +//*************************************** TReport_book book; book.add(cont_cesp_log); book.preview(); - - - //calcolati,se richiesti,gli ammortamenti, passa in rassegna AMMCE e AMMMV alla ricerca dei cespiti.. - //..da considerare per il trasferimento vero e proprio (sono quelli - } bool TTrasf_mov_ce_cg::create()