I can’t perform a Repository search with Nhibernate C#

Asked

Viewed 45 times

2

I’m new as a programmer, sorry if I can’t explain clearly, but please tell me what I did wrong and if possible how to do better, I want to improve as a programmer and user here at Stackoverflow I am trying to create a criteria to be able to fetch some specific information from my database, we are using the standard MVC and Nhibernate, Spring and I am getting the following error:

Spring.Data.Nhibernate.Hibernatesystemexception: 'Unable to perform find[SQL: SQL not available]

With two exceptions:

1: Argumentexception: The value "SGB.Services.Spec.DataTransferObjects.Dtocomposicaobeneficiobeneficiario" is not of the type "SGB.domain.Entities.Compositcaobeneficiobeneficiario" and cannot be used in this generic collection.

2:Genericadoexception: Unable to perform find[SQL: SQL not available]

Repository:

public DTOComposicaoBeneficioBeneficiario ObterBeneficioBeneficiarioOperadora(string codigoOperadora)
        {
            var criteria = DetachedCriteria.For<ComposicaoBeneficioBeneficiario>("cbb")
                .CreateCriteria("cbb.composicaoBeneficio", "cb", JoinType.InnerJoin);

            criteria
              .Add(Restrictions.Eq("cbb.identificadorOperadora", codigoOperadora));

            criteria.SetProjection(Projections.ProjectionList()
            .Add(Projections.Property("cbb.codigo").As("Codigo"))
            .Add(Projections.Property("cbb.identificadorOperadora").As("IdentificadorOperadora"))
            .Add(Projections.Property("cbb.nome").As("Nome"))
            .Add(Projections.Property("cbb.dependente").As("CodigoDependente"))
            .Add(Projections.Property("cbb.valorTotal").As("ValorTotal"))
            .Add(Projections.Property("cbb.valorFolha").As("ValorFolha"))
            .Add(Projections.Property("cb.codigo").As("CodigoComposicaoBeneficio")));

            criteria.SetResultTransformer(new NHibernate.Transform.AliasToBeanResultTransformer(typeof(DTOComposicaoBeneficioBeneficiario)));

            return List<ComposicaoBeneficioBeneficiario>(criteria).FirstOrDefault().Transform<DTOComposicaoBeneficioBeneficiario>();
        } 

DTO:

using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.ComponentModel.DataAnnotations;
using SGB.Common;
using SQFramework.Core.Reflection;

namespace SGB.Services.Spec.DataTransferObjects
{
    [DataContract()]
    [Serializable()]
    public class DTOComposicaoBeneficioBeneficiario
    {
        [DataMember(), Key(), Required()]
        public int Codigo { get; set; }

        [DataMember()]
        public string Nome { get; set; }

        [DataMember()]
        public string IdentificadorOperadora { get; set; }

        [DataMember]
        public DateTime DataNascimento { get; set; }

        [DataMember()]
        public string FaixaEtaria { get; set; }

        [DataMember()]
        public int CodigoFaixaEtaria { get; set; }

        [DataMember()]
        public virtual int? CodigoDependente { get; set; }

        [DataMember(), Map("ComposicaoBeneficio.Codigo"), Required()]
        public int CodigoComposicaoBeneficio { get; set; }

        [DataMember(), Map("TipoAcomodacaoBeneficio.Codigo"), Required()]
        public int CodigoTipoAcomodacaoBeneficio { get; set; }

        [DataMember(), Required()]
        public int CodigoTipoAcomodacao { get; set; }

        [DataMember(), Required()]
        public List<DTOPlanoAdicionalComposicaoBeneficioBeneficiario> PlanoAdicionalComposicaoBeneficioBeneficiario { get; set; }

        [DataMember(), Required()]
        public List<DTOPlanoAdicionalBeneficio> PlanoAdicionalBeneficio { get; set; }

        [DataMember(), Required()]
        public List<DTOItensPrecoBeneficiario> ItensPrecoBeneficiario { get; set; }

        #region [ VALORES ]

        [DataMember(), Required()]
        public decimal ValorTotal { get; set; }

        [DataMember()]
        public string ValorTotalFormatado { get => ValorTotal > 0 ? ValorTotal.ToString("C2") : "0,00"; set { } }

        [DataMember]
        public decimal ValorPacote { get; set; }

        [DataMember]
        public string ValorPacoteFormatado { get => ValorPacote > 0 ? ValorPacote.ToString("C2") : "0,00"; set { } }

        [DataMember]
        public decimal ValorFolha { get; set; }

        [DataMember]
        public string ValorFolhaFormatado { get => ValorFolha > 0 ? ValorFolha.ToString("C2") : "0,00"; set { } }

        [DataMember()]
        public decimal? ValorPlano { get; set; }

        [DataMember]
        public string ValorPlanoFormatado { get => ValorPlano.HasValue && ValorPlano > 0 ? ValorPlano.Value.ToString("C2") : "0,00"; set { } }

        [DataMember]
        public decimal ValorColaborador { get; set; }

        [DataMember]
        public string ValorColaboradorFormatado { get => ValorColaborador > 0 ? ValorColaborador.ToString("C2") : "0,00"; set { } }

        [DataMember]
        public decimal ValorEmpresa { get; set; }

        [DataMember]
        public string ValorEmpresaFormatado { get => ValorEmpresa > 0 ? ValorEmpresa.ToString("C2") : "0,00"; set { } }

        #endregion

        [DataMember()]
        public FormaDesconto FormaDesconto { get; set; }

        [DataMember]
        public int NumeroDependente { get; set; }

        [DataMember(), Required()]
        public bool Optante { get; set; }

        [DataMember(), Required()]
        public bool Titular { get; set; }

        [DataMember(), Required()]
        public List<DTOFaturaBeneficiario> faturaBeneficiario { get; set; }
    }
}

Entities:

using System;
using SQFramework.Spring.Domain;
using SGB.Integration.Spec;
using System.Collections.Generic;
using SGB.Common;
using SGB.Services.Spec.DataTransferObjects;
using SQFramework.Core;

namespace SGB.Domain.Entities
{
    public partial class ComposicaoBeneficioBeneficiario : DomainBase<ComposicaoBeneficioBeneficiario, IComposicaoBeneficioBeneficiarioRepository<ComposicaoBeneficioBeneficiario>>
    {
        public ComposicaoBeneficioBeneficiario()
        {
        }

        public ComposicaoBeneficioBeneficiario(ComposicaoBeneficio composicaoBeneficio)
        {
            SetComposicaoBeneficio(composicaoBeneficio);
        }

        protected int codigo;
        protected string nome;
        protected DateTime dataNascimento;
        protected string identificadorOperadora;
        protected decimal valorPacote;
        protected decimal valorFolha;
        protected decimal valorTotal;
        protected bool titular;
        protected bool optante;
        protected int? dependente;
        protected FormaDesconto formaDesconto;
        protected IList<PlanoAdicionalComposicaoBeneficioBeneficiario> planoAdicionalComposicaoBeneficioBeneficiario;
        protected ComposicaoBeneficio composicaoBeneficio;
        protected TipoAcomodacaoBeneficio tipoAcomodacaoBeneficio;
        protected IList<ItensPrecoBeneficiario> itensPrecoBeneficiarios;
        protected IList<FaturaBeneficiario> faturaBeneficiario;

        public virtual int Codigo { get => codigo; set { } }
        public virtual string Nome { get => nome; set => nome = value; }
        public virtual DateTime DataNascimento { get => dataNascimento; set => dataNascimento = value; }
        public virtual string IdentificadorOperadora { get => identificadorOperadora; set => identificadorOperadora = value; }
        public virtual decimal ValorPacote { get => valorPacote; set => valorPacote = value; }
        public virtual decimal ValorFolha { get => valorFolha; set => valorFolha = value; }
        public virtual decimal ValorTotal { get => valorTotal; set => valorTotal = value; }
        public virtual bool Titular { get => titular; set => titular = value; }
        public virtual bool Optante { get => optante; set => optante = value; }
        public virtual int? CodigoDependente { get => dependente; set => dependente = value; }
        public virtual FormaDesconto FormaDesconto { get => formaDesconto; set => formaDesconto = value; }
        public virtual IList<PlanoAdicionalComposicaoBeneficioBeneficiario> PlanoAdicionalComposicaoBeneficioBeneficiario => (planoAdicionalComposicaoBeneficioBeneficiario ?? (planoAdicionalComposicaoBeneficioBeneficiario = new List<PlanoAdicionalComposicaoBeneficioBeneficiario>()));
        public virtual ComposicaoBeneficio ComposicaoBeneficio => composicaoBeneficio;
        public virtual TipoAcomodacaoBeneficio TipoAcomodacaoBeneficio { get => tipoAcomodacaoBeneficio; set => tipoAcomodacaoBeneficio = value; }
        public virtual IList<ItensPrecoBeneficiario> ItensPrecoBeneficiarios => (itensPrecoBeneficiarios ?? (itensPrecoBeneficiarios = new List<ItensPrecoBeneficiario>()));
        public virtual IList<FaturaBeneficiario> FaturaBeneficiario => (faturaBeneficiario ?? (faturaBeneficiario = new List<FaturaBeneficiario>()));

        public virtual void SetComposicaoBeneficio(ComposicaoBeneficio composicaoBeneficio)
        {
            this.composicaoBeneficio = composicaoBeneficio;
        }

        public virtual void SetTipoAcomodacaoBeneficio(TipoAcomodacaoBeneficio tipoAcomodacaoBeneficio)
        {
            this.tipoAcomodacaoBeneficio = tipoAcomodacaoBeneficio;
        }

        public virtual int SalvarComposicaoBeneficioBeneficiario()
        {
            Save();
            return codigo;
        }

        public virtual DTOComposicaoBeneficioBeneficiario ObterOperadora(string codigoOperadora)
        {
            var composicaoBeneficiarios = GetRepository().ListAll();
            ComposicaoBeneficioBeneficiario composicaoDesejada = new ComposicaoBeneficioBeneficiario();

            foreach (var composicao in composicaoBeneficiarios)
            {
                if (composicao.IdentificadorOperadora == codigoOperadora)
                {
                    composicaoDesejada = composicao;
                    break;
                }
            }

            return composicaoDesejada.Transform<DTOComposicaoBeneficioBeneficiario>();
        }

    }
}


using SGB.Common;
using SGB.Common.Resources;
using SGB.Integration.Spec;
using SQFramework.Spring.Domain;
using System;
using System.Collections.Generic;


namespace SGB.Domain.Entities
{
    public partial class ComposicaoBeneficio : DomainBase<ComposicaoBeneficio, IComposicaoBeneficioRepository<ComposicaoBeneficio>>
    {
        public ComposicaoBeneficio()
        {
        }

        public ComposicaoBeneficio(Beneficio beneficio, Colaborador colaborador)
        {
            SetBeneficio(beneficio);
            SetColaborador(colaborador);
        }

        protected int codigo;
        protected decimal valorPacote;
        protected decimal valorFolha;
        protected decimal valorTotal;
        protected bool ativo;
        protected Beneficio beneficio;
        protected Colaborador colaborador;
        protected IList<Lancamento> lancamentos;
        protected IList<Historico> historico;
        protected IList<FechamentoBeneficioColaborador> fechamentoBeneficioColaborador;
        protected IList<ComposicaoBeneficioBeneficiario> composicaoBeneficioBeneficiarios;

        public virtual int Codigo { get => codigo; set { } }
        public virtual decimal ValorPacote => valorPacote;
        public virtual decimal ValorFolha => valorFolha;
        public virtual decimal ValorTotal => valorTotal;
        public virtual bool Ativo => ativo;
        public virtual Beneficio Beneficio => beneficio;
        public virtual Colaborador Colaborador => colaborador;
        public virtual IList<Lancamento> Lancamentos => (lancamentos ?? (lancamentos = new List<Lancamento>()));
        public virtual IList<Historico> Historico => (historico ?? (historico = new List<Historico>()));
        public virtual IList<FechamentoBeneficioColaborador> FechamentoBeneficioColaborador => (fechamentoBeneficioColaborador ?? (fechamentoBeneficioColaborador = new List<FechamentoBeneficioColaborador>()));
        public virtual IList<ComposicaoBeneficioBeneficiario> ComposicaoBeneficioBeneficiarios => (composicaoBeneficioBeneficiarios ?? (composicaoBeneficioBeneficiarios = new List<ComposicaoBeneficioBeneficiario>()));

        public virtual void SetBeneficio(Beneficio pBeneficio) => beneficio = pBeneficio;
        public virtual void SetColaborador(Colaborador pColaborador) => colaborador = pColaborador;
        public virtual void SetValorFolha(decimal pValorFolha) => valorFolha = pValorFolha;
        public virtual void SetValorPacote(decimal pValorPacote) => valorPacote = pValorPacote;
        public virtual void SetValorTotal(decimal pValorTotal) => valorTotal = pValorTotal;
        public virtual void SetAtivo(bool pAtivo) => ativo = pAtivo;

        public virtual void RegistraHistorico(TipoHistorico tipoHistorico, decimal valorPacoteAnterior, decimal valorFolhaAnterior, decimal valorTotalAnterior, decimal valorPacoteAtual, decimal valorFolhaAtual, decimal valorTotalAtual, Reajuste reajuste, string loginResponsavel, string observacao)
        {
            var itemHistorico = new Historico(this)
            {
                Data = DateTime.Now,
                Tipo = tipoHistorico,
                ValorPacoteAnterior = valorPacoteAnterior,
                ValorFolhaAnterior = valorFolhaAnterior,
                ValorTotalAnterior = valorTotalAnterior,
                ValorPacoteAtual = valorPacoteAtual,
                ValorFolhaAtual = valorFolhaAtual,
                ValorTotalAtual = valorTotalAtual,

                LoginResponsavel = loginResponsavel,
                Observacao = observacao

            };

            if (reajuste != null)
            {
                itemHistorico.SetReajuste(reajuste);
            }

            if (valorPacoteAnterior != valorPacoteAtual || valorPacoteAnterior != valorFolhaAtual)
            {
                Historico.Add(itemHistorico);
            }
        }

        public virtual void ReativaComposicao(decimal novoValorPacote, decimal novoValorFolha, decimal novoValorTotal, string loginResponsavel, string observacao)
        {
            RegistraHistorico(TipoHistorico.Ativação, ValorPacote, ValorFolha, ValorTotal, novoValorPacote, novoValorFolha, novoValorTotal, null, loginResponsavel, observacao);
            ativo = true;
            valorPacote = novoValorPacote;
            valorFolha = novoValorFolha;
        }

        public virtual void AtivaComposicao(decimal novoValorPacote, decimal novoValorFolha, decimal novoValorTotal, string loginResponsavel, string observacao)
        {
            RegistraHistorico(TipoHistorico.Ativação, 0, 0, 0, novoValorPacote, novoValorFolha, novoValorTotal, null, loginResponsavel, observacao);
            ativo = true;
            this.valorPacote = novoValorPacote;
            this.valorFolha = novoValorFolha;
        }

        public virtual void InativaComposicao(string loginResponsavel, string observacao)
        {
            if (!Ativo)
            {
                throw new ArgumentException(SpecificMessageResource.MSES03);
            }

            RegistraHistorico(TipoHistorico.Desativação, ValorPacote, ValorFolha, ValorTotal, 0, 0, 0, null, loginResponsavel, observacao);
            ativo = false;
            this.valorPacote = 0;
            this.valorFolha = 0;

            Save();
        }

        public virtual void AlterarValorComposicao(decimal novoValorPacote, decimal novoValorFolha, decimal novoValorTotal, string loginResponsavel, string observacao)
        {
            if (novoValorPacote == ValorPacote && novoValorFolha == ValorFolha)
            {
                return;
            }

            if (!beneficio.Disponivel)
            {
                throw new ArgumentException(GenericMessageResource.MSGS11);
            }

            RegistraHistorico(TipoHistorico.Movimentação, this.valorPacote, this.valorFolha, this.valorTotal, novoValorPacote, novoValorFolha, novoValorTotal, null, loginResponsavel, observacao);
            this.valorPacote = novoValorPacote;
            this.valorFolha = novoValorFolha;
        }

        public virtual void ReajustaComposicao(decimal valorComposicao, Reajuste reajuste, string loginResponsavel, string observacao)
        {
            RegistraHistorico(valorComposicao == 0 ? TipoHistorico.Desativação : TipoHistorico.Reajuste, ValorPacote, 0, ValorTotal, valorComposicao, 0, valorComposicao, reajuste, loginResponsavel, observacao);
            SetValorPacote(valorComposicao);
            SetValorTotal(ValorFolha + ValorPacote);
        }

        public virtual void AssociaComposicaoBeneficio(decimal novoValorPacote, decimal novoValorFolha, decimal novoValorTotal, string loginResponsavel, string observacao)
        {
            if (string.IsNullOrWhiteSpace(loginResponsavel))
            {
                throw new ArgumentException(String.Format(GenericMessageResource.MSGS25, loginResponsavel));
            }

            if (string.IsNullOrWhiteSpace(observacao))
            {
                throw new ArgumentException(String.Format(GenericMessageResource.MSGS25, observacao));
            }

            if (Ativo && (ValorPacote >= 0 || ValorFolha >= 0))
            {
                if (novoValorPacote == 0 && novoValorFolha == 0)
                {
                    InativaComposicao(loginResponsavel, observacao);
                    DeletarComposicaoBeneficioBeneficiario(this.ComposicaoBeneficioBeneficiarios);
                }
                else
                {
                    AlterarValorComposicao(novoValorPacote, novoValorFolha, novoValorTotal, loginResponsavel, observacao);
                }
            }
            else if (!Ativo && (novoValorPacote != 0 || novoValorFolha != 0))
            {
                ReativaComposicao(novoValorPacote, novoValorFolha, novoValorTotal, loginResponsavel, observacao);
            }

            Save();
        }

        public virtual ComposicaoBeneficio AssociarValeRefeicaoColaborador(int? codigoConvencaoColetivaFaixaDesconto, decimal? jornadaTrabalho,
            string loginResponsavel, string observacao)
        {
            if (codigoConvencaoColetivaFaixaDesconto == null)
            {
                throw new ArgumentException("Faixa salarial inválida. Verifique a localidade cadastrada nos demais sistemas.");
            }

            if (jornadaTrabalho == null)
            {
                throw new ArgumentException("Jornada de trabalho inválida. Verifique a jornada cadastrada nos demais sistemas.");
            }

            ComposicaoBeneficio composicaoBeneficio = null;
            var codigoTipoColaborador = Colaborador.TipoColaborador.Codigo;

            if (codigoTipoColaborador == (int)Common.TipoColaborador.Funcionario || codigoTipoColaborador == (int)Common.TipoColaborador.Estagiario)
            {
                var calculo = new ComposicaoBeneficioValeRefeicao();
                var convencaoColetiva = ConvencaoColetiva.GetRepository().ObterConvencaoColetivaPorLocalidade(Colaborador.CodigoCidade);

                composicaoBeneficio = this;
                calculo.CalcularValoresComposicaoBeneficioValeRefeicaoPorColaborador(ref composicaoBeneficio, convencaoColetiva,
                    codigoConvencaoColetivaFaixaDesconto,
                    jornadaTrabalho, codigoTipoColaborador, loginResponsavel, observacao);
            }

            return composicaoBeneficio;
        }

        public virtual void DeletarComposicaoBeneficioBeneficiario(IList<ComposicaoBeneficioBeneficiario> beneficiarios)
        {
            foreach (var item in beneficiarios)
            {
                if (item == null)
                {
                    continue;
                }

                item.PlanoAdicionalComposicaoBeneficioBeneficiario.Clear();
                item.ItensPrecoBeneficiarios.Clear();
                item.Delete();
            }

            ComposicaoBeneficioBeneficiarios.Clear();
        }
    }
}

From what I read in the error the DTO is not compatible with the entity, but I could not identify such incompatibility, could help me?

1 answer

2


Juan, good morning!

This passage tells your problem:

1: ArgumentException: O valor "SGB.Services.Spec.DataTransferObjects.DTOComposicaoBeneficioBeneficiario" não é do tipo "SGB.Domain.Entities.ComposicaoBeneficioBeneficiario" e não pode ser usado nesta coleção genérica.

Since C# is a strongly typed language (Strogly Typed), the compiler does not automatically convert to you. The type he is waiting for is "SGB.domain.Entities.Compositcaobeneficiobeneficiario", check that the class being used is not exchanged.

  • 1

    Angelo, good morning, Angelo. Thank you very much for the help that was, it should be of the type Compositcaobeneficiobeneficiario, however I tried to transform it to DTO in the return being that it should pass the penalty the Compositcaobeneficiobeneficiario, passing the entity to feathers works as it should, thank you very much.

Browser other questions tagged

You are not signed in. Login or sign up in order to post.