Beispiel #1
0
        public void ThrowExceptionWithEmptyListArgument()
        {
            // Arrange
            var sut = new TagProcessor();

            var listAnnotations = new List <UserAnnotations>();

            // Act & Assert
            Assert.Throws <ArgumentException>(() => sut.DisambiguateTags(listAnnotations));
        }
Beispiel #2
0
        public void ThrowExceptionWithNullArgument()
        {
            // Arrange
            var sut = new TagProcessor();

            List <UserAnnotations> listAnnotations = null;

            // Act & Assert
            Assert.Throws <ArgumentNullException>(() => sut.DisambiguateTags(listAnnotations));
        }
Beispiel #3
0
        public ActionResult RemoveTag(int id)
        {
            // get the list of classifications from Session
            List <TagModel> tags = getTags();

            tags.RemoveAt(tags.FindIndex(c => c.Id == id));

            TagProcessor.DeleteTag(id);

            return(RedirectToAction("Tags", "Language"));
        }
Beispiel #4
0
        public void ReturnNoTagsWhenAllUsersAgree()
        {
            // Arrange
            var sut = new TagProcessor();

            var listAnnotations = new List <UserAnnotations>
            {
                new UserAnnotations
                {
                    UserName = "******",
                    Tags     = new List <Tag>
                    {
                        new Tag
                        {
                            Category   = "Dogs",
                            StartIndex = 0,
                            EndIndex   = 10
                        },
                        new Tag
                        {
                            Category   = "Cats",
                            StartIndex = 22,
                            EndIndex   = 25
                        }
                    }
                },
                new UserAnnotations
                {
                    UserName = "******",
                    Tags     = new List <Tag>
                    {
                        new Tag
                        {
                            Category   = "Dogs",
                            StartIndex = 0,
                            EndIndex   = 10
                        },
                        new Tag
                        {
                            Category   = "Cats",
                            StartIndex = 22,
                            EndIndex   = 25
                        }
                    }
                }
            };

            // Act
            var tagsForExpertList = sut.DisambiguateTags(listAnnotations);

            //Assert
            Assert.Empty(tagsForExpertList);
        }
Beispiel #5
0
        public void IgnoreDuplicateTagValuesForUser()
        {
            // Arrange
            var sut = new TagProcessor();

            var listAnnotations = new List <UserAnnotations>
            {
                new UserAnnotations
                {
                    UserName = "******",
                    Tags     = new List <Tag>
                    {
                        new Tag
                        {
                            Category   = "Dogs",
                            StartIndex = 0,
                            EndIndex   = 10
                        }
                    }
                },
                new UserAnnotations
                {
                    UserName = "******",
                    Tags     = new List <Tag>
                    {
                        new Tag
                        {
                            Category   = "Dogs",
                            StartIndex = 0,
                            EndIndex   = 10
                        },
                        new Tag
                        {
                            Category   = "Cats",
                            StartIndex = 22,
                            EndIndex   = 25
                        },
                        new Tag
                        {
                            Category   = "Cats",
                            StartIndex = 22,
                            EndIndex   = 25
                        },
                    }
                }
            };

            // Act
            var tagsForExpertList = sut.DisambiguateTags(listAnnotations);

            //Assert
            Assert.Single(tagsForExpertList, x => x.Category == "Cats");
        }
Beispiel #6
0
        private List <TagModel> getTags()
        {
            List <TagModel> tags = new List <TagModel>();

            // the fail case for this method is if there is no selected language
            if (Session["Language"] == null)
            {
                return(tags);
            }

            // check if Session already has a tags list
            if (Session["Tags"] != null)
            {
                tags = (List <TagModel>)Session["Tags"];
                // now, if the list isn't empty return it
                if (tags.Count != 0)
                {
                    return(tags);
                }
            }

            // otherwise, Session does not have a tags list object, so we'll instead start checking the database
            // now load the tags from the database
            List <TagDataModel> dmClassifications = TagProcessor.LoadTags((int)Session["Language"]);

            foreach (TagDataModel tag in dmClassifications)
            {
                tags.Add(new TagModel
                {
                    Id          = tag.Id,
                    Name        = tag.Name,
                    Description = tag.Description
                });
            }

            // now make sure Session has tags list
            if (Session["Tags"] != null)
            {
                Session["Tags"] = tags;
            }
            else
            {
                Session.Add("Tags", tags);
            }

            return(tags);
        }
Beispiel #7
0
        public void ReturnBothTagsWhenDraw()
        {
            // Arrange
            var sut = new TagProcessor();

            var listAnnotations = new List <UserAnnotations>
            {
                new UserAnnotations
                {
                    UserName = "******",
                    Tags     = new List <Tag>
                    {
                        new Tag
                        {
                            Category   = "Dogs",
                            StartIndex = 0,
                            EndIndex   = 10
                        }
                    }
                },
                new UserAnnotations
                {
                    UserName = "******",
                    Tags     = new List <Tag>
                    {
                        new Tag
                        {
                            Category   = "Dogs",
                            StartIndex = 10,
                            EndIndex   = 20
                        }
                    }
                }
            };

            // Act
            var tagsForExpertList = sut.DisambiguateTags(listAnnotations);

            //Assert
            Assert.Equal(2, tagsForExpertList.Count);
        }
        public IBatchTagProcessor GetBatchTagProcessor(TagType tagType)
        {
            IBatchTagProcessor tagProcessor;

            switch (tagType)
            {
            case TagType.SGTIN_64:
                throw new NotImplementedException();

            case TagType.SGTIN_96:
                tagProcessor = new TagProcessor(new InMemoryTagRepository(), new SGTIN96STagHexStringValidator(), new SGTIN96TagFieldsConstructor());
                break;

            case TagType.SGTIN_198:
                throw new NotImplementedException();

            default:
                throw new NotImplementedException();
            }

            return(tagProcessor);
        }
Beispiel #9
0
        static bool ProcessTags(string tag, Range tagRange, TagProcessor tagProcessor, bool isSingle = false)
        {
            var startTag = "<" + tag + ">";
            var endTag   = "</" + tag + ">";

            var found = false;
            var range = tagRange.Duplicate;
            int startTagOffset;

            while (range.Start < range.End && (startTagOffset = range.Text.IndexOf(startTag)) != -1)
            {
                found = true;

                // Remove start tag
                range.Start += startTagOffset;
                DeleteChars(range, startTag.Length);

                if (!isSingle)
                {
                    // Remove end tag
                    var endTagOffset = range.Text.IndexOf(endTag);
                    DeleteCharsAt(range, endTagOffset, endTag.Length);
                    range.End = range.Start + endTagOffset;
                }
                else
                {
                    range.End = range.Start;
                }

                // Process at tag position
                tagProcessor(tag, range);

                range.Start = tagRange.Start;
                range.End   = tagRange.End;
            }

            return(found);
        }
Beispiel #10
0
        public ActionResult Tags(TagModel tag)
        {
            ClearAlerts("Alert Tags M", 3);

            // get the list of tags from Session
            List <TagModel> tags = getTags();

            // we'll need to validate the data
            if (tags.Exists(t => t.Name == tag.Name))
            {
                Session.Add("Alert Tags M1", "Tag name already exists. Please use a distinct name.");
                return(View());
            }

            // we need to add the tag to the database first to get the Id
            tag.Id = TagProcessor.CreateTag(tag.Name, (int)Session["Language"], tag.Description);
            tags.Add(tag);

            // lastly, we'll need to clear the values in the fields
            ModelState.SetModelValue("Name", new ValueProviderResult("", "", ModelState["Name"].Value.Culture));
            ModelState.SetModelValue("Description", new ValueProviderResult("", "", ModelState["Description"].Value.Culture));

            return(View());
        }
        protected override async Task PublishFileToDestinationAsync(FileInfo sourceFile, DirectoryInfo destinationRoot, DocFile page)
        {
            this.LogMessage(new ValidationMessage(sourceFile.Name, "Publishing file to HTML"));

            var destinationPath = this.GetPublishedFilePath(sourceFile, destinationRoot, HtmlOutputExtension);

            // Create a tag processor
            string tagsInput = PageParameters.ValueForKey<string>("tags", StringComparison.OrdinalIgnoreCase) ?? string.Empty;

            TagProcessor tagProcessor = new TagProcessor(tagsInput,
                page.Parent.SourceFolderPath, LogMessage);

            var converter = this.GetMarkdownConverter();
            var html = converter.Transform(tagProcessor.Preprocess(sourceFile));
            html = await tagProcessor.PostProcess(html, sourceFile, converter);

            var pageData = page.Annotation ?? new PageAnnotation();
            if (string.IsNullOrEmpty(pageData.Title))
            {
               pageData.Title = (from b in converter.Blocks
                             where b.BlockType == BlockType.h1
                             select b.Content).FirstOrDefault();
            }
            page.Annotation = pageData;
            await this.WriteHtmlDocumentAsync(html, page, destinationPath, destinationRoot.FullName);
        }
		static bool ProcessTags(string tag, Range tagRange, TagProcessor tagProcessor, bool isSingle = false)
		{
			var startTag = "<" + tag + ">";
			var endTag = "</" + tag + ">";

			var found = false;
			var range = tagRange.Duplicate;
			int startTagOffset;

			while(range.Start < range.End && (startTagOffset = range.Text.IndexOf(startTag)) != -1)
			{
				found = true;

				// Remove start tag
				range.Start += startTagOffset;
				DeleteChars(range, startTag.Length);

				if (!isSingle)
				{
					// Remove end tag
					var endTagOffset = range.Text.IndexOf(endTag);
					DeleteCharsAt(range, endTagOffset, endTag.Length);
					range.End = range.Start + endTagOffset;
				}
				else
				{
					range.End = range.Start;
				}

				// Process at tag position
				tagProcessor(tag, range);

				range.Start = tagRange.Start;
				range.End = tagRange.End;
			}

			return found;
		}
Beispiel #13
0
 protected virtual string GetContentsOfFile(string tags)
 {
     // Preprocess file content
     FileInfo docFile = new FileInfo(this.FullPath);
     TagProcessor tagProcessor = new TagProcessor(tags, Parent.SourceFolderPath);
     return tagProcessor.Preprocess(docFile);
 }
Beispiel #14
0
        /// <summary>
        /// Process the node for k-tags and k-expressions and return the processed node.
        /// </summary>
        /// <param name="readNode"></param>
        /// <param name="classNameAlias"></param>
        /// <param name="classNameAliasDepth"></param>
        /// <param name="depth"></param>
        /// <param name="isRepeat"></param>
        /// <param name="evaluator"></param>
        /// <returns></returns>
        private HtmlNode GetProcessedNode(HtmlNode readNode, Dictionary <string, AliasReference> classNameAlias, Dictionary <int, string> classNameAliasDepth, int depth, bool isRepeat, ExpressionEvaluator evaluator, string customerId, KEntity entity, dynamic websiteData, Models.Pagination viewDetails, string queryString, Dictionary <string, long> functionLog, bool isDetailsView, bool isNFSite)
        {
            try
            {
                HtmlNode returnNode = readNode.CloneNode(false);
                if (readNode.NodeType == HtmlNodeType.Comment)
                {
                    return(returnNode);
                }
                else if (readNode.NodeType == HtmlNodeType.Text)
                {
                    returnNode = HtmlTextNode.CreateNode(ReplaceKLanguage(readNode.OuterHtml, classNameAlias, evaluator, entity, viewDetails, websiteData, websiteData?._system?.kresult, queryString, functionLog, isDetailsView, isNFSite)) ?? returnNode;
                    return(returnNode);
                }
                else if (readNode.NodeType == HtmlNodeType.Element)
                {
                    if (isRepeat && (false || readNode.Attributes.Aggregate(false, (acc, x) => acc || x.Name.ToLower().Equals("k-norepeat"))))
                    {
                        returnNode = HtmlCommentNode.CreateNode("<!-- skip -->");
                    }

                    if (returnNode.Attributes.Count() > 0)
                    {
                        foreach (HtmlAttribute attribute in returnNode.Attributes.ToList())
                        {
                            if (returnNode.NodeType == HtmlNodeType.Comment)
                            {
                                break;
                            }
                            if (!String.IsNullOrEmpty(attribute.Name) && dynamicTagDescriptors.Contains(attribute.Name.ToLower()))
                            {
                                TagProcessor processor = processorFactory.GetProcessor(attribute.Name);
                                processor.ProcessNode(ref returnNode, attribute, classNameAlias, classNameAliasDepth, depth, customerId, evaluator, entity, websiteData, viewDetails, queryString, functionLog, isDetailsView, isNFSite);
                                if (!(attribute.Name.ToLower().Equals(LanguageAttributes.KPayAmount.GetDescription()) || attribute.Name.ToLower().Equals(LanguageAttributes.KPayPurpose.GetDescription())))
                                {
                                    returnNode.Attributes[attribute.Name.ToLower()]?.Remove();
                                }
                            }
                            else if (!attribute.Name.Equals("input", StringComparison.InvariantCultureIgnoreCase) && !attribute.Name.Equals("headers", StringComparison.InvariantCultureIgnoreCase) && Kitsune.Helper.Constants.WidgetRegulerExpression.IsMatch(attribute.Value))
                            {
                                attribute.Value = ReplaceKLanguage(attribute.Value, classNameAlias, evaluator, entity, viewDetails, websiteData, websiteData?._system?.kresult, queryString, functionLog, isDetailsView, isNFSite);
                                //attribute.Value = evaluator.EvaluateExpression(attribute.Value, entity, viewDetails, classNameAlias, websiteData, websiteData?._system?.kresult, queryString, isDetailsView, isNFSite);
                                if (returnNode.Name?.ToLower() == "img" && attribute.Name?.ToLower() == "src")
                                {
                                    attribute.Value = attribute.Value?.Trim();
                                }
                            }
                        }

                        if (requestType == KitsuneRequestUrlType.PRODUCTION && returnNode.Name?.ToLower() == "img")
                        {
                            string source = returnNode.Attributes.Where(x => x.Name.ToLower() == "src")?.FirstOrDefault()?.Value;
                            if (!string.IsNullOrEmpty(source) && !source.StartsWith("/") && !source.StartsWith(".") && !source.StartsWith("data:") && source.ToLower().IndexOf("k-img") < 0)
                            {
                                source = source.Replace(" ", "%20");
                                string ext    = source.Split('?')[0].Split('.').Last().ToLower();
                                string domain = source.Replace("http://", "").Replace("https://", "").Split('/')[0].ToLower();
                                if (!BlackListKImgFileExtension.Contains(ext) && !BlackListKImgDomain.Contains(domain) && !domain.Contains("cdn") && !domain.Contains("akamai") && !domain.Contains("cloudflare"))
                                {
                                    string rootUrl = websiteData?.rootaliasurl?.url?.Value;
                                    if (!source.StartsWith(rootUrl, StringComparison.InvariantCultureIgnoreCase))
                                    {
                                        string srcSetValue = "";
                                        foreach (int resolution in KLM_Constants.IMAGE_RESOLUTIONS)
                                        {
                                            srcSetValue += String.Format(KLM_Constants.K_IMG_FORMAT_STRING, resolution, source);
                                        }
                                        if (srcSetValue != null)
                                        {
                                            returnNode.Attributes.Add("srcset", srcSetValue);
                                            //returnNode.Attributes.Remove("src");
                                        }
                                    }
                                }
                            }
                        }
                    }
                    //if (returnNode.Name?.ToLower() == "img")
                    //{
                    //    string source = returnNode.Attributes.Where(x => x.Name.ToLower() == "src").FirstOrDefault().Value;
                    //    if (!string.IsNullOrEmpty(source))
                    //    {
                    //        string[] srcParts = source.Split('?')[0].Split('.');
                    //        if (!srcParts[srcParts.Length - 1].Equals("svg", StringComparison.InvariantCultureIgnoreCase))
                    //        {
                    //            string rootUrl = websiteData?.rootaliasurl?.url?.Value;
                    //            string path = websiteData?._system?.request?.urlpath?.Value;
                    //            string srcSetValue = GetSrcSetValue(rootUrl, path, source);
                    //            if (srcSetValue != null)
                    //            {
                    //                returnNode.Attributes.Add("srcset", srcSetValue);
                    //                //returnNode.Attributes.Remove("src");
                    //            }
                    //        }
                    //    }
                    //}

                    if (returnNode.Name?.ToLower() == LanguageAttributes.KScript.GetDescription()?.ToLower())
                    {
                        TagProcessor processor = processorFactory.GetProcessor(returnNode.Name);
                        processor.ProcessNode(ref returnNode, null, classNameAlias, classNameAliasDepth, depth, customerId, evaluator, entity, websiteData, viewDetails, queryString, functionLog, isDetailsView, isNFSite);
                    }
                }
                return(returnNode);
            }
            catch (Exception ex) { throw; }
        }