private static string EncodeArguments(object args, string keyPrefix = null)
{
if (!CanEnumerate(args))
{
return(Encode(args));
}
var encodedData = new List <string>();
foreach (var arg in Enumerate(args))
{
var encodedKey = keyPrefix == null?Encoder.UrlEncode(arg.Key) : keyPrefix + "[" + Encoder.UrlEncode(arg.Key) + "]";
if (CanEnumerate(arg.Value))
{
encodedData.Add(EncodeArguments(arg.Value, encodedKey));
}
else
{
encodedData.Add(encodedKey + "=" + Encode(arg.Value));
}
}
return(String.Join("&", encodedData));
}
/// <summary>
/// Render the Html in the same way that the DefaultViewService does
/// </summary>
/// <param name="model"></param>
/// <param name="page"></param>
/// <param name="html"></param>
/// <param name="clientName"></param>
/// <returns></returns>
private Task <Stream> Render(
CommonViewModel model,
string page,
string html,
string clientName = null)
{
Uri uriSiteUrl;
var applicationPath = string.Empty;
if (Uri.TryCreate(model.SiteUrl, UriKind.RelativeOrAbsolute, out uriSiteUrl))
{
if (uriSiteUrl.IsAbsoluteUri)
{
applicationPath = uriSiteUrl.AbsolutePath;
}
else
{
applicationPath = uriSiteUrl.OriginalString;
if (applicationPath.StartsWith("~/"))
{
applicationPath = applicationPath.TrimStart('~');
}
}
if (applicationPath.EndsWith("/"))
{
applicationPath = applicationPath.Substring(0, applicationPath.Length - 1);
}
}
var json = JsonConvert.SerializeObject(
model,
Formatting.None,
new JsonSerializerSettings {
ContractResolver = new CamelCasePropertyNamesContractResolver()
});
var additionalStylesheets = this.BuildTags(
"<link href='{0}' rel='stylesheet'>",
applicationPath,
this.config.Stylesheets);
var additionalScripts = this.BuildTags("<script src='{0}'></script>", applicationPath, this.config.Scripts);
var variables = new
{
siteName = Encoder.HtmlEncode(model.SiteName),
applicationPath,
model = Encoder.HtmlEncode(json),
page,
stylesheets = additionalStylesheets,
scripts = additionalScripts,
clientName
};
html = Replace(html, variables);
return(Task.FromResult(this.StringToStream(html)));
}
public void ProcessRequest(HttpContext context)
{
var tmFileStorage = TM_FileStorage.Current;
if (tmFileStorage.isNull())
{
throw new SecurityException("TM_FileStorage is not set");
}
var uploadTokenString = context.Request["uploadToken"];
if (uploadTokenString.isGuid().isFalse())
{
return;
}
var uploadToken = uploadTokenString.guid();
if (UploadTokens.contains(uploadToken).isFalse())
{
throw new SecurityException("Upload Token must be provided");
}
if (context.Request["qqfile"].inValid())
{
return;
}
string message;
var result = true;
//calculate target folder
var librariesZipsFolder = TMConfig.Current.TMSetup.LibrariesUploadedFiles;
var targetFolder = tmFileStorage.path_XmlDatabase().fullPath().pathCombine(librariesZipsFolder).fullPath();
if (targetFolder.valid())
{
targetFolder.createDir();
var fileName = XssEncoder.UrlEncode(context.Request["qqfile"]).Replace("%20", " ");
var filePath = targetFolder.pathCombine(fileName);
saveFile(context, filePath);
message = "file saved to: " + filePath;
}
else
{
result = false;
message = "Could find target directory";
}
var reply = @"{
success : " + (result ? "true" : "false") + @" ,
message : '" + message + @"'
}" ;
context.Response.Write(reply);
UploadTokens.remove(uploadToken);
}
/// <summary>
/// Encodes the given object using its "ToString" implementation.
/// </summary>
/// <param name="obj">The object.</param>
/// <returns></returns>
public static string Encode(object obj)
{
var result = obj != null?Encoder.UrlEncode(obj.ToString()) : "";
result = result.Replace("%7E", "~"); // Not sure if this is necessary.
result = EscapeRegex.Replace(result, match => { return(match.Value.ToUpper()); });
return(result);
}
private static void EncodeChanges(IEnumerable <Change> changes, StringBuilder data)
{
foreach (var each in changes)
{
var newString = each.NewValue as string;
var oldString = each.OldValue as string;
data.AppendFormat("{0}={1}|{2}&"
, each.ColumnName
, newString == null ? each.NewValue : Encoder.UrlEncode(newString)
, oldString == null ? each.OldValue : Encoder.UrlEncode(oldString));
}
if (data.Length > 0)
{
data.Length--;
}
}
public static string HtmlFormUrlEncode(string str)
{
return(Encoder.HtmlFormUrlEncode(str));
}
public static string HtmlFormUrlEncode(string str, int codePage)
{
return(Encoder.HtmlFormUrlEncode(str, codePage));
}
public void ProcessRequest(HttpContext httpContext)
{
context = HttpContextFactory.Current;
apiScriptCombiner.baseFolder = context.Server.MapPath("/");
var request = context.Request;
var response = context.Response;
response.Clear();
if (TMConfig.Current.enable304Redirects() && context.sent304Redirect())
{
return;
}
try
{
apiScriptCombiner.minifyCode = true;
apiScriptCombiner.ignoreCache = true;
if (request.QueryString["Hello"] == "TM")
{
response.Write("Good Morning");
return;
}
// Read setName, version from query string
apiScriptCombiner.setName = XssEncoder.UrlEncode(request.QueryString["s"]) ?? string.Empty;
apiScriptCombiner.version = XssEncoder.UrlEncode(request.QueryString["v"]) ?? string.Empty;
if (apiScriptCombiner.setName == string.Empty)
{
response.Write("//nothing to do");
return;
}
if (request.QueryString["dontMinify"] == "true")
{
apiScriptCombiner.minifyCode = false;
}
switch (request.QueryString["ct"])
{
case "css":
apiScriptCombiner.contentType = "text/css";
apiScriptCombiner.minifyCode = false;
break;
default:
apiScriptCombiner.contentType = "application/x-javascript";
break;
}
// Decide if browser supports compressed response
apiScriptCombiner.isCompressed = CanGZip(context.Request);
apiScriptCombiner.CombineFiles();
var responseBytes = apiScriptCombiner.CombinedBytes;
var isCompressed = apiScriptCombiner.isCompressed;
var contentType = apiScriptCombiner.contentType;
WriteBytes(responseBytes, isCompressed, contentType);
}
catch (Exception ex)
{
ex.log();
response.Write("//Error processing request" + ex.Message);
response.End();
}
}
public static string UrlEncode(string input, int codePage)
{
return(Encoder.UrlEncode(input, codePage));
}
public static string LdapFilterEncode(string input)
{
return(Encoder.LdapFilterEncode(input));
}
public static string LdapDistinguishedNameEncode(string input, bool useInitialCharacterRules,
bool useFinalCharacterRule)
{
return(Encoder.LdapDistinguishedNameEncode(input, useInitialCharacterRules, useFinalCharacterRule));
}
public static string VisualBasicScriptEncode(string input)
{
return(Encoder.VisualBasicScriptEncode(input));
}
public void ProcessRequest(HttpContext httpContext)
{
context = HttpContextFactory.Current;
var request = context.Request;
var response = context.Response;
response.Clear();
if (context.sent304Redirect())
{
return;
}
try
{
minifyCode = true;
ignoreCache = true;
if (request.QueryString["Hello"] == "TM")
{
response.Write("Good Morning");
return;
}
// Read setName, version from query string
setName = XssEncoder.UrlEncode(request.QueryString["s"]) ?? string.Empty;
version = XssEncoder.UrlEncode(request.QueryString["v"]) ?? string.Empty;
if (setName == string.Empty)
{
response.Write("//nothing to do");
return;
}
if (request.QueryString["dontMinify"] == "true")
{
minifyCode = false;
}
switch (request.QueryString["ct"])
{
case "css":
contentType = "text/css";
minifyCode = false;
break;
default:
contentType = "application/x-javascript";
break;
}
// Decide if browser supports compressed response
bool isCompressed = CanGZip(context.Request);
using (var memoryStream = new MemoryStream(8092))
{
// Decide regular stream or gzip stream based on whether the response can be compressed or not
//using (Stream writer = isCompressed ? (Stream)(new GZipStream(memoryStream, CompressionMode.Compress)) : memoryStream)
using (Stream writer = isCompressed ? (Stream)(new ICSharpCode.SharpZipLib.GZip.GZipOutputStream(memoryStream)) : memoryStream)
{
// Read the files into one big string
allScripts = new StringBuilder();
filesProcessed = GetScriptFileNames(setName);
foreach (string fileName in filesProcessed)
{
var fullPath = context.Server.MapPath(fileName.trim());
if (fullPath.fileExists())
{
allScripts.AppendLine("\n\n/********************************** ");
allScripts.AppendLine(" ***** " + fileName);
allScripts.AppendLine(" **********************************/\n\n");
allScripts.AppendLine(File.ReadAllText(fullPath));
}
}
var codeToSend = allScripts.ToString();
if (minifyCode)
{
// Minify the combined script files and remove comments and white spaces
var minifier = new JavaScriptMinifier();
minifiedCode = minifier.Minify(codeToSend);
codeToSend = minifiedCode;
}
// Send minfied string to output stream
byte[] bts = Encoding.UTF8.GetBytes(codeToSend);
writer.Write(bts, 0, bts.Length);
}
// Generate the response
var responseBytes = memoryStream.ToArray();
WriteBytes(responseBytes, isCompressed);
}
}
catch (Exception ex)
{
ex.log();
response.Write("//Error processing request" + ex.Message);
response.End();
}
}
public static string HtmlEncode(object value)
{
return(value == null ? string.Empty : Encoder.HtmlEncode(value.ToString()));
}
public static string JavascriptEncode(string str, bool emitQuotes = false)
{
return(Encoder.JavaScriptEncode(str, emitQuotes));
}
public static string JavascriptEncode(string str)
{
return(Encoder.JavaScriptEncode(str));
}
public static string XmlEncode(string input)
{
return(Encoder.XmlEncode(input));
}
public static string LdapDistinguishedNameEncode(string input)
{
return(Encoder.LdapDistinguishedNameEncode(input));
}
public static string CssEncode(string str)
{
return(Encoder.CssEncode(str));
}
public static string UrlEncode(string input, Encoding inputEncoding)
{
return(Encoder.UrlEncode(input, inputEncoding));
}
public static string HtmlAttributeEncode(string str)
{
return(Encoder.HtmlAttributeEncode(str));
}
public static string UrlEncode(string input)
{
return(Encoder.UrlEncode(input));
}
public static string HtmlEncode(string str, bool useNamedEntities)
{
return(Encoder.HtmlEncode(str, useNamedEntities));
}
private static string Encode(string str)
{
return(Encoder.XmlEncode(str));
}
public static string HtmlFormUrlEncode(string str, Encoding inputEncoding)
{
return(Encoder.HtmlFormUrlEncode(str, inputEncoding));
}
