Esempio n. 1
0
 /// <summary>
 /// Crea una rata di pagamento condomino valida.
 /// </summary>
 public VersamentiRate(VersamentoSoggetto versamento, RataSoggetto rata, decimal importo)
 {
     Versamento = versamento;
     Rata = rata;
     Importo = importo;
     if (Rata != null)
         Rata.Versamenti.Add(this);
     if (Versamento != null)
         Versamento.Rate.Add(this);
 }
Esempio n. 2
0
        public string CreazioneRateFuoriPreventivo(Esercizio esercizio, Dictionary<DateTime, Dictionary<int, RataSoggettoDTO>> listaRate, bool daSubentro, string descrizione, LogTransazione logTransazione)
        {
            var message = string.Empty;

            var pianoCorrente = _daoFactory.GetPianoRatealeDao().GetByEsercizio(esercizio);
            if (pianoCorrente == null)
            {
                pianoCorrente = new PianoRateale(esercizio, TipoAccorpamentoRateEnum.Nessuno, logTransazione);
                _daoFactory.GetPianoRatealeDao().SaveOrUpdate(pianoCorrente);
            }

            foreach (var kvp in listaRate)
            {
                LogTransazione logTransazioneDettaglio = null;
                if (pianoCorrente.ID > 0)
                    logTransazioneDettaglio = logTransazione;

                var dettaglio = new PianoRatealeDettaglio(pianoCorrente, kvp.Key, null, 0, daSubentro, logTransazioneDettaglio) { Importo = kvp.Value.Sum(rata => rata.Value.Importo) };
                if (pianoCorrente.ID == 0)
                    dettaglio.IsAcconto = true;

                if (!string.IsNullOrEmpty(descrizione) && descrizione.Length > 50)
                    descrizione = descrizione.Substring(0, 50);
                dettaglio.Descrizione = descrizione;
                _daoFactory.GetPianoRatealeDettaglioDao().SaveOrUpdate(dettaglio);
                var progressivo = 0;
                foreach (var kvpDett in kvp.Value)
                {
                    progressivo++;
                    var rata = new RataSoggetto(dettaglio, _daoFactory.GetSoggettoCondominioDao().GetById(kvpDett.Value.IdSoggettoCondominio, false), kvp.Key, kvpDett.Value.Importo.GetValueOrDefault(), logTransazione) { Progressivo = progressivo };
                    _daoFactory.GetRataSoggettoDao().SaveOrUpdate(rata);
                }
            }

            return message;
        }
Esempio n. 3
0
        private RataSoggettoDTO setDto(RataSoggetto item)
        {
            var dto = new RataSoggettoDTO
            {
                Version = item.Version,
                DataScadenza = item.DataScadenza,
                DescrizioneUnitaImmobiliare = item.Soggetto.UnitaImmobiliare.Descrizione,
                ID = item.ID,
                IdEsercizio = item.Esercizio.ID,
                DescrizioneEsercizio = item.Esercizio.DisplayName,
                IdSoggettoCondominio = item.Soggetto.ID,
                DescrizioneSoggettoCondominio = item.Soggetto.DisplayName,
                IdUnitaImmobiliare = item.Soggetto.UnitaImmobiliare.ID,
                OrdineUnitaImmobiliare = item.Soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault(),
                IdPersona = item.Soggetto.Persona.ID,
                TipoSoggettoCondominio = item.Soggetto.Tipo,
                Importo = item.Importo,
                Progressivo = item.Progressivo,
                StatoRata = item.Stato,
                Alert = false
            };

            if (item.PianoRatealeDettaglio != null)
            {
                dto.DisplayName = item.PianoRatealeDettaglio.Descrizione;
                dto.IdPianoDettaglioRatealeRiferimento = item.PianoRatealeDettaglio.ID;
            }

            if (item.SoggettoEmissione != null)
            {
                dto.IdSoggettoEmissione = item.SoggettoEmissione.ID;
                dto.DescrizioneSoggettoEmissione = item.SoggettoEmissione.DisplayName;
            }

            if (item.Emissione != null)
            {
                dto.IdTestataEmissione = item.Emissione.TestataEmissioneRate.ID;
                dto.IdDettaglioEmissione = item.Emissione.ID;
                dto.DataEmissione = item.Emissione.TestataEmissioneRate.Data;

                if (item.Emissione.Stato == StatoMavEnum.Radiato && item.Stato != StatoRataEnum.Pagata && item.Stato != StatoRataEnum.ParzialmentePagata)
                    dto.Alert = true;
            }

            return dto;
        }
        public TestataMovimentoContabile SetMovimentiSingolaRata(RataSoggetto rata, decimal importo, SoggettoCondominio soggetto, Esercizio esercizio, TestataMovimentoContabile testata, DateTime dataRegistrazione)
        {
            return null;
            var numeroRiga = 0;
            var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("ER");

            var message = IsAllowDataRegistrazione(new List<int> {esercizio.CondominioRiferimento.ID}, esercizio, dataRegistrazione);
            if (message.Count > 0)
            {
                _log.ErrorFormat("Tentativo di registrazione con data esterno all'intervallo consentito - {0} - rata:{1} - importo:{2} - soggetto:{3} - esercizio:{4}", Utility.GetMethodDescription(), rata.ID, importo, soggetto.ID, esercizio.ID);
                throw new InvalidDataException(string.Format("Tentativo di registrazione con data esterno all'intervallo consentito - data:{0}", dataRegistrazione.ToShortDateString()));
            }

            // ------------------------------------------------
            // Testata
            // ------------------------------------------------
            if (testata == null)
            {
                testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null);
                _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
            }
            else
                numeroRiga = testata.Movimenti.Max(mov => mov.NumeroRiga.GetValueOrDefault());

            // ------------------------------------------------
            // Rata
            // ------------------------------------------------
            numeroRiga++;
            var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRateCondomini()), importo, "A") {CondominoRiferimento = soggetto};
            string descrizioneRata;
            if (rata != null)
                descrizioneRata = "Rata n." + rata.PianoRatealeDettaglio.Progressivo;
            else
                descrizioneRata = "Rata";
            movimentoPatrimoniale.Descrizione = descrizioneRata + " - " + movimentoPatrimoniale.CondominoRiferimento.DisplayName;
            _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);

            // ------------------------------------------------
            // Crediti V/S Condomini
            // ------------------------------------------------
            numeroRiga++;
            var movimentoPatrimonialeCrediti = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini()), importo, "D")
            {
                CondominoRiferimento = soggetto,
                Descrizione = movimentoPatrimoniale.Descrizione
            };
            _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimonialeCrediti);

            return testata;
        }
Esempio n. 5
0
 private void addRataDaEmettere(SoggettoCondominio soggetto, Esercizio esercizio, RataSoggetto rata, Dictionary<int, RataSoggettoDTO> listaRate, decimal importo)
 {
     RataSoggettoDTO rataDto;
     if (listaRate.ContainsKey(soggetto.ID))
         rataDto = listaRate[soggetto.ID];
     else
     {
         rataDto = new RataSoggettoDTO
         {
             IdSoggettoCondominio = soggetto.ID,
             DataScadenza = rata.DataScadenza,
             IdEsercizio = esercizio.ID,
             DescrizioneEsercizio = esercizio.DisplayName,
             IdUnitaImmobiliare = soggetto.UnitaImmobiliare.ID,
             IdPersona = soggetto.Persona.ID,
             Subalterno = soggetto.UnitaImmobiliare.Subalterno,
             Importo = 0
         };
         listaRate.Add(soggetto.ID, rataDto);
     }
     rataDto.Importo += importo;
 }
Esempio n. 6
0
        public void setStatoRataDisplay(RataPersonaDTO dto, RataSoggetto rata)
        {
            switch (rata.Stato)
            {
                case StatoRataEnum.Pagata:
                    dto.StatoRataDisplay = StatoRataEnumDisplay.Pagata;
                    break;

                case StatoRataEnum.ParzialmentePagata:
                    dto.StatoRataDisplay = StatoRataEnumDisplay.ParzialmentePagata;
                    break;

                case StatoRataEnum.Inserita:
                case StatoRataEnum.Spedita:
                case StatoRataEnum.ParzialmenteSpedita:
                    if (dto.DataScadenza < DateTime.Today)
                        dto.StatoRataDisplay = StatoRataEnumDisplay.Scaduta;
                    else if (dto.DataScadenza < DateTime.Today.AddDays(7))
                        dto.StatoRataDisplay = StatoRataEnumDisplay.InScadenza;
                    else
                        dto.StatoRataDisplay = StatoRataEnumDisplay.Inserita;
                    break;
            }
        }
Esempio n. 7
0
        private DettaglioEmissioneRateDTO ToEmissioneDTO(RataSoggetto rata)
        {
            var dettaglio = new DettaglioEmissioneRateDTO
            {
                DataScadenza = rata.DataScadenza,
                DescrizioneSoggettoCondominio = rata.Soggetto.DisplayName,
                VersamentoMav = rata.Soggetto.VersamentoMav,
                IdEsercizio = rata.Esercizio.ID,
                IdSoggettoCondominio = rata.Soggetto.ID,
                Importo = rata.Importo,
                Progressivo = rata.Progressivo,
                IdRataSingola = rata.ID,
                StatoRata = rata.Stato,
                IdUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.ID,
                DescrizioneUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.Descrizione,
                TipoUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione,
                Rate = new List<DettaglioRataEmissioneRateDTO>(),
            };

            return dettaglio;
        }
Esempio n. 8
0
        private AuthorizationMessages deleteRata(RataSoggetto rata, bool force, bool cancelIfNotDeleted = false)
        {
            try
            {
                var fatalMessage = string.Empty;
                var warnMessage = string.Empty;

                if (!rata.DaRichiamare && rata.Stato != StatoRataEnum.Richiamata)
                {
                    var allowDeleteMessage = IsAllowDeleteRata(rata.ID);
                    if (string.IsNullOrEmpty(allowDeleteMessage.FatalMessage))
                    {
                        // =================================================================
                        // Se la rata è già stata emessa NON viene eliminata ma annullata
                        // =================================================================
                        if (rata.Emissione != null)
                        {
                            var messaggeAnnullamento = annullamentoRata(rata);
                            if (!string.IsNullOrEmpty(messaggeAnnullamento.FatalMessage))
                                fatalMessage += messaggeAnnullamento.FatalMessage + Environment.NewLine;
                            if (!string.IsNullOrEmpty(messaggeAnnullamento.WarnMessage))
                            {
                                warnMessage += messaggeAnnullamento.WarnMessage + Environment.NewLine;
                                if (force)
                                    rata.Emissione = null;
                            }
                        }
                        
                        if(rata.Emissione == null)
                        {
                            if (rata.Esercizio != null)
                            {
                                rata.Esercizio.Rate.Remove(rata);
                                rata.Esercizio = null;
                            }
                            
                            if (rata.PianoRatealeDettaglio != null)
                            {
                                rata.PianoRatealeDettaglio.RateSoggetti.Remove(rata);
                                rata.PianoRatealeDettaglio = null;
                            }

                            if (rata.Soggetto != null)
                            {
                                rata.Soggetto.Rate.Remove(rata);
                                rata.Soggetto = null;
                            }

                            if(rata.SoggettoEmissione != null)
                            {
                                rata.SoggettoEmissione.Rate.Remove(rata);
                                rata.SoggettoEmissione = null;
                            }

                            _daoFactory.GetRataSoggettoDao().Delete(rata);
                        }
                    }
                    else if (cancelIfNotDeleted)
                    {
                        rata.SetStato(StatoRataEnum.Richiamata);
                        rata.MotivoRichiamo = "Annullamento rata";
                    }
                    else
                        return allowDeleteMessage;
                }

                return new AuthorizationMessages(fatalMessage, warnMessage);
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nella eliminazione di una rata - {0} - rata: ", ex, Utility.GetMethodDescription(), rata.ID);
                throw;
            }
        }
Esempio n. 9
0
        private void writeMovimento20(RataSoggetto rata, StreamWriter sw, int numeroDisposizione, string intestazioneAzienda)
        {
            try
            {
                var sb = new StringBuilder(120);

                // Tipo Record
                sb.Append(" 20");

                // Numero Disposizione
                sb.Append(numeroDisposizione.ToString().PadLeft(7, '0'));

                // --------------------------------------------------------------------
                // Descrizione del creditore (condominio)
                // --------------------------------------------------------------------

                var descrizioneCondominioLength = 30;
                var indirizzoCondominioLength = 30;
                var localitaCondominioLength = 30;
                if (intestazioneAzienda.Length > 10)
                {
                    var gap = intestazioneAzienda.Length - 10;
                    descrizioneCondominioLength += gap;
                    indirizzoCondominioLength -= gap / 2;
                    localitaCondominioLength -= (gap - (30 - indirizzoCondominioLength));
                }

                // Descrizione condominio
                var ragioneSocialeCondominio = Conversione.ToInvioTelematico(rata.Esercizio.CondominioRiferimento.Descrizione);
                if (!string.IsNullOrEmpty(intestazioneAzienda))
                    ragioneSocialeCondominio = intestazioneAzienda + " " + ragioneSocialeCondominio;
                if (ragioneSocialeCondominio.Length > descrizioneCondominioLength)
                    ragioneSocialeCondominio = ragioneSocialeCondominio.Substring(0, descrizioneCondominioLength);
                sb.Append(ragioneSocialeCondominio.PadRight(descrizioneCondominioLength, ' '));

                // Indirizzo
                var indirizzoCondominio = string.Empty;
                if (rata.Esercizio.CondominioRiferimento.Indirizzo != null)
                    indirizzoCondominio = Conversione.ToInvioTelematico(rata.Esercizio.CondominioRiferimento.Indirizzo.GetIndirizzoCompleto());
                if (indirizzoCondominio.Length > indirizzoCondominioLength)
                    indirizzoCondominio = indirizzoCondominio.Substring(0, indirizzoCondominioLength);
                sb.Append(indirizzoCondominio.PadRight(indirizzoCondominioLength, ' '));

                // Località
                var localitaCondominio = string.Empty;
                if (rata.Esercizio.CondominioRiferimento.Indirizzo?.Comune != null)
                    localitaCondominio = Conversione.ToInvioTelematico(rata.Esercizio.CondominioRiferimento.Indirizzo.Comune.Descrizione);
                if (localitaCondominio.Length > localitaCondominioLength)
                    localitaCondominio = localitaCondominio.Substring(0, localitaCondominioLength);
                sb.Append(localitaCondominio.PadRight(localitaCondominioLength, ' '));

                // Codice Fiscale
                sb.Append(rata.Esercizio.CondominioRiferimento.CodiceFiscale.PadRight(16, ' '));

                // filler
                sb.Append(string.Empty.PadLeft(4));

                sw.WriteLine(sb.ToString());
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato durante la creazione di una singola riga di MAV - {0} - esercizio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), rata.Esercizio.ID, rata.Esercizio.CondominioRiferimento.Azienda.ID);
                throw;
            }
        }
Esempio n. 10
0
        // Coordinate ordinante
        private void writeMovimento16(RataSoggetto rata, DatiBancariCondomini banca, StreamWriter sw, int numeroDisposizione)
        {
            try
            {
                var sb = new StringBuilder(120);

                // Tipo Record
                sb.Append(" 16");

                // Numero Disposizione
                sb.Append(numeroDisposizione.ToString().PadLeft(7, '0'));

                // --------------------------------------------------------------------
                // Coordinate banca ordinante (banca del condominio)
                // --------------------------------------------------------------------
                var coord = new CoordinateBancarie
                {
                    Abi = banca.Abi,
                    Cab = banca.Cab,
                    ContoCorrente = banca.ContoCorrente
                };

                // Codice Paese
                sb.Append("IT");

                // CheckDigit IBAN
                sb.Append(coord.CalcolaCheckIBAN());

                // CIN
                sb.Append(coord.CalcolaCin());

                // ABI
                sb.Append(coord.Abi);

                // CAB
                sb.Append(coord.Cab);

                // Conto Corrente
                sb.Append(coord.ContoCorrente);

                // filler
                sb.Append(string.Empty.PadLeft(83));

                sw.WriteLine(sb.ToString());
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato durante la creazione di una singola riga di MAV - {0} - condominio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), banca.CondominioRiferimento.ID, banca.CondominioRiferimento.Azienda.ID);
                throw;
            }
        }
Esempio n. 11
0
        private void writeMovimentoRichiamo14(RataSoggetto rata, DatiBancariCondomini banca, StreamWriter sw, int numeroDisposizione)
        {
            try
            {
                var sb = new StringBuilder(120);

                // Tipo Record
                sb.Append(" 14");

                // Numero Disposizione
                sb.Append(numeroDisposizione.ToString().PadLeft(7, '0'));

                // filler
                sb.Append(string.Empty.PadLeft(12));

                // data scadenza
                sb.Append(convertData(rata.DataScadenza));

                // causale
                sb.Append("07000");

                // importo
                sb.Append((Math.Round(rata.Importo * 100, 0)).ToString().PadLeft(13, '0'));

                // segno
                sb.Append("+");

                // --------------------------------------------------------------------
                // Coordinate banca assuntrice (banca del condominio)
                // --------------------------------------------------------------------
                // ABI
                sb.Append(banca.Abi);

                // CAB
                sb.Append(banca.Cab);

                // Conto Corrente
                sb.Append(banca.ContoCorrente.PadLeft(12, '0'));

                // filler
                sb.Append(string.Empty.PadLeft(22));

                // --------------------------------------------------------------------
                // Coordinate azienda creditrice (condominio)
                // --------------------------------------------------------------------

                // Codice SIA
                sb.Append(rata.Esercizio.CondominioRiferimento.CodiceSIA.Trim().PadLeft(5, ' '));

                // Tipo codice (usato il codice fiscale del condominio quindi: '3')
                sb.Append("3");

                // Codice (usato il codice fiscale del condominio)
                sb.Append(rata.Esercizio.CondominioRiferimento.CodiceFiscale.PadRight(16, ' '));

                // filler
                sb.Append(string.Empty.PadLeft(6));

                // divisa
                sb.Append("E");

                sw.WriteLine(sb.ToString());
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato durante la creazione di una singola riga di MAV - {0} - esercizio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), rata.Esercizio.ID, rata.Esercizio.CondominioRiferimento.Azienda.ID);
                throw;
            }
        }
Esempio n. 12
0
        private void writeMovimento50(RataSoggetto rata, EmissioneRate testata, StreamWriter sw, int numeroDisposizione)
        {
            try
            {
                var sb = new StringBuilder(120);

                // Tipo Record
                sb.Append(" 50");

                // Numero Disposizione
                sb.Append(numeroDisposizione.ToString().PadLeft(7, '0'));

                // -----------------------------------------------------------------------------
                // Riferimenti al debito (è suddiviso in due segmenti di 40 caratteri ciascuno)
                // -----------------------------------------------------------------------------
                var descrizioneMav = rata.GetDescrizioneMAV(testata.Causale);
                sb.Append(descrizioneMav[0].PadRight(40, ' '));
                sb.Append(descrizioneMav[1].PadRight(40, ' '));

                // filler
                sb.Append(string.Empty.PadLeft(30));

                sw.WriteLine(sb.ToString());
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato durante la creazione di una singola riga di MAV - {0} - esercizio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), rata?.Esercizio.ID, rata?.Esercizio.CondominioRiferimento.Azienda.ID);
                throw;
            }
        }
Esempio n. 13
0
        private bool insert(RataSoggettoDTO dto, out RataSoggetto item)
        {
            item = null;
            var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);

            try
            {
                item = new RataSoggetto(daoFactory.GetEsercizioDao().GetById(dto.IdEsercizio, false), daoFactory.GetSoggettoCondominioDao().GetById(dto.IdSoggettoCondominio, false), dto.DataScadenza.GetValueOrDefault(), dto.Importo.GetValueOrDefault(), _logTransazione);

                if (dto.IdPianoDettaglioRatealeRiferimento > 0)
                    item.PianoRatealeDettaglio = daoFactory.GetPianoRatealeDettaglioDao().GetById(dto.IdPianoDettaglioRatealeRiferimento, false);
                item.Progressivo = dto.Progressivo;

                daoFactory.GetRataSoggettoDao().SaveOrUpdate(item);
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nell'inserimento delle rate soggetto - {0} - id:{1}", ex, Utility.GetMethodDescription(), dto.ID);
                throw;
            }

            return true;
        }
Esempio n. 14
0
        private bool update(RataSoggettoDTO dto, out RataSoggetto item)
        {
            var result = false;
            item = null;
            var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);

            try
            {
                item = daoFactory.GetRataSoggettoDao().GetById(dto.ID, false);

                // Condizione necessaria per il controllo del fatto che sul DB ho una versione uguale o più vecchia
                if (dto.Version == item.Version)
                {
                    item.DataScadenza = dto.DataScadenza.GetValueOrDefault();
                    item.Importo = dto.Importo.GetValueOrDefault();
                    if(dto.IdPianoDettaglioRatealeRiferimento > 0)
                        item.PianoRatealeDettaglio = daoFactory.GetPianoRatealeDettaglioDao().GetById(dto.IdPianoDettaglioRatealeRiferimento, false);
                    item.Progressivo = dto.Progressivo;

                    daoFactory.GetRataSoggettoDao().Update(item);
                    result = true;
                }
                else
                {
                    // Eccezione: Sul db c'è qualche cosa di più nuovo.
                    _log.ErrorFormat("Errore nel salvataggio della rata soggetto - {0} - id:{1}", Utility.GetMethodDescription(), dto.ID);
                }
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nel salvataggio della rata soggetto - {0} - id:{1}", ex, Utility.GetMethodDescription(), dto.ID);
                throw;
            }

            return result;
        }
Esempio n. 15
0
        public string EliminazioneRataSoggetto(RataSoggetto rata, string descrizione)
        {
            var message = string.Empty;

            if (rata.Stato == StatoRataEnum.Inserita)
            {
                // bugid#10127 se la rata ha solleciti non può essere eliminata
                // per annullarla occorre passare a true il terzo parametro, però attualmente, quando viene visualizzata la lista rate, una store procedure la riporta in stato immesso
                var resultDelete = deleteRata(rata, false);
                if (!string.IsNullOrEmpty(resultDelete.FatalMessage))
                    return resultDelete.FatalMessage;
                //                _daoFactory.GetRataSoggettoDao().Delete(rata);
            }
            else if (rata.Emissione != null && (rata.Stato == StatoRataEnum.Spedita || rata.Stato == StatoRataEnum.ParzialmenteSpedita))
            {
                rata.DaRichiamare = true;
                if (!string.IsNullOrEmpty(descrizione) && descrizione.Length > 50)
                    descrizione = descrizione.Substring(0, 50);
                rata.MotivoRichiamo = descrizione;
            }
            else
                message = "Non è possibile eliminare una rata che sia già pagata o parzialmente pagata." + Environment.NewLine;

            return message;
        }
Esempio n. 16
0
        public string CopiaRate(IList<PianoRatealeDettaglioDTO> dettaglioRate, int idEsercizio, TipoAccorpamentoRateEnum tipoAccorpamento, LogTransazione logTransazione)
        {
            try
            {
                var message = string.Empty;
                LogTransazione logTransazioneDettaglio = null;

                var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
                PianoRateale pianoRateale;
                if (GetPianoRatealeByEsercizio(idEsercizio) != null)
                {
                    pianoRateale = GetPianoRatealeByEsercizio(idEsercizio);
                    logTransazioneDettaglio = logTransazione;
                }
                else 
                    pianoRateale = new PianoRateale(esercizio, tipoAccorpamento, logTransazione);

                int progressivo = 0;
                if(pianoRateale.Rate.Count > 0)
                    progressivo = pianoRateale.Rate.Max(item => item.Progressivo);

                foreach (var dettaglioDto in dettaglioRate)
                {
                    progressivo++;
                    var dettaglio = _daoFactory.GetPianoRatealeDettaglioDao().GetById(dettaglioDto.ID, false);

                    var dettaglioNew = new PianoRatealeDettaglio(pianoRateale, dettaglioDto.DataScadenza, null, progressivo, false, logTransazioneDettaglio)
                    {
                        Descrizione = dettaglioDto.Descrizione,
                        IsAcconto = dettaglioDto.IsAcconto
                    };

                    foreach (var rata in dettaglio.RateSoggetti.Where(item => !item.DaRichiamare))
                    {
                        var rataNew = new RataSoggetto(esercizio, _soggettoService.GetSoggettoAttuale(rata.Soggetto, esercizio, esercizio.DataApertura.GetValueOrDefault()), dettaglioDto.DataScadenza, rata.Importo, null) {PianoRatealeDettaglio = dettaglioNew};
                        dettaglioNew.RateSoggetti.Add(rataNew);
                    }

                }

                return message;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nella copia delle rate - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), idEsercizio);
                throw;
            }
        }
Esempio n. 17
0
        private void writeMovimento30(RataSoggetto rata, StreamWriter sw, int numeroDisposizione)
        {
            try
            {
                var sb = new StringBuilder(120);

                // Tipo Record
                sb.Append(" 30");

                // Numero Disposizione
                sb.Append(numeroDisposizione.ToString().PadLeft(7, '0'));

                // --------------------------------------------------------------------
                // Descrizione debitore (condomino - è suddivisa in 2 segmenti alfanumerici di 30 caratteri ciascuno)
                // --------------------------------------------------------------------
                var tipoIndirizzo = TipoIndirizzo.Recapito;
                if (_impostazioniAzienda != null)
                    tipoIndirizzo = _impostazioniAzienda.TipoIndirizzoComunicazioni;

                var indirizzoCondomino = _personaService.GetRecapito(rata.Soggetto.Persona, tipoIndirizzo);
                var nomeCondomino = rata.Soggetto.DisplayName;
                if (!string.IsNullOrEmpty(indirizzoCondomino.Presso))
                    nomeCondomino += " c/o " + indirizzoCondomino.Presso;

                var descrizioneCondomino = Conversione.ToInvioTelematico(nomeCondomino);
                var descrizione1 = string.Empty;
                var descrizione2 = string.Empty;
                if (descrizioneCondomino.Length <= 30)
                {
                    descrizione1 = descrizioneCondomino.PadRight(30, ' ');
                    descrizione2 = string.Empty.PadLeft(30, ' ');
                }
                else if (descrizioneCondomino.Length > 30)
                {
                    descrizione1 = descrizioneCondomino.Substring(0, 30);
                    descrizione2 = descrizioneCondomino.Substring(30).PadRight(30, ' ');
                }

                if (descrizione2.Length > 30)
                    descrizione2 = descrizione2.Substring(0, 30);

                // Descrizione condomino
                sb.Append(descrizione1);
                sb.Append(descrizione2);

                // Codice Fiscale
                var codiceFiscale = string.Empty;
                if (rata.Soggetto.Persona.CodiceFiscale != null)
                    codiceFiscale = rata.Soggetto.Persona.CodiceFiscale;
                sb.Append(codiceFiscale.PadRight(16, ' '));

                // filler
                sb.Append(string.Empty.PadLeft(34));

                sw.WriteLine(sb.ToString());
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato durante la creazione di una singola riga di MAV - {0} - esercizio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), rata.Esercizio.ID, rata.Esercizio.CondominioRiferimento.Azienda.ID);
                throw;
            }
        }
Esempio n. 18
0
        private AuthorizationMessages annullamentoRata(RataSoggetto rata)
        {
            var fatalMessage = string.Empty;
            var warnMessage = string.Empty;
            if (rata.Emissione != null && rata.DataScadenza > DateTime.Today.AddDays(10))
            {
                rata.SetStato(StatoRataEnum.Inserita);
                rata.DaRichiamare = true;
                rata.MotivoRichiamo = "Annullamento rata";
                return new AuthorizationMessages(null, null);
            }

            if (rata.DataScadenza <= DateTime.Today.AddDays(10))
                warnMessage += "La rata non è richiamabile perchè già scaduta o perchè la scadenza è troppo vicina" + Environment.NewLine;

            return new AuthorizationMessages(fatalMessage, warnMessage);
        }
Esempio n. 19
0
        private void writeMovimento40(RataSoggetto rata, StreamWriter sw, int numeroDisposizione)
        {
            try
            {
                var sb = new StringBuilder(120);

                // Tipo Record
                sb.Append(" 40");

                // Numero Disposizione
                sb.Append(numeroDisposizione.ToString().PadLeft(7, '0'));

                // --------------------------------------------------------------------
                // Indirizzo del debitore (condomino)
                // --------------------------------------------------------------------
                var tipoIndirizzo = TipoIndirizzo.Recapito;
                if (_impostazioniAzienda != null)
                    tipoIndirizzo = _impostazioniAzienda.TipoIndirizzoComunicazioni;
                var indirizzoCondomino = _personaService.GetRecapito(rata.Soggetto.Persona, tipoIndirizzo);

                // via, civico e/o frazione
                var indirizzo = Conversione.ToInvioTelematico(indirizzoCondomino.Indirizzo + ", " + indirizzoCondomino.Civico + " " + indirizzoCondomino.Localita);
                string indirizzo1;
                var indirizzo2 = string.Empty;
                if (indirizzo.Length <= 30)
                    indirizzo1 = indirizzo;
                else
                {
                    indirizzo1 = indirizzo.Substring(0, 30);
                    indirizzo2 = indirizzo.Substring(30);
                }
                sb.Append(indirizzo1.PadRight(30, ' '));

                // cap
                var cap = string.Empty;
                if (indirizzoCondomino.Cap != null)
                {
                    cap = indirizzoCondomino.Cap.Trim();
                    if (cap.Length > 5)
                        cap = cap.Substring(0, 5);
                }
                sb.Append(cap.PadLeft(5, '0'));

                // comune e sigla provincia
                var comune = string.Empty;
                if(!string.IsNullOrEmpty(indirizzoCondomino.Comune?.Descrizione))
                    comune = Conversione.ToInvioTelematico(indirizzoCondomino.Comune.Descrizione.Trim());
                else if(indirizzoCondomino.Comune != null)
                    _log.ErrorFormat("Trovato comune senza DESCRIZIONE - {0} - comune:{1}", Utility.GetMethodDescription(), indirizzoCondomino.Comune.Codice);
                else
                    _log.ErrorFormat("Trovato indirizzo CONDOMINO senza COMUNE - {0} - condomino:{1}", Utility.GetMethodDescription(), rata.Soggetto.ID);

                if (comune.Length > 22)
                    comune = comune.Substring(0, 22);

                var provincia = string.Empty;
                if (indirizzoCondomino.Comune?.ProvinciaAppartenenza != null)
                    provincia = indirizzoCondomino.Comune.ProvinciaAppartenenza.Codice;
                sb.Append((comune + " " + provincia).PadRight(25, ' '));

                // seconda parte indirizzo
                if (indirizzo2.Length > 28)
                    indirizzo2 = indirizzo2.Substring(0, 28);
                sb.Append(indirizzo2.PadRight(28, ' '));

                // codice paese secondo codifica ISO 3166
                // TODO: Da gestire la tabella dei codici ISO
                sb.Append("IT");

                // filler
                sb.Append(string.Empty.PadLeft(20));

                sw.WriteLine(sb.ToString());
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato durante la creazione di una singola riga di MAV - {0} - rata:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), rata?.ID.ToString() ?? "<NULL>", _testata.Esercizio.ID);
                throw;
            }
        }
Esempio n. 20
0
        private RataSoggettoDTO setDto(RataSoggetto rata)
        {
            try
            {
                var dto = new RataSoggettoDTO
                {
                    DisplayName = rata.PianoRatealeDettaglio.Descrizione,
                    DataScadenza = rata.DataScadenza,
                    DescrizioneSoggettoCondominio = rata.Soggetto.DisplayName,
                    DescrizioneUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.Descrizione + " - " + rata.Soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione,
                    ID = rata.ID,
                    IdEsercizio = rata.Esercizio.ID,
                    DescrizioneEsercizio = rata.Esercizio.DisplayName,
                    Importo = rata.Importo,
                    StatoRata = rata.Stato,
                    IdSoggettoCondominio = rata.Soggetto.ID,
                    IdUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.ID,
                    IdPersona = rata.Soggetto.Persona.ID,
                    Progressivo = rata.Progressivo,
                    ImportoPagato = rata.Versamenti.Sum(vers => vers.Importo),
                    IsDeleteAllow = false,
                    TipoSoggettoCondominio = rata.Soggetto.Tipo,
                    OrdineUnitaImmobiliare = rata.Soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault(),
                    NumeroSolleciti = rata.Solleciti.Count,
                    Subalterno = rata.Soggetto.UnitaImmobiliare.Subalterno,
                    Alert = false
                };

                // E' ammesso il richiamo della rata solo se non è ancora stata pagata e se non vi sono rate collegate a livello di MAV
                if (rata.Stato != StatoRataEnum.Pagata && rata.Stato != StatoRataEnum.ParzialmentePagata)
                {
                    if (rata.Emissione == null || rata.Emissione.RateCollegate.Count <= 1)
                        dto.IsDeleteAllow = true;
                }

                if (rata.SoggettoEmissione != null)
                {
                    dto.IdSoggettoEmissione = rata.SoggettoEmissione.ID;
                    dto.DescrizioneSoggettoEmissione = rata.SoggettoEmissione.DisplayName;
                }

                if (rata.PianoRatealeDettaglio != null)
                {
                    dto.IdPianoDettaglioRatealeRiferimento = rata.PianoRatealeDettaglio.ID;
                    dto.DisplayName = rata.PianoRatealeDettaglio.Descrizione;
                }

                if (rata.Emissione?.Stato == StatoMavEnum.Radiato && rata.Stato != StatoRataEnum.Pagata && rata.Stato != StatoRataEnum.ParzialmentePagata)
                    dto.Alert = true;

                return dto;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato durante la inizializzazione di un elemento DTO di rata - {0} - idRata:{1}", ex, Utility.GetMethodDescription(), rata.ID);
                throw;
            }
        }
Esempio n. 21
0
        public ResultVersamento InsertVersamentoCondomino(Esercizio esercizio, RataSoggetto rata, DatiBancariCondomini banca, Conto contoBancario, CausaleContabile causaleVersamento, Conto contoVersamentoCondomini, DateTime dataVersamento, FileCBI file, LogTransazione logTransazione, TipoVersamentoDopoChiusuraEnum? tipoVersamentoDopoChiusura = null, TipoVersamentoPrimaAperturaEnum? tipoVersamentoPrimaApertura = null)
        {
            int? protocollo = null;
            int? idMovimentoContabile = null;
            var message = string.Empty;
            var descrizione = string.Empty;
            VersamentoSoggetto versamento = null;

            // La richiesta del versamento può avvenire solo se il versamento è successivo alla data di chiusura dell'esercizio
            if (dataVersamento <= esercizio.DataChiusura.GetValueOrDefault())
                tipoVersamentoDopoChiusura = null;

            // La richiesta del versamento prima dell'apertura può avvenire solo se il versamento è precedente alla data di apertura dell'esercizio
            if (dataVersamento >= esercizio.DataApertura.GetValueOrDefault())
                tipoVersamentoPrimaApertura = null;
            try
            {
                // ----------------------------------------------------
                //  Creo Versamento
                // ----------------------------------------------------
                if (string.IsNullOrEmpty(message))
                {
                    var progressivo = _protocolloService.GetProgressivo(TipoProtocollo.VersamentoCondomino, esercizio);
                    if (progressivo.Progressivo != null)
                    {
                        protocollo = progressivo.Progressivo;

                        // ------------------------------------------------------
                        //  Trovo l'esercizio contabile, se non esiste oppure se è chiuso
                        //  interrompo l'operazione di versamento
                        // ------------------------------------------------------
                        var esercizioContabile = esercizio;
                        if (esercizioContabile.Gestione == GestioneEsercizioEnum.Ordinario || (esercizioContabile.Gestione == GestioneEsercizioEnum.Straordinario && (esercizioContabile.Stato == StatoEsercizioEnum.Chiuso || esercizioContabile.DataChiusura.GetValueOrDefault() < dataVersamento)))
                        {
                            esercizioContabile = _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(esercizio.CondominioRiferimento, dataVersamento);
                            if (esercizioContabile == null || esercizioContabile.Stato == StatoEsercizioEnum.Chiuso)
                            {
                                var messageEsercizio = esercizioContabile == null ? "l'esercizio di competenza non è ancora stato aperto" : $"l'esercizio '{esercizioContabile.DisplayName}' è chiuso";
                                return new ResultVersamento(null, null, null, null, null, $"Non è possibile registrare il versamento in data {dataVersamento.ToShortDateString()} perchè {messageEsercizio}.");
                            }
                        }

                        try
                        {
                            versamento = new VersamentoSoggetto(esercizio, rata.Soggetto, contoBancario, dataVersamento, rata.Importo, file, banca, logTransazione, tipoVersamentoDopoChiusura, tipoVersamentoPrimaApertura);
                            _movimentoContabileService.SetMovimentiVersamentoCondomino(null, null, esercizioContabile, versamento, dataVersamento, causaleVersamento, contoVersamentoCondomini, null, file, logTransazione);
                        }
                        catch (InvalidDataException exception)
                        {
                            _log.ErrorFormat("Errore inaspettato nella registrazione del versamento del condomino - {0} - esercizio:{1} - rata:{2}", Utility.GetMethodDescription(), esercizioContabile.ID, rata.ID);
                            if (versamento != null)
                            {
                                if (logTransazione != null)
                                {
                                    logTransazione.Versamenti.Remove(versamento);
                                    versamento.LogTransazione = null;
                                }

                                if (file != null)
                                {
                                    file.Versamenti.Remove(versamento);
                                    versamento.File = null;
                                }

                                esercizio.VersamentiCondomini.Remove(versamento);
                                versamento.Esercizio = null;

                                rata.Soggetto.Versamenti.Remove(versamento);
                                versamento.Soggetto = null;

                                versamento = null;
                            }
                            return new ResultVersamento(null, null, null, null, null, $"Non è possibile registrare il versamento in data {dataVersamento.ToShortDateString()} perchè {exception.Message}.");
                        }
                        
                        setRataVersamentoDopoChiusura(versamento, esercizioContabile, logTransazione);

                        // ---------------------------------------------------------------------
                        // Se la rata non è ancora stata pagata associo il versamento alla rata
                        // ---------------------------------------------------------------------
                        // se la rata è già stata pagata, oppure se l'esercizio di riferimento è chiuso viene registrata come rata fuori piano rateale
                        if (rata.Stato != StatoRataEnum.Pagata && rata.Stato != StatoRataEnum.ParzialmentePagata && rata.Esercizio.Stato == StatoEsercizioEnum.Aperto )
                        {
                            var versamentoRata = new VersamentiRate(versamento, rata, rata.Importo);
                            rata.SetStato();
                        }
                        else
                        {
                            versamento.Causale = $"Versamento fuori piano rateale perchè la rata si trova in stato di {rata.Stato}";
                        }

                        idMovimentoContabile = versamento.MovimentoContabilePatrimoniale.ID;
                        descrizione = getDescrizioneVersamentoConfermato(versamento);
                    }
                    else
                        message += progressivo.Message + Environment.NewLine;
                }
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nel metodo: {0} - rata:{1} - dataVersamento:{2}", ex, Utility.GetMethodDescription(), rata.ID, dataVersamento);
                throw;
            }

            return new ResultVersamento(setVersamentoRicevutaDTO(versamento), null, protocollo, idMovimentoContabile, descrizione, message);
        }
Esempio n. 22
0
        private VersamentiRate setRataVersamentoDopoChiusura(VersamentoSoggetto versamento, Esercizio esercizio, LogTransazione logTransazione)
        {
            VersamentiRate rataVersamento = null;
            LogTransazione logTransazioneRata = null;
            if (esercizio.Gestione == GestioneEsercizioEnum.Ordinario && esercizio.Stato == StatoEsercizioEnum.Aperto && versamento.TipoVersamentoDopoChiusura == TipoVersamentoDopoChiusuraEnum.RicEsSucc)
            {
                var pianoRatealeDettaglio = _daoFactory.GetPianoRatealeDettaglioDao().GetRataVersamentoDopoChiusura(esercizio);
                if (pianoRatealeDettaglio == null)
                {
                    var pianoRateale = _daoFactory.GetPianoRatealeDao().GetByEsercizio(esercizio);
                    LogTransazione logTransazioneDettaglio = null;
                    if (pianoRateale == null)
                        pianoRateale = new PianoRateale(esercizio, TipoAccorpamentoRateEnum.Nessuno, logTransazione);
                    else
                        logTransazioneDettaglio = logTransazione;
                    pianoRatealeDettaglio = new PianoRatealeDettaglio(pianoRateale, esercizio.DataApertura, null, 0, false, logTransazioneDettaglio)
                    {
                        Descrizione = "Versamenti eseguiti dopo la chiusura",
                        IsAcconto = true,
                        VersamentiDopoChiusura = true
                    };
                }
                else
                    logTransazioneRata = logTransazione;

                var rataSoggetto = new RataSoggetto(pianoRatealeDettaglio, versamento.Soggetto, versamento.Data, versamento.Importo, logTransazioneRata);
                rataVersamento = new VersamentiRate(versamento, rataSoggetto, versamento.Importo);
                rataSoggetto.SetStato();
            }

            return rataVersamento;
        }
Esempio n. 23
0
        public void SalvaPianoRateale(PianoRatealeSoggetti pianoRatealeSoggetti, LogTransazione logTransazione)
        {
                       
/* Vecchio Codice per rimozione rendiconti

            // --------------------------------------------------
            //  Rimozione rendiconti preesistenti
            // --------------------------------------------------
            Esercizio esercizio =_daoFactory.GetEsercizioDao().GetById(pianoRatealeSoggetti.PianoRateale.IdEsercizio, false);
            foreach (RendicontoAnnuale rendiconto in esercizio.Rendiconti)
            {
                foreach (PianoRateale piano in rendiconto.PianiRateali)
                {
                   _daoFactory.GetPianoRatealeDao().Delete(piano);
                    piano.Rendiconto = null;
                    foreach (PianoRatealeDettaglio dettaglio in piano.Rate)
                        dettaglio.PianoRatealeRiferimento = null;
                }
                rendiconto.PianiRateali.Clear();
            }

            //List<RataSoggetto> rate = new List<RataSoggetto>(esercizio.Rate.Count);
            foreach (RataSoggetto rata in esercizio.Rate)
            {
                rata.Soggetto.Rate.Clear();
                if (rata.PianoRatealeDettaglio != null)
                {
                    rata.PianoRatealeDettaglio.RateSoggetti.Remove(rata);
                    rata.PianoRatealeDettaglio = null;
                    rata.Soggetto.Rate.Clear();
                    rata.Soggetto = null;
                }
               _daoFactory.GetRataSoggettoDao().Delete(rata);
                rate.Add(rata);
            }
            esercizio.Rate.Clear();
            foreach (RataSoggetto rata in rate)
            {
                esercizio.Rate.Remove(rata);
                rata.Esercizio = null;
            } 
 */
            try
            {

                // ====================================================================================================
                //  Rimozione piani rateali preesistenti (solo se non è una rata di acconto)
                // ====================================================================================================
                var esercizio = _daoFactory.GetEsercizioDao().Find(pianoRatealeSoggetti.PianoRateale.IdEsercizio, false);

                // leggo ora le rate da richiamare per evitare successivi problemi di cascade
                var rateDaRichiamare = _daoFactory.GetRataSoggettoDao().GetDaRichiamareByEsercizio(esercizio);
                var pianiEliminati = new List<PianoRateale>();

                if (esercizio != null)
                {
                    // ----------------------------------------------------------------------
                    //  Rimozione piani da rendiconti
                    // ----------------------------------------------------------------------
                    try
                    {
                        foreach (var rendiconto in esercizio.Rendiconti)
                        {
                            var pianiDaRimuovere = rendiconto.PianiRateali.ToList();
                            foreach (var piano in pianiDaRimuovere)
                            {
                                try
                                {
                                    var listaDettaglioRate = piano.Rate.ToList();
                                    foreach (var dettaglioPiano in listaDettaglioRate)
                                    {
                                        try
                                        {
                                            if (!dettaglioPiano.IsAcconto)
                                            {
                                                // Elimino impostazioni report dettaglio
                                                deleteImpostazioniReportDettaglioPiano(dettaglioPiano);

                                                piano.Rate.Remove(dettaglioPiano);
                                                dettaglioPiano.PianoRatealeRiferimento = null;

                                                if (dettaglioPiano.LogTransazione != null)
                                                {
                                                    dettaglioPiano.LogTransazione.PianoRateale.Remove(piano);
                                                    dettaglioPiano.LogTransazione = null;
                                                }
                                            }

                                        }
                                        catch (Exception ex)
                                        {
                                            _log.ErrorFormat("Errore inaspettato durante la rimozione dei piani rateali precedenti - SINGOLO DETTAGLIO PIANO - {0} - dettaglio piano:{1}", ex, Utility.GetMethodDescription(), dettaglioPiano.ID);
                                            throw;
                                        }
                                    }

                                }
                                catch (Exception ex)
                                {
                                    _log.ErrorFormat("Errore inaspettato durante la rimozione dei piani rateali precedenti - SINGOlO PIANO - {0} - piano:{1}", ex, Utility.GetMethodDescription(), piano.ID);
                                    throw;
                                }

                                if (piano.Rate.Count == 0)
                                {
                                    pianiEliminati.Add(piano);
                                    rendiconto.PianiRateali.Remove(piano);
                                    piano.Rendiconto = null;

                                    if (piano.LogTransazione != null)
                                    {
                                        piano.LogTransazione.PianoRateale.Remove(piano);
                                        piano.LogTransazione = null;
                                    }
                                }
                            }
                        }

                    }
                    catch (Exception ex)
                    {
                        _log.ErrorFormat("Errore inaspettato durante la rimozione dei piani rateali precedenti - RIMOZIONE PIANI RATEALI DA RENDICONTI - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
                        throw;
                    }

                    // ----------------------------------------------------------------------
                    //  Rimozione singole rate
                    // ----------------------------------------------------------------------
                    var rateToDelete = new List<PianoRatealeDettaglio>();
                    var ratePresenti = esercizio.Rate.ToList();
                    ratePresenti.AddRange(rateDaRichiamare);
                    try
                    {
                        foreach (var rata in ratePresenti)
                        {
                            try
                            {
                                if (rata.PianoRatealeDettaglio != null && !rata.PianoRatealeDettaglio.IsAcconto)
                                {
                                    if (!rateToDelete.Contains(rata.PianoRatealeDettaglio))
                                        rateToDelete.Add(rata.PianoRatealeDettaglio);

                                    rata.Esercizio?.Rate.Remove(rata);
                                    rata.PianoRatealeDettaglio.RateSoggetti.Remove(rata);
                                    rata.Esercizio = null;
                                    rata.PianoRatealeDettaglio = null;
                                    
                                    if (rata.Soggetto != null)
                                    {
                                        rata.Soggetto.Rate.Remove(rata);
                                        rata.Soggetto = null;
                                    }

                                    if (rata.SoggettoEmissione != null)
                                    {
                                        rata.SoggettoEmissione.Rate.Remove(rata);
                                        rata.SoggettoEmissione = null;
                                    }

                                    if (rata.LogTransazione != null)
                                    {
                                        rata.LogTransazione.Rate.Remove(rata);
                                        rata.LogTransazione = null;
                                    }

                                    //_daoFactory.GetRataSoggettoDao().Delete(rata);
                                }
                            }
                            catch (Exception ex)
                            {
                                _log.ErrorFormat("Errore inaspettato durante il salvataggio del piano rateale - SINGOlA RATA - {0} - rata:{1}", ex, Utility.GetMethodDescription(), rata.ID);
                                throw;

                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        _log.ErrorFormat("Errore inaspettato durante la rimozione dei piani rateali precedenti - RIMOZIONE SINGOLE RATE SOGGETTI - {0} - rataesercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
                        throw;
                    }

                    // ----------------------------------------------------------------------
                    //  Rimozione singoli dettaglio rate
                    // ----------------------------------------------------------------------
                    try
                    {
                        foreach (var dettaglio in rateToDelete)
                        {
                            try
                            {
                                if (dettaglio.PianoRatealeRiferimento != null)
                                {
                                    dettaglio.PianoRatealeRiferimento.Rate.Remove(dettaglio);
                                    dettaglio.PianoRatealeRiferimento = null;
                                }
                                dettaglio.RateSoggetti.Clear();
                            }
                            catch (Exception ex)
                            {
                                _log.ErrorFormat("Errore inaspettato durante la rimozione dei piani rateali precedenti - SINGOLO DETTAGLIO - {0} - dettaglio:{1}", ex, Utility.GetMethodDescription(), dettaglio.ID);
                                throw;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        _log.ErrorFormat("Errore inaspettato durante la rimozione dei piani rateali precedenti - RIMOZIONE DETTAGLI - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
                        throw;
                    }

                    // ====================================================================================================
                    //  Creazione nuovo piano rateale
                    // ====================================================================================================

                    // ----------------------------------------------------------------------
                    //  Oggetto PianoRateale
                    // ----------------------------------------------------------------------
                    LogTransazione logTransazioneDettaglio = null;
                    PianoRateale pianoRateale = null;
                    try
                    {
                        // Non devo considerare piani rateali eliminati nelle elaborazioni precedenti
                        if (pianiEliminati.All(item => item.ID != pianoRatealeSoggetti.PianoRateale.ID))
                            pianoRateale = _daoFactory.GetPianoRatealeDao().Find(pianoRatealeSoggetti.PianoRateale.ID, false);
                        if (pianoRateale == null)
                        {
                            pianoRateale = new PianoRateale(_daoFactory.GetRendicontoAnnualeDao().GetById(pianoRatealeSoggetti.PianoRateale.IdRendiconto.GetValueOrDefault(), false), pianoRatealeSoggetti.PianoRateale.Tipo, logTransazione);
                        }
                        else
                        {
                            pianoRateale.Rendiconto = _daoFactory.GetRendicontoAnnualeDao().GetById(pianoRatealeSoggetti.PianoRateale.IdRendiconto.GetValueOrDefault(), false);
                            logTransazioneDettaglio = logTransazione;
                        }

                        pianoRateale.Tipo = pianoRatealeSoggetti.PianoRateale.Tipo;
                        pianoRateale.ArrotondamentoImporti = pianoRatealeSoggetti.PianoRateale.ArrontondamentoImporti;

                    }
                    catch (Exception ex)
                    {
                        _log.ErrorFormat("Errore inaspettato durante il salvataggio del piano rateale - CREAZIONE O AGGIORNAMENTO OGGETTO PianoRateale - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
                        throw;
                    }

                    // ----------------------------------------------------------------------
                    //  Dettagli del piano rateale
                    // ----------------------------------------------------------------------
                    try
                    {
                        foreach (var dettaglioDto in pianoRatealeSoggetti.PianoRateale.Rate)
                        {
                            if (dettaglioDto.ID == 0)
                            {
                                try
                                {
                                    if (Conversione.IsSqlSmallDateTime(dettaglioDto.DataScadenza))
                                    {
                                        var dettaglio = new PianoRatealeDettaglio(pianoRateale, dettaglioDto.DataScadenza, dettaglioDto.PercentualeRiparto, dettaglioDto.Progressivo, false, logTransazioneDettaglio)
                                        {
                                            Descrizione = dettaglioDto.Descrizione,
                                            Importo = dettaglioDto.Importo,
                                            PercentualeSaldoEsercizioPrecedente = dettaglioDto.PercentualeRipartoSaldo
                                        };
                                    }
                                    else
                                    {
                                        _log.ErrorFormat("Tentativo di salvare rata con data di scadenza errata - {0} - data:{1} - esercizio:{2}", Utility.GetMethodDescription(), dettaglioDto.DataScadenza, esercizio.ID);
                                    }
                                }
                                catch (Exception ex)
                                {
                                    _log.ErrorFormat("Errore inaspettato durante il salvataggio del piano rateale - SINGOLO DETTAGLIO DTO - {0} - dettaglio:{1} - esercizio:{2} ", ex, Utility.GetMethodDescription(), dettaglioDto.ID, esercizio.ID);
                                    throw;
                                }
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        _log.ErrorFormat("Errore inaspettato durante il salvataggio del piano rateale - ELABORAZIONE DETTAGLI - {0} - esercizio:{1} ", ex, Utility.GetMethodDescription(), esercizio.ID);
                        throw;
                    }

                    // ----------------------------------------------------------------------
                    //  Singole rate
                    // ----------------------------------------------------------------------
                    try
                    {
                        foreach (var rataSoggettoDto in pianoRatealeSoggetti.RateSoggetti)
                        {
                            try
                            {
                                if (rataSoggettoDto.ID == 0)
                                {
                                    var rata = new RataSoggetto(pianoRateale.Esercizio, _daoFactory.GetSoggettoCondominioDao().GetById(rataSoggettoDto.IdSoggettoCondominio, false), rataSoggettoDto.DataScadenza.GetValueOrDefault(), rataSoggettoDto.Importo.GetValueOrDefault(), null) { Progressivo = rataSoggettoDto.Progressivo };
                                    if (rataSoggettoDto.Progressivo > 0)
                                    {
                                        PianoRatealeDettaglio dettaglio = null;
                                        var dto = rataSoggettoDto;
                                        var dettagli = (pianoRateale.Rate.Where(dett => dett.Progressivo == dto.Progressivo)).ToList();

                                        if (dettagli.Any())
                                        {
                                            if (dettagli.Count > 1)
                                                _log.DebugFormat("Trovata più di una rata con lo stesso progressivo - SINGOLO SOGGETTO - Valorizzazione progressivo - {0} - rata:{1} - soggetto:{2} - esercizio:{3}", Utility.GetMethodDescription(), rataSoggettoDto.ID, rataSoggettoDto.IdSoggettoCondominio, esercizio.ID);
                                            dettaglio = dettagli.First();
                                        }

                                        if (dettaglio == null)
                                        {
                                            _log.ErrorFormat("Non trovata la rata di dettaglio - Valorizzazione progressivo - {0} - rata:{1} - soggetto:{2} - esercizio:{3}", Utility.GetMethodDescription(), rataSoggettoDto.ID, rataSoggettoDto.IdSoggettoCondominio, esercizio.ID);
                                        }
                                        else
                                            dettaglio.RateSoggetti.Add(rata);

                                        rata.PianoRatealeDettaglio = dettaglio;
                                    }

                                    if (rata.PianoRatealeDettaglio == null || rata.PianoRatealeDettaglio.ID > 0)
                                        rata.LogTransazione = logTransazione;
                                }
                            }
                            catch (Exception ex)
                            {
                                _log.ErrorFormat("Errore inaspettato durante il salvataggio del piano rateale - Valorizzazione progressivo - {0} - rata:{1} - soggetto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), rataSoggettoDto.ID, rataSoggettoDto.IdSoggettoCondominio, esercizio.ID);
                                throw;
                            }
                        }

                    }
                    catch (Exception ex)
                    {
                        _log.ErrorFormat("Errore inaspettato durante il salvataggio del piano rateale - ELABORAZIONE DETTAGLIO SOGGETTO - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
                        throw;
                    }

                    var rateArrotondamenti = pianoRateale.Rate.Where(dettaglio => dettaglio.Progressivo == pianoRatealeSoggetti.PianoRateale.IdRataArrotondamenti).ToList();
                    if(rateArrotondamenti.Count > 1)
                        throw new InvalidDataException(string.Format("Errore nel salvataggio del piano rateale.{0}Il valore di progressivo non è corretto.{0}Si prega di contattare l'assistenza.", Environment.NewLine));

                    pianoRateale.RataArrotondamenti = rateArrotondamenti.SingleOrDefault();
                }
                else
                {
                    _log.WarnFormat("Esercizio non trovato nel salvataggio del piano rateale - {0} - esercizio:{1}", Utility.GetMethodDescription(), pianoRatealeSoggetti.PianoRateale.IdEsercizio);
                }
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato durante il salvataggio del piano rateale - {0} - pianoRatealeSoggetti:{1}", ex, Utility.GetMethodDescription(), pianoRatealeSoggetti.PianoRateale.ID);
                throw;
            }
        }
Esempio n. 24
0
 public TestataMovimentoContabile SetMovimentiSingolaRata(RataSoggetto rata, TestataMovimentoContabile testata, DateTime dataRegistrazione)
 {
     return null;
     return SetMovimentiSingolaRata(rata, rata.Importo, rata.Soggetto, rata.Esercizio, testata, dataRegistrazione);
 }
Esempio n. 25
0
        public string AggiornaImporti(IList<RataSoggettoAggiornamentoDTO> rate, bool rateAcconto, TipoAccorpamentoRateEnum tipo, LogTransazione logTransazione)
        {
            try
            {
                var message = string.Empty;
                LogTransazione logTransazioneDettaglio = null;
                var dettaglioPianoRateale = new Dictionary<DateTime, PianoRatealeDettaglio>();
                PianoRateale pianoRateale = null;

                foreach (var rata in rate)
                {
                    if (!(rata.Importo < 0))
                    {
                        if (Conversione.IsSqlSmallDateTime(rata.DataScadenza))
                        {
                            if (rata.Id > 0)
                            {
                                var rataDaAggiornare = _daoFactory.GetRataSoggettoDao().Find(rata.Id, false);
                                if (rataDaAggiornare != null)
                                {
                                    // Se la rata è stata richiamata occorre creare una nuova rata
                                    if (rataDaAggiornare.DaRichiamare || rataDaAggiornare.Stato == StatoRataEnum.Richiamata)
                                    {
                                        var rataNew = new RataSoggetto(rataDaAggiornare.Esercizio, rataDaAggiornare.Soggetto, rataDaAggiornare.DataScadenza, rata.Importo.GetValueOrDefault(), logTransazione)
                                        {
                                            PianoRatealeDettaglio = rataDaAggiornare.PianoRatealeDettaglio,
                                            Progressivo = rataDaAggiornare.Progressivo
                                        };
                                        rataNew.SetStato(StatoRataEnum.Inserita);
                                    }
                                    else
                                    {
                                        rataDaAggiornare.DataScadenza = rata.DataScadenza;
                                        rataDaAggiornare.Importo = rata.Importo.GetValueOrDefault();
                                    }
                                }
                                else
                                {
                                    message = "Il piano rateale che si è cercato di aggiornare è obsoleto. Rientrare nella funzione 'Rate' e riproporre l'aggiornamento.";
                                    _log.WarnFormat("Nell'aggiornamento manuale del piano rateale si sono verificati i seguenti errori - {0}:{1}{2}", Utility.GetMethodDescription(), Environment.NewLine, message);
                                    throw new InvalidDataException(message);
                                }
                            }
                            else
                            {
                                // Trovo la rata NON RICHIAMATA per lo stesso dettaglio, per il soggetto considerato, dovrebbe esserne presente una sola
                                var esercizio = _daoFactory.GetEsercizioDao().GetById(rata.IdEsercizio, false);
                                var pianoRatealeDettaglio = getPianoRatealeDettaglio(dettaglioPianoRateale, pianoRateale, esercizio, rata, rateAcconto, tipo, logTransazione, logTransazioneDettaglio, message);
                                if (pianoRatealeDettaglio != null)
                                {
                                    pianoRateale = pianoRatealeDettaglio.PianoRatealeRiferimento;
                                    logTransazioneDettaglio = pianoRatealeDettaglio.LogTransazione;
                                    var rateDaAggiornare = pianoRatealeDettaglio.RateSoggetti.Where(item => item.Soggetto.ID == rata.IdSoggettoCondominio && !item.DaRichiamare).ToList();
                                    if (!(rateDaAggiornare.Count > 1))
                                    {
                                        var rataDaAggiornare = rateDaAggiornare.FirstOrDefault();
                                        if (rataDaAggiornare == null)
                                        {
                                            var soggetto = _daoFactory.GetSoggettoCondominioDao().Find(rata.IdSoggettoCondominio, false);
                                            if (soggetto != null)
                                                rataDaAggiornare = new RataSoggetto(pianoRatealeDettaglio, soggetto, rata.DataScadenza, rata.Importo.GetValueOrDefault(), null);
                                        }

                                        if (rataDaAggiornare != null)
                                            rataDaAggiornare.Importo = rata.Importo.GetValueOrDefault();
                                    }
                                }
                            }
                        }
                        else
                        {
                            _log.ErrorFormat("Rata con data non valida - {0} - rata:{1} - data:{2} - soggetto:{3} - importo:{4} - esercizio:{5}", Utility.GetMethodDescription(), rata.Id, rata.DataScadenza, rata.IdSoggettoCondominio, rata.Importo, rata.IdEsercizio);
                        }
                    }
                }

                if (!string.IsNullOrEmpty(message))
                {
                    _log.WarnFormat("Si sono verificati i seguenti errori - {0} - message:{1}", Utility.GetMethodDescription(), message);
                }

                return message;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato durante l'aggiornamento degli importi delle rate - {0}", ex, Utility.GetMethodDescription());
                throw;
            }
        }
Esempio n. 26
0
        public void SetMovimentiRichiamoRata(RataSoggetto rata, LogTransazione logTransazione)
        {
            // Movimenti Contabili: Non devono essere registrati movimenti contabili all'atto dell'annullamento di una rata bugid#6383
            return;
            var numeroRiga = 0;
            var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IR");

            // ------------------------------------------------
            // Testata
            // ------------------------------------------------
            var testata = new TestataMovimentoContabile(rata.Esercizio, DateTime.Today, TipoTestataMovimentoContabileEnum.Automatica, logTransazione);

            // controllo data registrazione
            var message = IsAllowDataRegistrazione(new List<int> { rata.Esercizio.CondominioRiferimento.ID }, rata.Esercizio, testata.DataRegistrazione.GetValueOrDefault());
            if (message.Count > 0)
            {
                var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", testata.DataRegistrazione.GetValueOrDefault()));
                _log.ErrorFormat("Data di registrazione non valida - {0} - testata:{1} - data:{2} - rata:{3}", ex, Utility.GetMethodDescription(), testata.ID, testata.DataRegistrazione.GetValueOrDefault(), rata.ID);
                throw ex;
            }

            // ------------------------------------------------
            // Crediti V/S Condomini - a Saldo
            // ------------------------------------------------
            numeroRiga++;
            var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(rata.Esercizio.ID, rata.Esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini()), rata.Importo, "A")
            {
                CondominoRiferimento = rata.Soggetto,
                Descrizione = "Richiamo Rata n. " + rata.PianoRatealeDettaglio.Progressivo + " di " + rata.Soggetto.DisplayName + " - " + rata.MotivoRichiamo
            };

            // ------------------------------------------------
            // Storno rate condominiali
            // ------------------------------------------------
            numeroRiga++;
            var movimentoPatrimonialeAttivo = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(rata.Esercizio.ID, rata.Esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRateCondomini()), rata.Importo, "D")
            {
                CondominoRiferimento = rata.Soggetto,
                Descrizione = movimentoPatrimoniale.Descrizione
            };
        }
Esempio n. 27
0
 public RataSoggettoDTO GetByDomainEntity(RataSoggetto item)
 {
     try
     {
         return setDto(item);
     }
     catch (Exception ex)
     {
         _log.ErrorFormat("Errore nel caricamento delle rate soggetto - {0} - id:{1}", ex, Utility.GetMethodDescription(), item.ID);
         throw;
     }
 }