示例#1
0
        public async Task <IActionResult> Registro([Bind("UsuarioId,Email,Senha")] Usuario usuario)
        {
            if (ModelState.IsValid)
            {
                _context.Add(usuario);
                InformacaoLogin informacao = new InformacaoLogin
                {
                    UsuarioId  = usuario.UsuarioId,
                    EnderecoIP = Request.HttpContext.Connection.RemoteIpAddress.ToString(),
                    Data       = DateTime.Now.ToShortDateString(),
                    Horario    = DateTime.Now.ToShortTimeString()
                };

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

                HttpContext.Session.SetInt32("UsuarioId", usuario.UsuarioId);
                var claims = new List <Claim>
                {
                    new Claim(ClaimTypes.Email, usuario.Email)
                };

                var             userIdentity = new ClaimsIdentity(claims, "login");
                ClaimsPrincipal principal    = new ClaimsPrincipal(userIdentity);

                await HttpContext.SignInAsync(principal);


                return(RedirectToAction("Index", "Curriculos"));
            }
            return(View(usuario));
        }
 public Usuario SignUp(Usuario usuario, ref int status)
 {
     try
     {
         var hash = new Hash(SHA512.Create());
         // Caso o e-mail já exista, deverá retornar erro com a mensagem "E-mail já existente".
         if (_contexto.Usuarios.FirstOrDefault(t => t.Email.Equals(usuario.Email.Trim())) == null)
         {
             status = -1;
             return(null);
         }
         else
         {
             usuario.DataCriacao     = DateTime.Today;
             usuario.DataUltimoLogin = DateTime.Today;
             usuario.Senha           = hash.CriptografarSenha(usuario.Senha);
             usuario.Token           = Security.AccessManager.GenerateToken(usuario);
             _contexto.Add(usuario);
             foreach (Telefone telefone in usuario.Telefones)
             {
                 if (telefone != null)
                 {
                     _contexto.Add(telefone);
                 }
             }
             _contexto.SaveChanges();
         }
     }
     catch (Exception ex)
     {
         status = -2;
         return(null);
     }
     return(usuario);
 }
示例#3
0
        public async Task <IActionResult> AdocaoDetalhes(AdocaoViewModel model)
        {
            if (ModelState.IsValid)
            {
                var contato = new Contatosadocao()
                {
                    IdAnimal      = model.IdAnimal,
                    Nome          = model.Nome,
                    Email         = model.Email,
                    Telefone      = model.Telefone,
                    Justificativa = model.Justificativa
                };
                _context.Add(contato);
                await _context.SaveChangesAsync();

                return(RedirectToAction("AdocaoEmAnalise"));
            }
            var animal = _context.Animaisccz.Find(model.IdAnimal);

            model.Animal = animal;

            ViewData["CaminhoFoto"] = webHostEnvironment.WebRootPath;

            return(View(model));
        }
        public async Task <IActionResult> Create([Bind("Id,EscalaId,Data,EventoId,Destaque")] Quadro Quadro)
        {
            _context.Add(Quadro);
            await _context.SaveChangesAsync();

            return(RedirectToAction("Index"));
        }
示例#5
0
        public async Task <IActionResult> AddPessoa([FromBody] PessoaDto p)
        {
            if (p != null)
            {
                if (p.PessoaJuridicaFisica == 'F')
                {
                    PessoaFisica f = new PessoaFisica();
                    f.PreparaDados(null, p.Nome, p.Sobrenome, p.Cpf, p.DataNascimento, p.PessoaJuridicaFisica, p.CEP, p.Logradouro, p.Numero, p.Complemento, p.Bairro, p.Cidade, p.Uf);
                    _contexto.Add(f);
                    await _contexto.SaveChangesAsync();

                    return(Json("0"));
                }
                else
                {
                    PessoaJuridica j = new PessoaJuridica();
                    j.PreparaDados(null, p.RazaoSocial, p.NomeFantasia, p.Cnpj, p.PessoaJuridicaFisica, p.CEP, p.Logradouro, p.Numero, p.Complemento, p.Bairro, p.Cidade, p.Uf);
                    _contexto.Add(j);
                    await _contexto.SaveChangesAsync();

                    return(Json("0"));
                }
            }
            return(Json("-1"));
        }
        public async Task <IActionResult> SalvarSolicitacao([Bind("AgendamentoId,DataAgendamento,DataFimAgendamento,LaboratorioId,DisciplinaId,ProfessorId")] Agendamento agendamento)
        {
            var temNaBaseMesmoHorario = _context.Agendamento.Where(a => (a.DataAgendamento <= agendamento.DataAgendamento && a.DataFimAgendamento >= agendamento.DataFimAgendamento) && a.LaboratorioId == agendamento.LaboratorioId).ToList();

            if (temNaBaseMesmoHorario.Any())
            {
                ViewBag.error             = "Horários conflitantes com outro agendamento, favor altere os horarios e tente novamente.";
                ViewData["DisciplinaId"]  = new SelectList(_context.Set <Disciplina>(), "DisciplinaId", "NomeDisciplina", agendamento.DisciplinaId);
                ViewData["LaboratorioId"] = new SelectList(_context.Set <Laboratorio>(), "LaboratorioId", "NomeLaboratorio", agendamento.LaboratorioId);
                ViewData["ProfessorId"]   = new SelectList(_context.Set <Professor>(), "ProfessorId", "NomeProfessor", agendamento.ProfessorId);
                ViewData["UsuarioId"]     = new SelectList(_context.Usuarios, "UsuarioId", "Email", agendamento.UsuarioId);
                ViewData["StatusId"]      = new SelectList(_context.Set <Status>(), "StatusId", "NomeStatus");
                ViewBag.user = HttpContext.Session.GetString("LoginLogado");
                return(View("SolicitarAgendamento"));
            }
            if (agendamento.DataAgendamento < DateTime.Now)
            {
                ViewBag.error             = "Data ou horário anterior a data atual, favor seleciona outra data ou horário.";
                ViewData["DisciplinaId"]  = new SelectList(_context.Set <Disciplina>(), "DisciplinaId", "NomeDisciplina", agendamento.DisciplinaId);
                ViewData["LaboratorioId"] = new SelectList(_context.Set <Laboratorio>(), "LaboratorioId", "NomeLaboratorio", agendamento.LaboratorioId);
                ViewData["ProfessorId"]   = new SelectList(_context.Set <Professor>(), "ProfessorId", "NomeProfessor", agendamento.ProfessorId);
                ViewData["UsuarioId"]     = new SelectList(_context.Usuarios, "UsuarioId", "Email", agendamento.UsuarioId);
                ViewData["StatusId"]      = new SelectList(_context.Set <Status>(), "StatusId", "NomeStatus");
                ViewBag.user = HttpContext.Session.GetString("LoginLogado");
                return(View("SolicitarAgendamento"));
            }
            int idUser = Convert.ToInt32(HttpContext.Session.GetInt32("usuarioIdLogado"));

            agendamento.UsuarioId = idUser;
            agendamento.StatusId  = 2;
            _context.Add(agendamento);
            await _context.SaveChangesAsync();

            return(RedirectToAction("MeusAgendamentos"));
        }
示例#7
0
 public IActionResult ReservarViaje(Perro p)
 {
     if (ModelState.IsValid)
     {
         _c.Add(p);
         _c.SaveChanges();
         return(RedirectToAction("ReservarViaje1"));
     }
     return(View(p));
 }
        public async Task <IActionResult> Create([Bind("Id,Nome,Ativo")] Pessoa pessoa)
        {
            if (ModelState.IsValid)
            {
                _context.Add(pessoa);
                await _context.SaveChangesAsync();

                return(RedirectToAction("Index"));
            }
            return(View(pessoa));
        }
        public async Task <IActionResult> CreateSave([Bind("Id,PessoaId,LocalId,QuadroId")] ItemQuadro itemQuadro)
        {
            if (ModelState.IsValid)
            {
                _context.Add(itemQuadro);
                await _context.SaveChangesAsync();

                return(RedirectToAction("Index", "Quadro"));
            }
            return(View(itemQuadro));
        }
示例#10
0
        public async Task <IActionResult> Create([Bind("ID,Descricao,NomeResponsavel,EmailResponsavel")] Tarefa tarefa)
        {
            if (ModelState.IsValid)
            {
                _context.Add(tarefa);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View(tarefa));
        }
        public async Task <IActionResult> Create([Bind("Id,Titulo,AssuntoId,TopicoPaiId")] Topico topico)
        {
            if (ModelState.IsValid)
            {
                topico.DataHoraModificacao = DateTime.Now;
                _context.Add(topico);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            ViewData["Assuntos"] = new SelectList(_context.Assuntos, "Id", "Titulo");
            ViewData["Topicos"]  = new SelectList(_context.Topicos, "Id", "Titulo");
            return(View(topico));
        }
示例#12
0
 public JsonResult AdicionarTipoDespesas(string txtDespesas)
 {
     if (!string.IsNullOrEmpty(txtDespesas))
     {
         if (!_context.TipoDespesas.Any(x => x.Nome.ToUpper() == txtDespesas.ToUpper()))
         {
             TipoDespesas tipo = new TipoDespesas();
             tipo.Nome = txtDespesas;
             _context.Add(tipo);
             _context.SaveChanges();
             return(Json(true));
         }
     }
     return(Json(false));
 }
示例#13
0
        public async Task <IActionResult> Create([Bind("UsuarioId,NomeUsuario,Login,Email,Senha,CargoId,CursoId,StatusId")] Usuario usuario)
        {
            var temEmail = _context.Usuarios.Where(x => x.Email == usuario.Email).ToList();
            var temLogin = _context.Usuarios.Where(x => x.Login == usuario.Login).ToList();

            if (ModelState.IsValid && temEmail.Count == 0)
            {
                if (temLogin.Count == 0)
                {
                    _context.Add(usuario);
                    await _context.SaveChangesAsync();

                    return(RedirectToAction(nameof(Index)));
                }
                else
                {
                    ViewBag.LoginRepetido = true;
                    ViewData["CargoId"]   = new SelectList(_context.Cargos, "CargoId", "NomeCargo", usuario.CargoId);
                    ViewData["CursoId"]   = new SelectList(_context.Cursos, "CursoId", "Nome", usuario.CursoId);
                    ViewData["StatusId"]  = new SelectList(_context.Status, "StatusId", "NomeStatus", usuario.StatusId);
                    return(View(usuario));
                }
            }
            else
            {
                ViewBag.EmailRepetido = true;
                ViewData["CargoId"]   = new SelectList(_context.Cargos, "CargoId", "NomeCargo", usuario.CargoId);
                ViewData["CursoId"]   = new SelectList(_context.Cursos, "CursoId", "Nome", usuario.CursoId);
                ViewData["StatusId"]  = new SelectList(_context.Status, "StatusId", "NomeStatus", usuario.StatusId);
                return(View(usuario));
            }
        }
示例#14
0
        public async Task <IActionResult> CadastrarBlog(Blog blog, IFormFile imagem)
        {
            if (ModelState.IsValid)
            {
                var linkUpload = Path.Combine(_hostingEnvironment.WebRootPath, "uploads");
                if (imagem != null)
                {
                    Random rdm        = new Random();
                    var    nomeImagem = rdm.Next(0, 5000) + "_" + imagem.FileName;

                    using (var fileStream = new FileStream(Path.Combine(linkUpload, nomeImagem), FileMode.Create))
                    {
                        await imagem.CopyToAsync(fileStream);

                        blog.Imagem    = "~/uploads/" + nomeImagem;
                        blog.UsuarioId = int.Parse(HttpContext.Session.GetInt32("UsuarioId").ToString());
                    }
                }

                _contexto.Add(blog);
                await _contexto.SaveChangesAsync();

                return(RedirectToAction("Index", "Blog"));
            }

            return(View(blog));
        }
示例#15
0
        public async Task <ActionResult> Post(Persona persona)
        {
            contexto.Add(persona);
            await contexto.SaveChangesAsync();

            return(new CreatedAtRouteResult("obtenerPersona", new { PersonaId = persona.PersonaId }, persona));
        }
        public JsonResult AdicionarTipoDespesa(string txtDespesa)
        {
            if (!string.IsNullOrEmpty(txtDespesa))
            {
                if (!_context.TipoDespesas.Any(td => td.Nome.ToUpper() == txtDespesa.ToUpper()))
                {
                    TipoDespesa tipoDespesa = new TipoDespesa();
                    tipoDespesa.Nome = txtDespesa;
                    _context.Add(tipoDespesa);
                    _context.SaveChanges();

                    return(Json(true));
                }
            }
            return(Json(false));
        }
        public async Task <IActionResult> Registrar(int kwh)
        {
            if (kwh <= 0)
            {
                TempData["Mensagem"] = "*valor inválido ";
                return(RedirectToAction(nameof(Index)));
            }
            if (medidor.LeituraDoDiaJaRealizada())
            {
                TempData["Mensagem"] = $"O registro de hoje já foi realizado!";
                return(RedirectToAction(nameof(Index)));
            }

            if (medidor.ValorEhMenorDoQueOsQueJaForamRegistrados(kwh))
            {
                TempData["Mensagem"] = $"Digite um valor maior que o último registrado!";
                return(RedirectToAction(nameof(Index)));
            }
            var leitura = new LeituraDoRelogio(kwh);

            db.Add(leitura);
            await medidor.RegistrarConsumo(leitura.Kwh);

            db.SaveChanges();
            return(RedirectToAction(nameof(HomeController.Index), "Home"));
        }
示例#18
0
        public IActionResult Create([FromBody] UsuarioDTO usuario)
        {
            try
            {
            }
            catch (Exception ex)
            {
                return(this.StatusCode(StatusCodes.Status500InternalServerError, $"ERROR {ex.Message}"));
            }

            if (ModelState.IsValid)
            {
                var _usuario = _mapper.Map <Usuario>(usuario);
                _usuario.Travado    = true;
                _usuario.Verificado = false;
                _usuario.Criado     = System.DateTime.Now;

                _contexto.Add(_usuario);
                _contexto.SaveChanges();

                return(Ok(usuario));
            }

            return(BadRequest());
        }
示例#19
0
        public async Task <IActionResult> AdicionarPessoa(Pessoa pessoa, IFormFile foto)
        {
            if (ModelState.IsValid)
            {
                if (foto != null)
                {
                    string diretorio = Path.Combine(_webHostEnvironment.WebRootPath, "imagens");
                    string Fotonome  = Guid.NewGuid().ToString() + foto.FileName;

                    using (FileStream fileStream = new FileStream(Path.Combine(diretorio, Fotonome), FileMode.Create))
                    {
                        await foto.CopyToAsync(fileStream);

                        pessoa.Foto = "~/imagens/" + Fotonome;
                    }
                }
                else
                {
                    pessoa.Foto = "~/imagens/kisspng-computer-icons-user-clip-art-user-5abf13db298934.2968784715224718991702.jpg";
                }
                _contexto.Add(pessoa);
                await _contexto.SaveChangesAsync();

                TempData["Novo Contato"] = $"Contato incluido com sucesso";
                return(RedirectToAction(nameof(Index)));
            }
            return(View(pessoa));
        }
        public async Task ImportarDados(ExcelWorksheet worksheet, int rowCount, int colCount)
        {
            int contador = 1;

            for (int row = 2; row <= rowCount; row++)
            {
                Product product = new Product();
                for (int col = 1; col <= colCount; col++)
                {
                    if (col == 1)
                    {
                        product.Id = Guid.NewGuid();
                    }
                    if (col == 2)
                    {
                        product.Name = worksheet.Cells[row, col].Value.ToString();
                    }
                    if (col == 3)
                    {
                        product.Price = Convert.ToDecimal(worksheet.Cells[row, col].Value);
                    }
                }

                _context.Add(product);
                _context.SaveChanges();

                await WriteOnStream("Registro.: " + Convert.ToString(contador) + " de " + Convert.ToString(rowCount), rowCount.ToString(), Convert.ToString(contador));

                contador++;
            }
        }
示例#21
0
        public async Task <IActionResult> Create([Bind("PessoaId,Nome,Foto")] Pessoa pessoa, IFormFile imagem)
        {
            if (ModelState.IsValid)
            {
                //Converte e salva no banco
                if (imagem != null)
                {
                    byte[] b;

                    using (var x = imagem.OpenReadStream())
                    {
                        using (var ms = new MemoryStream())
                        {
                            x.CopyTo(ms);
                            b = ms.ToArray(); //Converte pra byte
                        }
                    }
                    pessoa.Foto = b;
                }

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

                return(RedirectToAction(nameof(Index)));
            }
            return(View(pessoa));
        }
示例#22
0
        public async Task <IActionResult> Create([Bind("ImagemId,Link,AlbumId")] Imagem imagem, IFormFile arquivo)
        {
            if (ModelState.IsValid)
            {
                var linkUpload = Path.Combine(_environment.WebRootPath, "Imagens");

                if (arquivo != null)
                {
                    //Salva imagem
                    using (var fileStream = new FileStream(Path.Combine(linkUpload, arquivo.FileName), FileMode.Create))
                    {
                        await arquivo.CopyToAsync(fileStream);

                        imagem.Link = "~/Imagens/" + arquivo.FileName;
                    }
                }

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

                return(RedirectToAction("Details", "Albums", new { id = imagem.AlbumId }));
            }
            ViewData["AlbumId"] = new SelectList(_context.Albums, "AlbumId", "Destino", imagem.AlbumId);
            return(View(imagem));
        }
        public async Task <IActionResult> Create([Bind("CPFcliente,NomeCliente,EmailCliente,TelefoneCliente,CEPcliente,StatusId")] Cliente cliente)
        {
            cliente.CPFcliente = cpfUser;
            try
            {
                if (ModelState.IsValid)
                {
                    var existeCliente = _context.Clientes.Where(c => c.NomeCliente == cliente.NomeCliente && c.StatusId == 1).Select(c => c.NomeCliente).FirstOrDefault();
                    if (existeCliente == null)
                    {
                        _context.Add(cliente);
                        await _context.SaveChangesAsync();

                        return(RedirectToAction(nameof(Index)));
                    }
                    else
                    {
                        ViewData["StatusId"] = new SelectList(_context.Status, "StatusId", "NomeStatus");

                        TempData["msgSucesso"] = "Nome já existente em nosso banco de dados!";
                        return(View());
                    }
                }
            }
            catch (Exception ex)
            {
                ViewData["StatusId"] = new SelectList(_context.Status, "StatusId", "NomeStatus");

                TempData["msgSucesso"] = "Erro na sua solicitação, favor tentar novamente!";
                return(View());
            }

            ViewData["StatusId"] = new SelectList(_context.Status, "StatusId", "NomeStatus", cliente.StatusId);
            return(View(cliente));
        }
        public async Task <IActionResult> Create([Bind("CPF,NomeJornaleiro,EmailJornaleiro,TelefoneJornaleiro,SenhaJornaleiro,StatusId, TipoId")] Jornaleiro jornaleiro)
        {
            ModelState.Remove("CPF");
            try
            {
                if (ModelState.IsValid)
                {
                    var emailOrName = _context.Jornaleiros.Where(j => j.EmailJornaleiro == jornaleiro.EmailJornaleiro || j.NomeJornaleiro == jornaleiro.NomeJornaleiro && j.StatusId == 1).Select(j => j.EmailJornaleiro).FirstOrDefault();
                    if (emailOrName == null)
                    {
                        jornaleiro.CPF = cpfUser;
                        _context.Add(jornaleiro);
                        await _context.SaveChangesAsync();

                        return(RedirectToAction(nameof(Index)));
                    }
                    else
                    {
                        TempData["msgSucesso"] = "E-mail ou nome de jornaleiro já cadastrado!";
                    }
                }
                ViewData["StatusId"] = new SelectList(_context.Status, "StatusId", "NomeStatus", jornaleiro.StatusId);
                ViewData["TipoId"]   = new SelectList(_context.Tipos, "TipoId", "NomeTipo");

                return(View(jornaleiro));
            }
            catch (Exception ex)
            {
                TempData["msgSucesso"] = "Erro na sua solicitação, favor tentar novamente!";
                ViewData["StatusId"]   = new SelectList(_context.Status, "StatusId", "NomeStatus", jornaleiro.StatusId);
                ViewData["TipoId"]     = new SelectList(_context.Tipos, "TipoId", "NomeTipo");

                return(View(jornaleiro));
            }
        }
示例#25
0
        public async Task <IActionResult> Create([Bind("PessoaId,Nome,Foto")] Pessoa pessoa, IFormFile Image)
        {
            if (ModelState.IsValid)
            {
                if (Image != null)
                {
                    byte[] b;
                    using (var or = Image.OpenReadStream())
                    {
                        using (var ms = new MemoryStream())
                        {
                            or.CopyTo(ms);
                            b           = ms.ToArray();
                            pessoa.Foto = b;
                        }
                    }
                }

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

                return(RedirectToAction(nameof(Index)));
            }
            return(View(pessoa));
        }
        public static bool Insertar(Usuarios usuario)
        {
            bool     insertado = false;
            Contexto contexto  = new Contexto();

            try
            {
                usuario.Clave = GetAESEncryption(usuario.Clave);

                if (contexto.Add(usuario) != null)
                {
                    insertado = contexto.SaveChanges() > 0;
                }
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                contexto.Dispose();
            }

            return(insertado);
        }
        public async Task <IActionResult> CriarPessoa(Pessoa pessoa, IFormFile foto)
        {
            if (ModelState.IsValid)
            {
                if (foto != null)
                {
                    string diretorio = Path.Combine(_webHostEnvironment.WebRootPath, "img");
                    string nomeFoto  = Guid.NewGuid().ToString() + foto.FileName;

                    using (FileStream fileStream = new FileStream(Path.Combine(diretorio, nomeFoto), FileMode.Create))
                    {
                        await foto.CopyToAsync(fileStream);

                        pessoa.Foto = "~/img/" + nomeFoto;
                    }
                }
                else
                {
                    pessoa.Foto = "~/img/usuario.png";
                }
                _contexto.Add(pessoa);
                await _contexto.SaveChangesAsync();

                TempData["ContatoNovo"] = $"Contato com nome {pessoa.Nome} {pessoa.Sobrenome} incluido com sucesso";
                return(RedirectToAction(nameof(Index)));
            }
            return(View(pessoa));
        }
示例#28
0
        public async Task <IActionResult> EnviarSolic([Bind("UsuarioId,Login,Senha,Email,CursoId,NomeUsuario,CargoId")] Usuario usuario)
        {
            try
            {
                int IdBanco       = 0;
                var stats         = _contexto.Status.Where(x => x.NomeStatus == "pendente").FirstOrDefault();
                var emailRepetido = _contexto.Usuarios.Select(u => u.Email).Contains(usuario.Email);
                var loginRepetido = _contexto.Usuarios.Select(u => u.Login).Contains(usuario.Login);
                IdBanco = stats.StatusId;
                var idUser = _contexto.Usuarios.Count() + 1;
                if (emailRepetido == true)
                {
                    TempData["msgSucesso"] = "E-mail já consta em nossa base de dados, favor insira outro e-mail";
                    return(RedirectToAction("GerarSenha"));
                }
                if (loginRepetido == true)
                {
                    TempData["msgSucesso"] = "Login já consta em nossa base de dados, favor insira outro Login";
                    return(RedirectToAction("GerarSenha"));
                }

                usuario.StatusId = 2;
                _contexto.Add(usuario);
                TempData["msgSucesso"] = "Solicitação enviada com sucesso";
                await _contexto.SaveChangesAsync();

                return(RedirectToAction("Logar"));
            }
            catch
            {
                TempData["msgSucesso"] = "Ocorreu um erro na sua solicitação, favor contate o administrador do site";
                return(RedirectToAction("GerarSenha"));
            }
        }
        public async Task <IActionResult> Create([Bind("ProdutoId,NomeProduto,ValorProduto,QuantideProduto,TipoProdId")] Produto produto)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    var produtoExist = _context.Produto.Where(p => p.NomeProduto == produto.NomeProduto).Select(p => p.NomeProduto).FirstOrDefault();
                    if (produtoExist == null)
                    {
                        _context.Add(produto);
                        await _context.SaveChangesAsync();

                        return(RedirectToAction(nameof(Index)));
                    }
                    else
                    {
                        ViewData["TipoProdId"] = new SelectList(_context.TipoProdutos, "TipoProdId", "NomeTipoProduto");

                        TempData["msgSucesso"] = "Nome de produto já existente!";
                    }
                }
            }
            catch (Exception)
            {
                ViewData["TipoProdId"] = new SelectList(_context.TipoProdutos, "TipoProdId", "NomeTipoProduto");

                TempData["msgSucesso"] = "Erro na sua solicitação, favor tentar novamente!";
            }

            return(View(produto));
        }
 private int gracavaoEmLote(List <Cliente> listaDeClientes)
 {
     foreach (var item in listaDeClientes)
     {
         _contexto.Add(item);
     }
     return(_contexto.SaveChanges());
 }