/// <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);
}
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;
}
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;
}
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;
}
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;
}
}
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;
}
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;
}
}
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;
}
}
// 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;
}
}
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;
}
}
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;
}
}
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;
}
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;
}
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;
}
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;
}
}
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;
}
}
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);
}
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;
}
}
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;
}
}
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);
}
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;
}
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;
}
}
public TestataMovimentoContabile SetMovimentiSingolaRata(RataSoggetto rata, TestataMovimentoContabile testata, DateTime dataRegistrazione)
{
return null;
return SetMovimentiSingolaRata(rata, rata.Importo, rata.Soggetto, rata.Esercizio, testata, dataRegistrazione);
}
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;
}
}
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
};
}
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;
}
}