public SpesaInfoDTO Salva(SpesaDTO spesaDto, IDictionary<DettaglioSpesaDTO, RipartizioneSpeseDTO> listaRipartizione, bool isMultiIva)
{
try
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var movimentoContabileService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IMovimentiContabiliService>();
var ripartizioneSpeseService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IRipartizioneSpeseService>();
var protocolloService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IProtocolloService>();
var ripartizioneSpesa = new RipartizioneSpeseRepository(_info, _windsorRepository);
// ------------------------------------------------------------
// Verifico se il fornitore è presente
// ------------------------------------------------------------
var fornitore = daoFactory.GetFornitoreDao().Find(spesaDto.IdFornitore.GetValueOrDefault(), false);
if (fornitore == null)
{
return new SpesaInfoDTO { Id = 0, IdentificativoArchiviazione = null, NumeroProtocollo = 0, StampaEtichettaArchiviazione = false, Message = "Il fornitore non è più presente in archivio." };
}
// ------------------------------------------------------------
// Prima di ogni modifica recupero i movimenti secondari
// ------------------------------------------------------------
IList<MovimentoContabile> movimentiSecondari = null;
if (spesaDto.ID > 0)
{
var spesa = daoFactory.GetSpesaDao().Find(spesaDto.ID, false);
if(spesa != null)
movimentiSecondari = ripartizioneSpeseService.GetMovimentiSecondari(spesa);
}
// ------------------------------------------------------------
// Creo la ripartizione per ogni movimento
// ------------------------------------------------------------
foreach (var dettaglioDto in spesaDto.Dettagli)
{
RipartizioneSpeseDTO ripartizione = null;
var dettaglio = ripartizioneSpesa.GetDettaglioDto(listaRipartizione, dettaglioDto.NumeroRiga.GetValueOrDefault());
if (dettaglio != null)
{
if (listaRipartizione.ContainsKey(dettaglio))
ripartizione = listaRipartizione[dettaglio];
}
if (ripartizione == null || ripartizione.UnitaImmobiliari == null)
{
var oldRipartizione = ripartizione;
ripartizione = new RipartizioneSpeseDTO();
if(oldRipartizione != null)
{
ripartizione.Descrizione = oldRipartizione.Descrizione;
ripartizione.DescrizioneVoceSpesa = oldRipartizione.DescrizioneVoceSpesa;
ripartizione.NomeModello = oldRipartizione.NomeModello;
}
}
foreach (var movimentoDto in dettaglioDto.Movimenti)
{
if (movimentoDto.ID > 0)
{
var movimento = daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
if (movimento?.MovimentoStorno != null)
{
try
{
movimentoDto.IdMovimentoStorno = movimento.MovimentoStorno.ID;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella lettura dell'id del movimento di storno - {0} - spesa:{1} - movimento:{2}", ex, Utility.GetMethodDescription(), spesaDto.ID, movimento.ID);
}
finally
{
movimento.MovimentoStorno = null;
}
}
}
movimentoDto.ID = 0;
if(dettaglioDto.IdModelloRipartizione == null)
ripartizioneSpesa.GetRipartizioneByMovimento(movimentoDto, spesaDto.IdEsercizio.GetValueOrDefault(), ripartizione);
}
}
// --------------------------------
// Aggiungo le ripartizioni tra le diverse unità immobiliari
// --------------------------------
ripartizioneSpesa.AddMovimentiRipartizione(listaRipartizione, spesaDto);
// --------------------------------
// Salvataggio della spesa
// --------------------------------
if(spesaDto.StatoSpesa == StatoSpesaEnum.Undefined)
spesaDto.StatoSpesa = StatoSpesaEnum.Inserita;
var resultSpesa = ManageDomainEntity(spesaDto, isMultiIva);
if (resultSpesa.Spesa != null)
{
var spesa = resultSpesa.Spesa;
// ripartizione di default
// TODO: Dato che la ripartizione ora viene ricalcolata quando serve (stampa riparto bilancio ecc....)
// probabilmente NON è più necessaria la chiamata a questo metodo
//ripartizioneSpesa.AddDefaultRipartizione(listaRipartizione, spesa);
// --------------------------------
// Movimenti contabili secondari
// --------------------------------
// Eliminazione della vecchia testata
if (spesaDto.IdTestata > 0)
{
var testata = daoFactory.GetTestataMovimentoContabileDao().Find(spesaDto.IdTestata, false);
// bugid#4168
if(testata != null)
deleteTestata(testata, daoFactory);
}
// Creazione dei nuovi movimenti contabili
movimentoContabileService.SetMovimentiInserimentoSpesa(spesa, null, spesaDto.DataRegistrazione);
// --------------------------------
// Modello registrazione contabile
// --------------------------------
if (listaRipartizione.Count > 0)
{
foreach (var dettaglio in spesa.Dettagli)
{
var kvpRipartizione = getDettaglioDto(listaRipartizione, dettaglio.NumeroRiga.GetValueOrDefault());
if (kvpRipartizione != null)
{
var listaMovimenti = new List<MovimentoContabileDTO>(kvpRipartizione.GetValueOrDefault().Key.Movimenti.Length);
listaMovimenti.AddRange(kvpRipartizione.GetValueOrDefault().Key.Movimenti);
var modello = ripartizioneSpesa.SalvaModelloRipartizioneContabile(kvpRipartizione.GetValueOrDefault().Value, dettaglio, listaMovimenti, dettaglio.ImportoLordo.GetValueOrDefault());
if (modello != null)
{
if (kvpRipartizione.GetValueOrDefault().Value.AssociatoFornitore)
{
var modelloContabileFornitore = new ModelloContabileFornitore(spesa.FornitoreRiferimento, modello, null);
daoFactory.GetModelloContabileFornitoreDao().SaveOrUpdate(modelloContabileFornitore);
}
dettaglio.ModelloRipartizione = modello;
}
}
}
}
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Aggiorno eventuali movimenti secondari collegati.
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
if (movimentiSecondari != null)
ripartizioneSpeseService.UpdateMovimentiSecondari(spesa, movimentiSecondari);
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
// Aggiorno i documenti
// ----------------------------------------------------------------------------------------------------------------------------------------------------------------
if (spesaDto.IdDocumenti.Count > 0)
{
foreach (var idDoc in spesaDto.IdDocumenti)
{
var documento = daoFactory.GetDocumentoDao().Find(idDoc, false);
if(documento != null)
documento.SpesaRiferimento = spesa;
}
}
// ======================================================================================
// Registro gli eventuali pagamenti immediati
// ======================================================================================
var pagamentoService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IPagamentoService>();
pagamentoService.CreatePagamentiImmediati(spesa.ID, spesaDto.Scadenze, null);
// ======================================================================================
// Recupero il numero di protocollo e l'identificativo di archiviazione
// ======================================================================================
if (spesa.NumeroProtocollo == null)
{
var progressivo = protocolloService.GetProgressivo(TipoProtocollo.Fattura, spesa.EsercizioRiferimento.DataApertura.GetValueOrDefault().Year, spesa.EsercizioRiferimento.CondominioRiferimento);
if (progressivo.Progressivo != null)
{
spesa.NumeroProtocollo = progressivo.Progressivo;
spesa.AnnoArchiviazioneOttica = spesa.EsercizioRiferimento.DataApertura.GetValueOrDefault().Year;
}
else
return new SpesaInfoDTO { Id = 0, IdentificativoArchiviazione = null, NumeroProtocollo = 0, StampaEtichettaArchiviazione = false, Message = progressivo.Message };
}
var identificativoArchiviazione = getArchiviazioneOtticaService().GetIdentificativoArchiviazione(spesa);
var impostazioni = daoFactory.GetImpostazioniAziendaDao().GetByAzienda(spesa.EsercizioRiferimento.CondominioRiferimento.Azienda.ID);
if (impostazioni == null)
{
impostazioni = new ImpostazioniAzienda(daoFactory.GetAziendaDao().GetById(spesa.EsercizioRiferimento.CondominioRiferimento.Azienda.ID, false));
daoFactory.GetImpostazioniAziendaDao().SaveOrUpdate(impostazioni);
}
var stampaEtichetta = impostazioni.UtilizzoEtichettatriceArchiviazioneOtticaFatture && spesa.IsAbilitataArchiviazioneOttica && spesaDto.ID == 0;
var etichettatrice = impostazioni.EtichettatriceArchiviazioneOttica;
var tipoEtichetta = impostazioni.TipoEtichettaArchiviazioneOttica;
var trayEtichettatriceAttivazioneOttica = impostazioni.TrayEtichettatriceAttivazioneOttica;
// ======================================================================================
// Aggiorno eventuali movimenti per interessi e sanzioni pagati in ritardo
// ======================================================================================
movimentoContabileService.SetMovimentiInteressiSanzioni(spesa);
return new SpesaInfoDTO { Id = spesa.ID, NumeroProtocollo = spesa.NumeroProtocollo.GetValueOrDefault(), IdentificativoArchiviazione = identificativoArchiviazione, StampaEtichettaArchiviazione = stampaEtichetta, EtichettatriceArchiviazione = etichettatrice, TipoEtichettaArchiviazione = tipoEtichetta, TrayEtichettatriceAttivazioneOttica = trayEtichettatriceAttivazioneOttica };
}
return new SpesaInfoDTO { Id = 0, NumeroProtocollo = 0, IdentificativoArchiviazione = null, StampaEtichettaArchiviazione = false, EtichettatriceArchiviazione = string.Empty, TipoEtichettaArchiviazione = "Testo", Message = resultSpesa.Message };
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel salvataggio della spesa - {0} - numeroDocumento:{1} - dataDocumento:{2} - dataRegistrazione:{3}", ex, Utility.GetMethodDescription(), spesaDto.NumeroDocumento, spesaDto.DataDocumento, spesaDto.DataRegistrazione);
throw;
}
}
public SpesaInfoDTO SalvaMovimento(RipartizioneSpeseDTO ripartizione, MovimentoContabileDTO movimentoAvere, List<MovimentoContabileDTO> movimentiDare, int? idMovimentoBancario, UserInfo userinfo)
{
var retryCount = 5;
var success = false;
var windsorRep = new WindsorConfigRepository();
SpesaInfoDTO item = null;
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new RipartizioneSpeseRepository(userinfo, windsorRep);
item = rep.SalvaMovimento(ripartizione, movimentoAvere, movimentiDare, idMovimentoBancario);
windsorRep.Commit();
success = true;
}
catch (InvalidDataException ex)
{
windsorRep.Rollback();
return new SpesaInfoDTO { Message = ex.Message };
}
catch (Exception ex)
{
windsorRep.Rollback();
if (!isRetryException(ex))
{
_log.ErrorFormat("Errore nel salvataggio del movimento - TENTATIVO:{0} - {1} - azienda:{2} - id:{3} - number:{4}", ex, (6 - retryCount), Utility.GetMethodDescription(), userinfo.Azienda, movimentoAvere.ID, getExceptionId(ex));
return new SpesaInfoDTO
{
Id = 0,
Message = "Un altro utente ha confermato un movimento.",
StampaEtichettaArchiviazione = false,
IdentificativoArchiviazione = null,
NumeroProtocollo = 0
};
}
// Add delay here if you wish.
System.Threading.Thread.Sleep(1000 * (6 - retryCount));
retryCount--;
_log.InfoFormat("Salvataggio Movimento - INIZIO TENTATIVO:{0} - {1} - azienda:{2}", (6 - retryCount), Utility.GetMethodDescription(), userinfo.Azienda);
}
}
return !success ? new SpesaInfoDTO { Id = 0, Message = "Un altro utente ha confermato un movimento.", StampaEtichettaArchiviazione = false, IdentificativoArchiviazione = null, NumeroProtocollo = 0 } : item;
}
public RipartizioneSpeseDTO GetRipartizioneByMovimentoEsistente(MovimentoContabileDTO movimento, int idEsercizio, RipartizioneSpeseDTO ripartizione, int? idContoDetrazione, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new RipartizioneSpeseRepository(userinfo, windsorRep);
var item = rep.GetRipartizioneByMovimentoEsistente(movimento, idEsercizio, ripartizione, idContoDetrazione);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - movimento:{1} - esercizio:{2} - azienda:{3}", ex, Utility.GetMethodDescription(), movimento.ID, idEsercizio, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public RipartizioneSpeseDTO GetRipartizioneByMovimentiEsistenti(IList<MovimentoContabileDTO> movimenti, int idEsercizio, RipartizioneSpeseDTO ripartizione, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new RipartizioneSpeseRepository(userinfo, windsorRep);
var item = rep.GetRipartizioneByMovimentiEsistenti(movimenti, idEsercizio, ripartizione);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - {0} - movimenti:{1} - esercizio:{2} - azienda:{3}", ex, Utility.GetMethodDescription(), movimenti.Aggregate(string.Empty, (current, movimentoContabileDTO) => current + (movimentoContabileDTO.ID + ",")), idEsercizio, userinfo.Azienda);
windsorRep.Rollback();
throw;
}
}
public RipartizioneSpeseDTO GetRipartizioneByModello(int idEsercizio, int idTestataMovimentoContabile, int idModello, int idCausale, decimal importo, TipoMovimentoEnum tipo, UserInfo userinfo)
{
var retryCount = 10;
var success = false;
var windsorRep = new WindsorConfigRepository();
RipartizioneSpeseDTO item = null;
while (retryCount >= 0 && !success)
{
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new RipartizioneSpeseRepository(userinfo, windsorRep);
item = rep.GetRipartizioneByModello(idEsercizio, idTestataMovimentoContabile, idModello, idCausale, importo, tipo);
windsorRep.Commit();
success = true;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione della funzione - TENTATIVO:{0} - {1} - esercizio:{2} - testataMovimentoContabile:{3} - modello:{4} - causale:{5} - importo:{6} - tipo:{7} - azienda:{8} - number:{9}", ex, (11 - retryCount), Utility.GetMethodDescription(), idEsercizio, idTestataMovimentoContabile, idModello, idCausale, importo, tipo, 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 - TENTATIVO:{0} - {1} - esercizio:{2} - testataMovimentoContabile:{3} - modello:{4} - causale:{5} - importo:{6} - tipo:{7} - azienda:{8}", (11 - retryCount), Utility.GetMethodDescription(), idEsercizio, idTestataMovimentoContabile, idModello, idCausale, importo, tipo, userinfo.Azienda);
}
}
if (!success)
windsorRep.Rollback();
return item;
}
public RipartizioneSpeseDTO SetRipartoByMovimento(int idMovimento, int? idContoDetrazione, UserInfo userinfo)
{
var windsorRep = new WindsorConfigRepository();
try
{
windsorRep.BeginTransaction(userinfo);
var rep = new RipartizioneSpeseRepository(userinfo, windsorRep);
var item = rep.SetRipartoByMovimento(idMovimento, idContoDetrazione);
windsorRep.Commit();
return item;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella esecuzione del riparto per movimento - {0} - movimento:{1}", ex, Utility.GetMethodDescription(), idMovimento);
throw;
}
}
