/// <summary>
/// Convert a halo 1 sound tag to the halo 2 version
/// </summary>
/// <param name="halo1"></param>
/// <param name="halo2"></param>
/// <returns></returns>
public bool Definitions(
Blam.Halo1.Tags.sound_group halo1,
Tags.sound_group halo2
)
{
return true;
}
/// <summary>
/// Convert a halo 1 collision model to the halo 2 version
/// </summary>
/// <param name="halo1"></param>
/// <param name="halo2"></param>
/// <returns></returns>
public bool Definitions(
Blam.Halo1.Tags.model_collision_group halo1,
Tags.collision_model_group halo2
)
{
return true;
}
/// <summary>
/// Convert a halo 1 render model to the halo 2 version
/// </summary>
/// <param name="halo1"></param>
/// <param name="halo2"></param>
/// <returns></returns>
public bool Definitions(
Blam.Halo1.Tags.gbxmodel_group halo1,
Tags.render_model_group halo2
)
{
return true;
}
/// <summary>
/// Creates new AdvancesSolverSettings.
/// </summary>
/// <param name="baseSettings">Base settings to copy.</param>
/// <param name="totalPoints">Maximum for points spent in the result tree. (>= 0)</param>
/// <param name="initialAttributes">Starting attributes of stats that calculations are based on.</param>
/// <param name="attributeConstraints">The attribute constraints the solver should try to fullfill.</param>
/// <param name="pseudoAttributeConstraints">The pseudo attribute constraints the solver should try to fullfill.</param>
/// <param name="weaponClass">WeaponClass used for pseudo attribute calculation.</param>
/// <param name="tags">Tags used for pseudo attribute calculation.</param>
/// <param name="offHand">OffHand used for pseudo attribute calculation.</param>
public AdvancedSolverSettings(SolverSettings baseSettings,
int totalPoints,
Dictionary<string, float> initialAttributes,
Dictionary<string, Tuple<float, double>> attributeConstraints,
Dictionary<PseudoAttribute, Tuple<float, double>> pseudoAttributeConstraints,
WeaponClass weaponClass, Tags tags, OffHand offHand)
: base(baseSettings)
{
if (totalPoints < 0) throw new ArgumentOutOfRangeException(nameof(totalPoints), totalPoints, "must be >= 0");
TotalPoints = totalPoints;
WeaponClass = weaponClass;
Tags = tags;
OffHand = offHand;
AttributeConstraints = attributeConstraints ?? new Dictionary<string, Tuple<float, double>>();
PseudoAttributeConstraints = pseudoAttributeConstraints ?? new Dictionary<PseudoAttribute, Tuple<float, double>>();
InitialAttributes = initialAttributes ?? new Dictionary<string, float>();
if (AttributeConstraints.Values.Any(tuple => tuple.Item2 < 0 || tuple.Item2 > 1))
throw new ArgumentException("Weights need to be between 0 and 1", "attributeConstraints");
if (AttributeConstraints.Values.Any(t => t.Item1 <= 0))
throw new ArgumentException("Target values need to be greater zero", "attributeConstraints");
if (PseudoAttributeConstraints.Values.Any(tuple => tuple.Item2 < 0 || tuple.Item2 > 1))
throw new ArgumentException("Weights need to be between 0 and 1", "pseudoAttributeConstraints");
if (PseudoAttributeConstraints.Values.Any(t => t.Item1 <= 0))
throw new ArgumentException("Target values need to be greater zero", "pseudoAttributeConstraints");
}
public async Task<IHttpActionResult> PutTags(Guid id, Tags tags)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
if (id != tags.id)
{
return BadRequest();
}
db.Entry(tags).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TagsExists(id))
{
return NotFound();
}
else
{
throw;
}
}
return StatusCode(HttpStatusCode.NoContent);
}
public ScenarioBuilder(string name, string description, Tags tags, FilePosition position)
{
this.title = name;
this.description = description;
this.position = position;
this.tags = tags;
}
/// <inheritdoc />
public Windows8TouchHandler(Tags touchTags, Tags mouseTags, Tags penTags, Func<Vector2, Tags, bool, TouchPoint> beginTouch, Action<int, Vector2> moveTouch, Action<int> endTouch, Action<int> cancelTouch) : base(touchTags, beginTouch, moveTouch, endTouch, cancelTouch)
{
this.mouseTags = mouseTags;
this.touchTags = touchTags;
this.penTags = penTags;
registerWindowProc(wndProcWin8);
}
public void SortBooksByTag(Tags tag)
{
books = storageAdapter.Load();
Comparison<Book> comparison;
switch (tag)
{
case Tags.Title:
comparison = Book.CompareByTitle;
break;
case Tags.Author:
comparison = Book.CompareByAuthor;
break;
case Tags.Year:
comparison = Book.CompareByYear;
break;
case Tags.Languadge:
comparison = Book.CompareByLanguadge;
break;
default:
comparison = Book.CompareByTitle;
break;
}
books.Sort(comparison);
Commit();
}
public Scenario(string keyword, string title, string description, Tags tags, ScenarioSteps scenarioSteps)
{
Keyword = keyword;
Title = title;
Description = description;
Tags = tags;
Steps = scenarioSteps ?? new ScenarioSteps();
}
public Feature(Text title, Tags tags, DescriptionLine[] description, Background background, params Scenario[] scenarios)
{
Tags = tags;
Description = description == null ? string.Empty : string.Join(Environment.NewLine, description.Select(d => d.LineText.Trim()).ToArray());
Background = background;
Scenarios = scenarios;
Title = title.Value;
}
void Awake()
{
_tags = FindObjectOfType<Tags>();
_currencyManager = FindObjectOfType<CurrencyManager>();
_scoreManager = FindObjectOfType<ScoreManager>();
_enemyMovement = FindObjectOfType<EnemyMovement>();
_anim = GetComponent<Animator>();
}
public TagDTO Create(Tags tag)
{
return new TagDTO(){
Url = urlbuilder.Link("GamingStoreRoute", new { id = tag.ID }),
Name = tag.Name
};
}
public Feature(string title, Tags tags, string description, Background background, params Scenario[] scenarios)
{
Tags = tags;
Description = description ?? string.Empty;
Background = background;
Scenarios = scenarios;
Title = title;
}
public ConditionSettings(Tags tags, OffHand offHand, string[] keystones, WeaponClass weaponClass)
{
if (keystones == null) throw new ArgumentNullException("keystones");
Tags = tags;
OffHand = offHand;
Keystones = keystones;
WeaponClass = weaponClass;
}
public ExampleSet(string keyword, string title, string description, Tags tags, GherkinTable table)
{
Keyword = keyword;
Title = title ?? string.Empty;
Description = description ?? "";
Tags = tags;
Table = table;
}
public ExampleBuilder(string keyword, string name, string description, Tags tags, FilePosition position)
{
this.keyword = keyword;
this.name = name;
this.description = description;
this.tags = tags;
this.position = position;
}
public void SetHeader(string keyword, string title, string description, Tags tags, FilePosition position)
{
this.keyword = keyword;
this.title = title;
this.description = description;
this.tags = tags;
this.position = position;
}
/// <summary>
/// Initializes a new instance of the <see cref="TouchHandler" /> class.
/// </summary>
/// <param name="tags">Tags to add to touches.</param>
/// <param name="beginTouch">A function called when a new touch is detected. As <see cref="InputSource.beginTouch" /> this function must accept a Vector2 position of the new touch and return an instance of <see cref="TouchPoint" />.</param>
/// <param name="moveTouch">A function called when a touch is moved. As <see cref="InputSource.moveTouch" /> this function must accept an int id and a Vector2 position.</param>
/// <param name="endTouch">A function called when a touch is lifted off. As <see cref="InputSource.endTouch" /> this function must accept an int id.</param>
/// <param name="cancelTouch">A function called when a touch is cancelled. As <see cref="InputSource.cancelTouch" /> this function must accept an int id.</param>
public TouchHandler(Tags tags, Func<Vector2, Tags, bool, TouchPoint> beginTouch, Action<int, Vector2> moveTouch, Action<int> endTouch, Action<int> cancelTouch)
{
this.tags = tags;
this.beginTouch = beginTouch;
this.moveTouch = moveTouch;
this.endTouch = endTouch;
this.cancelTouch = cancelTouch;
}
/// <summary>
/// Begin touch in given screen position.
/// </summary>
/// <param name="position">Screen position.</param>
/// <param name="tags">Initial tags.</param>
/// <returns>Internal touch id.</returns>
protected virtual ITouch beginTouch(Vector2 position, Tags tags)
{
if (CoordinatesRemapper != null)
{
position = CoordinatesRemapper.Remap(position);
}
return manager.INTERNAL_BeginTouch(position, tags);
}
internal static Tags FromJson(VkResponse response)
{
var tags = new Tags();
tags.Count = response["count"];
return tags;
}
private static Tags instantiate(DataSet ds)
{
Tags t = new Tags();
t.Id = Convert.ToInt16(ds.Tables[0].Rows[0]["id"]);
t.Tag = ds.Tables[0].Rows[0]["tag"].ToString();
return t;
}
/// <summary>
/// Разобрать из json.
/// </summary>
/// <param name="response">Ответ сервера.</param>
/// <returns></returns>
public static Tags FromJson(VkResponse response)
{
var tags = new Tags
{
Count = response["count"]
};
return tags;
}
long GetTagsId(string name, Tags tags) {
long tags_id;
string tags_cache_key = CacheKey(tags);
if (!cache_.Get(tags_cache_key, out tags_id)) {
tags_id = TagsIdFromDatabase(name, tags);
cache_.Set(tags_cache_key, tags_id);
}
return tags_id;
}
public Feature(string keyword, string title, Tags tags, string description, Background background, Scenario[] scenarios, Comment[] comments)
{
Keyword = keyword;
Title = title;
Tags = tags;
Description = description ?? string.Empty;
Background = background;
Scenarios = scenarios;
Comments = comments;
}
public async Task<IHttpActionResult> PostTags(Tags tags)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
db.Tags.Add(tags);
await db.SaveChangesAsync();
return CreatedAtRoute("DefaultApi", new { id = tags.id }, tags);
}
/// <summary>
/// Initializes a new tag manager.
/// </summary>
/// <param name="test">The test class type.</param>
/// <param name="methods">The set of methods to run.</param>
public TagManager(Type test, IEnumerable<ITestMethod> methods)
{
_testClass = test;
_classTags = new Tags();
_methodTags = new Dictionary<ITestMethod, Tags>();
_tagsToMethods = new Dictionary<string, List<ITestMethod>>();
Universe = new List<ITestMethod>(methods);
CreateClassTags(_testClass);
foreach (ITestMethod method in methods)
{
CreateMethodTags(method);
}
}
/// <summary>
/// Initializes a new instance of the TagManager class.
/// </summary>
/// <param name="group">The test group eing filter.</param>
/// <param name="methods">The set of methods to run.</param>
public TagManager(TestGroup group)
{
_group = group;
_groupTags = new Tags();
_methodTags = new Dictionary<TestMethod, Tags>();
_tagsToMethods = new Dictionary<string, List<TestMethod>>();
Universe = new List<TestMethod>(group.Methods);
CreateClassTags(_group);
foreach (TestMethod method in group.Methods)
{
CreateMethodTags(method);
}
}
private void BufferMeshResources(Tags.BSP.StructureBspClusterDataBlockNew[] structureBspClusterDataBlockNew)
{
if (structureBspClusterDataBlockNew.Length > 0)
{
mVBO_ids = new List<int>();
mVAO_id = GL.GenVertexArray();
GL.BindVertexArray(mVAO_id);
BufferElementArrayData(structureBspClusterDataBlockNew[0].section.stripIndices.Select(x => x.index).ToArray());
BufferVertexAttributeData(structureBspClusterDataBlockNew[0].section.vertexBuffers.Select(x => x.vertexBuffer).ToArray());
GL.BindVertexArray(0);
}
}
/// <summary>
/// Add a tag to this gameobject if it does not already exist. Also add the tagger component to the gameobject if it doesn't exist
/// </summary>
/// <param name="go">The game object</param>
/// <returns>A list of tags</returns>
public static void AddTag(this GameObject go, Tags tag)
{
var tagger = go.GetComponent<TagFrenzyList>();
if (tagger == null)
{
tagger = go.AddComponent<TagFrenzyList>();
}
//Make sure no deleted tags are hanging around before we add new ones
tagger.CleanupDeletedTags();
if (!tagger.SelectedEditorTags.Where(t => t.Tag == tag.ToString()).Any())
{
EditorTag et = MultiTagManager.EditorTags.Where(t => t.Tag == tag.ToString()).FirstOrDefault();
tagger.SelectedEditorTags.Add(et);
}
}
/// <summary>
/// Reads a tag in a media <paramref name="file"/>.
/// </summary>
/// <returns>Found value or <c>null</c> if not found.</returns>
/// <param name="file">Media full path file name.</param>
/// <param name="tag">Tag to find.</param>
public async Task<object> ReadTagAsync(string file, Tags tag)
{
if ((tag & (tag - 1)) != 0)
throw new NotSupportedException(string.Format("When writing a tag, you can only specify one tag, but was '{0}'.", tag));
if (tag == Tags.None)
throw new NotSupportedException("At least, you must specify a tag.");
var tags = await ReadTagsAsync(file, tag);
object value;
if (tags.TryGetValue(tag, out value))
{
Log.T("Found value '{0}' for tag '{1}'.", value, tag);
return value;
}
Log.T("No value found for tag '{0}'.", tag);
return null;
}
internal void EditListing()
{
//Clicking on the "Manage Listing" tab
MgmtListTab.Click();
//Clicking on the "Edit Icon"
Thread.Sleep(2000);
EditIcon.Click();
Thread.Sleep(2000);
//Populate the Excel Sheet
GlobalDefinitions.ExcelLib.PopulateInCollection(Base.ExcelPath, "EditListing");
//Edit the Title
Title.Clear();
Thread.Sleep(500);
Title.SendKeys(GlobalDefinitions.ExcelLib.ReadData(2, "Title"));
Base.test.Log(LogStatus.Pass, "Title has succesfully been edited");
//Edit the Description
Description.Clear();
Thread.Sleep(500);
Description.SendKeys(GlobalDefinitions.ExcelLib.ReadData(2, "Description"));
Base.test.Log(LogStatus.Pass, "Description has succesfully been edited");
//Select a category from dropdown
GlobalDefinitions.wait(2);
Actions action = new Actions(GlobalDefinitions.driver);
action.MoveToElement(category).Build().Perform();
Thread.Sleep(1000);
IList <IWebElement> Categorylist = category.FindElements(By.TagName("option"));
int count = Categorylist.Count;
Thread.Sleep(1500);
for (int i = 1; i < count; i++)
{
if (Categorylist[i].Text == ExcelLib.ReadData(2, "category").Trim())
{
Thread.Sleep(500);
Categorylist[i].Click();
Thread.Sleep(500);
Base.test.Log(LogStatus.Info, "Category has succesfully been edited");
}
}
//Edit the Subcategory
Thread.Sleep(2000);
action.MoveToElement(Subcategory).Build().Perform();
Thread.Sleep(1000);
IList <IWebElement> SubCat = Subcategory.FindElements(By.TagName("option"));
int SubCatCount = SubCat.Count;
for (int i = 0; i < SubCatCount; i++)
{
if (SubCat[i].Text == GlobalDefinitions.ExcelLib.ReadData(2, "Subcategory"))
{
SubCat[i].Click();
Base.test.Log(LogStatus.Pass, "Subcategory has succesfully been edited");
}
}
//Edit the Tags
Tags.SendKeys(GlobalDefinitions.ExcelLib.ReadData(2, "Tags"));
Thread.Sleep(1000);
Tags.SendKeys(Keys.Enter);
Base.test.Log(LogStatus.Pass, "Tag has succesfully been edited");
//Edit the Service Type-----------------------
// Storing all the elements under category of 'Service Type' in the list of WebLements
IList <IWebElement> AllRadioButtons = ServiceListingSection.FindElements(By.XPath("//input[@type='radio'][@name='serviceType']"));
//Indicating the number of buttons present
int Size = AllRadioButtons.Count;
//Starting the loop from the first radio button to the last radio button of Service Type
for (int i = 0; i < Size; i++)
{
//Storing the radio button to the string variable "Value", using the "value" attribute
string Value = AllRadioButtons.ElementAt(i).GetAttribute("value");
int j = i + 1;
var Name = GlobalDefinitions.driver.FindElement(By.XPath("//*[@id='service-listing-section']/div[2]/div/form/div[5]/div[2]/div[1]/div[" + j + "]/div/label")).Text;
//Checking if Name equals the "name" attribute - "locationType"
if (Name.Equals(ExcelLib.ReadData(2, "ServiceType")) && Value.Equals("" + i))
{
AllRadioButtons.ElementAt(i).Click();
Base.test.Log(LogStatus.Pass, "Service Type has succesfully been edited");
}
}
//Editing the Location Type
IList <IWebElement> AllTypes = ServiceListingSection.FindElements(By.XPath("//input[@type='radio'][@name='locationType']"));
int Types = AllTypes.Count;
for (int i = 0; i < Types; i++)
{
string Type = AllTypes.ElementAt(i).GetAttribute("value");
int k = i + 1;
var Name = GlobalDefinitions.driver.FindElement(By.XPath("//*[@id='service-listing-section']//div[2]/div/form/div[6]/div[2]/div/div[" + k + "]/div/label")).Text;
//Checking if Name equals the "name" attribute - "locationType"
if (Name.Equals(ExcelLib.ReadData(2, "LocationType")) && Type.Equals("" + i))
{
AllTypes.ElementAt(i).Click();
Base.test.Log(LogStatus.Pass, "Location Type has succesfully been edited");
}
}
// Editing Available Days -Start Date
Thread.Sleep(1000);
StartDate.SendKeys(Keys.Delete);
Thread.Sleep(500);
StartDate.SendKeys("25/04/2019");
Thread.Sleep(500);
StartDate.SendKeys(Keys.Tab);
Base.test.Log(LogStatus.Pass, "Start Date has succesfully been edited");
//Editing Available Days - End Date
Thread.Sleep(1000);
EndDate.SendKeys(Keys.Delete);
Thread.Sleep(500);
EndDate.SendKeys("24/12/2020");
//EndDate.SendKeys(ExcelLib.ReadData(2, "EndDate"));
Thread.Sleep(500);
EndDate.SendKeys(Keys.Tab);
Base.test.Log(LogStatus.Pass, "End Date has succesfully been edited");
//Editing Day
Day.Click();
//Editing Start Hour
StartHours.SendKeys(GlobalDefinitions.ExcelLib.ReadData(2, "StartHour"));
//Editing End Hour
GlobalDefinitions.wait(5);
EndHours.SendKeys(GlobalDefinitions.ExcelLib.ReadData(2, "EndHour"));
//Editing Skill Trade radio button
IList <IWebElement> OneSelection = ServiceListingSection.FindElements(By.XPath("//input[@type='radio'][@name='skillTrades']"));
bool aValue = false;
aValue = OneSelection.ElementAtOrDefault(0).Selected;
if (aValue == true)
{
OneSelection.ElementAt(1).Click();
Thread.Sleep(1500);
Credit.SendKeys(GlobalDefinitions.ExcelLib.ReadData(2, "Credit"));
Base.test.Log(LogStatus.Pass, "Skill Trade has succesfully been edited");
}
else
{
OneSelection.ElementAt(0).Click();
Thread.Sleep(1500);
SkillExchange.SendKeys(GlobalDefinitions.ExcelLib.ReadData(2, "SkillExchange"));
Base.test.Log(LogStatus.Pass, "Skill Trade has not been edited");
}
//Editing "Active" button - whether enable or disable service
IList <IWebElement> OneRadioButton = ServiceListingSection.FindElements(By.XPath("//input[@type='radio'][@name='isActive']"));
bool bValue = false;
bValue = OneRadioButton.ElementAtOrDefault(0).Selected;
if (bValue == true)
{
OneRadioButton.ElementAt(1).Click();
}
else
{
OneRadioButton.ElementAt(0).Click();
}
Thread.Sleep(3000);
string ActualValue = GlobalDefinitions.ExcelLib.ReadData(2, "Active Service");
Thread.Sleep(3000);
string ExpectedValue = "Hidden";
if (ExpectedValue.Trim().Equals(ActualValue.Trim()))
//if (ExpectedValue == ActualValue)
{
Base.test.Log(LogStatus.Pass, "Service is disabled");
}
else
{
Base.test.Log(LogStatus.Fail, "Service is enabled");
}
//Clicking on Save Button
SaveButton.Click();
Base.test.Log(LogStatus.Pass, "Listing has successfully been edited");
//Check if the edited skill is present in the Manage Listings
try
{
GlobalDefinitions.wait(2);
string ExpectedTitle = ExcelLib.ReadData(2, "Title");
string BeforeXPath = "//div[@id='listing-management-section']/div[2]/div/table/tbody/tr[";
Thread.Sleep(2000);
string AfterXpath = "]/td[3]";
for (int i = 1; i <= 5; i++)
{
GlobalDefinitions.wait(2);
string ColElements = driver.FindElement(By.XPath(BeforeXPath + i + AfterXpath)).Text;
if (ColElements.Contains(ExpectedTitle))
{
Base.test.Log(RelevantCodes.ExtentReports.LogStatus.Pass, "Edited Listing is displayed on the Listing Service page ");
string screenshotpath = SaveScreenShotClass.SaveScreenshot(GlobalDefinitions.driver, "Edited Listing is displayed on the Listing Service page");
Base.test.Log(RelevantCodes.ExtentReports.LogStatus.Pass, "Snapshot below:" + Base.test.AddBase64ScreenCapture(screenshotpath));
break;
}
else
{
Base.test.Log(RelevantCodes.ExtentReports.LogStatus.Fail, "Edited Listing is not displayed on the Listing Service page ");
string screenshotpath = SaveScreenShotClass.SaveScreenshot(GlobalDefinitions.driver, "Edited Listing is not displayed on the Listing Service page");
Base.test.Log(RelevantCodes.ExtentReports.LogStatus.Fail, "Snapshot below:" + Base.test.AddBase64ScreenCapture(screenshotpath));
}
}
}
catch (Exception e)
{
Base.test.Log(RelevantCodes.ExtentReports.LogStatus.Fail, "Error while displaying the edited listing" + e.Message);
string screenshotpath = SaveScreenShotClass.SaveScreenshot(GlobalDefinitions.driver, "Error, the listing has not been edited");
Base.test.Log(RelevantCodes.ExtentReports.LogStatus.Fail, "Snapshot below:" + Base.test.AddBase64ScreenCapture(screenshotpath));
}
}
private bool CheckIfContainsTaggedPost(IList <string> tags)
{
return(!Tags.Any() || tags.Any(x => Tags.Contains(x, StringComparer.OrdinalIgnoreCase)));
}
public static string GetTag(Tags tag) => _tags[tag];
public TagsTest()
{
Tags.Initialize();
}
public override async Task OnNavigatedToAsync(object parameter, NavigationMode mode, IDictionary <string, object> state)
{
var log = await ApplicationData.Current.LocalFolder.TryGetItemAsync("tdlib_log.txt") as StorageFile;
if (log != null)
{
var basic = await log.GetBasicPropertiesAsync();
LogSize = basic.Size;
}
var logOld = await ApplicationData.Current.LocalFolder.TryGetItemAsync("tdlib_log.txt.old") as StorageFile;
if (logOld != null)
{
var basic = await logOld.GetBasicPropertiesAsync();
LogOldSize = basic.Size;
}
var properties = typeof(IOptionsService).GetProperties();
foreach (var prop in properties)
{
if (string.Equals(prop.Name, "Values", StringComparison.OrdinalIgnoreCase))
{
continue;
}
var value = prop.GetValue(CacheService.Options);
if (value == null)
{
continue;
}
else if (value.Equals(true))
{
value = "true";
}
else if (value.Equals(false))
{
value = "false";
}
Options.Add(new DiagnosticsOption {
Name = prop.Name, Value = value
});
}
foreach (var item in CacheService.Options.Values)
{
var value = default(object);
if (item.Value is OptionValueBoolean boolean)
{
value = boolean.Value ? "true" : "false";
}
else if (item.Value is OptionValueInteger integer)
{
value = integer.Value;
}
else if (item.Value is OptionValueString strong)
{
value = strong.Value;
}
Options.Add(new DiagnosticsOption {
Name = item.Key, Value = value
});
}
var tags = Client.Execute(new GetLogTags()) as LogTags;
if (tags != null)
{
Tags.ReplaceWith(tags.Tags.Select(x => new DiagnosticsTag
{
Name = x,
Default = ((LogVerbosityLevel)Client.Execute(new GetLogTagVerbosityLevel(x))).VerbosityLevel,
Value = (VerbosityLevel)Settings.Diagnostics.GetValueOrDefault(x, -1)
}));
}
}
/// <summary>
/// Adds a new tag to this account. This method does not check for duplicate names.
/// </summary>
/// <param name="name">New tag name.</param>
/// <param name="value">New tag value.</param>
public void AddTag(string name, string value)
{
Tags.Add(new AccountTag(name, value));
}
public BlockControl(BlockField blockField) : this()
{
Tags.GenerateControls(controlsFlowLayoutPanel, blockField.Create());
titleLabel.Text = blockField.Name;
Field = blockField;
}
public bool HasTag(SubmarineTag tag)
{
return(Tags.HasFlag(tag));
}
/// <summary>
/// Get the tag type from it's name
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public static Type GetTagType(string name)
{
Tags.TryGetValue(name, out Tuple <ITagFactory, Type> result);
return(result.Item2);
}
public void ClearTags()
{
Tags.Clear();
}
protected WebApi()
{
Tags = new Tags();
}
private void Initialize(ComponentManager manager)
{
Tags.Add("Chair");
CollisionType = CollisionManager.CollisionType.Static;
}
internal void editShareskill()
{
GlobalDefinitions.ExcelLib.PopulateInCollection(Base.ExcelPath, "Service Data");
GlobalDefinitions.wait(1000);
//Enter Title
Title.SendKeys(GlobalDefinitions.ExcelLib.ReadData(2, "Title"));
//Enter Description
Description.SendKeys(GlobalDefinitions.ExcelLib.ReadData(2, "Description"));
//Select Category
SelectElement catg = new SelectElement(CategoryDropDown);
GlobalDefinitions.wait(1000);
catg.SelectByText(GlobalDefinitions.ExcelLib.ReadData(2, "Category"));
//Select Subcategory
OpenQA.Selenium.Support.UI.SelectElement subcatg = new SelectElement(SubCategoryDropDown);
GlobalDefinitions.wait(1000);
subcatg.SelectByText(GlobalDefinitions.ExcelLib.ReadData(2, "Sub Category"));
//Tags
GlobalDefinitions.wait(1000);
Tags.Click();
GlobalDefinitions.wait(1000);
Tags.SendKeys("FirstTag" + "\n");
//Select Service Type from radio buttons
OneOffServiceType.Click();
//Select Location Type radio button
onlineLocationType.Click();
//Select Available days and Time
//select startdate
StartDate.Click();
GlobalDefinitions.wait(1000);
StartDate.SendKeys("25062020");
//Select end date
EndDate.Click();
GlobalDefinitions.wait(1000);
EndDate.SendKeys("25072020");
//Select Monday
MondayCheckbox.Click();
//Select start time for Monday
MondayStartTime.Click();
GlobalDefinitions.wait(1000);
MondayStartTime.SendKeys("0930am");
GlobalDefinitions.wait(1000);
//Select end time for Monday
MondayendTime.Click();
GlobalDefinitions.wait(1000);
MondayendTime.SendKeys("0530pm");
GlobalDefinitions.wait(1000);
//Select Skill Trade radio button
Creditradiobutton.Click();
GlobalDefinitions.wait(1000);
GlobalDefinitions.wait(1000);
SkillExchangeTags.Click();
GlobalDefinitions.wait(1000);
SkillExchangeTags.SendKeys("FirstSTag" + "\n");
//Select Active radio button
ActiveRadiobutton.Click();
//Save the data
GlobalDefinitions.wait(1000);
Savebutton.Click();
GlobalDefinitions.wait(1000);
}
public NodeView UpdateFilter(string query, INode2 startNode, bool openModules)
{
// Parse query
Tags = ParseQuery(query);
// Set filter scope
if (Tags.Contains("<"))
{
MinLevel = int.MinValue;
MaxLevel = int.MaxValue;
Tags.Remove("<");
}
else if (Tags.Contains(">"))
{
MinLevel = 0;
MaxLevel = int.MaxValue;
Tags.Remove(">");
}
else
{
MinLevel = 0;
MaxLevel = 1;
}
// Set filter flags which control what to search
Flags = FilterFlags.None;
if (Tags.Contains("s"))
{
Flags |= FilterFlags.Send;
Flags |= FilterFlags.Receive;
Tags.Remove("s");
}
if (Tags.Contains("/"))
{
Flags |= FilterFlags.Comment;
Tags.Remove("/");
}
if (Tags.Contains("x"))
{
Flags |= FilterFlags.Effect;
Tags.Remove("x");
}
if (Tags.Contains("f"))
{
Flags |= FilterFlags.Freeframe;
Tags.Remove("f");
}
if (Tags.Contains("m"))
{
Flags |= FilterFlags.Module;
Tags.Remove("m");
}
if (Tags.Contains("p"))
{
Flags |= FilterFlags.Plugin;
Tags.Remove("p");
}
if (Tags.Contains("d"))
{
Flags |= FilterFlags.Dynamic;
Tags.Remove("d");
}
if (Tags.Contains("l"))
{
Flags |= FilterFlags.VL;
Tags.Remove("l");
}
if (Tags.Contains("i"))
{
Flags |= FilterFlags.IONode;
Tags.Remove("i");
}
if (Tags.Contains("e"))
{
Flags |= FilterFlags.Exposed;
Tags.Remove("e");
}
if (Tags.Contains("n"))
{
Flags |= FilterFlags.Native;
Tags.Remove("n");
}
if (Tags.Contains("a"))
{
Flags |= FilterFlags.VST;
Tags.Remove("a");
}
if (Tags.Contains("t"))
{
Flags |= FilterFlags.Patch;
Tags.Remove("t");
}
if (Tags.Contains("r"))
{
Flags |= FilterFlags.Unknown;
Tags.Remove("r");
}
if (Tags.Contains("v"))
{
Flags |= FilterFlags.VL;
Tags.Remove("v");
}
if (Tags.Contains("b"))
{
Flags |= FilterFlags.Boygrouped;
Tags.Remove("b");
}
if (Tags.Contains("w"))
{
Flags |= FilterFlags.Window;
Tags.Remove("w");
}
// If nothing set look for all kind of nodes
if (Flags == FilterFlags.None)
{
Flags = FilterFlags.AllNodeTypes;
}
// Set filter tags which control where to search
var wFlags = FilterFlags.None;
if (Tags.Contains("l"))
{
wFlags |= FilterFlags.Label;
Tags.Remove("l");
}
if (Tags.Contains("#"))
{
wFlags |= FilterFlags.ID;
Tags.Remove("#");
}
// If nothing set search in node name
if (wFlags == FilterFlags.None)
{
wFlags = FilterFlags.Name;
}
Flags |= wFlags;
// Set filter tags
for (int i = 0; i < Tags.Count; i++)
{
Tags[i] = Tags[i].Trim((char)160);
}
return(new NodeView(null, startNode, this, 0, openModules));
}
TagNode ParseTagStart(string input, ref int pos)
{
var end = pos;
if (!ParseChar(input, ref end, '['))
{
return(null);
}
var tagName = ParseName(input, ref end);
if (tagName is null)
{
return(null);
}
var tag = Tags.SingleOrDefault(t => t.Name.Equals(tagName, StringComparison.OrdinalIgnoreCase));
if (tag is null && ErrorOrReturn("UnknownTag", tagName))
{
return(null);
}
var result = new TagNode(tag);
var defaultAttrValue = ParseAttributeValue(input, ref end);
if (defaultAttrValue != null)
{
var attr = tag.FindAttribute(string.Empty);
if (attr is null && ErrorOrReturn("UnknownAttribute", tag.Name, "\"Default Attribute\""))
{
return(null);
}
result.AttributeValues.Add(attr, defaultAttrValue);
}
while (true)
{
ParseWhitespace(input, ref end);
var attrName = ParseName(input, ref end);
if (attrName is null)
{
break;
}
var attrVal = ParseAttributeValue(input, ref end);
if (attrVal is null && ErrorOrReturn(string.Empty))
{
return(null);
}
if (tag.Attributes is null && ErrorOrReturn("UnknownTag", tag.Name))
{
return(null);
}
var attr = tag.FindAttribute(attrName);
if (attr is null && ErrorOrReturn("UnknownTag", tag.Name, attrName))
{
return(null);
}
if (result.AttributeValues.ContainsKey(attr) && ErrorOrReturn("DuplicateAttribute", tagName, attrName))
{
return(null);
}
result.AttributeValues.Add(attr, attrVal);
}
if (!ParseChar(input, ref end, ']') && ErrorOrReturn("TagNotClosed", tagName))
{
return(null);
}
pos = end;
return(result);
}
public string GetTag(string attrName)
{
return(Tags != null && Tags.TryGetValue(attrName, out var value) ? value : null);
}
public TestServiceInfoFactory(Tags tags, string[] schemes)
: base(tags, schemes)
{
}
/// <inheritdoc />
public override string ToString()
{
var str = base.ToString();
if (Id != 0)
{
str += $",Id={Id}";
}
if (!Name.IsEmpty())
{
str += $",Name={Name}";
}
if (!Description.IsEmpty())
{
str += $",Descr={Description}";
}
if (!PackageId.IsEmpty())
{
str += $",PackageId={PackageId},Repo={Repository}";
}
if (!Tags.IsEmpty())
{
str += $",Tags={Tags}";
}
if (Author != 0)
{
str += $",Author={Author}";
}
if (Price != null)
{
str += $",Price={Price}";
}
if (RenewPrice != null)
{
str += $",Renew={RenewPrice}";
}
str += $",Downloads={DownloadCount}";
if (Rating != null)
{
str += $",Rating={Rating}";
}
if (!DocUrl.IsEmpty())
{
str += $",Doc={DocUrl}";
}
if (Picture != default)
{
str += $",Picture={Picture}";
}
str += $",Content={ContentType}";
if (SupportedPlugins != null)
{
str += $",Supported={SupportedPlugins.Value}";
}
if (!Extra.IsEmpty())
{
str += $",Extra={Extra}";
}
if (!LatestVersion.IsEmpty())
{
str += $",Ver={LatestVersion}";
}
if (!IsApproved)
{
str += $",Approved={IsApproved}";
}
return(str);
}
public static ConfirmedServiceAck Load(IValueStream stream)
{
ConfirmedServiceAck ret = null;
Tags tag = (Tags)stream.EnterChoice();
switch (tag)
{
case Tags.GetAlarmSummary:
ret = Value <GetAlarmSummaryWrapper> .Load(stream);
break;
case Tags.GetEnrollmentSummary:
ret = Value <GetEnrollmentSummaryWrapper> .Load(stream);
break;
case Tags.GetEventInformation:
ret = Value <GetEventInformationWrapper> .Load(stream);
break;
case Tags.AtomicReadFile:
ret = Value <AtomicReadFileWrapper> .Load(stream);
break;
case Tags.AtomicWriteFile:
ret = Value <AtomicWriteFileWrapper> .Load(stream);
break;
case Tags.CreateObject:
ret = Value <CreateObjectWrapper> .Load(stream);
break;
case Tags.ReadProperty:
ret = Value <ReadPropertyWrapper> .Load(stream);
break;
case Tags.ReadPropertyConditional:
ret = Value <ReadPropertyConditionalWrapper> .Load(stream);
break;
case Tags.ReadPropertyMultiple:
ret = Value <ReadPropertyMultipleWrapper> .Load(stream);
break;
case Tags.ReadRange:
ret = Value <ReadRangeWrapper> .Load(stream);
break;
case Tags.ConfirmedPrivateTransfer:
ret = Value <ConfirmedPrivateTransferWrapper> .Load(stream);
break;
case Tags.VtOpen:
ret = Value <VtOpenWrapper> .Load(stream);
break;
case Tags.VtData:
ret = Value <VtDataWrapper> .Load(stream);
break;
case Tags.Authenticate:
ret = Value <AuthenticateWrapper> .Load(stream);
break;
default:
throw new Exception();
}
stream.LeaveChoice();
return(ret);
}
public Tags Add(Tags tag)
{
context.Tags.Add(tag);
context.SaveChanges();
return(tag);
}
public void AddTagRange(List <string> tags)
{
Tags.AddRange(tags);
}
private bool CheckIfContainsTaggedPost(Post post)
{
return(!Tags.Any() || post.Tags.Any(x => Tags.Contains(x, StringComparer.OrdinalIgnoreCase)));
}
public bool HasTag(string attrName)
{
return(Tags != null && Tags.ContainsKey(attrName));
}
public void ConvertToInfluxLineProtocol(StringBuilder line)
{
if (Fields.Count == 0)
{
throw new InvalidOperationException("InfluxDB needs atleast one field in a line");
}
if (String.IsNullOrWhiteSpace(MeasurementName))
{
throw new InvalidOperationException("InfluxDB needs a measurement name to accept a point");
}
line.AppendFormat("{0}", MeasurementName.EscapeChars(comma: true, space: true));
if (Tags.Count > 0)
{
Tags.ToList().ForEach(t =>
{
line.AppendFormat(",{0}={1}", t.Key.EscapeChars(comma: true, equalSign: true, space: true), t.Value.EscapeChars(comma: true, equalSign: true, space: true));
});
}
var tType = typeof(T);
string fields;
line.Append(" ");
if (tType == typeof(string))
{
//string needs escaping, but = is allowed in value
Fields.ToList().ForEach(v =>
{
line.AppendFormat("{0}=\"{1}\",", v.Key.EscapeChars(comma: true, equalSign: true, space: true), v.Value.ToString().EscapeChars(doubleQuote: true));
});
line.Remove(line.Length - 1, 1);
}
else if (tType == typeof(long) || tType == typeof(int))
{
//int needs i suffix
Fields.ToList().ForEach(v =>
{
line.AppendFormat("{0}={1}i,", v.Key.EscapeChars(comma: true, equalSign: true, space: true), v.Value);
});
line.Remove(line.Length - 1, 1);
}
else if (tType == typeof(bool))
{
//bool is okay with True or False
Fields.ToList().ForEach(v =>
{
line.AppendFormat("{0}={1},", v.Key.EscapeChars(comma: true, equalSign: true, space: true), v.Value);
});
line.Remove(line.Length - 1, 1);
}
else if (tType == typeof(double))
{
//double has to have a . as decimal seperator for Influx
Fields.ToList().ForEach(v =>
{
line.AppendFormat("{0}={1},", v.Key.EscapeChars(comma: true, equalSign: true, space: true), String.Format(CultureInfo.GetCultureInfo("en-US"), "{0}", v.Value));
});
line.Remove(line.Length - 1, 1);
}
else if (typeof(IInfluxValueField).IsAssignableFrom(tType))
{
//fields = String.Join(",", Fields.Select(v => new StringBuilder().AppendFormat("{0}={1}", v.Key.EscapeChars(comma: true, equalSign: true, space: true), v.Value.ToString())));
Fields.ToList().ForEach(v =>
{
line.AppendFormat("{0}={1},", v.Key.EscapeChars(comma: true, equalSign: true, space: true), v.Value.ToString());
});
line.Remove(line.Length - 1, 1);
}
else
{
throw new ArgumentException(tType + " is not supported by this library at this point");
}
line.AppendFormat(" {0}", UtcTimestamp != DateTime.MinValue ? UtcTimestamp.ToEpoch(Precision) : DateTime.UtcNow.ToEpoch(Precision));
}
public APIRst GetBatchRealVal(Tags tags)
{
return(infoHelper.GetBatchRealVal(tags.list));
}
public void CanComputeWeight(double factor, double stdDev, int expected)
{
Assert.AreEqual(expected, Tags.ComputeWeight(factor, stdDev));
}
public bool IsSatisfiedBy(Tags item)
{
return(true);
}
public IEnumerable <Tag> GetTags()
{
return(Tags.Cast <Tag>());
}
public bool CreateTableWay(Media media, Tags tag, TagType tagType)
{
TableWay tableWay = new TableWay();
return(tableWay.CreateTableWay(media, tag, tagType));
}
public void Export(TextWriter writer)
{
if (Name != string.Empty)
{
writer.WriteIntent(3);
writer.Write("Name \"{0}\"\n", Name);
}
if (LOD != 0)
{
writer.WriteIntent(3);
writer.Write("LOD {0}\n", LOD);
}
Tags.Export(writer, 3);
RtBlend0.Export(writer, RtSeparateBlend ? 0 : -1);
RtBlend1.Export(writer, 1);
RtBlend2.Export(writer, 2);
RtBlend3.Export(writer, 3);
RtBlend4.Export(writer, 4);
RtBlend5.Export(writer, 5);
RtBlend6.Export(writer, 6);
RtBlend7.Export(writer, 7);
if (AlphaToMaskValue)
{
writer.WriteIntent(3);
writer.Write("AlphaToMask On\n");
}
if (!ZClipValue.IsOn())
{
writer.WriteIntent(3);
writer.Write("ZClip {0}\n", ZClipValue);
}
if (!ZTestValue.IsLEqual() && !ZTestValue.IsNone())
{
writer.WriteIntent(3);
writer.Write("ZTest {0}\n", ZTestValue);
}
if (!ZWriteValue.IsOn())
{
writer.WriteIntent(3);
writer.Write("ZWrite {0}\n", ZWriteValue);
}
if (!CullingValue.IsBack())
{
writer.WriteIntent(3);
writer.Write("Cull {0}\n", CullingValue);
}
if (!OffsetFactor.IsZero || !OffsetUnits.IsZero)
{
writer.WriteIntent(3);
writer.Write("Offset {0}, {1}\n", OffsetFactor.Val, OffsetUnits.Val);
}
if (!StencilRef.IsZero || !StencilReadMask.IsMax || !StencilWriteMask.IsMax || !StencilOp.IsDefault || !StencilOpFront.IsDefault || !StencilOpBack.IsDefault)
{
writer.WriteIntent(3);
writer.Write("Stencil {\n");
if (!StencilRef.IsZero)
{
writer.WriteIntent(4);
writer.Write("Ref {0}\n", StencilRef.Val);
}
if (!StencilReadMask.IsMax)
{
writer.WriteIntent(4);
writer.Write("ReadMask {0}\n", StencilReadMask.Val);
}
if (!StencilWriteMask.IsMax)
{
writer.WriteIntent(4);
writer.Write("WriteMask {0}\n", StencilWriteMask.Val);
}
if (!StencilOp.IsDefault)
{
StencilOp.Export(writer, StencilType.Base);
}
if (!StencilOpFront.IsDefault)
{
StencilOpFront.Export(writer, StencilType.Front);
}
if (!StencilOpBack.IsDefault)
{
StencilOpBack.Export(writer, StencilType.Back);
}
writer.WriteIntent(3);
writer.Write("}\n");
}
if (!FogMode.IsUnknown() || !FogColor.IsZero || !FogDensity.IsZero || !FogStart.IsZero || !FogEnd.IsZero)
{
writer.WriteIntent(3);
writer.Write("Fog {\n");
if (!FogMode.IsUnknown())
{
writer.WriteIntent(4);
writer.Write("Mode {0}\n", FogMode);
}
if (!FogColor.IsZero)
{
writer.WriteIntent(4);
writer.Write("Color ({0},{1},{2},{3})\n",
FogColor.X.Val.ToString(CultureInfo.InvariantCulture),
FogColor.Y.Val.ToString(CultureInfo.InvariantCulture),
FogColor.Z.Val.ToString(CultureInfo.InvariantCulture),
FogColor.W.Val.ToString(CultureInfo.InvariantCulture));
}
if (!FogDensity.IsZero)
{
writer.WriteIntent(4);
writer.Write("Density {0}\n", FogDensity.Val.ToString(CultureInfo.InvariantCulture));
}
if (!FogStart.IsZero || !FogEnd.IsZero)
{
writer.WriteIntent(4);
writer.Write("Range {0}, {1}\n",
FogStart.Val.ToString(CultureInfo.InvariantCulture),
FogEnd.Val.ToString(CultureInfo.InvariantCulture));
}
writer.WriteIntent(3);
writer.Write("}\n");
}
if (Lighting)
{
writer.WriteIntent(3);
writer.Write("Lighting {0}\n", LightingValue);
}
writer.WriteIntent(3);
writer.Write("GpuProgramID {0}\n", GpuProgramID);
}
