コード例 #1
0
ファイル: VersamentoSoggetto.cs プロジェクト: gipasoft/Sfera
        /// <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);
        }
コード例 #2
0
 /// <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;
 }
コード例 #3
0
        /// <summary>
        /// Crea uno Stabile valido
        /// </summary>
        public ConvocazioneAssemblea(Assemblea assemblea, SoggettoCondominio convocato)
        {
            Assemblea = assemblea;
            Convocato = convocato;

            if (Assemblea != null)
                Assemblea.Convocati.Add(this);
        }
コード例 #4
0
ファイル: SaldoSoggetto.cs プロジェクト: gipasoft/Sfera
        /// <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);
        }
コード例 #5
0
ファイル: VersamentoSoggetto.cs プロジェクト: gipasoft/Sfera
        /// <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);
        }
コード例 #6
0
        /// <summary>
        /// Crea un Subentro valido
        /// </summary>
        public SubentroUnitaImmobiliare(Subentro subentro, UnitaImmobiliare unita, SoggettoCondominio soggettoEntrante, SoggettoCondominio soggettoUscente)
        {
            Subentro = subentro;
            Unita = unita;
            SoggettoEntrante = soggettoEntrante;
            SoggettoUscente = soggettoUscente;

            if (Subentro != null)
                Subentro.UnitaImmobiliari.Add(this);
        }
コード例 #7
0
ファイル: SpeseUnita.cs プロジェクト: gipasoft/Sfera
        /// <summary>
        /// Crea una Spesa Unità valida
        /// </summary>
        public SpeseUnita(decimal? importo, UnitaImmobiliare unita, SoggettoCondominio soggettoCondominio, RipartizioneSpesa ripartizioneSpesa)
        {
            _importo = importo;
            _unitaRiferimento = unita;
            _soggettoCondominio = soggettoCondominio;

            if (ripartizioneSpesa != null)
            {
                _ripartizioneSpesa = ripartizioneSpesa;
                _ripartizioneSpesa.DettaglioRipartizione.Add(this);
            }
        }
コード例 #8
0
ファイル: SpeseUnita.cs プロジェクト: gipasoft/Sfera
        /// <summary>
        /// Crea una Spesa Unità valida
        /// </summary>
        public SpeseUnita(decimal? importo, UnitaImmobiliare unita, SoggettoCondominio soggettoCondominio, MovimentoContabile movimento)
        {
            _importo = importo;
            _unitaRiferimento = unita;
            _soggettoCondominio = soggettoCondominio;

            if (movimento != null)
            {
                _movimentoRiferimento = movimento;
                _movimentoRiferimento.DettaglioRipartizione.Add(this);
            }
        }
コード例 #9
0
 public ProprietarioDTO GetByDomainEntity(SoggettoCondominio proprietario)
 {
     try
     {
         return setDto(proprietario);
     }
     catch (Exception ex)
     {
         _log.ErrorFormat("Errore nel caricamento dei proprietari - {0} - id:{1}", ex, Utility.GetMethodDescription(), proprietario != null ? proprietario.ID.ToString(CultureInfo.InvariantCulture) : "<NULL>");
         throw;
     }
 }
コード例 #10
0
ファイル: DettaglioSubentro.cs プロジェクト: gipasoft/Sfera
        public DettaglioSubentro(Subentro subentro, Conto conto, SoggettoCondominio soggetto, decimal? importo, int giorni, TipoDettaglioSubentro tipo)
        {
            Subentro = subentro;
            Conto = conto;
            Soggetto = soggetto;
            Importo = importo;
            Giorni = giorni;
            Tipo = tipo;

            if (Subentro != null)
                Subentro.Dettagli.Add(this);
        }
コード例 #11
0
ファイル: RataSoggetto.cs プロジェクト: gipasoft/Sfera
        /// <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);
        }
コード例 #12
0
ファイル: Sollecito.cs プロジェクト: gipasoft/Sfera
        /// <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);
        }
コード例 #13
0
        public ConvocazioneAssembleaDTO GetBySoggettoCondominio(SoggettoCondominio soggetto)
        {
            try
            {
                return setDtoSoggetto(soggetto);
            }
            catch (Exception ex)
            {

                if (soggetto != null)
                    _log.Error("Errore nel caricamento dei convocati dell'assemblea per soggetto: Gipasoft.Business.Sfera.Repository.AssembleaConvocazioneRepository.GetBySoggettoCondominio() - id:" + soggetto.ID.ToString(), ex);
                else
                    _log.Error("Errore nel caricamento dei convocati dell'assemblea per soggetto: Gipasoft.Business.Sfera.Repository.AssembleaConvocazioneRepository.GetBySoggettoCondominio() - Soggetto --> null", ex);
                throw;
            }
        }
コード例 #14
0
ファイル: RataSoggetto.cs プロジェクト: gipasoft/Sfera
        /// <summary>
        /// Crea una rata di pagamento condomino valida.
        /// </summary>
        public RataSoggetto(PianoRatealeDettaglio pianoRatealeDettaglio, SoggettoCondominio soggetto, DateTime dataScadenza, decimal importo, LogTransazione logTransazione)
        {
            PianoRatealeDettaglio = pianoRatealeDettaglio;
            Esercizio = PianoRatealeDettaglio.PianoRatealeRiferimento.Esercizio;
            Soggetto = soggetto;
            DataScadenza = dataScadenza;
            Importo = importo;
            _stato = StatoRataEnum.Inserita;

            if (Soggetto != null)
                Soggetto.Rate.Add(this);

            if (PianoRatealeDettaglio != null)
                PianoRatealeDettaglio.RateSoggetti.Add(this);

            LogTransazione = logTransazione;
            if (LogTransazione != null)
                LogTransazione.Rate.Add(this);

        }
コード例 #15
0
ファイル: SoggettoService.cs プロジェクト: gipasoft/Sfera
        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;
            }
        }
コード例 #16
0
        private ConduttoreDTO setDto(SoggettoCondominio item)
        {
            try
            {
                var dto = new ConduttoreDTO
                {
                    Consigliere = item.Consigliere,
                    DataFine = item.DataFine,
                    DataInizio = item.DataInizio,
                    ID = item.ID,
                    PercentualeRiferimento = item.PercentualeRiferimento,
                    IdPersona = item.Persona.ID,
                    IsResidente = item.IsResidente,
                    DirittoPersonaleGodimento = item.DirittoPersonaleGodimento,
                    DisplayNominativo = item.DisplayName,
                    Descrizione = item.Descrizione,
                    DescrizioneAggiuntiva = item.DescrizioneAggiuntiva
                };

                if (item.UnitaImmobiliare.GruppoStabileRiferimento != null)
                    dto.IdCondominio = item.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.CondominioRiferimento.ID;
                dto.Tipo = TipoSoggetto.Conduttore;

                if (item.ModalitaConvocazione != null)
                    dto.ModalitaConvocazione = item.ModalitaConvocazione.ToString();

                if (item.DirittoReale != null)
                    dto.DirittoReale = item.DirittoReale.ToString();

                if (item.UnitaImmobiliare.Ordine != null)
                    dto.OrdineUnitaImmobiliare = item.UnitaImmobiliare.Ordine.Value;

                if (item.FrazionePossesso != null)
                {
                    dto.NumeratorePossesso = item.FrazionePossesso.Numerator;
                    dto.DenominatorePossesso = item.FrazionePossesso.Denominator;
                    dto.Possesso = item.FrazionePossesso.ToString();
                }

                // Unita immobiliare
                dto.IdUnitaImmobiliare = item.UnitaImmobiliare.ID;
                dto.DescrizioneUnitaImmobiliare = item.UnitaImmobiliare.Descrizione;

                dto.Principale = item.Principale;
                dto.VersamentoMav = item.VersamentoMav;

                // Soggetto Principale
                if (item.SoggettoPrincipale != null)
                {
                    dto.IdSoggettoPrincipale = item.SoggettoPrincipale.ID;
                    dto.DescrizioneSoggettoPrincipale = item.GetDescrizioneAccorpamento();
                }

                if (item.SubentriEntrata.Count > 0)
                    dto.IdSubentroEntrata = Library.IesiGenericCollections<SubentroUnitaImmobiliare>.GetByIndex(item.SubentriEntrata, 0).Subentro.ID;

                return dto;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nell'inserimento del conduttore - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), item.ID);
                throw;
            }
        }
コード例 #17
0
 private void addListaSoggettiAccorpati(Dictionary<SoggettoCondominio, IList<SoggettoCondominio>> listaSoggettiAccorpati, ReportRipartizioneBilancioDTO reportRipartizioneBilancioDTO, SoggettoCondominio soggetto, IList<SoggettoCondominio> soggettiAttivi)
 {
     var soggettoKey = listaSoggettiAccorpati.Keys.FirstOrDefault(item => item.ID == reportRipartizioneBilancioDTO.IdPartecipante);
     if (soggettoKey != null)
     {
         var soggettoValue = listaSoggettiAccorpati[soggettoKey].FirstOrDefault(item => item.ID == soggetto.ID);
         if (soggettoValue == null)
             listaSoggettiAccorpati[soggettoKey].Add(soggetto);
     }
     else
     {
         soggettoKey = soggettiAttivi.FirstOrDefault(item => item.ID == reportRipartizioneBilancioDTO.IdPartecipante) ??
                       _daoFactory.GetSoggettoCondominioDao().Find(reportRipartizioneBilancioDTO.IdPartecipante, false);
         listaSoggettiAccorpati.Add(soggettoKey, new List<SoggettoCondominio> { soggetto });
     }
 }
コード例 #18
0
ファイル: SollecitiService.cs プロジェクト: gipasoft/Sfera
        private string getNominativoPresso(Persona persona, SoggettoCondominio soggetto, Address indirizzo)
        {
            try
            {
                var nominativo = persona.DisplayName;
                try
                {
                    if (!string.IsNullOrEmpty(soggetto?.Descrizione))
                        nominativo = soggetto.Descrizione;
                }
                catch (Exception ex)
                {
                    _log.ErrorFormat("Errore nell'individuazione del nominativo completo di presso - DESCRIZIONE - {0} - persona:{1} - soggetto:{2}", ex, Utility.GetMethodDescription(), persona.ID.ToString(), soggetto?.ID.ToString() ?? "<NULL>");
                }

                if (!string.IsNullOrEmpty(indirizzo?.Presso))
                    nominativo += $"{Environment.NewLine}c/o {indirizzo.Presso}";

                return nominativo;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore nell'individuazione del nominativo completo di presso - {0} - persona:{1} - soggetto:{2}", ex, Utility.GetMethodDescription(), persona?.ID.ToString() ?? "<NULL>", soggetto?.ID.ToString() ?? "<NULL>");                
                return string.Empty;
            }
        }
コード例 #19
0
        public TestataMovimentoContabile SetMovimentoSpesaPersonale(Esercizio esercizio, TestataMovimentoContabile testata, SoggettoCondominio soggetto, Conto conto, string descrizione, decimal importo, DateTime dataRegistrazione)
        {
            var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
            if (testata == null)
            {
                testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null) {Descrizione = "Calcolo interessi di mora", IsAllowUpdate = true};
            }

            // controllo data registrazione
            var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, testata.DataRegistrazione.GetValueOrDefault());
            if (message.Count > 0)
            {
                var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", testata.DataRegistrazione.GetValueOrDefault()));
                _log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - soggetto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), testata.DataRegistrazione.GetValueOrDefault(), soggetto.ID, esercizio.ID);
                throw ex;
            }

            var movimento = new MovimentoContabile(testata, causale, testata.Movimenti.Count() + 1, conto, importo, "D") {Descrizione = descrizione};
            switch (soggetto.Tipo)
            {
                case TipoSoggetto.Proprietario:
                    movimento.PercentualeProprieta = 1;
                    break;
                case TipoSoggetto.Conduttore:
                    movimento.PercentualeProprieta = 0;
                    break;
            }

            movimento.IsRipartoPersonalizzato = true;
            new SpeseUnita(importo, null, soggetto, movimento);

            _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

            return testata;
        }
コード例 #20
0
        public TestataMovimentoContabile SetMovimentiSingolaRata(RataSoggetto rata, decimal importo, SoggettoCondominio soggetto, Esercizio esercizio, TestataMovimentoContabile testata, DateTime dataRegistrazione)
        {
            return null;
            var numeroRiga = 0;
            var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("ER");

            var message = IsAllowDataRegistrazione(new List<int> {esercizio.CondominioRiferimento.ID}, esercizio, dataRegistrazione);
            if (message.Count > 0)
            {
                _log.ErrorFormat("Tentativo di registrazione con data esterno all'intervallo consentito - {0} - rata:{1} - importo:{2} - soggetto:{3} - esercizio:{4}", Utility.GetMethodDescription(), rata.ID, importo, soggetto.ID, esercizio.ID);
                throw new InvalidDataException(string.Format("Tentativo di registrazione con data esterno all'intervallo consentito - data:{0}", dataRegistrazione.ToShortDateString()));
            }

            // ------------------------------------------------
            // Testata
            // ------------------------------------------------
            if (testata == null)
            {
                testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null);
                _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
            }
            else
                numeroRiga = testata.Movimenti.Max(mov => mov.NumeroRiga.GetValueOrDefault());

            // ------------------------------------------------
            // Rata
            // ------------------------------------------------
            numeroRiga++;
            var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRateCondomini()), importo, "A") {CondominoRiferimento = soggetto};
            string descrizioneRata;
            if (rata != null)
                descrizioneRata = "Rata n." + rata.PianoRatealeDettaglio.Progressivo;
            else
                descrizioneRata = "Rata";
            movimentoPatrimoniale.Descrizione = descrizioneRata + " - " + movimentoPatrimoniale.CondominoRiferimento.DisplayName;
            _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);

            // ------------------------------------------------
            // Crediti V/S Condomini
            // ------------------------------------------------
            numeroRiga++;
            var movimentoPatrimonialeCrediti = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini()), importo, "D")
            {
                CondominoRiferimento = soggetto,
                Descrizione = movimentoPatrimoniale.Descrizione
            };
            _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimonialeCrediti);

            return testata;
        }
コード例 #21
0
 /// <summary>
 /// Crea una ripartizione tra i diversi soggetti valida
 /// </summary>
 public SoggettoCondominioRipartizione(Conto conto, SoggettoCondominio soggetto, decimal percentualeRipartizione)
 {
     Conto = conto;
     Soggetto = soggetto;
     PercentualeRipartizione = percentualeRipartizione;
 }
コード例 #22
0
ファイル: SubentroService.cs プロジェクト: gipasoft/Sfera
 private bool isAllowDeleteSoggettoSubentro(SoggettoCondominio soggetto, GestioneCondomini.Domain.Subentro subentro)
 {
     // Se il tipo di subentro non corrisponde col tipo soggetto vuol dire che siamo nel caso di un subentro con unità rimasta sfitta
     // in questo caso il soggetto entrante (Proprietario) nelle spese di conduzione non dovrà ovviamente essere eliminato
     return subentro.TipoSubentro == soggetto.Tipo &&
            soggetto.SubentriEntrata.All(item => item.Subentro.ID == subentro.ID) &&
            soggetto.SubentriUscita.All(item => item.Subentro.ID == subentro.ID) &&
            soggetto.Versamenti.Count == 0;
 }
コード例 #23
0
ファイル: SubentroService.cs プロジェクト: gipasoft/Sfera
        /// <summary>
        /// Conferma del subentro.
        /// Se la persona entrante è null si tratta di un subentro di conduzione in cui l'appartamento rimane sfitto
        /// </summary>
        /// <param name="idCondominio">Condominio in cui è avvenuto il subentro</param>
        /// <param name="idUscente">Soggetto Uscente</param>
        /// <param name="entrante">Soggetto Entrante</param>
        /// <param name="idUnitaImmobiliarePrincipale">Unità immobiliare principale</param>
        /// <param name="idUnitaImmobiliari">Unità immobiliari per le quali è avvenuto il subentro</param>
        /// <param name="data">Data del subentro</param>
        /// <param name="spese">Spese di competenza tra uscente e entrante</param>
        /// <param name="rate">Rate eventualmente modficare</param>
        /// <param name="testoLettera"></param>
        /// <param name="speseUscente"></param>
        /// <param name="speseEntrante"></param>
        /// <param name="tipoSubentro">Tipo di subentro</param>
        /// <param name="tipoRendiconto">Rendiconto sul quale di basano i calcoli del subentro</param>
        /// <param name="oggettoLettera">Oggetto della lettera di subentro</param>
        /// <param name="spostamentoSaldi">Identifica se deve essere eseguito il trasferimento automatico dei saldi e delle rate</param>
        /// <param name="logTransazione">Log della transazione per permettere il salvataggio tramite cascade</param>
        /// <returns>Esito del subentro</returns>
        public EsitoSubentroDomain Conferma(int idCondominio, int idUscente, PersonaDTO entrante, int idUnitaImmobiliarePrincipale, IList<int> idUnitaImmobiliari, DateTime data, IList<CalcoloSubentroDTO> spese, IList<RataSoggettoSubentroDTO> rate, string oggettoLettera, string testoLettera, decimal speseUscente, decimal speseEntrante, TipoSoggetto tipoSubentro, TipoRendiconto tipoRendiconto, bool spostamentoSaldi, LogTransazione logTransazione)
        {
            try
            {
                var fatalMessage = string.Empty;
                var warnMessage = string.Empty;

                var condominio = _daoFactory.GetCondominioDao().GetById(idCondominio, false);
                var esercizio = _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(condominio, data);

                if(esercizio == null)
                    return new EsitoSubentroDomain(new EsitoSubentro(null, null, "La data del subentro non è corretta, verificare che sia aperto l'esercizio di competenza", null,null), null);

                // ==========================================================================
                //  Persone
                // ==========================================================================
                Persona personaEntrante = null;
                if (entrante != null)
                {
                    // se l'ID è correttamente valorizzato è stata scelta una persona già presente in anagrafica
                    personaEntrante = entrante.ID > 0 ? _daoFactory.GetPersonaDao().GetById(entrante.ID, false) : _personaService.SetNew(entrante);
                }
              
                // ==========================================================================
                //  Subentro
                // ==========================================================================
                var subentro = new GestioneCondomini.Domain.Subentro(
                    condominio,
                    data,
                    tipoSubentro,
                    oggettoLettera,
                    testoLettera,
                    speseUscente,
                    speseEntrante,
                    spostamentoSaldi,
                    logTransazione
                    )
                    {
                        SaldoUscente = _saldiCondominiService.GetSaldoByPersonaUnitaImmobiliari(esercizio.ID, new List<int> { idUscente }, idUnitaImmobiliari, true)
                    };

                // ==========================================================================
                //  Registro i nuovi condomini
                // ==========================================================================
                SoggettoCondominio soggettoEntrantePrincipale = null;
                SoggettoCondominio soggettoUscentePrincipale = null;
                SoggettoCondominio proprietarioPrincipale = null;
                foreach (var idUnitaImmobiliare in idUnitaImmobiliari)
                {
                    // -----------------------------
                    // Soggetto Entrante
                    // -----------------------------
                    var unita = _daoFactory.GetUnitaImmobiliareDao().GetById(idUnitaImmobiliare, false);
                    var proprietario = unita.GetProprietarioPrincipale(esercizio.DataChiusura);
                    SoggettoCondominio soggettoEntrante = null;

                    ISet<SoggettoCondominio> soggetti = null;
                    switch (tipoSubentro)
                    {
                        case TipoSoggetto.Conduttore:
                            if (personaEntrante != null)
                                soggettoEntrante = new Conduttore(unita, personaEntrante);
                            soggetti = unita.Conduttori;
                            break;

                        case TipoSoggetto.Proprietario:
                            if (personaEntrante != null)
                                soggettoEntrante = new Proprietario(unita, personaEntrante);
                            soggetti = unita.Proprietari;
                            break;

                        case TipoSoggetto.Soggetto:
                            if (personaEntrante != null)
                                soggettoEntrante = new SoggettoCondominio(unita, personaEntrante);
                            soggetti = unita.Soggetti;
                            break;
                    }

                    if (soggettoEntrante != null)
                        soggettoEntrante.IsResidente = _soggettoService.IsResidente(soggettoEntrante);

                    // -----------------------------
                    // Soggetto Uscente
                    // -----------------------------
                    //  Nel caso di subentro di conduzione se il conduttore non è presente il soggetto
                    //  uscente è il proprietario.
                    // -----------------------------
                    SoggettoCondominio soggettoUscente = null;
                    var soggettiUscenti = soggetti.Where(item => item.Persona.ID == idUscente).ToList();
                    if (soggettiUscenti.Count > 0)
                    {
                        if (soggettiUscenti.Count > 1)
                        {
                            _log.WarnFormat("Trovati più di un soggetto con la stessa persona anagrafica - PROPRIETARIO - {0} - unità immobiliare:{1} - condominio:{2} - uscente:{3} - entrante:{4}", Utility.GetMethodDescription(), unita?.ID.ToString(CultureInfo.InvariantCulture) ?? "<NULL>", idCondominio, idUscente, entrante != null ? entrante.DisplayName : "<NULL>");
                        }
                        soggettoUscente = soggettiUscenti.FirstOrDefault();
                    }

                    if (soggettoUscente != null)
                        soggettoUscente.DataFine = data;

                    else if (tipoSubentro == TipoSoggetto.Conduttore)
                    {
                        soggettiUscenti = unita.Proprietari.Where(item => item.Persona.ID == idUscente).ToList();
                        if (soggettiUscenti.Count > 0)
                        {
                            if (soggettiUscenti.Count > 1)
                            {
                                _log.WarnFormat("Trovati più di un soggetto con la stessa persona anagrafica - CONDUTTORE - {0} - unità immobiliare:{1} - condominio:{2} - uscente:{3} - entrante:{4}", Utility.GetMethodDescription(), unita?.ID.ToString(CultureInfo.InvariantCulture) ?? "<NULL>", idCondominio, idUscente, entrante != null ? entrante.DisplayName : "<NULL>");
                            }
                            soggettoUscente = soggettiUscenti.FirstOrDefault();
                        }
                    }

                    // soggettoEntrante = null l'unità immobiliare è rimasta sfitta
                    if (soggettoEntrante != null)
                    {
                        soggettoEntrante.DataInizio = data;
                        if (soggettoUscente != null)
                        {
                            soggettoEntrante.PercentualeRiferimento = soggettoUscente.PercentualeRiferimento;
                            soggettoEntrante.Principale = soggettoUscente.Principale;
                        }
                        else
                        {
                            soggettoEntrante.PercentualeRiferimento = 1m;
                            soggettoEntrante.Principale = true;
                        }
                        _daoFactory.GetSoggettoCondominioDao().SaveOrUpdate(soggettoEntrante);
                    }
                    else
                        soggettoEntrante = proprietario;

                    // -----------------------------
                    //  Unità Immobiliare
                    // -----------------------------
                    var subentroUnita = new SubentroUnitaImmobiliare(subentro, unita, soggettoEntrante, soggettoUscente);
                    if (unita.ID == idUnitaImmobiliarePrincipale)
                    {
                        subentroUnita.Principale = true;
                        soggettoUscentePrincipale = soggettoUscente;
                        soggettoEntrantePrincipale = soggettoEntrante;
                        proprietarioPrincipale = proprietario;
                    }

                    //-------------------------------------
                    // Se presenti accorpamenti li annullo
                    //-------------------------------------
                    if (soggettoUscente  != null && soggettoUscente.SoggettiCollegati.Count > 0)
                    {
                        warnMessage = string.Format("Il soggetto uscente aveva degli accorpamenti di rate configurati.{0}Gli accorpamenti sono stati eliminati.{0}", Environment.NewLine);
                        foreach (var soggettoCondominio in soggettoUscente.SoggettiCollegati)
                            soggettoCondominio.SoggettoPrincipale = null;

                        soggettoUscente.SoggettiCollegati.Clear();
                    }

                    unita.Descrizione = _daoFactory.GetUnitaImmobiliareDao().GetUnitaImmobiliareDescrizione(unita);
                }

                //--------------------------------
                // Dettagli
                //--------------------------------
                foreach(var calcoloSubentro in spese)
                {
                    // Uscente
                    // -------------
                    var dettaglioSubentroUscente = new DettaglioSubentro(subentro, _daoFactory.GetContoDao().GetById(calcoloSubentro.IdConto, false), soggettoUscentePrincipale, calcoloSubentro.ImportoSoggettoUscente, calcoloSubentro.GiorniUscente.Value, TipoDettaglioSubentro.Uscente);

                    // Entrante
                    // -------------
                    var dettaglioSubentroEntrante = new DettaglioSubentro(subentro, _daoFactory.GetContoDao().GetById(calcoloSubentro.IdConto, false), soggettoEntrantePrincipale, calcoloSubentro.ImportoSoggettoEntrante, calcoloSubentro.GiorniEntrante.Value, TipoDettaglioSubentro.Entrante);
                }

                // ==========================================================================
                //  Rate
                // ==========================================================================
                string descrizione;
                if(soggettoUscentePrincipale != null)
                    descrizione = "Subentro: " + soggettoUscentePrincipale.DisplayName + " - " + soggettoEntrantePrincipale.DisplayName;
                else
                    descrizione = "Subentro: " + proprietarioPrincipale.DisplayName + " - " + soggettoEntrantePrincipale.DisplayName;

                var listaRateDaEmettere = new Dictionary<DateTime, Dictionary<int, RataSoggettoDTO>>();
                foreach (var rataSubentro in rate)
                { 
                    var rata = _daoFactory.GetRataSoggettoDao().GetById(rataSubentro.ID, false);

                    // ----------------------------------------------------------
                    // Cancellazione o richiamo rata originale
                    // ----------------------------------------------------------
                    if (rataSubentro.Eliminare || rataSubentro.AssegnareAEntrante)
                        fatalMessage += _rateService.EliminazioneRataSoggetto(rata, descrizione);
                    
                    // ----------------------------------------------------------
                    // Modifica importo rata
                    // ----------------------------------------------------------
                    else if (rataSubentro.Importo != rata.Importo)
                    {
                        var rataAggiornamento = new RataSoggettoAggiornamentoDTO
                        {
                            DataScadenza = rata.DataScadenza,
                            Id = rata.ID,
                            IdEsercizio = rata.Esercizio.ID,
                            IdSoggettoCondominio = rata.Soggetto.ID,
                            Importo = rataSubentro.Importo
                        };
                        IList<RataSoggettoAggiornamentoDTO> rateAggiornamento = new List<RataSoggettoAggiornamentoDTO>(1);
                        rateAggiornamento.Add(rataAggiornamento);
                        _rateService.AggiornaImporti(rateAggiornamento, false, TipoAccorpamentoRateEnum.Nessuno, logTransazione);
                    }

                    // ----------------------------------------------------------
                    // Creazione nuova rata da emettere
                    // ----------------------------------------------------------
                    if (rataSubentro.AssegnareAEntrante)
                    {
                        Dictionary<int, RataSoggettoDTO> listaRate;
                        if (listaRateDaEmettere.ContainsKey(rata.DataScadenza))
                            listaRate = listaRateDaEmettere[rata.DataScadenza];
                        else
                        {
                            listaRate = new Dictionary<int, RataSoggettoDTO>();
                            listaRateDaEmettere.Add(rata.DataScadenza, listaRate);
                        }

                        if (rataSubentro.AssegnareAEntrante)
                            addRataDaEmettere(soggettoEntrantePrincipale, esercizio, rata, listaRate, rataSubentro.Importo);
                    }
                }
                fatalMessage += _rateService.CreazioneRateFuoriPreventivo(esercizio, listaRateDaEmettere, true, descrizione, logTransazione);

                // ==========================================================================
                //  Spostamento saldi
                //   - Solo se il tipo di subentro corrisponde con con il tipo di soggetto uscente
                // ==========================================================================
                if (spostamentoSaldi && soggettoUscentePrincipale.Tipo == tipoSubentro)
                {
                    var messageSpostamento = SpostamentoSaldi(subentro);
                    if (!string.IsNullOrEmpty(messageSpostamento.FatalMessage))
                        fatalMessage += messageSpostamento.FatalMessage;
                    if (!string.IsNullOrEmpty(messageSpostamento.WarnMessage))
                        warnMessage += messageSpostamento.WarnMessage;
                }

                int? idPersonaEntrante = null;
                if (personaEntrante != null)
                    idPersonaEntrante = personaEntrante.ID;

                // ==========================================================================
                //  Leggo le eventuali ripartizioni personalizzate
                // ==========================================================================
                var soggettiRipartizione = _daoFactory.GetSoggettoCondominioRipartizioneDao().GetBySoggetto(soggettoUscentePrincipale.ID);
                var soggettiRipartizioneDto = new List<SoggettoCondominioRipartizioneDTO>(soggettiRipartizione.Count);
                soggettiRipartizioneDto.AddRange(soggettiRipartizione.Select(item => new SoggettoCondominioRipartizioneDTO
                {
                    ID = item.ID, 
                    DescrizioneConto = item.Conto.Descrizione, 
                    IdConto = item.Conto.ID, 
                    DescrizioneSoggetto = 
                    item.Soggetto.DisplayName, 
                    IdSoggetto = item.Soggetto.ID, 
                    IdUnitaImmobiliare = item.Soggetto.UnitaImmobiliare.ID,
                    PercentualeRipartizione = item.PercentualeRipartizione,
                    DirittoReale = (item.Soggetto.DirittoReale != null) ? item.Soggetto.DirittoReale.GetValueOrDefault().ToString() : string.Empty, 
                    Tipo = item.Soggetto.Tipo
                }));

                var esitoSubentro = new EsitoSubentro(idPersonaEntrante, subentro.ID, fatalMessage, warnMessage, soggettiRipartizioneDto);
                return new EsitoSubentroDomain(esitoSubentro, subentro);
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore durante la conferma del subentro - {0} - idCondominio:{1} - idUscente:{2} - entrante:{3}", ex, Utility.GetMethodDescription(), idCondominio, idUscente, entrante != null ? entrante.DisplayName : "<NULL>");
                throw;
            }
        }
コード例 #24
0
ファイル: SubentroService.cs プロジェクト: gipasoft/Sfera
 private void addRataDaEmettere(SoggettoCondominio soggetto, Esercizio esercizio, RataSoggetto rata, Dictionary<int, RataSoggettoDTO> listaRate, decimal importo)
 {
     RataSoggettoDTO rataDto;
     if (listaRate.ContainsKey(soggetto.ID))
         rataDto = listaRate[soggetto.ID];
     else
     {
         rataDto = new RataSoggettoDTO
         {
             IdSoggettoCondominio = soggetto.ID,
             DataScadenza = rata.DataScadenza,
             IdEsercizio = esercizio.ID,
             DescrizioneEsercizio = esercizio.DisplayName,
             IdUnitaImmobiliare = soggetto.UnitaImmobiliare.ID,
             IdPersona = soggetto.Persona.ID,
             Subalterno = soggetto.UnitaImmobiliare.Subalterno,
             Importo = 0
         };
         listaRate.Add(soggetto.ID, rataDto);
     }
     rataDto.Importo += importo;
 }
コード例 #25
0
        private decimal getMillesimoBySoggettoConto(SoggettoCondominio soggetto, int idConto, IList<string> millesimiElaborati, IList<MillesimoDTO> millesimiAttivi)
        {
            // Se il soggetto è proprietario, il conto è di conduzione, ed è presente per la stessa unità e lo stesso conto un conduttore nel riparto i millesimi NON
            // devono essere sommati al proprietario perchè già considerati nella riga del conduttore - Utilizzata lista per memorizzare i millesimi già elaborati bugid#9140
            //var millesimo = soggetto.UnitaImmobiliare.Millesimi.FirstOrDefault(item => item.ContoRiferimento.ID == idConto);
            if (millesimiAttivi != null)
            {
                var millesimo = millesimiAttivi.FirstOrDefault(item => item.IdUnitaRiferimento == soggetto.UnitaImmobiliare.ID);
                if (millesimo != null && !millesimiElaborati.Contains($"{millesimo.IdUnitaRiferimento}&{millesimo.IdContoRiferimento}"))
                {
                    millesimiElaborati.Add($"{millesimo.IdUnitaRiferimento}&{millesimo.IdContoRiferimento}");
                    return millesimo.Valore.GetValueOrDefault();
                }
            }
            else
            {
                var millesimo = soggetto.UnitaImmobiliare.Millesimi.FirstOrDefault(item => item.ContoRiferimento.ID == idConto);
                if (millesimo != null && !millesimiElaborati.Contains($"{millesimo.UnitaRiferimento.ID}&{millesimo.ContoRiferimento.ID}"))
                {
                    millesimiElaborati.Add($"{millesimo.UnitaRiferimento.ID}&{millesimo.ContoRiferimento.ID}");
                    return millesimo.Valore.GetValueOrDefault();
                }
            }

            return 0;
        }
コード例 #26
0
 private DateTime getDataUscita(SoggettoCondominio soggetto)
 {
     var data = DateTime.MaxValue;
     if (soggetto.DataFine != null)
         data = soggetto.DataFine.GetValueOrDefault();
     return data;
 }
コード例 #27
0
 public ConduttoreDTO GetByDomainEntity(SoggettoCondominio conduttore)
 {
     try
     {
         return setDto(conduttore);
     }
     catch (Exception ex)
     {
         _log.ErrorFormat("Errore nel caricamento dei conduttori - {0} - id:{1}", ex, Library.Utility.GetMethodDescription(), conduttore != null ? conduttore.ID.ToString(CultureInfo.InvariantCulture) : "<NULL>");
         throw;
     }
 }
コード例 #28
0
ファイル: SoggettoService.cs プロジェクト: gipasoft/Sfera
        /// <summary>
        /// Consente di individuare se il condomino è residente confrontando l'indirizzo della persona con quello del condominio
        /// </summary>
        /// <remarks>Per stabilire se gli indirizzi corrispondono viene usato un componente di terze parti <see cref="http://www.shuffletext.com/Default.aspx"/></remarks>
        /// <param name="soggetto">Condomino</param>
        /// <returns>Ritorna true se è residente altrimenti false</returns>
        public bool IsResidente(SoggettoCondominio soggetto)
        {
            if (soggetto != null && soggetto.IsResidente == null && soggetto.UnitaImmobiliare != null && soggetto.UnitaImmobiliare.GruppoStabileRiferimento != null && soggetto.Persona != null && soggetto.Persona.IndirizzoResidenza != null && !string.IsNullOrEmpty(soggetto.Persona.IndirizzoResidenza.Indirizzo))
            {
                try
                {
                    var condominio = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.CondominioRiferimento;

                    if (condominio.Indirizzo != null)
                    {
                        var person = new SearchableDictionary<int>();
                        var fuzzy = new FuzzySearch<int>();
                        var query = new Query(QuerySearchOption.And, new NameSynonymThesaurusReader(), 0.75);
                        var scope = new IntellisenseScope<int>();

                        var persona = soggetto.Persona;

                        var indirizzoSoggetto = persona.IndirizzoResidenza.GetIndirizzoCompleto();
                        var indirizzoCondominio = condominio.Indirizzo.GetIndirizzoCompleto();

                        if (!string.IsNullOrEmpty(indirizzoSoggetto) && !string.IsNullOrEmpty(indirizzoCondominio))
                        {
                            person.Add(persona.ID, string.Format("{0}", indirizzoSoggetto));
                            fuzzy.Add(persona.ID, "Indirizzo", indirizzoSoggetto);

                            query.Clear();
                            query.CreateSearchTerm("Indirizzo", indirizzoCondominio, 0.20, true);

                            var fuzzyResult = fuzzy.Search(query, scope, 1);
                            return fuzzyResult.Count > 0 && fuzzyResult[0].Rank > 1;
                        }

                        return true;
                    }

                }
                catch (Exception ex)
                {
                    
                    _log.Warn("Errore inaspettato durante il set di residente - " + Library.Utility.GetMethodDescription(), ex);
                    return false;
                }
            }

            return false;
        }
コード例 #29
0
ファイル: RateService.cs プロジェクト: gipasoft/Sfera
        private SoggettoCondominio getSoggettoFromRate(IList<RataSoggetto> rate, SoggettoCondominio soggetto)
        {
            var rataSoggetto = rate.FirstOrDefault(item => item.Soggetto.Persona.ID == soggetto.Persona.ID);
            if (rataSoggetto != null)
                soggetto = rataSoggetto.Soggetto;

            return soggetto;
        }
コード例 #30
0
        private List<ReportRipartizioneBilancioDTO> elaboraSoggetto(SoggettoCondominio soggetto, IEnumerable<SoggettoCondominio> soggettiAttivi, IList<ReportRipartizioneBilancioDTO> totali, Esercizio esercizio, bool accorpamentoUnita)
        {
            try
            {
                if (totali.All(item => item.IdPartecipante != soggetto.ID))
                {

                    var fakeItem = new ReportRipartizioneBilancioDTO
                    {
                        IdPartecipante = soggetto.ID,
                        IdPersona = soggetto.Persona.ID,
                        IdUnitaImmobiliare = soggetto.UnitaImmobiliare.ID,
                        TipoUnitaImmobiliare = soggetto.UnitaImmobiliare.TipoUnitaImmobiliare.Descrizione,
                        Nominativo = soggetto.DisplayName,
                        OrdineUnitaImmobiliare = soggetto.UnitaImmobiliare.Ordine.GetValueOrDefault(),
                        SubalternoUnitaImmobiliare = soggetto.UnitaImmobiliare.Subalterno,
                        PianoUnitaImmobiliare = soggetto.UnitaImmobiliare.Piano,
                        InternoUnitaImmobiliare = getInternoUnitaImmobiliare(soggetto.UnitaImmobiliare),
                        OrdineStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.Ordine,
                        OrdineGruppoStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.Ordine,
                        DescrizioneStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.Descrizione,
                        DescrizioneGruppoStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.Descrizione,
                        IdStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.ID,
                        IdGruppoStabile = soggetto.UnitaImmobiliare.GruppoStabileRiferimento.ID,
                        TipoNominativo = (soggetto.Tipo == TipoSoggetto.Proprietario) ? "PROP" : "COND",
                        TipoNominativoEffettivo = soggetto.Tipo.ToString().Substring(0, 1),
                        CodiceConto = "666",
                        DisabilitaStampaMillesimi = true,
                        Importo = 0,
                        DataUscitaPartecipante = getDataUscita(soggetto),
                        OrdinePartecipante = soggetto.Tipo == TipoSoggetto.Proprietario ? 10 : 20
                    };

                    if (accorpamentoUnita)
                    {
                        var propPrincipale = (from item in soggettiAttivi
                                              where item.Tipo == TipoSoggetto.Proprietario && item.Principale.GetValueOrDefault() && item.UnitaImmobiliare.ID == soggetto.UnitaImmobiliare.ID
                                              select item).SingleOrDefault();
                        // Se il proprietario non è presente lo cerco tra tutti i proprietari
                        if (propPrincipale == null)
                        {
                            propPrincipale = (from item in soggetto.UnitaImmobiliare.Proprietari
                                              where item.DataInizio == null || item.DataInizio.Value < esercizio.DataChiusura
                                              orderby item.DataInizio.GetValueOrDefault() descending
                                              select item).FirstOrDefault();

                            _log.DebugFormat("Non trovato proprietario principale - {0} - unità:{1} - esercizio:{2}", Utility.GetMethodDescription(), soggetto.UnitaImmobiliare.ID, esercizio.ID);
                        }

                        if (propPrincipale != null)
                        {
                            fakeItem.IdPartecipante = propPrincipale.ID;
                            fakeItem.IdPersona = propPrincipale.Persona.ID;
                        }

                        fakeItem.Nominativo = soggetto.UnitaImmobiliare.Descrizione;
                    }

                    totali.Add(fakeItem);
                }
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato durante la lettura del datasource per il riparto del consuntivo - FAKE - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
                throw;
            }

            return totali.ToList();
        }