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; } }