private static string CheckForMentions(IMessageChannel channel, string message)
{
var words = message.Split().Where(x => x.StartsWith("@"));
if (!words.Any())
{
return(message);
}
var users = AsyncEnumerableExtensions.Flatten(channel.GetUsersAsync());
users.Select(x => $"@{x.Username}").Intersect(words.ToAsyncEnumerable()).ForEach(async x =>
{
var user = await users.First(y => y.Username == x.Substring(1));
message = message.Replace(x, user.Mention);
});
if (channel is SocketTextChannel)
{
var castChannel = (SocketTextChannel)channel;
var roles = castChannel.Guild.Roles;
roles.Select(x => $"@{x.Name}").Intersect(words).ToList().ForEach(x =>
{
var role = roles.First(y => y.Name == x.Substring(1));
message = message.Replace(x, role.Mention);
});
}
return(message);
}
//delete number of messages
public static async Task RoutineDelete(SocketCommandContext context, SocketUserMessage msg)
{
//get number of messages to delete
int del_num = 0;
String[] msg_array = msg.ToString().Split(' ');
if (msg_array.Length < 3)
{
//use default number
del_num = 1;
}
else if (!(int.TryParse(msg_array[2], out del_num) && del_num >= 0 && del_num <= 1000))
{
//failed to get specified number
throw new CommandException("invalid number of messages");
}
var messages_pages = context.Channel.GetMessagesAsync(msg, Direction.Before, del_num);
var messages = await AsyncEnumerableExtensions.FlattenAsync <IMessage>(messages_pages);
var i = 0;
foreach (var message in messages)
{
await context.Channel.DeleteMessageAsync(message);
//don't send more than 1 request per second
await Task.Delay(1000);
i += 1;
}
await context.Channel.SendMessageAsync(i.ToString() + " message(s) deleted.");
}
private async IAsyncEnumerable <BlobLease> LeaseRenewInterval(BlobLeaseClient client, BlobRequestConditions condition, [EnumeratorCancellation] CancellationToken token = default)
{
await foreach (var _ in AsyncEnumerableExtensions.Interval(LeaseRenewDuration, token))
{
yield return(await client.RenewAsync(condition, token));
}
}
public async ValueTask <int> Hyperlinq_AsyncEnumerable_Value()
{
var sum = 0;
await foreach (var item in AsyncEnumerableExtensions
.AsAsyncValueEnumerable <TestAsyncEnumerable.AsyncEnumerable, TestAsyncEnumerable.AsyncEnumerable.AsyncEnumerator, int>(asyncEnumerableValue, (enumerable, cancellationToken) => enumerable.GetAsyncEnumerator(cancellationToken))
.Where((item, _) => new ValueTask <bool>((item & 0x01) == 0)))
{
sum += item;
}
return(sum);
}
public async Task StartAsync()
{
this.ThrowIfDisposed();
this._cancellationToken.ThrowIfCancellationRequested();
SignalTask oldReadTask = (SignalTask)null;
CancellationTokenSource cancellationTokenSource = (CancellationTokenSource)null;
bool lockTaken = false;
object obj;
try
{
Monitor.Enter(obj = this._segmentLock, ref lockTaken);
if (!this._isRunning)
{
if (this._abortTokenSource.IsCancellationRequested)
{
cancellationTokenSource = this._abortTokenSource;
this._abortTokenSource = CancellationTokenSource.CreateLinkedTokenSource(this._cancellationToken);
oldReadTask = this._readTask;
this._readTask = new SignalTask(new Func <Task>(this.ReadSubList), this._abortTokenSource.Token);
}
this._isRunning = true;
}
else
{
goto label_15;
}
}
finally
{
if (lockTaken)
{
Monitor.Exit(obj);
}
}
await HlsPlaylistSegmentManager.CleanupReader(oldReadTask, cancellationTokenSource).ConfigureAwait(false);
if (this._programStream.Segments != null && this._programStream.Segments.Count > 0)
{
this.UpdatePlaylist();
}
ISegment segment = await AsyncEnumerableExtensions.FirstOrDefaultAsync <ISegment>(this.Playlist).ConfigureAwait(false);
if (null == segment)
{
Debug.WriteLine("HlsPlaylistSegmentManager.StartAsync() no segments found");
throw new FileNotFoundException("Unable to find the first segment");
}
this.ContentType = await this._programStream.GetContentTypeAsync(this._cancellationToken).ConfigureAwait(false);
this.WebReader = WebReaderExtensions.CreateChild(this._programStream.WebReader, (Uri)null, ContentKind.AnyMedia, this.ContentType);
label_15 :;
}
private static IAsyncEnumerable <Result <LevelSelectors> > GetLevelSelectorsEnumerableAsync(
this IReadOnlyMemoizationSessionWithLevelSelectors session,
Context context,
Fingerprint weakFingerprint,
CancellationToken cts,
int level)
{
return(AsyncEnumerableExtensions.CreateSingleProducerTaskAsyncEnumerable <Result <LevelSelectors> >(
async() =>
{
var result = await session.GetLevelSelectorsAsync(context, weakFingerprint, cts, level);
return new[] { result };
}));
}
private static Async::System.Collections.Generic.IAsyncEnumerable <Result <LevelSelectors> > GetLevelSelectorsEnumerableAsync(
this ILevelSelectorsProvider session,
Context context,
Fingerprint weakFingerprint,
CancellationToken cts,
int level)
{
return(AsyncEnumerableExtensions.CreateSingleProducerTaskAsyncEnumerable <Result <LevelSelectors> >(
async() =>
{
var result = await session.GetLevelSelectorsAsync(context, weakFingerprint, cts, level);
return new[] { result };
}));
}
private static IAsyncQueryable <NuGetPackage> Synchronized(IAsyncQueryable <NuGetPackage> async, Func <IQueryable <NuGetPackage>, IQueryable <NuGetPackage> > getNotEvaluated)
{
var syncTask = AsyncEnumerableExtensions.ToList(async);
syncTask.Wait();
var completedList = syncTask.Result;
var withFilter = getNotEvaluated(completedList.AsQueryable());
var completedEnumer = new CompletedAsyncEnumerator <NuGetPackage>(withFilter);
return(AsyncEnumerable.FromResult(completedEnumer));
}
internal static async Task <Lookup <TKey, TElement> > CreateForJoinAsync(IAsyncEnumerable <TElement> source, Func <TElement, TKey> keySelector, IEqualityComparer <TKey> comparer, CancellationToken cancellationToken)
{
var lookup = new Lookup <TKey, TElement>(comparer);
await foreach (var item in AsyncEnumerableExtensions.WithCancellation(source, cancellationToken).ConfigureAwait(false))
{
var key = keySelector(item);
if (key != null)
{
lookup.GetGrouping(key, create: true).Add(item);
}
}
return(lookup);
}
public void Method()
{
var a0 = new OptimizedAsyncEnumerable <TestType>().FirstAsync();
var b0 = new OptimizedAsyncEnumerable <TestType>().FirstOrDefaultAsync();
var c0 = AsyncEnumerableExtensions.FirstAsync(new OptimizedAsyncEnumerable <TestType>());
var d0 = AsyncEnumerableExtensions.FirstOrDefaultAsync(new OptimizedAsyncEnumerable <TestType>());
var a1 = new TestType().SingleAsync();
var b1 = new TestType().SingleOrDefaultAsync();
var c1 = NotAsyncEnumerableExtensions.SingleAsync(new TestType());
var d1 = NotAsyncEnumerableExtensions.SingleOrDefaultAsync(new TestType());
var c2 = SingleAsync(new TestType());
var d2 = SingleOrDefaultAsync(new TestType());
}
public void AsAsyncValueEnumerable_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap
.AsAsyncEnumerable(source);
// Act
var result = AsyncEnumerableExtensions
.AsAsyncValueEnumerable(wrapped);
// Assert
_ = result.Must()
.BeAsyncEnumerableOf <int>()
.BeEqualTo(source);
}
public void AsAsyncValueEnumerable_GetEnumerator_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap
.AsAsyncEnumerable(source);
// Act
var result = AsyncEnumerableExtensions
.AsAsyncValueEnumerable <Wrap.AsyncEnumerableWrapper <int>, Wrap.AsyncEnumerator <int>, int>(wrapped, (enumerable, _) => enumerable.GetAsyncEnumerator());
// Assert
_ = result.Must()
.BeAsyncEnumerableOf <int>()
.BeEqualTo(source);
}
internal static async Task <LookupWithTask <TKey, TElement> > CreateAsync(IAsyncEnumerable <TElement> source, Func <TElement, CancellationToken, ValueTask <TKey> > keySelector, IEqualityComparer <TKey> comparer, CancellationToken cancellationToken)
{
Debug.Assert(source != null);
Debug.Assert(keySelector != null);
var lookup = new LookupWithTask <TKey, TElement>(comparer);
await foreach (var item in AsyncEnumerableExtensions.WithCancellation(source, cancellationToken).ConfigureAwait(false))
{
var key = await keySelector(item, cancellationToken).ConfigureAwait(false);
lookup.GetGrouping(key, create: true).Add(item);
}
return(lookup);
}
/// <summary>
/// Enumerate known selectors for a given weak fingerprint.
/// </summary>
internal IAsyncEnumerable <GetSelectorResult> GetSelectors(Context context, Fingerprint weakFingerprint, CancellationToken cts)
{
return(AsyncEnumerableExtensions.CreateSingleProducerTaskAsyncEnumerable(() => getSelectorsCore()));
async Task <IEnumerable <GetSelectorResult> > getSelectorsCore()
{
var selectors = await GetSelectorsCoreAsync(context, weakFingerprint);
if (!selectors)
{
return(new GetSelectorResult[] { new GetSelectorResult(selectors) });
}
return(selectors.Value.Select(s => new GetSelectorResult(s)));
}
}
async Task ValidateAllReactionsAndRolesForGuild(TownGuild guildSettings)
{
try
{
SocketGuild guild = client.GetGuild(guildSettings.GuildId);
foreach (var messageSettings in guildSettings.RoleGrantingSettings.MessageSettings)
{
var channel = guild.GetChannel(messageSettings.Channel);
var message = await(channel as ISocketMessageChannel).GetMessageAsync(messageSettings.MessageToMonitor) as IUserMessage;
foreach (var reaction in message.Reactions)
{
if (messageSettings.ReactionsToRoles.TryGetValue(reaction.Key.Name, out GrantingRoleSettings grantingSettings))
{
var reactedUsers = message.GetReactionUsersAsync(reaction.Key, 1000);
var flattenedUsers = await AsyncEnumerableExtensions.FlattenAsync(reactedUsers);
foreach (var reactedUser in flattenedUsers)
{
if (client.CurrentUser.Id == reactedUser.Id)
{
continue;
}
await GrantUserRoleBasedOnReaction(reaction.Key, message, guild, guildSettings, guild.GetUser(reactedUser.Id));
}
}
}
await message.RemoveAllReactionsAsync();
Emoji[] emojis = messageSettings.ReactionsToRoles.Select(item => new Emoji(item.Key)).ToArray();
await message.AddReactionsAsync(emojis);
}
}
catch (Exception e)
{
Console.WriteLine(e);
Console.WriteLine("Failed validating all emotes on startup");
}
}
public async ValueTask AsAsyncValueEnumerable_With_ToArrayAsync_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap
.AsAsyncEnumerable(source);
var expected = Enumerable
.ToArray(source);
// Act
var result = await AsyncEnumerableExtensions
.AsAsyncValueEnumerable <int>(wrapped)
.ToArrayAsync();
// Assert
_ = result.Must()
.BeArrayOf <int>()
.BeEqualTo(expected);
}
public async ValueTask ToListAsync_With_ValidData_Must_Succeed(int[] source)
{
// Arrange
var wrapped = Wrap
.AsAsyncEnumerable(source);
var expected = Enumerable
.ToList(source);
// Act
var result = await AsyncEnumerableExtensions
.AsAsyncValueEnumerable(wrapped)
.ToListAsync();
// Assert
_ = result.Must()
.BeOfType <List <int> >()
.BeEnumerableOf <int>()
.BeEqualTo(expected);
}
private static string CheckForMentions(IMessageChannel channel, string message)
{
var words = message.Split().Where(x => x.StartsWith("@"));
if (!words.Any())
{
return(message);
}
var users = AsyncEnumerableExtensions.Flatten(channel.GetUsersAsync());
users.Select(x => $"@{x.Username}").Intersect(words.ToAsyncEnumerable()).ForEach(async x =>
{
var user = await users.First(y => y.Username == x.Substring(1));
message = message.Replace(x, user.Mention);
});
return(message);
}
private async Task IncludeAsync(
object entity,
IReadOnlyList <INavigation> navigationPath,
IReadOnlyList <AsyncRelatedEntitiesLoader> relatedEntitiesLoaders,
CancellationToken cancellationToken,
int currentNavigationIndex,
bool queryStateManager)
{
if (entity == null ||
currentNavigationIndex == navigationPath.Count)
{
return;
}
var navigation = navigationPath[currentNavigationIndex];
var keyComparer = IncludeCore(entity, navigation);
var key = navigation.GetTargetType().FindPrimaryKey();
LoadNavigationProperties(
entity,
navigationPath,
currentNavigationIndex,
await AsyncEnumerableExtensions.Select(relatedEntitiesLoaders[currentNavigationIndex](keyComparer), async(eli, ct) =>
{
var targetEntity = GetEntity(key, eli, queryStateManager, throwOnNullKey: false);
await IncludeAsync(
targetEntity,
navigationPath,
relatedEntitiesLoaders,
ct,
currentNavigationIndex + 1,
queryStateManager);
return(targetEntity);
})
.Where(e => e != null)
.ToList(cancellationToken));
}
public async static Task <string[]> BasicallyRun(
this Pipeline.Function fun,
string token,
int i = 0,
string[]?tokens = null !)
{
var result = new List <string>();
var cancellationToken = new CancellationToken();
await foreach (Token t in fun(
new Token(token),
i,
tokens is null ?
AsyncEnumerableExtensions.Empty <Token>() :
tokens
.Select(s => new Token(s))
.ToAsyncEnumerable(cancellationToken),
cancellationToken))
{
result.Add(t.String);
}
return(result.ToArray());
}
public IAsyncEnumerable <SearchResult> SearchAsync(string query, CancellationToken cancellationToken = default)
{
return(AsyncEnumerableExtensions.Empty <SearchResult>());
}
public ValueTask <TestType> Test_SingleAsync_Method() => AsyncEnumerableExtensions.FirstAsync(new OptimizedAsyncEnumerable <TestType>());
public async Task PurgeAsync(int count, bool self = true, bool silent = false)
{
var channel = Context.Channel as ITextChannel;
var request = await AsyncEnumerableExtensions.FlattenAsync(
channel.GetMessagesAsync(Context.Message.Id, Direction.Before, count)
);
if (!request.Any())
{
await Context.Message.AddReactionAsync(new Emoji("❌"));
return;
}
var messageCount = 0;
var filtered = request
.Where(m =>
{
if (!self)
{
return(false);
}
try
{
return(m is IUserMessage && (DateTimeOffset.UtcNow - m.CreatedAt).TotalDays < 14);
}
finally
{
messageCount++;
}
});
var messages = filtered as IMessage[] ?? filtered.ToArray();
if (self)
{
await Context.Message.DeleteAsync();
}
await channel.DeleteMessagesAsync(messages).ConfigureAwait(false);
if (silent)
{
return;
}
var sb = new StringBuilder();
sb.AppendLine($"Deleted `{messageCount}` messages.");
sb.AppendLine();
foreach (var author in messages.GroupBy(b => b.Author.Id))
{
var u = Context.Guild.GetUser(author.Key);
sb.AppendLine($"**{u?.ToString() ?? author.Key.ToString()}**: {author.Count()} messages");
}
var ok = await EmbedResponseAsync(ResponseFormat.Success, description : sb.ToString());
await Task.Delay(3000);
await ok.DeleteAsync();
}
/// <inheritdoc />
public Async::System.Collections.Generic.IAsyncEnumerable <StructResult <StrongFingerprint> > EnumerateStrongFingerprints(Context context)
{
var ctx = new OperationContext(context);
return(AsyncEnumerableExtensions.CreateSingleProducerTaskAsyncEnumerable <StructResult <StrongFingerprint> >(() => _database.EnumerateStrongFingerprintsAsync(ctx)));
}
public ValueTask <int[]> Hyperlinq_AsyncEnumerable_Value() =>
AsyncEnumerableExtensions.AsAsyncValueEnumerable <TestAsyncEnumerable.AsyncEnumerable, TestAsyncEnumerable.AsyncEnumerable.AsyncEnumerator, int>(
asyncEnumerableValue,
(enumerable, cancellationToken) => enumerable.GetAsyncEnumerator(cancellationToken))
.ToArrayAsync();
private async Task IncludeAsync(
object entity,
IReadOnlyList <INavigation> navigationPath,
IReadOnlyList <AsyncRelatedEntitiesLoader> relatedEntitiesLoaders,
CancellationToken cancellationToken,
int currentNavigationIndex,
bool queryStateManager)
{
if (entity == null ||
currentNavigationIndex == navigationPath.Count)
{
return;
}
EntityKey primaryKey;
Func <ValueBuffer, EntityKey> relatedKeyFactory;
var targetEntityType
= IncludeCore(
entity,
navigationPath[currentNavigationIndex],
out primaryKey,
out relatedKeyFactory);
var keyProperties
= targetEntityType.GetPrimaryKey().Properties;
var entityKeyFactory
= _entityKeyFactorySource
.GetKeyFactory(targetEntityType.GetPrimaryKey());
LoadNavigationProperties(
entity,
navigationPath,
currentNavigationIndex,
await AsyncEnumerableExtensions.Select(relatedEntitiesLoaders[currentNavigationIndex](primaryKey, relatedKeyFactory), async(eli, ct) =>
{
var entityKey
= entityKeyFactory
.Create(keyProperties, eli.ValueBuffer);
object targetEntity = null;
if (entityKey != EntityKey.InvalidEntityKey)
{
targetEntity
= GetEntity(
targetEntityType,
entityKey,
eli,
queryStateManager);
}
await IncludeAsync(
targetEntity,
navigationPath,
relatedEntitiesLoaders,
ct,
currentNavigationIndex + 1,
queryStateManager);
return(targetEntity);
})
.Where(e => e != null)
.ToList(cancellationToken));
}
public IAsyncEnumerable <StructResult <StrongFingerprint> > EnumerateStrongFingerprints(Context context)
{
var ctx = new OperationContext(context);
return(AsyncEnumerableExtensions.CreateSingleProducerTaskAsyncEnumerable(() => EnumerateStrongFingerprintsAsync(ctx)));
}
public static Task <List <T> > EvalAsync <T>(this IQueryable <T> source) => AsyncEnumerableExtensions.ToListAsync(source);
