public AuthorizationMessages SalvaPianoRateale(PianoRatealeSoggetti pianoRateale)
{
var result = GetServiceClient().SalvaPianoRateale(pianoRateale, GetUserInfo());
CloseService();
return result;
}
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 AuthorizationMessages SalvaPianoRateale(PianoRatealeSoggetti pianoRatealeSoggetti, UserInfo userinfo)
{
var retryCount = 10;
var success = false;
var windsorRep = new WindsorConfigRepository();
while (retryCount >= 0 && !success)
{
try
{
var logTransazione = windsorRep.BeginTransaction(userinfo, true, true);
var rateService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IRateService>();
rateService.SalvaPianoRateale(pianoRatealeSoggetti, logTransazione);
windsorRep.Commit(logTransazione);
success = true;
}
catch (InvalidDataException ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - TENTATIVO:{0} - {1} - azienda:{2} - number:{3}", (11 - retryCount), Utility.GetMethodDescription(), userinfo.Azienda, getExceptionId(ex), ex);
return new AuthorizationMessages(ex.Message, null);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - TENTATIVO:{0} - {1} - azienda:{2} - number:{3}", (11 - retryCount), Utility.GetMethodDescription(), userinfo.Azienda, getExceptionId(ex), ex);
windsorRep.Rollback();
if (!isRetryException(ex))
throw;
// Add delay here if you wish.
System.Threading.Thread.Sleep(1000 * (11 - retryCount));
retryCount--;
_log.InfoFormat("Esecuzione della funzione - INIZIO TENTATIVO:{0} - {1} - azienda:{2}", (11 - retryCount), Utility.GetMethodDescription(), userinfo.Azienda);
}
}
if (!success)
windsorRep.Rollback();
return new AuthorizationMessages();
}
