/// <summary>
/// Inserts RSSIs in Excel worksheet oSheetDataRSSIs
/// </summary>
/// <param name="metaTagsDic"></param>
/// <param name="readerCounter"></param>
private static void DoExcelInsertRSSIs(ConcurrentDictionary <string, MetaTag> metaTagsDic, int readerCounter)
{
foreach (string epc in metaTagsDic.Keys)
{
MetaTag metaTag = metaTagsDic[epc];
/// Ignores RSSI average if metaTag's rssiQueue isn't full
if (metaTag.RSSIAvg == -1)
{
continue;
}
if (readerCounter == 1)
{
/// R1 obtained RSSIs
UpdateRSSIs(readerCounter, R1EPCsDic, metaTag);
}
else
{
/// R2 obtained RSSIs
UpdateRSSIs(readerCounter, R2EPCsDic, metaTag);
}
}
}
private object CastMetaTagValueToDataType(MetaTag metaTag, string paramValue)
{
try
{
if (metaTag.DataType == "number")
{
double result = 0.0;
Double.TryParse(paramValue, out result);
return(result);
}
if (metaTag.DataType == "datetime")
{
return(DateTime.Parse(paramValue));
}
if (metaTag.DataType == "object")
{
return(JsonConvert.DeserializeObject <dynamic>(paramValue));
}
} catch (Exception e)
{
paramValue = e.ToString();
}
return(paramValue);
}
public MetaTag UpdateMetaTag(MetaTag updatedTag)
{
updatedTag.BlogId = Config.CurrentBlog.Id;
MetaTags.Update(updatedTag);
return(updatedTag);
}
public void CanDeleteEntryMetaTag()
{
var blog = UnitTestHelper.CreateBlogAndSetupContext();
var repository = new DatabaseObjectProvider();
Entry entry =
UnitTestHelper.CreateEntryInstanceForSyndication("Steven Harman", "Sweet arse entry!",
"Giddy, giddy, goo!");
UnitTestHelper.Create(entry);
MetaTag tag = UnitTestHelper.BuildMetaTag("Foo, bar, zaa?", "author", null, blog.Id, entry.Id, DateTime.UtcNow);
repository.Create(tag);
Assert.AreEqual(1, repository.GetMetaTagsForBlog(blog, 0, 100).Count,
"Should be one (1) MetaTag for this blog.");
Assert.AreEqual(1, repository.GetMetaTagsForEntry(entry, 0, 100).Count,
"Should be one (1) MetaTag for this entry.");
// Now let's remove it from the data store
Assert.IsTrue(repository.DeleteMetaTag(tag.Id), "Deleting the MetaTag failed.");
Assert.AreEqual(0, repository.GetMetaTagsForBlog(blog, 0, 100).Count,
"Should be zero (0) MetaTags for this blog.");
Assert.AreEqual(0, repository.GetMetaTagsForEntry(entry, 0, 100).Count,
"Should be zero (0) MetaTag for this entry.");
}
/// <summary>
/// Flushes remaining data to the file and then manually writes JSON tags to close the file out
/// </summary>
internal override async Task FlushWriter()
{
if (!FileCreated)
{
return;
}
if (Queue.Count > 0)
{
await WriteData();
}
var meta = new MetaTag
{
Count = Count,
CollectionMethods = (long)_context.ResolvedCollectionMethods,
DataType = DataType,
Version = DataVersion
};
await _jsonWriter.FlushAsync();
await _jsonWriter.WriteEndArrayAsync();
await _jsonWriter.WritePropertyNameAsync("meta");
await _jsonWriter.WriteRawValueAsync(JsonConvert.SerializeObject(meta, PrettyPrint));
await _jsonWriter.FlushAsync();
await _jsonWriter.CloseAsync();
}
public ActionResult <ItemResponse <MetaTag> > SelectById(int id)
{
ItemResponse <MetaTag> response = null;
ActionResult result = null;
try
{
MetaTag metaTag = _metaDataService.Select(id);
if (metaTag == null)
{
result = NotFound404(new ErrorResponse("You put the wrong id. Nothing exist with that id"));
}
else
{
response = new ItemResponse <MetaTag>();
response.Item = metaTag;
result = Ok200(response);
}
}
catch (Exception ex)
{
Logger.LogError(ex.ToString());
result = StatusCode(500, new ErrorResponse(ex.Message.ToString()));
}
return(result);
}
public static ICollection <MetaTag> BuildMetaTagsFor(Blog blog, Entry entry, int numberOfTags)
{
var tags = new List <MetaTag>(numberOfTags);
int?entryId = null;
if (entry != null)
{
entryId = entry.Id;
}
for (int i = 0; i < numberOfTags; i++)
{
MetaTag aTag = BuildMetaTag(
GenerateUniqueString().Left(50),
// if even, make a name attribute, else http-equiv
(i % 2 == 0) ? GenerateUniqueString().Left(25) : null,
(i % 2 == 1) ? GenerateUniqueString().Left(25) : null,
blog.Id,
entryId,
DateTime.UtcNow);
tags.Add(aTag);
}
return(tags);
}
/// <summary>
/// Finds the exact tag for the input text.
/// Does not perform partial matching or chain parsing.
/// </summary>
/// <param name="tagText">The input text to search for.</param>
/// <returns>The matching tag, or null if not found.</returns>
public MetaTag FindTag(string tagText)
{
string cleaned = MetaTag.CleanTag(tagText);
if (Tags.TryGetValue(cleaned, out MetaTag result))
{
return(result);
}
// TODO: Chain searching
int dotIndex = cleaned.IndexOf('.');
if (dotIndex > 0)
{
string tagBase = cleaned.Substring(0, dotIndex);
string secondarySearch;
if (tagBase == "playertag" || tagBase == "npctag")
{
// TODO: Object meta, to inform of down-typing like this?
secondarySearch = "entitytag" + cleaned.Substring(dotIndex);
}
else if (!tagBase.EndsWith("tag"))
{
secondarySearch = tagBase + "tag" + cleaned.Substring(dotIndex);
}
else
{
return(null);
}
return(FindTag(secondarySearch));
}
return(null);
}
public static string HtmlizeTags(string[] tags, MetaDocs meta)
{
StringBuilder tagOutput = new StringBuilder();
foreach (string tag in tags)
{
string[] parts = tag.Split(' ', 2);
string properName = $"<code>{ScriptHighlighter.ColorArgument(Util.EscapeForHTML(parts[0]), false)}</code>";
if (parts.Length == 2)
{
tagOutput.Append(properName).Append(' ').Append(ParseAndEscape(parts[1]));
}
else
{
MetaTag actualTag = meta.FindTag(parts[0]);
if (actualTag == null)
{
string nameLow = parts[0].ToLowerFast();
tagOutput.Append(Util.EscapeForHTML(parts[0])).Append((nameLow == "none" || nameLow == "todo") ? "" : " ERROR: TAG INVALID");
}
else
{
string desc = ParseAndEscape(actualTag.Description);
if (desc.Contains('\n'))
{
desc = desc.Before('\n') + $" <a href=\"/Docs/Tags/{actualTag.CleanedName}\">(...)</a>";
}
tagOutput.Append($"<a href=\"/Docs/Tags/{actualTag.CleanedName}\">").Append(properName).Append("</a> ").Append(desc);
}
}
tagOutput.Append("\n<br>");
}
return(tagOutput.ToString());
}
public void CanUpdateMetaTag(string content, string name, string httpequiv)
{
var blog = UnitTestHelper.CreateBlogAndSetupContext();
var repository = new DatabaseObjectProvider();
MetaTag tag = UnitTestHelper.BuildMetaTag(content, name, httpequiv, blog.Id, null, DateTime.UtcNow);
repository.Create(tag);
string randomStr = UnitTestHelper.GenerateUniqueString().Left(20);
tag.Content = content + randomStr;
if (!string.IsNullOrEmpty(name))
{
tag.Name = name + randomStr;
}
if (!string.IsNullOrEmpty(httpequiv))
{
tag.HttpEquiv = httpequiv + randomStr;
}
Assert.IsTrue(repository.Update(tag));
MetaTag updTag = repository.GetMetaTagsForBlog(blog, 0, 100)[0];
ValidateMetaTags(tag, updTag);
}
public void MetaTagRequiresContentAttribute(string contentValue, bool isValidResult, string errMsg)
{
var tag = new MetaTag(contentValue);
tag.Name = "description";
Assert.AreEqual(tag.IsValid, isValidResult);
}
public static MetaTag FillWithConfigDefaults(this MetaTag metaTag, Config config)
{
metaTag.Author = config.Metadata.Author;
metaTag.Title = config.Metadata.Title;
metaTag.ImageUrl = config.Metadata.CoverImage;
return(metaTag);
}
public void ShouldContainOneItem()
{
var item = new MetaTag("twitter:description", "some description");
_collection.Add(item);
Assert.NotEmpty(_collection);
}
/// <summary>
/// Tag meta docs user command.
/// </summary>
public void CMD_Tag(string[] cmds, SocketMessage message)
{
List <string> secondarySearches = new List <string>();
if (cmds.Length > 0)
{
cmds[0] = MetaTag.CleanTag(cmds[0]);
int dotIndex = cmds[0].IndexOf('.');
if (dotIndex > 0)
{
string tagBase = cmds[0].Substring(0, dotIndex);
string tagSuffix = cmds[0].Substring(dotIndex);
if (!tagBase.EndsWith("tag"))
{
secondarySearches.Add(tagBase + "tag" + tagSuffix);
}
string tagBaseLow = tagBase.ToLowerFast();
if (tagBaseLow == "player" || tagBaseLow == "npc" || tagBaseLow == "playertag" || tagBaseLow == "npctag")
{
secondarySearches.Add("entitytag" + tagSuffix);
}
secondarySearches.Add("elementtag" + tagSuffix);
}
}
int getDistanceTo(MetaTag tag)
{
int dist1 = StringConversionHelper.GetLevenshteinDistance(cmds[0], tag.CleanedName);
int dist2 = StringConversionHelper.GetLevenshteinDistance(cmds[0], tag.AfterDotCleaned);
int dist = Math.Min(dist1, dist2);
foreach (string secondSearch in secondarySearches)
{
int dist3 = StringConversionHelper.GetLevenshteinDistance(secondSearch, tag.CleanedName);
dist = Math.Min(dist, dist3);
}
return(dist);
}
string findClosestTag()
{
int lowestDistance = 20;
string lowestStr = null;
foreach (MetaTag tag in Program.CurrentMeta.Tags.Values)
{
int currentDistance = getDistanceTo(tag);
if (currentDistance < lowestDistance)
{
lowestDistance = currentDistance;
lowestStr = tag.CleanedName;
}
}
return(lowestStr);
}
AutoMetaCommand(Program.CurrentMeta.Tags, MetaDocs.META_TYPE_TAG, cmds, message, secondarySearches, altFindClosest: findClosestTag,
altMatchOrderer: (list) => list.OrderBy(getDistanceTo).ToList());
}
private static MetaTag CreateMetaTag(RuntimeSettings settings, Link link, string title, string description)
{
var meta = new MetaTag().FillWithConfigDefaults(settings.Configuration);
meta.Title = title;
meta.Url = link.ConvertToLinkOnHost(settings.Configuration.HostName);
meta.Description = description;
return(meta);
}
private string FillMeta(Config configruation)
{
var meta = new MetaTag().FillWithConfigDefaults(configruation);
meta.Title = $"{configruation.Metadata.Title} - {configruation.Translations[Translations.SearchPageTitle]}";
meta.Description = configruation.Translations[Translations.SearchPageTitle];
meta.Url = $"{configruation.HostName}search.html";
return(meta.GetHtmlMeta());
}
public override int Create(MetaTag metaTag)
{
return(_procedures.InsertMetaTag(metaTag.Content,
metaTag.Name.NullIfEmpty(),
metaTag.HttpEquiv.NullIfEmpty(),
BlogId,
metaTag.EntryId,
metaTag.DateCreated));
}
public override bool Update(MetaTag metaTag)
{
return(_procedures.UpdateMetaTag(metaTag.Id,
metaTag.Content,
metaTag.Name.NullIfEmpty(),
metaTag.HttpEquiv.NullIfEmpty(),
BlogId,
metaTag.EntryId));
}
public void Update_WithInvalidMetaTag_ThrowsArgumentException()
{
// arrange
var metaTag = new MetaTag(null);
// act, assert
Assert.IsFalse(metaTag.IsValid);
UnitTestHelper.AssertThrows <ArgumentException>(() => MetaTags.Update(metaTag));
}
protected void lbtn_Script_Edit_Command(object sender, CommandEventArgs e)
{
PageMgr myPageMgr = new PageMgr();
MetaTag myMetaTag = myPageMgr.Get_Page_MetaTag(e.CommandArgument.ToString());
tbx_UpdateScriptURL.Text = myMetaTag.Meta_Src;
btn_UpdateScript.CommandArgument = e.CommandArgument.ToString();
Panel_Update_Script.Visible = true;
}
public void MetaTagRequiresEitherNameOrHttpEquivAttribute(string nameValue, string httpEquivValue,
bool isValidResult, string errMsg)
{
var tag = new MetaTag("Steve rocks it!");
tag.Name = nameValue;
tag.HttpEquiv = httpEquivValue;
Assert.AreEqual(tag.IsValid, isValidResult, errMsg);
}
protected void lbtn_CSS_Edit_Command(object sender, CommandEventArgs e)
{
MasterPageMgr myMasterPageMgr = new MasterPageMgr();
MetaTag myMetaTag = myMasterPageMgr.Get_MasterPage_MetaTag(e.CommandArgument.ToString());
tbx_UpdateCSSURL.Text = myMetaTag.Meta_Src;
btn_UpdateCSS.CommandArgument = e.CommandArgument.ToString();
Panel_Update_CSS.Visible = true;
}
public void Update_WithInvalidMetaTag_ThrowsArgumentException()
{
// arrange
var metaTag = new MetaTag(null);
var repository = new DatabaseObjectProvider();
// act, assert
Assert.IsFalse(metaTag.IsValid);
UnitTestHelper.AssertThrows <ArgumentException>(() => repository.Update(metaTag));
}
public void ShouldNotInsertDuplicateItem()
{
var item = new MetaTag("twitter:description", "some description");
var itemDuplicate = new MetaTag("TWITTER:description", "some description");
_collection.Add(item);
_collection.Add(itemDuplicate);
Assert.Single(_collection);
}
/// <summary>
/// Flushes remaining data to the file and then manually writes JSON tags to close the file out
/// </summary>
internal override async Task FlushWriter()
{
if (Queue.Count > 0)
{
if (!_initialWrite)
{
await _streamWriter.WriteAsync(",");
}
if (_context.Flags.PrettyPrint)
{
await _streamWriter.WriteAsync(string.Join(",", Queue.Select(x => JsonSerializer.PrettyPrint(JsonSerializer.ToJsonString(x)))));
}
else
{
await _streamWriter.WriteAsync(string.Join(",", Queue.Select(JsonSerializer.ToJsonString)));
}
Queue.Clear();
}
if (_context.Flags.PrettyPrint)
{
await _streamWriter.WriteAsync("],\n\"meta\":");
}
else
{
await _streamWriter.WriteAsync(@"],""meta"":");
}
var meta = new MetaTag
{
Count = Count,
CollectionMethods = (long)_context.ResolvedCollectionMethods,
DataType = DataType,
Version = 4
};
if (_context.Flags.PrettyPrint)
{
await _streamWriter.WriteAsync(JsonSerializer.PrettyPrint(JsonSerializer.ToJsonString(meta)));
await _streamWriter.WriteAsync("\n}");
}
else
{
await _streamWriter.WriteAsync(JsonSerializer.ToJsonString(meta));
await _streamWriter.WriteAsync("}");
}
await _streamWriter.FlushAsync();
_streamWriter.Close();
}
public MetaTag AddMetaTagForBlog(string content, string name, string httpEquiv)
{
var newTag = new MetaTag(content)
{
Name = name, HttpEquiv = httpEquiv, BlogId = Config.CurrentBlog.Id, DateCreated = DateTime.Now
};
MetaTags.Create(newTag);
return(newTag);
}
private MetaTag Mapper(IDataReader reader)
{
MetaTag metaTag = new MetaTag();
int startingIndex = 0;
metaTag.Id = reader.GetSafeInt32(startingIndex++);
metaTag.Data = reader.GetSafeString(startingIndex++);
metaTag.MetaTagTypeId = reader.GetSafeInt32(startingIndex++);
metaTag.DateCreated = reader.GetSafeDateTime(startingIndex++);
metaTag.DateModified = reader.GetSafeDateTime(startingIndex++);
return(metaTag);
}
public void ShouldUpdateCorrectly()
{
var item = new MetaTag("twitter:description", "some description");
_collection.Add(item);
var newItem = new[] { new MetaTag("twitter:description", "some description") };
_collection.Update(newItem);
Assert.Single(_collection);
Assert.Equal("twitter:description", _collection.First().Name);
}
private static void InsertNewMetaTag(string content, string nameValue, string httpEquivValue, DateTime created,
int blogId, int?entryId)
{
var metaTag = new MetaTag();
metaTag.Content = content;
metaTag.Name = nameValue;
metaTag.HttpEquiv = httpEquivValue;
metaTag.DateCreated = created;
metaTag.BlogId = blogId;
metaTag.EntryId = entryId;
ObjectProvider.Instance().Create(metaTag);
}
public static MetaTagViewModel Convert(this MetaTag dto)
{
if (dto == null)
{
return(null);
}
return(new MetaTagViewModel
{
Count = dto.Count,
Tag = dto.Tag
});
}
/// <summary>
/// A new Marker associated with a counter control has been created;
/// Increment the counter controls value, and add the metatag to all data structures (including the database)
/// </summary>
/// <param name="myCounter"></param>
/// <param name="mtag"></param>
private void Markers_NewMetaTag(MyCounter myCounter, MetaTag mtag)
{
// Get the Counter Control's contents, increment its value (as we have added a new marker)
// Then update the control's content as well as the database
string counter_data = myCounter.Content;
if (String.IsNullOrWhiteSpace(counter_data)) counter_data = "0";
int count = 0;
try {
count = Convert.ToInt32(counter_data);
}
catch
{
count = 0; // If we can't convert it, assume that someone set the default value to a non-integer in the template, and just revert it to zero.
}
count++;
counter_data = count.ToString();
this.state.isContentValueChangedFromOutside = true;
dbData.UpdateRow(dbData.CurrentId, myCounter.DataLabel, counter_data);
myCounter.Content = counter_data;
state.isContentValueChangedFromOutside = false;
// Find the metatagCounter associated with this particular control so we can add a metatag to it
MetaTagCounter metatagCounter = null;
foreach (MetaTagCounter mtcounter in this.CounterCoords)
{
if (mtcounter.DataLabel == myCounter.Key)
{
metatagCounter = mtcounter;
break;
}
}
// Fill in the metatag information. Also create a TagFinder (which contains a reference to the counter index) and add it as the object's metatag
mtag.Label = myCounter.Label; // The tooltip will be the counter label plus its data label
mtag.Label += "\n" + myCounter.DataLabel;
mtag.Brush = Brushes.Red; // Make it Red (for now)
mtag.DataLabel = myCounter.DataLabel;
mtag.Annotate = true; // Show the annotation as its created. We will clear it on the next refresh
mtag.AnnotationAlreadyShown = false;
// Add the meta tag to the metatag counter
metatagCounter.AddMetaTag(mtag);
// Update this counter's list of points in the marker atabase
String pointlist = "";
foreach (MetaTag mt in metatagCounter.MetaTags)
{
if (! pointlist.Equals ("") ) pointlist += Constants.MARKERBAR; // We don't put a marker bar at the beginning of the point list
pointlist += String.Format("{0:0.000},{1:0.000}", mt.Point.X, mt.Point.Y); // Add a point in the form x,y e.g., 0.5, 0.7
}
this.dbData.MarkerTableAddPoint(myCounter.DataLabel, pointlist);
RefreshTheMarkableCanvasListOfMetaTags(true);
Speak(myCounter.Content + " " + myCounter.Label); // Speak the current count
}
public static MvcHtmlString Meta(this HtmlHelper helper, MetaTag name, object value)
{
return Meta(helper, name.ToString(), value);
}
//Create a metatag with the given point and add it to the metatag list
public MetaTag CreateMetaTag(System.Windows.Point point, string dataLabel)
{
MetaTag mtag = new MetaTag();
mtag.Point = point;
mtag.DataLabel = dataLabel;
this.AddMetaTag(mtag);
return mtag;
}
// Add a MetaTag to the list of MetaTags
public void AddMetaTag(MetaTag mtag)
{
this.MetaTags.Add(mtag);
}
/// <summary>
///
/// </summary>
/// <param name="queue"></param>
/// <param name="tag"></param>
/// <param name="query"></param>
public void RequestQueueFiles(QueueType queue, MetaTag tag, string query)
{
string filter = String.Empty;
List<string> trackList = new List<string>();
bool loop = true;
switch (tag)
{
case MetaTag.artist:
filter = XmlFilter(new[] {"ArtistPeople"}, query, true);
break;
case MetaTag.album:
filter = XmlFilter(new[] {"Album"}, query, true);
break;
case MetaTag.genre:
filter = XmlFilter(new[] {"Genre"}, query, true);
break;
case MetaTag.title:
trackList.Add(System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(query)));
loop = false;
break;
case MetaTag.none:
return;
default:
return;
}
if (trackList.Count == 0)
{
mbApiInterface.Library_QueryFiles(filter);
while (loop)
{
string current = mbApiInterface.Library_QueryGetNextFile();
if (String.IsNullOrEmpty(current)) break;
trackList.Add(current);
}
}
if (queue == QueueType.Next)
{
mbApiInterface.NowPlayingList_QueueFilesNext(trackList.ToArray());
}
else if (queue == QueueType.Last)
{
mbApiInterface.NowPlayingList_QueueFilesLast(trackList.ToArray());
}
else if (queue == QueueType.PlayNow)
{
mbApiInterface.NowPlayingList_Clear();
mbApiInterface.NowPlayingList_QueueFilesLast(trackList.ToArray());
mbApiInterface.NowPlayingList_PlayNow(trackList[0]);
}
}
