doubts with linq to sql

-1

Personal I have two tables, sale and sale Items: Sale:

 [Table("venda")]
public class VendaModel
{
    [Key]
    [Required]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public int id_venda  { get; set; }
    public DateTime dt_venda { get; set; }
    public int id_empresa { get; set; }
    public int? id_cliente { get; set; }
    public int? id_vendedor { get; set; }
    public string vlr_total { get; set; }
    public string perc_desc { get; set; }
    public string vlr_desc { get; set; }
    public string vlr_liq { get; set; }
    public int forma_pgto { get; set; }
    public int parcelas { get; set; }
    public string tipo { get; set; } //orcamento ou venda
    public int id_plano_conta { get; set; } //orcamento ou venda



    [JsonIgnore]
    [ForeignKey("id_empresa")]
    public virtual EmpresaModel EmpresaModel { get; set; }

    [JsonIgnore]
    [ForeignKey("id_cliente")]
    public virtual PessoaModel ClienteModel { get; set; }

    [JsonIgnore]
    [ForeignKey("id_vendedor")]
    public virtual PessoaModel VendedorModel { get; set; }

    public virtual ICollection<VendaItensModel> VendaItensModel { get; set; }

    [JsonIgnore]
    public virtual ICollection<ProdutoHistoricoModel> ProdutoHistoricoModel { get; set; }

}

Sale Items:

 [Table("venda_itens")]
public class VendaItensModel
{
    [Key]
    [Required]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public int id_venda_itens { get; set; }
    public int id_venda { get; set; }
    public int id_empresa  { get; set; }
    public int id_produto { get; set; }
    public string qtde { get; set; }
    public string preco_venda { get; set; }
    public string total_item { get; set; }

    [JsonIgnore]
    [ForeignKey("id_empresa")]
    public virtual EmpresaModel EmpresaModel { get; set; }

    [JsonIgnore]
    [ForeignKey("id_venda")]
    public virtual VendaModel VendaModel { get; set; }

    [ForeignKey("id_produto")]
    public virtual ProdutoModel ProdutoModel { get; set; }
}

With the query linq below (I am using this way to search the fields I want, if I do an object search, there are fields that I do not need), I'm looking for sales, but I need to modify the code to search the sales items:

 retorno = (from a in context.VendaModel
                                   join b in context.Pessoa on a.id_cliente equals b.id_pessoa
                                   join c in context.Pessoa on a.id_vendedor equals c.id_pessoa
                                   where a.id_empresa == idEmpresa
                                   && a.dt_venda >= rDtInicio
                                   && a.dt_venda <= rDFim
                                   && a.tipo == tipo

                                   select new
                                   {
                                       a.dt_venda,
                                       a.forma_pgto,
                                       a.id_cliente,
                                       a.id_empresa,
                                       a.id_venda,
                                       a.id_vendedor,
                                       a.parcelas,
                                       a.perc_desc,
                                       a.tipo,
                                       a.vlr_desc,
                                       a.vlr_liq,
                                       a.vlr_total,
                                       cliente = b.razao,
                                       vendedor = c.razao
                                   });

How could I do to bring the items of each sale, my view expects a Json with the sale and its items, more or less so (in the example below I'm just illustrating, I know the json structure is not quite that way):

[
    {
        vendaX[]
        itens venda X{}
        vendaY
        itens venda Y{}     
    }
]

The conversion to Json I know how to do, I just need to modify the Linq query, what would this query look like?

Product class

 [Table("produto")]
public class ProdutoModel
{
    [Key]
    [Required]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public int id_produto { get; set; }
    public int id_produto_grupo { get; set; }
    public int id_fabricante { get; set; }
    public int id_empresa { get; set; }
    public string barras { get; set; }
    public string nome { get; set; }
    public string und { get; set; }
    public string preco_compra { get; set; }
    public string margem_lucro { get; set; }
    public string preco_venda { get; set; }
    public string perc_comissao { get; set; }
    public string qtde_estoque { get; set; }
    public string est_minimo { get; set; }
    public string fracao { get; set; }
    public int situacao { get; set; }
    public string alldata { get; set; }
    public string data_cad { get; set; }
    public string perc_promocao { get; set; }
    public string desc_maximo { get; set; }

    [JsonIgnore]
    [ForeignKey("id_empresa")]
    public virtual EmpresaModel EmpresaModel { get; set; }

    [JsonIgnore]
    [ForeignKey("id_fabricante")]
    public virtual PessoaModel PessoaModel { get; set; }

    [JsonIgnore]
    [ForeignKey("id_produto_grupo")]
    public virtual ProdutoGrupoModel ProdutoGrupoModel { get; set; }
}

Return:

Ineedtogroupbysale

    
asked by anonymous 05.07.2018 / 00:40

2 answers

1
___ erkimt ___ doubts with linq to sql ______ qstntxt ___

Personal I have two tables, sale and sale Items: Sale:

//Inner Join entre a tabela de Venda e Itens da venda
var joinVendaItemVenda = context.VendaModel.Join(context.VendaItensModel,
                                             venda => venda.id_venda,
                                             itemVenda => itemVenda.id_venda,
                                             (venda, itemVenda) => new
                                             {
                                                Venda = new 
                                                {
                                                    venda.dt_venda,
                                                    venda.forma_pgto,
                                                    venda.id_cliente,
                                                    venda.id_empresa,
                                                    venda.id_venda,
                                                    venda.id_vendedor,
                                                    venda.parcelas,
                                                    venda.perc_desc,
                                                    venda.tipo,
                                                    venda.vlr_desc,
                                                    venda.vlr_liq,
                                                    venda.vlr_total
                                                },

                                                VendaItem = new
                                                {
                                                    itemVenda.id_venda_itens,
                                                    itemVenda.id_venda,
                                                    itemVenda.id_empresa,
                                                    itemVenda.id_produto,
                                                    itemVenda.qtde,
                                                    itemVenda.preco_venda,
                                                    itemVenda.total_item
                                                }
                                             })
                                        .Where(w => w.id_empresa == idEmpresa
                                                 && w.dt_venda >= rDtInicio
                                                 && w.dt_venda <= rDFim
                                                 && w.tipo == tipo);

//Inner Join entre as tabelas anteriores e a tabela pessoa (referente ao cliente)                                                    
var joinVendaCliente = joinVendaItemVenda.Join(context.Pessoa,
                                               venda => venda.Venda.id_cliente,
                                               cliente => cliente.id_pessoa,
                                               (venda, cliente) => new
                                               {
                                                    Venda = new 
                                                    {
                                                        venda.dt_venda,
                                                        venda.forma_pgto,
                                                        venda.id_cliente,
                                                        venda.id_empresa,
                                                        venda.id_venda,
                                                        venda.id_vendedor,
                                                        venda.parcelas,
                                                        venda.perc_desc,
                                                        venda.tipo,
                                                        venda.vlr_desc,
                                                        venda.vlr_liq,
                                                        venda.vlr_total,
                                                        Cliente = cliente.razao
                                                    },
                                                    VendaItem = venda.VendaItem,
                                                    //Cliente = cliente.razao
                                               });

//Inner join entre as tabelas anteriores e a tabela pessoa (referente ao vendedor)                                                 
var joinVendaVendedor = joinVendaCliente.Join(context.Pessoa,
                                              venda => venda.Venda.id_vendedor,
                                              vendedor => vendedor.id_pessoa,
                                              (venda, vendedor) => new
                                              {
                                                  Venda = new 
                                                  {
                                                      venda.dt_venda,
                                                      venda.forma_pgto,
                                                      venda.id_cliente,
                                                      venda.id_empresa,
                                                      venda.id_venda,
                                                      venda.id_vendedor,
                                                      venda.parcelas,
                                                      venda.perc_desc,
                                                      venda.tipo,
                                                      venda.vlr_desc,
                                                      venda.vlr_liq,
                                                      venda.vlr_total,
                                                      venda.Cliente,
                                                      Vendedor = vendedor.razao
                                                  },
                                                  VendaItem = venda.VendaItem
                                              });

//Inner join entre as tabelas anteriores e a tabela produto
var retorno = joinVendaVendedor.Join(context.Produto,
                                     venda => venda.VendaItem.id_produto,
                                     produto => produto.id_produto,
                                     (venda, produto) => new
                                     {
                                        Venda = new 
                                        {
                                            venda.dt_venda,
                                            venda.forma_pgto,
                                            venda.id_cliente,
                                            venda.id_empresa,
                                            venda.id_venda,
                                            venda.id_vendedor,
                                            venda.parcelas,
                                            venda.perc_desc,
                                            venda.tipo,
                                            venda.vlr_desc,
                                            venda.vlr_liq,
                                            venda.vlr_total,
                                            venda.Cliente,
                                            venda.Vendedor
                                        },
                                        VendaItem = venda.VendaItem,
                                        Produto = new
                                        {
                                            //Aqui estamos pegando o nome do produto, mas caso precise de mais algum campo é so informa-lo abaixo do nome
                                            produto.nome
                                        }
                                     })
                               .GroupBy(a => a.Venda)
                               .Select(s => new 
                               {
                                    Venda = s.Key,
                                    ItensVenda = s.Select(a => a.VendaItem),
                                    Produto = s.Select(a => a.Produto)
                               })
                               .ToList();

Sale Items:

//Inner Join entre a tabela de Venda e Itens da venda
var joinVendaItemVenda = context.VendaModel.Join(context.VendaItensModel,
                                             venda => venda.id_venda,
                                             itemVenda => itemVenda.id_venda,
                                             (venda, itemVenda) => new
                                             {
                                                Venda = new 
                                                {
                                                    venda.dt_venda,
                                                    venda.forma_pgto,
                                                    venda.id_cliente,
                                                    venda.id_empresa,
                                                    venda.id_venda,
                                                    venda.id_vendedor,
                                                    venda.parcelas,
                                                    venda.perc_desc,
                                                    venda.tipo,
                                                    venda.vlr_desc,
                                                    venda.vlr_liq,
                                                    venda.vlr_total
                                                },

                                                VendaItem = new
                                                {
                                                    itemVenda.id_venda_itens,
                                                    itemVenda.id_venda,
                                                    itemVenda.id_empresa,
                                                    itemVenda.id_produto,
                                                    itemVenda.qtde,
                                                    itemVenda.preco_venda,
                                                    itemVenda.total_item
                                                }
                                             })
                                        .Where(w => w.id_empresa == idEmpresa
                                                 && w.dt_venda >= rDtInicio
                                                 && w.dt_venda <= rDFim
                                                 && w.tipo == tipo);

//Inner Join entre as tabelas anteriores e a tabela pessoa (referente ao cliente)                                                    
var joinVendaCliente = joinVendaItemVenda.Join(context.Pessoa,
                                               venda => venda.Venda.id_cliente,
                                               cliente => cliente.id_pessoa,
                                               (venda, cliente) => new
                                               {
                                                    Venda = new 
                                                    {
                                                        venda.dt_venda,
                                                        venda.forma_pgto,
                                                        venda.id_cliente,
                                                        venda.id_empresa,
                                                        venda.id_venda,
                                                        venda.id_vendedor,
                                                        venda.parcelas,
                                                        venda.perc_desc,
                                                        venda.tipo,
                                                        venda.vlr_desc,
                                                        venda.vlr_liq,
                                                        venda.vlr_total,
                                                        Cliente = cliente.razao
                                                    },
                                                    VendaItem = venda.VendaItem,
                                                    //Cliente = cliente.razao
                                               });

//Inner join entre as tabelas anteriores e a tabela pessoa (referente ao vendedor)                                                 
var joinVendaVendedor = joinVendaCliente.Join(context.Pessoa,
                                              venda => venda.Venda.id_vendedor,
                                              vendedor => vendedor.id_pessoa,
                                              (venda, vendedor) => new
                                              {
                                                  Venda = new 
                                                  {
                                                      venda.dt_venda,
                                                      venda.forma_pgto,
                                                      venda.id_cliente,
                                                      venda.id_empresa,
                                                      venda.id_venda,
                                                      venda.id_vendedor,
                                                      venda.parcelas,
                                                      venda.perc_desc,
                                                      venda.tipo,
                                                      venda.vlr_desc,
                                                      venda.vlr_liq,
                                                      venda.vlr_total,
                                                      venda.Cliente,
                                                      Vendedor = vendedor.razao
                                                  },
                                                  VendaItem = venda.VendaItem
                                              });

//Inner join entre as tabelas anteriores e a tabela produto
var retorno = joinVendaVendedor.Join(context.Produto,
                                     venda => venda.VendaItem.id_produto,
                                     produto => produto.id_produto,
                                     (venda, produto) => new
                                     {
                                        Venda = new 
                                        {
                                            venda.dt_venda,
                                            venda.forma_pgto,
                                            venda.id_cliente,
                                            venda.id_empresa,
                                            venda.id_venda,
                                            venda.id_vendedor,
                                            venda.parcelas,
                                            venda.perc_desc,
                                            venda.tipo,
                                            venda.vlr_desc,
                                            venda.vlr_liq,
                                            venda.vlr_total,
                                            venda.Cliente,
                                            venda.Vendedor
                                        },
                                        VendaItem = venda.VendaItem,
                                        Produto = new
                                        {
                                            //Aqui estamos pegando o nome do produto, mas caso precise de mais algum campo é so informa-lo abaixo do nome
                                            produto.nome
                                        }
                                     })
                               .GroupBy(a => a.Venda)
                               .Select(s => new 
                               {
                                    Venda = s.Key,
                                    ItensVenda = s.Select(a => a.VendaItem),
                                    Produto = s.Select(a => a.Produto)
                               })
                               .ToList();

With the query linq below (I am using this way to search the fields I want, if I do an object search, there are fields that I do not need), I'm looking for sales, but I need to modify the code to search the sales items:

%pre%

How could I do to bring the items of each sale, my view expects a Json with the sale and its items, more or less so (in the example below I'm just illustrating, I know the json structure is not quite that way):

%pre%

The conversion to Json I know how to do, I just need to modify the Linq query, what would this query look like?

Product class

%pre%

Return:

Ineedtogroupbysale

    
_________azszpr312080

I'm going to modify the query to stay in LINQ structure with Lambda expression beauty?

Try using the following code snippet (I did based on your example):

%pre%

Any questions are available.

    
______ azszpr312722 ___

I was able to resolve it as follows:

%pre%

}

    
___
05.07.2018 / 02:11
0

I was able to resolve it as follows:

 using (var context = new ClassContexto(ClassMaster.conexao()))
                {


                    var arrvendas = context.VendaModel.Where(w => w.id_empresa == idEmpresa
                                                                  && w.dt_venda >= rDtInicio
                                                                  && w.dt_venda <= rDtFim)
                                                      .Select(i => new
                                                      {
                                                          i.ClienteModel.id_pessoa,
                                                          cliente = i.ClienteModel.razao,
                                                          vendedor = i.VendedorModel.razao,
                                                          i.dt_venda,
                                                          i.forma_pgto,
                                                          i.id_cliente,
                                                          i.id_empresa,
                                                          i.id_venda,
                                                          i.id_vendedor,
                                                          i.parcelas,
                                                          i.perc_desc,
                                                          i.tipo,
                                                          i.vlr_desc,
                                                          i.vlr_liq,
                                                          i.vlr_total,
                                                          n = i.VendaItensModel.Select(
                                                              o => new
                                                              {
                                                                  o.preco_venda,
                                                                  o.qtde,
                                                                  o.ProdutoModel.nome,
                                                                  o.id_produto,
                                                                  o.id_venda,
                                                                  o.id_venda_itens,
                                                                  o.total_item
                                                              }).ToList()

                                                      }).ToList();

}

    
07.07.2018 / 21:50