internal List<KeyValuePair<ILinkable, int>> GetTags(int numberOfItems)
{
Random r = new Random();
return Caching.Instances.Main.GetWithLocalCaching(new NamespacedCacheKey(CacheKeyPrefix.TagCloudData, new CacheKey(CacheKeyPrefix.TagCloudVersion), r.Next(10).ToString(), numberOfItems.ToString()),
() =>
{
List<int> tagKs = GetTagKs(numberOfItems);
Query getTags = new Query(new And(new Q(new Column(Tag.Columns.K), tagKs.ToArray())));
getTags.TableElement = new Join(new TableElement(Bobs.TablesEnum.TagPhoto), Tag.Columns.K, TagPhoto.Columns.TagK);
getTags.Columns = new ColumnSet(Tag.Columns.TagText, Tag.Columns.ShowInTagCloud, Tag.Columns.K, Tag.Columns.Blocked, Tag.Columns.BlockedByUsrK, Tag.Columns.BlockedDateTime);
getTags.ExtraSelectElements.Add("Frequency", "CAST(CEILING(LOG(COUNT(" + new Column(TagPhoto.Columns.TagK).InternalSqlName + "))+1) AS INT)");
getTags.GroupBy = new GroupBy(new GroupBy(Tag.Columns.K), new GroupBy(Tag.Columns.TagText), new GroupBy(Tag.Columns.Blocked), new GroupBy(Tag.Columns.BlockedByUsrK), new GroupBy(Tag.Columns.BlockedDateTime), new GroupBy(Tag.Columns.ShowInTagCloud));
getTags.OrderBy = new OrderBy(Tag.Columns.TagText, OrderBy.OrderDirection.Ascending);
List<Tag> tags = new TagSet(getTags).ToList();
return tags.ToList().ConvertAll(t => new KeyValuePair<ILinkable, int>(t, (int)t.ExtraSelectElements["Frequency"]));
},
new TimeSpan(0, 0, 30),
new TimeSpan(1, 0, 0)
);
}
public void Constructor_with_multiple_parameters_should_return_properly_initialized_instance()
{
var averageRoundTripTime = TimeSpan.FromSeconds(1);
var replicaSetConfig = new ReplicaSetConfig(
new [] { new DnsEndPoint("localhost", 27017), new DnsEndPoint("localhost", 27018) },
"name",
new DnsEndPoint("localhost", 27017),
1);
var state = ServerState.Connected;
var tags = new TagSet(new [] { new Tag("x", "a") });
var type = ServerType.ReplicaSetPrimary;
var version = new SemanticVersion(2, 6, 3);
var wireVersionRange = new Range<int>(2, 3);
var subject = new ServerDescription(
__serverId,
__endPoint,
state,
type,
averageRoundTripTime,
replicaSetConfig,
tags,
version,
wireVersionRange);
subject.AverageRoundTripTime.Should().Be(TimeSpan.FromSeconds(1));
subject.EndPoint.Should().Be(__endPoint);
subject.ReplicaSetConfig.Should().Be(replicaSetConfig);
subject.ServerId.Should().Be(__serverId);
subject.State.Should().Be(state);
subject.Tags.Should().Be(tags);
subject.Type.Should().Be(type);
}
private void GetResults()
{
Q tagTextQ = new Q(Tag.Columns.TagText, QueryOperator.TextContains, this.uiTagTextFilter.Text.Replace("*", "%"));
Q isBlockedQ;
switch (Convert.ToInt32(this.uiBlockedFilter.SelectedValue))
{
case -1: isBlockedQ = new Q(true); break;
case 0: isBlockedQ = new Q(Tag.Columns.Blocked, false); break;
case 1: isBlockedQ = new Q(Tag.Columns.Blocked, true); break;
default: throw new NotImplementedException();
}
Q showInTagCloudQ;
switch (Convert.ToInt32(this.uiShowInTagCloudFilter.SelectedValue))
{
case -1: showInTagCloudQ = new Q(true); break;
case 0: showInTagCloudQ = new Q(Tag.Columns.ShowInTagCloud, false); break;
case 1: showInTagCloudQ = new Q(Tag.Columns.ShowInTagCloud, true); break;
default: throw new NotImplementedException();
}
TagSet set = new TagSet(new Query(new And(tagTextQ, isBlockedQ, showInTagCloudQ)));
if (set.Count > 0)
{
this.uiResults.DataSource = set;
this.uiResults.DataBind();
this.uiResultsPanel.Visible = true;
this.uiResultsTitle.Visible = true;
}
else
{
this.uiResultsPanel.Visible = false;
this.uiResultsTitle.Visible = false;
}
}
public DynamicContentEvaluationContext(string storeId, string placeName, DateTime toDate, TagSet tags)
{
StoreId = storeId;
PlaceName = placeName;
ToDate = toDate;
Tags = tags;
}
public void AddBasic() {
var list = new TagSet();
using (IDisposable tag = list.Add("Order"))
Assert.Equal(1, list.Count);
Assert.Equal(0, list.Count);
}
public static ServerDescription Connected(ClusterId clusterId, EndPoint endPoint = null, ServerType serverType = ServerType.Standalone, TagSet tags = null, TimeSpan? averageRoundTripTime = null, Range<int> wireVersionRange = null)
{
return Disconnected(clusterId, endPoint)
.WithHeartbeatInfo(
averageRoundTripTime ?? TimeSpan.FromMilliseconds(1),
null,
tags,
serverType,
new SemanticVersion(2, 6, 3),
wireVersionRange ?? new Range<int>(0, 2));
}
public static ServerDescription Connected(ClusterId clusterId, EndPoint endPoint = null, ServerType serverType = ServerType.Standalone, TagSet tags = null, TimeSpan? averageRoundTripTime = null, Range<int> wireVersionRange = null)
{
return Disconnected(clusterId, endPoint).With(
averageRoundTripTime: averageRoundTripTime ?? TimeSpan.FromMilliseconds(1),
replicaSetConfig: null,
state: ServerState.Connected,
tags: tags,
type: serverType,
version: new SemanticVersion(2, 6, 3),
wireVersionRange: wireVersionRange ?? new Range<int>(0, 2));
}
public void AddRemove() {
var list = new TagSet();
using (list.Add("Order")) {
Assert.Equal(1, list.Count);
list.Remove("Order");
}
Assert.Equal(0, list.Count);
}
/// <summary>
/// Gets the display template.
/// </summary>
/// <param name="target">The target.</param>
/// <param name="tags">The tags.</param>
/// <returns></returns>
public string GetDisplayTemplate(TargetTypes target, TagSet tags)
{
var session = _customerSession.CustomerSession;
var tagsLocal = tags ?? session.GetCustomerTagSet();
return Helper.Get(
string.Format(DisplayTemplateCacheKey, target.ToString(), tagsLocal.GetCacheKey()),
() => _service.GetTemplate(target, tags),
AppConfigConfiguration.Instance.Cache.DisplayTemplateMappingsTimeout,
IsEnabled);
}
private IEnumerable<Pricelist> GetPriceListStackInternal(string catalogId, string currency, TagSet tags)
{
var evaluateContext = _priceListEvalContext;
evaluateContext.Currency = currency;
evaluateContext.CatalogId = catalogId;
evaluateContext.ContextObject = tags;
evaluateContext.CurrentDate = DateTime.Now;
var evaluator = _priceListEvaluator;
var lists = evaluator.Evaluate(evaluateContext);
return lists;
}
public void AddRemoveNested() {
var tags = new TagSet();
using (tags.Add("Order")) {
using (tags.Add("Step1")) {
Assert.Equal(2, tags.Count);
using (tags.Add("Step2"))
Assert.Equal(3, tags.Count);
Assert.Equal(2, tags.Count);
}
}
Assert.Equal(0, tags.Count);
}
public ExceptionlessConfiguration(IDependencyResolver resolver)
{
ServerUrl = DEFAULT_SERVER_URL;
UserAgent = DEFAULT_USER_AGENT;
Enabled = true;
EnableSSL = true;
DefaultTags = new TagSet();
DefaultData = new DataDictionary();
Settings = new SettingsDictionary();
if (resolver == null)
{
throw new ArgumentNullException("resolver");
}
_resolver = resolver;
EventEnrichmentManager.AddDefaultEnrichments(this);
}
public void Run_dynamiccontent_performance()
{
var repository = new EFDynamicContentRepository();
var cache = new HttpCacheRepository();
var evaluator = new DynamicContentEvaluator(repository, null, cache);
var service = new DynamicContentService(repository, evaluator);
DynamicContentConfiguration.Instance.Cache.IsEnabled = true;
var tags = new TagSet();
tags.Add("CategoryId", new Tag("VendorVirtual"));
tags.Add("StoreId", new Tag("SampleStore"));
tags.Add("CurrentUrl", new Tag("http://localhost/store"));
var items = service.GetItems("HomeMain", DateTime.Now, tags);
//items = service.GetItems("HomeMain", DateTime.Now, tags);
}
public void MatchTag()
{
var tag = new Hashtable();
tag["category"] = new string[] { "group1", "group2" };
var filter = new RuleFilter(null, tag, null);
var ruleTags = new Hashtable();
ruleTags["category"] = "group2";
Assert.True(filter.Match("rule1", TagSet.FromHashtable(ruleTags)));
ruleTags["category"] = "group1";
Assert.True(filter.Match("rule2", TagSet.FromHashtable(ruleTags)));
ruleTags["category"] = "group3";
Assert.False(filter.Match("rule3", TagSet.FromHashtable(ruleTags)));
Assert.False(filter.Match("rule4", null));
}
private void AddNewLanceMembers(ContractOverride contractOverride, TeamOverride teamOverride, LanceOverride lanceOverride, int numberOfUnitsInLance, int factionLanceSize)
{
for (int i = numberOfUnitsInLance; i < factionLanceSize; i++)
{
UnitSpawnPointOverride originalUnitSpawnPointOverride = lanceOverride.GetAnyTaggedLanceMember();
if (originalUnitSpawnPointOverride == null)
{
originalUnitSpawnPointOverride = lanceOverride.unitSpawnPointOverrideList[0];
}
UnitSpawnPointOverride unitSpawnPointOverride = originalUnitSpawnPointOverride.DeepCopy();
unitSpawnPointOverride.customUnitName = "";
TagSet companyTags = new TagSet(UnityGameInstance.BattleTechGame.Simulation.CompanyTags);
unitSpawnPointOverride.GenerateUnit(MetadataDatabase.Instance, UnityGameInstance.Instance.Game.DataManager, lanceOverride.selectedLanceDifficulty, lanceOverride.name, null, i, DataManager.Instance.GetSimGameCurrentDate(), companyTags);
lanceOverride.unitSpawnPointOverrideList.Add(unitSpawnPointOverride);
}
}
public void WithHeartbeat_should_return_new_instance_when_a_field_is_not_equal(string notEqualField)
{
var averageRoundTripTime = TimeSpan.FromSeconds(1);
var replicaSetConfig = new ReplicaSetConfig(
new[] { new DnsEndPoint("localhost", 27017), new DnsEndPoint("localhost", 27018) },
"name",
new DnsEndPoint("localhost", 27017),
1);
var state = ServerState.Connected;
var tags = new TagSet(new[] { new Tag("x", "a") });
var type = ServerType.ReplicaSetPrimary;
var version = new SemanticVersion(2, 6, 3);
var wireVersionRange = new Range <int>(2, 3);
var subject = new ServerDescription(
__serverId,
__endPoint,
state,
type,
averageRoundTripTime,
replicaSetConfig,
tags,
version,
wireVersionRange);
switch (notEqualField)
{
case "AverageRoundTripTime": averageRoundTripTime = averageRoundTripTime.Add(TimeSpan.FromSeconds(1)); break;
case "ReplicaSetConfig": replicaSetConfig = new ReplicaSetConfig(replicaSetConfig.Members, "newname", replicaSetConfig.Primary, replicaSetConfig.Version); break;
case "Tags": tags = new TagSet(new[] { new Tag("x", "b") }); break;
case "Type": type = ServerType.ReplicaSetSecondary; break;
case "Version": version = new SemanticVersion(version.Major, version.Minor, version.Patch + 1); break;
case "WireVersionRange": wireVersionRange = new Range <int>(0, 0); break;
}
var serverDescription2 = subject.WithHeartbeatInfo(averageRoundTripTime, replicaSetConfig, tags, type, version, wireVersionRange);
subject.Equals(serverDescription2).Should().BeFalse();
subject.Equals((object)serverDescription2).Should().BeFalse();
subject.GetHashCode().Should().NotBe(serverDescription2.GetHashCode());
}
public IHttpActionResult GetDynamicContent(string store,
string[] placeHolders,
[FromUri] string[] tags,
string language = "en-us")
{
var tagSet = new TagSet();
if (tags != null)
{
foreach (var tagArray in tags.Select(tag => tag.Split(new[] { ':' })))
{
tagSet.Add(tagArray[0], tagArray[1]);
}
}
// TODO: add tags ?tags={users:[id1,id2]}
// TODO: add caching
//Mutiple placeholders can be requested
var groups = new List <webModel.DynamicContentItemGroup>();
foreach (var holder in placeHolders)
{
var group = new webModel.DynamicContentItemGroup(holder);
var ctx = new DynamicContentEvaluationContext(store, holder, DateTime.Now, tagSet);
var results = _contentEvaluator.EvaluateItems(ctx);
if (results != null && results.Any())
{
group.Items.AddRange(results.Select(x => x.ToWebModel()));
groups.Add(group);
}
}
var retVal = new webModel.ResponseCollection <webModel.DynamicContentItemGroup>
{
Items = groups,
TotalCount = groups.Count()
};
return(this.Ok(retVal));
//return this.StatusCode(HttpStatusCode.NoContent);
}
public IHttpActionResult GetDynamicContent(
string[] placeHolders,
[FromUri] string[] tags,
string language = "en-us")
{
var tagSet = new TagSet();
if (tags != null)
{
foreach (var tagArray in tags.Select(tag => tag.Split(new[] { ':' })))
{
tagSet.Add(tagArray[0], tagArray[1]);
}
}
// TODO: add tags ?tags={users:[id1,id2]}
// TODO: add caching
//Mutiple placeholders can be requested
var groups = new List<webModel.DynamicContentItemGroup>();
foreach (var holder in placeHolders)
{
var group = new webModel.DynamicContentItemGroup(holder);
var ctx = new DynamicContentEvaluationContext(holder, DateTime.Now, tagSet);
var results = _contentEvaluator.EvaluateItems(ctx);
if (results != null && results.Any())
{
group.Items.AddRange(results.Select(x => x.ToWebModel()));
groups.Add(group);
}
}
var retVal = new webModel.ResponseCollection<webModel.DynamicContentItemGroup>
{
Items = groups,
TotalCount = groups.Count()
};
return this.Ok(retVal);
//return this.StatusCode(HttpStatusCode.NoContent);
}
public void Constructor_with_multiple_parameters_should_return_properly_initialized_instance()
{
var averageRoundTripTime = TimeSpan.FromSeconds(1);
var canonicalEndPoint = new DnsEndPoint("localhost", 27017);
var electionId = new ElectionId(ObjectId.GenerateNewId());
var helloOk = true;
var logicalSessionTimeout = TimeSpan.FromMinutes(1);
var replicaSetConfig = new ReplicaSetConfig(
new[] { new DnsEndPoint("localhost", 27017), new DnsEndPoint("localhost", 27018) },
"name",
new DnsEndPoint("localhost", 27017),
1);
var state = ServerState.Connected;
var tags = new TagSet(new[] { new Tag("x", "a") });
var type = ServerType.ReplicaSetPrimary;
var version = new SemanticVersion(3, 6, 0);
var wireVersionRange = new Range <int>(6, 14);
var subject = new ServerDescription(
__serverId,
__endPoint,
state: state,
type: type,
averageRoundTripTime: averageRoundTripTime,
canonicalEndPoint: canonicalEndPoint,
electionId: electionId,
helloOk: helloOk,
logicalSessionTimeout: logicalSessionTimeout,
replicaSetConfig: replicaSetConfig,
tags: tags,
version: version,
wireVersionRange: wireVersionRange);
subject.AverageRoundTripTime.Should().Be(TimeSpan.FromSeconds(1));
subject.CanonicalEndPoint.Should().Be(canonicalEndPoint);
subject.ElectionId.Should().Be(electionId);
subject.EndPoint.Should().Be(__endPoint);
subject.HelloOk.Should().Be(helloOk);
subject.LogicalSessionTimeout.Should().Be(logicalSessionTimeout);
subject.ReplicaSetConfig.Should().Be(replicaSetConfig);
subject.ServerId.Should().Be(__serverId);
subject.State.Should().Be(state);
subject.Tags.Should().Be(tags);
subject.Type.Should().Be(type);
}
public static int GetPilotSkillLevel(TagSet pilotTagSet)
{
if (pilotTagSet.Contains("pilot_npc_d10"))
{
return(10);
}
if (pilotTagSet.Contains("pilot_npc_d9"))
{
return(9);
}
if (pilotTagSet.Contains("pilot_npc_d8"))
{
return(8);
}
if (pilotTagSet.Contains("pilot_npc_d7"))
{
return(7);
}
if (pilotTagSet.Contains("pilot_npc_d6"))
{
return(6);
}
if (pilotTagSet.Contains("pilot_npc_d5"))
{
return(5);
}
if (pilotTagSet.Contains("pilot_npc_d4"))
{
return(4);
}
if (pilotTagSet.Contains("pilot_npc_d3"))
{
return(3);
}
if (pilotTagSet.Contains("pilot_npc_d2"))
{
return(2);
}
if (pilotTagSet.Contains("pilot_npc_d1"))
{
return(1);
}
// Default
return(7);
}
public void Run_dynamiccontent_performance()
{
var repository = new EFDynamicContentRepository();
var cache = new HttpCacheRepository();
var evaluator = new DynamicContentEvaluator(repository, null, cache);
var service = new DynamicContentService(repository, evaluator);
DynamicContentConfiguration.Instance.Cache.IsEnabled = true;
var tags = new TagSet();
tags.Add("CategoryId", new Tag("VendorVirtual"));
tags.Add("StoreId", new Tag("SampleStore"));
tags.Add("CurrentUrl", new Tag("http://localhost/store"));
var items = service.GetItems("HomeMain", DateTime.Now, tags);
//items = service.GetItems("HomeMain", DateTime.Now, tags);
}
public ExceptionlessConfiguration(IDependencyResolver resolver)
{
ServerUrl = DEFAULT_SERVER_URL;
UserAgent = DEFAULT_USER_AGENT;
SubmissionBatchSize = DEFAULT_SUBMISSION_BATCH_SIZE;
Enabled = true;
EnableSSL = true;
DefaultTags = new TagSet();
DefaultData = new DataDictionary();
Settings = new SettingsDictionary();
if (resolver == null)
{
throw new ArgumentNullException("resolver");
}
_resolver = resolver;
EventPluginManager.AddDefaultPlugins(this);
}
private RuleDocument GetExpected()
{
var annotations = new Hashtable();
annotations["severity"] = "Critical";
annotations["category"] = "Pod security";
var result = new RuleDocument(name: "Kubernetes.Deployment.NotLatestImage")
{
Synopsis = new TextBlock(text: "Containers should use specific tags instead of latest."),
Annotations = TagSet.FromHashtable(annotations),
Recommendation = new TextBlock(text: @"Deployments or pods should identify a specific tag to use for container images instead of latest. When latest is used it may be hard to determine which version of the image is running.
When using variable tags such as v1.0 (which may refer to v1.0.0 or v1.0.1) consider using imagePullPolicy: Always to ensure that the an out-of-date cached image is not used.
The latest tag automatically uses imagePullPolicy: Always instead of the default imagePullPolicy: IfNotPresent.")
};
return(result);
}
/// <summary>
/// The TAGSET to model.
/// </summary>
/// <param name="tagset">
/// The tagset DataModel.
/// </param>
/// <returns>
/// The <see cref="TagSet"/>.
/// </returns>
public static TagSet ToModel(this TAGSET tagset)
{
if (tagset == null)
{
return(null);
}
TagSet model = new TagSet
{
TagId = tagset.TagId,
NodeId = tagset.NodeId,
TagSetId = tagset.TagSetId,
Node = tagset.NODE.ToModel(),
Tag = tagset.TAG.ToModel()
};
return(model);
}
public static void Postfix(Weapon __instance, ref float __result)
{
if (ModInit.Settings.UsePlanetGravityTags == true && !combat.ActiveContract.ContractTypeValue.IsSkirmish)
{
if (ModInit.Settings.LetGravityAffectEnergyWeps != true && __instance.WeaponCategoryValue.IsEnergy)
{
return;
}
TagSet CurrentSystem = sim.CurSystem.Tags;
if (CurrentSystem.Contains("planet_size_small"))
{
WeaponRangeMultiplier = ModInit.Settings.lowgravWeaponOverride;
}
else if (CurrentSystem.Contains("planet_size_large"))
{
WeaponRangeMultiplier = ModInit.Settings.highgravWeaponOverride;
}
else
{
WeaponRangeMultiplier = 1.0f;
}
__result *= WeaponRangeMultiplier;
}
else
{
if (ModInit.Settings.LetGravityAffectEnergyWeps != true && __instance.WeaponCategoryValue.IsEnergy)
{
return;
}
if (combat.MapMetaData.biomeSkin == Biome.BIOMESKIN.lunarVacuum)
{
WeaponRangeMultiplier = ModInit.Settings.LunarWeaponOverride;
}
else if (combat.MapMetaData.biomeSkin == Biome.BIOMESKIN.martianVacuum)
{
WeaponRangeMultiplier = ModInit.Settings.MartianWeaponOverride;
}
else
{
WeaponRangeMultiplier = 1.0f;
}
__result *= WeaponRangeMultiplier;
}
}
public static List <MechComponent> GetComponentsInLocation(this AbstractActor target, int location, HashSet <string> excludeTags, HashSet <string> onlyTags)
{
List <MechComponent> result = new List <MechComponent>();
TagSet oTags = new TagSet(onlyTags);
TagSet eTags = new TagSet(excludeTags);
Log.Debug?.TWL(0, "GetComponentsInLocation " + target.DisplayName);
for (int t = 0; t < target.allComponents.Count; ++t)
{
MechComponent component = target.allComponents[t];
if (component.IsFunctional == false)
{
continue;
}
if (component.Location != location)
{
continue;
}
Log.Debug?.W(1, "component:" + component.defId);
if (onlyTags.Count > 0)
{
if (component.componentDef.ComponentTags.ContainsAny(oTags) == false)
{
Log.Debug?.WL(1, "onlyTags check fail");
continue;
}
}
if (excludeTags.Count > 0)
{
if (component.componentDef.ComponentTags.ContainsAny(eTags))
{
Log.Debug?.WL(1, "excludeTags check fail");
continue;
}
}
Log.Debug?.WL(1, "suitable");
for (int i = 0; i < component.inventorySize; ++i)
{
result.Add(component);
}
}
return(result);
}
public static ModelContext Create(IConfigurationRepository configurationRepository,
IConnectionStringRepository connectionStringRepository)
{
if (configurationRepository == null)
{
throw new ArgumentNullException("ConfigurationRepository");
}
if (connectionStringRepository == null)
{
throw new ArgumentNullException("ConnectionStringRepository");
}
if (_modelContext == null)
{
_modelContext = new ModelContext();
string connectionString = connectionStringRepository.ReadConnectionString("MongoDb");
//set read and write concern on client level
MongoClientSettings settings = new MongoClientSettings();
settings.ReadConcern = new ReadConcern(ReadConcernLevel.Majority);
Tag tag = new Tag("tagName", "tagValue");
TagSet tagSet = new TagSet(new List <Tag>()
{
tag
});
settings.ReadPreference = new ReadPreference(ReadPreferenceMode.Secondary, new List <TagSet>()
{
tagSet
});
WriteConcern writeConcernWithNumberOfServers = new WriteConcern(2, TimeSpan.FromSeconds(60), false, false);
WriteConcern writeConcerntWithMajority = new WriteConcern("majority", TimeSpan.FromSeconds(60), false, false);
settings.WriteConcern = writeConcerntWithMajority;
//set read and write concern on DB level
MongoDatabaseSettings dbSettings = new MongoDatabaseSettings();
_modelContext.Client = new MongoClient(connectionString);
_modelContext.Database = _modelContext.Client.GetDatabase(configurationRepository.GetConfigurationValue("DemoDatabaseName", "model"));
_modelContext.ConfigurationRepository = configurationRepository;
}
return(_modelContext);
}
override protected BehaviorTreeResults Tick()
{
unit.BehaviorTree.enemyUnits = new List <ICombatant>();
string[] targetTags = { "tutorial_sprint_target" };
TagSet targetTagSet = new TagSet(targetTags);
List <ITaggedItem> items = unit.Combat.ItemRegistry.GetObjectsOfTypeWithTagSet(TaggedObjectType.Unit, targetTagSet);
for (int i = 0; i < items.Count; ++i)
{
ICombatant targetUnit = items[i] as ICombatant;
if ((targetUnit != null) && (targetUnit.IsOperational))
{
unit.BehaviorTree.enemyUnits.Add(targetUnit);
}
}
return(BehaviorTreeResults.BehaviorTreeResultsFromBoolean(unit.BehaviorTree.enemyUnits.Count > 0));
}
private static string FindSizeTag(TagSet tags)
{
if (tags == null || tags.Count == 0)
{
Logger.Debug("Found no tags");
return(null);
}
foreach (var t in tags)
{
if (!t.StartsWith("MR-Resize-", ignoreCase: true, culture: CultureInfo.InvariantCulture))
{
continue;
}
Logger.Debug($"found a tag in for loop: {t}");
return(t);
}
return(null);
}
public static int CreateTagSet()
{
try
{
var dbContext = Program.NinjectKernel.Get <IRealmDbContext>();
var newTagSet = new TagSet();
dbContext.TagSets.Add(newTagSet);
dbContext.SaveChanges();
return(newTagSet.Id);
}
catch (Exception ex)
{
// todo log it
}
return(0);
}
public static int GetThreatLevelByTag(TagSet mechTags)
{
if (mechTags.Contains("unit_components_plusplusplus"))
{
return(3);
}
else if (mechTags.Contains("unit_components_plusplus"))
{
return(2);
}
else if (mechTags.Contains("unit_components_plus"))
{
return(1);
}
else
{
return(0);
}
}
public void With_should_return_same_instance_when_all_fields_are_equal()
{
var averageRoundTripTime = TimeSpan.FromSeconds(1);
var helloOk = true;
var lastUpdateTimestamp = DateTime.UtcNow;
var replicaSetConfig = new ReplicaSetConfig(
new[] { new DnsEndPoint("localhost", 27017), new DnsEndPoint("localhost", 27018) },
"name",
new DnsEndPoint("localhost", 27017),
1);
var state = ServerState.Connected;
var tags = new TagSet(new[] { new Tag("x", "a") });
var type = ServerType.ReplicaSetPrimary;
var version = new SemanticVersion(3, 6, 0);
var wireVersionRange = new Range <int>(6, 14);
var subject = new ServerDescription(
__serverId,
__endPoint,
averageRoundTripTime: averageRoundTripTime,
helloOk: helloOk,
lastUpdateTimestamp: lastUpdateTimestamp,
replicaSetConfig: replicaSetConfig,
state: state,
tags: tags,
type: type,
version: version,
wireVersionRange: wireVersionRange);
var result = subject.With(
averageRoundTripTime: averageRoundTripTime,
helloOk: helloOk,
lastUpdateTimestamp: lastUpdateTimestamp,
replicaSetConfig: replicaSetConfig,
state: ServerState.Connected,
tags: tags,
type: type,
version: version,
wireVersionRange: wireVersionRange);
result.ShouldBeEquivalentTo(subject);
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="ServerDescription" /> class.
/// </summary>
/// <param name="serverId">The server identifier.</param>
/// <param name="endPoint">The end point.</param>
/// <param name="averageRoundTripTime">The average round trip time.</param>
/// <param name="canonicalEndPoint">The canonical end point.</param>
/// <param name="electionId">The election identifier.</param>
/// <param name="heartbeatException">The heartbeat exception.</param>
/// <param name="maxBatchCount">The maximum batch count.</param>
/// <param name="maxDocumentSize">The maximum size of a document.</param>
/// <param name="maxMessageSize">The maximum size of a message.</param>
/// <param name="maxWireDocumentSize">The maximum size of a wire document.</param>
/// <param name="replicaSetConfig">The replica set configuration.</param>
/// <param name="state">The server state.</param>
/// <param name="tags">The replica set tags.</param>
/// <param name="type">The server type.</param>
/// <param name="version">The server version.</param>
/// <param name="wireVersionRange">The wire version range.</param>
/// <exception cref="System.ArgumentException">EndPoint and ServerId.EndPoint must match.</exception>
public ServerDescription(
ServerId serverId,
EndPoint endPoint,
Optional <TimeSpan> averageRoundTripTime = default(Optional <TimeSpan>),
Optional <EndPoint> canonicalEndPoint = default(Optional <EndPoint>),
Optional <ElectionId> electionId = default(Optional <ElectionId>),
Optional <Exception> heartbeatException = default(Optional <Exception>),
Optional <int> maxBatchCount = default(Optional <int>),
Optional <int> maxDocumentSize = default(Optional <int>),
Optional <int> maxMessageSize = default(Optional <int>),
Optional <int> maxWireDocumentSize = default(Optional <int>),
Optional <ReplicaSetConfig> replicaSetConfig = default(Optional <ReplicaSetConfig>),
Optional <ServerState> state = default(Optional <ServerState>),
Optional <TagSet> tags = default(Optional <TagSet>),
Optional <ServerType> type = default(Optional <ServerType>),
Optional <SemanticVersion> version = default(Optional <SemanticVersion>),
Optional <Range <int> > wireVersionRange = default(Optional <Range <int> >))
{
Ensure.IsNotNull(endPoint, "endPoint");
Ensure.IsNotNull(serverId, "serverId");
if (!EndPointHelper.Equals(endPoint, serverId.EndPoint))
{
throw new ArgumentException("EndPoint and ServerId.EndPoint must match.");
}
_averageRoundTripTime = averageRoundTripTime.WithDefault(TimeSpan.Zero);
_canonicalEndPoint = canonicalEndPoint.WithDefault(null);
_electionId = electionId.WithDefault(null);
_endPoint = endPoint;
_heartbeatException = heartbeatException.WithDefault(null);
_maxBatchCount = maxBatchCount.WithDefault(1000);
_maxDocumentSize = maxDocumentSize.WithDefault(4 * 1024 * 1024);
_maxMessageSize = maxMessageSize.WithDefault(Math.Max(_maxDocumentSize + 1024, 16000000));
_maxWireDocumentSize = maxWireDocumentSize.WithDefault(_maxDocumentSize + 16 * 1024);
_replicaSetConfig = replicaSetConfig.WithDefault(null);
_serverId = serverId;
_state = state.WithDefault(ServerState.Disconnected);
_tags = tags.WithDefault(null);
_type = type.WithDefault(ServerType.Unknown);
_version = version.WithDefault(null);
_wireVersionRange = wireVersionRange.WithDefault(null);
}
public static bool meetsNewReqs(StarSystem instance, TagSet reqTags, TagSet exTags, TagSet curTags)
{
try {
if (!curTags.ContainsAny(exTags, true))
{
foreach (string item in reqTags)
{
if (!curTags.Contains(item))
{
if (item.StartsWith("time"))
{
string[] times = item.Split('_');
if (!(instance.Sim.DaysPassed >= int.Parse(times[1])))
{
return(false);
}
}
else if (item.StartsWith("rep"))
{
string[] reps = item.Split('_');
int test = instance.Sim.GetRawReputation(Helper.getfaction(reps[1]));
if (!(test >= int.Parse(reps[2])))
{
return(false);
}
}
else
{
return(false);
}
}
}
Logger.LogLine("Return true");
return(true);
}
return(false);
}
catch (Exception e) {
Logger.LogError(e);
return(false);
}
}
public void When_two_sets_of_readPreferenceTags_are_specified()
{
var subject = new ConnectionString("mongodb://localhost?readPreferenceTags=dc:east,rack:1&readPreferenceTags=dc:west,rack:2");
var tagSet1 = new TagSet(new List <Tag>
{
new Tag("dc", "east"),
new Tag("rack", "1")
});
var tagSet2 = new TagSet(new List <Tag>
{
new Tag("dc", "west"),
new Tag("rack", "2")
});
subject.ReadPreferenceTags.Count.Should().Be(2);
subject.ReadPreferenceTags[0].Should().Be(tagSet1);
subject.ReadPreferenceTags[1].Should().Be(tagSet2);
}
public static bool ReadSizeFromTags(TagSet tags, out Vector3?size, out string rawTag)
{
size = null;
rawTag = null;
try
{
rawTag = FindSizeTag(tags);
if (string.IsNullOrEmpty(rawTag))
{
return(false);
}
var parts = rawTag.Split('-');
// for tags of style 'MR-Resize-N`
if (parts.Length == 3)
{
var resizeNumber = float.Parse(parts[2]);
size = new Vector3(resizeNumber, resizeNumber, resizeNumber);
Logger.Debug($"size from singular tag: [{size.Value.x},{size.Value.y},{size.Value.z}]");
return(true);
}
// for tags of style 'MR-Resize-X-Y-Z`
if (parts.Length == 5)
{
var resizeX = float.Parse(parts[2]);
var resizeY = float.Parse(parts[3]);
var resizeZ = float.Parse(parts[4]);
size = new Vector3(resizeX, resizeY, resizeZ);
Logger.Debug($"size from multi-tag: [{size.Value.x},{size.Value.y},{size.Value.z}]");
return(true);
}
}
catch (Exception e)
{
Logger.Error(e);
}
return(false);
}
public static bool Prefix(LanceOverride __instance, Contract contract,
ref TagSet ___lanceTagSet, ref TagSet ___lanceExcludedTagSet, ref List <UnitSpawnPointOverride> ___unitSpawnPointOverrideList)
{
TeamOverride teamOverride = TeamOverride_RunMadLibs.lanceOverrides[__instance.GetHashCode()];
IRBT14MadlibsFix.Logger.Log($"LO:RML using teamOverride:[{teamOverride.GetHashCode()}] for lanceOverride:[{__instance?.GetHashCode()}]");
LanceOverride_RunMadLibs.teamOverrides[__instance.GetHashCode()] = teamOverride;
contract.GameContext.SetObject(GameContextObjectTagEnum.CurrentTeam, teamOverride);
IRBT14MadlibsFix.Logger.Log($"LO:RML BEFORE madlibs lanceTagSet is:[{___lanceTagSet}]");
contract.RunMadLib(___lanceTagSet);
IRBT14MadlibsFix.Logger.Log($"LO:RML AFTER madlibs lanceTagSet is:[{___lanceTagSet}]");
contract.RunMadLib(___lanceExcludedTagSet);
for (int i = 0; i < ___unitSpawnPointOverrideList.Count; ++i)
{
___unitSpawnPointOverrideList[i].RunMadLib(contract);
}
return(false);
}
public static bool GetVehicleTags(ChassisDef chassis, DataManager dm, ref TagSet __result)
{
if (!chassis.IsVehicle())
{
return(true);
}
var mid = ChassisHandler.GetMDefFromCDef(chassis.Description.Id);
var mech = dm.VehicleDefs.Get(mid);
if (mech == null)
{
Control.Instance.LogError("Cannot find vehicle with id " + mid);
return(true);
}
__result = mech.VehicleTags;
return(false);
}
public static void Postfix(Turret __instance)
{
int init = Mod.Config.TurretPhases.UnitNone;
TagSet actorTags = __instance.GetTags();
if (actorTags != null && actorTags.Contains("unit_light"))
{
init = Mod.Config.TurretPhases.UnitLight;
}
else if (actorTags != null && actorTags.Contains("unit_medium"))
{
init = Mod.Config.TurretPhases.UnitMedium;
}
else if (actorTags != null && actorTags.Contains("unit_heavy"))
{
init = Mod.Config.TurretPhases.UnitHeavy;
}
Mod.Log.Debug?.Write($"Setting baseInit for turret: {CombatantUtils.Label(__instance)} to {init}");
__instance.StatCollection.Set <int>(ModStats.BaseInitiative, init);
}
public static float MeleeTonnage(this Turret turret)
{
float tonnage = Mod.Config.Melee.Turrets.DefaultTonnage;
TagSet actorTags = turret.GetTags();
if (actorTags != null && actorTags.Contains(ModConsts.Turret_Tag_Class_Light))
{
tonnage = Mod.Config.Melee.Turrets.LightTonnage;
}
else if (actorTags != null && actorTags.Contains(ModConsts.Turret_Tag_Class_Medium))
{
tonnage = Mod.Config.Melee.Turrets.LightTonnage;
}
else if (actorTags != null && actorTags.Contains(ModConsts.Turret_tag_Class_Heavy))
{
tonnage = Mod.Config.Melee.Turrets.LightTonnage;
}
return(tonnage);
}
public RuleDocument Process(TokenStream stream)
{
stream.MoveTo(0);
// Look for yaml header
var metadata = YamlHeader(stream);
RuleDocument doc = null;
// Process sections
while (!stream.EOF)
{
if (IsHeading(stream.Current, RULE_NAME_HEADING_LEVEL))
{
doc = new RuleDocument(stream.Current.Text)
{
Annotations = TagSet.FromDictionary(metadata)
};
}
else if (doc != null && IsHeading(stream.Current, RULE_ENTRIES_HEADING_LEVEL))
{
var matching = Synopsis(stream, doc) ||
Description(stream, doc) ||
Recommendation(stream, doc) ||
Notes(stream, doc) ||
RelatedLinks(stream, doc);
if (matching)
{
continue;
}
}
// Skip the current token
stream.Next();
}
return(doc);
}
public ServerDescription(
ServerId serverId,
EndPoint endPoint,
ServerState state,
ServerType type,
TimeSpan averageRoundTripTime,
ReplicaSetConfig replicaSetConfig,
TagSet tags,
SemanticVersion version,
Range <int> wireVersionRange)
: this(
averageRoundTripTime,
endPoint,
replicaSetConfig,
serverId,
state,
tags,
type,
version,
wireVersionRange)
{
}
public ExceptionlessConfiguration(IDependencyResolver resolver)
{
if (resolver == null)
{
throw new ArgumentNullException("resolver");
}
ServerUrl = DEFAULT_SERVER_URL;
UserAgent = DEFAULT_USER_AGENT;
SubmissionBatchSize = DEFAULT_SUBMISSION_BATCH_SIZE;
Enabled = true;
QueueMaxAge = TimeSpan.FromDays(7);
QueueMaxAttempts = 3;
DefaultTags = new TagSet();
DefaultData = new DataDictionary();
Settings = new SettingsDictionary();
IncludePrivateInformation = true;
_resolver = resolver;
EventPluginManager.AddDefaultPlugins(this);
}
void ApplyTags( TagSet s, string filename )
{
ShouldProcessReason reason;
bool sprocess = ShouldProcess("Applying tags to file \"" + filename + "\""
, "Should-we modify \"" + filename + "\" to apply tags to it?"
, "File modification confirmation"
, out reason);
if (!sprocess) return;
try {
var f = TagLib.File.Create(filename);
s.InjectIn(f.Tag);
f.Save();
if (passThru)
WriteObject(s);
}
catch (TagLib.UnsupportedFormatException e)
{
var err = new ErrorRecord(e, "The format is unsupported by get-tags", ErrorCategory.InvalidArgument, filename);
WriteError(err);
}
catch (System.IO.FileNotFoundException e)
{
var err = new ErrorRecord(e, "File doesn't exist", ErrorCategory.ResourceUnavailable, filename);
WriteError(err);
}
catch (TagLib.CorruptFileException e)
{
var err = new ErrorRecord(e, "File is corrupted", ErrorCategory.InvalidData, filename);
WriteError(err);
}
catch (Exception e)
{
WriteDebug(e.ToString());
}
}
public void Tags_should_parse_document_correctly()
{
var subject = new IsMasterResult(BsonDocument.Parse("{ tags: { a: \"one\", b: \"two\" } }"));
var expected = new TagSet(new[] { new Tag("a", "one"), new Tag("b", "two") });
subject.Tags.Should().Be(expected);
}
public void TestReadPreference_SecondaryWithTwoTagSets()
{
var tagSets = new TagSet[]
{
new TagSet(new [] { new Tag("dc", "ny"), new Tag("rack", "1") }),
new TagSet(new [] { new Tag("dc", "sf") })
};
var readPreference = new ReadPreference(ReadPreferenceMode.Secondary, tagSets);
var built = new MongoUrlBuilder { Server = _localhost, ReadPreference = readPreference };
var connectionString = "mongodb://localhost/?readPreference=secondary;readPreferenceTags=dc:ny,rack:1;readPreferenceTags=dc:sf";
foreach (var builder in EnumerateBuiltAndParsedBuilders(built, connectionString))
{
Assert.AreEqual(ReadPreferenceMode.Secondary, builder.ReadPreference.ReadPreferenceMode);
var builderTagSets = builder.ReadPreference.TagSets.ToArray();
Assert.AreEqual(2, builderTagSets.Length);
var builderTagSet1Tags = builderTagSets[0].Tags.ToArray();
var builderTagSet2Tags = builderTagSets[1].Tags.ToArray();
Assert.AreEqual(2, builderTagSet1Tags.Length);
Assert.AreEqual(new Tag("dc", "ny"), builderTagSet1Tags[0]);
Assert.AreEqual(new Tag("rack", "1"), builderTagSet1Tags[1]);
Assert.AreEqual(1, builderTagSet2Tags.Length);
Assert.AreEqual(new Tag("dc", "sf"), builderTagSet2Tags[0]);
Assert.AreEqual(connectionString, builder.ToString());
}
}
public Event() {
Tags = new TagSet();
Data = new DataDictionary();
}
public void ContainsAll_should_return_true_if_all_required_tags_are_present()
{
var tagSet = new TagSet(new[] { new Tag("name1", "value1"), new Tag("name2", "value2") });
var required = new TagSet(new[] { new Tag("name1", "value1") });
tagSet.ContainsAll(required).Should().BeTrue();
}
public void Equals_should_return_false_if_any_field_is_not_the_same()
{
var tagSet1 = new TagSet(new[] { new Tag("name1", "value1") });
var tagSet2 = new TagSet(new[] { new Tag("name2", "value2") });
tagSet1.Equals(tagSet2).Should().BeFalse();
tagSet1.Equals((object)tagSet2).Should().BeFalse();
}
public void Constructor_with_two_tag_should_create_tag_set_with_two_tags()
{
var tags = new[] { new Tag("name1", "value1"), new Tag("name2", "value2") };
var tagSet = new TagSet(tags);
tagSet.Tags.Should().Equal(tags);
}
public void ContainsAll_should_return_false_if_any_required_tag_is_missing()
{
var tagSet = new TagSet(new[] { new Tag("name1", "value1"), new Tag("name2", "value2") });
var required = new TagSet(new[] { new Tag("name1", "value1"), new Tag("name3", "value3") });
tagSet.ContainsAll(required).Should().BeFalse();
}
public void Constructor_with_no_tags_should_create_empty_tag_set()
{
var tags = new Tag[0];
var tagSet = new TagSet(tags);
tagSet.Tags.Count.Should().Be(0);
}
public void Constructor_with_one_tag_should_create_tag_set_with_one_tag()
{
var tags = new[] { new Tag("name", "value") };
var tagSet = new TagSet(tags);
tagSet.Tags.Should().Equal(tags);
}
public void Constructor_should_create_new_tag_list()
{
var tags = new[] { new Tag("name", "value") };
var tagSet = new TagSet(tags);
tagSet.Tags.Should().NotBeSameAs(tags);
}
public void Constructor_with_no_arguments_should_create_empty_tag_set()
{
var tagSet = new TagSet();
tagSet.Tags.Count.Should().Be(0);
}
public void Equals_should_return_true_if_all_fields_are_the_same()
{
var tagSet1 = new TagSet(new[] { new Tag("name", "value") });
var tagSet2 = new TagSet(new[] { new Tag("name", "value") });
tagSet1.Equals(tagSet2).Should().BeTrue();
tagSet1.Equals((object)tagSet2).Should().BeTrue();
}
public void Equals_should_return_false_if_rhs_is_not_a_TagSet()
{
var tagSet1 = new TagSet(new[] { new Tag("name", "value") });
tagSet1.Equals((object)"abc").Should().BeFalse();
}
public void When_two_sets_of_readPreferenceTags_are_specified()
{
var subject = new ConnectionString("mongodb://localhost?readPreferenceTags=dc:east,rack:1&readPreferenceTags=dc:west,rack:2");
var tagSet1 = new TagSet(new List<Tag>
{
new Tag("dc", "east"),
new Tag("rack", "1")
});
var tagSet2 = new TagSet(new List<Tag>
{
new Tag("dc", "west"),
new Tag("rack", "2")
});
subject.ReadPreferenceTags.Count.Should().Be(2);
subject.ReadPreferenceTags[0].Should().Be(tagSet1);
subject.ReadPreferenceTags[1].Should().Be(tagSet2);
}
public Error() {
Tags = new TagSet();
}
/// <summary>
/// Marks the error as being a critical occurrence.
/// </summary>
public void MarkAsCritical() {
if (Tags == null)
Tags = new TagSet();
Tags.Add("Critical");
}
