public static string GetExtension(this ConverterType converterType)
{
switch (converterType)
{
case ConverterType.Latex:
return(".tex");
case ConverterType.Markdown:
return(".md");
case ConverterType.Undefined:
case ConverterType.Text:
return(".txt");
default:
return("." + converterType.ToString().ToLower());
}
}
public static IEnumerable <MultipartFormParameter> ApiParameter(ConverterType from, ConverterType to, string template, string csl)
{
if (from != ConverterType.Undefined)
{
yield return(CreateField("from", from.ToString().ToLower()));
yield return(CreateField("ext", from.GetExtension()));
}
if (to != ConverterType.Undefined)
{
yield return(CreateField("to", to.ToString().ToLower()));
}
if (!string.IsNullOrWhiteSpace(template))
{
yield return(CreateField("template", template));
}
if (!string.IsNullOrWhiteSpace(csl))
{
yield return(CreateField("csl", csl));
}
}
public override IScriptCommand Execute(IParameterDic pm)
{
Func <object, object> checkParameters = p =>
{
if (p is string)
{
string pString = p as string;
if (pString.StartsWith("{") && pString.EndsWith("}"))
{
return(pm.Get(pString));
}
}
return(p);
};
switch (ConverterType)
{
case ValueConverterType.GetArrayItem:
Int32 id = ConverterParameter.Count() > 0 ? Int32.Parse(ConverterParameter.First().ToString()) : -1;
if (id == -1)
{
return(ResultCommand.Error(new KeyNotFoundException()));
}
Value = (Func <Object, Object>)(v => (v as Array).GetValue(id));
break;
case ValueConverterType.GetProperty:
string property = ConverterParameter.Count() > 0 ? ConverterParameter.First() as string : null;
Func <Object, Object> retVal = String.IsNullOrEmpty(property) ?
(Func <Object, Object>)(v => v) :
(Func <Object, Object>)(v =>
{
var typeInfo = v is Array ? typeof(Array).GetTypeInfo() : v.GetType().GetTypeInfo();
var propertyInfo = typeInfo.GetPropertyInfoRecursive(property);
if (propertyInfo == null)
{
var fieldInfo = typeInfo.GetFieldInfoRecursive(property);
if (fieldInfo == null)
{
throw new KeyNotFoundException(String.Format("{0} cannot be found in {1}", property, v.GetType()));
}
else
{
return(fieldInfo.GetValue(v));
}
}
else
{
return(propertyInfo.GetValue(v));
}
});
Value = retVal;
break;
case ValueConverterType.SetProperty:
string property1 = ConverterParameter.Count() > 0 ? ConverterParameter.First() as string : null;
Action <Object, Object> retVal1 = String.IsNullOrEmpty(property1) ?
(Action <Object, Object>)((o, v) => { }) :
(Action <Object, Object>)((o, v) =>
{
if (o == null)
{
return;
}
var typeInfo = o is Array ? typeof(Array).GetTypeInfo() : o.GetType().GetTypeInfo();
var propertyInfo = typeInfo.GetPropertyInfoRecursive(property1);
if (propertyInfo == null)
{
var fieldInfo = typeInfo.GetFieldInfoRecursive(property1);
if (fieldInfo == null)
{
logger.Error(String.Format("{0} cannot be found in {1}", property1, o.GetType()));
}
else
{
fieldInfo.SetValue(o, v);
}
}
else
{
propertyInfo.SetValue(o, v);
}
});
Value = retVal1;
break;
case ValueConverterType.ExecuteMethod:
string methodName = ConverterParameter.Count() > 0 ? ConverterParameter.First() as string : null;
object[] methodParameters = ConverterParameter.Skip(1)
.Select(param => checkParameters(param))
.ToArray();
Func <MethodInfo, bool> matchParametrers = (pi) =>
{
if (pi.GetParameters().Length == methodParameters.Length)
{
//var parameters = pi.GetParameters();
//for (int i = 0; i < methodParameters.Length; i++)
//{
// if (!(parameters[i].ParameterType
// .IsAssignableFrom(methodParameters[i].GetType())))
// return false;
//}
return(true);
}
return(false);
};
Func <Object, Object> retVa1l = String.IsNullOrEmpty(methodName) ?
(Func <Object, Object>)(v => v) :
(Func <Object, Object>)(v =>
{
var typeInfo = v is Array ? typeof(Array).GetTypeInfo() : v.GetType().GetTypeInfo();
var methodInfo = typeInfo.DeclaredMethods
.FirstOrDefault(
pi =>
pi.Name.Equals(methodName, StringComparison.CurrentCultureIgnoreCase) &&
matchParametrers(pi));
if (methodInfo == null)
{
throw new KeyNotFoundException(methodName);
}
else
{
return(methodInfo.Invoke(v, methodParameters));
}
});
Value = retVa1l;
break;
case ValueConverterType.AddValue:
Func <Object, Object> retVa12 = (Func <Object, Object>)(v =>
{
var mInfo = typeof(FileExplorer.Utils.ExpressionUtils)
.GetRuntimeMethods().First(m => m.Name == "Add")
.MakeGenericMethod(v.GetType());
foreach (var addItem in ConverterParameter.Select(p => checkParameters(p)).ToArray())
{
v = mInfo.Invoke(null, new object[] { v, addItem });
}
return(v);
});
Value = retVa12;
break;
case ValueConverterType.ConcatArray:
Func <Object, Object> retVa13 = (Func <Object, Object>)(v =>
{
var parameters = ConverterParameter.Select(p => checkParameters(p)).ToArray();
if (v == null)
{
v = Array.CreateInstance(parameters.First().GetType(), new int[] { 0 });
}
List <object> items2Add = new List <object>();
foreach (var item in parameters)
{
if (item is Array)
{
items2Add.AddRange((item as Array).Cast <object>());
}
else
{
items2Add.Add(item);
}
}
Array array = v as Array;
Type arrayType = array.GetType().GetElementType();
Array newArray = Array.CreateInstance(arrayType, array.Length + items2Add.Count());
Array.Copy(array, 0, newArray, 0, array.Length);
Array.Copy(items2Add.ToArray(), 0, newArray, array.Length, items2Add.Count());
return(newArray);
});
Value = retVa13;
break;
//case ValueConverterType.SubString:
// Func<Object, Object> retVa14 = (Func<Object, Object>)(v =>
// {
// if (ConverterParameter.Length != 2)
// return ResultCommand.Error(new ArgumentException("Incorrect number of parameters (2)."));
// var parameters = ConverterParameter.Select(p => checkParameters(p)).ToArray();
// int startIdx = (int)parameters[0];
// int? length = (int?)parameters[1];
// string str = v as string;
// return length.HasValue ? str.Substring(startIdx, length.Value) : str.Substring(startIdx);
// });
// Value = retVa14;
// break;
default: return(ResultCommand.Error(new NotSupportedException(ConverterType.ToString())));
}
return(base.Execute(pm));
}
