/// <summary>
/// Crea un Pagamento valido
/// </summary>
public Pagamento(ScadenzaFattura scadenza, Disposizione disposizione, decimal? importo, DateTime? dataPagamento, TipoPagamentoFatturaEnum tipo)
{
ScadenzaRiferimento = scadenza;
DisposizioneRiferimento = disposizione;
Importo = importo;
Data = dataPagamento;
Tipo = tipo;
if (scadenza != null)
scadenza.Pagamenti.Add(this);
if (disposizione != null)
disposizione.Pagamenti.Add(this);
}
public virtual IUpdatableBusinessEntity Copy()
{
ScadenzaFattura rata = new ScadenzaFattura(SpesaRiferimento, null, null);
return rata;
}
private bool insert(ScadenzaFatturaDTO dto, out ScadenzaFattura item)
{
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
item = null;
try
{
item = new ScadenzaFattura(daoFactory.GetSpesaDao().GetById(dto.IdSpesa, false), dto.Scadenza, dto.Importo) {ImportoRitenuta = dto.ImportoRitenuta};
daoFactory.GetScadenzaFatturaDao().SaveOrUpdate(item);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel salvataggio scadenza Fattura/Spesa - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), dto.ID);
throw;
}
return true;
}
private bool update(ScadenzaFatturaDTO dto, out ScadenzaFattura item)
{
var result = false;
var daoFactory = _windsorRepository.GetDaoFactory(_info.Azienda);
try
{
item = daoFactory.GetScadenzaFatturaDao().GetById(dto.ID, false);
// Solo se la scadenza non è stata pagata, oppure se l'importo da pagare è superiore a quello pagato, oppure l'importo pagato è uguale ma l'importo della ritenuta è diverso e la ritenuta non è stata ancora versata
if (item.Stato == StatoSpesaEnum.Inserita || item.Stato == StatoSpesaEnum.Autorizzata || dto.Importo > item.Importo || (dto.Importo == item.Importo && dto.ImportoRitenuta != item.ImportoRitenuta && !item.Pagamenti.Any(pag => pag.RitenutaAcconto.Stato == StatoRitenutaEnum.Pagata)))
{
item.Importo = dto.Importo;
item.ImportoRitenuta = dto.ImportoRitenuta;
item.Scadenza = dto.Scadenza;
item.SetStato();
result = true;
}
else
result = true;
}
catch (Exception ex)
{
_log.Error("Errore nel salvataggio della scadenza Fattura/Spesa: " + Library.Utility.GetMethodDescription() + " - id:" + dto.ID.ToString(), ex);
throw;
}
return result;
}
private ScadenzaFatturaDTO setDto(ScadenzaFattura item)
{
var dto = new ScadenzaFatturaDTO
{
ID = item.ID,
IdSpesa = item.SpesaRiferimento.ID,
Importo = item.Importo,
ImportoPagato = item.ImportoPagato,
ImportoRitenuta = item.ImportoRitenuta,
IdEsercizio = item.SpesaRiferimento.EsercizioRiferimento.ID,
Esercizio = item.SpesaRiferimento.EsercizioRiferimento.DisplayName,
IdCondominio = item.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID,
Condominio = item.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DisplayName
};
dto.ImportoResiduoRitenuta = Common.ContabilitaHelper.GetImportoRitenuta(item.ID, dto.Importo.GetValueOrDefault() - dto.ImportoPagato.GetValueOrDefault(), _windsorRepository.GetContainer(_info.Azienda));
dto.Scadenza = item.Scadenza;
dto.DisplayFornitore = item.SpesaRiferimento.FornitoreRiferimento.DisplayName;
dto.DisplayDataDocumento = item.SpesaRiferimento.DataDocumento;
dto.DisplayNumeroDocumento = item.SpesaRiferimento.NumeroDocumento;
dto.DisplayTipoDocumento = item.SpesaRiferimento.TipoDocumento;
var pagamenti = item.Pagamenti.Where(pag => pag.Stato != StatoSpesaEnum.Autorizzata).ToList();
if (pagamenti.Any())
{
var pag = pagamenti.FirstOrDefault();
if (pag != null)
{
if (pag.RitenutaAcconto != null && pag.RitenutaAcconto.TestataRiferimento != null && pag.RitenutaAcconto.TestataRiferimento.Data != null)
dto.DataPagamentoRitenuta = pag.RitenutaAcconto.TestataRiferimento.Data;
if (pag.Conto != null)
dto.IdContoPagamentoScadenza = pag.Conto.ID;
if (pag.MovimentoContabile != null)
{
if (pag.MovimentoContabile.SottoContoRiferimento != null)
dto.IdSottoContoPagamentoScadenza = pag.MovimentoContabile.SottoContoRiferimento.ID;
else if (pag.MovimentoContabile.ContoCorrenteBancario != null)
dto.IdSottoContoPagamentoScadenza = pag.MovimentoContabile.ContoCorrenteBancario.ID * -1;
}
}
}
dto.StatoScadenza = item.Stato;
dto.Version = item.Version;
// Pagamenti
var rep = getPagamentoFatturaRepository();
var pagamentiDTO = new List<PagamentoDTO>(pagamenti.Count);
pagamentiDTO.AddRange(from pagamento in pagamenti select rep.GetByDomainEntity(pagamento));
dto.Pagamenti = pagamentiDTO;
return dto;
}
public ScadenzaFatturaDTO GetByDomainEntity(ScadenzaFattura item)
{
try
{
return setDto(item);
}
catch (Exception ex)
{
_log.Error("Errore nel caricamento delle scadenze delle fatture: " + Library.Utility.GetMethodDescription() + " - id:" + item.ID.ToString(), ex);
throw;
}
}
public MovimentoContabile SetMovimentiStornoScadenza(DettaglioSpesa dettaglioSpesa, ScadenzaFattura scadenza, decimal importo, Esercizio esercizio, DateTime dataRegistrazione)
{
try
{
var message = IsAllowDataRegistrazione(new List<int> { scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
if (message.Count == 0)
{
var numeroRiga = 0;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("SS");
// ================================================
// Testata
// ================================================
var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null);
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
// ================================================
// Debiti VS Fornitori
// ================================================
numeroRiga++;
var segno = "D";
if (importo < 0)
{
segno = "A";
importo = importo * -1;
}
var movimentoPatrimoniale = new MovimentoContabile(testata, scadenza.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(scadenza.SpesaRiferimento.EsercizioRiferimento.ID, scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importo, segno)
{
Descrizione = "Storno Fatt. n." + scadenza.SpesaRiferimento.NumeroDocumento + " del " + scadenza.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString()
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
// ================================================
// Conto Economico
// ================================================
var importoTotale = 0m;
numeroRiga++;
if (scadenza.SpesaRiferimento.TipoDocumento != "FATBILAPP")
{
var movimenti = new List<MovimentoContabile>();
// Se è una FATTURA ......
if (scadenza.SpesaRiferimento.Dettagli.Count > 0)
{
importoTotale = scadenza.SpesaRiferimento.Dettagli.Sum(item => item.Movimenti.Sum(item2 => item2.GetImportoConSegno().GetValueOrDefault()));
foreach (var dettaglio in scadenza.SpesaRiferimento.Dettagli)
movimenti.AddRange(dettaglio.Movimenti);
}
// .... oppure una BOLLETTA
else if (scadenza.SpesaRiferimento.MovimentiBollette.Count > 0)
{
importoTotale = scadenza.SpesaRiferimento.MovimentiBollette.Sum(item => item.GetImportoConSegno().GetValueOrDefault());
movimenti.AddRange(scadenza.SpesaRiferimento.MovimentiBollette);
}
foreach (var movimento in movimenti)
{
var movimentoEconomico = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, (importo * movimento.GetImportoConSegno()) / importoTotale, invertiSegno(movimento.Segno))
{
SottoContoRiferimento = movimento.SottoContoRiferimento,
Descrizione = movimento.GetDescrizione(),
IsRipartoPersonalizzato = movimento.IsRipartoPersonalizzato,
LottiAddebito = movimento.LottiAddebito,
StabiliAddebito = movimento.StabiliAddebito,
GruppiAddebito = movimento.GruppiAddebito,
FornitoreRiferimento = movimento.FornitoreRiferimento,
DettaglioRiferimento = dettaglioSpesa
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoEconomico);
// Se è presente una ripartizione personalizzata o una spesa personale deve salvare anche il riparto.
foreach (var itemRiparto in movimento.DettaglioRipartizione)
{
var importoRiparto = (itemRiparto.Importo.GetValueOrDefault()*movimentoEconomico.Importo.GetValueOrDefault()/movimento.Importo.GetValueOrDefault()) * -1;
var spesaUnita = itemRiparto.MovimentoRiferimento.ContoRiferimento.IsSpesePersonali ? new SpeseUnita(importoRiparto, null, itemRiparto.SoggettoCondominio, movimentoEconomico) : new SpeseUnita(importoRiparto, itemRiparto.UnitaRiferimento, null, movimentoEconomico);
_daoFactory.GetSpeseUnitaDao().SaveOrUpdate(spesaUnita);
}
movimento.MovimentoStorno = movimentoEconomico;
}
}
// Se si tratta di fattura da Bilancio di Apertura lo storno avviene esclusivamente dal conto Bancario
else
{
var movimentoEconomico = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario()), importo, invertiSegno(movimentoPatrimoniale.Segno))
{
ContoCorrenteBancario = esercizio.CondominioRiferimento.DatiBancariPrincipale,
Descrizione = movimentoPatrimoniale.Descrizione
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoEconomico);
}
return movimentoPatrimoniale;
}
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
_log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - scadenza:{2} - importo:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, scadenza.ID, importo);
throw ex;
}
catch (Exception ex)
{
_log.Fatal("Errore inaspettato nella funzione - " + Utility.GetMethodDescription() + " - data:" + dataRegistrazione + " - scadenza:" + scadenza.ID + " - importo:" + importo, ex);
throw;
}
}
private ScadenzaFatturaDTO setScadenzaDto(ScadenzaFattura item)
{
var dto = new ScadenzaFatturaDTO
{
ID = item.ID,
IdSpesa = item.SpesaRiferimento.ID,
Importo = item.Importo,
ImportoPagato = item.ImportoPagato,
ImportoRitenuta = item.ImportoRitenuta
};
dto.ImportoResiduoRitenuta = Common.ContabilitaHelper.GetImportoRitenuta(item.SpesaRiferimento, dto.Importo.GetValueOrDefault() - dto.ImportoPagato.GetValueOrDefault());
dto.Scadenza = item.Scadenza;
dto.DisplayFornitore = item.SpesaRiferimento.FornitoreRiferimento.DisplayName;
dto.DisplayDataDocumento = item.SpesaRiferimento.DataDocumento;
dto.DisplayNumeroDocumento = item.SpesaRiferimento.NumeroDocumento;
dto.DisplayTipoDocumento = item.SpesaRiferimento.TipoDocumento;
if (item.Pagamenti.Count == 1)
{
var pag = IesiGenericCollections<Pagamento>.GetByIndex(item.Pagamenti, 0);
if (pag.RitenutaAcconto != null && pag.RitenutaAcconto.TestataRiferimento != null && pag.RitenutaAcconto.TestataRiferimento.Data != null)
dto.DataPagamentoRitenuta = pag.RitenutaAcconto.TestataRiferimento.Data;
if (pag.Conto != null)
dto.IdContoPagamentoScadenza = pag.Conto.ID;
if (pag.MovimentoContabile != null)
{
if (pag.MovimentoContabile.SottoContoRiferimento != null)
dto.IdSottoContoPagamentoScadenza = pag.MovimentoContabile.SottoContoRiferimento.ID;
else if (pag.MovimentoContabile.ContoCorrenteBancario != null)
dto.IdSottoContoPagamentoScadenza = pag.MovimentoContabile.ContoCorrenteBancario.ID * -1;
}
}
dto.StatoScadenza = StatoSpesaEnum.Stornata;
dto.Version = item.Version;
return dto;
}
public BilancioAperturaMessage SetBilancioApertura(TestataMovimentoContabileGestioneDTO testata)
{
try
{
var fatalMessage = string.Empty;
var warnMessage = string.Empty;
//==============================================
// Controllo esercizio
//==============================================
if (testata.CodiceEsercizio == 0)
{
_log.ErrorFormat("Non è definito alcun esercizio - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("Non è definito alcun esercizio", string.Empty, false);
}
var esercizio = _daoFactory.GetEsercizioDao().Find(testata.CodiceEsercizio, false);
if(esercizio == null)
{
_log.ErrorFormat("L'esercizio non è stato trovato - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage($"L'esercizio '{testata.CodiceEsercizio}' non è stato trovato.", string.Empty, false);
}
if(esercizio.Gestione == GestioneEsercizioEnum.Straordinario)
{
_log.ErrorFormat("L'esercizio deve essere un esercizio ordinario - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("L'esercizio deve essere un esercizio ordinario", string.Empty, false);
}
//==============================================
// Controllo Saldi Condomini
//==============================================
var saldiCondomini = _daoFactory.GetSaldoSoggettoDao().GetByEsercizioStabileScala(esercizio, null, null);
var contoCreditiCondomini = _daoFactory.GetContoDao().GetAllByCodice(esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini()).FirstOrDefault(item => item.EsercizioRiferimento == null);
if (contoCreditiCondomini != null)
{
var movimentiVersamentiCondomini = testata.Movimenti.Where(item => item.IdConto == contoCreditiCondomini.ID).ToList();
if (movimentiVersamentiCondomini.Count > 1)
{
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage($"Non può essere presente più di un movimento per il conto {contoCreditiCondomini.Codice} - {contoCreditiCondomini.Descrizione}", string.Empty, false);
}
if (movimentiVersamentiCondomini.Count == 1)
{
var importoCreditiCondomini = movimentiVersamentiCondomini.Sum(item => item.ImportoDare.GetValueOrDefault() - item.ImportoAvere.GetValueOrDefault());
if (importoCreditiCondomini > 0)
{
if (saldiCondomini.Count == 0)
{
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("Prima di registrare il bilancio di apertura occorre inserire i saldi iniziali dei singoli condomini", string.Empty, true);
}
var totaleSaldiCondomini = saldiCondomini.Sum(item => item.Importo);
if (importoCreditiCondomini != totaleSaldiCondomini)
{
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage($"L'importo del conto crediti v/condomini: {importoCreditiCondomini:c} non corrisponde con la somma dei saldi dei singoli condomini: {totaleSaldiCondomini:c}", string.Empty, true);
}
}
}
}
//==============================================
// Controllo data registrazione
//==============================================
if (testata.DataRegistrazione == null || !Conversione.IsSqlSmallDateTime(testata.DataRegistrazione.GetValueOrDefault()))
{
_log.ErrorFormat("Non è definita la data di registrazione - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("Non è definita la data di registrazione", string.Empty, false);
}
if(testata.DataRegistrazione.GetValueOrDefault() < esercizio.DataApertura.GetValueOrDefault())
{
_log.DebugFormat("La data di registrazione è inferiore alla data di apertura dell'esercizio - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("La data di registrazione è inferiore alla data di apertura dell'esercizio", string.Empty, false);
}
//==============================================
// Controllo correttezza importi
//==============================================
if (testata.Movimenti == null)
{
_log.FatalFormat("I movimenti sono a null - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("I movimenti sono a null", string.Empty, false);
}
if (testata.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()) != testata.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()))
fatalMessage = $"Il totale Dare:{testata.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()):c} non corrisponde col totale Avere:{testata.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()):c}.{Environment.NewLine}";
else
{
var listaDettagli = new Dictionary<int, DettaglioSpesa>();
// ==============================================================================================================
// Se il bilancio di apertura NON è registrato nel primo esercizio occorre registrare solo i movimenti contabili
// ==============================================================================================================
if (IsRequiredDatiFatturaBilancioApertura(esercizio.ID))
{
// ===============================================
// Controllo movimenti
// ===============================================
foreach (var dto in testata.Movimenti)
{
if (dto.Stato == "U")
{
var messageControllo = IsAllowUpdateMovimentoBilancioApertura(dto.ID, dto.IdSpesa);
if (string.IsNullOrEmpty(messageControllo))
{
// ------------------------------------------------------------------------------------
// Se il conto non è Fornitori e Ritenuta devo cancellare l'eventuale spesa associata
// ------------------------------------------------------------------------------------
var conto = _daoFactory.GetContoDao().GetById(dto.IdConto.GetValueOrDefault(), false);
if (conto.Codice == _pianoContiService.GetCodiceContoFornitori() || conto.Codice == _pianoContiService.GetCodiceContoRitenuta())
dto.IdSpesa = 0;
else
{
if (dto.IdSpesa > 0)
{
var messageDeleteSpesa = IsAllowDelete(dto.IdSpesa);
if (!string.IsNullOrEmpty(messageDeleteSpesa.FatalMessage))
return new BilancioAperturaMessage(messageDeleteSpesa.FatalMessage, string.Empty, false);
else
{
var movimento = _daoFactory.GetMovimentoContabileDao().Find(dto.ID, false);
if(movimento != null)
{
movimento.Spesa = null;
movimento.Testata.Movimenti.Remove(movimento);
movimento.Testata = null;
_daoFactory.GetMovimentoContabileDao().Delete(movimento);
}
Delete(dto.IdSpesa);
dto.ID = 0;
dto.IdSpesa = 0;
dto.IdFornitore = 0;
dto.NumeroDocumento = null;
dto.DataDocumento = null;
dto.ImportoFattura = null;
dto.ImportoIva = null;
dto.ImportoRitenuta = null;
dto.InteressiRitenuta = null;
dto.SanzioniRitenuta = null;
dto.AliquotaRitenuta = null;
dto.AltreSpese = null;
dto.AltreSpeseEsenti = null;
dto.DataPagamento = null;
dto.DataVersamentoRitenuta = null;
}
}
}
}
else
{
fatalMessage += messageControllo + Environment.NewLine;
_log.WarnFormat("{0} - {1} - testata:{2}", fatalMessage, Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage(fatalMessage, string.Empty, false);
}
}
}
var index = 0;
// ===============================================
// Elaborazione di tutti i movimenti
// ===============================================
foreach (var movimento in testata.Movimenti)
{
try
{
if (movimento.Stato == "U")
{
if (movimento.IdConto == null)
{
_log.FatalFormat("I movimenti sono a null - 2 - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage($"Non è presente il conto per la riga:{movimento.NumeroRiga.GetValueOrDefault()}", string.Empty, false);
}
index++;
if (movimento.ID == 0)
movimento.ID = index*-1;
// ----------------------------------------------------------
// Se è presente il fornitore devo gestire la fattura
// ----------------------------------------------------------
var conto = _daoFactory.GetContoDao().GetById(movimento.IdConto.GetValueOrDefault(), false);
if (movimento.IdFornitore > 0 && (conto.Codice == _pianoContiService.GetCodiceContoFornitori() || conto.Codice == _pianoContiService.GetCodiceContoRitenuta()))
{
var fornitore = _daoFactory.GetFornitoreDao().GetById(movimento.IdFornitore.GetValueOrDefault(), false);
// ----------------------------------
// Importi
// ----------------------------------
decimal importo;
decimal? importoRitenuta = null;
try
{
if (movimento.ImportoAvere.GetValueOrDefault() > 0)
{
importo = movimento.ImportoAvere.GetValueOrDefault() - movimento.AltreSpeseEsenti.GetValueOrDefault();
importoRitenuta = movimento.ImportoRitenuta;
}
else
{
importo = (movimento.ImportoDare.GetValueOrDefault() - movimento.AltreSpeseEsenti.GetValueOrDefault()) * -1;
if(movimento.ImportoRitenuta != null)
importoRitenuta = movimento.ImportoRitenuta.GetValueOrDefault()*-1;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - IMPORTI - {0} - idTestata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// ----------------------------------
// Spesa
// ----------------------------------
GestioneCondomini.Domain.Spesa spesa;
try
{
if (movimento.ID > 0)
{
var mov = _daoFactory.GetMovimentoContabileDao().Find(movimento.ID, false);
if (mov != null)
{
if (mov.Spesa != null)
spesa = mov.Spesa;
else
{
if (mov.DettaglioRiferimento?.SpesaRiferimento == null)
{
var messageSpesa = getNewSpesa(fornitore, esercizio, testata, movimento, out spesa);
if (!string.IsNullOrEmpty(messageSpesa))
{
fatalMessage += messageSpesa + Environment.NewLine;
_log.ErrorFormat("Errore nella generazione della spesa - {0} - idTestata:{1}", Utility.GetMethodDescription(), testata.ID);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage(fatalMessage, string.Empty, false);
}
}
else
spesa = mov.DettaglioRiferimento.SpesaRiferimento;
}
}
else
{
int? idMov = null;
if (mov != null)
idMov = mov.ID;
_log.ErrorFormat("Non è stato trovato il movimento contabile - {0} - id:{1}", Utility.GetMethodDescription(), idMov);
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return new BilancioAperturaMessage("Non è stato trovato il movimento contabile", string.Empty, false);
}
if (spesa != null)
spesa.FornitoreRiferimento = fornitore;
}
else
{
spesa = new GestioneCondomini.Domain.Spesa(fornitore, esercizio, null);
try
{
if (_protocolloService == null)
{
_log.ErrorFormat("Errore di inizializzazione del protocollo service - {0} - idEsercizio:{1} - idTestata:{2}", Utility.GetMethodDescription(), testata.CodiceEsercizio, testata.ID);
fatalMessage = "Errore di inizializzazione del protocollo service.";
}
if (movimento.DataDocumento == null)
{
_log.ErrorFormat("La data del documento è null - {0} - documento:{1} - movimento:{2} - esercizio:{3} - testata:{4}", Utility.GetMethodDescription(), movimento.NumeroDocumento, movimento.ID, testata.CodiceEsercizio, testata.ID);
fatalMessage = "La data del documento è null.";
}
if (esercizio.CondominioRiferimento == null)
{
_log.FatalFormat("Il Condominio è null - {0} - documento:{1} - movimento:{2} - esercizio:{3} - testata:{4}", Utility.GetMethodDescription(), movimento.NumeroDocumento, movimento.ID, testata.CodiceEsercizio, testata.ID);
fatalMessage = "Il Condominio è null.";
}
var protocollo = _protocolloService.GetProgressivo(TipoProtocollo.Fattura, esercizio.DataApertura.GetValueOrDefault().Year, esercizio.CondominioRiferimento);
if (protocollo.Progressivo != null)
spesa.NumeroProtocollo = protocollo.Progressivo;
else
return new BilancioAperturaMessage(protocollo.Message, string.Empty, false);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel recuperare il progressivo - {0} - data:{1:d} - condominio:{2} - movimento:{3} - esercizio:{4} - testata:{5}", ex, Utility.GetMethodDescription(), movimento.DataDocumento.GetValueOrDefault(), esercizio.CondominioRiferimento.ID, movimento.ID, testata.CodiceEsercizio, testata.ID);
fatalMessage = "Errore inaspettato nel recuperare il progressivo.";
}
_daoFactory.GetSpesaDao().SaveOrUpdate(spesa);
}
if (spesa != null)
{
spesa.TipoDocumento = "FATBILAPP";
spesa.ImportoRitenuta = importoRitenuta;
spesa.AltreSpeseEsenti = movimento.AltreSpeseEsenti;
spesa.AltreSpese = movimento.AltreSpese;
spesa.IsRitenutaCalcoloImponibile = spesa.FornitoreRiferimento.IsRitenutaCalcolataImponibile;
if(movimento.AliquotaRitenuta != null)
spesa.AliquotaRitenuta = movimento.AliquotaRitenuta.GetValueOrDefault()/100;
else
spesa.AliquotaRitenuta = null;
spesa.NumeroDocumento = movimento.NumeroDocumento;
spesa.DataDocumento = movimento.DataDocumento;
spesa.Stato = conto.Codice == _pianoContiService.GetCodiceContoFornitori() ? StatoSpesaEnum.Inserita : StatoSpesaEnum.Pagata;
movimento.IdSpesa = spesa.ID;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - SPESA - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// ----------------------------------
// Dettaglio Spesa
// ----------------------------------
DettaglioSpesa dettaglio = null;
try
{
if (conto.Codice == _pianoContiService.GetCodiceContoFornitori() || conto.Codice == _pianoContiService.GetCodiceContoRitenuta())
{
if (movimento.ID > 0 && _daoFactory.GetMovimentoContabileDao().GetById(movimento.ID, false).DettaglioRiferimento != null)
dettaglio = _daoFactory.GetMovimentoContabileDao().GetById(movimento.ID, false).DettaglioRiferimento;
else
{
dettaglio = new DettaglioSpesa(spesa, 1);
_daoFactory.GetDettaglioSpesaDao().SaveOrUpdate(dettaglio);
}
dettaglio.Descrizione = movimento.Descrizione;
dettaglio.ImportoLordo = conto.Codice == _pianoContiService.GetCodiceContoFornitori() ? importo - movimento.AltreSpese.GetValueOrDefault() : movimento.ImportoFattura;
dettaglio.ImportoIva = movimento.ImportoIva;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - DETTAGLIO SPESA - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// ------------------------------------------------------
// Scadenza - SOLO se non di tratta di nota di accredito
// ------------------------------------------------------
ScadenzaFattura scadenza = null;
try
{
if (spesa != null && movimento.ImportoDare.GetValueOrDefault() == 0)
{
if (movimento.ID > 0)
scadenza = IesiGenericCollections<ScadenzaFattura>.GetByIndex(spesa.Scadenze, 0);
if (scadenza == null)
{
scadenza = new ScadenzaFattura(spesa, esercizio.DataApertura, importo - spesa.ImportoRitenuta.GetValueOrDefault())
{
Stato = conto.Codice == _pianoContiService.GetCodiceContoFornitori() ? StatoSpesaEnum.Inserita : StatoSpesaEnum.Pagata
};
_daoFactory.GetScadenzaFatturaDao().SaveOrUpdate(scadenza);
}
if (conto.Codice == _pianoContiService.GetCodiceContoFornitori())
{
scadenza.Importo = importo + spesa.AltreSpeseEsenti.GetValueOrDefault() - spesa.ImportoRitenuta.GetValueOrDefault();
scadenza.ImportoRitenuta = spesa.ImportoRitenuta;
if (movimento.DataPagamento != null)
scadenza.Scadenza = movimento.DataPagamento.GetValueOrDefault();
}
else
{
scadenza.Importo = 0;
scadenza.ImportoRitenuta = importoRitenuta;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - SCADENZA - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// =================================================================================
// RITENUTE
// ----------------------------------
// Pagamento
// ----------------------------------
try
{
// Inserimento pagamento fattura per ritenuta in bilancio di apertura da pagare
if (scadenza != null && conto.Codice == _pianoContiService.GetCodiceContoRitenuta())
{
Pagamento pagamento;
if (scadenza.Pagamenti.Count > 0)
{
pagamento = scadenza.Pagamenti.First();
pagamento.Data = movimento.DataPagamento.GetValueOrDefault();
pagamento.RitenutaAcconto.Importo = scadenza.ImportoRitenuta;
pagamento.RitenutaAcconto.ImportoInteressi = movimento.InteressiRitenuta;
pagamento.RitenutaAcconto.ImportoSanzione = movimento.SanzioniRitenuta;
pagamento.Importo = spesa.ImportoLordo - pagamento.RitenutaAcconto.Importo.GetValueOrDefault();
pagamento.Stato = StatoSpesaEnum.Pagata;
// Se il pagamento è già presente devo annullare la ritenuta eventualmente già versata
// TODO: Verificare se è necessario controllare che non si tratti di un versamento CBI
if (pagamento.RitenutaAcconto != null && pagamento.RitenutaAcconto.TestataRiferimento != null)
{
var messageDeleteRitenuta = _ritenutaService.DeletePagamentoRitenuta(pagamento.RitenutaAcconto.TestataRiferimento.ID);
if (!string.IsNullOrEmpty(messageDeleteRitenuta))
fatalMessage += messageDeleteRitenuta + Environment.NewLine;
}
}
else
{
pagamento = new Pagamento(scadenza, null, spesa.ImportoLordo, movimento.DataPagamento.GetValueOrDefault(), TipoPagamentoFatturaEnum.AltroAmministratore)
{
RitenutaAcconto = new Ritenuta(scadenza.ImportoRitenuta)
{
ImportoInteressi = movimento.InteressiRitenuta,
ImportoSanzione = movimento.SanzioniRitenuta,
Stato = StatoRitenutaEnum.Inserita
},
Stato = StatoSpesaEnum.Pagata
};
_daoFactory.GetPagamentoDao().SaveOrUpdate(pagamento);
}
// -------------------------------------------------------------------------------------------
// Se presente la data di versamento della ritenuta la ritenuta inserita è già stata versata
// -------------------------------------------------------------------------------------------
if (string.IsNullOrEmpty(fatalMessage) && movimento.DataVersamentoRitenuta != null)
{
var contoRitenuta = _daoFactory.GetContoDao().GetByCodice(scadenza.SpesaRiferimento.EsercizioRiferimento.ID, scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario());
_ritenutaService.PagamentoRitenuta(pagamento, movimento.DataVersamentoRitenuta.GetValueOrDefault(), contoRitenuta, null, testata.Descrizione, null, null, null);
}
}
if (dettaglio != null)
listaDettagli.Add(movimento.ID, dettaglio);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - PAGAMENTO - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// =================================================================================
// FATTURE
// ---------------------------------------------------------------------------------
// Inserimento pagamento fattura per fattura in bilancio di apertura ma già pagata
// ---------------------------------------------------------------------------------
try
{
if (spesa != null && string.IsNullOrEmpty(fatalMessage) && conto.Codice == _pianoContiService.GetCodiceContoFornitori() && movimento.DataPagamento != null)
{
if (spesa.ID > 0 && scadenza?.Pagamenti != null && scadenza.Pagamenti.Count > 0)
{
var messageAnnullamentoPagamenti = _pagamentoService.IsAllowAnnullamentoPagamentiSpesa(spesa.ID);
if (string.IsNullOrEmpty(messageAnnullamentoPagamenti.FatalMessage))
_pagamentoService.AnnullamentoPagamentiSpesa(spesa.ID);
else
fatalMessage += messageAnnullamentoPagamenti.FatalMessage + Environment.NewLine;
}
if (string.IsNullOrEmpty(fatalMessage))
{
var idScadenza = 0;
decimal? importoScadenza = spesa.ImportoLordo;
var dataScadenza = movimento.DataPagamento;
var statoScadenza = StatoSpesaEnum.Inserita;
if (scadenza != null)
{
idScadenza = scadenza.ID;
importoScadenza = scadenza.Importo;
dataScadenza = scadenza.Scadenza;
statoScadenza = scadenza.Stato;
}
int? idSottoConto = null;
var datiBancari = esercizio.CondominioRiferimento.DatiBancariPrincipale;
if (datiBancari != null)
idSottoConto = datiBancari.ID*-1;
var scadenze = new List<ScadenzaFatturaDTO>(1)
{
new ScadenzaFatturaDTO
{
ID = idScadenza,
IdContoPagamentoScadenza = _pianoContiService.GetContoBancario(esercizio).ID,
DataPagamentoRitenuta = null,
DataPagamentoScadenza = movimento.DataPagamento.GetValueOrDefault(),
IdSottoContoPagamentoScadenza = idSottoConto,
IdSpesa = spesa.ID,
Importo = importoScadenza,
ImportoRitenuta = movimento.ImportoRitenuta,
Scadenza = dataScadenza,
StatoScadenza = statoScadenza,
Stato = "U"
}
};
var messagePagamenti = _pagamentoService.CreatePagamentiImmediati(spesa.ID, scadenze, null);
if (!string.IsNullOrEmpty(messagePagamenti))
fatalMessage += messagePagamenti + Environment.NewLine;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - PAGAMENTO 2 - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - SINGOLO MOVIMENTO - {0} - movimento:{1} - testata:{2}", ex, Utility.GetMethodDescription(), movimento.ID, testata.ID);
throw;
}
}
}
try
{
if(string.IsNullOrEmpty(fatalMessage))
{
var result = _movimentoContabileService.SetBilancioApertura(testata);
fatalMessage += result.Message;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - MOVIMENTI CONTABILI - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
try
{
if(string.IsNullOrEmpty(fatalMessage))
{
foreach (var dto in testata.Movimenti)
{
try
{
if (dto.IdMovimentoRiferimento > 0 && listaDettagli.ContainsKey(dto.ID))
_daoFactory.GetMovimentoContabileDao().GetById(dto.IdMovimentoRiferimento, false).DettaglioRiferimento = listaDettagli[dto.ID];
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - IMPOSTAZIONE DETTAGLIO RIFERIMENTO (SINGOLO DETTAGLIO) - {0} - id:{1} - testata:{2}", ex, Utility.GetMethodDescription(), dto.ID, testata.ID);
throw;
}
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - IMPOSTAZIONE DETTAGLIO RIFERIMENTO - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
// =============================================================================================
// Esercizi Precedenti: Se chiusi occorre eliminare le registrazioni di chiusura - bugid#2472
// =============================================================================================
var eserciziPrecedenti =
esercizio.CondominioRiferimento.Esercizi.Where(
item =>
item.Stato == StatoEsercizioEnum.Chiuso &&
item.Gestione == GestioneEsercizioEnum.Ordinario &&
item.DataApertura.GetValueOrDefault() < esercizio.DataApertura.GetValueOrDefault()).ToList();
foreach (var esercizioPrecedente in eserciziPrecedenti)
_movimentoContabileService.EliminazioneOperazioniAperturaChiusura(esercizioPrecedente);
}
if (!string.IsNullOrEmpty(fatalMessage))
{
_persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
_persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
}
return new BilancioAperturaMessage(fatalMessage, warnMessage, false);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nel salvataggio del bilancio di apertura - {0} - testata:{1}", ex, Utility.GetMethodDescription(), testata.ID);
throw;
}
}
public SpesaInfoDTO SalvaFiscale(SpesaFiscaleDTO dto)
{
try
{
var message = string.Empty;
var fornitore = _daoFactory.GetFornitoreDao().GetById(dto.IdFornitore, false);
var esercizio = _daoFactory.GetEsercizioDao().Find(dto.IdEsercizio, false);
if (esercizio == null)
throw new InvalidDataException("L'esercizio selezionato non è più presente in archivio.");
GestioneCondomini.Domain.Spesa spesa;
if (dto.ID == 0)
{
spesa = new GestioneCondomini.Domain.Spesa(fornitore, esercizio, null);
var protocollo = _protocolloService.GetProgressivo(TipoProtocollo.Fattura, esercizio.DataApertura.GetValueOrDefault().Year, esercizio.CondominioRiferimento);
if (protocollo.Progressivo != null)
{
spesa.NumeroProtocollo = protocollo.Progressivo;
_daoFactory.GetSpesaDao().SaveOrUpdate(spesa);
}
else
message = protocollo.Message + Environment.NewLine;
}
else
{
spesa = _daoFactory.GetSpesaDao().GetById(dto.ID, false);
spesa.FornitoreRiferimento = fornitore;
spesa.EsercizioRiferimento = esercizio;
}
var info = new SpesaInfoDTO();
if (string.IsNullOrEmpty(message))
{
spesa.ImportoRitenuta = dto.Scadenze.Sum(item => item.ImportoRitenuta);
spesa.AltreSpese = dto.AltreSpese;
spesa.AltreSpeseEsenti = dto.SpeseEsenti;
spesa.SpeseEsentiRitenuta = dto.SpeseEsentiRitenuta;
spesa.CassaProfessionisti = dto.CassaProfessionisti;
spesa.DataDocumento = dto.DataDocumento;
spesa.NumeroDocumento = dto.NumeroDocumento;
spesa.AliquotaRitenuta = dto.AliquotaRitenuta;
spesa.IsAbilitataArchiviazioneOttica = dto.IsAbilitataArchiviazioneOttica;
spesa.IsRitenutaCalcoloImponibile = dto.IsRitenutaCalcoloImponibile;
spesa.Stato = StatoSpesaEnum.Pagata;
spesa.TipoDocumento = dto.TipoDocumento;
spesa.Detrazione = dto.Detrazione;
spesa.EsenteRegimeMinimo = dto.EsenteRegimeMinimo;
// ----------------------------------------------------
// Dettagli
// ----------------------------------------------------
spesa.Dettagli.Clear();
var index = 0;
foreach (var dtoDettaglio in dto.Dettagli)
{
index++;
DettaglioSpesa dettaglio;
if (dtoDettaglio.ID == 0)
dettaglio = new DettaglioSpesa(spesa, index);
else
{
dettaglio = _daoFactory.GetDettaglioSpesaDao().GetById(dtoDettaglio.ID, false);
dettaglio.NumeroRiga = index;
spesa.Dettagli.Add(dettaglio);
}
dettaglio.AliquotaIva = dtoDettaglio.AliquotaIva;
dettaglio.Descrizione = dtoDettaglio.Descrizione;
dettaglio.ImportoIva = dtoDettaglio.ImportoIva;
dettaglio.ImportoLordo = dtoDettaglio.ImportoLordo;
dettaglio.SoggettoRitenutaAcconto = dtoDettaglio.SoggettoRitenutaAcconto;
}
// ----------------------------------------------------
// Scadenze / Pagamenti
// ----------------------------------------------------
// Pulizia movimenti, scadenze e pagamenti presenti
foreach (var scadenza in spesa.Scadenze)
{
foreach (var pagamento in scadenza.Pagamenti)
_daoFactory.GetPagamentoDao().Delete(pagamento);
_daoFactory.GetScadenzaFatturaDao().Delete(scadenza);
}
spesa.Scadenze.Clear();
foreach (var scadenzaDto in dto.Scadenze)
{
var scadenzaNew = new ScadenzaFattura(spesa, scadenzaDto.DataPagamento, scadenzaDto.Importo) { Stato = StatoSpesaEnum.Pagata };
var pagamentoNew = new Pagamento(scadenzaNew, null, scadenzaNew.Importo, scadenzaNew.Scadenza, TipoPagamentoFatturaEnum.Immediato) { Stato = StatoSpesaEnum.Pagata };
scadenzaNew.Pagamenti.Add(pagamentoNew);
_daoFactory.GetScadenzaFatturaDao().SaveOrUpdate(scadenzaNew);
// -----------------------------------------------------
// Ritenuta
// -----------------------------------------------------
// ritenuta PAGATA dal vecchio amministratore i dati, compresi interessi e sanzioni servono per il modello 770
var ritenuta = new Ritenuta(scadenzaDto.ImportoRitenuta);
if (!scadenzaDto.RitenutaNONPagata)
{
ritenuta.Stato = StatoRitenutaEnum.PagataAltroAmministratore;
ritenuta.DataPagamentoRitenuta = scadenzaDto.DataPagamentoRitenuta;
ritenuta.ImportoInteressi = scadenzaDto.ImportoInteressi;
ritenuta.ImportoSanzione = scadenzaDto.ImportoSanzioni;
}
// ritenuta NON Pagata inserita come da pagare
else
{
ritenuta.Stato = StatoRitenutaEnum.Inserita;
ritenuta.DataPagamentoRitenuta = null;
_daoFactory.GetSpesaDao().SaveOrUpdate(spesa);
_movimentoContabileService.SetMovimentiRitenutaPagataAltroAmministratore(spesa, scadenzaDto.DataPagamento.GetValueOrDefault());
}
pagamentoNew.RitenutaAcconto = ritenuta;
}
info = new SpesaInfoDTO
{
Id = spesa.ID,
NumeroProtocollo = spesa.NumeroProtocollo.GetValueOrDefault(),
};
if (spesa.IsAbilitataArchiviazioneOttica)
{
var impostazioni = _daoFactory.GetImpostazioniAziendaDao().GetByAzienda(spesa.EsercizioRiferimento.CondominioRiferimento.Azienda.ID);
info.IdentificativoArchiviazione = _archiviazioneService.GetIdentificativoArchiviazione(spesa);
info.StampaEtichettaArchiviazione = impostazioni.UtilizzoEtichettatriceArchiviazioneOtticaFatture && spesa.EsercizioRiferimento.CondominioRiferimento.IsAbilitataArchiviazioneOtticaPassivi.GetValueOrDefault();
info.EtichettatriceArchiviazione = impostazioni.EtichettatriceArchiviazioneOttica;
info.TipoEtichettaArchiviazione = impostazioni.TipoEtichettaArchiviazioneOttica;
}
spesa.Stato = StatoSpesaEnum.PagataAltroAmministratore;
}
else
info.Message = message;
return info;
}
catch (Exception ex)
{
_log.Fatal("Errore inaspettato nel salvataggio della spesa FISCALE - " + Utility.GetMethodDescription() + " - spesa:" + dto.ID, ex);
throw;
}
}
