public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
if (!rigidbody)
gameObject.AddComponent<Rigidbody>();
rigidbody.useGravity = UseGravity;
rigidbody.freezeRotation = true;
generator.OnGeneratedLevel += delegate(List<BaseRuleElement.ActorData> actorData,
List<BaseRuleElement.EventData> eventData,
List<BaseRuleElement.ReactionData> reactionData,
string filename)
{
currentState = State.RESPAWNING;
checkpoints = null;
};
tag = Tag;
int selected = 0;
if (Tag != "")
{
selected = System.Array.FindIndex(Checkpoint.PossibleCheckpointTargetTags, item => item == Tag);
}
checkpointDropDown = new DropDown(selected, Checkpoint.PossibleCheckpointTargetTags);
}
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
Viewport viewport;
if (AutoCalculateViewport)
{
CalculateViewportSizes();
viewport = viewportSizes.Find(item => item.cam.Id == Id);
}
else
{
viewport = new Viewport()
{
cam = this,
pos = new Vector2(ViewportXPos, ViewportYPos),
size = new Vector2(ViewportWidth, ViewportHeight)
};
}
ResetViewport(viewport);
ShowPrefabInGUI = false;
}
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
this.generator = generator;
generator.OnActorGOChanged += delegate(ActorData data, Actor newActor, RuleGenerator ruleGenerator)
{
if (ObjectToDeactivate != null && ObjectToDeactivate.Id == data.id)
{
ObjectToDeactivate = newActor;
}
};
if (ObjectToDeactivate == null)
{
ObjectToDeactivate = Reactor;
}
actorDropDown = new ActorDropDown(
System.Array.FindIndex(generator.Gui.ActorNames, item => item == Reactor.Label),
generator.Gui.ActorNames,
ref generator.Gui.OnAddedActor, ref generator.Gui.OnRenamedActor, ref generator.Gui.OnDeletedActor);
targetObjectDropDown = new DropDown(
(int)TargetObj,
System.Enum.GetNames(typeof(TargetObject)));
}
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
int selected = System.Array.FindIndex(possibleLevels, item => item == CurrentPrefab);
prefabDropDown = new DropDown(selected, possibleLevels);
}
public void RuleGen_SimpleRules()
{
// Arrange
TestLogger logger = new TestLogger();
ConfigurableAnalyzer analyzer = new ConfigurableAnalyzer();
var diagnostic1 = analyzer.RegisterDiagnostic(key: "DiagnosticID1", description: "Some description", helpLinkUri: "www.bing.com", tags: new[] { "unnecessary" });
var diagnostic2 = analyzer.RegisterDiagnostic(key: "Diagnostic2", description: "");
IRuleGenerator generator = new RuleGenerator(logger);
// Act
Rules rules = generator.GenerateRules(new[] { analyzer });
// Assert
AssertExpectedRuleCount(2, rules);
Rule rule1 = rules.Single(r => r.Key == diagnostic1.Id);
VerifyRule(diagnostic1, rule1);
rule1.Description.Contains(diagnostic1.Description.ToString()).Should().BeTrue("Invalid rule description");
rule1.Description.Contains(diagnostic1.HelpLinkUri).Should().BeTrue("Invalid rule description");
rule1.Description.Trim().StartsWith("<![CDATA").Should().BeFalse("Description should not be formatted as a CData section");
Rule rule2 = rules.Single(r => r.Key == diagnostic2.Id);
VerifyRule(diagnostic2, rule2);
rule2.Description.Contains(UIResources.RuleGen_NoDescription).Should().BeTrue("Invalid rule description");
}
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
this.generator = generator;
generator.OnActorGOChanged += delegate(ActorData data, Actor newActor, RuleGenerator ruleGenerator)
{
if (WatchedObject == null || WatchedObject.Id == data.id)
WatchedObject = newActor;
};
string[] actors = generator.Gui.ActorNames;
actorDropDown = new ActorDropDown(
System.Array.FindIndex(actors, item => item == Actor.Label), actors,
ref generator.Gui.OnAddedActor, ref generator.Gui.OnRenamedActor, ref generator.Gui.OnDeletedActor);
if (WatchedObject == null)
{
WatchedObject = generator.GetActor(0); // dont get global actor bec it could be anywhere
}
watchedActorDropDown = new ActorDropDown(
System.Array.FindIndex(actors, item => item == WatchedObject.Label), actors,
ref generator.Gui.OnAddedActor, ref generator.Gui.OnRenamedActor, ref generator.Gui.OnDeletedActor);
comparisonDropDown = new DropDown(
(int)TriggerWhenDistance,
System.Enum.GetNames(typeof(Comparison)));
}
public void RuleGen_SimpleRules()
{
// Arrange
TestLogger logger = new TestLogger();
ConfigurableAnalyzer analyzer = new ConfigurableAnalyzer();
var diagnostic1 = analyzer.RegisterDiagnostic(key: "DiagnosticID1", description: "Some description", helpLinkUri: "www.bing.com", tags: new[] { "unnecessary" });
var diagnostic2 = analyzer.RegisterDiagnostic(key: "Diagnostic2", description: "");
IRuleGenerator generator = new RuleGenerator(logger);
// Act
Rules rules = generator.GenerateRules(new[] { analyzer });
// Assert
AssertExpectedRuleCount(2, rules);
Rule rule1 = rules.Single(r => r.Key == diagnostic1.Id);
VerifyRule(diagnostic1, rule1);
Assert.IsTrue(rule1.Description.Contains(diagnostic1.Description.ToString()), "Invalid rule description");
Assert.IsTrue(rule1.Description.Contains(diagnostic1.HelpLinkUri), "Invalid rule description");
Assert.IsFalse(rule1.Description.Trim().StartsWith("<![CDATA"), "Description should not be formatted as a CData section");
Rule rule2 = rules.Single(r => r.Key == diagnostic2.Id);
VerifyRule(diagnostic2, rule2);
Assert.IsTrue(rule2.Description.Contains(UIResources.RuleGen_NoDescription), "Invalid rule description");
}
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
DontDeleteOnLoad = true;
Label = "GlobalActor";
Id = 1000;
}
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
dropdownNames = System.Enum.GetNames(typeof(KeyCode));
keyDropDown = new DropDown(System.Array.FindIndex(dropdownNames, item => item == InputKey.ToString()), dropdownNames);
}
public void RuleGeneratorMakesBuzz()
{
var gen = new RuleGenerator();
var output = gen.GenerateRuleSequence(5, "buzz");
var answer = new[] { "", "", "", "", "buzz" };
Assert.That(answer.SequenceEqual(output));
}
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
trackedButtonDropDown = new DropDown((int)TrackedButton, System.Enum.GetNames(typeof(MouseButton)));
if (TrackedCamera == null)
TrackedCamera = FindObjectOfType<PlayerCamera>();
}
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
if (counter == null)
{
counter = Counter.Get(CounterName);
}
kindOfChangeDropDown = new DropDown((int)KindOfChange, System.Enum.GetNames(typeof(Change)));
}
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
this.generator = generator;
string[] actors = generator.Gui.ActorNames;
actorDropDown = new ActorDropDown(
System.Array.FindIndex(actors, item => item == Reactor.Label),
actors,
ref generator.Gui.OnAddedActor, ref generator.Gui.OnRenamedActor, ref generator.Gui.OnDeletedActor);
}
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
generator.OnGeneratedLevel += delegate(List<BaseRuleElement.ActorData> actorData,
List<BaseRuleElement.EventData> eventData,
List<BaseRuleElement.ReactionData> reactionData,
string filename)
{
checkpoints = null;
currentState = PlayerState.RESPAWNING;
};
}
// add methods to the generated class
private static void AddClassMembers(RubyClass /*!*/ cls, string[] /*!*/ structMembers)
{
var newInstance = new RuleGenerator(RuleGenerators.InstanceConstructor);
cls.SingletonClass.DefineRuleGenerator("[]", (int)RubyMethodAttributes.PublicSingleton, newInstance);
cls.SingletonClass.DefineRuleGenerator("new", (int)RubyMethodAttributes.PublicSingleton, newInstance);
cls.SingletonClass.DefineLibraryMethod("members", (int)RubyMethodAttributes.PublicSingleton,
new Func <RubyClass, List <object> >(GetMembers)
);
for (int i = 0; i < structMembers.Length; i++)
{
string getter = structMembers[i];
cls.DefineRuleGenerator(getter, (int)RubyMethodAttributes.PublicInstance, CreateGetter(i));
cls.DefineRuleGenerator(getter + '=', (int)RubyMethodAttributes.PublicInstance, CreateSetter(i));
}
}
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
this.generator = generator;
if (FixedToObject)
{
Reactor.transform.parent = FixedToObject.transform;
Reactor.transform.localPosition = Offset;
}
// gui stuff
string[] actors = generator.Gui.ActorNames;
actorDropDown = new ActorDropDown(
System.Array.FindIndex(actors, item => item == Reactor.Label),
actors,
ref generator.Gui.OnAddedActor, ref generator.Gui.OnRenamedActor, ref generator.Gui.OnDeletedActor);
}
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
generator.OnActorGOChanged += delegate(ActorData data, Actor newActor, RuleGenerator ruleGenerator)
{
if (TargetObject == null || TargetObject.Id != data.id)
{
TargetObject = newActor;
}
};
string selectedName = "";
if (TargetObject != null)
selectedName = TargetObject.Label;
actorDropdown = new ActorDropDown(
System.Array.FindIndex(generator.Gui.ActorNames, item => item == selectedName),
generator.Gui.ActorNames,
ref generator.Gui.OnAddedActor, ref generator.Gui.OnRenamedActor, ref generator.Gui.OnDeletedActor);
}
public void Parse(RuleGenerator generator, string filename)
{
string filepath = Application.dataPath + @"/Rules/" + filename + ".xml";
XDocument xmlDoc = XDocument.Load(filepath);
if (xmlDoc == null)
{
Debug.LogError("Couldn't find rule file " + filename + " in the Resources folders. Aborting generation.");
return;
}
// parse actors
ParseActors(generator, xmlDoc.Element("rules").Element("actors"));
// parse events
ParseEvents(generator, xmlDoc.Element("rules").Element("events"));
// parse reactions
ParseReactions(generator, xmlDoc.Element("rules").Element("reactions"));
}
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
generator.OnActorGOChanged += delegate(ActorData data, Actor newActor, RuleGenerator ruleGenerator)
{
if (WinningActor != null && WinningActor.Id == data.id)
{
WinningActor = newActor;
}
if (LosingActor != null && LosingActor.Id == data.id)
{
LosingActor = newActor;
}
};
int selected = 0;
string[] endingNames = System.Enum.GetNames(typeof(GameEnd));
endingDropDown = new DropDown(0, endingNames);
if (WinningActor != null)
selected = System.Array.FindIndex(generator.Gui.ActorNames, item => item == WinningActor.Label);
winningDropDown = new ActorDropDown(selected,
generator.Gui.ActorNames,
ref generator.Gui.OnAddedActor,
ref generator.Gui.OnRenamedActor,
ref generator.Gui.OnDeletedActor);
selected = 0;
if (LosingActor != null)
selected = System.Array.FindIndex(generator.Gui.ActorNames, item => item == LosingActor.Label);
losingDropDown = new ActorDropDown(selected,
generator.Gui.ActorNames,
ref generator.Gui.OnAddedActor,
ref generator.Gui.OnRenamedActor,
ref generator.Gui.OnDeletedActor);
}
public void CheckNoTags()
{
// Arrange
TestLogger logger = new TestLogger();
ConfigurableAnalyzer analyzer = new ConfigurableAnalyzer();
var diagnostic1 = analyzer.RegisterDiagnostic(key: "DiagnosticID1", tags: new[] { "t1" });
var diagnostic2 = analyzer.RegisterDiagnostic(key: "DiagnosticID2", tags: new[] { "T2" });
IRuleGenerator generator = new RuleGenerator(logger);
// Act
Rules rules = generator.GenerateRules(new[] { analyzer });
// Assert
foreach (Rule rule in rules)
{
VerifyRuleValid(rule);
Assert.IsNull(rule.Tags);
}
}
public void CheckNoTags()
{
// Arrange
TestLogger logger = new TestLogger();
ConfigurableAnalyzer analyzer = new ConfigurableAnalyzer();
var diagnostic1 = analyzer.RegisterDiagnostic(key: "DiagnosticID1", tags: new[] { "t1" });
var diagnostic2 = analyzer.RegisterDiagnostic(key: "DiagnosticID2", tags: new[] { "T2" });
IRuleGenerator generator = new RuleGenerator(logger);
// Act
Rules rules = generator.GenerateRules(new[] { analyzer });
// Assert
foreach (Rule rule in rules)
{
VerifyRuleValid(rule);
Assert.IsNull(rule.Tags);
}
}
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
this.generator = generator;
generator.OnActorGOChanged += delegate(ActorData data, Actor newActor, RuleGenerator ruleGenerator)
{
if (CollideWithActor != null && CollideWithActor.Id == data.id)
CollideWithActor = newActor;
};
// setting up gui elements - actors
string[] actors = generator.Gui.ActorNames;
actorDropDown = new ActorDropDown(
System.Array.FindIndex(actors, item => item == Actor.Label),
actors,
ref generator.Gui.OnAddedActor, ref generator.Gui.OnRenamedActor, ref generator.Gui.OnDeletedActor);
// gui - tags
tagDropDown = new DropDown(PossibleCollisionTags.FindIndex(item => item == CollideWithTag), PossibleCollisionTags.ToArray());
// gui - collision with other actor
int index = 0;
if (CollideWithActor != null)
index = System.Array.FindIndex(actors, item => item == CollideWithActor.Label);
collisionActorDropDown = new ActorDropDown(index, actors,
ref generator.Gui.OnAddedActor, ref generator.Gui.OnRenamedActor, ref generator.Gui.OnDeletedActor);
// gui - triggering
triggerDropDown = new DropDown((int)TriggerOn, System.Enum.GetNames(typeof(CollisionPhase)));
// gui - choosing which kinds of objects to trigger
int init = 0;
if (CollideWithActor != null)
init = 1;
chooseObjectKindDropDown = new DropDown(init, new string[] { "any object which is a", "the actor" });
SubscribeRelay();
}
public void RulesMustHaveDescription()
{
// Arrange
TestLogger logger = new TestLogger();
ConfigurableAnalyzer analyzer = new ConfigurableAnalyzer();
var diagnostic1 = analyzer.RegisterDiagnostic(key: "DiagnosticID1", description: null);
var diagnostic2 = analyzer.RegisterDiagnostic(key: "DiagnosticID1", description: "");
var diagnostic3 = analyzer.RegisterDiagnostic(key: "DiagnosticID2", description: " ");
IRuleGenerator generator = new RuleGenerator(logger);
// Act
Rules rules = generator.GenerateRules(new[] { analyzer });
// Assert
foreach (Rule rule in rules)
{
VerifyRuleValid(rule);
Assert.AreEqual(rule.Description, UIResources.RuleGen_NoDescription);
}
}
public void RulesMustHaveDescription()
{
// Arrange
TestLogger logger = new TestLogger();
ConfigurableAnalyzer analyzer = new ConfigurableAnalyzer();
var diagnostic1 = analyzer.RegisterDiagnostic(key: "DiagnosticID1", description: null);
var diagnostic2 = analyzer.RegisterDiagnostic(key: "DiagnosticID1", description: "");
var diagnostic3 = analyzer.RegisterDiagnostic(key: "DiagnosticID2", description: " ");
IRuleGenerator generator = new RuleGenerator(logger);
// Act
Rules rules = generator.GenerateRules(new[] { analyzer });
// Assert
foreach (Rule rule in rules)
{
VerifyRuleValid(rule);
Assert.AreEqual(rule.Description, UIResources.RuleGen_NoDescription);
}
}
// add methods to the generated class
private static void AddClassMembers(RubyClass /*!*/ cls, string[] /*!*/ structMembers)
{
var newInstance = new RuleGenerator(RuleGenerators.InstanceConstructor);
var context = cls.Context;
var singletonClass = cls.GetOrCreateSingletonClass();
singletonClass.AddMethod(context, "[]", new RubyCustomMethodInfo(newInstance, RubyMemberFlags.Public, singletonClass));
singletonClass.AddMethod(context, "new", new RubyCustomMethodInfo(newInstance, RubyMemberFlags.Public, singletonClass));
singletonClass.AddMethod(context, "members", new RubyLibraryMethodInfo(
new[] { LibraryOverload.Create(new Func <RubyClass, RubyArray>(GetMembers), false, 0, 0) },
RubyMemberFlags.Public,
singletonClass
));
for (int i = 0; i < structMembers.Length; i++)
{
string getter = structMembers[i];
cls.AddMethod(context, getter, new RubyCustomMethodInfo(CreateGetter(i), RubyMemberFlags.Public, cls));
cls.AddMethod(context, getter + '=', new RubyCustomMethodInfo(CreateSetter(i), RubyMemberFlags.Public, cls));
}
}
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
this.generator = generator;
generator.OnActorGOChanged += delegate(ActorData data, Actor newActor, RuleGenerator ruleGenerator)
{
if (ActorDirectionIsRelativeTo != null && ActorDirectionIsRelativeTo.Id == data.id)
{
ActorDirectionIsRelativeTo = newActor;
}
};
if (Reactor.rigidbody == null)
Reactor.gameObject.AddComponent<Rigidbody>();
Reactor.rigidbody.freezeRotation = true;
Reactor.rigidbody.useGravity = false;
string[] actors = generator.Gui.ActorNames;
actorDropDown = new ActorDropDown(
System.Array.FindIndex(actors, item => item == Reactor.Label),
actors,
ref generator.Gui.OnAddedActor, ref generator.Gui.OnRenamedActor, ref generator.Gui.OnDeletedActor);
moveDirectionDropdown = new DropDown((int)MoveDirection, System.Enum.GetNames(typeof(Direction)));
relativeToDropdown = new DropDown((int)DirectionRelativeTo, System.Enum.GetNames(typeof(RelativeTo)));
relativeActorDropDown = new ActorDropDown(
ActorDirectionIsRelativeTo != null ?
System.Array.FindIndex(actors, item => item == ActorDirectionIsRelativeTo.Label) :
0,
actors,
ref generator.Gui.OnAddedActor, ref generator.Gui.OnRenamedActor, ref generator.Gui.OnDeletedActor);
}
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
Register();
}
static void Main(string[] args)
{
//Console.WriteLine();
//Console.ReadLine();
try
{
Console.WriteLine("Ingrese minSupport :");
double minSupport = 0.005;//Convert.ToDouble(Console.ReadLine()) / 100;
Console.WriteLine("Ingrese minConfidence :");
double minConfidence = Convert.ToDouble(Console.ReadLine()) / 100;
Data data = new Data(false);
FIGeneration fIGeneration = new FIGeneration();
fIGeneration.minSupport = minSupport;
RuleGenerator ruleGenerator = new RuleGenerator();
ruleGenerator.minConfidence = minConfidence;
ClustersGenerator clustersGenerator = new ClustersGenerator();
clustersGenerator.minPertencia = 0.60;
data.LoadTransactions();
data.LoadClientes();
Console.WriteLine("--> " + data.transactions.Count);
data.PodarTransacciones(0.003);
Console.WriteLine("--> " + data.transactions.Count);
data.PodarClientes();
Console.WriteLine("Clientes -> " + data.clientes.Count);
data.PodarArticulos();
Console.WriteLine("Items Podados.- " + data.items.Count);
data.PodarItemsPorSupport(minSupport);
fIGeneration.AprioriFrequentItemGeneration(3, data);
List <ItemSet> fi = fIGeneration.candidates.Where(x => x.items.Count > 1).ToList();
List <ItemSet> fiTotales = fIGeneration.candidates.ToList();
Console.WriteLine("Itemsets totales: " + fi.Count);
Console.WriteLine("---------------------------------------- \n Frequents ItemSe Generados... \n Creando Reglas de asociacion ...");
//Generando Reglas
ruleGenerator.GenerarReglas(fi, fIGeneration);
Console.WriteLine(ruleGenerator.associationRules.Count + "++++++++");
foreach (Rule rule in ruleGenerator.associationRules)
{
Console.WriteLine(rule.antecedente.ToStringItems() + " ->" + rule.consecuente.ToStringItems() + " " + rule.confidence);
}
//Generando CLusters
clustersGenerator.GenerarClusters(data.transactions, data.clientes, fi);
/*
* Analyzer analyzer = new Analyzer();
* analyzer.minPertenencia = 0.75;
* analyzer.minPertenencia = 0.75;
* analyzer.minSupport = 0.01;
* analyzer.LoadData();
* analyzer.PodarDatos(0.1/100);
* //analyzer.data.PodarItemsPorSupport(0.1);
*
* analyzer.GenerarFrequentItemSets(2);
* Console.WriteLine(analyzer.fIGeneration.candidates.Count);*/
foreach (ItemSet itemset in fIGeneration.candidates)
{
String cods = "";
itemset.items.ToList().ForEach(x => cods += x.Value.cod + " ");
Console.WriteLine("Conjunto frecuente -> Support: " + itemset.support + " Conjunto: " + cods);
}
// List<ItemSet> fi = fIGeneration.candidates.Where(x => x.items.Count > 1).ToList();
// clustersGenerator.GenerarClusters(data.transactions, data.clientes, fi);
foreach (Cluster c in clustersGenerator.clusters)
{
Console.WriteLine("Cluster: " + c.agrupador.ToStringItems());
foreach (Elemento e in c.elementos)
{
Console.WriteLine("Elemento: " + e.id + " pertenece un " + e.pertenencia + " al cluster");
}
}
Console.WriteLine(" Clusters final " + clustersGenerator.clusters.Count);
Console.WriteLine("Terminó!");
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine("Error main: " + e.Message + "\n" + e.StackTrace);
Console.ReadLine();
}
}
// add methods to the generated class
private static void AddClassMembers(RubyClass/*!*/ cls, string[]/*!*/ structMembers) {
var newInstance = new RuleGenerator(RuleGenerators.InstanceConstructor);
cls.SingletonClass.DefineRuleGenerator("[]", (int)RubyMethodAttributes.PublicSingleton, newInstance);
cls.SingletonClass.DefineRuleGenerator("new", (int)RubyMethodAttributes.PublicSingleton, newInstance);
cls.SingletonClass.DefineLibraryMethod("members", (int)RubyMethodAttributes.PublicSingleton,
new Func<RubyClass, List<object>>(GetMembers)
);
for (int i = 0; i < structMembers.Length; i++) {
string getter = structMembers[i];
cls.DefineRuleGenerator(getter, (int)RubyMethodAttributes.PublicInstance, CreateGetter(i));
cls.DefineRuleGenerator(getter + '=', (int)RubyMethodAttributes.PublicInstance, CreateSetter(i));
}
}
internal void ParseUserOofSettings(UserOofSettings oofSettings, MailTips mailTips, int traceId)
{
if (oofSettings.OofState == OofState.Disabled)
{
MailTipsLocalQuery.GetMailTipsTracer.TraceDebug <object, EmailAddress>((long)traceId, "{0} / {1}: OutOfOffice is disabled", TraceContext.Get(), mailTips.EmailAddress);
mailTips.OutOfOfficeMessage = string.Empty;
return;
}
DateTime utcNow = DateTime.UtcNow;
if (oofSettings.OofState == OofState.Scheduled && (utcNow > oofSettings.EndTime || utcNow < oofSettings.StartTime))
{
MailTipsLocalQuery.GetMailTipsTracer.TraceDebug <object, EmailAddress>((long)traceId, "{0} / {1}: OutOfOffice is Scheduled, but we're outside the scheduled interval", TraceContext.Get(), mailTips.EmailAddress);
mailTips.OutOfOfficeMessage = string.Empty;
return;
}
ReplyBody replyBody;
if (MailTipsAccessLevel.All != mailTips.Permission.AccessLevel)
{
MailTipsLocalQuery.GetMailTipsTracer.TraceDebug <object, EmailAddress>((long)traceId, "{0} / {1}: MailTipsAccessLevel is not All, retrieving external auto reply.", TraceContext.Get(), mailTips.EmailAddress);
replyBody = oofSettings.ExternalReply;
}
else if (this.clientContext is InternalClientContext)
{
MailTipsLocalQuery.GetMailTipsTracer.TraceDebug <object, EmailAddress>((long)traceId, "{0} / {1}: InternalClientContext detected, retrieving internal auto reply.", TraceContext.Get(), mailTips.EmailAddress);
replyBody = oofSettings.InternalReply;
}
else
{
ExternalClientContext externalClientContext = (ExternalClientContext)this.clientContext;
if (mailTips.Configuration.Domains.IsInternal(externalClientContext.EmailAddress.Domain))
{
MailTipsLocalQuery.GetMailTipsTracer.TraceDebug((long)traceId, "{0} / {1}: ExternalClientContext detected and caller domain {2} is internal to recipient organization {3}, retrieving internal auto reply.", new object[]
{
TraceContext.Get(),
mailTips.EmailAddress,
externalClientContext.EmailAddress.Domain,
mailTips.Configuration.OrganizationConfiguration.Configuration.OrganizationId
});
replyBody = oofSettings.InternalReply;
}
else
{
MailTipsLocalQuery.GetMailTipsTracer.TraceDebug((long)traceId, "{0} / {1}: ExternalClientContext detected and caller domain {2} is not internal to recipient organization {3}, retrieving external auto reply.", new object[]
{
TraceContext.Get(),
mailTips.EmailAddress,
externalClientContext.EmailAddress.Domain,
mailTips.Configuration.OrganizationConfiguration.Configuration.OrganizationId
});
replyBody = oofSettings.ExternalReply;
}
}
if (replyBody == null || replyBody.RawMessage == null || RuleGenerator.IsEmptyString(replyBody.RawMessage))
{
MailTipsLocalQuery.GetMailTipsTracer.TraceDebug <object, EmailAddress>((long)traceId, "{0} / {1}: OutOfOfficeMessage is null or empty", TraceContext.Get(), mailTips.EmailAddress);
mailTips.OutOfOfficeMessage = string.Empty;
return;
}
MailTipsLocalQuery.GetMailTipsTracer.TraceDebug <object, EmailAddress, string>((long)traceId, "{0} / {1}: OutOfOffice message has been retrieved: {2}", TraceContext.Get(), mailTips.EmailAddress, replyBody.Message);
string outOfOfficeMessage = MailTipsUtility.MakeSafeHtml(traceId, replyBody.Message);
mailTips.OutOfOfficeMessage = outOfOfficeMessage;
mailTips.OutOfOfficeMessageLanguage = replyBody.LanguageTag;
if (oofSettings.OofState == OofState.Scheduled)
{
mailTips.OutOfOfficeDuration = oofSettings.Duration;
}
}
// thread-safe:
public static void DefineRuleGenerator(RubyModule /*!*/ module, string /*!*/ name, int attributes, RuleGenerator /*!*/ generator)
{
Assert.NotNull(generator);
var flags = (RubyMemberFlags)(attributes & (int)RubyMethodAttributes.VisibilityMask);
bool skipEvent = ((RubyMethodAttributes)attributes & RubyMethodAttributes.NoEvent) != 0;
SetLibraryMethod(module, name, new RubyCustomMethodInfo(generator, flags, module), skipEvent);
}
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
comparisonDropDown = new DropDown((int)Compare, System.Enum.GetNames(typeof(Comparison)));
}
// thread-safe:
public void DefineRuleGenerator(string/*!*/ name, int attributes, RuleGenerator/*!*/ generator) {
Assert.NotNull(generator);
var flags = (RubyMemberFlags)(attributes & (int)RubyMethodAttributes.VisibilityMask);
bool skipEvent = ((RubyMethodAttributes)attributes & RubyMethodAttributes.NoEvent) != 0;
SetLibraryMethod(name, new RubyCustomMethodInfo(generator, flags, this), skipEvent);
}
public RubyCustomMethodInfo(RuleGenerator/*!*/ ruleGenerator, RubyMemberFlags flags, RubyModule/*!*/ declaringModule)
: base(flags, declaringModule)
{
Assert.NotNull(ruleGenerator, declaringModule);
_ruleGenerator = ruleGenerator;
}
public RubyCustomMethodInfo(RuleGenerator /*!*/ ruleGenerator, RubyMemberFlags flags, RubyModule /*!*/ declaringModule)
: base(flags, declaringModule)
{
Assert.NotNull(ruleGenerator, declaringModule);
_ruleGenerator = ruleGenerator;
}
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
int selected = 0;
if (TagForSpawnedObjects != "")
selected = System.Array.FindIndex(possibleSpawnTags, item => item == TagForSpawnedObjects);
tagDropDown = new DropDown(selected, possibleSpawnTags);
}
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
this.generator = generator;
}
// add methods to the generated class
private static void AddClassMembers(RubyClass/*!*/ cls, string[]/*!*/ structMembers) {
var newInstance = new RuleGenerator(RuleGenerators.InstanceConstructor);
var context = cls.Context;
var singletonClass = cls.GetOrCreateSingletonClass();
singletonClass.AddMethod(context, "[]", new RubyCustomMethodInfo(newInstance, RubyMemberFlags.Public, singletonClass));
singletonClass.AddMethod(context, "new", new RubyCustomMethodInfo(newInstance, RubyMemberFlags.Public, singletonClass));
singletonClass.AddMethod(context, "members", new RubyLibraryMethodInfo(
new[] { LibraryOverload.Create(new Func<RubyClass, RubyArray>(GetMembers), false, 0, 0) },
RubyMemberFlags.Public,
singletonClass
));
for (int i = 0; i < structMembers.Length; i++) {
string getter = structMembers[i];
cls.AddMethod(context, getter, new RubyCustomMethodInfo(CreateGetter(i), RubyMemberFlags.Public, cls));
cls.AddMethod(context, getter + '=', new RubyCustomMethodInfo(CreateSetter(i), RubyMemberFlags.Public, cls));
}
}
/// <summary>
/// Collects all events, so that they can be updated when appropriate
/// </summary>
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
RuleGenerator = generator;
// get all events
ScanEvents();
InitializeEvents();
// get all reactions
ScanReactions();
InitializeReactions();
OldPrefab = CurrentPrefab;
int selected;
if (CurrentPrefab == "")
selected = 0;
else
{
selected = System.Array.FindIndex(possiblePrefabs, item => item == CurrentPrefab);
}
prefabDropDown = new DropDown(selected, possiblePrefabs);
pausedEvents = false;
}
public override void Initialize(RuleGenerator generator)
{
base.Initialize(generator);
value = StartValue;
generator.Gui.OnDeletedActor += OnDeletedActor;
if (!counters.Find(item => item.name == Label))
counters.Add(this);
else
Debug.LogError("Two counters have the same name. Cannot add more than one counter with the name " + Label);
ShowPrefabInGUI = false;
}
