/// <summary>
/// Acquires and uses a user client.
/// </summary>
/// <param name="userToken">
/// The token of the user to acquire a client for.
/// </param>
/// <param name="use">
/// A function that takes a client and produces a task.
/// </param>
/// <typeparam name="T">
/// The type of value to produce.
/// </typeparam>
/// <returns>
/// A task that produces a value.
/// </returns>
public static Task <T> UseClientAsync <T>(OauthToken userToken, Func <GitHubClient, Task <T> > use)
{
var userClient = new GitHubClient(new ProductHeaderValue("UnSHACLed"));
userClient.Credentials = new Credentials(userToken.AccessToken);
return(use(userClient));
}
public ReturnResult <OauthToken> CreateAccessToken(TdMemberDataContract memberInfo)
{
if (null == memberInfo || memberInfo.UserKeyId < 1)
{
return(new ReturnResult <OauthToken>(101, null, "参数memberInfo错误"));
}
OauthToken accessToken = new OauthToken();
accessToken.ClientID = 10001; //目前默认为10001
accessToken.UserKeyId = memberInfo.UserKeyId;
accessToken.AccessToken = CreateToken();
accessToken.Expires = DateTime.Now.Epoch() + ACCESS_TOKEN_EXPIRES;
accessToken.Scope = "all"; //权限默认
accessToken.User = memberInfo;
RefreshTokenDataContract refreshToken = new RefreshTokenDataContract();
refreshToken.ClientID = accessToken.ClientID;
refreshToken.UserKeyID = accessToken.UserKeyId;
refreshToken.RefreshToken = CreateToken();
refreshToken.Expires = DateTime.Now.Epoch() + REFRESH_TOKEN_EXPIRES;
accessToken.RefreshToken = refreshToken.RefreshToken;
TokenRepository.Instance.InsertAccessToken(accessToken);
TokenRepository.Instance.InsertRefreshToken(refreshToken);
return(new ReturnResult <OauthToken>(accessToken));
}
public TokenData GetNewTokenData()
{
TokenData tokenData = null;
IDictionary <string, object> tokenParams = new Dictionary <string, object>
{
{ "client_id", _ClientId },
{ "client_secret", _ClientSecret },
{ "authorize_type", "certificate" }
};
DefaultHttpClient defaultHttpClient = new DefaultHttpClient();
string result = defaultHttpClient.Send(this.GetTokenUrl(), tokenParams, null, null);
OauthToken oAuthToken = JsonConvert.DeserializeObject <OauthToken>(result);
if (oAuthToken.Data == null)
{
tokenData = new TokenData
{
Message = result
};
return(tokenData);
}
string data = oAuthToken.Data.ToString();
tokenData = JsonConvert.DeserializeObject <TokenData>(data);
// Token添加缓存
if (cache.Contains(this._ClientId))
{
cache.Remove(this._ClientId);
}
cache.Add(this._ClientId, tokenData, tokenData.ExpiresTime.AddMinutes(-5));
return(tokenData);
}
public static async Task <string> GenerateTokenFromOAuth(GitHubClient Client, string ClientID, string ClientSecret, string Code)
{
OauthTokenRequest Request = new OauthTokenRequest(ClientID, ClientSecret, Code);
OauthToken Token = await Client.Oauth.CreateAccessToken(Request);
return(Token.AccessToken);
}
public async Task <string> GetAccessTokenAsync(string code)
{
var authRequest = new OauthTokenRequest(_settings.GitHub.ClientId, _settings.GitHub.ClientSecret, code);
OauthToken token = await _client.Oauth.CreateAccessToken(authRequest);
return(token.AccessToken);
}
public SsoToken MakeToken(string code, string evessokey, Guid userId)
{
if (string.IsNullOrEmpty(code) || string.IsNullOrEmpty(evessokey))
{
throw new EsiException("Code or EVESSOKey is null or empty");
}
string ssoData = "grant_type=authorization_code&code=" + code;
OauthToken oauthToken = GetOauthToken(evessokey, ssoData);
JwtSecurityToken decodedToken = new JwtSecurityToken(oauthToken.AccessToken);
string sub = decodedToken.Claims.First(c => c.Type == "sub").Value;
IList <string> subSplit = string.IsNullOrEmpty(sub) ? null : sub.Split(':');
if (subSplit == null)
{
throw new EsiException("Something went wrong getting the sub from the JWT token");
}
SsoToken token = new SsoToken
{
UserId = userId,
AccessToken = oauthToken.AccessToken,
ExpiresIn = DateTime.UtcNow.AddSeconds(oauthToken.ExpiresIn),
RefreshToken = oauthToken.RefreshToken,
CharacterId = Convert.ToInt32(subSplit[2]),
CharacterName = decodedToken.Claims.First(c => c.Type == "name").Value,
TokenType = (TokenType)Enum.Parse(typeof(TokenType), subSplit[0], true)
};
return(CreateScopesFlags(token, decodedToken.Claims.Where(x => x.Type == "scp").Select(x => x.Value).ToList()));
}
public async Task PostsWithCorrectBodyAndContentType()
{
var responseToken = new OauthToken(null, null, null);
var response = Substitute.For <IApiResponse <OauthToken> >();
response.Body.Returns(responseToken);
var connection = Substitute.For <IConnection>();
connection.BaseAddress.Returns(new Uri("https://api.github.com/"));
Uri calledUri = null;
FormUrlEncodedContent calledBody = null;
Uri calledHostAddress = null;
connection.Post <OauthToken>(
Arg.Do <Uri>(uri => calledUri = uri),
Arg.Do <object>(body => calledBody = body as FormUrlEncodedContent),
"application/json",
null,
Arg.Do <Uri>(uri => calledHostAddress = uri))
.Returns(_ => Task.FromResult(response));
var client = new OauthClient(connection);
var token = await client.CreateAccessToken(new OauthTokenRequest("secretid", "secretsecret", "code")
{
RedirectUri = new Uri("https://example.com/foo")
});
Assert.Same(responseToken, token);
Assert.Equal("login/oauth/access_token", calledUri.ToString());
Assert.NotNull(calledBody);
Assert.Equal("https://github.com/", calledHostAddress.ToString());
Assert.Equal(
"client_id=secretid&client_secret=secretsecret&code=code&redirect_uri=https%3A%2F%2Fexample.com%2Ffoo",
await calledBody.ReadAsStringAsync());
}
public override OauthToken.TokenData GetToken()
{
IDictionary <string, string> tokenParams = new Dictionary <string, string>
{
{ "client_id", clientId },
{ "client_secret", clientSecret },
{ "authorize_type", "authorization_code" },
{ "code", Code }
};
DefaultHttpClient defaultHttpClient = new DefaultHttpClient();
string result = defaultHttpClient.Send(this.GetTokenUrl(), tokenParams, null, null);
Console.WriteLine("t result *******************" + result);
OauthToken oAuthToken = JsonConvert.DeserializeObject <OauthToken>(result);
if (oAuthToken.Data == null)
{
TokenData tokenData = new TokenData
{
Message = result
};
return(tokenData);
}
string data = oAuthToken.Data.ToString();
TokenData toKenData = JsonConvert.DeserializeObject <TokenData>(data);
return(toKenData);
}
private OauthToken ParseReponse(string response)
{
var token = new OauthToken();
if (string.IsNullOrEmpty(response))
{
return(token);
}
// "oauth_token=qWnfRDBG47T57ud3peQeYtWHjoGSlbYtAwboQZuD&oauth_token_secret=iZJG3SKMA8BJexk4iEtQTwZmbstfR1TqoY1yKBo6&oauth_callback_confirmed=true" string
var keyValPairs = response.Split('&');
foreach (var splits in keyValPairs.Select(t => t.Split('=')))
{
switch (splits[0])
{
case "oauth_token":
token.Token = splits[1];
break;
case "oauth_token_secret":
token.Secret = splits[1];
break;
}
}
return(token);
}
/// <summary>
/// Guarda o modifica la imagen
/// </summary>
/// <param name="imagenVehiculo"></param>
/// <returns>ServerResponseImagenVehiculo</returns>
public ServerResponseImagenVehiculo SaveDocument(ImagenVehiculo imagenVehiculo)
{
ServerResponseImagenVehiculo serverResponseImagenVehiculo = null;
try
{
OauthToken oauthToken = ServerService.obtenerToken();
if (null != oauthToken)
{
var url = Constantes.SERVIDOR + VEHICULO + "savedoc";
var httpRequest = (HttpWebRequest)WebRequest.Create(url);
httpRequest.Method = "POST";
httpRequest.Headers["Authorization"] = "Bearer " + oauthToken.access_token;
httpRequest.ContentType = "application/json";
var data = JsonSerializer.Serialize <ImagenVehiculo>(imagenVehiculo);
using (var streamWriter = new StreamWriter(httpRequest.GetRequestStream()))
{
streamWriter.Write(data);
}
var httpResponse = (HttpWebResponse)httpRequest.GetResponse();
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
var result = streamReader.ReadToEnd();
serverResponseImagenVehiculo = JsonSerializer.Deserialize <ServerResponseImagenVehiculo>(result);
}
//Console.WriteLine(httpResponse.StatusCode);
}
else
{
serverResponseImagenVehiculo = new ServerResponseImagenVehiculo();
ErrorBean error = new ErrorBean();
error.code = MessageExceptions.SERVER_ERROR;
error.message = MessageExceptions.MSSG_SERVER_ERROR;
serverResponseImagenVehiculo.error = error;
}
}
catch (System.Exception)
{
serverResponseImagenVehiculo = new ServerResponseImagenVehiculo();
ErrorBean error = new ErrorBean();
error.code = MessageExceptions.SERVER_ERROR;
error.message = MessageExceptions.MSSG_SERVER_ERROR;
serverResponseImagenVehiculo.error = error;
}
return(serverResponseImagenVehiculo);
}
public JsonResult SetCount(OauthToken token, long articleId, int articleCategoryId, int type)
{
if (type != 2 && type != 3 && type != 6)
{
return(Json(new ReturnResult <bool>(1, false, "参数type错误")));
}
return(Json(articleContentService.UpdateArticleCount(articleId, articleCategoryId, token.UserKeyId, (ArticleCountEnum)type)));
}
/// <inheritdoc />
public Task <GitHubClient> NewUserAuthenticatedClient(OauthToken userToken)
{
var userClient = new GitHubClient(new ProductHeaderValue(_credentials.ApplicationUserAgent));
userClient.Credentials = new Credentials(userToken.AccessToken);
return(Task.FromResult(userClient));
}
public async Task <string> CreateAccessToken(string id, string secret, string code)
{
var request = new OauthTokenRequest(id, secret, code);
OauthToken token = await client.Oauth.CreateAccessToken(request);
return(token.AccessToken);
}
public void getTokenFromResponse_Should_Return_Token()
{
//arrange
//act
OauthToken token = AvansOauthHelper.getTokenFormUri("authentification_url=https://publicapi.avans.nl/oauth/login.php&oauth_token=oauthtoken&oauth_token_secret=oauthsecret&oauth_callback_confirmed=true");
//assert
Assert.Equal("oauthtoken", token.Token);
}
private string RequestOAuthToken(string clientId, string clientSecret, string authCode)
{
ProductHeaderValue productInfo = new ProductHeaderValue(GitHubIdentity);
GitHubClient client = new GitHubClient(productInfo);
OauthToken oauthToken =
client.Oauth.CreateAccessToken(new OauthTokenRequest(clientId, clientSecret, authCode)).GetAwaiter().GetResult();
return(oauthToken.AccessToken);
}
public JsonResult AddAttention(OauthToken token, long attentionUserKeyId)
{
var model = new ArticleAttentionDataContract();
model.UserKeyId = token.UserKeyId;
model.AttentionUserKeyId = attentionUserKeyId;
model.AttentionTime = DateTime.Now;
return(Json(articleAttentionService.AddArticleAttention(model)));
}
public JsonResult PublishComment(OauthToken token, long articleId, int articleCategoryId, string content)
{
var comment = new ArticleCommentDataContract()
{
ArticleID = articleId,
CommentContent = System.Web.HttpUtility.UrlDecode(content)
};
comment.UserKeyId = token.UserKeyId;
return(Json(articleCommentService.InsertArticleComment(comment, articleCategoryId)));
}
private static async Task <string> CreateOAuthToken(string clientId, string clientSecret, string authenticationCode)
{
var client = new GitHubClient(new ProductHeaderValue(GitHubIdentity));
OauthToken tokenInfo = await client.Oauth.CreateAccessToken(
new OauthTokenRequest(clientId, clientSecret, authenticationCode));
string token = tokenInfo.AccessToken;
return(token);
}
public JsonResult CollectArticle(OauthToken token, long articleId, int categoryId)
{
var model = new ArticleCollectDataContract()
{
UserKeyId = token.UserKeyId,
ArticleID = articleId,
CollectTime = DateTime.Now
};
return(Json(articleCollectService.AddArticleCollect(model, categoryId), JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Devuelve los datos con los filtros: matricula, plazas, capacidad y dispoiblilidad
/// </summary>
/// <param name="matricula"></param>
/// <param name="plazas"></param>
/// <param name="capacidad"></param>
/// <param name="dispoiblilidad"></param>
/// <returns>ServerResponseAlerta</returns>
public ServerResponseVehiculo GetAllFilter(string matricula, string plazas, string capacidad, string dispoiblilidad)
{
ServerResponseVehiculo serverResponseVehiculo;
try
{
OauthToken oauthToken = ServerService.obtenerToken();
if (null != oauthToken)
{
var url = Constantes.SERVIDOR + VEHICULO + "allFilter/" + matricula + "/" + plazas + "/" + capacidad + "/" + dispoiblilidad;
var httpRequest = (HttpWebRequest)WebRequest.Create(url);
httpRequest.Method = "GET";
httpRequest.Accept = "application/json";
httpRequest.Headers["Authorization"] = "Bearer " + oauthToken.access_token;
var httpResponse = (HttpWebResponse)httpRequest.GetResponse();
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
var result = streamReader.ReadToEnd();
serverResponseVehiculo = JsonSerializer.Deserialize <ServerResponseVehiculo>(result);
}
//Console.WriteLine(httpResponse.StatusCode);
}
else
{
serverResponseVehiculo = new ServerResponseVehiculo();
ErrorBean error = new ErrorBean();
error.code = MessageExceptions.SERVER_ERROR;
error.message = MessageExceptions.MSSG_SERVER_ERROR;
serverResponseVehiculo.error = error;
}
}
catch (System.Exception)
{
serverResponseVehiculo = new ServerResponseVehiculo();
ErrorBean error = new ErrorBean();
error.code = MessageExceptions.SERVER_ERROR;
error.message = MessageExceptions.MSSG_SERVER_ERROR;
serverResponseVehiculo.error = error;
}
return(serverResponseVehiculo);
}
/// <summary>
/// Devuelve todos los datos
/// </summary>
/// <returns>ServerResponseAlerta</returns>
public ServerResponseAlerta GetAll()
{
ServerResponseAlerta serverResponseAlerta;
try
{
OauthToken oauthToken = ServerService.obtenerToken();
if (null != oauthToken)
{
var url = Constantes.SERVIDOR + ALERTA + "all";
var httpRequest = (HttpWebRequest)WebRequest.Create(url);
httpRequest.Method = "GET";
httpRequest.Accept = "application/json";
httpRequest.Headers["Authorization"] = "Bearer " + oauthToken.access_token;
var httpResponse = (HttpWebResponse)httpRequest.GetResponse();
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
var result = streamReader.ReadToEnd();
serverResponseAlerta = JsonSerializer.Deserialize <ServerResponseAlerta>(result);
}
//Console.WriteLine(httpResponse.StatusCode);
}
else
{
serverResponseAlerta = new ServerResponseAlerta();
ErrorBean error = new ErrorBean();
error.code = MessageExceptions.SERVER_ERROR;
error.message = MessageExceptions.MSSG_SERVER_ERROR;
serverResponseAlerta.error = error;
}
}
catch (System.Exception)
{
serverResponseAlerta = new ServerResponseAlerta();
ErrorBean error = new ErrorBean();
error.code = MessageExceptions.SERVER_ERROR;
error.message = MessageExceptions.MSSG_SERVER_ERROR;
serverResponseAlerta.error = error;
}
return(serverResponseAlerta);
}
/// <summary>
/// Devuelve los datos con los filtros: Nombre, Email y Rol
/// </summary>
/// <param name="nombre"></param>
/// <param name="email"></param>
/// <param name="rol"></param>
/// <returns>ServerResponseUsuario</returns>
public ServerResponseUsuario GetAllFilter(string nombre, string email, string rol)
{
ServerResponseUsuario serverResponseUsuario;
try
{
OauthToken oauthToken = ServerService.obtenerToken();
if (null != oauthToken)
{
var url = Constantes.SERVIDOR + USUARIO + "allFilter/" + nombre + "/" + email + "/" + rol;
var httpRequest = (HttpWebRequest)WebRequest.Create(url);
httpRequest.Method = "GET";
httpRequest.Accept = "application/json";
httpRequest.Headers["Authorization"] = "Bearer " + oauthToken.access_token;
var httpResponse = (HttpWebResponse)httpRequest.GetResponse();
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
var result = streamReader.ReadToEnd();
serverResponseUsuario = JsonSerializer.Deserialize <ServerResponseUsuario>(result);
}
//Console.WriteLine(httpResponse.StatusCode);
}
else
{
serverResponseUsuario = new ServerResponseUsuario();
ErrorBean error = new ErrorBean();
error.code = MessageExceptions.SERVER_ERROR;
error.message = MessageExceptions.MSSG_SERVER_ERROR;
serverResponseUsuario.error = error;
}
}
catch (System.Exception)
{
serverResponseUsuario = new ServerResponseUsuario();
ErrorBean error = new ErrorBean();
error.code = MessageExceptions.SERVER_ERROR;
error.message = MessageExceptions.MSSG_SERVER_ERROR;
serverResponseUsuario.error = error;
}
return(serverResponseUsuario);
}
/// <inheritdoc />
public string SetTokenForCurrentUser(string state, OauthToken token)
{
if (state == _authState)
{
_userToken = token;
_hasUserToken = true;
return(_callback);
}
else
{
throw new Exception("OAUTH GITHUB STATE DOESNT MATCH");
}
}
public OauthToken GetAccessToken(string accessToken)
{
string sql = "SELECT AccessToken,ClientId,UserKeyId,Expires,Scope FROM access_tokens WHERE AccessToken = @accessToken";
OauthToken model = null;
using (var dr = SqlHelper.ExecuteReader(SqlHelper.GetConnSting(), CommandType.Text, sql, new SqlParameter("accessToken", accessToken)))
{
model = EntityHelper.GetEntity <OauthToken>(dr);
}
return(model);
}
public Oauth500px(string ConsumerKey, string ConsumerSecret, string CallbackUrl, string RequestUrl, string AuthorizeUrl, string AccessUrl)
{
consumerKey = ConsumerKey;
consumerSecret = ConsumerSecret;
OAuthAccessUrl = AccessUrl;
OAuthAuthorizeUrl = AuthorizeUrl;
OAuthRequestUrl = RequestUrl;
OAuthCallbackUrl = CallbackUrl;
OAuthSignatureMethod = "HMAC-SHA1";
OAuthSignatureMethodName = "HMAC_SHA1";
OAuthVersion = "1.0";
requestType = RequestType.POST;
Token = new OauthToken();
}
public bool InsertAccessToken(OauthToken accessToken)
{
string sql = @"INSERT INTO access_tokens(AccessToken,ClientId,UserKeyId,Expires,Scope)
VALUES(@AccessToken,@ClientId,@UserKeyId,@Expires,@Scope)" ;
var _parm = new SqlParameter[] {
new SqlParameter("@AccessToken", accessToken.AccessToken),
new SqlParameter("@ClientId", accessToken.ClientID),
new SqlParameter("@UserKeyId", accessToken.UserKeyId),
new SqlParameter("@Expires", accessToken.Expires),
new SqlParameter("@Scope", accessToken.Scope)
};
return(SqlHelper.ExecuteNonQuery(SqlHelper.GetConnSting(), CommandType.Text, sql, _parm) > 0);
}
public void Add(string service, OauthToken token)
{
Delete(service);
_context.Add(new AccessToken()
{
Service = service,
Token = _encryptor.Encrypt(token.Token),
Secret = _encryptor.Encrypt(token.Secret),
Created = DateTime.Now,
Expires = token.Expires,
SessionHandle = _encryptor.Encrypt(token.SessionHandle)
});
_context.SaveChanges();
}
public async Task ObtainNewToken()
{
if (client.Credentials.AuthenticationType == AuthenticationType.Basic)
{
throw new InvalidOperationException("Cannot obtain new token for non-oauth session!");
}
var request = new OauthTokenRequest(clientId, clientSecret, Code);
if (server.isCancelled)
{
return;
}
Token = await client.Oauth.CreateAccessToken(request);
session["OAuthToken"] = Token.AccessToken;
client.Credentials = new Credentials(Token.AccessToken);
}
public void OnAuthorization(AuthorizationContext filterContext)
{
if (filterContext == null)
{
filterContext.Result = new CustomJsonResult()
{
Data = new ReturnResult(-102, "程序异常,filterContext为null!")
};
}
var tokenString = filterContext.HttpContext.Request["accessToken"];
var clientId = Convert.ToInt32(filterContext.HttpContext.Request["clientId"]);
accessToken = tokenService.GetAccessToken(tokenString);
if (null == accessToken)
{
filterContext.Result = new CustomJsonResult()
{
Data = new ReturnResult(11, "参数assessToken错误")
};
return;
}
if (accessToken.ClientID != clientId)
{
filterContext.Result = new CustomJsonResult()
{
Data = new ReturnResult(12, "参数clientId错误")
};
}
if (accessToken.Expires < DateTime.Now.Epoch())
{
filterContext.Result = new CustomJsonResult()
{
Data = new ReturnResult(13, "assessToken已过期,请刷新或者重新登录")
};
}
accessToken.ClientIp = filterContext.HttpContext.Request.GetIp();
accessToken.User = memberService.GetMember(accessToken.UserKeyId);
if (null == accessToken.User)
{
filterContext.Result = new CustomJsonResult()
{
Data = new ReturnResult(14, "用户已失效,请重新登录")
};
}
}
public async Task <OauthToken> GetAccessToken(OauthToken token)
{
AuthorizationParameters = new Dictionary <string, string>()
{
{ OauthParameter.OauthConsumerKey, Constants.ConsumerKey },
{ OauthParameter.OauthNonce, GetNonce() },
{ OauthParameter.OauthSignatureMethod, OAuthSignatureMethod },
{ OauthParameter.OauthTimestamp, GetTimeStamp() },
{ OauthParameter.OauthToken, token.Token },
{ OauthParameter.OauthVerifier, token.Verifier },
{ OauthParameter.OauthVersion, OAuthVersion }
};
var response = await Sign(AccessUrl, Constants.ConsumerSecret, token.Secret, "POST", "").PostRequest(AccessUrl);
return(ParseReponse(response));
}
