Пример #1
0
        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));
        }
Пример #2
0
        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);
        }
Пример #3
0
        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());
        }
Пример #4
0
        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));
        }
Пример #5
0
        /// <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);
        }
Пример #7
0
        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);
        }
Пример #8
0
        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);
        }
Пример #9
0
        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);
        }
Пример #10
0
        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."));
        }
Пример #11
0
        /// <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);
        }
Пример #12
0
        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));
        }
Пример #13
0
 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));
        }
Пример #15
0
        /// <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;
        }
Пример #16
0
        /// <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;
        }
Пример #17
0
        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);
 }
Пример #19
0
 public void UpdateDimensao(Dimensao Dimensao)
 {
     context.Entry(Dimensao).State = EntityState.Modified;
 }
Пример #20
0
        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();
        }
Пример #21
0
        public void DeleteDimensao(int Dimensao)
        {
            Dimensao dim = context.Dimensoes.Find(Dimensao);

            context.Dimensoes.Remove(dim);
        }
Пример #22
0
        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");
            }
        }