public async Task <UserDataResponse> GetUserDataAsync(HttpContext context)
{
string userKey = context.Session.GetString(ICryptoService.UserKey);
ApplicationUser user = await UserManager.GetUserAsync(context.User);
UserDataResponse model = new UserDataResponse();
model.Notes = await Repository.GetUserNotesAsync(user.Id);
model.Labels = await Repository.GetUserLabelsAsync(user.Id);
string secretKey = Crypto.Decrypt(userKey, user.SecretKey);
foreach (var note in model.Notes)
{
note.Title = Crypto.Decrypt(secretKey, note.Title);
note.Content = Crypto.Decrypt(secretKey, note.Content);
}
foreach (var label in model.Labels)
{
label.Name = Crypto.Decrypt(secretKey, label.Name);
}
return(model);
}
public static UserDataResponse GetAllUsers()
{
UserDataResponse usuariosRespuesta;
var usuarios = context.Usuarios.ToList();
context.Alergias.ToList();
if (usuarios != null)
{
usuariosRespuesta = new UserDataResponse()
{
codigo = 200,
mensaje = "Operacion completada",
payload = usuarios
};
}
else
{
usuariosRespuesta = new UserDataResponse()
{
codigo = 500,
mensaje = "Error al buscar informacion",
payload = null
};
}
return(usuariosRespuesta);
}
public User(UserDataResponse responseData)
{
Id = responseData.Body.UserId;
Username = responseData.Body.Username;
AvatarUrl = responseData.Body.AvatarUrl;
Usergroup = responseData.Body.Group;
}
public static UserDataResponse GetUserId(int id)
{
var usuarioRespuesta = new UserDataResponse();
context.Alergias.ToList();
var usuario = context.Usuarios.Where(u => u.UsuarioId == id).ToList();
if (usuario != null)
{
usuarioRespuesta = new UserDataResponse()
{
codigo = 200,
mensaje = "Operacion completada",
payload = usuario
};
}
else
{
usuarioRespuesta = new UserDataResponse()
{
codigo = 400,
mensaje = "No se encontro información",
payload = null
};
}
return(usuarioRespuesta);
}
public User(UserDataResponse responseData)
{
this.ID = responseData.Body.UserID;
this.Username = responseData.Body.Username;
this.AvatarURL = responseData.Body.AvatarURL;
this.Usergroup = responseData.Body.Group;
}
public async Task <IActionResult> Register([FromBody] RegisterEntity model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
Name = model.Name, LastName = model.Name, UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
var token = await this.GenerateJSONWebToken(model.Email, user);
DateTime expirationDate = this.GetExpirationDate();
var rootData = new UserDataResponse(token, user.UserName, user.Email, expirationDate);
return(Created("api/v1/authentication/register", rootData));
}
return(Ok(string.Join(",", result.Errors?.Select(error => error.Description))));
}
string errorMessage = string.Join(", ", ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage));
Log.Warning(errorMessage ?? "Bad Request");
return(BadRequest(errorMessage ?? "Bad Request"));
}
public async Task <ActionResult> UserData()
{
ApplicationUser user = await _userManager.GetUserAsync(User);
var userData = new UserDataResponse {
Id = user.Id, Name = user.UserName, Email = user.Email
};
return(Ok(userData));
}
public async Task <ActionResult> UserData()
{
var user = await _userManager.GetUserAsync(User);
var userData = new UserDataResponse
{
login = user.UserName
};
return(Ok(userData));
}
public IActionResult GetUsersByRoomName([FromRoute] string roomName)
{
if (Tracker.TryGet(roomName, out var room))
{
var response = room.Users
.Select(user => UserDataResponse.FromUserData(user, self: user.Username == Client.Username));
return(Ok(response));
}
return(NotFound());
}
public async Task <ActionResult> UserData()
{
var user = await _userManager.GetUserAsync(User);
var userData = new UserDataResponse
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email
};
return(Ok(userData));
}
public IActionResult UserData()
{
var user = _userManager.Users.FirstOrDefault(x => x.Id == new Guid(User.Identity.Name));
var userData = new UserDataResponse
{
Name = user.UserName,
LastName = user.LastName,
City = user.City,
Email = user.Email,
Points = user.Points
};
return(Ok(userData));
}
public static UserDataResponse MapperApplicationUserToUserDataResponse(ApplicationUser user)
{
var userData = new UserDataResponse
{
FirstName = user.UserName,
LastName = user.LastName,
Email = user.Email,
CreatedAt = user.CreatedAt,
LastLogin = user.LastLogin,
Phones = Utils.MapperPhonesToEntitiesPhone(user.Phones.ToList())
};
return(userData);
}
public async Task Consume(ConsumeContext <IUserDataRequest> context)
{
var userId = context.Message.Id;
var db = new Database();
var user = db.Find().SingleOrDefault(u => u.Id == userId);
var response = new UserDataResponse
{
Id = user.Id,
Surname = user.Surname,
Firstname = user.Firstname
};
await context.RespondAsync <IUserDataResponse>(response);
}
private RoomResponse MapRoomToRoomResponse(Room room)
{
bool IsSelf(string username)
{
return(username == Client.Username);
}
var response = RoomResponse.FromRoom(room);
response.Users = room.Users
.Select(user => UserDataResponse.FromUserData(user, self: IsSelf(user.Username)));
response.Messages = room.Messages
.Select(message => RoomMessageResponse.FromRoomMessage(message, self: IsSelf(message.Username)));
return(response);
}
public async Task <ActionResult> UserData()
{
var user = await _userManager.GetUserAsync(User);
//var role = _userManager.GetRolesAsync(user);
var userData = new UserDataResponse
{
Name = user.UserName,
LastName = user.LastName,
City = user.City,
Email = user.Email,
Role = user.Roles[0]
};
return(Ok(userData));
}
public async Task <ActionResult> UserData()
{
var user = await _userManager.GetUserAsync(User);
//var merp = await _userManager.
var userData = new UserDataResponse
{
FirstName = user.FirstName,
LastName = user.LastName,
Recipes = user.Recipes
};
return(Ok(userData));
}
public async Task <ActionResult <MainResponse> > GetUser()
{
User user = HttpContext.GetUser();
if (user == null)
{
return(Unauthorized());
}
UserDataResponse userDataResponse = new UserDataResponse()
{
UserData = (ExtUser)user
};
userDataResponse.UserData.Img?.SetPath(_serverConfig.General.ServerPath + _serverConfig.FileRoutes.UserImages.Route);
return(MainResponse.GetSuccess(userDataResponse));
}
private void LoadOfValueUserData(UserDataResponse _userDataResponse)
{
// Get new instance of UserDataResponse
mainViewModel.UserData = new UserDataResponse();
mainViewModel.UserData.AppName = _userDataResponse.AppName;
mainViewModel.UserData.CantvDatas = _userDataResponse.CantvDatas;
mainViewModel.UserData.CneIvssDatas = _userDataResponse.CneIvssDatas;
mainViewModel.UserData.Email = _userDataResponse.Email;
mainViewModel.UserData.FirstName = _userDataResponse.FirstName;
mainViewModel.UserData.ImageArray = _userDataResponse.ImageArray;
mainViewModel.UserData.ImagePath = _userDataResponse.ImagePath;
mainViewModel.UserData.LastName = _userDataResponse.LastName;
mainViewModel.UserData.Password = _userDataResponse.Password;
mainViewModel.UserData.Telephone = _userDataResponse.Telephone;
mainViewModel.UserData.UserId = _userDataResponse.UserId;
mainViewModel.UserData.UserTypeId = _userDataResponse.UserTypeId;
mainViewModel.UserData.ZoomDatas = _userDataResponse.ZoomDatas;
}
protected override Response LogicImplementation()
{
var datas = UnitOfWork.Repository <Data>().GetItems(x => x.User == User);
var response = new UserDataResponse
{
ActiveTokenData = datas.Where(x => x.DataAccessToken.ExpiresAt > DateTime.Now).Select(x => new DataToken {
Id = x.Id, Description = x.Description, Value = x.Value, Token = x.DataAccessToken.TokenString
}).ToList(),
ExpiredTokenData = datas.Where(x => x.DataAccessToken.ExpiresAt < DateTime.Now).Select(x => new DataToken {
Id = x.Id, Description = x.Description, Value = "Данные скрыты", Token = x.DataAccessToken.TokenString
}).ToList()
};
return(CreateSuccessResponse("Данные успешно загружены. " +
$"Активные данные с валидным токеном: {response.ActiveTokenData.Count} шт. " +
$"Данных с окончившимся сроком действия токенов: {response.ExpiredTokenData.Count} шт.", response));
}
public async Task <ActionResult> UserData()
{
var user = await _userManager.GetUserAsync(User);
var userData = new UserDataResponse
{
UserName = user.UserName,
FirstName = user.FirstName,
LastName = user.LastName,
Birthdate = user.Birthdate,
Country = user.Country,
State = user.State,
City = user.City,
Email = user.Email
};
return(Ok(userData));
}
public async Task <ActionResult> Login([FromBody] UserLoginRequest loginRequest)
{
UserDataResponse userResponse = await authenticationService.AuthenticateUserAsync(loginRequest.USR_ID_TE, loginRequest.USR_PWD_TE);
if (userResponse.Success)
{
string token = authenticationService.GenerateValidationToken(userResponse.User.UserId, userResponse.User.Role, userResponse.User.ID);
LoginDataResponse loginDataResponse =
new LoginDataResponse()
{
Token = token,
UserName = string.Format("{0} {1}", userResponse.User.FirstName, userResponse.User.LastName),
};
return(Ok(loginDataResponse));
}
return(Unauthorized());
}
public async Task <UserDataResponse> Login(LoginEntity user)
{
var response = await _client.PostAsJsonAsync($"{_client.BaseAddress}api/v1/Users/Login", user);
Console.WriteLine(response.StatusCode);
if (response.StatusCode == HttpStatusCode.OK)
{
var content = await response.Content.ReadAsStringAsync();
var data = JsonConvert.DeserializeObject <UserDataResponse>(content);
await _localStorage.SetItemAsync("authToken", data.Token);
await _authenticationProvider.GetAuthenticationStateAsync();
data.StatusCode = response.StatusCode;
return(data);
}
string error;
switch (response.StatusCode)
{
case HttpStatusCode.Unauthorized:
error = "Unauthorized Access";
break;
case HttpStatusCode.BadRequest:
error = "Bad Request";
break;
case HttpStatusCode.InternalServerError:
error = "Internal Server Error";
break;
default:
error = "Undefined Error Occured";
break;
}
UserDataResponse failedResponse = new UserDataResponse(error, null, null, new DateTime());
failedResponse.StatusCode = response.StatusCode;
return(failedResponse);
}
public async Task <IActionResult> GetUserData(UserDataRequest userDataRequest)
{
Serilog.Log.Information("Request {userDataRequest}", userDataRequest);
// Check the PlatformToken for validity
if (userDataRequest?.PlatformToken == null || userDataRequest.PlatformToken != _gigDataServiceConfig.PlatformToken)
{
Serilog.Log.Error("Incorrect PlatformToken. Token {PlatformToken}", _gigDataServiceConfig?.PlatformToken);
// There are multiple registrations for the main mock platform
// service now, so disabling this requirement
//throw new Exception("MyGigDataToken mismatch.");
}
using (IAsyncDocumentSession session = _documentStore.OpenAsyncSession())
{
var user = await session
.Query <User>()
.Where(u => u.UserEmail == userDataRequest.UserEmail)
.FirstOrDefaultAsync();
if (user == null)
{
return(NotFound(new
{
message = $"Unable to find that user. Request UserEmail: '{userDataRequest.UserEmail}'"
}));
}
Serilog.Log.Information("User", user);
UserDataResponse response = new UserDataResponse {
Id = user.Id,
RequestId = userDataRequest.RequestId,
UserEmail = user.UserEmail,
Interactions = user.Interactions,
Achievements = user.Achievements
};
return(Ok(response));
}
}
public UserDataResponse SelectUserByUserIdAndPassword(String USR_ID_TE, String USR_PWD_TE)
{
optionsBuilder = new DbContextOptionsBuilder <ApplicationDbContext>();
userDataResponse = new UserDataResponse();
try
{
var context = new ApplicationDbContext(optionsBuilder.Options);
USR user = context.UserData.Where(u => u.USR_ID_TE == USR_ID_TE && u.USR_PWD_TE == USR_PWD_TE).FirstOrDefault();
userDataResponse.Success = false;
if (user != null)
{
userDataResponse.Success = true;
}
userDataResponse.User = user;
}
catch (Exception ex)
{
userDataResponse.Success = false;
userDataResponse.OperationException = ex;
}
return(userDataResponse);
}
public UserDataResponse GetUserData(int userID)
{
UserDataResponse userData = null;
string query = string.Format("select UserID, UserName, UserType,FullName, Address, PinCode, Mobile, Email, RegistrationID, RegisteredPHC from UserDetails where UserId = {0}", userID);
var loginData = dbService.ExecuteReader(query);
if (loginData.Rows.Count > 0)
{
userData = new UserDataResponse();
userData.UserId = Convert.ToInt32(loginData.Rows[0]["UserID"]);
userData.UserName = Convert.ToString(loginData.Rows[0]["UserName"]);
userData.UserType = Convert.ToInt32(loginData.Rows[0]["UserType"]);
userData.FullName = Convert.ToString(loginData.Rows[0]["FullName"]);
userData.Address = Convert.ToString(loginData.Rows[0]["Address"]);
userData.PinCode = Convert.ToString(loginData.Rows[0]["PinCode"]);
userData.Mobile = Convert.ToString(loginData.Rows[0]["Mobile"]);
userData.Email = Convert.ToString(loginData.Rows[0]["Email"]);
userData.RegistrationId = Convert.ToString(loginData.Rows[0]["RegistrationID"]);
userData.RegisteredPHC = Convert.ToString(loginData.Rows[0]["RegisteredPHC"]);
}
return(userData);
}
public async Task <ActionResult> Login([FromBody] LoginEntity model)
{
if (ModelState.IsValid)
{
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, false, false);
if (result.Succeeded)
{
var appUser = _userManager.Users.SingleOrDefault(r => r.Email == model.Email);
var token = await this.GenerateJSONWebToken(model.Email, appUser);
DateTime expirationDate = this.GetExpirationDate();
var rootData = new UserDataResponse(token, appUser.UserName, appUser.Email, expirationDate);
Log.Warning("Login endpoint reached");
return(Ok(rootData));
}
return(StatusCode((int)HttpStatusCode.Unauthorized, "Bad Credentials"));
}
string errorMessage = string.Join(", ", ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage));
Log.Warning(errorMessage ?? "Bad Request");
return(BadRequest(errorMessage ?? "Bad Request"));
}
public async Task <UserDataResponse> Register(RegisterEntity user)
{
var response = await _client.PostAsJsonAsync($"{_client.BaseAddress}api/v1/Users/Register", user);
if (response.StatusCode == System.Net.HttpStatusCode.Created)
{
var content = await response.Content.ReadAsStringAsync();
var data = JsonConvert.DeserializeObject <UserDataResponse>(content);
data.StatusCode = response.StatusCode;
return(data);
}
string error;
switch (response.StatusCode)
{
case HttpStatusCode.Unauthorized:
error = "Unauthorized Access";
break;
case HttpStatusCode.BadRequest:
error = "Bad Request";
break;
case HttpStatusCode.InternalServerError:
error = "Internal Server Error";
break;
default:
error = "Undefined Error Occured";
break;
}
UserDataResponse failedResponse = new UserDataResponse(error, null, null, new DateTime());
failedResponse.StatusCode = response.StatusCode;
return(failedResponse);
}
protected static void GetUserInformation()
{
if (UserID > 0)
{
System.Console.WriteLine(CurrentSessionID);
new Request()
{
Path = "User/Info",
Method = "GET",
ResponseType = typeof(UserDataResponse),
Parameters = new string[] { "id=" + UserID }
}.Send(delegate(Response _response)
{
if (_response != null)
{
UserDataResponse response = (UserDataResponse)_response;
if (response.Header.Status == "OK")
{
CurrentUser = new User(response);
if (OnLogin != null)
{
OnLogin.Invoke(CurrentUser);
}
}
else
{
if (OnLogout != null)
{
OnLogout.Invoke();
}
}
}
});
}
}
public async Task <UserDataResponse> AuthenticateUserAsync(string USR_ID_TE, string USR_PWD_TE)
{
UserDataResponse userDataResponse = new UserDataResponse();
try
{
User user =
await context.UserData
.FirstOrDefaultAsync(
(User usr) =>
usr.UserId.ToLower() == USR_ID_TE.ToLower() &&
usr.Password == USR_PWD_TE);
userDataResponse.Success = false;
if (user != null)
{
int?role = this.context.UserRoles.FirstOrDefault(_ => _.UserId == user.ID)?.RoleId;
user.Role = role ?? (int)Enums.Roles.OperationUser;
userDataResponse.Success = true;
userDataResponse.Message = "Valid User";
}
else
{
userDataResponse.Message = "User not found, Please check your credentials";
}
userDataResponse.User = user;
}
catch (Exception ex)
{
userDataResponse.Success = false;
userDataResponse.OperationException = ex;
userDataResponse.Message = "Error while getting user";
}
return(userDataResponse);
}
public IActionResult GetUserData()
{
var userContext = _dbContext.Set <User>();
var userEmail = User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.Name)?.Value;
if (userEmail == null)
{
return(BadRequest("Your session has ended please try to login again"));
}
var user = userContext.FirstOrDefault(x => x.Email == userEmail);
if (user == null)
{
return(BadRequest("Your session has ended"));
}
var result = new UserDataResponse {
Email = user.Email, Firstname = user.FirstName, Lastname = user.LastName
};
return(Ok(result));
}
public User(UserDataResponse responseData)
{
this.ID = responseData.Body.UserID;
this.Username = responseData.Body.Username;
this.AvatarURL = responseData.Body.AvatarURL;
this.Usergroup = responseData.Body.Group;
}
