public static bool TryConvertUnsafeString(IManosContext ctx, Type type, ParameterInfo param, UnsafeString unsafe_str_value, out object data)
{
if (type == typeof(UnsafeString))
{
data = unsafe_str_value;
return(true);
}
string str_value = unsafe_str_value == null ? null : unsafe_str_value.SafeValue;
if (TryConvertFormData(type, str_value, out data))
{
return(true);
}
if (str_value == null && param.DefaultValue != DBNull.Value)
{
data = param.DefaultValue;
return(true);
}
try {
data = Convert.ChangeType(str_value, type);
} catch {
Console.Error.WriteLine("Error while converting '{0}' to '{1}'.", str_value, type);
data = null;
return(false);
}
return(true);
}
public static bool TryGetDataForParamList(ParameterInfo [] parameters, ManosApp app, IManosContext ctx, out object [] data)
{
data = new object [parameters.Length];
int param_start = 1;
data [0] = ctx;
if (typeof(ManosApp).IsAssignableFrom(parameters [1].ParameterType))
{
data [1] = app;
++param_start;
}
for (int i = param_start; i < data.Length; i++)
{
string name = parameters [i].Name;
UnsafeString strd = ctx.Request.Data.Get(name);
if (!TryConvertType(ctx, parameters [i].ParameterType, strd, out data [i]))
{
return(false);
}
}
return(true);
}
/// <summary>
/// Assign a value into this dictionary with the specified key.
/// </summary>
/// <param name="key">
/// A <see cref="System.String"/>
/// </param>
/// <param name="value">
/// A <see cref="UnsafeString"/>
/// </param>
public void Set(string key, UnsafeString value)
{
int open = key.IndexOf('[');
if (open == -1)
{
dictionary [key] = value;
return;
}
string elkey = key.Substring(0, open);
int close = key.IndexOf(']');
if (close == -1 || close < open)
{
dictionary [elkey] = value;
return;
}
object col;
if (close == open + 1)
{
List <UnsafeString> list = null;
if (dictionary.TryGetValue(elkey, out col))
{
list = col as List <UnsafeString>;
if (list != null)
{
list.Add(value);
return;
}
}
list = new List <UnsafeString> ();
list.Add(value);
dictionary [elkey] = list;
return;
}
Dictionary <string, UnsafeString> dict = null;
string dname = UnsafeString.Escape(key.Substring(open + 1, close - open - 1));
if (dictionary.TryGetValue(elkey, out col))
{
dict = col as Dictionary <string, UnsafeString>;
if (dict != null)
{
dict [dname] = value;
return;
}
}
dict = new Dictionary <string, UnsafeString> ();
dict [dname] = value;
dictionary [elkey] = dict;
}
/// <summary>
/// Get a "safe" string from the dictionary, or, if the key doesn't exist in the dictionary, null.
/// </summary>
/// <param name="key">
/// </param>
/// <returns>
/// The "safe" version of the value that is stored in the dictionary.
/// </returns>
public string GetString(string key)
{
UnsafeString str = Get(key);
if (str == null)
{
return(null);
}
return(str.SafeValue);
}
/// <summary>
/// The "unsafe" version of the value that is stored in this dictionary, or "null" if no value is stored for the specified key.
/// </summary>
/// <param name="key">
/// A <see cref="System.String"/>
/// </param>
/// <returns>
/// A <see cref="UnsafeString"/>
/// </returns>
public UnsafeString Get(string key)
{
UnsafeString value = null;
if (dictionary.TryGetValue(key, out value))
{
return(value);
}
if (children != null)
{
children.Where(d => (value = d.Get(key)) != null).FirstOrDefault();
}
return(value);
}
public static bool TryConvertType(IManosContext ctx, Type type, UnsafeString unsafe_str_value, out object data)
{
if (type == typeof (UnsafeString)) {
data = unsafe_str_value;
return true;
}
string str_value = unsafe_str_value.SafeValue;
try {
data = Convert.ChangeType (str_value, type);
} catch {
Console.Error.WriteLine ("Error while converting '{0}' to '{1}'.", str_value, type);
data = null;
return false;
}
return true;
}
public byte [] GetBody()
{
StringBuilder data = null;
if (PostBody != null)
{
data = new StringBuilder();
data.Append(PostBody);
}
if (post_data != null)
{
data = new StringBuilder();
bool first = true;
foreach (string key in post_data.Keys)
{
if (!first)
{
data.Append('&');
}
first = false;
UnsafeString s = post_data.Get(key);
if (s != null)
{
data.AppendFormat("{0}={1}", key, s.UnsafeValue);
continue;
}
}
}
if (data == null)
{
return(null);
}
return(ContentEncoding.GetBytes(data.ToString()));
}
protected override void Write(UnsafeString message)
{
Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} \u00A6 " + message);
}
public void Set(string key, UnsafeString value)
{
dictionary [key] = value;
}
public void Set(string key, string value)
{
dictionary [key] = new UnsafeString (value);
}
public static bool TryConvertUnsafeString(IContext ctx, Type type, ParameterInfo param, UnsafeString unsafe_str_value, out object data)
{
if (type == typeof (UnsafeString)) {
data = unsafe_str_value;
return true;
}
string str_value = unsafe_str_value == null ? null : unsafe_str_value.SafeValue;
if (TryConvertFormData (type, str_value, out data))
return true;
if (str_value == null && param.DefaultValue != DBNull.Value) {
data = param.DefaultValue;
return true;
}
try {
data = Convert.ChangeType (str_value, type);
} catch {
Console.Error.WriteLine ("Error while converting '{0}' to '{1}'.", str_value, type);
data = null;
return false;
}
return true;
}
public static bool TryConvertType(IManosContext ctx, string name, ParameterInfo param, out object data)
{
Type dest = param.ParameterType;
if (dest.IsArray)
{
var list = ctx.Request.Data.GetList(name);
if (list != null)
{
Type element = dest.GetElementType();
IList arr = Array.CreateInstance(element, list.Count);
for (int i = 0; i < list.Count; i++)
{
object elem_data;
if (!TryConvertUnsafeString(ctx, element, param, list [i], out elem_data))
{
data = null;
return(false);
}
arr [i] = elem_data;
}
data = arr;
return(true);
}
}
if (dest.GetInterface("IDictionary") != null)
{
var dict = ctx.Request.Data.GetDict(name);
if (dict != null)
{
Type eltype = typeof(UnsafeString);
IDictionary dd = (IDictionary)Activator.CreateInstance(dest);
if (dest.IsGenericType)
{
Type [] args = dest.GetGenericArguments();
if (args.Length != 2)
{
throw new Exception("Generic Dictionaries must contain two generic type arguments.");
}
if (args [0] != typeof(string))
{
throw new Exception("Generic Dictionaries must use strings for their keys.");
}
eltype = args [1]; // ie the TValue in Dictionary<TKey,TValue>
}
foreach (string key in dict.Keys)
{
object elem_data;
if (!TryConvertUnsafeString(ctx, eltype, param, dict [key], out elem_data))
{
data = null;
return(false);
}
dd.Add(key, elem_data);
}
data = dd;
return(true);
}
}
UnsafeString strd = ctx.Request.Data.Get(name);
return(TryConvertUnsafeString(ctx, dest, param, strd, out data));
}
/// <summary>
/// Assign a value into this dictionary with the specified key.
/// </summary>
/// <param name="key">
/// A <see cref="System.String"/>
/// </param>
/// <param name="value">
/// A <see cref="UnsafeString"/>
/// </param>
public void Set(string key, UnsafeString value)
{
dictionary [key] = value;
}
/// <summary>
/// Assign a value into this dictionary with the specified key.
/// </summary>
/// <param name="key">
/// A <see cref="System.String"/>
/// </param>
/// <param name="value">
/// A <see cref="System.String"/>
/// </param>
public void Set(string key, string value)
{
dictionary [key] = new UnsafeString(value);
}
protected override void Write(UnsafeString message)
{
var log = ((ServiceStackLoggingTypeSource)TypeSource).Log;
var messageString = message.ToString();
switch (Level)
{
case LogLevel.None:
break;
case LogLevel.Trace:
case LogLevel.Debug:
if (Exception == null)
{
log.Debug(messageString);
}
else
{
log.Debug(messageString, Exception);
}
break;
case LogLevel.Info:
if (Exception == null)
{
log.Info(messageString);
}
else
{
log.Info(messageString, Exception);
}
break;
case LogLevel.Warning:
if (Exception == null)
{
log.Warn(messageString);
}
else
{
log.Warn(messageString, Exception);
}
break;
case LogLevel.Error:
if (Exception == null)
{
log.Error(messageString);
}
else
{
log.Error(messageString, Exception);
}
break;
case LogLevel.Critical:
if (Exception == null)
{
log.Fatal(messageString);
}
else
{
log.Fatal(messageString, Exception);
}
break;
}
}
/// <inheritdoc />
protected override void Write(UnsafeString message)
{
Log.Write(TranslateLevel(this.Level), "PostSharp", this, null, this.Exception, LogWriteMode.Queued,
null, this.TypeSource.Role + "." + this.RecordKind.ToString(), message.ToString(), null);
}