public NXPTag(TagType type)
{
tag = new Tag();
tag.Type = type;
password = new byte[4] { 0, 0, 0, 0 };
retries = 1;
}
/// <summary>
/// Gets the next node after the start index
/// </summary>
/// <param name="code">The code.</param>
/// <param name="startIndex">The index from which to start searching.</param>
/// <param name="tagType">Returns next tag type</param>
/// <param name="previousTag">The previous tag in the stack.</param>
/// <param name="isParseContent">If the content of the last opening node should be parsed. In Html all the content is parsed.</param>
protected override SyntaxNode GetNextNode(string code, ref int startIndex, out TagType tagType, Tag previousTag, bool isParseContent)
{
string currentSubstring = code.Substring(startIndex);
//in the regex I won't work with h1, h2... and such tags!
string regexPattern = previousTag == null || isParseContent ? @"</?[a-zA-Z]+[^<>]*/?>" : @"<" + previousTag.CloseTag + @">";
Match tag = Regex.Match(currentSubstring, regexPattern);
Tag registeredTag = null;
tagType = TagType.Open; //we just set it here and when needed will do it later
while (tag.Success && (registeredTag = GetTagByValue(tag.Value)) == null)//getting tags, but they are not registered.
{
tag = tag.NextMatch();
}
if (!tag.Success) //didn't find a registered tag until the end - return everything left as a text node
{
startIndex += currentSubstring.Length;
return new TextSyntaxNode(currentSubstring);
}
if (tag.Index == 0) //if the string given to the matcher was something like '<strong>...'
{
if (tag.Value.StartsWith("</"))
{
tagType = TagType.Close;
}
else if (tag.Value.EndsWith("/>"))
{
tagType = TagType.SelfClose;
}
startIndex += tag.Value.Length;
return new HtmlSyntaxNode(registeredTag as HtmlTag, tag.Value);
}
//there has been some text before the tag that I found...
startIndex += tag.Index; //move the start index for the other iterations
return new TextSyntaxNode(currentSubstring.Substring(0, tag.Index));
}
protected ITag ReadTag(ReadTagOptions options, TagType defaultTagType)
{
ITag result;
TagType type;
this.InitializeReader();
type = this.ReadTagType(defaultTagType);
result = TagFactory.CreateTag(type);
if ((options & ReadTagOptions.IgnoreName) == 0)
{
string name;
name = _reader.GetAttribute("name");
if (string.IsNullOrEmpty(name))
{
name = _reader.Name;
}
result.Name = name;
}
if ((options & ReadTagOptions.IgnoreValue) == 0)
{
result.Value = this.ReadTagValue(result);
}
return result;
}
public override bool CanCreateTag(TagType type)
{
if (Tag.Count > 0)
return Tag.ValueType == type;
else
return Enum.IsDefined(typeof(TagType), type) && type != TagType.TAG_END;
}
public string this[TagType type]
{
get { return GetId3Data()[type]; }
set
{
switch (type)
{
case TagType.Artist:
Artist = value;
break;
case TagType.Id:
TrackId = value;
break;
case TagType.Title:
Title = value;
break;
case TagType.Album:
Album = value;
break;
case TagType.Genre:
Genre = value;
break;
case TagType.Year:
Year = value;
break;
case TagType.Comment:
Comment = value;
break;
default:
throw new ArgumentOutOfRangeException(type.ToString(), type, null);
}
}
}
//TODO: move to separate class {READY}
public UserData GetInfoFromUser(TagType tag, Diff diff, IMp3File file, ICommunication communication)
{
communication.SendMessage($"File: {file.FilePath}");
communication.SendMessage($"There is a problem with tag \"{tag}\". ");
communication.SendMessage(
$"You can enter tag from: \n\t1) File name (Data: \"{diff.FileNameValue}\"), \n\t2) Mp3 Tags (Data: \"{diff.TagValue}\"), \n\t3) Manual");
while (true)
{
communication.SendMessage("Your choise (number): ");
SyncActions inputData;
var choiseCorrect = Enum.TryParse(communication.GetResponse(), out inputData);
if (!choiseCorrect)
{
communication.SendMessage("Wrong input!");
communication.SendMessage("You sholud enter number with action!");
continue;
}
switch (inputData)
{
case SyncActions.FromFileName:
return new UserData(inputData, diff.FileNameValue);
case SyncActions.FromTags:
return new UserData(inputData, diff.TagValue);
case SyncActions.Manual:
communication.SendMessage("Enter text for tag \"" + tag + "\"");
return new UserData(inputData, communication.GetResponse());
}
}
}
public OpenTag(TagType tag, IEnumerable<IExpression> arguments) {
_Tag = tag;
if (arguments == null)
_Arguments = new IExpression[0];
else
_Arguments = arguments.ToArray();
}
/// <summary>
/// Checks if the node is castable to another node of a given tag type.
/// </summary>
/// <param name="type">An NBT tag type.</param>
/// <returns>Status indicating whether this object could be cast to a node type represented by the given tag type.</returns>
public override bool IsCastableTo (TagType type)
{
return (type == TagType.TAG_BYTE ||
type == TagType.TAG_SHORT ||
type == TagType.TAG_INT ||
type == TagType.TAG_LONG);
}
/// <summary>
/// Gets the next node after the start index.
/// </summary>
/// <param name="code">The code.</param>
/// <param name="startIndex">The index from which to start searching.</param>
/// <param name="tagType">Returns the next tag type</param>
/// <param name="previousTag">The previous tag in the stack.</param>
/// <param name="isParseContent">If the content of the last opening node should be parsed.</param>
/// <returns></returns>
protected override SyntaxNode GetNextNode(string code, ref int startIndex, out TagType tagType, Tag previousTag, bool isParseContent)
{
string currentSubstring = code.Substring(startIndex);
string regexPattern = previousTag == null || isParseContent ? @"\[/?[a-z*][a-z0-9]*(=[^\[\]\n\r\v\f]+)?\]" : @"\[" + previousTag.CloseTag + @"\]"; //the close tag has /
Match tag = Regex.Match(currentSubstring, regexPattern);
Tag registeredTag = null;
tagType = TagType.Open; //we just set it here and when needed will do it later
while (tag.Success && (registeredTag = GetTagByValue(tag.Value)) == null)//getting tags, but they are not registered.
{
tag = tag.NextMatch();
}
if (!tag.Success) //didn't find a registered tag until the end - return everything left as a text node
{
startIndex += currentSubstring.Length;
return new TextSyntaxNode(currentSubstring);
}
if (tag.Index == 0) //if the string given to the matcher was something like '[b]...'
{
if (tag.Value.StartsWith("[/")) tagType = TagType.Close;
startIndex += tag.Value.Length;
return new BBCodeSyntaxNode(registeredTag as BBTag, tag.Value);
}
//there has been some text before the tag that I found...
startIndex += tag.Index; //move the start index for the other iterations
return new TextSyntaxNode(currentSubstring.Substring(0, tag.Index));
}
public TagData(string name, Hash sha1, TagType tagType)
{
Verify.Argument.IsNeitherNullNorWhitespace(name, "name");
_name = name;
_sha1 = sha1;
_tagType = tagType;
}
public static TagsManager CreateFormFile(String file, TagType type = TagType.Automatic, bool parseTags = true)
{
var handle = TagsLibCoreModule.CreateFunction.Delegate();
var result = new TagsManager(handle);
TagsLibCoreModule.LoadTagsFunction.Delegate(handle, file, type, parseTags);
return result;
}
public static TagsManager CreateFormMemory(IntPtr memory, ulong size, TagType type = TagType.Automatic, bool parseTags = true)
{
var handle = TagsLibCoreModule.CreateFunction.Delegate();
var result = new TagsManager(handle);
TagsLibCoreModule.LoadTagsFormMemoryFunction.Delegate(handle, memory, size, type, parseTags);
return result;
}
public IfElement(TagType tag, INode condition, INode trueValue, INode falseValue)
{
if (condition == null)
throw new ArgumentNullException("condition");
_Tag = tag;
_Condition = condition;
_TrueValue = trueValue;
_FalseValue = falseValue;
}
public CreateNodeForm(TagType tagType, bool hasName)
{
InitializeComponent();
_type = tagType;
_hasName = hasName;
SetNameBoxState();
SetSizeBoxState();
}
public SwitchElement(TagType tag, INode caseSwitch, IDictionary<int, INode> cases)
{
if (caseSwitch == null)
throw new ArgumentNullException("caseSwitch");
if (cases == null)
throw new ArgumentNullException("cases");
_Tag = tag;
_CaseSwitch = caseSwitch;
_Cases = new ReadOnlyDictionary<int, INode>(cases);
}
public override TagCollection GetUserTags(int userID, TagType type)
{
switch (type)
{
case TagType.Blog:
return GetUserBlogTags(userID);
default:
return new TagCollection();
}
}
public Tag(string name, TagType type, Guid owner, FileEntry entry)
{
TagName = name;
TagType = type;
Owner = owner;
if (entry != null)
{
EntryId = entry.ID;
EntryType = entry is File ? FileEntryType.File : FileEntryType.Folder;
}
}
public override bool CreateNode(TagType type)
{
if (!CanCreateTag(type))
return false;
if (Tag.Count == 0) {
Tag.ChangeValueType(type);
}
AppendTag(TagDataNode.DefaultTag(type));
return true;
}
public IEnumerable<Tag> GetTags(Guid owner, TagType tagType)
{
var q = Query("files_tag t")
.InnerJoin("files_tag_link l", Exp.EqColumns("l.tag_id", "t.id"))
.Select("t.name", "t.flag", "t.owner", "entry_id", "entry_type", "t.id")
.Where("l.tenant_id", TenantID)
.Where("t.owner", owner.ToString())
.Where("t.flag", (int)tagType);
return SelectTagByQuery(q);
}
public CompoundTag(StreamReader sr, string name, TagType type)
: base(sr, name, type)
{
while (true)
{
var t = parse(sr);
if (t.type == TagType.TagEnd) break;
subtags.Add((NamedTag) t);
}
}
public IEnumerable<Tag> GetTags(object entryID, FileEntryType entryType, TagType tagType)
{
var q = Query("files_tag t")
.InnerJoin("files_tag_link l", Exp.EqColumns("l.tag_id", "t.id"))
.Select("t.name", "t.flag", "t.owner", "entry_id", "entry_type", "tag_count", "t.id")
.Where("l.tenant_id", TenantID)
.Where("l.entry_type", (int) entryType)
.Where(Exp.Eq("l.entry_id", MappingID(entryID)))
.Where("t.flag", (int) tagType);
return SelectTagByQuery(q);
}
public static String GetFormDataTag(TagType type, IForm fd)
{
switch (type)
{
case TagType.Tile:
return String.Format("tile-data-{0}-form_type-{1}", fd.id, fd.form.form_type_id);
case TagType.Document:
return String.Format("doc-data-{0}-form_type-{1}", fd.id, fd.form.form_type_id);
case TagType.Container:
return String.Format("container-data-{0}-form_type-{1}", fd.id, fd.form.form_type_id);
default:
return null;
}
}
public IEnumerable<Tag> GetTags(string[] names, TagType tagType)
{
if (names == null) throw new ArgumentNullException("names");
var q = Query("files_tag t")
.InnerJoin("files_tag_link l", Exp.EqColumns("l.tag_id", "t.id"))
.Select("t.name", "t.flag", "t.owner", "entry_id", "entry_type", "tag_count", "t.id")
.Where("l.tenant_id", TenantID)
.Where("t.owner", Guid.Empty.ToString())
.Where(Exp.In("t.name", names))
.Where("t.flag", (int) tagType);
return SelectTagByQuery(q);
}
public static string LKTag(TagType eTagType, string context, IDictionary<string, object> htmlattributes)
{
TagBuilder tag = new TagBuilder(eTagType.ToString().ToLower());
tag.MergeAttributes(htmlattributes);
tag.InnerHtml = context;
string sHtml = "";
switch (eTagType)
{
case TagType.IMG:
sHtml = tag.ToString(TagRenderMode.SelfClosing);
break;
default:
sHtml = tag.ToString(TagRenderMode.Normal);
break;
}
return sHtml;
}
public static NamedTag parse(StreamReader sr, TagType type)
{
var name = "";
//read the name length
var buffer = new char[2];
sr.ReadBlock(buffer, 0, 2);
var bytebuf = new byte[] {(byte) buffer[1], (byte) buffer[0]};
short length = BitConverter.ToInt16(bytebuf, 0);
buffer = new char[length];
sr.ReadBlock(buffer, 0, length);
name = new string(buffer);
Type t = GetClrTypeForTag(type);
return (NamedTag)Activator.CreateInstance(t, sr, name, type);
}
public IEnumerable<Tag> GetTags(TagType tagType, params FileEntry[] fileEntries)
{
var filesId = fileEntries.Where(e => e is File).Select(e => MappingID(e.ID)).ToArray();
var foldersId = fileEntries.Where(e => e is Folder).Select(e => MappingID(e.ID)).ToArray();
var q = Query("files_tag t")
.InnerJoin("files_tag_link l",
Exp.EqColumns("l.tenant_id", "t.tenant_id") &
Exp.EqColumns("l.tag_id", "t.id"))
.Select("t.name", "t.flag", "t.owner", "entry_id", "entry_type", "tag_count", "t.id")
.Where("l.tenant_id", TenantID)
.Where((Exp.Eq("l.entry_type", (int)FileEntryType.File) & Exp.In("l.entry_id", filesId))
| (Exp.Eq("l.entry_type", (int)FileEntryType.Folder) & Exp.In("l.entry_id", foldersId)))
.Where("t.flag", (int)tagType);
return SelectTagByQuery(q);
}
public DefineTextTag(SwfReader r, bool useAlpha)
{
if (useAlpha)
{
tagType = TagType.DefineText2;
}
CharacterId = r.GetUI16();
TextBounds = new Rect(r);
TextMatrix = new Matrix(r);
glyphBits = (uint)r.GetByte();
advanceBits = (uint)r.GetByte();
while (r.PeekByte() != 0x00)
{
TextRecords.Add(new TextRecord(r, glyphBits, advanceBits, useAlpha));
}
byte end = r.GetByte();
}
public static String GetTag(TagType type, object obj, string addon = "")
{
var tag = String.Format("{0}-{1}", (
obj is region ? REGION + "-" + ((region)obj).region_id :
obj is edu ? EDU + "-"+((edu)obj).edu_id
: obj is municipality ? MUNICIPALITY + "-"+((municipality)obj).municipality_id
: obj is edu_kind ? EDU_TYPE + "-"+((edu_kind)obj).edu_kind_id : "ent"), addon);
switch (type)
{
case TagType.Tile:
return "tile-" + tag;
case TagType.Document:
return "doc-" + tag;
case TagType.Container:
return "container-" + tag;
default:
return null;
}
}
public override bool VisitMethodDecl(Method method)
{
if (!method.IsConstructor)
return false;
if (method.IsCopyConstructor)
return false;
if (method.Parameters.Count != 1)
return false;
var parameter = method.Parameters[0];
var parameterType = parameter.Type as PointerType;
if (parameterType == null)
return false;
if (!parameterType.IsReference)
return false;
var qualifiedPointee = parameterType.QualifiedPointee;
Class castFromClass;
if (!qualifiedPointee.Type.TryGetClass(out castFromClass))
return false;
var castToClass = method.OriginalNamespace as Class;
if (castToClass == null)
return false;
if (castFromClass == castToClass)
return false;
var operatorKind = method.IsExplicit
? CXXOperatorKind.ExplicitConversion
: CXXOperatorKind.Conversion;
var castToType = new TagType(castToClass);
var qualifiedCastToType = new QualifiedType(castToType);
var conversionOperator = new Method()
{
Name = Operators.GetOperatorIdentifier(operatorKind),
Namespace = castFromClass,
Kind = CXXMethodKind.Conversion,
IsSynthetized = true,
ConversionType = qualifiedCastToType,
ReturnType = qualifiedCastToType
};
conversionOperator.OperatorKind = operatorKind;
castFromClass.Methods.Add(conversionOperator);
return true;
}
public override bool CreateNode(TagType type)
{
if (!CanCreateTag(type))
return false;
if (FormRegistry.CreateNode != null) {
CreateTagFormData data = new CreateTagFormData() {
TagType = type, HasName = true,
};
data.RestrictedNames.AddRange(_container.TagNamesInUse);
if (FormRegistry.CreateNode(data)) {
AddTag(data.TagNode, data.TagName);
return true;
}
}
return false;
}
public IEnumerable <Tag> GetTags(TagType tagType, IEnumerable <FileEntry <string> > fileEntries)
{
return(TagDao.GetTags(tagType, fileEntries));
}
public virtual void RenderBeginTag(HtmlTextWriterTag tagKey)
{
this.TagKey = tagKey;
bool renderTag = true;
if (_isDescendant)
{
renderTag = OnTagRender(_tagName, _tagKey);
// Inherited renderers will be expecting to be able to filter any of the attributes at this point
FilterAttributes();
// write text before begin tag
string textBeforeTag = RenderBeforeTag();
if (textBeforeTag != null)
{
if (tabsPending)
{
OutputTabs();
}
writer.Write(textBeforeTag);
}
}
// gather information about this tag.
TagInformation tagInfo = _tagNameLookupArray[_tagIndex];
TagType tagType = tagInfo.tagType;
bool renderEndTag = renderTag && (tagType != TagType.NonClosing);
string endTag = renderEndTag ? tagInfo.closingTag : null;
// write the begin tag
if (renderTag)
{
if (tabsPending)
{
OutputTabs();
}
writer.Write(TagLeftChar);
writer.Write(_tagName);
for (int i = 0; i < _attrCount; i++)
{
RenderAttribute attr = _attrList[i];
writer.Write(SpaceChar);
writer.Write(attr.name);
if (attr.value != null)
{
writer.Write(EqualsDoubleQuoteString);
string attrValue = attr.value;
if (attr.isUrl)
{
if (attr.key != HtmlTextWriterAttribute.Href || !attrValue.StartsWith("javascript:", StringComparison.Ordinal))
{
attrValue = EncodeUrl(attrValue);
}
}
if (attr.encode)
{
WriteHtmlAttributeEncode(attrValue);
}
else
{
writer.Write(attrValue);
}
writer.Write(DoubleQuoteChar);
}
}
if (tagType == TagType.NonClosing)
{
writer.Write(SelfClosingTagEnd);
}
else
{
writer.Write(TagRightChar);
}
}
string textBeforeContent = RenderBeforeContent();
if (textBeforeContent != null)
{
if (tabsPending)
{
OutputTabs();
}
writer.Write(textBeforeContent);
}
// write text before the content
if (renderEndTag)
{
if (tagType == TagType.Inline)
{
_inlineCount += 1;
}
else
{
// writeline and indent before rendering content
WriteLine();
Indent++;
}
// Manually build end tags for unknown tag types.
if (endTag == null)
{
endTag = EndTagLeftChars + _tagName + TagRightChar.ToString();
}
}
if (_isDescendant)
{
// append text after the tag
string textAfterTag = RenderAfterTag();
if (textAfterTag != null)
{
endTag = (endTag == null) ? textAfterTag : textAfterTag + endTag;
}
// build end content and push it on stack to write in RenderEndTag
// prepend text after the content
string textAfterContent = RenderAfterContent();
if (textAfterContent != null)
{
endTag = (endTag == null) ? textAfterContent : textAfterContent + endTag;
}
}
// push end tag onto stack
PushEndTag(endTag);
// flush attribute and style lists for next tag
_attrCount = 0;
}
public IEnumerable <Tag> GetTags(Guid owner, TagType tagType)
{
return(null);
}
public IEnumerable <Tag> GetTags(string[] names, TagType tagType)
{
return(new List <Tag>());
}
public override bool CanCreateTag(TagType type)
{
return(_tree != null && _tree.Root != null && Enum.IsDefined(typeof(TagType), type) && type != TagType.TAG_END);
}
public IEnumerable <Tag> GetTags(TagType tagType, params FileEntry[] fileEntries)
{
return(null);
}
/// <summary>
/// Constructs a new <see cref="SchemaNodeList"/> with additional options.
/// </summary>
/// <param name="name">The name of the corresponding <see cref="TagNodeList"/>.</param>
/// <param name="type">The type of items contained in the corresponding <see cref="TagNodeList"/>.</param>
/// <param name="options">One or more option flags modifying the processing of this node.</param>
public SchemaNodeList(string name, TagType type, SchemaOptions options)
: base(name, options)
{
_type = type;
}
public IEnumerable <Tag> GetTags(Guid subject, TagType tagType, IEnumerable <FileEntry <string> > fileEntries)
{
return(TagDao.GetTags(subject, tagType, fileEntries));
}
/// <summary>
/// Constructs a new <see cref="SchemaNodeList"/> representing a <see cref="TagNodeList"/> named <paramref name="name"/> containing items of type <paramref name="type"/> matching the given schema.
/// </summary>
/// <param name="name">The name of the corresponding <see cref="TagNodeList"/>.</param>
/// <param name="type">The type of items contained in the corresponding <see cref="TagNodeList"/>.</param>
/// <param name="subschema">A <see cref="SchemaNode"/> representing a schema to verify against items contained in the corresponding <see cref="TagNodeList"/>.</param>
public SchemaNodeList(string name, TagType type, SchemaNode subschema)
: base(name)
{
_type = type;
_subschema = subschema;
}
public IEnumerable <Tag> GetTags(string entryID, FileEntryType entryType, TagType tagType)
{
return(TagDao.GetTags(entryID, entryType, tagType));
}
public IfEqualsElement(TagType tag, INode leftValue, INode rightValue, INode trueValue, INode falseValue)
: base(tag, new Comparison(DecodeExpressionType.Equal, leftValue, rightValue), trueValue, rightValue)
{
}
public static bool TryGetDeclaration <T>(this Type t, out T decl, T value = null) where T : Declaration
{
t = t.Desugar();
TagType tagType = null;
var type = t as TemplateSpecializationType;
if (type != null)
{
if (type.IsDependent)
{
if (type.Template is TypeAliasTemplate)
{
type.Desugared.Type.TryGetDeclaration(out decl, value);
decl = decl as T;
return(decl != null);
}
var classTemplate = type.Template as ClassTemplate;
if (classTemplate != null)
{
var templatedClass = classTemplate.TemplatedClass;
decl = templatedClass.CompleteDeclaration == null
? templatedClass as T
: (T)templatedClass.CompleteDeclaration;
if (decl != null)
{
if (value != null)
{
type.Template = new ClassTemplate {
TemplatedDecl = value
}
}
;
return(true);
}
return(false);
}
var templateTemplateParameter = type.Template as TemplateTemplateParameter;
if (templateTemplateParameter != null)
{
return((decl = templateTemplateParameter.TemplatedDecl as T) != null);
}
}
tagType = (type.Desugared.Type.GetFinalPointee() ?? type.Desugared.Type) as TagType;
}
else
{
tagType = t as TagType;
}
if (tagType != null)
{
decl = tagType.Declaration as T;
if (decl != null)
{
if (value != null)
{
tagType.Declaration = value;
}
return(true);
}
return(false);
}
decl = null;
return(false);
}
public string Parse(string template, Dictionary <string, string> context)
{
if (context == null)
{
context = new Dictionary <string, string>();
}
if (template == null)
{
return("");
}
State state = State.ECHO;
TagType tagType = TagType.NONE;
string retval = "";
string tag = "";
string subTemplate = "";
string temp = "";
string unhandledTag = "";
int nestingLevel = 0;
foreach (char c in template)
{
if (tagType == TagType.NONE)
{
switch (state)
{
case State.ERROR:
{
break;
}
case State.ECHO:
{
if (c == '{')
{
temp = "{";
unhandledTag = "";
unhandledTag += c;
state = State.TAG_OPENING;
}
else
{
retval += c;
}
break;
}
case State.TAG_OPENING:
{
if (c == '=')
{
if (tagType == TagType.NONE)
{
tagType = TagType.SUBSTITUTION;
}
unhandledTag += c;
state = State.SKIP;
}
else if (c == '@')
{
unhandledTag += c;
tagType = TagType.ACTION;
state = State.SKIP;
nestingLevel++;
}
else if (c == '{')
{
unhandledTag = "";
unhandledTag += c;
retval += temp;
}
else
{
retval += temp;
retval += c;
if (tagType != TagType.ACTION)
{
state = State.ECHO;
}
}
break;
}
}
}
else if (tagType == TagType.SUBSTITUTION)
{
switch (state)
{
case State.ERROR:
{
break;
}
case State.SKIP:
{
unhandledTag += c;
if ("\r\n\t ".IndexOf(c) == -1)
{
state = State.READ_TAG_DATA;
tag += c;
}
break;
}
case State.READ_TAG_DATA:
{
unhandledTag += c;
if (c == ':')
{
state = State.TAG_CLOSING;
temp = ":";
}
else
{
tag += c;
}
break;
}
case State.TAG_CLOSING:
{
if (c == '}')
{
if (context.ContainsKey(tag.Trim()))
{
retval += context[tag.Trim()];
}
else
{
retval += unhandledTag + c;
}
state = State.ECHO;
tag = "";
unhandledTag = "";
tagType = TagType.NONE;
}
else
{
unhandledTag += temp + c;
tag += temp + c;
state = State.READ_TAG_DATA;
}
break;
}
}
}
else if (tagType == TagType.ACTION)
{
switch (state)
{
case State.ERROR:
{
break;
}
case State.SKIP:
{
unhandledTag += c;
if ("\r\n\t ".IndexOf(c) == -1)
{
state = State.READ_TAG_DATA;
tag += c;
}
break;
}
case State.TAG_OPENING:
{
unhandledTag += c;
subTemplate += temp + c;
if (c == '@' || c == '=')
{
nestingLevel++;
}
state = State.READ_SUB_TEMPLATE;
break;
}
case State.READ_SUB_TEMPLATE:
{
unhandledTag += c;
if (c == ':')
{
temp = ":";
state = State.TAG_CLOSING;
}
else if (c == '{')
{
temp = "{";
state = State.TAG_OPENING;
}
else
{
subTemplate += c;
}
break;
}
case State.READ_TAG_DATA:
{
unhandledTag += c;
if ("\r\n\t{ ".IndexOf(c) != -1)
{
if (c == '{')
{
temp = "{";
state = State.TAG_OPENING;
}
else
{
subTemplate += c;
state = State.READ_SUB_TEMPLATE;
}
}
else
{
tag += c;
}
break;
}
case State.TAG_CLOSING:
{
unhandledTag += c;
if (c == '}')
{
nestingLevel--;
if (nestingLevel == 0)
{
// TODO :: we need to do the callback
if (TemplateActions.ContainsKey(tag) == true)
{
retval += TemplateActions[tag].Run(subTemplate, context);
//retval += unhandledTag + c;
}
else
{
retval += unhandledTag + c;
}
tag = "";
subTemplate = "";
temp = "";
unhandledTag = "";
state = State.ECHO;
tagType = TagType.NONE;
}
else
{
subTemplate += temp + c;
state = State.READ_SUB_TEMPLATE;
}
}
else
{
state = State.READ_SUB_TEMPLATE;
subTemplate += temp + c;
}
break;
}
}
}
}
if (state != State.ECHO)
{
throw new Exception(string.Format("Parser Finished in a Bad STATE {0}", state));
}
return(retval);
}
/// <summary>
/// Constructs a new <see cref="SchemaNodeList"/> representing a <see cref="TagNodeList"/> named <paramref name="name"/> containing <paramref name="length"/> items of type <paramref name="type"/>.
/// </summary>
/// <param name="name">The name of the corresponding <see cref="TagNodeList"/>.</param>
/// <param name="type">The type of items contained in the corresponding <see cref="TagNodeList"/>.</param>
/// <param name="length">The number of items contained in the corresponding <see cref="TagNodeList"/>.</param>
public SchemaNodeList(string name, TagType type, int length)
: base(name)
{
_type = type;
_length = length;
}
public override int GetHashCode()
{
unchecked
{
return(((Name != null ? Name.GetHashCode() : 0) * 397) ^ (TagType != null ? TagType.GetHashCode() : 0));
}
}
public IEnumerable <Tag> GetTags(object entryID, FileEntryType entryType, TagType tagType)
{
return(null);
}
public TagInformation(string name, TagType tagType, string closingTag)
{
this.name = name;
this.tagType = tagType;
this.closingTag = closingTag;
}
/// <summary>
/// Constructs a new <see cref="SchemaNodeList"/> representing a <see cref="TagNodeList"/> named <paramref name="name"/> containing items of type <paramref name="type"/>.
/// </summary>
/// <param name="name">The name of the corresponding <see cref="TagNodeList"/>.</param>
/// <param name="type">The type of items contained in the corresponding <see cref="TagNodeList"/>.</param>
public SchemaNodeList(string name, TagType type)
: base(name)
{
_type = type;
}
/// <summary>
/// Checks if the node is castable to another node of a given tag type.
/// </summary>
/// <param name="type">An NBT tag type.</param>
/// <returns>Status indicating whether this object could be cast to a node type represented by the given tag type.</returns>
public override bool IsCastableTo(TagType type)
{
return(type == TagType.TAG_FLOAT ||
type == TagType.TAG_DOUBLE);
}
public IEnumerable <Tag> GetTags(TagType tagType, IEnumerable <FileEntry <string> > fileEntries)
{
return(new List <Tag>());
}
void TagParsed(ILocation location, TagType tagtype, string tagId, TagAttributes attributes)
{
switch (tagtype)
{
case TagType.Close:
TagNode tn = currentNode as TagNode;
if (tn == null)
{
errors.Add(new ParseException(location, "Closing tag '" + tagId + "' does not match an opening tag."));
}
else
{
if (tn.TagName == tagId)
{
tn.EndLocation = location;
currentNode = currentNode.Parent;
tn.Close();
}
else
{
errors.Add(new ParseException(location, "Closing tag '" + tagId + "' does not match opening tag '" + tn.TagName + "'."));
currentNode = currentNode.Parent;
TagParsed(location, TagType.Close, tagId, null);
}
}
break;
case TagType.CodeRender:
case TagType.CodeRenderExpression:
case TagType.DataBinding:
try
{
AddtoCurrent(location, new ExpressionNode(location, tagId, tagtype == TagType.CodeRenderExpression));
}
catch (ParseException ex)
{
errors.Add(ex);
}
break;
case TagType.Directive:
try
{
AddtoCurrent(location, new DirectiveNode(location, tagId, attributes));
}
catch (ParseException ex)
{
errors.Add(ex);
}
break;
case TagType.Include:
throw new NotImplementedException("Server-side includes have not yet been implemented: " + location.PlainText);
case TagType.ServerComment:
//FIXME: the parser doesn't actually return these
throw new NotImplementedException("Server comments have not yet been implemented: " + location.PlainText);
case TagType.SelfClosing:
try
{
tn = new TagNode(location, tagId, attributes);
AddtoCurrent(location, tn);
tn.Close();
}
catch (ParseException ex)
{
errors.Add(ex);
}
break;
case TagType.Tag:
try
{
//HACK: implicit close on block level in HTML4
TagNode prevTag = currentNode as TagNode;
if (prevTag != null)
{
if (Array.IndexOf(implicitCloseOnBlock, prevTag.TagName.ToLowerInvariant()) > -1 &&
Array.IndexOf(blockLevel, tagId.ToLowerInvariant()) > -1)
{
errors.Add(new ParseException(location, "Unclosed " + prevTag.TagName + " tag. Assuming implicitly closed by block level tag."));
prevTag.Close();
currentNode = currentNode.Parent;
}
}
//create and add the new tag
TagNode child = new TagNode(location, tagId, attributes);
AddtoCurrent(location, child);
//HACK: implicitly closing tags in HTML4
if (Array.IndexOf(implicitSelfClosing, tagId.ToLowerInvariant()) > -1)
{
errors.Add(new ParseException(location, "Unclosed " + tagId + " tag. Assuming implicitly closed."));
child.Close();
}
else
{
currentNode = child;
}
}
catch (ParseException ex)
{
errors.Add(ex);
}
break;
case TagType.Text:
//FIXME: the parser doesn't actually return these
throw new NotImplementedException("Text tagtypes have not yet been implemented: " + location.PlainText);
}
}
// [CheckPermission(PageId.Tag, Permission.View)]
public async Task <IActionResult> GetListSubject(string tenantId, string languageId, TagType type, string subjectId)
{
var result = await _tagService.GetListSubject(tenantId, languageId, type, subjectId);
return(Ok(result));
}
public IEnumerable <Tag> GetTags(Guid owner, TagType tagType)
{
return(TagDao.GetTags(owner, tagType));
}
public CloseTag(TagType tag)
{
_Tag = tag;
}
public IEnumerable <Tag> GetTags(Guid owner, TagType tagType)
{
return(new List <Tag>());
}
public IEnumerable <Tag> GetTags(string[] names, TagType tagType)
{
return(TagDao.GetTags(names, tagType));
}
public bool CanUseInCurrent(TagType tagType)
{
return(((int)tagType < 1 || (int)tagType > 6) && tagType != TagType.Bold);
}
public IEnumerable <Tag> GetTags(string[] names, TagType tagType)
{
return(null);
}
/// <summary>
/// Constructs a new <see cref="SchemaNodeList"/> with additional options.
/// </summary>
/// <param name="name">The name of the corresponding <see cref="TagNodeList"/>.</param>
/// <param name="type">The type of items contained in the corresponding <see cref="TagNodeList"/>.</param>
/// <param name="length">The number of items contained in the corresponding <see cref="TagNodeList"/>.</param>
/// <param name="options">One or more option flags modifying the processing of this node.</param>
public SchemaNodeList(string name, TagType type, int length, SchemaOptions options)
: base(name, options)
{
_type = type;
_length = length;
}
//[CheckPermission(PageId.Tag, Permission.View)]
public async Task <IActionResult> Search(string tenantId, string languageId, string keyword, TagType type, int page = 1, int pageSize = 20)
{
var result = await _tagService.Search(tenantId, languageId, keyword, type, page, pageSize);
return(Ok(result));
}
