public DiscordClientConfiguration(
IApiClient apiClient, IGateway gateway, IExtendedCacheClient cache)
{
ApiClient = apiClient;
Gateway = gateway;
CacheClient = cache;
}
public BlackjackService(
IExtendedCacheClient cache,
ITransactionService transactionService)
{
this.repository = new BlackjackRepository(cache);
this.transactionService = transactionService;
}
public ScheduleWorker(
string taskName, ISchedulerService parent, IExtendedCacheClient cacheClient)
{
this.taskName = taskName;
this.cacheClient = cacheClient;
this.parent = parent;
}
public static async Task SyncAvatarAsync(IDiscordUser user, IExtendedCacheClient cache, MikiDbContext context)
{
PutObjectRequest request = new PutObjectRequest();
request.BucketName = "miki-cdn";
request.Key = $"avatars/{user.Id}.png";
request.ContentType = "image/png";
request.CannedACL = new S3CannedACL("public-read");
string avatarUrl = user.GetAvatarUrl();
using (var client = new Rest.RestClient(avatarUrl, true))
{
request.InputStream = await client.GetStreamAsync();
}
var response = await Global.CdnClient.PutObjectAsync(request);
if (response.HttpStatusCode != System.Net.HttpStatusCode.OK)
{
throw new AvatarSyncException();
}
await MikiApp.Instance.GetService <BunnyCDNClient>()
.PurgeCacheAsync($"https://mikido.b-cdn.net/avatars/{user.Id}.png");
User u = await User.GetAsync(context, user.Id, user.Username);
await cache.HashUpsertAsync("avtr:sync", user.Id.ToString(), 1);
u.AvatarUrl = u.Id.ToString();
await context.SaveChangesAsync();
}
public ScriptStorage(IExtendedCacheClient cache, long guildId, int keyLimit, int valueLimit)
{
this.cache = cache;
this.guildId = guildId;
this.keyLimit = keyLimit;
this.valueLimit = valueLimit;
values = new ConcurrentDictionary <string, IScriptValue>();
updatedKeys = new List <string>();
}
/// <summary>
/// Default caching strategy for Miki.Discord
/// </summary>
/// <param name="cache">Cache provider</param>
public DefaultCacheHandler(IExtendedCacheClient cache, IApiClient apiClient)
{
this.cache = cache;
Channels = new DiscordChannelCacheRepository(cache, apiClient);
Guilds = new DiscordGuildCacheRepository(cache, apiClient);
Members = new DiscordMemberCacheRepository(cache, apiClient);
Roles = new DiscordRoleCacheRepository(cache, apiClient);
Users = new DiscordUserCacheRepository(cache, apiClient);
}
public LotteryService(
IExtendedCacheClient cache,
ISchedulerService scheduler,
ITransactionService transactions,
LotteryEventHandler eventHandler)
{
this.transactions = transactions;
this.scheduler = scheduler.CreateWorker(
lotterySchedulerKey, eventHandler.HandleLotteryAsync);
this.entrySet = cache.CreateHashSet<LotteryEntry>(eventHandler.LotteryObjectsKey);
}
public DiscordClient(IApiClient apiClient, IGateway gateway, IExtendedCacheClient cacheClient)
{
ApiClient = apiClient;
Gateway = gateway;
cacheHandler = new DefaultCacheHandler(cacheClient, apiClient);
Events = new DiscordEventHandler(this, cacheHandler);
Events.SubscribeTo(Gateway);
eventCacheHandler = new EventCacheHandler(gateway, cacheHandler);
}
public SchedulerService(MikiApp app, IExtendedCacheClient cacheClient, ISentryClient sentryClient)
{
if (app == null)
{
throw new ArgumentNullException(nameof(app));
}
this.app = app;
this.cacheClient = cacheClient;
this.sentryClient = sentryClient;
taskCallbacks = new Dictionary <string, Func <IContext, string, Task> >();
cancellationToken = new CancellationTokenSource();
workerTask = RunWorkerAsync(cancellationToken.Token).ConfigureAwait(false);
}
public BlackjackService(IExtendedCacheClient cache)
{
_cache = cache;
}
public TestCache(IExtendedCacheClient cacheClient)
: base(cacheClient)
{
}
public CustomCommandsService(IExtendedCacheClient cache, IUnitOfWork unitOfWork, IUserService userService)
{
this.cache = cache;
this.unitOfWork = unitOfWork;
this.userService = userService;
}
public DiscordUserCacheRepository(IExtendedCacheClient cacheClient, IApiClient apiClient)
: base(cacheClient)
{
this.cacheClient = cacheClient;
this.apiClient = apiClient;
}
public BlackjackRepository(IExtendedCacheClient cache)
{
this.cache = cache;
}
protected BaseCacheRepository(IExtendedCacheClient cacheClient)
{
this.cacheClient = cacheClient;
}
public HashSet(IExtendedCacheClient cacheClient, string key)
{
_cacheClient = cacheClient;
_key = key;
}
/// <summary>
/// Creates an hash set struct for your cache client, exposing values in a more user-friendly way.
/// </summary>
/// <typeparam name="T">Type of value you want to store.</typeparam>
/// <param name="cacheClient">The cache client reference created.</param>
/// <param name="key">The key at which the hash set will be stored in the cache.</param>
public static IHashSet <T> CreateHashSet <T>(this IExtendedCacheClient cacheClient, string key)
{
return(new HashSet <T>(cacheClient, key));
}
public ScheduleWorkerGroup(
string taskName, ISchedulerService parent, IExtendedCacheClient cacheClient)
: base(taskName, parent, cacheClient)
{
}
