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)); }