public string ClearCalcoloAddebito(Esercizio esercizio, TipoUtenza tipoUtenza)
{
try
{
var message = string.Empty;
// ==================================================
// Elimino eventuali vecchi riparti
// ==================================================
var testate = _daoFactory.GetTestataRipartoBolletteDao().GetByEsercizioTipoUtenza(esercizio.ID, tipoUtenza.ID);
foreach (var item in testate)
{
foreach (var ripartoBollette in item.Riparto)
ripartoBollette.Testata = null;
item.Riparto.Clear();
_daoFactory.GetTestataRipartoBolletteDao().Delete(item);
}
return message;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato nella CLEAR del calcolo dell'addebito bolletta - {0} - esercizio:{1} - tipo utenza:{2}", ex, Library.Utility.GetMethodDescription(), esercizio != null ? esercizio.ID.ToString() : "<NULL>", tipoUtenza);
throw;
}
}
/// <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 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);
}
protected void SetUp()
{
var mocks = new MockRepository();
var azienda = new Azienda("PROV", "Azienda di prova");
var condominio = new Condominio("Condominio di prova", 31, 12, 2012, azienda);
var stabile = new Palazzina(condominio, "Stabile di prova", false);
condominio.Palazzine.Add(stabile);
var scala = new GruppoStabile(stabile, "Scala di prova");
var tipoUnitaImmobiliare = new TipoUnitaImmobiliare("Abitazione");
var unitaImmobiliare = new UnitaImmobiliare(scala, tipoUnitaImmobiliare);
var annoGestionale = new AnnoGestionale(condominio, 2012, 2012);
_esercizio = new Esercizio(condominio, new DateTime(2012, 1, 1), new DateTime(2012, 12, 31), annoGestionale, GestioneEsercizioEnum.Ordinario);
_subentroRepository = mocks.Stub<ISubentroUnitaImmobiliareDao>();
var subentro1 = mocks.Stub<SubentroUnitaImmobiliare>();
subentro1.SoggettoEntrante = new SoggettoCondominio(unitaImmobiliare, new Persona(TipoPersonaEnum.Fisica, "Giorgio", "Parmeggiani", 1, true));
subentro1.SoggettoUscente = new SoggettoCondominio(unitaImmobiliare, new Persona(TipoPersonaEnum.Fisica, "Daniele", "Vaccari", 1, true));
var subentro2 = mocks.Stub<SubentroUnitaImmobiliare>();
subentro1.SoggettoEntrante = new SoggettoCondominio(unitaImmobiliare, subentro1.SoggettoUscente.Persona);
subentro1.SoggettoUscente = new SoggettoCondominio(unitaImmobiliare, new Persona(TipoPersonaEnum.Fisica, "Luigi", "Cacciatori", 1, true));
using (mocks.Record())
{
SetupResult.For(_subentroRepository.GetByDataCondominio(_esercizio.CondominioRiferimento.ID, _esercizio.DataApertura.GetValueOrDefault(), _esercizio.DataChiusura.GetValueOrDefault(), false)).Return(new List<SubentroUnitaImmobiliare> { subentro1, subentro2 });
}
}
public static UnitaImmobiliare GetCondominioMonoScalaMonoProprietario()
{
var azienda = new Azienda("TEST", "Azienda di Test") { ID = 1 };
var condominio = new Condominio("Test", 31, 12, 2014, azienda);
var stabile = new Palazzina(condominio, "Stabile A - TEST");
var scala = new GruppoStabile(stabile, "Scala A - TEST");
var tipo = new TipoUnitaImmobiliare("Abitazione");
var unitaImmobiliare = new UnitaImmobiliare(scala, tipo);
// Esercizio
var annoGestionale = new AnnoGestionale(condominio, 2013, 2014);
var esercizio = new Esercizio(condominio, new DateTime(2014, 1, 1), new DateTime(2014, 12, 31), annoGestionale, GestioneEsercizioEnum.Ordinario);
condominio.Esercizi.Add(esercizio);
// Proprietario
var persona = new Persona(TipoPersonaEnum.Fisica, "Pinco", "Pallo", azienda.ID, true);
var proprietario = new Proprietario(unitaImmobiliare, persona)
{
PercentualeRiferimento = 100,
Principale = true
};
unitaImmobiliare.Soggetti.Add(proprietario);
return unitaImmobiliare;
}
/// <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 Dettaglio di spesa valido
/// </summary>
public SaldoSoggetto(SoggettoCondominio soggetto, Esercizio esercizio, decimal? importo)
{
Importo = importo;
Soggetto = soggetto;
Esercizio = esercizio;
if (Esercizio != null)
Esercizio.Saldi.Add(this);
}
public PianoRateale(Esercizio esercizio, TipoAccorpamentoRateEnum tipo, LogTransazione logTransazione)
{
Tipo = tipo;
Esercizio = esercizio;
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.PianoRateale.Add(this);
}
/// <summary>
/// Crea una Spesa valida
/// </summary>
public Spesa(Fornitore fornitore, Esercizio esercizio, LogTransazione logTransazione)
{
FornitoreRiferimento = fornitore;
EsercizioRiferimento = esercizio;
Stato = StatoSpesaEnum.Inserita;
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.Spese.Add(this);
}
public void SetUp()
{
_documentService = MockRepository.GenerateStub<IDocumentService>();
_fileSystem = MockRepository.GenerateStub<IFileSystem>();
const string str = "Documento Bolletta di Prova";
_documentoSpesa = new byte[str.Length * sizeof(char)];
Buffer.BlockCopy(str.ToCharArray(), 0, _documentoSpesa, 0, _documentoSpesa.Length);
_fileSystem = MockRepository.GenerateStub<IFileSystem>();
_fileSystem.Stub(x => x.ReadAllBytes(Arg<string>.Is.Anything)).Return(_documentoSpesa);
IList<Spesa> listaSpese = new List<Spesa>();
_utente = new Utente("PP");
_logTransazione = new LogTransazione(AzioneUtente.TransazioneContabile, _utente, Guid.NewGuid().ToString());
_azienda = new Azienda("PROV", "Prova") { ID = 1 };
_condominio1 = new Condominio("Condominio 1", 31, 12, 2014, _azienda) { CodiceFiscale = "91138030373" };
_annoGestionaleCondominio1 = new AnnoGestionale(_condominio1, 2014, 2014);
_esercizioCondominio1 = new Esercizio(_condominio1, new DateTime(2014, 1, 1), new DateTime(2014, 12, 31), _annoGestionaleCondominio1, GestioneEsercizioEnum.Ordinario);
_condominio2 = new Condominio("Condominio 2", 31, 12, 2014, _azienda) { CodiceFiscale = "90036640374" };
_annoGestionaleCondominio2 = new AnnoGestionale(_condominio2, 2014, 2014);
_esercizioCondominio2 = new Esercizio(_condominio2, new DateTime(2014, 1, 1), new DateTime(2014, 12, 31), _annoGestionaleCondominio2, GestioneEsercizioEnum.Ordinario);
_persona = new Persona(TipoPersonaEnum.Fisica, "Mario", "Rossi", _azienda.ID, true);
_fornitore = new Fornitore(_persona, _azienda.ID);
_documentiBolletteDTO = buildDocumentoBolletteDTO();
foreach (var documentoBollettaDTO in _documentiBolletteDTO)
{
var esercizio = _esercizioCondominio1;
if (documentoBollettaDTO.CodiceFiscaleCliente == _condominio2.CodiceFiscale)
esercizio = _esercizioCondominio2;
listaSpese.Add(new Spesa(_fornitore, esercizio, _logTransazione) { ID = documentoBollettaDTO.IdSpesa, NumeroDocumento = documentoBollettaDTO.NumeroDocumento, DataDocumento = documentoBollettaDTO.DataDocumento });
}
_daoFactory = MockRepository.GenerateStub<IDaoFactory>();
_daoFactory.Stub(x => x.GetCondominioDao().GetByCodiceFiscale(_condominio1.CodiceFiscale)).Return(_condominio1);
_daoFactory.Stub(x => x.GetCondominioDao().GetByCodiceFiscale(_condominio2.CodiceFiscale)).Return(_condominio2);
_spesaDao = MockRepository.GenerateStub<ISpesaDao>();
_documentoDao = MockRepository.GenerateStub<IDocumentoDao>();
_daoFactory.Stub(x => x.GetSpesaDao()).Return(_spesaDao);
_daoFactory.Stub(x => x.GetDocumentoDao()).Return(_documentoDao);
foreach (var spesa in listaSpese)
_spesaDao.Stub(x => x.Find(spesa.ID, false)).Return(spesa);
_utenzaDocumentoService = MockRepository.GenerateMock<UtenzaDocumentoService>(_daoFactory, _documentService, _fileSystem);
}
/// <summary>
/// Crea un sollecito valido.
/// </summary>
public Sollecito(Esercizio esercizio, Persona persona, DateTime data, DateTime dataLimiteRate, decimal importoLimite, decimal importoDaVersare, DatiBancariCondomini banca, string oggettoLettera, string testoLettera)
{
Esercizio = esercizio;
Persona = persona;
Data = data;
DataLimiteRate = dataLimiteRate;
ImportoLimite = importoLimite;
ImportoDaVersare = importoDaVersare;
OggettoLettera = oggettoLettera;
TestoLettera = testoLettera;
Banca = banca;
}
public SoggettoCondominio GetSoggettoPrincipale(Persona persona, Esercizio esercizio)
{
try
{
var soggetti = _daoFactory.GetSoggettoCondominioDao().GetByCondominioPersona(esercizio.CondominioRiferimento.ID, persona.ID).Where(item => item.DataFine == null || item.DataFine > esercizio.DataApertura.GetValueOrDefault()).ToList();
var soggetto = soggetti.FirstOrDefault(item => item.UnitaImmobiliare.TipoUnitaImmobiliare.ID == 1) ?? soggetti.FirstOrDefault();
return soggetto;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante la lettura del soggetto principale - {0} - persona:{1} - esercizio:{2}", ex, Library.Utility.GetMethodDescription(), persona.ID, esercizio.ID);
throw;
}
}
/// <summary>
/// Crea una rata di pagamento condomino valida.
/// </summary>
public RataSoggetto(Esercizio esercizio, SoggettoCondominio soggetto, DateTime dataScadenza, decimal importo, LogTransazione logTransazione)
{
Esercizio = esercizio;
Soggetto = soggetto;
DataScadenza = dataScadenza;
Importo = importo;
_stato = StatoRataEnum.Inserita;
if (Soggetto != null)
Soggetto.Rate.Add(this);
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.Rate.Add(this);
}
/// <summary>
/// Crea una Testata di movimento contabile valida
/// </summary>
public TestataMovimentoContabile(Esercizio esercizio, DateTime? dataRegistrazione, TipoTestataMovimentoContabileEnum tipo, LogTransazione logTransazione)
{
EsercizioRiferimento = esercizio;
DataRegistrazione = dataRegistrazione;
Tipo = tipo;
LogTransazione = logTransazione;
if (LogTransazione != null)
LogTransazione.TestateContabili.Add(this);
if (Tipo == TipoTestataMovimentoContabileEnum.Manuale)
IsAllowUpdate = true;
else if (Tipo == TipoTestataMovimentoContabileEnum.Automatica)
IsAllowUpdate = false;
}
/// <summary>
/// Crea un sollecito valido.
/// </summary>
public Sollecito(Esercizio esercizio, SoggettoCondominio soggetto, DateTime data, DateTime dataLimiteRate, decimal importoLimite, decimal importoDaVersare, DatiBancariCondomini banca, string oggettoLettera, string testoLettera)
{
Esercizio = esercizio;
Soggetto = soggetto;
Data = data;
DataLimiteRate = dataLimiteRate;
ImportoLimite = importoLimite;
ImportoDaVersare = importoDaVersare;
OggettoLettera = oggettoLettera;
TestoLettera = testoLettera;
Banca = banca;
if (Soggetto != null)
Soggetto.Solleciti.Add(this);
}
public IList<ImportiDTO> GetImportoMovimentiVersatoByEsercizio(Esercizio esercizio, int? idStabile, int? idScala)
{
try
{
if(esercizio.Gestione == GestioneEsercizioEnum.Straordinario)
return _daoFactory.GetVersamentoSoggettoDao().GetTotaleVersamentiByEsercizioSoggettoData(esercizio.ID, idStabile, idScala, null);
var causaleVersamenti = _daoFactory.GetCausaleContabileDao().GetByCodice("RR");
var causaleVersamentiDopoChiusura = _daoFactory.GetCausaleContabileDao().GetByCodice("VS");
if (causaleVersamenti != null && causaleVersamentiDopoChiusura != null)
{
var causali = new List<int>
{
causaleVersamenti.ID,
causaleVersamentiDopoChiusura.ID
};
var dataInizio = new DateTime(1753, 1, 1);
var dataFine = DateTime.MaxValue;
if (esercizio.Gestione == GestioneEsercizioEnum.Ordinario)
{
dataInizio = esercizio.DataApertura.GetValueOrDefault();
dataFine = esercizio.DataChiusura.GetValueOrDefault();
}
IList<MovimentoContabile> movimentiVersamenti;
var contoVersamenti = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini());
if(contoVersamenti != null)
movimentiVersamenti = _daoFactory.GetMovimentoContabileDao().GetByContoCausaleData(contoVersamenti.ID, causali, dataInizio, dataFine);
else
throw new InvalidDataException("Non trovato il conto versamenti condomini");
var movimentiPerCondomino = movimentiVersamenti.Where(item => item.CondominoRiferimento != null).GroupBy(item => item.CondominoRiferimento);
return movimentiPerCondomino.Select(movimentoCondomino => new ImportiDTO(movimentoCondomino.Key.ID, movimentoCondomino.Where(item => (idStabile == null || item.CondominoRiferimento.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.ID == idStabile.Value) && (idScala == null || item.CondominoRiferimento.UnitaImmobiliare.GruppoStabileRiferimento.ID == idScala.Value)).Sum(item => item.Segno == "A" ? item.Importo.GetValueOrDefault() : item.Importo.GetValueOrDefault() * -1))).ToList();
}
_log.FatalFormat("Non trovate le causali 'RR' - 'VS' - {0} - esercizio:{1}", Utility.GetMethodDescription(), esercizio.ID);
throw new InvalidDataException("Non trovate le causali 'RR' - 'VS'");
}
catch (Exception ex)
{
_log.ErrorFormat("Errore nella lettura degli importi versati per esercizio - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio?.ID.ToString() ?? "<NULL>");
throw;
}
}
public IList<string> IsAllowDataRegistrazione(IList<int> idCondomini, Esercizio esercizio, DateTime dataRegistrazione)
{
try
{
var message = new List<string>();
if (dataRegistrazione != DateTime.MinValue)
{
if (esercizio != null)
{
if (dataRegistrazione < esercizio.DataApertura.GetValueOrDefault() || dataRegistrazione > esercizio.DataChiusura.GetValueOrDefault() || esercizio.Stato == StatoEsercizioEnum.Chiuso)
{
message.Add(string.Format("Data non valida per l'esercizio {0} - Data inizio esercizio: {1:d} - Data fine esercizio:{2:d}", esercizio.DisplayName, esercizio.DataApertura.GetValueOrDefault(), esercizio.DataChiusura.GetValueOrDefault()));
_log.DebugFormat("Data di registrazione non corretta - {0} - esercizio:{1} - dataApertura:{2} - dataChiusura:{3} - dataRegistrazione:{4}", Utility.GetMethodDescription(), esercizio.ID, esercizio.DataApertura.GetValueOrDefault(), esercizio.DataChiusura.GetValueOrDefault(), dataRegistrazione);
}
}
foreach (var id in idCondomini)
{
var condominio = _daoFactory.GetCondominioDao().Find(id, false);
if (condominio != null)
{
var dataUltimaChiusura = _condominioService.GetDataUltimaChiusura(condominio).GetValueOrDefault();
if (dataRegistrazione <= dataUltimaChiusura)
{
message.Add(string.Format("Data non valida per il condominio {0} - Ultima chiusura: {1}", condominio.DisplayName, dataUltimaChiusura.ToShortDateString()));
_log.DebugFormat("Data di registrazione non corretta - {0} - condominio:{1} - dataUltimaChiusura:{2} - dataRegistrazione:{3}", Utility.GetMethodDescription(), id, dataUltimaChiusura, dataRegistrazione);
}
var esercizioCompetenza = getEsercizioCompetenza(condominio, dataRegistrazione);
if (esercizioCompetenza == null || esercizioCompetenza.Stato == StatoEsercizioEnum.Chiuso)
{
var messageEsercizio = esercizioCompetenza == null ? "l'esercizio di competenza non è ancora stato aperto" : string.Format("l'esercizio '{0}' è chiuso", esercizioCompetenza.DisplayName);
message.Add(string.Format("{0} - Non è possibile registrare il movimento in data {1:d} perchè {2}.", condominio.DisplayName, dataRegistrazione, messageEsercizio));
}
}
}
}
return message;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante il controllo di validità della data di registrazione - {0} - idCondomini:{1} - dataRegistrazione:{2}", ex, Utility.GetMethodDescription(), idCondomini.Aggregate(string.Empty, (current, id) => current + (id + " - ")), dataRegistrazione);
throw;
}
}
public SoggettoCondominio GetSoggettoAttuale(SoggettoCondominio soggetto, Esercizio esercizio, DateTime dataRiferimento)
{
try
{
if (!soggetto.SubentriUscita.Any())
{
var soggettiAttivi = _daoFactory.GetSoggettoCondominioDao().GetAttiviByEsercizioUnita(soggetto.UnitaImmobiliare.ID, esercizio);
if (soggettiAttivi.Any(item => item.ID == soggetto.ID))
return soggetto;
var proprietariPrincipali = soggettiAttivi.Where(item => item.Tipo == TipoSoggetto.Proprietario && item.Principale.GetValueOrDefault()).ToList();
if (soggetto.Tipo == TipoSoggetto.Proprietario && proprietariPrincipali.Any())
return proprietariPrincipali.FirstOrDefault();
if (soggetto.Tipo == TipoSoggetto.Proprietario && !proprietariPrincipali.Any())
return soggetto;
if (soggetto.Tipo == TipoSoggetto.Conduttore)
{
var conduttoriPrincipali = soggettiAttivi.Where(item => item.Tipo == TipoSoggetto.Conduttore && item.Principale.GetValueOrDefault()).ToList();
if (conduttoriPrincipali.Any())
return conduttoriPrincipali.FirstOrDefault();
if (proprietariPrincipali.Any())
return proprietariPrincipali.FirstOrDefault();
return soggetto;
}
return soggetto;
}
var subentro = soggetto.SubentriUscita.Where(item => item.Subentro.Data > dataRiferimento).OrderByDescending(item => item.Subentro.Data).FirstOrDefault();
if (subentro != null && subentro.SoggettoEntrante != null)
return GetSoggettoAttuale(subentro.SoggettoEntrante, esercizio, subentro.Subentro.Data);
return soggetto;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore durante la lettura del soggetto attuale - {0} - soggetto:{1} - esercizio:{2}", ex, Library.Utility.GetMethodDescription(), soggetto.ID, esercizio != null ? esercizio.ID.ToString() : "<NULL>");
throw;
}
}
public DataTable FillDataSource(DataTable table, int codiceConto, decimal? importo, Esercizio esercizio)
{
// Calcolo totale dei millesimi, per ragioni di performance memorizzo le istanze di millesimo trovate.
decimal totaleMillesimi = 0;
var conto = _daoFactory.GetContoDao().GetById(codiceConto, false);
var millesimi = GetByConto(conto, null, null, esercizio);
// =============================================================================
// Calcolo basato su millesimi
// =============================================================================
var millesimiRow = new Dictionary<DataRow, MillesimoDTO>();
if (!conto.IsSpesePersonali)
{
foreach (DataRow row in table.Rows)
{
try
{
row["ValoreMillesimo"] = DBNull.Value;
row["Importo"] = DBNull.Value;
if ((bool)row["Selezionato"])
{
var row1 = row;
var millesimiUnita = from millesimo in millesimi
where millesimo.IdUnitaRiferimento == (int)row1["IdUnitaImmobiliare"]
select millesimo;
foreach (var millesimo in millesimiUnita)
{
row["IdMillesimo"] = millesimo.ID;
if (millesimo.Valore != null)
{
row["ValoreMillesimo"] = millesimo.Valore;
totaleMillesimi += millesimo.Valore.Value;
}
millesimiRow.Add(row, millesimo);
break;
}
}
}
catch (Exception ex)
{
_log.Error("Errore nel calcolo dei millesimi per ripartizione spesa: " + Utility.GetMethodDescription() + " - Calcolo basato su millesimi", ex);
throw;
}
}
// --------------------------------------------
// Ricalcolo millesimi e importi
// --------------------------------------------
// Se il conto non è soggetto a ripartizione NON devo valorizzare l'importo
if (conto.Ripartizione)
{
var unitaSelezionate = 0;
foreach (var kvp in millesimiRow)
{
try
{
if ((bool)kvp.Key["Selezionato"] && kvp.Value.Valore != null)
unitaSelezionate++;
}
catch (Exception ex)
{
_log.Error("Errore nel calcolo dei millesimi per ripartizione spesa: " + Utility.GetMethodDescription() + " - Conteggio unità selezionate", ex);
throw;
}
}
foreach (var kvp in millesimiRow)
{
try
{
if ((bool)kvp.Key["Selezionato"] && kvp.Value.Valore != null)
{
if (totaleMillesimi != 0)
{
var valoreMillesimo = (kvp.Value.Valore.Value * 1000) / totaleMillesimi;
kvp.Key["ValoreMillesimo"] = valoreMillesimo;
if (importo != null)
kvp.Key["Importo"] = (valoreMillesimo * importo) / 1000;
}
else
{
kvp.Key["ValoreMillesimo"] = 0;
// importo diviso in parti uguali
kvp.Key["Importo"] = importo / unitaSelezionate;
}
}
}
catch (Exception ex)
{
_log.Error("Errore nel calcolo dei millesimi per ripartizione spesa: " + Utility.GetMethodDescription() + " - Ricalcolo millesimi e importi", ex);
throw;
}
}
}
}
// =============================================================================
// Spese Personali
// =============================================================================
else
{
// Se sono spese personali, se non è stato ancora definito un importo e se ho una solo unità selezionata, propongo l'intero importo.
var numeroSelezioni = 0;
DataRow rowSelezionata = null;
foreach (DataRow row in table.Rows)
{
if ((bool)row["Selezionato"])
{
numeroSelezioni++;
rowSelezionata = row;
}
else
{
row["Importo"] = 0;
row["ValoreMillesimo"] = 0;
}
}
if (numeroSelezioni == 1)
{
if (rowSelezionata != null)
{
rowSelezionata["Importo"] = importo;
rowSelezionata["ValoreMillesimo"] = 1000m;
}
}
}
return table;
}
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 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;
}
}
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;
}
private string[] getContiSottocontiDettagliAddebito(IEnumerable<MovimentoContabile> movimenti, ICollection<string> descrizioniConti, ICollection<string> descrizioniSottoConti, ICollection<string> dettagli, bool testata, bool detrazione, Esercizio esercizio)
{
var skip = 0;
if (testata)
skip = 1;
var descrizioneConto = string.Empty;
var descrizioneSottoConto = string.Empty;
var dettaglio = string.Empty;
foreach (var item in movimenti.Skip(skip))
{
// ----------------------------------
// Conti
// ----------------------------------
if (!descrizioniConti.Contains(item.GetContoRiferimento(detrazione).Descrizione))
{
if (!string.IsNullOrEmpty(descrizioneConto))
{
if (!descrizioneConto.Contains("<br/>"))
descrizioneConto = "<b>" + descrizioneConto + "</b><br/>";
else
descrizioneConto += "<br/>";
}
descrizioneConto += item.GetContoRiferimento(detrazione).Descrizione;
descrizioniConti.Add(item.GetContoRiferimento(detrazione).Descrizione);
}
// ----------------------------------
// Sotto Conti
// ----------------------------------
var sottoConto = getDescrizioneMovimento(item, esercizio, detrazione);
if (!descrizioniSottoConti.Contains(sottoConto))
{
if (!string.IsNullOrEmpty(descrizioneSottoConto))
{
if (!descrizioneSottoConto.Contains("<br/>"))
descrizioneSottoConto = "<b>" + descrizioneSottoConto + "</b><br/>";
else
descrizioneSottoConto += "<br/>";
}
descrizioneSottoConto += sottoConto;
descrizioniSottoConti.Add(sottoConto);
}
// ----------------------------------
// Dettagli
// ----------------------------------
if (dettagli != null && !dettagli.Contains(item.Descrizione))
{
if (!string.IsNullOrEmpty(dettaglio))
{
if (!dettaglio.Contains("<br/>"))
dettaglio = "<b>" + dettaglio + "</b><br/>";
else
dettaglio += "<br/>";
}
dettaglio += item.Descrizione;
dettagli.Add(item.Descrizione);
}
}
return new[]{ descrizioneConto, descrizioneSottoConto, dettaglio};
}
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 string AperturaContiPatrimoniali(Esercizio esercizio)
{
try
{
var message = string.Empty;
if (esercizio.GetEsercizioPrecedente() != null)
{
var testata = new TestataMovimentoContabile(esercizio, esercizio.DataApertura, TipoTestataMovimentoContabileEnum.Automatica, null) { AperturaChiusuraConti = true };
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("AC");
var contoTransitorio = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, "999");
// ---------------------------------------------------------------------------------------
// Registro tutti movimenti di apertura dei conti
// ---------------------------------------------------------------------------------------
var index = 0;
var testate = _daoFactory.GetTestataMovimentoContabileDao().GetTestateMovimentiByEsercizioCausale(esercizio.GetEsercizioPrecedente(), _daoFactory.GetCausaleContabileDao().GetByCodice("OC")).Where(item => item.AperturaChiusuraConti).ToList();
if (testate.Count > 1)
{
_log.ErrorFormat("ATTENZIONE: Trovata più di una testata con causale di chiusura 'OC' nell'esercizio - {0} - esercizio:{1}", Utility.GetMethodDescription(), esercizio.ID);
return string.Format("Trovata più di una testata di chiusura nell'esercizio: '{0}'", esercizio.DisplayName);
}
else if(testate.Count == 0)
{
_log.ErrorFormat("ATTENZIONE: Non è stata trovata nessuna causale di chiusura 'OC' nell'esercizio - {0} - esercizio:{1}", Utility.GetMethodDescription(), esercizio.ID);
return string.Format("Non è stata trovata nessuna testata di chiusura nell'esercizio: '{0}'", esercizio.DisplayName);
}
else
{
foreach (var movimento in testate[0].Movimenti)
{
var importo = movimento.GetImportoSenzaSegno();
index++;
if (movimento.ContoRiferimento.Codice != "998")
{
new MovimentoContabile(testata, causale, index, movimento.ContoRiferimento, importo, invertiSegno(movimento.Segno))
{
Descrizione = movimento.Descrizione.Replace("Chiusura", "Apertura"),
Stato = StatoMovimentoContabileEnum.Evaso,
FornitoreRiferimento = movimento.FornitoreRiferimento,
CondominoRiferimento = movimento.CondominoRiferimento,
ContoCorrenteBancario = movimento.ContoCorrenteBancario,
SottoContoRiferimento = movimento.SottoContoRiferimento
};
}
else
{
new MovimentoContabile(testata, causale, index, contoTransitorio, importo, invertiSegno(movimento.Segno))
{
Descrizione = movimento.Descrizione.Replace("Chiusura", "Apertura"),
Stato = StatoMovimentoContabileEnum.Evaso,
FornitoreRiferimento = movimento.FornitoreRiferimento,
CondominoRiferimento = movimento.CondominoRiferimento,
ContoCorrenteBancario = movimento.ContoCorrenteBancario,
SottoContoRiferimento = movimento.SottoContoRiferimento
};
}
}
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
}
}
return message;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante l'apertura dei conti patrimoniali - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
throw;
}
}
public string EliminazioneOperazioniAperturaChiusuraStraordinario(Esercizio esercizio)
{
try
{
var message = string.Empty;
// ========================================================
// Elimino i movimenti di chiusura dei conti economici
// ========================================================
var testataToDelete = esercizio.TestataContabileChiusura;
if (testataToDelete != null)
{
// Se l'esercizio di riferimento della testata è un esercizio straordinario la chiusura dello straordinario è avvenuta verso
// un altro esercizio straordinario, occorre allora eliminare i saldi di inizio esercizio
if (testataToDelete.EsercizioRiferimento.Gestione == GestioneEsercizioEnum.Straordinario)
{
foreach (var saldoSoggetto in testataToDelete.EsercizioRiferimento.Saldi)
saldoSoggetto.Esercizio = null;
testataToDelete.EsercizioRiferimento.Saldi.Clear();
}
// Eliminazione movimenti apertura/chiusura
esercizio.TestataContabileChiusura = null;
_daoFactory.GetTestataMovimentoContabileDao().Delete(testataToDelete);
// Elimino i movimenti di giroconto dei versamenti condomini
var testateChiusura = _daoFactory.GetTestataMovimentoContabileDao().GetTestateMovimentiByEsercizioChiusura(esercizio);
foreach (var testata in testateChiusura)
_daoFactory.GetTestataMovimentoContabileDao().Delete(testata);
// Elimino i movimenti di giroconto dei versamenti condomini dopo la data di chiusura
const string hql = "FROM MovimentoContabile MOV WHERE MOV.Testata.EsercizioRiferimento = :esercizio AND MOV.Causale.Codice = 'VC'";
var movimentiVersamentiDopoChiusura = _daoFactory.GetMovimentoContabileDao().GetByQuery(hql, new[] { new QueryParam("esercizio", esercizio.ID) });
foreach (var movimentoContabile in movimentiVersamentiDopoChiusura)
{
movimentoContabile.Testata.Movimenti.Remove(movimentoContabile);
movimentoContabile.ContoRiferimento.Movimenti.Remove(movimentoContabile);
_daoFactory.GetMovimentoContabileDao().Delete(movimentoContabile);
}
}
return message;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la eliminazione delle operazioni di apertura e chiusura conti - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio != null ? esercizio.ID.ToString() : "<NULL>");
throw;
}
}
public string EliminazioneOperazioniAperturaChiusura(Esercizio esercizio)
{
try
{
var message = string.Empty;
if (esercizio != null && esercizio.Gestione == GestioneEsercizioEnum.Ordinario)
{
// Testate movimenti di chiusura
var testateToDelete = _daoFactory.GetTestataMovimentoContabileDao().GetTestateMovimentiByEsercizioChiusura(esercizio).ToList();
// Testate movimenti di apertura
var annoSuccessivo = _daoFactory.GetAnnoGestionaleDao().GetAnnoSuccessivo(esercizio.AnnoGestionale.ID);
if (annoSuccessivo != null && annoSuccessivo.EsercizioOrdinario != null)
testateToDelete.AddRange(_daoFactory.GetTestataMovimentoContabileDao().GetTestateMovimentiByEsercizioApertura(annoSuccessivo.EsercizioOrdinario));
// Testate movimenti di chiusura temporanea dello straordinario
testateToDelete.AddRange(_daoFactory.GetTestataMovimentoContabileDao().GetByChiusuraEsercizioOrdinario(esercizio));
// ----------------------------------------
// Delete di tutte le testate
// ----------------------------------------
foreach (var testata in testateToDelete)
DeleteTestata(testata);
}
else
{
if (esercizio == null)
message += "L'esercizio è NULL." + Environment.NewLine;
else if(esercizio.Gestione != GestioneEsercizioEnum.Ordinario)
message += "L'esercizio non è un esercizio ordinario." + Environment.NewLine;
}
return message;
}
catch (Exception ex)
{
_log.ErrorFormat("Errore inaspettato durante la eliminazione delle operazioni di apertura e chiusura conti - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio != null ? esercizio.ID.ToString() : "<NULL>");
throw;
}
}
public TestataMovimentoContabile ChiusuraContiPatrimoniali(Esercizio esercizio)
{
try
{
var testata = new TestataMovimentoContabile(esercizio, esercizio.DataChiusura, TipoTestataMovimentoContabileEnum.Automatica, null) {AperturaChiusuraConti = true};
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("OC");
var contoTransitorio = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, "998");
// =======================================================================================
// Registro tutti movimenti di chiusura dei conti
// =======================================================================================
var index = 0;
foreach (var conto in esercizio.CondominioRiferimento.Conti)
{
if (conto.Tipo == TipoContoEconomicoEnum.Patrimoniale && conto.Codice != _pianoContiService.GetCodiceContoRateCondomini() && conto.Codice != "910")
{
try
{
// ================
// Conto Fornitori
// ================
if (conto.Codice == _pianoContiService.GetCodiceContoFornitori())
{
var saldi = getSaldoContoFornitori(esercizio.ID, conto.ID);
_log.DebugFormat("Chiusura conti - CONTO FORNITORI - {0} - esercizio:{1} - count:{2} - importo:{3}", Utility.GetMethodDescription(), esercizio.ID, saldi.Count, saldi.Sum(item => item.Value));
foreach (var kvp in saldi)
{
try
{
if (kvp.Value != 0)
{
var saldo = kvp.Value;
// ---------------------------------------------------------------------------------------
// Movimento di chiusura
// ---------------------------------------------------------------------------------------
_log.DebugFormat("Chiusura conti - SINGOLO FORNITORE - {0} - fornitore:{1} {2} - esercizio:{3} - importo:{4}", Utility.GetMethodDescription(), kvp.Key.ID, kvp.Key.DisplayName, esercizio.ID, saldo);
index++;
var segno = "D";
if (saldo < 0)
{
segno = "A";
saldo = saldo * -1;
}
new MovimentoContabile(testata, kvp.Key, causale, index, conto, saldo, segno)
{
FornitoreRiferimento = kvp.Key,
Descrizione = string.Format("Chiusura conto '{0} {1}' - {2} Esercizio '{3}'", conto.Codice, conto.Descrizione, kvp.Key.DisplayName, esercizio.DisplayName),
Stato = StatoMovimentoContabileEnum.Evaso
};
// ---------------------------------------------------------------------------------------
// Registro la contropartita in un conto transitorio
// ---------------------------------------------------------------------------------------
var saldoContropartita = kvp.Value;
index++;
segno = "A";
if (saldoContropartita < 0)
{
segno = "D";
saldoContropartita = saldoContropartita * -1;
}
index++;
new MovimentoContabile(testata, causale, index, contoTransitorio, saldoContropartita, segno)
{
FornitoreRiferimento = kvp.Key,
Stato = StatoMovimentoContabileEnum.Evaso,
Descrizione = string.Format("Chiusura di bilancio - conto '{0} {1}' - {2} Esercizio '{3}'", conto.Codice, conto.Descrizione, kvp.Key.DisplayName, esercizio.DisplayName)
};
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la chiusura dei conti patrimoniali - (SINGOLO FORNITORE) - {0} - fornitore:{1} - conto:{2} {3} - esercizio:{4}", ex, Utility.GetMethodDescription(), kvp.Key.ID, conto.ID, conto.Descrizione, esercizio.ID);
throw;
}
}
}
// ================
// Conto Banca
// ================
else if (conto.Codice == _pianoContiService.GetCodiceContoBancario())
{
var saldi = getSaldoContoBanca(esercizio.ID, conto.ID);
_log.DebugFormat("Chiusura conti - CONTO BANCA - {0} - esercizio:{1} - count:{2} - importo:{3}", Utility.GetMethodDescription(), esercizio.ID, saldi.Count, saldi.Sum(item => item.Value));
foreach (var kvp in saldi)
{
try
{
if (kvp.Value != 0)
{
var saldo = kvp.Value;
// ---------------------------------------------------------------------------------------
// Movimento di chiusura
// ---------------------------------------------------------------------------------------
_log.DebugFormat("Chiusura conti - SINGOLO FORNITORE - {0} - contoCorrente:{1} {2} - esercizio:{3} - importo:{4}", Utility.GetMethodDescription(), kvp.Key.ID, kvp.Key.DisplayName, esercizio.ID, saldo);
index++;
var segno = "D";
if (saldo < 0)
{
segno = "A";
saldo = saldo * -1;
}
new MovimentoContabile(testata, causale, index, conto, saldo, segno)
{
ContoCorrenteBancario = kvp.Key,
Descrizione = string.Format("Chiusura conto '{0} {1}' - {2} Esercizio '{3}'", conto.Codice, conto.Descrizione, kvp.Key.DisplayName, esercizio.DisplayName),
Stato = StatoMovimentoContabileEnum.Evaso
};
// ---------------------------------------------------------------------------------------
// Registro la contropartita in un conto transitorio
// ---------------------------------------------------------------------------------------
var saldoContropartita = kvp.Value;
index++;
segno = "A";
if (saldoContropartita < 0)
{
segno = "D";
saldoContropartita = saldoContropartita * -1;
}
index++;
new MovimentoContabile(testata, causale, index, contoTransitorio, saldoContropartita, segno)
{
ContoCorrenteBancario = kvp.Key,
Stato = StatoMovimentoContabileEnum.Evaso,
Descrizione = string.Format("Chiusura di bilancio - conto '{0} {1}' - {2} Esercizio '{3}'", conto.Codice, conto.Descrizione, kvp.Key.DisplayName, esercizio.DisplayName)
};
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la chiusura dei conti patrimoniali - (SINGOLO FORNITORE) - {0} - contoCorrente:{1} - conto:{2} {3} - esercizio:{4}", ex, Utility.GetMethodDescription(), kvp.Key.ID, conto.ID, conto.Descrizione, esercizio.ID);
throw;
}
}
}
// ================
// Conto Condomini
// ================
else if (conto.Codice == _pianoContiService.GetCodiceContoRateCondomini() || conto.Codice == _pianoContiService.GetCodiceContoVersamentiCondomini())
{
var saldi = getSaldoContoCondomini(esercizio.ID, conto.ID);
_log.DebugFormat("Chiusura conti - CONTO CONDOMINI - {0} - esercizio:{1} - count:{2} - importo:{3}", Utility.GetMethodDescription(), esercizio.ID, saldi.Count, saldi.Sum(item => item.Value));
foreach (var kvp in saldi)
{
try
{
if (kvp.Value != 0)
{
var saldo = kvp.Value;
// ---------------------------------------------------------------------------------------
// Movimento di chiusura
// ---------------------------------------------------------------------------------------
SoggettoCondominio soggettoCondominio = null;
var nomeCondomino = string.Empty;
if (kvp.Key > 0)
{
soggettoCondominio = _daoFactory.GetSoggettoCondominioDao().GetById(kvp.Key, false);
nomeCondomino = soggettoCondominio.DisplayName;
}
_log.DebugFormat("Chiusura conti - SINGOLO CONDOMINO - {0} - condomino:{1} {2} - esercizio:{3} - importo:{4}", Utility.GetMethodDescription(), kvp, nomeCondomino, esercizio.ID, saldo);
var segno = "D";
if (saldo < 0)
{
segno = "A";
saldo = saldo * -1;
}
index++;
new MovimentoContabile(testata, causale, index, conto, saldo, segno)
{
CondominoRiferimento = soggettoCondominio,
Stato = StatoMovimentoContabileEnum.Evaso,
Descrizione = string.Format("Chiusura conto '{0} {1}' - {2} Esercizio '{3}'", conto.Codice, conto.Descrizione, nomeCondomino, conto.EsercizioRiferimento == null ? esercizio.DisplayName : conto.EsercizioRiferimento.DisplayName),
};
// ---------------------------------------------------------------------------------------
// Registro la contropartita in un conto transitorio
// ---------------------------------------------------------------------------------------
var saldoContropartita = kvp.Value;
index++;
segno = "A";
if (saldoContropartita < 0)
{
segno = "D";
saldoContropartita = saldoContropartita * -1;
}
index++;
new MovimentoContabile(testata, causale, index, contoTransitorio, saldoContropartita, segno)
{
CondominoRiferimento = soggettoCondominio,
Stato = StatoMovimentoContabileEnum.Evaso,
Descrizione = string.Format("Chiusura di bilancio - conto '{0} {1}' - {2} Esercizio '{3}'", conto.Codice, conto.Descrizione, nomeCondomino, esercizio.DisplayName)
};
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la chiusura dei conti patrimoniali - (SINGOLO CONDOMINO) - {0} - condomino:{1} - conto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), kvp.Key, conto.Descrizione, esercizio.ID);
throw;
}
}
}
else
{
// ================
// Altri Conti
// ================
var idConti = new List<int> { conto.ID };
var movimenti = GetMovimentiByContiData(esercizio.CondominioRiferimento.ID, esercizio.DataApertura.GetValueOrDefault(), esercizio.DataChiusura.GetValueOrDefault(), idConti);
var movimentiPerSottoconto = movimenti.GroupBy(item => item.SottoContoRiferimento);
foreach (var sottoconto in movimentiPerSottoconto)
{
var saldo = sottoconto.Sum(item => item.GetImportoConSegno(false, true).GetValueOrDefault());
var saldoContropartita = saldo;
if (saldo != 0)
{
// ---------------------------------------------------------------------------------------
// Movimento di chiusura
// ---------------------------------------------------------------------------------------
var idSottoconto = "<NULL>";
var descrizioneSottoconto = "<NULL>";
if (sottoconto.Key != null)
{
idSottoconto = sottoconto.Key.ID.ToString();
descrizioneSottoconto = sottoconto.Key.Descrizione;
}
_log.DebugFormat("Chiusura conti - SINGOLO SOTTOCONTO - {0} - sottconto:{1} {2} - esercizio:{3} - importo:{4}", Utility.GetMethodDescription(), idSottoconto, descrizioneSottoconto, esercizio.ID, saldo);
index++;
var segno = "D";
if (saldo < 0)
{
segno = "A";
saldo = saldo * -1;
}
new MovimentoContabile(testata, causale, index, conto, saldo, segno)
{
SottoContoRiferimento = sottoconto.Key,
Descrizione = sottoconto.Key != null ? string.Format("Chiusura conto '{0} {1}' - {2} Esercizio '{3}'", conto.Codice, conto.Descrizione, sottoconto.Key.Descrizione, esercizio.DisplayName) : string.Format("Chiusura conto {0} - Esercizio '{1}'", conto.Descrizione, esercizio.DisplayName),
Stato = StatoMovimentoContabileEnum.Evaso
};
// ---------------------------------------------------------------------------------------
// Registro la contropartita in un conto transitorio
// ---------------------------------------------------------------------------------------
index++;
segno = "A";
if (saldoContropartita < 0)
{
segno = "D";
saldoContropartita = saldoContropartita * -1;
}
index++;
new MovimentoContabile(testata, causale, index, contoTransitorio, saldoContropartita, segno)
{
SottoContoRiferimento = sottoconto.Key,
Stato = StatoMovimentoContabileEnum.Evaso,
Descrizione = sottoconto.Key != null ? string.Format("Chiusura di bilancio '{0} {1}' - {2} Esercizio '{3}'", conto.Codice, conto.Descrizione, sottoconto.Key.Descrizione, esercizio.DisplayName) : string.Format("Chiusura di bilancio {0} - Esercizio '{1}'", conto.Descrizione, esercizio.DisplayName),
};
}
}
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la chiusura dei conti patrimoniali - (SINGOLO CONTO) - {0} - conto:{1} {2} - esercizio:{3}", ex, Utility.GetMethodDescription(), conto.ID, conto.Descrizione, esercizio.ID);
throw;
}
}
}
// Solo se sono presenti movimenti
if (testata.Movimenti.Count > 0)
{
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
return testata;
}
return null;
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la chiusura dei conti patrimoniali - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
throw;
}
}
public string ChiusuraContiEconomici(Esercizio esercizio, IEnumerable<ReportRipartizioneBilancioDTO> ripartizione)
{
try
{
var message = string.Empty;
var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("C1");
var contoCondomini = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini());
// =======================================================================================
// Tutti i conti economici sono chiusi nel conto Crediti v/condomini
// =======================================================================================
var testataEconomico = new TestataMovimentoContabile(esercizio, esercizio.DataChiusura, TipoTestataMovimentoContabileEnum.Automatica, null) { AperturaChiusuraConti = true };
var conti = esercizio.CondominioRiferimento.Conti.Where(item => item.Tipo == TipoContoEconomicoEnum.Economico && item.PresenteBilancio).ToList();
var contiChiusuraStraordinario = getContiEconomiciChiusuraStraordinario(esercizio.CondominioRiferimento.ID);
foreach (var conto in conti)
{
try
{
var importoConto = Math.Round(GetSaldoConto(esercizio.ID, conto.ID, contiChiusuraStraordinario), 2);
var importoRipartizione = 0m;
var reportRipartizioneBilancioDtos = ripartizione as IList<ReportRipartizioneBilancioDTO> ?? ripartizione.ToList();
var conto1 = conto;
var spesePerCondomino = reportRipartizioneBilancioDtos.Where(item => item.IdConto == conto1.ID && item.IdPartecipante > 0).GroupBy(item => item.IdPartecipante);
var indexEconomico = 0;
foreach (var reportRipartizioneBilancioDTO in spesePerCondomino)
{
try
{
var soggetto = _daoFactory.GetSoggettoCondominioDao().GetById(reportRipartizioneBilancioDTO.Key, false);
var importo = Math.Round(reportRipartizioneBilancioDTO.Sum(item => item.Importo.GetValueOrDefault()), 2);
importoRipartizione += importo;
if (importo != 0)
{
var segno = "A";
if (importo < 0)
{
segno = "D";
importo = importo * -1;
}
// ---------------------------------------------------------------------
// Chiusura conto economico
// ---------------------------------------------------------------------
indexEconomico++;
var descrizione = string.Format("Chiusura conto '{0} {1}' - {2} Esercizio '{3}'", conto.Codice, conto.Descrizione, soggetto.DisplayName, esercizio.DisplayName);
new MovimentoContabile(testataEconomico, causale, 1, conto, importo, segno)
{
Descrizione = descrizione,
CondominoRiferimento = soggetto,
Stato = StatoMovimentoContabileEnum.Evaso
};
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la chiusura dei conti economici (SINGOLO SOGGETTO) - {0} - conto:{1} - soggetto:{1}", ex, Utility.GetMethodDescription(), conto.ID, reportRipartizioneBilancioDTO.Key);
throw;
}
}
// ---------------------------------------------------------------------
// Contropartita crediti v/condomini
// ---------------------------------------------------------------------
var segnoConto = "D";
var importoRipartoConto = importoRipartizione;
if (importoRipartoConto < 0)
{
segnoConto = "A";
importoRipartoConto = importoRipartoConto * -1;
}
indexEconomico++;
new MovimentoContabile(testataEconomico, causale, indexEconomico, contoCondomini, importoRipartoConto, segnoConto)
{
Descrizione = string.Format("Chiusura conto '{0} {1}' - Esercizio '{2}'", conto.Codice, conto.Descrizione, esercizio.DisplayName),
Stato = StatoMovimentoContabileEnum.Evaso,
};
// ---------------------------------------------------------------------
// L'importo del conto non corrisponde con l'importo della ripartizione (dovuto all'arrotondamento tipico del riparto spese)
// ---------------------------------------------------------------------
if (importoConto != importoRipartizione)
{
var importoArrotondamento = importoConto - importoRipartizione;
var segno = "A";
if (importoArrotondamento < 0)
{
segno = "D";
importoArrotondamento = importoArrotondamento * -1;
}
// Conto economico
// ---------------------------------------------------------------------
indexEconomico++;
var descrizione = string.Format("Arrotondamento per riparto conto '{0} {1}' - Esercizio '{2}'", conto.Codice, conto.Descrizione, esercizio.DisplayName);
new MovimentoContabile(testataEconomico, causale, 1, conto, importoArrotondamento, segno)
{
Descrizione = descrizione,
Stato = StatoMovimentoContabileEnum.Evaso
};
// Contropartita conto Arrotondamenti
// ---------------------------------------------------------------------
indexEconomico++;
var contoArrotondamenti = _pianoContiService.GetContoArrotondamenti(esercizio);
_daoFactory.GetContoDao().SaveOrUpdate(contoArrotondamenti);
new MovimentoContabile(testataEconomico, causale, indexEconomico, contoArrotondamenti, importoArrotondamento, invertiSegno(segno))
{
Descrizione = descrizione,
Stato = StatoMovimentoContabileEnum.Evaso,
};
}
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la chiusura dei conti economici (SINGOLO CONTO) - {0} - conto:{1}", ex, Utility.GetMethodDescription(), conto.ID);
throw;
}
}
if (testataEconomico.Movimenti.Count > 0)
_daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testataEconomico);
return message;
}
catch (Exception ex)
{
_log.FatalFormat("Errore inaspettato durante la chiusura dei conti economici - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
throw;
}
}
