public AuthorizationMessages SalvaModello(ModelloListaRegistrazioneContabileDTO dto, bool ricalcoloSpeseEsistenti, int idUtente, LogTransazione logTransazione)
{
try
{
var logTransazioneModello = logTransazione;
var logTransazioneDettaglioModello = logTransazione;
var logTransazioneFornitoreModello = logTransazione;
var logTransazioneContoModello = logTransazione;
var fatalMessage = string.Empty;
var warnMessage = string.Empty;
ModelloRegistrazioneContabile modello = null;
if (dto.ID == 0)
{
var condominio = _daoFactory.GetCondominioDao().Find(dto.IdCondominio, false);
if (condominio != null)
{
var descrizione = string.Empty;
if (!string.IsNullOrEmpty(dto.Descrizione))
{
descrizione = dto.Descrizione;
if (descrizione.Length > 100)
descrizione = descrizione.Substring(0, 100);
}
var voceFattura = string.Empty;
if (!string.IsNullOrEmpty(dto.DescrizioneVoceFattura))
{
voceFattura = dto.DescrizioneVoceFattura;
if (voceFattura.Length > 512)
voceFattura = voceFattura.Substring(0, 512);
}
modello = new ModelloRegistrazioneContabile(condominio, descrizione, logTransazioneModello) { DescrizioneVoceFattura = voceFattura };
if (logTransazioneModello != null)
{
_daoFactory.GetModelloRegistrazioneContabileDao().SaveOrUpdate(modello);
logTransazioneContoModello = null;
logTransazioneDettaglioModello = null;
logTransazioneFornitoreModello = null;
}
}
}
else
{
modello = _daoFactory.GetModelloRegistrazioneContabileDao().Find(dto.ID, false);
if(modello != null)
modello.Descrizione = dto.Descrizione;
}
if (modello != null)
{
modello.DescrizioneVoceFattura = dto.DescrizioneVoceFattura;
// --------------------------
// Fornitori
// --------------------------
modello.Fornitori.Clear();
foreach (var dtoFornitore in dto.Fornitori)
{
ModelloContabileFornitore modelloFornitore = null;
if (dtoFornitore.ID == 0)
{
if (dtoFornitore.IdFornitore > 0)
{
var fornitore = _daoFactory.GetFornitoreDao().Find(dtoFornitore.IdFornitore, false);
if (fornitore != null)
{
modelloFornitore = new ModelloContabileFornitore(fornitore, modello, logTransazioneFornitoreModello);
if(logTransazioneFornitoreModello != null)
_daoFactory.GetModelloContabileFornitoreDao().SaveOrUpdate(modelloFornitore);
}
else
{
_log.WarnFormat("Fornitore inesistente - {0} - fornitore:{1}", Library.Utility.GetMethodDescription(), dtoFornitore.IdFornitore);
}
}
else
{
_log.WarnFormat("Fornitore non definito - {0}", Library.Utility.GetMethodDescription());
}
}
else
{
modelloFornitore = _daoFactory.GetModelloContabileFornitoreDao().Find(dtoFornitore.ID, false);
if (modelloFornitore != null)
modelloFornitore.Fornitore = _daoFactory.GetFornitoreDao().GetById(dtoFornitore.IdFornitore, false);
else
{
_log.WarnFormat("Modello inesistente - {0} - IdModello:{1}", Library.Utility.GetMethodDescription(), dtoFornitore.IdModello);
}
}
if (modelloFornitore != null)
modello.Fornitori.Add(modelloFornitore);
}
// --------------------------
// Conti
// --------------------------
modello.Conti.Clear();
foreach (var dtoConto in dto.Conti)
{
var conto = _daoFactory.GetContoDao().Find(dtoConto.IdConto, false);
var sottoConto = _daoFactory.GetSottoContoDao().Find(dtoConto.IdSottoConto, false);
var modelloConto = _daoFactory.GetContiModelloRegistrazioneContabileDao().Find(dtoConto.ID, false);
if (modelloConto == null)
{
modelloConto = new ContiModelloRegistrazioneContabile(modello, conto, sottoConto, dtoConto.PercentualeRipartizione, logTransazioneContoModello);
if (logTransazioneContoModello != null)
{
_daoFactory.GetContiModelloRegistrazioneContabileDao().SaveOrUpdate(modelloConto);
logTransazioneDettaglioModello = null;
}
}
else
{
modelloConto.PercentualeRipartizione = dtoConto.PercentualeRipartizione;
if (conto != null)
modelloConto.ContoRiferimento = conto;
if (sottoConto != null)
modelloConto.SottoContoRiferimento = sottoConto;
}
// --------------------------
// Riparto
// --------------------------
modelloConto.Unita.Clear();
foreach (var dtoRiparto in dtoConto.Riparto)
{
var modelloRiparto = _daoFactory.GetDettaglioModelloRegistrazioneContabileDao().Find(dtoRiparto.ID, false);
if (modelloRiparto == null)
{
modelloRiparto = new DettaglioModelloRegistrazioneContabile(modelloConto, logTransazioneDettaglioModello);
if(logTransazioneDettaglioModello != null)
_daoFactory.GetDettaglioModelloRegistrazioneContabileDao().SaveOrUpdate(modelloRiparto);
}
// Lotto
modelloRiparto.LottoRiferimento = dtoRiparto.IdLotto > 0 ? _daoFactory.GetLottoDao().GetById(dtoRiparto.IdLotto.Value, false) : null;
// Stabile
modelloRiparto.PalazzinaRiferimento = dtoRiparto.IdStabile > 0 ? _daoFactory.GetPalazzinaDao().GetById(dtoRiparto.IdStabile.Value, false) : null;
// Gruppo Stabile
modelloRiparto.GruppoStabileRiferimento = dtoRiparto.IdGruppoStabile > 0 ? _daoFactory.GetGruppoStabileDao().GetById(dtoRiparto.IdGruppoStabile.Value, false) : null;
// Unità Immobiliare
modelloRiparto.UnitaRiferimento = dtoRiparto.IdUnita > 0 ? _daoFactory.GetUnitaImmobiliareDao().GetById(dtoRiparto.IdUnita.Value, false) : null;
modelloConto.Unita.Add(modelloRiparto);
}
modello.Conti.Add(modelloConto);
}
if (ricalcoloSpeseEsistenti)
{
var authMessage = ReloadRipartizioneByModelloEsercizio(modello.ID, null, null, idUtente, logTransazione);
if (!string.IsNullOrEmpty(authMessage.FatalMessage))
fatalMessage += authMessage.FatalMessage + Environment.NewLine;
if (!string.IsNullOrEmpty(authMessage.WarnMessage))
warnMessage += authMessage.WarnMessage + Environment.NewLine;
}
return new AuthorizationMessages(fatalMessage, warnMessage) {Id = modello.ID};
}
return new AuthorizationMessages(fatalMessage, warnMessage);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il salvataggio del modello contabile - {0} - modello:{1} - condominio:{2}", ex, Library.Utility.GetMethodDescription(), dto.ID, dto.IdCondominio);
throw;
}
}
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 string SetModelloContabileFornitore(int idModello, int idFornitore)
{
string message = string.Empty;
if (idFornitore > 0 && idModello > 0)
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var modello = daoFactory.GetModelloRegistrazioneContabileDao().GetById(idModello, false);
var modelloFornitore = daoFactory.GetModelloContabileFornitoreDao().GetByFornitoreCondominio(idFornitore, modello.CondominioRiferimento.ID);
if (modelloFornitore == null)
{
modelloFornitore = new ModelloContabileFornitore(daoFactory.GetFornitoreDao().GetById(idFornitore, false), modello, null);
daoFactory.GetModelloContabileFornitoreDao().SaveOrUpdate(modelloFornitore);
}
}
else
{
message = idFornitore == 0 ? "Non è definito il fornitore" : "Non è definito il modello";
_log.ErrorFormat("{0}:{1}", message, Utility.GetMethodDescription());
}
return message;
}
