/// <summary>
/// Crea una Spesa Unità valida
/// </summary>
public SpeseUnita(decimal? importo, UnitaImmobiliare unita, SoggettoCondominio soggettoCondominio, MovimentoContabile movimento)
{
_importo = importo;
_unitaRiferimento = unita;
_soggettoCondominio = soggettoCondominio;
if (movimento != null)
{
_movimentoRiferimento = movimento;
_movimentoRiferimento.DettaglioRipartizione.Add(this);
}
}
private string insert(MovimentoContabileDTO dto, out MovimentoContabile item)
{
var message = string.Empty;
item = null;
try
{
var daoFactory = _windsorConfigRepository.GetContainer(_info.Azienda).Resolve<IDaoFactory>();
CausaleContabile causale = null;
if(dto.Causale != null)
causale = daoFactory.GetCausaleContabileDao().Find(dto.Causale.ID, false);
if (causale == null)
{
var idCausale = "<NULL>";
if (dto.Causale != null)
idCausale = dto.Causale.ID.ToString(CultureInfo.InvariantCulture);
_log.WarnFormat("Non è definito la causale per un movimento da inserire - {0} - causale:{1} - azienda:{2}", Utility.GetMethodDescription(), idCausale, _info.Azienda);
return "Non è definita la causale";
}
if (dto.NumeroRiga == null)
dto.NumeroRiga = 1;
DettaglioSpesa dettaglio = null;
var importo = Math.Round(dto.Importo.GetValueOrDefault(), 2);
var segno = dto.Segno;
if (importo < 0)
{
segno = invertiSegno(segno);
importo = importo*-1;
}
var conto = daoFactory.GetContoDao().Find(dto.IdConto.GetValueOrDefault(), false);
if (conto == null)
{
_log.WarnFormat("Non è definito il conto per un movimento da inserire - {0} - conto:{1} - azienda:{2}", Utility.GetMethodDescription(), dto.IdConto.GetValueOrDefault(), _info.Azienda);
return "Non è definito il conto economico";
}
if (dto.IdDettaglio != null)
{
dettaglio = daoFactory.GetDettaglioSpesaDao().GetById(dto.IdDettaglio.GetValueOrDefault(), false);
item = new MovimentoContabile(_testata, dettaglio, causale, dto.NumeroRiga, conto, importo, segno);
}
else
item = new MovimentoContabile(_testata, causale, dto.NumeroRiga, conto, importo, segno);
item.PercentualeProprieta = dto.PercentualeProprieta;
setSottoConto(dto, item, daoFactory);
if (dto.IdFornitore != null)
item.FornitoreRiferimento = daoFactory.GetFornitoreDao().GetById(dto.IdFornitore.Value, false);
item.Descrizione = dto.Descrizione;
item.NumeroAssegno = dto.NumeroAssegno;
item.Note = dto.Note;
item.GruppiAddebito = dto.GruppiAddebito;
item.LottiAddebito = dto.LottiAddebito;
item.StabiliAddebito = dto.StabiliAddebito;
if (dto.IsMovimentoEconomico != null)
item.IsMovimentoEconomico = dto.IsMovimentoEconomico.GetValueOrDefault();
if(dto.IdMovimentoStorno > 0)
{
var movimentoStorno = daoFactory.GetMovimentoContabileDao().Find(dto.IdMovimentoStorno.GetValueOrDefault(), false);
if(movimentoStorno != null)
{
movimentoStorno.LottiAddebito = item.LottiAddebito;
movimentoStorno.StabiliAddebito = item.StabiliAddebito;
movimentoStorno.GruppiAddebito = item.GruppiAddebito;
movimentoStorno.FornitoreRiferimento = item.FornitoreRiferimento;
movimentoStorno.ContoRiferimento = item.ContoRiferimento;
movimentoStorno.SottoContoRiferimento = item.SottoContoRiferimento;
item.MovimentoStorno = movimentoStorno;
}
}
// TODO: La valorizzazione del NumeroRegistrazione deve essere spostata nel Domain Model
if (dto.NumeroRegistrazione != null)
item.NumeroRegistrazione = dto.NumeroRegistrazione;
else
{
try
{
if(dettaglio != null)
{
var esercizio = daoFactory.GetEsercizioDao().GetById(dettaglio.SpesaRiferimento.EsercizioRiferimento.ID, true);
var numeroRegistrazione = esercizio.ProgressivoRegistrazioneContabile;
numeroRegistrazione++;
item.NumeroRegistrazione = numeroRegistrazione;
esercizio.ProgressivoRegistrazioneContabile = numeroRegistrazione;
}
}
catch (Exception ex)
{
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.Error("Errore inaspettato nel salvataggio (UPDATE) del numero di registrazione - " + Utility.GetMethodDescription(), ex);
var persistenceContext = _windsorConfigRepository.GetContainer(_info.Azienda).Resolve<IPersistenceContext>();
persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return message;
}
}
if (dto.IdEvasione != null)
item.EvasioneBancaria = daoFactory.GetEvasioneBancariaDao().Find(dto.IdEvasione.GetValueOrDefault(), false);
// ===========================================================================================
// BUGID#2159 - COMMENTATO: Con la nuova funzione di riparto aggregato gli oggetti SpeseUnita
// dovono essere usati SOLO per le spese personali o quando sono usate ripartizioni
// personalizzate
// ===========================================================================================
//if (dto.DettaglioRipartizione != null)
try
{
if (item.ContoRiferimento == null)
{
message = "Non è stato definito il conto di addebito";
_log.ErrorFormat("Conto a NULL - {0}", Utility.GetMethodDescription());
var persistenceContext = _windsorConfigRepository.GetContainer(_info.Azienda).Resolve<IPersistenceContext>();
persistenceContext.RollbackAndCloseSession(Login.Instance.CurrentLogin().LoginName);
persistenceContext.BeginTransaction(Login.Instance.CurrentLogin().LoginName, IsolationLevel.ReadUncommitted);
return message;
}
if ((item.ContoRiferimento.IsSpesePersonali || dto.IsRipartoPersonalizzato) && dto.DettaglioRipartizione != null)
{
var rep = new SpeseUnitaRepository(item, _info, _windsorConfigRepository);
foreach (var t in dto.DettaglioRipartizione)
{
if (t != null)
{
try
{
rep.ManageDomainEntity(t);
}
catch (Exception ex)
{
_log.Error("Errore nell'inserimento della testata del movimento: " + Utility.GetMethodDescription() + " - 1", ex);
throw;
}
}
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel salvataggio del movimento - (ManageDomainEntity) - {0} - azienda:{1}", ex, Utility.GetMethodDescription(), _info.Azienda);
throw;
}
item.IsRipartoPersonalizzato = dto.IsRipartoPersonalizzato;
daoFactory.GetMovimentoContabileDao().SaveOrUpdate(item);
}
catch(Exception ex)
{
_log.Error("Errore nel salvataggio del movimento: " + Utility.GetMethodDescription(), ex);
throw;
}
return message;
}
public MovimentoContabile SetMovimentiStornoPagamento(Pagamento pag, decimal importo, DateTime dataRegistrazione)
{
try
{
var esercizio = _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento, dataRegistrazione);
var message = IsAllowDataRegistrazione(new List<int> { pag.ScadenzaRiferimento.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 = "A";
if (importo < 0)
{
segno = "D";
importo = importo * -1;
}
var movimentoPatrimoniale = new MovimentoContabile(testata, pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga,
_daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID,
pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importo, segno)
{
Descrizione = "Storno Fatt. n." + pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento + " del " + pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString()
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
// ================================================
// Conto Patrimoniale
// ================================================
numeroRiga++;
var movimentoBancario = new MovimentoContabile(testata, causale, numeroRiga, pag.Conto, importo, invertiSegno(segno))
{
Descrizione = movimentoPatrimoniale.Descrizione,
FornitoreRiferimento = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento,
SottoContoRiferimento = pag.SottoConto,
ContoCorrenteBancario = pag.ContoCorrenteBancario
};
pag.MovimentoContabileStorno = movimentoBancario;
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);
return movimentoBancario;
}
var ex = new InvalidDataException(string.Format("La data di registrazione {0:d} non è valida", dataRegistrazione));
_log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - pagamento:{2} - importo:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, pag.ID, importo);
throw ex;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella funzione - {0} - data:{1} - pagamento:{2} - importo:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, pag.ID, importo);
throw;
}
}
public TestataMovimentoContabile SetMovimentiInserimentoSpesa(Spesa spesa, TestataMovimentoContabile testata, DateTime dataRegistrazione)
{
var message = IsAllowDataRegistrazione(new List<int> {spesa.EsercizioRiferimento.CondominioRiferimento.ID}, spesa.EsercizioRiferimento, dataRegistrazione);
if (message.Count == 0)
{
_daoFactory.GetSpesaDao().SaveOrUpdate(spesa);
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IF");
if (testata == null)
testata = new TestataMovimentoContabile(spesa.EsercizioRiferimento, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null);
testata.SpesaRiferimento = spesa;
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
// ------------------------------------------------
// Conto economico
// ------------------------------------------------
var numeroRiga = 0;
var importoEconomico = 0m;
foreach (var dettaglio in spesa.Dettagli)
{
if (numeroRiga == 0)
testata.Descrizione = dettaglio.GetDescrizione();
foreach (var movimento in dettaglio.Movimenti)
{
movimento.Testata = testata;
movimento.IsMovimentoEconomico = true;
testata.Movimenti.Add(movimento);
numeroRiga++;
movimento.NumeroRiga = numeroRiga;
if (movimento.Importo < 0)
_log.WarnFormat("Presente importo movimento con segno negativo - {0} - movimento:{1}", Utility.GetMethodDescription(), movimento.ID);
importoEconomico += Math.Round(movimento.GetImportoPerSpesa(true).GetValueOrDefault(), 2);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
}
}
foreach (var movimento in spesa.MovimentiBollette)
{
movimento.Testata = testata;
movimento.IsMovimentoEconomico = true;
testata.Movimenti.Add(movimento);
numeroRiga++;
movimento.NumeroRiga = numeroRiga;
if (movimento.GetImportoConSegno() < 0)
{
movimento.Segno = "A";
movimento.Importo = movimento.GetImportoConSegno()*-1;
}
importoEconomico += movimento.Importo.GetValueOrDefault();
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
}
// ------------------------------------------------
// Debiti VS Fornitori
// ------------------------------------------------
var importoTotale = spesa.ImportoLordo + spesa.AltreSpeseEsenti.GetValueOrDefault();
var importoTotaleArrotondato = Math.Round(importoTotale, 2);
numeroRiga++;
var segno = "A";
if (importoTotale < 0)
{
segno = "D";
importoTotaleArrotondato = importoTotaleArrotondato*-1;
}
var movimentoPatrimoniale = new MovimentoContabile(testata, spesa.FornitoreRiferimento, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(spesa.EsercizioRiferimento.ID, spesa.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importoTotaleArrotondato, segno)
{
Descrizione = $"Fatt. n. {spesa.NumeroDocumento} del {spesa.DataDocumento.GetValueOrDefault():d}"
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
// ------------------------------------------------
// Eventuale arrotondamento
// ------------------------------------------------
if (spesa.TipoDocumento == "NOTACC" || spesa.ImportoLordo < 0)
importoTotaleArrotondato = importoTotaleArrotondato*-1;
setMovimentoArrotondamento(importoTotaleArrotondato, importoEconomico, numeroRiga, spesa, testata, causale, null);
return testata;
}
var ex = new InvalidDataException($"La data di registrazione {dataRegistrazione:d} non è valida");
_log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - spesa:{2} - dataRegistrazione:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, spesa.ID, dataRegistrazione);
throw ex;
}
public void DeleteSingoloMovimento(MovimentoContabile mov)
{
try
{
if(mov != null)
{
if (mov.Testata != null)
{
mov.Testata.Movimenti.Remove(mov);
mov.Testata = null;
}
if (mov.ContoRiferimento != null)
{
mov.ContoRiferimento.Movimenti.Remove(mov);
mov.ContoRiferimento = null;
}
if (mov.CondominoRiferimento != null)
{
mov.CondominoRiferimento.Movimenti.Remove(mov);
mov.CondominoRiferimento = null;
}
if (mov.EvasioneBancaria != null)
{
mov.EvasioneBancaria.MovimentiContabili.Remove(mov);
mov.EvasioneBancaria = null;
}
if (mov.FornitoreRiferimento != null)
{
mov.FornitoreRiferimento.MovimentiContabili.Remove(mov);
mov.FornitoreRiferimento = null;
}
if (mov.ContoCorrenteBancario != null)
{
mov.ContoCorrenteBancario.MovimentiContabili.Remove(mov);
mov.ContoCorrenteBancario = null;
}
if (mov.DettaglioRiferimento != null)
{
mov.DettaglioRiferimento.Movimenti.Remove(mov);
mov.DettaglioRiferimento = null;
}
if(mov.Spesa != null)
{
mov.Spesa.MovimentiBollette.Remove(mov);
mov.Spesa = null;
}
mov.DettaglioRipartizione.Clear();
_daoFactory.GetMovimentoContabileDao().Delete(mov);
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la cancellazione di un singolo movimento - {0} - id:{1}", ex, Utility.GetMethodDescription(), mov.ID);
throw;
}
}
public TestataResult SetBilancioApertura(TestataMovimentoContabileGestioneDTO testataDto)
{
try
{
if(testataDto.DataRegistrazione == null)
throw new InvalidDataException("Non è definita la data di registrazione");
var message = string.Empty;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("AB");
var numeroRiga = 0;
var esercizio = _daoFactory.GetEsercizioDao().GetById(testataDto.CodiceEsercizio, false);
var saldiCondomini = _daoFactory.GetSaldoSoggettoDao().GetByEsercizioStabileScala(esercizio, null, null);
// Controllo correttezza importi
TestataMovimentoContabile testata = null;
if (testataDto.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()) != testataDto.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()))
message = "Il totale Dare:" + testataDto.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()).ToString("c") + " non corrisponde col totale Avere:" + testataDto.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()).ToString("c") + Environment.NewLine;
else if (testataDto.DataRegistrazione == null)
message = "Deve essere definita la data di registrazione" + Environment.NewLine;
else
{
foreach (var movimentoDto in testataDto.Movimenti)
{
if (movimentoDto.Stato == "U")
{
var conto = _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.GetValueOrDefault(), false);
if (conto.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini() && saldiCondomini.Count == 0)
{
message = "Prima di registrare il bilancio di apertura occorre inserire i saldi iniziali dei condomini" + Environment.NewLine;
break;
}
}
}
}
if(string.IsNullOrEmpty(message))
{
// controllo data registrazione
var messageData = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, testataDto.DataRegistrazione.GetValueOrDefault());
if (messageData.Count > 0)
{
_log.WarnFormat("Data di registrazione non valida - {0} - data:{1} - esercizio:{2}", Utility.GetMethodDescription(), testataDto.DataRegistrazione.GetValueOrDefault(), esercizio.ID);
return new TestataResult(null, messageData.Aggregate(message, (current, mess) => current + (mess + Environment.NewLine)));
}
const string hql = "FROM Esercizio ES WHERE ES.CondominioRiferimento = :condominio AND ES.DataApertura >= :data AND ES.DataChiusura <= :data AND ES.Gestione = :gestione";
var listaEsercizi = _daoFactory.GetEsercizioDao().GetByQuery(hql, new[] { new QueryParam("condominio", esercizio.CondominioRiferimento), new QueryParam("data", testataDto.DataRegistrazione.Value), new QueryParam("gestione", Conversione.ToHQLParameter(GestioneEsercizioEnum.Ordinario)) });
if (listaEsercizi.Count == 1)
esercizio = listaEsercizi[0];
testata = _daoFactory.GetTestataMovimentoContabileDao().Find(testataDto.ID, false);
if (testata == null)
{
testata = new TestataMovimentoContabile(esercizio, testataDto.DataRegistrazione.Value, TipoTestataMovimentoContabileEnum.Automatica, null) {AperturaBilancio = true};
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
}
else
{
testata.EsercizioRiferimento = esercizio;
testata.DataRegistrazione = testataDto.DataRegistrazione.Value;
}
testata.Descrizione = testataDto.Descrizione;
foreach (var movimentoDto in testataDto.Movimenti)
{
if (movimentoDto.Stato == "U")
{
var conto = _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.GetValueOrDefault(), false);
string segno;
decimal importo;
if (movimentoDto.ImportoAvere > 0)
{
importo = movimentoDto.ImportoAvere.GetValueOrDefault();
segno = "A";
}
else
{
importo = movimentoDto.ImportoDare.GetValueOrDefault();
segno = "D";
}
// =========================================================================================
// Per il conto versamenti SOLO ESERCIZIO ORDINARIO spalmo l'importo in base ai versamenti dei singoli condomini
// Elimino tutti i movimenti presenti
// =========================================================================================
MovimentoContabile movimento = null;
if (conto.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini() && conto.EsercizioRiferimento == null)
{
// elimino i movimenti
var movimentiOld = testata.Movimenti.Where(item => item.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini()).ToList();
bool deleteOriginalMovimento = movimentoDto.ID > 0;
foreach (var movimentoContabile in movimentiOld)
{
if (movimentoContabile.ID == movimentoDto.ID)
deleteOriginalMovimento = false;
DeleteSingoloMovimento(movimentoContabile);
}
if(deleteOriginalMovimento)
DeleteSingoloMovimento(_daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false));
// creo i nuovi movimenti
foreach (var saldoSoggetto in saldiCondomini)
{
var importoCondomino = saldoSoggetto.Importo;
segno = "D";
if (importoCondomino < 0)
{
segno = "A";
importoCondomino = importoCondomino*-1;
}
numeroRiga++;
movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, importoCondomino, segno) {Descrizione = movimentoDto.Descrizione};
if (string.IsNullOrEmpty(movimento.Descrizione))
movimento.Descrizione = string.Format("Apertura Conto {0}", saldoSoggetto.Soggetto.DisplayName);
movimento.CondominoRiferimento = saldoSoggetto.Soggetto;
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
testata.Movimenti.Add(movimento);
}
}
else
{
movimento = _daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
if (movimento == null)
{
numeroRiga++;
movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, importo, segno) {Descrizione = movimentoDto.Descrizione};
if (string.IsNullOrEmpty(movimento.Descrizione))
movimento.Descrizione = "Apertura Conto";
if (movimentoDto.IdFornitore != null && movimentoDto.IdFornitore.GetValueOrDefault() > 0)
movimento.FornitoreRiferimento = _daoFactory.GetFornitoreDao().GetById(movimentoDto.IdFornitore.Value, false);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
testata.Movimenti.Add(movimento);
}
else
{
numeroRiga++;
movimento.Segno = segno;
movimento.Importo = importo;
movimento.ContoRiferimento = conto;
movimento.NumeroRiga = numeroRiga;
movimento.Descrizione = movimentoDto.Descrizione;
if (movimentoDto.IdFornitore != null && movimentoDto.IdFornitore.GetValueOrDefault() > 0)
movimento.FornitoreRiferimento = _daoFactory.GetFornitoreDao().GetById(movimentoDto.IdFornitore.Value, false);
testata.Movimenti.Add(movimento);
}
}
if (movimento != null)
{
movimentoDto.IdMovimentoRiferimento = movimento.ID;
if (movimentoDto.IdSpesa > 0)
movimento.Spesa = _daoFactory.GetSpesaDao().GetById(movimentoDto.IdSpesa, false);
if (movimentoDto.IdSottoConto != null)
{
if (movimentoDto.IdSottoConto > 0)
{
if (movimento.ContoRiferimento.Codice != _pianoContiService.GetCodiceContoFornitori() && movimento.ContoRiferimento.Codice != _pianoContiService.GetCodiceContoRitenuta() && movimento.ContoRiferimento.Codice != _pianoContiService.GetCodiceContoVersamentiCondomini() && movimento.ContoRiferimento.Codice != _pianoContiService.GetCodiceContoRateCondomini())
{
var sottoConto = _daoFactory.GetSottoContoDao().GetById(movimentoDto.IdSottoConto.Value, false);
movimento.SottoContoRiferimento = sottoConto;
}
}
else
{
try
{
if (movimento.ContoRiferimento != null && !string.IsNullOrEmpty(movimento.ContoRiferimento.Codice))
{
if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoBancario())
{
var banca = _daoFactory.GetDatiBancariCondominiDao().Find(movimentoDto.IdSottoConto.Value * -1, false);
if (banca != null)
movimento.ContoCorrenteBancario = banca;
}
else if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini())
{
var soggettoCondominio = _daoFactory.GetSoggettoCondominioDao().Find(movimentoDto.IdSottoConto.Value*-1, false);
if (soggettoCondominio != null)
movimento.CondominoRiferimento = soggettoCondominio;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore imprevisto - CONTO CORRENTE - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
}
}
}
}
}
}
}
return new TestataResult(testata, message);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante l'aggiornamento della quadratura iniziale dei contabili - {0}", ex, Utility.GetMethodDescription());
throw;
}
}
public TestataMovimentoContabile SetMovimentiAddebitoCompetenze(AddebitoCompetenzaDTO addebito)
{
try
{
// se la testata è automatica non è possibile aggiornare gli importi nel dettaglio, se manuale è possibile l'aggiornamento.
// per ora la testata viene inserita come manuale.
TestataMovimentoContabile testata;
var esercizio = _daoFactory.GetEsercizioDao().Find(addebito.IdEsercizio, false);
var dataRegistrazione = addebito.DataRegistrazioneMovimentoContabile;
// controllo data registrazione
var messageData = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
if (messageData.Count == 0)
{
testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Manuale, null) {Descrizione = addebito.Descrizione, IsAllowUpdate = true};
var causale = _daoFactory.GetCausaleContabileDao().Find(addebito.IdCausale, false) ?? _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
var numeroRiga = 0;
// Contropartita
numeroRiga++;
var contoContropartita = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, "913");
new MovimentoContabile(testata, causale, numeroRiga, contoContropartita, addebito.Dettaglio.Sum(item => item.Importo), "A") {Descrizione = addebito.Descrizione};
foreach (var item in addebito.Dettaglio)
{
try
{
if (item.Importo != 0)
{
numeroRiga++;
var conto = _daoFactory.GetContoDao().Find(item.IdConto, false);
if (conto != null)
{
SottoConto sottoConto = null;
if (item.IdSottoConto != null)
sottoConto = _daoFactory.GetSottoContoDao().GetById(item.IdSottoConto.Value, false);
var soggetto = _daoFactory.GetSoggettoCondominioDao().Find(item.IdCondomino.GetValueOrDefault(), false);
if (soggetto != null)
{
var movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, item.Importo, "D")
{
SottoContoRiferimento = sottoConto,
Descrizione = item.DescrizioneMovimentoContabile,
CondominoRiferimento = soggetto
};
switch (soggetto.Tipo)
{
case TipoSoggetto.Proprietario:
movimento.PercentualeProprieta = 1;
break;
case TipoSoggetto.Conduttore:
movimento.PercentualeProprieta = 0;
break;
}
movimento.IsRipartoPersonalizzato = true;
new SpeseUnita(item.Importo, null, soggetto, movimento);
var dettaglio = _daoFactory.GetDettaglioAddebitoCompetenzaDao().Find(item.ID, false);
if (dettaglio != null)
{
dettaglio.MovimentoContabile = movimento;
dettaglio.Soggetto = soggetto;
}
}
}
}
}
catch (Exception ex)
{
_log.Fatal(
"Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - SINGOLO SOGGETTO - " +
Utility.GetMethodDescription() + " - id:" + item.ID + " - importo:" +
item.Importo + " - soggetto:" + item.IdCondomino + " - conto:" + item.IdConto +
" - sottoconto:" + item.IdSottoConto.GetValueOrDefault() + " - addebito:" + addebito.ID +
" - IdEsercizio:" + addebito.IdEsercizio, ex);
throw;
}
}
var addebitoItem = _daoFactory.GetAddebitoCompetenzaDao().Find(addebito.ID, false);
if (addebitoItem != null)
addebitoItem.TestataMovimento = testata;
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
}
else
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
_log.Fatal("Data di registrazione non valida - " + Utility.GetMethodDescription() + " - data:" + dataRegistrazione + " - addebito:" + addebito.ID + " - IdEsercizio:" + addebito.IdEsercizio, ex);
throw ex;
}
return testata;
}
catch (Exception ex)
{
_log.Fatal("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - " + Utility.GetMethodDescription() + " - addebito:" + addebito.ID + " - IdEsercizio:" + addebito.IdEsercizio, ex);
throw;
}
}
public TestataMovimentoContabile SetMovimentiSollecito(Esercizio esercizio, IList<Sollecito> solleciti, DateTime dataRegistrazione, Conto conto, SottoConto sottoconto)
{
try
{
// controllo data registrazione
var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
if (message.Count > 0)
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - conto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, conto.ID, esercizio.ID);
throw ex;
}
var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null)
{
Descrizione = "Addebito solleciti del " + dataRegistrazione.ToShortDateString(),
IsAllowUpdate = true
};
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
var numeroRiga = 0;
// Contropartita
numeroRiga++;
var contoContropartita = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, "913");
new MovimentoContabile(testata, causale, numeroRiga, contoContropartita, solleciti.Sum(item => item.ImportoCompetenza.GetValueOrDefault()), "A");
foreach (var soll in solleciti)
{
numeroRiga++;
var movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, soll.ImportoCompetenza, "D") {SottoContoRiferimento = sottoconto};
if (soll.Soggetto != null)
movimento.CondominoRiferimento = soll.Soggetto;
soll.MovimentoEconomico = movimento;
movimento.IsRipartoPersonalizzato = true;
var soggetto = soll.Soggetto ?? soll.Persona.SoggettiCondominio.FirstOrDefault(item => item.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.CondominioRiferimento.ID == soll.Esercizio.CondominioRiferimento.ID);
if (soggetto != null)
{
movimento.CondominoRiferimento = soggetto;
switch (soggetto.Tipo)
{
case TipoSoggetto.Proprietario:
movimento.PercentualeProprieta = 1;
break;
case TipoSoggetto.Conduttore:
movimento.PercentualeProprieta = 0;
break;
}
new SpeseUnita(soll.ImportoCompetenza, null, soggetto, movimento);
}
}
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
return testata;
}
catch (Exception ex)
{
_log.Fatal("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - " + Utility.GetMethodDescription() + " - IdEsercizio:" + esercizio.ID.ToString(), ex);
throw;
}
}
public TestataMovimentoContabile SetMovimentiSingolaRata(RataSoggetto rata, decimal importo, SoggettoCondominio soggetto, Esercizio esercizio, TestataMovimentoContabile testata, DateTime dataRegistrazione)
{
return null;
var numeroRiga = 0;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("ER");
var message = IsAllowDataRegistrazione(new List<int> {esercizio.CondominioRiferimento.ID}, esercizio, dataRegistrazione);
if (message.Count > 0)
{
_log.ErrorFormat("Tentativo di registrazione con data esterno all'intervallo consentito - {0} - rata:{1} - importo:{2} - soggetto:{3} - esercizio:{4}", Utility.GetMethodDescription(), rata.ID, importo, soggetto.ID, esercizio.ID);
throw new InvalidDataException(string.Format("Tentativo di registrazione con data esterno all'intervallo consentito - data:{0}", dataRegistrazione.ToShortDateString()));
}
// ------------------------------------------------
// Testata
// ------------------------------------------------
if (testata == null)
{
testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null);
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
}
else
numeroRiga = testata.Movimenti.Max(mov => mov.NumeroRiga.GetValueOrDefault());
// ------------------------------------------------
// Rata
// ------------------------------------------------
numeroRiga++;
var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRateCondomini()), importo, "A") {CondominoRiferimento = soggetto};
string descrizioneRata;
if (rata != null)
descrizioneRata = "Rata n." + rata.PianoRatealeDettaglio.Progressivo;
else
descrizioneRata = "Rata";
movimentoPatrimoniale.Descrizione = descrizioneRata + " - " + movimentoPatrimoniale.CondominoRiferimento.DisplayName;
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
// ------------------------------------------------
// Crediti V/S Condomini
// ------------------------------------------------
numeroRiga++;
var movimentoPatrimonialeCrediti = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini()), importo, "D")
{
CondominoRiferimento = soggetto,
Descrizione = movimentoPatrimoniale.Descrizione
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimonialeCrediti);
return testata;
}
public void SetMovimentiRitenutaPagataAltroAmministratore(Spesa spesa, DateTime dataRegistrazione)
{
try
{
if (spesa.EsercizioRiferimento == null)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - TESTATA - {0} - spesa:{1}", Utility.GetMethodDescription(), spesa.ID);
throw (new Exception("Non è definito l'esercizio di competenza per la spesa"));
}
var numeroRiga = 0;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("VR");
// ------------------------------------------------
// Testata
// ------------------------------------------------
TestataMovimentoContabile testata;
try
{
testata = new TestataMovimentoContabile(spesa.EsercizioRiferimento, DateTime.Today, TipoTestataMovimentoContabileEnum.Automatica, null)
{
DataRegistrazione = dataRegistrazione,
SpesaRiferimento = spesa
};
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
}
catch (Exception ex)
{
var countScadenze = string.Empty;
if (spesa.Scadenze != null)
countScadenze = spesa.Scadenze.Count.ToString();
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - TESTATA - {0} - spesa:{1} - scadenze:{2}", ex, Utility.GetMethodDescription(), spesa.ID, countScadenze);
throw;
}
// ------------------------------------------------
// Ritenuta
// ------------------------------------------------
numeroRiga++;
MovimentoContabile movimentoPatrimoniale;
var segnoRitenuta = "A";
try
{
var importoRitenuta = spesa.ImportoRitenuta.GetValueOrDefault();
if (spesa.ImportoRitenuta < 0)
{
segnoRitenuta = "D";
importoRitenuta = importoRitenuta*-1;
}
var contoRitenuta = _daoFactory.GetContoDao().GetByCodice(spesa.EsercizioRiferimento.ID, spesa.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRitenuta());
if (contoRitenuta != null)
{
try
{
movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, contoRitenuta, importoRitenuta, segnoRitenuta)
{
FornitoreRiferimento = spesa.FornitoreRiferimento,
Descrizione = "Ritenuta Fatt. n." + spesa.NumeroDocumento + " del " + spesa.DataDocumento.GetValueOrDefault().ToShortDateString()
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - RITENUTA INT - {0} - spesa:{1}", ex, Utility.GetMethodDescription(), spesa.ID);
throw;
}
}
else
{
_log.FatalFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - RITENUTA - {0} - spesa:{1}", Utility.GetMethodDescription(), spesa.ID);
throw (new InvalidDataException("Non trovato il conto per la registrazione delle Ritenute di Acconto"));
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - RITENUTA EXT - {0} - spesa:{1}", ex, Utility.GetMethodDescription(), spesa.ID);
throw;
}
// ------------------------------------------------
// Conto Patrimoniale
// ------------------------------------------------
numeroRiga++;
var segno = "D";
if (segnoRitenuta == "D")
segno = "A";
var contoPatrimonialeAltreSpese = _daoFactory.GetContoDao().GetByCodice(spesa.EsercizioRiferimento.ID, spesa.EsercizioRiferimento.CondominioRiferimento.ID, "909");
if (contoPatrimonialeAltreSpese != null)
{
try
{
var movimentoSpeseNonCompetenza = new MovimentoContabile(testata, causale, numeroRiga, contoPatrimonialeAltreSpese, movimentoPatrimoniale.Importo, segno)
{
FornitoreRiferimento = movimentoPatrimoniale.FornitoreRiferimento,
Descrizione = movimentoPatrimoniale.Descrizione
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSpeseNonCompetenza);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - PATRIMONIALE - {0} - spesa:{1}", ex, Utility.GetMethodDescription(), spesa.ID);
throw;
}
}
else
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - PATRIMONIALE - {0} - spesa:{1}", Utility.GetMethodDescription(), spesa.ID);
throw (new InvalidDataException("Non trovato il conto (909) patrimoniale per la registrazione delle Ritenute di Acconto"));
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di ritenuta pagata da altro amministratore - {0} - spesa:{1}", ex, Utility.GetMethodDescription(), spesa.ID);
throw;
}
}
public TestataMovimentoContabile SetMovimentiRitenuta(Pagamento pagamento, Ritenuta ritenuta, Conto contoPatrimoniale, int? idSottoConto, DateTime dataRegistrazione, string descrizione, string descrizioneAddebitoInteressi, string descrizioneAddebitoSanzioni, decimal? importo)
{
var esercizio = _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(pagamento.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento, dataRegistrazione);
if (esercizio == null || esercizio.Stato == StatoEsercizioEnum.Chiuso)
{
throw new InvalidDataException(string.Format("La data di registrazione {0:d} del versamento della ritenuta per {1:c} non è valida per il condominio:'{2}' perchè non è stato trovato un esercizio aperto di competenza", dataRegistrazione, ritenuta.Importo, pagamento.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DisplayName));
}
var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
if (message.Count == 0)
{
var numeroRiga = 0;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("VR");
var importoRitenuta = ritenuta.Importo.GetValueOrDefault();
if (importo != null)
importoRitenuta = importo.Value;
importoRitenuta = Math.Round(importoRitenuta, 2);
// ------------------------------------------------
// Testata
// ------------------------------------------------
var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null) { SpesaRiferimento = pagamento.ScadenzaRiferimento.SpesaRiferimento };
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
var contoRitenuta = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRitenuta());
var spesa = pagamento.ScadenzaRiferimento.SpesaRiferimento;
var firstDettaglio = spesa.Dettagli.FirstOrDefault();
TestataMovimentoContabile testataFattura = null;
if (firstDettaglio != null)
{
var firstMovimento = firstDettaglio.Movimenti.FirstOrDefault();
if (firstMovimento != null)
testataFattura = firstMovimento.Testata;
}
// ------------------------------------------------
// Interessi per Ravvedimento Operoso
// ------------------------------------------------
if (ritenuta.ImportoInteressi > 0)
{
if (testataFattura != null && !testataFattura.AperturaBilancio)
{
foreach (var dettaglio in spesa.Dettagli)
{
if (dettaglio.Movimenti.Count > 0)
{
foreach (var movimento in dettaglio.Movimenti)
{
var importoMovimento = movimento.GetImportoConSegno().GetValueOrDefault();
if (movimento.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
importoMovimento = importoMovimento * -1;
numeroRiga++;
var interesseCompetenza = ritenuta.ImportoInteressi.GetValueOrDefault();
if (spesa.ImportoLordo != 0)
interesseCompetenza = (ritenuta.ImportoInteressi.GetValueOrDefault() * importoMovimento) / spesa.ImportoLordo;
var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, interesseCompetenza, "D")
{
SottoContoRiferimento = movimento.SottoContoRiferimento,
FornitoreRiferimento = movimento.FornitoreRiferimento
};
if (!string.IsNullOrEmpty(descrizioneAddebitoInteressi))
movimentoInteresse.Descrizione = descrizioneAddebitoInteressi.Replace("<DescrizioneSpesa>", movimento.GetDescrizione());
_ripartizioneService.CloneRipartizioneByMovimento(movimentoInteresse, movimento);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);
}
}
else
{
numeroRiga++;
var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, contoRitenuta, ritenuta.ImportoInteressi, "D")
{
FornitoreRiferimento = spesa.FornitoreRiferimento,
Descrizione = "Interesse versamento ritenuta"
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);
}
}
}
else
{
numeroRiga++;
var sottoContoInteressiSanzioni = _daoFactory.GetSottoContoDao().GetInteressiSanzioniByEsercizio(testata.EsercizioRiferimento.ID, testata.EsercizioRiferimento.CondominioRiferimento.ID);
if (sottoContoInteressiSanzioni != null)
{
var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, sottoContoInteressiSanzioni.ContoRiferimento, ritenuta.ImportoInteressi, "D")
{
SottoContoRiferimento = sottoContoInteressiSanzioni,
FornitoreRiferimento = spesa.FornitoreRiferimento,
Descrizione = "Interesse versamento ritenuta"
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);
}
else
{
ritenuta.ImportoInteressi = 0;
}
}
}
// ------------------------------------------------
// Sanzione per Ravvedimento Operoso
// ------------------------------------------------
if (ritenuta.ImportoSanzione > 0)
{
if (testataFattura != null && !testataFattura.AperturaBilancio)
{
foreach (var dettaglio in spesa.Dettagli)
{
if (dettaglio.Movimenti.Count > 0)
{
foreach (var movimento in dettaglio.Movimenti)
{
var importoMovimento = movimento.GetImportoConSegno().GetValueOrDefault();
if (movimento.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
importoMovimento = importoMovimento*-1;
numeroRiga++;
var sanzioneCompetenza = ritenuta.ImportoSanzione.GetValueOrDefault();
if (spesa.ImportoLordo != 0)
sanzioneCompetenza = (ritenuta.ImportoSanzione.GetValueOrDefault()*
importoMovimento)/spesa.ImportoLordo;
var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga,
movimento.ContoRiferimento, sanzioneCompetenza, "D")
{
SottoContoRiferimento = movimento.SottoContoRiferimento,
FornitoreRiferimento = movimento.FornitoreRiferimento
};
if (!string.IsNullOrEmpty(descrizioneAddebitoSanzioni))
movimentoSanzione.Descrizione = descrizioneAddebitoSanzioni.Replace("<DescrizioneSpesa>", movimento.GetDescrizione());
_ripartizioneService.CloneRipartizioneByMovimento(movimentoSanzione, movimento);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);
}
}
else
{
numeroRiga++;
var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga, contoRitenuta, ritenuta.ImportoSanzione, "D")
{
FornitoreRiferimento = spesa.FornitoreRiferimento,
Descrizione = "Sanzione versamento ritenuta"
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);
}
}
}
else
{
numeroRiga++;
var sottoContoInteressiSanzioni = _daoFactory.GetSottoContoDao().GetInteressiSanzioniByEsercizio(testata.EsercizioRiferimento.ID, testata.EsercizioRiferimento.CondominioRiferimento.ID);
if (sottoContoInteressiSanzioni != null)
{
var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga, sottoContoInteressiSanzioni.ContoRiferimento, ritenuta.ImportoSanzione, "D")
{
SottoContoRiferimento = sottoContoInteressiSanzioni,
FornitoreRiferimento = spesa.FornitoreRiferimento,
Descrizione = "Sanzione versamento ritenuta"
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);
}
else
{
ritenuta.ImportoSanzione = 0;
}
}
}
// ------------------------------------------------
// Ritenuta
// ------------------------------------------------
numeroRiga++;
var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, contoRitenuta, importoRitenuta, "D")
{
FornitoreRiferimento = pagamento.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento,
Descrizione = "Ritenuta " + pagamento.GetDescrizione()
};
if (!string.IsNullOrEmpty(descrizione))
movimentoPatrimoniale.Descrizione += " - " + descrizione;
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
// ------------------------------------------------
// Conto Patrimoniale
// ------------------------------------------------
numeroRiga++;
var movimentoBancario = new MovimentoContabile(testata, causale, numeroRiga, contoPatrimoniale, importoRitenuta + ritenuta.ImportoInteressi.GetValueOrDefault() + ritenuta.ImportoSanzione.GetValueOrDefault(), "A")
{
FornitoreRiferimento = movimentoPatrimoniale.FornitoreRiferimento,
Descrizione = movimentoPatrimoniale.Descrizione
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);
if (idSottoConto != null)
{
if (idSottoConto > 0)
movimentoBancario.SottoContoRiferimento = _daoFactory.GetSottoContoDao().GetById(idSottoConto.Value, false);
if (idSottoConto < 0)
movimentoBancario.ContoCorrenteBancario = _daoFactory.GetDatiBancariCondominiDao().GetById(idSottoConto.Value*-1, false);
}
if (contoPatrimoniale.Codice == _pianoContiService.GetCodiceContoBancario() &&
movimentoBancario.ContoCorrenteBancario == null)
movimentoBancario.ContoCorrenteBancario = esercizio.CondominioRiferimento.DatiBancariPrincipale;
testata.Descrizione = movimentoPatrimoniale.Descrizione;
ritenuta.MovimentoContabilePagamento = movimentoBancario;
return testata;
}
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - pagamento:{2} - conto:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, pagamento.ID, contoPatrimoniale.ID);
throw ex;
}
public void SetMovimentiInteressiSanzioni(Spesa spesa)
{
try
{
foreach (var pag in spesa.Pagamenti)
{
try
{
var movimentiDaEliminare = _daoFactory.GetMovimentoContabileDao().GetInteressiSanzioniByPagamento(pag.ID);
if (movimentiDaEliminare.Count > 0)
{
var testata = movimentiDaEliminare[0].Testata;
var causale = movimentiDaEliminare[0].Causale;
var numeroRiga = testata.Movimenti.Max(item => item.NumeroRiga.GetValueOrDefault()) + 1;
// ------------------------------------------------
// Interessi per Ravvedimento Operoso
// ------------------------------------------------
try
{
if (pag.RitenutaAcconto.ImportoInteressi > 0)
{
var descrizioneAddebitoInteressi = string.Empty;
var movimentoInteresseOld = movimentiDaEliminare.FirstOrDefault(item => item.TipoInteresseSanzione == TipoInteresseSanzioneEnum.Interesse);
if (movimentoInteresseOld != null)
descrizioneAddebitoInteressi = movimentoInteresseOld.Descrizione;
foreach (var dettaglio in spesa.Dettagli)
{
foreach (var movimento in dettaglio.Movimenti)
{
var importoMovimento = movimento.GetImportoConSegno().GetValueOrDefault();
if (movimento.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
importoMovimento = importoMovimento * -1;
var interesseCompetenza = (pag.RitenutaAcconto.ImportoInteressi.GetValueOrDefault() * importoMovimento) / spesa.ImportoLordo;
var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, interesseCompetenza, "D")
{
SottoContoRiferimento = movimento.SottoContoRiferimento,
FornitoreRiferimento = movimento.FornitoreRiferimento,
Descrizione = descrizioneAddebitoInteressi.Replace("<DescrizioneSpesa>", movimento.GetDescrizione()),
TipoInteresseSanzione = TipoInteresseSanzioneEnum.Interesse,
PagamentoInteresseSanzione = pag
};
// "Interessi ravv. operoso - " + movimento.GetDescrizione();
_ripartizioneService.CloneRipartizioneByMovimento(movimentoInteresse, movimento);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);
}
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la scrittura dei movimenti per interessi e sanzioni (SINGOLO PAGAMENTO - INTERESSI) - {0} - pagamento:{1} - spesa:{2}", ex, Utility.GetMethodDescription(), pag.ID, spesa.ID);
throw;
}
// ------------------------------------------------
// Sanzione per Ravvedimento Operoso
// ------------------------------------------------
try
{
if (pag.RitenutaAcconto.ImportoSanzione > 0)
{
var movimentoSanzioneOld = movimentiDaEliminare.FirstOrDefault(item => item.TipoInteresseSanzione == TipoInteresseSanzioneEnum.Sanzione);
if (movimentoSanzioneOld != null)
{
var descrizioneAddebitoSanzioni = movimentoSanzioneOld.Descrizione;
foreach (var dettaglio in spesa.Dettagli)
{
foreach (var movimento in dettaglio.Movimenti)
{
var importoMovimento = movimento.GetImportoConSegno().GetValueOrDefault();
if (movimento.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
importoMovimento = importoMovimento * -1;
var sanzioneCompetenza = (pag.RitenutaAcconto.ImportoSanzione.GetValueOrDefault() * importoMovimento) / spesa.ImportoLordo;
var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, sanzioneCompetenza, "D")
{
SottoContoRiferimento = movimento.SottoContoRiferimento,
FornitoreRiferimento = movimento.FornitoreRiferimento,
Descrizione = descrizioneAddebitoSanzioni.Replace("<DescrizioneSpesa>", movimento.GetDescrizione()),
TipoInteresseSanzione = TipoInteresseSanzioneEnum.Sanzione,
PagamentoInteresseSanzione = pag
};
//"Sanzione ravv. operoso - " + movimento.GetDescrizione();
_ripartizioneService.CloneRipartizioneByMovimento(movimentoSanzione, movimento);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);
}
}
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la scrittura dei movimenti per interessi e sanzioni (SINGOLO PAGAMENTO - SANZIONE) - {0} - pagamento:{1} - spesa:{2}", ex, Utility.GetMethodDescription(), pag.ID, spesa.ID);
throw;
}
// ------------------------------------------------
// Cancello i vecchi movimenti
// ------------------------------------------------
try
{
foreach (var mov in movimentiDaEliminare)
{
try
{
DeleteSingoloMovimento(mov);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la scrittura dei movimenti per interessi e sanzioni (SINGOLO PAGAMENTO - CANCELLAZIONE VECCHI MOVIMENTI - SINGOLO MOVIMENTO) - {0} - pagamento:{1} - spesa:{2} - movimento:{3}", ex, Utility.GetMethodDescription(), pag.ID, spesa.ID, mov.ID);
throw;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la scrittura dei movimenti per interessi e sanzioni (SINGOLO PAGAMENTO - CANCELLAZIONE VECCHI MOVIMENTI) - {0} - pagamento:{1} - spesa:{2}", ex, Utility.GetMethodDescription(), pag.ID, spesa.ID);
throw;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la scrittura dei movimenti per interessi e sanzioni (SINGOLO PAGAMENTO) - {0} - pagamento:{1} - spesa:{2}", ex, Utility.GetMethodDescription(), pag.ID, spesa.ID);
throw;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la scrittura dei movimenti per interessi e sanzioni - {0} - spesa:{1}", ex, Utility.GetMethodDescription(), spesa.ID);
throw;
}
}
public void SetMovimentiRitenuta(PagamentoRitenuta fileRitenuta, string descrizioneAddebitoInteressi, string descrizioneAddebitoSanzioni)
{
try
{
var numeroRiga = 0;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("VR");
var lista = new Dictionary<Esercizio, TestataMovimentoContabile>(fileRitenuta.Pagamenti.Count);
foreach (var pag in fileRitenuta.Pagamenti)
{
try
{
// ------------------------------------------------
// Testata
// ------------------------------------------------
TestataMovimentoContabile testata;
var esercizi = (from es in _daoFactory.GetEsercizioDao().GetByCondominio(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento)
where es.Gestione == GestioneEsercizioEnum.Ordinario && es.DataApertura <= fileRitenuta.Data.GetValueOrDefault() && es.DataChiusura >= fileRitenuta.Data.GetValueOrDefault()
select es).ToList();
if (esercizi.Count() > 1)
{
var eserciziId = esercizi.Aggregate(string.Empty, (current, es) => current + (" id:" + es.ID + " descrizione:" + es.Descrizione + " - "));
_log.WarnFormat("Uno o più esercizi ordinari si sovrappongono - {0} - condominio:{1} - esercizi:{2}", Utility.GetMethodDescription(), pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, eserciziId);
}
var esercizio = esercizi.FirstOrDefault() ?? pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento;
if (lista.ContainsKey(esercizio))
testata = lista[esercizio];
else
{
var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, fileRitenuta.Data.GetValueOrDefault());
if (message.Count == 0)
{
testata = new TestataMovimentoContabile(esercizio, fileRitenuta.Data, TipoTestataMovimentoContabileEnum.Automatica, null);
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
lista.Add(esercizio, testata);
}
else
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", fileRitenuta.Data));
_log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - pagamento:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, pag.ID , esercizio.ID);
throw ex;
}
}
var spesa = pag.ScadenzaRiferimento.SpesaRiferimento;
var firstDettaglio = spesa.Dettagli.FirstOrDefault();
TestataMovimentoContabile testataFattura = null;
if (firstDettaglio != null)
{
var firstMovimento = firstDettaglio.Movimenti.FirstOrDefault();
if (firstMovimento != null)
testataFattura = firstMovimento.Testata;
}
// ------------------------------------------------
// Interessi per Ravvedimento Operoso
// ------------------------------------------------
if (pag.RitenutaAcconto.ImportoInteressi > 0)
{
if (testataFattura != null && !testataFattura.AperturaBilancio)
{
var importo = spesa.Dettagli.SelectMany(item => item.Movimenti).Sum(item => item.Importo.GetValueOrDefault());
foreach (var dettaglio in spesa.Dettagli)
{
try
{
foreach (var movimento in dettaglio.Movimenti)
{
try
{
var importoMovimento = movimento.GetImportoConSegno().GetValueOrDefault();
if (movimento.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
importoMovimento = importoMovimento * -1;
var interesseCompetenza = pag.RitenutaAcconto.ImportoInteressi.GetValueOrDefault();
if (spesa.ImportoLordo != 0)
interesseCompetenza = (pag.RitenutaAcconto.ImportoInteressi.GetValueOrDefault() * importoMovimento) / importo;
else
{
_log.WarnFormat("Trovata spesa con importo lordo a 0 - {0} - spesa:{1} - data:{2} - movimento:{3} - pagamento:{4} - file ritenuta:{5}", Utility.GetMethodDescription(), spesa.ID, fileRitenuta.Data, movimento.ID, pag.ID, fileRitenuta.ID);
}
var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, interesseCompetenza, "D")
{
SottoContoRiferimento = movimento.SottoContoRiferimento,
FornitoreRiferimento = movimento.FornitoreRiferimento,
Descrizione = descrizioneAddebitoInteressi.Replace("<DescrizioneSpesa>", movimento.GetDescrizione()),
TipoInteresseSanzione = TipoInteresseSanzioneEnum.Interesse,
PagamentoInteresseSanzione = pag
};
// TODO: Da verificare per i problemi riscontrati con interessi e sanzioni
// "Interessi ravv. operoso - " + movimento.GetDescrizione();
_ripartizioneService.CloneRipartizioneByMovimento(movimentoInteresse, movimento);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella funzione - (SINGOLO MOVIMENTO INTERESSE) - {0} - data:{1} - movimento:{2} - pagamento:{3} - file ritenuta:{4}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, movimento.ID, pag.ID, fileRitenuta.ID);
throw;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella funzione - (SINGOLO DETTAGLIO INTERESSE) - {0} - data:{1} - dettaglio:{2} - pagamento:{3} - file ritenuta:{4}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, dettaglio.ID, pag.ID, fileRitenuta.ID);
throw;
}
}
}
else
{
numeroRiga++;
var sottoContoInteressiSanzioni = _daoFactory.GetSottoContoDao().GetInteressiSanzioniByEsercizio(testata.EsercizioRiferimento.ID, testata.EsercizioRiferimento.CondominioRiferimento.ID);
if (sottoContoInteressiSanzioni != null)
{
var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, sottoContoInteressiSanzioni.ContoRiferimento, pag.RitenutaAcconto.ImportoInteressi.GetValueOrDefault(), "D")
{
SottoContoRiferimento = sottoContoInteressiSanzioni,
FornitoreRiferimento = spesa.FornitoreRiferimento,
Descrizione = "Interesse versamento ritenuta"
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);
}
else
{
pag.RitenutaAcconto.ImportoInteressi = null;
}
}
}
// ------------------------------------------------
// Sanzione per Ravvedimento Operoso
// ------------------------------------------------
if (pag.RitenutaAcconto.ImportoSanzione > 0)
{
if (testataFattura != null && !testataFattura.AperturaBilancio)
{
var importo = spesa.Dettagli.SelectMany(item => item.Movimenti).Sum(item => item.Importo.GetValueOrDefault());
foreach (var dettaglio in spesa.Dettagli)
{
try
{
foreach (var movimento in dettaglio.Movimenti)
{
try
{
var importoMovimento = movimento.GetImportoConSegno().GetValueOrDefault();
if (movimento.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
importoMovimento = importoMovimento * -1;
var sanzioneCompetenza = pag.RitenutaAcconto.ImportoSanzione.GetValueOrDefault();
if (spesa.ImportoLordo != 0)
sanzioneCompetenza = (pag.RitenutaAcconto.ImportoSanzione.GetValueOrDefault() * importoMovimento) / importo;
else
{
_log.WarnFormat("Trovata spesa con importo lordo a 0 - (SANZIONE) - {0} - spesa:{1} - data:{2} - movimento:{3} - pagamento:{4} - file ritenuta:{5}", Utility.GetMethodDescription(), spesa.ID, fileRitenuta.Data, movimento.ID, pag.ID, fileRitenuta.ID);
}
var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, sanzioneCompetenza, "D")
{
SottoContoRiferimento = movimento.SottoContoRiferimento,
FornitoreRiferimento = movimento.FornitoreRiferimento,
Descrizione = descrizioneAddebitoSanzioni.Replace("<DescrizioneSpesa>", movimento.GetDescrizione()),
TipoInteresseSanzione = TipoInteresseSanzioneEnum.Sanzione,
PagamentoInteresseSanzione = pag
};
//"Sanzione ravv. operoso - " + movimento.GetDescrizione();
_ripartizioneService.CloneRipartizioneByMovimento(movimentoSanzione, movimento);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella funzione - (SINGOLO MOVIMENTO INTERESSE) - {0} - data:{1} - movimento:{2} - pagamento:{3} - file ritenuta:{4}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, movimento.ID, pag.ID, fileRitenuta.ID);
throw;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella funzione - (SINGOLO DETTAGLIO RAVVEDIMENTO) - {0} - data:{1} - dettaglio:{2} - pagamento:{3} - file ritenuta:{4}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, dettaglio.ID, pag.ID, fileRitenuta.ID);
throw;
}
}
}
else
{
numeroRiga++;
var sottoContoInteressiSanzioni = _daoFactory.GetSottoContoDao().GetInteressiSanzioniByEsercizio(testata.EsercizioRiferimento.ID, testata.EsercizioRiferimento.CondominioRiferimento.ID);
if (sottoContoInteressiSanzioni != null)
{
var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga, sottoContoInteressiSanzioni.ContoRiferimento, pag.RitenutaAcconto.ImportoSanzione, "D")
{
SottoContoRiferimento = sottoContoInteressiSanzioni,
FornitoreRiferimento = spesa.FornitoreRiferimento,
Descrizione = "Sanzione versamento ritenuta"
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);
}
else
{
pag.RitenutaAcconto.ImportoSanzione = 0;
}
}
}
// ------------------------------------------------
// Ritenuta
// ------------------------------------------------
numeroRiga++;
var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRitenuta()), pag.RitenutaAcconto.Importo, "D")
{
FornitoreRiferimento = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento,
Descrizione = "Versamento Ritenuta " + pag.GetDescrizione()
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
// ------------------------------------------------
// BANCA
// ------------------------------------------------
numeroRiga++;
var movimentoBancario = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario()), pag.RitenutaAcconto.ImportoConInteressi + pag.RitenutaAcconto.ImportoSanzione.GetValueOrDefault(), "A")
{
FornitoreRiferimento = movimentoPatrimoniale.FornitoreRiferimento,
Descrizione = movimentoPatrimoniale.Descrizione,
ContoCorrenteBancario = esercizio.CondominioRiferimento.DatiBancariPrincipale
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);
pag.RitenutaAcconto.MovimentoContabilePagamento = movimentoBancario;
setMovimentoArrotondamento(testata, causale, null);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella funzione - (SINGOLO PAGAMENTO) - {0} - data:{1} - pagamento:{2} - fileRitenuta:{3}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, pag.ID, fileRitenuta.ID);
throw;
}
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella funzione - {0} - data:{1} - fileRitenuta:{2}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, fileRitenuta.ID);
throw;
}
}
public MovimentoContabile SetMovimentiRiscossione(Riscossione riscossione, int? idConto, int? idSottoConto, DateTime dataRegistrazione)
{
try
{
var esercizio = getEsercizioCompetenza(riscossione.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento, dataRegistrazione);
var message = IsAllowDataRegistrazione(new List<int> { riscossione.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
if (message.Count == 0)
{
var numeroRiga = 0;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("PF");
// ================================================
// Testata
// ================================================
var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null);
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
// ================================================
// Crediti VS Fornitori
// ================================================
numeroRiga++;
const string segnoFornitori = "A";
var movimentoFornitore = new MovimentoContabile(testata, riscossione.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga,
_daoFactory.GetContoDao().GetByCodice(riscossione.SpesaRiferimento.EsercizioRiferimento.ID, riscossione.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()),
Math.Abs(riscossione.Importo.GetValueOrDefault()), segnoFornitori)
{
Descrizione = "Riscossione Nota Accredito n." + riscossione.SpesaRiferimento.NumeroDocumento + " del " + riscossione.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString()
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoFornitore);
// ================================================
// Conto Patrimoniale
// ================================================
numeroRiga++;
const string segnoPatrimoniale = "D";
var conto = _daoFactory.GetContoDao().GetById(idConto.GetValueOrDefault(), false);
SottoConto sottoconto = null;
if (idSottoConto > 0)
sottoconto = _daoFactory.GetSottoContoDao().GetById(idSottoConto.Value, false);
var movimentoPatrimoniale = new MovimentoContabile(testata, riscossione.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga, conto, Math.Abs(riscossione.Importo.GetValueOrDefault() - riscossione.ImportoRitenuta.GetValueOrDefault()), segnoPatrimoniale)
{
SottoContoRiferimento = sottoconto,
Descrizione = "Riscossione Nota Accredito n." + riscossione.SpesaRiferimento.NumeroDocumento + " del " + riscossione.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString()
};
if (idSottoConto < 0)
movimentoPatrimoniale.ContoCorrenteBancario = _daoFactory.GetDatiBancariCondominiDao().GetById(idSottoConto.Value * -1, false);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
// ================================================
// Ritenuta Acconto
// ================================================
if (Math.Abs(riscossione.ImportoRitenuta.GetValueOrDefault()) > 0)
{
numeroRiga++;
const string segnoRitenuta = "D";
var movimentoRitenuta = new MovimentoContabile(testata, riscossione.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga,
_daoFactory.GetContoDao().GetByCodice(riscossione.SpesaRiferimento.EsercizioRiferimento.ID, riscossione.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRitenuta()), Math.Abs(riscossione.ImportoRitenuta.GetValueOrDefault()), segnoRitenuta)
{
Descrizione = "Riscossione Nota Accredito n." + riscossione.SpesaRiferimento.NumeroDocumento + " del " + riscossione.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString()
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoRitenuta);
}
return movimentoPatrimoniale;
}
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
_log.Fatal("Data di registrazione non valida - " + Utility.GetMethodDescription() + " - data:" + dataRegistrazione + " - riscossione:" + riscossione.ID + " - idConto:" + idConto.GetValueOrDefault() + " - idSottoConto:" + idSottoConto.GetValueOrDefault(), ex);
throw ex;
}
catch (Exception ex)
{
_log.Fatal("Errore inaspettato nella funzione - " + Utility.GetMethodDescription() + " - data:" + dataRegistrazione + " - riscossione:" + riscossione.ID + " - idConto:" + idConto.GetValueOrDefault() + " - idSottoConto:" + idSottoConto.GetValueOrDefault(), 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;
}
}
public TestataMovimentoContabile SetMovimentiContatoreCondominiale(Esercizio esercizio, IList<ImportoMovimento> importiAccredito, IList<ImportiDTO> addebitiContatoriDivisionali, DateTime dataRegistrazione, Conto contoAddebito, SottoConto sottoContoAddebito, string descrizione)
{
// controllo data registrazione
var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
if (message.Count > 0)
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), dataRegistrazione, esercizio.ID);
throw ex;
}
var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null)
{
Descrizione = descrizione,
IsAbilitataArchiviazioneOttica = false,
IsAllowUpdate = true
};
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("SC");
// -------------------------------------------------
// Calcolo Importo
// ------------------------------------------------
var importo = importiAccredito.Sum(item => item.Importo);
// -------------------------------------------------
// Segno Movimento
// ------------------------------------------------
var segnoContoEconomico = "D";
if (importo < 0)
{
segnoContoEconomico = "A";
importo = importo * -1;
}
// ------------------------------------------------
// Conto economico da addebitare
// ------------------------------------------------
var movimentoContoEconomicoAddebito = new MovimentoContabile(testata, causale, 1, contoAddebito, importo, segnoContoEconomico)
{
SottoContoRiferimento = sottoContoAddebito,
Descrizione = descrizione,
IsRipartoPersonalizzato = true
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomicoAddebito);
// ------------------------------------------------
// Conto economico da accreditare
// ------------------------------------------------
foreach (var item in importiAccredito)
{
var movimentoContoEconomicoAccredito = new MovimentoContabile(testata, causale, 2, _daoFactory.GetContoDao().GetById(item.IdConto, false), item.Importo, invertiSegno(segnoContoEconomico)) { Descrizione = descrizione, IsRipartoPersonalizzato = true };
if(item.IdSottoConto > 0)
movimentoContoEconomicoAccredito.SottoContoRiferimento = _daoFactory.GetSottoContoDao().GetById(item.IdSottoConto.GetValueOrDefault(), false);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomicoAccredito);
// Ripartizione tra le unità immobiliari
var totaleMillesimi = addebitiContatoriDivisionali.Sum(mill => mill.Importo);
foreach (var importiDTO in addebitiContatoriDivisionali)
{
var unita = _daoFactory.GetUnitaImmobiliareDao().GetById(importiDTO.Id, false);
var importoUnita = (movimentoContoEconomicoAccredito.GetImportoConSegno() * importiDTO.Importo) / totaleMillesimi;
var spesaUnita = new SpeseUnita(importoUnita, unita, null, movimentoContoEconomicoAccredito);
_daoFactory.GetSpeseUnitaDao().SaveOrUpdate(spesaUnita);
}
}
return testata;
}
public string SetMovimentoAccreditoInteressiMora(Esercizio esercizio, TestataMovimentoContabile testata, Conto conto, string descrizione, decimal importo, DateTime dataRegistrazione)
{
try
{
var message = string.Empty;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("RI");
if (testata == null)
testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null) {IsAllowUpdate = true};
// controllo data registrazione
var messageData = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, testata.DataRegistrazione.GetValueOrDefault());
if (messageData.Count > 0)
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", testata.DataRegistrazione.GetValueOrDefault()));
_log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - conto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), testata.DataRegistrazione.GetValueOrDefault(), conto.ID, esercizio.ID);
throw ex;
}
var movimento = new MovimentoContabile(testata, causale, testata.Movimenti.Count() + 1, conto, importo, "A") {Descrizione = descrizione};
_ripartizioneService.ReloadRipartizioneByMovimento(movimento);
return message;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di accredito per interessi di mora - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
throw;
}
}
public void SetMovimentiRichiamoRata(RataSoggetto rata, LogTransazione logTransazione)
{
// Movimenti Contabili: Non devono essere registrati movimenti contabili all'atto dell'annullamento di una rata bugid#6383
return;
var numeroRiga = 0;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IR");
// ------------------------------------------------
// Testata
// ------------------------------------------------
var testata = new TestataMovimentoContabile(rata.Esercizio, DateTime.Today, TipoTestataMovimentoContabileEnum.Automatica, logTransazione);
// controllo data registrazione
var message = IsAllowDataRegistrazione(new List<int> { rata.Esercizio.CondominioRiferimento.ID }, rata.Esercizio, testata.DataRegistrazione.GetValueOrDefault());
if (message.Count > 0)
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", testata.DataRegistrazione.GetValueOrDefault()));
_log.ErrorFormat("Data di registrazione non valida - {0} - testata:{1} - data:{2} - rata:{3}", ex, Utility.GetMethodDescription(), testata.ID, testata.DataRegistrazione.GetValueOrDefault(), rata.ID);
throw ex;
}
// ------------------------------------------------
// Crediti V/S Condomini - a Saldo
// ------------------------------------------------
numeroRiga++;
var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(rata.Esercizio.ID, rata.Esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini()), rata.Importo, "A")
{
CondominoRiferimento = rata.Soggetto,
Descrizione = "Richiamo Rata n. " + rata.PianoRatealeDettaglio.Progressivo + " di " + rata.Soggetto.DisplayName + " - " + rata.MotivoRichiamo
};
// ------------------------------------------------
// Storno rate condominiali
// ------------------------------------------------
numeroRiga++;
var movimentoPatrimonialeAttivo = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(rata.Esercizio.ID, rata.Esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRateCondomini()), rata.Importo, "D")
{
CondominoRiferimento = rata.Soggetto,
Descrizione = movimentoPatrimoniale.Descrizione
};
}
public TestataMovimentoContabile SetMovimentiAddebitoCompetenze(Esercizio esercizio, AddebitoCompetenza addebito, DateTime dataRegistrazione, Conto conto, SottoConto sottoConto, string descrizione)
{
try
{
// controllo data registrazione
var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
if (message.Count > 0)
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
_log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - addebito:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, addebito.ID, esercizio.ID);
throw ex;
}
// se la testata è automatica non è possibile aggiornare gli importi nel dettaglio, se manuale è possibile l'aggiornamento.
// per ora la testata viene inserita come manuale.
//TestataMovimentoContabile testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, Sfera.Enums.TipoTestataMovimentoContabileEnum.Automatica);
var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Manuale, null) {Descrizione = descrizione, IsAllowUpdate = true};
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
var numeroRiga = 0;
// Contropartita
numeroRiga++;
var contoContropartita = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, "913");
new MovimentoContabile(testata, causale, numeroRiga, contoContropartita, addebito.Dettaglio.Sum(item => item.Importo), "A") {Descrizione = descrizione};
foreach (var item in addebito.Dettaglio)
{
try
{
numeroRiga++;
var movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, item.Importo, "D")
{
SottoContoRiferimento = sottoConto,
Descrizione = descrizione,
CondominoRiferimento = item.Soggetto
};
item.MovimentoContabile = movimento;
switch (item.Soggetto.Tipo)
{
case TipoSoggetto.Proprietario:
movimento.PercentualeProprieta = 1;
break;
case TipoSoggetto.Conduttore:
movimento.PercentualeProprieta = 0;
break;
}
movimento.IsRipartoPersonalizzato = true;
new SpeseUnita(item.Importo, null, item.Soggetto, movimento);
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - SINGOLO DETTAGLIO - {0} - item:{1}", ex, Utility.GetMethodDescription(), item.ID);
throw;
}
}
addebito.TestataMovimento = testata;
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
return testata;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - {0} - esercizio:{1} - dataRegistrazione:{2} - addebito:{3} - conto:{4} - sottoconto:{5} - descrizione:{6}", ex, Utility.GetMethodDescription(), esercizio != null ? esercizio.ID.ToString() : "<NULL>", dataRegistrazione, addebito != null ? addebito.ID.ToString() : "<NULL>", conto != null ? conto.ID.ToString() : "<NULL>", sottoConto != null ? sottoConto.ID.ToString() : "<NULL>", descrizione);
throw;
}
}
public IList<TestataMovimentoContabile> SetMovimentiVersamentoCondomino(TestataMovimentoContabile testata, MovimentoContabile movimentoPatrimonialeAttivo, Esercizio esercizio, VersamentoSoggetto versamento, DateTime dataRegistrazione, CausaleContabile causale, Conto contoVersamentoCondomini, int? idMovimentoBancario, FileCBI file, LogTransazione logTransazione)
{
var testate = new List<TestataMovimentoContabile>();
if(causale == null)
causale = _daoFactory.GetCausaleContabileDao().GetByCodice("RR");
if (contoVersamentoCondomini == null)
contoVersamentoCondomini = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini());
bool evasioneBancaria = false;
// ================================================================================
// Registrazione Movimenti Contabili per Versamento Condomino
// ================================================================================
var rateVersate = string.Empty;
foreach (var versamentoRata in versamento.Rate)
{
if (!string.IsNullOrEmpty(rateVersate))
rateVersate += ", ";
rateVersate += versamentoRata.Rata.PianoRatealeDettaglio.Progressivo;
}
if (!string.IsNullOrEmpty(rateVersate))
rateVersate = "(" + rateVersate + ")";
var descrizione = $"Versamento Rata di {versamento.Soggetto.DisplayName} {rateVersate}";
// ------------------------------------------------
// Testata
// ------------------------------------------------
if (testata == null)
{
testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, file, logTransazione)
{
Descrizione = descrizione
};
}
testate.Add(testata);
var message = IsAllowDataRegistrazione(new List<int>(), testata.EsercizioRiferimento, testata.DataRegistrazione.GetValueOrDefault());
if (message.Count > 0)
{
var ex = new InvalidDataException($"La data di registrazione {testata.DataRegistrazione.GetValueOrDefault()} non è valida");
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - versamento:{2} - message:{3}", ex, Utility.GetMethodDescription(), testata.DataRegistrazione.GetValueOrDefault(), versamento.ID, message.Aggregate(string.Empty, (current, str) => current + string.Format("{0}{1}", message, Environment.NewLine)));
throw ex;
}
var numeroRiga = testata.Movimenti.Count;
// ------------------------------------------------
// Crediti V/S Condomini - a Saldo
// ------------------------------------------------
numeroRiga++;
var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, contoVersamentoCondomini, versamento.Importo, "A")
{
CondominoRiferimento = versamento.Soggetto,
Descrizione = descrizione
};
// ------------------------------------------------
// Banca / Cassa
// ------------------------------------------------
if (movimentoPatrimonialeAttivo == null)
{
evasioneBancaria = true;
numeroRiga++;
movimentoPatrimonialeAttivo = new MovimentoContabile(testata, causale, numeroRiga, versamento.ContoPatrimoniale, versamento.Importo, "D")
{
Descrizione = descrizione,
SottoContoRiferimento = versamento.SottoContoPatrimoniale,
ContoCorrenteBancario = versamento.ContoBancario,
NumeroAssegno = versamento.NumeroAssegno
};
}
else
movimentoPatrimonialeAttivo.Importo = movimentoPatrimonialeAttivo.GetImportoSenzaSegno() + versamento.Importo;
// ================================================================================
// SOLO ESERCIZI ORDINARI
// Se la data di registrazione è successiva alla data di chiusura dell'esercizio
// registro i movimenti, usando un contro transitorio, che permette di rilevare
// il versamento nello stato patrimoniale dell'esercizio.
// ================================================================================
if (versamento.TipoVersamentoDopoChiusura.GetValueOrDefault() == TipoVersamentoDopoChiusuraEnum.Giroconto && esercizio.Gestione == GestioneEsercizioEnum.Ordinario)
{
var esercizioPrecedente = esercizio.GetEsercizioPrecedente();
if (esercizioPrecedente != null)
{
var causaleVersamentiCondominiDopoChiusura = _daoFactory.GetCausaleContabileDao().GetByCodice("VS");
var contoVersamentiDopoChiusura = _pianoContiService.GetContoVersamentiSuccessiviAllaChiusura(esercizio);
try
{
if (movimentoPatrimoniale.CondominoRiferimento != null)
{
var descrizioneStorno = string.Format("Versamento dopo data chiusura - {0} del {1} {2}", movimentoPatrimoniale.CondominoRiferimento.DisplayName, movimentoPatrimoniale.Testata.DataRegistrazione.GetValueOrDefault().ToShortDateString(), rateVersate);
// ---------------------------------------------------------------------------------------
// Movimenti per storno e riconoscimento versamenti ai condomini
// Nuova testata nell'esercizio precedente per registrare lo storno
// ---------------------------------------------------------------------------------------
var numeroRigaStorno = 0;
var testataStorno = new TestataMovimentoContabile(esercizioPrecedente, esercizioPrecedente.DataChiusura, TipoTestataMovimentoContabileEnum.Automatica, file, logTransazione)
{
Descrizione = descrizioneStorno
};
testate.Add(testataStorno);
numeroRigaStorno++;
var movimentoVersamento = new MovimentoContabile(testataStorno, causaleVersamentiCondominiDopoChiusura, numeroRigaStorno, movimentoPatrimoniale.ContoRiferimento, movimentoPatrimoniale.Importo, movimentoPatrimoniale.Segno)
{
CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
Descrizione = descrizioneStorno
};
numeroRigaStorno++;
var movimentoContoTemporaneo = new MovimentoContabile(testataStorno, causaleVersamentiCondominiDopoChiusura, numeroRigaStorno, contoVersamentiDopoChiusura, movimentoPatrimoniale.Importo, invertiSegno(movimentoPatrimoniale.Segno))
{
CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
Descrizione = descrizioneStorno
};
// ---------------------------------------------------------------------------------------
// Nella stessa testata del versamento originale aggiungo il movimento di chiusura del conto temporaneo
// ---------------------------------------------------------------------------------------
numeroRiga++;
var descrizioneChiusuraStorno = string.Format("Chiusura dello storno del versamento dopo data chiusura - {0} del {1} {2}", movimentoPatrimoniale.CondominoRiferimento.DisplayName, movimentoPatrimoniale.Testata.DataRegistrazione.GetValueOrDefault().ToShortDateString(), rateVersate);
var movimentoVersamentoChiusura = new MovimentoContabile(testata, causaleVersamentiCondominiDopoChiusura, numeroRiga, movimentoPatrimoniale.ContoRiferimento, movimentoPatrimoniale.Importo, invertiSegno(movimentoPatrimoniale.Segno))
{
CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
Descrizione = descrizioneChiusuraStorno
};
numeroRiga++;
var movimentoContoTemporaneoChiusura = new MovimentoContabile(testata, causaleVersamentiCondominiDopoChiusura, numeroRiga, contoVersamentiDopoChiusura, movimentoPatrimoniale.Importo, movimentoPatrimoniale.Segno)
{
CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
Descrizione = descrizioneChiusuraStorno
};
versamento.TestataMovimentoDopoChiusura = testataStorno;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la registrazione dei movimenti per i versamenti eseguiti dopo la chiusura - SINGOLO MOVIMENTO - {0} - esercizio:{1} - movimento:{2}", ex, Utility.GetMethodDescription(), esercizio.ID, movimentoPatrimoniale.ID);
throw;
}
}
else
{
_log.ErrorFormat("Esercizio precedente a null - {0} - versamento:{1} - esercizio:{2}", Utility.GetMethodDescription(), versamento.ID, esercizio.ID);
}
}
// ================================================================================
// SOLO ESERCIZI ORDINARI - bugid#6223
// Se la data di registrazione è antecedente alla data di apertura dell'esercizio
// registro i movimenti, usando un contro transitorio, che permette di rilevare
// il versamento nello stato patrimoniale dell'esercizio.
// ================================================================================
if (versamento.TipoVersamentoPrimaApertura.GetValueOrDefault() == TipoVersamentoPrimaAperturaEnum.Giroconto && esercizio.Gestione == GestioneEsercizioEnum.Ordinario)
{
var annoSuccessivo = _daoFactory.GetAnnoGestionaleDao().GetAnnoSuccessivo(esercizio.AnnoGestionale.ID);
if (annoSuccessivo != null)
{
if (annoSuccessivo.EsercizioOrdinario != null)
{
var causaleVersamentiCondominiPrimaApertura = _daoFactory.GetCausaleContabileDao().GetByCodice("VA");
var contoVersamentiPrecedentiAllaApertura = _pianoContiService.GetContoVersamentiPrecedentiAllaApertura(esercizio);
try
{
if (movimentoPatrimoniale.CondominoRiferimento != null)
{
var descrizioneStorno = string.Format("Versamento prima della data di apertura - {0} del {1} {2}", movimentoPatrimoniale.CondominoRiferimento.DisplayName, movimentoPatrimoniale.Testata.DataRegistrazione.GetValueOrDefault().ToShortDateString(), rateVersate);
// ---------------------------------------------------------------------------------------
// Movimenti per storno e riconoscimento versamenti ai condomini
// Nuova testata nell'esercizio successivo per registrare lo storno
// ---------------------------------------------------------------------------------------
var numeroRigaStorno = 0;
var testataStorno = new TestataMovimentoContabile(annoSuccessivo.EsercizioOrdinario, annoSuccessivo.EsercizioOrdinario.DataApertura, TipoTestataMovimentoContabileEnum.Automatica, file, logTransazione)
{
Descrizione = descrizioneStorno
};
testate.Add(testataStorno);
numeroRigaStorno++;
var movimentoVersamento = new MovimentoContabile(testataStorno, causaleVersamentiCondominiPrimaApertura, numeroRigaStorno, movimentoPatrimoniale.ContoRiferimento, movimentoPatrimoniale.Importo, movimentoPatrimoniale.Segno)
{
CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
Descrizione = descrizioneStorno
};
numeroRigaStorno++;
var movimentoContoTemporaneo = new MovimentoContabile(testataStorno, causaleVersamentiCondominiPrimaApertura, numeroRigaStorno, contoVersamentiPrecedentiAllaApertura, movimentoPatrimoniale.Importo, invertiSegno(movimentoPatrimoniale.Segno))
{
CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
Descrizione = descrizioneStorno
};
// ---------------------------------------------------------------------------------------
// Nella stessa testata del versamento originale aggiungo il movimento di chiusura del conto temporaneo
// ---------------------------------------------------------------------------------------
numeroRiga++;
var descrizioneChiusuraStorno = string.Format("Chiusura dello storno del versamento prima della data di apertura - {0} del {1} {2}", movimentoPatrimoniale.CondominoRiferimento.DisplayName, movimentoPatrimoniale.Testata.DataRegistrazione.GetValueOrDefault().ToShortDateString(), rateVersate);
var movimentoVersamentoChiusura = new MovimentoContabile(testata, causaleVersamentiCondominiPrimaApertura, numeroRiga, movimentoPatrimoniale.ContoRiferimento, movimentoPatrimoniale.Importo, invertiSegno(movimentoPatrimoniale.Segno))
{
CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
Descrizione = descrizioneChiusuraStorno
};
numeroRiga++;
var movimentoContoTemporaneoChiusura = new MovimentoContabile(testata, causaleVersamentiCondominiPrimaApertura, numeroRiga, contoVersamentiPrecedentiAllaApertura, movimentoPatrimoniale.Importo, movimentoPatrimoniale.Segno)
{
CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
Descrizione = descrizioneChiusuraStorno
};
versamento.TestataMovimentoDopoChiusura = testataStorno;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la registrazione dei movimenti per i versamenti eseguiti dopo la chiusura - SINGOLO MOVIMENTO - {0} - esercizio:{1} - movimento:{2}", ex, Utility.GetMethodDescription(), esercizio.ID, movimentoPatrimoniale.ID);
throw;
}
}
}
else
{
_log.ErrorFormat("Esercizio successivo a null - {0} - versamento:{1} - esercizio:{2}", Utility.GetMethodDescription(), versamento.ID, esercizio.ID);
}
}
// ================================================================================
// Evado il corrispondente Movimento Bancario
// ================================================================================
if (evasioneBancaria && idMovimentoBancario != null)
{
EvadiMovimento(string.Format("Evasione automatica per contabilizzazione versamento condomino del {0}", dataRegistrazione.ToShortDateString()), new List<MovimentoContabile> { movimentoPatrimonialeAttivo }, new List<int> { idMovimentoBancario.Value }, dataRegistrazione, logTransazione);
_log.DebugFormat("Evasione automatica per contabilizzazione versamento condomino - {0} - movimento economico:{1} - movimento bancario:{2} - data registrazione:{3}", Utility.GetMethodDescription(), movimentoPatrimoniale.ID, idMovimentoBancario.GetValueOrDefault(), dataRegistrazione);
}
versamento.MovimentoContabilePatrimoniale = movimentoPatrimonialeAttivo;
return testate;
}
public TestataMovimentoContabile SetMovimentiVersamentiDopoChiusura(Esercizio esercizioStraordinario)
{
try
{
TestataMovimentoContabile testata = null;
var contoVersamentiCondomini = _daoFactory.GetContoDao().GetByCodice(esercizioStraordinario.ID, esercizioStraordinario.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini());
var movimenti = GetMovimentiByContiData(esercizioStraordinario.CondominioRiferimento.ID, esercizioStraordinario.DataChiusura.GetValueOrDefault().AddDays(1), DateTime.MaxValue, new List<int> { contoVersamentiCondomini.ID });
if (movimenti.Any())
{
testata = new TestataMovimentoContabile(esercizioStraordinario, esercizioStraordinario.DataChiusura, TipoTestataMovimentoContabileEnum.Automatica, null)
{
AperturaChiusuraConti = true,
Descrizione = "Versamento dopo data chiusura"
};
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("VC");
var contoVersamentiDopoChiusura = _pianoContiService.GetContoVersamentiSuccessiviAllaChiusura(esercizioStraordinario);
var numeroRiga = 0;
foreach (var movimentoContabile in movimenti)
{
try
{
if (movimentoContabile.CondominoRiferimento != null)
{
var descrizione = string.Format("Versamento dopo data chiusura - {0} del {1}", movimentoContabile.CondominoRiferimento.DisplayName, movimentoContabile.Testata.DataRegistrazione.GetValueOrDefault().ToShortDateString());
numeroRiga++;
var movimentoVersamento = new MovimentoContabile(testata, causale, numeroRiga, movimentoContabile.ContoRiferimento, movimentoContabile.Importo, movimentoContabile.Segno);
movimentoVersamento.CondominoRiferimento = movimentoContabile.CondominoRiferimento;
movimentoVersamento.Descrizione = descrizione;
numeroRiga++;
var movimentoContoTemporaneo = new MovimentoContabile(testata, causale, numeroRiga, contoVersamentiDopoChiusura, movimentoContabile.Importo, invertiSegno(movimentoContabile.Segno));
movimentoContoTemporaneo.CondominoRiferimento = movimentoContabile.CondominoRiferimento;
movimentoContoTemporaneo.Descrizione = descrizione;
// Nella stessa testata del versamento originale aggiungo il movimento di chiusura del conto temporaneo
var numeroRigaChiusura = movimentoContabile.Testata.Movimenti.Max(item => item.NumeroRiga) + 1;
var movimentoVersamentoChiusura = new MovimentoContabile(movimentoContabile.Testata, causale, numeroRigaChiusura, movimentoContabile.ContoRiferimento, movimentoContabile.Importo, invertiSegno(movimentoContabile.Segno));
movimentoVersamentoChiusura.CondominoRiferimento = movimentoContabile.CondominoRiferimento;
movimentoVersamentoChiusura.Descrizione = descrizione;
numeroRigaChiusura++;
var movimentoContoTemporaneoChiusura = new MovimentoContabile(movimentoContabile.Testata, causale, numeroRigaChiusura, contoVersamentiDopoChiusura, movimentoContabile.Importo, movimentoContabile.Segno);
movimentoContoTemporaneoChiusura.CondominoRiferimento = movimentoContabile.CondominoRiferimento;
movimentoContoTemporaneoChiusura.Descrizione = descrizione;
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la registrazione dei movimenti per i versamenti eseguiti dopo la chiusura - SINGOLO MOVIMENTO - {0} - esercizio:{1} - movimento:{2}", ex, Utility.GetMethodDescription(), esercizioStraordinario.ID, movimentoContabile.ID);
throw;
}
}
}
return testata;
}
catch (Exception ex)
{
var idEsercizio = string.Empty;
if (esercizioStraordinario != null)
idEsercizio = esercizioStraordinario.ID.ToString();
_log.FatalFormat("Errore inaspettato durante la registrazione dei movimenti per i versamenti eseguiti dopo la chiusura - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), idEsercizio);
throw;
}
}
public MovimentoContabile SetMovimentoBancarioGenerico(DatiBancariCondomini banca, Esercizio esercizioRiferimento, SottoConto sottoconto, decimal importo, string descrizione, DateTime dataRegistrazione, CausaleContabile causale)
{
try
{
var message = IsAllowDataRegistrazione(new List<int> { esercizioRiferimento.CondominioRiferimento.ID }, esercizioRiferimento, dataRegistrazione);
if (message.Count > 0)
{
var ex = new InvalidDataException($"La data di registrazione {dataRegistrazione} non è valida");
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), dataRegistrazione, esercizioRiferimento.ID);
throw ex;
}
var testata = new TestataMovimentoContabile(esercizioRiferimento, dataRegistrazione, TipoTestataMovimentoContabileEnum.Manuale, null)
{
Descrizione = descrizione,
IsAbilitataArchiviazioneOttica = false,
IsAllowUpdate = true
};
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
// -------------------------------------------------
// Segno Movimento
// ------------------------------------------------
string segnoContoEconomico = "D";
if (importo > 0)
segnoContoEconomico = "A";
else
importo = importo * -1;
// ------------------------------------------------
// Conto economico
// ------------------------------------------------
var movimentoContoEconomico = new MovimentoContabile(testata, causale, 1, sottoconto, importo, segnoContoEconomico) {Descrizione = descrizione};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomico);
_ripartizioneService.SalvaRipartizione(movimentoContoEconomico, esercizioRiferimento.CondominioRiferimento.ID);
// ------------------------------------------------
// BANCA
// ------------------------------------------------
var movimentoBancario = new MovimentoContabile(testata, causale, 2, _daoFactory.GetContoDao().GetByCodice(esercizioRiferimento.ID, esercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario()), importo, invertiSegno(segnoContoEconomico))
{
Descrizione = descrizione,
Stato = StatoMovimentoContabileEnum.Evaso,
ContoCorrenteBancario = banca
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);
return movimentoBancario;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella contabilizzazione di un movimento bancario - {0} - importo:{1} - descrizione:{2} - data registrazione:{3:d}", ex, Utility.GetMethodDescription(), importo, descrizione, dataRegistrazione);
throw;
}
}
public string SetTestataContabileGenerica(TestataMovimentoContabileGenericoDTO dto)
{
try
{
var message = string.Empty;
var numeroRiga = 0;
if (dto.IdEsercizio > 0)
{
if (dto.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()) !=
dto.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()))
message = "Il totale Dare:" + dto.Movimenti.Sum(mov => mov.ImportoDare.GetValueOrDefault()).ToString("c") + " non corrisponde col totale Avere:" + dto.Movimenti.Sum(mov => mov.ImportoAvere.GetValueOrDefault()).ToString("c") + Environment.NewLine;
else if (dto.DataRegistrazione == null)
message = "Deve essere definita la data di registrazione" + Environment.NewLine;
else
{
var esercizio = _daoFactory.GetEsercizioDao().Find(dto.IdEsercizio.GetValueOrDefault(), false);
if (esercizio != null && esercizio.Stato == StatoEsercizioEnum.Aperto)
{
// controllo data registrazione
var messageData = IsAllowDataRegistrazione(new List<int> {esercizio.CondominioRiferimento.ID}, esercizio, dto.DataRegistrazione.GetValueOrDefault());
if (messageData.Count > 0)
{
_log.WarnFormat("Data di registrazione non valida - {0} - data:{1} - esercizio:{2}", Utility.GetMethodDescription(), dto.DataRegistrazione.GetValueOrDefault(), esercizio.ID);
return messageData.Aggregate(message, (current, mess) => current + (mess + Environment.NewLine));
}
var causale = _daoFactory.GetCausaleContabileDao().GetById(dto.IdCausale, false);
var testata = _daoFactory.GetTestataMovimentoContabileDao().Find(dto.ID, false);
if (testata == null)
{
testata = new TestataMovimentoContabile(esercizio, dto.DataRegistrazione.Value, TipoTestataMovimentoContabileEnum.Manuale, null) {IsAllowUpdate = false};
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
}
else
{
// ----------------------------------------------------------
// Verifico che tutti i movimenti siano aggiornabili
// ----------------------------------------------------------
message = testata.Movimenti.Select(movimento => IsAllowUpdateMovimento(movimento.ID)).Where(messageMovimento => !string.IsNullOrEmpty(messageMovimento)).Aggregate(message, (current, messageMovimento) => current + string.Format("{0}{1}", messageMovimento, Environment.NewLine));
if (!string.IsNullOrEmpty(message))
return message;
// ----------------------------------------------------------
testata.EsercizioRiferimento = esercizio;
testata.DataRegistrazione = dto.DataRegistrazione.Value;
testata.Movimenti.Clear();
}
testata.Descrizione = dto.Descrizione;
foreach (var movimentoDto in dto.Movimenti)
{
numeroRiga++;
var conto = _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.GetValueOrDefault(), false);
string segno;
decimal importo;
if (movimentoDto.ImportoAvere > 0)
{
importo = movimentoDto.ImportoAvere.GetValueOrDefault();
segno = "A";
}
else
{
importo = movimentoDto.ImportoDare.GetValueOrDefault();
segno = "D";
}
var movimento = _daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
if (movimento == null)
{
movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, importo, segno) {Descrizione = movimentoDto.Descrizione};
if (movimentoDto.IdFornitore != null && movimentoDto.IdFornitore.GetValueOrDefault() > 0)
movimento.FornitoreRiferimento = _daoFactory.GetFornitoreDao().GetById(movimentoDto.IdFornitore.Value, false);
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
}
else
{
movimento.Causale = causale;
movimento.Segno = segno;
movimento.Importo = importo;
movimento.ContoRiferimento = conto;
movimento.NumeroRiga = numeroRiga;
movimento.Descrizione = movimentoDto.Descrizione;
if (movimentoDto.IdFornitore != null && movimentoDto.IdFornitore.GetValueOrDefault() > 0)
movimento.FornitoreRiferimento = _daoFactory.GetFornitoreDao().GetById(movimentoDto.IdFornitore.Value, false);
}
testata.Movimenti.Add(movimento);
if (movimentoDto.IdSottoConto != null)
{
if (movimentoDto.IdSottoConto > 0)
{
var sottoConto = _daoFactory.GetSottoContoDao().GetById(movimentoDto.IdSottoConto.Value, false);
movimento.SottoContoRiferimento = sottoConto;
}
else if (movimentoDto.IdSottoConto < 0)
{
if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoBancario())
{
var banca = _daoFactory.GetDatiBancariCondominiDao().Find(movimentoDto.IdSottoConto.Value*-1, false);
if (banca != null)
movimento.ContoCorrenteBancario = banca;
}
else if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoFornitori())
{
var fornitore = _daoFactory.GetFornitoreDao().Find(movimentoDto.IdSottoConto.Value*-1, false);
if (fornitore != null)
movimento.FornitoreRiferimento = fornitore;
}
else if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini() || movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoRateCondomini())
{
var soggetto = _daoFactory.GetSoggettoCondominioDao().Find(movimentoDto.IdSottoConto.Value*-1, false);
if (soggetto != null)
movimento.CondominoRiferimento = soggetto;
}
}
}
}
// Aggiorno l'importo dell'eventuale versamento associato
foreach (var movimentoContabile in testata.Movimenti)
{
var versamento = _daoFactory.GetVersamentoSoggettoDao().GetByMovimentoContabile(movimentoContabile);
if (versamento != null)
versamento.Importo = movimentoContabile.Importo.GetValueOrDefault();
}
}
else
{
if (esercizio != null)
message += "La registrazione non è possibile perchè l'esercizio è chiuso." + Environment.NewLine;
else
{
message += "L'esercizio non è più presente nel database." + Environment.NewLine;
_log.WarnFormat("Tentativo di registrare una testata generica di movimento contabile per un esercizio inesistente - {0} - esercizio:{1} - testata:{2}", Utility.GetMethodDescription(), dto.IdEsercizio, dto.ID);
}
}
}
}
return message;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante l'aggiornamento della testata generica di movimento contabile - {0}", Utility.GetMethodDescription(), ex);
throw;
}
}
public TestataMovimentoContabile SetMovimentoSpesaPersonale(Esercizio esercizio, TestataMovimentoContabile testata, SoggettoCondominio soggetto, Conto conto, string descrizione, decimal importo, DateTime dataRegistrazione)
{
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
if (testata == null)
{
testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null) {Descrizione = "Calcolo interessi di mora", IsAllowUpdate = true};
}
// controllo data registrazione
var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, testata.DataRegistrazione.GetValueOrDefault());
if (message.Count > 0)
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", testata.DataRegistrazione.GetValueOrDefault()));
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - soggetto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), testata.DataRegistrazione.GetValueOrDefault(), soggetto.ID, esercizio.ID);
throw ex;
}
var movimento = new MovimentoContabile(testata, causale, testata.Movimenti.Count() + 1, conto, importo, "D") {Descrizione = descrizione};
switch (soggetto.Tipo)
{
case TipoSoggetto.Proprietario:
movimento.PercentualeProprieta = 1;
break;
case TipoSoggetto.Conduttore:
movimento.PercentualeProprieta = 0;
break;
}
movimento.IsRipartoPersonalizzato = true;
new SpeseUnita(importo, null, soggetto, movimento);
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
return testata;
}
public string GetKeyContoSottoconto(MovimentoContabile movimento)
{
var idSottoconto = 0;
var idConto = movimento.ContoRiferimento.ID;
// Fornitore
if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoFornitori())
{
idSottoconto = movimento.FornitoreRiferimento != null ? movimento.FornitoreRiferimento.ID : movimento.ContoRiferimento.ID;
}
// Condomino - Versamenti
else if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini())
{
idSottoconto = movimento.CondominoRiferimento != null ? movimento.CondominoRiferimento.ID : movimento.ContoRiferimento.ID;
}
// Condomino - Rate
else if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoRateCondomini())
{
idSottoconto = movimento.CondominoRiferimento != null ? movimento.CondominoRiferimento.ID : movimento.ContoRiferimento.ID;
}
// Banca
else if (movimento.ContoRiferimento.Codice == _pianoContiService.GetCodiceContoBancario())
{
var contoCorrente = movimento.ContoCorrenteBancario;
if (contoCorrente == null && movimento.Testata.EsercizioRiferimento.CondominioRiferimento.DatiBancariPrincipale != null)
contoCorrente = movimento.Testata.EsercizioRiferimento.CondominioRiferimento.DatiBancariPrincipale;
if (contoCorrente != null)
idSottoconto = contoCorrente.ID;
}
// Altri
else if (movimento.SottoContoRiferimento != null)
idSottoconto = movimento.SottoContoRiferimento.ID;
// Sottoconto NON definito
else
idSottoconto = movimento.ContoRiferimento.ID;
return idConto + "&" + idSottoconto;
}
public IList<MovimentoContabile> SetMovimentoBolletta(BollettaDTO bolletta, Spesa spesa, TestataMovimentoContabile testata, LogTransazione logTransazione, bool controlloDataRegistrazione)
{
try
{
IList<MovimentoContabile> movimentiEconomici = new List<MovimentoContabile>();
CausaleContabile causale;
if (spesa.Utenza != null && spesa.Utenza.RipartoLetture)
causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
else
causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IF");
if (testata == null && spesa.TestateMovimenti.Count > 0)
{
testata = spesa.TestateMovimenti.FirstOrDefault();
if (testata != null)
{
testata.EsercizioRiferimento = spesa.EsercizioRiferimento;
testata.DataRegistrazione = bolletta.DataRegistrazione;
}
}
var dataRegistrazione = DateTime.Today;
if (bolletta.DataRegistrazione != null)
dataRegistrazione = bolletta.DataRegistrazione.GetValueOrDefault();
if (testata == null)
{
testata = new TestataMovimentoContabile(spesa.EsercizioRiferimento, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null) { SpesaRiferimento = spesa };
spesa.TestateMovimenti.Add(testata);
testata.IsAllowUpdate = false;
if(logTransazione == null)
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
else
testata.LogTransazione = logTransazione;
}
// controllo data registrazione
IList<string> message = new List<string>();
if(controlloDataRegistrazione)
message = IsAllowDataRegistrazione(new List<int> { spesa.EsercizioRiferimento.CondominioRiferimento.ID }, spesa.EsercizioRiferimento, testata.DataRegistrazione.GetValueOrDefault());
if (message.Count > 0)
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", testata.DataRegistrazione.GetValueOrDefault()));
_log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - spesa:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), testata.DataRegistrazione.GetValueOrDefault(), spesa.ID, spesa.EsercizioRiferimento.ID);
throw ex;
}
testata.Descrizione = bolletta.Descrizione;
testata.DataRegistrazione = dataRegistrazione;
// -------------------------------------------
// Elimino movimenti cancellati
// -------------------------------------------
foreach (var mov in testata.Movimenti.Where(item => item.NumeroRiga > 1).ToList())
DeleteSingoloMovimento(mov);
// -------------------------------------------
// Movimenti Economici
// -------------------------------------------
var numeroRiga = 1;
var importoEconomico = 0m;
foreach (var movimentoDto in bolletta.Movimenti)
{
if (movimentoDto.IdConto != null)
{
var importo = Math.Round(movimentoDto.Importo.GetValueOrDefault(), 2);
importoEconomico += importo;
var segno = "D";
if (importo < 0)
{
segno = "A";
importo = importo * -1;
}
var movimento = _daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
numeroRiga++;
if (movimento != null)
{
movimento.ContoRiferimento = _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.Value, false);
movimento.Segno = segno;
movimento.Importo = importo;
movimento.Causale = causale;
}
else
{
movimento = new MovimentoContabile(testata, spesa, causale, testata.Movimenti.Count + 1, _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.Value, false), importo, segno);
if(logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
}
movimento.IsMovimentoEconomico = true;
movimento.NumeroRiga = numeroRiga;
movimento.Descrizione = movimentoDto.Descrizione;
if (movimentoDto.IdSottoConto != null && movimentoDto.IdSottoConto > 0)
movimento.SottoContoRiferimento = _daoFactory.GetSottoContoDao().GetById(movimentoDto.IdSottoConto.Value, false);
movimentoDto.ID = movimento.ID;
movimentiEconomici.Add(movimento);
}
else
{
_log.ErrorFormat("Movimento senza conto associato - {0} - bolletta:{1}", Utility.GetMethodDescription(), bolletta.ID);
throw (new Exception("Movimento senza conto associato - " + Utility.GetMethodDescription() + " - idBolletta:" + bolletta.ID));
}
}
// ------------------------------------------------
// Debiti VS Fornitori
// ------------------------------------------------
var causalePatrimoniale = _daoFactory.GetCausaleContabileDao().GetByCodice("IF");
var importoTotale = spesa.ImportoBolletta.GetValueOrDefault();
var importoPatrimoniale = importoTotale;
var segnoPatrimoniale = "A";
if (importoTotale < 0)
{
segnoPatrimoniale = "D";
importoTotale = importoTotale * -1;
}
var movimentoPatrimoniale = (testata.Movimenti.Where(item => !item.IsMovimentoEconomico && !item.ContoRiferimento.IsArrotondamento)).FirstOrDefault();
if (movimentoPatrimoniale == null)
{
movimentoPatrimoniale = new MovimentoContabile(testata, spesa.FornitoreRiferimento, causalePatrimoniale, 1, _daoFactory.GetContoDao().GetByCodice(spesa.EsercizioRiferimento.ID, spesa.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importoTotale, segnoPatrimoniale);
if(logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
}
else
{
movimentoPatrimoniale.NumeroRiga = 1;
movimentoPatrimoniale.Importo = importoTotale;
movimentoPatrimoniale.Segno = segnoPatrimoniale;
}
movimentoPatrimoniale.Descrizione = $"Fatt. n. {spesa.NumeroDocumento} del {spesa.DataDocumento.GetValueOrDefault():d}";
// ------------------------------------------------
// Eventuale arrotondamento
// ------------------------------------------------
setMovimentoArrotondamento(importoPatrimoniale, importoEconomico, numeroRiga, spesa, testata, causale, logTransazione);
return movimentiEconomici;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella creazione del movimento di registrazione delle bollette - {0} - bolletta:{1}", ex, Utility.GetMethodDescription(), bolletta.ID);
throw;
}
}
public void SetMovimentiPagamenti(Disposizione disposizione, string tipoConto, LogTransazione logTransazione)
{
try
{
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("PF");
var lista = new Dictionary<Esercizio, TestataMovimentoContabile>(disposizione.Pagamenti.Count);
foreach (var pag in disposizione.Pagamenti)
{
try
{
var numeroRiga = 0;
var esercizioRiferimento = getEsercizioCompetenza(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento, pag.Data.GetValueOrDefault());
if (esercizioRiferimento == null)
{
var ex = new InvalidDataException(string.Format("Non trovato nessun esercizio attivo"));
_log.FatalFormat("Non trovato nessun esercizio attivo - {0} - condominio:{1} - disposizione:{2} - tipoConto:{3}", ex, Utility.GetMethodDescription(), pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, disposizione.ID, tipoConto);
throw ex;
}
var message = IsAllowDataRegistrazione(new List<int> { esercizioRiferimento.CondominioRiferimento.ID }, esercizioRiferimento, pag.Data.GetValueOrDefault());
if (message.Count == 0)
{
// ================================================
// Testata
// ================================================
TestataMovimentoContabile testata;
if (lista.ContainsKey(esercizioRiferimento))
testata = lista[esercizioRiferimento];
else
{
testata = new TestataMovimentoContabile(esercizioRiferimento, pag.Data, TipoTestataMovimentoContabileEnum.Automatica, logTransazione);
if(logTransazione == null)
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
// Per ora ritengo opportuno avere una testata di movimento contabile distinta per ogni pagamento.
// Per avere un testata che accorpi diversi pagamenti è sufficiente scommentare la riga successiva.
//lista.Add(esercizioRiferimento, testata);
}
// ================================================
// Debiti VS Fornitori
// ------------------------------------------------
// Se è già presente un movimento contabile legato alla ritenute
// vuol dire che il pagamento stato annullato.
// In questo caso il movimento di ritenuta non deve essere generato
// ================================================
numeroRiga++;
var importoFornitori = pag.Importo.GetValueOrDefault();
if (pag.RitenutaAcconto != null && pag.RitenutaAcconto.MovimentoContabileCreazione == null)
importoFornitori += pag.RitenutaAcconto.Importo.GetValueOrDefault();
var movimentoPatrimoniale = new MovimentoContabile(testata, pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importoFornitori, "D")
{
Descrizione = string.Format("Pagamento Fatt. n.{0} del {1:d}", pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento, pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.GetValueOrDefault())
};
if(logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
// ================================================
// Ritenuta
// ================================================
decimal importoRitenuta = 0;
if (pag.ScadenzaRiferimento.SpesaRiferimento.Detrazione.GetValueOrDefault() == 0 && pag.RitenutaAcconto != null && pag.RitenutaAcconto.MovimentoContabileCreazione == null && pag.RitenutaAcconto.Importo != null && pag.RitenutaAcconto.Importo.GetValueOrDefault() != 0)
{
numeroRiga++;
var segnoRitenuta = "A";
importoRitenuta = pag.RitenutaAcconto.Importo.GetValueOrDefault();
if (pag.RitenutaAcconto.Importo.GetValueOrDefault() < 0)
{
segnoRitenuta = "D";
importoRitenuta = importoRitenuta * -1;
}
var movimentoRitenuta = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRitenuta()), importoRitenuta, segnoRitenuta)
{
FornitoreRiferimento = movimentoPatrimoniale.FornitoreRiferimento
};
if (!string.IsNullOrEmpty(pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento) && pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento != null)
movimentoRitenuta.Descrizione = "Ritenuta Fatt. n." + pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento + " del " + pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.Value.ToShortDateString();
pag.RitenutaAcconto.MovimentoContabileCreazione = movimentoRitenuta;
if(logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoRitenuta);
}
// ================================================
// Conto Patrimoniale
// ================================================
numeroRiga++;
if (pag.Conto == null)
{
switch (tipoConto)
{
case "B":
pag.Conto = _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario());
break;
case "C":
pag.Conto = _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, "903");
break;
}
}
var segnoPagamento = "A";
var importoPagamento = importoFornitori - importoRitenuta;
if (importoPagamento < 0)
{
segnoPagamento = "D";
importoPagamento = importoPagamento * -1;
// Inverto segno e importo anche per il movimento di Debiti v/Fornitori
movimentoPatrimoniale.Segno = invertiSegno("D");
movimentoPatrimoniale.Importo = importoFornitori * -1;
}
var movimentoBancario = new MovimentoContabile(testata, causale, numeroRiga, pag.Conto, importoPagamento, segnoPagamento)
{
Descrizione = movimentoPatrimoniale.GetDescrizione(),
NumeroAssegno = pag.NumeroAssegno,
FornitoreRiferimento =
pag.ScadenzaRiferimento.SpesaRiferimento.
FornitoreRiferimento,
SottoContoRiferimento = pag.SottoConto,
ContoCorrenteBancario = pag.ContoCorrenteBancario
};
pag.MovimentoContabile = movimentoBancario;
if (logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);
}
else
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", pag.Data.GetValueOrDefault()));
_log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - pagamento:{2} - disposizione:{3} - tipoConto:{4} - esercizio:{5}", ex, Utility.GetMethodDescription(), pag.Data.GetValueOrDefault(), pag.ID, disposizione.ID, tipoConto, esercizioRiferimento.ID);
throw ex;
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la scrittura dei movimenti per pagamenti - (SINGOLO PAGAMENTO) - {0} - pagamento:{1} - disposizione:{2}", ex, Utility.GetMethodDescription(), pag.ID, disposizione.ID);
throw;
}
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la scrittura dei movimenti per pagamenti - {0} - disposizione:{1}", ex, Utility.GetMethodDescription(), disposizione.ID);
throw;
}
}
private void setMovimentoArrotondamento(decimal importoAvere, decimal importoDare, int numeroRiga, Spesa spesa, TestataMovimentoContabile testata, CausaleContabile causale, LogTransazione logTransazione)
{
if (importoAvere != importoDare)
{
var importoArrotondamento = importoAvere - importoDare;
numeroRiga++;
var segno = "D";
if (importoArrotondamento < 0)
{
segno = "A";
importoArrotondamento = importoArrotondamento * -1;
}
var contoArrotondamenti = _pianoContiService.GetContoArrotondamenti(testata.EsercizioRiferimento);
_daoFactory.GetContoDao().SaveOrUpdate(contoArrotondamenti);
var movimentoArrotondamento = new MovimentoContabile(testata, causale, numeroRiga, contoArrotondamenti, importoArrotondamento, segno)
{
Descrizione = spesa != null ? string.Format("Arrotondamento Fatt. n. {0} del {1:d}", spesa.NumeroDocumento, spesa.DataDocumento.GetValueOrDefault()) : string.Format("Arrotondamento per {0}", testata.GetDescrizione())
};
if(logTransazione == null)
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoArrotondamento);
}
}
private string getDescrizioneMovimento(MovimentoContabile movimento, Esercizio esercizio, bool detrazione)
{
if (movimento.SottoContoRiferimento != null)
return movimento.SottoContoRiferimento.GetDescrizione(esercizio, null, movimento);
if (!string.IsNullOrEmpty(movimento.GetDescrizione(detrazione)))
return movimento.GetDescrizione();
return string.Empty;
}
public TestataMovimentoContabile SetMovimentiRiscaldamentoAcqua(Esercizio esercizio, int idContoAcquaRiscaldata, int idContoRiscaldamento, string descrizioneMovimentoAcqua, string descrizioneMovimentoRiscaldamento, IList<ImportiDTO> importiRiscaldamento, DateTime dataRegistrazione, bool checkDataRegistrazione)
{
// controllo data registrazione
if (checkDataRegistrazione)
{
var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
if (message.Count > 0)
{
var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
_log.Fatal("Data di registrazione non valida - " + Utility.GetMethodDescription() + " - data:" + dataRegistrazione + " - IdEsercizio:" + esercizio.ID, ex);
throw ex;
}
}
var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null)
{
Descrizione = descrizioneMovimentoAcqua,
IsAbilitataArchiviazioneOttica = false,
IsAllowUpdate = true
};
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("SC");
// -------------------------------------------------
// Calcolo Importo
// ------------------------------------------------
var importo = importiRiscaldamento.Sum(item => item.Importo);
// -------------------------------------------------
// Segno Movimento
// ------------------------------------------------
var segnoContoEconomico = "D";
if (importo < 0)
{
segnoContoEconomico = "A";
importo = importo * -1;
}
// ------------------------------------------------
// Conto economico da addebitare
// ------------------------------------------------
var contoEconomico = _daoFactory.GetContoDao().GetById(idContoAcquaRiscaldata, false);
var movimentoContoEconomicoAddebito = new MovimentoContabile(testata, causale, 1, contoEconomico, importo, segnoContoEconomico)
{
Descrizione = descrizioneMovimentoAcqua,
IsRipartoPersonalizzato = true,
RipartoTramiteLetture = true
};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomicoAddebito);
_ripartizioneService.SalvaRipartizione(movimentoContoEconomicoAddebito, importiRiscaldamento, false);
// ------------------------------------------------
// Conto economico da accreditare
// ------------------------------------------------
var movimentoContoEconomicoAccredito = new MovimentoContabile(testata, causale, 2, _daoFactory.GetContoDao().GetById(idContoRiscaldamento, false), importo, invertiSegno(segnoContoEconomico)) {Descrizione = descrizioneMovimentoRiscaldamento};
_daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomicoAccredito);
return testata;
}