/// <summary>
/// Processes the request.
/// </summary>
/// <param name="request"></param>
/// <param name="callback"></param>
/// <returns></returns>
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
Url = request.Url;
var application = BaseMainApplication.Current;
application.InvokeOnMainAsync(() =>
{
try
{
var path = application.GetContentPath(request.Url);
if (application.ContentProvider.ContentExists(path))
{
Data = application.ContentProvider.GetContent(path);
}
}
catch (Exception e)
{
Data = null;
Exception = e;
GeneralLog.Error("Content request exception.", e);
}
callback.Continue();
});
return(true);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
Task.Run(() =>
{
using (callback)
{
try
{
_apiResponse = _apiRouter.ProcessRequest(request);
if (_apiResponse.Data != null)
{
_logger.Debug(_apiResponse.Data);
_responseBytes = Encoding.UTF8.GetBytes(_apiResponse.Data);
}
}
catch (Exception exception)
{
_logger.Error(exception, exception.Message);
_apiResponse = new ApiResponse(exception.Message, 500);
}
finally
{
callback.Continue();
}
}
});
return(true);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
try
{
string u = request.Url.Substring(17);
int i = u.IndexOf('/');
string file = u.Substring(0, i) + ":" + u.Substring(i);
file = HttpUtility.UrlDecode(file);
stream = File.Open(file, FileMode.Open);
callback.Continue();
return(true);
}
catch (Exception ex)
{
if (stream != null)
{
stream.Dispose();
}
MessageBox.Show(ex.ToString());
return(false);
}
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
try
{
Uri url = new Uri(request.Url);
string resourceName = url.LocalPath.Substring(1).Replace('/', '.');
resourceName = HttpUtility.UrlDecode(resourceName);
Assembly assm = Assembly.GetEntryAssembly();
stream = assm.GetManifestResourceStream(resourceName);
if (stream == null)
{
throw new Exception("找不到 名为 \"" + resourceName + "\" 的资源 。");
}
callback.Continue();
return(true);
}
catch (Exception ex)
{
if (stream != null)
{
stream.Dispose();
}
MessageBox.Show(ex.ToString());
return(false);
}
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
callback.Continue();
_completed = false;
_transmittedLen = 0;
return(true);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
var requestNo = Interlocked.Increment(ref _requestNo);
var response = new StringBuilder();
response.AppendFormat("<pre>\n");
response.AppendFormat("Requests processed by DemoAppResourceHandler: {0}\n", requestNo);
response.AppendFormat("Method: {0}\n", request.Method);
response.AppendFormat("URL: {0}\n", request.Url);
response.AppendLine();
response.AppendLine("Headers:");
var headers = request.GetHeaderMap();
foreach (string key in headers)
{
foreach (var value in headers.GetValues(key))
{
response.AppendFormat("{0}: {1}\n", key, value);
}
}
response.AppendLine();
response.AppendFormat("</pre>\n");
responseData = Encoding.UTF8.GetBytes(response.ToString());
callback.Continue();
return true;
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
var u = new Uri(request.Url);
var fileAbsolutePath = u.AbsolutePath;
var file = u.Authority + fileAbsolutePath;
if (string.IsNullOrEmpty(Path.GetFileName(file)))
{
file = Path.Combine(file, "index.html");
}
_totalBytesRead = 0;
_chromelyResource.Content = null;
_completed = false;
if (ProcessAssmblyEmbeddedFile(request.Url, file, fileAbsolutePath, callback))
{
return(true);
}
if (ProcessLocalFile(file, callback))
{
return(true);
}
callback.Dispose();
return(false);
}
protected override bool Open(CefRequest request, out bool handleRequest, CefCallback callback)
{
// Backwards compatibility. ProcessRequest will be called.
callback.Dispose();
handleRequest = false;
return(false);
}
public OnProcessRequestEventArgs(string _id, CefRequest _request, CefCallback _callback)
{
id = _id;
request = _request;
callback = _callback;
continueRequest = false; //do not continue by default
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
var requestNo = Interlocked.Increment(ref _requestNo);
var response = new StringBuilder();
response.AppendFormat("<pre>\n");
response.AppendFormat("Requests processed by DemoAppResourceHandler: {0}\n", requestNo);
response.AppendFormat("Method: {0}\n", request.Method);
response.AppendFormat("URL: {0}\n", request.Url);
response.AppendLine();
response.AppendLine("Headers:");
var headers = request.GetHeaderMap();
foreach (string key in headers)
{
foreach (var value in headers.GetValues(key))
{
response.AppendFormat("{0}: {1}\n", key, value);
}
}
response.AppendLine();
response.AppendFormat("</pre>\n");
responseData = Encoding.UTF8.GetBytes(response.ToString());
callback.Continue();
return(true);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
_uri = new Uri(request.Url);
//判断是否本地目录文件
var filePath = Path.GetFullPath(System.Environment.CurrentDirectory + "\\Resources" + _uri.AbsolutePath);
if (File.Exists(filePath))
{
responseData = ReadFileToBinary(filePath);
callback.Continue();
return(true);
}
//判断是否资源文件
var segments = _uri.Segments;
var file = segments[segments.Length - 1];
string resource;
if (resources.TryGetValue(file, out resource) &&
!String.IsNullOrEmpty(resource))
{
responseData = Encoding.UTF8.GetBytes(resource);
callback.Continue();
return(true);
}
process = false;
callback.Continue();
return(false);
}
private bool ProcessLocalFile(string file, CefCallback callback)
{
// Check if file exists and not empty
var fileInfo = new FileInfo(file);
if ((fileInfo.Exists) && fileInfo.Length > 0)
{
Task.Run(() =>
{
using (callback)
{
try
{
_fileBytes = File.ReadAllBytes(file);
string extension = Path.GetExtension(file);
_mime = MimeMapper.GetMimeType(extension);
}
catch (Exception exception)
{
Logger.Instance.Log.LogError(exception, exception.Message);
}
finally
{
callback.Continue();
}
}
});
return(true);
}
return(false);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
var u = new Uri(request.Url);
var file = u.Authority + u.AbsolutePath;
_totalBytesRead = 0;
_fileBytes = null;
_completed = false;
var fileInfo = new FileInfo(file);
// Check if file exists
if (!fileInfo.Exists)
{
_chromelyErrorHandler.HandleResourceError(ResourceStatus.FileNotFound, file, out _statusCode, out _statusText);
_fileBytes = _statusText.GetMemoryStream();
callback.Continue();
}
// Check if file exists but empty
else if (fileInfo.Length == 0)
{
_chromelyErrorHandler.HandleResourceError(ResourceStatus.ZeroFileSize, file, out _statusCode, out _statusText);
_fileBytes = _statusText.GetMemoryStream();
callback.Continue();
}
else
{
Task.Run(() =>
{
using (callback)
{
try
{
_fileBytes = File.ReadAllBytes(file);
string extension = Path.GetExtension(file);
_mime = MimeMapper.GetMimeType(extension);
_statusCode = ResourceConstants.StatusOK;
_statusText = ResourceConstants.StatusOKText;
}
catch (Exception exception)
{
_chromelyErrorHandler.HandleResourceError(ResourceStatus.FileProcessingError, file, exception, out _statusCode, out _statusText);
_fileBytes = _statusText.GetMemoryStream();
}
finally
{
callback.Continue();
}
}
});
return(true);
}
callback.Dispose();
return(false);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
var isCustomScheme = _config?.UrlSchemes?.IsUrlRegisteredCustomScheme(request.Url);
if (isCustomScheme.HasValue && isCustomScheme.Value)
{
Task.Run(() =>
{
using (callback)
{
try
{
var uri = new Uri(request.Url);
var path = uri.LocalPath;
var response = new ChromelyResponse();
if (string.IsNullOrEmpty(path))
{
response.ReadyState = (int)ReadyState.ResponseIsReady;
response.Status = (int)System.Net.HttpStatusCode.BadRequest;
response.StatusText = "Bad Request";
_chromelyResponse = response;
}
else
{
var parameters = request.Url.GetParameters();
var postData = GetPostData(request);
_chromelyResponse = _requestTaskRunner.Run(request.Method, path, parameters, postData);
string jsonData = _chromelyResponse.Data.EnsureResponseDataIsJsonFormat();
_responseBytes = Encoding.UTF8.GetBytes(jsonData);
}
}
catch (Exception exception)
{
Logger.Instance.Log.Error(exception);
_chromelyResponse =
new ChromelyResponse
{
Status = (int)HttpStatusCode.BadRequest,
Data = "An error occured."
};
}
finally
{
callback.Continue();
}
}
});
return(true);
}
Logger.Instance.Log.Error($"Url {request.Url} is not of a registered custom scheme.");
callback.Dispose();
return(false);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
if (callback != null)
{
callback.Continue();
}
return(true);
}
/// <summary>
/// The ProcessRequest.
/// </summary>
/// <param name="request">The request<see cref="CefRequest"/>.</param>
/// <param name="callback">The callback<see cref="CefCallback"/>.</param>
/// <returns>The <see cref="bool"/>.</returns>
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
var webRequest = CefGlue.Lib.Browser.WebRequest.Create(request);
this.respData = this.ExecuteCore(webRequest);
callback.Continue();
return(true);
}
protected override bool Open(CefRequest request, out bool handleRequest, CefCallback callback)
{
//if(handleRequest)
handleRequest = true;
callback.Continue();
return(true);
//throw new NotImplementedException();
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
this.url = request.Url;
this.callback = callback;
this.mythread = new Thread(new ThreadStart(this.MyThread));
this.mythread.Start();
return(true);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
Task task = new Task(() =>
{
Data = Encoding.UTF8.GetBytes(Parse(sql, connectionString, returnType, executionMode));
callback.Continue();
});
task.Start();
return(true);
}
protected override RequestHandlingFashion ProcessRequestAsync(CefRequest request, CefCallback callback)
{
lock (SyncRoot) {
if (Response == null && string.IsNullOrEmpty(RedirectUrl))
{
responseCallback = callback;
return(RequestHandlingFashion.ContinueAsync);
}
return(RequestHandlingFashion.Continue);
}
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
uri = new Uri(request.Url);
fileName = uri.AbsolutePath;
// if url is blocked
/*if (!myForm.IsURLOk(request.Url)) {
*
* // return true so it does not open up
* return true;
* }*/
// if url is browser file
if (uri.Host == "storage")
{
fileName = appPath + uri.Host + fileName;
if (File.Exists(fileName))
{
Task.Factory.StartNew(() => {
using (callback)
{
//var bytes = Encoding.UTF8.GetBytes(resource);
//stream = new MemoryStream(bytes);
FileStream fStream = new FileStream(fileName, FileMode.Open, FileAccess.Read);
// mimeType = CefResourceHandler.GetMimeType(Path.GetExtension(fileName));
stream = fStream;
callback.Continue();
}
});
return(true);
}
}
// if url is request for icon of another file
if (uri.Host == "fileicon")
{
Task.Factory.StartNew(() => {
using (callback)
{
stream = FileIconUtils.GetFileIcon(fileName, FileIconSize.Large);
// mimeType = ResourceHandler.GetMimeType(".png");
callback.Continue();
}
});
return(true);
}
// by default reject
callback.Dispose();
return(false);
}
protected override bool Open(CefRequest request, out bool handleRequest, CefCallback callback)
{
if (client != null)
{
throw new InvalidOperationException("DisableCspResourceHandler is not reusable!");
}
client = new Client(callback);
CefRuntime.PostTask(CefThreadId.IO, new CefActionTask(() => frame.CreateUrlRequest(request, client)));
handleRequest = false;
return(true);
}
/// <summary>
/// The on web socket request.
/// </summary>
/// <param name="server">
/// The server.
/// </param>
/// <param name="connectionId">
/// The connection id.
/// </param>
/// <param name="clientAddress">
/// The client address.
/// </param>
/// <param name="request">
/// The request.
/// </param>
/// <param name="callback">
/// The callback.
/// </param>
protected override void OnWebSocketRequest(
CefServer server,
int connectionId,
string clientAddress,
CefRequest request,
CefCallback callback)
{
// Cache name and connection identifier.
ConnectionNameMapper.Add(request.Url, connectionId);
// Always accept WebSocket connections.
callback.Continue();
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
//Uri uri = new Uri(request.Url);
//Debug.WriteLine("ProcessRequestAsync: " + request.Url);
Task task = new Task(() =>
{
Data = Encoding.UTF8.GetBytes(Parse(sql, connectionString, returnType, executionMode));
callback.Continue();
});
task.Start();
return(true);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
Debug.WriteLine(DBGPREFIX + "ProcessRequest for id: " + id);
var handler = OnProcessRequestEvent;
if (handler != null)
{
var e = new OnProcessRequestEventArgs(id, request, callback);
handler(null, e);
Debug.WriteLine(DBGPREFIX + "ProcessRequest for id: " + id + (e.continueRequest ? " will continue processing" : " will be cancelled"));
return(e.continueRequest);
}
return(false);
}
private bool ProcessLocalFile(string file, CefCallback callback)
{
var fileInfo = new FileInfo(file);
// Check if file exists
if (!fileInfo.Exists)
{
_chromelyErrorHandler.HandleResourceError(ResourceStatus.FileNotFound, file, out _statusCode, out _statusText);
_fileBytes = _statusText.GetMemoryStream();
callback.Continue();
}
// Check if file exists but empty
else if (fileInfo.Length == 0)
{
_chromelyErrorHandler.HandleResourceError(ResourceStatus.ZeroFileSize, file, out _statusCode, out _statusText);
_fileBytes = _statusText.GetMemoryStream();
callback.Continue();
}
else
{
Task.Run(() =>
{
using (callback)
{
try
{
_fileBytes = File.ReadAllBytes(file);
string extension = Path.GetExtension(file);
_mime = MimeMapper.GetMimeType(extension);
_statusCode = ResourceConstants.StatusOK;
_statusText = ResourceConstants.StatusOKText;
}
catch (Exception exception)
{
_chromelyErrorHandler.HandleResourceError(ResourceStatus.FileProcessingError, file, exception, out _statusCode, out _statusText);
_fileBytes = _statusText.GetMemoryStream();
}
finally
{
callback.Continue();
}
}
});
return(true);
}
return(false);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
lock (SyncRoot) {
if (Response == null && string.IsNullOrEmpty(RedirectUrl))
{
responseCallback = callback;
}
else
{
callback.Continue();
}
return(true);
}
}
protected override bool ReadResponse(Stream response, int bytesToRead, out int bytesRead, CefCallback callback)
{
if (bytesToRead == 0 || pos >= responseData.Length)
{
bytesRead = 0;
return false;
}
else
{
response.Write(responseData, pos, bytesToRead);
pos += bytesToRead;
bytesRead = bytesToRead;
return true;
}
}
private bool ProcessLocalFile(string file, CefCallback callback)
{
_fileInfo = new FileInfo(file);
// Check if file exists
if (!_fileInfo.Exists)
{
_chromelyResource = _chromelyErrorHandler.HandleError(_fileInfo);
callback.Continue();
}
// Check if file exists but empty
else if (_fileInfo.Length == 0)
{
_chromelyResource = _chromelyErrorHandler.HandleError(_fileInfo);
callback.Continue();
}
else
{
Task.Run(() =>
{
using (callback)
{
try
{
var fileBytes = File.ReadAllBytes(file);
_chromelyResource.Content = new MemoryStream(fileBytes);
string extension = Path.GetExtension(file);
_chromelyResource.MimeType = MimeMapper.GetMimeType(extension);
_chromelyResource.StatusCode = ResourceConstants.StatusOK;
_chromelyResource.StatusText = ResourceConstants.StatusOKText;
}
catch (Exception exception)
{
_chromelyResource = _chromelyErrorHandler.HandleError(_fileInfo, exception);
}
finally
{
callback.Continue();
}
}
});
return(true);
}
return(false);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
Task task = new Task(() =>
{
try
{
//var serializer = new JavaScriptSerializer();
//serializer.MaxJsonLength = Int32.MaxValue;
//serializer.RegisterConverters(new[] { new DynamicJsonConverter() });
var zip = new iZip(configuration.Application, Environment.CurrentDirectory, JsonMapper.ToObject <object>(zipString));
var zipBytes = Data = iZip.CreateZip(zip);
var dir = Environment.CurrentDirectory + "\\Web\\" + configuration.Application + "\\reports";
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
var dt = DateTime.Now.ToString("yyyyMMddHmmssfff");
var file = zip.Properties.Title.Replace(" ", "_") + "_" + dt + "_" + zip.Properties.Items + ".zip";
var path = dir + "\\" + file;
File.WriteAllBytes(path, zipBytes);
var echo = JsonMapper.ToJson(new FileHelper("OK", "reports/" + file, zip.Properties.Title, zip.Properties.Items));
Data = Encoding.UTF8.GetBytes(echo);
}
catch (Exception ex)
{
Log.Trace(ex.Message, ex.StackTrace);
var echo = JsonMapper.ToJson(new ErrorHelper(ex.Message, ex.StackTrace));
Data = Encoding.UTF8.GetBytes(echo);
}
callback.Continue();
});
task.Start();
return(true);
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
if (!this.PrepareRequest(request))
{
return(false);
}
_cancellationTokenSource = new CancellationTokenSource();
_dataStream = null;
GetResource();
return(true);
async void GetResource()
{
try
{
if (await LoadResourceData(_cancellationTokenSource.Token))
{
_dataStream = await GetResourceDataStream(_cancellationTokenSource.Token);
}
}
catch (TaskCanceledException)
{
Logger.Instance.Log.Info("The request was canceled.");
}
catch (Exception ex) when(ex.Message == "The request was aborted: The request was canceled.")
{
Logger.Instance.Log.Info("The request was canceled.");
}
catch (Exception ex)
{
Logger.Instance.Log.Error(ex, "Exception thrown while loading resource");
}
finally
{
callback.Continue();
callback.Dispose();
}
}
}
protected override bool ProcessRequest(CefRequest request, CefCallback callback)
{
var u = new Uri(request.Url);
var file = u.Authority + u.AbsolutePath;
_totalBytesRead = 0;
_fileBytes = null;
_completed = false;
// Check if file exists and not empty
var fileInfo = new FileInfo(file);
if ((fileInfo.Exists) && fileInfo.Length > 0)
{
Task.Run(() =>
{
using (callback)
{
try
{
_fileBytes = File.ReadAllBytes(file);
string extension = Path.GetExtension(file);
_mime = MimeMapper.GetMimeType(extension);
}
catch (Exception exception)
{
Logger.Instance.Log.Error(exception);
}
finally
{
callback.Continue();
}
}
});
return(true);
}
callback.Dispose();
return(false);
}
