public IList<ReportRipartoAcquaDTO> GetReportRipartoAcqua(int idEsercizio, UserInfo userinfo)
{
var retryCount = 10;
var success = false;
var windsorRep = new WindsorConfigRepository();
IList<ReportRipartoAcquaDTO> item = new List<ReportRipartoAcquaDTO>();
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new UtenzaRepository(userinfo, windsorRep);
item = rep.GetReportRipartoAcqua(idEsercizio);
windsorRep.Commit();
success = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la lettura del report del riparto acqua - 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("Lettura del report del riparto acqua - INIZIO TENTATIVO:{0} - {1} - esercizio:{2} - azienda:{3}", (11 - retryCount), Utility.GetMethodDescription(), idEsercizio, userinfo.Azienda);
}
}
if (!success)
windsorRep.Rollback();
return item;
}
private SpesaDTO setDto(Spesa spesa, bool includeDettagli, bool includeDettaglioMovimenti, int? anno, int? detrazione)
{
try
{
SpesaDTO dto = null;
if (spesa != null)
{
spesa.SetStato();
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
dto = new SpesaDTO
{
ID = spesa.ID,
AliquotaRitenuta = spesa.AliquotaRitenuta,
IsRitenutaCalcoloImponibile = spesa.IsRitenutaCalcoloImponibile,
AltreSpese = spesa.AltreSpese,
AltreSpeseEsenti = spesa.AltreSpeseEsenti,
SpeseEsentiRitenuta = spesa.SpeseEsentiRitenuta,
AliquotaCassaProfessionisti = spesa.AliquotaCassaProfessionisti,
CassaProfessionisti = spesa.CassaProfessionisti,
DataDocumento = spesa.DataDocumento,
DataInizioCompetenza = spesa.DataInizioCompetenza,
DataFineCompetenza = spesa.DataFineCompetenza,
IsAbilitataArchiviazioneOttica = spesa.IsAbilitataArchiviazioneOttica,
IsPrestazioneQualita = spesa.IsPrestazioneQualita,
Detrazione = spesa.Detrazione,
Contestata = spesa.Contestata,
EsclusaRendiconto = spesa.EsclusaRendiconto,
IdEsercizio = spesa.EsercizioRiferimento.ID,
DescrizioneEsercizio = spesa.EsercizioRiferimento.DisplayName,
DescrizioneCondominio = spesa.EsercizioRiferimento.CondominioRiferimento.DisplayName,
Sinistro = spesa.Sinistro > 0,
Autorizzata = spesa.Autorizzata,
EsenteRegimeMinimo = spesa.EsenteRegimeMinimo
};
if (spesa.Imponibile != 0)
dto.Imponibile = spesa.Imponibile;
dto.ImportoIva = spesa.ImportoIva;
dto.ImportoLordo = spesa.ImportoBolletta ?? spesa.ImportoLordo + spesa.AltreSpeseEsenti.GetValueOrDefault();
dto.ImportoRitenuta = spesa.ImportoRitenuta;
//if (spesa.TipoDocumento == "NOTACC")
//{
// dto.ImportoLordo = dto.ImportoLordo*-1;
// dto.ImportoRitenuta = dto.ImportoRitenuta*-1;
//}
if (spesa.FornitoreRiferimento != null)
{
dto.IdFornitore = spesa.FornitoreRiferimento.ID;
dto.DisplayFornitore = spesa.FornitoreRiferimento.DisplayName;
}
dto.ImportoNettoAPagare = dto.ImportoLordo.GetValueOrDefault() - dto.ImportoRitenuta.GetValueOrDefault();
dto.Note = spesa.Note;
dto.NumeroDocumento = spesa.NumeroDocumento;
if (!string.IsNullOrEmpty(spesa.NumeroDocumento) && spesa.DataDocumento != null && spesa.NumeroProtocollo != null)
dto.IdentificativoArchiviazioneOttica = getArchiviazioneOtticaService().GetIdentificativoArchiviazione(spesa);
dto.TipoDocumento = Decodifica.Instance.GetElement("TipoDocumentoContabile", spesa.TipoDocumento).Descrizione;
dto.IsMultiIva = spesa.IsMultiIva;
dto.StatoSpesa = spesa.Stato;
if (spesa.SpesaRiferimento != null)
{
dto.IdSpesaRiferimento = spesa.SpesaRiferimento.ID;
dto.DescrizioneSpesaRiferimento = spesa.SpesaRiferimento.ID.ToString();
if (!string.IsNullOrEmpty(spesa.SpesaRiferimento.NumeroDocumento))
dto.DescrizioneSpesaRiferimento += " - N. " + spesa.SpesaRiferimento.NumeroDocumento;
if (spesa.SpesaRiferimento.DataDocumento != null)
dto.DescrizioneSpesaRiferimento += " del " + spesa.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString();
foreach (var dettaglio in spesa.SpesaRiferimento.Dettagli)
{
dto.DescrizioneSpesaRiferimento += " - " + dettaglio.GetDescrizione();
break;
}
}
if (spesa.Utenza != null)
{
var rep = new UtenzaRepository(_info, _windsorRepository);
dto.Utenza = rep.GetDisplayName(spesa.Utenza);
}
dto.Version = spesa.Version;
DettaglioSpesa dettaglioPrincipale = null;
if (spesa.Dettagli.Count > 0)
dettaglioPrincipale = spesa.Dettagli.FirstOrDefault();
if (spesa.TipoDocumento == "BOLLETTA")
{
if (spesa.TestateMovimenti.Count > 0)
{
var testata = spesa.TestateMovimenti.FirstOrDefault();
if (testata != null)
{
dto.DisplayName = testata.GetDescrizione();
dto.IdTestata = testata.ID;
}
}
}
else
{
if (dettaglioPrincipale != null)
dto.DisplayName = dettaglioPrincipale.GetDescrizione();
}
// ------------------------------------------
// Nominativo Spesa Personale
// ------------------------------------------
// Solo per la lista (includeDettagli == false)
if (!includeDettagli)
{
var nominativoSpesaPersonale = string.Empty;
var movimentiPersonali = spesa.Dettagli.Where(item => item.Movimenti.Any(mov => mov.ContoRiferimento.IsSpesePersonali)).Select(item => item.Movimenti.ToList());
var personeElaborate = new List<string>();
foreach (var lista in movimentiPersonali)
{
foreach (var item in lista)
{
foreach (var spesaUnita in item.DettaglioRipartizione)
{
if (spesaUnita.Importo.GetValueOrDefault() != 0)
{
if (!string.IsNullOrEmpty(nominativoSpesaPersonale))
{
if (!nominativoSpesaPersonale.Contains("<br/>"))
nominativoSpesaPersonale = "<b>" + nominativoSpesaPersonale.Replace('&', 'e') + "</b><br/>";
else if (!nominativoSpesaPersonale.EndsWith("<br/>"))
nominativoSpesaPersonale += "<br/>";
}
// -------------------------------------------------
// Dettaglio riferito ad una unità immobiliare
// -------------------------------------------------
if (spesaUnita.UnitaRiferimento != null)
{
if (item.ContoRiferimento.PercentualeProprieta == 1)
{
var nominativo = spesaUnita.UnitaRiferimento.GetProprietarioPrincipale(spesa.EsercizioRiferimento.DataChiusura).DisplayName;
if (!personeElaborate.Contains(nominativo))
{
nominativoSpesaPersonale += nominativo;
personeElaborate.Add(nominativo);
}
}
else
{
var conduttore = spesaUnita.UnitaRiferimento.GetConduttorePrincipale(spesa.EsercizioRiferimento.DataChiusura);
var nominativo = conduttore != null ? conduttore.DisplayName : spesaUnita.UnitaRiferimento.GetProprietarioPrincipale(spesa.EsercizioRiferimento.DataChiusura).DisplayName;
if (!string.IsNullOrEmpty(nominativo) && !personeElaborate.Contains(nominativo))
{
nominativoSpesaPersonale += nominativo;
personeElaborate.Add(nominativo);
}
}
}
// -------------------------------------------------
// Dettaglio riferito direttamente ad un condomino
// -------------------------------------------------
if (spesaUnita.SoggettoCondominio != null)
{
var nominativo = spesaUnita.SoggettoCondominio.DisplayName;
if (!personeElaborate.Contains(nominativo))
{
nominativoSpesaPersonale += nominativo;
personeElaborate.Add(nominativo);
}
}
}
}
}
}
dto.NominativoSpesaPersonale = nominativoSpesaPersonale;
// ------------------------------------------
// Scale Addebito
// ------------------------------------------
var scaleElaborate = new List<int>();
if (spesa.TipoDocumento != "BOLLETTA")
{
var scaleAddebito = string.Empty;
var movimenti = (from item in spesa.Dettagli
where item.Movimenti.Any(mov => !string.IsNullOrEmpty(mov.GruppiAddebito))
select item.Movimenti.ToList()).ToList();
scaleAddebito = movimenti.Cast<IList<MovimentoContabile>>().Aggregate(scaleAddebito, (current, lista) => current + getScaleAddebito(lista, scaleElaborate, daoFactory));
dto.ScaleAddebito = scaleAddebito;
}
else
{
var movimenti = from item in spesa.MovimentiBollette
where !string.IsNullOrEmpty(item.GruppiAddebito)
select item;
dto.ScaleAddebito = getScaleAddebito(movimenti, scaleElaborate, daoFactory);
}
// ------------------------------------------
// Conti - Sottoconti - Dettaglio Addebito
// ------------------------------------------
var descrizioniConti = new List<string>();
var descrizioniSottoConti = new List<string>();
var dettagli = new List<string>();
if (spesa.TipoDocumento != "BOLLETTA")
{
var contiAddebito = string.Empty;
var sottoContiAddebito = string.Empty;
var dettagliAddebito = string.Empty;
var movimenti = (spesa.Dettagli.Select(item => item.Movimenti.ToList())).ToList();
foreach (IList<MovimentoContabile> lista in movimenti)
{
var descrizioni = getContiSottocontiDettagliAddebito(lista, descrizioniConti, descrizioniSottoConti, dettagli, false, detrazione != null, spesa.EsercizioRiferimento);
contiAddebito += descrizioni[0];
sottoContiAddebito += descrizioni[1];
dettagliAddebito += descrizioni[2];
}
dto.DescrizioneBilancio = contiAddebito;
dto.DescrizioneSottoconto = sottoContiAddebito;
dto.Dettaglio = dettagliAddebito;
}
else
{
var movimenti = spesa.MovimentiBollette.Select(item => item);
var descrizioni = getContiSottocontiDettagliAddebito(movimenti, descrizioniConti, descrizioniSottoConti, dettagli, false, detrazione != null, spesa.EsercizioRiferimento);
dto.DescrizioneBilancio = descrizioni[0];
dto.DescrizioneSottoconto = descrizioni[1];
dto.Dettaglio = descrizioni[2];
}
// ------------------------------------------
// Riparto personalizzato
// ------------------------------------------
dto.IsRipartoPersonalizzato = spesa.TipoDocumento == "BOLLETTA" ? spesa.IsRipartoPersonalizzato : spesa.Dettagli.Any(item => item.Movimenti.Any(item2 => item2.IsRipartoPersonalizzato));
}
// ------------------------------------------
// Dettagli
// ------------------------------------------
if (includeDettagli || includeDettaglioMovimenti)
{
var indexDettaglio = 0;
dto.Dettagli = new DettaglioSpesaDTO[spesa.Dettagli.Count];
foreach (var dettaglio in spesa.Dettagli)
{
var dettDto = setDettaglioDto(dettaglio, includeDettaglioMovimenti, detrazione != null);
dto.Dettagli[indexDettaglio] = dettDto;
indexDettaglio++;
}
// ------------------------------------------
// Scadenze
// ------------------------------------------
if (includeDettagli)
{
var indexScadenze = 0;
dto.Scadenze = new ScadenzaFatturaDTO[spesa.Scadenze.Count];
foreach (var scadenza in spesa.Scadenze)
{
var scadDto = getScadenzaRepository().GetByDomainEntity(scadenza);
dto.Scadenze[indexScadenze] = scadDto;
indexScadenze++;
}
var statoSpesa = spesa.Stato;
if (spesa.Scadenze.Any(item => item.Stato == StatoSpesaEnum.Stornata))
statoSpesa = StatoSpesaEnum.Stornata;
dto.StatoSpesa = statoSpesa;
}
}
// ------------------------------------------
// Testata Contabile
// ------------------------------------------
if (dettaglioPrincipale != null && dettaglioPrincipale.Movimenti.Count > 0)
{
var movimentoEconomico = IesiGenericCollections<MovimentoContabile>.GetByIndex(dettaglioPrincipale.Movimenti, 0);
if (movimentoEconomico != null)
{
if (movimentoEconomico.Testata != null)
dto.IdTestata = movimentoEconomico.Testata.ID;
else
{
_log.ErrorFormat("Trovato movimento economico senza testata - {0} - movimento:{1} - spesa:{2}", Utility.GetMethodDescription(), movimentoEconomico.ID, spesa.ID);
}
}
else
{
_log.WarnFormat("Trovato dettagli spesa senza movimenti associati - {0} - id:{1}", Utility.GetMethodDescription(), spesa.ID);
}
}
// ------------------------------------------
// Data Registrazione
// ------------------------------------------
if (spesa.Dettagli.Count > 0 && IesiGenericCollections<DettaglioSpesa>.GetByIndex(spesa.Dettagli, 0).Movimenti.Count > 0)
{
var dettaglio = IesiGenericCollections<DettaglioSpesa>.GetByIndex(spesa.Dettagli, 0);
var movimento = IesiGenericCollections<MovimentoContabile>.GetByIndex(dettaglio.Movimenti, 0);
if (movimento.Testata != null)
dto.DataRegistrazione = movimento.Testata.DataRegistrazione.GetValueOrDefault();
}
else if (spesa.TestateMovimenti != null)
{
var testata = spesa.TestateMovimenti.FirstOrDefault();
if(testata != null)
dto.DataRegistrazione = testata.DataRegistrazione.GetValueOrDefault();
}
// ------------------------------------------
// Importo Pagato (PER REPORT DETRAZIONI)
// ------------------------------------------
if (anno != null && detrazione != null)
{
if (spesa.Pagamenti.Any())
dto.ImportoPagato = spesa.GetImportoPagato(anno.GetValueOrDefault(), detrazione.GetValueOrDefault());
// Se non sono presenti pagamenti ma solo riscossioni (nota accredito) deve essere considerato l'intero importo bugid#6618
else if (spesa.Riscossioni.Count > 0)
{
dto.ImportoPagato = spesa.ImportoLordo;
}
}
}
return dto;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione dell'istanza DTO per una spesa - {0} - id:{1}", ex, Utility.GetMethodDescription(), spesa.ID);
throw;
}
}
public string SetRipartoBolletta(int idBolletta, int? idContoMillesimiSpalo, DateTime dataRegistrazione, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new UtenzaRepository(userinfo, windsorRep);
var item = rep.SetRipartoBolletta(idBolletta, idContoMillesimiSpalo, dataRegistrazione);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il riparto di una bolletta - {0} - bolletta:{1} - dataRegistrazione:{2} - azienda:{3}", ex, Utility.GetMethodDescription(), idBolletta, dataRegistrazione, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public AuthorizationMessages RipartoBollette(int idEsercizio, int idTipoUtenza, int? idContoAcquaRiscaldata, int? idContoRiscaldamento, int? idContoMillesimiSpalo, string descrizioneMovimentoAcqua, string descrizioneMovimentoRiscaldamento, decimal? tariffaRiscaldamentoAcqua, decimal? tariffaAcquaFredda, IList<ParametriAddebitoMovimento> parametriAddebitoMovimenti, DateTime? dataRegistrazione, UserInfo userinfo)
{
var retryCount = 10;
var success = false;
var windsorRep = new WindsorConfigRepository();
var item = new AuthorizationMessages();
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new UtenzaRepository(userinfo, windsorRep);
item = rep.RipartoBollette(idEsercizio, idTipoUtenza, idContoAcquaRiscaldata, idContoRiscaldamento, idContoMillesimiSpalo, descrizioneMovimentoAcqua, descrizioneMovimentoRiscaldamento, tariffaRiscaldamentoAcqua, tariffaAcquaFredda, parametriAddebitoMovimenti, dataRegistrazione);
windsorRep.Commit();
success = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il riparto di una bolletta - TENTATIVO:{0} - {1} - esercizio:{2} - tipoUtenza:{3} - azienda:{4} - number:{5}", ex, (11 - retryCount), Utility.GetMethodDescription(), idEsercizio, idTipoUtenza, 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("Riparto di una bolletta - INIZIO TENTATIVO:{0} - {1} - esercizio:{2} - tipoUtenza:{3} - azienda:{4}", (11 - retryCount), Utility.GetMethodDescription(), idEsercizio, userinfo.Azienda);
}
}
if (!success)
windsorRep.Rollback();
return item;
}
public BollettaDTO GetBollettaById(int id, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new UtenzaRepository(userinfo, windsorRep);
var item = rep.GetBollettaById(id);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante il recupero di una bolletta - {0} - id:{1}", ex, Utility.GetMethodDescription(), id);
windsorRep.Rollback();
throw;
}
}
public BollettaDTO GetBollettaByNumeroDataFattura(string numeroFattura, DateTime dataFattura, int idFornitore, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new UtenzaRepository(userinfo, windsorRep);
var item = rep.GetBollettaByNumeroDataFattura(numeroFattura, dataFattura, idFornitore, userinfo.Azienda);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante il recupero di una bolletta - {0} - numeroFattura:{1} - dataFattura:{2} - idFornitore:{3} - azienda:{4}", ex, Utility.GetMethodDescription(), numeroFattura, dataFattura, idFornitore, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public IList<TipoUtenzaDTO> GetTipoUtenzaByAzienda(UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new UtenzaRepository(userinfo, windsorRep);
var item = rep.GetTipoAllByAzienda(userinfo.Azienda);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.Error("Errore durante la lettura dei tipi utenze - " + Utility.GetMethodDescription() + " - idAzienda:" + userinfo.Azienda.ToString(), ex);
windsorRep.Rollback();
throw;
}
}
public string DeleteUtenza(int idUtenza, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var service = windsorRep.GetContainer(userinfo.Azienda).Resolve<IUtenzaService>();
var message = service.IsAllowDeleteUtenza(idUtenza);
if (string.IsNullOrEmpty(message))
{
var rep = new UtenzaRepository(userinfo, windsorRep);
var result = rep.Delete(idUtenza);
if (!result)
message = "Non è stato possibile eliminare l'utenza.";
}
windsorRep.Commit();
return message;
}
catch (Exception ex)
{
_log.Error("Errore durante la eliminazione di una utenza - " + Utility.GetMethodDescription() + " - idUtenza:" + idUtenza.ToString(), ex);
windsorRep.Rollback();
throw;
}
}
public int? SalvaUtenza(UtenzaDTO utenza, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new UtenzaRepository(userinfo, windsorRep);
var item = rep.ManageDomainEntity(utenza);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.Error("Errore durante l'aggiornamento di una utenza - " + Utility.GetMethodDescription() + " - idCondominio:" + utenza.CodiceCondominio.ToString() + " - idFornitore:" + utenza.CodiceFornitore.ToString() + " - idUtenza:" + utenza.ID.ToString(), ex);
windsorRep.Rollback();
throw;
}
}
public IList<UtenzaDTO> GetUtenzeAttiveByCondominio(int idCondominio, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new UtenzaRepository(userinfo, windsorRep);
var item = rep.GetAttiveByCondominio(idCondominio);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.Error("Errore durante la lettura delle utenze - " + Utility.GetMethodDescription() + " - idCondominio:" + idCondominio.ToString(), ex);
windsorRep.Rollback();
throw;
}
}
public IList<UtenzaDTO> GetUtenzeRipartoLettureByCondominio(int idCondominio, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new UtenzaRepository(userinfo, windsorRep);
var item = rep.GetRipartoLettureByCondominio(idCondominio);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante la lettura delle utenze con riparto tramite letture - {0} - idCondominio", ex, Utility.GetMethodDescription(), idCondominio.ToString(), ex);
windsorRep.Rollback();
throw;
}
}
public IList<UtenzaDTO> GetUtenzeAttiveByAzienda(UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new UtenzaRepository(userinfo, windsorRep);
var item = rep.GetAttiveByAzienda(userinfo.Azienda);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante la lettura delle utenze attive - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public UtenzaDTO GetUtenzaById(int id, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new UtenzaRepository(userinfo, windsorRep);
var item = rep.GetById(id);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante la lettura della utenza - {0} - id:{1} - azienda:{2}", ex, Utility.GetMethodDescription(), id, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
