public void AttachPart(TipoItem cribPart)
{
switch (cribPart)
{
case TipoItem.motor:
hasMotor = true;
PutMotor();
Debug.Log("Got Motor");
break;
case TipoItem.combustivel:
hasFuel = true;
PutCombustivel();
Debug.Log("Got Fuel");
break;
case TipoItem.espelho:
hasMirror = true;
PutEspelho();
Debug.Log("Got Mirror");
break;
default:
Debug.Log("Error, not supported part");
break;
}
audioSource.PlayOneShot(attachFx);
}
public async Task <IActionResult> PutTipoItem([FromRoute] string id, [FromBody] TipoItem tipoItem)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != tipoItem.Tipo)
{
return(BadRequest());
}
_context.Entry(tipoItem).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TipoItemExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void GetPart(TipoItem part)
{
switch (part)
{
case TipoItem.motor:
Debug.Log("Motor");
m_gotMotor = true;
break;
case TipoItem.combustivel:
Debug.Log("fuel");
m_gotFuel = true;
break;
case TipoItem.espelho:
Debug.Log("mirror");
m_gotMirror = true;
break;
default:
Debug.Log("Erro! Objeto não é uma parte da nave!");
break;
}
}
//Chama GetTipo e retorna o Tipo do Item
public static VerificadorDeAtualizacoes InstanciaTipoItem(Item item)
{
TipoItem tipoItem = GetTipo(item);
if (tipoItem == TipoItem.QueijoBrie)
{
return(new AtualizarQualidadeQueijoBrie());
}
else if (tipoItem == TipoItem.Ingressos)
{
return(new AtualizarQualidadeIngressos());
}
else if (tipoItem == TipoItem.ItemComum)
{
return(new AtualizarQualidadeItemComum());
}
else if (tipoItem == TipoItem.Lendario)
{
return(new AtualizarQualidadeLendario());
}
else if (tipoItem == TipoItem.Conjurado)
{
return(new AtualizarQualidadeConjurado());
}
else
{
return(new VerificadorDeAtualizacoes());
}
}
public TipoItemCollection ConsultaPorDescricao(string Descricao)
{
try
{
//Limpa e adiciona os parâmetros
acessoDadosSqlServer.LimparParametros();
acessoDadosSqlServer.AdicionarParametros("@TipoProcedure", "Descricao");
acessoDadosSqlServer.AdicionarParametros("@TipoItemID", "");
acessoDadosSqlServer.AdicionarParametros("@TipoItemDescricao", Descricao);
//Cria uma DataTable pois a store procedure returna uma tabela de dados
DataTable dataTable = acessoDadosSqlServer.ExecutarConsulta(CommandType.StoredProcedure, "uspConsultaTipoItem");
TipoItemCollection tipoItemCollection = new TipoItemCollection();
foreach (DataRow row in dataTable.Rows)
{
TipoItem tipoItem = new TipoItem();
tipoItem.TipoItemID = Convert.ToInt32(row["TipoItemID"]);
tipoItem.TipoItemDescricao = row["TipoItemDescricao"].ToString();
tipoItemCollection.Add(tipoItem);
}
return(tipoItemCollection);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public ActionResult DeleteConfirmed(int id)
{
TipoItem tipoItem = db.TipoItems.Find(id);
db.TipoItems.Remove(tipoItem);
db.SaveChanges();
return(RedirectToAction("Index"));
}
private void ActionNave(SpaceCrib nave)
{
if (cribPart != TipoItem.vazio)
{
nave.AttachPart(cribPart);
cribPart = TipoItem.vazio;
}
}
public ActionResult Edit([Bind(Include = "TipoItemID,Nome")] TipoItem tipoItem)
{
if (ModelState.IsValid)
{
db.Entry(tipoItem).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tipoItem));
}
public void PegarPart(PickupItem item)
{
if (cribPart == TipoItem.vazio)
{
// Debug.Log("Peguei uma peça carai");
cribPart = item.Item;
item.BeTaken();
teleportBaloon.enabled = true;
}
}
public void ItemsController_AgrearItemAProyecto()
{
HelperTestSistema.LimpiarArchivoBD();
HelperTestSistema.IniciarServidor();
//Creamos un proyecto y lo guardamos directamente en la base de datos
var proyecto = HelperInstanciacionProyectos.GetProyectos(1)[0];
using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
{
contexto.ContenedorObjetos.Store(proyecto);
}
//Instanciamos un nuevo item y lo agregamos al proyecto
Item nuevoItem = new Item(
"Item test", "Descripcion item test",
new TipoItem("Tipo 1", "Tipo 1 test"),
new Prioridad("Prioridad 1", "Prioridad de prueba"));
var controller = new ItemsController(HelperTestSistema.ObjectFactory);
controller.Post("P1", nuevoItem);
//Obtenemos los datos de la BD para validarlos
var proyectosBD = new List <Proyecto>();
var tipoItem = new TipoItem();
var prioridad = new Prioridad("", "");
using (IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory))
{
proyectosBD = (from Proyecto p in contexto.ContenedorObjetos select p).ToList();
prioridad = (from Prioridad p in contexto.ContenedorObjetos select p).SingleOrDefault();
tipoItem = (from TipoItem ti in contexto.ContenedorObjetos select ti).SingleOrDefault();
}
HelperTestSistema.ReiniciarConexion();
HelperTestSistema.FinalizarServidor();
//Asserts
Assert.Inconclusive("Refactorizar y terminar este test");
//Tiene que haber un solo proyecto en la BD
Assert.AreEqual(1, proyectosBD.Count);
//El proyecto debe tener un item
Assert.AreEqual(1, proyectosBD[0].Items.Count());
//El item debe tener el nombre y la descripcion correcta
Assert.AreEqual("Descripcion item test", proyectosBD[0].Items.ToList()[0].Descripcion);
//El item debe tener la prioridad correcta
Assert.AreSame(prioridad, proyectosBD[0].Items.ToList()[0].Prioridad);
Assert.AreEqual("Prioridad 1", proyectosBD[0].Items.ToList()[0].Prioridad.Nombre);
//El item debe tener asignado el tipo de item correcto
Assert.AreSame(tipoItem, proyectosBD[0].Items.ToList()[0].TipoItem);
Assert.AreEqual("Tipo 1", proyectosBD[0].Items.ToList()[0].TipoItem.Nombre);
}
public ActionResult Create([Bind(Include = "TipoItemID,Nome")] TipoItem tipoItem)
{
if (ModelState.IsValid)
{
db.TipoItems.Add(tipoItem);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(tipoItem));
}
public void PegarPart(PickupItem item)
{
if (cribPart == TipoItem.vazio)
{
Debug.Log("Player tem espaço");
// Debug.Log("Peguei uma peça carai");
cribPart = item.Item;
item.BeTaken();
teleportBaloon.SetActive(true);
}
}
public async Task <IActionResult> PostTipoItem([FromBody] TipoItem tipoItem)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.TipoItem.Add(tipoItem);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTipoItem", new { id = tipoItem.Tipo }, tipoItem));
}
public Cliente(int id,Int32 dni, string nombre, string apellido, string direccion, Int32 telefono, string mail, string fecha_nacimiento, TipoItem item)
{
this.clienteId = id;
this.Dni = dni;
this.Nombre = nombre;
this.Apellido = apellido;
this.Direccion = direccion;
this.Telefono = telefono;
this.Mail = mail;
this.Fecha_nacimiento = fecha_nacimiento;
this.item = item;
}
public async Task <ActionResult> Get(TipoItem tipoItem)
{
try
{
var itemsByTipo = await _repo.GetAllItemByTypeAsync(tipoItem);
var results = _mapper.Map <IEnumerable <ItemDTO> >(itemsByTipo);
return(Ok(results));
}
catch (System.Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Banco de dados falhou"));
}
}
public FormularioItem(TipoItem tipoCampo, HtmlHelper hh)
{
nome = "teste";
tipo = tipoCampo;
htmlHelper = hh;
section = new TagBuilder("section");
label = new TagBuilder("label");
labelInput = new TagBuilder("label");
input = new TagBuilder("input");
iconeTag = new TagBuilder("i");
tooltipTag = new TagBuilder("b");
erro = new TagBuilder("em");
atrbutosExtras = new Dictionary <string, object>();
}
// GET: TipoItens/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TipoItem tipoItem = db.TipoItems.Find(id);
if (tipoItem == null)
{
return(HttpNotFound());
}
return(View(tipoItem));
}
public static List <TipoItem> GetTiposDeItem(string nombreProyecto, int cantidad)
{
List <TipoItem> resultado = new List <TipoItem>();
for (int i = 1; i <= cantidad; i++)
{
TipoItem p = new TipoItem();
p.Nombre = String.Concat("Tipo de item ", i);
p.Descripcion = String.Concat(nombreProyecto, "-", "Tipo de item de prueba ", i);
resultado.Add(p);
}
return(resultado);
}
/// <summary>
/// Inicializa este control para mostrar el tipo de item al que se le asocia
/// </summary>
/// <param name="_tipoItem"></param>
/// <param name="_posicionOrigen"></param>
public void Inicializar(TipoItem _tipoItem, Vector2 _posicionOrigen)
{
ObtenerReferencias();
/*
* // reposicionar los items a comprar
* for (int i = 0; i < m_cntCompraItem.Length; ++i) {
* Vector3 posicion = m_cntCompraItem[i].transform.localPosition;
* m_cntCompraItem[i].transform.localPosition = new Vector3(_posicionOrigen.x + (i * SEPARACION_X_ENTRE_ITEMS), _posicionOrigen.y, 0.0f);
* }
*/
// mostrar la pagina
ShowPagina(m_numPaginaActual, _tipoItem);
}
public bool AttachPart(TipoItem cribPart)
{
bool resposta = false;
Debug.Log("Objeto é um:" + cribPart);
switch (cribPart)
{
case TipoItem.motor:
hasMotor = true;
PutMotor();
Debug.Log("Got Motor");
resposta = true;
break;
case TipoItem.combustivel:
hasFuel = true;
PutCombustivel();
Debug.Log("Got Fuel");
resposta = true;
break;
case TipoItem.espelho:
hasMirror = true;
PutEspelho();
Debug.Log("Got Mirror");
resposta = true;
break;
default:
Debug.Log("Error, not supported part");
resposta = false;
break;
}
if (resposta)
{
audioSource.PlayOneShot(attachFx);
}
else
{
Debug.Log("Como resposta é falsa");
audioSource.PlayOneShot(failFix);
}
return(resposta);
}
public async Task <Item[]> GetAllItemByTypeAsync(TipoItem type)
{
var itemsByType = await _context.Items
.Where(i => i.TipoItemId == type.Id)
.OrderBy(i => i.TipoItemId)
.ToArrayAsync();
foreach (Item item in itemsByType)
{
item.AuctionItems = await _context.AuctionItems
.Where(ai => ai.ItemId == item.Id)
.ToListAsync();
}
return(itemsByType);
}
public static List <TipoItem> GetTiposItemParaProyecto(Proyecto proyecto, int cantidad)
{
List <TipoItem> resultado = new List <TipoItem>();
for (int i = 1; i <= cantidad; i++)
{
TipoItem tipoItem = new TipoItem
(
String.Concat("I", i, proyecto.Codigo),
String.Concat("item ", i, " del ", proyecto.Codigo)
);
resultado.Add(tipoItem);
}
return(resultado);
}
/// <summary>
/// este método cria o item de acordo com o tipo definido pelo GUID
/// </summary>
/// <param name="tipo">Tipo de item que deverá ser criado</param>
/// <returns>Cria o item de acordo com o tipo</returns>
public static ItemBase Create(TipoItem tipo)
{
ItemBase item = null;
//TODO André: por enquanto está retornando somente o produto acabado, em breve teremos outros tipos
if(tipo.Is(TipoItem.Acabado))
item = new Data.Cadastro.Item.Produto.Acabado();
else if(tipo.Is(TipoItem.MateriaPrima))
item = new Data.Cadastro.Item.Produto.MateriaPrima();
else if(tipo.Is(TipoItem.Servico))
item = new Data.Cadastro.Item.Servico();
else
throw new NotImplementedException(String.Format("O tipo de item \"{0}\" não foi implementado.", Convert.ToString(tipo)));
item.TipoItem = tipo;
return item;
}
private string GetItemName(TipoItem value)
{
var itemInfo = value.GetType().GetMember(value.ToString());
if (itemInfo.Length != 1)
{
return(null);
}
var displayAttribute = itemInfo[0].GetCustomAttributes(typeof(DisplayAttribute), false)
as DisplayAttribute[];
if (displayAttribute == null || displayAttribute.Length != 1)
{
return(null);
}
return(displayAttribute[0].Name);
}
public void Alterar(TipoItem tipoItem)
{
try
{
//Limpa todos os parâmetros
acessoDadosSqlServer.LimparParametros();
//Adiciona os parâmetros para chamar a store procedure
acessoDadosSqlServer.AdicionarParametros("@TipoProcedure", "Alterar");
acessoDadosSqlServer.AdicionarParametros("@TipoItemID", tipoItem.TipoItemID);
acessoDadosSqlServer.AdicionarParametros("@TipoItemDescricao", tipoItem.TipoItemDescricao);
acessoDadosSqlServer.ExecutarManipulacao(CommandType.StoredProcedure, "uspManterTipoItem");
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
private void ActionSlot(PartSlot partWanted)
{
Debug.Log("ActionSlot");
if (partWanted != null && partWanted.Tipo != TipoItem.vazio && cribPart != TipoItem.vazio)
{
SpaceCrib nave = partWanted.gameObject.GetComponentInParent <SpaceCrib>();
if (partWanted.Tipo == cribPart)
{
if (nave.AttachPart(cribPart))
{
cribPart = TipoItem.vazio;
}
}
else
{
nave.PlayFailFix();
}
}
}
/// <summary>
/// Recupera a instância que trata de um tipo específico de item.
/// </summary>
/// <param name="sessao">A transação com o banco de dados.</param>
/// <param name="apiController">O controller que está sendo executado.</param>
/// <param name="tipoItem">O tipo de item que contém uma imagem.</param>
/// <returns>Uma instância para tratamento do item solicitado.</returns>
public static IExibicao ObterParaControleExibicao(
GDASession sessao,
ApiController apiController,
TipoItem tipoItem)
{
switch (tipoItem)
{
case TipoItem.Produto:
return(new ExibicaoProdutoStrategy(sessao, apiController));
case TipoItem.PecaProducao:
return(new ExibicaoPecaProducaoStrategy(sessao, apiController));
case TipoItem.SvgProjeto:
return(new ExibicaoSvgProjetoStrategy(sessao, apiController));
case TipoItem.Funcionario:
return(new ExibicaoFuncionarioStrategy(sessao, apiController));
}
return(null);
}
/// <summary>
/// Retorna um novo produto pelo GUID, identificando o seu tipo
/// </summary>
/// <param name="guid">GUID para pesquisar o produto</param>
/// <param name="viewOnly">Se true, traz apenas os campos de base, como GUID, EGUID, Nome Fantasia e Razão Social</param>
/// <returns></returns>
public static ItemBase Create(GUID guid, TipoItem tipo, bool viewOnly = true)
{
if(GUID.IsNullOrEmpty(guid)) return null;
ItemBase result = null;
Connection connection = null;
try
{
connection = DbContext.CreateConnection();
DataReader dr = connection.ExecuteReader(String.Format("SELECT TipoItem FROM cad_Item WHERE GUID = '{0}'", guid));
if(dr.Read())
{
result = Create(tipo);
if(viewOnly)
{
dr = DbContext.GetDisplayValues(result, new Where {
{ "cad_Item.GUID", guid }
}).DataReader;
if(dr.Read())
{
result.Populate(dr.GetString("p_GUID"));
}
}
else
result.Populate(guid);
}
}
finally
{
connection.Close();
}
return result;
}
private SubItemDeItem GetSubItemDeItem(Item item, TipoItem tipoItem, string nombre, string nombreUnidad, double precio)
{
SubItemsController contSubItem = new SubItemsController();
SubItem subItem = contSubItem.SubItemByNombre(db, nombre);
if (subItem == null)
{
UnidadsController contUnidad = new UnidadsController();
Unidad unidad = contUnidad.UnidadByNombre(db, nombreUnidad);
if (unidad == null)
{
unidad = new Unidad {
ID = 0, Descripcion = "", Nombre = nombreUnidad
};
unidad = contUnidad.Insertar(db, unidad);
}
subItem = new SubItem {
ID = 0, Nombre = nombre, PrecioUnitario = precio, TipoItem = tipoItem, Unidad = unidad
};
}
//else --> actualizar precio unitario del subitem (solo sirve de referencia)
SubItemDeItemsController contSubItemDeItem = new SubItemDeItemsController();
SubItemDeItem subItemDeItem = contSubItemDeItem.SubItemDeItemByItemSubItem(db, item, subItem);
if (subItemDeItem == null)
{
subItemDeItem = new SubItemDeItem {
ID = 0, Item = item, SubItem = subItem
};
subItemDeItem = contSubItemDeItem.Insertar(db, subItemDeItem);
}
return(subItemDeItem);
}
/// <summary>
/// remove o tipo de pessoa existente e retorna o novo tipo
/// </summary>
/// <param name="tipo">tipo de pessoa</param>
/// <param name="removeValue">tipo a ser removido</param>
/// <returns>novo tipo</returns>
public static TipoItem Remove(this TipoItem tipo, TipoItem removeValue)
{
tipo = tipo -= removeValue;
return tipo;
}
/// <summary>
/// Popula os dados do item
/// </summary>
/// <param name="dataReader"></param>
public override void Populate(DataReader dataReader)
{
#region base
base.Populate(dataReader);
GrupoItem = new GrupoItem((GUID)dataReader.GetValue<string>("p_GUIDGrupoItem"));
Descricao = dataReader.GetValue<string>("p_Descricao");
TipoItem = dataReader.GetValue<TipoItem>("p_TipoItem");
SituacaoTributaria = new CSTCSOSN((GUID)dataReader.GetValue<string>("p_GUIDCSTCSOSN"));
Aliquota = new AliquotaTributo((GUID)dataReader.GetValue<string>("p_GUIDAliquota"));
Replicado = dataReader.GetBoolean("p_Replicado");
#endregion
}
/// <summary>
/// este método cria o item de acordo com o tipo definido pelo GUID
/// </summary>
/// <param name="tipo">Tipo de item que deverá ser criado</param>
/// <param name="guid">guid do item que deverá ser carregado</param>
/// <returns>Cria o item de acordo com o tipo</returns>
public static ItemBase Create(TipoItem tipo, GUID guid)
{
ItemBase item = Create(tipo);
item.Populate(guid);
return item;
}
public TipoItem Post(string codigoProyecto, TipoItem tipoItem)
{
throw new NotImplementedException();
}
public Item(TipoItem t, object i)
{
tipo = t;
item = i;
}
/// <summary>
/// Adiciona um novo tipo ao tipo de pessoa existente e retorna o novo tipo
/// </summary>
/// <param name="tipo">tipo de pessoa</param>
/// <param name="addValue">valor que deverá ser adicionado</param>
/// <returns>novo tipo</returns>
public static TipoItem Add(this TipoItem tipo, TipoItem addValue)
{
tipo = tipo | addValue;
return tipo;
}
/// <summary>
/// compara se a origem é igual ao esperado
/// </summary>
/// <param name="origin">Origem. Valor Original</param>
/// <param name="expected">Valor esperado</param>
/// <returns>true se a origem for igual ao espereado</returns>
public static bool Is(this TipoItem origin, TipoItem expected)
{
return ((origin & expected) == expected);
}
/// <summary>
/// Muestra los elementos del numero de pagina especificado
/// </summary>
/// <param name="_numPagina"></param>
/// <param name="_tipoItem"></param>
private void ShowPagina(int _numPagina, TipoItem _tipoItem)
{
// guardar el numero de pagina actual
m_numPaginaActual = _numPagina;
// calcular el numero maximo de paginas a mostrar
int numTotalPaginas = 0;
switch (_tipoItem)
{
case TipoItem.POWER_UP_LANZADOR:
numTotalPaginas = 1 + (Mathf.Max(1, PowerupInventory.descriptoresLanzador.Length - 1) / NUM_ITEMS_PAGINA);
// actualizar los elementos del container
for (int i = 0; i < NUM_ITEMS_PAGINA; ++i)
{
if ((_numPagina * NUM_ITEMS_PAGINA) + i < PowerupInventory.descriptoresLanzador.Length)
{
m_cntCompraItem[i].ShowAsPowerUp(PowerupInventory.descriptoresLanzador[(_numPagina * NUM_ITEMS_PAGINA) + i]);
}
else
{
m_cntCompraItem[i].ShowAsPowerUp(null);
}
}
break;
case TipoItem.POWER_UP_PORTERO:
numTotalPaginas = 1 + (Mathf.Max(1, PowerupInventory.descriptoresPortero.Length - 1) / NUM_ITEMS_PAGINA);
// actualizar los elementos del container
for (int i = 0; i < NUM_ITEMS_PAGINA; ++i)
{
if ((_numPagina * NUM_ITEMS_PAGINA) + i < PowerupInventory.descriptoresPortero.Length)
{
m_cntCompraItem[i].ShowAsPowerUp(PowerupInventory.descriptoresPortero[(_numPagina * NUM_ITEMS_PAGINA) + i]);
}
else
{
m_cntCompraItem[i].ShowAsPowerUp(null);
}
}
break;
case TipoItem.ESCUDO:
numTotalPaginas = 1 + (Mathf.Max(1, EscudosManager.instance.GetNumEscudos() - 1) / NUM_ITEMS_PAGINA);
// asegurarse de que la pagina actual queda dentro de rango
_numPagina = Mathf.Clamp(_numPagina, 0, numTotalPaginas);
// actualizar los elementos del container
for (int i = 0; i < NUM_ITEMS_PAGINA; ++i)
{
m_cntCompraItem[i].ShowAsEscudo(EscudosManager.instance.GetEscudo((_numPagina * NUM_ITEMS_PAGINA) + i));
}
break;
}
// boton paginar izquierda
m_btnIzda.gameObject.SetActive(_numPagina > 0);
m_btnIzda.action = (_name) => {
GeneralSounds_menu.instance.select();
ShowPagina(--m_numPaginaActual, _tipoItem);
};
// boton paginar dcha
m_btnDcha.gameObject.SetActive(_numPagina < (numTotalPaginas - 1));
m_btnDcha.action = (_name) => {
GeneralSounds_menu.instance.select();
ShowPagina(++m_numPaginaActual, _tipoItem);
};
}
public void Injetar()
{
var itensEngenhariaP3D = capturarItensEngenhariaPlant3d();
//if (itensEngenhariaP3D.Count() > 0)
for (int i = 1; i <= itensEngenhariaP3D.Count(); i++)
{
//string nomeCatalogo = _endereco.Split('\\').Last().Split('.').First();
//CatalogoPlant3d catalogo = DefineCatalogo(nomeCatalogo);
using (var repositorioItemEngenharia = new Repositorio<ItemEngenharia>(_conexao))
{
//var itensCategoria = repositorioItemEngenharia.Query(x => x.GUID_ITEM_PAI == catalogo.GUID).ToList();
foreach (var item in itensEngenhariaP3D)
{
ItemEngenharia itemEngenharia = null;
itemEngenharia = repositorioItemEngenharia.Find(x => x.PnPID == (int)item.PnPID && x.GUID_CATALOGO == _catalogo.GUID);
if (itemEngenharia == null)
{
TipoItem tipoItem = null;
string tipoItemEng = item.ShortDescription.Split(',')[0];
using (var repositorioTiposItem = new Repositorio<TipoItem>(_conexao))
{
tipoItem = repositorioTiposItem.Find(x => x.NOME == tipoItemEng);
if (tipoItem == null)
{
tipoItem = new TipoItem()
{
GUID = Guid.NewGuid().ToString(),
NOME = tipoItemEng
};
repositorioTiposItem.Insert(tipoItem);
}
}
itemEngenharia = new ItemEngenharia()
{
GUID = Guid.NewGuid().ToString(),
GUID_TIPO_ITEM = tipoItem.GUID,
GUID_CATALOGO = _catalogo.GUID,
PnPID = (int)item.PnPID
};
repositorioItemEngenharia.Insert(itemEngenharia);
Type type = item.GetType();
foreach (var info in type.GetProperties())
{
PropriedadeItemEng propriedadeItemEng;
if (info.Name != "GUID" && info.Name != "CODIGO" && info.Name != "PnPID")
{
TipoPropriedade tipoPropriedade = null;
using (var repositorioTipos = new Repositorio<TipoPropriedade>(_conexao))
{
tipoPropriedade = repositorioTipos.Find(x => x.NOME == info.Name);
if (tipoPropriedade == null)
{
tipoPropriedade = new TipoPropriedade()
{
GUID = Guid.NewGuid().ToString(),
NOME = info.Name
};
repositorioTipos.Insert(tipoPropriedade);
}
}
using (var repositorioPropRelacionadas = new Repositorio<PrpiedadesRelacionadas>(_conexao))
{
PrpiedadesRelacionadas relacao = repositorioPropRelacionadas
.Find(x => x.GUID_PNPTABLE == tipoItem.GUID && x.GUID_PROPIEDADE == tipoPropriedade.GUID);
if (relacao == null)
{
relacao = new PrpiedadesRelacionadas()
{
GUID = Guid.NewGuid().ToString(),
GUID_PNPTABLE = tipoItem.GUID,
GUID_PROPIEDADE = tipoPropriedade.GUID
};
repositorioPropRelacionadas.Insert(relacao);
}
}
PropertyInfo campo = type.GetProperty(info.Name);
var valor = info.GetValue(item, null);
if (valor != null)
{
Valores valorTabelado = null;
using (var repositorioValores = new Repositorio<Valores>(_conexao))
{
valorTabelado = repositorioValores.Find(x => x.VALOR == valor.ToString());
if (valorTabelado == null)
{
valorTabelado = new Valores()
{
GUID = Guid.NewGuid().ToString(),
VALOR = valor.ToString(),
Sigla_BRASS = ""
};
repositorioValores.Insert(valorTabelado);
}
}
if (tipoPropriedade.NOME == "PartCategory")
{
var itemCategoria = repositorioItemEngenharia.Find(x => x.GUID == valorTabelado.GUID && x.GUID_CATALOGO == _catalogo.GUID);
if (itemCategoria == null)
{
itemCategoria = new ItemEngenharia()
{
GUID = valorTabelado.GUID,
GUID_TIPO_ITEM = tipoPropriedade.GUID,
GUID_CATALOGO = _catalogo.GUID,
PnPID = 0,
GUID_ITEM_PAI = _catalogo.GUID
};
repositorioItemEngenharia.Insert(itemCategoria);
}
itemEngenharia.GUID_ITEM_PAI = itemCategoria.GUID;
repositorioItemEngenharia.Edit(itemEngenharia);
}
PropriedadeEng propriedadeEng = null;
using (var repositorioPropriedades = new Repositorio<PropriedadeEng>(_conexao))
{
propriedadeEng = repositorioPropriedades.
Find(x => x.GUID_TIPO == tipoPropriedade.GUID && x.GUID_VALOR == valorTabelado.GUID);
if (propriedadeEng == null)
{
propriedadeEng = new PropriedadeEng()
{
GUID = Guid.NewGuid().ToString(),
GUID_TIPO = tipoPropriedade.GUID,
GUID_VALOR = valorTabelado.GUID
};
repositorioPropriedades.Insert(propriedadeEng);
}
}
using (var repositorioPropriedadeItemEng = new Repositorio<PropriedadeItemEng>(_conexao))
{
propriedadeItemEng = new PropriedadeItemEng()
{
GUID = Guid.NewGuid().ToString(),
GUID_ITEM_ENG = itemEngenharia.GUID,
GUID_PROPRIEDADE = propriedadeEng.GUID
};
repositorioPropriedadeItemEng.Insert(propriedadeItemEng);
}
}
}
}
}
}
}
}
}
