private static void Main(string[] args)
{
try
{
string url = @"http://localhost:53879/";
string timestamp = UnixEpochHelper.GetCurrentUnixTimestamp().TotalMilliseconds.ToString();
string nonce = new Random().NextDouble().ToString();
string signature = SignatureString("XXHHAREJDDF", timestamp, nonce);
string appended = string.Format("&signature={0}×tamp={1}&nonce={2}&appid={3}", signature, timestamp, nonce, "aabbcc");
string queryUrl = url + "api/Auth?userId=test" + appended;
TokenResult _tokenResult = WebRequest.HttpGet <TokenResult>(queryUrl, SerializationType.Json);
Console.WriteLine(_tokenResult.Access_token);
queryUrl = url + "api/Product/1?token=" + _tokenResult.Access_token;
string jsonText = WebRequest.HttpGet(queryUrl);
JObject jsonObj = JObject.Parse(jsonText);
string aa = jsonObj["Data"].ToString();
Console.WriteLine(jsonText);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
Console.ReadLine();
}
}
private static void Main(string[] args)
{
try
{
CreateAppConfig();
var apiServiceUrl = "http://localhost:24003/";
var timestamp = UnixEpochHelper.GetCurrentUnixTimestamp().TotalMilliseconds
.ToString(CultureInfo.InvariantCulture);
var nonce = new Random().NextDouble().ToString(CultureInfo.InvariantCulture);
var signature = SignatureHelper.Create(_appSecret, timestamp, nonce);
var appended =
$"&signature={signature}×tamp={timestamp}&nonce={nonce}&appid={_appId}";
var queryUrl = apiServiceUrl +
"api/Account/GetToken?userId=2c96ff542072420bc8d33bdd73bb9488&passWord=0000" + appended;
var responeText = SimulateWebRequest.Post(queryUrl, null);
Console.WriteLine(responeText);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
Console.ReadLine();
}
}
/// <summary>
/// 生成签名字符串
/// </summary>
/// <param name="appSecret">签名密钥</param>
/// <returns>WebApi签名</returns>
public static string Create(Guid appSecret)
{
string timestamp = UnixEpochHelper.GetCurrentUnixTimestamp().TotalMilliseconds.ToString(CultureInfo.InvariantCulture);
string nonce = new Random().NextDouble().ToString(CultureInfo.InvariantCulture);
return(Create(appSecret, timestamp, nonce));
}
/// <summary>
/// 检查请求签名合法性
/// </summary>
/// <param name="signature">加密签名字符串</param>
/// <param name="timestamp">时间戳</param>
/// <param name="nonce">随机数</param>
/// <param name="appConfig">应用接入配置信息</param>
/// <returns>CheckResult</returns>
public CheckResult CheckRequestSignature(string signature, string timestamp, string nonce, AppConfig appConfig)
{
ValidateOperator.Begin()
.NotNullOrEmpty(signature, "加密签名字符串")
.NotNullOrEmpty(timestamp, "时间戳")
.NotNullOrEmpty(nonce, "随机数")
.NotNull(appConfig, "AppConfig");
var appSecret = appConfig.AppSecret;
var signatureExpired = appConfig.SignatureExpiredMinutes;
string[] data = { appSecret, timestamp, nonce };
Array.Sort(data);
var signatureText = string.Join("", data);
signatureText = Md5Encryptor.Encrypt(signatureText);
if (!signature.CompareIgnoreCase(signatureText) && CheckHelper.IsNumber(timestamp))
{
return(CheckResult.Success());
}
var timestampMillis =
UnixEpochHelper.DateTimeFromUnixTimestampMillis(timestamp.ToDoubleOrDefault());
var minutes = DateTime.UtcNow.Subtract(timestampMillis).TotalMinutes;
return(minutes > signatureExpired?CheckResult.Fail("签名时间戳失效") : CheckResult.Success());
}
public OperatedResult <string> CheckIdentityToken(string token, AppConfig appConfig)
{
ValidateOperator.Begin()
.NotNullOrEmpty(token, "Token")
.NotNull(appConfig, "AppConfig");
try
{
var tokenText = ParseTokens(token, appConfig.SharedKey);
if (string.IsNullOrEmpty(tokenText))
{
return(OperatedResult <string> .Fail("用户令牌Token为空"));
}
dynamic root = JObject.Parse(tokenText);
string userid = root.iss;
var iat = root.iat;
var validTokenExpired =
new TimeSpan((int)(UnixEpochHelper.GetCurrentUnixTimestamp().TotalSeconds - iat))
.TotalDays > appConfig.TokenExpiredDay;
return(validTokenExpired
? OperatedResult <string> .Fail($"用户ID{userid}令牌失效")
: OperatedResult <string> .Success(userid));
}
catch (FormatException)
{
return(OperatedResult <string> .Fail("用户令牌非法"));
}
catch (SignatureVerificationException)
{
return(OperatedResult <string> .Fail("用户令牌非法"));
}
}
/// <summary>
/// 检查用户令牌
/// </summary>
/// <param name="token">用户令牌</param>
/// <param name="sharedKey">用于加密解密签名以及用户令牌的Key</param>
/// <param name="tokenExpiredDays">用户令牌过期天数</param>
/// <returns>
/// 检查结果
/// </returns>
public Tuple <bool, string> ValidateToken(string token, string sharedKey, int tokenExpiredDays)
{
//返回的结果对象
Tuple <bool, string> _checkeResult = new Tuple <bool, string>(false, "数据完整性检查不通过");
if (!string.IsNullOrEmpty(token))
{
try
{
string _decodedJwt = JsonWebToken.Decode(token, sharedKey);
if (!string.IsNullOrEmpty(_decodedJwt))
{
dynamic _root = JObject.Parse(_decodedJwt);
string _userid = _root.userId;
double _jwtcreated = (double)_root.claim;
bool _validTokenExpired = (new TimeSpan((int)(UnixEpochHelper.GetCurrentUnixTimestamp().TotalSeconds - _jwtcreated)).TotalDays) > tokenExpiredDays;
if (_validTokenExpired)
{
_checkeResult = new Tuple <bool, string>(false, "用户令牌失效.");
}
_checkeResult = new Tuple <bool, string>(true, _userid);
}
}
catch (SignatureVerificationException)
{
_checkeResult = new Tuple <bool, string>(false, "用户令牌非法.");
}
}
return(_checkeResult);
}
private Tuple <bool, string> ValidateSignature(string signature, string timestamp, string nonce, string appSecret, int timspanExpiredMinutes)
{
Tuple <bool, string> _checkeResult = new Tuple <bool, string>(false, "数据完整性检查不通过");
string[] _arrayParamter = { appSecret, timestamp, nonce };
Array.Sort(_arrayParamter);
string _signatureString = string.Join("", _arrayParamter);
_signatureString = MD5Encryptor.Encrypt(_signatureString);
if (signature.CompareIgnoreCase(signature) && CheckHelper.IsNumber(timestamp))
{
DateTime _timestampMillis = UnixEpochHelper.DateTimeFromUnixTimestampMillis(timestamp.ToDoubleOrDefault(0f));
double _minutes = DateTime.UtcNow.Subtract(_timestampMillis).TotalMinutes;
if (_minutes > timspanExpiredMinutes)
{
_checkeResult = new Tuple <bool, string>(false, "签名时间戳失效");
}
else
{
_checkeResult = new Tuple <bool, string>(true, string.Empty);
}
}
return(_checkeResult);
}
internal QueryResultsList(long startTimeUtc, long endTimeUtc, long timeResolutionInMilliseconds, IReadOnlyList <QueryResult> results)
{
this.StartTimeUtc = UnixEpochHelper.FromMillis(startTimeUtc);
this.EndTimeUtc = UnixEpochHelper.FromMillis(endTimeUtc);
this.TimeResolutionInMilliseconds = timeResolutionInMilliseconds;
this.Results = results;
}
public void DateTimeFromUnixTimestampMillisTest()
{
DateTime _actual = UnixEpochHelper.DateTimeFromUnixTimestampMillis(1422949956408);
DateTime _expected = new DateTime(2015, 02, 03, 7, 52, 36);
Assert.AreEqual(_expected.ToShortDateString(), _actual.ToShortDateString());
Assert.AreEqual(_expected.ToShortTimeString(), _actual.ToShortTimeString());
Assert.AreNotEqual(_expected, _actual);
}
private TokenInfo BuilderTokenInfo(UserInfo userInfo, AppInfo appInfo)
{
Dictionary <string, object> _payload = new Dictionary <string, object>()
{
{ "iss", userInfo.UserId },
{ "iat", UnixEpochHelper.GetCurrentUnixTimestamp().TotalSeconds }
};//负载数据
TokenInfo _tokenData = new TokenInfo
{
Access_token = JwtHelper.CreateTokens(appInfo.SharedKey, _payload),
Expires_in = appInfo.TokenExpiredDay * 24 * 3600
};
return(_tokenData);
}
/// <summary>
/// Gets the dimension values for dimensionName satifying the dimensionFilters and
/// </summary>
/// <param name="metricId">Metric id.</param>
/// <param name="filters">The dimension filters representing the pre-aggregate dimensions. Create an emtpy include filter for dimension with no filter values. Requested dimension should also be part of this and should be empty.</param>
/// <param name="dimensionName">Name of the dimension for which values are requested.</param>
/// <param name="startTimeUtc">Start time for evaluating dimension values.</param>
/// <param name="endTimeUtc">End time for evaluating dimension values.</param>
/// <returns>Dimension values for dimensionName.</returns>
public async Task <IEnumerable <string> > GetDimensionValuesAsync(MetricIdentifier metricId, List <Tuple <string, IEnumerable <string> > > filters, string dimensionName, DateTime startTimeUtc, DateTime endTimeUtc)
{
filters.Sort((item1, item2) => string.Compare(item1.Item1, item2.Item1, StringComparison.OrdinalIgnoreCase));
var baseUrl = string.Format(
"{0}/api/v2/hint/tenant/{1}/component/{2}/event/{3}/startTimeUtcMillis/{4}/endTimeUtcMillis/{5}",
Endpoint,
EscapeTwice(metricId.MonitoringAccount),
EscapeTwice(metricId.MetricNamespace),
EscapeTwice(metricId.MetricName),
UnixEpochHelper.GetMillis(startTimeUtc),
UnixEpochHelper.GetMillis(endTimeUtc));
var urlBuilder = new StringBuilder(baseUrl);
foreach (var filter in filters)
{
if (filter.Item1.Equals(dimensionName, StringComparison.OrdinalIgnoreCase) && filter.Item2.Count() > 0)
{
throw new ArgumentException("Dimension filters cannot contain requested dimension with filter values");
}
if (filter.Item2.Count() > 0)
{
foreach (var val in filter.Item2)
{
urlBuilder.Append("/").Append(EscapeTwice(filter.Item1)).Append("/").Append(EscapeTwice(val));
}
}
else
{
// Put Empty value.
urlBuilder.Append("/").Append(EscapeTwice(filter.Item1)).Append("/").Append(EscapeTwice("{{*}}"));
}
}
urlBuilder.Append("/").Append(EscapeTwice(dimensionName)).Append("/value");
var response = await GetResponse(
new Uri(urlBuilder.ToString()),
HttpMethod.Get,
HttpClient,
null,
ClientId).ConfigureAwait(false);
return(JsonConvert.DeserializeObject <List <string> >(response.Item1));
}
/// <summary>
/// 创建合法用户获取访问令牌接口数据
/// </summary>
/// <param name="identityUser">IdentityUser</param>
/// <param name="appConfig">AppConfig</param>
/// <returns>IdentityToken</returns>
public OperatedResult <IdentityToken> CreateIdentityToken(IdentityUser identityUser, AppConfig appConfig)
{
ValidateOperator.Begin()
.NotNull(identityUser, "IdentityUser")
.NotNull(appConfig, "AppConfig");
var payload = new Dictionary <string, object>
{
{ "iss", identityUser.UserId },
{ "iat", UnixEpochHelper.GetCurrentUnixTimestamp().TotalSeconds }
};
var identityToken = new IdentityToken
{
AccessToken = CreateIdentityToken(appConfig.SharedKey, payload),
ExpiresIn = appConfig.TokenExpiredDay * 24 * 3600
};
return(OperatedResult <IdentityToken> .Success(identityToken));
}
/// <summary>
/// 验证Token令牌是否合法
/// </summary>
/// <param name="token">令牌</param>
/// <param name="appid">应用ID</param>
/// <returns>CheckResult</returns>
public OperatedResult <string> ValidateToken(string token, Guid appid)
{
CheckResult _checkedParamter = CheckedValidateTokenParamter(token, appid);
if (!_checkedParamter.State)
{
return(OperatedResult <string> .Fail(_checkedParamter.Message));
}
CheckResult <AppInfo> _checkedAppChannel = CheckedAppInfo(appid);
if (!_checkedAppChannel.State)
{
return(OperatedResult <string> .Fail(_checkedAppChannel.Message));
}
try
{
AppInfo _appInfo = _checkedAppChannel.Data;
string _tokenString = JwtHelper.ParseTokens(token, _appInfo.SharedKey);
if (string.IsNullOrEmpty(_tokenString))
{
return(OperatedResult <string> .Fail("用户令牌Token为空"));
}
dynamic _root = JObject.Parse(_tokenString);
string _userid = _root.iss;
double _jwtcreated = (double)_root.iat;
bool _validTokenExpired =
(new TimeSpan((int)(UnixEpochHelper.GetCurrentUnixTimestamp().TotalSeconds - _jwtcreated))
.TotalDays) > _appInfo.TokenExpiredDay;
return(_validTokenExpired == true ? OperatedResult <string> .Fail($"用户ID{_userid}令牌失效") : OperatedResult <string> .Success(_userid));
}
catch (FormatException)
{
return(OperatedResult <string> .Fail("用户令牌非法"));
}
catch (SignatureVerificationException)
{
return(OperatedResult <string> .Fail("用户令牌非法"));
}
}
/// <summary>
/// 验证WebApi签名
/// </summary>
/// <param name="signature">签名</param>
/// <param name="timestamp">时间戳</param>
/// <param name="nonce">随机数</param>
/// <param name="appSecret">签名加密键</param>
/// <param name="signatureExpiredMinutes">签名过期分钟</param>
/// <returns>CheckResult</returns>
internal static CheckResult Validate(string signature, string timestamp, string nonce, string appSecret, int signatureExpiredMinutes)
{
string[] _arrayParamter = { appSecret, timestamp, nonce };
Array.Sort(_arrayParamter);
string _signatureString = string.Join("", _arrayParamter);
_signatureString = MD5Encryptor.Encrypt(_signatureString);
if (signature.CompareIgnoreCase(signature) && CheckHelper.IsNumber(timestamp))
{
DateTime _timestampMillis =
UnixEpochHelper.DateTimeFromUnixTimestampMillis(timestamp.ToDoubleOrDefault(0f));
double _minutes = DateTime.UtcNow.Subtract(_timestampMillis).TotalMinutes;
if (_minutes > signatureExpiredMinutes)
{
return(CheckResult.Fail("签名时间戳失效"));
}
}
return(CheckResult.Success());
}
/// <summary>
/// 获取用户令牌
/// </summary>
/// <param name="userId">用户Id</param>
/// <param name="signature">加密签名字符串</param>
/// <param name="timestamp">时间戳</param>
/// <param name="nonce">随机数</param>
/// <param name="appSecret">应用接入ID对应Key</param>
/// <param name="sharedKey">用于加密解密签名以及用户令牌的Key</param>
/// <param name="timspanExpiredMinutes">时间戳过期时间【分钟】</param>
/// <returns>
/// 用户令牌信息
/// </returns>
public TokenResult GetAccessToken(string userId, string signature, string timestamp, string nonce, string appSecret, string sharedKey, int timspanExpiredMinutes)
{
TokenResult _result = new TokenResult();
Tuple <bool, string> _checkedResult = ValidateSignature(signature, timestamp, nonce, appSecret, timspanExpiredMinutes);
if (_checkedResult.Item1)
{
Dictionary <string, object> _payload = new Dictionary <string, object>()
{
{ "userId", userId },
{ "claim", UnixEpochHelper.GetCurrentUnixTimestamp().TotalSeconds }
};
string _token = JsonWebToken.Encode(_payload, sharedKey, JwtHashAlgorithm.HS256);
_result.Access_token = _token;
_result.Expires_in = timspanExpiredMinutes * 24 * 3600;
}
else
{
throw new FrameworkException(_checkedResult.Item2);
}
return(_result);
}
public async Task <TimeSeries <MonitorIdentifier, bool?> > GetMonitorHistoryAsync(
DateTime startTimeUtc,
DateTime endTimeUtc,
TimeSeriesDefinition <MonitorIdentifier> monitorInstanceDefinition)
{
if (monitorInstanceDefinition == null)
{
throw new ArgumentNullException("monitorInstanceDefinition");
}
if (startTimeUtc > endTimeUtc)
{
throw new ArgumentException(string.Format("startTimeUtc [{0}] must be <= endTimeUtc [{1}]", startTimeUtc, endTimeUtc));
}
startTimeUtc = new DateTime(startTimeUtc.Ticks / TimeSpan.TicksPerMinute * TimeSpan.TicksPerMinute);
endTimeUtc = new DateTime(endTimeUtc.Ticks / TimeSpan.TicksPerMinute * TimeSpan.TicksPerMinute);
string dimensionsFlattened = null;
if (monitorInstanceDefinition.DimensionCombination != null)
{
dimensionsFlattened = string.Join(
"/",
monitorInstanceDefinition.DimensionCombination.Select(
d => string.Join("/", SpecialCharsHelper.EscapeTwice(d.Key), SpecialCharsHelper.EscapeTwice(d.Value))));
}
string operation = $"{this.HealthRelativeUrl}/history";
string url = string.Format(
"{0}{1}/monitoringAccount/{2}/metricNamespace/{3}/metric/{4}/monitorId/{5}/from/{6}/to/{7}{8}",
this.connectionInfo.GetEndpoint(monitorInstanceDefinition.Id.MetricIdentifier.MonitoringAccount),
operation,
monitorInstanceDefinition.Id.MetricIdentifier.MonitoringAccount,
SpecialCharsHelper.EscapeTwice(monitorInstanceDefinition.Id.MetricIdentifier.MetricNamespace),
SpecialCharsHelper.EscapeTwice(monitorInstanceDefinition.Id.MetricIdentifier.MetricName),
SpecialCharsHelper.EscapeTwice(monitorInstanceDefinition.Id.MonitorId),
UnixEpochHelper.GetMillis(startTimeUtc),
UnixEpochHelper.GetMillis(endTimeUtc),
dimensionsFlattened != null ? "/" + dimensionsFlattened : string.Empty);
var response = await this.GetResponseAsStringDelegate(
new Uri(url),
HttpMethod.Get,
this.httpClient,
monitorInstanceDefinition.Id.MetricIdentifier.MonitoringAccount,
operation,
null,
string.Empty,
null,
null,
MetricQueryResponseDeserializer.CurrentVersion,
NumAttempts).ConfigureAwait(false);
var values = JsonConvert.DeserializeObject <List <bool?> >(response.Item1);
return(new TimeSeries <MonitorIdentifier, bool?>(startTimeUtc, endTimeUtc, SerializationConstants.DefaultSeriesResolutionInMinutes, monitorInstanceDefinition, new List <List <bool?> > {
values
}, TimeSeriesErrorCode.Success));
}
