private void Reverse(int index1, int index2)
{
if (IsRootNode(treeView.SelectedNode))
{
if (!actionScript)
{
script.Reverse(index1, index2);
}
else
{
action.Reverse(index1, index2);
}
}
else
{
int parent = treeView.SelectedNode.Parent.Index;
EventCommand esc = script.Commands[parent];
esc.Queue.Reverse(index1, index2);
}
}
public override async Task <CommandBase> GetNewCommand()
{
if (await this.Validate())
{
if (this.command == null)
{
this.command = new EventCommand(this.EventType);
if (ChannelSession.Settings.EventCommands.Any(se => se.EventCommandType.Equals(this.command.EventCommandType)))
{
await DialogHelper.ShowMessage("This event already exists");
return(null);
}
ChannelSession.Settings.EventCommands.Add(this.command);
}
this.command.Unlocked = this.UnlockedControl.Unlocked;
return(this.command);
}
return(null);
}
public virtual void HandleRequest()
{
switch (EventCommand.ToLower())
{
case "list":
case "search":
Get();
break;
case "save":
Save();
break;
case "edit":
Edit();
break;
case "delete":
ResetSearch();
Delete();
Get();
break;
case "cancel":
ListMode();
Get();
break;
case "resetsearch":
ResetSearch();
Get();
break;
case "add":
Add();
break;
default:
break;
}
}
/// <summary>
/// Load and creates a command after saving a command. Returns null if no object
/// has been loaded.
/// </summary>
/// <param name="n">Node with the command infos</param>
/// <param name="fc">Current flightcomputer</param>
public static ICommand LoadCommand(ConfigNode n, FlightComputer fc)
{
ICommand command = null;
// switch the different commands
switch (n.name)
{
case "AttitudeCommand": { command = new AttitudeCommand(); break; }
case "ActionGroupCommand": { command = new ActionGroupCommand(); break; }
case "BurnCommand": { command = new BurnCommand(); break; }
case "ManeuverCommand": { command = new ManeuverCommand(); break; }
case "CancelCommand": { command = new CancelCommand(); break; }
case "TargetCommand": { command = new TargetCommand(); break; }
case "EventCommand": { command = new EventCommand(); break; }
case "DriveCommand": { command = new DriveCommand(); break; }
case "ExternalAPICommand": { command = new ExternalAPICommand(); break; }
}
if (command != null)
{
ConfigNode.LoadObjectFromConfig(command, n);
// additional loadings
var result = command.Load(n, fc);
RTLog.Verbose("Loading command {0}={1}", RTLogLevel.LVL1, n.name, result);
// delete command if we can't load the command correctlys
if (result == false)
{
command = null;
}
}
return(command);
}
private async Task SaveAndClose(bool isBasic)
{
await this.window.RunAsyncOperation(async() =>
{
ActionBase action = this.actionControl.GetAction();
if (action == null)
{
if (this.actionControl is ChatActionControl)
{
await DialogHelper.ShowMessage("The chat message must not be empty");
}
else if (this.actionControl is SoundActionControl)
{
await DialogHelper.ShowMessage(MixItUp.Base.Resources.EmptySoundFilePath);
}
return;
}
EventCommand newCommand = new EventCommand(this.eventType);
newCommand.IsBasic = isBasic;
newCommand.Actions.Add(action);
if (this.command != null)
{
ChannelSession.Settings.EventCommands.Remove(this.command);
}
ChannelSession.Settings.EventCommands.Add(newCommand);
await ChannelSession.SaveSettings();
this.window.Close();
if (!isBasic)
{
await Task.Delay(250);
CommandWindow window = new CommandWindow(new EventCommandDetailsControl(newCommand));
window.CommandSaveSuccessfully += (sender, cmd) => this.CommandSavedSuccessfully(cmd);
window.Show();
}
});
}
// treeview managers
private void AddCommand(EventCommand esc)
{
TreeNode node = esc.Node;
if (esc.QueueTrigger || esc.Locked)
{
if (esc.Queue == null)
{
return;
}
List <ActionCommand> queue = esc.Queue.Commands;
for (int i = 0; queue != null && i < queue.Count; i++)
{
ActionCommand asc = queue[i];
TreeNode child = asc.Node;
node.Nodes.Add(child);
}
}
// Add command
this.treeView.Nodes.Add(node);
}
private EventCommand ConvertCassandraRow(Row instance)
{
EventCommand eventCommand = new EventCommand();
eventCommand.TemperatureEvent = new TemperatureEvent();
eventCommand.ActuationCommand = new ActuationCommand();
eventCommand.TemperatureEvent.Timestamp = DateTime.Parse(instance["Timestamp"].ToString());
eventCommand.TemperatureEvent.StationName = instance["StationName"].ToString();
eventCommand.TemperatureEvent.DataInfluenced = (DataInfluenced)Enum.Parse(typeof(DataInfluenced), instance["DataInfluenced"].ToString());
eventCommand.TemperatureEvent.Latitude = (double)instance["Latitude"];
eventCommand.TemperatureEvent.Longitude = (double)instance["Longitude"];
eventCommand.TemperatureEvent.EventType = (EventType)Enum.Parse(typeof(EventType), instance["EventType"].ToString());
eventCommand.TemperatureEvent.Value = (double)instance["Value"];
eventCommand.ActuationCommand.Command = instance["Command"].ToString();
List <string> args = instance["Args"].ToString().Split("&").ToList();
eventCommand.ActuationCommand.AdditionalArguments.AddRange(args);
return(eventCommand);
Enum.Parse(typeof(EventType), "jp");
}
public void SpeedTest_50000Calls()
{
var conf = new Configuration()
{
Name = "Tester", ID = 1234
};
var environment = new EventHandlerEnvironment();
var command = new EventCommand(environment);
var va = Helpers.InitializeTestVA(conf);
var dispatcher = va.EventDispatcher;
for (int i = 0; i < 50000; i++)
{
dispatcher.Dispatch(command);
}
Assert.IsTrue(true);
}
internal static void ExecuteCommandEvent(string database, EventCommand waitingevent)
{
var store = new ObjectStoreWrapper(database);
LogWriter.LogInformation("Executing waiting event", LogEntryType.Information);
#region Execute inline global event handlers
foreach (var ge in _globaleventhandlers)
{
try
{
if (ge != null)
{
ge(store, waitingevent);
}
}
catch (Exception ex)
{
LogWriter.LogException(ex);
}
}
#endregion
var command = JObject.Parse(waitingevent.Command);
var currenthandlers = ChechHandlers(command);
if (currenthandlers != null)
{
foreach (var hh in currenthandlers)
{
try
{
hh.HandleCommand(store, command);
}
catch (Exception ex)
{
LogWriter.LogException(ex);
}
}
}
}
public void HandleRequest()
{
if (!String.IsNullOrEmpty(SalvarAgendamento))
{
EventCommand = SalvarAgendamento;
}
Console.WriteLine(EventCommand);
switch (EventCommand.ToLower())
{
case "lista":
case "pesquisar":
IsAgendamentoMode = false;
IsListMode = true;
GetAgendamentos();
break;
case "imprimir":
break;
case "salvar":
IsAgendamentoMode = false;
IsListMode = true;
salvarAgendamento();
break;
case "reagendar":
case "cancelar":
AtualizarStatus();
break;
case "novoagendamento":
IsAgendamentoMode = true;
IsListMode = false;
GetPacientes();
break;
}
}
public ActionResult Monitor(int id)
{
var eventt = EventCommand.Get(id);
if (LoggedUserIs(RoleEnum.EventAdministrator) && eventt.Organizer.Id != GetLoggedUser().Id)
{
return(RedirectToAction("Index", "ManageEvent"));
}
var eventtModel = new EventMonitorModel()
{
Id = eventt.Id,
Name = eventt.Name,
Latitude = eventt.Latitude,
Longitude = eventt.Longitude,
BeginDateTime = eventt.BeginDateTime,
EndDateTime = eventt.EndDateTime,
Address = eventt.Address.ToDisplay(),
OrganizerDisplay = eventt.Organizer.ToDisplay(),
Status = eventt.Status,
AmountPeople = Activities.Where(e => e.Event == eventt).Count(),
IsCollaborativeSearchStart = eventt.CollaborativeSearchDateTime.HasValue,
IAmOk = true,
LastUpdate = eventt.EndDateTime,
WithoutAnswer = true,
IAmNotOk = true,
Clustered = true,
};
if (eventt.EmergencyDateTime.HasValue)
{
eventtModel.EmergencyDateTime = eventt.EmergencyDateTime.Value;
}
if (eventt.CollaborativeSearchDateTime.HasValue)
{
eventtModel.CollaborativeSearchDateTime = eventt.CollaborativeSearchDateTime.Value;
}
return(View(eventtModel));
}
public void SpeedTest_AdditionalAssembly_100000Calls()
{
var conf = new Additional.TestConfiguration()
{
id = 1234
};
var environment = new EventHandlerEnvironment();
var command = new EventCommand(environment);
var va = Helpers.InitializeTestVA(conf);
var dispatcher = va.EventDispatcher;
dispatcher.IncludeAssemblies(typeof(Additional.TestConfiguration).Assembly);
for (int i = 0; i < 100000; i++)
{
dispatcher.Dispatch(command);
}
Assert.IsTrue(true);
}
private async Task PerformUserFirstJoins(IEnumerable <UserViewModel> users)
{
try
{
EventCommand command = ChannelSession.Constellation.FindMatchingEventCommand(EnumHelper.GetEnumName(OtherEventTypeEnum.MixerUserFirstJoin));
if (command != null)
{
foreach (UserViewModel user in users)
{
if (user.Data.ViewingMinutes == 0)
{
if (ChannelSession.Constellation.CanUserRunEvent(user, EnumHelper.GetEnumName(OtherEventTypeEnum.MixerUserFirstJoin)))
{
ChannelSession.Constellation.LogUserRunEvent(user, EnumHelper.GetEnumName(OtherEventTypeEnum.MixerUserFirstJoin));
await ChannelSession.Constellation.RunEventCommand(command, user);
}
}
}
}
}
catch (Exception ex) { Util.Logger.Log(ex); }
}
public void HandleRequest()
{
string cmd = EventCommand.ToLower();
switch (cmd)
{
case "reset":
Reset();
break;
case "geterrorqueue":
GetSelectedErrorQueue();
break;
case "selectlabel":
GetSelectedMessage();
break;
case "editbodyselectq":
SelectOutputQueue();
break;
case "editbodycancel":
Reset();
break;
case "post":
SaveMessage();
Reset();
break;
default:
var text = $"Command error: {cmd}";
MessageBox.Show(text, "Unknown Command", MessageBoxButtons.OK);
Reset();
break;
}
}
public long LogCommand(EventCommand command)
{
lock (_filelock)
{
CommandSN++;
if (Configuration.EnableJournaling)
{
if (OpenLogFile())
{
// Writing the journal
if (_ensureatomicwrites)
{
_logfile.Flush();
}
_logbuffer.Seek(0, SeekOrigin.Begin);
_logbuffer.SetLength(0);
_writer.Write('K');
_writer.Write(CommandSN);
_writer.Write(command.CommandMarker ?? string.Empty);
_writer.Write('D');
_writer.Write(command.Command);
_writer.Flush();
// this should be an atomic operation due to filestream flag used during open.
_logfile.Write(_logbuffer.ToArray(), 0, (int)_logbuffer.Length);
_logfile.Flush(_ensureatomicwrites);
if (_logfile.Length - _logfile.Position < _logfilefreespace)
{
IncreaseFileSize();
}
}
}
}
return(CommandSN);
}
public void HandleRequest()
{
switch (EventCommand.ToLower())
{
case "list":
case "search":
Get();
break;
case "resetsearch":
Get();
break;
case "add":
Add();
break;
case "cancel":
ListMode();
Get();
break;
case "save":
Save();
if (isValid)
{
Get();
}
break;
case "edit":
break;
default:
break;
}
}
public void HandleRequest()
{
switch (EventCommand.ToLower())
{
case "list":
case "search":
Get();
break;
case "resetsearch":
ResetSearch();
break;
case "add":
IsListAreaVisible = false;
IsSearchAreaVisible = false;
IsListAreaVisible = true;
break;
default:
break;
}
}
public void AssertThat_ChangesMadeInMultipleHandlers_PropagateToEnvironment()
{
var expectedID = 1234;
var expectedName = "Tester";
var conf = new Configuration()
{
Name = "Tester", ID = 1234
};
var va = Helpers.InitializeTestVA(conf);
var environment = va.CreateEventHandlerEnvironment(MFilesAPI.MFEventHandlerType.MFEventHandlerAfterSetProperties);
var command = new EventCommand(environment);
Dispatcher dispatcher = va.EventDispatcher;
dispatcher.Dispatch(command);
Assert.AreEqual(expectedID, environment.CurrentUserID);
Assert.AreEqual(expectedName, environment.Input);
}
public override void EventSourceCommand(string eventSourceName, EventCommand command, FilteringOptions options = null)
{
if (options == null)
{
options = new FilteringOptions();
}
foreach (EventSource source in EventSource.GetSources())
{
if (source.Name == eventSourceName)
{
DoCommand(source, command, options);
return;
}
}
_onEventSourceCreated += delegate(EventSource sourceBeingCreated)
{
if (eventSourceName != null && eventSourceName == sourceBeingCreated.Name)
{
DoCommand(sourceBeingCreated, command, options);
eventSourceName = null; // so we only do it once.
}
};
}
private async Task ProcessCardRedemption(JObject jobj)
{
string cardData = string.Empty;
StreamlootsCardModel card = jobj["data"].ToObject <StreamlootsCardModel>();
if (card != null)
{
UserViewModel user = new UserViewModel(0, card.data.Username);
UserModel userModel = await ChannelSession.Connection.GetUser(user.UserName);
if (userModel != null)
{
user = new UserViewModel(userModel);
}
EventCommand command = ChannelSession.Constellation.FindMatchingEventCommand(EnumHelper.GetEnumName(OtherEventTypeEnum.StreamlootsCardRedeemed));
if (command != null)
{
Dictionary <string, string> specialIdentifiers = new Dictionary <string, string>();
specialIdentifiers.Add("streamlootscardname", card.data.cardName);
specialIdentifiers.Add("streamlootscardimage", card.imageUrl);
specialIdentifiers.Add("streamlootscardhasvideo", (!string.IsNullOrEmpty(card.videoUrl)).ToString());
specialIdentifiers.Add("streamlootscardvideo", card.videoUrl);
specialIdentifiers.Add("streamlootscardsound", card.soundUrl);
string message = card.data.Message;
if (string.IsNullOrEmpty(message))
{
message = card.data.LongMessage;
}
specialIdentifiers.Add("streamlootsmessage", message);
await command.Perform(user, arguments : null, extraSpecialIdentifiers : specialIdentifiers);
}
}
}
public void HookPartMenus()
{
UIPartActionMenuPatcher.Wrap(vessel, (e, ignoreDelay) =>
{
var v = FlightGlobals.ActiveVessel;
if (v == null || v.isEVA || RTCore.Instance == null)
{
e.Invoke();
return;
}
var vs = RTCore.Instance.Satellites[v];
if (vs == null || vs.HasLocalControl)
{
e.Invoke();
}
else if (eventWhiteList.Contains(e.name))
{
e.Invoke();
}
else if (vs.FlightComputer != null && vs.FlightComputer.InputAllowed)
{
if (ignoreDelay)
{
e.Invoke();
}
else
{
vs.SignalProcessor.FlightComputer.Enqueue(EventCommand.Event(e));
}
}
else
{
ScreenMessages.PostScreenMessage(new ScreenMessage("No connection to send command on.", 4.0f, ScreenMessageStyle.UPPER_LEFT));
}
});
}
public async Task <IEnumerable <UserViewModel> > RemoveUsers(IEnumerable <uint> userIDs)
{
List <UserViewModel> results = new List <UserViewModel>();
await this.semaphore.WaitAndRelease(() =>
{
foreach (uint userID in userIDs)
{
if (this.users.ContainsKey(userID))
{
UserViewModel user = this.users[userID];
this.users.Remove(userID);
results.Add(user);
}
}
return(Task.FromResult(0));
});
EventCommand command = ChannelSession.Constellation.FindMatchingEventCommand(EnumHelper.GetEnumName(OtherEventTypeEnum.MixerUserLeft));
if (command != null)
{
foreach (UserViewModel user in results)
{
if (user.IsInChat)
{
if (ChannelSession.Constellation.CanUserRunEvent(user, EnumHelper.GetEnumName(OtherEventTypeEnum.MixerUserLeft)))
{
ChannelSession.Constellation.LogUserRunEvent(user, EnumHelper.GetEnumName(OtherEventTypeEnum.MixerUserLeft));
await ChannelSession.Constellation.RunEventCommand(command, user);
}
}
}
}
return(results);
}
public async Task PerformEvent(EventTrigger trigger)
{
if (this.CanPerformEvent(trigger))
{
UserViewModel user = trigger.User;
if (user == null)
{
user = ChannelSession.GetCurrentUser();
}
if (this.userEventTracking.ContainsKey(trigger.Type))
{
this.userEventTracking[trigger.Type].Add(user.ID);
}
EventCommand command = this.GetEventCommand(trigger.Type);
if (command != null)
{
Logger.Log(LogLevel.Debug, $"Performing event trigger: {trigger.Type}");
await command.Perform(user, platform : trigger.Platform, arguments : trigger.Arguments, extraSpecialIdentifiers : trigger.SpecialIdentifiers);
}
}
}
private async void PlayButton_Click(object sender, RoutedEventArgs e)
{
this.PlayButton.Visibility = Visibility.Collapsed;
this.StopButton.Visibility = Visibility.Visible;
this.EditButton.IsEnabled = false;
this.DeleteButton.IsEnabled = false;
this.EnableDisableToggleSwitch.IsEnabled = false;
CommandBase command = this.GetCommandFromCommandButtons <CommandBase>(this);
if (command != null)
{
UserViewModel currentUser = await ChannelSession.GetCurrentUser();
Dictionary <string, string> extraSpecialIdentifiers = new Dictionary <string, string>();
if (command is EventCommand)
{
EventCommand eventCommand = command as EventCommand;
switch (eventCommand.EventType)
{
case Mixer.Base.Clients.ConstellationEventTypeEnum.channel__id__hosted:
extraSpecialIdentifiers["hostviewercount"] = "123";
break;
case Mixer.Base.Clients.ConstellationEventTypeEnum.channel__id__resubscribed:
extraSpecialIdentifiers["usersubmonths"] = "5";
break;
}
switch (eventCommand.OtherEventType)
{
case OtherEventTypeEnum.GameWispSubscribed:
case OtherEventTypeEnum.GameWispResubscribed:
extraSpecialIdentifiers["subscribemonths"] = "999";
extraSpecialIdentifiers["subscribetier"] = "Test Tier";
extraSpecialIdentifiers["subscribeamount"] = "$12.34";
break;
case OtherEventTypeEnum.StreamlabsDonation:
case OtherEventTypeEnum.GawkBoxDonation:
case OtherEventTypeEnum.TiltifyDonation:
case OtherEventTypeEnum.ExtraLifeDonation:
case OtherEventTypeEnum.TipeeeStreamDonation:
case OtherEventTypeEnum.TreatStreamDonation:
case OtherEventTypeEnum.StreamJarDonation:
UserDonationModel donation = new UserDonationModel()
{
Amount = 12.34,
Message = "Test donation message",
ImageLink = currentUser.AvatarLink
};
switch (eventCommand.OtherEventType)
{
case OtherEventTypeEnum.StreamlabsDonation: donation.Source = UserDonationSourceEnum.Streamlabs; break;
case OtherEventTypeEnum.GawkBoxDonation: donation.Source = UserDonationSourceEnum.GawkBox; break;
case OtherEventTypeEnum.TiltifyDonation: donation.Source = UserDonationSourceEnum.Tiltify; break;
case OtherEventTypeEnum.ExtraLifeDonation: donation.Source = UserDonationSourceEnum.ExtraLife; break;
case OtherEventTypeEnum.TipeeeStreamDonation: donation.Source = UserDonationSourceEnum.TipeeeStream; break;
case OtherEventTypeEnum.TreatStreamDonation: donation.Source = UserDonationSourceEnum.TreatStream; break;
case OtherEventTypeEnum.StreamJarDonation: donation.Source = UserDonationSourceEnum.StreamJar; break;
}
foreach (var kvp in donation.GetSpecialIdentifiers())
{
extraSpecialIdentifiers[kvp.Key] = kvp.Value;
}
extraSpecialIdentifiers["donationtype"] = "Pizza";
break;
case OtherEventTypeEnum.PatreonSubscribed:
extraSpecialIdentifiers[SpecialIdentifierStringBuilder.PatreonTierNameSpecialIdentifier] = "Super Tier";
extraSpecialIdentifiers[SpecialIdentifierStringBuilder.PatreonTierAmountSpecialIdentifier] = "12.34";
extraSpecialIdentifiers[SpecialIdentifierStringBuilder.PatreonTierImageSpecialIdentifier] = "https://xforgeassets002.xboxlive.com/xuid-2535473787585366-public/b7a1d715-3a9e-4bdd-a030-32f9e2e0f51e/0013_lots-o-stars_256.png";
break;
case OtherEventTypeEnum.TwitterStreamTweetRetweet:
break;
case OtherEventTypeEnum.MixerSkillUsed:
extraSpecialIdentifiers["skillname"] = "Lots of stars";
extraSpecialIdentifiers["skilltype"] = EnumHelper.GetEnumName(SkillTypeEnum.Sticker);
extraSpecialIdentifiers["skillcosttype"] = "Embers";
extraSpecialIdentifiers["skillcost"] = "50";
extraSpecialIdentifiers["skillimage"] = "https://xforgeassets002.xboxlive.com/xuid-2535473787585366-public/b7a1d715-3a9e-4bdd-a030-32f9e2e0f51e/0013_lots-o-stars_256.png";
extraSpecialIdentifiers["skillissparks"] = false.ToString();
extraSpecialIdentifiers["skillisembers"] = true.ToString();
extraSpecialIdentifiers["skillmessage"] = "Hello World!";
break;
case OtherEventTypeEnum.MixerMilestoneReached:
extraSpecialIdentifiers["milestoneamount"] = "100";
extraSpecialIdentifiers["milestoneremainingamount"] = "100";
extraSpecialIdentifiers["milestonereward"] = "$10.00";
extraSpecialIdentifiers["milestonenextamount"] = "100";
extraSpecialIdentifiers["milestonenextremainingamount"] = "100";
extraSpecialIdentifiers["milestonenextreward"] = "$10.00";
extraSpecialIdentifiers["milestonefinalamount"] = "100";
extraSpecialIdentifiers["milestonefinalremainingamount"] = "100";
extraSpecialIdentifiers["milestonefinalreward"] = "$10.00";
extraSpecialIdentifiers["milestoneearnedamount"] = "100";
extraSpecialIdentifiers["milestoneearnedreward"] = "$10.00";
break;
case OtherEventTypeEnum.MixerSparksUsed:
extraSpecialIdentifiers["sparkamount"] = "10";
break;
case OtherEventTypeEnum.MixerEmbersUsed:
extraSpecialIdentifiers["emberamount"] = "10";
break;
}
}
else if (command is InteractiveCommand)
{
InteractiveCommand iCommand = (InteractiveCommand)command;
extraSpecialIdentifiers["mixplaycontrolid"] = iCommand.Name;
extraSpecialIdentifiers["mixplaycontrolcost"] = "123";
}
else if (command is CustomCommand)
{
if (command.Name.Equals(InventoryWindow.ItemsBoughtCommandName) || command.Name.Equals(InventoryWindow.ItemsSoldCommandName))
{
extraSpecialIdentifiers["itemtotal"] = "5";
extraSpecialIdentifiers["itemname"] = "Chocolate Bars";
extraSpecialIdentifiers["itemcost"] = "500";
extraSpecialIdentifiers["currencyname"] = "CURRENCY_NAME";
}
}
await command.PerformAndWait(currentUser, new List <string>() { "@" + currentUser.UserName }, extraSpecialIdentifiers);
if (command is PermissionsCommandBase)
{
PermissionsCommandBase permissionCommand = (PermissionsCommandBase)command;
permissionCommand.ResetCooldown(await ChannelSession.GetCurrentUser());
}
this.SwitchToPlay();
}
this.RaiseEvent(new RoutedEventArgs(CommandButtonsControl.PlayClickedEvent, this));
}
public static void SendCommand(EventSource eventSource, EventCommand command, IDictionary <string, string> commandArguments);
/// <summary>
/// Position the cursor at beginning of Interpreter
/// </summary>
public void Reset(EventCommand[] _list)
{
for(int i=0; i<branch.Length; i++)
{
branch[i].Reset();
}
list = _list;
index = 0;
}
public MainWindowViewModel()
{
OpenConnectionCommand = new RelayCommand(OpenConnection);
OpenLogsCommand = new EventCommand<IList>(open_logs, x => x.Count > 0);
ManagerWebsitesCommand = new EventCommand<IList>(ManageWebsites, x => x.Count > 0);
TabItemsViewModelCollection = new ObservableCollection<TabItemViewModel>();
CloseTabCommand = new EventCommand<TabItemViewModel>(close_tabs);
DeploymentSelectionChangedCommand = new EventCommand<object>(k => { OpenLogsCommand.RaiseCanExecuteChanged(); });
// public RelayCommand CloseTabCommand { get; set; }
//TODO Fix the watermarks.
StorageAccount = "Azure Storage Account";
StorageKey = "Key";
ConfigurationFolder = "Not Used";
//LogViewer = new TextEditorWrapper();
LoadConnectionInfo();
}
public ProductClickCommand(ProductClickActionFieldObject clickAction, ProductFieldObject product, EventCommand trackingEvent)
{
_clickAction = clickAction;
_product = product;
_trackingEvent = trackingEvent;
}
/// <summary>
/// Send a command to a particular EventSource identified by 'eventSource'
///
/// Calling this routine simply forwards the command to the EventSource.OnEventCommand
/// callback. What the EventSource does with the command and its arguments are from that point
/// EventSource-specific.
///
/// The eventSource is passed the EventListener that issued the command along with the command and
/// arguments. The contract is that to the extent possible the eventSource should not affect other
/// EventListeners (eg filtering events), however sometimes this simply is not possible (if the
/// command was to provoke a GC, or a System flush etc).
/// </summary>
public static void SendCommand(EventSource eventSource, EventCommand command, IDictionary<string, string> commandArguments)
{
if (eventSource == null)
throw new ArgumentNullException("eventSource");
// User-defined EventCommands should not conflict with the reserved commands.
if ((int)command <= (int)EventCommand.Update && (int)command != (int)EventCommand.SendManifest)
throw new ArgumentException("Invalid command value.", "command");
eventSource.SendCommand(null, 0, 0, command, true, EventLevel.LogAlways, EventKeywords.None, commandArguments);
}
// This is the internal entry point that code:EventListeners call when wanting to send a command to a
// eventSource. The logic is as follows
//
// * if Command == Update
// * enabled, level, matchAnyKeywords are used to set a default for all events for the
// curEventSource. In particular, if 'enabled' is false, 'level' and
// 'matchAnyKeywords' are not used.
// * OnEventCommand is invoked, which may cause calls to
// code:EventSource.EnableEventForDispatcher which may cause changes in the filtering
// depending on the logic in that routine.
// * else (command != Update)
// * Simply call OnEventCommand. The expectation is that filtering is NOT changed.
// * The 'enabled' 'level', matchAnyKeyword' arguments are ignored (must be true, 0, 0).
//
// dispatcher == null has special meaning. It is the 'ETW' dispatcher.
internal void SendCommand(EventListener listener, EventCommand command, bool enable, EventLevel level, EventKeywords matchAnyKeyword, IDictionary<string, string> commandArguments)
{
m_lastCommandException = null;
try
{
InsureInitialized();
// Find the per-EventSource dispatcher cooresponding to registered dispatcher
EventDispatcher eventSourceDispatcher = GetDispatcher(listener);
if (eventSourceDispatcher == null && listener != null) // dispatcher == null means ETW dispatcher
throw new ArgumentException(SR.EventSource_ListenerNotFound);
if (commandArguments == null)
commandArguments = new Dictionary<string, string>();
if (command == EventCommand.Update)
{
// Set it up using the 'standard' filtering bitfields
for (int i = 0; i < m_eventData.Length; i++)
EnableEventForDispatcher(eventSourceDispatcher, i, IsEnabledByDefault(i, enable, level, matchAnyKeyword));
command = EventCommand.Disable;
if (enable)
{
command = EventCommand.Enable;
if (!m_eventSourceEnabled)
{
// EventSource turned on for the first time, simply copy the bits.
m_level = level;
m_matchAnyKeyword = matchAnyKeyword;
}
else
{
// Already enabled, make it the most verbose of the existing and new filter
if (level > m_level)
m_level = level;
if (matchAnyKeyword == 0)
m_matchAnyKeyword = 0;
else if (m_matchAnyKeyword != 0)
m_matchAnyKeyword |= matchAnyKeyword;
}
// Send the manifest if we are writing to ETW
if (eventSourceDispatcher == null)
{
// eventSourceDispatcher == null means this is the ETW manifest
// If we are not completely initalized we can't send the manifest because WriteEvent
// will fail (handle was not returned from OS API). We will try again after the
// constuctor completes.
if (!m_ETWManifestSent && m_completelyInited)
{
m_ETWManifestSent = true;
SendManifest(m_rawManifest);
}
}
}
this.OnEventCommand(new EventCommandEventArgs(command, commandArguments, this, eventSourceDispatcher));
if (enable)
{
m_eventSourceEnabled = true;
}
else
{
// If we are disabling, maybe we can turn so 'quick checks' to filter
// quickly. These are all just optimizations (since later checks will still filter)
// reset the 'manifestSent' bit for the listener.
if (eventSourceDispatcher == null)
m_ETWManifestSent = false; // Null dispatcher means ETW dispatcher.
// There is a good chance EnabledForAnyListener are not as accurate as
// they could be, go ahead and get a better estimate.
for (int i = 0; i < m_eventData.Length; i++)
{
m_eventData[i].EnabledForAnyListener = false;
for (EventDispatcher dispatcher = m_Dispatchers; dispatcher != null; dispatcher = dispatcher.m_Next)
{
if (dispatcher.m_EventEnabled[i])
{
m_eventData[i].EnabledForAnyListener = true;
break;
}
}
}
// If no events are enabled, disable the global enabled bit.
if (!AnyEventEnabled())
{
m_level = 0;
m_matchAnyKeyword = 0;
m_eventSourceEnabled = false;
}
}
}
else
{
if (command == EventCommand.SendManifest)
SendManifest(m_rawManifest);
// These are not used for non-update commands and thus should always be 'default' values
Contract.Assert(enable == true);
Contract.Assert(m_level == EventLevel.LogAlways);
Contract.Assert(m_matchAnyKeyword == EventKeywords.None);
this.OnEventCommand(new EventCommandEventArgs(command, commandArguments, null, null));
}
}
catch (Exception e)
{
// Remember any exception and rethrow.
m_lastCommandException = e;
throw;
}
}
public LocalDataViewCommandGoToCreateMode(EventCommand command)
: base(command)
{
}
/// <summary> /// Send a command to an eventSource. Be careful this is async. You may wish to do a WaitForEnable /// </summary> public abstract void EventSourceCommand(string eventSourceName, EventCommand command, FilteringOptions options = null);
private void DoCommand(EventSource source, EventCommand command, FilteringOptions options)
{
if (command == EventCommand.Enable)
_listener.EnableEvents(source, options.Level, options.Keywords, options.Args);
else if (command == EventCommand.Disable)
_listener.DisableEvents(source);
else
throw new NotImplementedException();
}
public override void EventSourceCommand(string eventSourceName, EventCommand command, FilteringOptions options = null)
{
if (options == null)
options = new FilteringOptions();
foreach (EventSource source in EventSource.GetSources())
{
if (source.Name == eventSourceName)
{
DoCommand(source, command, options);
return;
}
}
_onEventSourceCreated += delegate (EventSource sourceBeingCreated)
{
if (eventSourceName != null && eventSourceName == sourceBeingCreated.Name)
{
DoCommand(sourceBeingCreated, command, options);
eventSourceName = null; // so we only do it once.
}
};
}
/// <summary> /// Send a command to an eventSource. Be careful this is async. You may wish to do a WaitForEnable /// </summary> public abstract void EventSourceCommand(string eventSourceName, EventCommand command, FilteringOptions options = null);
public override void EventSourceCommand(string eventSourceName, EventCommand command, FilteringOptions options = null)
{
if (command == EventCommand.Enable)
{
if (options == null)
options = new FilteringOptions();
_session.EnableProvider(eventSourceName, (TraceEventLevel)options.Level, (ulong)options.Keywords,
new TraceEventProviderOptions() { Arguments = options.Args });
}
else if (command == EventCommand.Disable)
{
_session.DisableProvider(TraceEventProviders.GetEventSourceGuidFromName(eventSourceName));
}
else
throw new NotImplementedException();
Thread.Sleep(200); // Calls are async, give them time to work.
}
/// <summary>
/// Send a command to a particular EventSource identified by 'eventSource'
///
/// Calling this routine simply forwards the command to the EventSource.OnEventCommand
/// callback. What the EventSource does with the command and its arguments are from that point
/// EventSource-specific.
///
/// The eventSource is passed the EventListener that issued the command along with the command and
/// arguments. The contract is that to the extent possible the eventSource should not affect other
/// EventListeners (eg filtering events), however sometimes this simply is not possible (if the
/// command was to provoke a GC, or a System flush etc).
/// </summary>
public static void SendCommand(EventSource eventSource, EventCommand command, IDictionary<string, string> commandArguments)
{
if (eventSource == null)
throw new ArgumentNullException(nameof(eventSource));
// User-defined EventCommands should not conflict with the reserved commands.
if ((int)command <= (int)EventCommand.Update && (int)command != (int)EventCommand.SendManifest)
throw new ArgumentException(SR.ArgumentOutOfRange_NeedPosNum, nameof(command));
eventSource.SendCommand(null, command, true, EventLevel.LogAlways, EventKeywords.None, commandArguments);
}
internal EventCommandEventArgs(EventCommand command, IDictionary<string, string> arguments, EventSource eventSource, EventDispatcher dispatcher)
{
this.Command = command;
this.Arguments = arguments;
this.eventSource = eventSource;
this.dispatcher = dispatcher;
}
protected virtual void initTarget(Object target)
{
// target可以让我们得到当前绘制的Component对象
m_Target = (EventCommand)target;
}
// This is the internal entry point that code:EventListeners call when wanting to send a command to a
// eventSource. The logic is as follows
//
// * if Command == Update
// * perEventSourceSessionId specifies the per-provider ETW session ID that the command applies
// to (if listener != null)
// perEventSourceSessionId = 0 - reserved for EventListeners
// perEventSourceSessionId = 1..SessionMask.MAX - reserved for activity tracing aware ETW sessions
// perEventSourceSessionId-1 represents the bit in the reserved field (bits 44..47) in
// Keywords that identifies the session
// perEventSourceSessionId = SessionMask.MAX+1 - reserved for legacy ETW sessions; these are
// discriminated by etwSessionId
// * etwSessionId specifies a machine-wide ETW session ID; this allows correlation of
// activity tracing across different providers (which might have different sessionIds
// for the same ETW session)
// * enable, level, matchAnyKeywords are used to set a default for all events for the
// eventSource. In particular, if 'enabled' is false, 'level' and
// 'matchAnyKeywords' are not used.
// * OnEventCommand is invoked, which may cause calls to
// code:EventSource.EnableEventForDispatcher which may cause changes in the filtering
// depending on the logic in that routine.
// * else (command != Update)
// * Simply call OnEventCommand. The expectation is that filtering is NOT changed.
// * The 'enabled' 'level', matchAnyKeyword' arguments are ignored (must be true, 0, 0).
//
// dispatcher == null has special meaning. It is the 'ETW' dispatcher.
internal void SendCommand(EventListener listener, int perEventSourceSessionId, int etwSessionId,
EventCommand command, bool enable,
EventLevel level, EventKeywords matchAnyKeyword,
IDictionary<string, string> commandArguments)
{
m_lastCommandException = null;
bool shouldReport = (perEventSourceSessionId > 0) && (perEventSourceSessionId <= SessionMask.MAX);
try
{
lock (EventListener.EventListenersLock)
{
EnsureInitialized();
// Find the per-EventSource dispatcher cooresponding to registered dispatcher
EventDispatcher eventSourceDispatcher = GetDispatcher(listener);
if (eventSourceDispatcher == null && listener != null) // dispatcher == null means ETW dispatcher
throw new ArgumentException(Environment.GetResourceString("EventSource_ListenerNotFound"));
if (commandArguments == null)
commandArguments = new Dictionary<string, string>();
if (command == EventCommand.Update)
{
// Set it up using the 'standard' filtering bitfields (use the "global" enable, not session specific one)
for (int i = 0; i < m_eventData.Length; i++)
EnableEventForDispatcher(eventSourceDispatcher, i, IsEnabledByDefault(i, enable, level, matchAnyKeyword));
if (enable)
{
if (!m_eventSourceEnabled)
{
// EventSource turned on for the first time, simply copy the bits.
m_level = level;
m_matchAnyKeyword = matchAnyKeyword;
}
else
{
// Already enabled, make it the most verbose of the existing and new filter
if (level > m_level)
m_level = level;
if (matchAnyKeyword == 0)
m_matchAnyKeyword = 0;
else if (m_matchAnyKeyword != 0)
m_matchAnyKeyword |= matchAnyKeyword;
}
}
// interpret perEventSourceSessionId's sign, and adjust perEventSourceSessionId to
// represent 0-based positive values
bool bSessionEnable = (perEventSourceSessionId >= 0);
if (perEventSourceSessionId == 0 && enable == false)
bSessionEnable = false;
if (listener == null)
{
if (!bSessionEnable)
perEventSourceSessionId = -perEventSourceSessionId;
// for "global" enable/disable (passed in with listener == null and
// perEventSourceSessionId == 0) perEventSourceSessionId becomes -1
--perEventSourceSessionId;
}
command = bSessionEnable ? EventCommand.Enable : EventCommand.Disable;
// perEventSourceSessionId = -1 when ETW sent a notification, but the set of active sessions
// hasn't changed.
// sesisonId = SessionMask.MAX when one of the legacy ETW sessions changed
// 0 <= perEventSourceSessionId < SessionMask.MAX for activity-tracing aware sessions
Contract.Assert(perEventSourceSessionId >= -1 && perEventSourceSessionId <= SessionMask.MAX);
// Send the manifest if we are enabling an ETW session
if (bSessionEnable && eventSourceDispatcher == null)
{
// eventSourceDispatcher == null means this is the ETW manifest
// SendCommand can be called from the EventSource constructor as a side effect of
// ETW registration. Unfortunately when this callback is active the provider is
// not actually enabled (WriteEvents will fail). Thus if we detect this condition
// (that we are still being constructed), we simply skip sending the manifest.
// When the constructor completes we will try again and send the manifest at that time.
//
// Note that we unconditionally send the manifest whenever we are enabled, even if
// we were already enabled. This is because there may be multiple sessions active
// and we can't know that all the sessions have seen the manifest.
if (m_completelyInited)
SendManifest(m_rawManifest);
else
m_deferedSendManifest = true;
}
#if FEATURE_ACTIVITYSAMPLING
if (bSessionEnable && perEventSourceSessionId != -1)
{
bool participateInSampling = false;
string activityFilters;
int sessionIdBit;
ParseCommandArgs(commandArguments, out participateInSampling,
out activityFilters, out sessionIdBit);
if (listener == null && commandArguments.Count > 0 && perEventSourceSessionId != sessionIdBit)
{
throw new ArgumentException(Environment.GetResourceString("EventSource_SessionIdError",
perEventSourceSessionId+SessionMask.SHIFT_SESSION_TO_KEYWORD,
sessionIdBit+SessionMask.SHIFT_SESSION_TO_KEYWORD));
}
if (listener == null)
{
UpdateEtwSession(perEventSourceSessionId, etwSessionId, true, activityFilters, participateInSampling);
}
else
{
ActivityFilter.UpdateFilter(ref listener.m_activityFilter, this, 0, activityFilters);
eventSourceDispatcher.m_activityFilteringEnabled = participateInSampling;
}
}
else if (!bSessionEnable && listener == null)
{
// if we disable an ETW session, indicate that in a synthesized command argument
if (perEventSourceSessionId >= 0 && perEventSourceSessionId < SessionMask.MAX)
{
commandArguments["EtwSessionKeyword"] = (perEventSourceSessionId+SessionMask.SHIFT_SESSION_TO_KEYWORD).ToString(CultureInfo.InvariantCulture);
}
}
#endif // FEATURE_ACTIVITYSAMPLING
this.OnEventCommand(new EventCommandEventArgs(command, commandArguments, this, eventSourceDispatcher));
#if FEATURE_ACTIVITYSAMPLING
if (listener == null && !bSessionEnable && perEventSourceSessionId != -1)
{
// if we disable an ETW session, complete disabling it
UpdateEtwSession(perEventSourceSessionId, etwSessionId, false, null, false);
}
#endif // FEATURE_ACTIVITYSAMPLING
if (enable)
{
m_eventSourceEnabled = true;
}
else
{
// If we are disabling, maybe we can turn on 'quick checks' to filter
// quickly. These are all just optimizations (since later checks will still filter)
#if FEATURE_ACTIVITYSAMPLING
// Turn off (and forget) any information about Activity Tracing.
if (listener == null)
{
// reset all filtering information for activity-tracing-aware sessions
for (int i = 0; i < SessionMask.MAX; ++i)
{
EtwSession etwSession = m_etwSessionIdMap[i];
if (etwSession != null)
ActivityFilter.DisableFilter(ref etwSession.m_activityFilter, this);
}
m_activityFilteringForETWEnabled = new SessionMask(0);
m_curLiveSessions = new SessionMask(0);
// reset activity-tracing-aware sessions
if (m_etwSessionIdMap != null)
for (int i = 0; i < SessionMask.MAX; ++i)
m_etwSessionIdMap[i] = null;
// reset legacy sessions
if (m_legacySessions != null)
m_legacySessions.Clear();
}
else
{
ActivityFilter.DisableFilter(ref listener.m_activityFilter, this);
eventSourceDispatcher.m_activityFilteringEnabled = false;
}
#endif // FEATURE_ACTIVITYSAMPLING
// There is a good chance EnabledForAnyListener are not as accurate as
// they could be, go ahead and get a better estimate.
for (int i = 0; i < m_eventData.Length; i++)
{
bool isEnabledForAnyListener = false;
for (EventDispatcher dispatcher = m_Dispatchers; dispatcher != null; dispatcher = dispatcher.m_Next)
{
if (dispatcher.m_EventEnabled[i])
{
isEnabledForAnyListener = true;
break;
}
}
m_eventData[i].EnabledForAnyListener = isEnabledForAnyListener;
}
// If no events are enabled, disable the global enabled bit.
if (!AnyEventEnabled())
{
m_level = 0;
m_matchAnyKeyword = 0;
m_eventSourceEnabled = false;
}
}
#if FEATURE_ACTIVITYSAMPLING
UpdateKwdTriggers(enable);
#endif // FEATURE_ACTIVITYSAMPLING
}
else
{
if (command == EventCommand.SendManifest)
SendManifest(m_rawManifest);
// These are not used for non-update commands and thus should always be 'default' values
Contract.Assert(enable == true);
Contract.Assert(m_level == EventLevel.LogAlways);
Contract.Assert(m_matchAnyKeyword == EventKeywords.None);
this.OnEventCommand(new EventCommandEventArgs(command, commandArguments, null, null));
}
#if FEATURE_ACTIVITYSAMPLING
if (m_completelyInited && (listener != null || shouldReport))
{
SessionMask m = SessionMask.FromId(perEventSourceSessionId);
ReportActivitySamplingInfo(listener, m);
}
OutputDebugString(string.Format(CultureInfo.InvariantCulture, "{0}.SendCommand(session {1}, cmd {2}, enable {3}, level {4}): live sessions {5:x}, sampling {6:x}",
m_name, perEventSourceSessionId, command, enable, level,
(ulong) m_curLiveSessions, (ulong) m_activityFilteringForETWEnabled));
#endif // FEATURE_ACTIVITYSAMPLING
}
}
catch (Exception e)
{
// Remember any exception and rethrow.
m_lastCommandException = e;
throw;
}
}
/// <summary>
/// Event Setup
/// </summary>
/// <param Name="_list">list of event commands</param>
/// <param Name="_event_id">event ID</param>
public void Setup(EventCommand[] _list, int _event_id)
{
// Clear inner situation of interpreter
Clear();
// Remember map ID
mapId = InGame.Map.MapId;
// Remember event ID
eventId = _event_id;
// Remember list of event commands
list = _list;
// Initialize index
index = 0;
}
public BasicEventCommandEditorControl(CommandWindow window, EventCommand command)
: this(window, command.EventType, BasicCommandTypeEnum.None)
{
this.command = command;
}
/// <summary>
/// Load and creates a command after saving a command. Returns null if no object
/// has been loaded.
/// </summary>
/// <param name="n">Node with the command infos</param>
/// <param name="fc">Current flightcomputer</param>
public static ICommand LoadCommand(ConfigNode n, FlightComputer fc)
{
ICommand command = null;
// switch the different commands
switch (n.name)
{
case "AttitudeCommand": { command = new AttitudeCommand(); break; }
case "ActionGroupCommand": { command = new ActionGroupCommand(); break; }
case "BurnCommand": { command = new BurnCommand(); break; }
case "ManeuverCommand": { command = new ManeuverCommand(); break; }
case "CancelCommand": { command = new CancelCommand(); break; }
case "TargetCommand": { command = new TargetCommand(); break; }
case "EventCommand": { command = new EventCommand(); break; }
case "DriveCommand": { command = new DriveCommand(); break; }
case "ExternalAPICommand": { command = new ExternalAPICommand(); break; }
}
if (command != null)
{
ConfigNode.LoadObjectFromConfig(command, n);
// additional loadings
var result = command.Load(n, fc);
RTLog.Verbose("Loading command {0}({1})={2}", RTLogLevel.LVL1, n.name, command.CmdGuid, result);
// delete command if we can't load the command correctlys
if (result == false)
command = null;
}
return command;
}