public async Task CanMakeUrlRequest()
{
var taskCompletionSource = new TaskCompletionSource <string>(TaskCreationOptions.RunContinuationsAsynchronously);
IUrlRequest urlRequest = null;
int statusCode = -1;
//Can be created on any valid CEF Thread, here we'll use the CEF UI Thread
await Cef.UIThreadTaskFactory.StartNew(delegate
{
var requestClient = new UrlRequestClient((IUrlRequest req, byte[] responseBody) =>
{
statusCode = req.Response.StatusCode;
taskCompletionSource.TrySetResult(Encoding.UTF8.GetString(responseBody));
});
var request = new Request();
request.Method = "GET";
request.Url = "https://code.jquery.com/jquery-3.4.1.min.js";
//Global RequestContext will be used
urlRequest = new UrlRequest(request, requestClient);
});
var stringResult = await taskCompletionSource.Task;
Assert.True(!string.IsNullOrEmpty(stringResult));
Assert.Equal(200, statusCode);
}
private static void OnResolveRequest(IUrlRequest request, bool throwException, Action <IRoutingContext, ResponseStatus> requestCallback)
{
if (!string.IsNullOrEmpty(request.SiteArea) && !SiteMapService.IsSiteAreaInitialized(request.SiteArea))
{
SiteMapService.InitializeSiteArea(request.SiteArea, (a) =>
{
if (a)
{
var _context = (IRoutingContext)null;
var _status = OnResolveRoute(request, throwException, out _context);
requestCallback(_context, _status);
}
else
{
if (throwException)
{
throw new SiteMapException(string.Format(SITEAREA_NOT_RESOLVED, request.SiteArea, request.RequestUrl),
request.SiteArea, request);
}
else
{
requestCallback(null, ResponseStatus.HandlerNotFound);
}
}
});
}
else
{
var _context = (IRoutingContext)null;
var _status = OnResolveRoute(request, throwException, out _context);
requestCallback(_context, _status);
}
}
public override RouteData GetRouteData(IUrlRequest request)
{
string virtualPath = request.RequestUrl;
ParametersCollection values = this._parsedRoute.Match(virtualPath, this.Defaults);
if (values == null)
{
return(null);
}
RouteData data = new RouteData(this, this.RouteHandler);
if (!this.ProcessConstraints(request, values, RouteDirection.IncomingRequest))
{
return(null);
}
foreach (var pair in values)
{
data.Values.Add(pair.Key, pair.Value);
}
if (this.DataTokens != null)
{
foreach (var pair2 in this.DataTokens)
{
data.DataTokens[pair2.Key] = pair2.Value;
}
}
return(data);
}
protected override void OnRequestComplete(IUrlRequest request)
{
logic.OnRequestComplete(request.RequestStatus switch {
UrlRequestStatus.Success => Success,
UrlRequestStatus.Failed => Failed,
_ => Unknown
});
public RoutingContext(IUrlRequest request, RouteData routeData, ParametersCollection parsedParameters)
{
Guard.ArgumentNotNull(request, "request");
Guard.ArgumentNotNull(routeData, "routeData");
Guard.ArgumentNotNull(parsedParameters, "parsedParameters");
_request = request;
_routeData = routeData;
_parsedParameters = parsedParameters;
}
internal UrlResponse(IUrlRequest request, ResponseStatus responseStatus,
Object content, ParametersCollection responseParameters, Exception error)
{
Guard.ArgumentNotNull(request, "request");
_request = request;
_responseStatus = responseStatus;
_content = content;
_responseParameters = responseParameters;
_error = error;
}
private bool ProcessConstraints(IUrlRequest request, ParametersCollection values, RouteDirection routeDirection)
{
if (this.Constraints != null)
{
foreach (var pair in this.Constraints)
{
if (!this.ProcessConstraint(request, pair.Value, pair.Key, values, routeDirection))
{
return(false);
}
}
}
return(true);
}
public static void Resolve(IUrlRequest request, Action <IUrlResponse> responseCallback)
{
Guard.ArgumentNotNull(request, "request");
Guard.ArgumentNotNull(responseCallback, "responseCallback");
OnResolveRequest(request, false, (c, s) =>
{
if (s != ResponseStatus.Success)
{
var _response = new UrlResponse(request, s, null);
responseCallback(_response);
}
else
{
// and we get the response, using a callback
OnResolveResponse(c, false, responseCallback);
}
});
}
//private IRoutingContext GetContext(IRoutingContext context)
//{
// if (context != null)
// {
// return context;
// }
// IRoutingRequest current = context.IRoutingRequest;
// if (current == null)
// {
// throw new InvalidOperationException(RouteCollection_RequiresContext);
// }
// return new RoutingContext(current, new RouteData());
//}
public RouteData GetRouteData(IUrlRequest request)
{
Guard.ArgumentNotNull(request, "request");
Guard.ArgumentValue(string.IsNullOrEmpty(request.RequestUrl), "request", ROUTING_URL_REQUIRED);
Guard.ArgumentValue(((request.RequestUrl.StartsWith("~", StringComparison.Ordinal) ||
request.RequestUrl.StartsWith("/", StringComparison.Ordinal)) ||
(request.RequestUrl.IndexOf('?') != -1)), "url", ROUTE_INVALID_ROUTE_URL);
using (this.GetReadLock())
{
foreach (RouteBase base2 in this)
{
RouteData routeData = base2.GetRouteData(request);
if (routeData != null)
{
return(routeData);
}
}
}
return(null);
}
///// <summary>this is not required in this framework since we only work with relative urls </summary>
//public override VirtualPathData GetVirtualPath(IRoutingContext context, ParametersDictionary values)
//{
// BoundUrl url = this._parsedRoute.Bind(context.RouteData.Values, values, this.Defaults, this.Constraints);
// if (url == null)
// {
// return null;
// }
// if (!this.ProcessConstraints(context.Request, url.Values, RouteDirection.UrlGeneration))
// {
// return null;
// }
// VirtualPathData data = new VirtualPathData(this, url.Url);
// if (this.DataTokens != null)
// {
// foreach (KeyValuePair<string, object> pair in this.DataTokens)
// {
// data.DataTokens[pair.Key] = pair.Value;
// }
// }
// return data;
//}
#endregion
#region Internal
protected virtual bool ProcessConstraint(IUrlRequest request, object constraint,
string parameterName, ParametersCollection values, RouteDirection routeDirection)
{
object obj2;
IRouteConstraint constraint2 = constraint as IRouteConstraint;
if (constraint2 != null)
{
return(constraint2.Match(request, this, parameterName, values, routeDirection));
}
string str = constraint as string;
if (str == null)
{
throw new InvalidOperationException(string.Format(Route_ValidationMustBeStringOrCustomConstraint,
new object[] { parameterName, this.Url }));
}
values.TryGetValue(parameterName, out obj2);
string input = Convert.ToString(obj2, CultureInfo.InvariantCulture);
string pattern = "^(" + str + ")$";
return(Regex.IsMatch(input, pattern, RegexOptions.CultureInvariant | RegexOptions.IgnoreCase));
}
/// <summary>
/// Called when some part of the response is read. This method will not be called if the <see cref="UrlRequestFlags.NoDownloadData"/> flag is set on the request.
/// </summary>
/// <param name="request">request</param>
/// <param name="data">A stream containing the bytes received since the last call. Cannot be used outside the scope of this method. </param>
protected virtual void OnDownloadData(IUrlRequest request, Stream data)
{
}
/// <summary>
/// Called when some part of the response is read. This method will not be called if the <see cref="UrlRequestFlags.NoDownloadData"/> flag is set on the request.
/// </summary>
/// <param name="request">request</param>
/// <param name="data">A stream containing the bytes received since the last call. Cannot be used outside the scope of this method. </param>
void IUrlRequestClient.OnDownloadData(IUrlRequest request, Stream data)
{
OnDownloadData(request, data);
}
public static void ResolveContext(IUrlRequest request, Action <IRoutingContext> contextCallback)
{
Guard.ArgumentNotNull(request, "request");
Guard.ArgumentNotNull(contextCallback, "contextCallback");
OnResolveRequest(request, true, (c, s) => contextCallback(c));
}
public SiteMapException(string message, string siteMapNode, IUrlRequest request, Exception innerException)
: base(message, innerException)
{
_siteMapNode = siteMapNode;
_request = request;
}
protected override void OnDownloadData(IUrlRequest request, Stream data)
{
logic.OnDownloadData(data);
}
public UrlResponse(IUrlRequest request, ResponseStatus responseStatus, Exception error)
: this(request, responseStatus, null, null, error)
{
}
public UrlResponse(IUrlRequest request, ResponseStatus responseStatus,
Object content, ParametersCollection responseParameters)
: this(request, responseStatus, content, responseParameters, null)
{
}
/// <summary>
/// Notifies the client of download progress.
/// </summary>
/// <param name="request">request</param>
/// <param name="current">denotes the number of bytes received up to the call </param>
/// <param name="total">is the expected total size of the response (or -1 if not determined).</param>
void IUrlRequestClient.OnDownloadProgress(IUrlRequest request, long current, long total)
{
OnDownloadProgress(request, current, total);
}
/// <summary>
/// Notifies the client of download progress.
/// </summary>
/// <param name="request">request</param>
/// <param name="current">denotes the number of bytes received up to the call </param>
/// <param name="total">is the expected total size of the response (or -1 if not determined).</param>
protected virtual void OnDownloadProgress(IUrlRequest request, long current, long total)
{
}
/// <inheritdoc/>
protected override void OnDownloadData(IUrlRequest request, Stream data)
{
onDownloadData?.Invoke(request, data);
}
/// <inheritdoc/>
protected override void OnRequestComplete(IUrlRequest request)
{
onRequestComplete?.Invoke(request);
}
//This method should provide the response for the specified request
public IUrlResponse Handle(IUrlRequest request)
{
string htmlContent = "Request Url: " + request.Url + "\n";
return(new UrlResponse(Encoding.UTF8.GetBytes(htmlContent)));
}
public SiteMapException(string message, string siteMapNode, IUrlRequest request)
: this(message, siteMapNode, request, null)
{
}
void IUrlRequestClient.OnRequestComplete(IUrlRequest request)
{
this?.completeAction(request, responseBody.ToArray());
}
/// <inheritdoc/>
protected override void OnUploadProgress(IUrlRequest request, long current, long total)
{
onUploadProgress?.Invoke(request, current, total);
}
private static ResponseStatus OnResolveRoute(IUrlRequest request, bool throwException, out IRoutingContext context)
{
Guard.ArgumentNotNull(request, "request");
Guard.ArgumentValue((!ValidateUrl(request.RequestUrl, false)), "request", INVALID_REQUEST_URL);
// default value
context = null;
// we check the url
if (!ValidateUrl(request.RequestUrl, throwException))
{
return(ResponseStatus.UrlInvalid);
}
// we get the route data first
RouteData routeData = RouteTable.Routes.GetRouteData(request);
if (routeData == null)
{
if (throwException)
{
throw new InvalidOperationException(NO_ROUTE_MATCHES);
}
return(ResponseStatus.UrlNotFound);
}
// we get the route handler
IRouteHandler routeHandler = routeData.RouteHandler;
if (routeHandler == null)
{
if (throwException)
{
throw new InvalidOperationException(NO_ROUTE_HANDLER);
}
return(ResponseStatus.HandlerNotFound);
}
// we merge the dictionaries (into the request parameters)
var _requestParameters = new ParametersCollection();
// we add the data-tokens specified with route, n_ote these can be overriden
if (routeData.DataTokens != null && routeData.DataTokens.Count > 0)
{
// we add the values, from the routes data, if it exists then we update the value
foreach (var _parameter in routeData.DataTokens)
{
_requestParameters.Add(_parameter.Key, _parameter.Value);
}
}
// we add the values found in the url merged with the default values, n_ote these can be overriden
if (routeData.Values != null && routeData.Values.Count > 0)
{
// we add the values, from the routes data, if it exists then we update the value
foreach (var _parameter in routeData.Values)
{
if (_requestParameters.ContainsKey(_parameter.Key))
{
_requestParameters[_parameter.Key] = _parameter.Value;
}
else
{
_requestParameters.Add(_parameter.Key, _parameter.Value);
}
}
}
// and our passed in parameters will override any existing entry
if (request.RequestParameters != null && request.RequestParameters.Count > 0)
{
foreach (var _parameter in request.RequestParameters)
{
if (_requestParameters.ContainsKey(_parameter.Key))
{
_requestParameters[_parameter.Key] = _parameter.Value;
}
else
{
_requestParameters.Add(_parameter.Key, _parameter.Value);
}
}
}
// we setup the request cotext and get the response
context = new RoutingContext(request, routeData, _requestParameters);
return(ResponseStatus.Success);
}
void IUrlRequestClient.OnDownloadData(IUrlRequest request, Stream data)
{
data.CopyTo(responseBody);
}
/// <summary>
/// Notifies the client that the request has completed.
/// Use the <see cref="IUrlRequest.RequestStatus"/> property to determine if the
/// request was successful or not.
/// </summary>
/// <param name="request">request</param>
void IUrlRequestClient.OnRequestComplete(IUrlRequest request)
{
OnRequestComplete(request);
}
void IUrlRequestClient.OnUploadProgress(IUrlRequest request, long current, long total)
{
}
/// <summary>
/// Notifies the client that the request has completed.
/// Use the <see cref="IUrlRequest.RequestStatus"/> property to determine if the
/// request was successful or not.
/// </summary>
/// <param name="request">request</param>
protected virtual void OnRequestComplete(IUrlRequest request)
{
}
