public async Task <IActionResult> Edit(int id, [Bind("Id,Nome,Email")] Utilizadores utilizadores)
{
if (id != utilizadores.Id)
{
return(RedirectToAction("Index"));
}
if (ModelState.IsValid)
{
try
{
_context.Update(utilizadores);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UtilizadoresExists(utilizadores.Id))
{
return(RedirectToAction("Index"));
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(utilizadores));
}
// GET: Utilizadores/Details/5
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Utilizadores utilizadores = await db.Utilizadores.FindAsync(id);
if (utilizadores == null)
{
return(HttpNotFound());
}
if (User.IsInRole("Gestor") ||
utilizadores.Email == User.Identity.Name)
{
// envia os dados do AGENTE para a View
return(View(utilizadores));
}
else
{
// estou a tentar aceder a dados não autorizados
return(RedirectToAction("Index"));
}
}
public async Task <ActionResult> Register([Bind(Include = "ID,NomeUtilizador,Nome")] Utilizadores Utilizador, RegisterViewModel model)
{
Utilizador.NomeUtilizador = model.Email;
if (ModelState.IsValid)
{
//Adiconar o utilizador a BD
db.Utilizadores.Add(Utilizador);
db.SaveChanges();
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
//adicionar utilizador a role "Utilizadores"
var RoleResult = await UserManager.AddToRoleAsync(user.Id, "Utilizadores");
var code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking this link: <a href=\"" + callbackUrl + "\">link</a>");
ViewBag.Link = callbackUrl;
return(View("DisplayEmail"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public static List <Avaria> Index()
{
Utilizador uti = Utilizadores.Autenticado();
List <Avaria> avarias = Avarias.Where("utilizador_id", "=", uti.Id);
return(avarias);
}
// GET: Utilizadores/Edit/5
public ActionResult Edit(int?id)
{
//como int? indica que o id pode ser null
//verificar se o id é null
if (id == null)
{
//redirecionar para a pagina inicial
return(RedirectToAction("Index", "Noticias"));
}
//pesquisar pelo utilizador
Utilizadores utilizadores = db.Utilizadores.Find(id);
//se o utilizador nao existir
if (utilizadores == null)
{
//redirecionar para a pagina inicial
return(RedirectToAction("Index", "Noticias"));
}
Session["UtilizadorID"] = utilizadores.ID;
Session["UtilizadorAvatar"] = utilizadores.Avatar;
//verificar se o utilizador é o utilizador logado
if (utilizadores.Username.Equals(User.Identity.Name))
{
return(View(utilizadores));
}
//se nao for o utilizador logado
else
{
//redirecionar para a pagina inicial
return(RedirectToAction("Index", "Noticias"));
}
}
public ActionResult Create([Bind(Include = "ContComment")] Comments comments, int id)
{
if (ModelState.IsValid)
{
//Buscar o User associado e o clip
Utilizadores user = db.Utilizadores.SingleOrDefault(u => u.Email.Equals(User.Identity.Name));
Clips clip = db.Clips.Find(id);
//retorna uma view de erro se nao encontrar o user ou o clip
if (user == null || clip == null)
{
return(HttpNotFound());
}
//Criar o comentario
var comment = new Comments
{
ContComment = comments.ContComment,
DateComment = DateTime.UtcNow,
ClipsFK = clip.ID,
UtilizadoresFK = user.ID
};
//Adiciona a base de dados e Guarda
db.Comments.Add(comment);
db.SaveChanges();
return(View());
}
//Se o modelo nao tiver valiado apresentar erro
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
// GET: Utilizadores/Details/5
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult Details(int?id)
{
// se se escrever 'int?' é possível
// não fornecer o valor para o ID e não há erro
// proteção para o caso de não ter sido fornecido um ID válido
if (id == null)
{
// instrução original
// devolve um erro qd não há ID
// logo, não é possível pesquisar por um Utilizador
// return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
// redirecionar para uma página que nós controlamos
return(RedirectToAction("Index"));
}
// procura na BD, o Utilizador cujo ID foi fornecido
Utilizadores utilizador = db.Utilizadores.Find(id);
// proteção para o caso de não ter sido encontrado qq Utilizador
// que tenha o ID fornecido
if (utilizador == null)
{
// o utilizador não foi encontrado
// logo, gera-se uma msg de erro
// return HttpNotFound();
// redirecionar para uma página que nós controlamos
return(RedirectToAction("Index"));
}
// entrega à View os dados do Utilizador encontrado
return(View(utilizador));
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Username,DataNascimento,Descricao,Avatar,Email")] Utilizadores utilizadores)
{
if (id != utilizadores.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(utilizadores);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UtilizadoresExists(utilizadores.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(utilizadores));
}
public ActionResult DeleteConfirmed(int id)
{
//Ir buscar o User e o Clip a base de dados
Utilizadores user = db.Utilizadores.SingleOrDefault(u => u.Email.Equals(User.Identity.Name));
Clips clips = db.Clips.Find(id);
//Se for Admin pode apagar qualquer Clip antes da verificacao do User == null && comment == null
//porque o admin nao e um Utilizador normal da aplicação
if (User.IsInRole("Admin"))
{
db.Clips.Remove(clips);
db.SaveChanges();
}
//Verifica se tanto o user como o clip existem e retorna 404 se nao encontrar algum dos dois
if (user == null || clips == null)
{
return(HttpNotFound());
}
//Verificar se o utilizador Autenticado e mesmo o dono do Clips, se for autoriza-se e concretiza-se a remoção
if (user.ID.Equals(clips.UserFK))
{
db.Clips.Remove(clips);
db.SaveChanges();
//return RedirectToAction("Index");
}
else
{
//Erro porque o comment nao e dele
}
return(View(clips));
}
public Boolean validate(HttpPostedFileBase file)
{
//se normal get last post datetime adicionar 7 dias
if (User.IsInRole("Normal"))
{
Utilizadores user1 = db.Utilizadores.SingleOrDefault(u => u.Email.Equals(User.Identity.Name));
Clips lastClip = user1.ListClips.Last();
DateTime validade = lastClip.DateClip.AddDays(7);
if (DateTime.Now >= validade && file.ContentLength < 10485760)
{
return(true);
}
else
{
return(false);
}
}
if (User.IsInRole("Premium"))
{
Utilizadores user1 = db.Utilizadores.SingleOrDefault(u => u.Email.Equals(User.Identity.Name));
Clips lastClip = user1.ListClips.Last();
DateTime validade = lastClip.DateClip.AddDays(7);
if (file.ContentLength < (10485760) * (2))
{
return(true);
}
else
{
return(false);
}
}
//se nao é nenhum dos roles
return(false);
}
public async Task <IActionResult> Edit(int id, [Bind("ID,NomeUser,Email,Localidade,Bio,UserId")] Utilizadores utilizadores)
{
if (id != utilizadores.ID)
{
return(NotFound());
}
var idUser = await _context.Utilizadores
.Where(e => e.UserId == _userManager.GetUserId(User))
.Select(e => e.UserId)
.FirstOrDefaultAsync();
utilizadores.UserId = idUser;
//if (ModelState.IsValid)
// {
try
{
_context.Update(utilizadores);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UtilizadoresExists(utilizadores.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(Redirect("~/Utilizadores/Details/" + utilizadores.ID));
// }
// return Redirect("~/Utilizadores/Details/" + utilizadores.ID);
}
public static List <Contrato> TodasLeituras()
{
Utilizador utilizador = Utilizadores.Autenticado();
List <Contrato> contratos = Contratos.Where("utilizador_id", "=", utilizador.Id.ToString());
return(contratos);
}
public ActionResult DeleteConfirmed(int id)
{
//Ir buscar o User e o Comment a base de dados
Utilizadores user = db.Utilizadores.SingleOrDefault(u => u.Email.Equals(User.Identity.Name));
Comments comments = db.Comments.Find(id);
//Se for Admin pode apagar qualquer Comment antes da verificacao do User == null && comment == null
//porque o admin nao e um Utilizador mas sim um User da Identity
if (User.IsInRole("Admin"))
{
db.Comments.Remove(comments);
db.SaveChanges();
return(RedirectToAction("Details", "Clips", new { id = comments.ClipsFK }));
}
//Verificar se eles existem
if (user == null || comments == null)
{
return(HttpNotFound());
}
//Verificar se o utilizador Autenticado e mesmo o dono do Comment, se for realiza-se a remoção
if (user.ID.Equals(comments.UtilizadoresFK))
{
db.Comments.Remove(comments);
db.SaveChanges();
return(RedirectToAction("Details", "Clips", new { id = comments.ClipsFK }));
}
else
{
return(new HttpStatusCodeResult(400));
}
}
public async Task <IActionResult> EditFuncionarios(int id, [Bind("UtilizadorId,Nome,Nif,DataNascimento,Morada,Telemovel,Email,CodigoPostal,Role")] Utilizadores utilizadores)
{
if (id != utilizadores.UtilizadorId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(utilizadores);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UtilizadoresExists(utilizadores.UtilizadorId))
{
return(NotFound());
}
else
{
throw;
}
}
}
ViewBag.Mensagem = "Informação do Funcionario editada com sucesso.";
return(View("SucessoFuncionarios"));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email,
Email = model.Email
//NomeProprio = model.NomeProprio,
//Apelido = model.Apelido,
//DataDeNascimento = model.DataDeNascimento,
//NIF = model.NIF
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
try
{
//se houve sucesso com a criação do utilizador
//tenho de guardar os dados do utilizador
Utilizadores utilizador = new Utilizadores();
utilizador = model.utilizador;
//associar estes dados com o utilizador q se registou
utilizador.NomeRegistoDoUtilizador = user.UserName;
//guardar oss dados na BD
ApplicationDbContext db = new ApplicationDbContext();
db.Utilizadores.Add(utilizador);
db.SaveChanges();
}
catch (Exception)
{
//eventualmente, apagar o utilizador que acabu de se registar
//eventualmente, numa tabela da BD o erro
// -nome do controller
// -nome do metodo
// -data
// -hora
// -mensagem gerada pelo erro
// -outros dados
//eventualmente, enviar email ao gestor do sistema com o relato do problema
//eventualmente, reenviar à view para reescrever os dados
}
var code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking this link: <a href=\"" + callbackUrl + "\">link</a>");
ViewBag.Link = callbackUrl;
return(View("DisplayEmail"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public ActionResult DeleteConfirmed(int id)
{
Utilizadores utilizadores = db.Utilizadores.Find(id);
db.Utilizadores.Remove(utilizadores);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public static Leitura Add(int valor, Contrato contrato)
{
Utilizador uti = Utilizadores.Autenticado();
DateTime data = DateTime.Now;
Leitura leitura = Leituras.Novo(valor, data, contrato);
return(leitura);
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Utilizadores utilizadores = await db.Utilizadores.FindAsync(id);
db.Utilizadores.Remove(utilizadores);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Register([Bind(Include = "ID,Name,BirthDate,MobileNumber,Description,Email,Sexo")] Utilizadores utilizador, RegisterViewModel model)
{
//Igualar os Emails tanto da Identity como os do Model Utilizadores
utilizador.Email = model.Email;
//Se não houver Utilizadores na Base de Dados entao iremos por o ID a 1.
//try
//{
// utilizador.ID = db.Utilizadores.Max(p => p.ID) + 1;
//} catch
//{
// utilizador.ID = 1;
//}
//Criacao De Listas Vazias
utilizador.ListClips = new List <Clips>();
utilizador.ListPayments = new List <Payments>();
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
//Adicionar o Utilizador a Base de Dados e Guardar a Alteração
db.Utilizadores.Add(utilizador);
db.SaveChanges();
//Associar o utilizador a Role 'NormalUser'
var roleResult = await UserManager.AddToRoleAsync(user.Id, "Normal");
if (!roleResult.Succeeded)
{
//Pagina de Erro
//Retorna a pagina de definição
return(View(model));
}
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email,
Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
try
{
/// se houve sucesso com a criação de um utilizador
/// tenho de guardar os dados do utilizador que se registou
Utilizadores utilizador = new Utilizadores();
utilizador = model.Utilizador;
// associar estes dados com o utilizador q se registou
utilizador.NomeRegistoDoUtilizador = user.UserName;
// guardar os dados na base de dados
MvcFolhetos.Models.ApplicationDbContext db = new MvcFolhetos.Models.ApplicationDbContext();
db.Utilizadores.Add(utilizador);
db.SaveChanges();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Nao foram guardados os dados do utilizador");
/// eventualmente, apagar o utilizador que se acabou de registar
/// eventualmente, registar numa tabela da BD o erro
/// - o nome do controller
/// - o nome do método
/// - a data
/// - a hora
/// - a mensagem de erro (ex.message)
/// - outros dados considerados relevantes
/// eventualmente, enviar email ao Gestor do Sistema com o relato da ocorrência
/// eventualmente, reenviar à view para reescrever os dados
}
//Calling the ASP.NET Identity API
var code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking this link: <a href=\"" + callbackUrl + "\">link</a>");
ViewBag.Link = callbackUrl;
return(View("DisplayEmail"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
static void Main(string[] args)
{
Console.WriteLine("A iniciar teste!");
//Log.PrintLog();
//Console.WriteLine("---------------Pedidos pelo NIF-------------------------");
////Todos os pedidos são por nif
//Servico municipio1 = new Servico("utilizadores");
//Utilizador u = (Utilizador)municipio1.Pedir(215532546);
//Console.WriteLine(u.Nome);
//Servico municipio2 = new Servico("faturas");
//Fatura f = (Fatura)municipio2.Pedir(215532546);
//Console.WriteLine(f.Valor + "Euros");
//Servico municipio3 = new Servico("contratos");
//Contrato c = (Contrato)municipio3.Pedir(215532546);
//Console.WriteLine(c.Codigo);
//Console.WriteLine("------------------Todos os Elementos----------------------");
//List<object> todos = municipio1.PedirTodos();
//foreach (Utilizador item in todos)
//{
// Console.WriteLine("--------------" + item.Nif + "--------------");
// Console.WriteLine(item.Nome);
// Console.WriteLine(item.Email);
// Console.WriteLine("--------------------------------------------");
//}
//Console.WriteLine("------------------Todos os Elementos por NIF----------------------");
//List<object> todosNif = municipio2.PedirTodos(215532546);
//foreach (Fatura item2 in todosNif)
//{
// Console.WriteLine("--------------" + item2.Data + "--------------");
// Console.WriteLine(item2.Valor + " Euros");
// Console.WriteLine(item2.Id);
// Console.WriteLine("--------------------------------------------");
//}
Console.WriteLine(Utilizadores.PedidoAcesso("264628773", "*****@*****.**").ToString());
DateTime data = DateTime.Now;
Utilizadores.Novo("*****@*****.**", data, "ze", "ze1234", "917920418", "12345678", TiposUtilizador.GetById(1));
Log.PrintLog();
Console.ReadLine();
}
public ActionResult Edit([Bind(Include = "ID,NomeProprio,Apelido,UserName")] Utilizadores utilizadores)
{
if (ModelState.IsValid)
{
db.Entry(utilizadores).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(utilizadores));
}
public ActionResult Edit([Bind(Include = "ID,Username,Email,DataNascimento,Descricao,Avatar")] Utilizadores utilizadores)
{
if (ModelState.IsValid)
{
db.Entry(utilizadores).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(utilizadores));
}
/// <summary>
/// Insere o utilizador se não existir
/// </summary>
/// <param name="novoUtilizador"></param>
/// <returns></returns>
public static bool InsereUtilizador(Utilizador novoUtilizador)
{
//verifica se o determinado filme já existe
if (Utilizadores.ExisteUtilizador(novoUtilizador))
{
return(false);
}
return(Utilizadores.InsereUtilizador(novoUtilizador));
}
public ActionResult Edit([Bind(Include = "ID,Name,BirthDate,MobileNumber,Description,Email,Sexo")] Utilizadores utilizadores)
{
if (ModelState.IsValid)
{
db.Entry(utilizadores).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(utilizadores));
}
public ActionResult Edit([Bind(Include = "ID,UserName,NomeCompleto,Email,ContactoTelefonico,DataNascimento")] Utilizadores utilizadores)
{
if (ModelState.IsValid)
{
db.Entry(utilizadores).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(utilizadores));
}
public ActionResult Create([Bind(Include = "ID,UserName,NomeCompleto,Email,ContactoTelefonico,DataNascimento")] Utilizadores utilizadores)
{
if (ModelState.IsValid)
{
db.Utilizadores.Add(utilizadores);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(utilizadores));
}
public ActionResult Create([Bind(Include = "ID,NomeProprio,Apelido,UserName")] Utilizadores utilizadores)
{
if (ModelState.IsValid)
{
db.Utilizadores.Add(utilizadores);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(utilizadores));
}
public ActionResult Registar([Bind(Include = "UtilizadorID,Nome,Email,Morada,CodPostal,NIF,Contacto,Imagem")] Utilizadores conta)
{
if (ModelState.IsValid)
{
db.Utilizadores.Add(conta);
db.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
return(View());
}
public ActionResult Login(Utilizadores utilizador)
{
if (ModelState.IsValid)
{
using (InforQuiDB infor = new InforQuiDB())
{
}
}
return(View(utilizador));
}
