public async Task <VerificationProvider> UpdateVerificationProvider(VerificationProvider verificationProvider)
{
_context.Update(verificationProvider);
await _context.SaveChangesAsync();
return(verificationProvider);
}
/// <summary>
/// Initializes a new instance of the <see cref="ObjectConverterRegistration"/> class.
/// </summary>
/// <param name="targetType">The type of conversion supported by the registered converter.</param>
/// <param name="objectCreator">A function used to create an instance of the registered
/// <see cref="IObjectConverter"/> implementation.</param>
/// <exception cref="ArgumentNullException">Thrown when the given target type or object
/// creation function is null.</exception>
internal ObjectConverterRegistration(Type targetType, Func <IObjectConverter> objectCreator)
{
VerificationProvider.VerifyNotNull(objectCreator, "objectCreator");
TargetType = targetType;
mObjectCreator = objectCreator;
}
private void HandleRegistration(string[] registrationParameters)
{
if (registrationParameters.Length != 2)
{
ConsoleHelper.WriteLine(ConsoleMessageType.Error,
"Invalid number of values specified for command registration. Please specify the name and program path.");
return;
}
// Extract the registration name and program path from the registration parameters
string registrationName = registrationParameters[0];
string programPath = registrationParameters[1];
VerificationProvider.VerifyValidString(registrationName, "registrationName");
VerificationProvider.VerifyValidString(programPath, "programPath");
// Check we haven't already made a registration with this name
if (ApplicationContext.ProgramRegistrations.ContainsKey(registrationName))
{
ConsoleHelper.WriteLine(ConsoleMessageType.Warning,
"A program has already been registered under the name '{0}' and will be overridden.",
registrationName);
}
// Store the registration, overriding any existing registrations
ApplicationContext.ProgramRegistrations[registrationName] = programPath;
ConsoleHelper.WriteLine(ConsoleMessageType.Information,
"A registration has been successfully made under '{0}' for the path '{1}'.",
registrationName, programPath);
}
/// <summary>
/// Registers the given information to make the command available for later execution.
/// </summary>
/// <typeparam name="TValue">The type of value expected to be handled by the execution action.</typeparam>
/// <param name="name">The name of the command to be registered.</param>
/// <param name="executionAction">The action to be executed when the command is triggered.</param>
/// <exception cref="ArgumentException">Thrown when the given command name is not a valid string.</exception>
/// <exception cref="ArgumentNullException">Thrown when the given execution action is null.</exception>
/// <remarks>
/// <para>
/// If a command registration already exists under the given name, that registration will be overwritten
/// by the given information.
/// </para>
/// </remarks>
public void Register <TValue>(string name, Action <TValue> executionAction)
{
VerificationProvider.VerifyValidString(name, "name");
VerificationProvider.VerifyNotNull(executionAction, "executionAction");
mCommandRegistrations[name] = new ExecutableCommandRegistration <TValue>(name, executionAction, mObjectConverterFactory);
}
public TutorialServer(GlobalUserDataProvider gudp, VerificationProvider botVer, ProblemBoardService pbService, ProblemProvider problemProvider, ILocalization lang)
{
_gudp = gudp;
_botVer = botVer;
_pbService = pbService;
_problemProvider = problemProvider;
_lang = lang;
}
public async Task <VerificationProvider> AddVerificationProvider(VerificationProvider verificationProvider)
{
await _context.VerificationProvider.AddAsync(verificationProvider);
await _context.SaveChangesAsync();
return(verificationProvider);
}
/// <summary>
/// Allows the application to be configured by derived classes.
/// </summary>
/// <param name="configuration">An action used to configure the rule set being used by the application for
/// defining the context parameters for the command-line argument parsing operation.</param>
/// <exception cref="ArgumentNullException">Thrown when the given configuration action is null.</exception>
protected ConsoleApplication <TContext> Configure(Action <CommandLineRuleSet> configuration)
{
VerificationProvider.VerifyNotNull(configuration, "configuration");
configuration.Invoke(mParser.RuleSet);
return(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="RunCommandApplicationContext"/> class.
/// </summary>
/// <param name="filePath">The path to which the context information should be written to and read from.</param>
/// <exception cref="ArgumentException">Thrown when the given file path is not a valid string.</exception>
public RunCommandApplicationContext(string filePath)
{
VerificationProvider.VerifyValidString(filePath, "filePath");
mFilePath = filePath;
// Make sure the directory exists
Directory.CreateDirectory(Path.GetDirectoryName(filePath));
}
/// <summary>
/// Mimics the <see cref="Console.WriteLine(string, object[])"/> method while changing the color of the output message
/// based on the specified message type.
/// </summary>
/// <param name="messageType">The type of message that is being displayed, which dictates the color of the output message.</param>
/// <param name="format">The message to be displayed that may optionally contain markers for string formatting.</param>
/// <param name="parameters">An optional collection of parameters to be formatted into the given message format.</param>
/// <exception cref="ArgumentNullException">Thrown when the given message format is a null reference.</exception>
public static void WriteLine(ConsoleMessageType messageType, string format, params object[] parameters)
{
VerificationProvider.VerifyNotNull(format, "format");
ChangeConsoleColor(messageType);
Console.WriteLine(format, parameters);
Console.ResetColor();
}
/// <summary>
/// Copies all configuration details from the given rule set into the current rule set.
/// </summary>
/// <param name="ruleSet">The rule set to copy the configuration details from.</param>
/// <exception cref="ArgumentNullException">Thrown when the given rule set is null.</exception>
public void Copy(CommandLineRuleSet ruleSet)
{
VerificationProvider.VerifyNotNull(ruleSet, "ruleSet");
// Copy the configuration details
Prefixes = ruleSet.Prefixes;
Separators = ruleSet.Separators;
AllowMultipleValues = ruleSet.AllowMultipleValues;
AllowSwitches = ruleSet.AllowSwitches;
}
/// <summary>
/// Initializes a new instance of the <see cref="ExecutableCommandRegistration{TValue}"/> class.
/// </summary>
/// <typeparam name="TValue">The type of value expected to be handled by the execution action.</typeparam>
/// <param name="name">The name of the command to be registered.</param>
/// <param name="executionAction">The action to be invoked when the command is triggered.</param>
/// <param name="objectConverterFactory">A factory used to create requested object converters.</param>
/// <exception cref="ArgumentException">Thrown when the given name is an invalid string.</exception>
/// <exception cref="ArgumentNullException">Thrown when the given or execution action object converter factory is null.</exception>
internal ExecutableCommandRegistration(string name, Action <TValue> executionAction, ObjectConverterFactory objectConverterFactory)
{
VerificationProvider.VerifyValidString(name, "name");
VerificationProvider.VerifyNotNull(executionAction, "executionAction");
VerificationProvider.VerifyNotNull(objectConverterFactory, "objectConverterFactory");
mName = name;
mExecutionAction = executionAction;
mObjectConverterFactory = objectConverterFactory;
}
public WaitingRoomService(DiscordSocketClient client, ILocalization lang, VerificationProvider botVer)
{
_client = client;
_lang = lang;
_botVer = botVer;
AlertedUserIds = new List <ulong>();
}
public async Task <IActionResult> PostPayment([FromBody] VerificationProvider provider)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _verificationProviderRepository.AddVerificationProvider(provider);
return(CreatedAtAction("GetPayment", new { id = provider.VerificationProviderId }, provider));
}
/// <summary>
/// Converts the given object value to an instance of the supported type.
/// </summary>
/// <param name="value">The object value to be converted.</param>
/// <returns>A strongly-typed representation of the given value converted to the supported type.</returns>
/// <exception cref="ArgumentNullException">Thrown when the given value is null.</exception>
/// <exception cref="InvalidOperationException">Thrown when the given value cannot be converted to the target type.</exception>
public TTarget Convert(object value)
{
VerificationProvider.VerifyNotNull(value, "value");
// Attempt a direct cast to the target type
if (value is TTarget)
{
return((TTarget)value);
}
return(ConvertCore(value));
}
/// <summary>
/// Attempts to retrieve an executable command registered under the given name.
/// </summary>
/// <param name="name">The name of the command registration to find.</param>
/// <returns>The executable command registered under the given name if it exists; otherwise null.</returns>
/// <exception cref="ArgumentException">Thrown when the given command name is not a valid string.</exception>
public IExecutableCommandRegistration GetCommandRegistration(string name)
{
VerificationProvider.VerifyValidString(name, "name");
IExecutableCommandRegistration registration;
if (!mCommandRegistrations.TryGetValue(name, out registration))
{
return(null);
}
return(registration);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConsoleApplication" /> class.
/// </summary>
/// <param name="applicationContext">An instance of the strongly-typed application context.</param>
/// <param name="arguments">A collection of all arguments passed through to the application
/// from the command line.</param>
/// <exception cref="ArgumentNullException">Thrown when the given application context or collection of arguments is null.</exception>
protected ConsoleApplication(TContext applicationContext, string[] arguments)
{
VerificationProvider.VerifyNotNull(applicationContext, "applicationContext");
VerificationProvider.VerifyNotNull(arguments, "arguments");
mRegistrar = new ExecutableCommandRegistrar(mObjectConverterFactory);
mArguments = arguments;
// Initialize and load the application context
mApplicationContext = applicationContext;
mApplicationContext.Load();
}
/// <summary>
/// Initializes a new instance of the <see cref="CommandResultSet"/> class.
/// </summary>
/// <param name="objectConverterFactory">A factory used to create requested object converters.</param>
/// <param name="commands">A collection of commands to add to the set.</param>
/// <exception cref="ArgumentNullException">Thrown when the given object converter factory or collection of commands is null.</exception>
internal CommandResultSet(ObjectConverterFactory objectConverterFactory, IEnumerable <CommandResult> commands)
{
VerificationProvider.VerifyNotNull(objectConverterFactory, "objectConverterFactory");
VerificationProvider.VerifyNotNull(commands, "commands");
mObjectConverterFactory = objectConverterFactory;
mCommands = commands;
// Extract all commands that have a key value
foreach (var command in commands)
{
mKeyedCommands[command.Key] = command;
}
}
/// <summary>
/// Parses the given collection of arguments based on the current parser rule set.
/// </summary>
/// <param name="arguments">A collection of all arguments passed through to the application
/// from the command line.</param>
/// <returns>A collection of commands resulting from the parse operation.</returns>
/// <exception cref="ArgumentNullException">Thrown when the given collection of arguments is null.</exception>
public IEnumerable <CommandResult> Parse(string[] arguments)
{
VerificationProvider.VerifyNotNull(arguments, "arguments");
var context = new CommandParsingContext(RuleSet);
foreach (string argument in arguments)
{
var command = Parse(context, argument);
if (command != null)
{
yield return(command);
}
}
}
/// <summary>
/// Executes the registered command by invoking the contained action.
/// </summary>
/// <param name="result">The result of the command parsing process pertinent to the registered command.</param>
/// <exception cref="ArgumentNullException">Thrown when the given command result is null.</exception>
/// <exception cref="InvalidOperationException">Thrown when invocation of the contained action fails.</exception>
public void Execute(CommandResult result)
{
VerificationProvider.VerifyNotNull(result, "result");
// Get hold of the relevant converter for the command value type
var converter = mObjectConverterFactory.Create <TValue>();
TValue value = converter.Convert(result.Value);
try
{
mExecutionAction.Invoke(value);
}
catch (Exception ex)
{
// Wrap the exception within an InvalidOperationException and re-throw
throw new InvalidOperationException(
"An error occurred while executing the command. See inner exception for details.", ex);
}
}
public async Task InitializeAsync(DiscordSocketClient client)
{
_client = client;
Global.Client = client;
_commandService = new CommandService();
_lang = Unity.Resolve <ILocalization>();
_botVer = Unity.Resolve <VerificationProvider>();
_waitingRoomService = Unity.Resolve <WaitingRoomService>();
_problemBoardService = Unity.Resolve <ProblemBoardService>();
_services = new ServiceCollection()
.AddSingleton(_client)
.AddSingleton(_commandService)
.AddSingleton(_lang)
.AddSingleton(Unity.Resolve <IDataStorage>())
.AddSingleton(Unity.Resolve <GlobalUserDataProvider>())
.AddSingleton(Unity.Resolve <AppConfig>())
.AddSingleton(Unity.Resolve <RpgRepository>())
.AddSingleton(Unity.Resolve <DiggingJobProvider>())
.AddSingleton(_waitingRoomService)
.AddSingleton(_problemBoardService)
.AddSingleton(Unity.Resolve <ProblemProvider>())
.AddSingleton(_botVer)
.BuildServiceProvider();
await _commandService.AddModulesAsync(Assembly.GetEntryAssembly());
_client.MessageReceived += HandleCommandAsync;
_client.MessageReceived += _waitingRoomService.MessageReceived;
_client.UserJoined += _waitingRoomService.UserJoined;
_client.UserLeft += _waitingRoomService.UserLeft;
_client.MessageReceived += _problemBoardService.MessageReceived;
_client.ReactionAdded += DmDeletions.CheckDeletionRequest;
}
/// <summary>
/// Attempts to retrieve a value from the set of commands that is stored under the given key.
/// </summary>
/// <typeparam name="TValue">The type of the value to be retrieved.</typeparam>
/// <param name="key">The key of the command to retrieve.</param>
/// <param name="value">An output parameter that will be populated with the requested value.</param>
/// <returns>True if the given key matches a stored command; false otherwise.</returns>
/// <exception cref="ArgumentException">Thrown when the given key value is not a valid string.</exception>
public bool TryGetValue <TValue>(string key, out TValue value)
{
VerificationProvider.VerifyValidString(key, "key");
// Initialize the output parameter with a default value
value = default(TValue);
CommandResult command;
if (!mKeyedCommands.TryGetValue(key, out command))
{
// The command does not exist under the given key
return(false);
}
// We have the command, so get hold of the relevant converter for its type
var converter = mObjectConverterFactory.Create <TValue>();
value = converter.Convert(command.Value);
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="CommandParsingContext"/> class.
/// </summary>
/// <param name="ruleSet">The rule set in use by the command parsing operations.</param>
/// <exception cref="ArgumentNullException">Thrown when the given rule set is null.</exception>
internal CommandParsingContext(CommandLineRuleSet ruleSet)
{
VerificationProvider.VerifyNotNull(ruleSet, "ruleSet");
mRuleSet = ruleSet;
}
public Debug(GlobalUserDataProvider gudp, VerificationProvider botVer, DiscordSocketClient client)
{
_gudp = gudp;
_botVer = botVer;
_client = client;
}
/// <summary>
/// Initializes a new instance of the <see cref="ExecutableCommandRegistrar"/> class.
/// </summary>
/// <param name="objectConverterFactory">A factory used to create requested object converters.</param>
/// <exception cref="ArgumentNullException">Thrown when the given object converter factory is null.</exception>
internal ExecutableCommandRegistrar(ObjectConverterFactory objectConverterFactory)
{
VerificationProvider.VerifyNotNull(objectConverterFactory, "objectConverterFactory");
mObjectConverterFactory = objectConverterFactory;
}
