public TagHelperExecutionContext Rent( string tagName, TagMode tagMode, IDictionary <object, object> items, string uniqueId, Func <Task> executeChildContentAsync) { TagHelperExecutionContext tagHelperExecutionContext; if (_nextIndex == _executionContexts.Count) { tagHelperExecutionContext = new TagHelperExecutionContext( tagName, tagMode, items, uniqueId, executeChildContentAsync, _startTagHelperWritingScope, _endTagHelperWritingScope); _executionContexts.Add(tagHelperExecutionContext); } else { tagHelperExecutionContext = _executionContexts[_nextIndex]; tagHelperExecutionContext.Reinitialize(tagName, tagMode, items, uniqueId, executeChildContentAsync); } _nextIndex++; return(tagHelperExecutionContext); }
/// <summary> /// Starts a <see cref="TagHelperExecutionContext"/> scope. /// </summary> /// <param name="tagName">The HTML tag name that the scope is associated with.</param> /// <param name="tagMode">HTML syntax of the element in the Razor source.</param> /// <param name="uniqueId">An identifier unique to the HTML element this scope is for.</param> /// <param name="executeChildContentAsync">A delegate used to execute the child content asynchronously.</param> /// <param name="startTagHelperWritingScope">A delegate used to start a writing scope in a Razor page.</param> /// <param name="endTagHelperWritingScope">A delegate used to end a writing scope in a Razor page.</param> /// <returns>A <see cref="TagHelperExecutionContext"/> to use.</returns> public TagHelperExecutionContext Begin( [NotNull] string tagName, TagMode tagMode, [NotNull] string uniqueId, [NotNull] Func<Task> executeChildContentAsync, [NotNull] Action startTagHelperWritingScope, [NotNull] Func<TagHelperContent> endTagHelperWritingScope) { IDictionary<object, object> items; // If we're not wrapped by another TagHelper, then there will not be a parentExecutionContext. if (_executionScopes.Count > 0) { items = new CopyOnWriteDictionary<object, object>( _executionScopes.Peek().Items, comparer: EqualityComparer<object>.Default); } else { items = new Dictionary<object, object>(); } var executionContext = new TagHelperExecutionContext( tagName, tagMode, items, uniqueId, executeChildContentAsync, startTagHelperWritingScope, endTagHelperWritingScope); _executionScopes.Push(executionContext); return executionContext; }
/// <summary> /// Starts a <see cref="TagHelperExecutionContext"/> scope. /// </summary> /// <param name="tagName">The HTML tag name that the scope is associated with.</param> /// <param name="tagMode">HTML syntax of the element in the Razor source.</param> /// <param name="uniqueId">An identifier unique to the HTML element this scope is for.</param> /// <param name="executeChildContentAsync">A delegate used to execute the child content asynchronously.</param> /// <param name="startTagHelperWritingScope">A delegate used to start a writing scope in a Razor page.</param> /// <param name="endTagHelperWritingScope">A delegate used to end a writing scope in a Razor page.</param> /// <returns>A <see cref="TagHelperExecutionContext"/> to use.</returns> public TagHelperExecutionContext Begin( string tagName, TagMode tagMode, string uniqueId, Func<Task> executeChildContentAsync, Action startTagHelperWritingScope, Func<TagHelperContent> endTagHelperWritingScope) { if (tagName == null) { throw new ArgumentNullException(nameof(tagName)); } if (uniqueId == null) { throw new ArgumentNullException(nameof(uniqueId)); } if (executeChildContentAsync == null) { throw new ArgumentNullException(nameof(executeChildContentAsync)); } if (startTagHelperWritingScope == null) { throw new ArgumentNullException(nameof(startTagHelperWritingScope)); } if (endTagHelperWritingScope == null) { throw new ArgumentNullException(nameof(endTagHelperWritingScope)); } IDictionary<object, object> items; // If we're not wrapped by another TagHelper, then there will not be a parentExecutionContext. if (_executionScopes.Count > 0) { items = new CopyOnWriteDictionary<object, object>( _executionScopes.Peek().Items, comparer: EqualityComparer<object>.Default); } else { items = new Dictionary<object, object>(); } var executionContext = new TagHelperExecutionContext( tagName, tagMode, items, uniqueId, executeChildContentAsync, startTagHelperWritingScope, endTagHelperWritingScope); _executionScopes.Push(executionContext); return executionContext; }
//参考 https://stackoverflow.com/questions/25457886/c-sharp-revit-api-createindependenttag-method-failing-to-add-tag-to-ceilings-e public IndependentTag CreateOneFloorIndependentTag(Document document, Floor floor, string labelName) { Autodesk.Revit.DB.View view = document.ActiveView; TagMode tagMode = TagMode.TM_ADDBY_CATEGORY; TagOrientation tagOri = TagOrientation.Horizontal; //Revit elements can be located by a point(most family instance),a line(walls, line based components) //or sketch(celling, floors etc); //Simply answer is to find the boundling of box of the floor and calculate the center of the //if the floor is a large L shape or something the boundling box center may not be over the floor at all //need some other algorithm to find the center point; //calculate the center of mark XYZ centerPoint = CalculateCenterOfMark(floor, view); IndependentTag newTag = document.Create.NewTag(view, floor, false, tagMode, tagOri, centerPoint); if (null == newTag) { throw new Exception("Create IndependentTag Failed!"); } //NewTag.tagText is read-only, so use the othter parameters to set the tag text; SetTagText(floor, labelName); return(newTag); }
/// <summary> /// Instantiates a new <see cref="TagHelperExecutionContext"/>. /// </summary> /// <param name="tagName">The HTML tag name in the Razor source.</param> /// <param name="tagMode">HTML syntax of the element in the Razor source.</param> /// <param name="items">The collection of items used to communicate with other /// <see cref="ITagHelper"/>s</param> /// <param name="uniqueId">An identifier unique to the HTML element this context is for.</param> /// <param name="executeChildContentAsync">A delegate used to execute the child content asynchronously.</param> /// <param name="startTagHelperWritingScope"> /// A delegate used to start a writing scope in a Razor page and optionally override the page's /// <see cref="HtmlEncoder"/> within that scope. /// </param> /// <param name="endTagHelperWritingScope">A delegate used to end a writing scope in a Razor page.</param> public TagHelperExecutionContext( string tagName, TagMode tagMode, IDictionary<object, object> items, string uniqueId, Func<Task> executeChildContentAsync, Action<HtmlEncoder> startTagHelperWritingScope, Func<TagHelperContent> endTagHelperWritingScope) { if (startTagHelperWritingScope == null) { throw new ArgumentNullException(nameof(startTagHelperWritingScope)); } if (endTagHelperWritingScope == null) { throw new ArgumentNullException(nameof(endTagHelperWritingScope)); } _tagHelpers = new List<ITagHelper>(); _allAttributes = new TagHelperAttributeList(); Context = new TagHelperContext(_allAttributes, items, uniqueId); Output = new TagHelperOutput(tagName, new TagHelperAttributeList(), GetChildContentAsync) { TagMode = tagMode }; Reinitialize(tagName, tagMode, items, uniqueId, executeChildContentAsync); _startTagHelperWritingScope = startTagHelperWritingScope; _endTagHelperWritingScope = endTagHelperWritingScope; }
public PhotoSearchOptions(string userId, string tags, TagMode tagMode, string text) { this.UserId = userId; this.Tags = tags; this.TagMode = tagMode; this.Text = text; }
/// <summary> /// Create an instance of the <see cref="PhotoSearchOptions"/> for a given user ID and tag list, /// with the selected tag mode, and containing the selected text. /// </summary> /// <param name="userId">The ID of the User to search for.</param> /// <param name="tags">The tags (comma delimited) to search for.</param> /// <param name="tagMode">The <see cref="TagMode"/> to use to search.</param> /// <param name="text">The text to search for in photo title and descriptions.</param> public PhotoSearchOptions(string userId, string tags, TagMode tagMode, string text) { UserId = userId; Tags = tags; TagMode = tagMode; Text = text; }
//ToDo: genericize this, so that it allows common settings for all tags, then unique settings as needed per tag public static List <IndependentTag> CreateTags(View view, FamilySymbol tagSymbol) { if (tagSymbol == null || tagSymbol.Category == null) { return(null); } Document _doc = view.Document; List <FamilyInstance> _reshores = new FilteredElementCollector(_doc).OfClass(typeof(FamilyInstance)).OfType <FamilyInstance>().ToList(); TagMode _tagMode = tagSymbol.Category.Id.IntegerValue == (int)BuiltInCategory.OST_MultiCategoryTags ? TagMode.TM_ADDBY_MULTICATEGORY : TagMode.TM_ADDBY_CATEGORY; List <IndependentTag> _tags = new List <IndependentTag>(); foreach (FamilyInstance _reshore in _reshores) { BoundingBoxXYZ _boundingBoxXYZ = _reshore.get_BoundingBox(null); XYZ _tagHeadCoordinate = (_boundingBoxXYZ.Min + _boundingBoxXYZ.Max) / 2.0; Reference _reference = new Reference(_reshore); IndependentTag _tag = IndependentTag.Create(_doc, view.Id, _reference, true, _tagMode, TagOrientation.Horizontal, _tagHeadCoordinate); _tags.Add(_tag); } return(_tags); }
public MarkupTagHelperBlock( string tagName, TagMode tagMode, IList <TagHelperAttributeNode> attributes) : this(tagName, tagMode, attributes, new SyntaxTreeNode[0]) { }
/// <summary> /// Starts a <see cref="TagHelperExecutionContext"/> scope. /// </summary> /// <param name="tagName">The HTML tag name that the scope is associated with.</param> /// <param name="tagMode">HTML syntax of the element in the Razor source.</param> /// <param name="uniqueId">An identifier unique to the HTML element this scope is for.</param> /// <param name="executeChildContentAsync">A delegate used to execute the child content asynchronously.</param> /// <param name="startTagHelperWritingScope">A delegate used to start a writing scope in a Razor page.</param> /// <param name="endTagHelperWritingScope">A delegate used to end a writing scope in a Razor page.</param> /// <returns>A <see cref="TagHelperExecutionContext"/> to use.</returns> public TagHelperExecutionContext Begin( string tagName, TagMode tagMode, string uniqueId, Func <Task> executeChildContentAsync, Action startTagHelperWritingScope, Func <TagHelperContent> endTagHelperWritingScope) { if (tagName == null) { throw new ArgumentNullException(nameof(tagName)); } if (uniqueId == null) { throw new ArgumentNullException(nameof(uniqueId)); } if (executeChildContentAsync == null) { throw new ArgumentNullException(nameof(executeChildContentAsync)); } if (startTagHelperWritingScope == null) { throw new ArgumentNullException(nameof(startTagHelperWritingScope)); } if (endTagHelperWritingScope == null) { throw new ArgumentNullException(nameof(endTagHelperWritingScope)); } IDictionary <object, object> items; // If we're not wrapped by another TagHelper, then there will not be a parentExecutionContext. if (_executionScopes.Count > 0) { items = new CopyOnWriteDictionary <object, object>( _executionScopes.Peek().Items, comparer: EqualityComparer <object> .Default); } else { items = new Dictionary <object, object>(); } var executionContext = new TagHelperExecutionContext( tagName, tagMode, items, uniqueId, executeChildContentAsync, startTagHelperWritingScope, endTagHelperWritingScope); _executionScopes.Push(executionContext); return(executionContext); }
public MarkupTagHelperBlock( string tagName, TagMode tagMode, IList <KeyValuePair <string, SyntaxTreeNode> > attributes) : this(tagName, tagMode, attributes, new SyntaxTreeNode[0]) { }
/// <summary> /// Create an instance of the <see cref="PhotoSearchOptions"/> for a given user ID and tag list, /// with the selected tag mode, and containing the selected text. /// </summary> /// <param name="userId">The ID of the User to search for.</param> /// <param name="tags">The tags (comma delimited) to search for.</param> /// <param name="tagMode">The <see cref="TagMode"/> to use to search.</param> /// <param name="text">The text to search for in photo title and descriptions.</param> public PhotoSearchOptions(string userId, string tags, TagMode tagMode, string text) { this.UserId = userId; this.Tags = tags; this.TagMode = tagMode; this.Text = text; }
/// <summary> /// Tag the beam's start and end. /// </summary> /// <param name="tagMode">Mode of tag</param> /// <param name="tagSymbol">Tag symbol wrapper</param> /// <param name="leader">Whether the tag has leader</param> /// <param name="tagOrientation">Orientation of tag</param> public void CreateTag(TagMode tagMode, FamilySymbolWrapper tagSymbol, bool leader, TagOrientation tagOrientation) { foreach (FamilyInstance beam in m_beamList) { //Get the start point and end point of the selected beam. Autodesk.Revit.DB.LocationCurve location = beam.Location as Autodesk.Revit.DB.LocationCurve; Autodesk.Revit.DB.Curve curve = location.Curve; Transaction t = new Transaction(m_revitDoc.Document); t.Start("Create new tag"); //Create tag on the beam's start and end. Reference beamRef = new Reference(beam); IndependentTag tag1 = IndependentTag.Create(m_revitDoc.Document, m_view.Id, beamRef, leader, tagMode, tagOrientation, curve.GetEndPoint(0)); IndependentTag tag2 = IndependentTag.Create(m_revitDoc.Document, m_view.Id, beamRef, leader, tagMode, tagOrientation, curve.GetEndPoint(1)); //Change the tag's object Type. tag1.ChangeTypeId(tagSymbol.FamilySymbol.Id); tag2.ChangeTypeId(tagSymbol.FamilySymbol.Id); t.Commit(); } }
private void CreateNewTagForPointLoad(View activeV, XYZ loadPosition, PointLoad pl) { Transaction t = new Transaction(_doc); t.Start("Create tag for point load"); TagMode tagMode = TagMode.TM_ADDBY_CATEGORY; TagOrientation tagorn = TagOrientation.Horizontal; IndependentTag tag = IndependentTag.Create(_doc, activeV.Id, new Reference(pl), false, tagMode, tagorn, loadPosition); FamilySymbol tagType = (from fs in new FilteredElementCollector(_doc) .OfCategory(BuiltInCategory.OST_PointLoadTags) .OfClass(typeof(FamilySymbol)) .Cast <FamilySymbol>() where fs.Name.Equals(Default.TYPE_NAME_POINT_LOAD) select fs) .FirstOrDefault(); if (tagType != null) { tag.ChangeTypeId(tagType.Id); } t.Commit(); AssociateTagToPointLoad(pl, tag); }
public static async Task <TagHelperOutput> ProcessAndGetOutputAsync( this TagHelper tagHelper, TagHelperAttributeList attributeList, TagHelperContext context, string tagName = "div", TagMode tagMode = TagMode.SelfClosing) { var innerOutput = new TagHelperOutput( tagName, attributeList, (useCachedResult, encoder) => Task.Run <TagHelperContent>(() => new DefaultTagHelperContent())) { TagMode = tagMode }; var innerContext = new TagHelperContext( attributeList, context.Items, Guid.NewGuid().ToString() ); tagHelper.Init(context); await tagHelper.ProcessAsync(innerContext, innerOutput); return(innerOutput); }
/// <summary> /// Starts a <see cref="TagHelperExecutionContext"/> scope. /// </summary> /// <param name="tagName">The HTML tag name that the scope is associated with.</param> /// <param name="tagMode">HTML syntax of the element in the Razor source.</param> /// <param name="uniqueId">An identifier unique to the HTML element this scope is for.</param> /// <param name="executeChildContentAsync">A delegate used to execute the child content asynchronously.</param> /// <param name="startTagHelperWritingScope">A delegate used to start a writing scope in a Razor page.</param> /// <param name="endTagHelperWritingScope">A delegate used to end a writing scope in a Razor page.</param> /// <returns>A <see cref="TagHelperExecutionContext"/> to use.</returns> public TagHelperExecutionContext Begin( [NotNull] string tagName, TagMode tagMode, [NotNull] string uniqueId, [NotNull] Func <Task> executeChildContentAsync, [NotNull] Action startTagHelperWritingScope, [NotNull] Func <TagHelperContent> endTagHelperWritingScope) { IDictionary <object, object> items; // If we're not wrapped by another TagHelper, then there will not be a parentExecutionContext. if (_executionScopes.Count > 0) { items = new CopyOnWriteDictionary <object, object>( _executionScopes.Peek().Items, comparer: EqualityComparer <object> .Default); } else { items = new Dictionary <object, object>(); } var executionContext = new TagHelperExecutionContext( tagName, tagMode, items, uniqueId, executeChildContentAsync, startTagHelperWritingScope, endTagHelperWritingScope); _executionScopes.Push(executionContext); return(executionContext); }
public TagControl() { _isNeedData = false; _enableScript = false; _useInnerTag = false; _mode = TagMode.Get; }
/// <summary> /// https://thebuildingcoder.typepad.com/blog/2010/06/set-tag-type.html /// </summary> /// <param name="document"></param> /// <param name="column"></param> /// <param name="viewId"></param> /// <returns></returns> private IndependentTag CreateIndependentTagColumn(Document document, FamilyInstance column, ElementId viewId, double Xoffset) { View view = document.GetElement(viewId) as View; // define tag mode and tag orientation for new tag TagMode tagMode = TagMode.TM_ADDBY_CATEGORY; TagOrientation tagorientation = TagOrientation.Horizontal; // Add the tag to the middle of the colunm Reference columnRef = new Reference(column); BoundingBoxXYZ bbox = column.get_BoundingBox(view); XYZ centroid = new XYZ((bbox.Max.X + bbox.Min.X) / 2, (bbox.Max.Y + bbox.Min.Y) / 2, (bbox.Max.Z + bbox.Min.Z) / 2); XYZ position = centroid + new XYZ(Xoffset, 0, 0); IndependentTag newTag = document.Create.NewTag(view, column, false, tagMode, tagorientation, position); if (null == newTag) { throw new Exception("Create IndependentTag Failed."); } return(newTag); }
/// <summary> /// Instantiates a new <see cref="TagHelperExecutionContext"/>. /// </summary> /// <param name="tagName">The HTML tag name in the Razor source.</param> /// <param name="tagMode">HTML syntax of the element in the Razor source.</param> /// <param name="items">The collection of items used to communicate with other /// <see cref="ITagHelper"/>s</param> /// <param name="uniqueId">An identifier unique to the HTML element this context is for.</param> /// <param name="executeChildContentAsync">A delegate used to execute the child content asynchronously.</param> /// <param name="startTagHelperWritingScope"> /// A delegate used to start a writing scope in a Razor page and optionally override the page's /// <see cref="HtmlEncoder"/> within that scope. /// </param> /// <param name="endTagHelperWritingScope">A delegate used to end a writing scope in a Razor page.</param> public TagHelperExecutionContext( string tagName, TagMode tagMode, IDictionary <object, object> items, string uniqueId, Func <Task> executeChildContentAsync, Action <HtmlEncoder> startTagHelperWritingScope, Func <TagHelperContent> endTagHelperWritingScope) { if (startTagHelperWritingScope == null) { throw new ArgumentNullException(nameof(startTagHelperWritingScope)); } if (endTagHelperWritingScope == null) { throw new ArgumentNullException(nameof(endTagHelperWritingScope)); } _tagHelpers = new List <ITagHelper>(); _allAttributes = new TagHelperAttributeList(); Context = new TagHelperContext(_allAttributes, items, uniqueId); Output = new TagHelperOutput(tagName, new TagHelperAttributeList(), GetChildContentAsync) { TagMode = tagMode }; Reinitialize(tagName, tagMode, items, uniqueId, executeChildContentAsync); _startTagHelperWritingScope = startTagHelperWritingScope; _endTagHelperWritingScope = endTagHelperWritingScope; }
protected BaseTagHelper(IHtmlGenerator generator, string tagName, TagMode tagMode) { Generator = generator; Id = new Random().Next(1000, 9999).ToString(); TagName = tagName; TagMode = tagMode; }
public void TagMode_ReturnsExpectedValue(TagMode tagMode) { // Arrange & Act var executionContext = new TagHelperExecutionContext("p", tagMode); // Assert Assert.Equal(tagMode, executionContext.TagMode); }
public override void FormatNode(IntermediateNodeFormatter formatter) { formatter.WriteContent(TagName); formatter.WriteProperty(nameof(TagHelpers), string.Join(", ", TagHelpers.Select(t => t.DisplayName))); formatter.WriteProperty(nameof(TagMode), TagMode.ToString()); formatter.WriteProperty(nameof(TagName), TagName); }
public MarkupTagHelperBlock( string tagName, TagMode tagMode, IList <TagHelperAttributeNode> attributes, params SyntaxTreeNode[] children) : base(new TagHelperBlockBuilder(tagName, tagMode, attributes, children)) { }
public void Reinitialize( string tagName, TagMode tagMode, IDictionary <object, object> items, string uniqueId, Func <Task> executeChildContentAsync) { }
public TagHelperExecutionContext Begin( string tagName, TagMode tagMode, string uniqueId, Func <Task> executeChildContentAsync) { throw null; }
/// <summary> /// Return a list of the top 100 unique places clustered by a given placetype for set of tags or machine tags. /// </summary> /// <param name="placeType">The ID for a specific place type to cluster photos by. </param> /// <param name="woeId">A Where on Earth identifier to use to filter photo clusters. </param> /// <param name="placeId">A Flickr Places identifier to use to filter photo clusters. </param> /// <param name="threshold">The minimum number of photos that a place type must have to be included. /// If the number of photos is lowered then the parent place type for that place will be used.</param> /// <param name="tags">A list of tags. Photos with one or more of the tags listed will be returned.</param> /// <param name="tagMode">Either 'any' for an OR combination of tags, or 'all' for an AND combination. /// Defaults to 'any' if not specified.</param> /// <param name="machineTags"></param> /// <param name="machineTagMode"></param> /// <param name="minUploadDate">Minimum upload date.</param> /// <param name="maxUploadDate">Maximum upload date.</param> /// <param name="minTakenDate">Minimum taken date.</param> /// <param name="maxTakenDate">Maximum taken date.</param> /// <param name="callback">Callback method to call upon return of the response from Flickr.</param> public void PlacesPlacesForTagsAsync(PlaceType placeType, string woeId, string placeId, int threshold, string[] tags, TagMode tagMode, string[] machineTags, MachineTagMode machineTagMode, DateTime minUploadDate, DateTime maxUploadDate, DateTime minTakenDate, DateTime maxTakenDate, Action <FlickrResult <PlaceCollection> > callback) { Dictionary <string, string> parameters = new Dictionary <string, string>(); parameters.Add("method", "flickr.places.placesForTags"); parameters.Add("place_type_id", placeType.ToString("D")); if (!String.IsNullOrEmpty(woeId)) { parameters.Add("woe_id", woeId); } if (!String.IsNullOrEmpty(placeId)) { parameters.Add("place_id", placeId); } if (threshold > 0) { parameters.Add("threshold", threshold.ToString(System.Globalization.NumberFormatInfo.InvariantInfo)); } if (tags != null && tags.Length > 0) { parameters.Add("tags", String.Join(",", tags)); } if (tagMode != TagMode.None) { parameters.Add("tag_mode", UtilityMethods.TagModeToString(tagMode)); } if (machineTags != null && machineTags.Length > 0) { parameters.Add("machine_tags", String.Join(",", machineTags)); } if (machineTagMode != MachineTagMode.None) { parameters.Add("machine_tag_mode", UtilityMethods.MachineTagModeToString(machineTagMode)); } if (minTakenDate != DateTime.MinValue) { parameters.Add("min_taken_date", UtilityMethods.DateToMySql(minTakenDate)); } if (maxTakenDate != DateTime.MinValue) { parameters.Add("max_taken_date", UtilityMethods.DateToMySql(maxTakenDate)); } if (minUploadDate != DateTime.MinValue) { parameters.Add("min_upload_date", UtilityMethods.DateToUnixTimestamp(minUploadDate)); } if (maxUploadDate != DateTime.MinValue) { parameters.Add("max_upload_date", UtilityMethods.DateToUnixTimestamp(maxUploadDate)); } GetResponseAsync <PlaceCollection>(parameters, callback); }
public TagHelperInfo( string tagName, TagMode tagMode, TagHelperBinding bindingResult) { TagName = tagName; TagMode = tagMode; BindingResult = bindingResult; }
/// <summary> /// Internal for testing purposes only. /// </summary> internal TagHelperExecutionContext(string tagName, TagMode tagMode) : this(tagName, tagMode, items: new Dictionary<object, object>(), uniqueId: string.Empty, executeChildContentAsync: async () => await Task.FromResult(result: true), startTagHelperWritingScope: () => { }, endTagHelperWritingScope: () => new DefaultTagHelperContent()) { }
/// <summary> /// Internal for testing purposes only. /// </summary> internal TagHelperExecutionContext(string tagName, TagMode tagMode) : this(tagName, tagMode, items : new Dictionary <object, object>(), uniqueId : string.Empty, executeChildContentAsync : () => TaskCache.CompletedTask, startTagHelperWritingScope : _ => { }, endTagHelperWritingScope : () => new DefaultTagHelperContent()) { }
public TagHelperExecutionContext( string tagName, TagMode tagMode, IDictionary <object, object> items, string uniqueId, Func <Task> executeChildContentAsync, Action <HtmlEncoder> startTagHelperWritingScope, Func <TagHelperContent> endTagHelperWritingScope) { }
/// <summary> /// Internal for testing purposes only. /// </summary> internal TagHelperExecutionContext(string tagName, TagMode tagMode) : this(tagName, tagMode, items : new Dictionary <object, object>(), uniqueId : string.Empty, executeChildContentAsync : async() => await Task.FromResult(result : true), startTagHelperWritingScope : () => { }, endTagHelperWritingScope : () => new DefaultTagHelperContent()) { }
public void Begin_SetsExecutionContextTagMode(TagMode tagMode) { // Arrange var scopeManager = new TagHelperScopeManager(); // Act var executionContext = BeginDefaultScope(scopeManager, "p", tagMode); // Assert Assert.Equal(tagMode, executionContext.TagMode); }
/// <summary> /// Instantiates a new <see cref="TagHelperChunk"/>. /// </summary> /// <param name="tagName">The tag name associated with the tag helpers HTML element.</param> /// <param name="tagMode">HTML syntax of the element in the Razor source.</param> /// <param name="attributes">The attributes associated with the tag helpers HTML element.</param> /// <param name="descriptors"> /// The <see cref="TagHelperDescriptor"/>s associated with this tag helpers HTML element. /// </param> public TagHelperChunk( string tagName, TagMode tagMode, IList <KeyValuePair <string, Chunk> > attributes, IEnumerable <TagHelperDescriptor> descriptors) { TagName = tagName; TagMode = tagMode; Attributes = attributes; Descriptors = descriptors; }
private static TagHelperExecutionContext BeginDefaultScope( TagHelperScopeManager scopeManager, string tagName, TagMode tagMode = TagMode.StartTagAndEndTag) { return(scopeManager.Begin( tagName, tagMode, uniqueId: string.Empty, executeChildContentAsync: async() => await Task.FromResult(result: true))); }
public void ExecutionContext_CreateTagHelperOutput_ReturnsExpectedTagMode(TagMode tagMode) { // Arrange var executionContext = new TagHelperExecutionContext("p", tagMode); // Act var output = executionContext.Output; // Assert Assert.Equal(tagMode, output.TagMode); }
/// <summary> /// Instantiates a new <see cref="TagHelperChunk"/>. /// </summary> /// <param name="tagName">The tag name associated with the tag helpers HTML element.</param> /// <param name="tagMode">HTML syntax of the element in the Razor source.</param> /// <param name="attributes">The attributes associated with the tag helpers HTML element.</param> /// <param name="descriptors"> /// The <see cref="TagHelperDescriptor"/>s associated with this tag helpers HTML element. /// </param> public TagHelperChunk( string tagName, TagMode tagMode, IList<KeyValuePair<string, Chunk>> attributes, IEnumerable<TagHelperDescriptor> descriptors) { TagName = tagName; TagMode = tagMode; Attributes = attributes; Descriptors = descriptors; }
/// <summary> /// Instantiates a new <see cref="TagHelperExecutionContext"/>. /// </summary> /// <param name="tagName">The HTML tag name in the Razor source.</param> /// <param name="tagMode">HTML syntax of the element in the Razor source.</param> /// <param name="items">The collection of items used to communicate with other /// <see cref="ITagHelper"/>s</param> /// <param name="uniqueId">An identifier unique to the HTML element this context is for.</param> /// <param name="executeChildContentAsync">A delegate used to execute the child content asynchronously.</param> /// <param name="startTagHelperWritingScope">A delegate used to start a writing scope in a Razor page.</param> /// <param name="endTagHelperWritingScope">A delegate used to end a writing scope in a Razor page.</param> public TagHelperExecutionContext( string tagName, TagMode tagMode, IDictionary<object, object> items, string uniqueId, Func<Task> executeChildContentAsync, Action startTagHelperWritingScope, Func<TagHelperContent> endTagHelperWritingScope) { if (tagName == null) { throw new ArgumentNullException(nameof(tagName)); } if (items == null) { throw new ArgumentNullException(nameof(items)); } if (uniqueId == null) { throw new ArgumentNullException(nameof(uniqueId)); } if (executeChildContentAsync == null) { throw new ArgumentNullException(nameof(executeChildContentAsync)); } if (startTagHelperWritingScope == null) { throw new ArgumentNullException(nameof(startTagHelperWritingScope)); } if (endTagHelperWritingScope == null) { throw new ArgumentNullException(nameof(endTagHelperWritingScope)); } _tagHelpers = new List<ITagHelper>(); _executeChildContentAsync = executeChildContentAsync; _startTagHelperWritingScope = startTagHelperWritingScope; _endTagHelperWritingScope = endTagHelperWritingScope; TagMode = tagMode; HTMLAttributes = new TagHelperAttributeList(); AllAttributes = new TagHelperAttributeList(); TagName = tagName; Items = items; UniqueId = uniqueId; }
/// <summary> /// Instantiates a new instance of the <see cref="TagHelperBlockBuilder"/> class /// with the provided <paramref name="tagName"/> and derives its <see cref="Attributes"/> /// and <see cref="BlockBuilder.Type"/> from the <paramref name="startTag"/>. /// </summary> /// <param name="tagName">An HTML tag name.</param> /// <param name="tagMode">HTML syntax of the element in the Razor source.</param> /// <param name="start">Starting location of the <see cref="TagHelperBlock"/>.</param> /// <param name="attributes">Attributes of the <see cref="TagHelperBlock"/>.</param> /// <param name="descriptors">The <see cref="TagHelperDescriptor"/>s associated with the current HTML /// tag.</param> public TagHelperBlockBuilder( string tagName, TagMode tagMode, SourceLocation start, IList<KeyValuePair<string, SyntaxTreeNode>> attributes, IEnumerable<TagHelperDescriptor> descriptors) { TagName = tagName; TagMode = tagMode; Start = start; Descriptors = descriptors; Attributes = new List<KeyValuePair<string, SyntaxTreeNode>>(attributes); Type = BlockType.Tag; ChunkGenerator = new TagHelperChunkGenerator(descriptors); }
/// <summary> /// Convert a <see cref="TagMode"/> to a string used when passing to Flickr. /// </summary> /// <param name="tagMode">The tag mode to convert.</param> /// <returns>The string to pass to Flickr.</returns> public static string TagModeToString(TagMode tagMode) { switch (tagMode) { case TagMode.None: return String.Empty; case TagMode.AllTags: return "all"; case TagMode.AnyTag: return "any"; case TagMode.Boolean: return "bool"; default: return String.Empty; } }
/// <summary> /// Starts a <see cref="TagHelperExecutionContext"/> scope. /// </summary> /// <param name="tagName">The HTML tag name that the scope is associated with.</param> /// <param name="tagMode">HTML syntax of the element in the Razor source.</param> /// <param name="uniqueId">An identifier unique to the HTML element this scope is for.</param> /// <param name="executeChildContentAsync">A delegate used to execute the child content asynchronously.</param> /// <returns>A <see cref="TagHelperExecutionContext"/> to use.</returns> public TagHelperExecutionContext Begin( string tagName, TagMode tagMode, string uniqueId, Func<Task> executeChildContentAsync) { if (tagName == null) { throw new ArgumentNullException(nameof(tagName)); } if (uniqueId == null) { throw new ArgumentNullException(nameof(uniqueId)); } if (executeChildContentAsync == null) { throw new ArgumentNullException(nameof(executeChildContentAsync)); } IDictionary<object, object> items; var parentExecutionContext = _executionContextPool.Current; // If we're not wrapped by another TagHelper, then there will not be a parentExecutionContext. if (parentExecutionContext != null) { items = new CopyOnWriteDictionary<object, object>( parentExecutionContext.Items, comparer: EqualityComparer<object>.Default); } else { items = new Dictionary<object, object>(); } var executionContext = _executionContextPool.Rent( tagName, tagMode, items, uniqueId, executeChildContentAsync); return executionContext; }
// Internal for testing internal TagHelperBlockBuilder( string tagName, TagMode tagMode, IList<KeyValuePair<string, SyntaxTreeNode>> attributes, IEnumerable<SyntaxTreeNode> children) { TagName = tagName; TagMode = tagMode; Attributes = attributes; Type = BlockType.Tag; ChunkGenerator = new TagHelperChunkGenerator(tagHelperDescriptors: null); // Children is IList, no AddRange foreach (var child in children) { Children.Add(child); } }
/// <summary> /// Instantiates a new <see cref="TagHelperExecutionContext"/>. /// </summary> /// <param name="tagName">The HTML tag name in the Razor source.</param> /// <param name="tagMode">HTML syntax of the element in the Razor source.</param> /// <param name="items">The collection of items used to communicate with other /// <see cref="ITagHelper"/>s</param> /// <param name="uniqueId">An identifier unique to the HTML element this context is for.</param> /// <param name="executeChildContentAsync">A delegate used to execute the child content asynchronously.</param> /// <param name="startTagHelperWritingScope">A delegate used to start a writing scope in a Razor page.</param> /// <param name="endTagHelperWritingScope">A delegate used to end a writing scope in a Razor page.</param> public TagHelperExecutionContext( [NotNull] string tagName, TagMode tagMode, [NotNull] IDictionary<object, object> items, [NotNull] string uniqueId, [NotNull] Func<Task> executeChildContentAsync, [NotNull] Action startTagHelperWritingScope, [NotNull] Func<TagHelperContent> endTagHelperWritingScope) { _tagHelpers = new List<ITagHelper>(); _executeChildContentAsync = executeChildContentAsync; _startTagHelperWritingScope = startTagHelperWritingScope; _endTagHelperWritingScope = endTagHelperWritingScope; TagMode = tagMode; HTMLAttributes = new TagHelperAttributeList(); AllAttributes = new TagHelperAttributeList(); TagName = tagName; Items = items; UniqueId = uniqueId; }
public Block TagHelperBlock( string tagName, TagMode tagMode, SourceLocation start, Block startTag, SyntaxTreeNode[] children, Block endTag) { var builder = new TagHelperBlockBuilder( tagName, tagMode, attributes: new List<KeyValuePair<string, SyntaxTreeNode>>(), children: children) { Start = start, SourceStartTag = startTag, SourceEndTag = endTag }; return builder.Build(); }
/// <summary> /// Search for photos. /// </summary> /// <param name="tags">A comma seperated list of tags to search for.</param> /// <param name="tagMode">Match all tags, or any tag.</param> /// <param name="text">Text to search for in photo title or description.</param> /// <returns>A <see cref="Photos"/> instance.</returns> public Photos PhotosSearch(string tags, TagMode tagMode, string text) { return PhotosSearch(null, tags, tagMode, text, DateTime.MinValue, DateTime.MinValue, 0, 0, 0, PhotoSearchExtras.All); }
/// <summary> /// Search for photos. /// </summary> /// <param name="userId">The ID of the user to search the photos of.</param> /// <param name="tags">A comma seperated list of tags to search for.</param> /// <param name="tagMode">Match all tags, or any tag.</param> /// <param name="text">Text to search for in photo title or description.</param> /// <param name="extras">Optional extras to return.</param> /// <returns>A <see cref="Photos"/> instance.</returns> public Photos PhotosSearch(string userId, string tags, TagMode tagMode, string text, PhotoSearchExtras extras) { return PhotosSearch(userId, tags, tagMode, text, DateTime.MinValue, DateTime.MinValue, 0, 0, 0, extras); }
// Actual PhotoSearch function /// <summary> /// Search for photos. /// </summary> /// <param name="userId">The ID of the user to search the photos of.</param> /// <param name="tags">A comma seperated list of tags to search for.</param> /// <param name="tagMode">Match all tags, or any tag.</param> /// <param name="text">Text to search for in photo title or description.</param> /// <param name="perPage">Number of photos to return per page.</param> /// <param name="page">The page number to return.</param> /// <param name="extras">Optional extras to return.</param> /// <param name="minUploadDate">The minimum upload date.</param> /// <param name="maxUploadDate">The maxmimum upload date.</param> /// <param name="license">The license type to return.</param> /// <returns>A <see cref="Photos"/> instance.</returns> public Photos PhotosSearch(string userId, string tags, TagMode tagMode, string text, DateTime minUploadDate, DateTime maxUploadDate, int license, int perPage, int page, PhotoSearchExtras extras) { PhotoSearchOptions options = new PhotoSearchOptions(); options.UserId = userId; options.Tags = tags; options.TagMode = tagMode; options.Text = text; options.MinUploadDate = minUploadDate; options.MaxUploadDate = maxUploadDate; if( license > 0 ) options.AddLicense(license); options.PerPage = perPage; options.Page = page; options.Extras = extras; return PhotosSearch(options); }
/// <summary> /// Switch the mode of a particular Tag to a mode. /// Valid Mode are <see cref="TagMode.Seamless"/> and <see cref="TagMode.Manual"/> /// </summary> /// <param name="name">The name of the tag to switch</param> /// <param name="mode">The mode to switch to</param> /// <exception cref="ArgumentOutOfRangeException">If the TagMode Specified is not a valid TagMode</exception> /// <exception cref="UnhandledException">Unhandled Exception</exception> /// <returns>true if the mode can be switch.</returns> public bool SwitchMode(string name, TagMode mode) { try { switch (mode) { case TagMode.Seamless: MonitorTag(name, true); break; case TagMode.Manual: MonitorTag(name, false); break; default: throw new ArgumentOutOfRangeException("mode"); } return true; } catch (ArgumentOutOfRangeException) { throw; } catch (Exception e) { //Handle some unexpected exception so that it does not hang the UI. ServiceLocator.GetLogger(ServiceLocator.DEBUG_LOG).Write(e); throw new UnhandledException(e); } }
public async Task RunAsync_SetsTagHelperOutputTagMode(TagMode tagMode) { // Arrange var runner = new TagHelperRunner(); var executionContext = new TagHelperExecutionContext("p", tagMode); var tagHelper = new TagHelperContextTouchingTagHelper(); executionContext.Add(tagHelper); executionContext.AddTagHelperAttribute("foo", true); // Act var output = await runner.RunAsync(executionContext); // Assert Assert.Equal(tagMode, output.TagMode); }
private static TagHelperOutput GetTagHelperOutput( string tagName, TagHelperAttributeList attributes, TagMode tagMode, string preElement, string preContent, string content, string postContent, string postElement) { var output = new TagHelperOutput(tagName, attributes) { TagMode = tagMode }; output.PreElement.AppendEncoded(preElement); output.PreContent.AppendEncoded(preContent); output.Content.AppendEncoded(content); output.PostContent.AppendEncoded(postContent); output.PostElement.AppendEncoded(postElement); return output; }
public PhotoSearchOptions(string userId, string tags, TagMode tagMode) : this(userId, tags, tagMode, (string) null) { }
public PlaceCollection PlacesPlacesForTags(string woeId, IEnumerable<string> tags, TagMode tagMode, DateTime? minUploadDate, DateTime? maxUploadDate, DateTime? minTakenDate, DateTime? maxTakenDate) { return PlacesPlacesForTags(PlaceType.None, woeId, null, null, tags, tagMode, null, MachineTagMode.None, minUploadDate, maxUploadDate, minTakenDate, maxTakenDate); }
public TagHelperExecutionContext Rent( string tagName, TagMode tagMode, IDictionary<object, object> items, string uniqueId, Func<Task> executeChildContentAsync) { TagHelperExecutionContext tagHelperExecutionContext; if (_nextIndex == _executionContexts.Count) { tagHelperExecutionContext = new TagHelperExecutionContext( tagName, tagMode, items, uniqueId, executeChildContentAsync, _startTagHelperWritingScope, _endTagHelperWritingScope); _executionContexts.Add(tagHelperExecutionContext); } else { tagHelperExecutionContext = _executionContexts[_nextIndex]; tagHelperExecutionContext.Reinitialize(tagName, tagMode, items, uniqueId, executeChildContentAsync); } _nextIndex++; return tagHelperExecutionContext; }
public PlaceCollection PlacesPlacesForTags(string woeId, IEnumerable<string> tags, TagMode tagMode) { return PlacesPlacesForTags(PlaceType.None, woeId, null, null, tags, tagMode, null, MachineTagMode.None, null, null, null, null); }
/// <summary> /// Search for photos. /// </summary> /// <param name="userId">The ID of the user to search the photos of.</param> /// <param name="tags">A comma seperated list of tags to search for.</param> /// <param name="tagMode">Match all tags, or any tag.</param> /// <param name="text">Text to search for in photo title or description.</param> /// <param name="perPage">Number of photos to return per page.</param> /// <param name="page">The page number to return.</param> /// <returns>A <see cref="Photos"/> instance.</returns> public Photos PhotosSearch(string userId, string tags, TagMode tagMode, string text, int perPage, int page) { return PhotosSearch(userId, tags, tagMode, text, DateTime.MinValue, DateTime.MinValue, 0, perPage, page, PhotoSearchExtras.All); }
private void RenderBeginTagHelperScope(string tagName, TagMode tagMode, IList<Chunk> children) { // Scopes/execution contexts are a runtime feature. if (_designTimeMode) { // Render all of the tag helper children inline for IntelliSense. _bodyVisitor.Accept(children); return; } // Call into the tag helper scope manager to start a new tag helper scope. // Also capture the value as the current execution context. _writer .WriteStartAssignment(ExecutionContextVariableName) .WriteStartInstanceMethodInvocation( ScopeManagerVariableName, _tagHelperContext.ScopeManagerBeginMethodName); // Assign a unique ID for this instance of the source HTML tag. This must be unique // per call site, e.g. if the tag is on the view twice, there should be two IDs. _writer.WriteStringLiteral(tagName) .WriteParameterSeparator() .Write("global::") .Write(typeof(TagMode).FullName) .Write(".") .Write(tagMode.ToString()) .WriteParameterSeparator() .WriteStringLiteral(GenerateUniqueId()) .WriteParameterSeparator(); // We remove the target writer so TagHelper authors can retrieve content. var oldWriter = _context.TargetWriterName; _context.TargetWriterName = null; using (_writer.BuildAsyncLambda(endLine: false)) { // Render all of the tag helper children. _bodyVisitor.Accept(children); } _context.TargetWriterName = oldWriter; _writer.WriteEndMethodInvocation(); }
public PlaceCollection PlacesPlacesForTags(PlaceType placeTypeId, string woeId, string placeId, int? threshold, IEnumerable<string> tags, TagMode tagMode, IEnumerable<string> machineTags, MachineTagMode machineTagMode, DateTime? minUploadDate, DateTime? maxUploadDate, DateTime? minTakenDate, DateTime? maxTakenDate) { var dictionary = new Dictionary<string, string>(); dictionary.Add("method", "flickr.places.placesForTags"); if (placeTypeId != PlaceType.None) dictionary.Add("place_type_id", placeTypeId.ToString().ToLower()); if (woeId != null) dictionary.Add("woe_id", woeId); if (placeId != null) dictionary.Add("place_id", placeId); if (threshold != null) dictionary.Add("threshold", threshold.ToString().ToLower()); if (tags != null) dictionary.Add("tags", tags == null ? String.Empty : String.Join(",", tags.ToArray())); if (tagMode != TagMode.None) dictionary.Add("tag_mode", tagMode.ToString().ToLower()); if (machineTags != null) dictionary.Add("machine_tags", machineTags == null ? String.Empty : String.Join(",", machineTags.ToArray())); if (machineTagMode != MachineTagMode.None) dictionary.Add("machine_tag_mode", machineTagMode.ToString().ToLower()); if (minUploadDate != null) dictionary.Add("min_upload_date", minUploadDate.Value.ToUnixTimestamp()); if (maxUploadDate != null) dictionary.Add("max_upload_date", maxUploadDate.Value.ToUnixTimestamp()); if (minTakenDate != null) dictionary.Add("min_taken_date", minTakenDate.Value.ToUnixTimestamp()); if (maxTakenDate != null) dictionary.Add("max_taken_date", maxTakenDate.Value.ToUnixTimestamp()); return GetResponse<PlaceCollection>(dictionary); }
/// <summary> /// Search for photos. /// </summary> /// <param name="userId">The ID of the user to search the photos of.</param> /// <param name="tags">An array of tags to search for.</param> /// <param name="tagMode">Match all tags, or any tag.</param> /// <param name="text">Text to search for in photo title or description.</param> /// <param name="minUploadDate">The minimum upload date.</param> /// <param name="maxUploadDate">The maxmimum upload date.</param> /// <param name="license">The license type to return.</param> /// <param name="perPage">Number of photos to return per page.</param> /// <param name="page">The page number to return.</param> /// <returns>A <see cref="Photos"/> instance.</returns> public Photos PhotosSearch(string userId, string[] tags, TagMode tagMode, string text, DateTime minUploadDate, DateTime maxUploadDate, int license, int perPage, int page) { return PhotosSearch(userId, String.Join(",", tags), tagMode, text, minUploadDate, maxUploadDate, license, perPage, page, PhotoSearchExtras.All); }
/// <summary> /// Search for photos. /// </summary> /// <param name="tags">A comma seperated list of tags to search for.</param> /// <param name="tagMode">Match all tags, or any tag.</param> /// <param name="text">Text to search for in photo title or description.</param> /// <param name="perPage">Number of photos to return per page.</param> /// <param name="page">The page number to return.</param> /// <param name="extras">Optional extras to return.</param> /// <returns>A <see cref="Photos"/> instance.</returns> public Photos PhotosSearch(string tags, TagMode tagMode, string text, int perPage, int page, PhotoSearchExtras extras) { return PhotosSearch(null, tags, tagMode, text, DateTime.MinValue, DateTime.MinValue, 0, perPage, page, extras); }