public List<Tag> BrowseTags()
{
//Cursor = Cursors.WaitCursor;
if (sc == null || !sc.IsConnected()) { this.Connect(); }
//check if the server is already connected, if not skip the execution
if (!(sc == null))
{
if (sc.IsConnected())
{
//build the tags query
var query = new TagQueryParams { PageSize = 100 };
var allTags = new List<Tag>();
List<Tag> tmp;
// return only string tags
query.Criteria.TagnameMask = "*";
query.Criteria.DataType = Proficy.Historian.ClientAccess.API.Tag.NativeDataType.Float;
//execute the query and populate the list datatype
while (sc.ITags.Query(ref query, out tmp))
allTags.AddRange(tmp);
allTags.AddRange(tmp);
//populate the combo box
//cboTags.DataSource = allTags;
//cboTags.DisplayMember = "Name";
//cboTags.ValueMember = "Name";
return allTags;
}
}
return null;
//Cursor = Cursors.Default;
}
public Tag GetTagBySlug(string slug, TagQueryParams queryParams = null)
{
var request = new RestRequest($"tags/slug/{slug}/", Method.GET);
ApplyTagQueryParams(request, queryParams);
return(Execute <TagResponse>(request)?.Tags?.Single());
}
public PartialFindResult <TagForApiContract> GetList(
string query = "",
bool allowChildren = true,
string categoryName = "",
int start = 0, int maxResults = DefaultMax, bool getTotalCount = false,
NameMatchMode nameMatchMode = NameMatchMode.Exact,
TagSortRule?sort = null,
bool preferAccurateMatches = false,
TagOptionalFields fields = TagOptionalFields.None,
ContentLanguagePreference lang = ContentLanguagePreference.Default,
TagTargetTypes target = TagTargetTypes.All)
{
maxResults = Math.Min(maxResults, fields != TagOptionalFields.None ? AbsoluteMax : int.MaxValue);
var queryParams = new TagQueryParams(new CommonSearchParams(TagSearchTextQuery.Create(query, nameMatchMode), false, preferAccurateMatches),
new PagingProperties(start, maxResults, getTotalCount))
{
AllowChildren = allowChildren,
CategoryName = categoryName,
SortRule = sort ?? TagSortRule.Name,
LanguagePreference = lang,
Target = target
};
var tags = _queries.Find(queryParams, fields, lang);
return(tags);
}
public TagResponse GetTags(TagQueryParams queryParams = null)
{
var request = new RestRequest("tags/", Method.GET);
ApplyTagQueryParams(request, queryParams);
return(Execute <TagResponse>(request));
}
public PartialFindResult <T> Find <T>(Func <Tag, T> fac, TagQueryParams queryParams, bool onlyMinimalFields = false)
where T : class
{
return(HandleQuery(ctx => {
var result = new TagSearch(ctx, queryParams.LanguagePreference).Find(queryParams, onlyMinimalFields);
return new PartialFindResult <T>(result.Items.Select(fac).ToArray(), result.TotalCount, queryParams.Common.Query);
}));
}
private static string[] GetTagNames(ServerConnection connection, string tagMask)
{
List <Tag> tags = new List <Tag>();
TagQueryParams tagQuery = new TagQueryParams {
PageSize = 100
};
tagQuery.Criteria.TagnameMask = tagMask;
tagQuery.Categories = Tag.Categories.Basic;
List <Tag> tagPage;
while (connection.ITags.Query(ref tagQuery, out tagPage))
{
tags.AddRange(tagPage);
}
tags.AddRange(tagPage);
return(tags.Select(o => o.Name).ToArray());
}
/// <summary>
/// Applies any specified parameters to the tag request.
/// </summary>
/// <param name="request">A tag REST request.</param>
/// <param name="queryParams">Query parameters.</param>
void ApplyTagQueryParams(RestRequest request, TagQueryParams queryParams)
{
if (queryParams != null)
{
if (queryParams.IncludePostCount)
{
request.AddQueryParameter("include", "count.posts");
}
if (queryParams.Fields != 0)
{
request.AddQueryParameter("fields", Ext.GetQueryStringFromFlagsEnum <TagFields>(queryParams.Fields));
}
if (!string.IsNullOrWhiteSpace(queryParams.Filter))
{
request.AddQueryParameter("filter", queryParams.Filter);
}
if (queryParams.NoLimit)
{
request.AddQueryParameter("limit", "all");
}
else if (queryParams.Limit > 0)
{
request.AddQueryParameter("limit", queryParams.Limit.ToString());
}
if (queryParams.Page > 0)
{
request.AddQueryParameter("page", queryParams.Page.ToString());
}
if (queryParams.Order?.Any() == true)
{
request.AddQueryParameter("order", Ext.GetOrderQueryString(queryParams.Order));
}
}
}
public PartialFindResult <TagForApiContract> Find(TagQueryParams queryParams, TagOptionalFields optionalFields,
ContentLanguagePreference lang)
{
return(Find(tag => new TagForApiContract(
tag, imagePersister, lang, optionalFields), queryParams, optionalFields == TagOptionalFields.None));
}
/// <summary>
/// Get a specific tag based on its slug.
/// </summary>
/// <returns>The tag matching the given slug.</returns>
/// <param name="slug">The slug of the tag to retrieve.</param>
/// <param name="queryParams">Parameters that affect the resultset.</param>
public new Tag GetTagBySlug(string slug, TagQueryParams queryParams = null)
{
return(base.GetTagBySlug(slug, queryParams));
}
/// <summary>
/// Get a specific tag based on its ID.
/// </summary>
/// <returns>The tag matching the given ID.</returns>
/// <param name="id">The ID of the tag to retrieve.</param>
/// <param name="queryParams">Parameters that affect the resultset.</param>
public new Tag GetTagById(string id, TagQueryParams queryParams = null)
{
return(base.GetTagById(id, queryParams));
}
/// <summary>
/// Get a collection of tags,
/// including meta data about pagination so you can retrieve data in chunks.
/// </summary>
/// <returns>The tags.</returns>
/// <param name="queryParams">Parameters that affect which tags are returned.</param>
public new TagResponse GetTags(TagQueryParams queryParams = null)
{
return(base.GetTags(queryParams));
}
private PartialFindResult <Tag> CallFind(TagQueryParams queryParams, bool onlyMinimalFields)
{
return(repository.HandleQuery(ctx => new TagSearch(ctx, ContentLanguagePreference.English).Find(queryParams, onlyMinimalFields)));
}
