public async Task <IActionResult> UserLogin([Bind] Utilizador user)
{
ModelState.Remove("nome");
ModelState.Remove("email");
if (ModelState.IsValid)
{
var LoginStatus = this.userHandling.validateUser(user);
if (LoginStatus)
{
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, user.username)
};
ClaimsIdentity userIdentity = new ClaimsIdentity(claims, "login");
ClaimsPrincipal principal = new ClaimsPrincipal(userIdentity);
await HttpContext.SignInAsync(principal);
return(RedirectToAction("getUsers", "UserView"));
}
else
{
TempData["UserLoginFailed"] = "Login Failed.Please enter correct credentials";
}
}
return(View());
}
public void ConsultaInsertTeste(string descricao, string data, int estado, int idlocal, int idTrat, bool expected)
{
//Arrange
bool res;
UtilizadorDA metodosUtilizador = new UtilizadorDA();
ConsultaDA consultas = new ConsultaDA();
List <Utilizador> listaUtilizadoresConsulta = new List <Utilizador>();
Utilizador utente = new Utilizador();
utente = metodosUtilizador.GetUtilizador(1);
Utilizador fisioterapeuta = new Utilizador();
fisioterapeuta = metodosUtilizador.GetUtilizador(2);
listaUtilizadoresConsulta.Add(utente);
listaUtilizadoresConsulta.Add(fisioterapeuta);
Consulta consultaNova = new Consulta();
consultaNova.Descricao = descricao;
consultaNova.Data = DateTime.Parse(data);
consultaNova.Estado = estado;
consultaNova.IdLocal = idlocal;
consultaNova.IdTratamento = idTrat;
//Act
res = consultas.InsereConsulta(consultaNova, listaUtilizadoresConsulta);
//Assert
Assert.Equal(res, expected);
}
public bool DeleteUtilizador()
{
if (SelectedUtilizador.Delete() == 1)
{
if (SelectedUtilizador.Idutilizador == Utilizadores.Count)
{
Utilizadores.Remove(SelectedUtilizador);
Utilizador.ReSeed(Utilizadores.Count);
}
else
{
foreach (Utilizador u in Utilizadores)
{
if (u.Idutilizador > SelectedUtilizador.Idutilizador)
{
u.Idutilizador -= 1;
}
}
Utilizadores.Remove(SelectedUtilizador);
Utilizador.CreateFromObservableCollection(Utilizadores);
}
return(true);
}
return(false);
}
public IActionResult Add([FromBody] Utilizador user)
{
var users = new List <Utilizador>();
users.Add(user);
return(new CreatedResult($"/api/user/{user.id}", user));
}
// GET: Objectivoes/Create
public ActionResult Create()
{
var userId = Convert.ToInt32(User.Identity.GetUserId());
var actual = db.Objectivoes.FirstOrDefault(p => p.UserID == userId && p.Data_fim == null);
var objectivo = db.Objectivoes.FirstOrDefault(p => p.UserID == userId);
Utilizador user = db.Utilizadors.FirstOrDefault(o => o.UserID == userId);
if (user.Nome == null)
{
ViewBag.SemDados = "Nao tem dados inseridos";
return(View());
}
if (actual == null)
{
if (objectivo == null)
{
ViewBag.UserGuide = "Primeiro Objectivo";
}
ViewBag.UserID = new SelectList(db.Utilizadors, "UserID", "Nome");
return(View());
}
else
{
TempData["Alert"] = "Ja existe um objectivo activo. Por favor conclua o objectivo actual antes de iniciar um novo";
return(RedirectToAction("Index"));
}
}
public bool Add_Linha()
{
Utilizador u = new Utilizador();
u.Idutilizador = Utilizadores.Count + 1;
return(CreateUtilizador(u));
}
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)
{
UserManager.AddToRole(user.Id, "User");
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
Utilizador newUser = new Utilizador()
{
UserID = user.Id
};
db.Utilizadors.Add(newUser);
db.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
return(View(model));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
Utilizador usertest = new Utilizador("joao", "*****@*****.**", "password");
DAOUtilizador dao = new DAOUtilizador();
dao.Insert(ref usertest);
var user = new ApplicationUser {
UserName = model.Name, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
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("PrefCategories", "Preferences"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public override void Notificar(LoginArgs args)
{
if (args.username.Equals("") || args.password.Equals(""))
{
Erro erro = new Erro("Por favor preencha todos os campos necessários");
return;
}
Utilizador user = autenticacao.FazerLogin(args.username, args.password);
if (user == null)
{
Erro erro = new Erro("Credenciais Erradas... Username e/ou Password não correspondem, tente novamente.");
Vista.ApagarTexto();
return;
}
Vista.Hide();
Vista.Close();
if (user.Tecnico != null)
{
new MenuTecnico(user.Tecnico);
}
else if (user.GestorDeFinanciamento != null)
{
new MenuGestor(user.GestorDeFinanciamento);
}
else if (user.ComissaoDeFinanciamento != null)
{
new MenuComissao(user.ComissaoDeFinanciamento);
}
}
public static async Task <bool> AutenticaUtilizador(String email, String password)
{
if (Connectivity.NetworkAccess != NetworkAccess.None)
{
HttpClient client = new HttpClient();
HttpResponseMessage response = await client.GetAsync("https://portourgalapi2020.azurewebsites.net/api/users/email/" + email);
if (response.IsSuccessStatusCode)
{
String json = await response.Content.ReadAsStringAsync();
Utilizador u = JsonConvert.DeserializeObject <Utilizador>(json);
byte[] data = System.Text.Encoding.ASCII.GetBytes(password);
data = new System.Security.Cryptography.SHA256Managed().ComputeHash(data);
String hashpwd = System.Text.Encoding.ASCII.GetString(data);
if (u != null && u.Password == hashpwd && email == u.Email)
{
user = u; return(true);
}
else
{
return(false);
}
}
}
return(false);
}
public MessageModel LoginUtilizador(string name, string password)
{
Utilizador utilizador = db.Utilizador.FirstOrDefault(a => a.nome == name);
if (utilizador == null)
{
MessageModel m1 = new MessageModel();
m1.StatusCode = 666;
m1.Message = "Utilizador nao existente";
return(m1);
}
UtilizadorModel u = new UtilizadorModel();
u.Name = utilizador.nome;
if (Hash(password) == utilizador.password)
{
u.Id = utilizador.id;
u.Url = utilizador.url;
u.StatusCode = 200;
u.Message = "Login Efectuado com Sucesso";
return(u);
}
else
{
MessageModel m1 = new MessageModel();
m1.StatusCode = 666;
m1.Message = "Password Errada";
return(m1);
}
}
public IActionResult NewUser(Utilizador _model)
{
DbContextOptions <PortefolioContext> _options = new DbContextOptions <PortefolioContext>();
var _context = new PortefolioContext(_options);
if (ModelState.IsValid)
{
//Novo id
_model.ID = (_context.Utilizadores.Count() + 1).ToString() + "#User";
//Pass segura com Hash MD5
_model.PasswordH = Funcionalidades.GetUInt64Hash(MD5.Create(), _model.PasswordH);
//Senão conseguir gerar a hash
if (_model.PasswordH == null)
{
return(View(_model));
}
_context.Utilizadores.Add(_model);
_context.SaveChanges();
return(RedirectToAction("Login", "Account"));
}
else
{
return(View(_model));
}
}
protected void btRecuperar_Click(object sender, EventArgs e)
{
try
{
if (tbEmail.Text.Trim().Length == 0)
{
throw new Exception("Erro no email");
}
string email = tbEmail.Text;
Utilizador utilizador = new Utilizador();
DataTable dados = utilizador.devolveDadosUtilizador(email);
if (dados == null || dados.Rows.Count == 0 || dados.Rows.Count > 1)
{
throw new Exception("Erro no email");
}
Guid g = Guid.NewGuid();
utilizador.recuperarPassword(email, g.ToString());
string mensagem = "Clique no link para recuperar a sua password.<br/>";
mensagem += "<a href='http://" + Request.Url.Authority + "/recuperarPassword.aspx?";
mensagem += "id=" + Server.UrlEncode(g.ToString()) + "'>Clique aqui</a>";
string meuemail = ConfigurationManager.AppSettings["MeuEmail"].ToString();
string minhapassword = ConfigurationManager.AppSettings["MinhaPassword"].ToString();
Helper.enviarMail(meuemail, minhapassword, email, "Recuperação de password", mensagem);
lbErro.Text = "Foi enviado um email";
}
catch
{
}
}
/// <summary>
/// Inicia a conexão do Utilizador
/// </summary>
/// <param name="utilizador">Utilizador que vai iniciar conexão</param>
public void Start(Utilizador utilizador)
{
Response resLogin = new Response(Response.Operation.Login, utilizador);
Helpers.SendSerializedMessage(_tcpClient, resLogin);
// Espera pela mensagem do servidor com os dados do user.
Boolean flagHaveUser = false;
while (!flagHaveUser)
{
Response resGetUserInfo = Helpers.ReceiveSerializedMessage(_tcpClient);
UtilizadorLigado = resGetUserInfo.Utilizador;
flagHaveUser = true;
/*
* Adiciona as Unidades Curriculares do Curso e Extras à lista de Aulas para podermos abrir
* separadores de chat.
* Para isso invoca um evento que é capturado no "MainViewModel",
*/
UtilizadorLigado.Curso?.UnidadesCurriculares?.ForEach(unidadeCurricular =>
AddUnidadeCurricularEvent?.Invoke(unidadeCurricular));
UtilizadorLigado.UnidadesCurriculares?.ForEach(unidadeCurricular =>
AddUnidadeCurricularEvent?.Invoke(unidadeCurricular));
}
MessageHandler();
}
protected void Application_PostAuthenticateRequest(Object sender, EventArgs e)
{
if (FormsAuthentication.CookiesSupported == true)
{
if (Request.Cookies[FormsAuthentication.FormsCookieName] != null)
{
try
{
//let us take out the username now
string username = FormsAuthentication.Decrypt(Request.Cookies[FormsAuthentication.FormsCookieName].Value).Name;
string roles = string.Empty;
Utilizador user = db.Utilizadors.SingleOrDefault(u => u.Username == username);
//roles = user.Roles;
//let us extract the roles from our own custom cookie
//Let us set the Pricipal with our user specific details
HttpContext.Current.User = new System.Security.Principal.GenericPrincipal(
new System.Security.Principal.GenericIdentity(username, "Forms"), roles.Split(';'));
}
catch (Exception ex)
{
string a = ex.Message;
//somehting went wrong
}
}
}
}
public async Task <IActionResult> Registar([FromForm] Utilizador ut)
{
try
{
Utilizador u = _context.Utilizador.Where(c => c.Email == ut.Email).FirstOrDefault();
if (u != null)
{
return(Redirect("/?email=" + ut.Email));
}
ut.Id = 0;
ut.Password = Myhelper.HashPassword(ut.Password);
System.Diagnostics.Debug.WriteLine(ut.Password);
_context.Utilizador.Add(ut);
_context.SaveChanges();
List <Claim> claims = new List <Claim>
{
new Claim(ClaimTypes.Name, ut.Id.ToString()),
};
ClaimsIdentity cIdentity = new ClaimsIdentity(claims, "login");
ClaimsPrincipal principal = new ClaimsPrincipal(cIdentity);
await HttpContext.SignInAsync(principal);
//Request.HttpContext.
return(Redirect("/Home/Tutorial/"));
}
catch
{
return(Redirect("/?email=" + ut.Email));
}
}
public ActionResult Login(Utilizador utilizador)
{
if (ModelState.IsValid)
{
ConexaoDB conn = new ConexaoDB("localhost", 3307, "root", "root", "formacao");
using (MySqlConnection conexao = conn.ObterConexao())
{
if (conexao != null)
{
string stm = "select * from utilizadores where email=@email and password=MD5(@password)";
using (MySqlCommand cmd = new MySqlCommand(stm, conexao))
{
cmd.Parameters.AddWithValue("@Email", utilizador.email);
cmd.Parameters.AddWithValue("@Password", utilizador.password);
using (MySqlDataReader reader = cmd.ExecuteReader())
{
if (reader.Read())
{
Session["login"] = 1;
Session["email"] = utilizador.email;
return(RedirectToAction("ListarAluno", "Aluno"));
}
}
}
}
}
}
return(RedirectToAction("Login"));
}
public async Task <IActionResult> PostAsync([FromForm] string email, [FromForm] string password)
{
if (email == null || password == null)
{
return(BadRequest(new
{
emailMissing = email == null,
passwordMissing = password == null
}));
}
Utilizador utilizador = new Utilizador()
{
Email = email,
Password = Myhelper.HashPassword(password)
};
try
{
utilizador = _context.Utilizador.Where(c => c.Email == utilizador.Email && c.Password == utilizador.Password).Single();
List <Claim> claims = new List <Claim>
{
new Claim(ClaimTypes.Name, utilizador.Id.ToString()),
};
ClaimsIdentity cIdentity = new ClaimsIdentity(claims, "login");
ClaimsPrincipal principal = new ClaimsPrincipal(cIdentity);
await HttpContext.SignInAsync(principal);
//Request.HttpContext.
return(Redirect("/Home/Cozinhar/"));
}
catch
{
return(Redirect("/?email=" + email));
}
}
public ActionResult Login(string email, string password)
{
//email = UtilizadorHelper.FromBase64(email);
if (ModelState.IsValid)
{
var utilizadores = (from u in db.Utilizadors
where u.email == email && u.password == password
select u);
if (utilizadores.ToList().Count == 0)
{
ModelState.AddModelError("", "Login data is incorrect");
return(View("Index"));
}
Utilizador utilizador = utilizadores.ToList().ElementAt <Utilizador>(0);
HttpCookie cookie = LoginHelper.CreateAuthorizeTicket(utilizador.email, utilizador.role);
Response.Cookies.Add(cookie);
}
else
{
ModelState.AddModelError("", "Login data is incorrect");
return(View("Index"));
}
return(RedirectToAction("LoginSucess", "Login"));
}
public ActionResult Registo(Utilizador utilizador)
{
if (ModelState.IsValid)
{
ConexaoDB conn = new ConexaoDB("localhost", 3307, "root", "root", "formacao");
using (MySqlConnection conexao = conn.ObterConexao())
{
if (conexao != null)
{
string stm = "insert into utilizadores values (0,@Email,MD5(@Password))";
using (MySqlCommand cmd = new MySqlCommand(stm, conexao))
{
cmd.Parameters.AddWithValue("@Email", utilizador.email);
cmd.Parameters.AddWithValue("@Password", utilizador.password);
int nRegistos = cmd.ExecuteNonQuery();
if (nRegistos == 1)
{
return(RedirectToAction("Login"));
}
}
}
}
}
return(RedirectToAction("Registo"));
}
private static void processLogin(PacoteLogin pacoteLogin, ClientData cd)
{
Utilizador u_pacote = pacoteLogin.GetUtilizador();
Utilizador u = dao_gestUtil.LoginUtilizador(u_pacote.GetUsername(), u_pacote.GetPassword());
Socket client_socket = cd.GetSocket();
if (u == null)
{
PacoteLogin pl_send = new PacoteLogin(null, "Login Failed!");
AMessage sending = Serializer.Serialize(pl_send);
client_socket.BeginSend(sending.Data, 0, sending.Data.Length, SocketFlags.None, new AsyncCallback(SendCallback), cd);
}
else
{
if (u is Cliente)
{
Cliente c = (Cliente)u;
PacoteLogin pl_send = new PacoteLogin(c, "CSucesso");
AMessage sending = Serializer.Serialize(pl_send);
cd.SetUtilizador(c);
TurnOn.SetActivityText(c.GetUsername() + " " + c.GetPassword() + "\n");
client_socket.BeginSend(sending.Data, 0, sending.Data.Length, SocketFlags.None, new AsyncCallback(SendCallback), cd);
}
else
{
Proprietario p = (Proprietario)u;
cd.SetUtilizador(p);
PacoteLogin pl_send = new PacoteLogin(p, "PSucesso");
AMessage sending = Serializer.Serialize(pl_send);
client_socket.BeginSend(sending.Data, 0, sending.Data.Length, SocketFlags.None, new AsyncCallback(SendCallback), cd);
}
}
}
public bool RegistarUtilizador(Utilizador u)
{
u.password = MyHelpers.HashPassword(u.password);
_context.utilizadores.Add(u);
_context.SaveChanges();
return(true);
}
public ActionResult Index([Bind(Include = "Utilizador, Morada")] RegisterView registerView)
{
if (registerView != null)
{
registerView.Morada.Utilizador_email = registerView.Utilizador.email;
registerView.Utilizador.SetUser();
if (ModelState.IsValid)
{
Utilizador user = db.Utilizadors.FirstOrDefault(x => x.email == registerView.Utilizador.email);
if (user == null)
{
db.Utilizadors.Add(registerView.Utilizador);
db.Moradas.Add(registerView.Morada);
db.SaveChanges();
return(RedirectToAction("Index", "Produtoes"));
}
else
{
ModelState.AddModelError("registerView.Utilizador.email", "Email address already exists.Please enter a different email address.");
}
}
else
{
return(View(registerView));
}
}
return(RedirectToAction("Index"));
}
public ActionResult Denuncias()
{
var den = from x in model.Denuncias select x;
List <Denuncias> lista = den.ToList <Denuncias>();
foreach (Denuncias d in lista)
{
var artigos = from f in model.Artigo where (f.IdArtigo == d.IdArtigo) select f;
Artigo al = artigos.ToList <Artigo>().FirstOrDefault();
d.IdArtigoNavigation.IdArtigo = al.IdArtigo;
d.IdArtigoNavigation.Nome = al.Nome;
d.IdArtigoNavigation.IdDono = al.IdDono; // acho que não é preciso mais info
var ut = from x in model.Utilizador where (x.Email.Equals(al.IdDono)) select x;
Utilizador u = ut.ToList <Utilizador>().FirstOrDefault();
al.IdDonoNavigation.Nome = u.Nome;
al.IdDonoNavigation.Email = u.Email;
al.IdDonoNavigation.NDenuncias = u.NDenuncias;
}
return(View(lista));
}
public bool Insert(Utilizador u)
{
Utilizador flag = FindByUsername(u.Username);
if (flag == null)
{
Connection con = new Connection();
using (SqlCommand command = con.Fetch().CreateCommand())
{
command.CommandType = CommandType.Text;
command.CommandText = "insert into [User] Values(@username,@password,@email,@type,@prefe,@name,1)";
command.Parameters.Add("@username", SqlDbType.Text).Value = u.Username;
command.Parameters.Add("@password", SqlDbType.Text).Value = u.Password;
command.Parameters.Add("@email", SqlDbType.Text).Value = u.Email;
command.Parameters.Add("@type", SqlDbType.Int).Value = u.Type;
command.Parameters.Add("@prefe", SqlDbType.Int).Value = u.Preferencia;
command.Parameters.Add("@name", SqlDbType.Text).Value = u.Nome;
command.ExecuteScalar();
con.Close();
return(true);
}
}
return(false);
}
public int LogIn(string user, string password)
{
int id = -1;
Connection con = new Connection();
using (SqlCommand command = con.Fetch().CreateCommand())
{
command.CommandType = CommandType.Text;
command.CommandText = "select Id_User from[User] where Username=@Username AND Password=@Password";
command.Parameters.Add("@Username", SqlDbType.VarChar);
command.Parameters.Add("@Password", SqlDbType.VarChar);
command.Parameters["@Username"].Value = user;
command.Parameters["@Password"].Value = Utilizador.HashPassword(password);
using (SqlDataAdapter adapter = new SqlDataAdapter(command))
{
DataTable result = new DataTable();
adapter.Fill(result);
if (result.Rows.Count > 0)
{
DataRow row = result.Rows[0];
id = int.Parse(row["Id_User"].ToString());
}
con.Close();
}
}
return(id);
}
public async Task <IActionResult> Edit(int id, [Bind("UtilizadorID,NomeUtilizador,MoradaUtilizador,MailUtilizador")] Utilizador utilizador)
{
if (id != utilizador.UtilizadorID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(utilizador);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UtilizadorExists(utilizador.UtilizadorID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(utilizador));
}
public async Task <bool> AddUtilizadorAsync(Utilizador utilizador)
{
try
{
string url = "http://knowhau.somee.com/api/User";
var uri = new Uri(string.Format(url, utilizador.email));
var data = JsonConvert.SerializeObject(utilizador);
var content = new StringContent(data, Encoding.UTF8, "application/json");
HttpResponseMessage response = null;
response = await client.PostAsync(uri, content);
if (!response.IsSuccessStatusCode)
{
return(false);
throw new Exception("Erro ao incluir utilizador");
}
return(true);
}
catch (Exception ex)
{
return(false);
throw ex;
}
}
public ActionResult CriarProfessor([Bind(Include = "Professor_id,nome,bi,utilizadorFK")] Professor professor)
{
var dbT = db.Database.BeginTransaction();
if (ModelState.IsValid)
{
db.Professors.Add(professor);
db.SaveChanges();
var username = professor.nome.Split(' ');
Utilizador user = new Utilizador();
user.nome = professor.nome;
user.nomeUtilizador = username[0].ToLower() + "." + username[username.Length - 1].ToLower();
user.papelFK = 2;
db.Utilizadors.Add(user);
db.SaveChanges();
professor.utilizadorFK = user.Utilizador_id;
db.Entry(professor).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
dbT.Commit();
return(RedirectToAction("Index"));
}
ViewBag.utilizadorFK = new SelectList(db.Utilizadors, "Utilizador_id", "nome", professor.utilizadorFK);
return(View(professor));
}
public async Task <IActionResult> Login(LogInModel model)
{
if (ModelState.IsValid)
{
UserDAO dAO = new UserDAO();
int id = dAO.LogIn(model.Username, model.Password);
if (id != -1)
{
Utilizador user = dAO.FindByUsername(model.Username);
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, model.Username),
new Claim(ClaimTypes.Sid, id.ToString()),
new Claim(ClaimTypes.Role, user.Type.ToString())
};
ClaimsIdentity userIdentity = new ClaimsIdentity(claims, "login");
ClaimsPrincipal principal = new ClaimsPrincipal(userIdentity);
await HttpContext.SignInAsync(principal);
return(RedirectToAction("Index", "User", new { area = "" }));
}
ModelState.AddModelError("", "Wrong username and password");
}
return(View(model));
}
public Utilizador getDadosUtilizador(string username, ComunicacaoBD comunicacaoBD)
{
Utilizador utilizador = null;
string query = "SELECT * " +
" FROM Utilizador " +
" WHERE " +
" username = @username";
SqlCommand comando = new SqlCommand(query);
comando.Parameters.Add(new SqlParameter("@username", username));
SqlDataReader resposta = invocaQueryLeitura(comando, comunicacaoBD);
while (resposta.Read() == true)
{
utilizador = new Utilizador();
utilizador.IdUtilizador = (string)resposta["idUtilizador"];
utilizador.Nome = (string)resposta["nome"];
utilizador.Username = (string)resposta["username"];
utilizador.Password = (string)resposta["password"];
}
if (resposta != null)
resposta.Close();
return utilizador;
}
public Utilizador GetUtilizadorByID(int uid)
{
Rede.Perfil perfil = Rede.Perfil.LoadById(uid);
Utilizador util = new Utilizador(perfil.Name, perfil.Nick, perfil.Morada, perfil.Telemovel, perfil.DataNascimento.ToString(), perfil.avatar);
return util;
}
