public ActionResult Create(Movimentacao movimentacao)
        {
            if (ModelState.IsValid)
            {
                /*
                TipoTransacao tipoTransacao = db.TipoTransacao.Single(t => t.Id == movimentacao.IdTipoTransacao);

                Estoque estoque = db.Estoque.Single(e => e.IdMaterial == movimentacao.IdItem);
                estoque.DataUltimaMovimentacao = movimentacao.Data;
                estoque.TipoUltimaTransacao = movimentacao.TipoTransacao.Descricao;

                if (tipoTransacao.Sigla == "EN")
                {
                    try
                    {
                        estoque.Quantidade += movimentacao.QuantidadeMovimentada;
                    }
                    catch { }
                }
                else if (tipoTransacao.Sigla == "SA")
                {
                    try
                    {
                        estoque.Quantidade -= movimentacao.QuantidadeMovimentada;
                    }
                    catch { }
                }
                else
                {
                    ViewBag.IdItem = new SelectList(db.Material, "Id", "Codigo", movimentacao.IdItem);
                    ViewBag.IdTipoTransacao = new SelectList(db.TipoTransacao, "Id", "Sigla", movimentacao.IdTipoTransacao);
                    return View(movimentacao);
                }
                */
                db.Movimentacao.AddObject(movimentacao);
                db.SaveChanges();
                return RedirectToAction("Index");
            }

            ViewBag.IdItem = new SelectList(db.Material, "Id", "Codigo", movimentacao.IdItem);
            ViewBag.IdTipoTransacao = new SelectList(db.TipoTransacao, "Id", "Sigla", movimentacao.IdTipoTransacao);
            return View(movimentacao);
        }
 public ActionResult Edit(Movimentacao movimentacao)
 {
     if (ModelState.IsValid)
     {
         db.Movimentacao.Attach(movimentacao);
         db.ObjectStateManager.ChangeObjectState(movimentacao, EntityState.Modified);
         db.SaveChanges();
         return RedirectToAction("Index");
     }
     ViewBag.IdItem = new SelectList(db.Material, "Id", "Codigo", movimentacao.IdItem);
     ViewBag.IdTipoTransacao = new SelectList(db.TipoTransacao, "Id", "Sigla", movimentacao.IdTipoTransacao);
     return View(movimentacao);
 }
 /// <summary>
 /// Deprecated Method for adding a new object to the Movimentacao EntitySet. Consider using the .Add method of the associated ObjectSet&lt;T&gt; property instead.
 /// </summary>
 public void AddToMovimentacao(Movimentacao movimentacao)
 {
     base.AddObject("Movimentacao", movimentacao);
 }
        public ActionResult Index(int? Material, int Quantidade, int Data)
        {
            if (!Material.HasValue)
            {
                return null;
            }

            Material material = db.Material.Single(m => m.Id == Material);

            for (int Ordem = 0; Ordem <= db.DependenciaMaterial.Max(m => m.Ordem); Ordem++)
            {
                // se for o Material "raiz", o sistema só deve gerar o planejamento de liberação

                if (Ordem == 0)
                {
                    Estoque estoque = db.Estoque.Single(e => e.IdMaterial == material.Id);

                    int QtdeSobra = estoque.Quantidade - Quantidade;
                    if (QtdeSobra < material.EstoqueMinimo)
                    {
                        int TotalFalta = material.EstoqueMinimo - QtdeSobra;

                        int Multiplicador = int.Parse(Math.Ceiling((double)TotalFalta / (double)material.LoteReposicao).ToString());

                        Planejamento planejamento = new Planejamento()
                        {
                            CodigoOrdem = material.Codigo + "_" + (Data - material.LeadTime).ToString(),
                            CodigoItem = material.Id,
                            DataPrevistaTermino = Data,
                            DataInicio = Data - material.LeadTime,
                            QuantidadeOrdem = material.LoteReposicao * Multiplicador,
                            Status = db.StatusPlanejamento.Single(s => s.Sigla == "P").Id
                        };

                        Movimentacao movimentacao = new Movimentacao()
                        {
                            IdItem = material.Id,
                            IdTipoTransacao = db.TipoTransacao.Single(t => t.Sigla == "SA").Id,
                            QuantidadeMovimentada = Quantidade,
                            Data = Data
                        };

                        db.Planejamento.AddObject(planejamento);
                        db.Movimentacao.AddObject(movimentacao);

                        db.SaveChanges();
                    }
                }
                else
                {
                    List<DependenciaMaterial> listDependencia =
                        db.DependenciaMaterial.Where(d => d.Ordem == Ordem).ToList();

                    foreach (DependenciaMaterial dependencia in listDependencia)
                    {
                        material = db.Material.Single(m => m.Id == dependencia.IdMaterialFilho);
                        Estoque estoque = db.Estoque.Single(e => e.IdMaterial == material.Id);

                        // para cada material filho, pegar os planejamentos do material pai

                        List<Planejamento> listPlanejamento =
                            db.Planejamento.Where(p => p.Material.Id == dependencia.IdMaterialPai).ToList();

                        foreach (Planejamento planejamentoPai in listPlanejamento)
                        {
                            int NecessidadeBruta = planejamentoPai.QuantidadeOrdem * Convert.ToInt32(dependencia.Quantidade);

                            int QtdeSobra = estoque.Quantidade - NecessidadeBruta;
                            if (QtdeSobra < material.EstoqueMinimo)
                            {
                                int TotalFalta = material.EstoqueMinimo - QtdeSobra;

                                int Multiplicador = int.Parse(Math.Ceiling((double)TotalFalta / (double)material.LoteReposicao).ToString());

                                Planejamento planejamentoFilho = new Planejamento()
                                {
                                    CodigoOrdem = material.Codigo + "_" + (planejamentoPai.DataInicio - material.LeadTime).ToString(),
                                    CodigoItem = material.Id,
                                    DataPrevistaTermino = planejamentoPai.DataInicio,
                                    DataInicio = planejamentoPai.DataInicio - material.LeadTime,
                                    QuantidadeOrdem = material.LoteReposicao * Multiplicador,
                                    Status = db.StatusPlanejamento.Single(s => s.Sigla == "P").Id
                                };

                                Movimentacao movimentacao = new Movimentacao()
                                {
                                    IdItem = material.Id,
                                    IdTipoTransacao = db.TipoTransacao.Single(t => t.Sigla == "SA").Id,
                                    QuantidadeMovimentada = NecessidadeBruta,
                                    Data = planejamentoFilho.DataPrevistaTermino.Value
                                };

                                db.Planejamento.AddObject(planejamentoFilho);
                                db.SaveChanges();

                                db.Movimentacao.AddObject(movimentacao);
                                db.SaveChanges();
                            }
                        }
                    }
                }
            }

            /*
            Planejamento planejamentoAnterior = new Planejamento()
            {
                QuantidadeOrdem = Quantidade,
                DataInicio = Data
            };

            int Multiplicador = 1;

            if (Ordem > 0)
            {
                List<DependenciaMaterial> dependencia =
                    db.DependenciaMaterial.Where(d => d.IdMaterialFilho == material.Id).ToList<DependenciaMaterial>();
            }

            Estoque estoque = db.Estoque.Single(e => e.IdMaterial == material.Id);

            Planejamento planejamentoNovo = new Planejamento()
            {
                QuantidadeOrdem = planejamentoAnterior.QuantidadeOrdem,
                DataPrevistaTermino = planejamentoAnterior.DataInicio,
                DataInicio = planejamentoAnterior.DataInicio - material.LeadTime,
                CodigoItem = material.Id
            };
            */

            var materiais = from M in db.Material
                            join D in db.DependenciaMaterial on M.Id equals D.IdMaterialFilho
                            where D.Ordem == 0
                            orderby M.Codigo
                            select M;

            ViewBag.Material = new SelectList(materiais, "Id", "Codigo");

            ViewBag.Mensagem = "Processamento efetuado com sucesso!";

            return View();
        }
 /// <summary>
 /// Create a new Movimentacao object.
 /// </summary>
 /// <param name="id">Initial value of the Id property.</param>
 /// <param name="idTipoTransacao">Initial value of the IdTipoTransacao property.</param>
 /// <param name="quantidadeMovimentada">Initial value of the QuantidadeMovimentada property.</param>
 /// <param name="data">Initial value of the Data property.</param>
 /// <param name="idItem">Initial value of the IdItem property.</param>
 public static Movimentacao CreateMovimentacao(global::System.Int32 id, global::System.Int32 idTipoTransacao, global::System.Int32 quantidadeMovimentada, global::System.Int32 data, global::System.Int32 idItem)
 {
     Movimentacao movimentacao = new Movimentacao();
     movimentacao.Id = id;
     movimentacao.IdTipoTransacao = idTipoTransacao;
     movimentacao.QuantidadeMovimentada = quantidadeMovimentada;
     movimentacao.Data = data;
     movimentacao.IdItem = idItem;
     return movimentacao;
 }