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);
}
public void Carregar(List <RamalEstoque> ramais)
{
foreach (var ramal in ramais)
{
_repositorio.Inserir(ramal);
//_colecao.InsertOne(ramal);
}
}
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);
}
}
public void InserirItem(ItemTubulacaoEstoque itemTubulacaoEstoque)
{
_repositorio.Inserir(itemTubulacaoEstoque);
//_colecao.InsertOne(itemTubulacaoEstoque);
}
public void CriaFamilias(string guidCatalogo)
{
var familiasRepositorio = new BaseMDBRepositorio <Familia>("Catalogo", "Familias");
var relacaoFamiliaItemRepositorio = new BaseMDBRepositorio <RelacaoFamiliaItem>("Catalogo", "RelacaoFamiliaItem");
var itemPipeRepositorio = new BaseMDBRepositorio <ItemPipe>("Catalogo", "ItemPipe");
var categoriasRepositorio = new BaseMDBRepositorio <Categoria>("Catalogo", "Categorias");
var filtroCategorias = Builders <Categoria> .Filter.Eq(x => x.GUID_CATALOGO, guidCatalogo);
var categorias = categoriasRepositorio.Encontrar(filtroCategorias);
foreach (var categoria in categorias)
{
var builderItemPipe = Builders <ItemPipe> .Filter;
var filterItemPipeEstoque = builderItemPipe.Eq(x => x.GUID_CATALOGO, guidCatalogo) & builderItemPipe.Eq(x => x.GUID_TIPO_ITEM, categoria.GUID_TIPO);
var itens = itemPipeRepositorio.Encontrar(filterItemPipeEstoque);
var relacaoPropriedadeItemRepositorio = new BaseMDBRepositorio <RelacaoPropriedadeItem>("Catalogo", "RelacaoPropriedadeItem");
var propriedadeItemRepositorio = new BaseMDBRepositorio <PropriedadeItem>("Catalogo", "PropriedadeItem");
foreach (var item in itens)
{
var filtroRelacaoPropriedadeItem = Builders <RelacaoPropriedadeItem> .Filter.Eq(x => x.GUID_ITEM_ENG, item.GUID);
var relacoes = relacaoPropriedadeItemRepositorio.Encontrar(filtroRelacaoPropriedadeItem);
var builderFamilias = Builders <Familia> .Filter;
var filterFamilias = builderFamilias.Eq(x => x.GUID_CATALOGO, guidCatalogo)
& builderFamilias.Eq(x => x.GUID_CATEGORIA, categoria.GUID);
var familias = familiasRepositorio.Encontrar(filterFamilias);
Familia familia = null;
if (familias.Count() == 0)
{
familia = new Familia(guidCatalogo, categoria.GUID);
foreach (var relacao in relacoes)
{
var filtroPropriedadeItem = Builders <PropriedadeItem> .Filter.Eq(x => x.GUID, relacao.GUID_PROPRIEDADE);
var propriedadeItem = propriedadeItemRepositorio.Encontrar(filtroPropriedadeItem).First();
var nomeTipoPropriedadeRepositorio = new BaseMDBRepositorio <NomeTipoPropriedade>("Catalogo", "NomeTipoPropriedade");
var builderNomeTipoPropriedade = Builders <NomeTipoPropriedade> .Filter;
var filtroNomeTipoPropriedade = builderNomeTipoPropriedade.Eq(x => x.GUID, propriedadeItem.GUID_TIPO)
& builderNomeTipoPropriedade.Eq(x => x.NOME, "PartFamilyLongDesc");
var propriedades = nomeTipoPropriedadeRepositorio.Encontrar(filtroNomeTipoPropriedade);
if (propriedades.Count() > 0)
{
var strPropriedade = propriedades.First().NOME;
if (strPropriedade == "PartFamilyLongDesc")
{
var valorTabeladoRepositorio = new BaseMDBRepositorio <ValorTabelado>("Catalogo", "ValorTabelado");
var filtroValorTabelado = Builders <ValorTabelado> .Filter.Eq(x => x.GUID, propriedadeItem.GUID_VALOR);
var valor = valorTabeladoRepositorio.Encontrar(filtroValorTabelado).First();
string strValor = valor.VALOR.Replace('"', '¨');
familia.GetType().GetProperty(strPropriedade).SetValue(familia, strValor);
break;
}
}
}
familiasRepositorio.Inserir(familia);
}
else
{
familia = familias.First();
}
RelacaoFamiliaItem relacaoFamiliaItem = new RelacaoFamiliaItem()
{
GUID_FAMILIA = familia.GUID,
GUID_ITEM = item.GUID,
GUID_CATEGORIA = categoria.GUID
};
relacaoFamiliaItemRepositorio.Inserir(relacaoFamiliaItem);
}
}
}
private void DefineCatalogo(string nomeCatalogo)
{
//Catalogo catalogo = null;
var catalogosMDBRepositorio = new BaseMDBRepositorio <Catalogo>("Catalogo", "Catalogo");
//using (var repositorioCatalogo = new Repositorio<CatalogoPlant3d>(_conexao))
//{
var catalogos = catalogosMDBRepositorio
.Encontrar(Builders <Catalogo> .Filter.Eq(x => x.NOME, nomeCatalogo));
//repositorioCatalogo.Find(x => x.NOME == nomeCatalogo);
if (catalogos.Count == 0)
{
string guidIdioma = string.Empty;
var idiomaMDBRepositorio = new BaseMDBRepositorio <Idioma>("Catalogo", "Idioma");
var builder = Builders <Idioma> .Filter;
var filter = builder.Eq(x => x.IDIOMA, _idioma) & builder.Eq(x => x.PAIS, _pais);
var idiomas = idiomaMDBRepositorio.Encontrar(filter);
if (idiomas.Count == 0)
{
guidIdioma = Guid.NewGuid().ToString();
var idioma = new Idioma()
{
IDIOMA = _idioma,
PAIS = _pais
};
idiomaMDBRepositorio.Inserir(idioma);
}
else
{
guidIdioma = idiomas.First().GUID;
}
_catalogo = new Catalogo()
{
NOME = nomeCatalogo,
GUID_IDIOMA = guidIdioma
};
catalogosMDBRepositorio.Inserir(_catalogo);
}
else
{
_catalogo = catalogos.First();
}
//}
//return _catalogo;
}
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);
}
}
}
}
}
}
//}
}