public async Task <PlayerStatBlock> GetUserStatsFromDBAsync()
{
//ConnectionManager.OpenInstanceConnection();
DbCommand dbCommand = ConnectionManager.GetConnection().CreateCommand();
string selectQuery = "SELECT nodesHarvested, distanceTraveled, goldEarned FROM UserStats WHERE UserID = @ID;";
ConnectionManager.CreateNamedParamater("@ID", UserSessionManager.GetID(), dbCommand);
dbCommand.CommandText = selectQuery;
Task <DbDataReader> readerTask = dbCommand.ExecuteReaderAsync();
PlayerStatBlock statBlock = new PlayerStatBlock();
DbDataReader reader = await readerTask;
while (reader.Read())
{
statBlock.totalGatheringPointsHarvested = reader.GetInt32(0);
statBlock.totalDistanceTraveled = reader.GetFloat(1);
statBlock.totalGoldCollected = reader.GetInt32(2);
}
reader.Close();
reader.Dispose();
dbCommand.Dispose();
//ConnectionManager.CloseInstanceConnection();
return(statBlock);
}
public async Task UpdatePlayerStatAsync(EUserStats userStat, PlayerStatBlock statBlock)
{
DbCommand dbCommand = ConnectionManager.GetConnection().CreateCommand();
string updateQuery = "UPDATE UserStats SET " + userStat.ToString() + " = @" + userStat.ToString() + " WHERE userID = @ID;";
ConnectionManager.CreateNamedParamater("@ID", UserSessionManager.GetID(), dbCommand);
switch (userStat)
{
case EUserStats.distanceTraveled:
ConnectionManager.CreateNamedParamater("@" + userStat.ToString(), statBlock.totalDistanceTraveled, dbCommand);
break;
case EUserStats.goldEarned:
ConnectionManager.CreateNamedParamater("@" + userStat.ToString(), statBlock.totalGoldCollected, dbCommand);
break;
case EUserStats.nodesHarvested:
ConnectionManager.CreateNamedParamater("@" + userStat.ToString(), statBlock.totalGatheringPointsHarvested, dbCommand);
break;
default:
break;
}
dbCommand.CommandText = updateQuery;
await Task.Run(() => dbCommand.ExecuteNonQuery());
dbCommand.Dispose();
}
public AccountService(IMemoryCache memoryCache, IJwtHandlers jwtHandlers, IViewRenderService viewRenderService)
{
_memoryCache = memoryCache;
_jwtHandlers = jwtHandlers;
_viewRenderService = viewRenderService;
_userSessionManager = new UserSessionManager(memoryCache);
}
public IActionResult Update([FromBody] TransExpenseModel model, string id)
{
TransExpenseModelOutput _expenseModel = new TransExpenseModelOutput();
try
{
if (ModelState.IsValid)
{
_logger.Information("update Post Expense");
UserSessionManager usrSession = new UserSessionManager();
var user = User as ClaimsPrincipal;
string userId = user.Claims.Where(c => c.Type == "USERID").Select(c => c.Value).SingleOrDefault();
ExpenseServices _expense = new ExpenseServices
{
objUser = usrSession.UserLog(userId)._userInfo
};
var response = _expense.Update(model, id);
_expenseModel.IsSuccess = true;
_expenseModel.Message = "Success Saving";
_expenseModel.Code = 200;
}
else
{
_logger.Error("update Expense");
string errordetails = "";
var errors = new List <string>();
foreach (var state in ModelState)
{
foreach (var error in state.Value.Errors)
{
string p = error.ErrorMessage;
errordetails = errordetails + error.ErrorMessage;
}
}
Dictionary <string, object> dict = new Dictionary <string, object>();
dict.Add("error", errordetails);
_expenseModel.IsSuccess = false;
_expenseModel.Message = "error update saving validating";
_expenseModel.Code = 422;
_expenseModel.CustomField = dict;
}
}
catch (Exception ex)
{
_logger.Error("update Post Expense" + ex.Message);
_expenseModel.IsSuccess = false;
_expenseModel.Message = "Failed update" +
" Saving" + ex.Message;
_expenseModel.Code = 422;
}
return(Ok(_expenseModel));
}
public IActionResult DetailCategory(string id)
{
CategoryModelOutput categoryModel = new CategoryModelOutput();
try
{
_logger.Information("Delete Category " + id);
UserSessionManager usrSession = new UserSessionManager();
var user = User as ClaimsPrincipal;
string userId = user.Claims.Where(c => c.Type == "USERID").Select(c => c.Value).SingleOrDefault();
DisplayCategory displayCategory = new DisplayCategory
{
objUser = usrSession.UserLog(userId)._userInfo
};
var collection = new List <CategoryModel>((List <CategoryModel>)displayCategory.DisplayDetailCategory(id));
categoryModel.IsSuccess = true;
categoryModel.Message = "Success";
categoryModel.Code = 200;
categoryModel.Data = collection;
}
catch (Exception ex)
{
_logger.Error("detail Category" + ex.Message);
categoryModel.IsSuccess = false;
categoryModel.Message = "Failed Delete" + ex.Message;
categoryModel.Code = 422;
}
return(Ok(categoryModel));
}
public IActionResult Delete(string id)
{
TransExpenseModelOutput _expenseModel = new TransExpenseModelOutput();
try
{
_logger.Information("Delete Expense " + id);
UserSessionManager usrSession = new UserSessionManager();
var user = User as ClaimsPrincipal;
string userId = user.Claims.Where(c => c.Type == "USERID").Select(c => c.Value).SingleOrDefault();
ExpenseServices _expense = new ExpenseServices
{
objUser = usrSession.UserLog(userId)._userInfo
};
var response = _expense.Delete(id);
_expenseModel.IsSuccess = true;
_expenseModel.Message = "Success Delete";
_expenseModel.Code = 200;
}
catch (Exception ex)
{
_logger.Error("delete Expense" + ex.Message);
_expenseModel.IsSuccess = false;
_expenseModel.Message = "Failed Delete" + ex.Message;
_expenseModel.Code = 422;
}
return(Ok(_expenseModel));
}
private async void LoginBtn_Click(object sender, EventArgs e)
{
loginBtn.Enabled = registerBtn.Enabled = false;
var areValidInputs = LoginViewModel.CheckInputs(usernameTxt.Text, passwordTxt.Text);
ShowErrors(areValidInputs);
if (areValidInputs != Validation.Correct)
{
loginBtn.Enabled = registerBtn.Enabled = true;
return;
}
var userFound = await Services.PicSayAndPlayService.LoginUser(usernameTxt.Text, passwordTxt.Text);
if (userFound == null)
{
Snackbar.Make(sender as Android.Views.View, "Datos incorrectos :(", Snackbar.LengthLong).Show();
loginBtn.Enabled = registerBtn.Enabled = true;
CleanInputs();
loginBtn.RequestFocus();
return;
}
loginBtn.Enabled = registerBtn.Enabled = true;
var session = new UserSessionManager(this);
session.CreateUserLoginSession(userFound.NickName, passwordTxt.Text);
Intent i = new Intent(this, typeof(MainActivity));
StartActivity(i);
this.Finish();
}
public async Task SaveFullPlayerStatusAsync()
{
var playerPos = playerObject.GetComponent <Transform>().position;
var playerGold = playerObject.GetComponent <PlayerData>().GetGoldHeld();
string updateQuery = "UPDATE PlayerStatus SET posX = @posX, posY = @posY, posZ = @posZ, goldCount = @currentGold WHERE playerID = @id;";
//ConnectionManager.OpenInstanceConnection();
DbCommand dbCommand = ConnectionManager.GetConnection().CreateCommand();
ConnectionManager.CreateNamedParamater("@posX", playerPos.x, dbCommand);
ConnectionManager.CreateNamedParamater("@posY", playerPos.y, dbCommand);
ConnectionManager.CreateNamedParamater("@posZ", playerPos.z, dbCommand);
ConnectionManager.CreateNamedParamater("@currentGold", playerGold, dbCommand);
ConnectionManager.CreateNamedParamater("id", UserSessionManager.GetID(), dbCommand);
dbCommand.CommandText = updateQuery;
await Task.Run(() => dbCommand.ExecuteNonQuery());
dbCommand.Dispose();
//ConnectionManager.CloseInstanceConnection();
}
public async Task GrantAuthAsync(bool verified, string username)
{
if (verified)
{
string selectQueryID = "SELECT ID FROM UserAccounts WHERE username = @username;";
//ConnectionManager.OpenInstanceConnection();
DbCommand dbCommand = ConnectionManager.GetConnection().CreateCommand();
ConnectionManager.CreateNamedParamater("@username", username, dbCommand);
dbCommand.CommandText = selectQueryID;
Task <DbDataReader> readerTask = dbCommand.ExecuteReaderAsync();
DbDataReader reader = await readerTask;
//Temp assigned -1 to prevent data collision
int tempID = -1;
while (reader.Read())
{
tempID = reader.GetInt32(0);
}
reader.Close();
reader.Dispose();
dbCommand.Dispose();
//ConnectionManager.CloseInstanceConnection();
//Create "AuthToken"
UserSessionManager.CreateUserSessionInstance(tempID, username);
}
}
public void EnsureGenerateTokens_regenerate_tokens_every_call()
{
var sessionTokenCounter = 0;
var keyManagerTokenCounter = 100;
_sessionAuthApiMock.Setup(obj => obj.V1AuthenticatePost()).Returns(() =>
{
++sessionTokenCounter;
return(new Token("sessionToken", "s" + sessionTokenCounter.ToString()));
});
_keyAuthApiMock.Setup(obj => obj.V1AuthenticatePost()).Returns(() =>
{
++keyManagerTokenCounter;
return(new Token("keyManagerToken", "km" + keyManagerTokenCounter.ToString()));
});
var userSessionManager = new UserSessionManager(_sessionAuthApiMock.Object, _keyAuthApiMock.Object, _certificate);
Assert.Equal("s1", userSessionManager.SessionToken);
Assert.Equal("km101", userSessionManager.KeyManagerToken);
Assert.Equal("s1", userSessionManager.SessionToken);
Assert.Equal("km101", userSessionManager.KeyManagerToken);
userSessionManager.GenerateTokens();
Assert.Equal("s2", userSessionManager.SessionToken);
Assert.Equal("km102", userSessionManager.KeyManagerToken);
Assert.Equal("km102", userSessionManager.KeyManagerToken);
}
public async Task UpdatePlayerAchievementUnlockAsync(EAchievements achievement, bool unlocked)
{
//ConnectionManager.OpenInstanceConnection();
DbCommand dbCommand = ConnectionManager.GetConnection().CreateCommand();
Debug.Log("Unlock Attempt");
Debug.Log((int)achievement);
int dbbool = 0;
if (unlocked)
{
dbbool = 1;
}
string updateQuery = "UPDATE PlayerAchievements SET unlocked = @unlocked WHERE playerID = @uID AND achievementID = @aID;";
ConnectionManager.CreateNamedParamater("@unlocked", dbbool, dbCommand);
ConnectionManager.CreateNamedParamater("@uID", UserSessionManager.GetID(), dbCommand);
ConnectionManager.CreateNamedParamater("@aID", (int)achievement, dbCommand);
dbCommand.CommandText = updateQuery;
await Task.Run(() => dbCommand.ExecuteNonQuery());
dbCommand.Dispose();
//ConnectionManager.CloseInstanceConnection();
}
public void EnsureGenerateTokens_regenerate_tokens_every_call()
{
var sessionTokenCounter = 0;
var keyManagerTokenCounter = 100;
_sessionAuthApiMock.Setup(obj => obj.V1Async(default(CancellationToken))).Returns(() =>
{
++sessionTokenCounter;
return(Task.FromResult(new Token()
{
Name = "sessionToken", Token1 = "s" + sessionTokenCounter.ToString()
}));
});
_keyAuthApiMock.Setup(obj => obj.V1Async(default(CancellationToken))).Returns(() =>
{
++keyManagerTokenCounter;
return(Task.FromResult(new Token()
{
Name = "keyManagerToken", Token1 = "km" + keyManagerTokenCounter.ToString()
}));
});
var userSessionManager = new UserSessionManager(_sessionAuthApiMock.Object, _keyAuthApiMock.Object, _certificate);
Assert.Equal("s1", userSessionManager.SessionToken);
Assert.Equal("km101", userSessionManager.KeyManagerToken);
Assert.Equal("s1", userSessionManager.SessionToken);
Assert.Equal("km101", userSessionManager.KeyManagerToken);
userSessionManager.GenerateTokens();
Assert.Equal("s2", userSessionManager.SessionToken);
Assert.Equal("km102", userSessionManager.KeyManagerToken);
Assert.Equal("km102", userSessionManager.KeyManagerToken);
}
public static void InitializeUserSessionManager(UserSessionManager <Guid, Guid> manager, Container container)
{
var cfg = container.GetInstance <IConfigService>();
var appSettings = cfg.GetApplicationSettings();
manager.MaximumSessionTimeout = TimeSpan.FromHours(appSettings.MaximumSessionTimeout);
}
public IActionResult Store([FromBody] CategoryModel model)
{
CategoryModelOutput categoryModel = new CategoryModelOutput();
try
{
if (ModelState.IsValid)
{
_logger.Information("Post Sub Category " + model.category_name);
UserSessionManager usrSession = new UserSessionManager();
var user = User as ClaimsPrincipal;
string userId = user.Claims.Where(c => c.Type == "USERID").Select(c => c.Value).SingleOrDefault();
CategoryServices categoryServices = new CategoryServices
{
objUser = usrSession.UserLog(userId)._userInfo
};
model.category_parentid = model.category_parentid;
var response = categoryServices.AddSubCategory(model);
categoryModel.IsSuccess = true;
categoryModel.Message = "Success Saving";
categoryModel.Code = 200;
}
else
{
_logger.Error("Post Sub Category " + model.category_name);
string errordetails = "";
var errors = new List <string>();
foreach (var state in ModelState)
{
foreach (var error in state.Value.Errors)
{
string p = error.ErrorMessage;
errordetails = errordetails + error.ErrorMessage;
}
}
Dictionary <string, object> dict = new Dictionary <string, object>();
dict.Add("error", errordetails);
categoryModel.IsSuccess = false;
categoryModel.Message = "error saving validating";
categoryModel.Code = 422;
categoryModel.CustomField = dict;
}
}
catch (Exception ex)
{
_logger.Error("Post Sub Category" + ex.Message);
categoryModel.IsSuccess = false;
categoryModel.Message = "Failed Saving" + ex.Message;
categoryModel.Code = 422;
}
return(Ok(categoryModel));
}
void DEBUGTestUserInfoInput()
{
if (Input.GetKeyDown(KeyCode.G))
{
Debug.Log(UserSessionManager.GetUsername());
Debug.Log(UserSessionManager.GetID());
}
}
private void SetUserInfo()
{
var session = new UserSessionManager(this);
var userDetails = session.GetUserDetails();
userDetails.TryGetValue(UserSessionManager.KEY_NICKNAME, out nickname);
usernameTvw.Text = nickname;
}
public IActionResult Update([FromBody] UserModel request, string id)
{
UserSessionManager usrSession = new UserSessionManager();
var user = User as ClaimsPrincipal;
string userId = user.Claims.Where(c => c.Type == "USERID").Select(c => c.Value).SingleOrDefault();
UserModelOutput userModelOutput = new UserModelOutput();
try
{
_logger.Information("Update User");
DisplayUser displayUser = new DisplayUser();
var query = new List <UserModel>((List <UserModel>)displayUser.DisplayAll()).AsQueryable();
if (ModelState.IsValid)
{
UserServices userServices = new UserServices
{
objUser = usrSession.UserLog(userId)._userInfo
};
var res = userServices.Update(request, id);
userModelOutput.IsSuccess = true;
userModelOutput.Message = "Success Update";
userModelOutput.Code = 200;
}
else
{
_logger.Error("Error Post Account");
string errordetails = "";
var errors = new List <string>();
foreach (var state in ModelState)
{
foreach (var error in state.Value.Errors)
{
string p = error.ErrorMessage;
errordetails = errordetails + error.ErrorMessage;
}
}
Dictionary <string, object> dict = new Dictionary <string, object>();
dict.Add("error", errordetails);
userModelOutput.IsSuccess = false;
userModelOutput.Message = "error Update validating";
userModelOutput.Code = 422;
userModelOutput.CustomField = dict;
}
}
catch (Exception ex)
{
_logger.Error(ex.Message.ToString());
userModelOutput.IsSuccess = false;
userModelOutput.Message = "Failed Update" + ex.Message;
userModelOutput.Code = 422;
}
return(Ok(userModelOutput));
}
public ChangesController(UserSessionManager userSessionManager)
{
if (userSessionManager == null)
{
throw new ArgumentNullException(nameof(userSessionManager));
}
this.userSessionManager = userSessionManager;
}
public ChatViewModel(Chat chat)
{
EnviarCommand = new Command(() => { Task.Run(Enviar); });
AtualizarCommand = new Command(() => { Task.Run(UpdateChat); });
_UserSession = new UserSessionManager();
_Service = new ChatService();
CurrentChat = chat;
Task.Run(UpdateChat);
}
public async void ClickVerify()
{
_mHandler = GameObject.FindObjectOfType <MenuHandler>();
_aConnection = GameObject.FindObjectOfType <AccountConnection>();
InputField codeInputField = null;
InputField nameInputField = null;
var test = GameObject.FindObjectsOfType <InputField>();
foreach (InputField x in test)
{
switch (x.name)
{
case nameof(EInputFieldNames.UsernameInputField):
nameInputField = x;
break;
case nameof(EInputFieldNames.PasswordInputField):
codeInputField = x;
break;
}
}
try
{
_username = nameInputField.text;
_passcode = codeInputField.text;
}
catch (NullReferenceException)
{
throw new NullReferenceException("ClickVerify: Use of unassigned InputField.");
}
//Now that we have the input field info, we can toggle off the login canvas
_mHandler.ToggleCanvas(_mHandler.GetLoginCanvas());
Task <BoolStringResult> verifyAccountTask = _aConnection.VerifyAccountAsync(_username, _passcode);
var result = await verifyAccountTask;
Debug.Log(result._successful);
Task authTask = _aConnection.GrantAuthAsync(result._successful, _username);
_mHandler.UpdateConfirmationMessageText(result._stringMessage + " Login", result._successful);
if (result._successful)
{
_mHandler.SetPrevCanvas(_mHandler.GetMainMenuCanvas());
}
_mHandler.ToggleCanvas(_mHandler.GetLoadingCanvas());
_mHandler.ToggleCanvas(_mHandler.GetMessageCanvas());
if (authTask.IsCompleted)
{
Debug.Log(UserSessionManager.GetUsername());
Debug.Log(UserSessionManager.GetID());
}
}
public UserSessionMiddleware(RequestDelegate next, IActionDescriptorCollectionProvider routeProvider,
IRouteDataService routeDataService, IPluginTypesService pluginTypesService, ISettingsProvider settingsProvider)
{
if (routeProvider == null)
{
throw new ArgumentNullException(nameof(routeProvider));
}
if (routeDataService == null)
{
throw new ArgumentNullException(nameof(routeDataService));
}
if (pluginTypesService == null)
{
throw new ArgumentNullException(nameof(pluginTypesService));
}
if (settingsProvider == null)
{
throw new ArgumentNullException(nameof(settingsProvider));
}
_next = next;
_routeData = new List <RouteData>();
UserSessionSettings Settings = settingsProvider.GetSettings <UserSessionSettings>(Constants.UserSessionConfiguration);
Settings.SessionTimeout = Shared.Utilities.CheckMinMax(Settings.SessionTimeout, 15, 200);
UserSessionManager.InitialiseSessionManager(new TimeSpan(0, (int)Settings.SessionTimeout, 0));
SessionHelper.InitSessionHelper();
if (!String.IsNullOrWhiteSpace(Settings.CookieName))
{
_cookieName = Settings.CookieName;
}
if (!String.IsNullOrWhiteSpace(Settings.EncryptionKey))
{
_cookieEncryptionKey = Settings.EncryptionKey;
}
if (!String.IsNullOrWhiteSpace(Settings.StaticFileExtensions))
{
_staticFileExtension = Settings.StaticFileExtensions;
}
_defaultCulture = Settings.DefaultCulture;
LoadLoggedInOutData(routeProvider, routeDataService, pluginTypesService);
LoadLoggedInData(routeProvider, routeDataService, pluginTypesService);
LoadLoggedOutData(routeProvider, routeDataService, pluginTypesService);
}
public IHttpActionResult Logout()
{
this.Authentication.SignOut(DefaultAuthenticationTypes.ExternalBearer);
var owinContext = this.Request.GetOwinContext();
var userSessionManager = new UserSessionManager(owinContext);
userSessionManager.InvalidateUserSession();
return(this.Ok("Logout successful"));
}
public IActionResult Post([FromBody] AccountModel request)
{
UserSessionManager usrSession = new UserSessionManager();
var user = User as ClaimsPrincipal;
string userId = user.Claims.Where(c => c.Type == "USERID").Select(c => c.Value).SingleOrDefault();
AccountModelOutput accountModelOutput = new AccountModelOutput();
try
{
_logger.Information("Saving Account");
if (ModelState.IsValid)
{
AccountServices accountServices = new AccountServices
{
objUser = usrSession.UserLog(userId)._userInfo
};
var res = accountServices.Add(request);
accountModelOutput.IsSuccess = true;
accountModelOutput.Message = "Success Saving";
accountModelOutput.Code = 200;
}
else
{
_logger.Error("Error Post Account");
string errordetails = "";
var errors = new List <string>();
foreach (var state in ModelState)
{
foreach (var error in state.Value.Errors)
{
string p = error.ErrorMessage;
errordetails = errordetails + error.ErrorMessage;
}
}
Dictionary <string, object> dict = new Dictionary <string, object>();
dict.Add("error", errordetails);
accountModelOutput.IsSuccess = false;
accountModelOutput.Message = "error saving validating";
accountModelOutput.Code = 422;
accountModelOutput.CustomField = dict;
}
}
catch (Exception ex)
{
_logger.Error(ex.Message.ToString());
accountModelOutput.IsSuccess = false;
accountModelOutput.Message = "Failed Saving" + ex.Message;
accountModelOutput.Code = 422;
}
return(Ok(accountModelOutput));
}
public void EnsureTokens_are_returned_without_explicitly_calling_GenerateTokens()
{
_sessionAuthApiMock.Setup(obj => obj.V1AuthenticatePost()).Returns(new Token("sessionToken", "s1"));
_keyAuthApiMock.Setup(obj => obj.V1AuthenticatePost()).Returns(new Token("keyManagerToken", "km1"));
var userSessionManager = new UserSessionManager(_sessionAuthApiMock.Object, _keyAuthApiMock.Object, _certificate);
var sessionToken = userSessionManager.SessionToken;
var keyManagerToken = userSessionManager.KeyManagerToken;
Assert.Equal("s1", sessionToken);
Assert.Equal("km1", keyManagerToken);
}
//[System.Web.Http.HttpPost]
public IHttpActionResult Logout()
{
Authentication.SignOut(CookieAuthenticationDefaults.AuthenticationType);
// Delete the user's session from the database (revoke its bearer token)
var userSessionManager = new UserSessionManager(this.repository);
userSessionManager.InvalidateUserSession();
return(Ok("Logout successfully"));
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
session = new UserSessionManager(this);
if (!session.IsUserLoggedIn)
{
StartActivity(typeof(LoginActivity));
}
else
{
StartActivity(typeof(MainActivity));
}
}
public async Task <PlayerAchievementBlock> GetUserAchievementsFromDBAsync()
{
PlayerAchievementBlock achievementBlock = new PlayerAchievementBlock();
//ConnectionManager.OpenInstanceConnection();
DbCommand dbCommand = ConnectionManager.GetConnection().CreateCommand();
string selectQuery = "SELECT achievementID, unlocked FROM PlayerAchievements WHERE playerID = @ID;";
ConnectionManager.CreateNamedParamater("@ID", UserSessionManager.GetID(), dbCommand);
dbCommand.CommandText = selectQuery;
Task <DbDataReader> readerTask = dbCommand.ExecuteReaderAsync();
DbDataReader reader = await readerTask;
while (reader.Read())
{
bool isUnlocked = false;
int achieveID = reader.GetInt32(0);
int unlockedint = reader.GetInt32(1);
//Bool is stored as int in SQLite, convert
if (unlockedint == 1)
{
isUnlocked = true;
}
switch (achieveID)
{
case (int)EAchievements.TotalGathers:
achievementBlock.totalGathersUnlocked = isUnlocked;
break;
case (int)EAchievements.DistanceTraveled:
achievementBlock.totalDistanceUnlocked = isUnlocked;
break;
case (int)EAchievements.TotalGold:
achievementBlock.totalGoldUnlocked = isUnlocked;
break;
}
}
reader.Close();
reader.Dispose();
dbCommand.Dispose();
//ConnectionManager.CloseInstanceConnection();
return(achievementBlock);
}
public IActionResult UpdateRolesUser(string rolesid)
{
try
{
_logger.Information("update Roles by user" + rolesid);
UserSessionManager usrSession = new UserSessionManager();
var user = User as ClaimsPrincipal;
string userId = user.Claims.Where(c => c.Type == "USERID").Select(c => c.Value).SingleOrDefault();
RolesServices rolesServices = new RolesServices
{
objUser = usrSession.UserLog(userId)._userInfo
};
var query = rolesServices.UpdateRoles(rolesid);
if (query.Result == 1)
{
var response = new RoleModelOutput
{
IsSuccess = true,
Code = 200,
Message = "Success Update",
};
return(Ok(response));
}
else
{
var response = new RoleModelOutput
{
IsSuccess = false,
Code = 422,
Message = "error update",
};
return(Ok(response));
}
}
catch (Exception ex)
{
_logger.Error(ex.Message.ToString());
var response = new RoleModelOutput
{
IsSuccess = false,
Code = 422,
Message = ex.Message.ToString(),
};
return(Ok(response));
}
}
private async void ExecuteLoginCommand()
{
User user = await UserRepositoryAsync.GetAsync(_email, _password);
if (user == null)
{
_isValidLogin = false;
OnPropertyChanged(nameof(IsValidLogin));
return;
//invalid credentials make error message visible
}
//Login user
UserSessionManager.LoginUser(user, _navigationService);
}
public IHttpActionResult Logout()
{
// This does not actually perform logout! The OWIN OAuth implementation
// does not support "revoke OAuth token" (logout) by design.
this.Authentication.SignOut(DefaultAuthenticationTypes.ExternalBearer);
// Delete the user's session from the database (revoke its bearer token)
var owinContext = this.Request.GetOwinContext();
var userSessionManager = new UserSessionManager(owinContext);
userSessionManager.InvalidateUserSession();
return this.Ok(new
{
message = "Logout successful."
});
}
public override void OnAuthorization(HttpActionContext actionContext)
{
if (SkipAuthorization(actionContext))
{
return;
}
var userSessionManager = new UserSessionManager(new TechShopData(new TechShopDbContext()));
if (userSessionManager.ValidateUserSession())
{
base.OnAuthorization(actionContext);
}
else
{
actionContext.Response = actionContext.ControllerContext.Request.CreateErrorResponse(
HttpStatusCode.Unauthorized, "Access token expried or not valid.");
}
}
public IHttpActionResult Logout()
{
this.Authentication.SignOut(DefaultAuthenticationTypes.ExternalBearer);
var owinContext = this.Request.GetOwinContext();
var userSessionManager = new UserSessionManager(owinContext);
userSessionManager.InvalidateUserSession();
return this.Ok(new
{
message = LogoutSuccessfulMessage
});
}
public async Task<IHttpActionResult> LoginUser(LoginUserBindingModel model)
{
if (this.User.Identity.GetUserId() != null)
{
return this.BadRequest(UserAlreadyLoggedInMessage);
}
if (model == null)
{
return this.BadRequest(InvalidUserDataMessage);
}
var testServer = TestServer.Create<Startup>();
var requestParams = new List<KeyValuePair<string, string>>
{
new KeyValuePair<string, string>("grant_type", "password"),
new KeyValuePair<string, string>("username", model.Username),
new KeyValuePair<string, string>("password", model.Password)
};
var requestParamsFormUrlEncoded = new FormUrlEncodedContent(requestParams);
var tokenServiceResponse = await testServer.HttpClient.PostAsync(
Startup.TokenEndpointPath, requestParamsFormUrlEncoded);
if (tokenServiceResponse.StatusCode == HttpStatusCode.OK)
{
var responseString = await tokenServiceResponse.Content.ReadAsStringAsync();
var jsSerializer = new JavaScriptSerializer();
var responseData =
jsSerializer.Deserialize<Dictionary<string, string>>(responseString);
var authToken = responseData["access_token"];
var username = responseData["userName"];
var owinContext = this.Request.GetOwinContext();
var userSessionManager = new UserSessionManager(owinContext);
userSessionManager.CreateUserSession(username, authToken);
userSessionManager.DeleteExpiredSessions();
}
return this.ResponseMessage(tokenServiceResponse);
}
public IHttpActionResult Logout()
{
// This does not actually perform logout! The OWIN OAuth implementation
// does not support "revoke OAuth token" (logout) by design.
this.Authentication.SignOut(DefaultAuthenticationTypes.ExternalBearer);
// Delete the user's session from the database (revoke its bearer token)
var owinContext = this.Request.GetOwinContext();
var userSessionManager = new UserSessionManager(owinContext);
userSessionManager.InvalidateUserSession();
return this.Ok(new
{
message = "Logout successful."
});
}
public async Task<IHttpActionResult> Login(LoginBindingModel model)
{
if (this.User.Identity.GetUserId() != null)
{
return this.BadRequest("User is already logged in.");
}
if (model == null)
{
return this.BadRequest("Invalid user data.");
}
var testServer = TestServer.Create<Startup>();
var requestParams = new List<KeyValuePair<string, string>>
{
new KeyValuePair<string, string>("grant_type", "password"),
new KeyValuePair<string, string>("username", model.Username),
new KeyValuePair<string, string>("password", model.Password)
};
var requestParamsFormUrlEncoded = new FormUrlEncodedContent(requestParams);
var tokenServiceResponse = await testServer.HttpClient.PostAsync(
"/api/token", requestParamsFormUrlEncoded);
if (tokenServiceResponse.StatusCode == HttpStatusCode.OK)
{
// Sucessful login --> create user session in the database
var responseString = await tokenServiceResponse.Content.ReadAsStringAsync();
var jsSerializer = new JavaScriptSerializer();
var responseData =
jsSerializer.Deserialize<Dictionary<string, string>>(responseString);
var authToken = responseData["access_token"];
var username = responseData["userName"];
var owinContext = this.Request.GetOwinContext();
var userSessionManager = new UserSessionManager(owinContext);
userSessionManager.CreateUserSession(username, authToken);
// Cleanup: delete expired sessions from the database
userSessionManager.DeleteExpiredSessions();
}
return this.ResponseMessage(tokenServiceResponse);
}
public async Task<IHttpActionResult> LoginUser(LoginUserBindingModel model)
{
if (model == null)
{
return this.BadRequest("Invalid user data");
}
// Invoke the "token" OWIN service to perform the login (POST /api/token)
// Use Microsoft.Owin.Testing.TestServer to perform in-memory HTTP POST request
var testServer = TestServer.Create<Startup>();
var requestParams = new List<KeyValuePair<string, string>>
{
new KeyValuePair<string, string>("grant_type", "password"),
new KeyValuePair<string, string>("username", model.Username),
new KeyValuePair<string, string>("password", model.Password)
};
var requestParamsFormUrlEncoded = new FormUrlEncodedContent(requestParams);
var tokenServiceResponse = await testServer.HttpClient.PostAsync(
Startup.TokenEndpointPath, requestParamsFormUrlEncoded);
if (tokenServiceResponse.StatusCode == HttpStatusCode.OK)
{
// Sucessful login --> create user session in the database
var responseString = await tokenServiceResponse.Content.ReadAsStringAsync();
var jsSerializer = new JavaScriptSerializer();
var responseData =
jsSerializer.Deserialize<Dictionary<string, string>>(responseString);
var authToken = responseData["access_token"];
var username = responseData["userName"];
var owinContext = this.Request.GetOwinContext();
var userSessionManager = new UserSessionManager(owinContext);
userSessionManager.CreateUserSession(username, authToken);
// Cleanup: delete expired sessions from the database
userSessionManager.DeleteExpiredSessions();
}
return this.ResponseMessage(tokenServiceResponse);
}
