/// <summary>
/// Crea uno Stabile valido
/// </summary>
public SottoConto(Conto contoRiferimento, string descrizione)
{
_descrizione = descrizione;
_contoRiferimento = contoRiferimento;
if (contoRiferimento != null)
contoRiferimento.SottoConti.Add(this);
}
/// <summary>
/// Crea un Versamento Condomino valido.
/// </summary>
public VersamentoSoggetto(Esercizio esercizio, SoggettoCondominio soggetto, Conto conto, DateTime data, decimal importo, int numeroProtocollo, TipoVersamentoSoggettoEnum tipo, LogTransazione logTransazione, TipoVersamentoDopoChiusuraEnum? tipoVersamentoDopoChiusura = null, TipoVersamentoPrimaAperturaEnum? tipoVersamentoPrimaApertura = null)
{
Esercizio = esercizio;
Soggetto = soggetto;
ContoPatrimoniale = conto;
Data = data;
Importo = importo;
Tipo = tipo;
NumeroProtocollo = numeroProtocollo;
TipoVersamentoDopoChiusura = tipoVersamentoDopoChiusura;
TipoVersamentoPrimaApertura = tipoVersamentoPrimaApertura;
if (Esercizio != null && Esercizio.Gestione == GestioneEsercizioEnum.Straordinario)
{
TipoVersamentoDopoChiusura = null;
TipoVersamentoPrimaApertura = null;
}
if (Soggetto != null)
Soggetto.Versamenti.Add(this);
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.Versamenti.Add(this);
}
/// <summary>
/// Crea un Dettaglio di spesa valido
/// </summary>
public RipartoConsuntivoSoggettoCondominio(SoggettoCondominio soggetto, Esercizio esercizio, Conto conto, decimal? importo)
{
Importo = importo;
Soggetto = soggetto;
Esercizio = esercizio;
Conto = conto;
}
/// <summary>
/// Crea una Testata di movimento contabile valida
/// </summary>
public TestataRipartoContatoreCondominiale(Esercizio esercizio, Contatore contatoreCondominiale, Conto contoAddebito, SottoConto sottocontoAddebito, string descrizioneMovimentoAddebito)
{
Esercizio = esercizio;
ContatoreCondominiale = contatoreCondominiale;
ContoAddebito = contoAddebito;
SottocontoAddebito = sottocontoAddebito;
DescrizioneMovimentoAddebito = descrizioneMovimentoAddebito;
}
/// <summary>
/// Crea un Versamento Condomino valido.
/// </summary>
public VersamentoSoggetto(Esercizio esercizio, SoggettoCondominio soggetto, Conto conto, DateTime data, decimal importo, FileCBI file, DatiBancariCondomini contoBancario, LogTransazione logTransazione, TipoVersamentoDopoChiusuraEnum? tipoVersamentoDopoChiusura = null, TipoVersamentoPrimaAperturaEnum? tipoVersamentoPrimaApertura = null)
: this(esercizio, soggetto, conto, data, importo, 0, TipoVersamentoSoggettoEnum.CBI, logTransazione, tipoVersamentoDopoChiusura, tipoVersamentoPrimaApertura)
{
ContoBancario = contoBancario;
File = file;
if (File != null)
File.Versamenti.Add(this);
}
/// <summary>
/// Crea un movimento contabile valido.
/// E' relativo al conto economico connesso alla registrazione di una spesa
/// </summary>
public RipartizioneSpesa(Spesa spesa, Conto conto, SottoConto sottoConto, decimal? importo, string segno, string descrizione)
{
Spesa = spesa;
ContoRiferimento = conto;
SottoContoRiferimento = sottoConto;
Importo = importo;
Segno = segno;
Descrizione = descrizione;
}
/// <summary>
/// Crea uno Stabile valido
/// </summary>
public Millesimo(Conto contoRiferimento, UnitaImmobiliare unita)
{
_unitaRiferimento = unita;
_contoRiferimento = contoRiferimento;
if (contoRiferimento != null)
{
contoRiferimento.Millesimi.Add(this);
unita.Millesimi.Add(this);
}
}
/// <summary>
/// Crea un punto di Ordine del Giorno valido
/// </summary>
public OrdineGiornoAssemblea(Assemblea assemblea, string descrizione, Conto contomillesimiRiferimento, int progressivo)
{
Assemblea = assemblea;
Descrizione = descrizione;
//MillesimiRiferimento = MillesimiRiferimento.Proprieta;
ContoMillesimiRiferimento = contomillesimiRiferimento;
Progressivo = progressivo;
if (Assemblea != null)
Assemblea.PuntoOrdineGiorno.Add(this);
}
public DettaglioSubentro(Subentro subentro, Conto conto, SoggettoCondominio soggetto, decimal? importo, int giorni, TipoDettaglioSubentro tipo)
{
Subentro = subentro;
Conto = conto;
Soggetto = soggetto;
Importo = importo;
Giorni = giorni;
Tipo = tipo;
if (Subentro != null)
Subentro.Dettagli.Add(this);
}
/// <summary>
/// Crea il dettaglio di ripartizione conti per un modello di ripartizione
/// </summary>
public ContiModelloRegistrazioneContabile(ModelloRegistrazioneContabile modello, Conto contoRiferimento, SottoConto sottoContoRiferimento, decimal? percentuale, LogTransazione logTransazione)
{
if (modello != null)
{
_modello = modello;
_contoRiferimento = contoRiferimento;
_sottoContoRiferimento = sottoContoRiferimento;
_percentualeRipartizione = percentuale;
_modello.Conti.Add(this);
}
if (LogTransazione != null)
LogTransazione.ContiModelliContabili.Add(this);
}
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 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 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 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 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 AperturaEsercizio(AnnoGestionale annoGestionale, Esercizio esercizio, Conto contoVersamentoCondomini)
{
AnnoGestionale = annoGestionale;
Esercizio = esercizio;
ContoVersamentoCondomini = contoVersamentoCondomini;
}
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;
}
private decimal getMillesimoRiferimento(UnitaImmobiliare unitaImmobiliare, Conto contoMillesimiRiferimento)
{
decimal valoreMillesimo = 0;
if (contoMillesimiRiferimento != null)
{
var millesimo = _daoFactory.GetMillesimoDao().GetByContoSoggetto(contoMillesimiRiferimento.ID, unitaImmobiliare.ID);
if (millesimo != null)
valoreMillesimo = millesimo.Valore.GetValueOrDefault();
}
return valoreMillesimo;
}
public decimal? GetRipartoImporto(UnitaImmobiliare unita, Conto conto, decimal importo, IList<MillesimoDTO> millesimi, Esercizio esercizio, IList<int> idUnitaImmobiliari)
{
try
{
decimal? importoRiparto = null;
if (conto != null && unita != null)
{
// Totale Millesimi
decimal totaleMillesimi;
int numeroMillesimi;
decimal? valore = null;
if (millesimi == null)
{
var millesimi2 = GetByConto(conto, null, null, esercizio);
if(idUnitaImmobiliari != null)
millesimi2 = millesimi2.Where(item => idUnitaImmobiliari.Contains(item.IdUnitaRiferimento)).ToList();
totaleMillesimi = millesimi2.Sum(mill => mill.Valore.GetValueOrDefault());
numeroMillesimi = millesimi2.Count;
var millesimo = _daoFactory.GetMillesimoDao().GetByContoSoggetto(conto.ID, unita.ID);
if(millesimo != null)
valore = millesimo.Valore;
}
else
{
totaleMillesimi = millesimi.Sum(mill => mill.Valore.GetValueOrDefault());
numeroMillesimi = millesimi.Count;
var millesimo = (millesimi.Where(mill => mill.IdContoRiferimento == conto.ID && mill.IdUnitaRiferimento == unita.ID)).SingleOrDefault();
if (millesimo != null)
valore = millesimo.Valore;
}
if (valore != null)
{
if (totaleMillesimi != 0)
{
var valoreMillesimo = (valore.GetValueOrDefault() * 1000) / totaleMillesimi;
importoRiparto = (importo * valoreMillesimo) / 1000m;
}
else
importoRiparto = importo / numeroMillesimi;
}
}
else
{
_log.WarnFormat("Conto o Unità a NULL - {0} - unità:{1} - conto:{2} - importo:{3} - esercizio:{4}", Utility.GetMethodDescription(), unita?.ID.ToString(CultureInfo.InvariantCulture) ?? "<NULL>", conto?.ID.ToString(CultureInfo.InvariantCulture) ?? "<NULL>", importo, esercizio?.ID.ToString(CultureInfo.InvariantCulture) ?? "<NULL>");
}
return importoRiparto;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nel calcolo del riparto dell'importo - {0} - unità:{1} - conto:{2} - importo:{3} - esercizio:{4}", ex, Utility.GetMethodDescription(), unita?.ID.ToString(CultureInfo.InvariantCulture) ?? "<NULL>", conto?.ID.ToString(CultureInfo.InvariantCulture) ?? "<NULL>", importo, esercizio?.ID.ToString(CultureInfo.InvariantCulture) ?? "<NULL>");
throw;
}
}
public virtual Conto ConvertToConto(Condominio condominio)
{
var conto = new Conto(condominio, Tipo, TipoPeriodoCompetenzaContabile.Esercizio, Descrizione, Ripartizione, UtilizzabileRegistrazioneSpese, UtilizzabileVersamentoCondomini)
{
DescrizioneBilancio = DescrizioneBilancio,
Codice = Codice,
PercentualeProprieta = PercentualeProprieta,
PresenteBilancio = PresenteBilancio,
Ordine = Ordine,
UtilizzabilePagamentoFornitori = UtilizzabilePagamentoFornitori,
CustomField = CustomField,
IsSpesePersonali = IsSpesePersonali,
IsLiquido = IsLiquido
};
foreach (var pianoSottoConto in SottoConti)
{
var sottoConto = pianoSottoConto.ConvertToSottoConto(conto);
sottoConto.CustomField = pianoSottoConto.CustomField;
conto.SottoConti.Add(sottoConto);
}
return conto;
}
public virtual SottoConto ConvertToSottoConto(Conto conto)
{
return new SottoConto(conto, Descrizione) { Codice = Codice };
}
private Conto loadContoSottoconto(DataRow row, Condominio condominio, Conto conto, Dictionary<int, Conto> loadedConti, string prefix, ref int indexConto)
{
int psConto = int.Parse(row["PS_CONTO"].ToString());
if (psConto <= 20)
{
if (int.Parse(row["PS_SOTTOC"].ToString()) == 0)
{
if (row["PS_DES_CONTO"] != DBNull.Value && !string.IsNullOrEmpty(row["PS_DES_CONTO"].ToString()))
{
var nomeConto = String.Concat(prefix, ((string)row["PS_DES_CONTO"]).Trim());
if(nomeConto.Length > 50)
nomeConto = nomeConto.Substring(0, 50);
conto = new Conto(condominio, TipoContoEconomicoEnum.Economico, TipoPeriodoCompetenzaContabile.Esercizio, nomeConto, true, true, false) {PresenteBilancio = true, CodiceImportazione = psConto.ToString()};
indexConto = indexConto + 10;
conto.Ordine = indexConto;
conto.Codice = conto.Ordine.ToString().PadLeft(3, '0');
loadedConti.Add(psConto, conto);
}
}
else if (conto != null)
{
if (row["PS_DES_SOTTOC"] != DBNull.Value && !string.IsNullOrEmpty(row["PS_DES_SOTTOC"].ToString()))
{
var indexSottoConto = 0;
var ultimoSottoconto = conto.SottoConti.OrderBy(item => item.Codice).LastOrDefault();
if (ultimoSottoconto != null)
indexSottoConto = int.Parse(ultimoSottoconto.Codice.Split('.')[1]) + 1;
new SottoConto(conto, (string) row["PS_DES_SOTTOC"])
{
Codice = conto.Codice + "." + indexSottoConto.ToString().PadLeft(3, '0'),
CodiceImportazione = row["PS_SOTTOC"].ToString()
};
}
}
}
return conto;
}
public int CalcolaGiorniCompetenza(Esercizio esercizio, Conto conto, DateTime dataIniziale, DateTime dataFinale)
{
try
{
var result = 0;
if(conto != null && esercizio != null)
{
var periodoCompetenza = GetPeriodoCompetenza(conto.TipoCompetenza, esercizio, conto.DataInizioCompetenza, conto.DataFineCompetenza);
var dataInizioCompetenza = periodoCompetenza.DataInizioCompetenza;
var dataFineCompetenza = periodoCompetenza.DataFineCompetenza;
if (dataFineCompetenza < dataInizioCompetenza)
dataFineCompetenza = dataFineCompetenza.AddYears(1);
// Loop per tutti i giorni dell'intervallo per calcolare i giorni di competenza
var data = dataIniziale;
while (data <= dataFinale)
{
if (controlloCompetenzaData(data, dataInizioCompetenza, dataFineCompetenza))
result++;
data = data.AddDays(1);
}
}
return result;
}
catch (Exception ex)
{
var idConto = "<NULL>";
if (conto != null)
idConto = conto.ID.ToString();
var idEsercizio = "<NULL>";
if (esercizio != null)
idEsercizio = esercizio.ID.ToString();
_log.ErrorFormat("Errore inaspettato durante il calcolo dei giorni di competenza - {0} - esercizio:{1} - conto:{2} - dataIniziale:{3} - dataFinale:{4}", ex, Library.Utility.GetMethodDescription(), idEsercizio, idConto, dataIniziale, dataFinale);
throw;
}
}
public Conto GetContoVersamentiPrecedentiAllaApertura(Esercizio esercizio)
{
var conto = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, GetCodiceContoVersamentiPrecedentiAllaApertura());
if (conto == null)
{
conto = new Conto(esercizio.CondominioRiferimento, TipoContoEconomicoEnum.Patrimoniale, TipoPeriodoCompetenzaContabile.Esercizio, "Versamenti di competenza esercizio successivo", false, false, false)
{
CustomField = false,
Codice = GetCodiceContoVersamentiPrecedentiAllaApertura()
};
_daoFactory.GetContoDao().SaveOrUpdate(conto);
}
return conto;
}
public Conto GetContoChiusuraStraordinario(Esercizio esercizio)
{
var conto = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, GetCodiceContoChiusuraTemporaneaStraordinari());
if (conto == null)
{
conto = new Conto(esercizio.CondominioRiferimento, TipoContoEconomicoEnum.Patrimoniale, TipoPeriodoCompetenzaContabile.Esercizio, string.Format("Bilancio di apertura: {0}", esercizio.DisplayName), false, false, false)
{
CustomField = false,
Codice = GetCodiceContoChiusuraTemporaneaStraordinari()
};
_daoFactory.GetContoDao().SaveOrUpdate(conto);
}
return conto;
}
public Conto GetContoArrotondamenti(Esercizio esercizio)
{
var conto = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, GetCodiceContoArrontondamenti());
if (conto == null)
{
conto = new Conto(esercizio.CondominioRiferimento, TipoContoEconomicoEnum.Patrimoniale, TipoPeriodoCompetenzaContabile.Esercizio, "Arrotondamenti", false, true, false)
{
CustomField = false,
Codice = GetCodiceContoArrontondamenti(),
IsArrotondamento = true
};
}
return conto;
}
/// <summary>
/// Crea una ripartizione tra i diversi soggetti valida
/// </summary>
public SoggettoCondominioRipartizione(Conto conto, SoggettoCondominio soggetto, decimal percentualeRipartizione)
{
Conto = conto;
Soggetto = soggetto;
PercentualeRipartizione = percentualeRipartizione;
}
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 IList<MillesimoDTO> GetByConto(Conto conto, List<int> stabili, List<int> gruppi, Esercizio esercizio)
{
IList<MillesimoDTO> millesimiDto = new List<MillesimoDTO>();
if (conto.ContatoreRiferimento == null)
{
var millesimi = conto.GetMillesimiAttivi(stabili, gruppi);
foreach (var millesimo in millesimi)
{
try
{
if (millesimo.UnitaRiferimento.GruppoStabileRiferimento != null)
{
millesimiDto.Add(new MillesimoDTO
{
ID = millesimo.ID,
IdUnitaRiferimento = millesimo.UnitaRiferimento.ID,
IdGruppoRiferimento = millesimo.UnitaRiferimento.GruppoStabileRiferimento.ID,
IdStabileRiferimento = millesimo.UnitaRiferimento.GruppoStabileRiferimento.PalazzinaRiferimento.ID,
IdLottoRiferimento = millesimo.UnitaRiferimento.GruppoStabileRiferimento.PalazzinaRiferimento.LottoRiferimento?.ID ?? 0,
IdContoRiferimento = conto.ID,
Valore = millesimo.Valore,
UnitaMisura = "PC"
});
}
else
{
throw new InvalidDataException($"L'unità immobiliare {millesimo.UnitaRiferimento.Ordine} - {millesimo.UnitaRiferimento.Descrizione} non è associata a nessuna scala");
}
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella creazione del dto di millesimo - {0} - id:{1}", ex, Utility.GetMethodDescription(), millesimo.ID);
throw;
}
}
}
else
{
var dataIniziale = esercizio.DataApertura.GetValueOrDefault();
//var esercizioPrecedente = esercizio.GetEsercizioPrecedente();
//if (esercizioPrecedente != null)
// dataIniziale = esercizioPrecedente.DataChiusura.GetValueOrDefault();
var letture = conto.ContatoreRiferimento.Letture.Where(
item =>
(item.Data == dataIniziale ||
item.Data == esercizio.DataChiusura.GetValueOrDefault()) &&
(
(stabili == null || stabili.Contains(item.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.ID)) &&
(gruppi == null || gruppi.Contains(item.UnitaImmobiliare.GruppoStabileRiferimento.ID))
)).ToList();
foreach (var lettura in letture.Where(item => item.Data == dataIniziale))
{
var valoreIniziale = lettura.Valore;
var letturaFinale = letture.FirstOrDefault(item => item.Data == esercizio.DataChiusura.GetValueOrDefault() && item.UnitaImmobiliare.ID == lettura.UnitaImmobiliare.ID);
var valoreFinale = 0m;
if (letturaFinale != null)
valoreFinale = letturaFinale.Valore;
// Cambio contatore rilevato
if (valoreFinale < valoreIniziale)
valoreIniziale = 0;
var dto = new MillesimoDTO
{
IdUnitaRiferimento = lettura.UnitaImmobiliare.ID,
InternoUnitaRiferimento = lettura.UnitaImmobiliare.InternoCompleto,
IdGruppoRiferimento = lettura.UnitaImmobiliare.GruppoStabileRiferimento.ID,
IdStabileRiferimento = lettura.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.ID,
IdLottoRiferimento = lettura.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.LottoRiferimento?.ID ?? 0,
IdContoRiferimento = conto.ID,
DescrizioneContoRiferimento = conto.Descrizione,
CodiceConto = conto.Codice,
Valore = valoreFinale - valoreIniziale,
UnitaMisura = "MC",
ID = 0
};
millesimiDto.Add(dto);
}
}
return millesimiDto;
}
public RendicontoAnnualeConto(RendicontoAnnuale rendiconto, Conto conto, decimal? importo)
{
Rendiconto = rendiconto;
ContoRiferimento = conto;
Importo = importo;
}
