private void Rescan(List <int> authorIds, bool isNew, CommandTrigger trigger, bool infoUpdated)
{
var rescanAfterRefresh = _configService.RescanAfterRefresh;
var shouldRescan = true;
if (isNew)
{
_logger.Trace("Forcing rescan. Reason: New author added");
shouldRescan = true;
}
else if (rescanAfterRefresh == RescanAfterRefreshType.Never)
{
_logger.Trace("Skipping rescan. Reason: never rescan after refresh");
shouldRescan = false;
}
else if (rescanAfterRefresh == RescanAfterRefreshType.AfterManual && trigger != CommandTrigger.Manual)
{
_logger.Trace("Skipping rescan. Reason: not after automatic refreshes");
shouldRescan = false;
}
else if (!infoUpdated)
{
_logger.Trace("Skipping rescan. Reason: no metadata updated");
shouldRescan = false;
}
if (shouldRescan)
{
// some metadata has updated so rescan unmatched
// (but don't add new authors to reduce repeated searches against api)
var folders = _rootFolderService.All().Select(x => x.Path).ToList();
_commandQueueManager.Push(new RescanFoldersCommand(folders, FilterFilesType.Matched, false, authorIds));
}
}
private void ProcessCommand(string rawString, MessageCreateEventArgs e, CommandTrigger type)
{
// The first thing we do is get rid of the prefix string from the command. We take the message from looking like say this:
// --say something
// to
// say something
// that way we don't have any excess characters getting in the way.
string rawCommand = rawString.Substring(config.Prefix.Length);
// A try catch block for executing the command and catching various things and reporting on errors.
try
{
if (type == CommandTrigger.MessageCreate)
{
commandManager.ExecuteOnMessageCommand(rawCommand, e.Channel, e.Author, e.Message, client);
}
else if (type == CommandTrigger.BotMentioned)
{
commandManager.ExecuteOnMentionCommand(rawCommand, e.Channel, e.Author, e.Message, client);
}
}
catch (UnauthorizedAccessException ex) // Bad permission
{
e.Channel.SendMessageAsync(ex.Message);
}
catch (ModuleNotEnabledException x) // Module is disabled
{
e.Channel.SendMessageAsync($"{x.Message}");
}
catch (Exception ex) // Any other error that could happen inside of the commands.
{
e.Channel.SendMessageAsync("Exception occurred while running command:\n```\n" + ex.Message + "\n```");
}
}
private void RescanSeries(Series series, bool isNew, CommandTrigger trigger)
{
var rescanAfterRefresh = _configService.RescanAfterRefresh;
var shouldRescan = true;
if (isNew)
{
_logger.Trace("Forcing rescan of {0}. Reason: New series", series);
shouldRescan = true;
}
else if (rescanAfterRefresh == RescanAfterRefreshType.Never)
{
_logger.Trace("Skipping rescan of {0}. Reason: never rescan after refresh", series);
shouldRescan = false;
}
else if (rescanAfterRefresh == RescanAfterRefreshType.AfterManual && trigger != CommandTrigger.Manual)
{
_logger.Trace("Skipping rescan of {0}. Reason: not after automatic scans", series);
shouldRescan = false;
}
if (!shouldRescan)
{
return;
}
try
{
_diskScanService.Scan(series);
}
catch (Exception e)
{
_logger.Error(e, "Couldn't rescan series {0}", series);
}
}
private UpdatePackage GetUpdatePackage(CommandTrigger updateTrigger)
{
_logger.ProgressDebug("Checking for updates");
var latestAvailable = _checkUpdateService.AvailableUpdate();
if (latestAvailable == null)
{
_logger.ProgressDebug("No update available");
return(null);
}
if (OsInfo.IsNotWindows && !_configFileProvider.UpdateAutomatically && updateTrigger != CommandTrigger.Manual)
{
_logger.ProgressDebug("Auto-update not enabled, not installing available update");
return(null);
}
// Safety net, ConfigureUpdateMechanism should take care of invalid settings
if (_configFileProvider.UpdateMechanism == UpdateMechanism.BuiltIn && _deploymentInfoProvider.IsExternalUpdateMechanism)
{
_logger.ProgressDebug("Built-In updater disabled, please use {0} to install", _deploymentInfoProvider.PackageUpdateMechanism);
return(null);
}
else if (_configFileProvider.UpdateMechanism != UpdateMechanism.Script && _deploymentInfoProvider.IsExternalUpdateMechanism)
{
_logger.ProgressDebug("Update available, please use {0} to install", _deploymentInfoProvider.PackageUpdateMechanism);
return(null);
}
return(latestAvailable);
}
public override void Execute(CommandTrigger trigger)
{
if (trigger is not GameCommandTrigger)
{
Logger.Error("This command can only be executed in game.");
return;
}
Execute(trigger as GameCommandTrigger);
}
internal static async Task <ICommandResult> GetCommandResultAsync(this IDurableClient durableClient, ICommand command)
{
if (durableClient is null)
{
throw new ArgumentNullException(nameof(durableClient));
}
if (command is null)
{
throw new ArgumentNullException(nameof(command));
}
var commandStatus = await durableClient
.GetStatusAsync(CommandTrigger.GetCommandOrchestrationInstanceId(command))
.ConfigureAwait(false);
if (commandStatus is null)
{
// the command orchestration wasn't created yet
// there is no way to return a command result
return(null);
}
else if (commandStatus.RuntimeStatus.IsFinal())
{
// the command orchestration reached a final state
// but the message orchestration is responsible to
// send the result and there could modify the overall
// command result (e.g. if a send operation fails).
var commandMessageStatus = await durableClient
.GetStatusAsync(CommandTrigger.GetCommandWrapperOrchestrationInstanceId(command))
.ConfigureAwait(false);
if (commandMessageStatus?.Output.HasValues ?? false)
{
return(commandMessageStatus.Output
.ToObject <ICommandResult>()
.ApplyStatus(commandMessageStatus));
}
}
// the command orchestration is in-flight
// get the current command result from its
// output or fallback to the default result
var commandResult = commandStatus.Output.HasValues
? commandStatus.Output.ToObject <ICommandResult>()
: command.CreateResult(); // fallback to the default command result
return(commandResult.ApplyStatus(commandStatus));
}
public Command ToCommand(string id)
{
var command = new Command()
{
Contexts = Contexts,
Id = id
};
Trigger trigger = null;
switch (MatcherType)
{
case CommandMatcherType.Command:
trigger = new CommandTrigger()
{
Name = MatcherString
};
break;
case CommandMatcherType.Regex:
// find flags at the end of expr like: "test/i"
// but not like "test\/slash"
var matches = Regex.Matches(MatcherString, @"[^\\]\/");
if (matches.Any())
{
var last_match = matches.Last();
var index = last_match.Index + 2; // since we have a [^\\] + \/ (2 chars)
var flags = MatcherString.Substring(index);
var expr = MatcherString.Substring(0, index - 1);
trigger = new RegexTrigger()
{
Expression = expr, Flags = flags.ToCharArray().Select(c => c.ToString()).ToList()
};
}
else
{
trigger = new RegexTrigger()
{
Expression = MatcherString
};
}
break;
}
command.Triggers = new List <Trigger>()
{
trigger
};
return(command);
}
/*
* [Obsolete]
* public CommandStub(string name, string description, string helpTag)
* {
* this.ID = IDGenerator.GenerateRandomCode();
*
* CommandName = name;
* Description = description;
* HelpTag = helpTag;
*
* Args = new List<string>();
* }
*
* [Obsolete]
* public CommandStub(string name, string description, CommandTrigger trigger = CommandTrigger.MessageCreate)
* {
* this.ID = IDGenerator.GenerateRandomCode();
*
* CommandName = name;
* Description = description;
* Trigger = trigger;
*
* Args = new List<string>();
* }
*
* [Obsolete]
* public CommandStub(Action<CommandArgs> action)
* {
* this.ID = IDGenerator.GenerateRandomCode();
*
* Do = action;
*
* Args = new List<string>();
* }
*
* [Obsolete]
* public CommandStub(string name, string description, Action<CommandArgs> action, CommandTrigger trigger = CommandTrigger.MessageCreate)
* {
* this.ID = IDGenerator.GenerateRandomCode();
*
* Do = action;
* CommandName = name;
* Description = description;
* Trigger = trigger;
*
* Args = new List<string>();
* }
*
* [Obsolete]
* public CommandStub(string name, string description, string helpTag, Action<CommandArgs> action, CommandTrigger trigger = CommandTrigger.MessageCreate)
* {
* this.ID = IDGenerator.GenerateRandomCode();
*
* Do = action;
* CommandName = name;
* Description = description;
* HelpTag = helpTag;
* Trigger = trigger;
*
* Args = new List<string>();
* }
*
* [Obsolete]
* public CommandStub(string name, string description, string helpTag, PermissionType minPerm, Action<CommandArgs> action, CommandTrigger trigger = CommandTrigger.MessageCreate)
* {
* this.ID = IDGenerator.GenerateRandomCode();
*
* Do = action;
* CommandName = name;
* Description = description;
* HelpTag = helpTag;
* MinimumPermission = minPerm;
* Trigger = trigger;
*
* Args = new List<string>();
* }
*
* [Obsolete]
* public CommandStub(string name, string description, string helpTag, PermissionType minPerm, int argCount, Action<CommandArgs> action, CommandTrigger trigger = CommandTrigger.MessageCreate)
* {
* this.ID = IDGenerator.GenerateRandomCode();
*
* Do = action;
* CommandName = name;
* Description = description;
* HelpTag = helpTag;
* MinimumPermission = minPerm;
* ArgCount = argCount;
* Trigger = trigger;
*
* Args = new List<string>();
* }
*
* [Obsolete]
* public CommandStub(string name, string description, string helpTag, PermissionType minPerm, int argCount, Action<CommandArgs> action)
* {
* this.ID = IDGenerator.GenerateRandomCode();
*
* Do = action;
* CommandName = name;
* Description = description;
* HelpTag = helpTag;
* MinimumPermission = minPerm;
* ArgCount = argCount;
*
* Args = new List<string>();
* }
*/
public CommandStub(string name, string description, string helpTag, Action <CommandArgs> action, PermissionType minPerm = PermissionType.User,
int argCount = 0, CommandTrigger trigger = CommandTrigger.MessageCreate)
{
ID = IDGenerator.GenerateRandomCode();
Do = action;
CommandName = name;
Description = description;
HelpTag = helpTag;
MinimumPermission = minPerm;
ArgCount = argCount;
Trigger = trigger;
Args = new List <string>();
}
/// <summary> Parses the command and spawns the corresponding process.</summary>
/// <param name="cmd">Command with the command name and its arguments</param>
/// <param name="trigger">What triggered the command, for some limited access control</param>
/// <param name="onDone">Callback the process will call on termination</param>
/// <param name="spawner">The spawner (typically a <see cref="Process"/>) used to spawn the process. If null, <see cref="CommandLine.spawner"/> will be used.</param>
/// <returns>The spawned <see cref="Process"/>. Can be null if it failed or was executed immediately.</returns>
public Process StartCmd(string cmd, CommandTrigger trigger, Action <Process> onDone = null, IProcessSpawner spawner = null)
{
MyTuple <string, List <string> > parsed = this.ParseCommand(cmd);
if (parsed.Item1 != "")
{
Command command;
if (this.commands.TryGetValue(parsed.Item1, out command))
{
return(command.Spawn(parsed.Item2, this.log, onDone, spawner ?? this.spawner, trigger));
}
else
{
this.log($"Unknown command {parsed.Item1}");
}
}
return(null);
}
private void Rescan(List <Artist> artists, bool isNew, CommandTrigger trigger, bool infoUpdated)
{
var rescanAfterRefresh = _configService.RescanAfterRefresh;
var shouldRescan = true;
var filter = FilterFilesType.Matched;
var folders = _rootFolderService.All().Select(x => x.Path).ToList();
if (isNew)
{
_logger.Trace("Forcing rescan. Reason: New artist added");
shouldRescan = true;
// only rescan artist folders - otherwise it can be super slow for
// badly organized / partly matched libraries
folders = artists.Select(x => x.Path).ToList();
}
else if (rescanAfterRefresh == RescanAfterRefreshType.Never)
{
_logger.Trace("Skipping rescan. Reason: never rescan after refresh");
shouldRescan = false;
}
else if (rescanAfterRefresh == RescanAfterRefreshType.AfterManual && trigger != CommandTrigger.Manual)
{
_logger.Trace("Skipping rescan. Reason: not after automatic refreshes");
shouldRescan = false;
}
else if (!infoUpdated && trigger != CommandTrigger.Manual)
{
_logger.Trace("Skipping rescan. Reason: no metadata updated after automatic refresh");
shouldRescan = false;
}
else if (!infoUpdated)
{
_logger.Trace("No metadata updated, only scanning new files");
filter = FilterFilesType.Known;
}
if (shouldRescan)
{
// some metadata has updated so rescan unmatched
// (but don't add new artists to reduce repeated searches against api)
_commandQueueManager.Push(new RescanFoldersCommand(folders, filter, false, artists.Select(x => x.Id).ToList()));
}
}
private void RefreshSelectedArtists(List <int> artistIds, bool isNew, CommandTrigger trigger)
{
bool updated = false;
var artists = _artistService.GetArtists(artistIds);
foreach (var artist in artists)
{
try
{
updated |= RefreshEntityInfo(artist, null, true, false, null);
}
catch (Exception e)
{
_logger.Error(e, "Couldn't refresh info for {0}", artist);
}
}
Rescan(artists, isNew, trigger, updated);
}
/// <summary>Creates a new command ready to be registered in a <see cref="CommandLine"/>.</summary>
/// <param name="name">Unique name of the command, used summon the command.</param>
/// <param name="actionProvider">Function that returns the </param>
/// <param name="briefHelp"></param>
/// <param name="detailedHelp"></param>
/// <param name="maxArgs">Ignored if <paramref name="nArgs"/> is given</param>
/// <param name="minArgs">Ignored if <paramref name="nArgs"/> is given</param>
/// <param name="nArgs">Number of argguments required by the command</param>
/// <param name="requiredTrigger"></param>
public Command(string name, ActionProvider actionProvider, string briefHelp, string detailedHelp = null, int maxArgs = int.MaxValue, int minArgs = 0, int nArgs = -1, CommandTrigger requiredTrigger = CommandTrigger.User)
{
this.Name = name;
this.provider = actionProvider;
this.BriefHelp = briefHelp;
if (detailedHelp != null)
{
this.help = detailedHelp.Split(new char[] { '\n' }).ToList();
}
if (nArgs >= 0)
{
this.MaxArgs = this.MinArgs = nArgs;
}
else
{
this.MaxArgs = maxArgs;
this.MinArgs = minArgs;
}
this.RequiredTrigger = requiredTrigger;
}
private void RefreshSelectedAuthors(List <int> authorIds, bool isNew, CommandTrigger trigger)
{
var updated = false;
var authors = _authorService.GetAuthors(authorIds);
foreach (var author in authors)
{
try
{
var data = GetSkyhookData(author.ForeignAuthorId);
updated |= RefreshEntityInfo(author, null, data, true, false, null);
}
catch (Exception e)
{
_logger.Error(e, "Couldn't refresh info for {0}", author);
}
}
Rescan(authorIds, isNew, trigger, updated);
}
public bool HandleCommand(CommandTrigger trigger)
{
if (trigger == null)
{
Logger.Warn("No CommandTrigger were pass.");
return(false);
}
if (!CommandsByAlias.TryGetValue(trigger.Args[0], out CommandBase command))
{
return(false);
}
if (!trigger.DefinedParametersCommand(command))
{
Logger.Info("No Parameters to defined in this command.");
return(false);
}
command.Execute(trigger);
return(true);
}
private void RescanArtist(Artist artist, bool isNew, CommandTrigger trigger, bool infoUpdated)
{
var rescanAfterRefresh = _configService.RescanAfterRefresh;
var shouldRescan = true;
if (isNew)
{
_logger.Trace("Forcing rescan of {0}. Reason: New artist", artist);
shouldRescan = true;
}
else if (rescanAfterRefresh == RescanAfterRefreshType.Never)
{
_logger.Trace("Skipping rescan of {0}. Reason: never recan after refresh", artist);
shouldRescan = false;
}
else if (rescanAfterRefresh == RescanAfterRefreshType.AfterManual && trigger != CommandTrigger.Manual)
{
_logger.Trace("Skipping rescan of {0}. Reason: not after automatic scans", artist);
shouldRescan = false;
}
if (!shouldRescan)
{
return;
}
try
{
// If some metadata has been updated then rescan unmatched files.
// Otherwise only scan files that haven't been seen before.
var filter = infoUpdated ? FilterFilesType.Matched : FilterFilesType.Known;
_diskScanService.Scan(artist, filter);
}
catch (Exception e)
{
_logger.Error(e, "Couldn't rescan artist {0}", artist);
}
}
public CommandModel Push <TCommand>(TCommand command, CommandPriority priority = CommandPriority.Normal, CommandTrigger trigger = CommandTrigger.Unspecified)
where TCommand : Command
{
Ensure.That(command, () => command).IsNotNull();
_logger.Trace("Publishing {0}", command.Name);
_logger.Trace("Checking if command is queued or started: {0}", command.Name);
var existingCommands = QueuedOrStarted(command.Name);
var existing = existingCommands.SingleOrDefault(c => CommandEqualityComparer.Instance.Equals(c.Body, command));
if (existing != null)
{
_logger.Trace("Command is already in progress: {0}", command.Name);
return(existing);
}
var commandModel = new CommandModel
{
Name = command.Name,
Body = command,
QueuedAt = DateTime.UtcNow,
Trigger = trigger,
Priority = priority,
Status = CommandStatus.Queued
};
_logger.Trace("Inserting new command: {0}", commandModel.Name);
_repo.Insert(commandModel);
_commandQueue.Add(commandModel);
return(commandModel);
}
public CommandModel Push(string commandName, DateTime?lastExecutionTime, DateTime?lastStartTime, CommandPriority priority = CommandPriority.Normal, CommandTrigger trigger = CommandTrigger.Unspecified)
{
dynamic command = GetCommand(commandName);
command.LastExecutionTime = lastExecutionTime;
command.LastStartTime = lastStartTime;
command.Trigger = trigger;
return(Push(command, priority, trigger));
}
/// <summary>Spawns a new <see cref="Process"/>, taking into account the arguments. Can fail and return null if the arguments are incorrect.</summary>
/// <param name="args">The arguments given to the command line.</param>
/// <param name="logger">The logger the process can use to log.</param>
/// <param name="onDone">The callback to call on process termination.</param>
/// <param name="spawner">Used to spawn the process</param>
/// <param name="trigger">What triggered the command</param>
/// <returns>The spawned process, if successful.</returns>
public Process Spawn(List <string> args, Action <string> logger, Action <Process> onDone, IProcessSpawner spawner, CommandTrigger trigger)
{
if (trigger < this.RequiredTrigger)
{
logger?.Invoke($"Permission denied for '{this.Name}'");
}
else if (args.Count <= this.MaxArgs && args.Count >= this.MinArgs)
{
MyTuple <int, bool, Action <Process> > parameters = this.provider(args, logger);
return(spawner.Spawn(parameters.Item3, this.Name, onDone, parameters.Item1, parameters.Item2));
}
else
{
logger?.Invoke($"Wrong number of arguments for '{this.Name}'");
logger?.Invoke($"Run -help '{this.Name}' for more info");
}
return(null);
}
public ProjectViewModel(ILifetimeScope lifetimeScope, Dispatcher dispatcher, LocLocalizer localizer, ProjectFileWorkspace workspace)
: base(lifetimeScope, dispatcher)
{
#region Init
var loadTrigger = new CommandTrigger();
Receive <IncommingEvent>(e => e.Action());
IsEnabled = RegisterProperty <bool>(nameof(IsEnabled)).WithDefaultValue(!workspace.ProjectFile.IsEmpty);
ProjectEntrys = this.RegisterUiCollection <ProjectEntryModel>(nameof(ProjectEntrys))
.AndAsync();
SelectedIndex = RegisterProperty <int>(nameof(SelectedIndex));
var self = Context.Self;
void TryUpdateEntry((string ProjectName, string EntryName, ActiveLanguage Lang, string Content) data)
{
var(projectName, entryName, lang, content) = data;
self.Tell(new UpdateRequest(entryName, lang, content, projectName));
}
void TryRemoveEntry((string ProjectName, string EntryName) data)
{
var(projectName, entryName) = data;
self.Tell(new RemoveRequest(entryName, projectName));
}
OnPreRestart += (exception, o) => Self.Tell(new InitProjectViewModel(workspace.Get(_project)));
void InitProjectViewModel(InitProjectViewModel obj)
{
_project = obj.Project.ProjectName;
Languages !.Add(new ProjectViewLanguageModel(localizer.ProjectViewLanguageBoxFirstLabel, true));
Languages.AddRange(obj.Project.ActiveLanguages.Select(al => new ProjectViewLanguageModel(al.Name, false)));
SelectedIndex += 0;
foreach (var projectEntry in obj.Project.Entries.OrderBy(le => le.Key))
{
ProjectEntrys.Add(new ProjectEntryModel(obj.Project, projectEntry, TryUpdateEntry, TryRemoveEntry));
}
ImportetProjects !.AddRange(obj.Project.Imports);
loadTrigger.Trigger();
}
Receive <InitProjectViewModel>(InitProjectViewModel);
#endregion
#region New Entry
IEnumerable <NewEntryInfoBase> GetEntrys()
{
var list = ImportetProjects.ToList();
list.Add(_project);
var allEntrys = list.SelectMany(pro => workspace.Get(pro).Entries.Select(e => e.Key)).ToArray();
return(allEntrys.Select(e => new NewEntryInfo(e)).OfType <NewEntryInfoBase>()
.Concat(allEntrys
.Select(s => s.Split('_', StringSplitOptions.RemoveEmptyEntries).FirstOrDefault())
.Where(s => !string.IsNullOrWhiteSpace(s))
.Distinct(StringComparer.Ordinal)
.Select(s => new NewEntrySuggestInfo(s !))));
}
void AddEntry(EntryAdd entry)
{
if (_project != entry.Entry.Project)
{
return;
}
ProjectEntrys.Add(new ProjectEntryModel(workspace.Get(_project), entry.Entry, TryUpdateEntry, TryRemoveEntry));
}
NewCommad
.ThenFlow(this.ShowDialog <INewEntryDialog, NewEntryDialogResult?, IEnumerable <NewEntryInfoBase> >(GetEntrys),
b =>
{
b.Mutate(workspace.Entrys).With(em => em.EntryAdd, em => res => em.NewEntry(_project, res !.Name)).ToSelf()
.Then(b2 => b2.Action(AddEntry));
})
public abstract void Execute(CommandTrigger trigger);
