public int ManageDomainEntity(SpeseUnitaDTO spesaDto)
{
try
{
if (spesaDto != null)
{
var spesa = manageSpesa(spesaDto);
return spesa != null ? spesa.ID : 0;
}
return 0;
}
catch (Exception ex)
{
var idStr = string.Empty;
if (spesaDto != null)
idStr = spesaDto.ID.ToString();
_log.Error("Errore nella gestione dei riparti delle unità - " + Library.Utility.GetMethodDescription() + " - id:" + idStr, ex);
throw;
}
}
private MovimentoContabileDTO setDto(MovimentoContabile item, bool includeDettaglioMovimenti, bool isEconomici, bool detrazione = false)
{
if (item != null)
{
if (item.ContoRiferimento == null)
{
_log.ErrorFormat("Non trovato conto per movimento contabile - {0} - movimento:{1}", Utility.GetMethodDescription(), item.ID);
return new MovimentoContabileDTO();
}
try
{
var daoFactory = _windsorConfigRepository.GetContainer(_info.Azienda).Resolve<IDaoFactory>();
var dto = new MovimentoContabileDTO
{
ID = item.ID,
Causale = getContabilitaRepostory().GetCausaleByDomainEntity(item.Causale),
Note = item.Note,
NumeroRiga = item.NumeroRiga,
NumeroRegistrazione = item.NumeroRegistrazione,
NumeroAssegno = item.NumeroAssegno,
Importo = item.GetImportoPerSpesa(isEconomici),
Segno = item.Segno,
PercentualeProprieta = item.PercentualeProprieta,
Descrizione = item.Descrizione,
IsRipartoPersonalizzato = item.IsRipartoPersonalizzato,
IdConto = item.ContoRiferimento.ID
};
if (item.SottoContoRiferimento != null)
dto.IdSottoConto = item.SottoContoRiferimento.ID;
else if (item.ContoCorrenteBancario != null)
dto.IdSottoConto = item.ContoCorrenteBancario.ID * -1;
if (item.Testata != null)
dto.IdTestata = item.Testata.ID;
else
_log.ErrorFormat("Trovato movimento contabile senza testata associata {0} - id:{1}", Utility.GetMethodDescription(), item.ID);
var speseUnita = new SpeseUnitaDTO[0];
if (includeDettaglioMovimenti)
{
speseUnita = new SpeseUnitaDTO[item.DettaglioRipartizione.Count];
var index = 0;
foreach (var spesa in item.DettaglioRipartizione)
{
speseUnita[index] = getSpeseUnitaRepository().GetByDomainEntity(spesa);
index++;
}
}
dto.DettaglioRipartizione = speseUnita;
if (item.FornitoreRiferimento != null)
dto.IdFornitore = item.FornitoreRiferimento.ID;
if (item.CondominoRiferimento != null)
dto.IdCondomino = item.CondominoRiferimento.ID;
// --------------------------
// Scale addebito
// --------------------------
if (!string.IsNullOrEmpty(item.GruppiAddebito))
{
var scaleAddebito = string.Empty;
var scale = item.GruppiAddebito.Split('&');
foreach (var idScala in scale)
{
try
{
var scala = daoFactory.GetGruppoStabileDao().Find(int.Parse(idScala), false);
if (scala != null)
{
if (!string.IsNullOrEmpty(scaleAddebito))
{
if (!scaleAddebito.Contains("<br/>"))
scaleAddebito = "<b>" + scaleAddebito + "</b><br/>";
else
scaleAddebito += "<br/>";
}
scaleAddebito += scala.Descrizione;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo dell'addebito scale - SINGOLA SCALA - {0} - scala:{1}", ex, Utility.GetMethodDescription(), idScala);
throw;
}
}
dto.Scale = scaleAddebito;
}
// --------------------------
// Stabili addebito
// --------------------------
if (!string.IsNullOrEmpty(item.StabiliAddebito))
{
var stabiliAddebito = string.Empty;
var stabili = item.StabiliAddebito.Split('&');
foreach (var idStabile in stabili)
{
try
{
var scala = daoFactory.GetPalazzinaDao().Find(int.Parse(idStabile), false);
if (scala != null)
{
if (!string.IsNullOrEmpty(stabiliAddebito))
{
if (!stabiliAddebito.Contains("<br/>"))
stabiliAddebito = "<b>" + stabiliAddebito + "</b><br/>";
else
stabiliAddebito += "<br/>";
}
stabiliAddebito += scala.Descrizione;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo dell'addebito stabili - SINGOLO STABILE - {0} - stabile:{1}", ex, Utility.GetMethodDescription(), idStabile);
throw;
}
}
dto.Stabili = stabiliAddebito;
}
// ---------------------------------------------
// Nominativo Spesa Personale
// ---------------------------------------------
var nominativoSpesaPersonale = string.Empty;
var personeElaborate = new List<string>();
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)
{
Spesa spesa = null;
if (item.DettaglioRiferimento != null && item.DettaglioRiferimento.SpesaRiferimento != null)
spesa = item.DettaglioRiferimento.SpesaRiferimento;
if (spesa != 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;
return dto;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel caricamento del Movimento Contabile - {0} - id:{1}", ex, Utility.GetMethodDescription(), item != null ? item.ID.ToString(CultureInfo.InvariantCulture) : "<NULL>");
throw;
}
}
return new MovimentoContabileDTO();
}
private bool insert(SpeseUnitaDTO spesaDto, out SpeseUnita spesa)
{
bool result;
spesa = null;
try
{
if (_movimento != null)
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
UnitaImmobiliare unitaImmobiliare = null;
if (spesaDto.IdUnitaRiferimento != null)
unitaImmobiliare = daoFactory.GetUnitaImmobiliareDao().Find(spesaDto.IdUnitaRiferimento.GetValueOrDefault(), false);
SoggettoCondominio soggettoCondominio = null;
if (spesaDto.IdSoggetto != null)
soggettoCondominio = daoFactory.GetSoggettoCondominioDao().Find(spesaDto.IdSoggetto.GetValueOrDefault(), false);
spesa = new SpeseUnita(spesaDto.Importo, unitaImmobiliare, soggettoCondominio, _movimento);
daoFactory.GetSpeseUnitaDao().SaveOrUpdate(spesa);
}
result = true;
}
catch (Exception ex)
{
_log.Error("Errore nell'inserimento del riparto delle unità - " + Library.Utility.GetMethodDescription(), ex);
result = false;
}
return result;
}
private SpeseUnita manageSpesa(SpeseUnitaDTO spesaDto)
{
SpeseUnita spesa = null;
bool result;
// Controllo sullo stato U, D, I
switch (spesaDto.Stato.ToUpper())
{
case "U":
result = update(spesaDto, out spesa);
if (!result)
throw new Exception("Il dato sul database è più recente di quello utilizzato");
break;
case "I":
result = insert(spesaDto, out spesa);
if (!result)
throw new Exception("Impossibile scrivere sul database");
break;
case "D":
result = delete(spesaDto);
if (!result)
throw new Exception("Il dato sul database è più recente di quello utilizzato");
break;
}
return spesa;
}
private bool delete(SpeseUnitaDTO spesaDto)
{
bool result = false;
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
try
{
var spesa = daoFactory.GetSpeseUnitaDao().GetById(spesaDto.ID, false);
// Condizione necessare per il controllo del fatto che sul DB ho una versione uguale o più vecchia
if (spesaDto.Version <= spesa.Version)
{
daoFactory.GetSpeseUnitaDao().Delete(spesa);
result = true;
}
else
{
// Eccezione: Sul db c'è qualche cosa di più nuovo.
_log.Error("Errore nel salvataggio del riparto delle unità id:" + spesaDto.ID + " - il dato sul db è più recente di quello che si vuole salvare");
}
}
catch (Exception ex)
{
_log.Error("Errore nel salvataggio del riparto delle unità - " + Library.Utility.GetMethodDescription() + " - id:" + spesaDto.ID, ex);
throw;
}
return result;
}
private bool update(SpeseUnitaDTO spesaDto, out SpeseUnita spesa)
{
var result = false;
spesa = null;
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
try
{
spesa = daoFactory.GetSpeseUnitaDao().GetById(spesaDto.ID, false);
// Condizione necessaria per il controllo del fatto che sul DB ho una versione uguale o più vecchia
if (spesaDto.Version == spesa.Version)
{
spesa.Importo = spesaDto.Importo;
spesa.MovimentoRiferimento = daoFactory.GetMovimentoContabileDao().GetById(spesaDto.IdMovimentoRiferimento, false);
if(spesaDto.IdUnitaRiferimento != null)
spesa.UnitaRiferimento = daoFactory.GetUnitaImmobiliareDao().GetById(spesaDto.IdUnitaRiferimento.GetValueOrDefault(), false);
if (spesaDto.IdSoggetto != null)
spesa.SoggettoCondominio = daoFactory.GetSoggettoCondominioDao().GetById(spesaDto.IdSoggetto.GetValueOrDefault(), false);
result = true;
}
else
{
// Eccezione: Sul db c'è qualche cosa di più nuovo.
_log.Error("Errore nel salvataggio della gestione dei riparti delle unità id:" + spesaDto.ID.ToString() + " - il dato sul db è più recente di quello che si vuole salvare");
}
}
catch (Exception ex)
{
_log.Error("Errore nel salvataggio della gestione dei riparti delle unità - " + Library.Utility.GetMethodDescription() + " - id:" + spesaDto.ID.ToString(), ex);
throw;
}
return result;
}
private SpeseUnitaDTO setSpeseUnitaDto(SpeseUnita spesa)
{
try
{
var dto = new SpeseUnitaDTO
{
ID = spesa.ID,
Importo = spesa.Importo,
IdMovimentoRiferimento = spesa.MovimentoRiferimento.ID,
};
if (spesa.UnitaRiferimento != null)
{
dto.IdUnitaRiferimento = spesa.UnitaRiferimento.ID;
dto.DescrizioneUnitaRiferimento = spesa.UnitaRiferimento.Descrizione;
}
if (spesa.SoggettoCondominio != null)
{
dto.IdSoggetto = spesa.SoggettoCondominio.ID;
dto.DescrizioneUnitaRiferimento = spesa.SoggettoCondominio.DisplayName;
}
return dto;
}
catch (Exception ex)
{
if (spesa != null)
{
_log.Error("Errore nel caricamento del riparto spese per unità - " + Library.Utility.GetMethodDescription() + " - id:" + spesa.ID, ex);
}
else
{
_log.Error("Errore nel caricamento del riparto spese per unità - " + Library.Utility.GetMethodDescription() + " - Spesa --> null", ex);
}
throw;
}
}
public SpesaInfoDTO SalvaMovimento(RipartizioneSpeseDTO ripartizione, MovimentoContabileDTO movimentoAvere, List<MovimentoContabileDTO> movimentiDare, int? idMovimentoBancario)
{
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 archiviazioneService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IArchiviazioneOtticaService>();
var persistenceContextService = _windsorRepository.GetContainer(_info.Azienda).Resolve<Data.IPersistenceContext>();
var index = 0;
movimentoAvere.NumeroRiga = index+1;
movimentoAvere.Descrizione = ripartizione.Descrizione;
if (movimentoAvere.Importo > 0)
movimentoAvere.Segno = "A";
else
{
movimentoAvere.Segno = "D";
movimentoAvere.Importo = movimentoAvere.Importo * -1;
}
int? idEsercizio = null;
try
{
var esercizio = daoFactory.GetEsercizioDao().GetById(ripartizione.Testata.IdEsercizio.GetValueOrDefault(), true);
if (esercizio.Stato == StatoEsercizioEnum.Aperto)
{
idEsercizio = esercizio.ID;
var numeroRegistrazione = esercizio.ProgressivoRegistrazioneContabile;
ripartizione.Testata.Movimenti = new MovimentoContabileDTO[movimentiDare.Count + 1];
ripartizione.Testata.Movimenti[0] = movimentoAvere;
numeroRegistrazione++;
movimentoAvere.NumeroRegistrazione = numeroRegistrazione;
// Salvo eventuali valori del movimento patrimoniale originale
if(movimentoAvere.ID > 0)
{
var movimento = daoFactory.GetMovimentoContabileDao().Find(movimentoAvere.ID, false);
if (movimento?.EvasioneBancaria != null)
movimentoAvere.IdEvasione = movimento.EvasioneBancaria.ID;
}
if (!(ripartizione.Testata.IdModelloRipartizione > 0))
{
foreach (var movimentoEconomico in movimentiDare)
{
index++;
numeroRegistrazione++;
if (movimentoEconomico.Importo < 0)
{
movimentoEconomico.Importo = movimentoEconomico.Importo*-1;
movimentoEconomico.Segno = "A";
}
else
movimentoEconomico.Segno = "D";
movimentoEconomico.IsMovimentoEconomico = true;
movimentoEconomico.NumeroRegistrazione = numeroRegistrazione;
movimentoEconomico.Causale = movimentoAvere.Causale;
movimentoEconomico.IdFornitore = movimentoAvere.IdFornitore;
if (string.IsNullOrEmpty(movimentoEconomico.Descrizione) && !esercizio.CondominioRiferimento.DescrizioneSpeseAutomatica)
movimentoEconomico.Descrizione = ripartizione.Descrizione;
movimentoEconomico.IdTestata = ripartizione.Testata.ID;
ripartizione.Testata.Movimenti[index] = movimentoEconomico;
// ---------------------------------------------------------------------
// Aggiorno addebiti per lotto, stabile o scala
// ---------------------------------------------------------------------
var spesePersonali = false;
if (movimentoEconomico.ID > 0)
{
var movimento = daoFactory.GetMovimentoContabileDao().Find(movimentoEconomico.ID, false);
if (movimento != null)
{
movimentoEconomico.LottiAddebito = movimento.LottiAddebito;
movimentoEconomico.StabiliAddebito = movimento.StabiliAddebito;
movimentoEconomico.GruppiAddebito = movimento.GruppiAddebito;
spesePersonali = movimento.ContoRiferimento.IsSpesePersonali;
}
}
// ---------------------------------------------------------------------
// Verifico se è stata eseguita una ripartizione personalizzata
// ---------------------------------------------------------------------
var key = ripartizioneSpeseService.GetKey(movimentoEconomico);
movimentoEconomico.IsRipartoPersonalizzato = false;
// Lasciare la valorizzazione di NumeroRiga DOPO il GetKey altrimenti la chiave NON viene trovata per i movimenti con più di 1 conto economico
movimentoEconomico.NumeroRiga = index + 1;
if (ripartizione.UnitaImmobiliari != null && ripartizione.UnitaImmobiliari.ContainsKey(key))
{
movimentoEconomico.LottiAddebito = getLottiAddebito(ripartizione, key);
movimentoEconomico.StabiliAddebito = getStabiliAddebito(ripartizione, key);
movimentoEconomico.GruppiAddebito = getGruppiAddebito(ripartizione, key);
var unita = ripartizione.UnitaImmobiliari[key];
var isPersonalizzato = unita.Count(item => item.Selezionato) < unita.Length;
// Considero il movimento come ripartito personalmente se non sono presenti specifici riparti per lotto, stabile o scala e non si tratta di un conto di spese personali
if (isPersonalizzato && !spesePersonali && string.IsNullOrEmpty(movimentoEconomico.LottiAddebito) && string.IsNullOrEmpty(movimentoEconomico.StabiliAddebito) && string.IsNullOrEmpty(movimentoEconomico.GruppiAddebito))
movimentoEconomico.IsRipartoPersonalizzato = true;
var conto = daoFactory.GetContoDao().GetById(movimentoEconomico.IdConto.Value, false);
if (conto.IsSpesePersonali || movimentoEconomico.IsRipartoPersonalizzato)
{
movimentoEconomico.DettaglioRipartizione = new SpeseUnitaDTO[unita.Length];
// -----------------------------------------------------------
// Per le unità ricalcolo gli importi
// -----------------------------------------------------------
var instanceModificata = getInstanceModificata(ripartizione, key);
if (!string.IsNullOrEmpty(instanceModificata) && instanceModificata != "U")
GetRipartizioneByMovimento(movimentoEconomico, esercizio.ID, ripartizione);
else
{
movimentoEconomico.DettaglioRipartizione = new SpeseUnitaDTO[movimentoEconomico.DettaglioRipartizione.Length];
var unitaSelected = ripartizione.UnitaImmobiliari[key];
for (var i = 0; i < unitaSelected.Length; i++)
{
if (unitaSelected[i].Selezionato)
{
var spesaUnitaDto = new SpeseUnitaDTO { ID = 0, IdMovimentoRiferimento = movimentoEconomico.ID, Importo = unitaSelected[i].Importo };
if (unitaSelected[i].IdSoggettoCondominio > 0)
spesaUnitaDto.IdSoggetto = unitaSelected[i].IdSoggettoCondominio;
else
spesaUnitaDto.IdUnitaRiferimento = unitaSelected[i].ID;
movimentoEconomico.DettaglioRipartizione[i] = spesaUnitaDto;
}
}
}
}
}
}
}
// -------------------------------------------
// Elimino vecchia testata
// -------------------------------------------
int? oldProtocollo = null;
int? oldAnnoArchiviazione = null;
var oldTipoTestata = TipoTestataMovimentoContabileEnum.Undefined;
AddebitoCompetenza addebito = null;
var testataOld = daoFactory.GetTestataMovimentoContabileDao().Find(ripartizione.Testata.ID, false);
if (testataOld != null)
{
if (testataOld.AddebitoCompetenze.Count > 0)
addebito = Library.IesiGenericCollections<AddebitoCompetenza>.GetByIndex(testataOld.AddebitoCompetenze, 0);
oldProtocollo = testataOld.NumeroProtocollo;
oldAnnoArchiviazione = testataOld.AnnoArchiviazioneOttica;
testataOld.EsercizioRiferimento = null;
// ------------------------------------------------------------------------
// Nel caso si tratti di un movimento generato automaticamente dalla procedura solleciti
// elimino la relazione tra sollecito e movimento contabile.
// Solo per le vecchie versioni di addebito competenze solleciti
// ------------------------------------------------------------------------
if (testataOld.Tipo == TipoTestataMovimentoContabileEnum.Automatica)
{
oldTipoTestata = testataOld.Tipo;
// per impostare correttamente la descrizione della testata
movimentoAvere.Descrizione = testataOld.Descrizione;
var solleciti = daoFactory.GetSollecitoDao().GetByTestataMovimentoContabile(testataOld.ID);
foreach (var sollecito in solleciti)
sollecito.MovimentoEconomico = null;
ripartizione.Testata.Tipo = testataOld.Tipo;
}
daoFactory.GetTestataMovimentoContabileDao().Delete(testataOld);
ripartizione.Testata.ID = 0;
foreach (var movDto in ripartizione.Testata.Movimenti)
{
if (movDto != null)
movDto.ID = 0;
}
}
// -------------------------------------------
// Creo nuova testata
// -------------------------------------------
var rep = new TestataMovimentoContabileRepository(_info, _windsorRepository, null);
var testata = rep.ManageDomainEntity(ripartizione.Testata);
if (testata == null || movimentoAvere == null)
{
if (testata == null)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio (UPDATE) del movimento - TESTATA NULL - {0} - esercizio:{1} - azienda:{2}", Library.Utility.GetMethodDescription(), idEsercizio.GetValueOrDefault(), _info.Azienda);
persistenceContextService.RollbackAndCloseSession(Security.Login.Instance.CurrentLogin().LoginName);
persistenceContextService.BeginTransaction(Security.Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new SpesaInfoDTO { Id = 0, NumeroProtocollo = 0, IdentificativoArchiviazione = null, StampaEtichettaArchiviazione = false, Message = "Errore inaspettato nel salvataggio del movimento, si prega di riprovare." };
}
if (movimentoAvere == null)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio (UPDATE) del movimento - MOVIMENTO AVERE NULL - {0} - esercizio:{1} - azienda:{2}", Library.Utility.GetMethodDescription(), idEsercizio.GetValueOrDefault(), _info.Azienda);
persistenceContextService.RollbackAndCloseSession(Security.Login.Instance.CurrentLogin().LoginName);
persistenceContextService.BeginTransaction(Security.Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new SpesaInfoDTO { Id = 0, NumeroProtocollo = 0, IdentificativoArchiviazione = null, StampaEtichettaArchiviazione = false, Message = "Errore inaspettato nel salvataggio del movimento, si prega di riprovare." };
}
}
testata.Descrizione = movimentoAvere.Descrizione;
if (oldProtocollo != null)
testata.NumeroProtocollo = oldProtocollo;
if (oldAnnoArchiviazione != null)
testata.AnnoArchiviazioneOttica = oldAnnoArchiviazione;
if (oldTipoTestata != TipoTestataMovimentoContabileEnum.Undefined)
testata.Tipo = oldTipoTestata;
// Aggiorno eventuali addebiti di competenze esistenti
if (addebito != null)
{
addebito.TestataMovimento = testata;
IList<MovimentoContabile> movimentiEconomici = testata.Movimenti.Where(item => item.IsEconomico()).ToList();
IList<DettaglioAddebitoCompetenza> dettagliAddebito = addebito.Dettaglio.ToList();
if (movimentiEconomici.Count == dettagliAddebito.Count)
{
for (var i = 0; i < dettagliAddebito.Count; i++)
dettagliAddebito[i].MovimentoContabile = movimentiEconomici[i];
}
else
{
throw new InvalidDataException("Non è possibile aggiornare direttamente un movimento contabile generato da un addebito di competenze");
//foreach (var dettaglioAddebito in addebito.Dettaglio)
// dettaglioAddebito.MovimentoContabile = null;
}
}
// ======================================================================================
// Evasione Movimenti
// ======================================================================================
if (idMovimentoBancario != null)
{
IList<MovimentoContabile> movimentiContabili = (from movimento in testata.Movimenti where !movimento.IsEconomico() select movimento).ToList();
IList<int> idMovimentiBancari = new List<int> {idMovimentoBancario.GetValueOrDefault()};
movimentoContabileService.EvadiMovimento($"Evasione automatica registrazione movimento contabile del {ripartizione.Testata.DataRegistrazione.GetValueOrDefault():d}", movimentiContabili, idMovimentiBancari, null, null);
}
// =====================================================================================================
// Se presente applico il modello di ripartizione, altrimenti ricalcolo valori o l'intera ripartizione
// =====================================================================================================
if (ripartizione.Testata.IdModelloRipartizione > 0)
{
var tipo = TipoMovimentoEnum.Spesa;
if (movimentoAvere.Segno == "D")
tipo = TipoMovimentoEnum.Accredito;
// NON VIENE PIù RICALCOLATA LE RIPARTIZIONE, SARA' CALCOLATA IN FASE DI BILANCIO
ripartizioneSpeseService.ApplyModello(testata, ripartizione.Testata.IdModelloRipartizione.Value, movimentoAvere.Importo.Value, tipo, false);
// Ripristino le descrizioni precedenti se presenti
foreach (var dto in movimentiDare)
{
if (!string.IsNullOrEmpty(dto.Descrizione))
{
var movimento = (from item in testata.Movimenti
where item.NumeroRiga == dto.NumeroRiga
select item).SingleOrDefault();
if (movimento != null)
movimento.Descrizione = dto.Descrizione;
}
}
}
else
{
// Salvataggio modello
testata.ModelloRipartizione = SalvaModelloRipartizioneContabile(ripartizione, testata, movimentiDare, movimentoAvere.Importo.Value);
}
// =====================================================================================================
// Salvataggio progressivo registrazione
// =====================================================================================================
esercizio.ProgressivoRegistrazioneContabile = numeroRegistrazione;
// =====================================================================================================
// Registrazione dell'eventuale arrotondamento
// =====================================================================================================
if (testata.Movimenti.FirstOrDefault() != null)
movimentoContabileService.SetMovimentoArrotondamento(null, testata, testata.Movimenti.FirstOrDefault().Causale, null);
// ======================================================================================
// Recupero il numero di protocollo e l'identificativo di archiviazione
// ======================================================================================
int protocollo;
if (testata.NumeroProtocollo.GetValueOrDefault() == 0)
{
{
var progressivo = protocolloService.GetProgressivo(TipoProtocollo.Fattura,
esercizio.DataApertura.GetValueOrDefault().Year,
testata.EsercizioRiferimento.CondominioRiferimento);
if (progressivo.Progressivo != null)
{
protocollo = progressivo.Progressivo.Value;
testata.NumeroProtocollo = protocollo;
testata.AnnoArchiviazioneOttica = esercizio.DataApertura.GetValueOrDefault().Year;
}
else
return new SpesaInfoDTO
{
Id = 0,
IdentificativoArchiviazione = null,
NumeroProtocollo = 0,
StampaEtichettaArchiviazione = false,
Message = progressivo.Message
};
}
}
else
{
protocollo = testata.NumeroProtocollo.Value;
}
var identificativoArchiviazione = archiviazioneService.GetIdentificativoArchiviazione(testata);
var movimentoPatrimoniale = (from item in testata.Movimenti
where item.NumeroRiga == movimentoAvere.NumeroRiga
select item).FirstOrDefault();
var idMovimentoPatrimoniale = 0;
if (movimentoPatrimoniale != null)
idMovimentoPatrimoniale = movimentoPatrimoniale.ID;
var impostazioni = daoFactory.GetImpostazioniAziendaDao().GetByAzienda(esercizio.CondominioRiferimento.Azienda.ID);
if (impostazioni == null)
{
impostazioni = new ImpostazioniAzienda(daoFactory.GetAziendaDao().GetById(esercizio.CondominioRiferimento.Azienda.ID, false));
daoFactory.GetImpostazioniAziendaDao().SaveOrUpdate(impostazioni);
}
var stampaEtichetta = false;
var etichettatrice = string.Empty;
var tipoEichetta = "Testo";
int? trayEtichettatriceAttivazioneOttica = null;
if (impostazioni != null)
{
stampaEtichetta = impostazioni.UtilizzoEtichettatriceArchiviazioneOtticaMovimenti && testata.IsAbilitataArchiviazioneOttica;
etichettatrice = impostazioni.EtichettatriceArchiviazioneOttica;
tipoEichetta = impostazioni.TipoEtichettaArchiviazioneOttica;
trayEtichettatriceAttivazioneOttica = impostazioni.TrayEtichettatriceAttivazioneOttica;
}
return new SpesaInfoDTO
{
Id = idMovimentoPatrimoniale,
NumeroProtocollo = testata.NumeroProtocollo.Value,
IdentificativoArchiviazione = identificativoArchiviazione,
StampaEtichettaArchiviazione = stampaEtichetta,
EtichettatriceArchiviazione = etichettatrice,
TipoEtichettaArchiviazione = tipoEichetta,
TrayEtichettatriceAttivazioneOttica = trayEtichettatriceAttivazioneOttica
};
}
return new SpesaInfoDTO
{
Id = 0,
NumeroProtocollo = 0,
IdentificativoArchiviazione = null,
StampaEtichettaArchiviazione = false,
Message = "La registrazione non è possibile perchè relativo ad un esercizio chiuso."
};
}
catch (Exception ex)
{
var message = ex.ToString().StartsWith("NHibernate.StaleObjectStateException") ? "Un altro utente ha confermato un movimento." : "Errore inaspettato nell'attribuzione del numero di registrazione, probabilmente determinato da un conflitto di aggiornamento";
_log.ErrorFormat("Errore inaspettato nel salvataggio (UPDATE) del movimento - {0} - idMovimentoAvere:{1} - esercizio:{2} - azienda:{3}", ex, Library.Utility.GetMethodDescription(), movimentoAvere.ID, idEsercizio.GetValueOrDefault(), _info.Azienda);
persistenceContextService.RollbackAndCloseSession(Security.Login.Instance.CurrentLogin().LoginName);
persistenceContextService.BeginTransaction(Security.Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new SpesaInfoDTO { Id = 0, NumeroProtocollo = 0, IdentificativoArchiviazione = null, StampaEtichettaArchiviazione = false, Message = message };
}
}
public void AddMovimentiRipartizione(IDictionary<DettaglioSpesaDTO, RipartizioneSpeseDTO> listaRipartizione, SpesaDTO spesa)
{
try
{
if (listaRipartizione.Count > 0)
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
var ripartizioneSpeseService = _windsorRepository.GetContainer(_info.Azienda).Resolve<IRipartizioneSpeseService>();
foreach (var dettaglio in spesa.Dettagli)
{
RipartizioneSpeseDTO ripartizione = null;
var key = GetDettaglioDto(listaRipartizione, dettaglio.NumeroRiga.GetValueOrDefault());
if (key != null && listaRipartizione.ContainsKey(key))
ripartizione = listaRipartizione[key];
else
{
_log.ErrorFormat("Chiave non trovata in listaRipartizione - {0} - dettaglio.NumeroRiga.Value:{1}", Library.Utility.GetMethodDescription(), dettaglio.NumeroRiga.GetValueOrDefault());
//throw new KeyNotFoundException("Chiave non trovata in listaRipartizione.");
}
if (ripartizione?.UnitaImmobiliari != null)
{
var listaMovimenti = new List<MovimentoContabileDTO>(dettaglio.Movimenti.Length);
foreach (var movimentoEconomico in dettaglio.Movimenti)
{
movimentoEconomico.IdFornitore = spesa.IdFornitore;
var conto = daoFactory.GetContoDao().GetById(movimentoEconomico.IdConto.GetValueOrDefault(), false);
listaMovimenti.Add(movimentoEconomico);
// ----------------------------------------------------
// Spesa Unità
// ----------------------------------------------------
UnitaImmobiliareSelectedDTO[] unita = null;
var keyUnita = ripartizioneSpeseService.GetKey(movimentoEconomico);
if (ripartizione.UnitaImmobiliari.ContainsKey(keyUnita))
unita = ripartizione.UnitaImmobiliari[keyUnita];
else
{
// Trasformato error in DEBUG senza exception perchè se viene modificata una spesa già inserita senza definire un riparto personalizzato la ripartizione NON
// sarà presente, quindi, in questi casi NON deve essere lanciata una exception ma sarà il metodo AddDefaultRipartizione ad aggiungere il riparto mancante.
// 24/10/2010 - Il metodo AddDefaultRipartizione non viene più richiamato perchè ora la ripartizione viene ricalcolata quando serve
_log.DebugFormat("Chiave non trovata in ripartizione.UnitaImmobiliari - {0} - keyUnita:{1}", Library.Utility.GetMethodDescription(), keyUnita);
//throw new KeyNotFoundException("Chiave non trovata in ripartizione.UnitaImmobiliari.");
}
var ripartoPersonalizzato = false;
if (unita != null)
{
movimentoEconomico.DettaglioRipartizione = new SpeseUnitaDTO[unita.Length];
if (conto.IsSpesePersonali || unita.Any(item => !item.Selezionato))
{
for (var j = 0; j < unita.Length; j++)
{
if (unita[j].Selezionato)
{
var spesaUnita = new SpeseUnitaDTO();
if (unita[j].IdSoggettoCondominio > 0)
spesaUnita.IdSoggetto = unita[j].IdSoggettoCondominio;
else
spesaUnita.IdUnitaRiferimento = unita[j].ID;
if (conto.IsSpesePersonali)
spesaUnita.Importo = unita[j].Importo;
movimentoEconomico.DettaglioRipartizione[j] = spesaUnita;
}
}
ripartoPersonalizzato = true;
}
movimentoEconomico.LottiAddebito = getLottiAddebito(ripartizione, keyUnita);
movimentoEconomico.StabiliAddebito = getStabiliAddebito(ripartizione, keyUnita);
movimentoEconomico.GruppiAddebito = getGruppiAddebito(ripartizione, keyUnita);
movimentoEconomico.IsRipartoPersonalizzato = false;
if (ripartoPersonalizzato && !conto.IsSpesePersonali && string.IsNullOrEmpty(movimentoEconomico.LottiAddebito) && string.IsNullOrEmpty(movimentoEconomico.StabiliAddebito) && string.IsNullOrEmpty(movimentoEconomico.GruppiAddebito))
movimentoEconomico.IsRipartoPersonalizzato = true;
}
}
}
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nell'inserimento dei movimenti di ripartizione - {0} - spesa:{1}", ex, Library.Utility.GetMethodDescription(), spesa?.ID.ToString() ?? "<NULL>");
throw;
}
}
