public async Task <IActionResult> Create([Bind("EvId,Titulo,Data,Preco,LocalFK")] Evento evento, PromotorEvento prEv)
        {
            if (ModelState.IsValid)
            {
                _context.Add(evento);
                await _context.SaveChangesAsync();

                //relacionar evento ao promotor que o criou
                prEv.EventoFK   = _context.Evento.Where(b => b.Titulo == evento.Titulo).Select(b => b.EvId).FirstOrDefault();
                prEv.PromotorFK = _context.Promotor.Where(b => b.Nome == User.Identity.Name).Select(b => b.ID).FirstOrDefault();
                _context.Add(prEv);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            ViewData["LocalFK"] = new SelectList(_context.Local, "ID", "NomeLocal", evento.LocalFK);
            return(View(evento));
        }
        public async Task <IActionResult> Create([Bind("ID,Nome,Email,Password,Foto")] Promotor promotor)
        {
            if (ModelState.IsValid)
            {
                _context.Add(promotor);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View(promotor));
        }
        public async Task <IActionResult> Create([Bind("ID,NomeLocal,Descrição,Capacidade,Foto")] Local local)
        {
            if (ModelState.IsValid)
            {
                _context.Add(local);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View(local));
        }
        public async Task <IActionResult> Create([Bind("PromotorFK,EventoFK")] PromotorEvento promotorEvento)
        {
            if (ModelState.IsValid)
            {
                _context.Add(promotorEvento);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            ViewData["EventoFK"]   = new SelectList(_context.Evento, "EvId", "EvId", promotorEvento.EventoFK);
            ViewData["PromotorFK"] = new SelectList(_context.Promotor, "ID", "ID", promotorEvento.PromotorFK);
            return(View(promotorEvento));
        }
        public async Task <IActionResult> Create([Bind("TicketID,email,Descrição,DataCompra,EventoFK2,Preco,IDFK")] Bilhete bilhete)
        {
            if (ModelState.IsValid)
            {
                //encontrar o ID Utilizador do user autenticado, adicionar data de compra e criar o bilhete
                bilhete.IDFK       = _context.Utilizador.Where(b => b.Nome == User.Identity.Name).Select(b => b.UserID).FirstOrDefault();
                bilhete.email      = User.Identity.Name;
                bilhete.DataCompra = DateTime.Now;
                _context.Add(bilhete);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            ViewData["EventoFK2"] = new SelectList(_context.Set <Evento>(), "EvId", "EvId", bilhete.EventoFK2);
            ViewData["IDFK"]      = new SelectList(_context.Set <Utilizador>(), "UserID", "UserID", bilhete.IDFK);
            return(View(bilhete));
        }
Exemplo n.º 6
0
        public async Task <IActionResult> OnPostAsync([FromForm(Name = "fotoUser")] IFormFile fotoUser, string returnUrl = null)
        {
            returnUrl      = returnUrl ?? Url.Content("~/");
            ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
            var role = _roleManager.FindByIdAsync(Input.Name).Result;

            //processar a fotografia
            string caminhoCompleto = "";
            bool   haImagem        = false;

            if (fotoUser == null)
            {
                Input.Foto = "noUser.jpg";
            }
            else
            {
                //sera o ficheiro uma imagemc
                if (fotoUser.ContentType == "image/jpeg" || fotoUser.ContentType == "image/png")
                {
                    //o ficheiro é uma imagem valida
                    //prepara a imagem para ser guardada no disco e o seu nome associado ao utilizador
                    Guid g;
                    g = Guid.NewGuid();
                    string extensao = Path.GetExtension(fotoUser.FileName).ToLower();
                    string nome     = g.ToString() + extensao;
                    //onde guardar o ficheiro
                    caminhoCompleto = Path.Combine(_caminho.WebRootPath, "Imagens\\Users", nome);
                    //associar o nome do ficheiro ao utilizador
                    Input.Foto = nome;
                    //assinalar que existe imagem e é preciso guarda-la no disco
                    haImagem = true;
                }
                else
                {
                    Input.Foto = "noUser.jpg";
                }
            }

            //criar um novo usuario na tabela respetiva dependendo do role
            if (role.Name.Equals("Utilizador"))
            {
                var user2 = new Models.Utilizador {
                    Nome = Input.Email, Email = Input.Email, Foto = Input.Foto, Password = Input.Password
                };

                /* var nome = _context.Utilizador.Where(p => p.Nome == Input.Email).FirstOrDefault();
                 * if(nome != null)
                 * {
                 *
                 * }
                 */
                _context.Add(user2);
            }
            else if (role.Name.Equals("Promotor"))
            {
                var user = new Models.Promotor {
                    Nome = Input.Email, Email = Input.Email, Foto = Input.Foto, Password = Input.Password
                };
                _context.Add(user);
            }
            else if (role.Name.Equals("Admin") && Input.Email.Contains("@t_eagle.com"))
            {
                //se pode ser admin se for do dominio da empresa (email confirmado)
                //se for admin precisa de ter dados utilizador e promotor
                var u = new Models.Utilizador {
                    Nome = Input.Email, Email = Input.Email, Foto = Input.Foto, Password = Input.Password
                };
                var u2 = new Models.Promotor {
                    Nome = Input.Email, Email = Input.Email, Foto = Input.Foto, Password = Input.Password
                };
                _context.Add(u);
                _context.Add(u2);
            }

            if (ModelState.IsValid)
            {
                var user = new TicketEagleUser {
                    UserName = Input.Email, Email = Input.Email, Nome = Input.Name
                };
                var result = await _userManager.CreateAsync(user, Input.Password);

                //guardar imagem em disco
                if (haImagem)
                {
                    using var stream = new FileStream(caminhoCompleto, FileMode.Create);
                    await fotoUser.CopyToAsync(stream);
                }

                if (result.Succeeded)
                {
                    _logger.LogInformation("User created a new account with password.");
                    await _userManager.AddToRoleAsync(user, role.Name);

                    var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);

                    code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
                    var callbackUrl = Url.Page(
                        "/Account/ConfirmEmail",
                        pageHandler: null,
                        values: new { area = "Identity", userId = user.Id, code = code, returnUrl = returnUrl },
                        protocol: Request.Scheme);

                    await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
                                                      $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");

                    if (_userManager.Options.SignIn.RequireConfirmedAccount)
                    {
                        return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
                    }
                    else
                    {
                        await _signInManager.SignInAsync(user, isPersistent : false);

                        ViewData["roles"] = new SelectList(_context.Roles, "Id", "Name");
                        return(LocalRedirect(returnUrl));
                    }
                    // await _signInManager.SignInAsync(user, isPersistent: false);
                    // return LocalRedirect(returnUrl);
                }
                foreach (var error in result.Errors)
                {
                    ViewData["roles"] = new SelectList(_context.Roles, "Id", "Name");
                    ModelState.AddModelError(string.Empty, error.Description);
                }
            }

            // If we got this far, something failed, redisplay form
            return(Page());
        }