示例#1
0
        public List <RamalEstoque> ExtraiArvoreEstoque()
        {
            //_itemEngenhariaService = new ItemEngenhariaService();

            var catalogoRepositorio = new BaseMDBRepositorio <Catalogo>("Catalogo", "Catalogo");

            var catalogos = catalogoRepositorio.Obter(); //_itemEngenhariaService.ObterCatalogos();


            var ramais = new List <RamalEstoque>();

            foreach (var catalogo in catalogos)
            {
                ramais.Add(new RamalEstoque(catalogo.NOME, catalogo.GUID, string.Empty));
            }

            ramais = ramais.OrderBy(x => x.name).ToList();

            foreach (var ramalCatalogo in ramais)
            {
                adicionaRamalCategoria(ramalCatalogo.guid, ramais);
            }

            var ramalEstoqueRepositorio = new BaseMDBRepositorio <RamalEstoque>("Catalogo", "RamalEstoque");

            ramalEstoqueRepositorio.Inserir(ramais);

            return(ramais);
        }
示例#2
0
        public void Injetar(string catalogoGUID)
        {
            var tipoItemEngRepositorio = new BaseMDBRepositorio <TipoItemEng>("Catalogo", "TipoItemEng");

            var tipos = tipoItemEngRepositorio.Obter();

            var categoriaRepositorio = new BaseMDBRepositorio <Categoria>("Catalogo", "Categorias");

            foreach (var tipo in tipos)
            {
                Categoria categoria = new Categoria()
                {
                    GUID_CATALOGO = catalogoGUID,
                    GUID_TIPO     = tipo.GUID
                };

                categoriaRepositorio.Inserir(categoria);
            }
        }
示例#3
0
 public List <RamalEstoque> Listar()
 {
     return(_repositorio.Obter()); //_colecao.AsQueryable().ToList();
 }
示例#4
0
        public List <NomeTipoPropriedade> ExtraiNomes()
        {
            var propriedadesRepositorio = new BaseMDBRepositorio <NomeTipoPropriedade>("Catalogo", "NomeTipoPropriedade");

            return(propriedadesRepositorio.Obter()); //_itemEngenhariaService.ObterCatalogos();
        }
示例#5
0
        public void Injetar()
        {
            var itensEngenhariaP3D = capturarItensEngenhariaPlant3d();


            //for (int i = 1; i <= itensEngenhariaP3D.Count(); i++)
            //{



            var itemPipeEstoqueRepositorio = new BaseMDBRepositorio <ItemPipe>("Catalogo", "ItemPipe");

            int conta = itemPipeEstoqueRepositorio.Obter().Count();

            if (conta < itensEngenhariaP3D.Count())
            {
                foreach (var item in itensEngenhariaP3D)
                {
                    var builder = Builders <ItemPipe> .Filter;
                    var filterItemPipeEstoque = builder.Eq(x => x.PnPID, (int)item.PnPID) & builder.Eq(x => x.GUID_CATALOGO, _catalogo.GUID);
                    var itensPipeEstoque      = itemPipeEstoqueRepositorio.Encontrar(filterItemPipeEstoque);



                    if (itensPipeEstoque.Count == 0)
                    {
                        TipoItemEng tipoItem    = null;
                        string      tipoItemEng = item.ShortDescription.Split(',')[0];



                        var tipoItemPipeStockRepositorio = new BaseMDBRepositorio <TipoItemEng>("Catalogo", "TipoItemEng");

                        var filterTiposItem = Builders <TipoItemEng> .Filter.Eq(x => x.NOME, tipoItemEng);

                        var tipos = tipoItemPipeStockRepositorio.Encontrar(filterTiposItem);



                        if (tipos.Count == 0)
                        {
                            tipoItem = new TipoItemEng()
                            {
                                NOME = tipoItemEng
                            };

                            tipoItemPipeStockRepositorio.Inserir(tipoItem);
                        }
                        else
                        {
                            tipoItem = tipos.First();
                        }


                        var itemPipe = new ItemPipe()
                        {
                            GUID_TIPO_ITEM = tipoItem.GUID,
                            GUID_CATALOGO  = _catalogo.GUID,
                            PnPID          = (int)item.PnPID
                        };

                        itemPipeEstoqueRepositorio.Inserir(itemPipe);

                        Type type = item.GetType();

                        foreach (var info in type.GetProperties())
                        {
                            if (info.Name != "GUID" && info.Name != "CODIGO" && info.Name != "PnPID")
                            {
                                NomeTipoPropriedade nomeTipoPropriedade = null;


                                var nomeTipoPropriedadeRepositorio = new BaseMDBRepositorio <NomeTipoPropriedade>("Catalogo", "NomeTipoPropriedade");
                                var filterNomeTipoPropriedade      = Builders <NomeTipoPropriedade> .Filter.Eq(x => x.NOME, info.Name);

                                var nomesTiposPropriedade = nomeTipoPropriedadeRepositorio.Encontrar(filterNomeTipoPropriedade);



                                if (nomesTiposPropriedade.Count == 0)
                                {
                                    nomeTipoPropriedade = new NomeTipoPropriedade()
                                    {
                                        NOME = info.Name
                                    };

                                    nomeTipoPropriedadeRepositorio.Inserir(nomeTipoPropriedade);
                                }
                                else
                                {
                                    nomeTipoPropriedade = nomesTiposPropriedade.First();
                                }



                                var relacaoEntrePropriedadesRepositorio = new BaseMDBRepositorio <RelacaoEntrePropriedades>("Catalogo", "RelacaoEntrePropriedades");
                                var builderRelacaoEntrePropriedades     = Builders <RelacaoEntrePropriedades> .Filter;
                                var filtroRelacaoEntrePropriedades      = builderRelacaoEntrePropriedades
                                                                          .Eq(x => x.GUID_PNPTABLE, tipoItem.GUID)
                                                                          &
                                                                          builderRelacaoEntrePropriedades
                                                                          .Eq(x => x.GUID_PROPIEDADE, nomeTipoPropriedade.GUID);

                                var relacoes = relacaoEntrePropriedadesRepositorio.Encontrar(filtroRelacaoEntrePropriedades);


                                if (relacoes.Count == 0)
                                {
                                    var relacao = new RelacaoEntrePropriedades()
                                    {
                                        GUID_PNPTABLE   = tipoItem.GUID,
                                        GUID_PROPIEDADE = nomeTipoPropriedade.GUID
                                    };

                                    relacaoEntrePropriedadesRepositorio.Inserir(relacao);
                                }



                                PropertyInfo campo = type.GetProperty(info.Name);
                                var          valor = info.GetValue(item, null);

                                if (valor != null)
                                {
                                    var valorTabeladoRepositorio = new BaseMDBRepositorio <ValorTabelado>("Catalogo", "ValorTabelado");
                                    var filterValorTabelado      = Builders <ValorTabelado> .Filter.Eq(x => x.VALOR, valor.ToString());

                                    var valoresTabelados = valorTabeladoRepositorio.Encontrar(filterValorTabelado);


                                    ValorTabelado valorTabelado = null;

                                    if (valoresTabelados.Count == 0)
                                    {
                                        valorTabelado = new ValorTabelado()
                                        {
                                            VALOR       = valor.ToString(),
                                            Sigla_BRASS = ""
                                        };

                                        valorTabeladoRepositorio.Inserir(valorTabelado);
                                    }
                                    else
                                    {
                                        valorTabelado = valoresTabelados.First();
                                    }


                                    if (nomeTipoPropriedade.NOME == "PartCategory")
                                    {
                                        ItemPipe itemCategoria = null;
                                        var      builderItem   = Builders <ItemPipe> .Filter;
                                        var      filterItem    = builderItem.Eq(x => x.GUID, valorTabelado.GUID)
                                                                 & builderItem.Eq(x => x.GUID_CATALOGO, _catalogo.GUID);
                                        var itens = itemPipeEstoqueRepositorio.Encontrar(filterItem);

                                        if (itens.Count == 0)
                                        {
                                            itemCategoria = new ItemPipe()
                                            {
                                                GUID_TIPO_ITEM = nomeTipoPropriedade.GUID,
                                                GUID_CATALOGO  = _catalogo.GUID,
                                                PnPID          = 0,
                                                GUID_ITEM_PAI  = _catalogo.GUID
                                            };

                                            itemPipeEstoqueRepositorio.Inserir(itemCategoria);
                                        }
                                        else
                                        {
                                            itemCategoria = itens.First();
                                        }

                                        itemPipe.GUID_ITEM_PAI = itemCategoria.GUID;


                                        itemPipeEstoqueRepositorio.Atualizar(itemPipe);
                                    }



                                    PropriedadeItem propriedadeEng = null;

                                    var propriedadeRepositorio = new BaseMDBRepositorio <PropriedadeItem>("Catalogo", "PropriedadeItem");
                                    var builderPropriedade     = Builders <PropriedadeItem> .Filter;
                                    var filterPropriedade      =
                                        builderPropriedade.Eq(x => x.GUID_TIPO, nomeTipoPropriedade.GUID)
                                        & builderPropriedade.Eq(x => x.GUID_VALOR, valorTabelado.GUID);
                                    var propriedades = propriedadeRepositorio.Encontrar(filterPropriedade);

                                    if (propriedades.Count == 0)
                                    {
                                        propriedadeEng = new PropriedadeItem()
                                        {
                                            GUID_TIPO  = nomeTipoPropriedade.GUID,
                                            GUID_VALOR = valorTabelado.GUID
                                        };

                                        propriedadeRepositorio.Inserir(propriedadeEng);
                                    }
                                    else
                                    {
                                        propriedadeEng = propriedades.First();
                                    }


                                    var relacaoPropriedadeItemRepositorio =
                                        new BaseMDBRepositorio <RelacaoPropriedadeItem>("Catalogo", "RelacaoPropriedadeItem");


                                    var relacaoPropriedadeItem = new RelacaoPropriedadeItem()
                                    {
                                        GUID_ITEM_ENG    = itemPipe.GUID,
                                        GUID_PROPRIEDADE = propriedadeEng.GUID
                                    };


                                    relacaoPropriedadeItemRepositorio.Inserir(relacaoPropriedadeItem);
                                }
                            }
                        }
                    }
                }
            }


            //}
        }