public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
Response response = new Response
{
Embed = EmbedUtility.ToEmbed(Help),
Message = Help,
ResponseType = ResponseType.Default
};
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string commandDetail = command.CommandDetail;
response = waitHandler.CreatePleaseWaitResponse(senderDetail.ServerSettings.Language);
Task.Run(async() =>
{
Response asyncResponse = await BuildMemeAsync(senderDetail.ServerSettings.Language, args);
if (asyncResponse == null)
{
string err = ($"{Emojis.NoEntry} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_NoImageMessages")}");
asyncResponse = new Response
{
Embed = EmbedUtility.ToEmbed(err),
Message = err,
ResponseType = ResponseType.Default
};
}
await asyncResponder.SendResponseAsync(args, asyncResponse);
waitHandler.PopPleaseWaitMessage();
});
return(new[] { response });
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
return(Response.CreateArrayFromString(AddZalgo(command.CommandDetail)));
}
//ctor
public InsertDispatchHistoryCommand(SenderSettings senderSettings, ISignalDispatchHistoryQueries <TKey> historyQueries,
IEventSettingsQueries <TKey> eventSettingsQueries)
: base(senderSettings)
{
_eventSettingsQueries = eventSettingsQueries;
_flushQueues[FlushAction.Insert] = new FlushQueue <SignalDispatch <TKey> >(items => historyQueries.InsertMany(items));
}
//init
public DirectSignalProvider(IEventQueue <TKey> eventQueues, IDispatchQueue <TKey> dispatchQueues,
IMonitor <TKey> eventSink, ISignalEventQueries <TKey> eventQueries,
ISignalDispatchQueries <TKey> dispatchQueries, SenderSettings senderSettings)
: base(eventQueues, dispatchQueues, eventSink, eventQueries, dispatchQueries, senderSettings)
{
_isStarted = false;
}
public static void AddIntegrations(this IServiceCollection services, IConfiguration configuration)
{
var senderSection = configuration.GetSection("Integration").GetSection("Sender");
var brokerSection = configuration.GetSection("Integration").GetSection("Broker");
bool.TryParse(senderSection["Durable"], out var durable);
var queueSettings = new SenderSettings
{
Queue = senderSection["Queue"],
Durable = durable,
ExchangeType = senderSection["ExchangeType"],
Exchange = senderSection["Exchange"]
};
var brokerSettings = new BrokerSettings
{
Host = brokerSection["Host"],
Port = int.Parse(brokerSection["Port"]),
User = brokerSection["User"],
Password = brokerSection["Password"]
};
services.AddScoped((provider) =>
{
return(new QueueSender(queueSettings, brokerSettings));
});
services.AddScoped <AdministrationNotifier>();
services.AddScoped <GivingPromoCodeToCustomerNotifier>();
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
if (Constants.IsBotOwner(args.UserId))
{
Task.Run(async() =>
{
string name = command.CommandDetail;
if (args.ChannelId != Constants.ConsoleId)
{
var guild = await client.GetGuildAsync(args.GuildId).ConfigureAwait(false);
var user = guild.GetUser(client.CurrentUser.Id);
await user.ModifyAsync(x => x.Nickname = name).ConfigureAwait(false);
}
else
{
Console.Title = name;
}
});
return(new Response[] { Response.CreateFromReact(Emojis.ThumbsUpUnicode) });
}
else
{
return(Response.CreateArrayFromString($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(serverSettings.Language, "Error_BotOwnerOnly")}."));
}
}
public override int GetHashCode()
{
int hash = 1;
if (Tag.Length != 0)
{
hash ^= Tag.GetHashCode();
}
if (senderSettings_ != null)
{
hash ^= SenderSettings.GetHashCode();
}
if (proxySettings_ != null)
{
hash ^= ProxySettings.GetHashCode();
}
if (Expire != 0L)
{
hash ^= Expire.GetHashCode();
}
if (Comment.Length != 0)
{
hash ^= Comment.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
//ctor
public CheckLockExpirationCommand(ILockTracker <TKey> lockTracker, ISignalDispatchQueries <TKey> dispatchQueries,
SenderSettings settings)
{
_lockTracker = lockTracker;
_dispatchQueries = dispatchQueries;
_settings = settings;
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
// First, substitute the variables.
string message = VariableStrings.Replace(command.CommandDetail, args.Username, args.UserId.ToString(), args.GuildName, command.CommandDetail);
if (string.IsNullOrWhiteSpace(message))
{
// Use the command's name instead.
message = command.FullCommandExcludingCommandPrefix;
}
// Shrug.
message = message.StripAccents();
// Now substitute the replacements from the table.
StringBuilder sb = new StringBuilder();
foreach (char c in message)
{
string letter = c.ToString();
foreach (var replacementPair in replaceTable)
{
letter = letter.Replace(replacementPair.Key, replacementPair.Value, (ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal));
// If a replacement was made.
if (letter != c.ToString())
{
break;
}
}
sb.Append(letter);
}
string output = reverse ? new string(sb.ToString().Reverse().ToArray()) : sb.ToString();
List <Response> responses = new List <Response>
{
new Response
{
Embed = null,
Message = output,
ResponseType = ResponseType.Default
}
};
if (doTTS)
{
responses.Add(
new Response
{
Embed = null,
Message = output,
ResponseType = ResponseType.Default_TTS
}
);
}
return(responses.ToArray());
}
//init
public SubscribersFetcher(ILogger logger, SenderSettings senderSettings
, ISubscriberQueries <TKey> subscriberQueries)
{
_logger = logger;
_subscriberQueries = subscriberQueries;
ItemsQueryLimit = senderSettings.SubscribersFetcherItemsQueryLimit;
}
internal IList <Response> ExecuteCommand(SenderSettings senderDetail, IMessageDetail messageDetail)
{
List <Response> responses = new List <Response>();
CommandMessageHelper helper = new CommandMessageHelper(senderDetail.ServerSettings.CommandSymbol, messageDetail.Message);
Languages currentLanguage = senderDetail.ServerSettings.Language;
// If we're running default, assume English.
if (currentLanguage == Languages.Default)
{
currentLanguage = Languages.English;
}
if (helper.IsCommand || messageDetail.IsPrivate)
{
// Check language specific commands.
foreach (Command command in commands[currentLanguage])
{
if (command.Aliases.Contains(helper.CommandLower, StringComparer.OrdinalIgnoreCase) || command.NoSetAlias)
{
responses.AddRange(command.Execute(senderDetail, messageDetail));
}
}
// Then check defaults.
foreach (Command command in commands[Languages.Default])
{
if (command.Aliases.Contains(helper.CommandLower, StringComparer.OrdinalIgnoreCase) || command.NoSetAlias)
{
responses.AddRange(command.Execute(senderDetail, messageDetail));
}
}
}
else
{
// Check only commands that do not require a command symbol.
// Check language specific commands.
foreach (Command command in commands[currentLanguage].Where(c => !c.RequiresSymbol))
{
if (command.Aliases.Contains(helper.CommandLower, StringComparer.OrdinalIgnoreCase) || command.NoSetAlias)
{
responses.AddRange(command.Execute(senderDetail, messageDetail));
}
}
// Then check defaults.
foreach (Command command in commands[Languages.Default].Where(c => !c.RequiresSymbol))
{
if (command.Aliases.Contains(helper.CommandLower, StringComparer.OrdinalIgnoreCase) || command.NoSetAlias)
{
responses.AddRange(command.Execute(senderDetail, messageDetail));
}
}
}
return(responses);
}
//ctor
public CheckConsolidationLockExpirationCommand(IConsolidationLockTracker <TKey> lockTracker,
IConsolidationLockQueries <TKey> consolidationLockQueries, SenderSettings settings,
IDispatchQueue <TKey> dispatchQueue)
{
_consolidationLockTracker = lockTracker;
_consolidationLockQueries = consolidationLockQueries;
_settings = settings;
_dispatchQueue = dispatchQueue;
}
//init
public FlushJobBase(SenderSettings senderSettings)
{
FlushPeriod = senderSettings.FlushJobFlushPeriod;
QueueLimit = senderSettings.FlushJobQueueLimit;
IsBatchingEnabled = senderSettings.FlushJobBatchingEnabled;
//how to flush items
_flushQueues = new Dictionary <FlushAction, FlushQueue <T> >();
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string requestStr = command.CommandDetail;
ulong requestedId;
if (string.IsNullOrWhiteSpace(requestStr))
{
// Default to the user asking.
requestedId = args.UserId;
}
else
{
// Parse a mention?
if (requestStr.StartsWith("<@") && requestStr.EndsWith(">"))
{
requestStr = requestStr.Substring("<@".Length, requestStr.Length - 3); // Minus 3 for <@nnnnn>
}
// Id?
if (!ulong.TryParse(requestStr, out requestedId))
{
// No, fail.
return(Response.CreateArrayFromString($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_NoResults")}: {requestStr}"));
}
}
if (client != null)
{
Task.Run(async() =>
{
// From the id, determine if it's a user or server.
// Is it a server?
var candidateServer = await client.GetGuildAsync(requestedId).ConfigureAwait(false);
if (candidateServer != null)
{
await asyncResponder.SendResponseAsync(args, Response.CreateFromString($"{candidateServer.IconUrl}")).ConfigureAwait(false);
}
// Is it a channel?
IChannel candidateChannel = await client.GetDMChannelAsync(requestedId).ConfigureAwait(false);
if (candidateChannel != null)
{
await asyncResponder.SendResponseAsync(args, Response.CreateFromString($"{candidateChannel.GetGuild().IconUrl}")).ConfigureAwait(false);
}
// Is it a user?
IUser candidateUser = client.GetUser(requestedId);
if (candidateUser != null)
{
await asyncResponder.SendResponseAsync(args, Response.CreateFromString($"{candidateUser.GetAvatarUrl(ImageFormat.Auto, 2048)}")).ConfigureAwait(false);
}
});
}
return(new Response[] { Response.WaitForAsync });
}
//init
public BaseSignalProvider(IEventQueue <TKey> eventQueue, IDispatchQueue <TKey> dispatchQueue, IMonitor <TKey> eventSink,
ISignalEventQueries <TKey> eventQueries, ISignalDispatchQueries <TKey> dispatchQueries, SenderSettings senderSettings)
{
_eventQueue = eventQueue;
_dispatchQueue = dispatchQueue;
_monitor = eventSink;
_eventQueries = eventQueries;
_dispatchQueries = dispatchQueries;
_senderSettings = senderSettings;
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
StringBuilder sb = new StringBuilder();
string charArray = command.CommandDetail.StripAccents();
int length = charArray.Length;
if (length > 80)
{
string err = ($"{Emojis.NoEntry} {languageHandler.GetPhrase(serverSettings.Language, "Error_NotAFile")}");
sb.AppendLine(err);
}
else
{
sb.AppendLine();
foreach (char c in charArray)
{
if (char.IsLetterOrDigit(c))
{
sb.Append(":regional_indicator_").Append(char.ToLowerInvariant(c)).Append(": ");
}
else if (c == ' ')
{
sb.Append(":blue_heart: ");
}
else if (c == '!')
{
sb.Append(":grey_exclamation: ");
}
else if (c == '?')
{
sb.Append(":grey_question: ");
}
else if (c == '\'')
{
sb.Append(":arrow_down_small: ");
}
else
{
sb.Append(c);
}
}
sb.AppendLine();
foreach (char _ in charArray)
{
sb.Append(Emojis.CheerleaderSymbols[rand.Next(0, Emojis.CheerleaderSymbols.Count)]).Append(' ');
}
}
return(Response.CreateArrayFromString(sb.ToString()));
}
//init
public SignalServiceInstanceProvider(IEventQueue <TKey> eventQueues, IDispatchQueue <TKey> dispatchQueues,
IMonitor <TKey> eventSink, ISignalEventQueries <TKey> eventQueries,
ISignalDispatchQueries <TKey> dispatchQueries, SenderSettings senderSettings)
{
_eventQueues = eventQueues;
_dispatchQueues = dispatchQueues;
_monitor = eventSink;
_eventQueries = eventQueries;
_dispatchQueries = dispatchQueries;
_senderSettings = senderSettings;
}
/// <summary>
/// c'tor taking settings to configure the endpoint with
/// </summary>
public TransportFactoryImpl(ReceiverSettings receiverSettings, SenderSettings senderSettings)
{
_addresses = new ReaderWriterLockedDictionary<Uri, IAzureServiceBusEndpointAddress>();
_connCache = new ReaderWriterLockedDictionary<Uri, ConnectionHandler<AzureServiceBusConnection>>();
_formatter = new AzureServiceBusMessageNameFormatter();
_receiverSettings = receiverSettings;
_senderSettings = senderSettings;
_logger.Debug("created new transport factory");
}
/// <summary>
/// c'tor taking settings to configure the endpoint with
/// </summary>
public TransportFactoryImpl(ReceiverSettings receiverSettings, SenderSettings senderSettings)
{
_addresses = new ReaderWriterLockedDictionary <Uri, AzureServiceBusEndpointAddress>();
_connCache = new ReaderWriterLockedDictionary <Uri, ConnectionHandler <ConnectionImpl> >();
_formatter = new AzureMessageNameFormatter();
_receiverSettings = receiverSettings;
_senderSettings = senderSettings;
_logger.Debug("created new transport factory");
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
if (Constants.IsBotOwner(senderDetail.UserSettings.UserId))
{
controller.Initialise();
return(new Response[] { Response.CreateFromReact(Emojis.SoonUnicode) });
}
else
{
return(Response.CreateArrayFromString($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_BotOwnerOnly")}."));
}
}
//init
public DatabaseEventProvider(IEventQueue <TKey> eventQueue, IMonitor <TKey> eventSink
, SenderSettings senderSettings, ISignalEventQueries <TKey> eventQueries, ILogger logger)
{
_eventQueue = eventQueue;
_monitor = eventSink;
_eventQueries = eventQueries;
_logger = logger;
QueryPeriod = senderSettings.DatabaseSignalProviderQueryPeriod;
ItemsQueryCount = senderSettings.DatabaseSignalProviderItemsQueryCount;
MaxFailedAttempts = senderSettings.DatabaseSignalProviderItemsMaxFailedAttempts;
}
//init
public SignalEventFlushJob(SenderSettings senderSettings, ITemporaryStorage <SignalEvent <TKey> > temporaryStorage
, ISignalEventQueries <TKey> queries)
: base(senderSettings, temporaryStorage, queries)
{
FlushPeriod = senderSettings.FlushJobFlushPeriod;
QueueLimit = senderSettings.FlushJobQueueLimit;
IsTemporaryStorageEnabled = senderSettings.SignalQueueIsTemporaryStorageEnabled;
_temporaryStorageParameters = new TemporaryStorageParameters()
{
QueueType = NotificationsConstants.TS_EVENT_QUEUE_KEY,
EntityVersion = NotificationsConstants.TS_ENTITIES_VERSION
};
}
//init
public DispatchProcessor(SenderState <TKey> hubState, IDispatchQueue <TKey> dispatchQueue,
ILogger logger, SenderSettings senderSettings, IDispatchChannelRegistry <TKey> channelRegistry,
IEnumerable <IDispatchProcessingCommand <TKey> > processingCommands)
: base(logger)
{
_hubState = hubState;
_dispatchQueue = dispatchQueue;
_channelRegistry = channelRegistry;
_processingCommands = processingCommands
.OrderBy(x => x.Order)
.ToArray();
MaxParallelItems = senderSettings.MaxParallelDispatchesProcessed;
}
//init
public EventProcessor(SenderState <TKey> hubState, IMonitor <TKey> eventSink
, ILogger logger, SenderSettings senderSettings
, IEventQueue <TKey> eventQueue, IDispatchQueue <TKey> dispatchQueue
, IEventHandlerRegistry <TKey> handlerRegistry, IEventSettingsQueries <TKey> eventSettingsQueries)
: base(logger)
{
_hubState = hubState;
_monitor = eventSink;
_eventQueue = eventQueue;
_dispatchQueue = dispatchQueue;
_handlerRegistry = handlerRegistry;
_eventSettingsQueries = eventSettingsQueries;
MaxParallelItems = senderSettings.MaxParallelEventsProcessed;
}
/// <summary>
/// c'tor
/// </summary>
public OutboundTransportImpl(
[NotNull] AzureServiceBusEndpointAddress address,
[NotNull] ConnectionHandler<ConnectionImpl> connectionHandler,
[NotNull] SenderSettings settings)
{
if (address == null) throw new ArgumentNullException("address");
if (connectionHandler == null) throw new ArgumentNullException("connectionHandler");
if (settings == null) throw new ArgumentNullException("settings");
_connectionHandler = connectionHandler;
_settings = settings;
_address = address;
_logger.DebugFormat("created outbound transport for address '{0}'", address);
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string responseMessage;
if (Constants.IsBotOwner(args.UserId))
{
string channelIdStr = command.CommandParams[1];
if (!string.IsNullOrWhiteSpace(channelIdStr))
{
bool parsed = ulong.TryParse(channelIdStr, out ulong targetChannelId);
if (parsed)
{
string messageToSend = string.Join(" ", command.CommandParams, 2, command.CommandParams.Length - 2);
if (string.IsNullOrEmpty(messageToSend))
{
responseMessage = ($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_IncorrectParameter")}: say <channel id> <message> -- message");
}
else
{
if (asyncResponder.SendResponse(targetChannelId, Response.CreateFromString(messageToSend)))
{
responseMessage = ($"{Emojis.TickSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "YourRequestHasBeenSent")}: {messageToSend} --> {channelIdStr}");
}
else
{
responseMessage = ($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_NoResults")}: {channelIdStr}");
}
}
}
else
{
responseMessage = ($"{Emojis.CrossSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_IncorrectParameter")}: say <channel id> <message> -- {channelIdStr}");
}
}
else
{
responseMessage = $"{Emojis.CrossSymbol} say <channel id> <message>.";
}
}
else
{
responseMessage = $"{Emojis.CrossSymbol} {languageHandler.GetPhrase(serverSettings.Language, "Error_BotOwnerOnly")}.";
}
return(Response.CreateArrayFromString(responseMessage));
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
StringBuilder retVal = new StringBuilder();
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string[] commandParams = command.CommandParams;
Command[] commands = commandController.GetCommandsForLanguage(senderDetail.ServerSettings.Language);
Discord.Color responseColor = Discord.Color.Green;
if (string.IsNullOrWhiteSpace(command.CommandDetail))
{
var commandsByModule = commands.GroupBy(x => x.Module).ToDictionary(grouping => grouping.Key, grouping => grouping.ToList());
foreach (var pair in commandsByModule)
{
retVal.Append("**");
retVal.Append(pair.Key.ToString());
retVal.AppendLine("**");
retVal.AppendLine(string.Join(", ", pair.Value.Select(c => c.Aliases[0])));
retVal.AppendLine();
}
}
else
{
string search = command.CommandArgs.First().ToLowerInvariant();
Command found = commands.FirstOrDefault(c => c.Aliases.Contains(search, StringComparer.OrdinalIgnoreCase));
if (found != null)
{
retVal.AppendLine(found.Help + "\r\n" + found.Examples);
}
else
{
retVal.AppendLine($"{Emojis.QuestionSymbol} {languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Error_IncorrectParameter")}");
responseColor = Discord.Color.Red;
}
}
string message = retVal.ToString();
Response response = new Response
{
Embed = Utility.EmbedUtility.ToEmbed(message, responseColor),
Message = message,
ResponseType = ResponseType.Default
};
return(new[] { response });
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string choice = choices[rand.Next(choices.Length)];
string result = VariableStrings.Replace(choice, args.Username, args.UserId.ToString(), args.GuildName, command.CommandDetail);
Response response = new Response
{
Embed = null,
Message = result,
ResponseType = responseType
};
return(new[] { response });
}
//init
public EventQueue(SenderSettings senderSettings, ITemporaryStorage <SignalEvent <TKey> > temporaryStorage
, ISignalFlushJob <SignalEvent <TKey> > signalFlushJob, ILogger logger)
: base(temporaryStorage)
{
_signalFlushJob = signalFlushJob;
_logger = logger;
PersistBeginOnItemsCount = senderSettings.SignalQueuePersistBeginOnItemsCount;
PersistEndOnItemsCount = senderSettings.SignalQueuePersistEndOnItemsCount;
IsTemporaryStorageEnabled = senderSettings.SignalQueueIsTemporaryStorageEnabled;
_temporaryStorageParameters = new TemporaryStorageParameters()
{
QueueType = NotificationsConstants.TS_EVENT_QUEUE_KEY,
EntityVersion = NotificationsConstants.TS_ENTITIES_VERSION
};
}
//init
public DatabaseDispatchProvider(IDispatchQueue <TKey> dispatchQueue, IMonitor <TKey> eventSink, SenderSettings senderSettings,
IDispatchChannelRegistry <TKey> dispatcherRegistry, ISignalDispatchQueries <TKey> dispatchQueries, ILogger logger,
ILockTracker <TKey> lockTracker, IConsolidationLockTracker <TKey> consolidationLockTracker)
{
_dispatchQueue = dispatchQueue;
_monitor = eventSink;
_dispatcherRegistry = dispatcherRegistry;
_dispatchQueries = dispatchQueries;
_logger = logger;
_lockTracker = lockTracker;
_consolidationLockTracker = consolidationLockTracker;
_senderSettings = senderSettings;
QueryPeriod = senderSettings.DatabaseSignalProviderQueryPeriod;
ItemsQueryCount = senderSettings.DatabaseSignalProviderItemsQueryCount;
MaxFailedAttempts = senderSettings.DatabaseSignalProviderItemsMaxFailedAttempts;
}
public override IList <Response> Execute(SenderSettings senderDetail, IMessageDetail args)
{
ServerSettings serverSettings = senderDetail.ServerSettings;
UserSettings userSettings = senderDetail.UserSettings;
CommandMessageHelper command = new CommandMessageHelper(serverSettings.CommandSymbol, args.Message);
string[] commandParams = command.CommandParams;
var allAchievements = SaveData.Achievements.Achievement.AllAchievements;
var unlockedAchievements = userSettings.UserStats.GetAchievements();
// First, reply to the room that the command was written in.
// This has minimal information so as to not spoil achievements
// for other users.
string outputToChannel = ($"{languageHandler.GetPhrase(senderDetail.ServerSettings.Language, "Achievements_AchievementsUnlocked")}: {unlockedAchievements.Count}/{allAchievements.Count} {Emojis.Trophy}");
Response channelResponse = new Response
{
Embed = Utility.EmbedUtility.ToEmbed(outputToChannel, 200, 200, 50),
ResponseType = ResponseType.Default
};
// Next, PM the user their achievements and any still to unlock.
StringBuilder sb = new StringBuilder();
foreach (var achievement in allAchievements)
{
if (achievement.HasAchieved(userSettings.UserStats))
{
sb.AppendLine($"{Emojis.Trophy} {achievement.GetDescription(languageHandler, senderDetail.ServerSettings.Language)}");
}
else
{
sb.AppendLine($"???");
}
}
string outputToPrivate = sb.ToString();
Response privateResponse = new Response
{
Embed = Utility.EmbedUtility.ToEmbed(outputToPrivate, 200, 200, 50),
ResponseType = ResponseType.Private
};
return(new[] { channelResponse, privateResponse });
}
//init
public SignalFlushJobBase(SenderSettings senderSettings, ITemporaryStorage <TSignal> temporaryStorage, ISignalQueries <TSignal> queries)
: base(senderSettings)
{
_temporaryStorage = temporaryStorage;
_queries = queries;
//how to flush items
new List <FlushAction>
{
FlushAction.Insert,
FlushAction.Update,
FlushAction.DeleteOne
}
.ForEach(action => _flushQueues[action] = new FlushQueue <SignalWrapper <TSignal> >(items => MakeQuery(items, action)));
//what to do after flushing
_flushedItemsHandlers.Add(RemovedFlushedFromTempStorage);
}
