public CondominioDTO[] GetCondomini(UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var repo = new CondominioRepository(userinfo, windsorRep);
CondominioDTO[] items = repo.GetAll();
windsorRep.Commit();
return items;
}
catch(Exception ex)
{
_log.ErrorFormat("Errore nel caricamento dei condomini - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public CondominioDTO[] GetCondominiByAzienda(UserInfo userinfo)
{
var retryCount = 10;
var success = false;
var windsorRep = new WindsorConfigRepository();
CondominioDTO[] item = null;
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var repo = new CondominioRepository(userinfo, windsorRep);
item = repo.GetAllByAzienda(userinfo.Azienda);
windsorRep.Commit();
success = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel caricamento dei condomini per azienda - TENTATIVO:{0} - {1} - azienda:{2} - number:{3}", ex, (11 - retryCount), Utility.GetMethodDescription(), userinfo.Azienda, getExceptionId(ex));
windsorRep.Rollback();
if (!isRetryException(ex))
throw;
// Add delay here if you wish.
System.Threading.Thread.Sleep(1000 * (11 - retryCount));
retryCount--;
_log.InfoFormat("Caricamento dei condomini per azienda - INIZIO TENTATIVO:{0} - {1} - azienda:{2}", (11 - retryCount), Utility.GetMethodDescription(), userinfo.Azienda);
}
}
if (!success)
windsorRep.Rollback();
return item;
}
public AuthorizationMessages AnnullamentoEmissioneRata(int idRata, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rateService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IRateService>();
var item = rateService.AnnullamentoEmissioneRata(idRata);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - rata:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), idRata, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public IList<RataSoggettoDTO> GetRateByEsercizioPersone(int? idEsercizio, IList<int> idPersone, DateTime? dataRate, bool sollecitaProprietarioConduzione, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rateService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IRateService>();
var item = rateService.GetRataByEsercizioPersone(idEsercizio, idPersone, dataRate, sollecitaProprietarioConduzione);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - esercizio:{1} - dataRate:{2} - azienda:{3}", ex, Utility.GetMethodDescription(), idEsercizio, dataRate, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public IList<RataSoggettoDTO> GetRataByPersonaUnitaImmobiliari(int idEsercizio, int idPersona, IList<int> unitaImmobiliari, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rateService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IRateService>();
var item = rateService.GetRataByPersonaUnitaImmobiliari(idEsercizio, idPersona, unitaImmobiliari);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - persona:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), idPersona, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public string GetCausaleEmissioneRate(UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new AziendaRepository(userinfo, windsorRep);
var item = rep.GetCausaleEmissioneRate(userinfo.Azienda);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public PianoRatealeDTO GetPianoRatealeByEsercizio(int idEsercizio, bool dettaglioRate, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new PianoRatealeRepository(userinfo, windsorRep);
var item = rep.GetByEsercizio(idEsercizio, dettaglioRate);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - esercizio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), idEsercizio, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public string DeleteRendiconto(int id, UserInfo userinfo)
{
var retryCount = 10;
var success = false;
var windsorRep = new WindsorConfigRepository();
string item = null;
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var bilancioService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IBilancioService>();
item = bilancioService.DeleteRendiconto(id);
windsorRep.Commit();
success = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - TENTATIVO:{0} - {1} - id:{2} - azienda:{3} - number:{4}", ex, (11 - retryCount), Utility.GetMethodDescription(), id, userinfo.Azienda, getExceptionId(ex));
windsorRep.Rollback();
if (!isRetryException(ex))
throw;
// Add delay here if you wish.
System.Threading.Thread.Sleep(1000 * (11 - retryCount));
retryCount--;
_log.InfoFormat("Set rendiconto preventivo - INIZIO TENTATIVO:{0} - {1} - id:{2} - azienda:{3}", (11 - retryCount), Utility.GetMethodDescription(), id, userinfo.Azienda);
}
}
if (!success)
windsorRep.Rollback();
return item;
}
public ControlEnableEnum IsOpenBilancioPreventivo(int idEsercizio, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var bilancioService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IBilancioService>();
var item = bilancioService.IsOpen(idEsercizio);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - esercizio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), idEsercizio, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public bool IsAllowCalcoloPreventivoDaConsuntivo(int idEsercizio, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var bilancioService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IBilancioService>();
var item = bilancioService.IsAllowCalcoloPreventivoDaConsuntivo(idEsercizio);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.Error("Errore nella esecuzione della funzione - " + Utility.GetMethodDescription() + " - azienda:" + userinfo.Azienda, ex);
windsorRep.Rollback();
throw;
}
}
public string AggiornaDescrizioneUnitaImmobiliareAzienda(bool allUnita, UserInfo userinfo)
{
var retryCount = 5;
var success = false;
var windsorRep = new WindsorConfigRepository();
var item = string.Empty;
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var repo = new UnitaImmobiliariRepository(userinfo, windsorRep);
item = repo.AggiornaDescrizioneUnitaImmobiliareAzienda(userinfo.Azienda, allUnita);
windsorRep.Commit();
success = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nell'aggiornamento della descrizione dell'unità immobiliare - TENTATIVO:{0} - {1} - allUnita:{2} - azienda:{3} - number:{4}", ex, (6 - retryCount), Utility.GetMethodDescription(), allUnita, userinfo.Azienda, getExceptionId(ex));
windsorRep.Rollback();
if (!isRetryException(ex))
throw;
// Add delay here if you wish.
System.Threading.Thread.Sleep(1000 * (6 - retryCount));
retryCount--;
_log.InfoFormat("Aggiornamento della descrizione dell'unità immobiliare - INIZIO TENTATIVO:{0} - {1} - allUnita:{2} - azienda:{3}", (6 - retryCount), Utility.GetMethodDescription(), allUnita, userinfo.Azienda);
}
}
if (!success)
windsorRep.Rollback();
return item;
}
public IEnumerable<ReportRipartizioneBilancioDTO> GetRipartizioneBilancioPreventivo(int idEsercizio, int? idStabile, int? idScala, bool ripartizioneProprietarioConduttore, bool accorpamentoUnita, TipoAccorpamentoRateEnum tipoAccorpamento, bool stampaSaldi, bool onlyCondominio, bool addebitoDirettoStabileScala, IList<int> idCondomini, UserInfo userinfo)
{
var retryCount = 10;
var success = false;
var windsorRep = new WindsorConfigRepository();
IEnumerable<ReportRipartizioneBilancioDTO> item = null;
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var bilancioService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IBilancioService>("bilancioService.ripartoaggregato");
item = bilancioService.GetDataSourceRipartizioneBilancioPreventivo(idEsercizio, idStabile, idScala, ripartizioneProprietarioConduttore, accorpamentoUnita, tipoAccorpamento, true, stampaSaldi, onlyCondominio, false, addebitoDirettoStabileScala, idCondomini, idCondomini != null && idCondomini.Count > 0);
windsorRep.Commit();
success = true;
}
catch (InvalidDataException ex)
{
windsorRep.Rollback();
return new List<ReportRipartizioneBilancioDTO>();
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - TENTATIVO:{0} - {1} - azienda:{2} - number:{3}", ex, (6 - retryCount), Utility.GetMethodDescription(), userinfo.Azienda, getExceptionId(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}", (6 - retryCount), Utility.GetMethodDescription(), userinfo.Azienda);
}
}
if (!success)
windsorRep.Rollback();
return item;
}
public IEnumerable<ReportRipartizioneBilancioDTO> GetRipartizioneDetrazione(int idCondominio, int anno, int detrazione, IList<int> idSpese, bool accorpamentoUnita, TipoAccorpamentoRateEnum tipoAccorpamento, UserInfo userinfo)
{
var retryCount = 10;
var success = false;
var windsorRep = new WindsorConfigRepository();
IEnumerable<ReportRipartizioneBilancioDTO> item = null;
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var bilancioService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IBilancioService>();
item = bilancioService.GetDataSourceRipartizioneBilancioConsuntivo(null, idCondominio, anno, detrazione, idSpese, null, null, false, accorpamentoUnita, tipoAccorpamento, true, false, false, false, null);
windsorRep.Commit();
success = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - TENTATIVO:{0} - {1} - condominio:{2} - anno:{3} - destrazione:{4} - accorpamento:{5} - azienda:{6} - number:{7}", ex, (6 - retryCount), Utility.GetMethodDescription(), idCondominio, anno, detrazione, tipoAccorpamento, userinfo.Azienda, getExceptionId(ex));
windsorRep.Rollback();
if (!isRetryException(ex))
throw;
// Add delay here if you wish.
System.Threading.Thread.Sleep(1000 * (11 - retryCount));
retryCount--;
_log.InfoFormat("Errore nella esecuzione della funzione - TENTATIVO:{0} - {1} - condominio:{2} - anno:{3} - destrazione:{4} - accorpamento:{5} - azienda:{6}", (6 - retryCount), Utility.GetMethodDescription(), idCondominio, anno, detrazione, tipoAccorpamento, userinfo.Azienda);
}
}
if (!success)
windsorRep.Rollback();
return item;
}
public IEnumerable<ReportBilancioDTO> GetBilancioConsuntivoDetrazioneMovimenti(int idCondominio, int? idStabile, int? idScala, string datiFatturaNumeroRegistrazione, int anno, int detrazione, IList<int> idSpese, bool addebitiCondominio, bool addebitiDirettiStabileScala, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var bilancioService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IBilancioService>();
var item = bilancioService.GetDataSourceBilancioConsuntivo_Movimenti(null, idCondominio, idStabile, idScala, null, null, datiFatturaNumeroRegistrazione, anno, detrazione, idSpese, false, false, false, LimitePagamenti.DataChiusura, true, addebitiCondominio, addebitiDirettiStabileScala);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - condominio:{1} - anno:{2} - detrazione:{3} - spese:{4} - azienda:{5}", ex, Utility.GetMethodDescription(), idCondominio, anno, detrazione, idSpese.Aggregate(string.Empty, (current, i) => current + (i + ", ")), userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public IEnumerable<ReportBilancioDTO> GetBilancioConsuntivoDetrazioneSottoConto(int idCondominio, int anno, int detrazione, IList<int> idSpese, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var bilancioService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IBilancioService>();
var item = bilancioService.GetDataSourceBilancioConsuntivo_SottoConto(null, idCondominio, anno, detrazione, idSpese, false, false);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - condominio:{1} - anno:{2} - detrazione:{3} - azienda:{1}", ex, Utility.GetMethodDescription(), idCondominio, anno, detrazione, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public IList<SituazioneSoggettoCondominioDTO> GetSituazioneContabileBySoggetti(int idEsercizio, IList<int> idSoggetti, DateTime dataSituazioneContabile, bool spesePersonali, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var bilancioService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IBilancioService>();
var item = bilancioService.GetSituazioneSoggettiCondominio(idEsercizio, idSoggetti, dataSituazioneContabile, spesePersonali);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - esercizio:{1} - dataSituazione:{2:d} - azienda:{3}", ex, Utility.GetMethodDescription(), idEsercizio, dataSituazioneContabile, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public ResultSituazioneCondominoContabileDTO GetSituazioneContabileCondomino(int idEsercizio, IList<int> idPersone, bool elaboraSpesePersonali, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var service = windsorRep.GetContainer(userinfo.Azienda).Resolve<IStatoPatrimonialeService>();
var item = service.GetSituazioneContabileCondomino(idEsercizio, idPersone, elaboraSpesePersonali);
windsorRep.Commit();
return new ResultSituazioneCondominoContabileDTO(item, null);
}
catch (InvalidDataException ex)
{
windsorRep.Rollback();
return new ResultSituazioneCondominoContabileDTO(null, ex.Message);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - esercizio:{1} - persone:{2} - azienda:{3}", ex, Utility.GetMethodDescription(), idEsercizio, idPersone.Aggregate(string.Empty, (current, id) => current + (id + ", ")), userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public ResultImportiDTO GetImportiBilancioPreventivoCorrente(int idEsercizio, TipoAccorpamentoRateEnum tipoAccorpamento, UserInfo userinfo)
{
var retryCount = 5;
var success = false;
var windsorRep = new WindsorConfigRepository();
IList<ImportiDTO> item = null;
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var bilancioService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IBilancioService>();
item = bilancioService.GetImportiPreventivoCorrente(idEsercizio, tipoAccorpamento);
windsorRep.Commit();
success = true;
}
catch (InvalidDataException ex)
{
return new ResultImportiDTO(null, ex.Message);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - TENTATIVO:{0} - {1} - esercizio:{2} - azienda:{3} -number:{4}", ex, (6 - retryCount), Utility.GetMethodDescription(), idEsercizio, userinfo.Azienda, getExceptionId(ex));
windsorRep.Rollback();
if (!isRetryException(ex))
throw;
// Add delay here if you wish.
System.Threading.Thread.Sleep(1000 * (6 - retryCount));
retryCount--;
_log.InfoFormat("Esecuzione della funzione - TENTATIVO:{0} - {1} - esercizio:{2} - azienda:{3}", (6 - retryCount), Utility.GetMethodDescription(), idEsercizio, userinfo.Azienda);
}
}
if (!success)
windsorRep.Rollback();
return new ResultImportiDTO(item, null);
}
public SoggettoCondominioDTO GetProprietarioPrincipale(int idUnitaImmobiliare, int idEsercizio, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new SoggettoRepository(userinfo, windsorRep);
var item = rep.GetProprietarioPrincipale(idUnitaImmobiliare, idEsercizio);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella lettura del proprietario principale - {0} - unità:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), idUnitaImmobiliare, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public decimal GetTotaleImportoBilancioPreventivoCorrente(int idEsercizio, UserInfo userinfo)
{
var retryCount = 5;
var success = false;
var windsorRep = new WindsorConfigRepository();
decimal item = 0;
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var bilancioService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IBilancioService>();
item = bilancioService.GetTotaleImportoBilancioPreventivoCorrente(idEsercizio);
windsorRep.Commit();
success = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - TENTATIVO:{0} - {1} - esercizio:{2} - azienda:{3} - number:{4}", ex, (6 - retryCount), Utility.GetMethodDescription(), idEsercizio, userinfo.Azienda, getExceptionId(ex));
windsorRep.Rollback();
if (!isRetryException(ex))
throw;
// Add delay here if you wish.
System.Threading.Thread.Sleep(1000 * (6 - retryCount));
retryCount--;
_log.InfoFormat("Esecuzione della funzione - INIZIO TENTATIVO:{0} - esercizio:{1} - azienda:{2}", (6 - retryCount), Utility.GetMethodDescription(), idEsercizio, userinfo.Azienda);
}
}
if (!success)
windsorRep.Rollback();
return item;
}
public ResultMessages<IList<DettaglioEmissioneRateDTO>> GetDettaglioEmissioneRateByEsercizio(int idEsercizio, List<int> dettagli, List<int> soggetti, bool? rateDaRichiamare, bool accorpare, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rateService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IRateService>();
var item = rateService.GetRataSoggettoDaEmettereByEsercizio(idEsercizio, dettagli, soggetti,
rateDaRichiamare, accorpare);
windsorRep.Commit();
return new ResultMessages<IList<DettaglioEmissioneRateDTO>>(item, null ,null);
}
catch (InvalidDataException ex)
{
return new ResultMessages<IList<DettaglioEmissioneRateDTO>>(null, ex.Message, null);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - esercizio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), idEsercizio, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public void SalvaBilancio(int idEsercizio, byte[] bytes, TipoRendiconto tipo, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var bilancioService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IBilancioService>();
bilancioService.SalvaBilancio(idEsercizio, bytes, tipo);
windsorRep.Commit();
}
catch (Exception ex)
{
_log.Error("Errore nella esecuzione della funzione - " + Utility.GetMethodDescription() + " - azienda:" + userinfo.Azienda, ex);
windsorRep.Rollback();
throw;
}
}
public IList<DettaglioEmissioneRateDTO> GetRateCondominiDaRichiamare(int idEsercizio, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rateService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IRateService>();
var item = rateService.GetRataSoggettoDaRichiamare(idEsercizio);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - esercizio:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), idEsercizio, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public ResultBilancioPreventivo GetPreventivoByEsercizio(int idEsercizio, int? idStabile, int? idScala, bool importiEsercizioPrecedente, UserInfo userinfo)
{
_log.DebugFormat("Esecuzione della funzione - {0} - tentativo:{1} - esercizio:{2} - azienda:{3}", Utility.GetMethodDescription(), userinfo.Tentativo, idEsercizio , userinfo.Azienda);
var retryCount = 10;
var success = false;
var windsorRep = new WindsorConfigRepository();
BilancioPreventivoDTO item = null;
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var bilancioService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IBilancioService>();
item = bilancioService.GetPreventivo(idEsercizio, idStabile, idScala, importiEsercizioPrecedente);
windsorRep.Commit();
success = true;
}
catch (InvalidDataException ex)
{
windsorRep.Rollback();
return new ResultBilancioPreventivo(null, ex.Message);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - TENTATIVO:{0} - {1} - esercizio:{2} - stabile:{3} - scala:{4} - azienda:{5} - number:{6}", ex, (11 - retryCount), Utility.GetMethodDescription(), idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), userinfo.Azienda, getExceptionId(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} - esercizio:{2} - stabile:{3} - scala:{4} - azienda:{5} - number:{6}", (11 - retryCount), Utility.GetMethodDescription(), idEsercizio, idStabile.GetValueOrDefault(), idScala.GetValueOrDefault(), userinfo.Azienda, getExceptionId(ex));
}
}
if (!success)
windsorRep.Rollback();
return new ResultBilancioPreventivo(item, null);
}
public IList<EsercizioRateVersamentiDTO> GetRateVersamentiByPersonaCondominioGroupByEserciziAttivi(int idCondominio, int idPersona, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rateService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IRateService>();
var item = rateService.GetRateVersamentiByPersonaCondominioGroupByEserciziAttivi(idCondominio, idPersona);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - persona:{1} - condominio:{2} - azienda:{3}", ex, Utility.GetMethodDescription(), idPersona, idCondominio, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public ResultBilancioPreventivo CalcolaPreventivo(int idEsercizio, int? idStabile, int? idScala, TipoRendiconto riferimentoVariazione, decimal? variazione, bool dettaglioSottoConto, bool copiaEsercizioPrecedente, bool importiEsercizioPrecedente, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var bilancioService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IBilancioService>();
var item = bilancioService.CalcolaPreventivo(idEsercizio, idStabile, idScala, riferimentoVariazione,
variazione, dettaglioSottoConto, copiaEsercizioPrecedente, importiEsercizioPrecedente);
windsorRep.Commit();
return new ResultBilancioPreventivo(item, null);
}
catch (InvalidDataException ex)
{
windsorRep.Rollback();
return new ResultBilancioPreventivo(null, ex.Message);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public AuthorizationMessages DeleteRateCondomini(IList<int> rate, bool force, UserInfo userinfo)
{
_log.InfoFormat("Esecuzione della funzione - {0} - tentativo:{1} - rate:{2} - azienda:{3}", Utility.GetMethodDescription(), userinfo.Tentativo, rate.Aggregate(string.Empty, (current, id) => current + (id.ToString(CultureInfo.InvariantCulture) + ", ")), userinfo.Azienda);
var retryCount = 10;
var success = false;
var windsorRep = new WindsorConfigRepository();
var item = new AuthorizationMessages();
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var rateService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IRateService>();
item = rateService.DeleteRate(rate, force);
windsorRep.Commit();
success = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - TENTATIVO:{0} - {1} - rate:{2} - azienda:{3} - number:{4}", ex, (11 - retryCount), Utility.GetMethodDescription(), rate.Aggregate(string.Empty, (current, id) => current + (id.ToString(CultureInfo.InvariantCulture) + ", ")), userinfo.Azienda, getExceptionId(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 esecuzione della funzione - INIZIO TENTATIVO:{0} - {1} - rate:{2} - azienda:{3}", (11 - retryCount), Utility.GetMethodDescription(), rate.Aggregate(string.Empty, (current, id) => current + (id.ToString() + ", ")), userinfo.Azienda);
}
}
if (!success)
windsorRep.Rollback();
return item;
}
public string SetRendicontoPreventivo(int idEsercizio, int? idStabile, int? idScala, BilancioPreventivoDTO bilancioPreventivo, StatoRendicontoEnum stato, bool dettaglioSottoConto, UserInfo userinfo)
{
var retryCount = 10;
var success = false;
var windsorRep = new WindsorConfigRepository();
string item = null;
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var bilancioService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IBilancioService>();
item = bilancioService.SetRendicontoPreventivo(idEsercizio, idStabile, idScala, bilancioPreventivo, stato, dettaglioSottoConto);
windsorRep.Commit();
success = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - TENTATIVO:{0} - {1} - esercizio:{2} - stabile:{3} - scala:{4} - dettaglioSottoConto:{5} - stato:{6} - azienda:{7} - number:{8}", ex, (11 - retryCount), Utility.GetMethodDescription(), idEsercizio, idStabile, idScala, dettaglioSottoConto, stato, userinfo.Azienda, getExceptionId(ex));
windsorRep.Rollback();
if (!isRetryException(ex))
throw;
// Add delay here if you wish.
System.Threading.Thread.Sleep(1000 * (11 - retryCount));
retryCount--;
_log.InfoFormat("Set rendiconto preventivo - INIZIO TENTATIVO:{0} - {1} - esercizio:{2} - stabile:{3} - scala:{4} - dettaglioSottoConto:{5} - stato:{6} - azienda:{7}", (11 - retryCount), Utility.GetMethodDescription(), idEsercizio, idStabile, idScala, dettaglioSottoConto, stato, userinfo.Azienda);
}
}
if (!success)
windsorRep.Rollback();
return item;
}
public IList<RataSoggettoDTO> GetRateByEsercizio(int idEsercizio, UserInfo userinfo)
{
var retryCount = 10;
var success = false;
var windsorRep = new WindsorConfigRepository();
IList<RataSoggettoDTO> item = null;
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var rateService = windsorRep.GetContainer(userinfo.Azienda).Resolve<IRateService>();
item = rateService.GetRataByEsercizio(idEsercizio);
windsorRep.Commit();
success = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - TENTATIVO:{0} - {1} - esercizio:{2} - azienda:{3} - number:{4}", ex, (11 - retryCount), Utility.GetMethodDescription(), idEsercizio, userinfo.Azienda, getExceptionId(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 esecuzione della funzione - INIZIO TENTATIVO:{0} - {1} - esercizio:{2} - azienda:{3}", (11 - retryCount), Utility.GetMethodDescription(), idEsercizio, userinfo.Azienda);
}
}
if (!success)
windsorRep.Rollback();
return item;
}
public RendicontoAnnualeDTO GetRendicontoById(int id, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new RendicontoAnnualeRepository(userinfo, windsorRep);
var item = rep.GetById(id);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - id:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), id, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
