/// <summary>
///分页检索标签
/// </summary>
///<param name="query">查询条件</param>
/// <param name="pageIndex">当前页码</param>
/// <param name="pageSize">每页记录数</param>
/// <returns></returns>
public PagingDataSet <T> GetTags(TagQuery query, int pageIndex, int pageSize)
{
PagingDataSet <T> tags = null;
var sql = PetaPoco.Sql.Builder;
if (!string.IsNullOrEmpty(query.Keyword))
{
//防sql注入
query.Keyword = StringUtility.StripSQLInjection(query.Keyword);
sql.Where("TagName like @0", "%" + query.Keyword + "%");
}
if (query.PubliclyAuditStatus.HasValue)
{
sql.Where("AuditStatus = @0", (int)query.PubliclyAuditStatus);
}
if (!string.IsNullOrEmpty(query.TenantTypeId))
{
sql.Where("TenantTypeId = @0", query.TenantTypeId);
}
if (query.IsFeatured.HasValue)
{
sql.Where("IsFeatured = @0", query.IsFeatured);
}
sql.OrderBy("ItemCount Desc");
tags = GetPagingEntities(pageSize, pageIndex, sql);
return(tags);
}
public async Task <FullQueryResponse <TagQuery, Tag> > SearchTags(TagQuery query)
{
List <Tag> tags = await searchTags(query);
// Return our read-only collection:
return(new FullQueryResponse <TagQuery, Tag>(query, new ReadOnlyCollection <Tag>(tags)));
}
private static void SerializeTagsQuery(XmlWriter xmlWriter, TagQuery tagQuery)
{
xmlWriter.WriteStartElement("TagQuery", "");
if (tagQuery.IsSetMaxKeys())
{
xmlWriter.WriteElementString("MaxKeys", "", S3Transforms.ToXmlStringValue(tagQuery.MaxKeys.Value));
}
xmlWriter.WriteElementString("IncludeTags", "", tagQuery.IncludeTags ? "true" : "false");
if (tagQuery.IsSetContinuationToken())
{
xmlWriter.WriteElementString("ContinuationToken", "", tagQuery.ContinuationToken);
}
xmlWriter.WriteStartElement("And", "");
foreach (TagQueryFilter filter in tagQuery.And)
{
SerializeTagQueryFilter(xmlWriter, filter);
}
xmlWriter.WriteEndElement(); // And
xmlWriter.WriteEndElement(); // TagQuery
}
/// <summary>
/// get a chunk of matches
/// </summary>
/// <param name="searcherName"></param>
/// <param name="tagGroup"></param>
/// <param name="tagName"></param>
/// <param name="sort"></param>
/// <returns></returns>
internal static MatchesResult GetTagMatches(string searcherName, string tagGroup, string tagName, string sort, int skip, int take)
{
var matchesResult = new MatchesResult();
var lookQuery = new LookQuery(searcherName);
var tagQuery = new TagQuery(); // setting a tag query, means only items that have tags will be returned
if (!string.IsNullOrWhiteSpace(tagGroup) && string.IsNullOrWhiteSpace(tagName)) // only have the group to query
{
// TODO: add a new field into the lucene index (would avoid additional query to first look up the tags in this group)
var tagsInGroup = QueryService.GetTags(searcherName, tagGroup).Select(x => x.Key).ToArray();
tagQuery.HasAny = tagsInGroup;
}
else if (!string.IsNullOrWhiteSpace(tagName)) // we have a specifc tag
{
tagQuery.Has = new LookTag(tagGroup, tagName);
}
lookQuery.TagQuery = tagQuery;
QueryService.SetSort(lookQuery, sort);
var lookResult = lookQuery.Search();
matchesResult.TotalItemCount = lookResult.TotalItemCount;
matchesResult.Matches = lookResult
.SkipMatches(skip)
.Take(take)
.Select(x => (MatchesResult.Match)x)
.ToArray();
return(matchesResult);
}
public static void ClassInitialize(TestContext testContext)
{
TestHelper.IndexThings(new Thing[] {
new Thing()
{
Tags = TagQuery.MakeTags("shape:circle", "size:large")
},
new Thing()
{
Tags = TagQuery.MakeTags("shape:circle", "size:medium")
},
new Thing()
{
Tags = TagQuery.MakeTags("shape:circle", "size:small")
},
new Thing()
{
Tags = TagQuery.MakeTags("shape:square", "size:large")
},
new Thing()
{
Tags = TagQuery.MakeTags("shape:square", "size:medium")
},
new Thing()
{
Tags = TagQuery.MakeTags("shape:square", "size:small")
}
});
}
public TagsCleanDocumentsController(IDocumentService documentService, TagQuery tagQuery,
IDataSetSelector dataSetSelector)
{
this.dataSetSelector = dataSetSelector;
this.tagQuery = tagQuery;
this.documentService = documentService;
}
internal override void SetQuery <T>(TagQuery query, T val, bool bypassCheck)
{
TagQueryToken token = null;
if (!bypassCheck)
{
token = query.Next();
if (token != null && !token.Name.Equals(Name))
{
return;
}
}
TagQueryToken nextToken = query.Peek();
if (nextToken != null)
{
NbtTag nextTag = Get(nextToken.Name);
if (nextTag == null)
{
return;
}
nextTag.SetQuery <T>(query, val, false);
Set(nextToken.Name, nextTag);
return;
}
}
public List <string> QueryTag(PicasaWebPhoto photo)
{
List <string> retval = new List <string>();
this.m_tagQuery = new TagQuery(TagQuery.CreatePicasaUri(this.m_userName, this.m_albumName, photo.AccessId));
this.m_tagService = new PicasaService("Tags");
//this.m_tagService.setUserCredentials(this.m_userName, this.m_password);
this.m_tagService.SetAuthenticationToken(this.mUserToken);
CreateTagProxy();
try
{
this.m_tagFeed = this.m_tagService.Query(this.m_tagQuery);
foreach (PicasaEntry entry in m_tagFeed.Entries)
{
retval.Add(entry.Title.Text);
}
}
catch (Exception e)
{
this.m_tagQuery = null;
this.m_tagService.RequestFactory = null;
this.m_tagService = null;
this.m_tagFeed = null;
throw new Exception("Query Tag Exception", e);
}
this.m_tagQuery = null;
this.m_tagService.RequestFactory = null;
this.m_tagService = null;
this.m_tagFeed = null;
return(retval);
}
public void TagQueryHandler_TagQueryNotEmptyDatabase_Array()
{
//given
var repository = LiteDbHelper.CreateMemoryDb();
var handler = new TagQueryHandler(repository);
var query = new TagQuery();
var tags = new[]
{
new Tag {
Name = "tag1"
},
new Tag {
Name = "tag2"
},
new Tag {
Name = "tag3"
},
new Tag {
Name = "tag4"
},
new Tag {
Name = "tag5"
},
};
repository.Database.UpsertBulk(tags);
//when
var result = handler.Execute(query);
//then
Assert.Equal(tags.OrderBy(x => x.Id), result.OrderBy(x => x.Id));
}
internal override T Query <T>(TagQuery query, bool bypassCheck)
{
TagQueryToken token = null;
if (!bypassCheck)
{
token = query.Next();
if (token != null && !token.Name.Equals(Name))
{
return(null);
}
}
TagQueryToken nextToken = query.Peek();
if (nextToken != null)
{
NbtTag nextTag = Get(nextToken.Name);
if (nextTag == null)
{
return(null);
}
return(nextTag.Query <T>(query));
}
return((T)((NbtTag)this));
}
/// <summary>
/// Processes the specified tag query.
/// </summary>
/// <param name="tagQuery">The tag query.</param>
/// <param name="messageContext">The message context.</param>
/// <param name="storeContext">The store context.</param>
/// <returns>TagQueryResult</returns>
internal static TagQueryResult Process(TagQuery tagQuery, MessageContext messageContext, IndexStoreContext storeContext)
{
TagQueryResult tagQueryResult;
string[] tagNames = null;
bool typeExists = false;
try
{
typeExists = storeContext.TagHashCollection.TryGetTagNames(messageContext.TypeId, out tagNames);
tagQueryResult = new TagQueryResult
{
TypeExists = typeExists,
TagNames = tagNames
};
}
catch (Exception ex)
{
tagQueryResult = new TagQueryResult
{
TypeExists = typeExists,
TagNames = tagNames,
ExceptionInfo = ex.Message
};
LoggingUtil.Log.ErrorFormat("TypeId {0} -- Error processing TagQuery : {1}", messageContext.TypeId, ex);
}
return(tagQueryResult);
}
public bool Delete(string name)
{
var xmlResponse = connection.GetXmlDocument(TagQuery.Delete(name));
Console.WriteLine(xmlResponse.ToString());
return(xmlResponse.ToString() == Constant.DELETE_CORRECT_RESPONSE);
}
public bool Rename(string oldName, string newName)
{
var xmlResponse = connection.GetXmlDocument(TagQuery.Rename(oldName, newName));
Console.WriteLine(xmlResponse.ToString());
return(xmlResponse.ToString() == Constant.RENAME_CORRECT_RESPONSE);
}
public void TagQueryConstructorTest()
{
string queryUri = "http://www.google.com/test";
string expected = "http://www.google.com/test?kind=tag";
TagQuery target = new TagQuery(queryUri);
Assert.AreEqual(new Uri(expected), target.Uri);
}
public ActionResult ManageTags(string keyword, string tenantTypeId, bool?isFeatured, AuditStatus?auditStatus = null, int pageIndex = 1, int pageSize = 20)
{
pageResourceManager.InsertTitlePart("标签管理");
TagService tagService = new TagService(tenantTypeId);
PubliclyAuditStatus?publiclyAuditStatus = null;
if (auditStatus != null)
{
publiclyAuditStatus = (PubliclyAuditStatus?)auditStatus;
}
TagQuery tagQuery = new TagQuery();
tagQuery.PubliclyAuditStatus = publiclyAuditStatus;
tagQuery.Keyword = keyword;
tagQuery.TenantTypeId = tenantTypeId;
if (isFeatured.HasValue)
{
tagQuery.IsFeatured = isFeatured.Value;
}
PagingDataSet <Tag> tags = tagService.GetTags(tagQuery, pageIndex, pageSize);
AuthorizationService authorizationService = new AuthorizationService();
//所属下拉框
List <TenantType> tenantTypesList = tenantTypeService.Gets(MultiTenantServiceKeys.Instance().Tag()).ToList <TenantType>();
List <TenantType> newTenantTypesList = new List <TenantType>();
if (UserContext.CurrentUser.IsInRoles(RoleNames.Instance().SuperAdministrator(), RoleNames.Instance().ContentAdministrator()))
{
newTenantTypesList.Insert(0, new TenantType {
ApplicationId = 0, Name = "不限", TenantTypeId = ""
});
newTenantTypesList.AddRange(tenantTypesList);
}
else
{
foreach (var item in tenantTypesList)
{
if (new AuthorizationService().IsApplicationManager(UserContext.CurrentUser, item.ApplicationId))
{
newTenantTypesList.Add(item);
}
}
}
SelectList tenants = new SelectList(newTenantTypesList.Select(n => new { text = n.Name, value = n.TenantTypeId }), "value", "text", tenantTypeId);
ViewData["tenants"] = tenants;
//所属名称
Dictionary <string, string> tenantsDictionary = tenantTypesList.ToDictionary(n => n.TenantTypeId, n => n.Name);
ViewData["tenantsDictionary"] = tenantsDictionary;
return(View(tags));
}
public async Task <IHttpActionResult> Get([FromUri] TagQuery query)
{
var tags = _tagDataService.Query;
if (!string.IsNullOrEmpty(query.SearchText))
{
tags = tags.Where(x => x.Title.Contains(query.SearchText));
}
tags = tags.Where(x => x.SchemeId == query.SchemeId);
return(Ok(((await tags.OrderByDescending(x => x.Title).Take(18).ToListAsync()).MapToViewModel())));
}
public IActionResult Get([FromQuery] TagQuery query)
{
try
{
var tags = _getTags.Execute(query);
return(Ok(tags));
}
catch (NotFoundException)
{
return(NotFound());
}
}
public ReadOnlyCollection <Tag> GetAll()
{
var xmlResponse = connection.GetXmlDocument(TagQuery.All());
var tags = (from tag in xmlResponse.Descendants("tag")
select new Tag
{
Name = tag.Attribute("tag").Value,
Count = Convert.ToInt32(tag.Attribute("count").Value)
}).ToList <Tag>();
return(new ReadOnlyCollection <Tag>(tags));
}
public Task<string[]> GetPriceListsAsync(
string catalog,
string currency,
TagQuery query)
{
var parameters = new { catalog, currency };
return
GetAsync<string[]>(
CreateRequestUri(
String.Format(RelativePaths.PriceLists),
query.GetQueryString(parameters)));
}
public void All_Small_Or_Medium_Circles()
{
var lookQuery = new LookQuery(TestHelper.GetSearchingContext());
lookQuery.TagQuery = new TagQuery();
lookQuery.TagQuery.All = TagQuery.MakeTags("shape:circle");
lookQuery.TagQuery.Any = TagQuery.MakeTags("size:small", "size:medium");
var lookResult = LookService.RunQuery(lookQuery);
Assert.IsTrue(lookResult.Success);
Assert.AreEqual(2, lookResult.TotalItemCount);
}
public void Different_Tags_Second_Empty()
{
var tagQuery1 = new TagQuery()
{
HasAll = TagQuery.MakeTags("tag1")
};
var tagQuery2 = new TagQuery()
{
HasAll = new LookTag[] { }
};
Assert.AreNotEqual(tagQuery1, tagQuery2);
}
public void Same_Tags_Different_Quantity_Alternate()
{
var tagQuery1 = new TagQuery()
{
HasAll = TagQuery.MakeTags("tag1", "tag1")
};
var tagQuery2 = new TagQuery()
{
HasAll = TagQuery.MakeTags("tag1")
};
Assert.AreNotEqual(tagQuery1, tagQuery2);
}
public void Same_Tag_Collection_Of_Collections_Mixed_Up()
{
var tagQuery1 = new TagQuery()
{
HasAnyAnd = new LookTag[][] { TagQuery.MakeTags("tag2", "tag1"), TagQuery.MakeTags("tag3", "tag4") }
};
var tagQuery2 = new TagQuery()
{
HasAnyAnd = new LookTag[][] { TagQuery.MakeTags("tag3", "tag4"), TagQuery.MakeTags("tag1", "tag2") }
};
Assert.AreEqual(tagQuery1, tagQuery2);
}
public void Same_Tag_Collection_Of_Collections_Both_Empty()
{
var tagQuery1 = new TagQuery()
{
HasAnyAnd = new LookTag[][] { }
};
var tagQuery2 = new TagQuery()
{
HasAnyAnd = new LookTag[][] { }
};
Assert.AreEqual(tagQuery1, tagQuery2);
}
public void Different_Tag_Collection_Of_Collections_Second_Empty()
{
var tagQuery1 = new TagQuery()
{
HasAnyAnd = new LookTag[][] { TagQuery.MakeTags("tag1", "tag2") }
};
var tagQuery2 = new TagQuery()
{
HasAnyAnd = new LookTag[][] { }
};
Assert.AreNotEqual(tagQuery1, tagQuery2);
}
public void Different_Tags()
{
var tagQuery1 = new TagQuery()
{
HasAll = TagQuery.MakeTags("tag1", "tag2")
};
var tagQuery2 = new TagQuery()
{
HasAll = TagQuery.MakeTags("tag2", "tag3")
};
Assert.AreNotEqual(tagQuery1, tagQuery2);
}
public void Null_Null()
{
var tagQuery1 = new TagQuery()
{
HasAll = null
};
var tagQuery2 = new TagQuery()
{
HasAll = null
};
Assert.AreEqual(tagQuery1, tagQuery2);
}
public void Same_Tags_Same_Order()
{
var tagQuery1 = new TagQuery()
{
HasAll = TagQuery.MakeTags("tag1", "tag2")
};
var tagQuery2 = new TagQuery()
{
HasAll = TagQuery.MakeTags("tag1", "tag2")
};
Assert.AreEqual(tagQuery1, tagQuery2);
}
public void Null_Tags()
{
var tagQuery1 = new TagQuery()
{
HasAll = null
};
var tagQuery2 = new TagQuery()
{
HasAll = TagQuery.MakeTags("tag1", "tag2")
};
Assert.AreNotEqual(tagQuery1, tagQuery2);
}
public void Same_Tags_Both_Empty()
{
var tagQuery1 = new TagQuery()
{
HasAll = new LookTag[] { }
};
var tagQuery2 = new TagQuery()
{
HasAll = new LookTag[] { }
};
Assert.AreEqual(tagQuery1, tagQuery2);
}
public TagsTableDto GetAll(TagsTableFilterModelDto tagsTableFilter)
{
TagQuery tagQuery = _mapper.Map <TagQuery>(tagsTableFilter);
IPagedList <Tag> tags = _tagApiService.GetTags(tagQuery);
List <TagsTableRowDto> tagsTableRowDtos = _mapper.Map <IEnumerable <Tag>, IEnumerable <TagsTableRowDto> >(tags).ToList();
return(new TagsTableDto
{
TagsTableRows = tagsTableRowDtos,
TotalDisplayedRecords = tags.TotalCount,
TotalRecords = tags.TotalCount
});
}
public Task<ResponseCollection<DynamicContentItemGroup>> GetDynamicContentAsync(string storeId, string[] placeHolders, TagQuery query)
{
var parameters = new { store = storeId, placeHolders = String.Join(",", placeHolders) };
return GetAsync<ResponseCollection<DynamicContentItemGroup>>(
CreateRequestUri(RelativePaths.DynamicContents, query.GetQueryString(parameters)));
}
/// <summary>
/// List items matching the given query
/// </summary>
public Task<ResponseCollection<DynamicContentItemGroup>> GetDynamicContentAsync(string[] placeHolder, TagQuery query)
{
return GetAsync<ResponseCollection<DynamicContentItemGroup>>(CreateRequestUri(String.Format(RelativePaths.Contents, string.Join(",", placeHolder)), query.GetQueryString()));
}
public ActionResult ManageTags(string keyword, string tenantTypeId, bool? isFeatured, AuditStatus? auditStatus = null, int pageIndex = 1, int pageSize = 20)
{
pageResourceManager.InsertTitlePart("标签管理");
TagService tagService = new TagService(tenantTypeId);
PubliclyAuditStatus? publiclyAuditStatus = null;
if (auditStatus != null)
{
publiclyAuditStatus = (PubliclyAuditStatus?)auditStatus;
}
TagQuery tagQuery = new TagQuery();
tagQuery.PubliclyAuditStatus = publiclyAuditStatus;
tagQuery.Keyword = keyword;
tagQuery.TenantTypeId = tenantTypeId;
if (isFeatured.HasValue)
{
tagQuery.IsFeatured = isFeatured.Value;
}
PagingDataSet<Tag> tags = tagService.GetTags(tagQuery, pageIndex, pageSize);
AuthorizationService authorizationService = new AuthorizationService();
//所属下拉框
List<TenantType> tenantTypesList = tenantTypeService.Gets(MultiTenantServiceKeys.Instance().Tag()).ToList<TenantType>();
List<TenantType> newTenantTypesList = new List<TenantType>();
if (UserContext.CurrentUser.IsInRoles(RoleNames.Instance().SuperAdministrator(), RoleNames.Instance().ContentAdministrator()))
{
newTenantTypesList.Insert(0, new TenantType { ApplicationId = 0, Name = "不限", TenantTypeId = "" });
newTenantTypesList.AddRange(tenantTypesList);
}
else
{
foreach (var item in tenantTypesList)
{
if (new AuthorizationService().IsApplicationManager(UserContext.CurrentUser, item.ApplicationId))
{
newTenantTypesList.Add(item);
}
}
}
SelectList tenants = new SelectList(newTenantTypesList.Select(n => new { text = n.Name, value = n.TenantTypeId }), "value", "text", tenantTypeId);
ViewData["tenants"] = tenants;
//所属名称
Dictionary<string, string> tenantsDictionary = tenantTypesList.ToDictionary(n => n.TenantTypeId, n => n.Name);
ViewData["tenantsDictionary"] = tenantsDictionary;
return View(tags);
}
/// <summary>
/// 管理微博话题
/// </summary>
public ActionResult ManageMicroblogTopics(string keyword = "", bool? isFeatured = null, int pageIndex = 1, int pageSize = 30)
{
pageResourceManager.InsertTitlePart("微博话题管理");
TagQuery tagQuery = new TagQuery();
tagQuery.TenantTypeId = TenantTypeIds.Instance().Microblog();
tagQuery.Keyword = keyword;
tagQuery.IsFeatured = isFeatured;
PagingDataSet<Tag> topics = tagService.GetTags(tagQuery, pageIndex, pageSize);
return View(topics);
}
