// -------------------------------------------------------------------------- // Scadenzario // fv 24/8/94 // -------------------------------------------------------------------------- #include #include #include "cgpagame.h" #include "cgsaldac.h" #include "cg2102.h" #include "cg2100.h" #include "cg21sld.h" #include #include TPagamento& TPrimanota_application::pagamento() const { CHECK(_pag, "Pagamento nullo"); return *_pag; } bool TPrimanota_application::pag_notify(TSheet_field& ps, int r, KEY k) { TMask* msk = &(ps.mask()); // if (!msk->is_running()) return TRUE; // Necessario per evitare il CHECK sul pagamento nullo if (!app().is_fattura() || app()._pag == NULL) return TRUE; // Necessario per evitare il CHECK sul pagamento nullo TPagamento& pag = app().pagamento(); TString_array& rws = app().pag_rows(); const int rdiff = msk->get_int(FS_RDIFFER); const bool in_valuta = pag.in_valuta(); const int impos = in_valuta ? 2 : 1; // ts contiene la vecchia riga, ns la nuova TToken_string ts(128), ns(128); TString16 banca; bool doit = TRUE, m_impl = FALSE, m_impv = FALSE, m_perc = FALSE, m_pag = FALSE; bool m_scad = FALSE, m_tipo = FALSE, m_ulc = FALSE, mod = FALSE, m_implit = FALSE; word ahiahi = P_OK; TString news(10), newl(15), newv(15), newp(15), newt(1), newu(1); bool recalc = msk->get_bool(FS_RECALC); bool mcomm = msk->get_bool(FS_MCOMM); switch (k) { case K_SPACE: { const bool can = !recalc && pag.n_rate() > 1 && ps.row(r).get_char(13) != 'X'; ps.sheet_mask().enable(DLG_DELREC, can); } break; case K_ENTER: ns = ps.row(r); ts = rws.row(r); news = ns.get(0); // Data scadenza newl = ns.get(1); // Imponibile (lire) newv = ns.get(2); // Imponibile (valuta) newp = ns.get(3); // Percentuale newt = ns.get(4); // Tipo pagamento newu = ns.get(5); // Ulteriore classificazione // qui viene il bello, si fa per dire if (news != ts.get(0)) // modificata data scadenza mod = m_scad = TRUE; if (real(newp) != real(ts.get(3))) // modificata percentuale mod = m_perc = TRUE; if (real(newl) != real(ts.get(1))) // modificato importo lire { // se si modifica la percentuale nessun importo viene cagato if ((recalc && !m_perc) || (!recalc)) mod = m_impl = TRUE; } if (in_valuta && real(newv) != real(ts.get(2))) { // se si modifica la percentuale nessun importo viene cagato if ((recalc && !m_perc) || (!recalc)) mod = m_impv = TRUE; } if (newt != ts.get(4)) // modificato tipo pagamento mod = m_tipo = m_ulc = TRUE; if (newu != ts.get(5)) // modificata ulteriore classificazione mod = m_ulc = TRUE; else if (m_tipo) { // forza reset di ulc se si e' modificato il tipo rata m_ulc = TRUE; newu = ""; } break; case K_DEL: doit = !recalc && pag.n_rate() > 1 && ps.row(r).get_char(13) != 'X'; if (doit) { pag.remove_rata(r); msk->set(FS_NRATE, pag.n_rate()); } break; case K_INS: // permette aggiunta e cancellazione solo se non c'e' ricalcolo automatico doit = !recalc; break; case K_CTRL+K_INS: // Post inserimento { const int prev = r - 1; const int gio_scad = pag.scad_rata(prev); TDate data_scad(pag.data_rata(prev)); pag.add_rata(ZERO, gio_scad, pag.tipo_rata(prev), pag.ulc_rata(prev)); pag.next_scad(data_scad, gio_scad, pag.mese_commerciale(), r); pag.set_datarata(r, data_scad); // pag.adjust_fixed_scad(); pag.set_sheet(ps); rws = ps.rows_array(); } break; default: break; } // settato da recalc_rate se occorre ridefinire lo sheet // aggiungendo o togliendo righe bool need_recalc = FALSE; if (k == K_ENTER) { if (mod && recalc) { // ricalcola sheet come sai fare tu ahiahi = pag.recalc_rate(r, m_perc, ((m_perc || m_impv) ? (m_perc ? (const char*)newp : (const char*)newv) : NULL), (m_impl ? (const char*)newl : NULL), (m_scad ? (const char*)news : NULL), (m_tipo ? (const char*)newt : NULL), (m_ulc ? (const char*)newu : NULL), rdiff, mcomm, need_recalc); // see if rdiff changed msk->set(FS_RDIFFER, pag.rate_differenziate() ? "1" : "2"); msk->set(FS_NRATE, pag.n_rate()); } if (!recalc) { ahiahi = P_OK; // put data as they are TToken_string& trw = pag.rata(r); TToken_string& trs = ps.row(r); if (m_tipo) trw.add(newt,2); if (m_ulc) trw.add(newu, 5); if (m_scad) { trw.add(news,3); if (r > 0) { TDate d(news); int scd = (int)(d - pag.data_rata(r-1)); if (pag.mese_commerciale() && (scd % 30) != 0) scd = 30 * ((scd/30)+1); trw.add(scd, 0); } trs.add(news, 0); } if (m_impl) { trw.add(newl,7); if (!in_valuta) { // si ricalcola la percentuale a modifica importo in lire solo // se non c'e' l'importo in valuta const real p = pag.recalc_percrata(r, FALSE); trs.add(p.string(), 3); } } if (m_impv) { trw.add(newv,4); const real p = pag.recalc_percrata(r, TRUE); trs.add(p.string(), 3); } if (mod) { rws.row(r) = trs; ps.force_update(r); } } if (ahiahi) // any error? Rimetti le righe com'erano prima { if (recalc) { TString err(80); pag.strerr(ahiahi,err); warning_box(err); ps.row(r) = rws.row(r); ps.force_update(r); } } else if (recalc && mod && need_recalc) { // ridefinisci lo sheet sulla base delle nuove rate pag.set_sheet(ps); rws = ps.rows_array(); } } return doit; } bool TPrimanota_application::pag_sheet_handler(TMask_field& f, KEY key) { bool ok = TRUE; if (key == K_TAB || key == K_ENTER) { TMask& m = f.mask(); TPagamento& pag = app().pagamento(); const TDate dt(m.get(F_DATADOC)); pag.set_datadoc(dt); word err = pag.validate(); if (m.edit_mode()) err &= ~(P_RSUM | P_TOTNCLIT | P_TOTNCVAL ); // Ignora totale importi e rate if (err != P_OK) { TString s(256); pag.strerr(err, s); return f.error_box(s); } const bool in_valuta = m.get(SK_VALUTA).not_empty(); real imp; if (key == K_ENTER && m.edit_mode()) { real tot = m.get(in_valuta ? SK_TOTDOCVAL : F_TOTALE); for (int r = pag.n_rate()-1; r >= 0; r--) imp += in_valuta ? pag.tval_rata(r) : pag.tlit_rata(r); imp.round(pag.round(in_valuta)); tot.round(pag.round(in_valuta)); if (imp != tot) { const char* const pic = in_valuta ? ".3" : "."; const TString is(imp.string(pic)); const TString ts(tot.string(pic)); ok = yesno_box("Il totale delle rate e' %s mentre\n" "il totale del documento e' %s.\n" "Si desidera registrare ugualmente?", (const char*)is, (const char*)ts); } } if (key == K_ENTER && in_valuta) { const real totlit = m.get(F_TOTALE); imp = ZERO; for (int r = pag.n_rate()-1; r >= 0; r--) imp += pag.tlit_rata(r); imp.round(pag.round(FALSE)); if (imp != totlit) { const TString is(imp.string(".")); const TString ts(totlit.string(".")); ok = yesno_box("Il totale in lire delle rate e' %s mentre\n" "il totale del documento e' %s.\n" "Si desidera registrare ugualmente?", (const char*)is, (const char*)ts); } } } return ok; } bool TPrimanota_application::tipopag_handler(TMask_field& f, KEY key) { if ((key == K_TAB || key == K_ENTER) && f.dirty()) { TMask& m = f.mask(); int t = m.get_int(105); if (t <= 0) { t = 1; f.set("1"); } const char u = m.get(106)[0]; const TPagamento& pag = app().pagamento(); bool ok; const char* s = pag.desc_tipo(t, u, &ok); if (!ok) m.reset(106); m.set(107, s); } return TRUE; } bool TPrimanota_application::codpag_handler(TMask_field& f, KEY key) { bool ok = TRUE; TMask& m = f.mask(); TPrimanota_application& a = app(); const bool set_scad = a.is_fattura() && m.page_enabled(2); // E' attiva pagina 3 if (key == K_ENTER) { if (set_scad && f.get().empty()) { f.error_box("Il codice di pagamento e' obbligatorio!"); /* "Se possibile esso verra' proposto, ma potra'\n" "essere modificato prima di registrare il movimento."); */ const char typ = a.clifo(); const long cod = m.get_long(typ == 'C' ? F_CLIENTE : F_FORNITORE); TLocalisamfile clifo(LF_CLIFO); clifo.put(CLI_TIPOCF, typ); clifo.put(CLI_CODCF, cod); if (clifo.read() == NOERR) { const TString& cp = clifo.get(CLI_CODPAG); if (cp.not_empty()) { f.set(cp); key = K_TAB; } } ok = FALSE; } } if (key == K_TAB && f.focusdirty() && m.insert_mode() && set_scad) a.set_scadenze(m); return ok; } bool TPrimanota_application::annorif_handler(TMask_field& f, KEY key) { bool ok = TRUE; if (f.to_check(key)) { const TMask& m = f.mask(); if (!m.get(F_NUMRIF).blank() && f.get().empty()) { const TString& anno = m.get(F_DATADOC).right(4); f.set(anno); ok = error_box("L'anno di riferimento partita e' obbligatorio!"); /* "Se possibile esso verra' proposto, ma potra'\n" "essere modificato prima di registrare il movimento."); */ } } return ok; } bool TPrimanota_application::numrif_handler(TMask_field& f, KEY key) { bool ok = TRUE; if (f.to_check(key, TRUE)) { TPrimanota_application& a = app(); TMask& m = f.mask(); bool required = m.insert_mode() && a.is_fattura(); required &= key == K_ENTER || f.focusdirty(); required &= !(m.get_bool(F_SOLAIVA) || m.field(F_OCCASEDIT).active()); if (required && f.get().blank()) { if (m.get(F_CODPAG).empty()) { TMask_field& clifo = m.field(a.iva() == iva_vendite ? F_CLIENTE : F_FORNITORE); clifo.set_dirty(); clifo.on_hit(); } TMask_field& anno = m.field(F_ANNORIF); if (m.get(F_ANNORIF).empty()) m.set(F_ANNORIF, m.get(F_DATADOC).right(4)); f.set(m.get(a._npart_is_prot ? F_PROTIVA : F_NUMDOC)); key = K_TAB; // Forza la successiva activate_numrif ok = f.error_box("Il numero di riferimento partita e' obbligatorio!"); /* "Se possibile esso verra' proposto, ma potra'\n" "essere modificato prima di registrare il movimento."); */ } if (key == K_TAB && a.is_fattura()) a.activate_numrif(m, TRUE); if (ok && key == K_ENTER && m.edit_mode()) { const TPartita* old = a.partite().first(); if (old && old->ok() && f.get().blank()) // Se esisteva una partita ma ora non piu' { const KEY k = yesnocancel_box("Attenzione la fattura della partita %d %s verra' eliminata.\n" "Premere SI per cancellarla, NO per ripristinarla, ANNULLA per modificarla", old->anno(), (const char*)old->numero()); switch (k) { case K_NO: f.set(old->numero()); if (m.get(F_ANNORIF).empty()) m.set(F_ANNORIF, old->anno()); break; case K_ESC: ok = FALSE; break; default: break; } } } } return ok; } bool TPrimanota_application::valuta_handler(TMask_field& f, KEY key) { if (key == K_TAB && f.to_check(key, TRUE)) { TMask& m = f.mask(); const TString val = f.get(); const bool full = val.not_empty(); if (full) { TMask_field& dc = m.field(SK_DATACAMBIO); if (dc.get().empty()) // Inizializza data cambio se assente dc.set(m.get(F_DATADOC)); if (f.focusdirty()) { dc.set_dirty(); dc.check(RUNNING_CHECK); // Forza ricerca cambio dc.on_hit(); // Forza messaggi (eventuale copia a pag. 3) } } else { m.set(SK_CAMBIO, "", TRUE); m.set(SK_TOTDOCVAL, "", TRUE); } m.enable(SK_CAMBIO, full); m.enable(SK_TOTDOCVAL, full); if (app().is_fattura()) m.set(FS_VALUTA, val); // Copia a pagina 3 } return TRUE; } bool TPrimanota_application::datacambio_handler(TMask_field& f, KEY key) { if (key == K_TAB && f.to_check(key, TRUE)) { if (app().is_fattura()) f.mask().set(FS_DATACAMBIO, f.get()); // Copia a pagina 3 } return TRUE; } bool TPrimanota_application::cambio_handler(TMask_field& f, KEY key) { if (key == K_TAB && f.to_check(key, TRUE)) { TMask& m = f.mask(); TPrimanota_application& a = app(); bool update = a.is_fattura(); // Devo ricopiarmi a pagina 3? if (f.focusdirty()) { // Forza il ricalcolo del totale in lire se necessario a.gioca_cambi(m.insert_mode() ? 0x1 : 0x0); } else update &= !m.is_running(); if (update) m.set(FS_CAMBIO, f.get()); // Copia a pagina 3 } return TRUE; } bool TPrimanota_application::reset_handler(TMask_field& f, KEY key) { if (key == K_SPACE) { TMask& m = f.mask(); app().reset_pagamento(); app().set_scadenze(m); } return TRUE; } bool TPrimanota_application::recalc_handler(TMask_field& f, KEY key) { TPrimanota_application& a = app(); if (key == K_SPACE && a.is_fattura()) { TMask& m = f.mask(); TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET); TPagamento& pag = a.pagamento(); const bool recalc_aut = f.get().not_empty(); if (!recalc_aut && pag.tipo_prima_rata() > 3) { // SE CAMBIANO I SIGNIFICATI DEL TIPO PRIMA RATA BISOGNA RIFARE TUTTO pag.set_tipo_prima_rata(pag.tipo_prima_rata() - 3); m.set(FS_TIPOPR, pag.desc_tpr()); pag.set_tpr4(TRUE); } else if (recalc_aut && pag.was_tpr4()) { // SE CAMBIANO I SIGNIFICATI DEL TIPO PRIMA RATA BISOGNA RIFARE TUTTO pag.set_tpr4(FALSE); bool yak = pag.tlit_rata(0) != pag.importo_da_non_dividere(FALSE); if (pag.in_valuta()) yak |= (pag.tval_rata(0) != pag.importo_da_non_dividere(TRUE)); if (yak) { if (yesno_box("L'importo della prima rata e' stato modificato. " "Con il ricalcolo automatico esso non sara' piu'" " modificabile. Si desidera " "riportare le rate alle condizioni iniziali?")) { pag.set_tipo_prima_rata(pag.tipo_prima_rata() + 3); m.set(FS_TIPOPR, pag.desc_tpr()); a.reset_pagamento(); a.set_scadenze(m); } else warning_box("Il tipo prima rata e' stato modificato in \"%s\" per " "poter mantenere la rateazione scelta e la possibilita' di " "ricalcolo automatico", pag.desc_tpr()); } else { pag.set_tipo_prima_rata(pag.tipo_prima_rata() + 3); m.set(FS_TIPOPR, pag.desc_tpr()); } } const bool on = pag.tipo_prima_rata() < 4 || !recalc_aut; ps.enable_cell(0, 1, on); ps.enable_cell(0, 2, on); ps.enable_cell(0, 3, on); ps.enable_column(3, recalc_aut); ps.sheet_mask().enable(DLG_DELREC, !recalc_aut); } return TRUE; } bool TPrimanota_application::nrate_handler(TMask_field& f, KEY key) { if (key == K_TAB && f.focusdirty()) { TPagamento& pag = app().pagamento(); pag.set_numero_rate(atoi(f.get())); if (pag.dirty()) { TMask& m = f.mask(); TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET); pag.set_sheet(ps); app().pag_rows() = ps.rows_array(); } f.set(format("%d", pag.n_rate())); } return TRUE; } bool TPrimanota_application::codcab_handler(TMask_field& f, KEY key) { if (key == K_TAB && f.focusdirty()) { const TMask& m = f.mask(); const short id = f.dlg() == FS_NSCAB ? FS_NSABI : FS_VSABI; const int pos = id == FS_NSABI ? 7 : 9; // Posizione codici ABI sullo sheet const TString16 abi = m.get(id); const TString16 cab = m.get(id+1); TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET); for (int i = ps.items()-1; i >= 0; i--) // Setta la banca in tutte le righe { TToken_string& row = ps.row(i); row.add(abi, pos); row.add(cab, pos+1); } ps.force_update(); } return TRUE; } bool TPrimanota_application::ratalit_handler(TMask_field& f, KEY key) { TMask& m = app().curr_mask(); if (key == K_F8 || (key == K_TAB && f.get().empty() && m.is_running())) { const TPagamento& pag = app().pagamento(); if (pag.in_valuta()) { const TValuta v(m, FS_VALUTA, FS_DATACAMBIO, FS_CAMBIO); const real other(f.mask().get(103)); const char* s = v.val2lit(other).string(); f.set(s); } } return TRUE; } bool TPrimanota_application::rataval_handler(TMask_field& f, KEY key) { if (key == K_F8 || (key == K_TAB && f.get().empty())) { TPagamento& pag = app().pagamento(); if (pag.in_valuta()) { const TValuta v(app().curr_mask(), FS_VALUTA, FS_DATACAMBIO, FS_CAMBIO); const real other(f.mask().get(102)); TString16 s(v.lit2val(other).string()); f.set(s); } } return TRUE; } void TPrimanota_application::reset_pagamento() { TPagamento& pag = pagamento(); pag.read(); pag.set_rate_auto(); } void TPrimanota_application::recalc_scadenze(const TDate& d) { TPagamento& pag = pagamento(); pag.set_inizio(d); // ridefinisci lo sheet sulla base delle nuove rate TSheet_field& ps = pags(); TString_array& rws = pag_rows(); pag.set_sheet(ps); rws = ps.rows_array(); } void TPrimanota_application::set_pagamento(const char* c, const char* d) { if (_pag != NULL) { delete _pag; _pag = NULL; } if (c != NULL || d != NULL) { if (!TDate::isdate(d)) d = ""; _pag = new TPagamento(c, d); } } void TPrimanota_application::set_totale_pagamento(bool update) { const TMask& m = curr_mask(); TPagamento& pag = pagamento(); const real imposta = m.get_real(F_IMPOSTE); const real imponibile = m.get_real(F_TOTALE) - imposta; const real spese = ZERO; const TValuta cambio(m, SK_VALUTA, SK_DATACAMBIO, SK_CAMBIO); if (cambio.in_valuta()) { const real imposval = cambio.lit2val(imposta); const real imponval = m.get_real(SK_TOTDOCVAL) - imposval; pag.set_total_valuta(imponval, imposval, spese, cambio.cambio(), imponibile, imposta, spese); } else { pag.set_total(imponibile, imposta, spese); } if (update) { TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET); pagamento().set_sheet(ps); // Aggiorna lo sheet pag_rows() = ps.rows_array(); // copia sheet } } void TPrimanota_application::set_scadenze(TMask& m) { const TString cp(m.get(F_CODPAG)); const TString dt(m.get(F_DATADOC)); set_pagamento(cp, dt); set_totale_pagamento(FALSE); TPagamento& pag = pagamento(); if (m.field(FS_RECALC).enabled()) { m.set(FS_RDIFFER, pag.rate_differenziate() ? "1" : "2"); m.set(FS_NAMEPAG, pag.name()); m.set(FS_TIPOPR, pag.desc_tpr()); m.set(FS_MCOMM, pag.mese_commerciale() ? "X" : ""); m.set(FS_RECALC, m.insert_mode() ? "X" : "", TRUE); m.set(FS_NRATE, pag.n_rate()); } pag.set_rate_auto(); TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET); pag.set_sheet(ps); // prepara lo sheet _pag_rows = ps.rows_array(); // copia sheet } bool TPrimanota_application::read_scadenze(TMask& m) { const int anno = m.get_int(F_ANNORIF); const TString16 numpart(m.get(F_NUMRIF)); if (anno <= 0 || numpart.blank()) // Partita vuota return FALSE; TBill clifo; cerca_conto_cf(clifo); const TPartita& part = partite().partita(clifo, anno, numpart); const TRectype& testa = _rel->curr(); const long nreg = testa.get_long(MOV_NUMREG); const TDate datadoc = testa.get_date(MOV_DATADOC); const int npart = part.prima_fattura(nreg); if (npart <= 0) // Non esiste una riga per questo movimento { partite().destroy(); return FALSE; // Non dovrebbe succedere mai, in quanto gia' beccato sopra! } // Determino il codice pagamento dalla riga di fattura TString codpag; const TRiga_partite& partita = part.riga(npart); if (partita.rate() > 0) { const TRiga_scadenze& primarata = partita.rata(1); codpag = primarata.get(SCAD_CODPAG); } set_pagamento(codpag, datadoc.string()); TPagamento& pag = pagamento(); const bool in_valuta = m.get(SK_VALUTA).not_empty(); const real totale = m.get(in_valuta ? SK_TOTDOCVAL : F_TOTALE); if (totale != partita.importo(in_valuta).valore() || m.get_real(F_IMPOSTE) != partita.get_real(PART_IMPOSTA)) { warning_box("Gli importi delle scadenze non corrispondono al totale documento"); } set_totale_pagamento(FALSE); TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET); const int protette = partita.ultima_rata_con_abbuoni_diffcam(); pag.zap_rate(); // Azzera pagamento for (int i = 1; i <= partita.rate(); i++) // E' necessario andare in avanti!!! { const TRiga_scadenze& scadenza = partita.rata(i); real importo = scadenza.get(SCAD_IMPORTO); const TDate scad = scadenza.get(SCAD_DATASCAD); const int tipop = scadenza.get_int(SCAD_TIPOPAG); const bool prot = i <= protette; // Non cancellabile const TString16 ulc = scadenza.get(SCAD_ULTCLASS); if (in_valuta) { const real impval(scadenza.get(SCAD_IMPORTOVAL)); pag.set_rata(i-1, impval, importo, scad, tipop, ulc, prot); } else pag.set_rata(i-1, ZERO, importo, scad, tipop, ulc, prot); TToken_string& str = ps.row(i-1); str.add(scadenza.get(SCAD_CODABIPR), 7); str.add(scadenza.get(SCAD_CODCABPR), 8); str.add(scadenza.get(SCAD_CODABI), 9); str.add(scadenza.get(SCAD_CODCAB), 10); if (i == 1) { m.set(FS_NSABI, str.get(7)); m.set(FS_NSCAB, str.get(8)); m.set(FS_VSABI, str.get(9)); m.set(FS_VSCAB, str.get(10)); m.set(FS_AGENTE, scadenza.get(SCAD_CODAG)); } str.add(scadenza.get(SCAD_DESCR), 11); str.add(scadenza.get(SCAD_BLOCCATA), 12); str.add(prot ? "X" : " ", 13); } m.set(FS_RDIFFER, pag.rate_differenziate() ? "1" : "2"); m.set(FS_NAMEPAG, pag.name()); m.set(FS_TIPOPR, pag.desc_tpr()); m.set(FS_MCOMM, pag.mese_commerciale() ? "X" : "", TRUE); m.set(FS_RECALC, m.insert_mode() ? "X" : "", TRUE); m.set(FS_NRATE, pag.n_rate()); pag.set_sheet(ps); _pag_rows = ps.rows_array(); return TRUE; } int TPrimanota_application::cerca_conto_cf(TBill& bill) const { const char tipocf = clifo(); const long codcf = curr_mask().get_long(tipocf == 'C' ? F_CLIENTE : F_FORNITORE); TString_array& a = cgs().rows_array(); for (int r = 0; r < a.items(); r++) { TToken_string& row = a.row(r); bill.get(row, 2, 0x1); if (bill.tipo() == tipocf && bill.codclifo() == codcf) return r; } bill.set(0, 0, codcf, tipocf); return -1; } void TPrimanota_application::write_scadenze(const TMask& m) { const long nreg = m.get_long(F_NUMREG); const int anno = m.get_int(F_ANNORIF); const TString numpart(m.get(F_NUMRIF)); TPartita* oldgame = partite().first(); TPartita* newgame = NULL; int nuova_riga = 0; if (anno > 0 && !numpart.blank() && m.page_enabled(2)) { const int tmov = causale().tipomov(); const TString desc(m.get(F_DESCR)); const TString codpag(m.get(F_CODPAG)); const TString codcaus(causale().codice()); const TValuta cambio(m, SK_VALUTA, SK_DATACAMBIO, SK_CAMBIO); const TString agente(m.get(FS_AGENTE)); const char sezione = get_cgs_imp(0).sezione(); // Dare/Avere TBill clifo; const int riga_clifo = cerca_conto_cf(clifo); CHECK(riga_clifo >= 0, "Impossibile generare la fattura senza gruppo/conto cliente"); newgame = new TPartita(clifo, anno, numpart); const int row = newgame->prima_fattura(nreg); // Riga fattura di questo movimento TRiga_partite& partita = row <= 0 ? newgame->new_row() : newgame->riga(row); nuova_riga = partita.get_int(PART_NRIGA); TPagamento& pag = pagamento(); // put data on partita partita.put(PART_TIPOMOV, tmov); partita.put(PART_NREG, nreg); partita.put(PART_NUMRIG, riga_clifo+1); partita.put(PART_DATAREG, m.get(F_DATAREG)); partita.put(PART_DATADOC, m.get(F_DATADOC)); partita.put(PART_NUMDOC, m.get(F_NUMDOC)); partita.put(PART_DESCR, desc); partita.put(PART_CODCAUS, codcaus); partita.put(PART_REG, causale().reg().name()); partita.put(PART_PROTIVA, m.get_long(F_PROTIVA)); partita.put(PART_SEZ, sezione); const TImporto totdoc = get_cgs_imp(riga_clifo); partita.put(PART_IMPTOTDOC, totdoc.valore()); cambio.put(partita); const bool in_valuta = cambio.in_valuta(); if (in_valuta) partita.put(PART_IMPTOTVAL, m.get(SK_TOTDOCVAL)); real imponibile, imponibile_val; for (int i = pag.n_rate()-1; i >= 0; i--) { if (in_valuta) imponibile_val += pag.tval_rata(i); imponibile += pag.tlit_rata(i); } partita.put(PART_IMPORTO, imponibile); partita.put(PART_IMPORTOVAL, imponibile_val); partita.put(PART_IMPOSTA, m.get(F_IMPOSTE)); partita.put(PART_SPESE, pag.spese()); TSheet_field& ps = (TSheet_field&)m.field(FS_RATESHEET); partita.elimina_rata(-1); // Elimina tutte le rate eventuali for (i = 0; i < ps.items(); i++) { TToken_string& row = ps.row(i); TRiga_scadenze& scadenza = partita.new_row(); scadenza.put(SCAD_CODPAG, codpag); // Codice pagamento scadenza.put(SCAD_CODAG, agente); // Codice agente scadenza.put(SCAD_DATASCAD, row.get(0)); // 0 = Data scadenza scadenza.put(SCAD_IMPORTO, row.get()); // 1 = Importo scadenza.put(SCAD_IMPORTOVAL, row.get()); // 2 = Importo in valuta row.get(); // 3 = Percentuale scadenza.put(SCAD_TIPOPAG, row.get()); // 4 = Tipo pagamento scadenza.put(SCAD_ULTCLASS, row.get()); // 5 = Ulteriore classificazione row.get(); // 6 = Descrizione pagamento scadenza.put(SCAD_CODABIPR, row.get()); // 7 = Ns ABI scadenza.put(SCAD_CODCABPR, row.get()); // 8 = Ns CAB scadenza.put(SCAD_CODABI, row.get()); // 9 = Vs ABI scadenza.put(SCAD_CODCAB, row.get()); //10 = Vs CAB scadenza.put(SCAD_DESCR, row.get()); //11 = Note scadenza.put(SCAD_BLOCCATA, row.get()); //12 = Non pagabile } } if (oldgame != NULL) { const int rigafatt = oldgame->prima_fattura(nreg); if (rigafatt > 0) { if (newgame == NULL || *oldgame != *newgame) { bool sposta = newgame != NULL; if (sposta) { sposta = (oldgame->conto().sottoconto() == newgame->conto().sottoconto()); if (sposta) sposta = yesno_box("Si desidera spostare la fattura e gli eventuali\n" "pagamenti relativi nella partita %d %s?", anno, (const char*)numpart); } if (sposta) { oldgame->sposta_riga(rigafatt, *newgame, nuova_riga); } else { oldgame->scollega_pagamenti(rigafatt); oldgame->rimuovi_riga(rigafatt); } oldgame->rewrite(); } else { oldgame->sposta_riga(rigafatt, *newgame, nuova_riga); } } } if (newgame != NULL) // Se non ho cancellato il numero partita ... { newgame->write(); // Salva nuova partita delete newgame; } } /////////////////////////////////////////////////////////// // Gestione pagamenti /////////////////////////////////////////////////////////// bool TPrimanota_application::showpartite_handler(TMask_field& f, KEY k) { bool ok = TRUE; TMask& m = f.mask(); TPrimanota_application& a = app(); TMask& cm = a.curr_mask(); const char tipo = m.get(CG_ROWTYPE)[0]; const bool is_nota = tipo == 'T' && a.causale().tipomov() == 2 && cm.field(F_NUMRIF).active(); const bool tras = a._as400 && a.causale().tipomov() > 1 && m.get(CG_TIPO).not_empty(); if (tipo == 'K' || is_nota || tras) { TSheet_field& s = *m.get_sheet(); const int riga = s.selected(); if (k == K_SPACE) { const bool ok = a.edit_partite(m, riga); if (ok && riga < s.items()) k = K_ENTER; } if (k == K_ENTER) { const long curreg = cm.insert_mode() ? NUMREG_PROVVISORIO : cm.get_long(F_NUMREG); const TImporto importo(a.get_cgs_imp(riga)); const TImporto speso(a.partite().importo_speso(curreg, riga+1)); if (tipo == 'K' && !speso.is_zero()) { a.disable_cgs_cells(riga, 'K'); a.cgs().force_update(riga); } if (importo != speso) { TString msg(128); msg << "L'importo sul saldaconto della riga " << (riga+1) << " e' " << speso.valore().string("."); if (!speso.is_zero()) msg << (speso.sezione() == 'A' ? " Avere" : " Dare"); return f.error_box(msg); } f.set_focus(); } } return ok; } // deleting significato // -1 sto cancellando tutto // 0 non sto cancellando nulla // 1 sto cancellando la prima riga contabile // n sto cancellando la ennesima riga contabile bool TPrimanota_application::notify_edit_pagamento(TPartita& p, TRectype& new_pag, const TValuta& valuta, int deleting) { const int nriga = new_pag.get_int(PAGSCA_NRIGA); // Riga fattura const int nrata = new_pag.get_int(PAGSCA_NRATA); // Numero rata const int nrigp = new_pag.get_int(PAGSCA_NRIGP); // Riga pagamento const TRectype& old_pag = p.pagamento(nriga, nrata, nrigp); const TRiga_partite& somma = p.riga(nrigp); const int riga_contabile = somma.get_int(PART_NUMRIG); // Riga movimento TSheet_field& sheet = cgs(); if (_as400) deleting = -1; // Ignora contropartite if (deleting >= 0) { const char sez = somma.sezione(); // Sezione importo e ritenute const char controsez = sez == 'A' ? 'D' : 'A'; // Sezione contropartita // Aggiornamento contopartita const TImporto old_importo(controsez, old_pag.get_real(PAGSCA_IMPORTO)); TBill old_conto; old_conto.get(old_pag, TRUE); const TImporto new_importo(controsez, new_pag.get_real(PAGSCA_IMPORTO)); TBill new_conto; new_conto.get(new_pag, TRUE); if (old_importo != new_importo || old_conto != new_conto) { const int old_riga = bill2pos(old_conto, 'I'); if (old_riga >= 0) { const bool empty = sub_cgs_imp(old_riga, old_importo); if (empty && (new_importo.is_zero() || new_conto != old_conto)) sheet.destroy(old_riga); } // Importo della contropartita if (!new_importo.is_zero() && new_conto.ok()) { const int new_riga = bill2pos(new_conto, 'I'); if (new_riga < 0) { const int tp = somma.get_int(PART_TIPOPAG); const int da = p.tipopag2causale(tp); const TString descagg(causale().desc_agg(da)); set_cgs_row(new_riga, new_importo, new_conto, descagg, 'I'); } else add_cgs_imp(new_riga, new_importo); } } // Aggiornamento ritenute const real old_ritenute(old_pag.get(PAGSCA_RITENUTE)); const real new_ritenute(new_pag.get(PAGSCA_RITENUTE)); if (old_ritenute != new_ritenute) { const TImporto grow_ritenute(controsez, new_ritenute-old_ritenute); const riga = type2pos('F'); if (riga < 0) { TBill conto_rit; causale().bill(RIGA_RITENUTE, conto_rit); const TString desc(causale().desc_agg(RIGA_RITENUTE)); set_cgs_row(riga, grow_ritenute, conto_rit, desc, 'F'); } else { const bool empty = add_cgs_imp(riga, grow_ritenute); if (empty) sheet.destroy(riga); } } } // if (deleting >= 0) char old_ap, new_ap; TImporto old_abbuono, new_abbuono, old_diffcam, new_diffcam; const bool empty = p.modifica_pagamento(new_pag, valuta, old_ap, old_abbuono, old_diffcam, new_ap, new_abbuono, new_diffcam, TRUE); if (deleting >= 0) { // Se c'e' differenza negli abbuoni if (old_abbuono != new_abbuono || old_ap != new_ap) { if (old_ap != ' ') // Se c'era un abbuono ... { const int riga_abb = type2pos(old_ap); CHECK(riga_abb >= 0, "Chiss'e' fregato gli abbuoni?"); const bool empty = add_cgs_imp(riga_abb, old_abbuono); if (empty && new_ap != old_ap) sheet.destroy(riga_abb); if (deleting != riga_contabile) { // Sottrae l'abbuono con la sezione invertita dalla riga contabile sub_cgs_imp(riga_contabile-1, old_abbuono); } } if (new_ap != ' ') // Se ci sono abbuoni { const riga_abb = type2pos(new_ap); new_abbuono.swap_section(); new_abbuono.normalize(); if (riga_abb < 0) { const int rc = new_ap == 'A' ? RIGA_ABBUONI_ATTIVI : RIGA_ABBUONI_PASSIVI; TBill conto_abb; causale().bill(rc, conto_abb); const TString desc(causale().desc_agg(rc)); app().set_cgs_row(riga_abb, new_abbuono, conto_abb, desc, new_ap); } else add_cgs_imp(riga_abb, new_abbuono); if (deleting != riga_contabile) { // Aggiunge l'abbuono con la sezione invertita sub_cgs_imp(riga_contabile-1, new_abbuono); } } } // Se c'e' variazione nella differenza cambi if (old_diffcam != new_diffcam) { const int riga_diffcam = type2pos('C'); TImporto grow_diffcam(old_diffcam); grow_diffcam -= new_diffcam; grow_diffcam.normalize(); if (riga_diffcam < 0) { TBill conto_diffcam; causale().bill(RIGA_DIFFCAM, conto_diffcam); const TString desc(causale().desc_agg(RIGA_DIFFCAM)); set_cgs_row(riga_diffcam, grow_diffcam, conto_diffcam, desc, 'C'); } else { const bool empty = add_cgs_imp(riga_diffcam, grow_diffcam); if (empty) sheet.destroy(riga_diffcam); } if (deleting != riga_contabile) { // Aggiunge la differenza con la sezione invertita sub_cgs_imp(riga_contabile-1, grow_diffcam); } } } // if (deleting >= 0) return empty; } // Scorre tutte le righe della partita ed azzera i pagamenti relativi a alla riga contabile // cancellata e decrementa i numeri riga superiori a numrig bool TPrimanota_application::notify_cgline_deletion(TPartita& partita, long nreg, int numrig) { bool found = FALSE; // Al primo "giro" elimino i pagamenti dalla rate for (int p = partita.last(); p > 0; p = partita.pred(p)) { TRiga_partite& part = partita.riga(p); if (part.is_fattura()) { for (int r = part.rate(); r > 0; r--) { const TRiga_scadenze& scad = part.rata(r); for (int s = scad.last(); s > 0; s = scad.pred(s)) { const TRiga_partite& sum = partita.riga(s); if (sum.get_long(PART_NREG) == nreg && (numrig <= 0 || sum.get_int(PART_NUMRIG) == numrig)) { TRectype nul_pag(scad.row(s)); nul_pag.zero(PAGSCA_IMPORTO); nul_pag.zero(PAGSCA_IMPORTOVAL); nul_pag.zero(PAGSCA_RITENUTE); nul_pag.put(PAGSCA_ACCSAL, 'A'); const TValuta val; // Non cambiare valuta notify_edit_pagamento(partita, nul_pag, val, numrig); found = TRUE; } } } } } // Alla fine del "giro" elimino i pagamenti non assegnati TRecord_array& unas = partita.unassigned(); for (int u = unas.last_row(); u > 0; u = unas.pred_row(u)) { const TRiga_partite& sum = partita.riga(u); if (sum.get_long(PART_NREG) == nreg && (numrig <= 0 || sum.get_int(PART_NUMRIG) == numrig)) { TRectype nul_pag(unas.row(u, FALSE)); nul_pag.zero(PAGSCA_IMPORTO); nul_pag.zero(PAGSCA_IMPORTOVAL); nul_pag.zero(PAGSCA_RITENUTE); nul_pag.put(PAGSCA_ACCSAL, 'A'); // Inutile, ma l'ho copiato da sopra const TValuta val; // Non cambiare valuta notify_edit_pagamento(partita, nul_pag, val, numrig); found = TRUE; } } // Al secondo "giro" decremento NRIGP dalle righe di pagamento if (numrig > 0) { for (p = partita.last(); p > 0; p = partita.pred(p)) { TRiga_partite& part = partita.riga(p); if (!part.is_fattura()) { if (part.get_long(PART_NREG) == nreg) { const int nr = part.get_int(PART_NUMRIG); if (nr > numrig) part.put(PART_NUMRIG, nr-1); } } } } return found; } bool TPrimanota_application::notify_cgline_deletion(int numrig) { bool found = FALSE; const long nreg = curr_mask().get_long(F_NUMREG); // if (curr_mask().edit_mode()) // partite().add_numreg(nreg); // Gia' fatto dalla read for (TPartita* game = partite().first(); game; game = partite().next()) found |= notify_cgline_deletion(*game, nreg, numrig); return found; }