// // Ricezione dati: lista controllo movimenti // #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "cglib01.h" #include "cglib04.h" #include "cg6700.h" class TRic_ListaMov : public TPrintapp { TTable* _tab_tra,* _tab_pag,* _tab_tpd,* _tab_iva, *_tab_ese; TIsamtempfile* _tmov,* _trmov,* _tiva,* _tpart,* _tscad,* _tpagsca; TLocalisamfile* _caus,* _ditte,* _clifo,* _pcon, *_mov, *_rmov, *_rmoviva; TLocalisamfile* _part,* _scad,* _pagsca; TRelation* _rel, *_relSC; //TCursor* _cur, *_curSC; int _cur, _curSC; TTransfer_file* _trasfer; TLibro_giornale* _giornale; TEsercizi_contabili _ec; char _ric_auto,_tipo_lista; TFilename _pathfile; TString _descr_causale, _descr_conto; TString16 _causale, _registro, _numdoc, _tipodoc, _codval; TString16 _codpag, _codiva, _tipo_conto; TString _record, _numpart, _descr_anag, _descr_pag, _tipom_cau, _codval_part, _codpag_scad,_reg; bool _mov_sez, _errore_grave, _esiste_conto, _seconda_volta, _errore_grave_SC; bool _is_iva, _is_salda, _risposta, _continua, _intestaSC, _errore_grave_totale; bool _prima_volta,_calcola,_prima_rata_pag,_ho_stampato; char _sdt, _sezione, _tipocf, _sez, _tipocf_p; int _ae, _anno, _gruppo, _conto, _tipocr, _tipod, _tiporeg, _tipomov, _tipopag, _nriga; int _gruppoc, _contoc, _gruppocr, _contocr, _annoiva, _gruppocl, _contocl, _numrig, _annoese; int _gruppo_p, _conto_p, _anno_prec; TDate _datacomp, _datadoc, _datareg, _data74tr, _datacam, _datacam_part,_datapag; real _importo, _impo, _impos, _tot_dare, _tot_avere, _tot_doc, _tot_val; real _cambio, _cambio_part, _impo_print, _impos_print; long _codcf, _numero, _protiva, _sottoconto, _numreg; long _sottocontoc, _sottocontocr, _codcf_p; TBit_array _err; byte _controllo; real _imp,_impval; TString _numpart_prec; int _tipopag_pag; protected: char sezione_ritsoc(const TRectype& part) const; real segno_ritsoc(const TRectype& part) const; public: virtual bool check_autorization() const {return FALSE;} virtual bool set_print(int m); virtual bool user_create() ; virtual bool user_destroy(); virtual bool preprocess_page(int,int); virtual bool preprocess_print(int,int); virtual print_action postprocess_page(int,int); virtual print_action postprocess_print(int file, int counter); virtual void postclose_print(); char look_sdt(); const char* get_codiva_des(const char*); bool DescrConto(int,int,long); bool check_archivi(); bool look_pag(); bool errori_partita(int,int,long); bool controlla_mov(); bool controlla_rmov(); bool controlla_riva(); void stampa_errori_mov(int); void stampa_errori_rmov(int); void stampa_errori_riva(int); void aggiorna_mov(); void aggiorna_rmov(char tipoc, char tipocc); void aggiorna_iva(char tipo); void setta_parametri(const TString&, const TString&); void setta_intestazione(); char TipoConto(int g, int c); // Funzioni per lista controllo movimenti saldaconto bool controlla_partite(); void stampa_errori_partite(int riga); bool controlla_scadenze(); void stampa_errori_scadenze(int riga); bool controlla_pagsca(); void stampa_errori_pagsca(int riga); bool controlla_anaCF_Pcon(char tipocf,int gruppo,int conto,long codcf); bool controlla_anagrafica(char tipo, int gruppo, int conto); bool cerca_codpag(TString& codpag); bool cerca_tipopag_codpag(TString& codpag, int tipopag); bool ulteriore_classificazione(int tipopag, TString& ultclass); bool banca(long abi,long cab); bool agente(const char* codag) const; bool record_partite(int nriga); bool record_scadenze(int nriga,int nrata); void descrizione_pagamento(TString& descr,int tipopag,TString& ultclass,TString& codpag); void esamina_partite(); void aggiorna_partite(); bool solo_SC(long numreg); void calcola_imposta(long numreg, real& imposta); bool calcola_impdocval(long nreg,int nrig,char tipo,int g,int c, long s,int anno,TString& numpart,int nriga,real& doc,real& val); void calcola_importo(char tipo,int g,int c,long s,int anno,TString& numpart,int nriga); void aggiorna_partita(real& importo,real& importoval,real& abbuoni,real& diffcam, real& ritfis,real& ritsoc,TString& sez,TString& sezabb,TString& sezdc); void azzera_impdocval(); int cerca_anno_solare_esercizio(int codice_esercizio); bool esiste_rata(); const char * get_error(int err); void apri_file_SC(); void chiudi_file_SC(); TLibro_giornale& giornale() { return *_giornale; } TTransfer_file& trasfer() { return *_trasfer; } TRic_ListaMov(char ric_auto = '\0',char tipo_lista = '\0'); virtual ~TRic_ListaMov() {} }; HIDDEN inline TRic_ListaMov& app() { return (TRic_ListaMov&)main_app();} TRic_ListaMov::TRic_ListaMov(char ric_auto,char tipo_lista): _ric_auto(toupper(ric_auto)), _tipo_lista(toupper(tipo_lista)), _err(80) {} char TRic_ListaMov::look_sdt() { TConfig conf(CONFIG_DITTA); return conf.get("FlStTra")[0]; } bool TRic_ListaMov::look_pag() { TTable t ("%CPG"); t.zero(); t.put("CODTAB",_codpag); if (t.read() != NOERR) return FALSE; return TRUE; } const char* TRic_ListaMov::get_codiva_des(const char* codiva) { TTable iva ("%IVA"); iva.zero(); iva.put("CODTAB", codiva); if (iva.read() == NOERR) return iva.get("S0"); else return NULL; } bool TRic_ListaMov::DescrConto(int g, int c, long s) { TString80 ragsoc; const char* descr = NULL; TLocalisamfile pconti (LF_PCON); pconti.setkey(1); pconti.zero(); pconti.put(PCN_GRUPPO, g); pconti.put(PCN_CONTO, c); pconti.put(PCN_SOTTOCONTO, 0L); if (pconti.read() == NOERR) { _tipo_conto = pconti.get(PCN_TMCF); if (_tipo_conto == "C" || _tipo_conto == "F") { TLocalisamfile clifo (LF_CLIFO); clifo.setkey(1); clifo.zero(); clifo.put(CLI_TIPOCF, _tipo_conto); clifo.put(CLI_CODCF, s); if (clifo.read() != NOERR) { _descr_conto = ""; return FALSE; } else { char tipoa = clifo.get_char("TIPOAPER"); if (tipoa == 'F') //persona fisica { TString80 cognome, nome; ragsoc = clifo.get("RAGSOC"); cognome = ragsoc.mid(0,30); nome = ragsoc.mid(30,20); cognome.trim(); nome.trim(); ragsoc = cognome; ragsoc << " " << nome; _descr_conto = ragsoc; } else _descr_conto = clifo.get("RAGSOC"); } } else { pconti.zero(); pconti.put(PCN_GRUPPO, g); pconti.put(PCN_CONTO, c); pconti.put(PCN_SOTTOCONTO, s); if (pconti.read() != NOERR) { _descr_conto = ""; return FALSE; } else _descr_conto = pconti.get(PCN_DESCR); } } else { _descr_conto = ""; return FALSE; } return TRUE; } bool TRic_ListaMov::user_create() { TToken_string exp; TToken_string exp1; _trasfer = new TTransfer_file(); _tab_tra = new TTable ("%TRA"); _tab_tpd = new TTable ("%TPD"); _tab_pag = new TTable ("%CPG"); _tab_iva = new TTable ("%IVA"); _tab_ese = new TTable ("ESC"); _caus = new TLocalisamfile (LF_CAUSALI); _ditte = new TLocalisamfile (LF_NDITTE); _clifo = new TLocalisamfile (LF_CLIFO); _pcon = new TLocalisamfile (LF_PCON); _mov = new TLocalisamfile (LF_MOV); _rmov = new TLocalisamfile (LF_RMOV); _rmoviva = new TLocalisamfile (LF_RMOVIVA); _part = NULL; _scad = NULL; _pagsca = NULL; _tpart = NULL; _tscad = NULL; _tpagsca = NULL; // _part = new TLocalisamfile (LF_PARTITE); // _scad = new TLocalisamfile (LF_SCADENZE); // _pagsca = new TLocalisamfile (LF_PAGSCA); if (_ric_auto != 'A') { TIndwin pnd(0,TR("Controllo archivi..."),FALSE, FALSE); if (!check_archivi()) return FALSE; } TFilename tmpmov = "%"; tmpmov << get_firm_dir(); tmpmov << SLASH << TEMP_MOV; TFilename tmprmov = "%"; tmprmov << get_firm_dir(); tmprmov << SLASH << TEMP_RMOV; TFilename tmprmoviva = "%"; tmprmoviva << get_firm_dir(); tmprmoviva << SLASH << TEMP_RMOVIVA; _tmov = new TIsamtempfile(LF_MOV, tmpmov, 0); _trmov = new TIsamtempfile(LF_RMOV, tmprmov, 0); _is_iva = FALSE; TFilename tmp = tmprmoviva.mid(1); tmp.ext("dbf"); if (tmp.exist()) { _tiva = new TIsamtempfile(LF_RMOVIVA, tmprmoviva, 0); _is_iva = TRUE; } else _tiva = NULL; _rel = new TRelation(_tmov); _rel->add(_trmov,"NUMREG=NUMREG",1,0,0,FALSE); if (_is_iva) _rel->add(_tiva, "NUMREG=NUMREG",1,0,0,FALSE); _cur = add_cursor(new TCursor (_rel, "", 1)); // Cursore definito sui file dei movimenti contabili e iva // ************************************************* // *** Parte riguardante il Saldaconto se esiste *** // ************************************************* TFilename tmppart = "%"; tmppart << get_firm_dir(); tmppart << SLASH << TEMP_PART; tmp = tmppart.mid(1); tmp << ".dbf"; _is_salda = tmp.exist(); _giornale = new TLibro_giornale(); printer().footerlen(5); _tipom_cau = ""; _codpag_scad = ""; _risposta = FALSE; _continua = TRUE; _intestaSC = FALSE; _seconda_volta = FALSE; _errore_grave_SC = FALSE; _prima_volta = TRUE; _gruppo_p = -1; _conto_p = -1; _codcf_p = -1; _prima_rata_pag = FALSE; _numpart_prec = ""; _ho_stampato = FALSE; return TRUE; } void TRic_ListaMov::apri_file_SC() { TToken_string exp; TToken_string exp1; TFilename tmp; // ************************************************* // *** Parte riguardante il Saldaconto se esiste *** // ************************************************* TFilename tmppart = "%"; tmppart << get_firm_dir(); tmppart << "\\" << TEMP_PART; TFilename tmpscad = "%"; tmpscad << get_firm_dir(); tmpscad << "\\" << TEMP_SCAD; TFilename tmppagsca = "%"; tmppagsca << get_firm_dir(); tmppagsca << "\\" << TEMP_PAGSCA; tmp = tmppart.mid(1); tmp << ".dbf"; _is_salda = tmp.exist(); if (_is_salda) { _part = new TLocalisamfile (LF_PARTITE); _scad = new TLocalisamfile (LF_SCADENZE); _pagsca = new TLocalisamfile (LF_PAGSCA); _tpart = new TIsamtempfile(LF_PARTITE, tmppart, 0); _tscad = new TIsamtempfile(LF_SCADENZE, tmpscad, 0); _tpagsca = new TIsamtempfile(LF_PAGSCA,tmppagsca, 0); _relSC = new TRelation(_tpart); exp.add("TIPOC=TIPOC"); exp.add("GRUPPO=GRUPPO"); exp.add("CONTO=CONTO"); exp.add("SOTTOCONTO=SOTTOCONTO"); exp.add("ANNO=ANNO"); exp.add("NUMPART==NUMPART"); exp.add("NRIGA=NRIGA"); _relSC->add(_tscad,exp,1,0,0,FALSE); exp1.add("TIPOC=TIPOC"); exp1.add("GRUPPO=GRUPPO"); exp1.add("CONTO=CONTO"); exp1.add("SOTTOCONTO=SOTTOCONTO"); exp1.add("ANNO=ANNO"); exp1.add("NUMPART==NUMPART"); _relSC->add(_tpagsca,exp1,1,0,0,FALSE); _curSC = add_cursor(new TCursor (_relSC, "", 1)); // Cursore definito sui movimenti del saldaconto } } bool TRic_ListaMov::check_archivi() { long ditta_ric = get_firm(); if (!prefix().exist(ditta_ric)) return error_box(FR("Non esistono gli archivi della ditta %05ld: procedura interrotta"), ditta_ric); TTransfer_file& tr = trasfer(); _pathfile = tr.path(); _pathfile = _pathfile << HEADER; if (!tr.open(_pathfile)) return error_box(TR("Al momento non ci sono trasferimenti attivi sulla ditta selezionata")); if (!tr.read_control_rec()) return error_box(TR("Rilevati errori gravi negli archivi: procedura interrotta")); else _record = tr.record(); const char sd = look_sdt(); if (sd <= ' ') return error_box(TR("Ricezione tabelle non effettuata: richiamare il programma relativo")); _sdt = sd; if (_sdt == 'T') return error_box(TR("Ricezione tabelle non effettuata: richiamare il programma relativo")); if (_sdt == 'M') return yesno_box(TR("Controllo gia' effettuato: si desidera ripeterlo ?")); if (_sdt != '*' && _sdt != 'C') return error_box(TR("Rilevati errori gravi negli archivi: procedura interrotta")); TString16 ult = tr.ult_file(); TString16 key = tr.key(); ult.strip_spaces(); key.strip_spaces(); if (_sdt == 'C') if ( ult.not_empty() || key.not_empty() ) return error_box(TR("Rilevati errori gravi negli archivi: procedura interrotta")); if (_sdt == '*') { tr.remove_all(); return warning_box(TR("Trasferimento interamente completato: proseguire per cancellare i file")); } return TRUE; } void TRic_ListaMov::stampa_errori_mov(int riga) { long i = _err.first_one(); if (i != -1) { for (; i <= _err.last_one(); i++) if (_err[i]) set_row(++riga, "@8g%s", get_error(i)); } } int TRic_ListaMov::cerca_anno_solare_esercizio(int codice) { TTable ese ("ESC"); TDate datafine; int anno = 0; TString dep (format("%04d", codice)); ese.zero(); ese.put("CODTAB", dep); if (ese.read() == NOERR) datafine = ese.get_date("D1"); if (datafine != botime) anno = datafine.year(); return anno; } bool TRic_ListaMov::controlla_mov() { bool check_reg = TRUE; TString16 causreg; TDate udata; char tipocf = ' '; TTransfer_file& tr = trasfer(); _tiporeg = 0; if ( !TDate::isdate(_datareg.string()) ) { _errore_grave = TRUE; _err.set(0L); } TString app (_datacomp.string()); if (app.empty()) tr.datafine_esprec(_anno,_datacomp); if ( TDate::isdate(_datareg.string()) ) { int pr; const int ar = date2esc(_datareg); // Esercizio in corso pr = _ec.pred(ar); // Esercizio precedente if (ar == 0) { _err.set(1); _errore_grave = TRUE; } if ( TDate::isdate(_datacomp.string()) ) { const int ae = date2esc(_datacomp); if (ae == 0) { _err.set(3); _errore_grave = TRUE; } else if (ae != ar && ae != pr && ar) _err.set(4); } } int pp; _annoese = date2esc(_datacomp); // Esercizio in corso pp = _ec.pred(_annoese); if ( !TDate::isdate(_datacomp.string()) ) { _errore_grave = TRUE; _err.set(2); } TLibro_giornale& gio = giornale(); bool ok = gio.read(_ae); //se _ae e' zero la read considera come anno quello corrente if (_datareg < gio.last_print()) { _errore_grave = TRUE; _err.set(5); } TString16 dd = _datadoc.string(); if (dd.not_empty()) if ( !TDate::isdate(_datadoc.string()) ) _err.set(6); //if (_causale.not_empty()) //{ TLocalisamfile caus(LF_CAUSALI); caus.setkey(1); caus.zero(); caus.put(CAU_CODCAUS,_causale); if (caus.read() == NOERR) { _tipodoc = caus.get(CAU_TIPODOC); if (_is_salda) _tipom_cau = caus.get(CAU_TIPOMOV); } else { caus.zero(); if (_causale.not_empty()) //se la causale e' significativa { _errore_grave = TRUE; _err.set(7); } } //_tipodoc = caus.get(CAU_TIPODOC); ho sempre quello letto sul movimento! causreg = caus.get(CAU_REG); _descr_causale = caus.get(CAU_DESCR); _mov_sez = caus.get_bool(CAU_MOVSEZ); //} if (!_codpag.blank()) { bool ok = look_pag(); if (!ok) _err.set(8); } if (!_registro.blank()) //movimento iva (fattura) { if (_causale.empty()) //se la causale non e' significativa { _errore_grave = TRUE; check_reg = FALSE; _err.set(9); } if (check_reg && _ae) { int anno = cerca_anno_solare_esercizio(_ae); TRegistro rg (_registro, anno); if (rg.name().empty()) { _errore_grave = TRUE; check_reg = FALSE; _err.set(9); } else { _tiporeg = rg.tipo(); udata = rg.last_print(); } } } else if (!causreg.blank() && _ae) { int anno = cerca_anno_solare_esercizio(_ae); TRegistro rg (causreg, anno); if (rg.name().empty()) { _errore_grave = TRUE; check_reg = FALSE; _err.set(9); } else { _tiporeg = rg.tipo(); udata = rg.last_print(); } _registro = causreg; } /* if (!_registro.blank()) { if (_tiporeg == 1) _tipocf = tipocf = 'C'; else if (_tiporeg == 2) _tipocf = tipocf = 'F'; // if (_tiporeg != 0) //se esiste, uso quello della causale!!! // { TTable tabtpd("%TPD"); tabtpd.put("CODTAB", _tipodoc); if (tabtpd.read() == NOERR) { bool cor = tabtpd.get_bool("B0"); if (!cor) if (_codcf != 0l) { TLocalisamfile clifo(LF_CLIFO); clifo.zero(); clifo.put(CLI_CODCF, _codcf); clifo.put(CLI_TIPOCF,tipocf); if (clifo.read() != NOERR) { _errore_grave = TRUE; _err.set(10); } } else { _errore_grave = TRUE; _err.set(10); } } else { if (_codcf != 0l) { TLocalisamfile clifo(LF_CLIFO); clifo.zero(); clifo.put(CLI_CODCF, _codcf); clifo.put(CLI_TIPOCF,tipocf); if (clifo.read() != NOERR) { _errore_grave = TRUE; _err.set(10); } } else { _errore_grave = TRUE; _err.set(10); } } // } } */ TString16 d74 = _data74tr.string(); if (d74.not_empty()) if ( !TDate::isdate(_data74tr.string()) ) _err.set(11); if (!_registro.blank() && check_reg) if (_datareg < udata) { _errore_grave = TRUE; _err.set(12); } if (_err.ones()) return TRUE; return FALSE; } bool TRic_ListaMov::errori_partita(int g, int c, long s) { TLocalisamfile pconti (LF_PCON); pconti.setkey(1); pconti.zero(); pconti.put(PCN_GRUPPO, g); pconti.put(PCN_CONTO, c); pconti.put(PCN_SOTTOCONTO, 0L); if (pconti.read() == NOERR) { char tipo = pconti.get(PCN_TMCF)[0]; if (tipo == 'C' || tipo == 'F') { TLocalisamfile clifo (LF_CLIFO); clifo.setkey(1); clifo.zero(); clifo.put(CLI_TIPOCF, tipo); clifo.put(CLI_CODCF, s); if (clifo.read() != NOERR) return FALSE; } else { pconti.zero(); pconti.put(PCN_GRUPPO, g); pconti.put(PCN_CONTO, c); pconti.put(PCN_SOTTOCONTO, s); if (pconti.read() != NOERR) return FALSE; } } else return FALSE; return TRUE; } void TRic_ListaMov::stampa_errori_partite(int riga) { long i = _err.first_one(); if (i != -1) { for (; i <= _err.last_one(); i++) if (_err[i]) set_row(++riga, "@22g%s", get_error(i)); } } char TRic_ListaMov::TipoConto(int g, int c) { TLocalisamfile pcon (LF_PCON); char tipo = ' '; pcon.setkey(1); pcon.zero(); pcon.put(PCN_GRUPPO, g); pcon.put(PCN_CONTO, c); pcon.put(PCN_SOTTOCONTO, 0l); if (pcon.read() == NOERR) tipo = pcon.get_char(PCN_TMCF); return tipo; } bool TRic_ListaMov::controlla_rmov() { TLocalisamfile& rmov = current_cursor()->file(LF_RMOV); int gruppo, conto, gruppoc, contoc; long sottoconto, sottocontoc; char sezione; real importo, dare, avere; if (current_cursor()->is_first_match(LF_RMOV)) { dare = avere = ZERO; TRecnotype nrec = rmov.recno(); rmov.zero(); rmov.setkey(1); rmov.put(RMV_NUMREG, _numero); for (rmov.read(_isgteq); !rmov.eof() ;rmov.next()) { const TRectype& rec = rmov.curr(); if (rec.get_long(RMV_NUMREG) != _numero) break; gruppo = rec.get_int(RMV_GRUPPO); conto = rec.get_int(RMV_CONTO); sottoconto = rec.get_long(RMV_SOTTOCONTO); gruppoc = rec.get_int(RMV_GRUPPOC); contoc = rec.get_int(RMV_CONTOC); sottocontoc = rec.get_long(RMV_SOTTOCONTOC); sezione = rec.get_char(RMV_SEZIONE); importo = rec.get_real(RMV_IMPORTO); _tipo_conto = ""; char tipo = TipoConto(gruppo,conto); char tipoc = TipoConto(gruppoc,contoc); aggiorna_rmov(tipo,tipoc); if (gruppo != 0 && conto != 0 && sottoconto != 0l) _esiste_conto = DescrConto(gruppo,conto,sottoconto); else { _esiste_conto = FALSE; _descr_conto = ""; } //_num_rec = rec.get_long(RMV_ANNOES); if (sezione == 'D') dare += importo; if (sezione == 'A') avere += importo; if (gruppo == 0 || conto == 0 || sottoconto == 0l) { rmov.readat(nrec); return TRUE; } else { bool ok = errori_partita(gruppo,conto,sottoconto); if (!ok) { rmov.readat(nrec); return TRUE; } } if ( (importo != ZERO && sezione == '\0') || (sezione != 'D' && sezione != 'A' && sezione != '\0') ) { rmov.readat(nrec); return TRUE; } if (gruppoc != 0 || contoc != 0 || sottocontoc != 0l) { bool ok = errori_partita(gruppoc,contoc,sottocontoc); if (!ok) { rmov.readat(nrec); return TRUE; } } if (!_mov_sez && importo == ZERO) { rmov.readat(nrec); return TRUE; } } if (dare.round(2) != avere.round(2)) { rmov.readat(nrec); return TRUE; } rmov.readat(nrec); } return FALSE; } void TRic_ListaMov::stampa_errori_rmov(int riga) { if (_gruppo == 0 || _conto == 0 || _sottoconto == 0l) { _errore_grave = TRUE; set_row(++riga, FR("@8g*** Sottoconto partita non valido o non presente in archivio")); } else { if (!_esiste_conto) { _errore_grave = TRUE; set_row(++riga, FR("@8g*** Sottoconto partita non valido o non presente in archivio")); } } if ( (_importo != ZERO && _sezione == '\0') || (_sezione != 'D' && _sezione != 'A' && _sezione != '\0') ) { _errore_grave = TRUE; set_row(++riga, FR("@8g*** Segnale dare/avere non valido")); } if (_sezione == 'D') _tot_dare += _importo; if (_sezione == 'A') _tot_avere += _importo; if (_gruppoc != 0 || _contoc != 0 || _sottocontoc != 0l) { bool ok = errori_partita(_gruppoc,_contoc,_sottocontoc); if (!ok) set_row(++riga, FR("@8g--- Sottoconto contropartita non valido o non presente in archivio")); } if (!_mov_sez && _importo == ZERO) set_row(++riga, FR("@8g--- Importo riga uguale a zero")); } bool TRic_ListaMov::controlla_riva() { TLocalisamfile& rmoviva = current_cursor()->file(LF_RMOVIVA); TTable tab_iva("%IVA"); TString16 codiva; int tipodet, tipocr, gruppocr, contocr; long sottocontocr; real impo, impos; bool testata = TRUE; bool no_grave = FALSE; if (current_cursor()->is_first_match(LF_RMOVIVA)) { TRecnotype nrec = rmoviva.recno(); rmoviva.setkey(1); rmoviva.zero(); rmoviva.put(RMI_NUMREG, _numero); TRectype recc (rmoviva.curr()); for (rmoviva.read(_isgteq); !rmoviva.eof() ;rmoviva.next()) { TRectype rec (rmoviva.curr()); if (rec > recc) break; //_n_rec = rec.get_int(RMI_ANNOES); codiva = rec.get(RMI_CODIVA); tipodet = rec.get_int(RMI_TIPODET); tipocr = rec.get_int(RMI_TIPOCR); gruppocr = rec.get_int(RMI_GRUPPO); contocr = rec.get_int(RMI_CONTO); sottocontocr = rec.get_long(RMI_SOTTOCONTO); impo = rec.get_real(RMI_IMPONIBILE); impos = rec.get_real(RMI_IMPOSTA); if (testata) { char tipocf = ' '; if (!_registro.blank()) { if (_tiporeg == 1) _tipocf = tipocf = 'C'; else if (_tiporeg == 2) _tipocf = tipocf = 'F'; TTable tabtpd("%TPD"); tabtpd.put("CODTAB", _tipodoc); if (tabtpd.read() == NOERR) { bool cor = tabtpd.get_bool("B0"); if (!cor) if (_codcf != 0l) { TLocalisamfile clifo(LF_CLIFO); clifo.zero(); clifo.put(CLI_CODCF, _codcf); clifo.put(CLI_TIPOCF,tipocf); if (clifo.read() != NOERR) { _errore_grave = TRUE; _err.set(10); } } else { _errore_grave = TRUE; _err.set(10); } } else { if (_codcf != 0l) { TLocalisamfile clifo(LF_CLIFO); clifo.zero(); clifo.put(CLI_CODCF, _codcf); clifo.put(CLI_TIPOCF,tipocf); if (clifo.read() != NOERR) { _errore_grave = TRUE; _err.set(10); } } else { _errore_grave = TRUE; _err.set(10); } } } testata = FALSE; } //TString impostr = impo.string(); //TString impostastr = impos.string(); _tot_doc += impo + impos; //TString totdocstr = _tot_doc.string(); _impo = impo; _impos = impos; char tipo = TipoConto(gruppocr,contocr); aggiorna_iva(tipo); if (!_tipodoc.blank()) { TTable tabtpd("%TPD"); tabtpd.put("CODTAB", _tipodoc); if (tabtpd.read() == NOERR) { bool cor = tabtpd.get_bool("B0"); if (cor) { _impo = impo + impos; _impos = ZERO; } } } TTable iva ("%IVA"); iva.zero(); iva.put("CODTAB", codiva); if (iva.read() != NOERR) { no_grave = TRUE; } if ( tipocr != 0 && tipocr != 1 && tipocr != 2 && tipocr != 3 && tipocr != 4 && tipocr != 5 && tipocr != 8 && tipocr != 9 ) { no_grave = TRUE; } if (gruppocr == 0 || contocr == 0 || sottocontocr == 0l) { no_grave = TRUE; } else if (gruppocr != 0 && contocr != 0 && sottocontocr != 0l) { bool ok = errori_partita(gruppocr,contocr,sottocontocr); if (!ok) { no_grave = TRUE; } } if (tipodet != 0 && tipodet != 1 && tipodet != 3 && tipodet != 9) { no_grave = TRUE; } } if (no_grave) { rmoviva.readat(nrec); return TRUE; } rmoviva.readat(nrec); } return FALSE; } void TRic_ListaMov::stampa_errori_riva(int riga) { TTable iva ("%IVA"); iva.zero(); iva.put("CODTAB", _codiva); if (iva.read() != NOERR) set_row(++riga, FR("@8g--- Codice IVA non valido o non presente in tabella")); if ( _tipocr != 0 && _tipocr != 1 && _tipocr != 2 && _tipocr != 3 && _tipocr != 4 && _tipocr != 5 && _tipocr != 8 && _tipocr != 9 ) set_row(++riga, FR("@8g--- Tipo costo/ricavo non valido")); if (_gruppocr == 0 || _contocr == 0 || _sottocontocr == 0l) set_row(++riga, FR("@8g--- Sottoconto costo/ricavo non valido o non presente in archivio")); else if (_gruppocr != 0 && _contocr != 0 && _sottocontocr != 0l) { bool ok = errori_partita(_gruppocr,_contocr,_sottocontocr); if (!ok) set_row(++riga, FR("@8g--- Sottoconto costo/ricavo non valido o non presente in archivio")); } if (_tipod != 0 && _tipod != 1 && _tipod != 3 && _tipod != 9) set_row(++riga, FR("@8g--- Tipo indetraibilita' non valido")); } bool TRic_ListaMov::controlla_anaCF_Pcon(char tipocf,int gruppo,int conto,long codcf) { if (codcf == 0) return TRUE; if (tipocf == 'C' || tipocf == 'F') { TLocalisamfile clifo (LF_CLIFO); clifo.setkey(1); clifo.zero(); clifo.put(CLI_TIPOCF, tipocf); clifo.put(CLI_CODCF, codcf); if (clifo.read() == NOERR) { TString descr = clifo.get(CLI_RAGSOC); TString app1 = descr.mid(0,30); app1.trim(); TString app2 = descr.mid(30,20); app2.trim(); _descr_anag = app1 << " " << app2; return TRUE; } else { _descr_anag = ""; return FALSE; } } else { TLocalisamfile pcon (LF_PCON); pcon.setkey(1); pcon.zero(); pcon.put(PCN_GRUPPO, gruppo); pcon.put(PCN_CONTO, conto); pcon.put(PCN_SOTTOCONTO, codcf); if (pcon.read() == NOERR) { _descr_anag = pcon.get(PCN_DESCR); return TRUE; } else { _descr_anag = ""; return FALSE; } } return TRUE; } bool TRic_ListaMov::controlla_anagrafica(char tipo, int gruppo, int conto) { TLocalisamfile pcon (LF_PCON); pcon.setkey(1); pcon.zero(); pcon.put(PCN_GRUPPO, gruppo); pcon.put(PCN_CONTO, conto); pcon.read(); if (pcon.get_int(PCN_GRUPPO) == gruppo && pcon.get_int(PCN_CONTO) == conto) if (pcon.get_char(PCN_TMCF) == tipo) return TRUE; return FALSE; } bool TRic_ListaMov::esiste_rata() { TLocalisamfile& scad = current_cursor()->file(LF_SCADENZE); TRecnotype record = scad.recno(); scad.zero(); scad.put(SCAD_TIPOCF, _tipocf); if (_gruppo != 0) scad.put(SCAD_GRUPPO, _gruppo); if (_conto != 0) scad.put(SCAD_CONTO, _conto); if (_codcf != 0) scad.put(SCAD_SOTTOCONTO, _codcf); scad.put(SCAD_ANNO, _anno); scad.put(SCAD_NUMPART, _numpart); scad.put(SCAD_NRIGA, _nriga); TRectype recscad (scad.curr()); for (scad.read(_isgteq); !scad.eof(); scad.next()) { TString rec = recscad.get(SCAD_NUMPART); TString file = scad.get(SCAD_NUMPART); if (scad.curr() != recscad || file != rec) break; return TRUE; } scad.readat(record); return FALSE; } const char * TRic_ListaMov::get_error(int err) { switch (err) { case 0: return TR("*** Data operazione non valida"); break; case 1: return TR("*** Data operazione non compresa in alcun esercizio"); break; case 2: return TR("*** Data competenza non valida"); break; case 3: return TR("*** Data competenza non compresa in alcun esercizio"); break; case 4: return TR("--- Data competenza incompatibile con data operazione"); break; case 5: return TR("*** Data operazione antecedente ad ultima stampa giornale"); break; case 6: return TR("--- Data documento non valida"); break; case 7: return TR("*** Codice causale non valido o non presente in archivio"); break; case 8: return TR("--- Codice pagamento non valido o non presente in tabella"); break; case 9: return TR("*** Codice registro IVA non valido o non presente in tabella"); break; case 10: return TR("*** Codice cliente/fornitore non valido o non presente in anagrafica"); break; case 11: return TR("--- Data 74 ter non valida"); break; case 12: return TR("*** Data operazione antecedente ad ultima stampa registro IVA"); break; case 13: return TR("*** Tipo anagrafico C/F errato"); break; case 14: return TR("*** Codice anagrafico C/F/Piano Conti errato"); break; case 15: return TR("*** Rif. partite saldaconto errato"); break; case 16: return TR("--- Codice valuta errato"); break; case 17: return TR("*** Data cambio non valida"); break; case 18: return TR("*** Data pagamento/incasso non valida"); break; case 19: return TR("*** Tipo pagamento errato"); break; case 20: return TR("*** Segno D/A errato"); break; case 21: return TR("*** Cambio mancante"); break; case 22: return TR("*** Gruppo/Conto errato"); break; case 23: return TR("*** Rif. rata partite saldaconto errato"); break; case 24: return TR("*** Data scadenza non valida"); break; case 25: return TR("--- Ulteriore classificazione non valida o non presente in archivio"); break; case 26: return TR("*** Importo rata in lire mancante"); break; case 27: return TR("*** Importo rata in valuta mancante"); break; case 28: return TR("--- Codice Nostra banca non valido o non presente in archivio"); break; case 29: return TR("--- Codice Vostra banca non valido o non presente in archivio"); break; case 30: return TR("--- Codice agente non valido o non presente in archivio"); break; case 31: return TR("--- Data sollecito non valida"); break; case 32: return TR("*** Rif. fattura errato"); break; case 33: return TR("*** Rif. rata fattura errato"); break; case 34: return TR("*** In acconto/a saldo errato"); break; case 35: return TR("*** Importo inc./pag. in lire mancante"); break; case 36: return TR("*** Importo inc./pag. in valuta mancante"); break; case 37: return TR("*** Flag abbuono attivo/passivo errato"); break; case 38: return TR("*** Codice valuta errato"); break; case 39: return TR("*** Tipo movimento causale non congruo con tipo movimento saldaconto"); break; case 40: return TR("--- Tipo pagamento del codice di pagamento non congruo con tipo pagamento del saldaconto"); break; default: return ""; break; } } bool TRic_ListaMov::controlla_partite() { if (_tipocf != 'C' && _tipocf != 'F' && _tipocf != '\0') { _errore_grave_SC = TRUE; _err.set(13); } if (!controlla_anaCF_Pcon(_tipocf,_gruppo,_conto,_codcf)) { _errore_grave_SC = TRUE; _err.set(14); } if (_anno == 0 || _numpart.empty() || _nriga == 0) { _errore_grave_SC = TRUE; _err.set(15); } if ( !TDate::isdate(_datareg.string()) ) { _errore_grave_SC = TRUE; _err.set(0L); } TString16 dd = _datadoc.string(); if (dd.not_empty()) if ( !TDate::isdate(_datadoc.string()) ) _err.set(6); if (_causale.empty()) { _descr_causale = ""; if (_numreg != 0) { _errore_grave_SC = TRUE; _err.set(7); } } else { TLocalisamfile caus(LF_CAUSALI); caus.setkey(1); caus.zero(); caus.put(CAU_CODCAUS,_causale); if (caus.read() != NOERR) { caus.zero(); _errore_grave_SC = TRUE; _err.set(7); } _descr_causale = caus.get(CAU_DESCR); int tipomov_caus = caus.get_int(CAU_TIPOMOV); if (_tipomov != tipomov_caus) { _errore_grave_SC = TRUE; _err.set(39); } } if (_codval.not_empty()) { TTable val ("%VAL"); TString dep (format("%-3s", (const char*) _codval)); val.zero(); val.put("CODTAB", dep); if (val.read() != NOERR) { _errore_grave_SC = TRUE; _err.set(38); } if (_cambio == ZERO) { _errore_grave_SC = TRUE; _err.set(21); } TString16 dcam = _datacam.string(); if (dcam.empty() || !TDate::isdate(_datacam.string()) ) _err.set(17); } if (_tipomov != 1) { if (esiste_rata()) { if (_tipopag < 1 || _tipopag > 9) { _errore_grave_SC = TRUE; _err.set(19); } TString datapag_str = _datapag.string(); if ( datapag_str.empty() || !TDate::isdate(_datapag.string()) ) { _errore_grave_SC = TRUE; _err.set(18); } } } if (_gruppocl != 0 && _contocl != 0) { if (!controlla_anagrafica(_tipocf,_gruppocl,_contocl)) { _errore_grave_SC = TRUE; _err.set(22); } } if (_sez != 'D' && _sez != 'A') { _errore_grave_SC = TRUE; _err.set(20); } if (_err.ones()) return TRUE; return FALSE; } bool TRic_ListaMov::cerca_codpag(TString& codpag) { TTable cpg ("%CPG"); _descr_pag = ""; cpg.zero(); cpg.put("CODTAB", codpag); if (cpg.read() == NOERR) { _descr_pag = cpg.get("S0"); // _tipopag_pag = atoi(cpg.get("S4")); return TRUE; } return FALSE; } bool TRic_ListaMov::cerca_tipopag_codpag(TString& codpag, int tipopag) { TTable rpg ("%RPG"); TString16 dep; for (int i = 0; ; i++) { dep.format("%-s%3d", (const char*) codpag, i); rpg.put("CODTAB", dep); if (rpg.read() == NOERR) { const int tipo = rpg.get_int("I1"); if (tipo == tipopag) { _tipopag_pag = tipo; return TRUE; } } else break; } return FALSE; } bool TRic_ListaMov::ulteriore_classificazione(int tipopag, TString& ultclass) { TTable clr ("%CLR"); TString dep (format("%d%s", tipopag, (const char*) ultclass)); clr.zero(); clr.put("CODTAB", dep); if (clr.read() == NOERR) return TRUE; return FALSE; } bool TRic_ListaMov::banca(long abi,long cab) { if (abi == 0 && cab == 0) return TRUE; TTable ban ("%BAN"); TString dep; if (abi != 0 && cab != 0) dep.format("%05ld%05ld", abi,cab); if (abi != 0 && cab == 0) dep.format("%05ld", abi); ban.zero(); ban.put("CODTAB", dep); if (ban.read() == NOERR) return TRUE; return FALSE; } bool TRic_ListaMov::agente(const char* codag) const { static int test_file = -1; bool ok = TRUE; if (codag && *codag) { if (test_file < 0) { TDir d; d.get(LF_AGENTI); test_file = fexist(d.filename()); // Controlla l'esistenza del file } if (test_file) { const TRectype& age = cache().get(LF_AGENTI, codag); ok = !age.empty(); } } return ok; } bool TRic_ListaMov::controlla_scadenze() { int tipopag,nrata; TString codpag,ultclass,codag; TDate datascad,datasoll; real importo,importoval; long abins,cabns,abivs,cabvs; importo = ZERO; importoval = ZERO; TLocalisamfile& scad = current_cursor()->file(LF_SCADENZE); if (current_cursor()->is_first_match(LF_SCADENZE)) { TRecnotype nrec = scad.recno(); scad.zero(); scad.setkey(1); scad.put(SCAD_TIPOCF, _tipocf); if (_gruppo != 0) scad.put(SCAD_GRUPPO, _gruppo); if (_conto != 0) scad.put(SCAD_CONTO, _conto); if (_codcf != 0) scad.put(SCAD_SOTTOCONTO, _codcf); scad.put(SCAD_ANNO, _anno); scad.put(SCAD_NUMPART, _numpart); scad.put(SCAD_NRIGA, _nriga); TRectype recc (scad.curr()); for (scad.read(_isgteq); !scad.eof() ;scad.next()) { TRectype rec (scad.curr()); TString filea = recc.get(SCAD_NUMPART); TString file = rec.get(SCAD_NUMPART); if (rec != recc || file != filea) break; nrata = rec.get_int (SCAD_NRATA); tipopag = rec.get_int (SCAD_TIPOPAG); codpag = rec.get (SCAD_CODPAG); ultclass = rec.get (SCAD_ULTCLASS); datascad = rec.get_date(SCAD_DATASCAD); datasoll = rec.get_date(SCAD_DATASOLL); importo = rec.get_real(SCAD_IMPORTO); importoval = rec.get_real(SCAD_IMPORTOVAL); abins = rec.get_long(SCAD_CODABIPR); cabns = rec.get_long(SCAD_CODCABPR); abivs = rec.get_long(SCAD_CODABI); cabvs = rec.get_long(SCAD_CODCAB); codag = rec.get (SCAD_CODAG); if (nrata == 0) { scad.readat(nrec); return TRUE; } if ( !TDate::isdate(datascad.string()) ) { scad.readat(nrec); return TRUE; } if (codpag.not_empty()) // Modifica 01-10-96 chiesta da Patrizia: se il codice di { // pagamento non e' significativo non va controllato, if (!cerca_codpag(codpag)) // altrimenti si presenta l'errore su quelle partite { // generate in automatico dove non e' possibile indicare scad.readat(nrec); // il codice di pagamento. return TRUE; } if (tipopag < 1 || tipopag > 9) { scad.readat(nrec); return TRUE; } if (!cerca_tipopag_codpag(codpag,tipopag)) { scad.readat(nrec); return TRUE; } } if (ultclass.not_empty()) { if (!ulteriore_classificazione(tipopag,ultclass)) { scad.readat(nrec); return TRUE; } } if (importo == ZERO) { scad.readat(nrec); return TRUE; } if (_codval.not_empty() && importoval == ZERO) { scad.readat(nrec); return TRUE; } if (!banca(abins,cabns)) { scad.readat(nrec); return TRUE; } if (!banca(abivs,cabvs)) { scad.readat(nrec); return TRUE; } if (!agente(codag)) { scad.readat(nrec); return TRUE; } TString datasoll_str = datasoll.string(); if ( datasoll_str.not_empty() && !TDate::isdate(datasoll.string()) ) { scad.readat(nrec); return TRUE; } } scad.readat(nrec); } return FALSE; } void TRic_ListaMov::descrizione_pagamento(TString& descr,int tipopag,TString& ultclass,TString& codpag) { TString dep; if (ultclass.not_empty()) { TTable clr ("%CLR"); dep.format("%d%s", tipopag,(const char*) ultclass); clr.zero(); clr.put("CODTAB", dep); if (clr.read() == NOERR) descr = clr.get("S0"); else descr = ""; } else { TTable rpg ("%RPG"); int tipo; for (int i = 0; !rpg.eof(); rpg.next(), i++) { dep.format("%-s%3d", (const char*) codpag, i); rpg.zero(); rpg.put("CODTAB", dep); if (rpg.read() == NOERR) { tipo = rpg.get_int("I1"); if (tipo == tipopag) { switch(tipo) { case 1: descr = TR("Rimessa diretta"); break; case 2: descr = TR("Tratta"); break; case 3: descr = TR("Ricevuta bancaria"); break; case 4: descr = TR("Cessione"); break; case 5: descr = TR("Paghero'"); break; case 6: descr = TR("Lettera di credito"); break; case 7: descr = TR("Tratta accettata"); break; case 8: descr = TR("Rapporti interbancari diretti"); break; case 9: descr = TR("Bonifico"); break; case 10: descr = TR("Altro"); break; default: break; }; break; } } else { descr = ""; break; } } } } void TRic_ListaMov::stampa_errori_scadenze(int riga) { TCursor* cur = current_cursor(); TString numpart = cur->curr(LF_SCADENZE).get (SCAD_NUMPART); int nriga = cur->curr(LF_SCADENZE).get_int (SCAD_NRIGA); int nrata = cur->curr(LF_SCADENZE).get_int (SCAD_NRATA); int tipopag = cur->curr(LF_SCADENZE).get_int (SCAD_TIPOPAG); TString codpag = cur->curr(LF_SCADENZE).get (SCAD_CODPAG); TString ultclass = cur->curr(LF_SCADENZE).get (SCAD_ULTCLASS); TDate datascad = cur->curr(LF_SCADENZE).get_date(SCAD_DATASCAD); TDate datasoll = cur->curr(LF_SCADENZE).get_date(SCAD_DATASOLL); real importo = cur->curr(LF_SCADENZE).get_real(SCAD_IMPORTO); real importoval = cur->curr(LF_SCADENZE).get_real(SCAD_IMPORTOVAL); long abins = cur->curr(LF_SCADENZE).get_long(SCAD_CODABIPR); long cabns = cur->curr(LF_SCADENZE).get_long(SCAD_CODCABPR); long abivs = cur->curr(LF_SCADENZE).get_long(SCAD_CODABI); long cabvs = cur->curr(LF_SCADENZE).get_long(SCAD_CODCAB); TString codag = cur->curr(LF_SCADENZE).get (SCAD_CODAG); TString descr_pagamento; descrizione_pagamento(descr_pagamento,tipopag,ultclass,codpag); if (_prima_rata_pag) { set_row(riga,FR("@26gN.rata Data scad. Sez Importo Importo valuta")); set_row(riga++,FR("@88gCond.pagamento Nostra banca Vostra banca Agente")); _prima_rata_pag = FALSE; } set_row(riga,"@27g%4d", nrata); set_row(riga,"@38g%10s", (const char*) datascad.string()); set_row(riga,"@51g%c", _sez); set_row(riga,"@55g%r", &importo); if (importoval != ZERO) set_row(riga,"@71g%15s", importoval.string("###.###.###,@@@")); set_row(riga,"@88g%-4s", (const char*) codpag); set_row(riga,"@92g/@93g%d", tipopag); set_row(riga,"@94g/@95g%s", (const char*) ultclass); set_row(riga,"@100g%-50s", (const char*) descr_pagamento); if (abins != 0) set_row(riga,"@158g%ld", abins); if (cabns != 0) set_row(riga,"@165g%ld", cabns); if (abivs != 0) set_row(riga,"@172g%ld", abivs); if (cabvs != 0) set_row(riga,"@179g%ld", cabvs); set_row(riga,"@189g%-5s", (const char*) codag); if (nrata == 0) { _errore_grave_SC = TRUE; set_row(++riga, "@30g%s", get_error(23)); } if ( !TDate::isdate(datascad.string()) ) { _errore_grave_SC = TRUE; set_row(++riga, "@30g%s", get_error(24)); } if (codpag.not_empty()) // Modifica 01-10-96 chiesta da Patrizia: per spiegazione vedi { // funzione controlla_scadenze(); if (!cerca_codpag(codpag)) { _errore_grave_SC = TRUE; set_row(++riga, "@30g*** Codice pagamento non valido o non presente in tabella"); } if (tipopag < 1 || tipopag > 9) { _errore_grave_SC = TRUE; set_row(++riga, "@30g%s", get_error(19)); } if (!cerca_tipopag_codpag(codpag,tipopag)) { // _errore_grave_SC = TRUE; // CM700491 set_row(++riga, "@30g%s", get_error(40)); } } if (ultclass.not_empty()) { if (!ulteriore_classificazione(tipopag,ultclass)) set_row(++riga, "@30g%s", get_error(25)); } if (importo == ZERO) { _errore_grave_SC = TRUE; set_row(++riga, "@30g%s", get_error(26)); } if (_codval.not_empty() && importoval == ZERO) { _errore_grave_SC = TRUE; set_row(++riga, "@30g%s", get_error(27)); } if (!banca(abins,cabns)) set_row(++riga, "@30g%s", get_error(28)); if (!banca(abivs,cabvs)) set_row(++riga, "@30g%s", get_error(29)); if (!agente(codag)) set_row(++riga, "@30g%s", get_error(30)); TString datasoll_str = datasoll.string(); if ( datasoll_str.not_empty() && !TDate::isdate(datasoll.string()) ) set_row(++riga, "@30g%s", get_error(31)); } bool TRic_ListaMov::record_partite(int nriga) { bool ok = FALSE; for (int p = 0; p < 2 && !ok; p++) { TLocalisamfile* fpart = p == 0 ? _tpart : _part; TLocalisamfile& part = *fpart; const TRecnotype nrec = part.recno(); part.zero(); part.put(PART_TIPOCF, _tipocf); part.put(PART_GRUPPO, _gruppo); part.put(PART_CONTO, _conto); part.put(PART_SOTTOCONTO, _codcf); part.put(PART_ANNO, _anno); part.put(PART_NUMPART, _numpart); part.put(PART_NRIGA, nriga); ok = part.read() == NOERR; part.readat(nrec); } return ok; } bool TRic_ListaMov::record_scadenze(int nrigp,int nrata) { bool ok = FALSE; for (int p = 0; p < 2 && !ok; p++) { TLocalisamfile* fscad = p == 0 ? _tscad : _scad; TLocalisamfile& scad = *fscad; const TRecnotype nrec = scad.recno(); scad.zero(); scad.put(SCAD_TIPOCF, _tipocf); scad.put(SCAD_GRUPPO, _gruppo); scad.put(SCAD_CONTO, _conto); scad.put(SCAD_SOTTOCONTO, _codcf); scad.put(SCAD_ANNO, _anno); scad.put(SCAD_NUMPART, _numpart); scad.put(SCAD_NRIGA, nrigp); scad.put(SCAD_NRATA, nrata); ok = scad.read() == NOERR; scad.readat(nrec); } return ok; } bool TRic_ListaMov::controlla_pagsca() { char tipoc,accsaldo,passat; int nriga,nrata,gruppoc,contoc; TString codag; real importo,importoval,abbuoni; long abins,cabns,abivs,cabvs,sottocc; bool errore_non_grave = FALSE; importo = ZERO; importoval = ZERO; TLocalisamfile& pagsca = current_cursor()->file(LF_PAGSCA); if (current_cursor()->is_first_match(LF_PAGSCA)) { TRecnotype nrec = pagsca.recno(); pagsca.zero(); pagsca.setkey(1); pagsca.put(PAGSCA_TIPOC, _tipocf); if (_gruppo != 0) pagsca.put(PAGSCA_GRUPPO, _gruppo); if (_conto != 0) pagsca.put(PAGSCA_CONTO, _conto); if (_codcf != 0) pagsca.put(PAGSCA_SOTTOCONTO, _codcf); pagsca.put(PAGSCA_ANNO, _anno); pagsca.put(PAGSCA_NUMPART, _numpart); TRectype recc (pagsca.curr()); for (pagsca.read(_isgteq); !pagsca.eof() ;pagsca.next()) { int nrigp = pagsca.get_int(PAGSCA_NRIGP); TRectype rec (pagsca.curr()); TString filea = recc.get(PAGSCA_NUMPART); TString file = rec.get(PAGSCA_NUMPART); if (rec != recc || file != filea) break; if (nrigp != _nriga) continue; nriga = rec.get_int (PAGSCA_NRIGA); nrata = rec.get_int (PAGSCA_NRATA); accsaldo = rec.get_char(PAGSCA_ACCSAL); importo = rec.get_real(PAGSCA_IMPORTO); importoval = rec.get_real(PAGSCA_IMPORTOVAL); abbuoni = rec.get_real(PAGSCA_ABBUONI); passat = rec.get_char(PAGSCA_PASSATT); abins = rec.get_long(PAGSCA_CODABIPR); cabns = rec.get_long(PAGSCA_CODCABPR); abivs = rec.get_long(PAGSCA_CODABI); cabvs = rec.get_long(PAGSCA_CODCAB); codag = rec.get (PAGSCA_CODAG); tipoc = rec.get_char(PAGSCA_TIPOCC); gruppoc = rec.get_int (PAGSCA_GRUPPOC); contoc = rec.get_int (PAGSCA_CONTOC); sottocc = rec.get_long(PAGSCA_SOTTOCONTC); if (nriga != 9999) { if (!record_partite(nriga)) { pagsca.readat(nrec); return TRUE; } } if (nrata != 9999) { if (!record_scadenze(nriga,nrata)) { pagsca.readat(nrec); return TRUE; } } if (accsaldo != 'A' && accsaldo != 'S') { pagsca.readat(nrec); return TRUE; } if (importo == ZERO) { pagsca.readat(nrec); return TRUE; } if (_codval.not_empty() && importoval == ZERO) { pagsca.readat(nrec); return TRUE; } if (abbuoni != ZERO && (passat != 'A' && passat != 'P') ) { pagsca.readat(nrec); return TRUE; } if (!banca(abins,cabns)) errore_non_grave = TRUE; if (!banca(abivs,cabvs)) errore_non_grave = TRUE; if (!agente(codag)) errore_non_grave = TRUE; if (!controlla_anaCF_Pcon(tipoc,gruppoc,contoc,sottocc)) errore_non_grave = TRUE; } pagsca.readat(nrec); if (errore_non_grave ) return TRUE; } return FALSE; } void TRic_ListaMov::stampa_errori_pagsca(int riga) { TCursor* cur = current_cursor(); const TRectype& pagsca = cur->curr(LF_PAGSCA); int nrigp = pagsca.get_int (PAGSCA_NRIGP); if (nrigp == _nriga) { int nriga = pagsca.get_int (PAGSCA_NRIGA); int nrata = pagsca.get_int (PAGSCA_NRATA); char accsaldo = pagsca.get_char(PAGSCA_ACCSAL); real importo = pagsca.get_real(PAGSCA_IMPORTO); real importoval = pagsca.get_real(PAGSCA_IMPORTOVAL); real abbuoni = pagsca.get_real(PAGSCA_ABBUONI); real ritenute = pagsca.get_real(PAGSCA_RITENUTE); real ritsoc = pagsca.get_real(PAGSCA_RITSOC); real diffcam = pagsca.get_real(PAGSCA_DIFFCAM); char passat = pagsca.get_char(PAGSCA_PASSATT); long abins = pagsca.get_long(PAGSCA_CODABIPR); long cabns = pagsca.get_long(PAGSCA_CODCABPR); long abivs = pagsca.get_long(PAGSCA_CODABI); long cabvs = pagsca.get_long(PAGSCA_CODCAB); TString codag = pagsca.get (PAGSCA_CODAG); char tipoc = pagsca.get_char(PAGSCA_TIPOCC); int gruppoc = pagsca.get_int (PAGSCA_GRUPPOC); int contoc = pagsca.get_int (PAGSCA_CONTOC); long sottocc = pagsca.get_long(PAGSCA_SOTTOCONTC); controlla_anaCF_Pcon(tipoc,gruppoc,contoc,sottocc); if (_prima_rata_pag) { set_row(riga,FR("@22gRif. rata acc./saldo Sez Importo Importo valuta Contropartita")); set_row(riga++,FR("@158gNostra banca Vostra banca Agente")); _prima_rata_pag = FALSE; } else set_row(riga++, ""); set_row(riga,"@22g%4d", nriga); set_row(riga,"@26g/@27g%4d", nrata); set_row(riga,"@42g%c", accsaldo); set_row(riga,"@51g%c", _sez); set_row(riga,"@55g%r", &importo); if (importoval != ZERO) set_row(riga,"@71g%15s", (const char*) importoval.string("###.###.###,@@@")); set_row(riga,"@88g%c", tipoc); if (gruppoc != 0) set_row(riga,"@90g%3d", gruppoc); if (contoc != 0) set_row(riga,"@94g%3d", contoc); if (sottocc != 0) { set_row(riga,"@98g%6ld", sottocc); set_row(riga,"@105g%-50s", (const char*) _descr_anag); } if (abins != 0) set_row(riga,"@158g%ld", abins); if (cabns != 0) set_row(riga,"@165g%ld", cabns); if (abivs != 0) set_row(riga,"@172g%ld", abivs); if (cabvs != 0) set_row(riga,"@179g%ld", cabvs); set_row(riga,"@189g%-5s", (const char*) codag); if (ritenute != ZERO) { riga++; set_row(riga,"@51g%c", _sez); set_row(riga,"@55g%r", &ritenute); set_row(riga,FR("@88gRitenute professionali")); } if (abbuoni != ZERO) { riga++; char sezione; if (passat == 'A') sezione = 'D'; else if (passat == 'P') sezione = 'A'; if (sezione != _sez) abbuoni = abbuoni * -1; set_row(riga,"@51g%c", sezione); if (_codval.not_empty()) set_row(riga,"@71g%15s", (const char*) abbuoni.string("###.###.###,@@@")); else set_row(riga,"@55g%r", &abbuoni); if (passat == 'A') set_row(riga,"@88gAbbuoni attivi"); else if (passat == 'P') set_row(riga,FR("@88gAbbuoni passivi")); } if (diffcam != ZERO) { riga++; char sezione = _sez; if (diffcam < ZERO) { diffcam = diffcam * -1; if (_sez == 'D') sezione = 'A'; else if (_sez == 'A') sezione = 'D'; } set_row(riga,"@51g%c", sezione); set_row(riga,"@55g%r", &diffcam); set_row(riga,FR("@88gDifferenza cambio")); } if (nriga != 9999) { if (!record_partite(nriga)) { _errore_grave_SC = TRUE; set_row(++riga, "@30g%s", get_error(32)); } } if (nrata != 9999) { if (!record_scadenze(nriga,nrata)) { _errore_grave_SC = TRUE; set_row(++riga, "@30g%s", get_error(33)); } } if (accsaldo != 'A' && accsaldo != 'S') { _errore_grave_SC = TRUE; set_row(++riga, "@30g%s", get_error(34)); } if (importo == ZERO) { _errore_grave_SC = TRUE; set_row(++riga, "@30g%s", get_error(35)); } if (_codval.not_empty() && importoval == ZERO) { _errore_grave_SC = TRUE; set_row(++riga, "@30g%s", get_error(36)); } if (abbuoni != ZERO && (passat != 'A' && passat != 'P') ) { _errore_grave_SC = TRUE; set_row(++riga, "@30g%s", get_error(37)); } if (!banca(abins,cabns)) set_row(++riga, "@30g%s", get_error(28)); if (!banca(abivs,cabvs)) set_row(++riga, "@30g%s", get_error(29)); if (!agente(codag)) set_row(++riga, "@30g%s", get_error(30)); if (!controlla_anaCF_Pcon(tipoc,gruppoc,contoc,sottocc)) set_row(++riga, FR("@30g--- Codice contropartita errato")); } } void TRic_ListaMov::azzera_impdocval() { TRecnotype recn = _tpart->recno(); TIsamtempfile& part = *_tpart; part.setkey(1); part.zero(); for (part.first(); !part.eof(); part.next()) { int tipomov = part.get_int(PART_TIPOMOV); if (tipomov != 1 && tipomov != 4) { part.zero(PART_IMPTOTDOC); part.zero(PART_IMPTOTVAL); part.rewrite(); } } _tpart->readat(recn); } bool TRic_ListaMov::preprocess_print(int file, int counter) { if (file == LF_PARTITE) azzera_impdocval(); return TRUE; } bool TRic_ListaMov::preprocess_page(int file,int counter) { TCursor* cur = current_cursor(); if (counter) return TRUE; reset_print(); if (file == LF_MOV) { _anno = cur->curr(LF_MOV).get_int(MOV_ANNOES); _datacomp = cur->curr(LF_MOV).get_date(MOV_DATACOMP); _datadoc = cur->curr(LF_MOV).get_date(MOV_DATADOC); _data74tr = cur->curr(LF_MOV).get_date(MOV_DATA74TER); _causale = cur->curr(LF_MOV).get(MOV_CODCAUS); _registro = cur->curr(LF_MOV).get(MOV_REG); format_if_zero(_registro, 3); _tipodoc = cur->curr(LF_MOV).get(MOV_TIPODOC); _numdoc = cur->curr(LF_MOV).get(MOV_NUMDOC); _datareg = cur->curr(LF_MOV).get_date(MOV_DATAREG); _codcf = cur->curr(LF_MOV).get_long(MOV_CODCF); _numero = cur->curr(LF_MOV).get_long(MOV_NUMREG); _protiva = cur->curr(LF_MOV).get_long(MOV_PROTIVA); _codval = cur->curr(LF_MOV).get(MOV_CODVALI); _codpag = cur->curr(LF_MOV).get(MOV_CODPAG); _annoiva = _datareg.year(); _tot_dare = _tot_avere = ZERO; _tot_doc = ZERO; _tipodoc = ""; _tipocf = ' '; _ae = date2esc(_datareg); //_num_rec = cur->curr(LF_MOV).get_long(MOV_NUMGIO); bool controlla = controlla_mov(); //se TRUE => ci sono errori nella testata bool veriva = FALSE; if (_is_iva) //Va fatto solo se ho ricevuto anche l'iva veriva = controlla_riva(); bool verrmov = controlla_rmov(); bool verifica = (veriva || verrmov); aggiorna_mov(); if ( (_controllo == 1 && controlla) || _controllo == 2 || (_controllo == 1 && verifica) ) { TString16 datareg_str = _datareg.string(); // "Fai vedere lo stesso ..-..-.... anche se non c'e' la data..." if (datareg_str.empty()) datareg_str = " - - "; TString16 datadoc_str = _datadoc.string(); if (datadoc_str.empty()) datadoc_str = " - - "; int r = 1; set_row(r++, ""); set_row(r,FR("Operazione n. %-7ld"), _numero); set_row(r,FR(" del %s"), (const char*)datareg_str); set_row(r,FR(" doc. n. %-7s"), (const char*)_numdoc); set_row(r,FR(" del %s"), (const char*)datadoc_str); if (!_registro.blank()) //e' una fattura { set_row(r,FR(" registro IVA %-3s"), (const char*)_registro); set_row(r,FR(" protocollo n. %-5ld"), _protiva); } set_row(r, FR(" comp. %d"), _anno); // Guy: Aggiunta stampa mese di liquidazione se presente const int meseliq = cur->curr(LF_MOV).get_int(MOV_MESELIQ); if (meseliq > 0) set_row(r, FR(" mese liq. %d"), meseliq); stampa_errori_mov(r); _ho_stampato = TRUE; return TRUE; } return FALSE; } else if (file == LF_RMOV) { _gruppo = cur->curr(LF_RMOV).get_int(RMV_GRUPPO); _conto = cur->curr(LF_RMOV).get_int(RMV_CONTO); _sottoconto = cur->curr(LF_RMOV).get_long(RMV_SOTTOCONTO); _gruppoc = cur->curr(LF_RMOV).get_int(RMV_GRUPPOC); _contoc = cur->curr(LF_RMOV).get_int(RMV_CONTOC); _sottocontoc = cur->curr(LF_RMOV).get_long(RMV_SOTTOCONTOC); _importo = cur->curr(LF_RMOV).get_real(RMV_IMPORTO); _sezione = cur->curr(LF_RMOV).get(RMV_SEZIONE)[0]; TString80 descr = cur->curr(LF_RMOV).get(RMV_DESCR); int numrig = cur->curr(LF_RMOV).get_int(RMV_NUMRIG); _tipo_conto = ""; if (_gruppo != 0 && _conto != 0 && _sottoconto != 0l) _esiste_conto = DescrConto(_gruppo,_conto,_sottoconto); else { _esiste_conto = FALSE; _descr_conto = ""; } int r = 1; set_row(r, "P%d", numrig); set_row(r, "@5g%3s %-.20s @30g%-.24s @56g%03d %03d %06ld @71g%-.28s", (const char*) _causale, (const char*) _descr_causale, (const char*) descr, _gruppo, _conto, _sottoconto, (const char*) _descr_conto); if (_sezione == 'D') set_row(r, "@99g%r", &_importo); else if (_sezione == 'A') set_row(r, "@116g%r", &_importo); else set_row(r, "@107g%r", &_importo); stampa_errori_rmov(r); // TLocalisamfile& rmov = current_cursor()->file(LF_RMOV); // rmov.put(RMV_ANNOES, _annoese); // rmov.rewrite(); } else if (file == LF_RMOVIVA) { real impo = cur->curr(LF_RMOVIVA).get_real(RMI_IMPONIBILE); real impos = cur->curr(LF_RMOVIVA).get_real(RMI_IMPOSTA); int numrig = cur->curr(LF_RMOVIVA).get_int(RMI_NUMRIG); _tipocr = cur->curr(LF_RMOVIVA).get_int(RMI_TIPOCR); _tipod = cur->curr(LF_RMOVIVA).get_int(RMI_TIPODET); _codiva = cur->curr(LF_RMOVIVA).get(RMI_CODIVA); //_n_rec = cur->curr(LF_RMOVIVA).get_int(RMI_ANNOES); _gruppocr = cur->curr(LF_RMOVIVA).get_int(RMI_GRUPPO); _contocr = cur->curr(LF_RMOVIVA).get_int(RMI_CONTO); _sottocontocr = cur->curr(LF_RMOVIVA).get_long(RMI_SOTTOCONTO); TString80 codiva_des(get_codiva_des(_codiva)); //_tot_doc += impo + impos; _impo = impo; _impos = impos; if (!_tipodoc.blank()) { TTable tabtpd("%TPD"); tabtpd.put("CODTAB", _tipodoc); if (tabtpd.read() == NOERR) { bool cor = tabtpd.get_bool("B0"); if (cor) { _impo = impo + impos; _impos = ZERO; } } } int r = 1; // Cambia segno se si tratta di note di credito o storni if (_tipodoc == "NC" || _tipodoc == "ST") { _impo_print = _impo * (-1); _impos_print = _impos * (-1); } else { _impo_print = _impo; _impos_print = _impos; } set_row(r, "I%d", numrig); set_row(r, FR("@5gImponibile@16g%r"),&_impo_print); set_row(r, FR("@32gImposta@40g%r"), &_impos_print); set_row(r, FR("@56gCodice@63g%4s"), (const char*) _codiva); set_row(r, "@68g%s", (const char*) codiva_des); if (_tipod != 0) set_row(r," %d", _tipod); stampa_errori_riva(r); } if (file == LF_PARTITE) { _err.reset(); _tipomov = cur->curr(LF_PARTITE).get_int (PART_TIPOMOV); _tipocf = cur->curr(LF_PARTITE).get_char(PART_TIPOCF); _gruppo = cur->curr(LF_PARTITE).get_int (PART_GRUPPO); _conto = cur->curr(LF_PARTITE).get_int (PART_CONTO); _codcf = cur->curr(LF_PARTITE).get_long(PART_SOTTOCONTO); _anno = cur->curr(LF_PARTITE).get_int (PART_ANNO); _numpart = cur->curr(LF_PARTITE).get (PART_NUMPART); _nriga = cur->curr(LF_PARTITE).get_int (PART_NRIGA); _numreg = cur->curr(LF_PARTITE).get_long(PART_NREG); _numrig = cur->curr(LF_PARTITE).get_int (PART_NUMRIG); _datareg = cur->curr(LF_PARTITE).get_date(PART_DATAREG); _datadoc = cur->curr(LF_PARTITE).get_date(PART_DATADOC); _numdoc = cur->curr(LF_PARTITE).get (PART_NUMDOC); _reg = cur->curr(LF_PARTITE).get (PART_REG); _protiva = cur->curr(LF_PARTITE).get_long(PART_PROTIVA); _causale = cur->curr(LF_PARTITE).get (PART_CODCAUS); _tipopag = cur->curr(LF_PARTITE).get_int (PART_TIPOPAG); _datapag = cur->curr(LF_PARTITE).get_date(PART_DATAPAG); _codval = cur->curr(LF_PARTITE).get (PART_CODVAL); _cambio = cur->curr(LF_PARTITE).get_real(PART_CAMBIO); _datacam = cur->curr(LF_PARTITE).get (PART_DATACAM); _sez = cur->curr(LF_PARTITE).get_char(PART_SEZ); _gruppocl = cur->curr(LF_PARTITE).get_int (PART_GRUPPOCL); _contocl = cur->curr(LF_PARTITE).get_int (PART_CONTOCL); aggiorna_partite(); bool verpagsca = controlla_pagsca(); bool verscad = controlla_scadenze(); bool controlla = controlla_partite(); //se TRUE => ci sono errori nella testata bool verifica = (verpagsca || verscad); if ( (_controllo == 1 && controlla) || _controllo == 2 || (_controllo == 1 && verifica) ) { TString16 datareg_str = _datareg.string(); // "Fai vedere lo stesso ..-..-.... anche se non c'e' la data..." if (datareg_str.empty()) datareg_str = " - - "; TString16 datadoc_str = _datadoc.string(); if (datadoc_str.empty()) datadoc_str = " - - "; TString16 datapag_str = _datapag.string(); if (datapag_str.empty()) datapag_str = " - - "; TString16 datacam_str = _datacam.string(); if (datacam_str.empty()) datacam_str = " - - "; TString ccf; if (_tipocf == 'C') ccf = TR("Cliente: "); else if (_tipocf == 'F') ccf = TR("Fornitore:"); else ccf = TR("Conto: "); // I riga di testata int r = 1; set_row(r++, ""); if (_tipocf != _tipocf_p || _gruppo != _gruppo_p || _conto != _conto_p || _codcf != _codcf_p) { set_row(r++, ""); set_row(r,"@b%s", (const char*) ccf); if (_gruppo != 0) set_row(r,"@b%3d", _gruppo); if (_conto != 0) set_row(r,"@b%3d", _conto); set_row(r,"@b%6ld", _codcf); set_row(r++," @b%-50s", (const char*) _descr_anag); } // II riga di testata (L'intestazione viene stampata solo a rottura di partita) if (_tipocf != _tipocf_p || _gruppo != _gruppo_p || _conto != _conto_p || _codcf != _codcf_p || _numpart != _numpart_prec || _anno != _anno_prec) set_row(r,FR("@0g@rRif. partita")); set_row(r,FR("@14gN.riga@22gN.operaz./riga Data oper. Data doc. N.doc. Reg Prot. Causale")); set_row(r++,FR("@142gTipo/Data pag. Cod.val Cambio Data cambio Sez")); if (_tipocf != _tipocf_p || _gruppo != _gruppo_p || _conto != _conto_p || _codcf != _codcf_p || _numpart != _numpart_prec || _anno != _anno_prec) { set_row(r,"%4d", _anno); set_row(r,"@4g/%-7s", (const char*) _numpart); } set_row(r,"@15g%4d", _nriga); if (_numreg != 0) set_row(r,"@23g%7ld", _numreg); else set_row(r,"@23g-"); if (_numrig != 0) set_row(r,"@32g%4d", _numrig); else set_row(r,"@32g-"); set_row(r,"@38g%10s", (const char*) datareg_str); set_row(r,"@50g%10s", (const char*) datadoc_str); set_row(r,"@62g%-7s", (const char*) _numdoc); if (_tipomov == 1 || _tipomov == 2) { set_row(r,"@71g%-3s", (const char*) _reg); if (_protiva != 0) set_row(r,"@76g%05ld", _protiva); } set_row(r,"@83g%-3s", (const char*) _causale); set_row(r,"@88g%-50s", (const char*) _descr_causale); if (_tipopag != 0) set_row(r,"@144g%d", _tipopag); set_row(r,"@147g%10s", (const char*) datapag_str); set_row(r,"@160g%-3s", (const char*) _codval); if (_cambio != ZERO) set_row(r,"@166g%15s",(const char*) _cambio.string("#.###.###,@@@@@")); set_row(r,"@183g%10s", (const char*) datacam_str); set_row(r,"@196g%c", _sez); _tipocf_p = _tipocf; _gruppo_p = _gruppo; _conto_p = _conto; _codcf_p = _codcf; stampa_errori_partite(r); _prima_rata_pag = TRUE; _numpart_prec = _numpart; _anno_prec = _anno; _ho_stampato = TRUE; return TRUE; } return FALSE; } if (file == LF_SCADENZE) { int r = 1; stampa_errori_scadenze(r); } if (file == LF_PAGSCA) { int r = 1; stampa_errori_pagsca(r); } return TRUE; } print_action TRic_ListaMov::postprocess_page(int file,int count) { if (count) return NEXT_PAGE; if (file == LF_MOV) { reset_print(); _err.reset(); int n = 1; const TCurrency sbil(real(_tot_dare - _tot_avere)); if (!sbil.is_zero()) { _errore_grave = TRUE; set_row(n++, FR("@8g*** Il movimento risulta sbilanciato. Totali rilevati:@99g%r@116g%r"), &_tot_dare, &_tot_avere); return REPEAT_PAGE; } } if (file == LF_PARTITE) { reset_print(); _err.reset(); } return NEXT_PAGE; } print_action TRic_ListaMov::postprocess_print(int file, int counter) { if (file == LF_MOV || file == LF_PARTITE) if (_ho_stampato) printer().formfeed(); return NEXT_PAGE; } void TRic_ListaMov::postclose_print() { bool esegui; // La variabile esegui mi permette di visualizzare il messaggio se non c'e il // saldaconto, oppure se c'e' il saldaconto ma e' gia' stato eseguito il controllo // su quest'ultimo if ( (_is_salda && _seconda_volta) || !_is_salda) esegui = TRUE; else esegui = FALSE; if (_is_salda) if (_seconda_volta) _seconda_volta = FALSE; else _seconda_volta = TRUE; _errore_grave_totale = _errore_grave || _errore_grave_SC; if (esegui) { if (_errore_grave_totale) { if (_ric_auto == 'A') { _risposta = TRUE; _continua = yesno_box(TR("Rilevati ERRORI GRAVI durante il controllo movimenti: \n Controllare gli errori sulla lista dei movimenti stampata per eseguire le correzioni. \n Continuare ugualmente?")); TTransfer_file& tr = trasfer(); if (!_continua) _record.overwrite(" ",240); //_record e' letto nella read_control_rec() else { TConfig conf (CONFIG_DITTA); conf.set("FlStTra", "M"); _record.overwrite("Z",240); } const int size = 1024; tr.write_control_rec(_record, size); tr.read_control_rec(); } else { message_box(TR("Rilevati errori gravi durante il controllo movimenti:\n trasferimento interrotto")); TTransfer_file& tr = trasfer(); _record.overwrite(" ",240); //_record e' letto nella read_control_rec() const int size = 1024; tr.write_control_rec(_record, size); tr.read_control_rec(); chiudi_file_SC(); } } else { if (_ric_auto == 'A') _risposta = TRUE; else message_box(TR("CONTROLLO MOVIMENTI terminato: \n proseguire con RICEZIONE movimenti")); TConfig conf (CONFIG_DITTA); conf.set("FlStTra", "M"); TTransfer_file& tr = trasfer(); _record.overwrite("Z",240); //_record e' letto nella read_control_rec() const int size = 1024; tr.write_control_rec(_record, size); tr.read_control_rec(); chiudi_file_SC(); } } // if (esegui) } char TRic_ListaMov::sezione_ritsoc(const TRectype& part) const { TString16 key; key << part.get(PART_CODCAUS) << "|14"; // Riga ritenute sociali const char sezrs = cache().get(LF_RCAUSALI, key, RCA_SEZIONE)[0]; return sezrs > ' ' ? (sezrs == 'D' ? 'A' : 'D') : part.get_char(PART_SEZ); } real TRic_ListaMov::segno_ritsoc(const TRectype& part) const { return part.get_char(PART_SEZ) == sezione_ritsoc(part) ? UNO : -UNO; } void TRic_ListaMov::esamina_partite() { bool prima_volta = TRUE; int numrigp = -1; TRecnotype recp = _tpart->recno(); TIsamtempfile& part = *_tpart; part.setkey(2); part.zero(); part.put(PART_NREG, _numero); const TRectype partita (part.curr()); for (part.read(_isgteq); !part.eof(); part.next()) { if (part.curr() != partita) break; int tipomov = part.get_int(PART_TIPOMOV); int numrig = part.get_int(PART_NUMRIG); // if (numrig != numrigp) // { real doc = ZERO; real val = ZERO; if (tipomov != 1 && tipomov != 2) { TIsamtempfile& pagsca = *_tpagsca; pagsca.zero(); pagsca.put(PAGSCA_TIPOC, part.get_char(PART_TIPOCF)); pagsca.put(PAGSCA_GRUPPO, part.get_int (PART_GRUPPO)); pagsca.put(PAGSCA_CONTO, part.get_int (PART_CONTO)); pagsca.put(PAGSCA_SOTTOCONTO, part.get_long(PART_SOTTOCONTO)); pagsca.put(PAGSCA_ANNO, part.get_int (PART_ANNO)); pagsca.put(PAGSCA_NUMPART, part.get (PART_NUMPART)); int nriga = part.get_int(PART_NRIGA); TRectype pagamenti (pagsca.curr()); for (pagsca.read(_isgteq); !pagsca.eof(); pagsca.next()) { TString rec = pagamenti.get(PAGSCA_NUMPART); TString file = pagsca.get(PAGSCA_NUMPART); if (pagsca.curr() != pagamenti || file != rec) break; int nrigp = pagsca.get_int(PAGSCA_NRIGP); if (nrigp != nriga) continue; doc += pagsca.get_real(PAGSCA_IMPORTO) + pagsca.get_real(PAGSCA_RITENUTE); doc += pagsca.get_real(PAGSCA_RITSOC) * segno_ritsoc(part.curr()); val += pagsca.get_real(PAGSCA_IMPORTOVAL); } if (prima_volta) _tot_doc = ZERO; _tot_doc += doc; } if (tipomov == 1) { TRecnotype recs = _tscad->recno(); TIsamtempfile& scad = *_tscad; scad.zero(); scad.put(SCAD_TIPOCF, part.get_char(PART_TIPOCF)); scad.put(SCAD_GRUPPO, part.get_int (PART_GRUPPO)); scad.put(SCAD_CONTO, part.get_int (PART_CONTO)); scad.put(SCAD_SOTTOCONTO, part.get_long(PART_SOTTOCONTO)); scad.put(SCAD_ANNO, part.get_int (PART_ANNO)); scad.put(SCAD_NUMPART, part.get (PART_NUMPART)); scad.put(SCAD_NRIGA, part.get_int (PART_NRIGA)); TRectype scadenze (scad.curr()); for (scad.read(_isgteq); !scad.eof(); scad.next()) { TString rec = scadenze.get(SCAD_NUMPART); TString file = scad.get(SCAD_NUMPART); if (scad.curr() != scadenze || file != rec) break; val += scad.get_real(SCAD_IMPORTOVAL); } _tscad->readat(recs); } if (prima_volta) _tot_val = ZERO; _tot_val += val; // } // numrigp = numrig; if (prima_volta) { _codval_part = part.get (PART_CODVAL); _datacam_part = part.get_date(PART_DATACAM); _cambio_part = part.get_real(PART_CAMBIO); if (tipomov == 1) { TRecnotype recs = _tscad->recno(); TIsamtempfile& scad = *_tscad; char tipo = part.get_char(PART_TIPOCF); int gruppo = part.get_int (PART_GRUPPO); int conto = part.get_int (PART_CONTO); long sottoc = part.get_long(PART_SOTTOCONTO); int anno = part.get_int (PART_ANNO); TString numpart = part.get (PART_NUMPART); int nriga = part.get_int (PART_NRIGA); scad.setkey(1); scad.zero(); scad.put(SCAD_TIPOCF, tipo); scad.put(SCAD_GRUPPO, gruppo); scad.put(SCAD_CONTO, conto); scad.put(SCAD_SOTTOCONTO, sottoc); scad.put(SCAD_ANNO, anno); scad.put(SCAD_NUMPART, numpart); scad.put(SCAD_NRIGA, nriga); TRectype scadenza (scad.curr()); _codpag_scad = ""; for (scad.read(_isgteq); !scad.eof(); scad.next()) { TString rec = scadenza.get(SCAD_NUMPART); TString file = scad.get(SCAD_NUMPART); if (scad.curr() != scadenza || file != rec) break; _codpag_scad = scad.get(SCAD_CODPAG); break; } _tscad->readat(recs); } prima_volta = FALSE; } } _tpart->readat(recp); } void TRic_ListaMov::aggiorna_mov() { TLocalisamfile& mov = current_cursor()->file(LF_MOV); if (_is_salda) esamina_partite(); if (_anno == 0) mov.put(MOV_ANNOES, _annoese); mov.put(MOV_DATACOMP, _datacomp); mov.put(MOV_ANNOIVA, _annoiva); mov.put(MOV_REG, _registro); mov.put(MOV_TIPODOC, _tipodoc); mov.put(MOV_TIPO, _tipocf); if (mov.get(MOV_TIPOMOV).empty()) mov.put(MOV_TIPOMOV, _tipom_cau); mov.put(MOV_CODPAG, _codpag_scad); const bool first_time = mov.get("TOCFP")!="X"; if ((_tipodoc == "NC" || _tipodoc == "ST") && first_time) // swap sign only if it's first time { _tot_doc = -_tot_doc; mov.put("TOCFP","X"); } // NB In caso di ricezione da sistema ritsoc e ritfis valgono sempre 0 // quindi in caso di ricezione da PC ripristina il totale documento corretto. real ritsoc = mov.get(MOV_RITSOC); real ritfis = mov.get(MOV_RITFIS); _tot_doc = _tot_doc - ritsoc - ritfis; mov.put(MOV_TOTDOC, _tot_doc); if (_is_salda) { if (mov.get_real(MOV_TOTDOCVAL) == ZERO) mov.put(MOV_TOTDOCVAL, _tot_val); if (mov.get(MOV_CODVAL).empty()) mov.put(MOV_CODVAL, _codval_part); if (mov.get(MOV_DATACAM).empty()) mov.put(MOV_DATACAM, _datacam_part); if (mov.get_real(MOV_CAMBIO) == ZERO) mov.put(MOV_CAMBIO, _cambio_part); } mov.rewrite(); } void TRic_ListaMov::aggiorna_rmov(char tipoc, char tipocc) { TLocalisamfile& rmov = current_cursor()->file(LF_RMOV); if (_anno == 0) rmov.put(RMV_ANNOES, _annoese); rmov.put(RMV_TIPOC, tipoc); rmov.put(RMV_TIPOCC, tipocc); rmov.rewrite(); } void TRic_ListaMov::aggiorna_iva(char tipo) { TLocalisamfile& riva = current_cursor()->file(LF_RMOVIVA); TLocalisamfile& mov = current_cursor()->file(LF_MOV); if (_anno == 0) riva.put(RMI_ANNOES, _annoese); const bool first_time = mov.get("TOCFP") != "X"; if ((_tipodoc == "NC" || _tipodoc == "ST") && first_time) // swap sign only if it is the first time { _impo = _impo * -1; _impos = _impos * -1; } riva.put(RMI_IMPONIBILE, _impo); riva.put(RMI_IMPOSTA, _impos); riva.put(RMI_TIPOC, tipo); riva.rewrite(); } bool TRic_ListaMov::solo_SC(long numreg) { TIsamtempfile& tmov = *_tmov; tmov.setkey(1); tmov.zero(); tmov.put(MOV_NUMREG, numreg); if (tmov.read() == NOERR) return FALSE; return TRUE; } void TRic_ListaMov::calcola_imposta(long nreg, real& imposta) { TRecnotype recn = _tiva->recno(); TIsamtempfile& riva = *_tiva; riva.zero(); riva.put(RMI_NUMREG, nreg); TRectype recriva (riva.curr()); for (riva.read(_isgteq); !riva.eof(); riva.next()) { if (riva.curr() > recriva) break; real imp (riva.get_real(RMI_IMPOSTA)); imposta += imp; } _tiva->readat(recn); } bool TRic_ListaMov::calcola_impdocval(long nreg,int nrig,char tipoc,int gruppo,int conto,long sottoc, int anno,TString& numpart,int nriga,real& doc,real& val) { TRecnotype recn = _tpagsca->recno(); TIsamtempfile& pagsca = *_tpagsca; bool prima_volta = TRUE; doc = ZERO; val = ZERO; pagsca.zero(); pagsca.put(PAGSCA_TIPOC, tipoc); pagsca.put(PAGSCA_GRUPPO, gruppo); pagsca.put(PAGSCA_CONTO, conto); pagsca.put(PAGSCA_SOTTOCONTO, sottoc); pagsca.put(PAGSCA_ANNO, anno); pagsca.put(PAGSCA_NUMPART, numpart); // pagsca.put(PAGSCA_NRIGA, nriga); const TRectype pagamenti (pagsca.curr()); for (pagsca.read(_isgteq); !pagsca.eof(); pagsca.next()) { TString rec = pagamenti.get(PAGSCA_NUMPART); TString file = pagsca.get(PAGSCA_NUMPART); if (pagsca.curr() != pagamenti || file != rec) break; int nrigp = pagsca.get_int(PAGSCA_NRIGP); if (nrigp != nriga) continue; doc += pagsca.get_real(PAGSCA_IMPORTO) + pagsca.get_real(PAGSCA_RITENUTE); const real ritsoc = pagsca.get(PAGSCA_RITSOC); if (!ritsoc.is_zero()) { TToken_string key; key.add(tipoc); key.add(gruppo); key.add(conto); key.add(sottoc); key.add(anno); key.add(numpart); const TRectype& part = cache().get(LF_PARTITE, key); doc += ritsoc * segno_ritsoc(part); } val += pagsca.get_real(PAGSCA_IMPORTOVAL); } _tpagsca->readat(recn); if (nreg != 0 && nrig != 0) { int key = _tpart->getkey(); TRecnotype rec = _tpart->recno(); TIsamtempfile& part = *_tpart; part.setkey(2); part.zero(); part.put(PART_NREG, nreg); part.put(PART_NUMRIG, nrig); TRectype partita (part.curr()); for (part.read(); !part.eof(); part.next()) { if (part.curr() > partita) break; real imp = part.get_real(PART_IMPTOTDOC) + doc; real impval = part.get_real(PART_IMPTOTVAL) + val; part.put(PART_IMPTOTDOC, imp); part.put(PART_IMPTOTVAL, impval); part.setkey(1); part.rewrite(); part.setkey(2); } _tpart->readat(rec); _tpart->setkey(key); } else return TRUE; return FALSE; } void TRic_ListaMov::calcola_importo(char tipoc,int gruppo,int conto,long sottoc, int anno,TString& numpart,int nriga) { TRecnotype recn = _tscad->recno(); TIsamtempfile& scad = *_tscad; scad.setkey(1); scad.zero(); scad.put(SCAD_TIPOCF, tipoc); scad.put(SCAD_GRUPPO, gruppo); scad.put(SCAD_CONTO, conto); scad.put(SCAD_SOTTOCONTO, sottoc); scad.put(SCAD_ANNO, anno); scad.put(SCAD_NUMPART, numpart); scad.put(SCAD_NRIGA, nriga); TRectype scadenza (scad.curr()); for (scad.read(_isgteq); !scad.eof(); scad.next()) { TString rec = scadenza.get(SCAD_NUMPART); TString file = scad.get(SCAD_NUMPART); if (scad.curr() != scadenza || file != rec) break; _imp += scad.get_real(SCAD_IMPORTO); _impval += scad.get_real(SCAD_IMPORTOVAL); } _tscad->readat(recn); } void TRic_ListaMov::aggiorna_partita(real& importo,real& importoval,real& abbuoni,real& diffcam, real& ritfis,real& ritsoc, TString& sez,TString& sezabb,TString& sezdc) { TRecnotype recn = _tpagsca->recno(); TIsamtempfile& pagsca = *_tpagsca; real abb,diff; abb = ZERO; diff = ZERO; pagsca.setkey(1); pagsca.zero(); pagsca.put(PAGSCA_TIPOC, _tipocf); pagsca.put(PAGSCA_GRUPPO, _gruppo); pagsca.put(PAGSCA_CONTO, _conto); pagsca.put(PAGSCA_SOTTOCONTO, _codcf); pagsca.put(PAGSCA_ANNO, _anno); pagsca.put(PAGSCA_NUMPART, _numpart); TRectype pagamento (pagsca.curr()); for (pagsca.read(_isgteq); !pagsca.eof(); pagsca.next()) { TString rec = pagamento.get(PAGSCA_NUMPART); TString file = pagsca.get(PAGSCA_NUMPART); if (pagsca.curr() != pagamento || file != rec) break; int nrigp = pagsca.get_int(PAGSCA_NRIGP); if (_nriga != nrigp) continue; importo += pagsca.get_real(PAGSCA_IMPORTO); importoval += pagsca.get_real(PAGSCA_IMPORTOVAL); ritfis += pagsca.get_real(PAGSCA_RITENUTE); ritsoc += pagsca.get_real(PAGSCA_RITSOC); abb = pagsca.get_real(PAGSCA_ABBUONI); if (abb != ZERO) { if (sezabb.empty()) { abbuoni += abb; sezabb = sez; } else if (sez == sezabb) abbuoni += abb; else abbuoni -= abb; } diff = pagsca.get_real(PAGSCA_DIFFCAM); if (diff != ZERO) { if (sezdc.empty()) { diffcam += diff; sezdc = sez; } else if (sez == sezdc) diffcam += diff; else diffcam -= diff; } } if (abbuoni < ZERO) { abbuoni = abbuoni * -1; if (sezabb == "D") sezabb = "A"; else if (sezabb == "A") sezabb = "D"; } if (diffcam < ZERO) { diffcam = diffcam * -1; if (sezdc == "D") sezdc = "A"; else if (sezdc == "A") sezdc = "D"; } _tpagsca->readat(recn); } void TRic_ListaMov::aggiorna_partite() { TLocalisamfile& part = current_cursor()->file(LF_PARTITE); real imposta = ZERO; if (!solo_SC(_numreg) && _tipomov == 1) // && (part.get_real(PART_IMPOSTA) == ZERO) ) { if (_is_iva) { calcola_imposta(_numreg,imposta); part.put(PART_IMPOSTA, imposta); } } if (_tipomov != 1 && _tipomov != 4) { /* if (_prima_volta) { _prima_volta = FALSE; if (part.get_real(PART_IMPTOTDOC) == ZERO) _calcola = TRUE; else _calcola = FALSE; } */ // if (_calcola) // { real doc; real val; if (calcola_impdocval(_numreg,_numrig,_tipocf,_gruppo,_conto,_codcf,_anno,_numpart,_nriga,doc,val)) { part.put(PART_IMPTOTDOC, doc); part.put(PART_IMPTOTVAL, val); } // } } if (_tipomov == 1 ) //&& (part.get_real(PART_IMPORTO) == ZERO) ) { calcola_importo(_tipocf,_gruppo,_conto,_codcf,_anno,_numpart,_nriga); part.put(PART_IMPORTO, _imp); part.put(PART_IMPORTOVAL, _impval); _imp = ZERO; _impval = ZERO; } if (_tipomov != 1) // && (part.get_real(PART_IMPORTO) == ZERO) ) { real importo = ZERO; real importoval = ZERO; real ritfis = ZERO; real ritsoc = ZERO; real abbuoni = ZERO; real diffcam = ZERO; TString sez = part.get(PART_SEZ); TString sezabb = part.get(PART_SEZABB); TString sezdc = part.get(PART_SEZDIFCAM); aggiorna_partita(importo,importoval,abbuoni,diffcam,ritfis,ritsoc,sez,sezabb,sezdc); part.put(PART_IMPORTO, importo); part.put(PART_IMPORTOVAL, importoval); part.put(PART_RITENUTE, ritfis); part.put(PART_RITSOC, ritsoc); part.put(PART_SEZABB, sezabb); part.put(PART_ABBUONI, abbuoni); part.put(PART_SEZDIFCAM, sezdc); part.put(PART_DIFFCAM, diffcam); } part.rewrite(); } bool TRic_ListaMov::user_destroy() { delete _giornale; delete _trasfer; delete _rel; // Sono gia' distrutti in quanto parte di _rel // delete _tmov; // delete _trmov; // if (_is_iva) delete _tiva; delete _caus; delete _ditte; delete _clifo; delete _pcon; delete _mov; delete _rmov; delete _rmoviva; delete _part; delete _scad; delete _pagsca; delete _tab_pag; delete _tab_tpd; delete _tab_iva; delete _tab_ese; delete _tab_tra; return TRUE; } void TRic_ListaMov::chiudi_file_SC() { if (_is_salda) { delete _relSC; _relSC = NULL; // Non cancellare: Gia' contenuti in _relSC // delete _tpart; _tpart = NULL; // delete _tscad; _tscad = NULL; // delete _tpagsca; _tpagsca = NULL; delete _part; _part = NULL; delete _scad; _scad = NULL; delete _pagsca; _pagsca = NULL; } } bool TRic_ListaMov::set_print(int m) { if (_ric_auto == 'A') { if (_risposta) // Metto questa variabile booleana per uscire, altrimenti { // il programma andrebbe in loop andando ancora in stampa TString appname = "cg6 -0"; TString body = ""; if (_continua) body = "1"; else body = "0"; TMessage msg (appname,"",(const char*)body); TMailbox mb; mb.send(msg); return FALSE; } if (_seconda_volta && _is_salda) { reset_files(); // Resetta l'albero di stampa precedente relativo ai movimenti contabili e iva select_cursor(_curSC); // Seleziona il cursore relativo ai movimenti del saldaconto add_file (LF_PARTITE); add_file (LF_SCADENZE, LF_PARTITE); add_file (LF_PAGSCA, LF_PARTITE); _errore_grave_SC = FALSE; _intestaSC = TRUE; _prima_volta = TRUE; _ho_stampato = FALSE; } else { TString80 nome; long ditta_ric = get_firm(); TTransfer_file& tr = trasfer(); // Nella lista controllo movimenti lanciata da menu il record di // controllo dell'header viene letto nella funzione check_archivi // Nella ricezione in automatico devo leggerlo in questo punto _pathfile = tr.path(); _pathfile = _pathfile << HEADER; if (!tr.open(_pathfile)) return error_box(TR("Al momento non presenti trasferimenti attivi sulla ditta selezionata")); if (!tr.read_control_rec()) return error_box(TR("Rilevati errori gravi negli archivi: procedura interrotta")); else _record = tr.record(); if (_tipo_lista == 'A') _controllo = 2; else _controllo = 1; apri_file_SC(); reset_files(); // Resetta l'albero di stampa precedente relativo ai movimenti del saldaconto select_cursor(_cur); // Seleziona il cursore relativo ai movimenti contabili e iva add_file (LF_MOV); add_file (LF_RMOV, LF_MOV); if (_is_iva) add_file (LF_RMOVIVA, LF_MOV); _errore_grave = FALSE; _errore_grave_totale = FALSE; _intestaSC = FALSE; _err.reset(); } setta_parametri(" ", "C"); set_real_picture("###.###.###.###"); set_magic_currency(TRUE); printer().footerlen(5); setta_intestazione(); _err.reset(); } else { if (_seconda_volta && _is_salda) { reset_files(); // Resetta l'albero di stampa precedente relativo ai movimenti contabili e iva select_cursor(_curSC); // Seleziona il cursore relativo ai movimenti del saldaconto add_file (LF_PARTITE); add_file (LF_SCADENZE, LF_PARTITE); add_file (LF_PAGSCA, LF_PARTITE); _errore_grave_SC = FALSE; _intestaSC = TRUE; _prima_volta = TRUE; _ho_stampato = FALSE; } else { TMask msk ("cg6700a"); TTransfer_file& tr = trasfer(); apri_file_SC(); msk.set(F_NUMERO, tr.nultras()); msk.set(F_DATALIMITE, tr.dataultras()); const char sdt[2] = { look_sdt(), '\0' }; msk.set(F_SDT, sdt); msk.set(F_SIGLA, tr.ult_file()); msk.set(F_CHIAVE, tr.key()); if (msk.run() != K_ENTER) return FALSE; _controllo = msk.get_int(F_LISTA); reset_files(); // Resetta l'albero di stampa precedente relativo ai movimenti del saldaconto select_cursor(_cur); // Seleziona il cursore relativo ai movimenti contabili e iva add_file (LF_MOV); add_file (LF_RMOV, LF_MOV); if (_is_iva) add_file (LF_RMOVIVA, LF_MOV); _errore_grave = FALSE; _errore_grave_totale = FALSE; _intestaSC = FALSE; } if (_sdt == '*') ::remove(_pathfile); setta_parametri(" ", "C"); set_real_picture("###.###.###.###"); set_magic_currency(TRUE); printer().footerlen(5); setta_intestazione(); _err.reset(); } return TRUE; } void TRic_ListaMov::setta_intestazione() { int soh = 1; TString sep(132); TString sep1(198); TString ragsoc(50); TLocalisamfile nditte(LF_NDITTE); nditte.zero(); nditte.put(NDT_CODDITTA, get_firm()); if (nditte.read() == NOERR) ragsoc = nditte.get(NDT_RAGSOC); reset_header(); if (_intestaSC) { sep1 << TR("Ditta ") << get_firm(); sep1 << " " << ragsoc; sep1.left_just(198); set_header (soh++, (const char*) sep1); sep1 = ""; sep1 << FR("Data @< Pag. @#"); sep1.right_just(193); sep1.overwrite (TR("LISTA DI CONTROLLO MOVIMENTI DI SALDACONTO")); set_header (soh++, (const char*)sep1); sep1.fill('-'); set_header (soh++, (const char *) sep1); } else { sep << TR("Ditta ") << get_firm(); sep << " " << ragsoc; sep.left_just(132); set_header (soh++, (const char*) sep); sep = ""; sep << FR("Data @< Pag. @#"); sep.right_just(127); sep.overwrite (TR("LISTA DI CONTROLLO MOVIMENTI IN TRASFERIMENTO")); set_header (soh++, (const char*)sep); sep.fill('-'); set_header (soh++, (const char *) sep); set_header (soh++, FR("Rig Cod.causale @30gDescriz.aggiuntiva @56gCod.conto @71gDescriz.conto @99gDare @116gAvere")); set_header (soh, (const char *) sep); } } void TRic_ListaMov::setta_parametri(const TString& sigla, const TString& flag) { TTransfer_file& tr = trasfer(); TConfig conf (CONFIG_DITTA); conf.set("FlStTra", flag); TString rec = tr.record(); rec.overwrite(sigla,240); const int size = 1024; tr.write_control_rec(rec, size); } int cg6700 (int argc, char* argv[]) { char p1 = '\0'; char p2 = '\0'; if (argc >= 4) p1 = *argv[2]; if (argc >= 5) p2 = *argv[3]; TRic_ListaMov* a = new TRic_ListaMov(p1,p2); a->run(argc, argv,TR("Lista controllo movimenti")); delete a; return TRUE; }