public async Task <IActionResult> Refresh(RefreshRequest request)
{
User user = await dbContext.Users.FirstOrDefaultAsync(it => it.RefreshToken.Equals(request.RefreshToken, StringComparison.OrdinalIgnoreCase));
if (user == null)
{
// The refresh token presented by the client is invalid.
return(Unauthorized());
}
// The refresh token was accepted.
// Security Note: We don't need to regenerate the refresh token
// since the owner has already been authenticated.
// An impersonating JWT bearer will only have access util token
// expiry.
// The JWT bearer will only have the refresh token under
// the scenario that they have the account credentials.
RefreshResponse response = new RefreshResponse()
{
Token = CreateTokenFor(user)
};
return(Ok(response));
}
public Task <RefreshResponse> Refresh()
{
return(Task.Factory.StartNew(() =>
{
var res = new RefreshResponse();
try
{
var file = Utils.DownloadFile(BaseUrl + "/versions.gz", LastModified);
if (file.WasModified)
{
List <Version> changes;
ParseVersionList(file.Content, out changes);
res.ChangedVersions = changes;
res.HasChanged = true;
LastModified = file.DateModified;
}
}
catch (Exception ex)
{
Trace.TraceError("Error reading version list from {0}: {1}", BaseUrl, ex);
}
return res;
}));
}
public RefreshResponse RefreshToken(string token)
{
RefreshResponse refreshResponse = new RefreshResponse();
try {
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
tokenHandler.ValidateToken(token, new TokenValidationParameters {
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(key),
ValidateIssuer = false,
ValidateAudience = false,
// set clockskew to zero so tokens expire exactly at token expiration time (instead of 5 minutes later)
ClockSkew = TimeSpan.Zero
}, out SecurityToken validatedToken);
var jwtToken = (JwtSecurityToken)validatedToken;
var userId = int.Parse(jwtToken.Claims.First(x => x.Type == "unique_name").Value);
// refreshResponse.Token = generateJwtToken (userId.ToString (), "WEB");
// refreshResponse.RefreshToken = generateRefreshToken (userId.ToString (), "WEB");
refreshResponse.Message = "Refresh token regenerated.";
refreshResponse.IsAPIValid = true;
return(refreshResponse);
} catch (Exception ex) {
return(refreshResponse = new RefreshResponse()
{
Message = "Token expired. Error : " + ex.Message,
IsAPIValid = false
});
}
}
public IActionResult Refresh()
{
string bearer = HttpContext.Request.Headers["ZestyApiBearer"];
if (String.IsNullOrWhiteSpace(bearer))
{
ThrowApplicationError("Bearer non found");
}
string secret = Business.User.GetSecret(bearer);
string token = JwtBuilder.Create()
.WithAlgorithm(new HMACSHA256Algorithm())
.WithSecret(secret)
.AddClaim("exp", DateTimeOffset.UtcNow.AddHours(12).ToUnixTimeSeconds())
.AddClaim("user", Context.Current.User)
.Encode();
logger.Debug($"token generated: {token}");
Business.User.SaveBearer(Context.Current.User.Id, token);
RefreshResponse response = new RefreshResponse()
{
Bearer = token
};
return(GetOutput(response));
}
private RefreshResponse Unpack(GenericRefreshProtocolProtos.GenericRefreshResponseProto
proto)
{
// The default values
string message = null;
string sender = null;
int returnCode = -1;
// ... that can be overridden by data from the protobuf
if (proto.HasUserMessage())
{
message = proto.GetUserMessage();
}
if (proto.HasExitStatus())
{
returnCode = proto.GetExitStatus();
}
if (proto.HasSenderName())
{
sender = proto.GetSenderName();
}
// ... and put into a RefreshResponse
RefreshResponse response = new RefreshResponse(returnCode, message);
response.SetSenderName(sender);
return(response);
}
private void Refresh()
{
try
{
RefreshRequest refreshRequest = new RefreshRequest();
refreshRequest.id = "admin";
RefreshResponse response = BroadCastControllerProxy.broadCastControllerProxy.Refresh(refreshRequest);
if (response.retCode == "0")
{
lastRefreshTime = DateTime.Now;
BroadCastControllerProxy.broadCastControllerProxy.Token = response.accessToken;//获取令牌
int.TryParse(response.expires, out refreshTick);
if (refreshTick < 1)
{
refreshTick = 7200;//默认2小时刷新一次
}
LogHelper.Debug("Http远程刷新登录状态成功");
}
else
{
LogHelper.Error("广播系统远程刷新接口调用异常，错误码:" + response.retCode);
}
}
catch (Exception ex)
{
LogHelper.Error("刷新广播系统Http远程服务器异常," + ex);
}
}
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 <bool> Handle(RefreshRequest message, IOutputPort <RefreshResponse> outputPort)
{
RefreshResponse response = new RefreshResponse {
rowInfo = message.rowInfo, dbSetName = message.dbSetName
};
try
{
Metadata.RunTimeMetadata metadata = _service.GetMetadata();
DbSetInfo dbSetInfo = metadata.DbSets.Get(message.dbSetName) ?? throw new InvalidOperationException($"The DbSet {message.dbSetName} was not found in metadata");
message.SetDbSetInfo(dbSetInfo);
message.rowInfo.SetDbSetInfo(dbSetInfo);
RefreshContext <TService> context = new RefreshContext <TService>(message,
response,
(TService)_service,
_serviceContainer);
await _pipeline(context);
}
catch (Exception ex)
{
if (ex is System.Reflection.TargetInvocationException)
{
ex = ex.InnerException;
}
string err = _onError(ex);
response.error = new ErrorInfo(err, ex.GetType().Name);
}
outputPort.Handle(response);
return(true);
}
public override async Task PrepareAsync(CancellationToken cancellation)
{
if (IsReady && DateTime.Now < _authExpiration)
{
return;
}
var data = GetCredentials();
var clientId = data.Item1;
var clientSecret = data.Item2.Substring(2);
var enc = Storage.GetEncrypted <string>(KeyAuthToken);
if (enc == null)
{
return;
}
try {
_authToken = JsonConvert.DeserializeObject <AuthResponse>(enc);
_authExpiration = Storage.Get(KeyAuthExpiration, default(DateTime));
} catch (Exception) {
Logging.Warning("Can’t load auth token");
return;
}
if (DateTime.Now < _authExpiration)
{
IsReady = true;
return;
}
RefreshResponse refresh = null;
try {
refresh = await Request.Post <RefreshResponse>(@"https://login.microsoftonline.com/common/oauth2/v2.0/token", new NameValueCollection {
{ @"client_id", clientId },
{ @"client_secret", clientSecret },
{ @"refresh_token", _authToken.RefreshToken },
{ @"grant_type", @"refresh_token" }
}, null, cancellation : cancellation);
} catch (Exception e) {
Logging.Warning(e);
}
cancellation.ThrowIfCancellationRequested();
if (refresh == null)
{
Storage.Remove(KeyAuthToken);
}
else
{
_authToken.AccessToken = refresh.AccessToken;
_authExpiration = DateTime.Now + TimeSpan.FromSeconds(refresh.ExpiresIn) - TimeSpan.FromSeconds(20);
Storage.SetEncrypted(KeyAuthToken, JsonConvert.SerializeObject(_authToken));
Storage.Set(KeyAuthExpiration, _authExpiration);
IsReady = true;
}
}
public TwitchAuth(ServiceEnum serviceType, string clientId, RefreshResponse refreshResponse)
{
ServiceType = serviceType;
Expired = false;
ClientId = clientId;
AccessToken = refreshResponse.AccessToken;
RefreshToken = refreshResponse.RefreshToken;
}
public void Refresh()
{
LoginRequest request = new LoginRequest(connection, "*****@*****.**", "7CujD&pg4nh");
LoginResponse response = request.Send();
Assert.AreEqual(response.StatusCode, System.Net.HttpStatusCode.OK);
RefreshRequest request2 = new RefreshRequest(connection, response.refresh_token);
RefreshResponse response2 = request2.Send();
Assert.AreEqual(response2.StatusCode, System.Net.HttpStatusCode.OK);
}
public RefreshContext(
RefreshRequest request,
RefreshResponse response,
TService service,
IServiceContainer <TService> serviceContainer
)
{
_ExceptionInfo = null;
Request = request;
Response = response;
Service = service;
ServiceContainer = serviceContainer;
Properties = new Dictionary <string, object>();
}
private ICollection <RefreshResponse> Unpack(GenericRefreshProtocolProtos.GenericRefreshResponseCollectionProto
collection)
{
IList <GenericRefreshProtocolProtos.GenericRefreshResponseProto> responseProtos =
collection.GetResponsesList();
IList <RefreshResponse> responses = new AList <RefreshResponse>();
foreach (GenericRefreshProtocolProtos.GenericRefreshResponseProto rp in responseProtos)
{
RefreshResponse response = Unpack(rp);
responses.AddItem(response);
}
return(responses);
}
//Twitch Token Refresher
public async void TwitchTokenRefresher()
{
if (!_q)
{
RefreshResponse v = await Task.Run(() => RefreshTokenCall()).ConfigureAwait(true);
_settings.refreshToken = v.RefreshToken;
_settings.accessToken = v.AccessToken;
//ThreadManager.Build(_main.SaveSettingsThread, "SaveSettingsThread");
_q = true;
ThreadManager.WakeUp("Client_connect");
ThreadManager.CloseThread("TwitchTokenRefresher");
}
}
public IActionResult RefreshToken()
{
string refreshToken = Request.Cookies["refreshToken"];
RefreshResponse refreshResponse = _authService.RefreshToken(refreshToken, IpAddress());
if (refreshResponse == null)
{
return(Unauthorized("Invalid token"));
}
SetTokenCookie(refreshResponse.RefreshToken);
return(Ok(refreshResponse));
}
public IActionResult RefreshToken([FromQuery] TokenRequest request)
{
if (ModelState.IsValid)
{
RefreshResponse response = userService.RefreshToken(request.Token);
if (response.Success)
{
return(Ok(response.Auth));
}
return(BadRequest(response.AllErrors()));
}
return(BadRequest(ModelState.Errors()));
}
public RefreshResponse RefreshToken(string token)
{
RefreshResponse response = new RefreshResponse();
try
{
ClaimsPrincipal claim = TokenHelper.ValidateAndDecodeRefreshToken(token);
int UserId = int.Parse(claim.Identity.Name);
Authentication auth = dbContext.Authentication.Include(a => a.User).SingleOrDefault(a => a.UserId == UserId);
if (auth != null)
{
string passwordHash = claim.Identities.FirstOrDefault().Claims.Where(c => c.Type == ClaimTypes.Hash).Single().Value;
//make sure password hasn't changed since token was issued
if (HashHelper.GetStringSha256Hash(auth.Password) != passwordHash)
{
response.Success = false;
response.AddError("*", "Password has been changed since this refresh token was generated.");
}
else
{
response.Auth = new Auth(auth.UserId, auth.Email, TokenHelper.GenerateAccessToken(auth.User), TokenHelper.GenerateRefreshToken(auth.User));
response.Success = true;
response.Message = "Access token renewed";
}
}
else
{
response.Success = false;
response.AddError("*", "Link is invalid or has expired");
}
}
catch (Exception e)
{
response.Success = false;
response.AddError("*", "Refresh token invalid or expired");
}
return(response);
}
public static bool RefreshToken(string accessToken, string clientToken)
{
bool tokenRefreshed = false;
ValidateRequest validateRequest = new ValidateRequest(accessToken, clientToken);
/* token is not more valid, ask to revalidate it */
HttpWebRequest httpRefreshWebRequest = (HttpWebRequest)WebRequest.Create(CommonData.authServerRefreshURL);
httpRefreshWebRequest.ContentType = "application/json";
httpRefreshWebRequest.Method = "POST";
using (StreamWriter refreshStreamWriter = new StreamWriter(httpRefreshWebRequest.GetRequestStream()))
{
string json = JsonConvert.SerializeObject(validateRequest);
refreshStreamWriter.Write(json);
refreshStreamWriter.Flush();
refreshStreamWriter.Close();
try
{
HttpWebResponse httpResponse = (HttpWebResponse)httpRefreshWebRequest.GetResponse();
using (StreamReader streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
/* Connected */
string result = streamReader.ReadToEnd();
RefreshResponse refreshResponse = JsonConvert.DeserializeObject <RefreshResponse>(result);
CommonData.launcherProfileJson.authenticationDatabase.accessToken = refreshResponse.accessToken;
tokenRefreshed = true;
}
}
catch (Exception)
{
/* ERROR to revalidate the token */
}
}
CommonData.saveLauncherProfile();
return(tokenRefreshed);
}
public Task <RefreshResponse> Refresh(string writableRoot)
{
return(Task.Factory.StartNew(() =>
{
var res = new RefreshResponse();
try
{
var file = Utils.DownloadFile(BaseUrl + "/versions.gz", LastModified);
if (file.WasModified)
{
List <Version> changes;
ParseVersionList(file.Content, out changes);
res.ChangedVersions = changes;
LastModified = file.DateModified;
var uri = new Uri(BaseUrl);
var pathString = uri.Host + uri.PathAndQuery + uri.Fragment;
var targetFolder = Path.Combine(writableRoot, "rapid", pathString);
if (!Directory.Exists(targetFolder))
{
Directory.CreateDirectory(targetFolder);
}
var targetPath = Path.Combine(targetFolder, "versions.gz");
if (!File.Exists(targetPath) || !File.ReadAllBytes(targetPath).SequenceEqual(file.Content))
{
File.WriteAllBytes(targetPath, file.Content);
res.HasChanged = true;
}
}
}
catch (Exception ex)
{
Trace.TraceError("Error reading version list from {0}: {1}", BaseUrl, ex);
}
return res;
}));
}
public bool CheckExpiration()
{
RefreshResponse refresh = CheckExpiration(ExpirationDateTime, RefreshToken);
if (refresh != null)
{
if (refresh.IsValid())
{
ApiToken = CurrentUser.ApiToken = refresh.ApiToken;
RefreshToken = CurrentUser.RefreshToken = refresh.RefreshToken;
Expiration = CurrentUser.TokenExpiration = refresh.TokenExpiration;
RefreshThread = new Thread(new RefreshTokenWorker(this).Start);
RefreshThread.Start();
}
else
{
return(false);
}
}
return(true);
}
public async Task <ActionResult> Refresh([FromBody] RefreshRequest refreshInfo)
{
RefreshResponse res = await DomainService.ServiceRefreshRow(refreshInfo);
return(new ChunkedResult <RefreshResponse>(res, DomainService.Serializer));
}
public Task<RefreshResponse> Refresh()
{
return Task.Factory.StartNew(() =>
{
var res = new RefreshResponse();
try
{
var file = Utils.DownloadFile(BaseUrl + "/versions.gz", LastModified);
if (file.WasModified)
{
List<Version> changes;
ParseVersionList(file.Content, out changes);
res.ChangedVersions = changes;
res.HasChanged = true;
LastModified = file.DateModified;
}
}
catch (Exception ex)
{
Trace.TraceError("Error reading version list from {0}: {1}", BaseUrl, ex);
}
return res;
});
}
public async Task <ActionResult> Refresh([ServiceParamsBinder] RefreshRequest refreshInfo)
{
RefreshResponse response = await DomainService.ServiceRefreshRow(refreshInfo);
return(new ChunkedResult <RefreshResponse>(response, Serializer));
}
/// <summary>
/// Gets an access token to use as a bearer in request headers.
/// Returns null if there isn't a valid access or refresh token.
/// If a null is returned, the user should be logged out to re-authenticate.
/// Returns ServerUtils.ServerErr if the request failed for other reasons.
/// </summary>
/// <returns>The access token.</returns>
private static async Task <string> GetAccessToken()
{
DatabaseManager dbManager = await Storage.GetDatabaseManager(false);
if (dbManager.CurrentUser == null)
{
return(null);
}
// return access token if one exists and is still valid
if (!string.IsNullOrWhiteSpace(dbManager.CurrentUser.AccessToken) &&
dbManager.CurrentUser.AccessExpiresAt > DateTime.UtcNow)
{
return(dbManager.CurrentUser.AccessToken);
}
// need to get new access token.
// Check that we have a refresh token which exists and is valid
if (!string.IsNullOrWhiteSpace(dbManager.CurrentUser.RefreshToken) &&
dbManager.CurrentUser.RefreshExpiresAt > DateTime.UtcNow)
{
// request new access token
try
{
using (var client = new HttpClient())
{
Dictionary <string, string> args = new Dictionary <string, string>
{
{ "grant_type", "refresh_token" },
{ "refresh_token", dbManager.CurrentUser.RefreshToken }
};
HttpRequestMessage req = new HttpRequestMessage(HttpMethod.Post, ConfidentialData.api + "Token")
{
Content = new FormUrlEncodedContent(args)
};
HttpResponseMessage resp = await client.SendAsync(req);
if (resp.Content == null || !resp.IsSuccessStatusCode)
{
// failed, check if the refresh token is invalid
if (resp.Content != null && resp.StatusCode == HttpStatusCode.BadRequest)
{
string json = await resp.Content.ReadAsStringAsync();
if (!string.IsNullOrWhiteSpace(json))
{
ErrorResponse errResp = JsonConvert.DeserializeObject <ErrorResponse>(json);
if (errResp != null && errResp.Error == "invalid_grant")
{
// token invalid, prompt new sign-in
return(null);
}
}
}
// failed for reasons other than the token, shouldn't log out
return(ServerErr);
}
else
{
string json = await resp.Content.ReadAsStringAsync();
RefreshResponse refResp = JsonConvert.DeserializeObject <RefreshResponse>(json);
if (refResp != null && !string.IsNullOrWhiteSpace(refResp.Access_token))
{
// success! Save the new access token and its expiry time
dbManager.CurrentUser.AccessToken = refResp.Access_token;
dbManager.CurrentUser.AccessExpiresAt = DateTime.UtcNow.AddSeconds(refResp.Expires_in);
dbManager.AddUser(dbManager.CurrentUser);
return(refResp.Access_token);
}
return(ServerErr);
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(ServerErr);
}
}
// returning null should prompt return to sign-in
return(null);
}
public RefreshResponse Refresh()
{
var res = new RefreshResponse();
res.WaitHandle = new EventWaitHandle(false, EventResetMode.ManualReset);
var wc = new WebClient()
{
Proxy = null
};
wc.DownloadDataCompleted += (s, digestResult) =>
{
// digest downloaded
if (digestResult.Error != null || digestResult.Cancelled)
{
// digest download failed
Trace.TraceError(string.Format("Failed to download digest for {0}: {1}", BaseUrl, digestResult.Error));
res.WaitHandle.Set();
}
else if (Hash.ByteArrayEquals(LastDigest, digestResult.Result))
{
res.WaitHandle.Set(); // digest same as before
}
else
{
// digest new
var wcRevs = new WebClient()
{
Proxy = null
};
wcRevs.DownloadDataCompleted += (s2, versionsResult) =>
{
// version list downloaded
try
{
if (versionsResult.Error != null || versionsResult.Cancelled)
{
Trace.TraceError(string.Format("Failed to download versions from {0}: {1}", BaseUrl, versionsResult.Error));
}
else
{
List <Version> changes;
ParseVersionList(versionsResult.Result, out changes);
res.ChangedVersions = changes;
res.HasChanged = true;
LastDigest = digestResult.Result;
}
}
catch (Exception ex)
{
Trace.TraceError("Error reading version list from {0}: {1}", BaseUrl, ex);
}
finally
{
res.WaitHandle.Set();
}
};
wcRevs.DownloadDataAsync(new Uri(BaseUrl + "/versions.gz"));
// start version list download
}
};
wc.DownloadDataAsync(new Uri(BaseUrl + "/versions.digest"));
return(res);
}
public void OnAuthentication(AuthenticationContext filterContext)
{
//Get current user
ClaimsPrincipal user = filterContext.HttpContext.User as ClaimsPrincipal;
if (user != null && user.Identity.IsAuthenticated)
{
ClaimsIdentity identity = new ClaimsIdentity(user.Identity);
DateTime expiresTime = DateTimeOffset.FromUnixTimeSeconds(long.Parse(identity.FindFirst(ClaimTypes.Expiration).Value)).LocalDateTime;
if (expiresTime < DateTime.Now)
{
string connection = ConfigurationManager.AppSettings["InternalAPIURL"];
string refreshToken = identity.FindFirst("RefreshToken").Value;
RefreshRequest refreshRequest = new RefreshRequest(connection, refreshToken);
RefreshResponse refreshResponse = refreshRequest.Send();
GetUserDetailsRequest userDetailRequest = new GetUserDetailsRequest(connection, refreshResponse.access_token, new Guid(refreshResponse.user_id));
GetUserDetailsResponse userDetailResponse = userDetailRequest.Send();
if (refreshResponse.StatusCode == System.Net.HttpStatusCode.OK && userDetailResponse.StatusCode == System.Net.HttpStatusCode.OK)
{
//Update the user's claims
identity.RemoveClaim(identity.FindFirst("AccessToken"));
identity.RemoveClaim(identity.FindFirst(ClaimTypes.Expiration));
identity.RemoveClaim(identity.FindFirst(ClaimTypes.Name));
identity.RemoveClaim(identity.FindFirst(ClaimTypes.NameIdentifier));
identity.AddClaim(new Claim("AccessToken", refreshResponse.access_token));
identity.AddClaim(new Claim(ClaimTypes.Expiration, refreshResponse.expireTime));
identity.AddClaim(new Claim(ClaimTypes.Name, refreshResponse.user_nick));
identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, refreshResponse.user_id));
var roleClaims = identity.FindAll(ClaimTypes.Role);
foreach (Claim role in roleClaims)
{
identity.RemoveClaim(role);
}
if (userDetailResponse.PERMISSIONS.Administrator)
{
identity.AddClaim(new Claim(ClaimTypes.Role, "Administrator"));
}
if (userDetailResponse.PERMISSIONS.Developer)
{
identity.AddClaim(new Claim(ClaimTypes.Role, "Developer"));
}
var authenticationManager = filterContext.HttpContext.GetOwinContext().Authentication;
authenticationManager.SignOut();
AuthenticationProperties properties = new AuthenticationProperties {
IsPersistent = Convert.ToBoolean(identity.FindFirst(ClaimTypes.IsPersistent).Value)
};
authenticationManager.SignIn(properties, identity);
ClaimsPrincipal claimsPrincipal = new ClaimsPrincipal(identity);
filterContext.HttpContext.User = claimsPrincipal;
}
else
{
filterContext.HttpContext.GetOwinContext().Authentication.SignOut();
}
}
}
else
{
filterContext.Result = new RedirectToRouteResult(new RouteValueDictionary {
{ "controller", "Account" }, { "action", "Login" }
});
}
}
public Task<RefreshResponse> Refresh(string writableRoot)
{
return Task.Factory.StartNew(() =>
{
var res = new RefreshResponse();
try
{
var file = Utils.DownloadFile(BaseUrl + "/versions.gz", LastModified);
if (file.WasModified)
{
List<Version> changes;
ParseVersionList(file.Content, out changes);
res.ChangedVersions = changes;
res.HasChanged = true;
LastModified = file.DateModified;
var targetFolder = Path.Combine(writableRoot, "rapid", new Uri(BaseUrl).Host);
if (!Directory.Exists(targetFolder)) Directory.CreateDirectory(targetFolder);
File.WriteAllBytes(Path.Combine(targetFolder, "versions.gz"), file.Content);
}
}
catch (Exception ex)
{
Trace.TraceError("Error reading version list from {0}: {1}", BaseUrl, ex);
}
return res;
});
}
public virtual void SetUp()
{
// Register Handlers, first one just sends an ok response
firstHandler = Org.Mockito.Mockito.Mock <RefreshHandler>();
Org.Mockito.Mockito.Stub(firstHandler.HandleRefresh(Org.Mockito.Mockito.AnyString
(), Org.Mockito.Mockito.Any <string[]>())).ToReturn(RefreshResponse.SuccessResponse
());
RefreshRegistry.DefaultRegistry().Register("firstHandler", firstHandler);
// Second handler has conditional response for testing args
secondHandler = Org.Mockito.Mockito.Mock <RefreshHandler>();
Org.Mockito.Mockito.Stub(secondHandler.HandleRefresh("secondHandler", new string[]
{ "one", "two" })).ToReturn(new RefreshResponse(3, "three"));
Org.Mockito.Mockito.Stub(secondHandler.HandleRefresh("secondHandler", new string[]
{ "one" })).ToReturn(new RefreshResponse(2, "two"));
RefreshRegistry.DefaultRegistry().Register("secondHandler", secondHandler);
}
public string Refresh(string sAccessToken, string sClientToken)
{
// declare needed objects
string sJsonResponse = null;
WebResponse response = null;
StreamReader stringResponse = null;
Stream dataStream = null;
// create and fill JSON object
RefreshRequest jsonObject = new RefreshRequest
{
AccessToken = sAccessToken,
ClientToken = sClientToken
};
// Serialize JSON
string sJsonRequest = Json.RefreshRequest.Serialize.ToJson(jsonObject);
// send HTTP POST request
try
{
// Create request
WebRequest request = WebRequest.Create(sAuthServer + "/refresh");
// set Method
request.Method = "POST";
// set TimeOut
request.Timeout = 3000;
// append POST data
byte[] byteArray = Encoding.UTF8.GetBytes(sJsonRequest);
request.ContentType = "application/json";
request.ContentLength = byteArray.Length;
dataStream = request.GetRequestStream();
dataStream.Write(byteArray, 0, byteArray.Length);
// Get response
response = request.GetResponse();
stringResponse = new StreamReader(response.GetResponseStream());
// return answer
sJsonResponse = stringResponse.ReadToEnd().Trim();
// close open objects
}
catch (WebException ex)
{
switch (ex.Status)
{
case WebExceptionStatus.ProtocolError:
if (ex.Message.Contains("500") || ex.Message.Contains("503"))
{
throw new Exception("Mojang Loginservice nicht verfügbar.");
}
if (ex.Message.Contains("403"))
{
// Get Json Answer
sJsonResponse = new StreamReader(ex.Response.GetResponseStream()).ReadToEnd().Trim();
// deserialize JSON
AuthenticatieError ErrorMessage = AuthenticatieError.FromJson(sJsonResponse);
if (ErrorMessage.ErrorMessage == "Invalid token.")
{
throw new MCInvalidTokenException(ErrorMessage.ErrorMessage);
}
throw new Exception(ErrorMessage.ErrorMessage);
}
throw new Exception(ex.Message);
default:
throw new Exception(ex.Message);
}
}
finally
{
// close everything
if (stringResponse != null)
{
stringResponse.Close();
}
if (dataStream != null)
{
dataStream.Close();
}
if (response != null)
{
response.Close();
}
}
// Deserialize JSON into object
RefreshResponse MCResponse = RefreshResponse.FromJson(sJsonResponse);
//return
return(MCResponse.AccessToken);
}
