Example #1
0
        /// <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);
        }
Example #2
0
        /// <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);
        }
        public IList<ResultVersamento> InsertVersamentoByPersona(int idEsercizio, int idConto, int? idSottoConto, DateTime dataVersamento, string numeroAssegno, string causale, string nota, int? idMovimentoBancario, List<RataPersonaDTO> rate, LogTransazione logTransazione, TipoVersamentoDopoChiusuraEnum? tipoVersamentoDopoChiusura, TipoVersamentoPrimaAperturaEnum? tipoVersamentoPrimaApertura)
        {
            var message = string.Empty;

            TestataMovimentoContabile testata = null;
            MovimentoContabile movimentoPatrimoniale = null;
            var result = new List<ResultVersamento>();
            try
            {
                var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false);

                // ------------------------------------------------------
                //  Trovo l'esercizio contabile, se  non è esiste oppure se è chiuso
                //  interrompo l'operazione di versamento
                // ------------------------------------------------------
                var esercizioContabile = esercizio;
                if (esercizio.Gestione == GestioneEsercizioEnum.Ordinario)
                {
                    esercizioContabile = _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(esercizio.CondominioRiferimento, dataVersamento);
                    if (esercizioContabile == null || esercizioContabile.Stato == StatoEsercizioEnum.Chiuso)
                    {
                        var messageEsercizio = esercizioContabile == null ? "l'esercizio di competenza non è ancora stato aperto" : $"l'esercizio '{esercizioContabile.DisplayName}' è chiuso";
                        return new List<ResultVersamento> { new ResultVersamento(null, null, null, null, null, $"Non è possibile registrare il versamento in data {dataVersamento.ToShortDateString()} perchè {messageEsercizio}.")};
                    }
                }

                // La richiesta del versamento può avvenire solo se il versamento è successivo alla data di chiusura dell'esercizio
                if (dataVersamento <= esercizio.DataChiusura.GetValueOrDefault())
                    tipoVersamentoDopoChiusura = null;

                var listaRate = rate.Where(item => item.Selezionabile && item.ImportoVersamento > 0)
                        .GroupBy(item => item.IdSoggetto)
                        .Select(rateSoggetto => rateSoggetto);

                foreach (var ratePerSoggetto in listaRate)
                {
                    var importo = ratePerSoggetto.Sum(item => item.ImportoVersamento.GetValueOrDefault());

                    // ========================================================
                    //  Creo il versamento e i relativi movimenti economici
                    // ========================================================
                    var progressivo = _protocolloService.GetProgressivo(TipoProtocollo.VersamentoCondomino, esercizio);
                    if (progressivo.Progressivo == null)
                    {
                        var resultVersamenti = new List<ResultVersamento> {new ResultVersamento(null, null, null, null, null, progressivo.Message)};
                        return resultVersamenti;
                    }

                    var protocollo = progressivo.Progressivo;
                    var versamento = new VersamentoSoggetto(esercizio, _daoFactory.GetSoggettoCondominioDao().GetById(ratePerSoggetto.Key, false), _daoFactory.GetContoDao().GetById(idConto, false), dataVersamento, importo, protocollo.Value, TipoVersamentoSoggettoEnum.Manuale, logTransazione, tipoVersamentoDopoChiusura, tipoVersamentoPrimaApertura) {NumeroAssegno = numeroAssegno, Causale = causale, Nota = nota};

                    if (idSottoConto != null)
                    {
                        if (idSottoConto > 0)
                            versamento.SottoContoPatrimoniale = _daoFactory.GetSottoContoDao().GetById(idSottoConto.Value, false);
                        else if (idSottoConto < 0)
                            versamento.ContoBancario = _daoFactory.GetDatiBancariCondominiDao().GetById(idSottoConto.Value * -1, false);
                    }

                    var rateDaEmettere = new List<RataSoggetto>();
                    if (rate != null)
                    {
                        foreach (var rataDto in ratePerSoggetto)
                        {
                            if (rataDto.ID > 0)
                            {
                                var rata = _daoFactory.GetRataSoggettoDao().GetById(rataDto.ID, false);
                                var versamentoRata = new VersamentiRate(versamento, rata, rataDto.ImportoVersamento.GetValueOrDefault());

                                // ----------------------------------------------------
                                // Se la rata non è stata emessa devo creare movimento
                                // ----------------------------------------------------
                                if (rata.Stato == StatoRataEnum.Inserita)
                                    rateDaEmettere.Add(rata);
                                rata.SetStato();
                            }
                        }
                    }

                    var testateContabili = _movimentoContabileService.SetMovimentiVersamentoCondomino(testata, movimentoPatrimoniale, esercizioContabile, versamento, versamento.Data, null, null, idMovimentoBancario, null, logTransazione);
                    testata = testateContabili[0];
                    setRataVersamentoDopoChiusura(versamento, esercizioContabile, logTransazione);

                    // Salvataggi
                    _daoFactory.GetVersamentoSoggettoDao().SaveOrUpdate(versamento);

                    var testateMovimenti = testata.Movimenti.Where(item => item.ContoRiferimento.ID == versamento.ContoPatrimoniale.ID).ToList();
                    if (testateMovimenti.Count > 1)
                        _log.ErrorFormat("ATTENZIONE: Trovato più di una testata di movimento - {0} - versamento:{1} - conto:{1} - testate:{2}", Utility.GetMethodDescription(), versamento.ID, versamento.ContoPatrimoniale.ID, testateMovimenti.Aggregate(string.Empty, (current, movimentoContabile) => current + movimentoContabile.ID));

                    movimentoPatrimoniale = testateMovimenti.FirstOrDefault();
                    int? idMovimentoPatrimoniale = null;
                    if (movimentoPatrimoniale != null)
                        idMovimentoPatrimoniale = movimentoPatrimoniale.ID;

                    result.Add(new ResultVersamento(setVersamentoRicevutaDTO(versamento), versamento.ID, protocollo, idMovimentoPatrimoniale, getDescrizioneVersamentoConfermato(versamento), message));
                }
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nel metodo - {0} - esercizio:{1} - conto:{2} - sottoconto:{3} - dataVersamento:{4} - numeroAssegno:{5} - causale:{6}", ex, Utility.GetMethodDescription(), idEsercizio, idConto, idSottoConto.GetValueOrDefault(), dataVersamento, numeroAssegno, causale);
                throw;
            }

            return result;
        }
        public ResultVersamento InsertVersamentoCondomino(int idEsercizio, int idSoggetto, int idConto, int? idSottoConto, DateTime dataVersamento, decimal importo, string numeroAssegno, string causale, string nota, int? idMovimentoBancario, List<RataSoggettoVersataDTO> rate, LogTransazione logTransazione, TipoVersamentoDopoChiusuraEnum? tipoVersamentoDopoChiusura = null, TipoVersamentoPrimaAperturaEnum? tipoVersamentoPrimaApertura = null)
        {
            int? protocollo = null;
            int? idMovimentoContabile = null;
            int? idVersamento = null;
            var message = string.Empty;
            var descrizione = string.Empty;
            VersamentoSoggetto versamento = null;

            try
            {
                var contoPatrimoniale = _daoFactory.GetContoDao().Find(idConto, false);
                if(contoPatrimoniale == null)
                    return new ResultVersamento(null, null, null, null, null, "Non è stato trovato il conto patrimoniale (banca/cassa) selezionato.");

                // ========================================================
                //  Creo il versamento e i relativi movimenti economici
                // ========================================================
                var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false);

                var soggetto = _daoFactory.GetSoggettoCondominioDao().Find(idSoggetto, false);
                if(soggetto == null)
                    return new ResultVersamento(null, null, null, null, null, "Il condomino non è più presente in archivio");

                // ------------------------------------------------------
                //  Trovo l'esercizio contabile, se  non è esiste oppure se è chiuso
                //  interrompo l'operazione di versamento
                // ------------------------------------------------------
                var esercizioContabile = esercizio;
                if (esercizio.Gestione == GestioneEsercizioEnum.Ordinario)
                {
                    esercizioContabile = _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(esercizio.CondominioRiferimento, dataVersamento);
                    if (esercizioContabile == null || esercizioContabile.Stato == StatoEsercizioEnum.Chiuso)
                    {
                        var messageEsercizio = esercizioContabile == null ? "l'esercizio di competenza non è ancora stato aperto" : $"l'esercizio '{esercizioContabile.DisplayName}' è chiuso";
                        return new ResultVersamento(null, null, null, null, null, $"Non è possibile registrare il versamento in data {dataVersamento.ToShortDateString()} perchè {messageEsercizio}.");
                    }
                }
                
                var progressivo = _protocolloService.GetProgressivo(TipoProtocollo.VersamentoCondomino, esercizio);

                // La richiesta del versamento può avvenire solo se il versamento è successivo alla data di chiusura dell'esercizio
                if (dataVersamento <= esercizio.DataChiusura.GetValueOrDefault())
                    tipoVersamentoDopoChiusura = null;

                if (progressivo.Progressivo == null)
                    message = progressivo.Message + string.Empty;
                else
                {
                    protocollo = progressivo.Progressivo;

                    versamento = new VersamentoSoggetto(esercizio, soggetto, contoPatrimoniale, dataVersamento, importo, protocollo.Value, TipoVersamentoSoggettoEnum.Manuale, logTransazione, tipoVersamentoDopoChiusura, tipoVersamentoPrimaApertura) {NumeroAssegno = numeroAssegno, Causale = causale, Nota = nota};

                    if (idSottoConto != null)
                    {
                        if (idSottoConto > 0)
                            versamento.SottoContoPatrimoniale = _daoFactory.GetSottoContoDao().GetById(idSottoConto.Value, false);
                        else if (idSottoConto < 0)
                            versamento.ContoBancario = _daoFactory.GetDatiBancariCondominiDao().GetById(idSottoConto.Value * -1, false);
                    }

                    var testateContabili = _movimentoContabileService.SetMovimentiVersamentoCondomino(null, null, esercizioContabile, versamento, versamento.Data, null, null, idMovimentoBancario, null, logTransazione);
                    var versamentiRate = setRataVersamentoDopoChiusura(versamento, esercizioContabile, logTransazione);

                    if (rate != null)
                    {
                        foreach (var rataDto in rate)
                        {
                            if (rataDto.IdRata > 0)
                            {
                                var rata = _daoFactory.GetRataSoggettoDao().Find(rataDto.IdRata, false);
                                if(rata != null)
                                {
                                    var versamentoRata = new VersamentiRate(versamento, rata, rataDto.ImportoVersamento);
                                    rata.SetStato();
                                }
                            }
                        }
                    }

                    _daoFactory.GetVersamentoSoggettoDao().SaveOrUpdate(versamento);

                    idVersamento = versamento.ID;
                    idMovimentoContabile = versamento.MovimentoContabilePatrimoniale.ID;
                    descrizione = getDescrizioneVersamentoConfermato(versamento);
                }
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nel metodo: {0} - esercizio:{1} - conto:{1} - sottoconto:{2} - soggetto:{3} - dataVersamento:{4:d} - importo:{5} - numeroAssegno:{6} - causale:{7}", ex, Utility.GetMethodDescription(), idEsercizio, idConto, idSottoConto.GetValueOrDefault(), idSoggetto, dataVersamento, importo, numeroAssegno, causale);
                throw;
            }

            return new ResultVersamento(setVersamentoRicevutaDTO(versamento), idVersamento, protocollo, idMovimentoContabile, descrizione, message);
        }
        public ResultVersamento InsertVersamentoCondomino(Esercizio esercizio, RataSoggetto rata, DatiBancariCondomini banca, Conto contoBancario, CausaleContabile causaleVersamento, Conto contoVersamentoCondomini, DateTime dataVersamento, FileCBI file, LogTransazione logTransazione, TipoVersamentoDopoChiusuraEnum? tipoVersamentoDopoChiusura = null, TipoVersamentoPrimaAperturaEnum? tipoVersamentoPrimaApertura = null)
        {
            int? protocollo = null;
            int? idMovimentoContabile = null;
            var message = string.Empty;
            var descrizione = string.Empty;
            VersamentoSoggetto versamento = null;

            // La richiesta del versamento può avvenire solo se il versamento è successivo alla data di chiusura dell'esercizio
            if (dataVersamento <= esercizio.DataChiusura.GetValueOrDefault())
                tipoVersamentoDopoChiusura = null;

            // La richiesta del versamento prima dell'apertura può avvenire solo se il versamento è precedente alla data di apertura dell'esercizio
            if (dataVersamento >= esercizio.DataApertura.GetValueOrDefault())
                tipoVersamentoPrimaApertura = null;
            try
            {
                // ----------------------------------------------------
                //  Creo Versamento
                // ----------------------------------------------------
                if (string.IsNullOrEmpty(message))
                {
                    var progressivo = _protocolloService.GetProgressivo(TipoProtocollo.VersamentoCondomino, esercizio);
                    if (progressivo.Progressivo != null)
                    {
                        protocollo = progressivo.Progressivo;

                        // ------------------------------------------------------
                        //  Trovo l'esercizio contabile, se non esiste oppure se è chiuso
                        //  interrompo l'operazione di versamento
                        // ------------------------------------------------------
                        var esercizioContabile = esercizio;
                        if (esercizioContabile.Gestione == GestioneEsercizioEnum.Ordinario || (esercizioContabile.Gestione == GestioneEsercizioEnum.Straordinario && (esercizioContabile.Stato == StatoEsercizioEnum.Chiuso || esercizioContabile.DataChiusura.GetValueOrDefault() < dataVersamento)))
                        {
                            esercizioContabile = _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(esercizio.CondominioRiferimento, dataVersamento);
                            if (esercizioContabile == null || esercizioContabile.Stato == StatoEsercizioEnum.Chiuso)
                            {
                                var messageEsercizio = esercizioContabile == null ? "l'esercizio di competenza non è ancora stato aperto" : $"l'esercizio '{esercizioContabile.DisplayName}' è chiuso";
                                return new ResultVersamento(null, null, null, null, null, $"Non è possibile registrare il versamento in data {dataVersamento.ToShortDateString()} perchè {messageEsercizio}.");
                            }
                        }

                        try
                        {
                            versamento = new VersamentoSoggetto(esercizio, rata.Soggetto, contoBancario, dataVersamento, rata.Importo, file, banca, logTransazione, tipoVersamentoDopoChiusura, tipoVersamentoPrimaApertura);
                            _movimentoContabileService.SetMovimentiVersamentoCondomino(null, null, esercizioContabile, versamento, dataVersamento, causaleVersamento, contoVersamentoCondomini, null, file, logTransazione);
                        }
                        catch (InvalidDataException exception)
                        {
                            _log.ErrorFormat("Errore inaspettato nella registrazione del versamento del condomino - {0} - esercizio:{1} - rata:{2}", Utility.GetMethodDescription(), esercizioContabile.ID, rata.ID);
                            if (versamento != null)
                            {
                                if (logTransazione != null)
                                {
                                    logTransazione.Versamenti.Remove(versamento);
                                    versamento.LogTransazione = null;
                                }

                                if (file != null)
                                {
                                    file.Versamenti.Remove(versamento);
                                    versamento.File = null;
                                }

                                esercizio.VersamentiCondomini.Remove(versamento);
                                versamento.Esercizio = null;

                                rata.Soggetto.Versamenti.Remove(versamento);
                                versamento.Soggetto = null;

                                versamento = null;
                            }
                            return new ResultVersamento(null, null, null, null, null, $"Non è possibile registrare il versamento in data {dataVersamento.ToShortDateString()} perchè {exception.Message}.");
                        }
                        
                        setRataVersamentoDopoChiusura(versamento, esercizioContabile, logTransazione);

                        // ---------------------------------------------------------------------
                        // Se la rata non è ancora stata pagata associo il versamento alla rata
                        // ---------------------------------------------------------------------
                        // se la rata è già stata pagata, oppure se l'esercizio di riferimento è chiuso viene registrata come rata fuori piano rateale
                        if (rata.Stato != StatoRataEnum.Pagata && rata.Stato != StatoRataEnum.ParzialmentePagata && rata.Esercizio.Stato == StatoEsercizioEnum.Aperto )
                        {
                            var versamentoRata = new VersamentiRate(versamento, rata, rata.Importo);
                            rata.SetStato();
                        }
                        else
                        {
                            versamento.Causale = $"Versamento fuori piano rateale perchè la rata si trova in stato di {rata.Stato}";
                        }

                        idMovimentoContabile = versamento.MovimentoContabilePatrimoniale.ID;
                        descrizione = getDescrizioneVersamentoConfermato(versamento);
                    }
                    else
                        message += progressivo.Message + Environment.NewLine;
                }
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nel metodo: {0} - rata:{1} - dataVersamento:{2}", ex, Utility.GetMethodDescription(), rata.ID, dataVersamento);
                throw;
            }

            return new ResultVersamento(setVersamentoRicevutaDTO(versamento), null, protocollo, idMovimentoContabile, descrizione, message);
        }
 public IList<ResultVersamento> InsertVersamentoByPersona(int idEsercizio, int idConto, int? idSottoConto, DateTime dataVersamento, string numeroAssegno, string causale, string nota, int? idMovimentoBancario, List<RataPersonaDTO> rate, TipoVersamentoDopoChiusuraEnum? tipoVersamentoDopoChiusura, TipoVersamentoPrimaAperturaEnum? tipoVersamentoPrimaApertura)
 {
     var result = GetServiceClient().InsertVersamentoByPersona(idEsercizio, idConto, idSottoConto, dataVersamento, numeroAssegno, causale, nota, idMovimentoBancario, rate, tipoVersamentoDopoChiusura, tipoVersamentoPrimaApertura, GetUserInfo());
     CloseService();
     return result;
 }
Example #7
0
        public IList<ResultVersamento> InsertVersamentoByPersona(int idEsercizio, int idConto, int? idSottoConto, DateTime dataVersamento, string numeroAssegno, string causale, string nota, int? idMovimentoBancario, List<RataPersonaDTO> rate, TipoVersamentoDopoChiusuraEnum? tipoVersamentoDopoChiusura, TipoVersamentoPrimaAperturaEnum? tipoVersamentoPrimaApertura, UserInfo userinfo)
		{
            var retryCount = 5;
            var success = false;
            var windsorRep = new WindsorConfigRepository();
            IList<ResultVersamento> item = null;
            while (retryCount >= 0 && !success)
            {
                try
                {
                    var logTransazione = windsorRep.BeginTransaction(userinfo, true, true);
                    var service = windsorRep.GetContainer(userinfo.Azienda).Resolve<IVersamentiCondominiService>();
                    item = service.InsertVersamentoByPersona(idEsercizio, idConto, idSottoConto, dataVersamento, numeroAssegno, causale, nota, idMovimentoBancario, rate, logTransazione, tipoVersamentoDopoChiusura, tipoVersamentoPrimaApertura);

                    windsorRep.Commit(logTransazione);
                    success = true;
                }
                catch (Exception ex)
                {
                    _log.ErrorFormat("Errore nella esecuzione della funzione - TENTATIVO:{0} - {1} - esercizio:{2} - conto:{3} - sottoconto:{4} - dataVersamento:{5:d} - numeroAssegno:{6} - causale:{7} - nota:{8} - movimentoBancario:{9} - rate:{10} - azienda:{11} - number:{12}", ex, (6 - retryCount), Utility.GetMethodDescription(), idEsercizio, idConto, idSottoConto.GetValueOrDefault(), dataVersamento, numeroAssegno, causale, nota, idMovimentoBancario.GetValueOrDefault(), rate, userinfo.Azienda, getExceptionId(ex));

                    windsorRep.Rollback();
                    if (!isRetryException(ex) && false)
                        throw;

                    // Add delay here if you wish. 
                    System.Threading.Thread.Sleep(1000 * (6 - retryCount));
                    retryCount--;
                    _log.InfoFormat("Errore nella esecuzione della funzione - INIZIO TENTATIVO:{0} - {1} - esercizio:{2} - conto:{3} - sottoconto:{4} - dataVersamento:{5:d} - numeroAssegno:{6} - causale:{7} - nota:{8} - movimentoBancario:{9} - rate:{10} - azienda:{11}", (6 - retryCount), Utility.GetMethodDescription(), idEsercizio, idConto, idSottoConto.GetValueOrDefault(), dataVersamento, numeroAssegno, causale, nota, idMovimentoBancario.GetValueOrDefault(), rate, userinfo.Azienda);
                }
            }

            if (!success)
                windsorRep.Rollback();

            return item;
		}