public override IEnumerable<DynamicNode> GetDynamicNodeCollection()
{
var result = new List<DynamicNode>();
var assembly = Assembly.GetExecutingAssembly();
var controllers = assembly.GetTypes().Where(t => t.IsSubclassOf(typeof(Controller)) && !t.Name.StartsWith("T4MVC_"));
foreach (var controller in controllers)
{
var controllerName = controller.Name.Replace("Controller", string.Empty);
var actions = controller.GetMethods()
.Where(m => m.ReturnType.IsSubclassOf(typeof(ActionResult)) || m.ReturnType == typeof(ActionResult))
.Where(m => !m.GetCustomAttributes(typeof(NonActionAttribute), true).Any())
.Where(m => m.IsPublic);
foreach (var action in actions)
{
var isOnBlackList = BlackList.Any(bl => bl.Item1 == controllerName && bl.Item2 == action.Name);
var isPartialAction = action.GetCustomAttributes(typeof (DefaultRoutingAttribute), true).Any();
var isPrivate = action.GetCustomAttributes(typeof(AuthorizeAttribute), true).Any() || action.GetCustomAttributes(typeof(AuthorizeRolesAttribute), true).Any();
var isPost = action.GetCustomAttributes(typeof (HttpPostAttribute), true).Any();
var hasParameters = action.GetParameters().Any(p => !p.IsOptional);
if (isOnBlackList || isPartialAction || isPrivate || isPost || hasParameters)
continue;
var node = new DynamicNode {Controller = controllerName, Action = action.Name};
var isChangingFrequently = FrequentlyChanging.Any(fc => fc.Item1 == controllerName && fc.Item2 == action.Name);
if (isChangingFrequently)
node.ChangeFrequency = ChangeFrequency.Daily;
else
node.ChangeFrequency = ChangeFrequency.Monthly;
result.Add(node);
}
}
return result;
}
public override IEnumerable<DynamicNode> GetDynamicNodeCollection()
{
var returnValue = new List<DynamicNode>();
foreach (SiteMapModel post in _postService.GetSiteMapData(20))
{
var node = new DynamicNode
{
Title = post.Title,
Controller = "Post",
Action = "Index",
Area = "",
LastModifiedDate = post.ModifiedDate ?? post.CreatedDate,
ChangeFrequency = ChangeFrequency.Daily,
UpdatePriority = UpdatePriority.Absolute_050,
};
node.RouteValues.Add("id", post.Id);
node.RouteValues.Add("title", UrlExtensions.ResolveTitleForUrl(node.Title));
returnValue.Add(node);
}
// Return
return returnValue;
}
protected override string ParseMethod( DynamicNode.Method node, KParameterList pars )
{
string host = Parse( node.Host, pars );
string name = node.Name.ToUpper();
string item = null;
string alias = null;
string extra = null;
// ROOT-LEVEL...
if( host == null ) {
switch( name ) {
case "CAST":
if( node.Arguments == null || node.Arguments.Length != 2 ) throw new ArgumentException( "CAST operator expects two arguments." );
item = Parse( node.Arguments[0], pars ); // No raw strings
alias = Parse( node.Arguments[1], null, rawstr: true ); // pars=null to avoid parametrize aliases
alias = alias.Validated( "Alias", invalidChars: TypeHelper.InvalidNameChars );
return string.Format( "CAST( {0} AS {1} )", item, alias );
}
}
// COLUMN-LEVEL...
else {
switch( name ) {
case "LEFT":
if( node.Arguments == null || node.Arguments.Length != 1 ) throw new ArgumentException( "LEFT operator expects one argument." );
item = Parse( node.Arguments[0], pars );
return string.Format( "LEFT( {0}, {1} )", host, item );
case "RIGHT":
if( node.Arguments == null || node.Arguments.Length != 1 ) throw new ArgumentException( "RIGHT operator expects one argument." );
item = Parse( node.Arguments[0], pars );
return string.Format( "RIGHT( {0}, {1} )", host, item );
case "LEN":
if( node.Arguments != null && node.Arguments.Length != 0 ) throw new ArgumentException( "LEN operator does not expect any arguments." );
return string.Format( "LEN( {0} )", host );
case "LOWER":
if( node.Arguments != null && node.Arguments.Length != 0 ) throw new ArgumentException( "LOWER operator does not expect any arguments." );
return string.Format( "LOWER( {0} )", host );
case "UPPER":
if( node.Arguments != null && node.Arguments.Length != 0 ) throw new ArgumentException( "UPPER operator does not expect any arguments." );
return string.Format( "UPPER( {0} )", host );
case "YEAR":
if( node.Arguments != null && node.Arguments.Length != 0 ) throw new ArgumentException( "YEAR operator does not expect any arguments." );
return string.Format( "DATEPART( YEAR, {0} )", host );
case "MONTH":
if( node.Arguments != null && node.Arguments.Length != 0 ) throw new ArgumentException( "MONTH operator does not expect any arguments." );
return string.Format( "DATEPART( MONTH, {0} )", host );
case "DAY":
if( node.Arguments != null && node.Arguments.Length != 0 ) throw new ArgumentException( "DAY operator does not expect any arguments." );
return string.Format( "DATEPART( DAY, {0} )", host );
case "HOUR":
if( node.Arguments != null && node.Arguments.Length != 0 ) throw new ArgumentException( "HOUR operator does not expect any arguments." );
return string.Format( "DATEPART( HOUR, {0} )", host );
case "MINUTE":
if( node.Arguments != null && node.Arguments.Length != 0 ) throw new ArgumentException( "MINUTE operator does not expect any arguments." );
return string.Format( "DATEPART( MINUTE, {0} )", host );
case "SECOND":
if( node.Arguments != null && node.Arguments.Length != 0 ) throw new ArgumentException( "SECOND operator does not expect any arguments." );
return string.Format( "DATEPART( SECOND, {0} )", host );
case "MILLISECOND":
if( node.Arguments != null && node.Arguments.Length != 0 ) throw new ArgumentException( "MILLISECOND operator does not expect any arguments." );
return string.Format( "DATEPART( MILLISECOND, {0} )", host );
case "OFFSET":
if( node.Arguments != null && node.Arguments.Length != 0 ) throw new ArgumentException( "OFFSET operator does not expect any arguments." );
return string.Format( "DATEPART( TZ, {0} )", host );
case "LIKE":
if( node.Arguments == null || node.Arguments.Length != 1 ) throw new ArgumentException( "LIKE operator expects one argument." );
item = Parse( node.Arguments[0], pars );
return string.Format( "( {0} LIKE {1} )", host, item );
case "NOTLIKE":
if( node.Arguments == null || node.Arguments.Length != 1 ) throw new ArgumentException( "NOT LIKE operator expects one argument." );
item = Parse( node.Arguments[0], pars );
return string.Format( "( {0} NOT LIKE {1} )", host, item );
case "CONTAINS":
if( node.Arguments == null || node.Arguments.Length != 1 ) throw new ArgumentException( "CONTAINS operator expects one argument." );
item = Parse( node.Arguments[0], pars );
return string.Format( "CONTAINS( {0}, {1} )", host, item );
case "PATINDEX":
if( node.Arguments == null || node.Arguments.Length != 1 ) throw new ArgumentException( "PATINDEX operator expects one argument." );
item = Parse( node.Arguments[0], pars );
return string.Format( "PATINDEX( {1}, {0} )", host, item ); // Note {0} and {1} are reversed
case "SUBSTRING":
if( node.Arguments == null || node.Arguments.Length != 2 ) throw new ArgumentException( "SUBSTRING operator expects two arguments." );
item = Parse( node.Arguments[0], pars );
extra = Parse( node.Arguments[1], pars );
return string.Format( "SUBSTRING( {0}, {1}, {2} )", host, item, extra );
case "LTRIM":
if( node.Arguments != null && node.Arguments.Length != 0 ) throw new ArgumentException( "LTRIM operator does not expect any arguments." );
return string.Format( "LTRIM( {0} )", host );
case "RTRIM":
if( node.Arguments != null && node.Arguments.Length != 0 ) throw new ArgumentException( "RTRIM operator does not expect any arguments." );
return string.Format( "RTRIM( {0} )", host );
case "TRIM":
if( node.Arguments != null && node.Arguments.Length != 0 ) throw new ArgumentException( "TRIM operator does not expect any arguments." );
return string.Format( "LTRIM( RTRIM( {0} ) )", host );
}
}
// DEFAULT case...
return base.ParseMethod( node, pars );
}
private void zStart(string[] args) {
var path = @"C:\Program Files (x86)\MSBuild\Microsoft.Cpp\v4.0\V110\1033\lib.xml";
var doc = XDocument.Load(path);
dynamic xml = new DynamicNode(doc);
foreach (var property in xml) {
string subType = property.Attributes.Has("Subtype") ? property.Attributes.Subtype : "";
switch ((string)property.LocalName) {
case "BoolProperty":
Console.WriteLine(@"""{0}"".MapBoolean(),", property.Attributes.Name);
break;
case "StringListProperty":
switch (subType) {
case "folder":
Console.WriteLine(@"""{0}"".MapFolderList(),", property.Attributes.Name);
break;
case "file":
Console.WriteLine(@"""{0}"".MapFileList(),", property.Attributes.Name);
break;
case "":
Console.WriteLine(@"""{0}"".MapStringList(),", property.Attributes.Name);
break;
default:
throw new Exception("Unknown subtype:{0}".format(subType));
}
break;
case "IntProperty":
Console.WriteLine(@"""{0}"".MapInt(),", property.Attributes.Name);
break;
case "StringProperty":
switch (subType) {
case "folder":
Console.WriteLine(@"""{0}"".MapFolder(),", property.Attributes.Name);
break;
case "file":
Console.WriteLine(@"""{0}"".MapFile(),", property.Attributes.Name);
break;
case "":
Console.WriteLine(@"""{0}"".MapString(),", property.Attributes.Name);
break;
default:
throw new Exception("Unknown subtype:{0}".format(subType));
}
break;
case "EnumProperty":
var values = new List<string>();
foreach (var enumvalue in property) {
if (enumvalue.LocalName == "EnumProperty.Arguments") {
continue;
}
values.Add(enumvalue.Attributes.Name);
}
Console.WriteLine(@"""{0}"".MapEnum({1}),", property.Attributes.Name, values.Select(each => @"""" + each + @"""").Aggregate((current, each) => current + ", " + each));
break;
case "Rule.Categories":
case "Rule.DataSource":
break;
default:
Console.WriteLine("==============================UNKNOWN TYPE: {0}", property.LocalName);
break;
}
}
}
/// <summary>
/// Parses a method invocation.
/// This method is used to implement the virtual extensions feature, including:
/// <para>Argument level:</para>
/// <para>- x.Not(...) => (NOT ...)</para>
/// <para>- x.Distinct(expression) => DISTINCT expression</para>
/// <para>Element level:</para>
/// <para>- x.Element.As(name) => Element AS name</para>
/// <para>- x.Element.In(arg, ...) => Element IN (arg, ...)</para>
/// <para>- x.Element.NotIn(arg, ...) => NOT Element IN (arg, ...)</para>
/// <para>- x.Element.Between(arg1, arg2) => Element BETWEEN arg1 AND arg2</para>
/// <para>- x.Element.Like(arg) => Element LIKE arg</para>
/// <para>- x.Element.NotLike(arg) => Element NOT LIKE arg</para>
/// <para>Default case:</para>
/// <para>- The default case where the name of the method and its arguments are parsed as-is.</para>
/// <para>This overriden method adds the following ones:</para>
/// <para>- x.Element.Cast(type)</para>
/// <para>- x.Element.Left(n), x.Element.Right(n)</para>
/// <para>- x.Element.Len(), x.Element.Lower(), x.Element.Upper()</para>
/// <para>- x.Element.Year(), x.Element.Month(), x.Element.Day()</para>
/// <para>- x.Element.Hour(), x.Element.Minute(), x.Element.Second(), x.Element.Millisecond()</para>
/// <para>- x.Element.Offset()</para>
/// <para>- x.Element.Contains(item), x.Element.Patindex(num), x.Element.Substring(start,len)</para>
/// <para>- x.Element.Trim(), x.Element.Rtrim(), x.Element.Rtrim()</para>
/// </summary>
protected override string OnParseMethod(DynamicNode.Method obj, Core.IParameterCollection pars, bool nulls)
{
string name = obj.Name.ToUpper();
string parent = obj.Host == null ? null : Parse(obj.Host, pars, nulls);
string item = null;
string extra = null;
// Root-level methods...
if (obj.Host == null)
{
switch (name)
{
case "CAST":
if (obj.Arguments == null) throw new ArgumentException("CAST() argument list is null.");
if (obj.Arguments.Length != 2) throw new ArgumentException("CAST() requires two arguments.");
item = Parse(obj.Arguments[0], pars, nulls);
extra = Parse(obj.Arguments[1], pars, nulls);
return string.Format("CAST({0} AS {1})", item, extra);
}
}
// Item-level methods...
if (obj.Host != null)
{
switch (name)
{
case "LEFT":
if (obj.Arguments == null) throw new ArgumentException("LEFT() argument list is null.");
if (obj.Arguments.Length != 1) throw new ArgumentException("LEFT() requires one argument.");
item = Parse(obj.Arguments[0], pars, nulls);
return string.Format("LEFT({0}, {1})", parent, item);
case "RIGHT":
if (obj.Arguments == null) throw new ArgumentException("RIGHT() argument list is null.");
if (obj.Arguments.Length != 1) throw new ArgumentException("RIGHT() requires one argument.");
item = Parse(obj.Arguments[0], pars, nulls);
return string.Format("RIGHT({0}, {1})", parent, item);
case "LEN":
if (obj.Arguments != null) throw new ArgumentException("LEN() shall be a parameterless method.");
return string.Format("LEN({0})", parent);
case "LOWER":
if (obj.Arguments != null) throw new ArgumentException("LOWER() shall be a parameterless method.");
return string.Format("LOWER({0})", parent);
case "UPPER":
if (obj.Arguments != null) throw new ArgumentException("UPPER() shall be a parameterless method.");
return string.Format("UPPER({0})", parent);
case "YEAR":
if (obj.Arguments != null) throw new ArgumentException("YEAR() shall be a parameterless method.");
return string.Format("DATEPART(YEAR, {0})", parent);
case "MONTH":
if (obj.Arguments != null) throw new ArgumentException("MONTH() shall be a parameterless method.");
return string.Format("DATEPART(MONTH, {0})", parent);
case "DAY":
if (obj.Arguments != null) throw new ArgumentException("DAY() shall be a parameterless method.");
return string.Format("DATEPART(DAY, {0})", parent);
case "HOUR":
if (obj.Arguments != null) throw new ArgumentException("HOUR() shall be a parameterless method.");
return string.Format("DATEPART(HOUR, {0})", parent);
case "MINUTE":
if (obj.Arguments != null) throw new ArgumentException("MINUTE() shall be a parameterless method.");
return string.Format("DATEPART(MINUTE, {0})", parent);
case "SECOND":
if (obj.Arguments != null) throw new ArgumentException("SECOND() shall be a parameterless method.");
return string.Format("SECOND(DAY, {0})", parent);
case "MILLISECOND":
if (obj.Arguments != null) throw new ArgumentException("MILLISECOND() shall be a parameterless method.");
return string.Format("DATEPART(MILLISECOND, {0})", parent);
case "OFFSET":
if (obj.Arguments != null) throw new ArgumentException("OFFSET() shall be a parameterless method.");
return string.Format("DATEPART(TZ, {0})", parent);
case "CONTAINS":
if (obj.Arguments == null) throw new ArgumentException("CONTAINS() argument list is null.");
if (obj.Arguments.Length != 1) throw new ArgumentException("CONTAINS() requires just one argument.");
item = Parse(obj.Arguments[0], pars, nulls);
return string.Format("CONTAINS({0}, {1})", parent, item);
case "PATINDEX":
if (obj.Arguments == null) throw new ArgumentException("PATINDEX() argument list is null.");
if (obj.Arguments.Length != 1) throw new ArgumentException("PATINDEX() requires just one argument.");
item = Parse(obj.Arguments[0], pars, nulls);
return string.Format("PATINDEX({1}, {0})", parent, item); // Beware, indexes inverted!
case "SUBSTRING":
if (obj.Arguments == null) throw new ArgumentException("SUBSTRING() argument list is null.");
if (obj.Arguments.Length != 2) throw new ArgumentException("SUBSTRING() requires two arguments.");
item = Parse(obj.Arguments[0], pars, nulls);
extra = Parse(obj.Arguments[1], pars, nulls);
return string.Format("SUBSTRING({0}, {1}, {2})", parent, item, extra);
case "LTRIM":
if (obj.Arguments != null) throw new ArgumentException("LTRIM() is a parameterless method.");
return string.Format("LTRIM({0})", parent);
case "RTRIM":
if (obj.Arguments != null) throw new ArgumentException("RTRIM() is a parameterless method.");
return string.Format("RTRIM({0})", parent);
case "TRIM":
if (obj.Arguments != null) throw new ArgumentException("TRIM() is a parameterless method.");
return string.Format("LTRIM(RTRIM({0}))", parent);
}
}
// Reverting to whatever the base class intercepts...
return base.OnParseMethod(obj, pars, nulls);
}
protected virtual string ParseInvoke( DynamicNode.Invoke node, KParameterList pars = null )
{
// This is used as an especial syntax to merely concatenate its arguments separated by spaces if needed...
// It is used as a way to extend the supported syntax without the need of treating all the possible cases...
if( node.Arguments == null ) return string.Empty;
if( node.Arguments.Length == 0 ) return string.Empty;
StringBuilder sb = new StringBuilder();
bool first = true;
foreach( object arg in node.Arguments ) {
if( !first ) {
bool space = true;
if( ( arg is string ) && ( (string)arg ).StartsWith( " " ) ) space = false;
if( space ) sb.Append( " " );
}
else first = false;
if( arg is string ) sb.Append( (string)arg );
else sb.Append( Parse( arg, pars, rawstr: true, nulls: true ) );
}
return sb.ToString();
}
protected virtual string ParseBinary( DynamicNode.Binary node, KParameterList pars = null )
{
string op = ""; switch( node.Operation ) {
case ExpressionType.Add: op = "+"; break;
case ExpressionType.Subtract: op = "-"; break;
case ExpressionType.Multiply: op = "*"; break;
case ExpressionType.Divide: op = "/"; break;
case ExpressionType.Modulo: op = "%"; break;
case ExpressionType.Power: op = "^"; break;
case ExpressionType.And: op = "AND"; break;
case ExpressionType.Or: op = "OR"; break;
// Treating NULL targets as special cases...
case ExpressionType.Equal: op = node.Right == null ? "IS" : "="; break;
case ExpressionType.NotEqual: op = node.Right == null ? "IS NOT" : "!="; break;
case ExpressionType.GreaterThan: op = ">"; break;
case ExpressionType.GreaterThanOrEqual: op = ">="; break;
case ExpressionType.LessThan: op = "<"; break;
case ExpressionType.LessThanOrEqual: op = "<="; break;
default: throw new ArgumentException( "Not supported operator: '" + node.Operation + "'." );
}
string left = Parse( node.Left, pars ); // Not nulls: left is assumed to be an object
string right = Parse( node.Right, pars, nulls: true );
return string.Format( "( {0} {1} {2} )", left, op, right );
}
protected virtual string ParseSetMember( DynamicNode.SetMember node, KParameterList pars = null )
{
string parent = Parse( node.Host, pars );
string name = parent == null ? node.Name : string.Format( "{0}.{1}", parent, node.Name );
string value = Parse( node.Value, pars, nulls: true );
return string.Format( "{0} = ( {1} )", name, value );
}
/// <summary>
/// Mains the specified args.
/// </summary>
/// <param name="args">The args.</param>
/// <returns></returns>
/// <remarks></remarks>
private int main(IEnumerable<string> args)
{
var options = args.Switches();
var parameters = args.Parameters();
Console.CancelKeyPress += (x, y) => {
Console.WriteLine("Stopping ...");
};
foreach (string arg in options.Keys) {
IEnumerable<string> argumentParameters = options[arg];
switch (arg) {
case "nologo":
this.Assembly().SetLogo("");
break;
case "send":
send= true;
break;
case "rescan-tools":
ProgramFinder.IgnoreCache = true;
break;
case "output":
outputfilename = argumentParameters.Last().GetFullPath();
break;
case "default":
var drive = argumentParameters.Last();
var driveletter = string.IsNullOrEmpty(drive) ? 'c' : drive[0];
parameters = new[] {@"{0}:\program files*", @"{0}:\cyg*", @"{0}:\ming*", @"{0}:\msys*",@"{0}:\*ddk*"}.Select(d => d.format(driveletter)).Aggregate(parameters, (current, path) => current.UnionSingleItem(path));
break;
case "help":
return Help();
}
}
// make sure that we're in the parent directory of the .buildinfo file.
// Environment.CurrentDirectory = Path.GetDirectoryName(Path.GetDirectoryName(buildinfo));
Logo();
if (parameters.Count() < 1) {
return Fail("Missing directory to scan. \r\n\r\n Use --help for command line help.");
}
var dirList = new List<string>();
foreach( var d in parameters) {
var i = d.LastIndexOf("\\");
if (i > -1) {
dirList.AddRange(Directory.EnumerateDirectories(d.Substring(0, i + 1), d.Substring(i + 1)));
} else {
dirList.AddRange(Directory.EnumerateDirectories(Environment.CurrentDirectory,d));
}
}
Console.WriteLine("Folders that will be searched");
foreach (var dir in dirList) {
Console.WriteLine(" {0}", dir.GetFullPath());
}
Console.WriteLine("---------------------------------------------------------\r\n");
var EXEs = Enumerable.Empty<string>();
// EXEs = dirList.Aggregate(EXEs, (current, dir) => current.Union(Directory.EnumerateFiles(dir.GetFullPath(), "*.exe", SearchOption.AllDirectories)));
EXEs = dirList.Aggregate(EXEs, (current, dir) => current.Union(dir.GetFullPath().DirectoryEnumerateFilesSmarter("*.exe", SearchOption.AllDirectories) ));
// "".DirectoryEnumerateFilesSmarter("*.exe", SearchOption.AllDirectories)
var matchPatterns = new[] {
"*cl*.exe",
"*cc*.exe",
"*++*.exe",
"*cpp*.exe",
"*plusplus*.exe",
"*windres*.exe",
"*rc*.exe",
"*mc*.exe",
"*idl*.exe",
"*link*.exe",
"*ld*.exe",
"*lib*.exe",
"*asm*.exe",
"*ml*.exe",
"*mt*.exe",
"*make*.exe",
};
var filterPatterns = new[] {
"*plink*",
"**\\calibre**",
"**\\git**",
"**\\bazaar**",
"**\\jetbrains**",
"**sql**",
"**\\mirc**",
"**pantaray**",
"**Windows Installer XML**",
"**internet explorer**",
"**live**",
"**office**",
"**help**",
"**home server**",
"**media**",
};
var candidates = from exe in EXEs where
matchPatterns.HasWildcardMatch(exe) &&
!filterPatterns.HasWildcardMatch(exe) &&
new FileInfo(exe).Length > 4096
select exe;
dynamic xmldoc = new DynamicNode("Tools");
foreach (var exe in candidates) {
try {
var Node = InterrogateBinary(exe);
xmldoc.Node.Add(Node);
Console.WriteLine(" {0}", exe);
} catch (Exception e)
{
Console.WriteLine("{0} ===== {1}",exe, e.Message);
// Console.WriteLine(e.Message);
// Console.WriteLine(e.StackTrace);
}
}
if (!string.IsNullOrEmpty(outputfilename)) {
File.WriteAllText(outputfilename, xmldoc.Node.ToString());
} else if (send) {
// send it
Console.WriteLine("Uploading...");
var d = new Dictionary<string, string>();
d.Add("data", xmldoc.Node.ToString());
"http://static.withinwindows.com/sqm/upload.php".Post(d);
Console.WriteLine("Done");
}
else {
Console.WriteLine(xmldoc.Node.ToString());
}
return 0;
}
/// <summary>
/// Parsers a get member operation.
/// </summary>
protected virtual string OnParseGetMember(DynamicNode.GetMember obj, IParameterCollection pc, bool nulls)
{
string host = obj.Host == null ? null : Parse(obj.Host, pc, nulls);
string name = host == null ? obj.Name : "{0}.{1}".FormatWith(host, obj.Name);
return name;
}
/// <summary>
/// Parsers a dynamic argument.
/// </summary>
protected virtual string OnParseArgument(DynamicNode.Argument obj)
{
if (!Core.Parser.ComplexTags) return null;
if (obj.Name.Length <= 1) return null;
return obj.Name;
}
public static bool IsPropertyPopulated(this DynamicNode node, string propertyName, out string value)
{
value = node.SafeProperty(propertyName);
return(!string.IsNullOrEmpty(value));
}
public override IEnumerable <DynamicNode> GetDynamicNodeCollection(ISiteMapNode node)
{
var reader = unitOfWork.ReaderRepository.GetSPDataReader("SiteMap");
//USers
while (reader.Read())
{
DynamicNode dynamicNode = new DynamicNode("User_" + reader.GetInt32(0), reader[1] as string);
// Preserve our route parameter explicitly
dynamicNode.RouteValues.Add("UId", reader.GetInt32(0));
dynamicNode.RouteValues.Add("UName", StringHelper.URLName(String.Concat(reader[1] as string, " ", reader[2] as string)));
dynamicNode.Controller = "UserProfile";
dynamicNode.Action = "UProfile";
yield return(dynamicNode);
}
reader.NextResult();
//Company
while (reader.Read())
{
DynamicNode dynamicNode = new DynamicNode("Company_" + reader.GetInt32(0), reader[1] as string);
// Preserve our route parameter explicitly
dynamicNode.RouteValues.Add("CoId", reader.GetInt32(0));
dynamicNode.RouteValues.Add("CoName", StringHelper.URLName(reader[1] as string));
dynamicNode.Controller = "Company";
dynamicNode.Action = "CProfile";
yield return(dynamicNode);
}
reader.NextResult();
//Store
while (reader.Read())
{
DynamicNode dynamicNode = new DynamicNode("Store_" + reader.GetInt32(0), reader[1] as string);
// Preserve our route parameter explicitly
dynamicNode.RouteValues.Add("StId", reader.GetInt32(0));
dynamicNode.RouteValues.Add("StName", StringHelper.URLName(reader[1] as string));
dynamicNode.Controller = "Store";
dynamicNode.Action = "SProfile";
yield return(dynamicNode);
}
reader.NextResult();
//Product
while (reader.Read())
{
DynamicNode dynamicNode = new DynamicNode("Product_" + reader.GetInt32(0), reader[1] as string);
// Preserve our route parameter explicitly
dynamicNode.RouteValues.Add("PrId", reader.GetInt32(0));
dynamicNode.RouteValues.Add("PrName", StringHelper.URLName(reader[1] as string));
dynamicNode.Controller = "Product";
dynamicNode.Action = "Detail";
yield return(dynamicNode);
}
reader.NextResult();
//Service
while (reader.Read())
{
DynamicNode dynamicNode = new DynamicNode("Service_" + reader.GetInt32(0), reader[1] as string);
// Preserve our route parameter explicitly
dynamicNode.RouteValues.Add("SrId", reader.GetInt32(0));
dynamicNode.RouteValues.Add("SrName", StringHelper.URLName(reader[1] as string));
dynamicNode.Controller = "Service";
dynamicNode.Action = "Detail";
yield return(dynamicNode);
}
reader.NextResult();
//Question
while (reader.Read())
{
DynamicNode dynamicNode = new DynamicNode("Question_" + reader.GetInt32(0), reader[1] as string);
// Preserve our route parameter explicitly
dynamicNode.RouteValues.Add("QId", reader.GetInt32(0));
dynamicNode.RouteValues.Add("QName", StringHelper.URLName(reader[1] as string));
dynamicNode.Controller = "Question";
dynamicNode.Action = "Detail";
dynamicNode.LastModifiedDate = reader.GetDateTime(2);
yield return(dynamicNode);
}
reader.NextResult();
//Groups
while (reader.Read())
{
DynamicNode dynamicNode = new DynamicNode("Group_" + reader.GetInt32(0), reader[1] as string);
// Preserve our route parameter explicitly
dynamicNode.RouteValues.Add("GId", reader.GetInt32(0));
dynamicNode.RouteValues.Add("GName", StringHelper.URLName(reader[1] as string));
dynamicNode.Controller = "Group";
dynamicNode.Action = "GroupPage";
dynamicNode.LastModifiedDate = reader.GetDateTime(2);
yield return(dynamicNode);
}
reader.NextResult();
//GroupSessions
while (reader.Read())
{
DynamicNode dynamicNode = new DynamicNode("GroupSession_" + reader.GetInt32(0), reader[1] as string);
// Preserve our route parameter explicitly
dynamicNode.RouteValues.Add("SsId", reader.GetInt32(0));
dynamicNode.RouteValues.Add("GSName", StringHelper.URLName(reader[1] as string));
dynamicNode.Controller = "GroupSession";
dynamicNode.Action = "Detail";
dynamicNode.LastModifiedDate = reader.GetDateTime(2);
yield return(dynamicNode);
}
reader.NextResult();
//Seminars
while (reader.Read())
{
DynamicNode dynamicNode = new DynamicNode("Seminar_" + reader.GetInt32(0), reader[1] as string);
// Preserve our route parameter explicitly
dynamicNode.RouteValues.Add("SnId", reader.GetInt32(0));
dynamicNode.RouteValues.Add("SnName", StringHelper.URLName(reader[1] as string));
dynamicNode.Controller = "Seminar";
dynamicNode.Action = "Detail";
dynamicNode.LastModifiedDate = reader.GetDateTime(2);
yield return(dynamicNode);
}
reader.NextResult();
while (reader.Read())
{
DynamicNode dynamicNode = new DynamicNode("Book_" + reader.GetInt32(0), reader[1] as string);
// Preserve our route parameter explicitly
dynamicNode.RouteValues.Add("BId", reader.GetInt32(0));
dynamicNode.RouteValues.Add("BName", StringHelper.URLName(reader[1] as string));
dynamicNode.Controller = "Book";
dynamicNode.Action = "Detail";
dynamicNode.LastModifiedDate = reader.GetDateTime(2);
yield return(dynamicNode);
}
reader.Close();
}
// Note: remember web.config: <add type="GAM.Umbraco.HttpModules.GAMAuthorizationModule" name="GAMAuthorizationModule" /> system.webServer.modules
public void application_PreRequestHandlerExecute(object sender, EventArgs e)
{
//return;
DynamicNode currentNode = null;
var ctx = HttpContext.Current;
// ignore images, css and js requests
if (ctx.Response.ContentType != "text/html")
{
return;
}
// ignore error status codes
if (ctx.Response.StatusCode != 200)
{
return;
}
// ignore back end pages
if (ctx.Request.RawUrl.ToLower().StartsWith("/umbraco/", StringComparison.InvariantCultureIgnoreCase))
{
return;
}
if (ctx.Request.RawUrl.ToLower().Contains("/authorization/"))
{
return;
}
//if (ctx.Request.PhysicalPath.ToLower().Contains(@"\authorization\")) return;
var previewMode = "" + ctx.Request.Cookies["UMB_PREVIEW"];
if (!string.IsNullOrEmpty(previewMode))
{
return;
}
try
{
currentNode = new DynamicNode(Node.GetCurrent().Id);
if (currentNode.NiceUrl.ToLower().Contains("/authorization/"))
{
return;
}
// skip disclaimer nodes
if (string.Compare(currentNode.NodeTypeAlias, "disclaimer", true) == 0)
{
return;
}
if (!currentNode.IsCompliedFor(UserFacade.CurrentComplianceGroup))
{
UserFacade.PendingDeepLink = ctx.Request.RawUrl;
// server.TransferRequest breaks session variables *sometimes*
// (not when the url is localhost, but when the full server name is used...)
//ctx.Server.TransferRequest("/en/authorization/deep-link.aspx?targetNode=" + currentNode.Id.ToString());
ctx.Response.Redirect("/en/authorization/deep-link.aspx?targetNode=" + currentNode.Id.ToString(), true);
}
}
catch
{
}
//var orgTargetUrl = ctx.Request.RawUrl;
}
/// <summary>
/// Loads the specified node uid.
/// </summary>
/// <param name="NodeUid">The node uid.</param>
/// <param name="ControlUid">The control uid.</param>
void IPropertyPage.Load(string NodeUid, string ControlUid)
{
ControlSettings settings = new ControlSettings();
DynamicNode dNode = PageDocument.Current.DynamicNodes.LoadByUID(NodeUid);
if (dNode != null)
{
settings = dNode.GetSettings(NodeUid);
}
// Bind templates
DisplayTemplate.Items.Clear();
DisplayTemplate.Items.Add(new ListItem("(use default)", ""));
TemplateDto templates = DictionaryManager.GetTemplateDto();
if (templates.main_Templates.Count > 0)
{
DataView view = templates.main_Templates.DefaultView;
view.RowFilter = "TemplateType = 'entry'";
foreach (DataRowView row in view)
{
DisplayTemplate.Items.Add(new ListItem(row["FriendlyName"].ToString(), row["Name"].ToString()));
}
DisplayTemplate.DataBind();
}
// Bind catalogs
CatalogList.Items.Clear();
CatalogList.Items.Add(new ListItem("(use default)", ""));
CatalogDto catalogs = CatalogContext.Current.GetCatalogDto(CMSContext.Current.SiteId);
if (catalogs.Catalog.Count > 0)
{
foreach (CatalogDto.CatalogRow row in catalogs.Catalog)
{
if (row.IsActive && row.StartDate <= FrameworkContext.Current.CurrentDateTime && row.EndDate >= FrameworkContext.Current.CurrentDateTime)
{
CatalogList.Items.Add(new ListItem(row.Name, row.Name));
}
}
CatalogList.DataBind();
}
if (settings != null && settings.Params != null)
{
Param prm = settings.Params;
if ((prm["NodeCode"] != null) && (prm["NodeCode"] is string))
{
NodeCode.Text = prm["NodeCode"].ToString();
}
if ((prm["EntryCode"] != null) && (prm["EntryCode"] is string))
{
EntryCode.Text = prm["EntryCode"].ToString();
}
if ((prm["DisplayTemplate"] != null) && (prm["DisplayTemplate"] is string))
{
CommonHelper.SelectListItem(DisplayTemplate, prm["DisplayTemplate"].ToString());
}
if ((prm["CatalogName"] != null) && (prm["CatalogName"] is string))
{
CommonHelper.SelectListItem(CatalogList, prm["CatalogName"].ToString());
}
}
}
/// <summary>
/// Interrogates the binary.
/// </summary>
/// <param name="binaryPath">The binary path.</param>
/// <returns></returns>
/// <remarks></remarks>
public XElement InterrogateBinary(string binaryPath)
{
binaryPath = binaryPath.GetFullPath();
var peInfo = PEInfo.Scan(binaryPath);
dynamic node = new DynamicNode("tool");
node.FileName = peInfo.VersionInfo.FileName ?? "*";
node.Comments = peInfo.VersionInfo.Comments ?? "*";
node.CompanyName = peInfo.VersionInfo.CompanyName ?? "*";
node.FileDescription = peInfo.VersionInfo.FileDescription ?? "*";
node.FileVersion = peInfo.VersionInfo.FileVersion ?? "*";
node.InternalName = peInfo.VersionInfo.InternalName ?? "*";
node.Language = peInfo.VersionInfo.Language ?? "*";
node.LegalCopyright = peInfo.VersionInfo.LegalCopyright ?? "*";
node.LegalTrademarks = peInfo.VersionInfo.LegalTrademarks ?? "*";
node.OriginalFilename = peInfo.VersionInfo.OriginalFilename ?? "*";
node.PrivateBuild = peInfo.VersionInfo.PrivateBuild ?? "*";
node.ProductName = peInfo.VersionInfo.ProductName ?? "*";
node.ProductVersion = peInfo.VersionInfo.ProductVersion ?? "*";
node.SpecialBuild = peInfo.VersionInfo.SpecialBuild ?? "*" ;
node.Attributes.ProductPrivatePart = peInfo.VersionInfo.ProductPrivatePart ;
node.Attributes.ProductBuildPart = peInfo.VersionInfo.ProductBuildPart ;
node.Attributes.ProductMajorPart = peInfo.VersionInfo.ProductMajorPart ;
node.Attributes.ProductMinorPart = peInfo.VersionInfo.ProductMinorPart ;
node.Attributes.FileBuildPart = peInfo.VersionInfo.FileBuildPart ;
node.Attributes.FileMajorPart = peInfo.VersionInfo.FileMajorPart ;
node.Attributes.FileMinorPart = peInfo.VersionInfo.FileMinorPart ;
node.Attributes.FilePrivatePart = peInfo.VersionInfo.FilePrivatePart ;
node.Attributes.IsDebug = peInfo.VersionInfo.IsDebug ;
node.Attributes.IsPatched = peInfo.VersionInfo.IsPatched ;
node.Attributes.IsPrivateBuild = peInfo.VersionInfo.IsPrivateBuild ;
node.Attributes.IsPreRelease = peInfo.VersionInfo.IsPreRelease ;
node.Attributes.IsSpecialBuild = peInfo.VersionInfo.IsSpecialBuild ;
node.Dependencies = "";
foreach (var d in peInfo.DependencyInformation.Where(each => !(each.Module.Contains("system32") || each.Module.Contains("syswow64") ||each.Module.Contains("winsxs") ) )) {
dynamic depnode = new DynamicNode("dependency");
depnode.Attributes.Filename = d.Filename;
depnode.Attributes.Module = d.Module;
depnode.Attributes.LinkTimeStamp = d.LinkTimeStamp;
depnode.Attributes.FileSize = d.FileSize;
depnode.Attributes.LinkChecksum = d.LinkChecksum;
depnode.Attributes.RealChecksum = d.RealChecksum;
depnode.Attributes.CPU = d.CPU;
depnode.Attributes.Subsystem = d.Subsystem;
depnode.Attributes.FileVer = d.FileVer;
depnode.Attributes.ProductVer = d.ProductVer;
depnode.Attributes.ImageVer = d.ImageVer;
depnode.Attributes.LinkerVer = d.LinkerVer;
depnode.Attributes.OSVer = d.OSVer;
depnode.Attributes.SubsystemVer = d.SubsystemVer;
((XElement)node.Dependencies.Node).Add((XElement)depnode.Node);
}
StringsUtility.Value.Exec(@"/accepteula ""{0}""",binaryPath);
var rx = new Regex(@"\S*\.dll",RegexOptions.Multiline);
var match = rx.Match(StringsUtility.Value.StandardOut);
while (match.Success) {
dynamic stringNode = new DynamicNode("string");
stringNode.Attributes.dll = match.Value;
((XElement)node.Hints.Node).Add((XElement)stringNode.Node);
match = match.NextMatch();
}
return node.Node;
}
/// <summary>
/// Parsers a set member operation.
/// </summary>
protected virtual string OnParseSetMember(DynamicNode.SetMember obj, IParameterCollection pc, bool nulls)
{
string host = obj.Host == null ? null : Parse(obj.Host, pc, nulls);
string name = host == null ? obj.Name : "{0}.{1}".FormatWith(host, obj.Name);
string value = Parse(obj.Value, pc, nulls);
return "{0} = ({1})".FormatWith(name, value);
}
protected virtual string ParseGetMember( DynamicNode.GetMember node, KParameterList pars = null )
{
string parent = Parse( node.Host, pars );
string name = parent == null ? node.Name : string.Format( "{0}.{1}", parent, node.Name );
return name;
}
/// <summary>
/// Parsers a set indexed operation.
/// </summary>
protected virtual string OnParseSetIndexedMember(DynamicNode.SetIndexed obj, IParameterCollection pc, bool nulls)
{
if (obj.Indexes == null || obj.Indexes.Length == 0) return string.Empty;
StringBuilder sb = new StringBuilder(); foreach (var index in obj.Indexes)
{
if (index is string) sb.Append((string)index);
else sb.Append(Parse(index, pc, nulls));
}
string host = obj.Host == null ? null : Parse(obj.Host, pc);
string name = host == null ? sb.ToString() : "{0}{1}".FormatWith(host, sb.ToString());
string value = Parse(obj.Value, pc, nulls);
return "{0} = ({1})".FormatWith(name, value);
}
protected virtual string ParseUnary( DynamicNode.Unary node, KParameterList pars = null )
{
switch( node.Operation ) {
// Artifacts from the DynamicParser class that are not usefull here...
case ExpressionType.IsFalse:
case ExpressionType.IsTrue: return Parse( node.Target, pars );
// Unary supported operations...
case ExpressionType.Not: return string.Format( "( NOT {0} )", Parse( node.Target, pars ) );
case ExpressionType.Negate: return string.Format( "!( {0} )", Parse( node.Target, pars ) );
}
throw new ArgumentException( "Not supported unary operation: " + node );
}
/// <summary>
/// Parsers a binary operation.
/// </summary>
protected virtual string OnParseBinary(DynamicNode.Binary obj, IParameterCollection pc, bool nulls)
{
string oper = ""; switch (obj.Operation)
{
case ExpressionType.Add: oper = "+"; break;
case ExpressionType.Subtract: oper = "-"; break;
case ExpressionType.Multiply: oper = "*"; break;
case ExpressionType.Divide: oper = "/"; break;
case ExpressionType.Modulo: oper = "%"; break;
case ExpressionType.Power: oper = "^"; break;
case ExpressionType.And: oper = "AND"; break;
case ExpressionType.Or: oper = "OR"; break;
case ExpressionType.GreaterThan: oper = ">"; break;
case ExpressionType.GreaterThanOrEqual: oper = ">="; break;
case ExpressionType.LessThan: oper = "<"; break;
case ExpressionType.LessThanOrEqual: oper = "<="; break;
case ExpressionType.Equal: oper = (obj.Right == null) ? "IS" : "="; break;
case ExpressionType.NotEqual: oper = (obj.Right == null) ? "IS NOT" : "!="; break;
default:
throw new ArgumentException("Not supported binary operation '{0}'.".FormatWith(obj));
}
string left = this.Parse(obj.Left, pc, nulls);
string right = this.Parse(obj.Right, pc, nulls);
return "({0} {1} {2})".FormatWith(left, oper, right);
}
protected virtual string ParseMethod( DynamicNode.Method node, KParameterList pars = null )
{
string parent = Parse( node.Host, pars );
string method = node.Name.ToUpper();
string item = null;
// ROOT-LEVEL...
if( parent == null ) {
switch( method ) {
case "NOT":
if( node.Arguments == null || node.Arguments.Length != 1 ) throw new ArgumentException( "NOT operator expects one argument." );
item = Parse( node.Arguments[0], pars );
return string.Format( "( NOT {0} )", item );
}
}
// COLUMN-LEVEL...
else {
switch( method ) {
case "IN":
if( node.Arguments == null || node.Arguments.Length != 1 ) throw new ArgumentException( "IN operator expects one argument." );
item = Parse( node.Arguments[0], pars );
return string.Format( "{0} IN ( {1} )", parent, item );
case "AS":
if( node.Arguments == null || node.Arguments.Length != 1 ) throw new ArgumentException( "AS operator expects one argument." );
item = Parse( node.Arguments[0], null, rawstr: true ); // pars=null to avoid parametrize aliases
item = item.Validated( "Alias", invalidChars: TypeHelper.InvalidNameChars );
return string.Format( "{0} AS {1}", parent, item );
}
}
// DEFAULT-CASE...
method = parent == null ? node.Name : string.Format( "{0}.{1}", parent, node.Name );
StringBuilder sb = new StringBuilder();
sb.AppendFormat( "{0}(", method ); if( node.Arguments != null && node.Arguments.Length != 0 ) {
sb.Append( " " );
bool first = true; foreach( object argument in node.Arguments ) {
if( !first ) sb.Append( ", " ); else first = false;
sb.Append( Parse( argument, pars, nulls: true ) ); // We don't accept raw strings here!!!
}
sb.Append( " " );
}
sb.Append( ")" );
return sb.ToString();
}
/// <summary>
/// Parsers an unary operation.
/// </summary>
protected virtual string OnParseUnary(DynamicNode.Unary obj, IParameterCollection pc, bool nulls)
{
switch (obj.Operation)
{
// This are artifacts generated by the parser...
case ExpressionType.IsTrue:
case ExpressionType.IsFalse:
return this.Parse(obj.Target, pc, nulls);
case ExpressionType.Not:
return "(NOT {0})".FormatWith(Parse(obj.Target, pc, nulls));
case ExpressionType.Negate:
return "-{0}".FormatWith(this.Parse(obj.Target, pc, nulls));
}
throw new ArgumentException("Not supported unary operation '{0}'".FormatWith(obj));
}
protected virtual string ParseConvert( DynamicNode.Convert node, KParameterList pars = null )
{
DEBUG.WriteLine( "\n-- PENDING: KParser.ParseConvert() requires an override..." );
string r = Parse( node.SourceNode, pars );
return r;
}
/// <summary>
/// Parses a method invocation.
/// This method is used to implement the virtual extensions feature, including:
/// <para>Argument level:</para>
/// <para>- x.Not(...) => (NOT ...)</para>
/// <para>- x.Distinct(expression) => DISTINCT expression</para>
/// <para>Element level:</para>
/// <para>- x.Element.As(name) => Element AS name</para>
/// <para>- x.Element.In(arg, ...) => Element IN (arg, ...)</para>
/// <para>- x.Element.NotIn(arg, ...) => NOT Element IN (arg, ...)</para>
/// <para>- x.Element.InList(...) / .NotInList(...) => Interprets the single argument as a list</para>
/// <para>- x.Element.Between(arg1, arg2) => Element BETWEEN arg1 AND arg2</para>
/// <para>- x.Element.Like(arg) => Element LIKE arg</para>
/// <para>- x.Element.NotLike(arg) => Element NOT LIKE arg</para>
/// <para>Default case:</para>
/// <para>- The default case where the name of the method and its arguments are parsed as-is.</para>
/// </summary>
protected virtual string OnParseMethod(DynamicNode.Method obj, IParameterCollection pc, bool nulls)
{
string name = obj.Name.ToUpper();
string parent = obj.Host == null ? null : Parse(obj.Host, pc, nulls);
string item = null;
StringBuilder sb = new StringBuilder();
string str = null;
int i = 0;
IEnumerable iter = null;
// Root-level methods...
if (parent == null)
{
switch (name)
{
case "NOT":
if (obj.Arguments == null) throw new ArgumentException("NOT() argument list is null.");
if (obj.Arguments.Length != 1) throw new ArgumentException("NOT() requires just one argument.");
item = Parse(obj.Arguments[0], pc, nulls);
return "(NOT {0})".FormatWith(item);
case "DISTINCT":
if (obj.Arguments == null) throw new ArgumentException("DISTINCT() argument list is null.");
if (obj.Arguments.Length != 1) throw new ArgumentException("DISTINCT() requires just one argument.");
item = Parse(obj.Arguments[0], pc, nulls);
return "DISTINCT {0}".FormatWith(item);
}
}
// Item-level methods...
switch (name)
{
case "AS":
if (obj.Arguments == null) throw new ArgumentException("AS() argument list is null.");
if (obj.Arguments.Length != 1) throw new ArgumentException("AS() requires just one argument.");
item = Parse(obj.Arguments[0], pc, nulls);
return "{0} AS {1}".FormatWith(parent, item);
case "IN":
if (obj.Arguments == null) throw new ArgumentException("IN() argument list is null.");
if (obj.Arguments.Length == 0) throw new ArgumentException("IN() requires at least one argument.");
for (i = 0; i < obj.Arguments.Length; i++)
{
str = Parse(obj.Arguments[i], pc, nulls);
item = item == null ? str : "{0}, {1}".FormatWith(item, str);
}
return "{0} IN ({1})".FormatWith(parent, item);
case "NOTIN":
if (obj.Arguments == null) throw new ArgumentException("NOTIN() argument list is null.");
if (obj.Arguments.Length == 0) throw new ArgumentException("NOTIN() requires at least one argument.");
for (i = 0; i < obj.Arguments.Length; i++)
{
str = Parse(obj.Arguments[i], pc, nulls);
item = item == null ? str : "{0}, {1}".FormatWith(item, str);
}
return "NOT {0} IN ({1})".FormatWith(parent, item);
case "INLIST":
if (obj.Arguments == null) throw new ArgumentException("INLIST() argument list is null.");
if (obj.Arguments.Length != 1) throw new ArgumentException("INLIST() requires just one argument.");
iter = obj.Arguments[0] as IEnumerable; if (iter == null) throw new ArgumentException("Argument '{0}' is not an iterable one.".FormatWith(obj.Arguments[0].Sketch()));
foreach (var temp in iter)
{
str = Parse(temp, pc, nulls);
item = item == null ? str : "{0}, {1}".FormatWith(item, str);
}
return "{0} IN ({1})".FormatWith(parent, item);
case "NOTINLIST":
if (obj.Arguments == null) throw new ArgumentException("NOTINLIST() argument list is null.");
if (obj.Arguments.Length != 1) throw new ArgumentException("NOTINLIST() requires just one argument.");
iter = obj.Arguments[0] as IEnumerable; if (iter == null) throw new ArgumentException("Argument '{0}' is not an iterable one.".FormatWith(obj.Arguments[0].Sketch()));
foreach (var temp in iter)
{
str = Parse(temp, pc, nulls);
item = item == null ? str : "{0}, {1}".FormatWith(item, str);
}
return "NOT {0} IN ({1})".FormatWith(parent, item);
case "BETWEEN":
if (obj.Arguments == null) throw new ArgumentException("BETWEEN() argument list is null.");
if (obj.Arguments.Length != 2) throw new ArgumentException("BETWEEN() requires two arguments.");
item = Parse(obj.Arguments[0], pc, nulls);
str = Parse(obj.Arguments[1], pc, nulls);
return "{0} BETWEEN ({1}) AND ({2})".FormatWith(parent, item, str);
case "LIKE":
if (obj.Arguments == null) throw new ArgumentException("LIKE() argument list is null.");
if (obj.Arguments.Length != 1) throw new ArgumentException("LIKE() requires just one argument.");
item = Parse(obj.Arguments[0], pc, nulls);
return "{0} LIKE ({1})".FormatWith(parent, item);
case "NOTLIKE":
if (obj.Arguments == null) throw new ArgumentException("NOTLIKE() argument list is null.");
if (obj.Arguments.Length != 1) throw new ArgumentException("NOTLIKE() requires just one argument.");
item = Parse(obj.Arguments[0], pc, nulls);
return "{0} NOT LIKE ({1})".FormatWith(parent, item);
}
// Intercepting "rounded" escape syntax because the "tag" is interpreted as a method name...
DynamicNode node = obj; while (node.Host != null) node = node.Host;
if (((DynamicNode.Argument)node).Name == obj.Name)
{
node = new DynamicNode.Invoke((DynamicNode.Argument)node, obj.Arguments);
item = OnParseInvoke((DynamicNode.Invoke)node, pc, nulls);
node.Dispose();
string host = obj.Host == null ? null : Parse(obj.Host, pc, nulls);
string temp = host == null ? item : "{0}{1}".FormatWith(host, item);
return temp;
}
// Default case...
name = parent == null ? obj.Name : "{0}.{1}".FormatWith(parent, obj.Name);
sb.AppendFormat("{0}(", name); if (obj.Arguments != null)
{
for (i = 0; i < obj.Arguments.Length; i++)
{
if (i != 0) sb.Append(", ");
sb.Append(Parse(obj.Arguments[i], pc, nulls));
}
}
sb.Append(")");
return sb.ToString();
}
/// <summary>
/// Parsers an invocation operation.
/// </summary>
protected virtual string OnParseInvoke(DynamicNode.Invoke obj, IParameterCollection pc, bool nulls)
{
if (obj.Arguments == null || obj.Arguments.Length == 0) return string.Empty;
StringBuilder sb = new StringBuilder(); foreach (var arg in obj.Arguments)
{
if (arg is string) sb.Append((string)arg);
else sb.Append(Parse(arg, pc, nulls));
}
string host = obj.Host == null ? null : Parse(obj.Host, pc, nulls);
string name = host == null ? sb.ToString() : "{0}{1}".FormatWith(host, sb.ToString());
return name;
}
/// <summary>
/// Parsers a conversion operation.
/// </summary>
protected virtual string OnParseConvert(DynamicNode.Convert obj, IParameterCollection pc, bool nulls)
{
return Parse(obj.Target, pc, nulls);
}
private dynamic InitXaml() {
dynamic node = new DynamicNode("ProjectSchemaDefinitions", "clr-namespace:Microsoft.Build.Framework.XamlTypes;assembly=Microsoft.Build.Framework");
var rule = node.Add("Rule");
rule.Attributes.Name = "ReferencedPackages{0}".format(Guid.NewGuid());
rule.Attributes.PageTemplate = "tool";
rule.Attributes.DisplayName = "Referenced Packages";
rule.Attributes.SwitchPrefix = "/";
rule.Attributes.Order = "1";
var categories = rule.Add("Rule.Categories");
var category = categories.Add("Category");
category.Attributes.Name = _pkgName;
category.Attributes.DisplayName = _pkgName;
var datasources = rule.Add("Rule.DataSource");
var datasource = datasources.Add("DataSource");
datasource.Attributes.Persistence = "ProjectFile";
datasource.Attributes.ItemType = "";
return node;
}
public virtual TAssociative VisitDynamicNode(DynamicNode node)
{
return(VisitAssociativeNode(node));
}
