/// <summary> ctor </summary>
public GeneralHttpClient(ApiServiceNames namedhttpClient, HttpClient httpClient)
{
_httpClient = httpClient;
_namedhttpClient = namedhttpClient;
_logger = GeneralContext.GetService <ILogger>();
RequestUrl = $"api/{_namedhttpClient}/";
}
public static JwtBearerEvents ConfigureJwtBearerEvents()
{
return(new JwtBearerEvents
{
OnAuthenticationFailed = context =>
{
if (context.Exception.GetType() == typeof(SecurityTokenExpiredException))
{
context.Response.Headers.Add("Token-Expired", "true");
}
return Task.CompletedTask;
},
OnTokenValidated = context =>
{
// Add the access_token as a claim, as we may actually need it
var accessToken = context.SecurityToken as JwtSecurityToken;
if (accessToken != null)
{
ClaimsIdentity identity = context.Principal.Identity as ClaimsIdentity;
if (identity != null)
{
identity.AddClaim(new Claim("access_token", accessToken.RawData));
IAuthOptions authOptions = GeneralContext.GetService <IAuthOptions>();
AppUser appUser = Util.ReadToken <AppUser>(accessToken.RawData, authOptions.KEY);
if (appUser != null)
{
context.Success();
}
else
{
context.Fail("Unauthorized");
}
}
}
if (!context.Result.Succeeded)
{
context.Response.Headers.Add("Token-OnTokenValidated", "false");
}
return Task.CompletedTask;
},
OnChallenge = context =>
{
if (context.Response.StatusCode < 200 || context.Response.StatusCode > 299)
{
context.Response.Headers.Add("Token-OnChallenge", "false");
}
return Task.CompletedTask;
},
});
}
public static void ConfigureApiAuthentication(this IServiceCollection services, IAuthOptions authOptions)
{
AuthenticationBuilder authenticationBuilder;
if (authOptions.AuthenticationType == "Bearer")
{
authenticationBuilder = services
.AddAuthentication(x =>
{
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
//x.RequireAuthenticatedSignIn = false;
})
.AddJwtBearer(options =>
{
IAuthOptions authOptions = GeneralContext.GetService <IAuthOptions>();
var key = Encoding.ASCII.GetBytes(authOptions.KEY);
options.Events = ConfigureJwtBearerEvents();
options.RequireHttpsMetadata = false;
options.SaveToken = true;
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(key),
ValidateIssuer = false,
ValidateAudience = false,
RequireExpirationTime = false,
ValidateLifetime = true
};
//options.SecurityTokenValidators.Add(new ApiTokenValidator());
});
}
else
{
authenticationBuilder = services.AddAuthentication(ApiAuthSchemes.DefaultAuthScheme);
}
authenticationBuilder.AddCookie(ApiAuthSchemes.DefaultAuthScheme, options =>
{
options.LoginPath = new Microsoft.AspNetCore.Http.PathString("/AdminApi/Login");
});
}
public GeneralLocalizer(IStringLocalizerFactory factory, IHttpContextAccessor httpContextAccessor)
{
_session = httpContextAccessor.HttpContext.Session;
_appConfig = GeneralContext.GetService <TConfig>();
_currentCulture = _appConfig.DefaultCultureName;
_cultureHe = new CultureInfo("he-IL");
_cultureEn = new CultureInfo("en-US");
if (!_session.Contains(SessionKeys.SelectedCultureName))
{
_session.Set(SessionKeys.SelectedCultureName, _currentCulture);
}
switch (_appConfig.Domain)
{
case "TMS":
ResourceType = typeof(GlobalResources);
break;
case "ATD":
ResourceType = typeof(GlobalResourcesAtd);
break;
case "EG":
ResourceType = typeof(GlobalResourcesEg);
break;
default:
ResourceType = typeof(GlobalResources);
break;
}
string resourceTypeName = ResourceType.Name;
//Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.CreateSpecificCulture(culture);
//Thread.CurrentThread.CurrentUICulture = Thread.CurrentThread.CurrentCulture;
var assemblyFullName = ResourceType.GetTypeInfo().Assembly.FullName;
var assemblyName = new AssemblyName(assemblyFullName);
_localizer = factory.Create(resourceTypeName, assemblyName.Name);
}
/// <summary> Create response details /// </summary>
private ApiResponse CreateResponseDetails <TResult>(HttpResponseMessage response, Exception apiException = null, string message = null)
{
ApiResponse apiResponse = null;
try
{
// get action declaredType
Type responseDeclaredType = typeof(TResult); //HttpContext.GetActionReturnType();
HttpStatusCode statusCode = apiException != null ? HttpStatusCode.Conflict : response.StatusCode;
string messageInfo = !response.IsSuccessStatusCode
? response.Content?.ReadAsStringAsync().Result
: response.StatusCode.ToString();
// create api response
apiResponse = new ApiResponse((int)response.StatusCode)
{
TraceId = GeneralContext.CreateTraceId(),
RequestUrl = GeneralContext.HttpContext?.GetRequestUrl(),
Value = responseDeclaredType?.GetDefault(),
ActionType = responseDeclaredType,
Message = message ?? apiException?.GetApiMessageInfo() ?? messageInfo,
Error = apiException != null ? new ApiError(apiException) : null,
StatusCode = $"{(int)statusCode}: {statusCode}"
};
_logger.Information($"traceId: {apiResponse.TraceId}, message: {apiResponse.Message}");
}
catch (Exception ex)
{
_logger.Error(ex.GetApiMessageInfo("Unhandled exception"));
//context.Response.StatusCode = StatusCodes.Status500InternalServerError;
}
return(apiResponse);
}
public async Task <string> SendAsync(object data, string returnUrl)
{
var dataString = JsonConvert.SerializeObject(data);
//var userByteArray = loggedUser.ToByteArrayUtf8();
//var encryptData = Convert.ToBase64String(userByteArray);
IAuthOptions authOptions = GeneralContext.GetService <IAuthOptions>();
string encryptedData = Util.EncryptText(dataString, authOptions.KEY);
var httpRequestMessage = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = _httpClient.BaseAddress,
Content = new StringContent(encryptedData)
}; //GeneralContext.GetSessionData(_appConfig)
httpRequestMessage.Headers.Add(HttpRequestXHeader.Data.GetDisplayName(), encryptedData);
httpRequestMessage.Headers.Add(HttpRequestXHeader.ReturnUrl.GetDisplayName(), returnUrl);
var response = await _httpClient.SendAsync(httpRequestMessage);
return(response.StatusCode == HttpStatusCode.Redirect
? response.Headers.Location.OriginalString
: null);
}
