saherelm/xSaherelmWorkspace
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
671372bfe80ff0b2a88996ebaecdc791ea0e80d9
xSaherelmWorkspace/Documents/GeneratedContext/xDashboard-xIdentityService-20260807_230353.txt
T
saherelm 42173745de last ...
2026-08-08 00:31:18 +03:30

8769 lines
279 KiB
Plaintext
Raw Blame History

### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Configuration\XIdentityServiceConfiguration.cs
using xIdentityService.Constants;
namespace xIdentityService.Configuration {
public partial class XIdentityServiceConfiguration {
public string Authority { get; set; }
public string ApiName { get; set; }
public string ApiSecret { get; set; }
public string ClientId { get; set; }
public string ClientSecret { get; set; }
public string XPoweredValue { get; set; }
public XTokenType TokenType { get; set; }
public string XRevisionSecretKey { get; set; }
public int DefaultClientTimeout { get; set; } = 360;
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Configuration\XProxyConfiguration.cs
using System.Collections.Generic;
using xModels.Base;
namespace xIdentityService.Configuration {
/// <summary>
/// XProxy Middleware Configuration ...
/// </summary>
public class XProxyConfiguration {
/// <summary>
/// Proxy Host Address for Clients Which Use XProxy Server ...
/// </summary>
/// <value></value>
public string Host { get; set; }
/// <summary>
/// if EnableXPoweredByAthorization property setted to true, this property determines
/// the header must be this value ...
/// </summary>
/// <value></value>
public string XPoweredValue { get; set; }
/// <summary>
/// Determines Proxy Http Handler Check SSL or not ...
/// </summary>
/// <value></value>
public bool DisableSSLCheck { get; set; }
/// <summary>
/// Determines Http Client Handler Allow Auto Redirect or not ...
/// </summary>
/// <value></value>
public bool AllowAutoRedirect { get; set; }
/// <summary>
/// Determines Proxy Server Log Received Requests or not ...
/// </summary>
/// <value></value>
public bool EnableLogging { get; set; }
/// <summary>
/// DefineRoutes for Handling ...
/// </summary>
/// <value></value>
public HashSet<XProxyRouteDescriptor> Routes { get; set; }
}
/// <summary>
/// Describe a Proxy Route ...
/// </summary>
public class XProxyRouteDescriptor : XBaseDescriptor {
/// <summary>
/// Determines which route can handled for Proxyfing ...
/// </summary>
/// <value></value>
public string Route { get; set; }
/// <summary>
/// Determines Proxy Server Handle Athorization or not ...
/// </summary>
/// <value></value>
public bool EnableAuthorization { get; set; }
/// <summary>
/// Determines Which Scopes allowed to this route if authorizations enabled ...
/// </summary>
/// <value></value>
public HashSet<string> AllowedScopes { get; set; }
/// <summary>
/// Determines Which Roles allowed to this route if authorizations enabled ...
/// </summary>
/// <value></value>
public HashSet<string> AllowedRoles { get; set; }
/// <summary>
/// Determines XProxy Can Check XPowered By Authorization or not ...
/// </summary>
/// <value></value>
public bool EnableXPoweredByAthorization { get; set; }
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Constants\ConfigurationNodeNames.cs
namespace xIdentityService.Constants {
public partial struct ConfigurationNodeNames {
public const string XPROXY_CONFIGURATION_NODE_NAME = "ProxyConfiguration";
public const string IDENTITY_SERVICE_NODE_NAME = "IdentityServiceConfiguration";
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Constants\XApiAccountEndpoint.cs
using xExceptions.Attributes;
namespace xIdentityService.Constants
{
public enum XApiAccountEndpoint
{
//
#region Authentication ...
[StringValue("Account/DiscoveryDocument")]
DiscoveryDocument,
[StringValue("Account/RequestScopeAccessToken")]
RequestScopeAccessToken,
[StringValue("Account/Authenticate")]
Authenticate,
[StringValue("Account/Login")]
Login,
[StringValue("Account/RefreshTokens")]
RefreshTokens,
[StringValue("Account/ChangePassword")]
ChangePassword,
[StringValue("Account/ResetPassword")]
ResetPassword,
#endregion
//
#region Proile ...
[StringValue("Account/Profile/{ids}/GetNames")]
GetNames,
[StringValue("Account/Profile/GetNameIds")]
GetNameIds,
[StringValue("Account/Profile/{userSelectByParam}")]
GetProfile,
[StringValue("Account/Profile/Query")]
QueryProfiles,
[StringValue("Account/Profile/Avatars/Query/{userSelectByParam}")]
QueryAvatars,
[StringValue("Account/Profile/Update/{userSelectByParam}")]
UpdateProfile,
[StringValue("Account/Profile/{userSelectByParam}")]
FullUpdateProfile,
[StringValue("Account/Profile/Avatar")]
AddAvatar,
[StringValue("Account/Profile/Avatars")]
AddAvatars,
[StringValue("Account/Profile/Avatars/{ids}")]
RemoveAvatars,
[StringValue("Account/Profile/Avatars/{id}/Set")]
SetAvatar,
#endregion
//
#region Search ...
[StringValue("Account/OpenToSearch/Query")]
QueryOpenToSearchProfiles,
#endregion
//
#region Registration ...
[StringValue("Account/CanRegisterUserName/{userName}")]
CanRegisterUserName,
[StringValue("Account/CanRegisterMobileNumber/{mobileNumber}")]
CanRegisterMobileNumber,
[StringValue("Account/CanRegisterEmail/{email}")]
CanRegisterEmail,
[StringValue("Account/IsConfirmedEmail")]
IsConfirmedEmail,
[StringValue("Account/IsConfirmedMobile")]
IsConfirmedMobile,
[StringValue("Account/ConfirmRegistration")]
ConfirmRegistration,
[StringValue("Account/ConfirmMobileNumber")]
ConfirmMobileNumber,
[StringValue("Account/ConfirmEmailAddress")]
ConfirmEmailAddress,
[StringValue("Account/RequestConfirmMobile")]
RequestConfirmMobile,
[StringValue("Account/RequestConfirmEmail")]
RequestConfirmEmail,
[StringValue("Account/RequestResetPassword")]
RequestResetPassword,
[StringValue("Account/RequestConfirmRegistration")]
RequestConfirmRegistration,
[StringValue("Account/InviteUser")]
InviteUser,
[StringValue("Account/RequestRegistration")]
RequestRegistration,
[StringValue("Account/AddAccountInfo")]
AddAccountInfo,
[StringValue("Account/AttachProfileImage")]
AttachProfileImage,
[StringValue("Account/FinishRegistration")]
FinishRegistration,
#endregion
//
#region Friendship ...
[StringValue("Account/Friendship/{destUser}/Follow")]
Follow,
[StringValue("Account/Friendship/{destUser}/Cancel")]
Cancel,
[StringValue("Account/Friendship/{destUser}/UnFollowFollower")]
UnFollowFollower,
[StringValue("Account/Friendship/{destUser}/UnFollowFollowing")]
UnFollowFollowing,
[StringValue("Account/Friendship/{destUser}/Block")]
Block,
[StringValue("Account/Friendship/{destUser}/UnBlock")]
UnBlock,
[StringValue("Account/Friendship/{destUser}/AcceptRequest")]
AcceptRequest,
[StringValue("Account/Friendship/{destUser}/RejectRequest")]
RejectRequest,
[StringValue("Account/Friendship/{destUser}/FriendshipInfo")]
FriendshipInfo,
[StringValue("Account/Friendship/{destUser}/IsFollower")]
IsFollower,
[StringValue("Account/Friendship/{destUser}/FollowerState")]
FollowerState,
[StringValue("Account/Friendship/{destUser}/Follower")]
Follower,
[StringValue("Account/Friendship/Followers")]
Followers,
[StringValue("Account/Friendship/AllFollowers")]
AllFollowers,
[StringValue("Account/Friendship/FollowersList")]
FollowersList,
[StringValue("Account/Friendship/QueryFollowers")]
QueryFollowers,
[StringValue("Account/Friendship/{destUser}/IsFollowing")]
IsFollowing,
[StringValue("Account/Friendship/{destUser}/FollowingState")]
FollowingState,
[StringValue("Account/Friendship/{destUser}/Following")]
Following,
[StringValue("Account/Friendship/Followings")]
Followings,
[StringValue("Account/Friendship/AllFollowings")]
AllFollowings,
[StringValue("Account/Friendship/FollowingsList")]
FollowingsList,
[StringValue("Account/Friendship/QueryFollowings")]
QueryFollowings,
#endregion
//
#region Admin ...
[StringValue("Account/Ban")]
Ban,
[StringValue("Account/UnBan")]
UnBan,
[StringValue("Account/IsBanned/{userSelectByParam}")]
IsBanned,
#endregion
//
#region Open Actions ...
[StringValue("Account/Open")]
Open,
#endregion
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Constants\XAuthenticationScheme.cs
using xExceptions.Attributes;
namespace xIdentityService.Constants {
public enum XAuthenticationScheme {
[StringValue ("token")]
XToken,
[StringValue ("introspection")]
XIntrospection,
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Constants\XHeader.cs
using xExceptions.Attributes;
namespace xIdentityService.Constants
{
/// <summary>
/// All Available Headers ...
/// </summary>
public enum XHeader
{
/// <summary>
/// Hub Connection ID Header Keys ...
/// </summary>
[StringValue("requestID")]
ConnectionId,
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Constants\XParam.cs
using xExceptions.Attributes;
namespace xIdentityService.Constants {
public enum XParam {
[StringValue ("Content-Type")]
XContentType,
[StringValue ("{boundary}")]
XBoundary,
[StringValue ("{userSelectByParam}")]
XUserSelectByParam,
[StringValue ("{destUser}")]
XDestUser,
[StringValue ("{id}")]
XId,
[StringValue ("{ids}")]
XIds,
[StringValue ("Origin")]
XOrigin,
[StringValue ("{userName}")]
XUserName,
[StringValue ("{mobileNumber}")]
XMobileNumber,
[StringValue ("{email}")]
XEmail,
[StringValue ("role")]
XRole,
[StringValue ("forceRole")]
XForceRole,
[StringValue ("IsRefreshed")]
XIsRefreshed,
[StringValue ("file")]
XFile,
[StringValue ("files")]
XFiles,
[StringValue ("actionToken")]
XActionToken,
[StringValue ("request")]
XRequest,
[StringValue ("scope")]
XScope,
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Constants\XProxyConstants.cs
namespace xIdentityService.Constants {
public struct XProxyConstants {
public const string XPROXY_HTTP_CLIENT = "XProxyHttpClient";
public const string XPROXY_FORWARD_HEADER = "xForwardHeader";
public const string XPROXY_ACCEPTED_HEADERS = "xAcceptedHeaders";
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Constants\XResponseContentTypes.cs
namespace xIdentityService.Constants {
public struct XResponseContentTypes {
public const string HTML = "text/html";
public const string JSON = "application/json";
public const string JavaScript = "text/javascript";
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Constants\XTokenType.cs
namespace xIdentityService.Constants {
public enum XTokenType {
//
// Summary:
// Self-contained Json Web Token
Jwt,
//
// Summary:
// Reference token
Reference
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Controllers\XBaseIdentityApiController.cs
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using xCommons.Attributes;
using xCommons.Configurations;
using xCommons.Providers;
using xIdentityService.Interfaces;
namespace xIdentityService.Controllers
{
/// <summary>
/// Base Identity Api Controller
/// </summary>
[ApiController]
[RequireXPowered(true)]
[Route("api/[controller]")]
[Produces("application/json")]
public abstract class XBaseIdentityApiController : XBaseIdentityController
{
protected XBaseIdentityApiController(
ILogger logger,
XAppConfiguration appConfiguration,
IXIdentityProvider identityProvider,
XValidationProvider validationProvider
) : base(
logger,
appConfiguration,
identityProvider,
validationProvider
)
{ }
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Controllers\XBaseIdentityApiV1Controller.cs
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using xCommons.Attributes;
using xCommons.Configurations;
using xCommons.Providers;
using xIdentityService.Interfaces;
namespace xIdentityService.Controllers
{
/// <summary>
/// Base Identity Api V1 Controller
/// </summary>
[ApiController]
[ApiVersion("1.0")]
[RequireXPowered(true)]
[Route("api/v{version:apiVersion}/[controller]")]
public abstract class XBaseIdentityApiV1Controller : XBaseIdentityApiController
{
protected XBaseIdentityApiV1Controller(
ILogger logger,
XAppConfiguration appConfiguration,
IXIdentityProvider identityProvider,
XValidationProvider validationProvider
) : base(
logger,
appConfiguration,
identityProvider,
validationProvider
)
{ }
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Controllers\XBaseIdentityController.cs
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using xCommons.Configurations;
using xCommons.Constants;
using xCommons.Controllers;
using xCommons.Extensions;
using xCommons.Providers;
using xExceptions.Constants;
using xIdentityModels.Constants;
using xIdentityModels.Models;
using xIdentityService.Constants;
using xIdentityService.Interfaces;
namespace xIdentityService.Controllers
{
public abstract class XBaseIdentityController : XBaseController
{
//
public IXIdentityProvider IdentityProvider { get; }
protected XBaseIdentityController(
ILogger logger,
XAppConfiguration appConfiguration,
IXIdentityProvider identityProvider,
XValidationProvider validationProvider
) : base(
logger,
appConfiguration,
validationProvider
)
{
IdentityProvider = identityProvider;
}
//
#region NonActions ...
/// <summary>
/// Retrieve Connection ID for Hubs ...
/// </summary>
/// <returns></returns>
[NonAction]
public string GetConnectionId()
{
//
var result = "";
//
var headerKey = XHeader.ConnectionId.GetStringValue();
//
// Check if Connection ID is Provided ...
if (Request.Headers.ContainsKey(headerKey))
{
result = Request.Headers[headerKey];
}
//
return result;
}
/// <summary>
/// Retrieve User Identifier Base on XActionRequest
/// </summary>
/// <param name="model"></param>
/// <param name="forceNotNull"></param>
/// <param name="excludes"></param>
/// <returns></returns>
[NonAction]
public string GetUserSelectByParam(
XActionRequest model,
bool forceNotNull = true,
ICollection<XUserSelectBy> excludes = null
)
{
//
// Validate Args ...
ValidationProvider.NotNull(model);
//
var result = IdentityProvider.GetUserSelectByParam(
model,
forceNotNull,
excludes
);
//
return result;
}
/// <summary>
/// Retrieve Access Token
/// </summary>
/// <returns></returns>
[NonAction]
public async Task<string> GetAccessToken()
{
//
var accessToken = Request.Headers[XAuthorization.Header].ToString();
if (accessToken.IsNullOrEmpty())
{
//
accessToken = await HttpContext
.GetTokenAsync(XAuthorization.AccessToken);
}
//
if (accessToken
.ToNormalString()
.Contains(XAuthorization.TokenIdentifier
.ToNormalString()))
{
//
accessToken = accessToken
.Remove(0, XAuthorization.TokenIdentifier.Length);
}
//
return accessToken;
}
/// <summary>
/// Retrieve Refresh Token
/// </summary>
/// <returns></returns>
[NonAction]
public async Task<string> GetRefreshToken()
{
//
var refreshToken = Request.Headers[XAuthorization.RefreshToken].ToString();
if (refreshToken.IsNullOrEmpty())
{
//
refreshToken = await HttpContext
.GetTokenAsync(XAuthorization.RefreshToken);
}
//
return refreshToken;
}
/// <summary>
/// Retrieve Access Token Expiration Date
/// </summary>
/// <returns></returns>
[NonAction]
public async Task<long> GetTokenExpiresAt()
{
//
var expiresAtStr = Request.Headers[XAuthorization.ExpiresAt].ToString();
if (expiresAtStr.IsNullOrEmpty())
{
//
expiresAtStr = await HttpContext
.GetTokenAsync(XAuthorization.ExpiresAt);
}
//
var expiresAt = expiresAtStr.ConvertTo<long>();
//
return expiresAt;
}
/// <summary>
/// Retrieve All Required Tokens
/// </summary>
/// <returns></returns>
[NonAction]
public async Task<XLoginResponse> RetrieveTokensAsXLoginResponse()
{
//
var accessToken = await GetAccessToken();
var refreshToken = await GetRefreshToken();
var expiresAt = await GetTokenExpiresAt();
//
return new XLoginResponse
{
AccessToken = accessToken,
RefreshToken = refreshToken,
ExpiresAt = expiresAt
};
}
/// <summary>
/// Retrieve All Required Tokens
/// </summary>
/// <returns></returns>
[NonAction]
public async Task<XTokenResponse> RetrieveTokensAsXTokenResponse()
{
//
var accessToken = await GetAccessToken();
var refreshToken = await GetRefreshToken();
var expiresAt = await GetTokenExpiresAt();
//
return new XTokenResponse
{
AccessToken = accessToken,
RefreshToken = refreshToken,
ExpiresAt = expiresAt
};
}
/// <summary>
/// Retrive UserInfo
/// </summary>
/// <returns></returns>
[NonAction]
public async Task<XUserClaimsInfoDto> GetUserInfo()
{
//
var claims = User.Claims ?? null;
if (!claims.HasChild())
{
return null;
}
var xTokens = await RetrieveTokensAsXTokenResponse();
var result = new XUserClaimsInfoDto(
xTokens.AccessToken,
xTokens.RefreshToken,
xTokens.ExpiresAt,
User.Claims
);
//
return result;
}
/// <summary>
/// Validate User Authenticated and Retrieve User Info
/// </summary>
/// <returns></returns>
[NonAction]
public async Task<XUserClaimsInfoDto> ValidateAndGetUserInfo()
{
//
if (!User.Identity.IsAuthenticated)
{
XException.NotAuthorized.Throw();
}
//
var result = await GetUserInfo();
if (result.IsNull())
{
XException.NotAuthorized.Throw();
}
//
return result;
}
#endregion
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\DI\XDIHelperExtension.cs
using System;
using IdentityModel.AspNetCore.OAuth2Introspection;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using xCommons.Authorization;
using xCommons.Extensions;
using xIdentityService.Configuration;
using xIdentityService.Constants;
using xIdentityService.Interfaces;
using xIdentityService.Providers;
using xIdentityService.Security;
namespace xIdentityService.DI {
public static partial class XDIHelperExtension {
/// <summary>
/// Extract Module Configuration Structure from IConfiguration interface
/// </summary>
/// <param name="config"></param>
/// <returns></returns>
public static XIdentityServiceConfiguration GetXIdentityServiceConfiguration (this IConfiguration config) {
//
var xIdentityServiceConfigSection = config.GetSection (ConfigurationNodeNames.IDENTITY_SERVICE_NODE_NAME);
return xIdentityServiceConfigSection.Get<XIdentityServiceConfiguration> ();
}
/// <summary>
/// Register Service and All it's Requirements
/// </summary>
/// <param name="services"></param>
/// <param name="configuration"></param>
public static void AddXIdentityService (
this IServiceCollection services,
IConfiguration configuration,
ServiceLifetime lifeTime = ServiceLifetime.Singleton
) {
//
var identityConfiguration = configuration.GetXIdentityServiceConfiguration ();
AddIdentityService (
services,
identityConfiguration,
lifeTime
);
}
/// <summary>
/// Register Service and All it's Requirements
/// </summary>
/// <param name="services"></param>
/// <param name="configuration"></param>
public static void AddXIdentityService (
this IServiceCollection services,
XIdentityServiceConfiguration configuration,
ServiceLifetime lifeTime = ServiceLifetime.Singleton
) {
AddIdentityService (services, configuration, lifeTime);
}
/// <summary>
/// Register Custome Token Provider
/// </summary>
/// <param name="services"></param>
/// <typeparam name="T"></typeparam>
public static void AddXTokenProvider<T> (
this IServiceCollection services,
ServiceLifetime lifetime = ServiceLifetime.Singleton)
where T : IXTokenProvider {
//
Console.WriteLine ("IdentityService: Add Custom Token Provider ...");
services.Add (new ServiceDescriptor (typeof (IXTokenProvider), typeof (T), lifetime));
}
/// <summary>
/// Use Authentication
/// </summary>
/// <param name="app"></param>
public static void UseXIdentityService (this IApplicationBuilder app) {
app.UseAuthentication ();
}
//
#region Private ...
private static void AddIdentityService (
this IServiceCollection services,
XIdentityServiceConfiguration config,
ServiceLifetime lifeTime = ServiceLifetime.Singleton
) {
//
services.AddSingleton<XIdentityServiceConfiguration> (config);
//
var builder = services
.AddAuthentication (XAuthenticationScheme.XToken.GetStringValue ());
//
// Add JWT Handler ...
builder.AddJwtBearer (
XAuthenticationScheme.XToken.GetStringValue (), options => {
//
options.Authority = config.Authority;
options.TokenValidationParameters.ValidateAudience = false;
options.TokenValidationParameters.ValidTypes = new [] { "at+jwt" };
//
options.ForwardDefaultSelector = context => {
//
var path = context.Request.Path.Value;
//
var fromHeader = TokenRetrieval.FromAuthorizationHeader ();
var fromQuery = TokenRetrieval.FromQueryString ();
var bearerToken = fromHeader (context.Request) ?? fromQuery (context.Request);
//
var result = XAuthenticationScheme.XToken.GetStringValue ();
if (!bearerToken.IsNull () && !bearerToken.Contains (".")) {
result = XAuthenticationScheme.XIntrospection.GetStringValue ();
}
//
return result;
};
});
//
// Add OAuthIntrospect ...
builder.AddOAuth2Introspection (
XAuthenticationScheme.XIntrospection.GetStringValue (), options => {
//
options.Authority = config.Authority;
options.ClientId = config.ApiName;
options.ClientSecret = config.ClientSecret;
//
options.TokenRetriever = new Func<HttpRequest, string> (req => {
//
var fromHeader = TokenRetrieval.FromAuthorizationHeader ();
var fromQuery = TokenRetrieval.FromQueryString ();
//
var bearerToken = fromHeader (req) ?? fromQuery (req);
//
return bearerToken;
});
});
//
// Register Authorization Handler ...
services.AddSingleton<IAuthorizationHandler, RequiredRolesHandler> ();
Console.WriteLine ("IdentityService: register Authorization Handlers ...");
//
// Register Identity Provider ...
services.Add (new ServiceDescriptor (typeof (IXIdentityProvider), typeof (XIdentityProvider), lifeTime));
Console.WriteLine ("IdentityService: Register IdentityProvider ...");
//
// Try To Register InMemoryTokenProvier if it's not Provided ...
IXTokenProvider xTokenProvider = null;
try {
xTokenProvider = services.GetRegisteredService<IXTokenProvider> ();
} catch { }
if (xTokenProvider.IsNull ()) {
//
Console.WriteLine ("IdentityService: there is no Custom Token Provider, Adding InMemoryTokenProvider instead ...");
services.Add (new ServiceDescriptor (typeof (IXTokenProvider), typeof (XInMemoryTokenProvider), lifeTime));
}
//
// Adding Security Provider ...
services.Add (new ServiceDescriptor (typeof (IXSecurityProvider), typeof (XSecurityProvider), lifeTime));
Console.WriteLine ("IdentityService: Register Security Provider ...");
}
#endregion
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Extensions\AuthorizationPolicyBuilderExtensions.cs
using IdentityModel;
using Microsoft.AspNetCore.Authorization;
namespace xIdentityService.Extensions {
public static class AuthorizationPolicyBuilderExtensions {
/// <summary>
/// Adds a policy to check for required scopes.
/// </summary>
/// <param name="builder"></param>
/// <param name="scope">List of any required scopes. The token must contain at least one of the listed scopes.</param>
/// <returns></returns>
public static AuthorizationPolicyBuilder RequireScope (this AuthorizationPolicyBuilder builder, params string[] scope) {
return builder.RequireClaim (JwtClaimTypes.Scope, scope);
}
}
/// <summary>
/// Helper for creating scope-related policies
/// </summary>
public static class ScopePolicy {
/// <summary>
/// Creates a policy to check for required scopes.
/// </summary>
/// <param name="scopes">List of any required scopes. The token must contain at least one of the listed scopes.</param>
/// <returns></returns>
public static AuthorizationPolicy Create (params string[] scopes) {
return new AuthorizationPolicyBuilder ()
.RequireScope (scopes)
.Build ();
}
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Extensions\HttpContextExtensions.cs
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using xCommons.Constants;
using xCommons.Extensions;
using xIdentityModels.Models;
using xIdentityService.Constants;
namespace xIdentityService.Extensions {
public static class HttpContextExtensions {
/// <summary>
/// Retrieve Authentication Service ...
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public static IAuthenticationService GetAuthenticationService (this HttpContext context) {
//
var result = context.RequestServices
.GetRequiredService<IAuthenticationService> ();
//
return result;
}
/// <summary>
/// Retrieve Specific Token from HttpContext ...
/// </summary>
/// <param name="context"></param>
/// <param name="tokenName"></param>
/// <param name="scheme"></param>
/// <returns></returns>
public static async Task<string> GetXTokenAsync (
this HttpContext context,
string tokenName,
XAuthenticationScheme scheme = XAuthenticationScheme.XToken
) {
//
// Validate Args ...
if (tokenName.IsNullOrEmpty ()) {
return null;
}
//
var authService = context.GetAuthenticationService ();
if (authService.IsNull ()) {
return null;
}
//
var authResult = await authService
.AuthenticateAsync (
context,
scheme
.GetStringValue ()
);
//
var result = authResult?.Properties?
.GetTokenValue (tokenName);
return result;
}
/// <summary>
/// Retrieve Access Token
/// </summary>
/// <returns></returns>
public static async Task<string> GetAccessToken (this HttpContext context) {
//
var accessToken = context.Request.Headers[XAuthorization.Header]
.ToString ();
if (accessToken.IsNullOrEmpty ()) {
accessToken = await context
.GetTokenAsync (XAuthorization.AccessToken);
}
//
if (accessToken
.ToNormalString ()
.Contains (XAuthorization.TokenIdentifier
.ToNormalString ())) {
accessToken = accessToken
.Remove (0, XAuthorization.TokenIdentifier.Length);
}
//
return accessToken;
}
/// <summary>
/// Retrieve Refresh Token
/// </summary>
/// <returns></returns>
public static async Task<string> GetRefreshToken (this HttpContext context) {
//
var refreshToken = context.Request.Headers[XAuthorization.RefreshToken]
.ToString ();
if (refreshToken.IsNullOrEmpty ()) {
refreshToken = await context
.GetTokenAsync (XAuthorization.RefreshToken);
}
//
return refreshToken;
}
/// <summary>
/// Retrieve Access Token Expiration Date
/// </summary>
/// <returns></returns>
public static async Task<long> GetTokenExpiresAt (this HttpContext context) {
//
var expiresAtStr = context.Request.Headers[XAuthorization.ExpiresAt]
.ToString ();
if (expiresAtStr.IsNullOrEmpty ()) {
expiresAtStr = await context
.GetTokenAsync (XAuthorization.ExpiresAt);
}
//
var expiresAt = expiresAtStr.ConvertTo<long> ();
//
return expiresAt;
}
/// <summary>
/// Retrieve All Required Tokens
/// </summary>
/// <returns></returns>
public static async Task<XTokenResponse> RetrieveTokensAsXTokenResponse (HttpContext context) {
//
var accessToken = await GetAccessToken (context);
var refreshToken = await GetRefreshToken (context);
var expiresAt = await GetTokenExpiresAt (context);
//
return new XTokenResponse {
AccessToken = accessToken,
RefreshToken = refreshToken,
ExpiresAt = expiresAt
};
}
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Extensions\StreamExtensions.cs
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using xCommons.Extensions;
namespace xIdentityService.Extensions
{
public static partial class StreamExtensions
{
/// <summary>
/// Converts an Stream to Async Enumerable ...
/// </summary>
/// <param name="stream"></param>
/// <param name="bufferSize"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public static async IAsyncEnumerable<byte[]> ToAsyncEnumerable(
this Stream stream,
int bufferSize = 8192,
[System.Runtime.CompilerServices.EnumeratorCancellation]
CancellationToken cancellationToken = default
)
{
//
var buffer = new byte[bufferSize];
while (true)
{
//
int read = await stream
.ReadAsync(
buffer,
0,
buffer.Length,
cancellationToken
);
//
if (read == 0)
{
yield break;
}
//
yield return buffer.Take(read).ToArray();
}
}
/// <summary>
/// Converts an Stream to Async Enumerable ...
/// </summary>
/// <param name="stream"></param>
/// <param name="bufferSize"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public static async IAsyncEnumerable<T> ToAsyncEnumerable<T>(
this Stream stream,
int bufferSize = 8192,
[System.Runtime.CompilerServices.EnumeratorCancellation]
CancellationToken cancellationToken = default
)
{
//
var buffer = new byte[bufferSize];
while (true)
{
//
int read = await stream
.ReadAsync(
buffer,
0,
buffer.Length,
cancellationToken
);
if (read == 0)
{
yield break;
}
//
T chunk = default(T);
var readedBuffer = buffer.Take(read).ToArray();
var str = readedBuffer.FromBytes();
if (str.IsNullOrEmpty())
{
yield return chunk;
}
try
{
chunk = str.FromJSON<T>();
}
catch
{ }
//
yield return chunk;
}
}
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Extensions\XModelExtensions.cs
using xIdentityModels.Dtos;
using xModels.Dtos;
namespace xIdentityService.Extensions
{
public static class XModelExtensions
{
public static XPersonDto ToXPersonDto(this XOpenActionUserInfoDto source)
{
//
var result = new XPersonDto
{
Avatar = source.Avatar,
Lastname = source.Lastname,
Username = source.Username,
Firstname = source.Firstname,
};
//
return result;
}
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Extensions\XTokenExtensions.cs
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using IdentityModel.Client;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc.Filters;
using xCommons.Constants;
using xCommons.Extensions;
using xExceptions.Constants;
using xExceptions.Models;
using xIdentityModels.Models;
using xIdentityService.Interfaces;
public static partial class XTokenExtensions {
/// <summary>
/// Retrieve Tokens From Headers
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static XLoginResponse RetrieveTokens (this HttpRequest source) {
//
var accessToken = source.Headers[XAuthorization.Header].ToString ();
var refreshToken = source.Headers[XAuthorization.RefreshToken].ToString ();
//
var expiresAtStr = source.Headers[XAuthorization.ExpiresAt].ToString ();
long expiresAt = expiresAtStr.ConvertTo<long> ();
//
if (accessToken
.ToNormalString ()
.Contains (XAuthorization.TokenIdentifier.ToNormalString ())) {
accessToken = accessToken.Remove (0, XAuthorization.TokenIdentifier.Length);
}
//
return new XLoginResponse {
AccessToken = accessToken,
RefreshToken = refreshToken,
ExpiresAt = expiresAt
};
}
/// <summary>
/// Retrieve Tokens From HttpContext
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static async Task<XLoginResponse> RetrieveTokens (this HttpContext source) {
//
var accessToken = await source.GetTokenAsync (XAuthorization.AccessToken);
if (accessToken
.ToNormalString ()
.Contains (XAuthorization.TokenIdentifier.ToNormalString ())) {
accessToken = accessToken.Remove (0, XAuthorization.TokenIdentifier.Length);
}
var refreshToken = await source.GetTokenAsync (XAuthorization.RefreshToken);
var expiresAtStr = await source.GetTokenAsync (XAuthorization.ExpiresAt);
long expiresAt = expiresAtStr.ConvertTo<long> ();
//
var headerRequestTokens = source.Request.RetrieveTokens ();
//
var result = new XLoginResponse {
AccessToken = accessToken ?? headerRequestTokens.AccessToken,
RefreshToken = refreshToken ?? headerRequestTokens.RefreshToken,
ExpiresAt = expiresAt != 0 ? expiresAt : headerRequestTokens.ExpiresAt
};
//
return result;
}
/// <summary>
/// Retrieve Tokens From ActionExecutingContext
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static async Task<XLoginResponse> RetrieveTokens (this ActionExecutingContext source) {
//
var result = await source.HttpContext.RetrieveTokens ();
return result;
}
/// <summary>
/// Retrieve Tokens From XUserInfo instance
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static XTokenResponse RetrieveTokens (this XUserClaimsInfoDto source) {
//
var result = new XLoginResponse {
AccessToken = source.AccessToken,
RefreshToken = source.RefreshToken,
ExpiresAt = source.ExpiresAt
};
//
return result;
}
/// <summary>
/// Retrieve Tokens From IHeader Dictionary
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static XLoginResponse RetrieveTokens (this IHeaderDictionary source) {
//
var accessToken = source[XAuthorization.Header].ToString () ?? "";
if (accessToken
.ToNormalString ()
.Contains (XAuthorization.TokenIdentifier.ToNormalString ())) {
accessToken = accessToken.Remove (0, XAuthorization.TokenIdentifier.Length);
}
//
var refreshToken = source[XAuthorization.RefreshToken].ToString () ?? "";
//
var expiresAtStr = source[XAuthorization.ExpiresAt].ToString () ?? "";
var expiresAt = expiresAtStr.ConvertTo<long> ();
//
var result = new XLoginResponse {
AccessToken = accessToken,
RefreshToken = refreshToken,
ExpiresAt = expiresAt
};
//
return result;
}
/// <summary>
/// Retrieve IXIdentityProvider from HttpContext
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static IXIdentityProvider GetXApiIdentityProvider (this FilterContext source) {
//
var services = source.HttpContext.RequestServices;
return (IXIdentityProvider) services
.GetService (typeof (IXIdentityProvider));
}
/// <summary>
/// Generate XLoginResponse instance based on TokenResponse
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static XLoginResponse CreateXLoginResponse (this TokenResponse source) {
//
if (source.IsNull () ||
source.IsError) {
XException.InvalidToken.Throw ();
}
//
var expiresAt = new DateTimeOffset (DateTime.UtcNow)
.ToUnixTimeSeconds () +
source.ExpiresIn;
//
var result = new XLoginResponse {
AccessToken = source.AccessToken,
RefreshToken = source.RefreshToken,
ExpiresAt = expiresAt
};
//
return result;
}
/// <summary>
/// Add Authorization Tokens in Headers of
/// Specific IHeaderDictionary instance
/// </summary>
/// <param name="source"></param>
/// <param name="model"></param>
public static void SetXAuthenticationTokens (this IHeaderDictionary source, XLoginResponse model, string secret = null) {
//
source.Remove (XAuthorization.Header);
source.Remove (XAuthorization.RefreshToken);
source.Remove (XAuthorization.ExpiresAt);
source.Remove (XAuthorization.RevisionChecksum);
//
source.Add (XAuthorization.Header, $"{XAuthorization.TokenIdentifier}{model.AccessToken}");
source.Add (XAuthorization.RefreshToken, $"{model.RefreshToken}");
source.Add (XAuthorization.ExpiresAt, $"{model.ExpiresAt}");
//
if (!secret.IsNullOrEmpty ()) {
var revisionChecksum = model.GetRevisionChecksum (secret);
source.Add (XAuthorization.RevisionChecksum, revisionChecksum);
}
}
/// <summary>
/// Add Authorization Tokens in Headers of
/// Specific IHeaderDictionary instance
/// </summary>
/// <param name="source"></param>
/// <param name="model"></param>
public static void SetXAuthenticationTokens (this HttpRequestHeaders source, XLoginResponse model) {
//
source.Remove (XAuthorization.Header);
source.Remove (XAuthorization.RefreshToken);
source.Remove (XAuthorization.ExpiresAt);
source.Remove (XAuthorization.RevisionChecksum);
//
source.Add (XAuthorization.Header, $"{XAuthorization.TokenIdentifier}{model.AccessToken}");
source.Add (XAuthorization.RefreshToken, $"{model.RefreshToken}");
source.Add (XAuthorization.ExpiresAt, $"{model.ExpiresAt}");
}
/// <summary>
/// Add Authorization Tokens in Headers of
/// Specific HttpRequest instance
/// </summary>
/// <param name="source"></param>
/// <param name="model"></param>
public static void SetXAuthenticationTokens (this HttpRequest source, XLoginResponse model) {
source.Headers.SetXAuthenticationTokens (model);
}
/// <summary>
/// Add Authorization Tokens in Headers of
/// Specific HttpRequest instance
/// </summary>
/// <param name="source"></param>
/// <param name="model"></param>
public static void SetXAuthenticationTokens (this HttpRequestMessage source, XLoginResponse model) {
source.Headers.SetXAuthenticationTokens (model);
}
/// <summary>
/// Add ReNewed Authorization Tokens in Headers of
/// Specific Response.
/// Later in HttpInterceptors we can Look for AccessToken-ReNewed
/// header Value and Renew User Tokens based on it
/// </summary>
/// <param name="source"></param>
/// <param name="model"></param>
public static void SetXAuthenticationTokens (this HttpResponse source, XLoginResponse model, string secret) {
source.Headers.SetXAuthenticationTokens (model, secret);
}
/// <summary>
/// Determines a Token Can Refrsh or not
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static bool IsRefreshable (this XLoginResponse source) {
//
var containsTokenData = !source.IsNull () &&
!source.AccessToken.IsNullOrEmpty () &&
!source.RefreshToken.IsNullOrEmpty ();
if (!containsTokenData) {
return false;
}
//
var current = new DateTimeOffset (DateTime.UtcNow)
.ToUnixTimeSeconds ();
//
// var result = current > source.ExpiresAt || current > source.ExpiresAt - XAuthorization.ThresholdBeforeTokenExpiration;
var result = current > source.ExpiresAt - XAuthorization.ThresholdBeforeTokenExpiration;
//
return result;
}
/// <summary>
/// Generate a Revision Checksum for new Tokens
/// </summary>
/// <param name="source"></param>
/// <param name="secret"></param>
/// <returns></returns>
public static string GetRevisionChecksum (this XLoginResponse source, string secret) {
return (source.AccessToken +
secret +
source.RefreshToken +
secret +
source.ExpiresAt.ToString ()
)
.ToMd5String ();
}
/// <summary>
/// Generate a Revision Checksum for new Tokens
/// </summary>
/// <param name="source"></param>
/// <param name="secret"></param>
/// <returns></returns>
public static string GetRevisionChecksum (this XTokenResponse source, string secret) {
return (source.AccessToken +
secret +
source.RefreshToken +
secret +
source.ExpiresAt.ToString ()
)
.ToMd5String ();
}
/// <summary>
/// Check an XLoginResponse instance is Valid with it's revision
/// </summary>
/// <param name="source"></param>
/// <param name="checksum"></param>
/// <param name="secret"></param>
/// <returns></returns>
public static bool ValidateRevisionChecksum (this XLoginResponse source, string checksum, string secret) {
//
var xChecksum = source.GetRevisionChecksum (secret);
return checksum == xChecksum;
}
/// <summary>
/// Check an XTokenResponse instance is Valid with it's revision
/// </summary>
/// <param name="source"></param>
/// <param name="checksum"></param>
/// <param name="secret"></param>
/// <returns></returns>
public static bool ValidateRevisionChecksum (this XTokenResponse source, string checksum, string secret) {
//
var xChecksum = source.GetRevisionChecksum (secret);
return checksum == xChecksum;
}
/// <summary>
/// Retrieve Exception Details if Fails
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static Exception GetException (this TokenResponse source) {
//
// Validate Args ...
if (source.IsNull () || !source.IsError) {
return XException.ActionFailed.ToException ();
}
//
XError error = source.ErrorDescription.FromJSON<XError> ();
return error.ToException ();
}
/// <summary>
/// Convert XTokenResponse to Header Dictionary
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static IDictionary<string, string> ToHeaderDictionary (this XTokenResponse source) {
//
var result = new Dictionary<string, string> { { XAuthorization.RefreshToken, source.RefreshToken },
{ XAuthorization.ExpiresAt, source.ExpiresAt.ToString () }
};
//
return result;
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Extensions\XUserClaimsInfoDtoExtensions.cs
using xCommons.Extensions;
using xIdentityModels.Constants;
using xIdentityModels.Models;
namespace xIdentityService.Extensions {
public static class XUserClaimsInfoDtoExtensions {
public static string GetUserSelectByParam (
this XUserClaimsInfoDto source,
XUserSelectBy userSelectBy = XUserSelectBy.Username
) {
//
var result = "";
//
switch (userSelectBy) {
//
case XUserSelectBy.ID:
result = source.UserId;
break;
//
case XUserSelectBy.Username:
result = source.UserName;
break;
//
case XUserSelectBy.Email:
result = source.Email;
break;
//
case XUserSelectBy.MobileNumber:
result = source.PhoneNumber;
break;
}
//
if (result.IsNullOrEmpty ()) {
//
if (!source.UserId.IsNullOrEmpty ()) {
result = source.UserId;
} else if (!source.UserName.IsNullOrEmpty ()) {
result = source.UserName;
} else if (!source.Email.IsNullOrEmpty ()) {
result = source.Email;
} else if (!source.PhoneNumber.IsNullOrEmpty ()) {
result = source.PhoneNumber;
}
}
//
return result;
}
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Interfaces\IXBaseIdentityHttpProvider.cs
using System;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using RestSharp;
using xCommons.Providers;
using xHttpService.Constants;
using xIdentityModels.Constants;
using xIdentityModels.Models;
using xIdentityService.Models;
namespace xIdentityService.Interfaces
{
/// <summary>
/// an interface for Identity Provided Http Based Services ...
/// </summary>
public interface IXBaseIdentityHttpProvider
{
/// <summary>
/// Client Base Url ...
/// </summary>
/// <value></value>
string BaseUrl { get; }
/// <summary>
/// Logger ...
/// </summary>
/// <value></value>
ILogger Logger { get; }
/// <summary>
/// Powered Value ...
/// </summary>
/// <value></value>
string XPoweredValue { get; }
/// <summary>
/// Default Client Timeout ...
/// </summary>
/// <value></value>
int DefaultClientTimeout { get; }
/// <summary>
/// Default Buffering Chunk Size ...
/// </summary>
/// <value></value>
int DefaultBufferingChunckSize { get; }
/// <summary>
/// Validation Provider ...
/// </summary>
/// <value></value>
XValidationProvider ValidationProvider { get; }
/// <summary>
/// Get an Instance of Http Client
/// </summary>
/// <returns></returns>
HttpClient GetHttpClient(XTokenResponse tokens = null);
HttpClient GetHttpClient(XUserClaimsInfoDto userInfo = null);
/// <summary>
/// Get an Instance of RestClient
/// </summary>
/// <returns></returns>
RestClient GetRestClient(XTokenResponse tokens = null);
RestClient GetRestClient(XUserClaimsInfoDto userInfo = null);
/// <summary>
/// Get an Instance of RestRequest
/// </summary>
/// <param name="endpoint"></param>
/// <param name="addXPoweredValue"></param>
/// <param name=""></param>
/// <param name="headers"></param>
/// <param name="queryStrings"></param>
/// <returns></returns>
RestRequest GetRestRequet(
Enum endpoint,
bool addXPoweredValue = true,
IDictionary<string, string> @params = null,
IDictionary<string, string> headers = null,
IDictionary<string, string> queryStrings = null
);
/// <summary>
/// Handle Call Specific Request and retrieve Response
/// </summary>
/// <param name="client"></param>
/// <param name="request"></param>
/// <param name="method"></param>
/// <param name="supportRefreshingTokens"></param>
/// <param name="cancellationToken"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
Task<T> RunRestRequest<T>(
RestClient client,
RestRequest request,
XHttpMethod method,
bool supportRefreshingTokens = true,
CancellationToken cancellationToken = default
);
/// <summary>
/// Access a Get Request Stream as AsyncEnumerable ...
/// </summary>
/// <param name="endpoint"></param>
/// <param name="bufferLength"></param>
/// <param name="addXPoweredValue"></param>
/// <param name="tokens"></param>
/// <param name="@params"></param>
/// <param name="headers"></param>
/// <param name="queryStrings"></param>
/// <param name="cancellationToken"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
Task<Stream> StreamData(
Enum endpoint,
int bufferLength = 8194,
bool addXPoweredValue = true,
XTokenResponse tokens = null,
IDictionary<string, string> @params = null,
IDictionary<string, string> headers = null,
IDictionary<string, string> queryStrings = null,
CancellationToken cancellationToken = default
);
/// <summary>
/// Handle Call Specified Request and Retrieve XBaseRestResponse<T> ...
/// </summary>
/// <param name="client"></param>
/// <param name="request"></param>
/// <param name="method"></param>
/// <param name="supportRefreshingTokens"></param>
/// <param name="cancellationToken"></param>
/// <typeparam name="T"></typeparam>
/// <returns>an instance of XBaseRestResponse<T></returns>
Task<XBaseRestResponse<T>> RunRestRequestByResponse<T>(
RestClient client,
RestRequest request,
XHttpMethod method,
bool supportRefreshingTokens = true,
CancellationToken cancellationToken = default
);
/// <summary>
/// Get User SelectBy Param
/// </summary>
/// <param name="model"></param>
/// <param name="forceNotNull"></param>
/// <param name="excludes"></param>
/// <returns></returns>
string GetUserSelectByParam(
XActionRequest model,
bool forceNotNull = true,
ICollection<XUserSelectBy> excludes = null
);
/// <summary>
/// Converts UserInfo to TokenResponse model ...
/// </summary>
/// <param name="userInfo"></param>
/// <returns></returns>
XTokenResponse ToTokenResponse(XUserClaimsInfoDto userInfo = null);
/// <summary>
/// Prepare Url Address of Specified Enum by Filling Params
/// and Query Strings Attach ...
/// </summary>
/// <param name="endpoint"></param>
/// <param name="attachBaseUrl"></param>
/// <param name="@params"></param>
/// <param name="queryStrings"></param>
/// <returns></returns>
string PrepareUrl(
Enum endpoint,
bool attachBaseUrl = false,
IDictionary<string, string> @params = null,
IDictionary<string, string> queryStrings = null
);
/// <summary>
/// Prepare Url Address by Filling Params
/// and Query Strings Attach ...
/// </summary>
/// <param name="url"></param>
/// <param name="attachBaseUrl"></param>
/// <param name="@params"></param>
/// <param name="queryStrings"></param>
/// <returns></returns>
string PrepareUrl(
string url,
bool attachBaseUrl = false,
IDictionary<string, string> @params = null,
IDictionary<string, string> queryStrings = null
);
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Interfaces\IXBaseReferenced.cs
using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using xDataService.Models;
using xIdentityModels.Models;
using xModels.Base;
namespace xIdentityService.Interfaces
{
/// <summary>
/// a Referenced Service is a Service which can Referenced to other Items ...
/// </summary>
public interface IXBaseReferenced<TEntity, TKey>
where TEntity : XBaseEntity<TKey>
{
/// <summary>
/// Get Reference Identifier for Specified Provider and Specified Item ...
/// </summary>
/// <param name="providedFor"></param>
/// <param name="forProvidedId"></param>
/// <returns></returns>
string GetIdentifier<TReferenceKey>(
string providedFor,
TReferenceKey forProvidedId
);
/// <summary>
/// Check Specified Item has Refernce to Provider ...
/// </summary>
/// <param name="providedFor"></param>
/// <param name="forProvidedId"></param>
/// <param name="id"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task<bool> IsProvidedFor<TReferenceKey>(
string providedFor,
TReferenceKey forProvidedId,
TKey id,
CancellationToken cancellationToken = default
);
/// <summary>
/// Add Specified Reference to Specified Item ...
/// </summary>
/// <param name="providedFor"></param>
/// <param name="forProvidedId"></param>
/// <param name="id"></param>
/// <param name="forIndex"></param>
/// <param name="userInfo"></param>
/// <param name="connectionId"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task AddReference<TReferenceKey>(
string providedFor,
TReferenceKey forProvidedId,
TKey id,
int forIndex = 0,
XUserClaimsInfoDto userInfo = null,
string connectionId = null,
CancellationToken cancellationToken = default
);
/// <summary>
/// Remove Specified Reference from Specified Item ...
/// </summary>
/// <param name="providedFor"></param>
/// <param name="forProvidedId"></param>
/// <param name="id"></param>
/// <param name="forIndex"></param>
/// <param name="userInfo"></param>
/// <param name="connectionId"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
Task RemoveReference<TReferenceKey>(
string providedFor,
TReferenceKey forProvidedId,
TKey id,
int forIndex = 0,
XUserClaimsInfoDto userInfo = null,
string connectionId = null,
CancellationToken cancellationToken = default
);
/// <summary>
/// Get Specified References ...
/// </summary>
/// <param name="providedFor"></param>
/// <param name="id"></param>
/// <param name="cancellationToken"></param>
/// <typeparam name="TReferenceKey"></typeparam>
/// <returns></returns>
Task<IEnumerable<XReference<string>>> GetReferences(
string providedFor,
TKey id,
CancellationToken cancellationToken = default
);
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Interfaces\IXBaseReferencedController.cs
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using xDataService.Models;
using xModels.Base;
namespace xIdentityService.Interfaces
{
public interface IXBaseReferencedController<TEntity, TKey>
where TEntity : XBaseEntity<TKey>
{
/// <summary>
/// Check an Item Has Reference to Specified ProvideFor and Specified forProvidedId ...
/// </summary>
/// <param name="id"></param>
/// <param name="providedFor"></param>
/// <param name="forProvidedId"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
[HttpGet("{id}/Reference/IsProvidedFor")]
Task<ActionResult<bool>> IsProvidedFor(
[FromRoute] TKey id,
[FromQuery] string providedFor,
[FromQuery] object forProvidedId,
CancellationToken cancellationToken = default
);
/// <summary>
/// Add a Reference to Item for Specified ProvideFor and Specified forProvidedId ...
/// </summary>
/// <param name="id"></param>
/// <param name="providedFor"></param>
/// <param name="forProvidedId"></param>
/// <param name="forIndex"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
[HttpPost("{id}/Reference")]
Task<ActionResult> AddReference(
[FromRoute] TKey id,
[FromQuery] string providedFor,
[FromQuery] object forProvidedId,
[FromQuery] int forIndex = 0,
CancellationToken cancellationToken = default
);
/// <summary>
/// Remove a Reference from Item for Specified ProvideFor and Specified forProvidedId ...
/// </summary>
/// <param name="id"></param>
/// <param name="providedFor"></param>
/// <param name="forProvidedId"></param>
/// <param name="forIndex"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
[HttpDelete("{id}/Reference")]
Task<ActionResult> RemoveReference(
[FromRoute] TKey id,
[FromQuery] string providedFor,
[FromQuery] object forProvidedId,
[FromQuery] int forIndex = 0,
CancellationToken cancellationToken = default
);
/// <summary>
/// Retrieve References of Specified Itemfor providedFor ...
/// </summary>
/// <param name="id"></param>
/// <param name="providedFor"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
[HttpGet("{id}/References")]
Task<ActionResult<IEnumerable<XReference<string>>>> GetReferences(
[FromRoute] TKey id,
[FromQuery] string providedFor,
CancellationToken cancellationToken = default
);
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Interfaces\IXIdentityBaseReferencedProvider.cs
using System.Collections.Generic;
using System.Threading.Tasks;
using xDataService.Models;
using xIdentityModels.Models;
using xModels.Dtos;
namespace xIdentityService.Interfaces
{
/// <summary>
/// in Some Cases we have Entities Which Can Referenced for Specified
/// Provider and Types ...
/// this interface Globaly introduce all available Actions for those ...
///
/// TKey: type of Provider Models Keys ...
/// TModel: type of Dto which Referenced ...
/// </summary>
public interface IXIdentityBaseReferencedProvider<TModel, TKey>
{
//
#region Props ...
/// <summary>
/// Provider Identifier ...
/// </summary>
string Provider { get; }
#endregion
//
#region Referenced Actions ...
/// <summary>
/// Get Specified Indexed Reference for Specific Provided ID ...
/// </summary>
/// <param name="providedForId"></param>
/// <param name="forIndex"></param>
/// <returns></returns>
Task<TModel> GetReference(
TKey providedForId,
int forIndex = 0
);
/// <summary>
/// Retrieve all Exists References of Specific Provided ID ...
/// </summary>
/// <param name="providedForId"></param>
/// <returns></returns>
Task<IEnumerable<TModel>> GetAllReferences(TKey providedForId);
/// <summary>
/// Extract all Referencing Models for Specified Key ...
/// </summary>
/// <param name="providedForId"></param>
/// <returns></returns>
Task<IEnumerable<XReference<TKey>>> GetAllReferencings(TKey providedForId);
/// <summary>
/// Count References ...
/// </summary>
/// <param name="providedForId"></param>
/// <returns></returns>
Task<int> CountReferences(TKey providedForId);
/// <summary>
/// Retrieve References of Specific Provided ID as Query ...
/// </summary>
/// <param name="providedForId"></param>
/// <returns></returns>
Task<XQueryResult<TModel>> QueryReferences(
XQuery query,
TKey providedForId
);
/// <summary>
/// Add Reference a Model to Specific Provided ID ...
/// </summary>
/// <param name="model"></param>
/// <param name="providedForId"></param>
/// <param name="connectionId"></param>
/// <param name="userInfo"></param>
/// <returns></returns>
Task<bool> AddReference(
TModel model,
TKey providedForId,
string connectionId = null,
XUserClaimsInfoDto userInfo = null
);
/// <summary>
/// Add Reference a Model to Specific XRefence<TKey> ...
/// </summary>
/// <param name="model"></param>
/// <param name="reference"></param>
/// <param name="connectionId"></param>
/// <param name="userInfo"></param>
/// <returns></returns>
Task<bool> AddReference(
TModel model,
XReference<TKey> reference,
string connectionId = null,
XUserClaimsInfoDto userInfo = null
);
/// <summary>
/// Remove Reference a Model for Specific Provided ID ...
/// </summary>
/// <param name="model"></param>
/// <param name="providedForId"></param>
/// <param name="connectionId"></param>
/// <param name="userInfo"></param>
/// <returns></returns>
Task<bool> RemoveReference(
TModel model,
TKey providedForId,
string connectionId = null,
XUserClaimsInfoDto userInfo = null
);
/// <summary>
/// Remove Reference a Model for Specific XRefence<TKey> ...
/// </summary>
/// <param name="model"></param>
/// <param name="providedForId"></param>
/// <param name="connectionId"></param>
/// <param name="userInfo"></param>
/// <returns></returns>
Task<bool> RemoveReference(
TModel model,
XReference<TKey> reference,
string connectionId = null,
XUserClaimsInfoDto userInfo = null
);
/// <summary>
/// Remove All References to Specified Key ...
/// </summary>
/// <param name="providedForId"></param>
/// <param name="connectionId"></param>
/// <param name="userInfo"></param>
/// <returns></returns>
Task<bool> RemoveReferences(
TKey providedForId,
string connectionId = null,
XUserClaimsInfoDto userInfo = null
);
#endregion
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Interfaces\IXIdentityProvider.cs
using System.Collections.Generic;
using System.Threading.Tasks;
using IdentityModel.Client;
using Microsoft.AspNetCore.Http;
using RestSharp;
using xHttpService.Constants;
using xIdentityModels.Constants;
using xIdentityModels.Dtos;
using xIdentityModels.Models;
using xIdentityModels.Navigations;
using xModels.Dtos;
namespace xIdentityService.Interfaces
{
public partial interface IXIdentityProvider
{
//
string BaseUrl { get; }
string RevisionSecretKey { get; }
IXSecurityProvider SecurityProvider { get; }
//
#region Tools ...
string GetUserSelectByParam(
XActionRequest model,
bool forceNotNull = true,
ICollection<XUserSelectBy> excludes = null
);
#endregion
//
#region Tools ...
Task<T> RunRestRequest<T>(
RestClient client,
RestRequest request,
XHttpMethod method,
bool supportRefreshingTokens = false
);
#endregion
//
#region Authentication ...
Task<DiscoveryDocumentResponse> RequestDiscoveryDocument();
Task<XTokenResponse> RequestScopeAccessToken(string scope);
Task<TokenIntrospectionResponse> Introspection(XTokenResponse model);
Task<XLoginResponse> Login(XLoginRequest model);
Task Logout(XTokenResponse model);
Task<XTokenResponse> Authenticate(XLoginRequest model);
Task<XTokenResponse> RefreshTokens(XTokenResponse model);
Task ChangePassword(
XTokenResponse tokens,
XActionRequest model
);
#endregion
//
#region Profile ...
Task<IEnumerable<string>> GetUserNames(
XTokenResponse tokens,
string userIds
);
Task<IEnumerable<XUserNameIdResponse>> GetUserNameIds(
XTokenResponse tokens,
XUserNameIdRequest model
);
Task<XUserProfileDto> GetUserProfile(
XTokenResponse tokens,
string userSelectByParam
);
Task<XQueryResult<XUserProfileDto>> QueryUsers(
XTokenResponse tokens,
XQuery query
);
Task<XQueryResult<XUserProfileDto>> QueryInRoleUsers(
XTokenResponse tokens,
string role,
XQuery query,
bool forceRole = false
);
Task<XQueryResult<XProfileImage>> QueryAvatars(
XTokenResponse tokens,
string userSelectByParam,
XQuery query
);
Task<XUserProfileDto> ProfileUpdateAsync(
XTokenResponse tokens,
string userSelectByParam,
XProfileUpdateRequest model
);
Task<XUserProfileDto> FullProfileUpdateAsync(
XTokenResponse tokens,
string userSelectByParam,
XProfileUpdateRequest request
);
Task<XUserProfileDto> AddAvatar(
XTokenResponse tokens,
IFormFile file
);
Task<XUserProfileDto> AddAvatars(
XTokenResponse tokens,
IFormFileCollection files
);
Task<XUserProfileDto> SetAvatar(
XTokenResponse tokens,
int avatarId
);
Task<XUserProfileDto> RemoveAvatars(
XTokenResponse tokens,
string avatarIds
);
#endregion
//
#region Search ...
/// <summary>
/// Query Open To Search User Profiles ...
/// </summary>
/// <param name="tokens">requested user's identifiers</param>
/// <param name="query">how to filter results based on <see>XQuery</see> structure</param>
/// <returns>an instance of <see>XQueryResult</see> of <see>XUserProfileDto</see></returns>
Task<XQueryResult<XUserProfileDto>> QueryOpenToSearchUsers(
XTokenResponse tokens,
XQuery query
);
#endregion
//
#region Registration ...
Task<bool> CanRegister(string userSelectByParam);
Task<XActionResponse> InviteUser(
XTokenResponse tokens,
XActionRequest model
);
Task<XActionResponse> RequestRegistration(
XActionRequest model
);
Task<XActionResponse> AddAccountInfo(
XActionRequest model
);
Task<XActionResponse> AttachProfileImage(
string actionToken,
IFormFile file
);
Task FinishRegistration(XActionRequest model);
Task<bool> IsConfirmedEmail(
XTokenResponse tokens,
string userSelectByParam
);
Task<bool> IsConfirmedMobile(
XTokenResponse tokens,
string userSelectByParam
);
Task RequestConfirmRegistration(XActionRequest model);
Task ConfirmRegistration(
XActionRequest model
);
Task<XActionResponse> RequestConfirmMobile(XActionRequest model);
Task<XActionResponse> ConfirmMobileNumber(XActionRequest model);
Task<XActionResponse> RequestConfirmEmail(XActionRequest model);
Task<XActionResponse> ConfirmEmailAddress(XActionRequest model);
Task<XActionResponse> RequestResetPassword(XActionRequest model);
Task ResetPassword(XActionRequest model);
#endregion
//
#region Friendship ...
Task<XFriendshipFollowing> Follow(
XTokenResponse tokens,
string destUser
);
Task<bool> Cancel(
XTokenResponse tokens,
string destUser
);
Task UnFollowFollower(
XTokenResponse tokens,
string destUser
);
Task UnFollowFollowing(
XTokenResponse tokens,
string destUser
);
Task<XFriendshipFollowing> Block(
XTokenResponse tokens,
string destUser
);
Task<XFriendshipFollowing> UnBlock(
XTokenResponse tokens,
string destUser
);
Task<XFriendshipFollower> AcceptRequest(
XTokenResponse tokens,
string destUser
);
Task<XFriendshipFollower> RejectRequest(
XTokenResponse tokens,
string destUser
);
Task<XFriendshipInfoDto> GetFriendshipInfo(
XTokenResponse tokens,
string destUser
);
Task<bool> IsFollower(
XTokenResponse tokens,
string destUser
);
Task<XFriendshipFollower> GetFollower(
XTokenResponse tokens,
string destUser
);
Task<XFriendshipState> GetFollowerState(
XTokenResponse tokens,
string destUser
);
Task<IEnumerable<XFriendshipFollower>> GetFollowers(XTokenResponse tokens);
Task<IEnumerable<XFriendshipFollower>> GetAllFollowers(XTokenResponse tokens);
Task<IEnumerable<string>> GetFollowingList(XTokenResponse tokens);
Task<XQueryResult<XFriendDto>> QueryFollowers(
XQuery query,
string destUser,
XTokenResponse tokens
);
Task<bool> IsFollowing(
XTokenResponse tokens,
string destUser
);
Task<XFriendshipFollowing> GetFollowing(
XTokenResponse tokens,
string destUser
);
Task<XFriendshipState> GetFollowingState(
XTokenResponse tokens,
string destUser
);
Task<IEnumerable<XFriendshipFollowing>> GetFollowings(XTokenResponse tokens);
Task<IEnumerable<XFriendshipFollowing>> GetAllFollowings(XTokenResponse tokens);
Task<IEnumerable<string>> GetFollowersList(XTokenResponse tokens);
Task<XQueryResult<XFriendDto>> QueryFollowings(
XQuery query,
string destUser,
XTokenResponse tokens
);
#endregion
//
#region Admin ...
Task<IEnumerable<string>> Ban(
XTokenResponse tokens,
XUserNameIdRequest model
);
Task<IEnumerable<string>> UnBan(
XTokenResponse tokens,
XUserNameIdRequest model
);
Task<bool> IsBanned(
XTokenResponse tokens,
string userSelectByParam
);
#endregion
//
#region Open Actions ...
//
XDeviceDto GetDevice();
//
Task<XOpenActionInnerDto> OpenGet(
XOpenActionInnerDto model
);
//
Task<XOpenActionUserInfoDto> GetUserInfo(
XDeviceDto device,
string userSelectByParam
);
Task<XOpenActionUserInfoDto> GetUserInfo(
XOpenActionInnerDto dto
);
Task<XOpenActionUserInfoDto> GetUserInfo(
string token,
string request
);
//
Task<IEnumerable<XOpenActionUserInfoDto>> GetUserInfos(
XDeviceDto device,
string ids
);
Task<IEnumerable<XOpenActionUserInfoDto>> GetUserInfos(
XOpenActionInnerDto dto
);
Task<IEnumerable<XOpenActionUserInfoDto>> GetUserInfos(
string token,
string request
);
#endregion
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Interfaces\IXProxyHelper.cs
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using xIdentityService.Configuration;
namespace xIdentityService.Interfaces {
public interface IXProxyHelper {
/// <summary>
/// Proxy Configuration ...
/// </summary>
/// <value></value>
XProxyConfiguration Configuration { get; }
/// <summary>
/// retrie Normalize Host ...
/// </summary>
/// <returns></returns>
string NormalizeHost ();
/// <summary>
/// Validate XProxy Configuration for Client ...
/// </summary>
/// <returns></returns>
bool ValidateConfiguration ();
/// <summary>
/// Retrieve all Prepared url of Routes ...
/// </summary>
/// <returns></returns>
IEnumerable<string> GetRouteUrls ();
/// <summary>
/// retrieve all registred Routes ...
/// </summary>
/// <returns></returns>
IEnumerable<XProxyRouteDescriptor> GetRoutes ();
/// <summary>
/// Prepare a request url for a Proxy Route ...
/// </summary>
/// <param name="url"></param>
/// <param name="descriptor"></param>
/// <returns></returns>
string PrepareActionUrlForXProxyRoute (
string url,
XProxyRouteDescriptor descriptor
);
/// <summary>
/// Prepare a request url for a Selected Proxy Route ...
/// </summary>
/// <param name="url"></param>
/// <param name="whereClause"></param>
/// <returns></returns>
string PrepareActionUrlForXProxyRoute (
string url,
Expression<Func<XProxyRouteDescriptor, bool>> whereClause
);
/// <summary>
/// Find an Specific Route ...
/// </summary>
/// <param name="whereClause"></param>
/// <returns></returns>
XProxyRouteDescriptor FindRoute (Expression<Func<XProxyRouteDescriptor, bool>> whereClause);
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Interfaces\IXSecurityProvider.cs
namespace xIdentityService.Interfaces
{
public partial interface IXSecurityProvider
{
string Encrypt(string plainText);
string Decrypt(string cipherText);
string EncryptFromBytes(byte[] textBytes);
string DecryptFromBytes(byte[] cipherBytes);
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Interfaces\IXTokenProvider.cs
using System.Threading.Tasks;
using xIdentityModels.Models;
namespace xIdentityService.Interfaces {
public partial interface IXTokenProvider {
Task<bool> IsTokenExists (string accessToken);
Task<bool> IsTokenExists (XTokenResponse tokens);
Task<bool> RemoveToken (string accessToken);
Task<bool> RemoveToken (XTokenResponse tokens);
Task<XTokenResponse> RetrieveToken (string accessToken);
Task<bool> AddToken (XTokenResponse tokens);
Task<bool> UpdateToken (XTokenResponse tokens);
Task<bool> AddOrUpdateToken (XTokenResponse tokens);
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Middlewares\XIdentityTokenRefresher.cs
using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using xCommons.Constants;
using xCommons.Extensions;
using xIdentityModels.Extensions;
using xIdentityService.Interfaces;
namespace xIdentityService.Middlewares {
public partial class XIdentityTokenRefresherMiddleware {
//
#region Properties ...
private readonly ILogger logger;
private readonly RequestDelegate next;
private readonly IXTokenProvider tokenProvider;
private readonly IXIdentityProvider identityProvider;
#endregion
//
#region Constructor ...
public XIdentityTokenRefresherMiddleware (
RequestDelegate next,
ILoggerFactory loggerFactory,
IXTokenProvider tokenProvider,
IXIdentityProvider identityProvider
) {
//
this.next = next;
this.tokenProvider = tokenProvider;
this.identityProvider = identityProvider;
this.logger = loggerFactory
.CreateLogger<XIdentityTokenRefresherMiddleware> ();
}
#endregion
//
#region Actions ...
public async Task Invoke (HttpContext context) {
//
// Handle Request ...
await HandleRequest (context);
//
// Do Main Task ...
try {
await next.Invoke (context);
} catch (Exception ex) {
logger.LogError ($"Error: {ex.Message}");
}
//
// Handle Response ...
await HandleResponse (context);
}
#endregion
//
#region Private ...
private async Task HandleRequest (HttpContext context) {
//
// Log ...
logger.LogInformation ($"Start Process Request ...");
//
// Check Access Token ...
var hasAccessToken = HasAccessToken (context);
if (!hasAccessToken) {
return;
}
//
// Check Access Token ...
var accessToken = GetAccessToken (context);
var isExists = await tokenProvider
.IsTokenExists (accessToken);
if (!isExists) {
return;
}
//
// Try Check is Refreshable ...
var tokens = await tokenProvider
.RetrieveToken (accessToken);
if (tokens.IsNull ()) {
return;
}
//
// Check is Expired or Refreshable ...
var isRefreshable = tokens.IsRefreshable ();
if (!isRefreshable) {
return;
}
//
// Refresh Token ...
var refreshedTokens = await identityProvider
.RefreshTokens (tokens);
if (refreshedTokens.IsNull ()) {
return;
}
//
// Set Refreshed AccessToken to Request ...
context
.Request
.Headers[XAuthorization.Header] =
$"{XAuthorization.TokenIdentifier}{refreshedTokens.AccessToken}";
}
private async Task HandleResponse (HttpContext context) {
//
// Log ...
logger.LogInformation ($"Start Process Response ...");
//
await Task.Run (() => { });
}
private bool HasAccessToken (HttpContext context) {
//
// Check Headers ...
if (context.IsNull () ||
context.Request.IsNull () ||
context.Request.Headers.IsNull ()) {
return false;
}
//
var result = context
.Request
.Headers
.ContainsKey (
XAuthorization.Header
);
//
return result;
}
private string GetAccessToken (HttpContext context) {
//
var hasAccessToken = HasAccessToken (context);
if (!hasAccessToken) {
return string.Empty;
}
//
// Get Result ...
var result = context
.Request
.Headers[
XAuthorization.Header
];
result = result
.ToString ()
.Replace (
XAuthorization.TokenIdentifier,
""
);
//
return result;
}
#endregion
}
/// <summary>
/// Provide all DI Requirements for XIdentityTokenRefresher Middleware
/// </summary>
public static class XIdentityTokenRefresherDIHelper {
/// <summary>
/// Use XTokenValidator Middleware
/// </summary>
/// <param name="app"></param>
public static void UseXIdentityTokenRefresher (this IApplicationBuilder app) {
app.UseMiddleware<XIdentityTokenRefresherMiddleware> ();
}
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Middlewares\XProxyMiddleware.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Web;
using IdentityModel;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.WebUtilities;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using xCommons.Extensions;
using xExceptions.Constants;
using xIdentityService.Configuration;
using xIdentityService.Constants;
using xIdentityService.Interfaces;
using xIdentityService.Providers;
using xModels.Base;
namespace xIdentityService.Middlewares {
/// <summary>
/// Proxy Server Middleware ...
/// </summary>
public class XProxyMiddleware : XBaseClass {
//
#region Pros ...
private readonly HttpClient HTTP_CLIENT;
private readonly RequestDelegate NEXT_MIDDLEWARE;
private readonly XProxyConfiguration CONFIGURATION;
#endregion
//
#region Constructor ...
public XProxyMiddleware (
ILoggerFactory loggerFactory,
RequestDelegate nextMiddleware,
XProxyConfiguration configuration,
IHttpClientFactory httpClientFactory
) : base (loggerFactory) {
//
this.CONFIGURATION = configuration;
this.NEXT_MIDDLEWARE = nextMiddleware;
//
// Create Http Client ...
this.HTTP_CLIENT = httpClientFactory
.CreateClient (XProxyConstants.XPROXY_HTTP_CLIENT);
//
// Logging Server Configuration ...
LogXProxyServerConfig ();
}
#endregion
//
#region Public ...
public async Task InvokeAsync (HttpContext context) {
//
#region Bussiness Logic ...
//
var routeDescriptor = GetRouteDescriptor (context.Request);
if (!routeDescriptor.IsNull ()) {
//
#region Handle Authorization ...
//
try {
//
// Handle XPowered ...
if (routeDescriptor.EnableXPoweredByAthorization) {
//
var isPoweredByPass = context.Request.Headers
.Any (h => h.Key
.ToNormalString () == xCommons.Constants.XAuthorization.XPoweredBy
.ToNormalString () &&
h.Value
.ToString ()
.ToNormalString () == CONFIGURATION.XPoweredValue
.ToNormalString ()
);
//
if (!isPoweredByPass) {
ThrowNotAuthorizedException ();
}
}
//
// Handle EndableAuthorization ...
if (routeDescriptor.EnableAuthorization) {
//
// Retrieve User Info for Authentication ...
var userName = context.User.Identity.Name;
var isUserAuthenticated = !userName.IsNull () &&
context.User.Identity.IsAuthenticated;
if (!isUserAuthenticated &&
!routeDescriptor.AllowedScopes.HasChild ()
) {
ThrowNotAuthorizedException ();
}
//
// Check Allowed Scopes Authorization ...
if (routeDescriptor.AllowedScopes.HasChild ()) {
//
var scopeClaims = context.User.Claims
.Where (c => c.Type == JwtClaimTypes.Scope)
.Select (c => c.Value);
var isScopePassed = scopeClaims.HasChild () &&
scopeClaims.Any (c => routeDescriptor.AllowedScopes
.Any (allowedScope => allowedScope
.ToNormalString () == c
.ToNormalString ()
)
);
if (!isScopePassed) {
ThrowNotAuthorizedException ();
}
}
//
// Check Allowed Roles Authorization ...
if (
isUserAuthenticated &&
routeDescriptor.AllowedRoles.HasChild ()
) {
//
var roleClaim = context.User.Claims
.FirstOrDefault (c => c.Type == JwtClaimTypes.Role);
var isRolePassed = !roleClaim.IsNull () &&
routeDescriptor.AllowedRoles
.Any (role => role
.ToNormalString () == roleClaim.Value
.ToNormalString ());
if (!isRolePassed) {
ThrowNotAuthorizedException ();
}
}
}
} catch {
context.Response.StatusCode = (int) HttpStatusCode.Unauthorized;
return;
}
#endregion
//
// Extract Request Uri from Received Request ...
var requestUri = GetUri (context.Request);
if (!requestUri.IsNull ()) {
//
// Retrieve Request based on current ...
var request = GetRequestMessage (
uri: requestUri,
context: context
);
//
SendLog ($"Send Request to Recieve Response ...", LogLevel.Information);
//
// Send Request and Retrieve Response ...
try {
//
var response = await HTTP_CLIENT.SendAsync (
request,
HttpCompletionOption.ResponseContentRead
);
//
// Set Current Response Status Code ...
context.Response.StatusCode = (int) response.StatusCode;
//
// Retrieve Response Headers and Set To Current Response ...
HandleResponseHeaders (context, response);
//
// Processing Response Content ...
await ProcessResponseContent (context, response);
} catch (Exception ex) {
//
LogMessage ($"Exception: {ex.Message}", LogLevel.Error);
//
context.Response.StatusCode = (int) HttpStatusCode.BadRequest;
}
//
return;
}
}
#endregion
//
await NEXT_MIDDLEWARE (context);
}
#endregion
//
#region Private ...
/// <summary>
/// Throw Required Exception ...
/// </summary>
private void ThrowNotAuthorizedException () {
throw XException.NotAuthorized.ToException ();
}
/// <summary>
/// Show propper logs if Enabled ...
/// </summary>
/// <param name="message"></param>
/// <param name="logLevel"></param>
private void SendLog (string message, LogLevel logLevel = LogLevel.Information) {
//
if (!CONFIGURATION.EnableLogging) {
return;
}
//
LogMessage (
message: message,
logLevel: logLevel
);
}
/// <summary>
/// Log Proxy Server Configuration ...
/// </summary>
private void LogXProxyServerConfig () {
//
// Retrieve XProxyConfiguration class from Configurations and Validate them ...
if (CONFIGURATION.IsNull ()) {
throw XException.InvalidConfiguration.ToException ();
}
//
// Try to Log Proxy Configuration ...
ConsoleMessage ("===============================");
ConsoleMessage ("= Proxy Server Configurations: ");
ConsoleMessage ("===============================");
//
ConsoleMessage ($"Host: {CONFIGURATION.Host}");
ConsoleMessage ($"XPoweredValue: {CONFIGURATION.XPoweredValue}");
ConsoleMessage ($"EnableLogging: {CONFIGURATION.EnableLogging}");
ConsoleMessage ($"DisableSSLCheck: {CONFIGURATION.DisableSSLCheck}");
ConsoleMessage ($"AllowAutoRedirect: {CONFIGURATION.AllowAutoRedirect}");
ConsoleMessage ($" ");
ConsoleMessage ($"Routes: ");
ConsoleMessage ($" ");
//
CONFIGURATION.Routes
.ToList ()
.ForEach (routeDescriptor => {
ConsoleMessage ("===============================");
ConsoleMessage ($"= Rote => {routeDescriptor.Route}");
ConsoleMessage ("===============================");
ConsoleMessage ($"AllowedRoles: {routeDescriptor.AllowedRoles.ToJSON()}");
ConsoleMessage ($"AllowedScopes: {routeDescriptor.AllowedScopes.ToJSON()}");
ConsoleMessage ($"EnableAuthorization: {routeDescriptor.EnableAuthorization}");
ConsoleMessage ($"EnableXPoweredByAthorization: {routeDescriptor.EnableXPoweredByAthorization}");
ConsoleMessage ($" ");
});
}
/// <summary>
/// Retrieve Destination Request Path based on Current Request ...
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private Uri GetUri (HttpRequest request) {
//
// Create temp result ...
Uri result = null;
var requestPath = "";
//
SendLog ($"Receive Request: {request.Path} ...", LogLevel.Information);
//
// Try to Findout Route Descriptor ...
var routeDescriptor = GetRouteDescriptor (request);
//
// Route Descriptor Exists && Path for Delegating ...
if (!routeDescriptor.IsNull () &&
request.Path
.StartsWithSegments (routeDescriptor.Route)
) {
//
// Prepare Request Path by Cleaning Starter Path Segment ...
requestPath = request.Path
.ToString ()
.Replace (routeDescriptor.Route, "");
if (requestPath.StartsWith ("/")) {
requestPath = requestPath.Substring (1);
}
//
// Decoding URL ...
requestPath = HttpUtility.UrlDecode (requestPath);
//
var colonIndex = requestPath.IndexOf (":");
if (colonIndex > -1) {
//
var doubleSlash = requestPath.Substring (colonIndex + 1, 2);
var isDoubleSlash = doubleSlash == "//";
//
if (!isDoubleSlash) {
//
var protocol = requestPath
.Substring (0, colonIndex);
var section = requestPath
.Substring (colonIndex + 2, requestPath.Length - colonIndex - 2);
//
requestPath = $"{protocol}://{section}";
}
}
}
//
// Validate Request Path ...
if (!requestPath.IsNullOrEmpty ()) {
//
result = new Uri (requestPath);
//
SendLog ($"Process Request: {requestPath} ...", LogLevel.Information);
}
//
return result;
}
/// <summary>
/// Retrieve Propper Request Message based on HttpContext and uri ...F
/// </summary>
/// <param name="context"></param>
/// <param name="uri"></param>
/// <returns></returns>
private HttpRequestMessage GetRequestMessage (
HttpContext context,
Uri uri
) {
//
var result = new HttpRequestMessage ();
FillRequest (context, result);
//
// Handle Queries ...
SendLog ($"Start Processing Queries: ");
foreach (var query in context.Request.Query) {
//
var key = query.Key;
var value = HttpUtility.UrlDecode (query.Value);
//
uri = new Uri (
QueryHelpers.AddQueryString (
uri.OriginalString,
new Dictionary<string, string> {
[key] = value
}
)
);
//
SendLog ($"Query : {key}:{value} was Processed ...");
}
//
result.RequestUri = uri;
result.Headers.Host = uri.Host;
//
// Retrieve Request Method ...
result.Method = GetMethod (context.Request.Method);
//
return result;
}
/// <summary>
/// Fill Request Message by provide HttpContext ...
/// </summary>
/// <param name="context"></param>
/// <param name="message"></param>
private void FillRequest (
HttpContext context,
HttpRequestMessage message
) {
//
var requestMethod = context.Request.Method;
//
if (!HttpMethods.IsGet (requestMethod) &&
!HttpMethods.IsHead (requestMethod) &&
!HttpMethods.IsTrace (requestMethod) &&
!HttpMethods.IsDelete (requestMethod)
) {
//
var streamContent = new StreamContent (context.Request.Body);
message.Content = streamContent;
}
//
// Handle Base Headers ...
var regularHeaders = context.Request.Headers
.Where (hr => hr.Key != XProxyConstants.XPROXY_ACCEPTED_HEADERS &&
!hr.Key
.Contains (
XProxyConstants.XPROXY_FORWARD_HEADER
)
);
//
// Handle Aceepted Headers ...
IEnumerable<string> acceptedHeaders = null;
var acceptedHeadersKeyValue = context.Request.Headers
.FirstOrDefault (hr =>
hr.Key == XProxyConstants.XPROXY_ACCEPTED_HEADERS
);
if (!acceptedHeadersKeyValue.IsNull ()) {
//
acceptedHeaders = acceptedHeadersKeyValue.Value
.ToString ()
.ParseListString<string> ();
//
// Filter Regular Headers ...
if (
regularHeaders.HasChild () &&
acceptedHeaders.HasChild ()
) {
//
regularHeaders = regularHeaders
.Where (rhr => acceptedHeaders
.Contains (rhr.Key)
);
}
}
foreach (var header in regularHeaders) {
//
SendLog ($"Adding Header: {header.Key}:{header.Value} ...");
//
message.Headers.Add (
header.Key,
header.Value
.ToString ()
);
}
//
// Handle ForWarded Headers ...
// Since Forward Headers is Custom kind, this means user actually need this
// Header, so there is no need to put them on AcceptedHeaders ...
var forwardHeaders = context.Request.Headers
.Where (hr => hr.Key
.Contains (
XProxyConstants.XPROXY_FORWARD_HEADER
)
);
foreach (var header in forwardHeaders) {
//
var key = header.Key
.Replace (
XProxyConstants.XPROXY_FORWARD_HEADER,
string.Empty
);
//
SendLog ($"Forwarding Header: {header.Key} to {key} ...");
//
message.Headers
.Add (
key,
header.Value
.ToString ()
);
}
}
/// <summary>
/// Retreive and Extract Method Type of HttpRequest ...
/// </summary>
/// <param name="method"></param>
/// <returns></returns>
private static HttpMethod GetMethod (string method) {
//
if (HttpMethods.IsDelete (method)) {
return HttpMethod.Delete;
} else if (HttpMethods.IsGet (method)) {
return HttpMethod.Get;
} else if (HttpMethods.IsHead (method)) {
return HttpMethod.Head;
} else if (HttpMethods.IsOptions (method)) {
return HttpMethod.Options;
} else if (HttpMethods.IsPost (method)) {
return HttpMethod.Post;
} else if (HttpMethods.IsPut (method)) {
return HttpMethod.Put;
} else if (HttpMethods.IsTrace (method)) {
return HttpMethod.Trace;
}
//
return new HttpMethod (method);
}
/// <summary>
/// add all headers exists in HttpResponse MEssage to Current Context Response Headers ...
/// </summary>
/// <param name="context"></param>
/// <param name="message"></param>
private void HandleResponseHeaders (
HttpContext context,
HttpResponseMessage message
) {
//
// Handle Message Headers ...
foreach (var header in message.Headers) {
context.Response.Headers[header.Key] = header.Value
.ToArray ();
}
//
// Handle Message Content Headers ...
foreach (var header in message.Content.Headers) {
context.Response.Headers[header.Key] = header.Value
.ToArray ();
}
//
context.Response.Headers.Remove ("transfer-encoding");
}
/// <summary>
/// Processing Response Content and Handle it on HttpContextResponse ...
/// </summary>
/// <param name="context"></param>
/// <param name="response"></param>
/// <returns></returns>
private async Task ProcessResponseContent (
HttpContext context,
HttpResponseMessage message
) {
//
// Reading Content as Byte Array ...
var contentBytes = await message.Content
.ReadAsByteArrayAsync ();
//
// Check ContentType of Response ...
if (
IsContentOfType (message, XResponseContentTypes.HTML) ||
IsContentOfType (message, XResponseContentTypes.JSON) ||
IsContentOfType (message, XResponseContentTypes.JavaScript)
) {
//
// If their String Content ...
var stringContent = Encoding.UTF8.GetString (contentBytes);
//
// TODO: here we can change String Contents ...
//
// Writing new Content to Response ...
await context.Response
.WriteAsync (
stringContent,
Encoding.UTF8
);
} else {
//
// if they have non string content ...
await context.Response.Body
.WriteAsync (
buffer: contentBytes,
offset: 0,
count: contentBytes.Length
);
}
//
SendLog ($"Response Content Processed ...", LogLevel.Information);
}
/// <summary>
/// Check Content Type of Specific Response ...
/// </summary>
/// <param name="response"></param>
/// <param name="type"></param>
/// <returns></returns>
private bool IsContentOfType (
HttpResponseMessage response,
string type
) {
//
// Create EMpty Result ...
var result = false;
//
// Retrieve and Check Content Type of Response ...
if (response.Content?.Headers?.ContentType != null) {
result = response.Content.Headers.ContentType.MediaType == type;
}
//
return result;
}
/// <summary>
/// Retrieve and Extract Route Descriptor ...
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
private XProxyRouteDescriptor GetRouteDescriptor (HttpRequest request) {
//
// Validate Args ...
if (
CONFIGURATION.IsNull () ||
!CONFIGURATION.Routes.HasChild ()
) {
return null;
}
//
var result = CONFIGURATION.Routes
.FirstOrDefault (rd => !rd.Route.IsNullOrEmpty () &&
request.Path
.StartsWithSegments (rd.Route
.ToNormalString ()
)
);
//
return result;
}
#endregion
}
/// <summary>
/// Provide all requirements for Dependency Injection Handler ...
/// </summary>
public static class XDIHelperExtension {
/// <summary>
/// Retrieve XProxy Middelware Configuration from Configuration ...
/// </summary>
/// <param name="config"></param>
/// <returns></returns>
public static XProxyConfiguration GetXProxyConfiguration (this IConfiguration config) {
//
var xProxyConfiguration = config.GetSection (ConfigurationNodeNames.XPROXY_CONFIGURATION_NODE_NAME);
return xProxyConfiguration.Get<XProxyConfiguration> ();
}
/// <summary>
/// Register HTTP Handler for XProxy Server ...
/// </summary>
/// <param name="services"></param>
/// <param name="configuration"></param>
/// <param name="httpHandler"></param>
public static void AddXProxyHttpHandler (
this IServiceCollection services,
IConfiguration configuration,
HttpClientHandler httpHandler = null
) {
//
var proxyConfig = configuration.GetXProxyConfiguration ();
if (proxyConfig.IsNull ()) {
throw XException.InvalidConfiguration.ToException ();
}
//
services.AddXProxyHttpHandler (
httpHandler: httpHandler,
configuration: proxyConfig
);
}
/// <summary>
/// Register HTTP Handler for XProxy Server ...
/// </summary>
/// <param name="services"></param>
/// <param name="configuration"></param>
/// <param name="httpHandler"></param>
public static void AddXProxyHttpHandler (
this IServiceCollection services,
XProxyConfiguration configuration,
HttpClientHandler httpHandler = null
) {
//
if (configuration.IsNull ()) {
throw XException.InvalidConfiguration.ToException ();
}
//
if (httpHandler.IsNull ()) {
httpHandler = new HttpClientHandler ();
}
//
httpHandler.AllowAutoRedirect = configuration.AllowAutoRedirect;
//
if (configuration.DisableSSLCheck) {
httpHandler.ServerCertificateCustomValidationCallback = (sender, certificate, chain, sslPolicyErrors) => true;
}
//
services
.AddHttpClient (XProxyConstants.XPROXY_HTTP_CLIENT)
.ConfigurePrimaryHttpMessageHandler (() => {
return httpHandler;
});
}
/// <summary>
/// Register XProxy On Server ...
/// </summary>
/// <param name="services"></param>
/// <param name="configuration"></param>
/// <param name="httpHandler"></param>
public static void AddXProxyServer (
this IServiceCollection services,
IConfiguration configuration,
HttpClientHandler httpHandler = null
) {
//
var proxyConfig = configuration.GetXProxyConfiguration ();
//
services.AddXProxyServer (
httpHandler: httpHandler,
configuration: proxyConfig
);
}
/// <summary>
/// Register XProxy On Server ...
/// </summary>
/// <param name="services"></param>
/// <param name="configuration"></param>
/// <param name="httpHandler"></param>
public static void AddXProxyServer (
this IServiceCollection services,
XProxyConfiguration configuration,
HttpClientHandler httpHandler = null
) {
//
// Validate Args ...
if (configuration.IsNull ()) {
throw XException.InvalidConfiguration.ToException ();
}
//
// Register Proxy Configuration ...
services.AddSingleton<XProxyConfiguration> (configuration);
//
// Regiter Proxy Handler ...
services.AddXProxyHttpHandler (
httpHandler: httpHandler,
configuration: configuration
);
}
/// <summary>
/// Register XProxy On Server ...
/// </summary>
/// <param name="services"></param>
/// <param name="configuration"></param>
public static void AddXProxyClient (
this IServiceCollection services,
IConfiguration configuration
) {
//
var proxyConfig = configuration.GetXProxyConfiguration ();
//
services.AddXProxyClient (
configuration: proxyConfig
);
}
/// <summary>
/// Register XProxy On Client ...
/// </summary>
/// <param name="services"></param>
/// <param name="configuration"></param>
public static void AddXProxyClient (
this IServiceCollection services,
XProxyConfiguration configuration
) {
//
// Validate Args ...
if (configuration.IsNull ()) {
throw XException.InvalidConfiguration.ToException ();
}
//
// Register Proxy Configuration ...
services.AddSingleton<XProxyConfiguration> (configuration);
//
// Register IXProxyHelper ...
services.AddSingleton<IXProxyHelper, XProxyHelper> ();
}
/// <summary>
/// Adding XProxy Middleware to Applications ...
/// </summary>
/// <param name="app"></param>
public static void UseXProxy (this IApplicationBuilder app) {
app.UseMiddleware<XProxyMiddleware> ();
}
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Models\XBaseRestResponse.cs
using RestSharp;
namespace xIdentityService.Models
{
public class XBaseRestResponse<T>
{
public T Model { get; set; }
public IRestResponse Response { get; set; }
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Partial\XIdentityProvider+Admin.cs
using System.Collections.Generic;
using System.Threading.Tasks;
using xCommons.Extensions;
using xHttpService.Constants;
using xIdentityModels.Dtos;
using xIdentityModels.Models;
using xIdentityService.Constants;
namespace xIdentityService.Providers {
public partial class XIdentityProvider {
//
#region Admin ...
/// <summary>
/// Ban Specific Users
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="model">an instance of <see>XUserNameIdRequest</see> which represents user identifier list to Ban</param>
/// <returns>a list of banned users identifiers</returns>
public async Task<IEnumerable<string>> Ban (
XTokenResponse tokens,
XUserNameIdRequest model
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (
tokens,
model
)
.AddNotEmpty (tokens.AccessToken)
.AddNotZeroChilds (model.Ids)
.ValidateGroupAsync ();
//
var client = GetRestClient (tokens);
//
var request = GetRestRequet (XApiAccountEndpoint.Ban);
request.AddJsonBody (model);
//
var response = await RunRestRequest<IEnumerable<string>> (
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// UnBann Specific Users
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="model">an instance of <see>XUserNameIdRequest</see> which represents user identifier list to Ban</param>
/// <returns>a list of unbanned users identifiers</returns>
public async Task<IEnumerable<string>> UnBan (
XTokenResponse tokens,
XUserNameIdRequest model
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (
tokens,
model
)
.AddNotEmpty (tokens.AccessToken)
.AddNotZeroChilds (model.Ids)
.ValidateGroupAsync ();
//
var client = GetRestClient (tokens);
//
var request = GetRestRequet (XApiAccountEndpoint.UnBan);
request.AddJsonBody (model);
//
var response = await RunRestRequest<IEnumerable<string>> (
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// Check Specific User is Banned or not
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="userSelectByParam">specified user's identifier</param>
/// <returns>a boolean value which represent user banned or not</returns>
public async Task<bool> IsBanned (
XTokenResponse tokens,
string userSelectByParam
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (tokens)
.AddNotEmpty (
userSelectByParam,
tokens.AccessToken
)
.ValidateGroupAsync ();
//
var client = GetRestClient (tokens);
//
var request = GetRestRequet (
XApiAccountEndpoint.IsBanned,
@params : new Dictionary<string, string> { { XParam.XUserSelectByParam.GetStringValue (), userSelectByParam } }
);
//
var response = await RunRestRequest<bool> (
client,
request,
XHttpMethod.GET
);
return response;
}
#endregion
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Partial\XIdentityProvider+Authentication.cs
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using IdentityModel.Client;
using xCommons.Extensions;
using xExceptions.Constants;
using xHttpService.Constants;
using xIdentityModels.Extensions;
using xIdentityModels.Models;
using xIdentityService.Constants;
namespace xIdentityService.Providers {
public partial class XIdentityProvider {
//
#region Authentication Handlers ...
/// <summary>
/// Request for Discovery Document
/// </summary>
/// <returns>an instance of DiscoveryDocumentResponse</returns>
public async Task<DiscoveryDocumentResponse> RequestDiscoveryDocument () {
//
var httpClient = GetHttpClient ();
//
try {
//
var result = httpClient
.GetDiscoveryDocumentAsync (identityConfiguration.Authority)
.ContinueWith (docTask => {
//
httpClient.Dispose ();
return docTask.Result;
});
//
return await result;
} catch {
throw XException.ActionFailed.ToException ();
}
}
/// <summary>
/// Request AccessToken for Specific XApiScope
/// </summary>
/// <param name="scope">a member of <see>XApiScope</see></param>
/// <returns>an instance of <see>XTokenResponse</see></returns>
public async Task<XTokenResponse> RequestScopeAccessToken (string scope) {
//
// Validate Args ...
var scopeName = string.Empty;
try {
scopeName = scope; // scope.GetStringValue ();
} catch { }
if (scopeName.IsNullOrEmpty ()) {
XException.InvalidArgs.Throw ();
}
//
var client = GetRestClient ();
var request = GetRestRequet (
XApiAccountEndpoint.RequestScopeAccessToken,
headers : new Dictionary<string, string> { { XParam.XScope.GetStringValue (), scope.ToString () } });
//
var response = await RunRestRequest<XTokenResponse> (
client,
request,
XHttpMethod.POST
);
//
// Save Token ...
if (!response.IsNull ()) {
await tokenProvider.AddOrUpdateToken (response);
}
//
return response;
}
/// <summary>
/// Validate a token
/// </summary>
/// <param name="model">Authentication Tokens</param>
/// <returns>an instance of TokenIntrospectionResponse</returns>
public async Task<TokenIntrospectionResponse> Introspection (XTokenResponse model) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (model)
.AddNotEmpty (model.AccessToken)
.ValidateGroupAsync ();
//
var httpClient = GetHttpClient ();
//
try {
//
var discoDoc = await RequestDiscoveryDocument ();
if (discoDoc.IsError) {
XException.ActionFailed.Throw ();
}
//
var response = await httpClient.IntrospectTokenAsync (new TokenIntrospectionRequest {
//
Address = discoDoc.IntrospectionEndpoint,
ClientId = identityConfiguration.ClientId,
ClientSecret = identityConfiguration.ClientSecret,
//
Token = model.AccessToken
});
if (response.IsError) {
throw new Exception (response.Error);
}
//
return response;
} catch {
throw XException.ActionFailed.ToException ();
}
}
/// <summary>
/// Authenticate a User
/// </summary>
/// <param name="model">User Login Required Info, an instance of <see>XLoginRequest</see></param>
/// <returns>an instance of <see>XTokenResponse</see></returns>
public async Task<XTokenResponse> Authenticate (XLoginRequest model) {
//
// Validate Args ...
validationProvider
.GroupValidationBuilder ()
.AddNotNull (model)
.AddNotEmpty (
model.UserSelectBy,
model.Password
)
.ValidateGroup ();
//
var client = GetRestClient ();
var request = GetRestRequet (XApiAccountEndpoint.Authenticate);
request.AddJsonBody (model);
//
var response = await RunRestRequest<XTokenResponse> (
client,
request,
XHttpMethod.POST
);
//
// Save Token ...
if (!response.IsNull ()) {
await tokenProvider.AddOrUpdateToken (response);
}
//
return response;
}
/// <summary>
/// Do Login based on XLoginRequest
/// </summary>
/// <param name="model">User Login Required Info, an instance of <see>XLoginRequest</see></param>
/// <returns>an instance of <see>XTokenResponse</see></returns>
public async Task<XLoginResponse> Login (XLoginRequest model) {
//
// Validate Args ...
validationProvider
.GroupValidationBuilder ()
.AddNotNull (model, model.Device)
.AddNotEmpty (
model.UserSelectBy,
model.Password
)
.ValidateGroup ();
//
var client = GetRestClient ();
var request = GetRestRequet (XApiAccountEndpoint.Login);
request.AddJsonBody (model);
//
var response = await RunRestRequest<XLoginResponse> (
client,
request,
XHttpMethod.POST
);
//
if (!response.IsNull ()) {
//
var tokens = response.ToXTokenResponse ();
await tokenProvider.AddOrUpdateToken (tokens);
}
//
return response;
}
/// <summary>
/// Logout from System
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task Logout (XTokenResponse model) {
//
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (model)
.AddNotEmpty (model.AccessToken)
.ValidateGroupAsync ();
//
var isExists = await tokenProvider
.IsTokenExists (model.AccessToken);
if (isExists) {
await tokenProvider
.RemoveToken (model.AccessToken);
}
}
/// <summary>
/// Refresh Tokens
/// </summary>
/// <param name="model">Authentication Tokens</param>
/// <returns>an instance of <see>XTokenResponse</see></returns>
public async Task<XTokenResponse> RefreshTokens (XTokenResponse model) {
//
// Validate Args ...
validationProvider
.GroupValidationBuilder ()
.AddNotNull (model)
.AddNotEmpty (
model.AccessToken,
model.RefreshToken
)
.ValidateGroup ();
//
var client = GetRestClient (model);
//
var request = GetRestRequet (
XApiAccountEndpoint.RefreshTokens,
headers : model.ToHeaderDictionary ());
request.AddJsonBody (model);
//
var response = await RunRestRequest<XTokenResponse> (
client,
request,
XHttpMethod.POST
);
if (!response.IsNull ()) {
await tokenProvider.UpdateToken (response);
}
//
return response;
}
#endregion
//
#region Password Actions Handlers ...
/// <summary>
/// Change Password
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
/// <returns></returns>
public async Task ChangePassword (
XTokenResponse tokens,
XActionRequest model
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (tokens, model)
.AddNotEmpty (
model.Lang,
model.Password,
model.NewPassword,
model.ReturnUrl)
.AddNotNull (model.Device)
.ValidateGroupAsync ();
//
// Validate User Select By Param ...
var userSelectByParam = GetUserSelectByParam (
model,
forceNotNull : true,
excludes : null);
//
var client = GetRestClient (tokens);
var request = GetRestRequet (
XApiAccountEndpoint.ChangePassword,
headers : tokens.ToHeaderDictionary ());
request.AddJsonBody (model);
//
var response = await RunRestRequest<Object> (
client,
request,
XHttpMethod.POST
);
}
#endregion
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Partial\XIdentityProvider+Friendship.cs
using System.Collections.Generic;
using System.Threading.Tasks;
using xCommons.Extensions;
using xHttpService.Constants;
using xHttpService.Extensions;
using xIdentityModels.Constants;
using xIdentityModels.Dtos;
using xIdentityModels.Models;
using xIdentityModels.Navigations;
using xIdentityService.Constants;
using xModels.Dtos;
namespace xIdentityService.Providers
{
public partial class XIdentityProvider
{
//
#region Friendship ...
/// <summary>
/// Follow a User
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="destUser">a user identifier which represent destination user</param>
/// <returns>an instance of <see>XFriendshipFollowing</see></returns>
public async Task<XFriendshipFollowing> Follow(
XTokenResponse tokens,
string destUser
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(
destUser,
tokens.AccessToken
)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(
XApiAccountEndpoint.Follow,
@params: new Dictionary<string, string> { { XParam.XDestUser.GetStringValue (), destUser }
}
);
//
var response = await RunRestRequest<XFriendshipFollowing>(
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// Cancel Following Request
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="destUser">a user identifier which represent destination user</param>
/// <returns>a boolean value</returns>
public async Task<bool> Cancel(
XTokenResponse tokens,
string destUser
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(
destUser,
tokens.AccessToken
)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(
XApiAccountEndpoint.Cancel,
@params: new Dictionary<string, string> { { XParam.XDestUser.GetStringValue (), destUser }
}
);
//
var response = await RunRestRequest<bool>(
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// Unfollow a Follower
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="destUser">a user identifier which represent destination user</param>
/// <returns></returns>
public async Task UnFollowFollower(
XTokenResponse tokens,
string destUser
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(
destUser,
tokens.AccessToken
)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(
XApiAccountEndpoint.UnFollowFollower,
@params: new Dictionary<string, string> { { XParam.XDestUser.GetStringValue (), destUser }
}
);
//
var response = await RunRestRequest<object>(
client,
request,
XHttpMethod.POST
);
}
/// <summary>
/// Unfollow Following
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="destUser">a user identifier which represent destination user</param>
/// <returns></returns>
public async Task UnFollowFollowing(
XTokenResponse tokens,
string destUser
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(
destUser,
tokens.AccessToken
)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(
XApiAccountEndpoint.UnFollowFollowing,
@params: new Dictionary<string, string> { { XParam.XDestUser.GetStringValue (), destUser }
}
);
//
var response = await RunRestRequest<object>(
client,
request,
XHttpMethod.POST
);
}
/// <summary>
/// Block a Follower
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="destUser">a user identifier which represent destination user</param>
/// <returns>an instance of <see>XFriendshipFollowing</see></returns>
public async Task<XFriendshipFollowing> Block(
XTokenResponse tokens,
string destUser
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(
destUser,
tokens.AccessToken
)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(
XApiAccountEndpoint.Block,
@params: new Dictionary<string, string> { { XParam.XDestUser.GetStringValue (), destUser }
}
);
//
var response = await RunRestRequest<XFriendshipFollowing>(
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// Unblock a Blocked User
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="destUser">a user identifier which represent destination user</param>
/// <returns>an instance of <see>XFriendshipFollowing</see></returns>
public async Task<XFriendshipFollowing> UnBlock(
XTokenResponse tokens,
string destUser
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(
destUser,
tokens.AccessToken
)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(
XApiAccountEndpoint.UnBlock,
@params: new Dictionary<string, string> { { XParam.XDestUser.GetStringValue (), destUser }
}
);
//
var response = await RunRestRequest<XFriendshipFollowing>(
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// Accept a Following Request
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="destUser">a user identifier which represent destination user</param>
/// <returns>an instance of <see>XFriendshipFollower</see></returns>
public async Task<XFriendshipFollower> AcceptRequest(
XTokenResponse tokens,
string destUser
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(
destUser,
tokens.AccessToken
)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(
XApiAccountEndpoint.AcceptRequest,
@params: new Dictionary<string, string> { { XParam.XDestUser.GetStringValue (), destUser }
}
);
//
var response = await RunRestRequest<XFriendshipFollower>(
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// Reject a Following Request
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="destUser">a user identifier which represent destination user</param>
/// <returns>an instance of <see>XFriendshipFollower</see></returns>
public async Task<XFriendshipFollower> RejectRequest(
XTokenResponse tokens,
string destUser
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(
destUser,
tokens.AccessToken
)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(
XApiAccountEndpoint.RejectRequest,
@params: new Dictionary<string, string> { { XParam.XDestUser.GetStringValue (), destUser }
}
);
//
var response = await RunRestRequest<XFriendshipFollower>(
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// Get Friendship Info Model between Specific User and Current User
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="destUser">a user identifier which represent destination user</param>
/// <returns>an instance of <see>XFriendshipInfoDto</see></returns>
public async Task<XFriendshipInfoDto> GetFriendshipInfo(
XTokenResponse tokens,
string destUser
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(
destUser,
tokens.AccessToken
)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(
XApiAccountEndpoint.FriendshipInfo,
@params: new Dictionary<string, string> { { XParam.XDestUser.GetStringValue (), destUser }
}
);
//
var response = await RunRestRequest<XFriendshipInfoDto>(
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Check a User IsFollower of Requested User
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="destUser">a user identifier which represent destination user</param>
/// <returns>a boolean value</returns>
public async Task<bool> IsFollower(
XTokenResponse tokens,
string destUser
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(
destUser,
tokens.AccessToken
)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(
XApiAccountEndpoint.IsFollower,
@params: new Dictionary<string, string> { { XParam.XDestUser.GetStringValue (), destUser }
}
);
//
var response = await RunRestRequest<bool>(
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Get Specific Follower
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="destUser">a user identifier which represent destination user</param>
/// <returns>an instance of <see>XFriendshipFollower</see></returns>
public async Task<XFriendshipFollower> GetFollower(
XTokenResponse tokens,
string destUser
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(
destUser,
tokens.AccessToken
)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(
XApiAccountEndpoint.Follower,
@params: new Dictionary<string, string> { { XParam.XDestUser.GetStringValue (), destUser }
}
);
//
var response = await RunRestRequest<XFriendshipFollower>(
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Get Follower State of a User
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="destUser">a user identifier which represent destination user</param>
/// <returns>an instance of <see>XFriendshipState</see></returns>
public async Task<XFriendshipState> GetFollowerState(
XTokenResponse tokens,
string destUser
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(
destUser,
tokens.AccessToken
)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(
XApiAccountEndpoint.FollowerState,
@params: new Dictionary<string, string> { { XParam.XDestUser.GetStringValue (), destUser }
}
);
//
var response = await RunRestRequest<XFriendshipState>(
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Get Followers List Of Current User
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <returns>a collection of <see>XFriendshipFollower</see></returns>
public async Task<IEnumerable<XFriendshipFollower>> GetFollowers(
XTokenResponse tokens
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(tokens.AccessToken)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(XApiAccountEndpoint.Followers);
//
var response = await RunRestRequest<IEnumerable<XFriendshipFollower>>(
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Get All Followers List Includes Blocked, Requested and etc
/// of Current User
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <returns>a collection of <see>XFriendshipFollower</see></returns>
public async Task<IEnumerable<XFriendshipFollower>> GetAllFollowers(
XTokenResponse tokens
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(tokens.AccessToken)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(XApiAccountEndpoint.AllFollowers);
//
var response = await RunRestRequest<IEnumerable<XFriendshipFollower>>(
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Return Followers UserName's List of Current User
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <returns>a collection of UserNames</returns>
public async Task<IEnumerable<string>> GetFollowersList(
XTokenResponse tokens
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(tokens.AccessToken)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(XApiAccountEndpoint.FollowersList);
//
var response = await RunRestRequest<IEnumerable<string>>(
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Retrieve All User's Followers based on Query Model ...
/// </summary>
/// <param name="query">Query Model Descriptor</param>
/// <param name="destUser">Dest User for Reading Followers</param>
/// <param name="tokens">Requester User's Descriptor</param>
/// <returns></returns>
public async Task<XQueryResult<XFriendDto>> QueryFollowers(
XQuery query,
string destUser,
XTokenResponse tokens
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(destUser)
.AddNotEmpty(tokens.AccessToken)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(XApiAccountEndpoint.QueryFollowers);
//
// Attach XQuery to Request ...
request = request.AttachXQuery(query);
request = request.AttachDestUser(destUser);
//
var response = await RunRestRequest<XQueryResult<XFriendDto>>(
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Check a User is in Followings of Current User
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="destUser">a user identifier which represent destination user</param>
/// <returns>a boolean value</returns>
public async Task<bool> IsFollowing(
XTokenResponse tokens,
string destUser
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(
destUser,
tokens.AccessToken
)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(
XApiAccountEndpoint.IsFollowing,
@params: new Dictionary<string, string> { { XParam.XDestUser.GetStringValue (), destUser }
}
);
//
var response = await RunRestRequest<bool>(
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Get Specific Following Model
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="destUser">a user identifier which represent destination user</param>
/// <returns>an instance of <see>XFriendshipFollowing</see></returns>
public async Task<XFriendshipFollowing> GetFollowing(
XTokenResponse tokens,
string destUser
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(
destUser,
tokens.AccessToken
)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(
XApiAccountEndpoint.Following,
@params: new Dictionary<string, string> { { XParam.XDestUser.GetStringValue (), destUser }
}
);
//
var response = await RunRestRequest<XFriendshipFollowing>(
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Get Following State Relation between Specific User
/// and Current User
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="destUser">a user identifier which represent destination user</param>
/// <returns>an instance of <see>XFriendshipState</see></returns>
public async Task<XFriendshipState> GetFollowingState(
XTokenResponse tokens,
string destUser
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(
destUser,
tokens.AccessToken
)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(
XApiAccountEndpoint.FollowingState,
@params: new Dictionary<string, string> { { XParam.XDestUser.GetStringValue (), destUser }
}
);
//
var response = await RunRestRequest<XFriendshipState>(
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Get Followings of Current User
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <returns>a collection of <see>XFriendshipFollowing</see></returns>
public async Task<IEnumerable<XFriendshipFollowing>> GetFollowings(
XTokenResponse tokens
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(tokens.AccessToken)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(XApiAccountEndpoint.Followings);
//
var response = await RunRestRequest<IEnumerable<XFriendshipFollowing>>(
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Get All Following List Includes Blocked, Requested and etc
/// of Current User
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <returns>a collection of <see>XFriendshipFollowing</see></returns>
public async Task<IEnumerable<XFriendshipFollowing>> GetAllFollowings(
XTokenResponse tokens
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(tokens.AccessToken)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(XApiAccountEndpoint.AllFollowings);
//
var response = await RunRestRequest<IEnumerable<XFriendshipFollowing>>(
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Return Following UserName's List of Current User
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <returns>a collection of UserNames</returns>
public async Task<IEnumerable<string>> GetFollowingList(
XTokenResponse tokens
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(tokens.AccessToken)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(XApiAccountEndpoint.FollowingsList);
//
var response = await RunRestRequest<IEnumerable<string>>(
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Retrieve All User's Followings based on Query Model ...
/// </summary>
/// <param name="query">Query Model Descriptor</param>
/// <param name="destUser">Dest User for Reading Followers</param>
/// <param name="tokens">Requester User's Descriptor</param>
/// <returns></returns>
public async Task<XQueryResult<XFriendDto>> QueryFollowings(
XQuery query,
string destUser,
XTokenResponse tokens
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens)
.AddNotEmpty(destUser)
.AddNotEmpty(tokens.AccessToken)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(XApiAccountEndpoint.QueryFollowings);
//
// Attach XQuery to Request ...
request = request.AttachXQuery(query);
request = request.AttachDestUser(destUser);
//
var response = await RunRestRequest<XQueryResult<XFriendDto>>(
client,
request,
XHttpMethod.GET
);
return response;
}
#endregion
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Partial\XIdentityProvider+Open.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
using MongoDB.Bson;
using xCommons.Constants;
using xCommons.Extensions;
using xExceptions.Constants;
using xHttpService.Constants;
using xIdentityModels.Dtos;
using xIdentityService.Constants;
using xModels.Dtos;
namespace xIdentityService.Providers
{
public partial class XIdentityProvider
{
/// <summary>
/// Prepare API Based Device to Open Actions ...
/// </summary>
/// <returns></returns>
public XDeviceDto GetDevice()
{
//
var os = "XSaherElmOS";
bool isOSX = RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
bool isLinux = RuntimeInformation.IsOSPlatform(OSPlatform.Linux);
bool isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
if (isOSX)
{
os = "MacOs";
}
else if (isLinux)
{
os = "Linux";
}
else if (isWindows)
{
os = "Windows";
}
var agent = RuntimeInformation.FrameworkDescription;
if (agent.IsNullOrEmpty())
{
agent = "XSaherElmOSAgent";
}
var version = RuntimeInformation.OSArchitecture + ", " + RuntimeInformation.OSDescription;
if (version.IsNullOrEmpty())
{
version = "XSaherElmOSVersion";
}
var browser = "XSaherElmBrowser_" + RevisionSecretKey.ToMd5String();
//
var result = new XDeviceDto
{
Os = os,
Browser = browser,
UserAgent = agent,
OsVersion = version,
DeviceType = XDeviceType.Desktop,
};
//
return result;
}
//
#region OpenGet ...
public async Task<XOpenActionInnerDto> OpenGet(
XOpenActionInnerDto model
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(model)
.AddNotEmpty(model.Token)
.AddNotEmpty(model.Payload)
.ValidateGroupAsync();
//
var result = await OpenGet(
token: model.Token,
actionRequest: model.Payload
);
//
return result;
}
public async Task<XOpenActionInnerDto> OpenGet(
string token,
string actionRequest
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotEmpty(token)
.AddNotEmpty(actionRequest)
.ValidateGroupAsync();
//
// Retrieve Rest Client ...
var client = GetRestClient();
//
// Prepare Rest Request ...
var request = GetRestRequet(
XApiAccountEndpoint.Open,
headers: new Dictionary<string, string>
{
{ XAuthentication.TOKEN, token}
},
queryStrings: new Dictionary<string, string>
{
{ XParam.XRequest.GetStringValue(), actionRequest }
}
);
//
// Run Request and Retrieve Response ...
var response = await RunRestRequestByResponse<string>(
client,
request,
XHttpMethod.GET
);
//
// Now we Have to Validate the recieved response ...
//
// Read token from Headers ...
var responseToken = response.Response.Headers
.First(h => h.Name == XAuthentication.TOKEN).Value.ToString();
if (responseToken.IsNullOrEmpty())
{
XException.ActionFailed.Throw();
}
//
// Decript Recieve Response ...
var responseJson = response.Model; // SecurityProvider.Decrypt(response.Model);
if (responseJson.IsNullOrEmpty())
{
XException.ActionFailed.Throw();
}
//
var result = new XOpenActionInnerDto
{
Token = responseToken,
Payload = responseJson
};
//
// Retrieve Model and Validate it ...
var responseModel = responseJson.FromJSON<XOpenActionRequestDto>();
if (responseModel.IsNull() ||
responseModel.Payload.IsNullOrEmpty() ||
responseToken != responseModel.Checksum ||
responseModel.Timestamp.FromTimestamp().IsExPired())
{
XException.ActionFailed.Throw();
}
//
return result;
}
#endregion
//
#region GetUserInfo ...
public async Task<XOpenActionUserInfoDto> GetUserInfo(
XDeviceDto device,
string userSelectByParam
)
{
//
// Validate Args ...
validationProvider.NotNull(device);
validationProvider.NotEmpty(userSelectByParam);
//
// Prepare Open Action Model ...
var opaModel = new XOpenActionRequestDto
{
Device = device,
Payload = userSelectByParam,
Action = XOpenActions.GetUserInfo,
Timestamp = DateTime.UtcNow.AddMinutes(5).ToTimestamp().ToString()
};
if (!opaModel.Validate())
{
XException.InvalidArgs.Throw();
}
//
// Fill Checksum Filed ...
var token = opaModel.ToOpenActionToken();
opaModel.Checksum = token;
//
// Prepare Request ...
var opaJson = opaModel.ToJson();
var requestString = SecurityProvider.Encrypt(opaJson);
//
return await GetUserInfo(
token: token,
request: requestString
);
}
public async Task<XOpenActionUserInfoDto> GetUserInfo(
XOpenActionInnerDto dto
)
{
//
return await GetUserInfo(
token: dto.Token,
request: dto.Payload
);
}
public async Task<XOpenActionUserInfoDto> GetUserInfo(
string token,
string request
)
{
//
// Validate Args ...
validationProvider.NotEmpty(token);
validationProvider.NotEmpty(request);
//
// Retrieve and Validate Response ...
var response = await OpenGet(
token: token,
actionRequest: request
);
if (response.IsNull() ||
response.Token.IsNullOrEmpty() ||
response.Payload.IsNullOrEmpty())
{
XException.ActionFailed.Throw();
}
//
// Now we Have to Converts Repose Payload to Result Model ...
// Note that the respose Model's payload here is Decrypted and
// actually is Json Representation of Result Model ...
var requestModel = response.Payload.FromJSON<XOpenActionRequestDto>();
if (requestModel.IsNull())
{
XException.ActionFailed.Throw();
}
//
var resultJson = SecurityProvider.Decrypt(requestModel.Payload);
var result = resultJson.FromJSON<XOpenActionUserInfoDto>();
if (result.IsNull())
{
XException.NotFound.Throw();
}
//
return result;
}
#endregion
//
#region GetUserInfos ...
public async Task<IEnumerable<XOpenActionUserInfoDto>> GetUserInfos(
XDeviceDto device,
string ids
)
{
//
// Validate Args ...
validationProvider.NotNull(device);
validationProvider.NotEmpty(ids);
//
// Prepare Open Action Model ...
var opaModel = new XOpenActionRequestDto
{
Payload = ids,
Device = device,
Action = XOpenActions.GetUserInfos,
Timestamp = DateTime.UtcNow.AddMinutes(5).ToTimestamp().ToString()
};
if (!opaModel.Validate())
{
XException.InvalidArgs.Throw();
}
//
// Fill Checksum Filed ...
var token = opaModel.ToOpenActionToken();
opaModel.Checksum = token;
//
// Prepare Request ...
var opaJson = opaModel.ToJson();
var requestString = SecurityProvider.Encrypt(opaJson);
//
return await GetUserInfos(
token: token,
request: requestString
);
}
public async Task<IEnumerable<XOpenActionUserInfoDto>> GetUserInfos(
XOpenActionInnerDto dto
)
{
//
return await GetUserInfos(
token: dto.Token,
request: dto.Payload
);
}
public async Task<IEnumerable<XOpenActionUserInfoDto>> GetUserInfos(
string token,
string request
)
{
//
// Validate Args ...
validationProvider.NotEmpty(token);
validationProvider.NotEmpty(request);
//
// Retrieve and Validate Response ...
var response = await OpenGet(
token: token,
actionRequest: request
);
if (response.IsNull() ||
response.Token.IsNullOrEmpty() ||
response.Payload.IsNullOrEmpty())
{
XException.ActionFailed.Throw();
}
//
// Now we Have to Converts Repose Payload to Result Model ...
// Note that the respose Model's payload here is Decrypted and
// actually is Json Representation of Result Model ...
var requestModel = response.Payload.FromJSON<XOpenActionRequestDto>();
if (requestModel.IsNull())
{
XException.ActionFailed.Throw();
}
//
var resultJson = SecurityProvider.Decrypt(requestModel.Payload);
var result = resultJson.FromJSON<IEnumerable<XOpenActionUserInfoDto>>();
if (result.IsNull())
{
XException.NotFound.Throw();
}
//
return result;
}
#endregion
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Partial\XIdentityProvider+Profile.cs
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using xCommons.Extensions;
using xHttpService.Constants;
using xHttpService.Extensions;
using xIdentityModels.Dtos;
using xIdentityModels.Models;
using xIdentityModels.Navigations;
using xIdentityService.Constants;
using xModels.Dtos;
namespace xIdentityService.Providers {
public partial class XIdentityProvider {
//
#region User Actions ...
/// <summary>
/// Retrieve User Names based on UserIds
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="ids">a comma seperated list of UserIds</param>
/// <returns>a collection of UserNames</returns>
public async Task<IEnumerable<string>> GetUserNames (
XTokenResponse tokens,
string ids
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (tokens)
.AddNotEmpty (ids, tokens.AccessToken)
.ValidateGroupAsync ();
//
var client = GetRestClient (tokens);
var request = GetRestRequet (
XApiAccountEndpoint.GetNames,
@params : new Dictionary<string, string> { { XParam.XIds.GetStringValue (), ids } }
);
//
var response = await RunRestRequest<IEnumerable<string>> (
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// get user ids and retrieve corresponding user names
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="model">an instance of <see>XUserNameIdRequest</see> which represent required UserIds collection</param>
/// <returns>a collection of <see>XUserNameIdResponse</see> instance</returns>
public async Task<IEnumerable<XUserNameIdResponse>> GetUserNameIds (
XTokenResponse tokens,
XUserNameIdRequest model
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (model, tokens)
.AddNotZeroChilds (model.Ids)
.AddNotEmpty (tokens.AccessToken)
.ValidateGroupAsync ();
//
var client = GetRestClient (tokens);
var request = GetRestRequet (XApiAccountEndpoint.GetNameIds);
request.AddJsonBody (model);
//
var response = await RunRestRequest<IEnumerable<XUserNameIdResponse>> (
client,
request,
XHttpMethod.POST
);
return response;
}
#endregion
//
#region Profile Actions ...
/// <summary>
/// Get Profile Object of Specific User
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="userSelectByParam">determine's which user profile must be retrieved</param>
/// <returns>an instance of <see>XUserProfileDto</see></returns>
public async Task<XUserProfileDto> GetUserProfile (
XTokenResponse tokens,
string userSelectByParam
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (tokens)
.AddNotEmpty (userSelectByParam, tokens.AccessToken)
.ValidateGroupAsync ();
//
var client = GetRestClient (tokens);
//
var request = GetRestRequet (
XApiAccountEndpoint.GetProfile,
@params : new Dictionary<string, string> { { XParam.XUserSelectByParam.GetStringValue (), userSelectByParam } }
);
//
var response = await RunRestRequest<XUserProfileDto> (
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Retrieve Users Based On Query
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="query">how to filter results based on <see>XQuery</see> structure</param>
/// <returns>an instance of <see>XQueryResult</see> of <see>XUserProfileDto</see></returns>
public async Task<XQueryResult<XUserProfileDto>> QueryUsers (
XTokenResponse tokens,
XQuery query
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (tokens, query)
.AddNotEmpty (tokens.AccessToken)
.ValidateGroupAsync ();
//
var client = GetRestClient (tokens);
//
var request = GetRestRequet (XApiAccountEndpoint.QueryProfiles);
//
// Attach XQuery to Request ...
request = request.AttachXQuery (query);
//
var response = await RunRestRequest<XQueryResult<XUserProfileDto>> (
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Retrieve Users Based On Query and Specified role
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="role">an string which represent user role</param>
/// <param name="query">how to filter results based on <see>XQuery</see> structure</param>
/// <param name="forceRole">if it's true the user must has exact role, otherwise top level users also listed</param>
/// <returns>an instance of <see>XQueryResult</see> of <see>XUserProfileDto</see></returns>
public async Task<XQueryResult<XUserProfileDto>> QueryInRoleUsers (
XTokenResponse tokens,
string role,
XQuery query,
bool forceRole = false
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (tokens, query)
.AddNotEmpty (tokens.AccessToken, role)
.ValidateGroupAsync ();
//
var client = GetRestClient (tokens);
//
var request = GetRestRequet (
XApiAccountEndpoint.QueryProfiles,
headers : new Dictionary<string, string> { { XParam.XRole.GetStringValue (), role },
{ XParam.XForceRole.GetStringValue (), forceRole.AsHttpParamString () }
}
);
//
// Attach XQuery to Request ...
request = request.AttachXQuery (query);
//
var response = await RunRestRequest<XQueryResult<XUserProfileDto>> (
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Query Specified User's Profile Images
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="userSelectByParam">determine's which user profile must be retrieved</param>
/// <param name="query">how to filter results based on <see>XQuery</see> structure</param>
/// <returns>an instance of <see>XQueryResult</see> of <see>XProfileImage</see></returns>
public async Task<XQueryResult<XProfileImage>> QueryAvatars (
XTokenResponse tokens,
string userSelectByParam,
XQuery query
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (tokens, query)
.AddNotEmpty (tokens.AccessToken, userSelectByParam)
.ValidateGroupAsync ();
//
var client = GetRestClient (tokens);
//
var request = GetRestRequet (
XApiAccountEndpoint.QueryAvatars,
@params : new Dictionary<string, string> { { XParam.XUserSelectByParam.GetStringValue (), userSelectByParam }
}
);
//
// Attach XQuery to Request ...
request = request.AttachXQuery (query);
//
var response = await RunRestRequest<XQueryResult<XProfileImage>> (
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Update User Profile based on <see>XProfileUpdateRequest</see> (FirstName/LastName/DateOfBirth)
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="userSelectByParam">determine's which user profile must be retrieved</param>
/// <param name="model">user update info, an instance of <see>XProfileUpdateRequest</see></param>
/// <returns>an instance of <see>XUserProfileDto</see></returns>
public async Task<XUserProfileDto> ProfileUpdateAsync (
XTokenResponse tokens,
string userSelectByParam,
XProfileUpdateRequest model
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (tokens, model)
.AddNotEmpty (tokens.AccessToken, userSelectByParam)
.ValidateGroupAsync ();
//
var client = GetRestClient (tokens);
//
var request = GetRestRequet (
XApiAccountEndpoint.UpdateProfile,
@params : new Dictionary<string, string> { { XParam.XUserSelectByParam.GetStringValue (), userSelectByParam }
}
);
request.AddJsonBody (model);
//
var response = await RunRestRequest<XUserProfileDto> (
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// Update a User Profile based on <see>XProfileUpdateRequest</see> Full
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="userSelectByParam">determine's which user profile must be retrieved</param>
/// <param name="model">user update info, an instance of <see>XProfileUpdateRequest</see></param>
/// <returns>an instance of <see>XUserProfileDto</see></returns>
public async Task<XUserProfileDto> FullProfileUpdateAsync (
XTokenResponse tokens,
string userSelectByParam,
XProfileUpdateRequest model
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (tokens, model)
.AddNotEmpty (tokens.AccessToken, userSelectByParam)
.ValidateGroupAsync ();
//
var client = GetRestClient (tokens);
//
var request = GetRestRequet (
XApiAccountEndpoint.FullUpdateProfile,
@params : new Dictionary<string, string> { { XParam.XUserSelectByParam.GetStringValue (), userSelectByParam }
}
);
request.AddJsonBody (model);
//
var response = await RunRestRequest<XUserProfileDto> (
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// Add a New Profile Image
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="file">an specific File to upload, <see>IFormFile</see></param>
/// <returns>an instance of <see>XUserProfileDto</see></returns>
public async Task<XUserProfileDto> AddAvatar (
XTokenResponse tokens,
IFormFile file
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (tokens, file)
.AddNotEmpty (tokens.AccessToken)
.ValidateGroupAsync ();
//
var client = GetRestClient (tokens);
//
var request = GetRestRequet (XApiAccountEndpoint.AddAvatar);
request.AlwaysMultipartFormData = true;
request.AddFileBytes (
XParam.XFile.GetStringValue (),
file.ToByteArray (),
file.FileName,
file.ContentType
);
//
var response = await RunRestRequest<XUserProfileDto> (
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// Add a New Collection of Profile Images
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="files">a collection of Files to upload, <see>IFormFileCollection</see></param>
/// <returns>an instance of <see>XUserProfileDto</see></returns>
public async Task<XUserProfileDto> AddAvatars (
XTokenResponse tokens,
IFormFileCollection files
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (tokens)
.AddNotZeroChilds (files)
.AddNotEmpty (tokens.AccessToken)
.ValidateGroupAsync ();
//
var client = GetRestClient (tokens);
//
var request = GetRestRequet (XApiAccountEndpoint.AddAvatars);
request.AlwaysMultipartFormData = true;
//
// Add Files ...
foreach (var file in files) {
//
// Add Single file ...
request.AddFileBytes (
XParam.XFiles.GetStringValue (),
file.ToByteArray (),
file.FileName,
file.ContentType
);
}
//
var response = await RunRestRequest<XUserProfileDto> (
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// set Specified Profile Image as Avatar
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="id">an integer which reperesent AvatarId to set as current Avatar</param>
/// <returns>an instance of <see>XUserProfileDto</see></returns>
public async Task<XUserProfileDto> SetAvatar (
XTokenResponse tokens,
int id
) {
//
// Validate Args ...
id.ValidateIntId ();
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (tokens)
.AddNotEmpty (tokens.AccessToken)
.ValidateGroupAsync ();
//
var client = GetRestClient (tokens);
//
var request = GetRestRequet (
XApiAccountEndpoint.SetAvatar,
@params : new Dictionary<string, string> { { XParam.XId.GetStringValue (), id.ToString () }
}
);
//
var response = await RunRestRequest<XUserProfileDto> (
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// Remove Profile Images
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="avatarIds">a comma seperated list of avatarIds to remove</param>
/// <returns>an instance of <see>XUserProfileDto</see></returns>
public async Task<XUserProfileDto> RemoveAvatars (
XTokenResponse tokens,
string avatarIds
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (tokens)
.AddNotEmpty (avatarIds, tokens.AccessToken)
.ValidateGroupAsync ();
//
var client = GetRestClient (tokens);
//
var request = GetRestRequet (
XApiAccountEndpoint.RemoveAvatars,
@params : new Dictionary<string, string> { { XParam.XIds.GetStringValue (), avatarIds }
}
);
//
var response = await RunRestRequest<XUserProfileDto> (
client,
request,
XHttpMethod.DELETE
);
return response;
}
#endregion
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Partial\XIdentityProvider+Registration.cs
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using xCommons.Extensions;
using xExceptions.Constants;
using xHttpService.Constants;
using xIdentityModels.Constants;
using xIdentityModels.Extensions;
using xIdentityModels.Models;
using xIdentityService.Constants;
namespace xIdentityService.Providers {
public partial class XIdentityProvider {
//
#region Registration ...
/// <summary>
/// Check a User Selector is Available for Registration or Not
/// </summary>
/// <param name="userSelectByParam">an string value which reperesent a user</param>
/// <returns>a boolean value</returns>
public async Task<bool> CanRegister (string userSelectByParam) {
//
// Validate ARgs ...
validationProvider.NotEmpty (userSelectByParam);
//
var client = GetRestClient ();
//
// Check Endpoint ...
var endpoint = XApiAccountEndpoint.CanRegisterUserName;
var @params = new Dictionary<string, string> { { XParam.XUserName.GetStringValue (), userSelectByParam } };
//
// Check UserSelectByType ...
var type = userSelectByParam.GetUserSelectByType ();
switch (type) {
//
case XUserSelectBy.Username:
break;
//
case XUserSelectBy.MobileNumber:
//
endpoint = XApiAccountEndpoint.CanRegisterMobileNumber;
@params = new Dictionary<string, string> { { XParam.XMobileNumber.GetStringValue (), userSelectByParam } };
break;
//
case XUserSelectBy.Email:
//
endpoint = XApiAccountEndpoint.CanRegisterEmail;
@params = new Dictionary<string, string> { { XParam.XEmail.GetStringValue (), userSelectByParam } };
break;
//
default:
throw XException.InvalidData.ToException ();
}
//
var request = GetRestRequet (
endpoint,
@params: @params
);
//
var response = await RunRestRequest<bool> (
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Invite a User to Register on Dashboard
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
/// <returns>an instance of <see>XActionResponse</see></returns>
public async Task<XActionResponse> InviteUser (
XTokenResponse tokens,
XActionRequest model
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (
tokens,
model,
model.Device)
.AddNotEmpty (
tokens.AccessToken,
model.Lang,
model.Email,
model.ReturnUrl)
.AddEmailAddress (model.Email)
.ValidateGroupAsync ();
//
var client = GetRestClient (tokens);
//
var request = GetRestRequet (XApiAccountEndpoint.InviteUser);
request.AddJsonBody (model);
//
var response = await RunRestRequest<XActionResponse> (
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// Recieve some Basic Informations and Start Registration Proccess
/// if they Valid
///
/// Registration Proccess Starts with Invoking this Action
/// </summary>
/// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
/// <returns>an instance of <see>XActionResponse</see></returns>
public async Task<XActionResponse> RequestRegistration (
XActionRequest model
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (
model,
model.Device,
model.DateOfBirth)
.AddNotEmpty (
model.Lang,
model.FirstName,
model.LastName)
.ValidateGroupAsync ();
//
var client = GetRestClient ();
//
var request = GetRestRequet (XApiAccountEndpoint.RequestRegistration);
request.AddJsonBody (model);
//
var response = await RunRestRequest<XActionResponse> (
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// Add User Account Informations
/// </summary>
/// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
/// <returns>an instance of <see>XActionResponse</see></returns>
public async Task<XActionResponse> AddAccountInfo (
XActionRequest model
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (
model,
model.Device)
.AddNotEmpty (
model.Lang,
model.UserName,
model.Password,
model.ActionToken)
.ValidateGroupAsync ();
//
var client = GetRestClient ();
//
var request = GetRestRequet (XApiAccountEndpoint.AddAccountInfo);
request.AddJsonBody (model);
//
var response = await RunRestRequest<XActionResponse> (
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// Upload and Attach a Profile Image for User. this is an Optional Step
/// </summary>
/// <param name="actionToken">user's requested action token</param>
/// <param name="file">an instance of <see>IFormFile</see> for user's Avatar</param>
/// <returns>an instance of <see>XActionResponse</see></returns>
public async Task<XActionResponse> AttachProfileImage (
string actionToken,
IFormFile file
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (file)
.AddNotEmpty (actionToken)
.ValidateGroupAsync ();
//
var client = GetRestClient ();
//
var request = GetRestRequet (XApiAccountEndpoint.AttachProfileImage);
//
// Prepare Request Data ...
request.AddParameter (XParam.XActionToken.GetStringValue (), actionToken);
request.AddFileBytes (
XParam.XFile.GetStringValue (),
file.ToByteArray (),
file.FileName,
file.ContentType
);
//
var response = await RunRestRequest<XActionResponse> (
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// Finish Registrationn Proccess
/// </summary>
/// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
/// <returns></returns>
public async Task FinishRegistration (XActionRequest model) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotEmpty (
model.Lang,
model.Password,
model.ReturnUrl)
.AddNotNull (model.Device)
.AddUrl (model.ReturnUrl)
.ValidateGroupAsync ();
//
// Create Http Client ...
var client = GetRestClient ();
//
// Create Request ...
var request = GetRestRequet (XApiAccountEndpoint.FinishRegistration);
//
// Prepare Request Data ...
request.AddJsonBody (model);
//
var response = await RunRestRequest<object> (
client,
request,
XHttpMethod.POST
);
}
/// <summary>
/// Check User is Confirmed Email or not
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="userSelectByParam">an string value which reperesent a user</param>
/// <returns>a boolean value</returns>
public async Task<bool> IsConfirmedEmail (
XTokenResponse tokens,
string userSelectByParam
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (tokens)
.AddNotEmpty (
tokens.AccessToken,
userSelectByParam)
.ValidateGroupAsync ();
//
var client = GetRestClient (tokens);
//
var request = GetRestRequet (XApiAccountEndpoint.IsConfirmedEmail);
//
var response = await RunRestRequest<bool> (
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Check User is Confirmed Mobile or not
/// </summary>
/// <param name="tokens">Authentication Tokens</param>
/// <param name="userSelectByParam">an string value which reperesent a user</param>
/// <returns>a boolean value</returns>
public async Task<bool> IsConfirmedMobile (
XTokenResponse tokens,
string userSelectByParam
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (tokens)
.AddNotEmpty (
tokens.AccessToken,
userSelectByParam)
.ValidateGroupAsync ();
//
var client = GetRestClient (tokens);
//
var request = GetRestRequet (XApiAccountEndpoint.IsConfirmedMobile);
//
var response = await RunRestRequest<bool> (
client,
request,
XHttpMethod.GET
);
return response;
}
/// <summary>
/// Request Registration Confirm
/// </summary>
/// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
/// <returns></returns>
public async Task RequestConfirmRegistration (XActionRequest model) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotEmpty (
model.Lang,
model.Password,
model.ReturnUrl)
.AddNotNull (model.Device)
.AddUrl (model.ReturnUrl)
.ValidateGroupAsync ();
//
// Get UserSelect By Param ...
var userSelectByParam = model.GetUserSelectByParam ();
validationProvider.NotEmpty (userSelectByParam);
//
var client = GetRestClient ();
//
var request = GetRestRequet (XApiAccountEndpoint.RequestConfirmRegistration);
request.AddJsonBody (model);
//
var response = await RunRestRequest<object> (
client,
request,
XHttpMethod.POST
);
}
/// <summary>
/// Confirm Registration
/// </summary>
/// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
/// <returns></returns>
public async Task ConfirmRegistration (
XActionRequest model
) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotEmpty (
model.Lang,
model.ActionToken,
model.ReturnUrl
)
.AddNotNull (model.Device)
.ValidateGroupAsync ();
//
var client = GetRestClient ();
//
var request = GetRestRequet (XApiAccountEndpoint.ConfirmRegistration);
request.AddJsonBody (model);
//
var response = await RunRestRequest<object> (
client,
request,
XHttpMethod.POST
);
}
/// <summary>
/// Request For Mobile Number Change/Confirm
/// </summary>
/// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
/// <returns>an instance of <see>XActionResponse</see></returns>
public async Task<XActionResponse> RequestConfirmMobile (XActionRequest model) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotEmpty (
model.Lang,
model.Password,
model.MobileNumber
)
.AddNotNull (model.Device)
.AddMobileNumber (model.MobileNumber)
.ValidateGroupAsync ();
//
// Get UserSelect By Param ...
var userSelectByParam = GetUserSelectByParam (
model,
excludes : new List<XUserSelectBy> {
XUserSelectBy.Email,
XUserSelectBy.MobileNumber
});
//
var client = GetRestClient ();
//
var request = GetRestRequet (XApiAccountEndpoint.RequestConfirmMobile);
request.AddJsonBody (model);
//
var response = await RunRestRequest<XActionResponse> (
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// Confirm Requested Mobile Number
/// </summary>
/// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
/// <returns>an instance of <see>XActionResponse</see></returns>
public async Task<XActionResponse> ConfirmMobileNumber (XActionRequest model) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotEmpty (
model.Lang,
model.ActionToken,
model.MobileVerificationCode
)
.AddNotNull (model.Device)
.ValidateGroupAsync ();
//
var client = GetRestClient ();
//
var request = GetRestRequet (XApiAccountEndpoint.ConfirmMobileNumber);
request.AddJsonBody (model);
//
var response = await RunRestRequest<XActionResponse> (
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// Request For Email Address Change/Confirm
/// </summary>
/// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
/// <returns>an instance of <see>XActionResponse</see></returns>
public async Task<XActionResponse> RequestConfirmEmail (XActionRequest model) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotEmpty (
model.Lang,
model.Email,
model.Password)
.AddNotNull (model.Device)
.AddEmailAddress (model.Email)
.ValidateGroupAsync ();
//
// Get UserSelect By Param ...
var userSelectByParam = GetUserSelectByParam (
model,
excludes : new List<XUserSelectBy> {
XUserSelectBy.Email,
XUserSelectBy.MobileNumber
});
//
var client = GetRestClient ();
//
var request = GetRestRequet (XApiAccountEndpoint.RequestConfirmEmail);
request.AddJsonBody (model);
//
var response = await RunRestRequest<XActionResponse> (
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// Confirm Requested Email Address
/// </summary>
/// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
/// <returns>an instance of <see>XActionResponse</see></returns>
public async Task<XActionResponse> ConfirmEmailAddress (XActionRequest model) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotEmpty (
model.Lang,
model.ActionToken,
model.EmailVerificationCode
)
.AddNotNull (model.Device)
.ValidateGroupAsync ();
//
var client = GetRestClient ();
//
var request = GetRestRequet (XApiAccountEndpoint.ConfirmEmailAddress);
request.AddJsonBody (model);
//
var response = await RunRestRequest<XActionResponse> (
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// Request Reset Password Action
/// </summary>
/// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
/// <returns>an instance of <see>XActionResponse</see></returns>
public async Task<XActionResponse> RequestResetPassword (XActionRequest model) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotEmpty (
model.Lang,
model.ReturnUrl)
.AddNotNull (model.Device)
.AddUrl (model.ReturnUrl)
.ValidateGroupAsync ();
//
// Get UserSelect By Param ...
var userSelectByParam = GetUserSelectByParam (
model,
excludes : new List<XUserSelectBy> {
XUserSelectBy.Email,
XUserSelectBy.MobileNumber
});
//
var client = GetRestClient ();
//
var request = GetRestRequet (XApiAccountEndpoint.RequestResetPassword);
request.AddJsonBody (model);
//
var response = await RunRestRequest<XActionResponse> (
client,
request,
XHttpMethod.POST
);
return response;
}
/// <summary>
/// Reset a User's Password
/// </summary>
/// <param name="model">an instance of <see>XActionRequest</see> class which provider requirement for action</param>
/// <returns></returns>
public async Task ResetPassword (XActionRequest model) {
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder ()
.AddNotNull (model)
.AddNotEmpty (
model.Lang,
model.ActionToken,
model.NewPassword,
model.ReturnUrl)
.AddNotNull (model.Device)
.ValidateGroupAsync ();
//
var client = GetRestClient ();
//
var request = GetRestRequet (XApiAccountEndpoint.ResetPassword);
request.AddJsonBody (model);
//
var response = await RunRestRequest<object> (
client,
request,
XHttpMethod.POST
);
}
#endregion
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Partial\XIdentityProvider+Search.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using xHttpService.Constants;
using xHttpService.Extensions;
using xIdentityModels.Dtos;
using xIdentityModels.Models;
using xIdentityService.Constants;
using xModels.Dtos;
namespace xIdentityService.Providers
{
public partial class XIdentityProvider
{
//
#region Actions ...
/// <summary>
/// Query Open To Search User Profiles ...
/// </summary>
/// <param name="tokens">requested user's identifiers</param>
/// <param name="query">how to filter results based on <see>XQuery</see> structure</param>
/// <returns>an instance of <see>XQueryResult</see> of <see>XUserProfileDto</see></returns>
public async Task<XQueryResult<XUserProfileDto>> QueryOpenToSearchUsers(
XTokenResponse tokens,
XQuery query
)
{
//
// Validate Args ...
await validationProvider
.GroupValidationBuilder()
.AddNotNull(tokens, query)
.AddNotEmpty(tokens.AccessToken)
.ValidateGroupAsync();
//
var client = GetRestClient(tokens);
//
var request = GetRestRequet(XApiAccountEndpoint.QueryOpenToSearchProfiles);
//
// Attach XQuery to Request ...
request = request.AttachXQuery(query);
//
var response = await RunRestRequest<XQueryResult<XUserProfileDto>>(
client,
request,
XHttpMethod.GET
);
return response;
}
#endregion
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Providers\XBaseIdentityHttpProvider.cs
using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using RestSharp;
using RestSharp.Authenticators;
using xCommons.Constants;
using xCommons.Extensions;
using xCommons.Providers;
using xExceptions.Constants;
using xHttpService.Constants;
using xIdentityModels.Constants;
using xIdentityModels.Extensions;
using xIdentityModels.Models;
using xIdentityService.Constants;
using xIdentityService.Interfaces;
using xIdentityService.Models;
using xIdentityService.Extensions;
using System.Diagnostics.Tracing;
using MySqlX.XDevAPI.Common;
namespace xIdentityService.Providers
{
/// <summary>
/// an abstraction Implementation for Identity Provided Http Based Services ...
/// </summary>
public abstract class XBaseIdentityHttpProvider : IXBaseIdentityHttpProvider
{
/// <summary>
/// Client Base Url ...
/// </summary>
/// <value></value>
public string BaseUrl { get; }
/// <summary>
/// Logger ...
/// </summary>
/// <value></value>
public ILogger Logger { get; }
/// <summary>
/// Powered Value ...
/// </summary>
/// <value></value>
public string XPoweredValue { get; }
/// <summary>
/// Default Client Timeout ...
/// </summary>
/// <value></value>
public int DefaultClientTimeout { get; }
/// <summary>
/// Default Buffering Chunk Size ...
/// </summary>
/// <value></value>
public int DefaultBufferingChunckSize { get; }
/// <summary>
/// Validation Provider ...
/// </summary>
/// <value></value>
public XValidationProvider ValidationProvider { get; }
/// <summary>
/// Token Provider ...
/// </summary>
private readonly IXTokenProvider tokenProvider;
/// <summary>
/// Identity Provider ...
/// </summary>
private readonly IXIdentityProvider identityProvider;
public XBaseIdentityHttpProvider(
string baseUrl,
ILogger logger,
string poweredValue,
int defaultClientTimeout,
IXTokenProvider tokenProvider,
IXIdentityProvider identityProvider,
XValidationProvider validationProvider,
int defaultBufferingChunckSize = 8192
)
{
//
Logger = logger;
BaseUrl = baseUrl;
XPoweredValue = poweredValue;
this.tokenProvider = tokenProvider;
ValidationProvider = validationProvider;
this.identityProvider = identityProvider;
DefaultClientTimeout = defaultClientTimeout;
DefaultBufferingChunckSize = defaultBufferingChunckSize;
}
//
#region Tools ...
/// <summary>
/// Get an Instance of Http Client
/// </summary>
/// <returns></returns>
public HttpClient GetHttpClient(XTokenResponse tokens = null)
{
//
HttpClient httpClient = null;
//
// httpClient = new HttpClient ();
var httpClientHandler = new HttpClientHandler()
{
ServerCertificateCustomValidationCallback = (sender, cert, chain, sslPolicyErrors) =>
{
//
Logger.LogInformation(
$"XSSL Handler: {Environment.NewLine}, sender: {sender}, {Environment.NewLine} cert: {cert}, {Environment.NewLine} chain: {chain}, {Environment.NewLine} sslPolicyErrors: {sslPolicyErrors}"
);
//
return true;
},
ClientCertificateOptions = ClientCertificateOption.Manual,
};
httpClient = new HttpClient(httpClientHandler);
//
// Set Authenticator ...
if (!tokens.IsNull() &&
!tokens.AccessToken.IsNullOrEmpty())
{
//
httpClient.DefaultRequestHeaders
.Add(
XAuthorization.Header,
$"{XAuthentication.BEARER} {tokens.AccessToken}");
}
//
// Refresh Token ...
if (!tokens.IsNull() &&
!tokens.RefreshToken.IsNullOrEmpty())
{
//
httpClient.DefaultRequestHeaders
.Add(
XAuthorization.RefreshToken,
tokens.RefreshToken);
}
//
// ExpiresAt ...
if (!tokens.IsNull() &&
tokens.ExpiresAt > 0)
{
//
httpClient.DefaultRequestHeaders
.Add(
XAuthorization.ExpiresAt,
tokens.ExpiresAt.AsHttpParamString());
}
//
// Set Default Timeout ...
httpClient.Timeout = TimeSpan.FromSeconds(DefaultClientTimeout == -1 ? 10000 : DefaultClientTimeout);
//
return httpClient;
}
public HttpClient GetHttpClient(XUserClaimsInfoDto userInfo = null)
{
//
XTokenResponse tokens = ToTokenResponse(userInfo);
//
return GetHttpClient(tokens);
}
/// <summary>
/// Get an Instance of RestClient
/// </summary>
/// <returns></returns>
public RestClient GetRestClient(XTokenResponse tokens = null)
{
//
var client = new RestClient(BaseUrl);
//
// Set Authenticator ...
if (!tokens.IsNull() &&
!tokens.AccessToken.IsNullOrEmpty())
{
client.Authenticator = new JwtAuthenticator(tokens.AccessToken);
}
//
// Refresh Token ...
if (!tokens.IsNull() &&
!tokens.RefreshToken.IsNullOrEmpty())
{
client.AddDefaultHeader(XAuthorization.RefreshToken, tokens.RefreshToken);
}
//
// ExpiresAt ...
if (!tokens.IsNull() &&
tokens.ExpiresAt > 0)
{
client.AddDefaultHeader(XAuthorization.ExpiresAt, tokens.ExpiresAt.AsHttpParamString());
}
//
// Set Default Timeout ...
client.Timeout = DefaultClientTimeout;
//
// SSL Validation Handler ...
client.RemoteCertificateValidationCallback = (sender, cert, chain, sslPolicyErrors) =>
{
//
Logger.LogInformation(
$"XSSL Handler: {Environment.NewLine}, sender: {sender}, {Environment.NewLine} cert: {cert}, {Environment.NewLine} chain: {chain}, {Environment.NewLine} sslPolicyErrors: {sslPolicyErrors}"
);
//
return true;
};
//
return client;
}
public RestClient GetRestClient(XUserClaimsInfoDto userInfo = null)
{
//
XTokenResponse tokens = ToTokenResponse(userInfo);
//
return GetRestClient(tokens);
}
/// <summary>
/// Get an Instance of RestRequest
/// </summary>
/// <param name="endpoint"></param>
/// <param name="addXPoweredValue"></param>
/// <param name=""></param>
/// <param name="headers"></param>
/// <param name="queryStrings"></param>
/// <returns></returns>
public RestRequest GetRestRequet(
Enum endpoint,
bool addXPoweredValue = true,
IDictionary<string, string> @params = null,
IDictionary<string, string> headers = null,
IDictionary<string, string> queryStrings = null
)
{
//
var url = PrepareUrl(
@params: @params,
endpoint: endpoint,
queryStrings: queryStrings
);
//
// Create request ...
var request = new RestRequest(url, DataFormat.Json);
//
if (addXPoweredValue)
{
request.AddHeader(XAuthorization.XPoweredBy, XPoweredValue);
}
//
// Add Headers to request ...
if (!headers.IsNull() && headers.Count > 0)
{
//
var enumerator = headers.GetEnumerator();
while (enumerator.MoveNext())
{
//
var item = enumerator.Current;
request.AddHeader(item.Key, item.Value);
}
}
//
return request;
}
/// <summary>
/// Handle Call Specific Request and retrieve Response
/// </summary>
/// <param name="client"></param>
/// <param name="request"></param>
/// <param name="method"></param>
/// <param name="supportRefreshingTokens"></param>
/// <param name="cancellationToken"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public async Task<T> RunRestRequest<T>(
RestClient client,
RestRequest request,
XHttpMethod method,
bool supportRefreshingTokens = true,
CancellationToken cancellationToken = default
)
{
//
var response = await Task.Run(async () =>
{
//
IRestResponse resp = null;
//
// Call Endpoint Service using Specified Method ...
switch (method)
{
//
// Get ...
case XHttpMethod.GET:
resp = client.Get(request);
break;
//
// Put ...
case XHttpMethod.PUT:
resp = client.Put(request);
break;
//
// Post ...
case XHttpMethod.POST:
resp = client.Post(request);
break;
//
// Delete ...
case XHttpMethod.DELETE:
resp = client.Delete(request);
break;
}
//
if (!resp.IsSuccessful)
{
//
// Log Exception ...
Logger.LogError($"Error: {resp.ErrorMessage}");
Logger.LogError($"Exception: {resp.ErrorException.ToJSON()}");
if (!resp.ErrorMessage.IsNullOrEmpty() &&
resp.ErrorMessage.Contains("timed out"))
{
XException.Timeout.Throw();
}
//
// TODO: Check UnAuthorized Status here for
// Refresh Tokens or Issue Correct Exception ...
if (supportRefreshingTokens &&
resp.StatusCode == System.Net.HttpStatusCode.Unauthorized)
{
//
var isRefreshed = request.Parameters.Any(rp =>
rp.Name == XParam.XIsRefreshed.GetStringValue() &&
rp.Value.ToString().ToNormalString() == true.ToJSON());
//
Logger.LogInformation($"isRefreshed: {isRefreshed}");
//
// Get Access Token ...
XTokenResponse tokens = null;
var accessToken = request.Parameters.FirstOrDefault(rp =>
rp.Name.ToNormalString() == XAuthorization.Header.ToNormalString()).Value.ToString();
if (!accessToken.IsNullOrEmpty())
{
//
accessToken = accessToken.Replace(XAuthorization.TokenIdentifier, "");
//
if (!accessToken.IsNullOrEmpty())
{
tokens = await tokenProvider.RetrieveToken(accessToken);
}
}
//
// Refresh Token and then re do request ...
if (!isRefreshed &&
!accessToken.IsNullOrEmpty() &&
!tokens.IsNull() &&
tokens.IsRefreshable())
{
//
request.AddHeader(XParam.XIsRefreshed.GetStringValue(), true.ToJSON());
//
// Refreshe Tokens ...
var refreshedTokens = await identityProvider
.RefreshTokens(tokens);
//
// Renew Rest Client with Refreshed Tokens ...
var timeout = client.Timeout;
client = GetRestClient(refreshedTokens);
client.Timeout = Timeout.Infinite;
//
// Do Request Again using renew Client ...
return await RunRestRequest<T>(
client: client,
request: request,
method: method);
}
}
//
var ex = resp.Content.ToXError();
if (!ex.IsNull())
{
throw ex.ToException();
}
//
// UnAuthorized ...
if (resp.StatusCode == System.Net.HttpStatusCode.Unauthorized)
{
XException.NotAuthorized.Throw();
}
//
// NotFound ...
if (resp.StatusCode == System.Net.HttpStatusCode.NotFound)
{
XException.NotFound.Throw();
}
//
XException.ActionFailed.Throw();
}
//
var result = resp.Content.FromJSON<T>();
return result;
},
cancellationToken: cancellationToken);
//
return response;
}
/// <summary>
/// Access a Get Request Stream as AsyncEnumerable ...
/// </summary>
/// <param name="endpoint"></param>
/// <param name="bufferLength"></param>
/// <param name="addXPoweredValue"></param>
/// <param name="tokens"></param>
/// <param name="@params"></param>
/// <param name="headers"></param>
/// <param name="queryStrings"></param>
/// <param name="cancellationToken"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public async Task<Stream> StreamData(
Enum endpoint,
int bufferLength = 8194,
bool addXPoweredValue = true,
XTokenResponse tokens = null,
IDictionary<string, string> @params = null,
IDictionary<string, string> headers = null,
IDictionary<string, string> queryStrings = null,
[System.Runtime.CompilerServices.EnumeratorCancellation]
CancellationToken cancellationToken = default
)
{
//
var url = PrepareUrl(
@params: @params,
endpoint: endpoint,
attachBaseUrl: true,
queryStrings: queryStrings
);
var client = GetHttpClient(tokens);
if (addXPoweredValue)
{
//
client.DefaultRequestHeaders
.Add(
XAuthorization.XPoweredBy,
XPoweredValue
);
}
//
// For SSE, you might want to set the Accept header, though not strictly necessary for just streaming
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept
.Add(
new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("text/event-stream"));
//
var response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
response.EnsureSuccessStatusCode();
//
var stream = await response.Content.ReadAsStreamAsync();
//
return stream;
// using (var response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, cancellationToken))
// {
// //
// int readedBuffers = 0;
// response.EnsureSuccessStatusCode();
// var buffer = new byte[bufferLength];
// var stream = await response.Content.ReadAsStreamAsync();
// //
// while ((readedBuffers = await stream.ReadAsync(buffer, 0, buffer.Length)) > 0)
// {
// //
// var content = buffer.FromBytes();
// Console.WriteLine(content);
// }
// // await foreach (var message in stream) {
// // Console.WriteLine(message);
// // }
// // await foreach (var item in stream.ToAsyncEnumerable<byte[]>(cancellationToken: cancellationToken))
// // {
// // //
// // Console.WriteLine(item);
// // // T value = item.IsNull()
// // // ? default(T)
// // // : item.FromBytes().FromJSON<T>();
// // // //
// // // yield return value;
// // }
// }
///
///
///
///
//
// var eventSource = new EventSource(url);
// // eventSource.
// // var client = GetHttpClient(tokens);
// // if (addXPoweredValue)
// // {
// // //
// // client.DefaultRequestHeaders
// // .Add(
// // XAuthorization.XPoweredBy,
// // XPoweredValue);
// // }
// // //
// // // For SSE, you might want to set the Accept header, though not strictly necessary for just streaming
// // client.DefaultRequestHeaders.Accept.Clear();
// // client.DefaultRequestHeaders.Accept
// // .Add(
// // new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("text/event-stream"));
// // //
// // using (var response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, cancellationToken))
// // {
// // //
// // response.EnsureSuccessStatusCode();
// // var stream = await response.Content.ReadAsStreamAsync();
// // await foreach (var item in stream.ToAsyncEnumerable<byte[]>(cancellationToken: cancellationToken))
// // {
// // //
// // T value = item.IsNull()
// // ? default(T)
// // : item.FromBytes().FromJSON<T>();
// // //
// // yield return value;
// // }
// // }
}
/// <summary>
/// Handle Call Specified Request and Retrieve XBaseRestResponse<T> ...
/// </summary>
/// <param name="client"></param>
/// <param name="request"></param>
/// <param name="method"></param>
/// <param name="supportRefreshingTokens"></param>
/// <param name="cancellationToken"></param>
/// <typeparam name="T"></typeparam>
/// <returns>an instance of XBaseRestResponse<T></returns>
public async Task<XBaseRestResponse<T>> RunRestRequestByResponse<T>(
RestClient client,
RestRequest request,
XHttpMethod method,
bool supportRefreshingTokens = true,
CancellationToken cancellationToken = default
)
{
//
var response = await Task.Run(async () =>
{
//
IRestResponse resp = null;
//
// Call Endpoint Service using Specified Method ...
switch (method)
{
//
// Get ...
case XHttpMethod.GET:
resp = client.Get(request);
break;
//
// Put ...
case XHttpMethod.PUT:
resp = client.Put(request);
break;
//
// Post ...
case XHttpMethod.POST:
resp = client.Post(request);
break;
//
// Delete ...
case XHttpMethod.DELETE:
resp = client.Delete(request);
break;
}
//
if (!resp.IsSuccessful)
{
//
// Log Exception ...
Logger.LogError($"Error: {resp.ErrorMessage}");
Logger.LogError($"Exception: {resp.ErrorException.ToJSON()}");
if (!resp.ErrorMessage.IsNullOrEmpty() &&
resp.ErrorMessage.Contains("timed out"))
{
XException.Timeout.Throw();
}
//
// TODO: Check UnAuthorized Status here for
// Refresh Tokens or Issue Correct Exception ...
if (supportRefreshingTokens &&
resp.StatusCode == System.Net.HttpStatusCode.Unauthorized)
{
//
var isRefreshed = request.Parameters.Any(rp =>
rp.Name == XParam.XIsRefreshed.GetStringValue() &&
rp.Value.ToString().ToNormalString() == true.ToJSON());
//
Logger.LogInformation($"isRefreshed: {isRefreshed}");
//
// Get Access Token ...
XTokenResponse tokens = null;
var accessToken = request.Parameters.FirstOrDefault(rp =>
rp.Name.ToNormalString() == XAuthorization.Header.ToNormalString()).Value.ToString();
if (!accessToken.IsNullOrEmpty())
{
//
accessToken = accessToken.Replace(XAuthorization.TokenIdentifier, "");
//
if (!accessToken.IsNullOrEmpty())
{
tokens = await tokenProvider.RetrieveToken(accessToken);
}
}
//
// Refresh Token and then re do request ...
if (!isRefreshed &&
!accessToken.IsNullOrEmpty() &&
!tokens.IsNull() &&
tokens.IsRefreshable())
{
//
request.AddHeader(XParam.XIsRefreshed.GetStringValue(), true.ToJSON());
//
// Refreshe Tokens ...
var refreshedTokens = await identityProvider
.RefreshTokens(tokens);
//
// Renew Rest Client with Refreshed Tokens ...
var timeout = client.Timeout;
client = GetRestClient(refreshedTokens);
client.Timeout = Timeout.Infinite;
//
// Do Request Again using renew Client ...
return await RunRestRequestByResponse<T>(
client: client,
request: request,
method: method
);
}
}
//
var ex = resp.Content.ToXError();
if (!ex.IsNull())
{
throw ex.ToException();
}
//
// UnAuthorized ...
if (resp.StatusCode == System.Net.HttpStatusCode.Unauthorized)
{
XException.NotAuthorized.Throw();
}
//
// NotFound ...
if (resp.StatusCode == System.Net.HttpStatusCode.NotFound)
{
XException.NotFound.Throw();
}
//
XException.ActionFailed.Throw();
}
//
var result = new XBaseRestResponse<T>
{
Response = resp,
Model = resp.Content.FromJSON<T>()
};
//
return result;
},
cancellationToken: cancellationToken);
//
return response;
}
/// <summary>
/// Get User SelectBy Param
/// </summary>
/// <param name="model"></param>
/// <param name="forceNotNull"></param>
/// <param name="excludes"></param>
/// <returns></returns>
public string GetUserSelectByParam(
XActionRequest model,
bool forceNotNull = true,
ICollection<XUserSelectBy> excludes = null
)
{
//
// Validate Args ...
ValidationProvider.NotNull(model);
//
var id = model.UserId;
var userName = model.UserName;
var email = model.Email;
var phoneNumber = model.MobileNumber;
//
if (excludes != null)
{
//
if (excludes.Contains(XUserSelectBy.ID))
{
id = null;
}
if (excludes.Contains(XUserSelectBy.Email))
{
email = null;
}
if (excludes.Contains(XUserSelectBy.MobileNumber))
{
phoneNumber = null;
}
if (excludes.Contains(XUserSelectBy.Username))
{
userName = null;
}
}
var selectByParam =
id.IsNullOrEmpty() ?
userName.IsNullOrEmpty() ?
email.IsNullOrEmpty() ?
phoneNumber.IsNullOrEmpty() ? null : phoneNumber : email : userName : id;
//
// Check result ...
if (forceNotNull &&
selectByParam.IsNullOrEmpty())
{
XException.InvalidData.Throw();
}
//
return selectByParam;
}
/// <summary>
/// Prepare Url Address of Specified Enum by Filling Params
/// and Query Strings Attach ...
/// </summary>
/// <param name="endpoint"></param>
/// <param name="attachBaseUrl"></param>
/// <param name="@params"></param>
/// <param name="queryStrings"></param>
/// <returns></returns>
public string PrepareUrl(
Enum endpoint,
bool attachBaseUrl = false,
IDictionary<string, string> @params = null,
IDictionary<string, string> queryStrings = null
)
{
//
// Retrieving Url Template ...
var url = endpoint.GetStringValue();
//
// Filling Parmas and Query Strings of Url ...
url = PrepareUrl(
url: url,
@params: @params,
queryStrings: queryStrings,
attachBaseUrl: attachBaseUrl
);
//
return url;
}
/// <summary>
/// Prepare Url Address by Filling Params
/// and Query Strings Attach ...
/// </summary>
/// <param name="url"></param>
/// <param name="attachBaseUrl"></param>
/// <param name="@params"></param>
/// <param name="queryStrings"></param>
/// <returns></returns>
public string PrepareUrl(
string url,
bool attachBaseUrl = false,
IDictionary<string, string> @params = null,
IDictionary<string, string> queryStrings = null
)
{
//
if (attachBaseUrl)
{
//
var baseUrl = BaseUrl;
if (!baseUrl.EndsWith("/"))
{
baseUrl = $"{baseUrl}/";
}
//
url = $"{baseUrl}{url}";
}
//
// Add Route Payloads ...
if (!@params.IsNull() && @params.Count > 0)
{
//
var enumerator = @params.GetEnumerator();
while (enumerator.MoveNext())
{
//
var item = enumerator.Current;
//
url = url.Replace(item.Key, item.Value.ToUrlEncoded());
}
}
//
// Add Query Strings ...
if (!queryStrings.IsNull() && queryStrings.Count > 0)
{
//
url = $"{url}?";
var enumerator = queryStrings.GetEnumerator();
while (enumerator.MoveNext())
{
//
var item = enumerator.Current;
//
url += $"{item.Key}={item.Value.ToUrlEncoded()}&";
}
//
// remove lates & ...
if (url.EndsWith("&"))
{
url = url.Substring(0, url.Length - 1);
}
}
//
return url;
}
/// <summary>
/// Converts UserInfo to TokenResponse model ...
/// </summary>
/// <param name="userInfo"></param>
/// <returns></returns>
public XTokenResponse ToTokenResponse(XUserClaimsInfoDto userInfo = null)
{
//
XTokenResponse result = null;
//
if (!userInfo.IsNull())
{
//
result = new XTokenResponse
{
AccessToken = userInfo.AccessToken.IsNullOrEmpty()
? ""
: userInfo.AccessToken,
RefreshToken = userInfo.RefreshToken.IsNullOrEmpty()
? ""
: userInfo.RefreshToken,
ExpiresAt = userInfo.ExpiresAt,
};
//
if (userInfo.AccessToken.IsNullOrEmpty())
{
result = null;
}
}
//
return result;
}
#endregion
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Providers\XIdentityProvider.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using RestSharp;
using RestSharp.Authenticators;
using xCommons.Constants;
using xCommons.Extensions;
using xCommons.Providers;
using xExceptions.Constants;
using xHttpService.Constants;
using xIdentityModels.Constants;
using xIdentityModels.Extensions;
using xIdentityModels.Models;
using xIdentityService.Configuration;
using xIdentityService.Constants;
using xIdentityService.Interfaces;
using xIdentityService.Models;
namespace xIdentityService.Providers {
public partial class XIdentityProvider : IXIdentityProvider {
private readonly IXTokenProvider tokenProvider;
private readonly IHostingEnvironment environment;
private JsonSerializerSettings jsonSerializerSettings;
private readonly XValidationProvider validationProvider;
private readonly XIdentityServiceConfiguration identityConfiguration;
public ILogger<XIdentityProvider> Logger { get; }
public IXSecurityProvider SecurityProvider { get; }
public string BaseUrl { get; }
public string RevisionSecretKey { get; }
public bool ReadResponseAsString { get; set; }
public XIdentityProvider (
IXTokenProvider tokenProvider,
IHostingEnvironment environment,
ILogger<XIdentityProvider> logger,
IXSecurityProvider securityProvider,
XIdentityServiceConfiguration identityConfiguration,
XValidationProvider validationProvider
) {
//
BaseUrl = identityConfiguration.Authority;
RevisionSecretKey = identityConfiguration.XRevisionSecretKey;
//
this.environment = environment;
Logger = logger;
SecurityProvider = securityProvider;
//
this.identityConfiguration = identityConfiguration;
this.validationProvider = validationProvider;
this.jsonSerializerSettings = new JsonSerializerSettings {
ContractResolver = new CamelCasePropertyNamesContractResolver ()
};
//
this.tokenProvider = tokenProvider;
}
//
#region Tools ...
/// <summary>
/// Get an Instance of Http Client
/// </summary>
/// <returns></returns>
public HttpClient GetHttpClient () {
//
HttpClient httpClient = null;
//
// httpClient = new HttpClient ();
var httpClientHandler = new HttpClientHandler () {
ServerCertificateCustomValidationCallback = (sender, cert, chain, sslPolicyErrors) => {
//
Logger.LogInformation (
$"XSSL Handler: {Environment.NewLine}, sender: {sender}, {Environment.NewLine} cert: {cert}, {Environment.NewLine} chain: {chain}, {Environment.NewLine} sslPolicyErrors: {sslPolicyErrors}"
);
//
return true;
},
ClientCertificateOptions = ClientCertificateOption.Manual,
};
httpClient = new HttpClient (httpClientHandler);
//
// Set Timeout ...
// TODO: Fix this ...
// httpClient.Timeout = TimeSpan
// .FromSeconds (identityConfiguration.DefaultClientTimeout);
//
return httpClient;
}
/// <summary>
/// Get an Instance of RestClient
/// </summary>
/// <returns></returns>
public RestClient GetRestClient (XTokenResponse tokens = null) {
//
var client = new RestClient (BaseUrl);
//
// Set Authenticator ...
if (!tokens.IsNull () &&
!tokens.AccessToken.IsNullOrEmpty ()) {
client.Authenticator = new JwtAuthenticator (tokens.AccessToken);
}
//
// Refresh Token ...
if (!tokens.IsNull () &&
!tokens.RefreshToken.IsNullOrEmpty ()) {
client.AddDefaultHeader (XAuthorization.RefreshToken, tokens.RefreshToken);
}
//
// ExpiresAt ...
if (!tokens.IsNull () &&
tokens.ExpiresAt > 0) {
client.AddDefaultHeader (XAuthorization.ExpiresAt, tokens.ExpiresAt.AsHttpParamString ());
}
//
// Set Default Timeout ...
client.Timeout = identityConfiguration.DefaultClientTimeout;
//
// SSL Validation Handler ...
client.RemoteCertificateValidationCallback = (sender, cert, chain, sslPolicyErrors) => {
//
Logger.LogInformation (
$"XSSL Handler: {Environment.NewLine}, sender: {sender}, {Environment.NewLine} cert: {cert}, {Environment.NewLine} chain: {chain}, {Environment.NewLine} sslPolicyErrors: {sslPolicyErrors}"
);
//
return true;
};
//
return client;
}
/// <summary>
/// Get an Instance of RestRequest
/// </summary>
public RestRequest GetRestRequet (
XApiAccountEndpoint endpoint,
bool addXPoweredValue = true,
IDictionary<string, string> @params = null,
IDictionary<string, string> headers = null,
IDictionary<string, string> queryStrings = null
) {
//
var url = endpoint.GetStringValue ();
//
// Add Route Payloads ...
if (!@params.IsNull () && @params.Count > 0) {
//
var enumerator = @params.GetEnumerator ();
while (enumerator.MoveNext ()) {
//
var item = enumerator.Current;
//
url = url.Replace (item.Key, item.Value.ToUrlEncoded ());
}
}
//
// Add Query Strings ...
if (!queryStrings.IsNull () && queryStrings.Count > 0) {
//
url = $"{url}?";
var enumerator = queryStrings.GetEnumerator ();
while (enumerator.MoveNext ()) {
//
var item = enumerator.Current;
//
url += $"{item.Key}={item.Value.ToUrlEncoded ()}&";
}
//
// remove lates & ...
if (url.EndsWith ("&")) {
url = url.Substring (0, url.Length - 1);
}
}
//
// Create request ...
var request = new RestRequest (url, DataFormat.Json);
//
if (addXPoweredValue) {
request.AddHeader (XAuthorization.XPoweredBy, identityConfiguration.XPoweredValue);
}
//
// Add Headers to request ...
if (!headers.IsNull () && headers.Count > 0) {
//
var enumerator = headers.GetEnumerator ();
while (enumerator.MoveNext ()) {
//
var item = enumerator.Current;
request.AddHeader (item.Key, item.Value);
}
}
//
return request;
}
/// <summary>
/// Handle Call Specific Request and retrieve Response
/// </summary>
/// <param name="client"></param>
/// <param name="request"></param>
/// <param name="method"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public async Task<T> RunRestRequest<T> (
RestClient client,
RestRequest request,
XHttpMethod method,
bool supportRefreshingTokens = true
) {
//
var response = await Task.Run (async () => {
//
IRestResponse resp = null;
//
// Call Endpoint Service using Specified Method ...
switch (method) {
//
// Get ...
case XHttpMethod.GET:
resp = client.Get (request);
break;
//
// Put ...
case XHttpMethod.PUT:
resp = client.Put (request);
break;
//
// Post ...
case XHttpMethod.POST:
resp = client.Post (request);
break;
//
// Delete ...
case XHttpMethod.DELETE:
resp = client.Delete (request);
break;
}
//
if (!resp.IsSuccessful) {
//
// Log Exception ...
Logger.LogError ($"Error: {resp.ErrorMessage}");
Logger.LogError ($"Exception: {resp.ErrorException.ToJSON()}");
if (!resp.ErrorMessage.IsNullOrEmpty () &&
resp.ErrorMessage.Contains ("timed out")) {
XException.Timeout.Throw ();
}
//
// TODO: Check UnAuthorized Status here for
// Refresh Tokens or Issue Correct Exception ...
if (supportRefreshingTokens &&
resp.StatusCode == System.Net.HttpStatusCode.Unauthorized) {
//
var isRefreshed = request.Parameters.Any (rp =>
rp.Name == XParam.XIsRefreshed.GetStringValue () &&
rp.Value.ToString ().ToNormalString () == true.ToJSON ());
//
Logger.LogInformation ($"isRefreshed: {isRefreshed}");
//
// Get Access Token ...
XTokenResponse tokens = null;
var accessToken = request.Parameters.FirstOrDefault (rp =>
rp.Name.ToNormalString () == XAuthorization.Header.ToNormalString ()).Value.ToString ();
if (!accessToken.IsNullOrEmpty ()) {
//
accessToken = accessToken.Replace (XAuthorization.TokenIdentifier, "");
//
if (!accessToken.IsNullOrEmpty ()) {
tokens = await tokenProvider.RetrieveToken (accessToken);
}
}
//
// Refresh Token and then re do request ...
if (!isRefreshed &&
!accessToken.IsNullOrEmpty () &&
!tokens.IsNull () &&
tokens.IsRefreshable ()) {
//
request.AddHeader (XParam.XIsRefreshed.GetStringValue (), true.ToJSON ());
//
// Refreshe Tokens ...
var refreshedTokens = await RefreshTokens (tokens);
//
// Renew Rest Client with Refreshed Tokens ...
var timeout = client.Timeout;
client = GetRestClient (refreshedTokens);
client.Timeout = Timeout.Infinite;
//
// Do Request Again using renew Client ...
return await RunRestRequest<T> (
client: client,
request: request,
method: method);
}
}
//
var ex = resp.Content.ToXError ();
if (!ex.IsNull ()) {
throw ex.ToException ();
}
//
// UnAuthorized ...
if (resp.StatusCode == System.Net.HttpStatusCode.Unauthorized) {
XException.NotAuthorized.Throw ();
}
//
// NotFound ...
if (resp.StatusCode == System.Net.HttpStatusCode.NotFound) {
XException.NotFound.Throw ();
}
//
XException.ActionFailed.Throw ();
}
//
var result = resp.Content.FromJSON<T> ();
return result;
});
//
return response;
}
public async Task<XBaseRestResponse<T>> RunRestRequestByResponse<T> (
RestClient client,
RestRequest request,
XHttpMethod method,
bool supportRefreshingTokens = true
) {
//
var response = await Task.Run (async () => {
//
IRestResponse resp = null;
//
// Call Endpoint Service using Specified Method ...
switch (method) {
//
// Get ...
case XHttpMethod.GET:
resp = client.Get (request);
break;
//
// Put ...
case XHttpMethod.PUT:
resp = client.Put (request);
break;
//
// Post ...
case XHttpMethod.POST:
resp = client.Post (request);
break;
//
// Delete ...
case XHttpMethod.DELETE:
resp = client.Delete (request);
break;
}
//
if (!resp.IsSuccessful) {
//
// Log Exception ...
Logger.LogError ($"Error: {resp.ErrorMessage}");
Logger.LogError ($"Exception: {resp.ErrorException.ToJSON()}");
if (!resp.ErrorMessage.IsNullOrEmpty () &&
resp.ErrorMessage.Contains ("timed out")) {
XException.Timeout.Throw ();
}
//
// TODO: Check UnAuthorized Status here for
// Refresh Tokens or Issue Correct Exception ...
if (supportRefreshingTokens &&
resp.StatusCode == System.Net.HttpStatusCode.Unauthorized) {
//
var isRefreshed = request.Parameters.Any (rp =>
rp.Name == XParam.XIsRefreshed.GetStringValue () &&
rp.Value.ToString ().ToNormalString () == true.ToJSON ());
//
Logger.LogInformation ($"isRefreshed: {isRefreshed}");
//
// Get Access Token ...
XTokenResponse tokens = null;
var accessToken = request.Parameters.FirstOrDefault (rp =>
rp.Name.ToNormalString () == XAuthorization.Header.ToNormalString ()).Value.ToString ();
if (!accessToken.IsNullOrEmpty ()) {
//
accessToken = accessToken.Replace (XAuthorization.TokenIdentifier, "");
//
if (!accessToken.IsNullOrEmpty ()) {
tokens = await tokenProvider.RetrieveToken (accessToken);
}
}
//
// Refresh Token and then re do request ...
if (!isRefreshed &&
!accessToken.IsNullOrEmpty () &&
!tokens.IsNull () &&
tokens.IsRefreshable ()) {
//
request.AddHeader (XParam.XIsRefreshed.GetStringValue (), true.ToJSON ());
//
// Refreshe Tokens ...
var refreshedTokens = await RefreshTokens (tokens);
//
// Renew Rest Client with Refreshed Tokens ...
var timeout = client.Timeout;
client = GetRestClient (refreshedTokens);
client.Timeout = Timeout.Infinite;
//
// Do Request Again using renew Client ...
return await RunRestRequestByResponse<T> (
client: client,
request: request,
method: method
);
}
}
//
var ex = resp.Content.ToXError ();
if (!ex.IsNull ()) {
throw ex.ToException ();
}
//
// UnAuthorized ...
if (resp.StatusCode == System.Net.HttpStatusCode.Unauthorized) {
XException.NotAuthorized.Throw ();
}
//
// NotFound ...
if (resp.StatusCode == System.Net.HttpStatusCode.NotFound) {
XException.NotFound.Throw ();
}
//
XException.ActionFailed.Throw ();
}
//
var result = new XBaseRestResponse<T>
{
Response = resp,
Model = resp.Content.FromJSON<T> ()
};
//
return result;
});
//
return response;
}
/// <summary>
/// Get User SelectBy Param
/// </summary>
/// <param name="model"></param>
/// <param name="forceNotNull"></param>
/// <param name="excludes"></param>
/// <returns></returns>
public string GetUserSelectByParam (
XActionRequest model,
bool forceNotNull = true,
ICollection<XUserSelectBy> excludes = null
) {
//
// Validate Args ...
validationProvider.NotNull (model);
//
var id = model.UserId;
var userName = model.UserName;
var email = model.Email;
var phoneNumber = model.MobileNumber;
//
if (excludes != null) {
//
if (excludes.Contains (XUserSelectBy.ID)) {
id = null;
}
if (excludes.Contains (XUserSelectBy.Email)) {
email = null;
}
if (excludes.Contains (XUserSelectBy.MobileNumber)) {
phoneNumber = null;
}
if (excludes.Contains (XUserSelectBy.Username)) {
userName = null;
}
}
var selectByParam =
id.IsNullOrEmpty () ?
userName.IsNullOrEmpty () ?
email.IsNullOrEmpty () ?
phoneNumber.IsNullOrEmpty () ? null : phoneNumber : email : userName : id;
//
// Check result ...
if (forceNotNull &&
selectByParam.IsNullOrEmpty ()) {
XException.InvalidData.Throw ();
}
//
return selectByParam;
}
#endregion
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Providers\XInMemoryTokenProvider.cs
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using xCommons.Extensions;
using xIdentityModels.Models;
using xIdentityService.Interfaces;
namespace xIdentityService.Providers {
public partial class XInMemoryTokenProvider : IXTokenProvider {
private IDictionary<string, XTokenResponse> DbContext;
public XInMemoryTokenProvider () {
//
this.DbContext = new Dictionary<string, XTokenResponse> ();
}
public async Task<bool> IsTokenExists (string accessToken) {
//
// Validate Args ...
if (accessToken.IsNullOrEmpty ()) {
return false;
}
//
// Process Result ...
var result = DbContext.Keys.Any (k => k == accessToken);
return await Task.FromResult (result);
}
public async Task<bool> IsTokenExists (XTokenResponse tokens) {
//
// Validate Args ...
if (tokens.IsNull () ||
tokens.AccessToken.IsNullOrEmpty () ||
!await IsTokenExists (tokens.AccessToken)) {
return false;
};
//
// Process Result ...
var result = await IsTokenExists (tokens.AccessToken);
return result;
}
public async Task<bool> RemoveToken (string accessToken) {
//
// Validate Args ...
if (accessToken.IsNullOrEmpty ()) {
return false;
}
//
// Process Result ...
var result = DbContext.Remove (accessToken);
return await Task.FromResult (result);
}
public async Task<bool> RemoveToken (XTokenResponse tokens) {
//
// Validate Args ...
if (tokens.IsNull () ||
tokens.AccessToken.IsNullOrEmpty () ||
!await IsTokenExists (tokens.AccessToken)) {
return false;
};
//
// Process Result ...
var result = await RemoveToken (tokens.AccessToken);
return result;
}
public async Task<XTokenResponse> RetrieveToken (string accessToken) {
//
// Validate Args ...
if (accessToken.IsNullOrEmpty () ||
!await IsTokenExists (accessToken)) {
return null;
}
//
// Process Result ...
var result = DbContext[accessToken];
return result;
}
public async Task<bool> AddToken (XTokenResponse tokens) {
//
// Validate Args ...
if (tokens.IsNull () ||
tokens.AccessToken.IsNullOrEmpty () ||
await IsTokenExists (tokens.AccessToken)) {
return false;
};
//
// Process Result ...
try {
//
DbContext.Add (tokens.AccessToken, tokens);
return true;
} catch {
return false;
}
}
public async Task<bool> UpdateToken (XTokenResponse tokens) {
//
// Validate Args ...
if (tokens.IsNull () ||
tokens.AccessToken.IsNullOrEmpty () ||
!await IsTokenExists (tokens.AccessToken)) {
return false;
};
//
// Process Result ...
try {
//
DbContext[tokens.AccessToken] = tokens;
return true;
} catch {
return false;
}
}
public async Task<bool> AddOrUpdateToken (XTokenResponse tokens) {
//
// Validate Args ...
if (tokens.IsNull () ||
tokens.AccessToken.IsNullOrEmpty ()
) {
return false;
};
//
// Process Result ...
try {
//
var isExists = await IsTokenExists (tokens);
if (isExists) {
return await UpdateToken (tokens);
} else {
return await AddToken (tokens);
}
} catch {
return false;
}
}
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Providers\XProxyHelper.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Web;
using xCommons.Extensions;
using xExceptions.Constants;
using xIdentityService.Configuration;
using xIdentityService.Interfaces;
namespace xIdentityService.Providers {
public class XProxyHelper : IXProxyHelper {
//
#region Props ...
public XProxyConfiguration Configuration { get; }
#endregion
//
#region Constructor ...
public XProxyHelper (XProxyConfiguration configuration) {
this.Configuration = configuration;
}
#endregion
//
#region Actions ...
/// <summary>
/// Validate XProxy Configuration for Client ...
/// </summary>
/// <returns></returns>
public bool ValidateConfiguration () {
//
var result = !Configuration.IsNull () &&
!Configuration.Host.IsNullOrEmpty () &&
Configuration.Host.IsValidUrl () &&
Configuration.Routes.HasChild ();
//
return result;
}
/// <summary>
/// retrie Normalize Host ...
/// </summary>
/// <returns></returns>
public string NormalizeHost () {
//
var result = string.Empty;
//
if (!Configuration.IsNull () &&
!Configuration.Host.IsNullOrEmpty () &&
Configuration.Host.IsValidUrl ()
) {
//
result = Configuration.Host
.ToNormalString ();
//
if (result.EndsWith ("/")) {
result = result.Substring (0, result.Length - 1);
}
}
//
return result;
}
/// <summary>
/// retrieve all registred Routes ...
/// </summary>
/// <returns></returns>
public IEnumerable<XProxyRouteDescriptor> GetRoutes () {
//
// Validate Args ...
if (Configuration.IsNull ()) {
return null;
}
//
return Configuration.Routes;
}
/// <summary>
/// Retrieve all Prepared url of Routes ...
/// </summary>
/// <returns></returns>
public IEnumerable<string> GetRouteUrls () {
//
var normalHost = NormalizeHost ();
if (normalHost.IsNullOrEmpty ()) {
return null;
}
//
var result = GetRoutes ()
.Select (r => $"{normalHost}{r.Route}");
//
return result;
}
/// <summary>
/// Find an Specific Route ...
/// </summary>
/// <param name="whereClause"></param>
/// <returns></returns>
public XProxyRouteDescriptor FindRoute (Expression<Func<XProxyRouteDescriptor, bool>> whereClause) {
//
// Validate Arg ...
if (whereClause.IsNull ()) {
return null;
}
//
var whereFunc = whereClause
.Compile ();
//
var result = GetRoutes ()
.FirstOrDefault (whereFunc);
//
return result;
}
/// <summary>
/// Prepare a request url for a Proxy Route ...
/// </summary>
/// <param name="url"></param>
/// <param name="descriptor"></param>
/// <returns></returns>
public string PrepareActionUrlForXProxyRoute (
string url,
XProxyRouteDescriptor descriptor
) {
//
if (!url.IsValidUrl () ||
url.IsNullOrEmpty () ||
!ValidateConfiguration ()
) {
throw XException.InvalidArgs.ToException ();
}
//
// find Route ...
var routeDescriptor = GetRoutes ()
.FirstOrDefault (r => r
.IsSameContent (descriptor)
);
//
// Validate Route Descriptor ...
if (
routeDescriptor.IsNull () ||
routeDescriptor.Route.IsNullOrEmpty ()
) {
throw XException.InvalidArgs.ToException ();
}
//
// Retrieve and Validate Host Address ...
var host = NormalizeHost ();
if (!host.IsValidUrl () ||
host.IsNullOrEmpty ()
) {
throw XException.InvalidArgs.ToException ();
}
//
url = $"{host}{routeDescriptor.Route}/{HttpUtility.UrlEncode(url)}";
//
return url;
}
/// <summary>
/// Prepare a request url for a Selected Proxy Route ...
/// </summary>
/// <param name="url"></param>
/// <param name="whereClause"></param>
/// <returns></returns>
public string PrepareActionUrlForXProxyRoute (
string url,
Expression<Func<XProxyRouteDescriptor, bool>> whereClause
) {
//
if (!url.IsValidUrl () ||
url.IsNullOrEmpty () ||
whereClause.IsNull () ||
!ValidateConfiguration ()
) {
throw XException.InvalidArgs.ToException ();
}
//
var descriptor = FindRoute (whereClause);
//
// find Route ...
var result = PrepareActionUrlForXProxyRoute (
url: url,
descriptor: descriptor
);
//
return result;
}
#endregion
//
#region Private ...
#endregion
}
}
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xIdentityService\Security\XSecurityProvider.cs
using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using xCommons.Extensions;
using xCommons.Helpers;
using xCommons.Providers;
using xIdentityService.Configuration;
using xIdentityService.Interfaces;
namespace xIdentityService.Security {
public partial class XSecurityProvider : IXSecurityProvider {
private readonly string secretKey;
private readonly byte[] iv;
private readonly byte[] key;
private readonly XValidationProvider validationProvider;
public XSecurityProvider (
XIdentityServiceConfiguration identityConfiguration,
XValidationProvider validationProvider
) {
//
this.secretKey = identityConfiguration.XRevisionSecretKey.ToMd5String ();
this.validationProvider = validationProvider;
//
var ivBytes = new byte[16];
var keyBytes = new byte[32];
var secretBytes = Encoding.UTF8.GetBytes (this.secretKey);
//
Array.Copy (
secretBytes,
ivBytes,
secretBytes.Length < ivBytes.Length ?
secretBytes.Length :
ivBytes.Length
);
this.iv = ivBytes;
//
Array.Copy (
secretBytes,
keyBytes,
secretBytes.Length < keyBytes.Length ?
secretBytes.Length :
keyBytes.Length
);
this.key = keyBytes;
// Encoding.UTF8.GetBytes (this.secretKey);
}
public string Encrypt (string plainText) {
//
validationProvider.NotEmpty (plainText);
//
var textBytes = Encoding.UTF8.GetBytes (plainText);
var result = EncryptFromBytes (textBytes);
//
return result;
}
public string Decrypt (string cipherText) {
//
validationProvider.NotEmpty (cipherText);
//
var cipherBytes = Convert.FromBase64String (cipherText);
var result = DecryptFromBytes (cipherBytes);
//
return result;
}
public string EncryptFromBytes (byte[] textBytes) {
//
// Validate Args ...
validationProvider.NotNull (textBytes);
// Declare the string used to hold
// the decrypted text.
byte[] encryptedBytes = null;
// Create an RijndaelManaged object
// with the specified key and IV.
using (var rijAlg = new RijndaelManaged ()) {
//Settings
rijAlg.Mode = CipherMode.CBC;
rijAlg.Padding = PaddingMode.PKCS7;
// rijAlg.FeedbackSize = 128;
rijAlg.Key = key;
rijAlg.IV = iv;
//
using (var encryptor = rijAlg.CreateEncryptor (rijAlg.Key, rijAlg.IV)) {
encryptedBytes = encryptor.TransformFinalBlock (textBytes, 0, textBytes.Length);
}
}
//
return Convert.ToBase64String (encryptedBytes);
}
public string DecryptFromBytes (byte[] cipherBytes) {
//
// Validate Args ...
validationProvider.NotNull (cipherBytes);
// Declare the string used to hold
// the decrypted text.
string plaintext = null;
// Create an RijndaelManaged object
// with the specified key and IV.
using (var rijAlg = new RijndaelManaged ()) {
//Settings
rijAlg.Mode = CipherMode.CBC;
rijAlg.Padding = PaddingMode.PKCS7;
// rijAlg.FeedbackSize = 128;
rijAlg.Key = key;
rijAlg.IV = iv;
// Create a decrytor to perform the stream transform.
var decryptor = rijAlg.CreateDecryptor (rijAlg.Key, rijAlg.IV);
// Create the streams used for decryption.
using (var msDecrypt = new MemoryStream (cipherBytes)) {
using (var csDecrypt = new CryptoStream (msDecrypt, decryptor, CryptoStreamMode.Read)) {
using (var srDecrypt = new StreamReader (csDecrypt)) {
// Read the decrypted bytes from the decrypting stream
// and place them in a string.
plaintext = srDecrypt.ReadToEnd ();
}
}
}
}
//
return plaintext;
}
}
}
Reference in New Issue View Git Blame Copy Permalink