public TestataMovimentoContabile SetMovimentiAddebitoCompetenze(Esercizio esercizio, AddebitoCompetenza addebito, DateTime dataRegistrazione, Conto conto, SottoConto sottoConto, string descrizione)
        {
            try
            {
                // controllo data registrazione
                var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
                if (message.Count > 0)
                {
                    var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
                    _log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - addebito:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, addebito.ID, esercizio.ID);
                    throw ex;
                }

                // se la testata è automatica non è possibile aggiornare gli importi nel dettaglio, se manuale è possibile l'aggiornamento.
                // per ora la testata viene inserita come manuale.
                //TestataMovimentoContabile testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, Sfera.Enums.TipoTestataMovimentoContabileEnum.Automatica);
                var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Manuale, null) {Descrizione = descrizione, IsAllowUpdate = true};

                var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
                var numeroRiga = 0;

                // Contropartita
                numeroRiga++;
                var contoContropartita = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, "913");
                new MovimentoContabile(testata, causale, numeroRiga, contoContropartita, addebito.Dettaglio.Sum(item => item.Importo), "A") {Descrizione = descrizione};

                foreach (var item in addebito.Dettaglio)
                {
                    try
                    {
                        numeroRiga++;
                        var movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, item.Importo, "D")
                        {
                            SottoContoRiferimento = sottoConto,
                            Descrizione = descrizione,
                            CondominoRiferimento = item.Soggetto
                        };
                        item.MovimentoContabile = movimento;
                    
                        switch (item.Soggetto.Tipo)
                        {
                            case TipoSoggetto.Proprietario:
                                movimento.PercentualeProprieta = 1;
                                break;
                            case TipoSoggetto.Conduttore:
                                movimento.PercentualeProprieta = 0;
                                break;
                        }

                        movimento.IsRipartoPersonalizzato = true;
                        new SpeseUnita(item.Importo, null, item.Soggetto, movimento);

                    }
                    catch (Exception ex)
                    {
                        _log.ErrorFormat("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - SINGOLO DETTAGLIO - {0} - item:{1}", ex, Utility.GetMethodDescription(), item.ID);
                        throw;
                    }
                }

                addebito.TestataMovimento = testata;
                _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

                return testata;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - {0} - esercizio:{1} - dataRegistrazione:{2} - addebito:{3} - conto:{4} - sottoconto:{5} - descrizione:{6}", ex, Utility.GetMethodDescription(), esercizio != null ? esercizio.ID.ToString() : "<NULL>", dataRegistrazione, addebito != null ? addebito.ID.ToString() : "<NULL>", conto != null ? conto.ID.ToString() : "<NULL>", sottoConto != null ? sottoConto.ID.ToString() : "<NULL>", descrizione);
                throw;
            }
        }
Beispiel #2
0
        public SpesaInfoDTO AddebitoCompetenze(int idEsercizio, DateTime data, string descrizione, int idConto, int? idSottoConto, IList<ImportiDTO> importi)
        {
            try
            {
                var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false);
                if (esercizio.Stato == Sfera.Enums.StatoEsercizioEnum.Aperto)
                {
                    var addebito = new AddebitoCompetenza(esercizio, data, descrizione);

                    foreach (var item in importi)
                    {
                        var persona = _daoFactory.GetPersonaDao().Find(item.Id, false);
                        if (persona != null)
                        {
                            var soggetto = _soggettoService.GetSoggettoPrincipale(persona, esercizio);
                            if(soggetto != null)
                                new DettaglioAddebitoCompetenza(addebito, _soggettoService.GetSoggettoPrincipale(persona, esercizio), item.Importo);
                            else
                                _log.ErrorFormat("Soggetto non trovato non trovato - {0} - persona:{1} - esercizio:{2}", Library.Utility.GetMethodDescription(), item.Id, esercizio.ID);
                        }
                        else
                            _log.ErrorFormat("Persona non trovato - {0} - persona:{1}", Library.Utility.GetMethodDescription(), item.Id);
                    }

                    SottoConto sottoConto = null;
                    if (idSottoConto != null)
                        sottoConto = _daoFactory.GetSottoContoDao().Find(idSottoConto.Value, false);
                    var testata = _movimentiContabiliService.SetMovimentiAddebitoCompetenze(esercizio, addebito, addebito.Data, _daoFactory.GetContoDao().GetById(idConto, false), sottoConto, descrizione);

                    if (testata.DataRegistrazione != null)
                    {
                        var protocollo = _protocolloService.GetProgressivo(Sfera.Enums.TipoProtocollo.Fattura, esercizio.DataApertura.GetValueOrDefault().Year, testata.EsercizioRiferimento.CondominioRiferimento);
                        if (protocollo.Progressivo != null)
                        {
                            testata.NumeroProtocollo = protocollo.Progressivo;
                            testata.AnnoArchiviazioneOttica = esercizio.DataApertura.GetValueOrDefault().Year;

                            _daoFactory.GetAddebitoCompetenzaDao().SaveOrUpdate(addebito);

                            var impostazioni = _daoFactory.GetImpostazioniAziendaDao().GetByAzienda(esercizio.CondominioRiferimento.Azienda.ID);
                            return new SpesaInfoDTO { Id = testata.ID, IdentificativoArchiviazione = _archiviazioneOtticaService.GetIdentificativoArchiviazione(testata), NumeroProtocollo = testata.NumeroProtocollo.GetValueOrDefault(), StampaEtichettaArchiviazione = impostazioni.UtilizzoEtichettatriceArchiviazioneOtticaMovimenti && esercizio.CondominioRiferimento.IsAbilitataArchiviazioneOtticaPassivi.GetValueOrDefault(), EtichettatriceArchiviazione = impostazioni.EtichettatriceArchiviazioneOttica, TipoEtichettaArchiviazione = impostazioni.TipoEtichettaArchiviazioneOttica };
                        }
                        return new SpesaInfoDTO { Id = 0, IdentificativoArchiviazione = null, NumeroProtocollo = 0, StampaEtichettaArchiviazione = false, EtichettatriceArchiviazione = string.Empty, TipoEtichettaArchiviazione = string.Empty, Message = protocollo.Message };
                    }
                }
                return new SpesaInfoDTO { Id = 0, IdentificativoArchiviazione = null, NumeroProtocollo = 0, StampaEtichettaArchiviazione = false, EtichettatriceArchiviazione = string.Empty, TipoEtichettaArchiviazione = string.Empty, Message = "L'esercizio è chiuso non è ammesso l'addebito di competenze." };
            }
            catch (Exception ex)
            {
                
                _log.Fatal("Errore inaspettato nell'addebito delle competenze - " + Library.Utility.GetMethodDescription() + " - (Creazione movimenti contabili) - idEsercizio:" + idEsercizio.ToString() + " - descrizione:" + descrizione, ex);
                throw;
            }
        }