private IList <PageBE> GetTaggedPages(TagBE tag)
{
IList <ulong> pageIds = _session.Tags_GetPageIds(tag.Id);
IList <PageBE> pages = PageBL.GetPagesByIdsPreserveOrder(pageIds);
return(PermissionsBL.FilterDisallowed(_user, pages, false, Permissions.BROWSE));
}
public XDoc GetTagXml(TagBE tag, bool showPages, string pageFilterLanguage)
{
string uriText = null, titleText = null;
switch (tag.Type)
{
case TagType.DEFINE:
uriText = Utils.AsPublicUiUri(tag.DefinedTo.Title);
titleText = tag.Name;
break;
case TagType.DATE:
uriText = _dekiContext.UiUri.Uri.AtPath("Special:Events").With("from", tag.Name).ToString();
DateTime date = DateTime.ParseExact(tag.Name, "yyyy-MM-dd", _culture, DateTimeStyles.None);
titleText = date.ToString("D", _culture);
break;
case TagType.TEXT:
if (null != tag.DefinedTo)
{
uriText = Utils.AsPublicUiUri(tag.DefinedTo.Title);
}
else
{
uriText = _dekiContext.UiUri.AtPath("Special:Tags").With("tag", tag.Name).ToString();
}
titleText = tag.Name;
break;
}
XDoc result = new XDoc("tag");
result.Attr("value", tag.PrefixedName);
result.Attr("id", tag.Id);
result.Attr("href", _dekiContext.ApiUri.At("site", "tags", tag.Id.ToString()).ToString());
if (tag.OccuranceCount > 0)
{
result.Attr("count", tag.OccuranceCount);
}
result.Elem("type", tag.Type.ToString().ToLowerInvariant());
result.Elem("uri", uriText);
result.Elem("title", titleText);
if (null != tag.RelatedPages)
{
result.Add(PageBL.GetPageListXml(tag.RelatedPages, "related"));
}
if (showPages)
{
IList <PageBE> pages = GetTaggedPages(tag);
if (pageFilterLanguage != null)
{
// filter pages by language
pages = (from page in pages where page.Language == pageFilterLanguage select page).ToList();
}
result.Add(PageBL.GetPageListXml(pages, "pages"));
}
return(result);
}
private TagBE Tags_Populate(IDataReader dr)
{
TagBE tag = new TagBE();
tag._Type = dr.Read <uint>("tag_type");
tag.Id = dr.Read <uint>("tag_id");
tag.Name = dr.Read <string>("tag_name");
return(tag);
}
private void UpdateTag(TagBE tag)
{
_session.Tags_Update(tag);
// update tagged pages
var taggedPages = GetTaggedPages(tag);
foreach (var page in taggedPages)
{
PageBL.Touch(page, _dekiContext.Now);
_eventSink.PageTagsUpdate(_dekiContext.Now, page, _user);
}
}
public void Tags_Update(TagBE tag)
{
Catalog.NewQuery(@" /* Tags_Update */
UPDATE tags SET
tag_name = ?TAGNAME,
tag_type = ?TAGTYPE
WHERE tag_id = ?TAGID;
")
.With("TAGNAME", tag.Name)
.With("TAGTYPE", tag.Type)
.With("TAGID", tag.Id)
.Execute();
_log.DebugFormat("tag '{0}'({1}) updated", tag.Name, tag.Type);
}
private List <TagBE> ReadTagsListXml(XDoc tagsDoc)
{
List <TagBE> result = new List <TagBE>();
foreach (XDoc tagDoc in tagsDoc["tag/@value"])
{
TagBE tag = ParseTag(tagDoc.Contents);
if (null != tag)
{
result.Add(tag);
}
}
return(result);
}
public bool Tags_ValidateDefineTagMapping(TagBE tag)
{
if (tag == null)
{
throw new ArgumentNullException("tag");
}
if (tag.Type != TagType.DEFINE)
{
throw new ArgumentException("Tag has to be of type DEFINE");
}
return(Catalog.NewQuery(@" /* Tags_ValidateDefineTagMapping */
DELETE FROM tag_map WHERE tagmap_tag_id = ?TAGID AND (SELECT COUNT(*) FROM pages WHERE page_id = tagmap_page_id) = 0;
SELECT COUNT(*) FROM tag_map WHERE tagmap_tag_id = ?TAGID;")
.With("TAGID", tag.Id).ReadAsInt() > 0);
}
public TagBE ParseTag(string prefixedName)
{
TagBE tag = null;
// retrieve the tag type
prefixedName = prefixedName.Trim();
if (0 < prefixedName.Length)
{
tag = new TagBE();
if (prefixedName.StartsWithInvariantIgnoreCase(TagPrefix.DEFINE))
{
tag.Type = TagType.DEFINE;
}
else if (prefixedName.StartsWithInvariantIgnoreCase(TagPrefix.DATE))
{
tag.Type = TagType.DATE;
}
else if (prefixedName.StartsWithInvariantIgnoreCase(TagPrefix.USER))
{
tag.Type = TagType.USER;
}
// remove the prefix from the tag
int prefixLength = tag.Prefix.Length;
if (prefixLength < prefixedName.Length)
{
tag.Name = prefixedName.Substring(prefixLength);
}
else
{
throw new TagInvalidArgumentException(prefixedName);
}
// the tag is a date and not valid, change its type to text
if (TagType.DATE == tag.Type)
{
DateTime date;
if (!DateTime.TryParseExact(tag.Name, "yyyy-MM-dd", _culture, DateTimeStyles.None, out date))
{
tag.Type = TagType.TEXT;
tag.Name = prefixedName;
}
}
}
return(tag);
}
public TagBE Tags_GetById(uint tagid)
{
TagBE tag = null;
Catalog.NewQuery(@" /* Tags_GetById */
SELECT `tag_id`, `tag_name`, `tag_type`
FROM `tags`
WHERE `tag_id` = ?TAGID;")
.With("TAGID", tagid)
.Execute(delegate(IDataReader dr) {
while (dr.Read())
{
tag = Tags_Populate(dr);
}
});
return(tag);
}
public uint Tags_Insert(TagBE tag)
{
try {
return(Catalog.NewQuery(@" /* Tags_Insert */
INSERT INTO tags (tag_name, tag_type) VALUES (?TAGNAME, ?TAGTYPE);
SELECT LAST_INSERT_ID();")
.With("TAGNAME", tag.Name)
.With("TAGTYPE", tag.Type)
.ReadAsUInt() ?? 0);
} catch (MySqlException e) {
if (e.Number == 1062)
{
_log.DebugFormat("tag '{0}'({1}) already exists, returning 0", tag.Name, tag.Type);
return(0);
}
throw;
}
}
public void PutTags(PageBE page, string[] tags)
{
List <TagBE> newTags = new List <TagBE>();
foreach (string tagName in tags)
{
TagBE tag = ParseTag(tagName);
if (null != tag)
{
newTags.Add(tag);
}
}
if (newTags.Count == 0)
{
return;
}
PutTags(page, newTags);
}
public TagBE Tags_GetByNameAndType(string tagName, TagType type)
{
TagBE tag = null;
Catalog.NewQuery(@" /* Tags_GetByNameAndType */
SELECT `tag_id`, `tag_name`, `tag_type`
FROM `tags`
WHERE `tag_name` = ?TAGNAME
AND `tag_type` = ?TAGTYPE;")
.With("TAGNAME", tagName)
.With("TAGTYPE", type)
.Execute(delegate(IDataReader dr) {
while (dr.Read())
{
tag = Tags_Populate(dr);
}
});
return(tag);
}
public TagBE GetTagFromPathSegment(string tagPathSegment)
{
TagBE tag = null;
uint id = 0;
string tagId = tagPathSegment;
if (uint.TryParse(tagId, out id))
{
tag = _session.Tags_GetById(id);
}
else
{
if (tagId.StartsWith("="))
{
string prefixedName = tagId.Substring(1);
prefixedName = XUri.Decode(prefixedName);
TagBE tmpTag = ParseTag(prefixedName);
tag = _session.Tags_GetByNameAndType(tmpTag.Name, tmpTag.Type);
}
}
if (tag != null)
{
IList <TagBE> tags = new List <TagBE>();
tags.Add(tag);
tags = FilterDisallowed(tags);
if (tags.Count == 0)
{
tag = null;
}
}
if (tag == null)
{
throw new TagNotFoundException();
}
return(tag);
}
public IList <TagBE> Tags_GetByPageId(ulong pageid)
{
// retrieve the tags associated with a specified page id
List <TagBE> tags = new List <TagBE>();
Catalog.NewQuery(@" /* Tags_GetByPageId */
SELECT `tag_id`, `tag_name`, `tag_type`
FROM `tag_map`
JOIN `tags`
ON `tag_map`.`tagmap_tag_id`=`tags`.`tag_id`
WHERE `tagmap_page_id` = ?PAGEID; ")
.With("PAGEID", (uint)pageid)
.Execute(delegate(IDataReader dr) {
while (dr.Read())
{
TagBE t = Tags_Populate(dr);
if (t != null)
{
tags.Add(t);
}
}
});
return(tags);
}
public IList <TagBE> Tags_GetByQuery(string partialName, TagType type, DateTime from, DateTime to)
{
// retrieve the tags associated with a specified page id
List <TagBE> tags = new List <TagBE>();
bool hasWhere = false;
StringBuilder query = new StringBuilder();
query.Append(@" /* Tags_GetByQuery */
SELECT `tag_id`, `tag_name`, `tag_type`
FROM tags ");
if (!string.IsNullOrEmpty(partialName))
{
query.AppendFormat("WHERE tag_name LIKE '{0}%' ", DataCommand.MakeSqlSafe(partialName));
hasWhere = true;
}
if (type != TagType.ALL)
{
if (hasWhere)
{
query.Append("AND ");
}
else
{
query.Append("WHERE ");
}
query.AppendFormat(" tag_type={0} ", (int)type);
hasWhere = true;
}
if ((type == TagType.DATE) && (from != DateTime.MinValue))
{
if (hasWhere)
{
query.Append("AND ");
}
else
{
query.Append("WHERE ");
}
query.AppendFormat("tag_name >= '{0}' ", from.ToString("yyyy-MM-dd"));
hasWhere = true;
}
if ((type == TagType.DATE) && (to != DateTime.MaxValue))
{
if (hasWhere)
{
query.Append("AND ");
}
else
{
query.Append("WHERE ");
}
query.AppendFormat("tag_name <= '{0}' ", to.ToString("yyyy-MM-dd"));
}
Catalog.NewQuery(query.ToString())
.Execute(delegate(IDataReader dr) {
while (dr.Read())
{
TagBE t = Tags_Populate(dr);
tags.Add(t);
}
});
return(tags);
}
private DekiResourceBuilder CompareTagSets(List <TagBE> current, List <TagBE> proposed, out List <TagBE> added, out List <uint> removed)
{
// perform a subtraction of tags (in both directions) to determine which tags were added and removed from one set to another
added = new List <TagBE>();
removed = new List <uint>();
TagComparer tagComparer = new TagComparer();
current.Sort(tagComparer);
proposed.Sort(tagComparer);
// determine which pages have been added
StringBuilder addedSummary = new StringBuilder();
List <TagBE> addedList = new List <TagBE>();
foreach (TagBE proposedTag in proposed)
{
if ((current.BinarySearch(proposedTag, tagComparer) < 0))
{
// only add the tag if is not already being added
bool includeTag = (added.BinarySearch(proposedTag, tagComparer) < 0);
if (includeTag && (TagType.TEXT == proposedTag.Type))
{
TagBE proposedTagDefine = new TagBE();
proposedTagDefine.Type = TagType.DEFINE;
proposedTagDefine.Name = proposedTag.Name;
if (0 <= proposed.BinarySearch(proposedTagDefine, tagComparer))
{
includeTag = false;
}
}
if (includeTag)
{
added.Add(proposedTag);
if (1 < added.Count)
{
addedSummary.Append(", ");
}
addedSummary.Append(proposedTag.PrefixedName);
}
}
}
// determine which pages have been removed
StringBuilder removedSummary = new StringBuilder();
foreach (TagBE currentTag in current)
{
if (proposed.BinarySearch(currentTag, tagComparer) < 0)
{
removed.Add(currentTag.Id);
if (1 < removed.Count)
{
removedSummary.Append(", ");
}
removedSummary.Append(currentTag.PrefixedName);
}
}
// create a diff summary string
var diffSummary = new DekiResourceBuilder();
if (0 < addedSummary.Length)
{
diffSummary.Append(DekiResources.TAG_ADDED(addedSummary.ToString()));
}
if (0 < removedSummary.Length)
{
if (!diffSummary.IsEmpty)
{
diffSummary.Append(" ");
}
diffSummary.Append(DekiResources.TAG_REMOVED(removedSummary.ToString()));
}
return(diffSummary);
}
