public async Task <IActionResult> Create([Bind("Id,Tarefa")] Profissao profissao)
        {
            if (ModelState.IsValid)
            {
                _context.Add(profissao);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View(profissao));
        }
Exemple #2
0
        public async Task <IActionResult> Create([Bind("Id,Nome")] Genero genero)
        {
            if (ModelState.IsValid)
            {
                _context.Add(genero);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View(genero));
        }
Exemple #3
0
        public async Task <IActionResult> Create([Bind("Id,Premio,FilmeFK,PessoaFK")] PessoaFilme pessoaFilme)
        {
            if (ModelState.IsValid)
            {
                _context.Add(pessoaFilme);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            ViewData["FilmeFK"]  = new SelectList(_context.Filme, "Id", "Titulo", pessoaFilme.FilmeFK);
            ViewData["PessoaFK"] = new SelectList(_context.Pessoa, "Id", "Nome", pessoaFilme.PessoaFK);
            return(RedirectToAction("Index", "Filmes"));
        }
        public async Task <IActionResult> Create([Bind("Id,FilmeFK,GeneroFK")] FilmeGenero filmeGenero)
        {
            if (ModelState.IsValid)
            {
                _context.Add(filmeGenero);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            ViewData["FilmeFK"]  = new SelectList(_context.Filme, "Id", "Titulo", filmeGenero.FilmeFK);
            ViewData["GeneroFK"] = new SelectList(_context.Genero, "Id", "Nome", filmeGenero.GeneroFK);
            return(View(filmeGenero));
        }
        public async Task <IActionResult> Create([Bind("Id,Estado,UtilIdFK,FilFK")] UtilFilme utilFilme)
        {
            utilFilme.UtilIdFK = _userManager.GetUserId(User);


            if (ModelState.IsValid)
            {
                _context.Add(utilFilme);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            ViewData["FilFK"] = new SelectList(_context.Filme, "Id", "Titulo", utilFilme.FilFK);
            return(View(utilFilme));
        }
Exemple #6
0
        public async Task CreateGestorAsync(WatchListDbContext context, UserManager <ApplicationUser> userManager)
        {
            const string nome     = "gestor";
            const string email    = "*****@*****.**";
            const string password = "******";



            var user = new ApplicationUser
            {
                UserName       = email,
                Email          = email,
                DataRegisto    = DateTime.Now,
                EmailConfirmed = true, // o email está confirmado
            };

            if (!userManager.Users.Contains <ApplicationUser>(user))
            {
                var util = new Watch_List.Models.Utilizador

                {
                    Email    = email,
                    Id       = 1,
                    Nome     = nome,
                    UtilIdFK = user.Id,
                };
                var result = await userManager.CreateAsync(user, password);

                if (result.Succeeded)
                {
                    await userManager.AddToRoleAsync(user, "Gestor");
                }
                context.Add(context.Utilizador); // adicionar o utilizador
                await context.SaveChangesAsync();
            }
        }
        public async Task <IActionResult> Create([Bind("Id,Nome,Foto,DataNasc,DataObi,DataInic,Nacionalidade,ProfissaoFK")] Pessoa pessoa, IFormFile imagem)
        {
            if (pessoa.ProfissaoFK < 0)
            {
                // não foi escolhido uma profissao válida
                ModelState.AddModelError("", "Não se esqueça de escolher uma profissão...");
                // devolver o controlo à View
                var profissao = (from pr in _context.Profissao
                                 join p in _context.Pessoa on pr.Id equals p.ProfissaoFK
                                 select pr)
                                .OrderBy(pr => pr.Tarefa);

                ViewData["ProFK"] = new SelectList(profissao, "Id", "Tarefa");
                return(View(pessoa));
            }
            // var auxiliar
            string caminhoCompleto = "";


            if (imagem == null)
            {
                // não há ficheiro
                // adicionar msg de erro
                ModelState.AddModelError("", "Adicione uma fotografia, por favor");
                // devolver o controlo à View
                var profissao = (from pr in _context.Profissao
                                 join p in _context.Pessoa on pr.Id equals p.ProfissaoFK
                                 select pr)
                                .OrderBy(pr => pr.Tarefa);

                ViewData["ProFK"] = new SelectList(profissao, "Id", "Tarefa");

                return(View(pessoa));
                //pessoa.Foto = "noimage.png";
            }
            else
            {
                // há ficheiro. Mas, será um ficheiro válido?
                if (imagem.ContentType == "image/jpeg" || imagem.ContentType == "image/png" || imagem.ContentType == "image/jpg")
                {
                    // definir o novo nome da fotografia
                    Guid g;
                    g = Guid.NewGuid();
                    caminhoCompleto = g.ToString(); // determinar a extensão do nome da imagem

                    string extensao = Path.GetExtension(imagem.FileName).ToLower();
                    // caminho completo do ficheiro
                    caminhoCompleto = caminhoCompleto + extensao;

                    // associar este ficheiro aos dados ds foto
                    pessoa.Foto = caminhoCompleto;

                    // localização do armazenamento da imagem
                    string localizacaoFicheiro = _caminho.WebRootPath;
                    caminhoCompleto = Path.Combine(localizacaoFicheiro, "Imagens", caminhoCompleto);
                }
                else
                {
                    // ficheiro não é válido
                    // adicionar msg de erro
                    ModelState.AddModelError("", "Só pode escolher uma imagem");
                    // devolver o controlo à View
                    var profissao = (from pr in _context.Profissao
                                     join p in _context.Pessoa on pr.Id equals p.ProfissaoFK
                                     select pr)
                                    .OrderBy(pr => pr.Tarefa);

                    ViewData["ProFK"] = new SelectList(profissao, "Id", "Tarefa");
                    return(View(pessoa));
                }
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Add(pessoa);
                    await _context.SaveChangesAsync();

                    // vou guardar, agora, no disco rígido do Servidor a imagem
                    using var stream = new FileStream(caminhoCompleto, FileMode.Create);
                    await imagem.CopyToAsync(stream);

                    return(RedirectToAction(nameof(Index)));
                }
                catch (Exception)
                {
                    ModelState.AddModelError("", "Ocorreu um erro...");
                }
            }
            ViewData["ProFK"] = new SelectList(_context.Profissao.OrderBy(pr => pr.Tarefa), "Id", "Tarefa", pessoa.ProfissaoFK);

            return(View(pessoa));
        }
Exemple #8
0
        public async Task <IActionResult> Create([Bind("Id,Titulo,Ano,Resumo,Poster,Trailer")] Filme filme, IFormFile foto)
        {
            string caminhoCompleto = "";
            bool   haImagem        = false;

            // avaliar se  o utilizador escolheu uma opção válida na dropdown
            /******************************************/


            if (foto == null)
            {
                // não há ficheiro!

                filme.Poster = "noimage.png";
            }
            else
            {
                // há ficheiro.

                if (foto.ContentType == "image/jpeg" || foto.ContentType == "image/png")
                {
                    //existe imagem

                    Guid g;
                    g = Guid.NewGuid();
                    // identificar a Extensão do ficheiro
                    string extensao = Path.GetExtension(foto.FileName).ToLower();
                    // nome do ficheiro
                    string nome = g.ToString() + extensao;


                    // Identificar o caminho onde o ficheiro vai ser guardado
                    caminhoCompleto = Path.Combine(_caminho.WebRootPath, "Imagens", nome);
                    // associar o nome da fotografia
                    filme.Poster = nome;
                    // assinalar que existe imagem
                    haImagem = true;
                }
                else
                {
                    filme.Poster = "noimage.png";
                }
            }
            if (ModelState.IsValid)
            {
                try {
                    _context.Add(filme);
                    await _context.SaveChangesAsync();

                    if (haImagem)
                    {
                        using var stream = new FileStream(caminhoCompleto, FileMode.Create);
                        await foto.CopyToAsync(stream);
                    }

                    // redireciona o utilizador para a View Index
                    return(RedirectToAction(nameof(Index)));
                }
                catch (Exception)
                {
                    ModelState.AddModelError("", "Ocorreu um erro...");
                }
            }

            ViewData["ListFilmes"] = new SelectList(_context.Filme.OrderBy(c => c.Titulo), "Id", "Titulo", foto);

            return(View(filme));
        }