public async Task <ActionResult> RefreshPassword([FromBody] RefreshModel refreshData)
{
string EmailErrorMessage;
bool isEmail = ValidateEmail(refreshData.Email, out EmailErrorMessage);
if (isEmail == true)
{
try
{
var auth = new FirebaseAuthProvider(new FirebaseConfig(ApiKey));
var ab = auth.SendPasswordResetEmailAsync(refreshData.Email);
return(StatusCode(200));
}
catch (Firebase.Auth.FirebaseAuthException ex)
{
return(StatusCode(400, new { error_desc = ex.Reason.ToString() }));
}
}
else
{
return(StatusCode(400, new { error_desc = "Wrong email format." }));
}
}
public ActionResult RefreshToken()
{
var jsonString = String.Empty;
Request.InputStream.Position = 0;
using (var inputStream = new StreamReader(Request.InputStream))
{
jsonString = inputStream.ReadToEnd();
}
JavaScriptSerializer javaScriptSerializer = new JavaScriptSerializer();
RefreshModel serJsonDetails = javaScriptSerializer.Deserialize(jsonString, typeof(RefreshModel)) as RefreshModel;
RefreshModel refreshtoken = new APIDAL().LookupRefreshToken(new Guid(serJsonDetails.refresh_token)).FirstOrDefault();
IdentityUser user = UserManager.FindByNameAsync(refreshtoken.email).GetAwaiter().GetResult(); //awaite.getresult to force synchronous call.
if (user != null)
{
JWTPayload payload = new JWTPayload(user.Email, user.FirstName, user.LastName, user.Telephone);
payload.iat = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
payload.exp = payload.iat + (60 * 60); //1 hour
byte[] secretKey = Encoding.ASCII.GetBytes("ErvliegtEenMeeuwLangsHetRaamokja");
RefreshResponse response = new RefreshResponse();
response.access_token = Jose.JWT.Encode(payload, secretKey, JwsAlgorithm.HS256);
response.token_type = "Bearer";
return(Json(response));
}
return(new APIAuth(Request, Response).Forbidden());
}
public async Task <IActionResult> Refresh(RefreshModel model)
{
var principal = GetPrincipalFromExpiredToken(model.Token);
var username = principal.Identity.Name;
var savedRefreshToken = await GetRefreshToken(username); //Retrieve the refresh token from [AspNetUserTokens] table
if (savedRefreshToken != model.RefreshToken)
{
await signInManager.SignOutAsync().ConfigureAwait(true);
ModelState.AddModelError("Invalid Token", "Token is no longer valid. Please log back in.");
return(BadRequest(ModelState));
}
var newJwtToken = GenerateAccessToken(principal.Claims);
var newRefreshToken = GenerateRefreshToken();
await DeleteRefreshToken(username).ConfigureAwait(true);
await SaveRefreshToken(username, newRefreshToken).ConfigureAwait(true);
return(new ObjectResult(new
{
jwt = newJwtToken,
refreshToken = newRefreshToken
}));
}
/// <summary>
/// Handles the change of a dictionary on the file system
/// </summary>
/// <param name="dictionary"></param>
private static void HandleInstanceDictionaryChangesOnFileSystem(Dictionary dictionary)
{
OpenFileOperation openFile = new OpenFileOperation(dictionary.FilePath, EfsSystem.Instance, false, true);
openFile.ExecuteUsingProgressDialog(GuiUtils.MdiWindow, "Refreshing dictionary " +
Path.GetFileNameWithoutExtension(dictionary.FilePath), false);
RefreshModel.Execute();
}
/// <summary>
/// Perform the work as a background task
/// </summary>
public override void ExecuteWork()
{
MarkingHistory.PerformMark(() =>
{
FinderRepository.INSTANCE.ClearCache();
Frame.Translate();
});
RefreshModel.Execute();
}
/// <summary>
/// Translates the corresponding test case, according to translation rules
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
public void TranslateHandler(object sender, EventArgs args)
{
MarkingHistory.PerformMark(() =>
{
FinderRepository.INSTANCE.ClearCache();
Item.Translate(true);
});
RefreshModel.Execute();
}
// [ProducesResponseType(409, Type = typeof(ClientErrorResponse))]
public async Task <IActionResult> Refresh(RefreshModel model)
{
try
{
return(Ok(await accessTokenProvider.RefreshTokenAsync(model.Token)));
}
catch
{
return(this.Error("E_INVALID_REFRESH_TOKEN", "Refresh token was invalid"));
}
}
private void HandleDelete(object sender, EventArgs e)
{
if (Selected != null)
{
IModelElement model = Selected.Model as IModelElement;
if (model != null)
{
model.Delete();
RefreshModel.Execute();
}
}
}
/// <summary>
/// Perform the work as a background task
/// </summary>
public override void ExecuteWork()
{
MarkingHistory.PerformMark(() =>
{
FinderRepository.INSTANCE.ClearCache();
foreach (Frame frame in Dictionary.Tests)
{
frame.Translate();
}
});
RefreshModel.Execute();
}
private void restart_Click(object sender, EventArgs e)
{
if (EfsSystem.Runner != null)
{
EfsSystem.Runner.EndExecution();
EfsSystem.Runner = null;
}
Clear();
EfsSystem.Instance.Context.HandleEndOfCycle();
RefreshModel.Execute();
tabControl1.SelectedTab = testExecutionTabPage;
}
private static void OutputJavRefresh(object sendProcess, DataReceivedEventArgs output)
{
if (!string.IsNullOrEmpty(output.Data) && output.Data.StartsWith("AV:"))
{
var jsonStr = output.Data.Replace("AV:", "");
RefreshModel rm = JsonConvert.DeserializeObject <RefreshModel>(jsonStr);
Console.WriteLine("扫描 --> " + rm.Name);
models.Add(rm);
}
}
public async Task <IActionResult> Refresh([FromBody] RefreshModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ProblemModel(ModelState)));
}
var agentId = GetAgentIdentifier();
ClaimsPrincipal principal;
try
{
principal = _securityService.GetPrincipalFromExpiredToken(model.Jwt);
}
catch (SecurityTokenException)
{
return(Unauthorized());
}
var userName = principal.Identity.Name;
var savedRefreshTokens = new List <UserToken>();
try
{
savedRefreshTokens = await _accountService.GetRefreshTokens(userName, _jwtAuthentication.ValidIssuer, _jwtAuthentication.ValidAudience, agentId);
}
catch (InvalidOperationException)
{
return(Unauthorized());
}
if (!(savedRefreshTokens.Any(o => o.Token == model.RefreshToken && o.Expiration > DateTime.UtcNow)))
{
return(Unauthorized());
}
var newJwtToken = _securityService.GenerateToken(principal.Claims);
var newRefreshToken = _securityService.GenerateRefreshToken();
var refreshTokenExpiration = DateTime.UtcNow.AddDays(_staticConfig.RefreshTokenExpirationDays);
await _accountService.DeleteRefreshToken(userName, model.RefreshToken);
await _accountService.SaveRefreshToken(userName, newRefreshToken, agentId,
_jwtAuthentication.ValidIssuer, _jwtAuthentication.ValidAudience, refreshTokenExpiration);
return(Ok(new TokenResultModel
{
Jwt = newJwtToken,
RefreshToken = newRefreshToken
}));
}
public IActionResult RefreshToken(RefreshModel refreshModel)
{
if (!ModelState.IsValid)
{
return(Unauthorized());
}
AuthenticateResponse response = _userService.RefreshToken(refreshModel.Username, refreshModel.RefreshToken);
if (response == null)
{
return(Unauthorized());
}
return(Ok(response));
}
public IActionResult RevokeRefreshToken(RefreshModel refreshModel)
{
if (!ModelState.IsValid)
{
return(Unauthorized());
}
bool isRevoked = _userService.RevokeRefreshToken(refreshModel.Username, refreshModel.RefreshToken);
if (!isRevoked)
{
return(Unauthorized());
}
return(Ok("Revoked"));
}
public IActionResult RefreshToken([FromRoute] string refreshToken)
{
var userId = HttpContext.GetUserId();
if (!_manager.FindUser(userId))
{
return(BadRequest("User does not exist"));
}
var response = new RefreshModel
{
AccessToken = _jwtIssuer.IssueAccessJwt(userId),
RefreshToken = _jwtIssuer.IssueRefreshJwt(userId)
};
return(Ok(response));
}
public async Task <IActionResult> Refresh(RefreshModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
ClaimsPrincipal principal;
try
{
principal = GetPrincipalFromExpiredToken(model.Token);
}
catch (SecurityTokenException e)
{
return(BadRequest(e.Message));
}
var user = await _userManager.FindByIdAsync(principal.Identity.Name);
var result = await _dbContext.UserTokens.SingleOrDefaultAsync(t =>
t.UserId == user.Id && t.Value == model.RefreshToken);
if (user is null || result is null)
{
return(BadRequest());
}
var newToken = GenerateJwtToken(principal.Claims);
await _userManager.RemoveAuthenticationTokenAsync(user, _jwtOptions.RefreshProvider,
"RefreshToken");
var newRefreshToken = await _userManager.GenerateUserTokenAsync(user,
_jwtOptions.RefreshProvider, "RefreshToken");
await _userManager.SetAuthenticationTokenAsync(user, _jwtOptions.RefreshProvider,
"RefreshToken", newRefreshToken);
return(Ok(new
{
token = newToken,
expiration = DateTime.Now.AddMinutes(Convert.ToDouble(_jwtOptions.TokenValidMinutes)),
refreshToken = newRefreshToken
}));
}
public async Task <IActionResult> Post([FromBody] RefreshModel model)
{
try {
var refresh = await this.authService.RefreshToken(model.RefreshToken);
return(Ok(new TokenResponse()
{
RefreshToken = refresh.Refresh.EncodedToken,
Token = refresh.Token.EncodedToken,
ExpiresAt = refresh.Token.TokenModel.ValidTo,
Sub = refresh.Token.TokenModel.Subject,
UniqueName = refresh.Token.TokenModel.Claims.FirstOrDefault(c => c.Type == JwtRegisteredClaimNames.UniqueName)?.Value
}));
} catch (LoginException error) {
return(Unauthorized(new ErrorResponse()
{
Message = error.Message
}));
}
}
public async Task <AuthResponse> RefreshAsync(RefreshModel model)
{
var user = await GetUserByAccessTokenAsync(model.AccessToken);
if (user == null)
{
throw new SecurityTokenException("Invalid token!");
}
var refreshToken = await _sessionRefreshTokenRepository.GetSessionByTokenAsync(model.RefreshToken);
if (refreshToken == null || refreshToken.UserId != user.Id)
{
throw new SecurityTokenException("Invalid token!");
}
else if (!refreshToken.IsActive || DateTime.UtcNow > refreshToken.ExpiredTime)
{
throw new SecurityTokenException("Expired token!");
}
return(GetAuthResponse(user, await UpdateRefreshToken(refreshToken)));
}
public void AddTransitionHandler(object sender, EventArgs args)
{
SelectStartAndTargetStateForTransition dialog = new SelectStartAndTargetStateForTransition();
dialog.SetStateMachine(Item.EnclosingStateMachine, Item);
dialog.ShowDialog(GuiUtils.MdiWindow);
if (dialog.OkCkicked)
{
State sourceState = Item.EnclosingStateMachine.FindState(dialog.StartStateName);
if (sourceState != null)
{
Rule rule = Rule.CreateDefault(sourceState.StateMachine.Rules);
sourceState.StateMachine.appendRules(rule);
RuleCondition ruleCondition = (RuleCondition)rule.RuleConditions[0];
Action action = Action.CreateDefault(ruleCondition.Actions);
action.ExpressionText = "THIS <- " + dialog.EndStateName;
ruleCondition.appendActions(action);
RefreshModel.Execute();
}
}
}
public async Task <AuthResponse> RefreshAsync([FromBody] RefreshModel model)
{
return(await _authService.RefreshAsync(model));
}
public void AddHandler(object sender, EventArgs args)
{
Item.appendSteps(Step.CreateDefault(Item.Steps));
// TODO do this in a less ad hoc way
RefreshModel.Execute();
}
public static List <RefreshModel> GetJavbusAVList(string url, int page, bool onlyMag = true)
{
List <RefreshModel> ret = new List <RefreshModel>();
var cc = HtmlManager.GetCookies("https://www.javbus.com");
if (onlyMag)
{
cc.Add(new Cookie()
{
Domain = "www.javbus.com",
Name = "existmag",
Value = "mag"
});
}
else
{
cc.Add(new Cookie()
{
Domain = "www.javbus.com",
Name = "existmag",
Value = "all"
});
}
var c = new CookieContainer();
c.Add(cc);
for (int i = 1; i <= page; i++)
{
var htmlResult = HtmlManager.GetHtmlContentViaUrl(url + "/" + i, "utf-8", true, c);
if (htmlResult.Success)
{
HtmlDocument htmlDocument = new HtmlDocument();
htmlDocument.LoadHtml(htmlResult.Content);
var itemPath = "//div[@class='item']";
var itemNodes = htmlDocument.DocumentNode.SelectNodes(itemPath);
foreach (var item in itemNodes)
{
if (!item.InnerHtml.Contains("avatar-box"))
{
RefreshModel temp = new RefreshModel();
var itemUrl = item.ChildNodes[1].Attributes["href"].Value;
var id = itemUrl.Substring(itemUrl.LastIndexOf("/") + 1);
var name = item.ChildNodes[1].ChildNodes[1].ChildNodes[1].Attributes["title"].Value;
var pic = item.ChildNodes[1].ChildNodes[1].ChildNodes[1].Attributes["src"].Value;
temp.Id = id;
temp.Name = name;
temp.Url = pic.Replace("https://pics.javbus.com/thumb/", "https://pics.javbus.com/cover/").Replace(".jpg", "_b.jpg");
ret.Add(temp);
}
}
}
}
return(ret);
}
public async Task <AuthResponse> RefreshAsync(RefreshModel model)
{
return(await _authProvider.RefreshAsync(model));
}
public IActionResult Refresh([FromBody] RefreshModel refreshModel)
{
var principal = tokenService.GetPrincipalFromExpiredToken(refreshModel.AccessToken);
// If null, the token isn't valid
if (principal == null)
{
return(BadRequest());
}
// Gets the user Id from Claims
int Id;
Int32.TryParse(principal.FindFirstValue(ClaimTypes.NameIdentifier), out Id);
User user = unitOfWork.Users.Retrieve(Id);
// Checks that the user exists and has a refresh token
if (user == null || user.RefreshTokens.Count() == 0)
{
return(BadRequest());
}
// Checks that the refresh token from the client,
// matches one asignt to the user
RefreshToken storedRefreshToken = null;
foreach (RefreshToken r in user.RefreshTokens)
{
if ((r.Token).Equals(refreshModel.RefreshToken))
{
storedRefreshToken = r;
}
}
if (storedRefreshToken == null)
{
return(BadRequest());
}
// Generates a new access token and refresh token
var newJwtToken = tokenService.GenerateAccessToken(principal.Claims);
var newRefreshToken = tokenService.GenerateRefreshToken();
// Deletes the old refresh token from database
unitOfWork.Users.DeleteRefrechToken(storedRefreshToken);
// Add the new refresh token to user
user.RefreshTokens.Add
(
new RefreshToken {
Token = newRefreshToken
}
);
unitOfWork.Users.Update(user);
unitOfWork.Save();
return(new ObjectResult(new
{
accessToken = newJwtToken,
refreshToken = newRefreshToken
}));
}
public async Task LogoutAsync([FromBody] RefreshModel model)
{
await _authService.LogoutAsync(HttpContext.GetCurrentUserId());
}
public async Task UpdateValidValues(PropertyInfo propertyInfo, IEnumerable <string> validOptions)
{
validValues[propertyInfo] = validOptions;
await RefreshModel.Invoke();
}
public async Task <IActionResult> Refresh([FromBody] RefreshModel model)
{
return(Ok());
}
