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 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 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 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 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);
}