public async Task <IActionResult> Login(LoginInputVM model)
{
if (ModelState.IsValid)
{
// check password
bool correctPassword = await _userDataService.CheckUserPassword(model.Username, model.Password);
if (!correctPassword)
{
ModelState.AddModelError("", AuthenticationOptions.InvalidCredentialsErrorMessage);
return(await Login(Request.Query["returnUrl"]));
}
// get user object
var user = await _userDataService.GetUserByUsername(model.Username);
await LogUserIn(user, model.RememberLogin);
Microsoft.Extensions.Primitives.StringValues returnUrl = "";
if (Request.Query.TryGetValue("returnUrl", out returnUrl))
{
return(Redirect(Request.Query["returnUrl"]));
}
return(RedirectToAction("index", "home"));
}
ModelState.AddModelError("", AuthenticationOptions.InvalidCredentialsErrorMessage);
return(await Login(Request.Query["returnUrl"]));
}
/// <summary>
/// Get a value indicating whether the request is made by search engine (web crawler)
/// </summary>
/// <returns>Result</returns>
public virtual bool IsSearchEngine()
{
if (_httpContextAccessor?.HttpContext == null)
{
return(false);
}
try
{
BrowscapXmlHelper browscapXmlHelper = GetBrowscapXmlHelper();
//we cannot load parser
if (browscapXmlHelper == null)
{
return(false);
}
Microsoft.Extensions.Primitives.StringValues userAgent = _httpContextAccessor.HttpContext.Request.Headers[HeaderNames.UserAgent];
return(!string.IsNullOrWhiteSpace(userAgent) && browscapXmlHelper.IsCrawler(userAgent));
}
catch
{
// ignored
}
return(false);
}
public async Task <IActionResult> Register(RegisterVM model)
{
if (ModelState.IsValid)
{
var user = new User()
{
Email = model.Email
};
try
{
var newUser = await _userDataService.Create(user, model.Password);
if (newUser != null)
{
await LogUserIn(newUser, false);
Microsoft.Extensions.Primitives.StringValues returnUrl = "";
if (Request.Query.TryGetValue("returnUrl", out returnUrl))
{
return(Redirect(Request.Query["returnUrl"]));
}
return(RedirectToAction("MyProfile", "Account"));
}
}
catch (Exception ex)
{
// add errors...
return(View(model));
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public virtual async Task InvokeAsync(HttpContext context, RequestDelegate next)
{
_logger.Here(l => l.Entering(_correlationProvider, CorrelationIdHeaderName, _obtainCorrelationIdFromRequestHeaders));
if (_obtainCorrelationIdFromRequestHeaders)
{
string lowerCaseCorrelationIdHeaderName = CorrelationIdHeaderName.ToLower();
Microsoft.Extensions.Primitives.StringValues headerValue = context.Request.Headers.FirstOrDefault(x => x.Key.ToLower() == lowerCaseCorrelationIdHeaderName).Value;
if (headerValue.Count > 0)
{
var correlationValue = headerValue.First();
_logger.Here(l => l.LogTrace("Using {@0} header value {@1} as correlation id.", CorrelationIdHeaderName, correlationValue));
_correlationProvider.SetCorrelationId(correlationValue);
}
}
CorrelationProvider.CurrentCorrelationProvider = _correlationProvider;
using (_logger.BeginScope(new[] { new KeyValuePair <string, object>(Constants.CorrelationId, _correlationProvider.GetCorrelationId()) }))
{
await next(context);
}
_logger.Here(l => l.Exiting());
}
public void GetsUserTokenFromHeaderWithJwtTokenSourceSetToHeader()
{
var user = new ClaimsPrincipal();
var mockHttpContextAccessor = new Mock <IHttpContextAccessor>();
mockHttpContextAccessor.SetupGet(m => m.HttpContext.User)
.Returns(user);
var mockRequest = new Mock <HttpRequest>();
var userToken = "user token";
var userTokenBytes = Encoding.UTF8.GetBytes(userToken);
var mockHeaderDictionary = new Mock <IHeaderDictionary>();
var userTokenHeader = new Microsoft.Extensions.Primitives.StringValues("Bearer " + userToken);
mockHeaderDictionary.SetupGet(d => d["Authorization"]).Returns(userTokenHeader);
mockRequest.SetupGet(s => s.Headers).Returns(mockHeaderDictionary.Object);
var mockHttpContext = new Mock <HttpContext>();
mockHttpContext.SetupGet(c => c.Request).Returns(mockRequest.Object);
mockHttpContextAccessor.SetupGet(c => c.HttpContext).Returns(mockHttpContext.Object);
var authOptions = new AuthOptions {
JwtTokenSource = "header"
};
var mockTokenRefreshAgent = new Mock <ITokenRefreshAgent>();
var authService = new AuthService(mockHttpContextAccessor.Object, mockTokenRefreshAgent.Object, Mock.Of <IUrlHelperFactory>(), Options.Create(authOptions), Mock.Of <IAuthenticationService>());
var returnedUserToken = authService.UserToken;
Assert.Equal(userToken, returnedUserToken);
}
public override void OnActionExecuting(ActionExecutingContext context)
{
Microsoft.Extensions.Primitives.StringValues authorizationHeader = "";
bool headerPresent = context.HttpContext.Request.Headers.TryGetValue("Authorization", out authorizationHeader);
if (headerPresent)
{
// extract and parse header value
var headerValue = authorizationHeader.ToString();
var headerParts = headerValue.Split(':');
// authenticate
if (headerParts.Length == 2)
{
AppUser matchingUser = null;
bool found = AppUsers.TryGetValue(headerParts[0], out matchingUser);
if (found && headerParts[1] == matchingUser.Password)
{
return;
}
}
}
// reaching here means authentication failed
context.Result = new UnauthorizedResult();
}
public GroupsController(IMediator mediator, IConfiguration configuration)
{
_mediator = mediator;
_configuration = configuration;
vSignInName = new Microsoft.Extensions.Primitives.StringValues();
_exceptionHandler = new ExceptionHandler();
}
public static void AddHeader(this IHeaderDictionary headers, string key, string value)
{
var values = new Microsoft.Extensions.Primitives.StringValues(value);
var pair = new KeyValuePair <string, Microsoft.Extensions.Primitives.StringValues>(key, values);
headers.Add(pair);
}
public async Task Http_context_maps_if_none_match()
{
//Arrange
const string fakeEtag = "84de625db71b56d480d47bdc32377d23144b8c65";
var fakeIfNoneMatch = new Microsoft.Extensions.Primitives.StringValues(fakeEtag);
var context = A.Fake <HttpContext>();
var response = A.Fake <HttpResponse>();
var request = A.Fake <HttpRequest>();
A.CallTo(() => request.Headers.TryGetValue(HeaderNames.IfNoneMatch, out fakeIfNoneMatch))
.Returns(true);
A.CallTo(() => context.Request).Returns(request);
A.CallTo(() => response.Headers.ContainsKey(HeaderNames.ETag)).Returns(true);
A.CallTo(() => response.Headers[HeaderNames.ETag]).Returns(fakeEtag);
A.CallTo(() => context.Response).Returns(response);
//Act
var cachedResponse = new CachedResponse(context, Array.Empty <byte>());
await cachedResponse.MapToContext(context);
//Assert
Assert.Equal(cachedResponse.Headers[HeaderNames.ETag], response.Headers[HeaderNames.ETag]);
Assert.Equal(StatusCodes.Status304NotModified, response.StatusCode);
Assert.Equal(0, response.ContentLength);
}
public async Task <ActionResult> CreateAsync(IFormCollection collection)
{
try
{
var requestEnvironment = new RaaSP_Portal_External.DataAccess.Models.Request.Environment();
var environment = new Microsoft.Extensions.Primitives.StringValues();
var requestUser = new User();
var user = new Microsoft.Extensions.Primitives.StringValues();
collection.TryGetValue("user", out user);
//TODO: Cast Form Object to Environment Model
Uri businessUser = await CreateUserRequestAsync(requestUser);
if (collection.ContainsKey("environment"))
{
collection.TryGetValue("environment", out environment);
//TODO: Cast Form Object to Environment Model
Uri businessEnvironment = await CreateEnvironmentRequestAsync(requestEnvironment);
}
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public async Task PostGet()
{
var metadataOnly = GetBoolValueQueryString("metadataOnly", required: false) ?? false;
using (ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
{
var docs = await context.ReadForMemoryAsync(RequestBodyStream(), "docs");
if (docs.TryGet("Ids", out BlittableJsonReaderArray array) == false)
{
ThrowRequiredPropertyNameInRequest("Ids");
}
var ids = new string[array.Length];
for (int i = 0; i < array.Length; i++)
{
ids[i] = array.GetStringByIndex(i);
}
context.OpenReadTransaction();
// init here so it can be passed to TW
var idsStringValues = new Microsoft.Extensions.Primitives.StringValues(ids);
if (TrafficWatchManager.HasRegisteredClients)
{
AddStringToHttpContext(idsStringValues.ToString(), TrafficWatchChangeType.Documents);
}
await GetDocumentsByIdAsync(context, idsStringValues, metadataOnly);
}
}
public void OnAuthorization(AuthorizationFilterContext context)
{
if (context != null)
{
if (context.HttpContext.Response.Headers.ContainsKey("Token-Expired"))
{
context.HttpContext.Response.StatusCode = StatusCodes.Status401Unauthorized;
context.Result = new JsonResult("")
{
Value = new { Error = "User is not logged in" }
};
return;
}
if (context.HttpContext.Request.Headers.ContainsKey("Authorization"))
{
Microsoft.Extensions.Primitives.StringValues accessToken_Bearear = context.HttpContext.Request.Headers["Authorization"];
User User = _tokenValidatorService.AuthenticateUser(accessToken_Bearear.ToString().Split("Bearer")[1]?.Trim());
if (User != null)
{
// nothing to do
}
else
{
context.Result = new JsonResult("")
{
Value = new { Error = "User is not logged in" }
};
}
}
}
}
/// <summary>
/// 验证登录的情况
/// </summary>
/// <param name="context"></param>
/// <param name="type">0=检查登录，获取用户信息，不退出；1=检查登录，未登录直接退出</param>
protected void CheckLogin(ActionExecutingContext context, int type)
{
CurrentUserTicket = new TicketEntity();
Microsoft.Extensions.Primitives.StringValues token = context.HttpContext.Request.Headers["AccessToken"];
if (!string.IsNullOrWhiteSpace(token))
{
//存在AccessToken值，进行验证
RedisCacheTicket authBase = new RedisCacheTicket(token);
TicketEntity userTicket = authBase.CurrentUserTicket;
if (userTicket != null && userTicket.MemberID > 0)
{
CurrentUserTicket = userTicket;
return;
}
}
if (type == 1)
{
//以上检查未登录，直接退出
//直接输出结果，不经过Controller
ResponseResult result = new ResponseResult()
{
errno = 30,
errmsg = "请重新登录",
};
context.Result = new ContentResult()
{
Content = result.SerializeObject(), StatusCode = 200
};
}
}
public IActionResult PedidoSocio(IFormCollection data)
{
Microsoft.Extensions.Primitives.StringValues indicativo = data["Indicativo"];
string telemovel = HelperFunctions.NormalizeWhiteSpace(data["Telemovel"]);
string nome = HelperFunctions.NormalizeWhiteSpace(data["Nome"]);
if (ModelState.IsValid)
{
PedidoSocio p = new PedidoSocio()
{
DataNascimento = DateTime.Parse(data["DataNascimento"]),
Email = data["Email"],
Fotografia = data["Fotografia"],
Nacionalidade = data["Nacionalidade"],
Nome = nome,
Sexo = data["sexo"],
Username = data["Username"],
Telemovel = new string("+" + indicativo + telemovel),
NumCC = data["NumCC"]
};
_context.PedidosSocios.Add(p);
_context.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
return(View());
}
public bool TryGetValue(string key, out Microsoft.Extensions.Primitives.StringValues value)
{
var success = _data.TryGetValue(key, out var val);
value = new Microsoft.Extensions.Primitives.StringValues(val);
return(success);
}
private async Task GetDocumentsByIdAsync(DocumentsOperationContext context, Microsoft.Extensions.Primitives.StringValues ids, bool metadataOnly)
{
var sw = Stopwatch.StartNew();
var includePaths = GetStringValuesQueryString("include", required: false);
var documents = new List <Document>(ids.Count);
var includes = new List <Document>(includePaths.Count * ids.Count);
var includeDocs = new IncludeDocumentsCommand(Database.DocumentsStorage, context, includePaths, isProjection: false);
GetCountersQueryString(Database, context, out var includeCounters);
GetTimeSeriesQueryString(Database, context, out var includeTimeSeries);
GetCompareExchangeValueQueryString(Database, out var includeCompareExchangeValues);
using (includeCompareExchangeValues)
{
foreach (var id in ids)
{
Document document = null;
if (string.IsNullOrEmpty(id) == false)
{
document = Database.DocumentsStorage.Get(context, id);
}
if (document == null && ids.Count == 1)
{
HttpContext.Response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
documents.Add(document);
includeDocs.Gather(document);
includeCounters?.Fill(document);
includeTimeSeries?.Fill(document);
includeCompareExchangeValues?.Gather(document);
}
includeDocs.Fill(includes);
includeCompareExchangeValues?.Materialize();
var actualEtag = ComputeHttpEtags.ComputeEtagForDocuments(documents, includes, includeCounters, includeTimeSeries, includeCompareExchangeValues);
var etag = GetStringFromHeaders("If-None-Match");
if (etag == actualEtag)
{
HttpContext.Response.StatusCode = (int)HttpStatusCode.NotModified;
return;
}
HttpContext.Response.Headers[Constants.Headers.Etag] = "\"" + actualEtag + "\"";
int numberOfResults = 0;
numberOfResults = await WriteDocumentsJsonAsync(context, metadataOnly, documents, includes, includeCounters?.Results, includeTimeSeries?.Results,
includeCompareExchangeValues?.Results, numberOfResults);
AddPagingPerformanceHint(PagingOperationType.Documents, nameof(GetDocumentsByIdAsync), HttpContext.Request.QueryString.Value, numberOfResults,
documents.Count, sw.ElapsedMilliseconds);
}
}
public void OnAuthorization(AuthorizationFilterContext context)
{
Microsoft.Extensions.Primitives.StringValues token = context.HttpContext.Request.Headers["AccessToken"];
if (!string.IsNullOrWhiteSpace(token))
{
//存在AccessToken值，进行验证
//RedisCacheTicket authBase = new RedisCacheTicket(token);
//TicketEntity userTicket = authBase.CurrentUserTicket;
//if (userTicket != null && userTicket.ID.ToLong() > 0)
//{
// CurrentUserTicket = userTicket;
// return;
//}
}
//直接输出结果，不经过Controller
ResponseResult result = new ResponseResult()
{
errno = 30,
errmsg = "请重新登录",
};
context.Result = new ContentResult()
{
Content = result.SerializeObject(), StatusCode = 200
};
}
public static async Task sendMsg(Microsoft.Extensions.Primitives.StringValues fromUrl, string json)
{
using (HttpClient client = new HttpClient())
{
Uri u = new Uri(fromUrl);
HttpContent c = new StringContent(json, Encoding.UTF8, "application/json");
HttpRequestMessage request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = u,
Content = c
};
HttpResponseMessage result = await client.SendAsync(request);
// BaseInfomation.Client.
if (result.IsSuccessStatusCode)
{
// response = result.StatusCode.ToString();
}
else
{
Console.WriteLine($"{fromUrl}推送失败！");
}
client.Dispose();
}
}
public async Task Invoke(HttpContext context)
{
// Do something here
//context.Response.ContentType = "application/pdf";
//await context.Response.Body.WriteAsync
Microsoft.Extensions.Primitives.StringValues paramFileName = new Microsoft.Extensions.Primitives.StringValues();
context.Request.Query.TryGetValue("filename", out paramFileName);
string FileName = paramFileName.ToString();
if (FileName != "")
{
try
{
byte[] FileBytes = File.ReadAllBytes(FileName);
context.Response.StatusCode = StatusCodes.Status200OK;
context.Response.ContentType = "application/pdf";
await context.Response.Body.WriteAsync(FileBytes, 0, FileBytes.Length);
}
catch (Exception ex)
{
context.Response.StatusCode = StatusCodes.Status500InternalServerError;
await context.Response.WriteAsync(ex.Message);
}
}
else
{
context.Response.StatusCode = StatusCodes.Status500InternalServerError;
await context.Response.WriteAsync("URL requires a filename parameter.");
}
}
public string Get()
{
Microsoft.Extensions.Primitives.StringValues SecureToken = string.Empty;
//HttpContext httpContext = null;
_httpContext.HttpContext.Request.Headers.TryGetValue("UserName", out SecureToken);
return(SecureToken);
}
public override void OnActionExecuting(ActionExecutingContext context)
{
base.OnActionExecuting(context);
Microsoft.Extensions.Primitives.StringValues token = context.HttpContext.Request.Headers["AccessToken"];
if (!string.IsNullOrWhiteSpace(token))
{
//存在AccessToken值，进行验证
var userTicket = redisRepository.GetValueAsync <UserTicket>(token).Result;
if (userTicket != null && userTicket.ID.ToLong() > 0)
{
return;
}
}
//其它情况直接跳出，直接输出结果
ResponseResult result = new ResponseResult()
{
errno = 30,
errmsg = "请重新登录",
};
context.Result = new ContentResult()
{
Content = result.SerializeObject(), StatusCode = 200
};
}
public Task BindModelAsync(ModelBindingContext bindingContext)
{
if (bindingContext == null)
{
throw new ArgumentNullException(nameof(bindingContext));
}
var result = new Dictionary <string, object> {
};
var form = bindingContext.HttpContext.Request.Form;
if (form == null)
{
bindingContext.ModelState.AddModelError("FormData", "The data is null");
return(Task.CompletedTask);
}
foreach (var k in form.Keys)
{
Microsoft.Extensions.Primitives.StringValues v = string.Empty;
var flag = form.TryGetValue(k, out v);
if (flag)
{
result.Add(k, v);
}
}
bindingContext.Result = ModelBindingResult.Success(result);
return(Task.CompletedTask);
}
private static string BuildQueryFromRequest(Microsoft.Extensions.Primitives.StringValues filters, out List <object> values)
{
var query = "";
values = new List <object>();
foreach (var filter in filters)
{
foreach (var op in Operators)
{
var args = filter.Split(op);
if (args.Length > 1)
{
var field = args[0];
var value = args[1];
if (query != string.Empty)
{
query += " and ";
}
query += $"{field} {op} @{values.Count}";
//check if numeric
if (int.TryParse(value, out int newValue))
{
values.Add(newValue);
}
else
{
values.Add(value);
}
}
}
}
return(query);
}
public async Task <IActionResult> GetTrips([FromHeader] object header)
{
Microsoft.Extensions.Primitives.StringValues value = "";
var coll = Request.Headers.TryGetValue("Authorization", out value);
var values = value.ToString().Split().ToList();
var stream = values[1];
var handler = new JwtSecurityTokenHandler();
var jsonToken = handler.ReadToken(stream);
var tokenS = handler.ReadToken(stream) as JwtSecurityToken;
//await CommandDispatcher.DispatchAsync(command);
var userId = Guid.Parse(tokenS.Claims.First().Value);
var trips = await _context.Trips.Where(x => x.UserId == userId).ToListAsync();
Dictionary <string, Tuple <string, List <string> > > tripList = new Dictionary <string, Tuple <string, List <string> > >();
List <TripPOCOs> trip_list = new List <TripPOCOs>();
foreach (var trip in trips)
{
var _trips = new TripPOCOs();
_trips.locations = _context.Destinations.Where(x => x.TripId == trip.Id).Select(x => x.Name).ToList();
_trips.image_url = trip.PhotoUrl;
_trips.name = trip.TripName;
_trips.created_at = trip.CreatedAt.ToString("g",
DateTimeFormatInfo.InvariantInfo);
_trips.Id = trip.Id;
trip_list.Add(_trips);
}
return(Json(new
{
trip_list
}));
}
public override void OnActionExecuting(ActionExecutingContext context)
{
base.OnActionExecuting(context);
Microsoft.Extensions.Primitives.StringValues token = context.HttpContext.Request.Headers["AccessToken"];
if (!string.IsNullOrWhiteSpace(token))
{
//存在AccessToken值，进行验证
RedisCacheTicket authBase = new RedisCacheTicket(token);
TicketEntity userTicket = authBase.CurrentUserTicket;
if (userTicket != null && userTicket.MemberID > 0)
{
CurrentUserTicket = userTicket;
return;
}
}
//直接输出结果，不经过Controller
ResponseResult result = new ResponseResult()
{
errno = 30,
errmsg = "请重新登录",
};
context.Result = new ContentResult()
{
Content = SerializerJson.SerializeObject(result), StatusCode = 200
};
}
/// <summary>
/// Checks for the presence of API Key that is configured in Freshchat webhook.
/// </summary>
/// <param name="context"></param>
void IAuthorizationFilter.OnAuthorization(AuthorizationFilterContext context)
{
var freshChatHeaderPresent = context.HttpContext.Request.Headers.Keys.Where(k => string.Compare(k, "X-Freshchat-Signature", true) == 0);
if (!freshChatHeaderPresent.Any())
{
context.Result = new BadRequestObjectResult("Missing X-Freshchat-Signature header.");
}
else
{
Microsoft.Extensions.Primitives.StringValues apiKeyValues = default(Microsoft.Extensions.Primitives.StringValues);
if (context.HttpContext.Request.Query.TryGetValue("freshchatAPIKey", out apiKeyValues))
{
if (apiKeyValues.Count > 0)
{
string apiKey = apiKeyValues[0];
IFreshChatClientService freshChatClient = (IFreshChatClientService)context.HttpContext.RequestServices.GetService(typeof(IFreshChatClientService));
if (!freshChatClient.VerifyCall(apiKey))
{
context.Result = new UnauthorizedResult();
}
}
else
{
context.Result = new BadRequestObjectResult("Missing freshchatAPIKey.");
}
}
else
{
context.Result = new BadRequestObjectResult("Missing freshchatAPIKey.");
}
}
}
private void AddedBearerErrorHeader(AuthorizationFilterContext context, string BearerError, string BearerErrorDescription)
{
string formatError = string.Format("Bearer error=\"{0}\", error_description=\"{1}\"", BearerError, BearerErrorDescription);
Microsoft.Extensions.Primitives.StringValues authError = new Microsoft.Extensions.Primitives.StringValues(formatError);
context.HttpContext.Response.Headers.Add("www-authenticate", authError);
LogWarningMessage("Autherization Bearer Errror: " + formatError);
}
private async Task <RecaptchaResponse> SendVerifyRequestAsync(Microsoft.Extensions.Primitives.StringValues response)
{
var result = await Client.PostAsync($"https://{RecaptchaSettings.Site}/recaptcha/api/siteverify", new StringContent(
$"secret={RecaptchaSettings.SecretKey}&response={response}", Encoding.UTF8, "application/x-www-form-urlencoded"));
var captchaResponse = JsonSerializer.Deserialize <RecaptchaResponse>(await result.Content.ReadAsStringAsync());
return(captchaResponse);
}
public static string GetCustomerId(this Microsoft.AspNetCore.Mvc.Controller controller)
{
Microsoft.Extensions.Primitives.StringValues customerId = Microsoft.Extensions.Primitives.StringValues.Empty;
if (!controller.HttpContext.Request.Headers.TryGetValue("customerId", out customerId))
{
return(string.Empty);
}
return(customerId.ToString().ToLower());
}
Microsoft.Extensions.Primitives.StringValues GetFormValue(HttpRequest request, string key)
{
Microsoft.Extensions.Primitives.StringValues val = new Microsoft.Extensions.Primitives.StringValues();
if (request.Form.TryGetValue(key, out val))
{
return(val);
}
return(val);
}
