public static HttpWebRequest CreatePostRequest(IWebConnection connection, string path, IDictionary<string, object> parameters)
{
var webRequest = (HttpWebRequest)WebRequest.Create(string.Format("{0}//{1}", connection.Address, path));
webRequest.Headers.Add(CookieContainer.REQUESTHEADER_SESSIONCOOKIE, connection.CookieContainer.Cookie);
webRequest.Method = WebMethod.POST;
webRequest.UserAgent = WebConnection.USER_AGENT;
webRequest.ContentType = WebConnection.CONTENT_TYPE;
webRequest.AllowAutoRedirect = false;
webRequest.Headers.Add("X-CSRF-Token", connection.CsrfTokenContainer.CsrfToken);
//parameters.Add(WebConnection.CSRF_TOKEN_PARAM_NAME, connection.CsrfTokenContainer.CsrfToken);
string postData = ParseParametersToJson(parameters);
webRequest.AllowWriteStreamBuffering = true;
Stream requestStream = webRequest.GetRequestStream();
var encoding = new UTF8Encoding();
byte[] bytes = encoding.GetBytes(postData);
if (bytes.Length > 0)
requestStream.Write(bytes, 0, bytes.Length);
else
webRequest.ContentLength = 0;
requestStream.Close();
return webRequest;
}
public WebDataService(string key)
{
//default to ComicVine
this.connection = new ComicVineWebConnection();
this.reader = new ComicVineXMLReader();
this.urlBuilder = new ComicVineURLBuilder(key, format);
}
public static string ProcessResponse(IWebConnection connection,
HttpWebResponse httpWebResponse)
{
string responseText = string.Empty;
string cookie = httpWebResponse.Headers.Get(CookieContainer.RESPONSEHEADER_SESSIONCOOKIE);
if (!string.IsNullOrEmpty(cookie)) {
connection.CookieContainer.SetCookie(cookie);
}
using (Stream stream = httpWebResponse.GetResponseStream()) {
if (stream != null) {
using (var reader = new StreamReader(stream, true)) {
var responseTextBuilder = new StringBuilder((int)httpWebResponse.ContentLength);
while (!reader.EndOfStream) {
var buffer = new char[1024];
reader.Read(buffer, 0, buffer.Length);
var cleanBuffer = buffer.Where(c => c != '\0').ToArray();
if (cleanBuffer.Length > 0)
responseTextBuilder.Append(cleanBuffer);
}
responseText = responseTextBuilder.ToString();
}
}
}
string csrfToken = ExtractCsrfToken(responseText);
if (!string.IsNullOrEmpty(csrfToken))
connection.CsrfTokenContainer.SetCsrfToken(csrfToken);
return responseText;
}
public ShellWebConnection(
IWebConnection webConnection,
ISession session,
string requestedFile,
RequestParameters getParameters,
byte[] content,
string contentType,
CookiesFromBrowser cookiesFromBrowser,
CallingFrom callingFrom)
: base(webConnection.WebServer, callingFrom, webConnection.Generation + 1)
{
_Content = new WebConnectionContent.InMemory(content);
_ContentType = contentType;
_Session = session;
_Method = WebMethod.GET;
_CookiesFromBrowser = cookiesFromBrowser;
_CookiesToSet = webConnection.CookiesToSet;
_HttpVersion = webConnection.HttpVersion;
_RequestedHost = webConnection.RequestedHost;
_Headers = new Dictionary<string, string>(webConnection.Headers);
_MimeReader = webConnection.MimeReader;
BaseWebConnection = webConnection;
_RequestedFile = requestedFile;
_GetParameters = getParameters;
_PostParameters = null;
}
public WebDataService(string key)
{
//default to ComicVine
this.connection = new ComicVineWebConnection();
this.reader = new ComicVineXMLReader();
this.urlBuilder = new ComicVineURLBuilder(key, format);
}
public override IWebResults CallMethod(IWebConnection webConnection, IWebHandlerPlugin webHandlerPlugin)
{
object[] arguments = new object[NumParameters];
// Decode the arguments
foreach (MimeReader.Part mimePart in webConnection.MimeReader)
if (ParameterIndexes.ContainsKey(mimePart.Name))
{
uint parameterIndex = ParameterIndexes[mimePart.Name];
arguments[parameterIndex] = mimePart;
}
// The first argument is always the web connection
arguments[0] = webConnection;
object toReturn;
try
{
toReturn = MethodInfo.Invoke(webHandlerPlugin, arguments);
}
catch (TargetInvocationException e)
{
// Invoke wraps exceptions
throw e.InnerException;
}
return (IWebResults)toReturn;
}
public DerpImagesViewModel(bool favorite, IWebConnection web)
{
IsFavoriteView = favorite;
CurrentKey = string.Empty;
HasNavigationBar = true;
derpibooru = new DerpibooruService(web);
}
public static RootInfo GetRoot (string rootUri, IWebConnection connection)
{
// TODO: Error-handling in GET and Deserialize
string jsonString = connection.Get (rootUri, null);
RootInfo root = ParseJson (jsonString);
return root;
}
public ShellWebConnection(
IWebConnection webConnection,
WebMethod method,
string url,
byte[] content,
string contentType,
CookiesFromBrowser cookiesFromBrowser,
CallingFrom callingFrom)
: base(webConnection.WebServer, callingFrom, webConnection.Generation + 1)
{
_Content = new WebConnectionContent.InMemory(content);
_ContentType = contentType;
_Session = webConnection.Session;
_Method = method;
_CookiesFromBrowser = cookiesFromBrowser;
_CookiesToSet = webConnection.CookiesToSet;
_HttpVersion = webConnection.HttpVersion;
_RequestedHost = webConnection.RequestedHost;
_Headers = new Dictionary<string, string>(webConnection.Headers);
_MimeReader = webConnection.MimeReader;
BaseWebConnection = webConnection;
DetermineRequestedFileAndGetParameters(url);
TryDecodePostParameters();
}
/// <summary>
/// Evaluates the named template
/// </summary>
/// <param name="webConnection"></param>
/// <param name="filename"></param>
/// <param name="arguments"></param>
/// <returns></returns>
public IWebResults Evaluate(IWebConnection webConnection, string filename, IDictionary<string, object> arguments)
{
try
{
Stream results = EvaluateToStream(
webConnection,
arguments,
filename);
IWebResults toReturn;
// Hack to work around a bug in IE handling xhtml
// Basically, IE won't handle > and < in xhtml
string userAgent;
if (webConnection.Headers.TryGetValue("USER-AGENT", out userAgent))
if (userAgent.Contains(" MSIE "))
{
StreamReader sr = new StreamReader(results);
string result = sr.ReadToEnd();
result = result.Replace("<?xml version=\"1.0\" encoding=\"utf-8\"?><html", "");
result = result.Split(new char[] { '>' }, 2)[1];
result = "<!DOCTYPE html>\n<html>" + result;
string[] splitAtScriptTag = result.Split(new string[] {"<script>"}, StringSplitOptions.None);
StringBuilder resultBuilder = new StringBuilder(splitAtScriptTag[0]);
for (int ctr = 1; ctr < splitAtScriptTag.Length; ctr++)
{
string[] scriptAndPostTags = splitAtScriptTag[ctr].Split(new string[] {"</script>"}, StringSplitOptions.None);
if (scriptAndPostTags.Length == 1)
resultBuilder.Append(scriptAndPostTags[0]);
else
{
string script = scriptAndPostTags[0].Replace(">", ">").Replace("<", "<");
resultBuilder.Append("<script>");
resultBuilder.Append(script);
resultBuilder.Append("</script>");
resultBuilder.Append(scriptAndPostTags[1]);
}
}
toReturn = WebResults.From(Status._200_OK, resultBuilder.ToString());
toReturn.ContentType = "text/html";
return toReturn;
}
// Everyone else gets real XML
toReturn = WebResults.From(Status._200_OK, results);
toReturn.ContentType = ContentType;
return toReturn;
}
catch (TemplateException te)
{
throw new WebResultsOverrideException(WebResults.From(Status._500_Internal_Server_Error, te.Message), te);
}
}
public IWebResults Evaluate(IWebConnection webConnection, string filename)
{
Dictionary<string, object> arguments = new Dictionary<string, object>();
foreach (KeyValuePair<string, string> getParameter in webConnection.GetParameters)
arguments[getParameter.Key] = getParameter.Value;
return Evaluate(webConnection, filename, arguments);
}
public static RootInfo GetRoot(string rootUri, IWebConnection connection)
{
// TODO: Error-handling in GET and Deserialize
string jsonString = connection.Get(rootUri, null);
RootInfo root = ParseJson(jsonString);
return(root);
}
public ShellWebConnection(
string url,
IWebConnection webConnection,
RequestParameters postParameters,
CookiesFromBrowser cookiesFromBrowser)
: this(url, webConnection, postParameters, cookiesFromBrowser, webConnection.CallingFrom)
{
}
public static UserInfo GetUser (string userUri, IWebConnection connection)
{
// TODO: Error-handling in GET and Deserialize
string jsonString = connection.Get (userUri, null);
UserInfo user = ParseJson (jsonString);
user.Connection = connection;
user.Uri = userUri;
return user;
}
public ShellWebConnection(
string url,
IWebConnection webConnection,
RequestParameters postParameters,
CookiesFromBrowser cookiesFromBrowser,
CallingFrom callingFrom)
: this(url, webConnection, postParameters, cookiesFromBrowser, callingFrom, WebMethod.GET)
{
}
public IWebConnection Connect()
{
if (_webConnection == null || _webConnection.State == ConnectionState.Corrupted) {
_webConnection = new WebConnection(Address, _username, _password);
_webConnection.Open();
}
return _webConnection;
}
public static UserInfo GetUser(string userUri, IWebConnection connection)
{
// TODO: Error-handling in GET and Deserialize
string jsonString = connection.Get(userUri, null);
UserInfo user = ParseJson(jsonString);
user.Connection = connection;
user.Uri = userUri;
return(user);
}
public static HttpWebRequest CreateGetRequest(IWebConnection connection, string path)
{
var webRequest = (HttpWebRequest)WebRequest.Create(string.Format("{0}//{1}", connection.Address, path));
webRequest.Headers.Add(CookieContainer.REQUESTHEADER_SESSIONCOOKIE, connection.CookieContainer.Cookie);
webRequest.Method = WebMethod.GET;
webRequest.UserAgent = WebConnection.USER_AGENT;
webRequest.ContentType = WebConnection.CONTENT_TYPE;
webRequest.AllowAutoRedirect = false;
return webRequest;
}
public BlockingShellWebConnection(
IWebConnection webConnection,
WebMethod method,
string url,
byte[] content,
string contentType,
CookiesFromBrowser cookiesFromBrowser,
CallingFrom callingFrom)
: base(webConnection, method, url, content, contentType, cookiesFromBrowser, callingFrom)
{
}
public BlockingShellWebConnection(
IWebConnection webConnection,
ISession session,
string requestedFile,
RequestParameters getParameters,
byte[] content,
string contentType,
CookiesFromBrowser cookiesFromBrowser,
CallingFrom callingFrom)
: base(webConnection, session, requestedFile, getParameters, content, contentType, cookiesFromBrowser, callingFrom)
{
}
public IWebResults CallMethod(IWebConnection webConnection, CallingFrom callingFrom)
{
object toReturn;
FilePermissionEnum? minimumPermission;
switch (callingFrom)
{
case CallingFrom.Local:
minimumPermission = WebCallableMethod.WebCallableAttribute.MinimumPermissionForTrusted;
break;
case CallingFrom.Web:
minimumPermission = WebCallableMethod.WebCallableAttribute.MinimumPermissionForWeb;
break;
default:
// This clause shouldn't be hit, but in case it is, require the strictest permission possible
minimumPermission = FilePermissionEnum.Administer;
break;
}
ID<IUserOrGroup, Guid> userId = webConnection.Session.User.Id;
// If this user isn't the owner, then verify that the user has the appropriate permission
if (null != minimumPermission)
if (FileContainer.OwnerId != userId)
{
bool hasPermission = false;
// Get appropriate permission
FilePermissionEnum? userPermission = FileContainer.LoadPermission(userId);
if (null != userPermission)
if (userPermission.Value >= minimumPermission.Value)
hasPermission = true;
// If the user doesn't explicitly have the needed permission, try loading any potentially-needed declaritive permissions
if (!hasPermission)
hasPermission = FileContainer.HasNamedPermissions(userId, WebCallableMethod.NamedPermissions);
if (!hasPermission)
return WebResults.From(Status._401_Unauthorized, "Permission Denied for method " + WebCallableMethod.MethodInfo.Name);
}
if (null != WebCallableMethod.WebMethod)
if (WebCallableMethod.WebMethod.Value != webConnection.Method)
return WebResults.From(Status._405_Method_Not_Allowed, "Allowed method: " + WebCallableMethod.WebMethod.Value.ToString());
toReturn = WebCallableMethod.CallMethod(webConnection, WebHandlerPlugin);
return (IWebResults)toReturn;
}
public static HttpWebRequest CreateGetRequest(IWebConnection connection, string path, IDictionary<string, object> parameters)
{
var queryStringBuilder = new StringBuilder();
queryStringBuilder.Append('?');
foreach (var parameter in parameters)
{
queryStringBuilder.Append(string.Format("{0}={1}&", parameter.Key, parameter.Value));
}
// Remove last &
queryStringBuilder.Remove(queryStringBuilder.Length - 1, 1);
string queryString = Uri.EscapeUriString(queryStringBuilder.ToString());
return CreateGetRequest(connection, string.Concat(path, queryString));
}
public override IWebResults CallMethod(IWebConnection webConnection, IWebHandlerPlugin webHandlerPlugin)
{
object toReturn;
try
{
toReturn = MethodInfo.Invoke(webHandlerPlugin, new object[] { webConnection });
}
catch (TargetInvocationException e)
{
// Invoke wraps exceptions
throw e.InnerException;
}
return (IWebResults)toReturn;
}
/// <summary>
/// Creates a scope wrapper
/// </summary>
/// <param name="fileHandlerFactoryLocator"></param>
/// <param name="webConnection"></param>
/// <param name="javascript"></param>
/// <param name="fileContainer"></param>
/// <param name="constructScopeResults"></param>
public ScopeWrapper(
FileHandlerFactoryLocator fileHandlerFactoryLocator,
SubProcess subProcess,
IFileContainer fileContainer,
ParentScope parentScope,
IWebConnection constructWebConnection,
out object constructScopeResults)
{
_FileContainer = fileContainer;
_SubProcess = subProcess;
_ParentScope = parentScope;
_ScopeId = GetScopeID();
_FileHandlerFactoryLocator = fileHandlerFactoryLocator;
constructScopeResults = ConstructScope(constructWebConnection);
}
public override IWebResults CallMethod(IWebConnection webConnection, IWebHandlerPlugin webHandlerPlugin)
{
if (null == webConnection.Content)
return WebResults.From(Status._400_Bad_Request, "No data sent");
object toReturn;
try
{
toReturn = MethodInfo.Invoke(webHandlerPlugin, new object[] { webConnection, GetSecondArgument(webConnection.Content) });
}
catch (TargetInvocationException e)
{
// Invoke wraps exceptions
throw e.InnerException;
}
return (IWebResults)toReturn;
}
public void Setup()
{
if (testMode == "Live")
{
repository = new MSSQLDatabase();
connection = new ComicVineWebConnection();
}
else
{
repository = new TestRepository();
connection = new TestWebConnection();
}
key = repository.GetSetting("WebServiceKey");
format = "xml";
urlBuilder = new ComicVineURLBuilder(key, format);
reader = new ComicVineXMLReader();
service = new WebDataService(connection, reader, urlBuilder);
}
public void Setup()
{
if (testMode == "Live")
{
repository = new MSSQLDatabase();
connection = new ComicVineWebConnection();
}
else
{
repository = new TestRepository();
connection = new TestWebConnection();
}
key = repository.GetSetting("WebServiceKey");
format = "xml";
urlBuilder = new ComicVineURLBuilder(key, format);
reader = new ComicVineXMLReader();
service = new WebDataService(connection, reader, urlBuilder);
}
public IWebResults DoComet(IWebConnection webConnection)
{
ushort sessionIdValue = default(ushort);
if (!ushort.TryParse(
webConnection.EitherArgumentOrException("s"),
NumberStyles.AllowHexSpecifier,
CultureInfo.InvariantCulture,
out sessionIdValue))
{
return WebResults.FromString(Status._417_Expectation_Failed, "Invalid session ID");
}
ID<ICometSession, ushort> sessionId = new ID<ICometSession, ushort>(sessionIdValue);
ICometSession cometSession;
try
{
cometSession = CometHandler[sessionId];
}
catch (BadCometSessionId)
{
return WebResults.FromString(Status._400_Bad_Request, "Bad SESSION_KEY");
}
//object data = JsonReader.Deserialize("{\"d\": " + webConnection.Content.AsString() + "}");
// This is silly, but for some reason the array is quoted when it's sent...
string wtf = JsonReader.Deserialize<string>(webConnection.Content.AsString());
object[] packets = JsonReader.Deserialize<object[]>(wtf);
foreach (object[] packet in packets)
cometSession.RecieveData(
Convert.ToUInt64(packet[0]),
packet[2].ToString());
return WebResults.FromStatus(Status._200_OK);
}
public static HttpWebResponse Dispatch(IWebConnection connection, HttpWebRequest httpWebRequest)
{
try {
return (HttpWebResponse) httpWebRequest.GetResponse();
}
catch (WebException webException)
{
Log.Error(webException);
if (webException.Response is HttpWebResponse)
{
var response = webException.Response as HttpWebResponse;
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
throw new NeedLogonException();
}
}
throw;
}
catch (Exception exception)
{
Log.Error(exception);
throw;
}
}
public WebSyncServer (string serverUrl, IWebConnection connection)
{
this.connection = connection;
rootUri = serverUrl.TrimEnd ('/') + "/api/1.0/";
}
public DerpibooruService(IWebConnection web)
{
_web = web;
}
public List <DerpTag> GetTagInfoFromDerpibooru(List <DerpTag> oldTags, int max, IWebConnection _web, out int newcount)
{
newcount = 0;
List <DerpTag> newTags = new List <DerpTag>();
using (WebClient webClient = new WebClient())
{
int pageindex = 1;
string url = "https://derpibooru.org/tags?page=";
string infostr;
string tempstr;
string tempstr2;
ProgressBarHeight = 8;
ProgressBarIsVisible = true;
while (true)
{
infostr = webClient.DownloadString(url + pageindex);
infostr = Library.extractionString(infostr, "<div class=\"tag-list\">", "</div>");
if (infostr.Contains("<span class=\"tag dropdown\" "))
{
while (infostr.Contains("<span class=\"tag dropdown\" "))
{
try
{
Library.extractionString(infostr, out infostr, "<span class=\"tag dropdown\" ", "Filter</a></span></span>", out tempstr);
DerpTag tag = new DerpTag();
tag.CategoryStrEn = Library.extractionString(tempstr, "data-tag-category=\"", "\"");
tag.Id = Library.extractionString(tempstr, "data-tag-id=\"", "\"");
tempstr2 = Library.extractionString(tempstr, "data-tag-name=\"", "\"");
tag.NameEn = tag.NameKr = System.Web.HttpUtility.HtmlDecode(tempstr2).Replace("'", "'");
tempstr2 = Library.extractionString(tempstr, "title=\"", "\"");
tag.DescriptionEn = tag.DescriptionKr = System.Web.HttpUtility.HtmlDecode(tempstr2);
DerpTag temp = oldTags.Find(i => i.Id == tag.Id);
if (temp != null)
{
tag = temp;
}
else
{
newcount++;
}
tag.Index = newTags.Count;
newTags.Add(tag);
Progress = (float)newTags.Count / max;
if (newTags.Count >= max)
{
goto EndPoint;
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
goto EndPoint;
}
}
}
else
{
break;
}
pageindex++;
}
EndPoint:
for (int season = 9; season > 0; season--)
{
int fin = season == 3 ? 13 : 26;
var tags = new DerpTag($"spoiler:s{season.ToString("D2")}")
{
Category = DerpTagCategory.SPOILER, Index = newTags.Count
};
newTags.RemoveAll(i => i.NameEn == tags.NameEn);
newTags.Add(tags);
for (int episod = fin; episod > 0; episod--)
{
var tage = new DerpTag($"spoiler:s{season.ToString("D2")}e{episod.ToString("D2")}")
{
Category = DerpTagCategory.SPOILER, Index = newTags.Count
};
newTags.RemoveAll(i => i.NameEn == tage.NameEn);
newTags.Add(tage);
}
}
newTags.Add(new DerpTag("score.gt:100"));
newTags.Add(new DerpTag("score.gt:500"));
newTags.Add(new DerpTag("score.gt:1000"));
newTags.Add(new DerpTag("score.gte:100"));
newTags.Add(new DerpTag("score.gte:500"));
newTags.Add(new DerpTag("score.gte:1000"));
newTags.Add(new DerpTag("score.lt:100"));
newTags.Add(new DerpTag("score.lt:500"));
newTags.Add(new DerpTag("score.lt:1000"));
newTags.Add(new DerpTag("score.lte:100"));
newTags.Add(new DerpTag("score.lte:500"));
newTags.Add(new DerpTag("score.lte:1000"));
var olds = oldTags.FindAll(i => newTags.Find(j => j.NameEn == i.NameEn) == null);
newTags.AddRange(olds);
ProgressBarHeight = 0;
ProgressBarIsVisible = false;
}
return(newTags);
}
public WebDataService(IWebConnection connection, IWebDataReader reader, IURLBuilder urlBuilder)
{
this.connection = connection;
this.reader = reader;
this.urlBuilder = urlBuilder;
}
public WebSyncServer(string serverUrl, IWebConnection connection)
{
this.connection = connection;
rootUri = serverUrl.TrimEnd('/') + "/api/1.0/";
}
public WebSyncServer(string serverUrl, IWebConnection connection)
{
this.connection = connection;
rootUri = serverUrl + "/api/1.0/"; // TODO: Trim trailing / from serverUrl if necessary
}
/// <summary>
/// Constructor for when a web request is generated publicly instead of externally
/// </summary>
/// <param name="webServer"></param>
/// <param name="session"></param>
/// <param name="url"></param>
/// <param name="content"></param>
/// <param name="contentType"></param>
/// <param name="cookiesFromBrowser"></param>
/// <param name="callingFrom"></param>
/// <param name="method"></param>
public ShellWebConnection(
IWebServer webServer,
ISession session,
string url,
byte[] content,
string contentType,
CookiesFromBrowser cookiesFromBrowser,
CallingFrom callingFrom,
WebMethod method)
: base(webServer, callingFrom, 0)
{
_Content = new WebConnectionContent.InMemory(content);
_ContentType = contentType;
_Session = session;
_Method = method;
_CookiesFromBrowser = cookiesFromBrowser;
_CookiesToSet = new List<CookieToSet>();
_HttpVersion = 1;
_RequestedHost = null;
_Headers = new Dictionary<string, string>();
DetermineRequestedFileAndGetParameters(url);
TryDecodePostParameters();
if (null == BaseWebConnection)
BaseWebConnection = this;
}
public ShellWebConnection(
string url,
IWebConnection webConnection,
RequestParameters postParameters,
CookiesFromBrowser cookiesFromBrowser,
CallingFrom callingFrom,
WebMethod method)
: base(webConnection.WebServer, callingFrom, webConnection.Generation + 1)
{
_PostParameters = postParameters;
_Content = webConnection.Content;
_ContentType = webConnection.ContentType;
_Session = webConnection.Session;
_Method = method;
_CookiesFromBrowser = cookiesFromBrowser;
_CookiesToSet = webConnection.CookiesToSet;
_HttpVersion = webConnection.HttpVersion;
_RequestedHost = webConnection.RequestedHost;
_Headers = new Dictionary<string, string>(webConnection.Headers);
_MimeReader = webConnection.MimeReader;
BaseWebConnection = webConnection;
DetermineRequestedFileAndGetParameters(url);
}
/// <summary>
/// Generates composite Javascript from a list of scripts
/// </summary>
/// <param name="webConnection"></param>
/// <param name="scriptUrls"></param>
/// <returns></returns>
private string GenerateCompositeJavascript(IWebConnection webConnection, IEnumerable<string> scriptUrls)
{
StringBuilder scriptBuilder = new StringBuilder();
foreach (string scriptUrl in scriptUrls)
{
try
{
IWebResults webResult = webConnection.ShellTo(scriptUrl);
int statusCode = (int)webResult.Status;
if ((statusCode >= 200) && (statusCode < 300))
{
string script = webResult.ResultsAsString;
script = JavaScriptMinifier.Instance.Minify(script);
scriptBuilder.AppendFormat("\n// {0}\n", scriptUrl);
scriptBuilder.Append("try {");
scriptBuilder.Append(script);
scriptBuilder.Append("} catch (exception) { }");
// Note: exceptions are swallowed
// This form of compression shouldn't be used when a developer is trying to debug, instead, they should
// turn on Javascript debug mode, which disables this compression and allows them to use the browser's
// debugger
}
}
catch (Exception e)
{
log.Error("Error loading script in GenerateCompositeJavascript for script " + scriptUrl, e);
}
}
return scriptBuilder.ToString();
}
public IWebResults GetScaled(
IWebConnection webConnection,
int? width,
int? height,
int? maxWidth,
int? maxHeight,
int? minWidth,
int? minHeight)
{
int returnedWidth;
int returnedHeight;
double aspectRatio = Convert.ToDouble(Image.Width) / Convert.ToDouble(Image.Height);
double inverseAspectRatio = Convert.ToDouble(Image.Height) / Convert.ToDouble(Image.Width);
// First, figure out what the size of the returned image will be based on specified height or width
if ((null != width) && (null != height))
{
returnedHeight = height.Value;
returnedWidth = width.Value;
aspectRatio = Convert.ToDouble(returnedWidth) / Convert.ToDouble(returnedHeight);
inverseAspectRatio = Convert.ToDouble(returnedHeight) / Convert.ToDouble(returnedWidth);
}
else if (null != width)
{
returnedWidth = width.Value;
returnedHeight = Convert.ToInt32(
Convert.ToDouble(width.Value) * inverseAspectRatio);
}
else if (null != height)
{
returnedHeight = height.Value;
returnedWidth = Convert.ToInt32(
Convert.ToDouble(height.Value) * aspectRatio);
}
else
{
returnedWidth = Image.Width;
returnedHeight = Image.Height;
}
// Second, make sure that maxes and mins aren't violated
if (null != maxWidth)
if (returnedWidth > maxWidth.Value)
{
returnedWidth = maxWidth.Value;
returnedHeight = Convert.ToInt32(
Convert.ToDouble(maxWidth.Value) * inverseAspectRatio);
}
if (null != maxHeight)
if (returnedHeight > maxHeight.Value)
{
returnedHeight = maxHeight.Value;
returnedWidth = Convert.ToInt32(
Convert.ToDouble(maxHeight.Value) * aspectRatio);
}
if (null != minWidth)
if (returnedWidth < minWidth.Value)
{
returnedWidth = minWidth.Value;
returnedHeight = Convert.ToInt32(
Convert.ToDouble(minWidth.Value) * inverseAspectRatio);
}
if (null != minHeight)
if (returnedHeight < minHeight.Value)
{
returnedHeight = minHeight.Value;
returnedWidth = Convert.ToInt32(
Convert.ToDouble(minHeight.Value) * aspectRatio);
}
// Now, in the rare chance that size doesn't change, don't do anything
// (disabled due to MIME ambiguities)
//if ((returnedWidth == Image.Width) && (returnedHeight == Image.Height))
// return ReadAll(webConnection);
// The image must be resized.
// Check to see if there is a cached version
string cacheKey = "resized_w_" + returnedWidth + "_h_" + returnedHeight;
byte[] resizedImageBytes;
IWebResults toReturn;
if (FileHandler.TryGetCached(cacheKey, out resizedImageBytes))
{
MemoryStream stream = new MemoryStream(resizedImageBytes, false);
toReturn = WebResults.From(Status._200_OK, stream);
}
else
{
// There wasn't a cached version. The resizing must occur
// reference: http://www.glennjones.net/Post/799/Highqualitydynamicallyresizedimageswithnet.htm
Image thumbnail = new Bitmap(returnedWidth, returnedHeight);
Graphics graphic = System.Drawing.Graphics.FromImage(thumbnail);
// Set up high-quality resize mode
graphic.InterpolationMode = InterpolationMode.HighQualityBicubic;
graphic.SmoothingMode = SmoothingMode.HighQuality;
graphic.PixelOffsetMode = PixelOffsetMode.HighQuality;
graphic.CompositingQuality = CompositingQuality.HighQuality;
// do the resize
graphic.DrawImage(Image, 0, 0, returnedWidth, returnedHeight);
// Save as a high quality JPEG
ImageCodecInfo[] info = ImageCodecInfo.GetImageEncoders();
EncoderParameters encoderParameters;
encoderParameters = new EncoderParameters(1);
encoderParameters.Param[0] = new EncoderParameter(Encoder.Quality, 100L);
MemoryStream ms = new MemoryStream();
thumbnail.Save(ms, info[1], encoderParameters);
resizedImageBytes = new byte[ms.Length];
// Saved the resized image in the cache
ms.Seek(0, SeekOrigin.Begin);
ms.Read(resizedImageBytes, 0, resizedImageBytes.Length);
FileHandler.SetCached(cacheKey, resizedImageBytes);
ms.Seek(0, SeekOrigin.Begin);
toReturn = WebResults.From(Status._200_OK, ms);
}
toReturn.ContentType = "image/jpeg";
return toReturn;
//Image.
}
/// <summary>
/// Returns the file with all header/footers resolved as XML for further processing
/// </summary>
/// <param name="arguments"></param>
/// <param name="templateFileContainer"></param>
/// <param name="webConnection"></param>
/// <param name="templateParsingState"></param>
/// <returns></returns>
private void ResolveHeaderFooter(
IWebConnection webConnection,
IDictionary<string, object> arguments,
IFileContainer templateFileContainer,
TemplateParsingState templateParsingState)
{
HashSet<string> checkedHeaderFooters = new HashSet<string>();
XmlDocument templateDocument = templateParsingState.LoadXmlDocumentAndReplaceGetParameters(arguments, templateFileContainer, XmlParseMode.Xml);
// I think this is to work around an issue when directly viewing a template with an empty <oc:component /> tag
templateParsingState.TemplateDocument = templateDocument;
// While the first node isn't HTML, keep loading header/footers
while ("html" != templateDocument.FirstChild.LocalName)
{
XmlNode firstChild = templateDocument.FirstChild;
string headerFooter = "/DefaultTemplate/headerfooter.ochf";
XmlNodeList nodesToInsert;
if (("componentdef" == firstChild.LocalName) && (templateParsingState.TemplateHandlerLocator.TemplatingConstants.TemplateNamespace == firstChild.NamespaceURI))
{
XmlAttribute headerFooterAttribue = firstChild.Attributes["headerfooter"];
if (null != headerFooterAttribue)
headerFooter = FileHandlerFactoryLocator.FileSystemResolver.GetAbsolutePath(
templateFileContainer.ParentDirectoryHandler.FileContainer.FullPath,
headerFooterAttribue.Value);
nodesToInsert = firstChild.ChildNodes;
}
else
nodesToInsert = templateDocument.ChildNodes;
string headerFooterOverride;
if (webConnection.GetParameters.TryGetValue("HeaderFooterOverride", out headerFooterOverride))
headerFooter = headerFooterOverride;
if (checkedHeaderFooters.Contains(headerFooter))
throw new TemplateException("Looping within templates: " + headerFooter + " eventually points to itself as a headerfooter!!!");
else
checkedHeaderFooters.Add(headerFooter);
templateParsingState.SetCWD(nodesToInsert, templateFileContainer.ParentDirectoryHandler.FileContainer.FullPath);
try
{
templateFileContainer = FileHandlerFactoryLocator.FileSystemResolver.ResolveFile(headerFooter);
} catch (FileDoesNotExist fdne)
{
log.Error(headerFooter + " does not exist", fdne);
throw new WebResultsOverrideException(WebResults.From(Status._500_Internal_Server_Error, headerFooter + " does not exist"));
}
templateDocument = templateParsingState.LoadXmlDocumentAndReplaceGetParameters(
arguments,
templateFileContainer,
XmlParseMode.Xml);
templateParsingState.TemplateDocument = templateDocument;
// find <oc:component /> tag
int numOcComponentTags = 0;
XmlNodeList componentTags = templateDocument.GetElementsByTagName("component", templateParsingState.TemplateHandlerLocator.TemplatingConstants.TemplateNamespace);
foreach (XmlNode componentNode in Enumerable<XmlNode>.FastCopy(Enumerable<XmlNode>.Cast(componentTags)))
if ((null == componentNode.Attributes.GetNamedItem("url", templateParsingState.TemplateHandlerLocator.TemplatingConstants.TemplateNamespace)) && (null == componentNode.Attributes.GetNamedItem("src", templateParsingState.TemplateHandlerLocator.TemplatingConstants.TemplateNamespace)))
{
numOcComponentTags++;
if (1 == numOcComponentTags)
templateParsingState.ReplaceNodes(componentNode, nodesToInsert);
else
templateParsingState.ReplaceNodes(
componentNode,
templateParsingState.GenerateWarningNode("Warning: Duplicate <oc:component /> tag, count " + numOcComponentTags.ToString()));
}
// Attempt to recover from a missing <oc:component /> tag
if (0 == numOcComponentTags)
{
XmlNodeList bodyTags = templateDocument.GetElementsByTagName(
"body", templateParsingState.TemplateHandlerLocator.TemplatingConstants.HtmlNamespace);
XmlElement bodyTag = null;
if (null != bodyTags)
if (bodyTags.Count > 0)
bodyTag = (XmlElement)bodyTags[0];
if (null == bodyTag)
{
bodyTag = (XmlElement)templateDocument.FirstChild;
}
bodyTag.AppendChild(
templateParsingState.GenerateWarningNode(
@"WARNING!!!
--------------
" + headerFooter + @" is missing a needed <oc:component /> tag!!!
The tag must be empty with no attributes. This is where the content for each page is displayed"));
XmlElement componentNode = templateDocument.CreateElement(
"component", templateParsingState.TemplateHandlerLocator.TemplatingConstants.TemplateNamespace);
bodyTag.AppendChild(componentNode);
templateParsingState.ReplaceNodes(componentNode, nodesToInsert);
}
}
templateParsingState.SetCWD(templateDocument.ChildNodes, templateFileContainer.ParentDirectoryHandler.FileContainer.FullPath);
}