public override bool Validar(Produto pBase, Produto pParte)
{
Dimensao dbase = pBase.Dimensao;
Dimensao dparte = pParte.Dimensao;
return(dbase.Ocupa(dparte, ComprimentoMin, ComprimentoMax, LarguraMin, LarguraMax, AlturaMin, AlturaMax));
}
public async Task <Produto> Update(int id, ProdutoDTO produtodto)
{
Produto produto = _produtorepo.GetById(id).Result;
Dimensao dimensao = new Dimensao(produtodto.DimensaoDTO);
var lista_matacab = await ConstruirMaterialAcabamentoDeDTO(produtodto);
Categoria categoria = _categoriarepo.GetById(produtodto.Categoria.ID).Result;
if (lista_matacab.Count == 0)
{
throw new ArgumentException("Tem que existir materiais");
}
if (categoria == null)
{
throw new ArgumentException("Categoria inválida.");
}
produto.Update(produtodto.Nome, categoria, dimensao, lista_matacab);
//await DeleteAgregacoes(id); Depreciado
await _produtorepo.Update(id, produto);
//wait AgregarProdutos(produto, produtodto.Partes); Depreciado
return(produto);
}
public async Task <IActionResult> PutDimensao([FromRoute] int id, [FromBody] Dimensao dimensao)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != dimensao.Id)
{
return(BadRequest());
}
repdimensao.UpdateDimensao(dimensao);
try
{
repdimensao.Save();
}
catch (DbUpdateConcurrencyException)
{
if (!DimensaoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PostDimensao([FromBody] Dimensao dimensao)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
repdimensao.InsertDimensao(dimensao);
repdimensao.Save();
return(CreatedAtAction("GetDimensao", new { id = dimensao.Id }, dimensao));
}
/// <summary>
/// Retorna as dimenções da Imagem, Deve ser passado o caminho inteiro onde a imagem esta armazenada
/// </summary>
/// <param name="nomeArquivo"></param>
/// <returns></returns>
public static Dimensao retornaTamanhoImagem(string nomeArquivo)
{
//Pega imagem
System.Drawing.Image imagemEnviada = System.Drawing.Image.FromFile(nomeArquivo);
//Determina largura e altura
Dimensao dimensao = new Dimensao();
dimensao.Largura = imagemEnviada.PhysicalDimension.Width;
dimensao.Altura = imagemEnviada.PhysicalDimension.Height;
return(dimensao);
}
public void AddDimensaoTest(string nome, string descricao, bool sucesso)
{
var context = GetAppDbContext();
IUnitOfWork unitOfWork = new UnitOfWork(context);
Dimensao dimensao = new Dimensao {
Nome = nome,
Descricao = descricao,
DataCadastro = DateTime.Now
};
unitOfWork.DimensaoRepository.Add(dimensao);
Assert.True(sucesso);
}
public IEnumerable <DimensaoDto> GetDimensoes()
{
IEnumerable <DimensaoDto> ListaDimensoesDTO = Enumerable.Empty <DimensaoDto>();
DimensaoDto aux = new DimensaoDto();
foreach (Dimensao dimensao in repdimensao.GetDimensao())
{
Dimensao dim = repdimensao.GetDimensoesByID(dimensao.Id);
aux = new DimensaoDto();
aux.Altura.Id =
aux.Profundidade.Id = repDimensaoDc.GetDimensoesByID(dimensao.Profundidade.Id).Id;
aux.Largura.Id = repDimensaoDc.GetDimensoesByID(dimensao.Largura.Id).Id;
ListaDimensoesDTO = ListaDimensoesDTO.Concat(new[] { aux });
}
return(ListaDimensoesDTO);
}
public void CriarViagem_DadosCompletos_DeveRetornarNaoNulo()
{
//Arrange
//Criando personagem:
_personagemDimensao = new Dimensao(1, "C-130");
_personagem = new Personagem(1, "Ricky", _personagemDimensao, "http://labcon.fafich.ufmg.br/wp-content/uploads/2018/06/5164749-940x429.jpg");
//Criando viagem:
_origem = new Dimensao(1, "C-130");
_destino = new Dimensao(2, "C-131");
//Act
_viagem = new Viagem(1, _personagem, _origem, _destino);
//Assert
Assert.NotNull(_viagem);
}
public Produto ConstruirProdutoDeDTO(ProdutoDTO produtodto)
{
Dimensao dimensao = new Dimensao(produtodto.DimensaoDTO);
Categoria categoria = _categoriarepo.GetById(produtodto.Categoria.ID).Result;
if (categoria == null)
{
throw new ArgumentException("Categoria inválida.");
}
//Material mat = _materialrepo.GetById(produtodto.MaterialDTO.MaterialID).Result
//if (mat == null) throw new ArgumentException("Material inválido.");
var materiaisacabamento = ConstruirMaterialAcabamentoDeDTO(produtodto).Result;
Produto p = new Produto(
produtodto.Nome, dimensao, categoria, materiaisacabamento);
//Depreciado, Raúl
//AgregarProdutos(p, produtodto.Partes);
return(p);
}
public async Task <AppResponse> AvaliarAluno(AvaliarAluno request)
{
Aluno aluno = await _uow.Usuarios.ObterAluno(request.UsuarioId);
if (aluno == null)
{
return(new AppResponse(false, "Aluno não encontrado."));
}
Dimensao dimensao = await _uow.Dimensoes.Get(request.IdDimensao);
if (dimensao == null)
{
return(new AppResponse(false, "Dimensão não encontrada."));
}
Avaliacao avaliacao = await _uow.Usuarios.ObterAvaliacaoAluno(request.IdDimensao, aluno.Id, request.Semestre);
if (avaliacao == null)
{
avaliacao = new Avaliacao(request.IdDimensao, aluno.Id, request.Nota, request.Semestre);
if (!avaliacao.TaValido())
{
return(new AppResponse(false, "Não foi possivel avaliar o aluno.", avaliacao.ObterErros()));
}
_uow.Usuarios.AvaliarAluno(avaliacao);
await _uow.CommitAsync();
}
else
{
avaliacao.AtualizarNota(request.Nota);
await _uow.CommitAsync();
}
return(new AppResponse(true, "Aluno avaliado com sucesso."));
}
/// <param name="nomeArquivo">Caminho do Arquivo</param>
/// <param name="maxLarg">Largura Máxima</param>
/// <param name="maxAlt">Altura Máxima</param>
/// <param name="largura">Largura</param>
/// <param name="altura">Altura</param>
public static Dimensao retornaProporcaoImagem(string nomeArquivo, float maxLarg, float maxAlt, float largura, float altura)
{
System.Drawing.Image OriImg = System.Drawing.Image.FromFile(nomeArquivo);
Dimensao dimensao = new Dimensao();
if (OriImg.Width > OriImg.Width)
{
//Padrão Paisagem
if (OriImg.Width > maxLarg)
{
dimensao.Largura = maxLarg;
dimensao.Altura = Convert.ToInt32(OriImg.Height * dimensao.Largura / OriImg.Width);
}
else
{
dimensao.Largura = OriImg.Width;
dimensao.Altura = OriImg.Height;
}
}
else
{
//Padrão Retrato
if (OriImg.Height > maxAlt)
{
dimensao.Altura = maxAlt;
dimensao.Largura = Convert.ToInt32(OriImg.Width * dimensao.Largura / OriImg.Height);
}
else
{
dimensao.Largura = OriImg.Width;
dimensao.Altura = OriImg.Height;
}
}
return(dimensao);
}
public async Task <Validar> ValidarItemDeProduto(ItemDTO itemDTO)
{
bool valid = true;
if (!await _produto_repo.Exists(itemDTO.Produto_id))
{
return(Validar.NaoEncontrado);
}
Produto pOriginal = await _produto_repo.GetById(itemDTO.Produto_id);
valid &= pOriginal.validarMaterialAcabamento(itemDTO.Material, itemDTO.Acabamento);
Dimensao d = new Dimensao(itemDTO.Dimensao);
valid &= pOriginal.Dimensao.Validar(d);
if (!valid)
{
return(Validar.Invalido);
}
Produto concretizacao = new Produto(itemDTO);
return(await ValidarPartes(concretizacao, itemDTO.Partes));
}
public void InsertDimensao(Dimensao Dimensao)
{
context.Dimensoes.Add(Dimensao);
}
public DimensaoDC GetDimensoesByID(int DimensaoId)
{
Dimensao dim = context.Dimensoes.Find(DimensaoId);
return(context.DimensoesDC.Find(dim));
}
/// <summary>
/// Retorna as dimenções da Imagem, Deve ser passado o caminho inteiro onde a imagem esta armazenada
/// </summary>
/// <param name="nomeArquivo"></param>
/// <returns></returns>
public static Dimensao retornaTamanhoImagem(string nomeArquivo)
{
//Pega imagem
System.Drawing.Image imagemEnviada = System.Drawing.Image.FromFile(nomeArquivo);
//Determina largura e altura
Dimensao dimensao = new Dimensao();
dimensao.Largura = imagemEnviada.PhysicalDimension.Width;
dimensao.Altura = imagemEnviada.PhysicalDimension.Height;
return dimensao;
}
/// <param name="nomeArquivo">Caminho do Arquivo</param>
/// <param name="maxLarg">Largura Máxima</param>
/// <param name="maxAlt">Altura Máxima</param>
/// <param name="largura">Largura</param>
/// <param name="altura">Altura</param>
public static Dimensao retornaProporcaoImagem(string nomeArquivo, float maxLarg, float maxAlt, float largura, float altura)
{
System.Drawing.Image OriImg = System.Drawing.Image.FromFile(nomeArquivo);
Dimensao dimensao = new Dimensao();
if (OriImg.Width > OriImg.Width)
{
//Padrão Paisagem
if (OriImg.Width > maxLarg)
{
dimensao.Largura = maxLarg;
dimensao.Altura = Convert.ToInt32(OriImg.Height * dimensao.Largura / OriImg.Width);
}
else
{
dimensao.Largura = OriImg.Width;
dimensao.Altura = OriImg.Height;
}
}
else
{
//Padrão Retrato
if (OriImg.Height > maxAlt)
{
dimensao.Altura = maxAlt;
dimensao.Largura = Convert.ToInt32(OriImg.Width * dimensao.Largura / OriImg.Height);
}
else
{
dimensao.Largura = OriImg.Width;
dimensao.Altura = OriImg.Height;
}
}
return dimensao;
}
public Fato Obter(int id, bool simplificado = false)
{
Fato retorno = new Fato();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(EsquemaBanco))
{
#region Fato
Comando comando = bancoDeDados.CriarComando(@"select f.id, f.nome, f.tabela, f.tid from {0}tab_fato f where f.id = :id", EsquemaBanco);
comando.AdicionarParametroEntrada("id", id, DbType.Int32);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
if (reader.Read())
{
retorno.Id = reader.GetValue <int>("id");
retorno.Nome = reader.GetValue <string>("nome");
retorno.Tabela = reader.GetValue <string>("tabela");
retorno.Tid = reader.GetValue <string>("tid");
}
reader.Close();
}
#endregion
if (simplificado || retorno.Id == 0)
{
return(retorno);
}
#region Dimensoes
comando = bancoDeDados.CriarComando(@"select d.id, d.fato, d.nome, d.tabela from {0}tab_dimensao d where d.fato = :id order by d.nome", EsquemaBanco);
comando.AdicionarParametroEntrada("id", id, DbType.Int32);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
while (reader.Read())
{
Dimensao dimensao = new Dimensao();
dimensao.Id = reader.GetValue <int>("id");
dimensao.Nome = reader.GetValue <string>("nome");
dimensao.Tabela = reader.GetValue <string>("tabela");
retorno.Dimensoes.Add(dimensao);
}
reader.Close();
}
#endregion
#region Campos
comando = bancoDeDados.CriarComando(@"select c.id, c.codigo, c.fato, c.dimensao, c.campo, c.alias, c.tipo_dado, c.campo_exibicao, c.campo_filtro,
c.campo_ordenacao, c.consulta, c.campo_consulta, c.sistema_consulta from {0}tab_campo c where c.fato = :id order by c.alias" , EsquemaBanco);
comando.AdicionarParametroEntrada("id", id, DbType.Int32);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
while (reader.Read())
{
Campo campo = new Campo();
campo.Id = reader.GetValue <int>("id");
campo.Codigo = reader.GetValue <int>("codigo");
campo.Nome = reader.GetValue <string>("campo");
campo.Alias = reader.GetValue <string>("alias");
campo.TipoDados = reader.GetValue <int>("tipo_dado");
campo.CampoExibicao = reader.GetValue <bool>("campo_exibicao");
campo.CampoFiltro = reader.GetValue <bool>("campo_filtro");
campo.CampoOrdenacao = reader.GetValue <bool>("campo_ordenacao");
campo.Consulta = reader.GetValue <string>("consulta");
campo.CampoConsulta = reader.GetValue <string>("campo_consulta");
campo.SistemaConsulta = reader.GetValue <int>("sistema_consulta");
campo.DimensaoNome = retorno.Nome;
campo.Tabela = retorno.Tabela;
int dimensaoId = reader.GetValue <int>("dimensao");
if (dimensaoId > 0)
{
var dimensao = retorno.Dimensoes.Single(d => d.Id == dimensaoId);
dimensao.Campos.Add(campo);
campo.DimensaoNome = dimensao.Nome;
campo.Tabela = dimensao.Tabela;
}
retorno.Campos.Add(campo);
}
reader.Close();
}
#endregion
}
return(retorno);
}
public void Add(Dimensao dimensao)
{
_appDBContext.Dimensoes.Add(dimensao);
}
public void UpdateDimensao(Dimensao Dimensao)
{
context.Entry(Dimensao).State = EntityState.Modified;
}
public MappingProfile()
{
CreateMap <Categoria, CategoriaDTOID>().ForMember(dest => dest.ID, opt => opt.MapFrom(src => src.CategoriaID)).ReverseMap();
CreateMap <Acabamento, AcabamentoDTO>()
.ForMember(dest => dest.Nome, opt => opt.MapFrom(src => src.Nome))
.ReverseMap();
CreateMap <ProdutoMaterialAcabamento, MaterialAcabamentoDTO>()
.ForMember(dest => dest.id, opt => opt.MapFrom(src => src.MaterialAcabamento.MaterialAcabamentoID))
.ForMember(dest => dest.Material, opt => opt.MapFrom(src => src.MaterialAcabamento.Material))
.ForMember(dest => dest.Acabamento, opt => opt.MapFrom(src => src.MaterialAcabamento.Acabamento));
CreateMap <Material, MaterialDTO>()
.ForMember(dest => dest.Nome, opt => opt.MapFrom(src => src.Nome))
.ReverseMap();
CreateMap <Produto, ProdutoDTO>()
.ForMember(dest => dest.Categoria, opt => opt.MapFrom(src => src.Categoria))
.ForMember(dest => dest.MaterialAcabamentoDTO, opt => opt.MapFrom(src => src.ProdutoMaterialAcabamentos))
.ForMember(dest => dest.DimensaoDTO, opt => opt.MapFrom(src => src.Dimensao));
CreateMap <Categoria, CategoriaDTO>()
.ForMember(dest => dest.SuperCategoria, opt => opt.MapFrom(src => src.SuperCatID))
.ForMember(dest => dest.CategoriaDTOID, opt => opt.MapFrom(src => src.CategoriaID));
CreateMap <Categoria, CategoriaDTOID>()
.ForMember(dest => dest.ID, opt => opt.MapFrom(src => src.CategoriaID))
.ForMember(dest => dest.Nome, opt => opt.MapFrom(src => src.Nome));
CreateMap <ValorNumerico, double>().ConvertUsing(src => src.Valor);
CreateMap <TipoValor, string>().ConvertUsing(src => Dimensao.converterTipoValor(src));
CreateMap <Dimensao, DimensaoDTO>()
.ForMember(dest => dest.Altura, opt => opt.MapFrom(src => src.Altura))
.ForMember(dest => dest.Comprimento, opt => opt.MapFrom(src => src.Comprimento))
.ForMember(dest => dest.Largura, opt => opt.MapFrom(src => src.Largura))
.ForMember(dest => dest.TipoAltura, opt => opt.MapFrom(src => src.TipoValorAltura))
.ForMember(dest => dest.TipoComprimento, opt => opt.MapFrom(src => src.TipoValorComprimento))
.ForMember(dest => dest.TipoLargura, opt => opt.MapFrom(src => src.TipoValorLargura));
CreateMap <Restricao, RestricaoDTO>()
.ForMember(dest => dest.Nome, opt => opt.MapFrom(src => src.NomeRestricao))
.ForMember(dest => dest.id, opt => opt.MapFrom(src => src.RestricaoID))
.ForMember(dest => dest.Tipo, opt => opt.MapFrom(src => src.TipoRestricao));
CreateMap <RestricaoOcupacao, RestricaoOcupacaoDTO>()
.IncludeBase <Restricao, RestricaoDTO>()
.ForMember(dest => dest.AlturaMin, opt => opt.MapFrom(src => src.AlturaMin))
.ForMember(dest => dest.AlturaMax, opt => opt.MapFrom(src => src.AlturaMax))
.ForMember(dest => dest.ComprimentoMin, opt => opt.MapFrom(src => src.ComprimentoMin))
.ForMember(dest => dest.ComprimentoMax, opt => opt.MapFrom(src => src.ComprimentoMax))
.ForMember(dest => dest.LarguraMin, opt => opt.MapFrom(src => src.LarguraMin))
.ForMember(dest => dest.LarguraMax, opt => opt.MapFrom(src => src.LarguraMax));
CreateMap <Agregacao, AgregacaoDTO>()
.ForMember(dest => dest.ProdutoBase, opt => opt.MapFrom(src => src.Base))
.ForMember(dest => dest.ProdutoParte, opt => opt.MapFrom(src => src.Parte))
.ForMember(dest => dest.id, opt => opt.MapFrom(src => src.AgregacaoID));
CreateMap <MaterialAcabamento, MaterialAcabamentoDTO>()
.ForMember(dest => dest.id, opt => opt.MapFrom(src => src.MaterialAcabamentoID))
.ForMember(dest => dest.Material, opt => opt.MapFrom(src => src.Material))
.ForMember(dest => dest.Acabamento, opt => opt.MapFrom(src => src.Acabamento))
.ReverseMap();
}
public void DeleteDimensao(int Dimensao)
{
Dimensao dim = context.Dimensoes.Find(Dimensao);
context.Dimensoes.Remove(dim);
}
public static void Initialize(ClosifyContext context)
{
if (context.Categorias.Any())
{
return;
}
Categoria[] categorias =
{
new Categoria {
Nome = "Armário"
},
new Categoria {
Nome = "Módulo Gavetas"
},
new Categoria {
Nome = "Gavetas"
},
new Categoria {
Nome = "Portas"
},
new Categoria {
Nome = "Cabide"
},
new Categoria
{
Nome = "Espelhos"
}
};
context.Categorias.AddRange(categorias);
context.SaveChanges();
Categoria[] subCategorias =
{
new Categoria {
Nome = "Armário de Sala",
SuperCategoria = categorias[0],
SuperCatID = categorias[0].CategoriaID
},
new Categoria {
Nome = "Armário de Jardim",
SuperCategoria = categorias[0],
SuperCatID = categorias[0].CategoriaID
}
};
categorias[0].AdicionarSubCategoria(subCategorias[0]);
categorias[0].AdicionarSubCategoria(subCategorias[1]);
//context.Categorias.AddRange(subCategorias);
context.SaveChanges();
Acabamento[] acabamentos =
{
new Acabamento("Natural")
,
new Acabamento("Polido")
,
new Acabamento("Envernizado")
,
new Acabamento("Anodizado")
};
Material[] materiais =
{
new Material("Madeira"),
new Material("Aluminio"),
new Material("MDF"),
};
context.Materiais.AddRange(materiais);
context.SaveChanges();
context.Acabamentos.AddRange(acabamentos);
context.SaveChanges();
MaterialAcabamento[] madeiraAcabamentos =
{
new MaterialAcabamento(materiais[0], acabamentos[0]), //Madeira Natural
new MaterialAcabamento(materiais[0], acabamentos[1]), //Madeira Polido
new MaterialAcabamento(materiais[0], acabamentos[2]) //Madeira Envernizado
};
MaterialAcabamento[] aluminioAcabamentos =
{
new MaterialAcabamento(materiais[1], acabamentos[3])//Aluminio Anodizado
};
MaterialAcabamento[] mdfAcabamentos =
{
new MaterialAcabamento(materiais[2], acabamentos[0]), //MDF Natural
new MaterialAcabamento(materiais[2], acabamentos[1]), //MDF Polido
new MaterialAcabamento(materiais[2], acabamentos[2]) //MDF Envernizado
};
DimensaoDTO dimensaodto = new DimensaoDTO
{
TipoAltura = "discreto",
TipoComprimento = "discreto",
TipoLargura = "continuo",
Altura = new List <double> {
100, 200
},
Comprimento = new List <double> {
20, 30, 40
},
Largura = new List <double> {
10, 20
}
};
Dimensao d = new Dimensao(dimensaodto);
//Armario
Produto armario1 = new Produto
{
Nome = "Armário Xpto",
Categoria = subCategorias[0],
Dimensao = d,
};
foreach (MaterialAcabamento ma in madeiraAcabamentos)
{
armario1.AddMaterialAcabamento(ma);
}
foreach (MaterialAcabamento ma in aluminioAcabamentos)
{
armario1.AddMaterialAcabamento(ma);
}
foreach (MaterialAcabamento ma in mdfAcabamentos)
{
armario1.AddMaterialAcabamento(ma);
}
context.Produtos.Add(armario1);
context.SaveChanges();
//Criar Porta
DimensaoDTO dporta = new DimensaoDTO
{
TipoAltura = "continuo",
TipoComprimento = "continuo",
TipoLargura = "continuo",
Altura = new List <double> {
1, 200
},
Comprimento = new List <double> {
1, 400
},
Largura = new List <double> {
1, 100
}
};
Produto porta = new Produto
{
Nome = "Porta 1",
Categoria = categorias[3],
Dimensao = new Dimensao(dporta)
};
context.Produtos.Add(porta);
context.SaveChanges();
foreach (MaterialAcabamento ma in madeiraAcabamentos)
{
porta.AddMaterialAcabamento(ma);
}
foreach (MaterialAcabamento ma in mdfAcabamentos)
{
porta.AddMaterialAcabamento(ma);
}
foreach (MaterialAcabamento ma in aluminioAcabamentos)
{
porta.AddMaterialAcabamento(ma);
}
context.SaveChanges();
Agregacao a2 = new Agregacao(armario1, porta);
a2.Restricoes.Add(RestricaoFactory.RestricaoObrigatoria());
a2.Restricoes.Add(RestricaoFactory.RestricaoMaterial());
if (a2.Validar())
{
context.Agregacoes.Add(a2);
context.SaveChanges();
}
else
{
throw new ArgumentException("Erro ao fazer a agregação");
}
DimensaoDTO dmodulogavetas = new DimensaoDTO
{
TipoAltura = "continuo",
TipoComprimento = "continuo",
TipoLargura = "continuo",
Altura = new List <double> {
10, 100
},
Comprimento = new List <double> {
20, 100
},
Largura = new List <double> {
5, 40
}
};
Produto moduloGavetas = new Produto
{
Nome = "Modulo Gavetas 1",
Categoria = categorias[1],
Dimensao = new Dimensao(dmodulogavetas)
};
context.Produtos.Add(moduloGavetas);
foreach (MaterialAcabamento ma in madeiraAcabamentos)
{
moduloGavetas.AddMaterialAcabamento(ma);
}
foreach (MaterialAcabamento ma in mdfAcabamentos)
{
moduloGavetas.AddMaterialAcabamento(ma);
}
foreach (MaterialAcabamento ma in aluminioAcabamentos)
{
moduloGavetas.AddMaterialAcabamento(ma);
}
context.SaveChanges();
Agregacao armario1_modulogavetas = new Agregacao(armario1, moduloGavetas);
context.Agregacoes.Add(armario1_modulogavetas);
context.SaveChanges();
DimensaoDTO dto_gaveta = new DimensaoDTO
{
TipoAltura = "discreto",
TipoComprimento = "discreto",
TipoLargura = "discreto",
Altura = new List <double> {
10, 20
},
Comprimento = new List <double> {
20, 30, 40
},
Largura = new List <double> {
5
}
};
Dimensao d_gaveta = new Dimensao(dto_gaveta);
//Gaveta
Produto gaveta = new Produto
{
Nome = "Gaveta 1",
Categoria = categorias[1],
Dimensao = d_gaveta,
};
foreach (MaterialAcabamento ma in madeiraAcabamentos)
{
gaveta.AddMaterialAcabamento(ma);
}
foreach (MaterialAcabamento ma in mdfAcabamentos)
{
gaveta.AddMaterialAcabamento(ma);
}
context.Produtos.Add(gaveta);
context.SaveChanges();
Agregacao a1 = new Agregacao(moduloGavetas, gaveta);
a1.Restricoes.Add(RestricaoFactory.RestricaoObrigatoria());
context.Agregacoes.Add(a1);
DimensaoDTO dtodim_gaveta2 = new DimensaoDTO
{
TipoAltura = "discreto",
TipoComprimento = "discreto",
TipoLargura = "discreto",
Altura = new List <double> {
10, 20, 30
},
Comprimento = new List <double> {
20, 30, 40
},
Largura = new List <double> {
5, 10, 15, 20
}
};
Produto gaveta2 = new Produto
{
Nome = "Gaveta 2",
Categoria = categorias[1],
Dimensao = new Dimensao(dtodim_gaveta2)
};
foreach (MaterialAcabamento ma in madeiraAcabamentos)
{
gaveta2.AddMaterialAcabamento(ma);
}
foreach (MaterialAcabamento ma in mdfAcabamentos)
{
gaveta2.AddMaterialAcabamento(ma);
}
context.Produtos.Add(gaveta2);
context.SaveChanges();
Agregacao a3 = new Agregacao(moduloGavetas, gaveta2);
a3.Restricoes.Add(RestricaoFactory.RestricaoOpcional());
if (a3.Validar())
{
context.Agregacoes.Add(a3);
context.SaveChanges();
}
else
{
throw new ArgumentException("Erro ao fazer a agregação a3");
}
context.SaveChanges();
DimensaoDTO dcabide = new DimensaoDTO
{
TipoAltura = "continuo",
TipoComprimento = "continuo",
TipoLargura = "continuo",
Altura = new List <double> {
1, 200
},
Comprimento = new List <double> {
1, 400
},
Largura = new List <double> {
1, 100
}
};
Produto cabide = new Produto
{
Nome = "Cabide 1",
Categoria = categorias[4],
Dimensao = new Dimensao(dcabide)
};
foreach (MaterialAcabamento ma in madeiraAcabamentos)
{
cabide.AddMaterialAcabamento(ma);
}
foreach (MaterialAcabamento ma in mdfAcabamentos)
{
cabide.AddMaterialAcabamento(ma);
}
foreach (MaterialAcabamento ma in aluminioAcabamentos)
{
cabide.AddMaterialAcabamento(ma);
}
context.Produtos.Add(cabide);
context.SaveChanges();
DimensaoDTO darmario2 = new DimensaoDTO
{
TipoAltura = "continuo",
TipoComprimento = "discreto",
TipoLargura = "discreto",
Altura = new List <double> {
50, 200
},
Comprimento = new List <double> {
20, 30, 40
},
Largura = new List <double> {
10, 20, 30, 40
}
};
Produto armario2 = new Produto
{
Nome = "Armario 2",
Categoria = categorias[1],
Dimensao = new Dimensao(darmario2)
};
context.Produtos.Add(armario2);
context.SaveChanges();
foreach (MaterialAcabamento ma in mdfAcabamentos)
{
armario2.AddMaterialAcabamento(ma);
}
Agregacao armario2_modulogavetas = new Agregacao(armario2, moduloGavetas);
armario2_modulogavetas.Restricoes.Add(RestricaoFactory.RestricaoOpcional());
if (armario2_modulogavetas.Validar())
{
context.Agregacoes.Add(armario2_modulogavetas);
context.SaveChanges();
}
else
{
throw new ArgumentException("Erro ao fazer a agregação armario2_modulogavetas");
}
Agregacao armario2_cabide = new Agregacao(armario2, cabide);
armario2_cabide.Restricoes.Add(RestricaoFactory.RestricaoObrigatoria());
if (armario2_cabide.Validar())
{
context.Agregacoes.Add(armario2_cabide);
context.SaveChanges();
}
else
{
throw new ArgumentException("Erro ao fazer a agregação armario2_cabide");
}
Agregacao armario2_porta = new Agregacao(armario2, porta);
armario2_porta.Restricoes.Add(RestricaoFactory.RestricaoMaterial());
if (armario2_porta.Validar())
{
context.Agregacoes.Add(armario2_porta);
context.SaveChanges();
}
else
{
throw new ArgumentException("Erro ao fazer a agregação armario2_porta");
}
DimensaoDTO dimEspelho = new DimensaoDTO
{
TipoAltura = "continuo",
TipoComprimento = "continuo",
TipoLargura = "discreto",
Altura = new List <double> {
20, 120
},
Comprimento = new List <double> {
10, 20
},
Largura = new List <double> {
8
}
};
Produto espelho1 = new Produto
{
Nome = "Espelho",
Categoria = categorias[5],
Dimensao = new Dimensao(dimEspelho)
};
foreach (MaterialAcabamento ma in aluminioAcabamentos)
{
espelho1.AddMaterialAcabamento(ma);
}
context.Produtos.Add(espelho1);
context.SaveChanges();
Agregacao armario_espelho = new Agregacao(armario1, espelho1);
RestricaoOcupacaoDTO restOcupacao = new RestricaoOcupacaoDTO
{
AlturaMin = 0,
AlturaMax = 0.50f/*,
* ComprimentoMin = 0,
* ComprimentoMax = 0.50f,
* LarguraMin = 0,
* LarguraMax = 0.50f */
};
armario_espelho.Restricoes.Add(RestricaoFactory.RestricaoOcupacao(restOcupacao));
if (armario_espelho.Validar())
{
context.Agregacoes.Add(armario_espelho);
context.SaveChanges();
}
else
{
throw new ArgumentException("Erro ao fazer a agregação armario_espelho");
}
}