public static SqlString tagSet(SqlString tags, SqlString name, SqlString value)
{
return(TagHelper.SetValue(tags.Value, name.Value, value.Value));
}
/// <summary>
/// Bulk tag creation.
/// </summary>
/// <param name="settings">The settings.</param>
/// <returns></returns>
public Result <BulkResults> BulkCreate(string dataSetName, List <Tag> tags, int parallelLimit, long requestSize)
{
var results = new BulkResults();
var tagIsInteger = DataSet(dataSetName).TagIsInteger;
if (tagIsInteger && tags.Any(tag => tag.Id.Any(ch => !char.IsDigit(ch))))
{
results.Results = tags
.Where(tag => tag.Id.Any(ch => !char.IsDigit(ch)))
.Select(t => BulkResult.Create(
t.Id,
StatusCodes.Status400BadRequest,
string.Format(TagResources.TagIdShouldBeIntegerType, t.ParentId, t.Id)))
.ToList();
return(Result.Ok(results));
}
var tagIdsByLevel = TagHelper.GetTagIdsByLevel(tags, item => item.ParentId, item => item.Id);
var validIds = tagIdsByLevel.SelectMany(l => l.Value).ToList();
var invalidIds = tags.Select(t => t.Id).Except(validIds);
if (invalidIds.Any())
{
results.Results = tags
.Where(t => invalidIds.Contains(t.Id))
.Select(t => BulkResult.Create(t.Id, StatusCodes.Status404NotFound, string.Format(TagResources.ParentId_0_NotFoundInTagWithId_1, t.ParentId, t.Id))).ToList();
// returns with OK status, individual items contain error code
return(Result.Ok(results));
}
var orderedTagElasticList = tagIdsByLevel
.SelectMany(dic => dic.Value)
.Select(id =>
{
var tag = tags.FirstOrDefault(t => t.Id == id);
var tagElastic = new TagElastic
{
Id = tag.Id,
Name = tag.Name,
ParentIdList = new List <string>()
};
if (!string.IsNullOrWhiteSpace(tag.ParentId))
{
tagElastic.ParentIdList.Add(tag.ParentId);
}
return(tagElastic);
})
.ToList();
TagHelper.AdjustTagElastics(orderedTagElasticList);
var tagQuery = TagQuery(dataSetName);
tagQuery.DeleteAll();
var bulkResponseStruct = tagQuery.ParallelBulkIndex(orderedTagElasticList, parallelLimit, requestSize);
results.Results.AddRange(bulkResponseStruct.ToBulkResult());
return(Result.Ok(results));
}
void OnGUI()
{
bool playerError = false;
bool detectionError = false;
bool reachError = false;
bool tagError = false;
playerError = GameObject.FindGameObjectWithTag("Player") == null;
if (!playerError)
{
if (GUILayout.Button(Styles.PlayerTagTrue, Styles.helpbox))
{
infoString = "An object with the tag 'Player' was found.";
}
detectionError = GameObject.FindGameObjectWithTag("Player").GetComponent <DoorDetectionLite>() == null;
if (!detectionError)
{
if (GUILayout.Button(Styles.DetectionTrue, Styles.helpbox))
{
infoString = "The detection script component was found attached to the player.";
}
reachError = GameObject.FindGameObjectWithTag("Player").GetComponent <DoorDetectionLite>().Reach == 0;
if (!reachError)
{
if (GUILayout.Button(Styles.ReachTrue, Styles.helpbox))
{
infoString = "The reach variable is not 0. \n";
}
}
else if (reachError)
{
if (GUILayout.Button(Styles.ReachFalse, Styles.helpbox))
{
infoString = "The reach variable is 0. \n";
EditorGUIUtility.PingObject(GameObject.FindGameObjectWithTag("Player").GetComponent <DoorDetectionLite>());
}
}
}
else if (detectionError)
{
if (GUILayout.Button(Styles.DetectionFalse, Styles.helpbox))
{
EditorGUIUtility.PingObject(GameObject.FindGameObjectWithTag("Player"));
infoString = "The player doesn't have the detection script attached to it.";
}
if (GUILayout.Button(Styles.ReachUnknown, Styles.helpbox))
{
infoString = "There is no information on the reach variable.";
EditorGUIUtility.PingObject(GameObject.FindGameObjectWithTag("Player"));
}
}
}
else if (playerError)
{
if (GUILayout.Button(Styles.PlayerTagFalse, Styles.helpbox))
{
infoString = "There was no object found with the tag 'Player'.";
}
if (GUILayout.Button(Styles.DetectionUnknown, Styles.helpbox))
{
infoString = "There is no information on the detection script.";
}
if (GUILayout.Button(Styles.ReachUnknown, Styles.helpbox))
{
infoString = "There is no information on the reach variable.";
}
}
tagError = TagHelper.DoesDoorTagNotExist();
if (!tagError)
{
if (GUILayout.Button(Styles.TagTrue, Styles.helpbox))
{
infoString = "The tag 'Door' has been created. \n";
}
}
else if (tagError)
{
if (GUILayout.Button(Styles.TagFalse, Styles.helpbox))
{
infoString = ("The tag 'Door' has not yet been created. \n");
}
}
if (playerError || tagError || reachError || detectionError)
{
EditorGUILayout.LabelField(infoString, Styles.helpbox);
}
else
{
EditorGUILayout.LabelField("No errors found! \n", Styles.helpbox);
}
EditorGUILayout.Space();
GUILayout.Label("V1.1.0", Styles.centeredVersionLabel);
EditorGUILayout.Space();
}
public void ReturnsTrueForBothNull()
{
Assert.IsTrue(TagHelper.AreTagsEqual(null, null));
}
public void ReturnsFalseForDifferentCasingStrings()
{
Assert.IsFalse(TagHelper.AreTagsEqual("Catel", "catel"));
}
/// <summary>
/// Registers the object and automatically watches the object. As soon as the <see cref="INotifyPropertyChanged.PropertyChanged"/> event
/// occurs, it will automatically create a backup of the property to support undo.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="tag">The tag.</param>
/// <exception cref="ArgumentNullException">The <paramref name="instance"/> is <c>null</c>.</exception>
public void RegisterObject(INotifyPropertyChanged instance, object tag = null)
{
Argument.IsNotNull("instance", instance);
Log.Debug("Registering object of type '{0}' with tag '{1}'", instance.GetType().Name, TagHelper.ToString(tag));
if (!_observers.ContainsKey(instance))
{
_observers[instance] = new ObjectObserver(instance, tag, this);
Log.Debug("Registered object");
}
else
{
Log.Debug("Object already registered, not registered");
}
}
public void InitTags(string customData)
{
if (string.IsNullOrWhiteSpace(customData) == false)
{
var descSplit = customData.Split('\n');
foreach (var tag in descSplit)
{
//UseChat
if (tag.Contains("[UseChat:") == true)
{
UseChat = TagHelper.TagBoolCheck(tag);
}
//ChatMinTime
if (tag.Contains("[MinTime:") == true)
{
MinTime = TagHelper.TagIntCheck(tag, MinTime);
}
//ChatMaxTime
if (tag.Contains("[MaxTime:") == true)
{
MaxTime = TagHelper.TagIntCheck(tag, MaxTime);
}
//ChatStartsReady
if (tag.Contains("[StartsReady:") == true)
{
StartsReady = TagHelper.TagBoolCheck(tag);
}
//ChatChance
if (tag.Contains("[Chance:") == true)
{
Chance = TagHelper.TagIntCheck(tag, Chance);
}
//MaxChats
if (tag.Contains("[MaxChats:") == true)
{
MaxChats = TagHelper.TagIntCheck(tag, MaxChats);
}
//BroadcastRandomly
if (tag.Contains("[BroadcastRandomly:") == true)
{
BroadcastRandomly = TagHelper.TagBoolCheck(tag);
}
//ChatMessages
if (tag.Contains("[ChatMessages:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempValue) == false)
{
ChatMessages.Add(tempValue);
}
}
//ChatAudio
if (tag.Contains("[ChatAudio:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempValue) == false)
{
ChatAudio.Add(tempValue);
}
}
//ChatAvatar
if (tag.Contains("[ChatAvatar:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempValue) == false)
{
ChatAvatar.Add(tempValue);
}
}
//SendToAllOnlinePlayers
if (tag.Contains("[SendToAllOnlinePlayers:") == true)
{
SendToAllOnlinePlayers = TagHelper.TagBoolCheck(tag);
}
//GPSLabel
if (tag.Contains("[GPSLabel:"))
{
GPSLabel = TagHelper.TagStringCheck(tag);
}
//BroadcastChatType
if (tag.Contains("[BroadcastChatType:") == true)
{
BroadcastChatType.Add(TagHelper.TagBroadcastTypeEnumCheck(tag));
}
//Author
if (tag.Contains("[Author:") == true)
{
Author = TagHelper.TagStringCheck(tag);
}
//Color
if (tag.Contains("[Color:") == true)
{
Color = TagHelper.TagStringCheck(tag);
}
//IgnoreAntennaRequirement
if (tag.Contains("[IgnoreAntennaRequirement:") == true)
{
IgnoreAntennaRequirement = TagHelper.TagBoolCheck(tag);
}
//IgnoredAntennaRangeOverride
if (tag.Contains("[IgnoredAntennaRangeOverride:") == true)
{
IgnoredAntennaRangeOverride = TagHelper.TagDoubleCheck(tag, IgnoredAntennaRangeOverride);
}
//UseRandomNameGeneratorFromMES
if (tag.Contains("[UseRandomNameGeneratorFromMES:") == true)
{
UseRandomNameGeneratorFromMES = TagHelper.TagBoolCheck(tag);
}
//ChatVolumeMultiplier
if (tag.Contains("[ChatVolumeMultiplier:") == true)
{
ChatVolumeMultiplier.Add(TagHelper.TagFloatCheck(tag, 1));
}
}
}
if (MinTime > MaxTime)
{
MinTime = MaxTime;
}
if (StartsReady == true)
{
SecondsUntilChat = 0;
}
else
{
SecondsUntilChat = Rnd.Next(MinTime, MaxTime);
}
}
private string GetFormattedTripleTag(string key, string value)
{
return(TagHelper.GetFormattedTripleTag(key, value));
}
public static async Task <string> RenderAsync(this TagHelper tagHelper, TagHelperAttributeList attributeList, TagHelperContext context, HtmlEncoder htmlEncoder, string tagName = "div", TagMode tagMode = TagMode.SelfClosing)
{
var innerOutput = await tagHelper.ProcessAndGetOutputAsync(attributeList, context, tagName, tagMode);
return(innerOutput.Render(htmlEncoder));
}
/// <summary>
/// FindEntriesByTag.
/// </summary>
/// <param name="TenantTag">En sträng<see cref="string"/> med koden till hyresgästens tagg.</param>
/// <returns>En DataTable<see cref="DataTable"/> med sökresultat.</returns>
public static DataTable FindEntriesByTag(string TenantTag)
{
return(TagHelper.FindEntriesByTag(TenantTag, MaxEntries));
}
public void InitTags(string customData)
{
if (string.IsNullOrWhiteSpace(customData) == false)
{
var descSplit = customData.Split('\n');
foreach (var tag in descSplit)
{
//UseConditions
if (tag.Contains("[UseConditions:") == true)
{
this.UseConditions = TagHelper.TagBoolCheck(tag);
}
//MatchAnyCondition
if (tag.Contains("[MatchAnyCondition:") == true)
{
this.MatchAnyCondition = TagHelper.TagBoolCheck(tag);
}
//CheckAllLoadedModIDs
if (tag.Contains("[CheckAllLoadedModIDs:") == true)
{
this.CheckAllLoadedModIDs = TagHelper.TagBoolCheck(tag);
}
//AllModIDsToCheck
if (tag.Contains("[AllModIDsToCheck:") == true)
{
var tempValue = TagHelper.TagLongCheck(tag, 0);
if (tempValue != 0)
{
this.AllModIDsToCheck.Add(tempValue);
}
}
//CheckAnyLoadedModIDs
if (tag.Contains("[CheckAnyLoadedModIDs:") == true)
{
this.CheckAnyLoadedModIDs = TagHelper.TagBoolCheck(tag);
}
//AnyModIDsToCheck
if (tag.Contains("[AnyModIDsToCheck:") == true)
{
var tempValue = TagHelper.TagLongCheck(tag, 0);
if (tempValue != 0)
{
this.AnyModIDsToCheck.Add(tempValue);
}
}
//CheckTrueBooleans
if (tag.Contains("[CheckTrueBooleans:") == true)
{
this.CheckTrueBooleans = TagHelper.TagBoolCheck(tag);
}
//TrueBooleans
if (tag.Contains("[TrueBooleans:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempValue) == false)
{
this.TrueBooleans.Add(tempValue);
}
}
//CheckCustomCounters
if (tag.Contains("[CheckCustomCounters:") == true)
{
this.CheckCustomCounters = TagHelper.TagBoolCheck(tag);
}
//CustomCounters
if (tag.Contains("[CustomCounters:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempValue) == false)
{
this.CustomCounters.Add(tempValue);
}
}
//CustomCountersTargets
if (tag.Contains("[CustomCountersTargets:") == true)
{
var tempValue = TagHelper.TagIntCheck(tag, 0);
if (tempValue != 0)
{
this.CustomCountersTargets.Add(tempValue);
}
}
//CheckTrueSandboxBooleans
if (tag.Contains("[CheckTrueSandboxBooleans:") == true)
{
this.CheckTrueSandboxBooleans = TagHelper.TagBoolCheck(tag);
}
//TrueSandboxBooleans
if (tag.Contains("[TrueSandboxBooleans:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempValue) == false)
{
this.TrueSandboxBooleans.Add(tempValue);
}
}
//CheckCustomSandboxCounters
if (tag.Contains("[CheckCustomSandboxCounters:") == true)
{
this.CheckCustomSandboxCounters = TagHelper.TagBoolCheck(tag);
}
//CustomSandboxCounters
if (tag.Contains("[CustomSandboxCounters:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempValue) == false)
{
this.CustomSandboxCounters.Add(tempValue);
}
}
//CustomSandboxCountersTargets
if (tag.Contains("[CustomSandboxCountersTargets:") == true)
{
var tempValue = TagHelper.TagIntCheck(tag, 0);
if (tempValue != 0)
{
this.CustomSandboxCountersTargets.Add(tempValue);
}
}
//CheckGridSpeed
if (tag.Contains("[CheckGridSpeed:") == true)
{
this.CheckGridSpeed = TagHelper.TagBoolCheck(tag);
}
//MinGridSpeed
if (tag.Contains("[MinGridSpeed:") == true)
{
this.MinGridSpeed = TagHelper.TagFloatCheck(tag, this.MinGridSpeed);
}
//MaxGridSpeed
if (tag.Contains("[MaxGridSpeed:") == true)
{
this.MaxGridSpeed = TagHelper.TagFloatCheck(tag, this.MaxGridSpeed);
}
//CheckMESBlacklistedSpawnGroups
if (tag.Contains("[CheckMESBlacklistedSpawnGroups:") == true)
{
this.CheckMESBlacklistedSpawnGroups = TagHelper.TagBoolCheck(tag);
}
//SpawnGroupBlacklistContainsAll
if (tag.Contains("[SpawnGroupBlacklistContainsAll:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempValue) == false)
{
this.SpawnGroupBlacklistContainsAll.Add(tempValue);
}
}
//SpawnGroupBlacklistContainsAny
if (tag.Contains("[SpawnGroupBlacklistContainsAny:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempValue) == false)
{
this.SpawnGroupBlacklistContainsAny.Add(tempValue);
}
}
}
}
}
public static IEnumerable tagRead(SqlString tag)
{
return(TagHelper.Parse(tag.Value).OrderBy(_ => _.Key));
}
public static SqlBoolean tagMatch(SqlString tags, SqlString name)
{
return(TagHelper.Match(tags.Value, name.Value));
}
public static SqlString tagGet(SqlString tags, SqlString name)
{
return(TagHelper.Value(tags.Value, name.Value));
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="mText">经过处理的标签文本（去除空格 \s*、br/hr替换）</param>
/// <param name="mOrigin">原始标签文本</param>
/// <param name="mDeep">嵌套深度</param>
/// <param name="config">配置</param>
/// <param name="no_">标签的递增编码</param>
protected BaseTag(string mText, string mOrigin, int mDeep, TagConfig config, int no_)
{
this.Config = config;
this.Deep = mDeep;
this.Text = mText;
this.Origin = mOrigin;
this.NO_ = no_;
this.TagName = string.Concat(this.GetType().Name, "_", this.Text.Length, TagHelper.RandomNext(999), "_", (this.NO_ + 1));
this.PlaceHolderName = string.Concat("#", this.TagName, "#");
this.In_Pairs = this.Text.LastIndexOf('/') != this.Text.Length - 2;
this.Discover();
}
public static ScikitOnnxContext ToOnnx(IDataTransform trans, ref string[] inputs, ref string[] outputs,
string name = null, string producer = "Scikit.ML",
long version = 0, string domain = "onnx.ai.ml",
OnnxVersion onnxVersion = OnnxVersion.Stable,
IDataView[] begin = null, IHostEnvironment host = null)
{
if (host == null)
{
/*using (*/
var env = new DelegateEnvironment(0);/*)*/
return(ToOnnx(trans, ref inputs, ref outputs, name, producer, version, domain, onnxVersion, begin, env));
}
if (name == null)
{
name = trans.GetType().Name;
}
GuessOutputs(trans, ref outputs);
GuessInputs(trans, ref inputs, begin);
if (inputs == null || inputs.Length == 0)
{
throw host.Except("Inputs cannot be empty.");
}
if (outputs == null || outputs.Length == 0)
{
throw host.Except("Outputs cannot be empty.");
}
var assembly = System.Reflection.Assembly.GetExecutingAssembly();
var versionInfo = System.Diagnostics.FileVersionInfo.GetVersionInfo(assembly.Location);
var ctx = new ScikitOnnxContext(host, name, producer, versionInfo.FileVersion,
version, domain, onnxVersion);
var hasin = new HashSet <string>(inputs);
var uniqueVars = EnumerateVariables(trans, begin).ToArray();
var mapInputType = new Dictionary <string, DataViewType>();
foreach (var it in uniqueVars.Where(c => c.position == TagHelper.GraphPositionEnum.first))
{
mapInputType[it.variableName] = it.variableType;
}
foreach (var col in inputs)
{
ctx.AddInputVariable(mapInputType[col], col);
}
var views = TagHelper.EnumerateAllViews(trans, begin);
var transforms = views.Where(c => (c.Item1 as IDataTransform) != null)
.Select(c => c.Item1)
.ToArray();
foreach (var tr in transforms.Reverse())
{
var tron = tr as ICanSaveOnnx;
if (tron == null)
{
throw host.ExceptNotSupp($"Transform {tr.GetType()} cannot be saved in Onnx format.");
}
if (!tron.CanSaveOnnx(ctx))
{
throw host.ExceptNotSupp($"Transform {tr.GetType()} cannot be saved in ONNX format.");
}
var tron2 = tron as ISaveAsOnnx;
if (!tron2.CanSaveOnnx(ctx))
{
throw host.ExceptNotSupp($"Transform {tr.GetType()} does not implement SaveAsOnnx.");
}
tron2.SaveAsOnnx(ctx);
}
var mapOuputType = new Dictionary <string, DataViewType>();
foreach (var it in uniqueVars.Where(c => c.position == TagHelper.GraphPositionEnum.last))
{
mapOuputType[it.variableName] = it.variableType;
}
foreach (var col in outputs)
{
var variableName = ctx.TryGetVariableName(col);
var trueVariableName = ctx.AddIntermediateVariable(null, col, true);
ctx.CreateNode("Identity", variableName, trueVariableName, ctx.GetNodeName("Identity"), "");
ctx.AddOutputVariable(mapOuputType[col], trueVariableName);
}
return(ctx);
}
public void InitTags()
{
//TODO: Try To Get Triggers From Block Storage At Start
//Start With This Class
if (string.IsNullOrWhiteSpace(RemoteControl.CustomData) == true)
{
return;
}
var descSplit = RemoteControl.CustomData.Split('\n');
foreach (var tag in descSplit)
{
//Triggers
if (tag.Contains("[Triggers:") == true)
{
bool gotTrigger = false;
var tempValue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempValue) == false)
{
byte[] byteData = { };
if (TagHelper.TriggerObjectTemplates.TryGetValue(tempValue, out byteData) == true)
{
try {
var profile = MyAPIGateway.Utilities.SerializeFromBinary <TriggerProfile>(byteData);
if (profile != null)
{
gotTrigger = AddTrigger(profile);
}
} catch (Exception e) {
Logger.MsgDebug("Exception In Trigger Setup for Tag: " + tag, DebugTypeEnum.BehaviorSetup);
Logger.MsgDebug(e.ToString(), DebugTypeEnum.BehaviorSetup);
}
}
}
if (!gotTrigger)
{
Logger.MsgDebug("Could Not Find Trigger Profile Associated To Tag: " + tag, DebugTypeEnum.BehaviorSetup);
}
}
//TriggerGroups
if (tag.Contains("[TriggerGroups:") == true)
{
bool gotTrigger = false;
var tempValue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempValue) == false)
{
byte[] byteData = { };
if (TagHelper.TriggerGroupObjectTemplates.TryGetValue(tempValue, out byteData) == true)
{
try {
var profile = MyAPIGateway.Utilities.SerializeFromBinary <TriggerGroupProfile>(byteData);
if (profile != null)
{
gotTrigger = true;
foreach (var trigger in profile.Triggers)
{
AddTrigger(trigger);
}
}
} catch (Exception) {
}
}
}
if (!gotTrigger)
{
Logger.WriteLog("Could Not Find Trigger Group Profile Associated To Tag: " + tag);
}
}
}
}
public void Process()
{
TagHelper.Process(null, TagHelperOutput);
}
/// <summary>
/// Registers the collection and automatically. As soon as the <see cref="INotifyCollectionChanged.CollectionChanged"/> event
/// occurs, it will automatically create a backup of the collection to support undo.
/// </summary>
/// <param name="collection">The collection.</param>
/// <param name="tag">The tag.</param>
/// <exception cref="ArgumentNullException">The <paramref name="collection"/> is <c>null</c>.</exception>
public void RegisterCollection(INotifyCollectionChanged collection, object tag = null)
{
Argument.IsNotNull("collection", collection);
Log.Debug("Registering collection of type '{0}' with tag '{1}'", collection.GetType().Name, TagHelper.ToString(tag));
if (!_observers.ContainsKey(collection))
{
_observers[collection] = new CollectionObserver(collection, tag, this);
Log.Debug("Registered collection");
}
else
{
Log.Debug("Collection already registered, not registered");
}
}
public IHtmlContent Render(TModel entity)
{
return(TagHelper.Combine(string.Empty));
}
public ActionResult Detail(int id, Company model, string returnUrl, FormCollection m)
{
ViewBag.ReturnUrl = returnUrl;
ViewBag.tags = m["tags"];
int myid = id;
DateTime?dtm = null;
if (m["FirstContactRaw"].Trim().Length > 0)
{
bool isokA = false;
dtm = DateHelper.ConvertDate(m["FirstContactRaw"], out isokA);
if (!isokA || dtm == null)
{
ModelState.AddModelError("", "Chybný formát data pro Datum prvního kontaktu.");
}
if (!isokA)
{
return(View(model));
}
}
using (var scope = new TransactionScope(
TransactionScopeOption.RequiresNew,
new TransactionOptions()
{
IsolationLevel = IsolationLevel.ReadCommitted
}))
{
Entities cx = new Entities();
model.FirstContact = dtm;
//update NonProfitOrg
Company p = null;
try
{
if (model.Id == 0)
{
p = model;
cx.Company.Add(p);
p.Updated = DateTime.UtcNow;
p.UpdatedBy = NonProfitCRM.Components.SystemHelper.GetUserName;
Logger.Log(NonProfitCRM.Components.SystemHelper.GetUserName, "Create Company " + model.Name + " / " + p.IdentificationNumber, null, model,
"Company", p.Id);
cx.SaveChanges();
myid = p.Id;
}
else
{
p = cx.Company.Single(e => e.Id == id);
string _oldObject = Logger.Serialize(p);
p.StatusId = model.StatusId;
p.Address = model.Address;
p.Insurance = model.Insurance;
p.City = model.City;
p.Contact1Email = model.Contact1Email;
p.Contact1Name = model.Contact1Name;
p.Contact1Note = model.Contact1Note;
p.Contact1Phone = model.Contact1Phone;
p.Contact2Email = model.Contact2Email;
p.Contact2Name = model.Contact2Name;
p.Contact2Note = model.Contact2Note;
p.Contact2Phone = model.Contact2Phone;
p.CountryId = model.CountryId;
p.IdentificationNumber = model.IdentificationNumber;
p.Name = model.Name;
p.Note = model.Note;
p.RegionId = model.RegionId;
p.Www = model.Www;
p.FirstContact = model.FirstContact;
p.ContactPerson = model.ContactPerson;
p.Updated = DateTime.UtcNow;
p.UpdatedBy = NonProfitCRM.Components.SystemHelper.GetUserName;
cx.SaveChanges();
Logger.Log(NonProfitCRM.Components.SystemHelper.GetUserName, "Modify Company " + model.Name + " / " + p.IdentificationNumber,
_oldObject, Logger.Serialize(p), "Company", p.Id);
}
TagHelper.SetTags(p.Id, "Company", m["tags"], cx);
}
catch (DbUpdateException e)
{
var sqlException = e.GetBaseException() as SqlException;
if (sqlException != null)
{
if (sqlException.Errors.Count > 0)
{
switch (sqlException.Errors[0].Number)
{
case 2601: // Foreign Key violation
ModelState.AddModelError("ICOIssue", "Firma nebo Lead se stejným IČ již existuje!");
return(View(model));
default:
throw;
}
}
}
else
{
throw;
}
}
scope.Complete();
StatisticsHelper.InvalidateCacheCRM();
}
if (id == 0 && (m["saveandtask"] != null))
{
return(RedirectToAction("Detail", new { id = myid, returnUrl = returnUrl }));
}
else
{
// redirect
if (returnUrl != null && returnUrl.Length > 0)
{
return(Redirect(returnUrl));
}
else
{
return(RedirectToAction("List", "Company"));
}
}
}
public void QPT79_Does_Not_Apply_Escapes_On_Set_Value()
{
var tag = TagHelper.SetValue("", "a", "x:/");
Assert.AreEqual("/a:x~`/", tag);
}
public void ReturnsTrueForEqualStrings()
{
Assert.IsTrue(TagHelper.AreTagsEqual("Catel", "Catel"));
}
public void Q346_Match_Test(string src, string mask, bool result)
{
Assert.AreEqual(result, TagHelper.Match(src, mask));
}
public void InitTags(string customData)
{
if (string.IsNullOrWhiteSpace(customData) == false)
{
var descSplit = customData.Split('\n');
foreach (var tag in descSplit)
{
//UseSpawn
if (tag.Contains("[UseSpawn:") == true)
{
UseSpawn = TagHelper.TagBoolCheck(tag);
}
//FirstSpawnTimeMs
if (tag.Contains("[FirstSpawnTimeMs:") == true)
{
FirstSpawnTimeMs = TagHelper.TagFloatCheck(tag, FirstSpawnTimeMs);
}
//SpawnMinCooldown
if (tag.Contains("[SpawnMinCooldown:") == true)
{
SpawnMinCooldown = TagHelper.TagFloatCheck(tag, SpawnMinCooldown);
}
//SpawnMaxCooldown
if (tag.Contains("[SpawnMaxCooldown:") == true)
{
SpawnMaxCooldown = TagHelper.TagFloatCheck(tag, SpawnMaxCooldown);
}
//MaxSpawns
if (tag.Contains("MaxSpawns:") == true)
{
MaxSpawns = TagHelper.TagIntCheck(tag, MaxSpawns);
}
//SpawnGroups
if (tag.Contains("SpawnGroups:") == true)
{
var tempvalue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempvalue) == false)
{
SpawnGroups.Add(tempvalue);
}
}
//UseRelativeSpawnPosition
if (tag.Contains("[UseRelativeSpawnPosition:") == true)
{
UseRelativeSpawnPosition = TagHelper.TagBoolCheck(tag);
}
//MinDistance
if (tag.Contains("[MinDistance:") == true)
{
MinDistance = TagHelper.TagDoubleCheck(tag, MinDistance);
}
//MaxDistance
if (tag.Contains("[MaxDistance:") == true)
{
MaxDistance = TagHelper.TagDoubleCheck(tag, MaxDistance);
}
//MinAltitude
if (tag.Contains("[MinAltitude:") == true)
{
MinAltitude = TagHelper.TagDoubleCheck(tag, MinAltitude);
}
//MaxAltitude
if (tag.Contains("[MaxAltitude:") == true)
{
MaxAltitude = TagHelper.TagDoubleCheck(tag, MaxAltitude);
}
//RelativeSpawnOffset
if (tag.Contains("[RelativeSpawnOffset:") == true)
{
RelativeSpawnOffset = TagHelper.TagVector3DCheck(tag);
}
//RelativeSpawnVelocity
if (tag.Contains("[RelativeSpawnVelocity:") == true)
{
RelativeSpawnVelocity = TagHelper.TagVector3DCheck(tag);
}
//IgnoreSafetyChecks
if (tag.Contains("[IgnoreSafetyChecks:") == true)
{
IgnoreSafetyChecks = TagHelper.TagBoolCheck(tag);
}
//InheritNpcAltitude
if (tag.Contains("[InheritNpcAltitude:") == true)
{
InheritNpcAltitude = TagHelper.TagBoolCheck(tag);
}
//ForceSameFactionOwnership
if (tag.Contains("[ForceSameFactionOwnership:") == true)
{
ForceSameFactionOwnership = TagHelper.TagBoolCheck(tag);
}
}
}
if (SpawnMinCooldown > SpawnMaxCooldown)
{
SpawnMinCooldown = SpawnMaxCooldown;
}
}
public void InitTags(string customData)
{
if (string.IsNullOrWhiteSpace(customData) == false)
{
var descSplit = customData.Split('\n');
foreach (var tag in descSplit)
{
//Type
if (tag.Contains("[Type:") == true)
{
Type = TagHelper.TagStringCheck(tag);
}
//UseTrigger
if (tag.Contains("[UseTrigger:") == true)
{
UseTrigger = TagHelper.TagBoolCheck(tag);
}
//InsideAntenna
if (tag.Contains("[InsideAntenna:") == true)
{
InsideAntenna = TagHelper.TagBoolCheck(tag);
}
//InsideAntennaName
if (tag.Contains("[InsideAntennaName:") == true)
{
InsideAntennaName = TagHelper.TagStringCheck(tag);
}
//TargetDistance
if (tag.Contains("[TargetDistance:") == true)
{
TargetDistance = TagHelper.TagDoubleCheck(tag, TargetDistance);
}
//MinCooldown
if (tag.Contains("[MinCooldownMs:") == true)
{
MinCooldownMs = TagHelper.TagFloatCheck(tag, MinCooldownMs);
}
//MaxCooldown
if (tag.Contains("[MaxCooldownMs:") == true)
{
MaxCooldownMs = TagHelper.TagFloatCheck(tag, MaxCooldownMs);
}
//StartsReady
if (tag.Contains("[StartsReady:") == true)
{
StartsReady = TagHelper.TagBoolCheck(tag);
}
//MaxActions
if (tag.Contains("[MaxActions:") == true)
{
MaxActions = TagHelper.TagIntCheck(tag, MaxActions);
}
//Actions
if (tag.Contains("[Actions:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
bool gotAction = false;
if (string.IsNullOrWhiteSpace(tempValue) == false)
{
byte[] byteData = { };
if (TagHelper.ActionObjectTemplates.TryGetValue(tempValue, out byteData) == true)
{
try {
var profile = MyAPIGateway.Utilities.SerializeFromBinary <ActionProfile>(byteData);
if (profile != null)
{
Actions.Add(profile);
gotAction = true;
}
} catch (Exception) {
}
}
}
if (!gotAction)
{
Logger.WriteLog("Could Not Find Action Profile Associated To Tag: " + tag);
}
}
//DamageTypes
if (tag.Contains("[DamageTypes:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
if (!string.IsNullOrWhiteSpace(tempValue) && DamageTypes.Contains(tempValue) == false)
{
DamageTypes.Add(tempValue);
}
}
//ExcludedDamageTypes
if (tag.Contains("[ExcludedDamageTypes:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
if (!string.IsNullOrWhiteSpace(tempValue) && ExcludedDamageTypes.Contains(tempValue) == false)
{
ExcludedDamageTypes.Add(tempValue);
}
}
//MinPlayerReputation
if (tag.Contains("[MinPlayerReputation:") == true)
{
MinPlayerReputation = TagHelper.TagIntCheck(tag, MinPlayerReputation);
}
//MaxPlayerReputation
if (tag.Contains("[MaxPlayerReputation:") == true)
{
MaxPlayerReputation = TagHelper.TagIntCheck(tag, MaxPlayerReputation);
}
//AllPlayersMustMatchReputation
if (tag.Contains("[AllPlayersMustMatchReputation:") == true)
{
AllPlayersMustMatchReputation = TagHelper.TagBoolCheck(tag);
}
//CustomReputationRangeCheck
if (tag.Contains("[CustomReputationRangeCheck:") == true)
{
CustomReputationRangeCheck = TagHelper.TagDoubleCheck(tag, CustomReputationRangeCheck);
}
//Conditions
if (tag.Contains("[Conditions:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
bool gotCondition = false;
if (string.IsNullOrWhiteSpace(tempValue) == false)
{
byte[] byteData = { };
if (TagHelper.ConditionObjectTemplates.TryGetValue(tempValue, out byteData) == true)
{
try {
var profile = MyAPIGateway.Utilities.SerializeFromBinary <ConditionProfile>(byteData);
if (profile != null)
{
Conditions = profile;
gotCondition = true;
}
} catch (Exception) {
}
}
}
if (!gotCondition)
{
Logger.WriteLog("Could Not Find Condition Profile Associated To Tag: " + tag);
}
}
//ConditionCheckResetsTimer
if (tag.Contains("[ConditionCheckResetsTimer:") == true)
{
ConditionCheckResetsTimer = TagHelper.TagBoolCheck(tag);
}
//CommandReceiveCode
if (tag.Contains("[CommandReceiveCode:") == true)
{
CommandReceiveCode = TagHelper.TagStringCheck(tag);
}
//PlayerNearPositionOffset
if (tag.Contains("[PlayerNearPositionOffset:") == true)
{
PlayerNearPositionOffset = TagHelper.TagVector3DCheck(tag);
}
//ActionExecution
if (tag.Contains("[ActionExecution:") == true)
{
ActionExecution = TagHelper.TagActionExecutionCheck(tag);
}
//SensorName
if (tag.Contains("[SensorName:") == true)
{
SensorName = TagHelper.TagStringCheck(tag);
}
//DespawnTypeFromSpawner
if (tag.Contains("[DespawnTypeFromSpawner:") == true)
{
DespawnTypeFromSpawner = TagHelper.TagStringCheck(tag);
}
}
}
if (MinCooldownMs > MaxCooldownMs)
{
MinCooldownMs = MaxCooldownMs;
}
if (StartsReady == true)
{
CooldownTime = 0;
}
else
{
CooldownTime = Rnd.Next((int)MinCooldownMs, (int)MaxCooldownMs);
}
}
/// <summary>
/// Gets the tags.
/// </summary>
/// <param name="withDetails">if set to <c>true</c> [with details].</param>
/// <returns></returns>
public List <Tag> GetTagModels(string dataSetName, bool withDetails)
{
var dataSet = DataSet(dataSetName).DataSet;
var tags = new List <Tag>();
var tagElastics = TagQuery(dataSetName).GetAll().Items;
var tagElasticsDic = tagElastics.ToDictionary(t => t.Id, t => t);
var wordQuery = queryFactory.GetWordQuery(dataSet.Name);
Dictionary <string, int> docCountDic = null;
Dictionary <string, int> wordCountDic = null;
if (withDetails)
{
docCountDic = DocumentQuery(dataSetName).CountForTags(tagElasticsDic.Keys.ToList(), dataSet.TagField);
// the text field contains the concatenate word also, so we have to use the interpretedfields
wordCountDic = wordQuery.CountForWord(dataSet.InterpretedFields.Select(Elastic.Queries.DocumentQuery.MapDocumentObjectName).ToList(), 1, tagElasticsDic.Keys.ToList(), Elastic.Queries.DocumentQuery.MapDocumentObjectName(dataSet.TagField));
}
foreach (var tagId in tagElasticsDic.Keys)
{
var tagElastic = tagElasticsDic[tagId];
var pathItems = tagElasticsDic
.Where(d => tagElastic.ParentIdList.Contains(d.Key))
.OrderBy(t => t.Value.Level)
.Select(d => new PathItem {
Id = d.Value.Id, Name = d.Value.Name, Level = d.Value.Level
})
.ToList();
var wordCount = 0;
var documentCount = 0;
if (withDetails)
{
documentCount = docCountDic[tagId];
wordCount = wordCountDic[tagId];
}
var tag = new Tag
{
Id = tagElastic.Id,
Name = tagElastic.Name,
ParentId = tagElastic.ParentId(),
Properties = new TagProperties
{
Paths = pathItems,
IsLeaf = tagElastic.IsLeaf,
Level = tagElastic.Level,
DocumentCount = documentCount,
WordCount = wordCount
}
};
tags.Add(tag);
}
if (withDetails)
{
var tagIdsByLevel = TagHelper.GetTagIdsByLevel(tags, p => p.ParentId, i => i.Id);
// Go leaf to root to add child document & word count to parent properties
if (tagIdsByLevel.Keys.Count > 1)
{
for (int level = tagIdsByLevel.Keys.Count - 2; level > 0; level--)
{
foreach (var tagIdByLevel in tagIdsByLevel[level])
{
var tag = tags.FirstOrDefault(t => t.Id == tagIdByLevel);
if (tag == null)
{
continue;
}
var childTags = tags.Where(t => t.ParentId == tagIdByLevel).ToList();
tag.Properties.DocumentCount += childTags.Sum(t => t.Properties.DocumentCount);
tag.Properties.WordCount += childTags.Sum(t => t.Properties.WordCount);
}
}
}
}
return(tags);
}
private static void ExportDataBlockToFile(DataBlock block, TextWriter writer, PortalPlc parentPlc)
{
block.CalcluateAddresses(parentPlc);
foreach (var entry in block)
{
AddDataEntry(entry, block.Name + ".", new Address());
}
void AddDataEntry(DataEntry entry, string entryPrefix, Address parentOffset)
{
var addressPrefix = "";
var type = "";
switch (entry.DataType)
{
case DataType.ARRAY:
TagHelper.ResolveArrayChildren(entry, parentPlc);
// write a new entry for each of the children
foreach (var child in entry.Children)
{
AddDataEntry(child, entryPrefix, entry.Address.Value + parentOffset);
}
break;
case DataType.BOOL:
addressPrefix = "DBX";
type = "Boolean";
break;
case DataType.BYTE:
addressPrefix = "DBB";
type = "Byte";
break;
case DataType.CHAR:
addressPrefix = "DBB";
type = "Char";
break;
case DataType.DATE:
case DataType.DATE_AND_TIME:
addressPrefix = "DATE";
type = "Date";
break;
case DataType.TIME:
case DataType.DINT:
addressPrefix = "DBD";
type = "Long";
break;
case DataType.DWORD:
addressPrefix = "DBD";
type = "Dword";
break;
case DataType.INT:
addressPrefix = "DBW";
type = "Short";
break;
case DataType.REAL:
addressPrefix = "DBD";
type = "Float";
break;
case DataType.STRING:
addressPrefix = "STRING";
type = "String";
break;
case DataType.UDT:
case DataType.STRUCT:
entry.CalcluateAddresses(parentPlc);
foreach (var child in entry)
{
AddDataEntry(child, entryPrefix + entry.Name + ".", entry.Address.Value + parentOffset);
}
break;
case DataType.WORD:
addressPrefix = "DBW";
type = "Word";
break;
default:
throw new SiemensException("Data type: '" + entry.DataType.ToString() + "' not supported.");
}
if (TagHelper.IsPrimitive(entry.DataType))
{
var absoluteAddress = parentOffset + entry.Address.Value;
var addressString = "DB" + block.Number + "." + addressPrefix + absoluteAddress.Byte;
if (entry.DataType == DataType.BOOL)
{
addressString += "." + absoluteAddress.Bit;
}
else if (entry.DataType == DataType.STRING)
{
addressString += "." + (parentPlc?.GetConstantValue(entry.StringLength) ?? entry.StringLength.Value).ToString();
}
var entryItems = new string[16]
{
entryPrefix + entry.Name,
addressString,
type,
"1",
"R/W",
"100",
string.Empty,
string.Empty,
string.Empty,
string.Empty,
string.Empty,
string.Empty,
string.Empty,
string.Empty,
string.Empty,
entry.Comment
};
writer.WriteLine(string.Join(",", entryItems));
}
}
}
public string ToHtml()
{
string htmlMenu = "";
foreach (var item in this.Menu)
{
htmlMenu += item.ToHtml();
}
var ul = TagHelper.Create(Tag.ul, new TagAttribute(Attr.Class, "dropdown-menu dropdown-with-icons"), htmlMenu);
var li = TagHelper.Create(Tag.li, new TagAttribute(Attr.Class, "dropdown"), this.Toggle.ToHtml() + TagHelper.ToHtml(ul));
var h = TagHelper.ToHtml(li);
return(h);
}
public void InitTags(string customData)
{
if (string.IsNullOrWhiteSpace(customData) == false)
{
var descSplit = customData.Split('\n');
foreach (var tag in descSplit)
{
//UseChatBroadcast
if (tag.Contains("[UseChatBroadcast:") == true)
{
this.UseChatBroadcast = TagHelper.TagBoolCheck(tag);
}
//ChatData
if (tag.Contains("[ChatData:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
bool gotChat = false;
if (string.IsNullOrWhiteSpace(tempValue) == false)
{
byte[] byteData = { };
if (TagHelper.ChatObjectTemplates.TryGetValue(tempValue, out byteData) == true)
{
try {
var profile = MyAPIGateway.Utilities.SerializeFromBinary <ChatProfile>(byteData);
if (profile != null)
{
ChatData = profile;
gotChat = true;
}
else
{
Logger.WriteLog("Deserialized Chat Profile was Null");
}
} catch (Exception e) {
Logger.WriteLog("Caught Exception While Attaching to Action Profile:");
Logger.WriteLog(e.ToString());
}
}
else
{
Logger.WriteLog("Chat Profile Not in Dictionary");
}
}
if (!gotChat)
{
Logger.WriteLog("Could Not Find Chat Profile Associated To Tag: " + tag);
}
}
//BarrelRoll
if (tag.Contains("[BarrelRoll:") == true)
{
this.BarrelRoll = TagHelper.TagBoolCheck(tag);
}
//Strafe
if (tag.Contains("[Strafe:") == true)
{
this.Strafe = TagHelper.TagBoolCheck(tag);
}
//ChangeAutopilotSpeed
if (tag.Contains("[ChangeAutopilotSpeed:") == true)
{
this.ChangeAutopilotSpeed = TagHelper.TagBoolCheck(tag);
}
//NewAutopilotSpeed
if (tag.Contains("[NewAutopilotSpeed:") == true)
{
this.NewAutopilotSpeed = TagHelper.TagFloatCheck(tag, this.NewAutopilotSpeed);
}
//SpawnEncounter
if (tag.Contains("[SpawnEncounter:") == true)
{
this.SpawnEncounter = TagHelper.TagBoolCheck(tag);
}
//Spawner
if (tag.Contains("[Spawner:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
bool gotSpawn = false;
if (string.IsNullOrWhiteSpace(tempValue) == false)
{
byte[] byteData = { };
if (TagHelper.SpawnerObjectTemplates.TryGetValue(tempValue, out byteData) == true)
{
try {
var profile = MyAPIGateway.Utilities.SerializeFromBinary <SpawnProfile>(byteData);
if (profile != null)
{
Spawner = profile;
gotSpawn = true;
}
} catch (Exception) {
}
}
}
if (!gotSpawn)
{
Logger.WriteLog("Could Not Find Spawn Profile Associated To Tag: " + tag);
}
}
//SelfDestruct
if (tag.Contains("[SelfDestruct:") == true)
{
this.SelfDestruct = TagHelper.TagBoolCheck(tag);
}
//Retreat
if (tag.Contains("[Retreat:") == true)
{
this.Retreat = TagHelper.TagBoolCheck(tag);
}
//TerminateBehavior
if (tag.Contains("[TerminateBehavior:") == true)
{
this.TerminateBehavior = TagHelper.TagBoolCheck(tag);
}
//BroadcastCurrentTarget
if (tag.Contains("[BroadcastCurrentTarget:") == true)
{
this.BroadcastCurrentTarget = TagHelper.TagBoolCheck(tag);
}
//SwitchToReceivedTarget
if (tag.Contains("[SwitchToReceivedTarget:") == true)
{
this.SwitchToReceivedTarget = TagHelper.TagBoolCheck(tag);
}
//BroadcastDamagerTarget
if (tag.Contains("[BroadcastDamagerTarget:") == true)
{
this.BroadcastDamagerTarget = TagHelper.TagBoolCheck(tag);
}
//BroadcastSendCode
if (tag.Contains("[BroadcastSendCode:") == true)
{
this.BroadcastSendCode = TagHelper.TagStringCheck(tag);
}
//SwitchToBehavior
if (tag.Contains("[SwitchToBehavior:") == true)
{
this.SwitchToBehavior = TagHelper.TagBoolCheck(tag);
}
//NewBehavior
if (tag.Contains("[NewBehavior:") == true)
{
this.NewBehavior = TagHelper.TagStringCheck(tag);
}
//PreserveSettingsOnBehaviorSwitch
if (tag.Contains("[PreserveSettingsOnBehaviorSwitch:") == true)
{
this.PreserveSettingsOnBehaviorSwitch = TagHelper.TagBoolCheck(tag);
}
//PreserveTriggersOnBehaviorSwitch
if (tag.Contains("[PreserveTriggersOnBehaviorSwitch:") == true)
{
this.PreserveTriggersOnBehaviorSwitch = TagHelper.TagBoolCheck(tag);
}
//PreserveTargetDataOnBehaviorSwitch
if (tag.Contains("[PreserveTargetDataOnBehaviorSwitch:") == true)
{
this.PreserveTargetDataOnBehaviorSwitch = TagHelper.TagBoolCheck(tag);
}
//RefreshTarget
if (tag.Contains("[RefreshTarget:") == true)
{
this.RefreshTarget = TagHelper.TagBoolCheck(tag);
}
//SwitchTargetProfile
if (tag.Contains("[SwitchTargetProfile:") == true)
{
this.SwitchTargetProfile = TagHelper.TagBoolCheck(tag);
}
//NewTargetProfile
if (tag.Contains("[NewTargetProfile:") == true)
{
this.NewTargetProfile = TagHelper.TagStringCheck(tag);
}
//TriggerTimerBlocks
if (tag.Contains("[TriggerTimerBlocks:") == true)
{
this.TriggerTimerBlocks = TagHelper.TagBoolCheck(tag);
}
//TimerBlockNames
if (tag.Contains("[TimerBlockNames:") == true)
{
var tempvalue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempvalue) == false)
{
this.TimerBlockNames.Add(tempvalue);
}
}
//ChangeReputationWithPlayers
if (tag.Contains("[ChangeReputationWithPlayers:") == true)
{
this.ChangeReputationWithPlayers = TagHelper.TagBoolCheck(tag);
}
//ReputationChangeRadius
if (tag.Contains("[ReputationChangeRadius:") == true)
{
this.ReputationChangeRadius = TagHelper.TagDoubleCheck(tag, ReputationChangeRadius);
}
//ReputationChangeFactions
if (tag.Contains("[ReputationChangeFactions:") == true)
{
var tempvalue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempvalue) == false)
{
this.ReputationChangeFactions.Add(tempvalue);
}
}
//ReputationChangeAmount
if (tag.Contains("[ReputationChangeAmount:") == true)
{
int tempValue = TagHelper.TagIntCheck(tag, 0);
this.ReputationChangeAmount.Add(tempValue);
}
//ActivateAssertiveAntennas
if (tag.Contains("[ActivateAssertiveAntennas:") == true)
{
this.ActivateAssertiveAntennas = TagHelper.TagBoolCheck(tag);
}
//ChangeAntennaOwnership
if (tag.Contains("[ChangeAntennaOwnership:") == true)
{
this.ChangeAntennaOwnership = TagHelper.TagBoolCheck(tag);
}
//AntennaFactionOwner
if (tag.Contains("[AntennaFactionOwner:") == true)
{
this.AntennaFactionOwner = TagHelper.TagStringCheck(tag);
}
//CreateKnownPlayerArea
if (tag.Contains("[CreateKnownPlayerArea:") == true)
{
this.CreateKnownPlayerArea = TagHelper.TagBoolCheck(tag);
}
//KnownPlayerAreaRadius
if (tag.Contains("[KnownPlayerAreaRadius:") == true)
{
this.KnownPlayerAreaRadius = TagHelper.TagDoubleCheck(tag, KnownPlayerAreaRadius);
}
//KnownPlayerAreaTimer
if (tag.Contains("[KnownPlayerAreaTimer:") == true)
{
this.KnownPlayerAreaTimer = TagHelper.TagIntCheck(tag, KnownPlayerAreaTimer);
}
//KnownPlayerAreaMaxSpawns
if (tag.Contains("[KnownPlayerAreaMaxSpawns:") == true)
{
this.KnownPlayerAreaMaxSpawns = TagHelper.TagIntCheck(tag, KnownPlayerAreaMaxSpawns);
}
//DamageToolAttacker
if (tag.Contains("[DamageToolAttacker:") == true)
{
this.DamageToolAttacker = TagHelper.TagBoolCheck(tag);
}
//DamageToolAttackerAmount
if (tag.Contains("[DamageToolAttackerAmount:") == true)
{
this.DamageToolAttackerAmount = TagHelper.TagFloatCheck(tag, this.DamageToolAttackerAmount);
}
//DamageToolAttackerParticle
if (tag.Contains("[DamageToolAttackerParticle:") == true)
{
this.DamageToolAttackerParticle = TagHelper.TagStringCheck(tag);
}
//DamageToolAttackerSound
if (tag.Contains("[DamageToolAttackerSound:") == true)
{
this.DamageToolAttackerSound = TagHelper.TagStringCheck(tag);
}
//PlayParticleEffectAtRemote
if (tag.Contains("[PlayParticleEffectAtRemote:") == true)
{
this.PlayParticleEffectAtRemote = TagHelper.TagBoolCheck(tag);
}
//ParticleEffectId
if (tag.Contains("[ParticleEffectId:") == true)
{
this.ParticleEffectId = TagHelper.TagStringCheck(tag);
}
//ParticleEffectOffset
if (tag.Contains("[ParticleEffectOffset:") == true)
{
this.ParticleEffectOffset = TagHelper.TagVector3DCheck(tag);
}
//ParticleEffectScale
if (tag.Contains("[ParticleEffectScale:") == true)
{
this.ParticleEffectScale = TagHelper.TagFloatCheck(tag, this.ParticleEffectScale);
}
//ParticleEffectMaxTime
if (tag.Contains("[ParticleEffectMaxTime:") == true)
{
this.ParticleEffectMaxTime = TagHelper.TagFloatCheck(tag, this.ParticleEffectMaxTime);
}
//ParticleEffectColor
if (tag.Contains("[ParticleEffectColor:") == true)
{
this.ParticleEffectColor = TagHelper.TagVector3DCheck(tag);
}
//SetBooleansTrue
if (tag.Contains("[SetBooleansTrue:") == true)
{
var tempvalue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempvalue) == false)
{
this.SetBooleansTrue.Add(tempvalue);
}
}
//SetBooleansFalse
if (tag.Contains("[SetBooleansFalse:") == true)
{
var tempvalue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempvalue) == false)
{
this.SetBooleansFalse.Add(tempvalue);
}
}
//IncreaseCounters
if (tag.Contains("[IncreaseCounters:") == true)
{
var tempvalue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempvalue) == false)
{
this.IncreaseCounters.Add(tempvalue);
}
}
//DecreaseCounters
if (tag.Contains("[DecreaseCounters:") == true)
{
var tempvalue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempvalue) == false)
{
this.DecreaseCounters.Add(tempvalue);
}
}
//ResetCounters
if (tag.Contains("[ResetCounters:") == true)
{
var tempvalue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempvalue) == false)
{
this.ResetCounters.Add(tempvalue);
}
}
//SetSandboxBooleansTrue
if (tag.Contains("[SetSandboxBooleansTrue:") == true)
{
var tempvalue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempvalue) == false)
{
this.SetSandboxBooleansTrue.Add(tempvalue);
}
}
//SetSandboxBooleansFalse
if (tag.Contains("[SetSandboxBooleansFalse:") == true)
{
var tempvalue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempvalue) == false)
{
this.SetSandboxBooleansFalse.Add(tempvalue);
}
}
//IncreaseSandboxCounters
if (tag.Contains("[IncreaseSandboxCounters:") == true)
{
var tempvalue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempvalue) == false)
{
this.IncreaseSandboxCounters.Add(tempvalue);
}
}
//DecreaseSandboxCounters
if (tag.Contains("[DecreaseSandboxCounters:") == true)
{
var tempvalue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempvalue) == false)
{
this.DecreaseSandboxCounters.Add(tempvalue);
}
}
//ResetSandboxCounters
if (tag.Contains("[ResetSandboxCounters:") == true)
{
var tempvalue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempvalue) == false)
{
this.ResetSandboxCounters.Add(tempvalue);
}
}
//ChangeAttackerReputation
if (tag.Contains("[ChangeAttackerReputation:") == true)
{
this.ChangeAttackerReputation = TagHelper.TagBoolCheck(tag);
}
//ChangeAttackerReputationFaction
if (tag.Contains("[ChangeAttackerReputationFaction:") == true)
{
var tempvalue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempvalue) == false)
{
this.ChangeAttackerReputationFaction.Add(tempvalue);
}
}
//ChangeAttackerReputationAmount
if (tag.Contains("[ChangeAttackerReputationAmount:") == true)
{
var tempvalue = TagHelper.TagIntCheck(tag, 0);
this.ChangeAttackerReputationAmount.Add(tempvalue);
}
//ReputationChangesForAllAttackPlayerFactionMembers
if (tag.Contains("[ReputationChangesForAllAttackPlayerFactionMembers:") == true)
{
this.ReputationChangesForAllAttackPlayerFactionMembers = TagHelper.TagBoolCheck(tag);
}
//ChangeTargetProfile
if (tag.Contains("[ChangeTargetProfile:") == true)
{
this.ChangeTargetProfile = TagHelper.TagBoolCheck(tag);
}
//NewTargetProfileId
if (tag.Contains("[NewTargetProfileId:") == true)
{
this.NewTargetProfileId = TagHelper.TagStringCheck(tag);
}
//ChangeBlockNames
if (tag.Contains("[ChangeBlockNames:") == true)
{
this.ChangeBlockNames = TagHelper.TagBoolCheck(tag);
}
//ChangeBlockNamesFrom
if (tag.Contains("[ChangeBlockNamesFrom:") == true)
{
var tempvalue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempvalue) == false)
{
this.ChangeBlockNamesFrom.Add(tempvalue);
}
}
//ChangeBlockNamesTo
if (tag.Contains("[ChangeBlockNamesTo:") == true)
{
var tempvalue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempvalue) == false)
{
this.ChangeBlockNamesTo.Add(tempvalue);
}
}
//ChangeAntennaRanges
if (tag.Contains("[ChangeAntennaRanges:") == true)
{
this.ChangeAntennaRanges = TagHelper.TagBoolCheck(tag);
}
//AntennaNamesForRangeChange
if (tag.Contains("[AntennaNamesForRangeChange:") == true)
{
var tempvalue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempvalue) == false)
{
this.AntennaNamesForRangeChange.Add(tempvalue);
}
}
//AntennaRangeChangeType
if (tag.Contains("[AntennaRangeChangeType:") == true)
{
this.AntennaRangeChangeType = TagHelper.TagStringCheck(tag);
}
//AntennaRangeChangeAmount
if (tag.Contains("[AntennaRangeChangeAmount:") == true)
{
this.AntennaRangeChangeAmount = TagHelper.TagFloatCheck(tag, this.AntennaRangeChangeAmount);
}
//ForceDespawn
if (tag.Contains("[ForceDespawn:") == true)
{
this.ForceDespawn = TagHelper.TagBoolCheck(tag);
}
//ResetCooldownTimeOfTriggers
if (tag.Contains("[ResetCooldownTimeOfTriggers:") == true)
{
this.ResetCooldownTimeOfTriggers = TagHelper.TagBoolCheck(tag);
}
//ResetTriggerCooldownNames
if (tag.Contains("[ResetTriggerCooldownNames:") == true)
{
var tempvalue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempvalue) == false)
{
this.ResetTriggerCooldownNames.Add(tempvalue);
}
}
//BroadcastGenericCommand
if (tag.Contains("[BroadcastGenericCommand:") == true)
{
this.BroadcastGenericCommand = TagHelper.TagBoolCheck(tag);
}
//BehaviorSpecificEventA
if (tag.Contains("[BehaviorSpecificEventA:") == true)
{
this.BehaviorSpecificEventA = TagHelper.TagBoolCheck(tag);
}
//ChangeInertiaDampeners
if (tag.Contains("[ChangeInertiaDampeners:") == true)
{
this.ChangeInertiaDampeners = TagHelper.TagBoolCheck(tag);
}
//InertiaDampenersEnable
if (tag.Contains("[InertiaDampenersEnable:") == true)
{
this.InertiaDampenersEnable = TagHelper.TagBoolCheck(tag);
}
//EnableTriggers
if (tag.Contains("[EnableTriggers:") == true)
{
this.EnableTriggers = TagHelper.TagBoolCheck(tag);
}
//EnableTriggerNames
if (tag.Contains("[EnableTriggerNames:") == true)
{
var tempvalue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempvalue) == false)
{
this.EnableTriggerNames.Add(tempvalue);
}
}
//DisableTriggers
if (tag.Contains("[DisableTriggers:") == true)
{
this.DisableTriggers = TagHelper.TagBoolCheck(tag);
}
//DisableTriggerNames
if (tag.Contains("[DisableTriggerNames:") == true)
{
var tempvalue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempvalue) == false)
{
this.DisableTriggerNames.Add(tempvalue);
}
}
//StaggerWarheadDetonation
if (tag.Contains("[StaggerWarheadDetonation:") == true)
{
this.StaggerWarheadDetonation = TagHelper.TagBoolCheck(tag);
}
//ChangeRotationDirection
if (tag.Contains("[ChangeRotationDirection:") == true)
{
this.ChangeRotationDirection = TagHelper.TagBoolCheck(tag);
}
//RotationDirection
if (tag.Contains("[RotationDirection:") == true)
{
this.RotationDirection = TagHelper.TagDirectionEnumCheck(tag);
}
//GenerateExplosion
if (tag.Contains("[GenerateExplosion:") == true)
{
this.GenerateExplosion = TagHelper.TagBoolCheck(tag);
}
//ExplosionOffsetFromRemote
if (tag.Contains("[ExplosionOffsetFromRemote:") == true)
{
this.ExplosionOffsetFromRemote = TagHelper.TagVector3DCheck(tag);
}
//ExplosionRange
if (tag.Contains("[ExplosionRange:") == true)
{
this.ExplosionRange = TagHelper.TagIntCheck(tag, ExplosionRange);
}
//ExplosionDamage
if (tag.Contains("[ExplosionDamage:") == true)
{
this.ExplosionDamage = TagHelper.TagIntCheck(tag, ExplosionDamage);
}
}
}
}
