private string GenerateJsonWebToken(UserInformationViewModel userInfo)
{
var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config["Jwt:Key"]));
var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);
JwtSecurityToken token;
if (userInfo.Username == "admin")
{
token = new JwtSecurityToken(_config["Jwt:Issuer"],
_config["Jwt:Issuer"],
new Claim[]
{
new Claim("Administrator", ""),
new Claim("UserName", userInfo.Username)
},
expires: DateTime.Now.AddMinutes(120),
signingCredentials: credentials);
}
else
{
token = new JwtSecurityToken(_config["Jwt:Issuer"],
_config["Jwt:Issuer"],
null,
expires: DateTime.Now.AddMinutes(120),
signingCredentials: credentials);
}
return(new JwtSecurityTokenHandler().WriteToken(token));
}
public IHttpActionResult GetUserInformation(long id)
{
User user = _userMgr.ReadUser(id);
if (user == null)
{
return(BadRequest("User not found"));
}
if (User.Identity.Name == user.Email)
{
var model = new UserInformationViewModel()
{
Id = user.Id,
Firstname = user.Firstname,
Lastname = user.Lastname,
Picture = null,
HasOrganisation = false
};
if (user.Organisation != null)
{
model.HasOrganisation = true;
}
if (user.AvatarUrl != null)
{
model.Picture = user.AvatarUrl;
}
return(Ok(model));
}
return(BadRequest());
}
public async Task <JsonResult> GetConnectionSingleByMID(string ID)
{
try {
var data = ConnectionServices.GetByMemberSingleID(ID);
var vmModel = new List <ConnectionViewModel>();
foreach (var model in data)
{
var temp = new ConnectionViewModel()
{
ID = model.ID.ToString(),
GroupName = model.ConnectionName
};
foreach (var member in model.Members)
{
//assign userinformationmodel
var vm = new UserInformationViewModel()
{
User = member.UserID.ToString()
};
temp.PushMembers(member, vm);
}
vmModel.Add(temp);
}
return(Json(new { success = true, data = vmModel }, JsonRequestBehavior.AllowGet));
} catch (Exception e) {
Console.Write(e);
return(Json(new { success = false, message = MessageUtility.ServerError() }, JsonRequestBehavior.AllowGet));
}
}
public async Task <IActionResult> ChangeUserInformation(UserInformationViewModel vm)
{
if (!ModelState.IsValid)
{
return(View(vm));
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
user.Email = vm.Email;
user.FirstName = vm.FirstName;
user.LastName = vm.LastName;
var result = await _userManager.UpdateAsync(user);
if (result != IdentityResult.Success)
{
vm.InformationSaved = false;
return(View(vm));
}
vm.InformationSaved = true;
return(View(vm));
}
public async Task <IViewComponentResult> InvokeAsync(string Id)
{
var usuario = _contexto.Usuarios.FirstOrDefault(u => u.Id == Id);
var nivelAcesso = (from n in _contexto.NiveisAcessos
join r in _contexto.UserRoles
on n.Id equals r.RoleId
join u in _contexto.Usuarios
on r.UserId equals u.Id
where u.Id == Id
select n.Name).FirstOrDefault();
var Setor = (from s in _contexto.Setores
join u in _contexto.Usuarios
on s.SetorId equals u.SetorId
where u.Id == Id
select s.Descricao).FirstOrDefault();
var sobreUsuario = _contexto.SobreUsuarios.Where(s => s.UsuarioId == Id).FirstOrDefault();
UserInformationViewModel user = new UserInformationViewModel();
user.Nome = usuario.Nome;
user.NivelAcesso = nivelAcesso;
user.NomeSetor = Setor;
user.DtCadastro = usuario.DtCadastro;
user.Id = usuario.Id;
if (sobreUsuario != null)
{
user.Foto = sobreUsuario.Foto;
}
return(View(user));
}
public ActionResult EditProfile(UserInformationViewModel model, HttpPostedFileBase avatar)
{
var userId = User.Identity.GetUserId();
var user = db.Users.Find(userId);
user.FirstName = model.Fname;
user.LastName = model.Lname;
user.DisplayName = model.DisplayName;
user.Email = model.Email;
user.UserName = model.Email;
//db.Entry(editUser);
if (avatar != null)
{
if (ImageUploadValidator.IsWebFriendlyImage(avatar))
{
var filename = Path.GetFileName(avatar.FileName);
avatar.SaveAs(Path.Combine(Server.MapPath("~/Avatars/"), filename));
user.AvatarPath = "/Avatars/" + filename;
}
}
db.SaveChanges();
return(RedirectToAction("EditProfile", "Home"));
}
public IActionResult Add()
{
var model = new UserInformationViewModel();
model.SelectListItems = _roles;
return(View(model));
}
public async Task <IActionResult> ImportFileExecute([FromForm] FileExecutionViewModel file)
{
var reader = new StreamReader(file.File.OpenReadStream());
string line;
while ((line = reader.ReadLine()) != null)
{
var userToBeRegistered = line.Split(';');
if (userToBeRegistered.Length < 7)
{
continue;
}
var userToRegister = new UserInformationViewModel
{
Nume = userToBeRegistered[0],
Prenume = userToBeRegistered[1],
Profesor = userToBeRegistered[2],
Clasa = userToBeRegistered[3],
Scoala = userToBeRegistered[4],
Username = userToBeRegistered[5],
Password = userToBeRegistered[6]
};
var result = await _userInformationService.RegisterUser(userToRegister, string.Empty);
if (result == false)
{
//log the errors
ModelState.AddModelError("", $"Something bad happened for user + {userToRegister.Nume}");
}
}
return(RedirectToAction(nameof(Index), new { searchString = string.Empty }));
}
public ActionResult Create(UserInformationViewModel userinfo)
{
if (ModelState.IsValid)
{
//insert gar
//converting view model to entity model
tblUserInformation tblUserInformation = new tblUserInformation();
tblUserInformation.FirstName = userinfo.FirstName;
tblUserInformation.LastName = userinfo.LastName;
tblUserInformation.Email = userinfo.Email;
tblUserInformation.Password = Cryptography.Encrypt(userinfo.Password);
tblUserInformation.PhoneNo = userinfo.PhoneNo;
tblUserInformation.Address = userinfo.Address;
tblUserInformation.City = userinfo.City;
tblUserInformation.Country = userinfo.Country;
tblUserInformation.PostalCode = userinfo.PostalCode;
tblUserInformation.ProfileImage = userinfo.ProfileImage;
tblUserInformation.UserTypeID = 2;
db.tblUserInformations.Add(tblUserInformation);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(userinfo));
}
public void Authorize()
{
try
{
_accontHelper = AccountHelper._getInstance;
string userId = HttpContext.Session.GetObject("coviduserid");
if (string.IsNullOrEmpty(userId))
{
ReturnToLogout();
}
CurrentUserId = Convert.ToInt32(userId);
int roleId = _accontHelper.GetRoleByUserid(Convert.ToInt32(userId));
if (roleId < 1)
{
ReturnToLogout();
}
if (roleId == 1)
{
IsUserInAdminRole = true;
}
ViewBag.roleId = roleId;
UserInformationViewModel userInfo = _accontHelper.UserDataByUserId(Convert.ToInt32(userId));
ViewBag.fullName = string.IsNullOrEmpty(userInfo.NAME) ? "Unknown" : userInfo.NAME;
}
catch
{
ReturnToLogout();
}
}
public UserInformationViewModel UserDataByUserId(int uid)
{
List <UserInfoDto> getUserInfo = _userInfoManager.GetUserInfoData();
UserInfoDto userDetails = getUserInfo.Where(t => t.USERID == uid).FirstOrDefault();
UserInformationViewModel userInfo = CommonHelper.ConvertTo <UserInformationViewModel>(userDetails);
return(userInfo);
}
public async Task <IActionResult> Get()
{
var user = await GetApiUser();
UserInformationViewModel userViewModel = await GenerateUserInformationViewModel(user);
return(Ok(userViewModel));
}
public ActionResult Information(string userName)
{
UserInformationViewModel ui = new UserInformationViewModel();
ui.typeUsers = dal.ShowTypeUsers();
ui.user = dal.ShowUserInfo(userName);
return(View(ui));
}
//token ro dakhel ye ghaleb mirize
public TokenInformationViewModel CreateUserToken(User userData)
{
return(new TokenInformationViewModel
{
Token = CreateToken(userData),
ExpirationDate = DateTime.Now.AddMonths(1),
UserInformationViewModel = UserInformationViewModel.GetUserInformationViewModel(userData)
});
}
public object GetUserInformation()
{
CurrentUserInfo currentUserInfo = _tokenHelper.GetUserInfo();
UserData userData = _accountLogic.GetUser(currentUserInfo.Id);
return(Request.CreateResponse(HttpStatusCode.OK, new BaseResponse(ResponseStatus.Success.ToString(),
ResponseMessagesModel.Success,
UserInformationViewModel.GetUserInformationViewModel(userData))));
}
public async Task <IActionResult> SearchUser([Bind("SearchUsername")] UserInformationViewModel formModel)
{
var userName = await _userService.SearchUsersAsync(formModel.SearchUsername);
var model = new UserSearchResultViewModel
{
UserName = userName
};
return(PartialView("_SearchUserNameResult", model));
}
public async Task <IActionResult> UserInformationEdit(UserInformationViewModel userInformationViewModel)
{
AppUser user = await _userManager.GetUserAsync(User);
user.FirstName = userInformationViewModel.FirstName;
user.LastName = userInformationViewModel.LastName;
user.Email = userInformationViewModel.Email;
var result = await _userManager.UpdateAsync(user);
return(RedirectToAction("UserInformation", "Account"));
}
public static UserInformationEntity ToBLLInformationUsers(this UserInformationViewModel information)
{
return(new UserInformationEntity
{
Id = information.Id,
Age = information.Age,
Avatar = information.Avatar,
FirstName = information.FirstName,
LastName = information.LastName,
UserId = information.UserId
});
}
public ActionResult Informations()
{
var currentUser = UserManager.FindByIdAsync(User.Identity.GetUserId()).Result;
var userInformation = new UserInformationViewModel
{
Name = currentUser.Name,
Birthdate = currentUser.Birthdate,
Surname = currentUser.Surname
};
return(PartialView(userInformation));
}
public ActionResult Index(long?uid)
{
var userInformationView = new UserInformationViewModel
{
UserTypeList = new SelectList(_userTypeService.GetAll(), "Id", "Name"),
RoleList = new SelectList(_roleService.GetAll(), "Id", "Name"),
EmployeeCategoryList = new SelectList(_employeeCategoryService.GetAll(), "Id", "Name"),
EmployeeList = new SelectList(string.Empty, "Id", "EmployeeCode"),
};
return(View(userInformationView));
}
public async Task <IActionResult> Index()
{
var model = new UserInformationViewModel
{
UserID = await _accountService.GetInloggedUserIDAsync(),
Email = await _accountService.GetEmailAsync(),
Username = _accountService.GetUserName(),
Friends = _mapper.Map <List <FriendViewModel> >(await _userService.GetFriendsAsync()).Where(x => x.FriendRequestAccepted == true).ToList()
};
return(View(model));
}
public async Task <IActionResult> PerfilUsuario(string UsuarioId)
{
_logger.LogInformation("Pegando o Usuário logado");
var usuarioLogado = await _usuarioRepositorio.PegarUsuarioLogado(User);
if (usuarioLogado.Id != null)
{
_logger.LogInformation("Buscando usuário atraves do id");
var usuario = await _contexto.Usuarios.Where(u => u.Id == UsuarioId).Include(u => u.Setor).FirstOrDefaultAsync();
var nivelAcesso = (from n in _contexto.NiveisAcessos
join ur in _contexto.UserRoles
on n.Id equals ur.RoleId
join u in _contexto.Usuarios
on ur.UserId equals u.Id
where u.Id == UsuarioId
select n).Select(e => e.Name).First();
var sobreUsuario = _contexto.SobreUsuarios.FirstOrDefault(u => u.UsuarioId == UsuarioId);
UserInformationViewModel user = new UserInformationViewModel();
user.Id = usuario.Id;
user.Nome = usuario.Nome;
user.CPF = usuario.CPF;
user.Email = usuario.Email;
user.UserName = usuario.UserName;
user.DataNascimento = usuario.DataNascimento;
user.NomeSetor = usuario.Setor.Descricao;
user.NivelAcesso = nivelAcesso;
user.Telefone = usuario.Telefone;
user.Numero = usuario.Numero;
if (sobreUsuario != null)
{
user.Formacao = sobreUsuario.Formacao;
user.Foto = sobreUsuario.Foto;
user.SobreUsuarioId = sobreUsuario.SobreUsuarioId;
if (sobreUsuario.CepId != null)
{
var cep = _contexto.Cep.FirstOrDefault(c => c.CepId == sobreUsuario.CepId);
user.CEP = cep.CEP;
user.Logradouro = cep.Logradouro;
user.Bairro = cep.Bairro;
user.Cidade = cep.Cidade;
user.UF = cep.UF;
user.CepId = cep.CepId;
}
}
return(View(user));
}
_logger.LogError("Usuário diferente do logado no computador");
return(RedirectToAction("Login", "Usuarios"));
}
public async Task <IActionResult> UserInformationEdit()
{
AppUser user = await _userManager.GetUserAsync(User);
UserInformationViewModel userInformationViewModel = new UserInformationViewModel
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
};
return(View(userInformationViewModel));
}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
tblUserInformation tblUserInformation = db.tblUserInformations.Find(id);
var config = new MapperConfiguration(x => { x.CreateMap <tblUserInformation, UserInformationViewModel>(); });
var _mapper = config.CreateMapper();
UserInformationViewModel userinfo = _mapper.Map <UserInformationViewModel>(tblUserInformation);
return(View(userinfo));
}
public ActionResult <UserInformationViewModel> GetUserInformation()
{
string userId = User.GetUserIdToken();
ApplicationUser applicationUser = usersRepository.GetUserInformation(userId);
if (applicationUser == null)
{
return(NotFound("Specified user does not exist."));
}
UserInformationViewModel model = mapper.Map <ApplicationUser, UserInformationViewModel>(applicationUser);
model.Rating = usersRepository.GetAverageRating(userId);
return(Ok(model));
}
public async Task <IActionResult> ChangeUserInformation()
{
var user = await _userManager.GetUserAsync(User);
var vm = new UserInformationViewModel
{
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
InformationSaved = false
};
return(View(vm));
}
public virtual ActionResult GetUserById(Guid UserId)
{
var db = Current.DB;
var model = new UserInformationViewModel();
model.User = Membership.GetUser(UserId, false);
if (model.User == null)
{
return(RedirectToAction("NotFound", "Error"));
}
model.Suspensions = db.UserSuspensions.Where(s => s.UserID == UserId).ToList();
model.ReinstateDate = model.Suspensions.Max(r => r.ReinstateDate);
return(View(model));
}
// UpdateUser
// Task devuelve una tarea ya que los metodos implementados por ASP.Identity son asincronos
public async Task <ActionResult> GetCurrentUser()
{
var userId = CurrentUserHelper.Get.UserId;
var model = await UserManager.FindByIdAsync(userId);
var userView = new UserInformationViewModel
{
Id = model.Id,
Name = model.Name,
LastName = model.LastName,
Email = model.Email
};
return(View(userView));
}
public async Task <IActionResult> Add([FromForm] UserInformationViewModel userInformation)
{
if (ModelState.IsValid)
{
var result = await _userInformationService.RegisterUser(userInformation, userInformation.Role);
if (result == true)
{
return(RedirectToAction("Index", new { searchString = string.Empty }));
}
ModelState.AddModelError("", "Something bad happened.");
return(View());
}
return(View());
}
public async Task <IActionResult> Put([FromBody] UserInformationViewModel body)
{
var user = await GetApiUser();
user.FirstName = body.FirstName;
user.LastName = body.LastName;
user.PhoneNumber = body.PhoneNumber;
user.PictureUrl = body.PictureUrl;
_context.Users.Update(user);
_context.SaveChanges();
UserInformationViewModel userViewModel = await GenerateUserInformationViewModel(user);
return(Ok(userViewModel));
}
public static UserInformationViewModel GetUserInformation(this HttpContextBase context)
{
if (!context.User.Identity.IsAuthenticated)
return null;
if (context.Items["UserInformation"] == null) {
var user = _usersRepository.GetUserByEmail(context.User.Identity.Name);
if (user == null) {
FormsAuthentication.SignOut();
return null;
}
var userInformation = new UserInformationViewModel(user);
context.Items["UserInformation"] = userInformation;
}
return context.Items["UserInformation"] as UserInformationViewModel;
}
