Пример #1
0
        public async Task <IActionResult> Edit(string id, [Bind("ID,Nome,DataDeCriacao,IdentificacaoObra,Observacoes,HorasEstudio,HorasPosProducao,DataEntrega,Total,RequerenteFK")] Servico servico,
                                               IFormCollection form, string Tipos, string ServSolicitados)
        {
            string datasExecucao = form["DataExecucao"];

            if (String.IsNullOrEmpty(id))
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    #region Associar Tipos
                    try
                    {
                        var tiposToRemove = await _context.Servicos_Tipos.Where(st => st.ServicoFK.Equals(servico.ID)).ToArrayAsync();

                        _context.RemoveRange(tiposToRemove);

                        if (!String.IsNullOrEmpty(Tipos)) // Caso existam tipos a serem adicionados
                        {
                            var tiposToAdd = Tipos.Split(",").Select(t => new Servico_Tipo
                            {
                                ServicoFK = servico.ID,
                                TipoFK    = Int32.Parse(t)
                            }).ToArray();
                            await _context.AddRangeAsync(tiposToAdd);
                        }

                        await _context.SaveChangesAsync();
                    }
                    catch (Exception e)
                    {
                        _email.NotifyError("Erro ao associar tipos ao serviço.", "ServicosController", "Edit - POST", e.Message);
                    }
                    #endregion

                    #region Associar ServSolic
                    try
                    {
                        var servSolicToRemove = await _context.Servicos_ServicosSolicitados.Where(sst => sst.ServicoFK.Equals(servico.ID)).ToArrayAsync();

                        _context.RemoveRange(servSolicToRemove);

                        if (!String.IsNullOrEmpty(ServSolicitados)) // Caso existam serviços solicitados a serem adicionados
                        {
                            var servSolicToAdd = ServSolicitados.Split(",").Select(ss => new Servico_ServicoSolicitado
                            {
                                ServicoFK           = servico.ID,
                                ServicoSolicitadoFK = Int32.Parse(ss)
                            }).ToArray();
                            await _context.AddRangeAsync(servSolicToAdd);
                        }

                        await _context.SaveChangesAsync();
                    }
                    catch (Exception e)
                    {
                        _email.NotifyError("Erro ao associar serviços solicitados ao serviço.", "ServicosController", "Edit - POST", e.Message);
                    }
                    #endregion

                    #region TratamentoDatasExecucao
                    try
                    {
                        var datasToRemove = _context.Servicos_DatasExecucao.Where(sd => sd.ServicoFK.Equals(servico.ID)).ToArray();
                        _context.RemoveRange(datasToRemove);

                        if (!String.IsNullOrEmpty(datasExecucao))
                        {
                            foreach (string dataStr in datasExecucao.Split(','))
                            {
                                if (!String.IsNullOrEmpty(dataStr)) // Certificar que a string não está vazia
                                {
                                    // Separar o ano, mes e dia
                                    string[]     dataArray = dataStr.Split('-');
                                    DataExecucao date      = new DataExecucao
                                    {
                                        Data = new DateTime(Int32.Parse(dataArray[0]), Int32.Parse(dataArray[1]), Int32.Parse(dataArray[2]))
                                    };
                                    // Criar nova data de execução
                                    _context.Add(date);
                                    await _context.SaveChangesAsync();

                                    // Adicionar relação da nova data com o servico
                                    await _context.AddAsync(new Servico_DataExecucao
                                    {
                                        DataExecucaoFK = date.ID,
                                        ServicoFK      = servico.ID
                                    });

                                    await _context.SaveChangesAsync();
                                }
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        _email.NotifyError("Erro ao adicionar datas de execução de um serviço.", "ServicosController", "Edit - POST", e.Message);
                    }
                    #endregion TratamentoDatasExecucao

                    try
                    {
                        // Não deixar as horas ficarem null
                        servico.HorasEstudio     = servico.HorasEstudio ?? 0;
                        servico.HorasPosProducao = servico.HorasPosProducao ?? 0;
                        servico.Total            = servico.Total ?? 0;

                        // Adicionar paragrafos nas observações, caso existam
                        if (!String.IsNullOrEmpty(servico.Observacoes))
                        {
                            servico.Observacoes = servico.Observacoes.Replace("\r\n", "<br/>");
                        }

                        _context.Update(servico);
                        await _context.SaveChangesAsync();
                    }
                    catch (Exception e)
                    {
                        await _logger.LogError(
                            descricao : "Erro ao editar um serviço.",
                            classe : "ServicosController",
                            metodo : "Edit",
                            erro : e.Message
                            );
                    }
                }
                catch (DbUpdateConcurrencyException e)
                {
                    if (!ServicosExists(servico.ID))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        await _logger.LogError(
                            descricao : "Erro ao editar um serviço.",
                            classe : "ServicosController",
                            metodo : "Edit",
                            erro : e.Message
                            );
                    }
                }

                TempData["Feedback"] = "Serviço editado com sucesso.";
                return(RedirectToAction(nameof(Details), new { id = servico.ID }));
            }

            // Lista da tabela intermediaria dos servico com os seus tipos
            var sevicos_tipos = await _context.Servicos_Tipos.Where(st => st.ServicoFK == id).ToListAsync();

            // Lista da tabela intermediaria dos servico com os seus serviços solicitados
            var sevicosSolicitados = await _context.Servicos_ServicosSolicitados.Where(st => st.ServicoFK == id).ToListAsync();

            return(View(
                       new ServicosCreateViewModel
            {
                Servico = servico,
                RequerentesList = new SelectList(_context.Requerentes, "ID", "Nome", servico.RequerenteFK),
                TiposList = _context.Tipos.Select(t => new SelectListItem()
                {
                    // Verificar se o tipo em que nos encontramos em cada instancia do select (select percorre todos), coincide com algum valor da lista servicos_tipos
                    // Caso exista, retorna verdade
                    Selected = (sevicos_tipos.Where(st => st.TipoFK == t.ID).Count() != 0),
                    Text = t.Nome,
                    Value = t.ID + ""
                }),
                ServSolicitados = _context.ServicosSolicitados.Select(s => new SelectListItem()
                {
                    // Verificar se o tipo em que nos encontramos em cada instancia do select (select percorre todos), coincide com algum valor da lista servicos_servicosSolicitados
                    // Caso exista, retorna verdade
                    Selected = (sevicosSolicitados.Where(st => st.ServicoSolicitadoFK == s.ID).Count() != 0),
                    Text = s.Nome,
                    Value = s.ID + ""
                })
            }));
        }
Пример #2
0
        public async Task <IActionResult> Create(
            [Bind("ID,Nome,DataDeCriacao,IdentificacaoObra,Observacoes,HorasEstudio,HorasPosProducao,DataEntrega,Total,RequerenteFK")] Servico servico,
            IFormCollection form, string Tipos, string ServSolicitados)
        {
            string datasExec = form["DataExecucao"];

            // Certificar que é selecionado um requerente
            if (servico.RequerenteFK == null)
            {
                ModelState.AddModelError("Servico.RequerenteFK", "É necessário escolher um requerente.");
            }

            try
            {
                if (ModelState.IsValid)
                {
                    #region Tratamento-Muitos-Para-Muitos

                    string[] array;

                    if (!String.IsNullOrEmpty(Tipos)) // Caso existam tipos a serem adicionados
                    {
                        array = Tipos.Split(",");     // Partir os tipos num array
                        List <Servico_Tipo> tiposList = new List <Servico_Tipo>();

                        foreach (string tipoId in array) // Correr esse array
                        {
                            // Associar o tipo
                            Servico_Tipo st = new Servico_Tipo
                            {
                                ServicoFK = servico.ID,
                                TipoFK    = Int32.Parse(tipoId)
                            };
                            tiposList.Add(st);
                        }
                        servico.Servicos_Tipos = tiposList;
                    }

                    if (!String.IsNullOrEmpty(ServSolicitados)) // Caso existam servicos solicitados a serem adicionados
                    {
                        array = ServSolicitados.Split(",");     // Partir os servicos solicitados num array
                        List <Servico_ServicoSolicitado> servSolicList = new List <Servico_ServicoSolicitado>();

                        foreach (string servSolicId in array) // Correr esse array
                        {
                            // Associar o servico solicitados
                            Servico_ServicoSolicitado sss = new Servico_ServicoSolicitado
                            {
                                ServicoFK           = servico.ID,
                                ServicoSolicitadoFK = Int32.Parse(servSolicId)
                            };
                            servSolicList.Add(sss);
                        }
                        servico.Servicos_ServicosSolicitados = servSolicList;
                    }

                    #endregion Tratamento-Muitos-Para-Muitos

                    // Não deixar as horas ficarem null
                    servico.HorasEstudio     = servico.HorasEstudio ?? 0;
                    servico.HorasPosProducao = servico.HorasPosProducao ?? 0;
                    servico.Total            = servico.Total ?? 0;

                    // Adicionar paragrafos nas observações, caso existam
                    if (!String.IsNullOrEmpty(servico.Observacoes))
                    {
                        servico.Observacoes = servico.Observacoes.Replace("\r\n", "<br/>");
                    }

                    _context.Add(servico);
                    await _context.SaveChangesAsync();

                    #region Datas de execução
                    if (datasExec != null)
                    {
                        foreach (string dataStr in datasExec.Split(','))
                        {
                            if (!dataStr.Equals(""))
                            {
                                // Separar o ano, mes e dia
                                string[] dataArray = dataStr.Split('-');
                                // Criar novo objeto data
                                DateTime data = new DateTime(Int32.Parse(dataArray[0]), Int32.Parse(dataArray[1]), Int32.Parse(dataArray[2]));

                                _context.DataExecucao.Add(new DataExecucao
                                {
                                    Data = data
                                });
                                await _context.SaveChangesAsync();

                                // Pesquisar a data acaba de inserir para que esta possa ser associada na tabela intermédia 'Servicos_DatasExecucao'
                                DataExecucao newDate = await _context.DataExecucao.Where(d => d.Data == data).FirstOrDefaultAsync();

                                _context.Servicos_DatasExecucao.Add(
                                    new Servico_DataExecucao()
                                {
                                    ServicoFK      = servico.ID,
                                    DataExecucaoFK = newDate.ID
                                }
                                    );
                                await _context.SaveChangesAsync();
                            }
                        }
                    }
                    #endregion

                    TempData["Feedback"] = "Serviço criado com sucesso.";
                    return(RedirectToAction(nameof(Details), new { id = servico.ID }));
                }
            }
            catch (Exception e)
            {
                await _logger.LogError(
                    descricao : "Erro ao criar um serviço.",
                    classe : "ServicosController",
                    metodo : "Create",
                    erro : e.Message
                    );
            }

            return(View(
                       new ServicosCreateViewModel
            {
                Servico = servico,
                RequerentesList = new SelectList(_context.Requerentes, "ID", "Nome"),
                TiposList = _context.Tipos.Select(t => new SelectListItem()
                {
                    Selected = false,
                    Text = t.Nome,
                    Value = t.ID + ""
                }),
                ServSolicitados = _context.ServicosSolicitados.Select(s => new SelectListItem()
                {
                    Selected = false,
                    Text = s.Nome,
                    Value = s.ID + ""
                })
            }));
        }