コード例 #1
3
 protected override Task ExecuteAsync(IMongoCollection<BsonDocument> collection)
 {
     var cursor = collection.FindAsync(_filter, _options).GetAwaiter().GetResult();
     return cursor.ToListAsync();
 }
コード例 #2
0
        public async Task<IEnumerable<Climb>> ExecuteAsync(GetClimbsQueryParameters parameters,
            IMongoCollection<Climb> collection)
        {
            var filters = new List<FilterDefinition<Climb>>();

            if (parameters.Id != Guid.Empty)
            {
                var filter = Builders<Climb>.Filter.Eq(c => c.Id == parameters.Id, true);

                filters.Add(filter);
            }

            if (parameters.Styles != null && parameters.Styles.Count > 0)
            {
                var filter = Builders<Climb>.Filter.AnyIn(c => c.Styles, parameters.Styles);
                filters.Add(filter);
            }

            if (!string.IsNullOrEmpty(parameters.Name))
            {
                var filter = Builders<Climb>.Filter.Eq(c => c.Name == parameters.Name, true);
                filters.Add(filter);
            }

            var complexFilter = Builders<Climb>.Filter.And(filters);

            var fullCollection = await collection.FindAsync(complexFilter);
            return await fullCollection.ToListAsync();
        }
コード例 #3
0
ファイル: FindTest.cs プロジェクト: RavenZZ/MDRelation
 protected override void Execute(IMongoCollection<BsonDocument> collection, bool async)
 {
     if (async)
     {
         var cursor = collection.FindAsync(_filter, _options).GetAwaiter().GetResult();
         cursor.ToListAsync().GetAwaiter().GetResult();
     }
     else
     {
         collection.FindSync(_filter, _options).ToList();
     }
 }
コード例 #4
0
        public virtual async Task <TEntity> GetById(string id)
        {
            var data = await DbSet.FindAsync(Builders <TEntity> .Filter.Eq("Id", id));

            return(data.SingleOrDefault());
        }
コード例 #5
0
 public async Task <List <Bid> > Get() => await(await _bids.FindAsync(bid => true)).ToListAsync();
コード例 #6
0
 public async Task <User> Get(string id) => (await _users.FindAsync(user => user.Id == id)).FirstOrDefault();
コード例 #7
0
        public async Task <List <Mover> > GetMoversAsync()
        {
            var movers = await _movers.FindAsync(vehicules => true);

            return(await movers.ToListAsync());
        }
コード例 #8
0
        public async Task Cor(CommandContext ctx)
        {
            IMongoDatabase                Local  = Program.Database.GetDatabase("local");
            DiscordEmbedBuilder           Embed  = new DiscordEmbedBuilder();
            IMongoCollection <ClanMember> Member = Local.GetCollection <ClanMember>("membros");
            IMongoCollection <Player>     Player = Local.GetCollection <Player>("players");
            IAsyncCursor <Player>         query  = await Player.FindAsync(x => x.DiscordID == ctx.Member.Id);

            List <Player> responce = query.ToList();

            if (responce.Count == 0)
            {
                Player.InsertOne(new Player {
                    DiscordID = ctx.Member.Id, CurrentXP = 0, CurrentLevel = 0, _id = new ObjectId()
                });
            }
            else
            {
                Player player = responce[0];
                IAsyncCursor <ClanMember> query2 = await Member.FindAsync(x => x.PlayerID == player._id);

                List <ClanMember> responce2 = query2.ToList();

                if (responce2.Count == 0)
                {
                    Embed
                    .WithDescription("Só membros do clã possuem acesso aos perfis.")
                    .WithAuthor("Você não é um membro do clã!")
                    .WithColor(Colors.SagiriPink);
                    await ctx.RespondAsync(embed : Embed);
                }
                else
                {
                    ClanMember membro = responce2[0];
                    IMongoCollection <Profile> Profile = Local.GetCollection <Profile>("profile");
                    IAsyncCursor <Profile>     query3  = await Profile.FindAsync(x => x.ClanMemberID == membro._id);

                    List <Profile> responce3 = query3.ToList();
                    if (responce3.Count == 0)
                    {
                        Profile perfil = new Profile();
                        perfil.ClanMemberID = membro._id;
                        perfil._id          = new ObjectId();

                        Profile.InsertOne(perfil);
                        Embed
                        .WithDescription("eu criei. Digite o comando novamente para salvar.")
                        .WithAuthor("Você não tinha um perfil, mas ...")
                        .WithColor(Colors.SagiriGray);
                        await ctx.RespondAsync(embed : Embed);
                    }
                    else
                    {
                        Profile p = responce3[0];
                        Embed
                        .WithDescription("Digite a letra referente a sua cor:\n\n**[A]**marelo\n**[V]**erde\nA**[z]**ul\n**[L]**aranja\n**[R]**oxo")
                        .WithAuthor("Escolha a cor")
                        .WithColor(Colors.SagiriGray);
                        DiscordMessage botmsg = await ctx.RespondAsync(embed : Embed);

                        DiscordMessage msg = await ctx.GetResponce(Program.Interactivity);

                        switch (msg.Content.ToLower())
                        {
                        case "a":
                            p.CsColor = "A";
                            break;

                        case "v":
                            p.CsColor = "V";
                            break;

                        case "z":
                            p.CsColor = "Z";
                            break;

                        case "l":
                            p.CsColor = "L";
                            break;

                        case "r":
                            p.CsColor = "R";
                            break;

                        default:
                            p.CsColor = "";
                            Embed
                            .WithDescription("Tenha certeza que digitou apenas a letra em destaque.")
                            .WithAuthor("Cor Inválida")
                            .WithColor(Colors.SagiriPink);
                            await botmsg.ModifyAsync(embed : Embed.Build());

                            break;
                        }
                        if (!String.IsNullOrWhiteSpace(p.CsColor))
                        {
                            Profile.UpdateOne(Builders <Profile> .Filter.Eq("ClanMemberID", membro._id), Builders <Profile> .Update.Set("CsColor", p.CsColor));
                            Embed
                            .WithDescription("")
                            .WithAuthor("Cor atualizada.")
                            .WithColor(Colors.SagiriBlue);
                            await botmsg.ModifyAsync(embed : Embed.Build());
                        }
                    }
                }
            }
        }
コード例 #9
0
ファイル: DataCollectors.cs プロジェクト: lulzzz/cbs
 public async Task <DataCollector> GetByIdAsync(Guid id)
 {
     return((await _collection.FindAsync(d => d.DataCollectorId == id)).SingleOrDefault());
 }
コード例 #10
0
        public async Task <List <TEntity> > FindAsync(FilterDefinition <TEntity> filterDefinition)
        {
            var res = await _collection.FindAsync(filterDefinition);

            return(await res.ToListAsync());
        }
コード例 #11
0
        /// <summary>
        /// Get All Countries.
        /// </summary>
        /// <returns></returns>
        public async Task <IEnumerable <HRCountry> > GetFullsAsync()
        {
            IEnumerable <HRCountry> retour = null;

            //1-
            try
            {
                MondoDBConnexionParam        conParam   = MondoDBConnexionParamFactory.CreateMondoDBConnexionParam(_config);
                IMongoCollection <HRCountry> collection = MongoDBCollectionGetter <HRCountry> .GetCollection(conParam);

                //1.1-
                if (collection != null)
                {
                    //1.1.2-
                    FilterDefinitionBuilder <HRCountry> bld        = new FilterDefinitionBuilder <HRCountry>();
                    Task <IAsyncCursor <HRCountry> >    retourTask = null;
                    try
                    {
                        retourTask = collection.FindAsync(bld.Empty);


                        FilterDefinitionBuilder <HRCountry> builder = new FilterDefinitionBuilder <HRCountry>();
                        builder.Eq <Region>((HRCountry x) => x.Region, Region.Africa);
                        //1.1.3-
                        await retourTask;
                        if (retourTask.Result != null)
                        {
                            //Force to list to avoid return asyn enum that can be enumerate only once.
                            retour = retourTask.Result.ToList();
                        }
                    }
                    finally
                    {
                        if (retourTask != null)
                        {
                            if (retourTask.Result != null)
                            {
                                retourTask.Result.Dispose();
                            }
                            retourTask.Dispose();
                        }
                    }
                }
                else
                {
                    String ErrorMessage = "No Collection found in MongoDBCountriesRepository GetFullsAsync";
                    if (_logger != null)
                    {
                        _logger.LogError(ErrorMessage);
                    }
                    throw new InvalidOperationException(ErrorMessage);
                }
            }
            catch (Exception ex)
            {
                if (_logger != null)
                {
                    _logger.LogError(ex.Message);
                }
                throw;
            }
            //2-
            return(retour);
        }
コード例 #12
0
 public virtual async Task <TEntity> GetById(Guid id) => (await _dbSet.FindAsync <TEntity>(Builders <TEntity> .Filter.Eq("_id", id))).FirstOrDefault();
コード例 #13
0
        public async Task <IEnumerable <T> > FindAsync(Expression <Func <T, bool> > filter)
        {
            var data = await _collection.FindAsync(filter);

            return(data.ToEnumerable());
        }
コード例 #14
0
 public async Task <List <T> > Get(CancellationToken cancellationToken) =>
 (await _entities?.FindAsync(
      entity => true,
      null,
      cancellationToken))?.ToList(cancellationToken);
コード例 #15
0
 public static async Task <TDocument> FindOneAsync <TDocument>(this IMongoCollection <TDocument> collection, FilterDefinition <TDocument> filter)
 {
     return(await(await collection.FindAsync(filter)).FirstOrDefaultAsync());
 }
コード例 #16
0
ファイル: ImageRepository.cs プロジェクト: 421p/grekd
        public static async Task <byte[]> GetImageRaw(int id)
        {
            var data = await _images.FindAsync(FilterDefinition <StoredImage> .Empty);

            return(data.ToEnumerable().ElementAt(id).Bytes);
        }
コード例 #17
0
 /// <inheritdoc />
 public Task <T> GetAsync(Guid id) => Collection.FindAsync(o => o.Id == id).Result?.SingleOrDefaultAsync();
コード例 #18
0
ファイル: MongoExtensions.cs プロジェクト: IT-rolling-out/IRO
 public static async Task<T> FindOneOrDefaultAsync<T>(this IMongoCollection<T> col, Expression<Func<T, bool>> filter)
 {
     var documents = await col.FindAsync(filter);
     return await documents.FirstOrDefaultAsync();
 }
コード例 #19
0
ファイル: Extensions.cs プロジェクト: FDNT/FNDTAPI
        /// <summary>
        /// Returns first element of <see cref="IMongoCollection{TDocument}"/>, for which <paramref name="predicate"/> returns true,
        /// or returns default value, if there's no such element.
        /// </summary>
        /// <typeparam name="T">Type of Collection's elements</typeparam>
        /// <param name="collection"><see cref="IMongoCollection{TDocument}"/> on which operations will be made.</param>
        /// <param name="predicate">Function, which determines, which element should be returned.</param>
        /// <returns>First occurrence of elements for which <paramref name="predicate"/> returns true and default value if there's no such element.</returns>
        public static async Task <T> FirstOrDefaultAsync <T> (this IMongoCollection <T> collection, Expression <Func <T, bool> > predicate)
        {
            var temp = await collection.FindAsync(predicate);

            return(await temp.FirstOrDefaultAsync());
        }
コード例 #20
0
 public async Task <IEnumerable <RelyingParty> > GetAll()
 {
     return((await _relyingParties.FindAsync(rp => true)).ToEnumerable());
 }
コード例 #21
0
 public async Task <IEnumerable <IFeatureToggleModel> > Get()
 {
     return((await _featureToggles.FindAsync(ft => true)).ToList());
 }
コード例 #22
0
        public async Task <User> Load(string id)
        {
            var filter = Builders <User> .Filter.Eq("Id", id);

            return(await(await _collection.FindAsync(filter)).FirstOrDefaultAsync());
        }
コード例 #23
0
 public async Task <List <Message> > Get()
 {
     return(await(await _chats.FindAsync(Chat => true)).ToListAsync());
 }
コード例 #24
0
        public async Task <Customer> ReadCustomerAsync(string customerId)
        {
            var results = await _customerColl.FindAsync(c => c.CustomerId == customerId);

            return(await results.FirstOrDefaultAsync());
        }
コード例 #25
0
        public async Task Imagem(CommandContext ctx, string link)
        {
            IMongoDatabase                Local  = Program.Database.GetDatabase("local");
            IMongoCollection <Player>     Player = Local.GetCollection <Player>("players");
            IMongoCollection <ClanMember> Member = Local.GetCollection <ClanMember>("membros");
            IAsyncCursor <Player>         query  = await Player.FindAsync(x => x.DiscordID == ctx.Member.Id);

            List <Player>       responce = query.ToList();
            DiscordEmbedBuilder Embed    = new DiscordEmbedBuilder();

            if (responce.Count == 0)
            {
                Player.InsertOne(new Player {
                    DiscordID = ctx.Member.Id, CurrentXP = 0, CurrentLevel = 0, _id = new ObjectId()
                });
            }
            else
            {
                Player p = responce[0];
                IAsyncCursor <ClanMember> query2 = await Member.FindAsync(x => x.PlayerID == p._id);

                List <ClanMember> responce2 = query2.ToList();
                if (responce2.Count == 0)
                {
                    Embed
                    .WithDescription("Só membros do clã possuem acesso ao perfil.")
                    .WithAuthor("Você não é um membro do clã!")
                    .WithColor(Colors.SagiriPink);
                    await ctx.RespondAsync(embed : Embed);
                }
                else
                {
                    ClanMember member = responce2[0];
                    IMongoCollection <Profile> Profile = Local.GetCollection <Profile>("profile");
                    IAsyncCursor <Profile>     query3  = await Profile.FindAsync(x => x.ClanMemberID == member._id);

                    List <Profile> responce3 = query3.ToList();
                    if (responce3.Count == 0)
                    {
                        Embed
                        .WithDescription("eu criei.\n\nEdite seu perfil novamente para salvar.")
                        .WithAuthor("Você não tinha um perfil, mas ...")
                        .WithColor(Colors.SagiriGray);
                        await ctx.RespondAsync(embed : Embed);
                    }
                    else
                    {
                        Profile perfil   = responce3[0];
                        string  b64image = "";
                        using (WebClient wc = new WebClient())
                        {
                            wc.DownloadFile(link, "_temp.png");
                            byte[] byteStream = File.ReadAllBytes($"{Directory.GetCurrentDirectory()}/_temp.png");
                            b64image = Convert.ToBase64String(byteStream);
                            File.Delete($"{Directory.GetCurrentDirectory()}/_temp.png");
                        }
                        Profile.UpdateOne(Builders <Profile> .Filter.Eq("ClanMemberID", member._id), Builders <Profile> .Update.Set("CustomImage", b64image));
                        Embed
                        .WithAuthor("Imagem atualizada")
                        .WithColor(Colors.SagiriBlue);
                        await ctx.RespondAsync(embed : Embed);
                    }
                }
            }
        }
コード例 #26
0
 public async Task <IEnumerable <Product> > GetAllAsync()
 {
     return((await _collection.FindAsync(new BsonDocument())).ToList());
 }
コード例 #27
0
ファイル: DataCoordinators.cs プロジェクト: GLink/cbs
 public async Task<DataCoordinator> GetByIdAsync(Guid id)
 {
     return (await _collection.FindAsync(a => a.Id == id)).SingleOrDefault();
 }
コード例 #28
0
        public async Task RemoveCargoReactRoleAsync(CommandContext ctx, DiscordChannel canalReactRole = null, DiscordEmoji emoji = null)
        {
            await ctx.TriggerTypingAsync();

            new Thread(async() =>
            {
                try
                {
                    DiscordEmbedBuilder embed = new DiscordEmbedBuilder();

                    if (canalReactRole == null || emoji == null)
                    {
                        embed.WithColor(Program.Bot.Utilities.HelpCommandsColor())
                        .WithAuthor("Como executar este comando:", null, Values.infoLogo)
                        .AddField("PC/Mobile", $"{ctx.Prefix}rr cargo.del Canal[Id] Emoji")
                        .WithFooter($"Comando requisitado pelo: {Program.Bot.Utilities.DiscordNick(ctx.Member)}", iconUrl: ctx.Member.AvatarUrl)
                        .WithTimestamp(DateTime.Now);

                        await ctx.RespondAsync(embed: embed.Build());
                        return;
                    }

                    if (string.IsNullOrWhiteSpace(emoji.Url))
                    {
                        embed.WithAuthor("Emoji inválido!", null, Values.infoLogo)
                        .WithColor(Program.Bot.Utilities.RandomColorEmbed())
                        .WithDescription("Digite um emoji válido!")
                        .WithFooter($"Comando requisitado pelo: {Program.Bot.Utilities.DiscordNick(ctx.Member)}", iconUrl: ctx.Member.AvatarUrl)
                        .WithTimestamp(DateTime.Now);

                        await ctx.RespondAsync(embed: embed.Build());
                        return;
                    }

                    IMongoDatabase local = Program.Bot.LocalDB;

                    IMongoCollection <Jogos> jogos   = local.GetCollection <Jogos>(Values.Mongo.jogos);
                    IMongoCollection <Reacts> reacts = local.GetCollection <Reacts>(Values.Mongo.reacts);

                    FilterDefinition <Jogos> filtroJogos = Builders <Jogos> .Filter.Eq(x => x.idDoEmoji, emoji.Id);
                    List <Jogos> resultadoJogos          = await(await jogos.FindAsync(filtroJogos)).ToListAsync();

                    Jogos ultimoResultadoJogo = resultadoJogos.LastOrDefault();

                    List <Reacts> resultadoReacts = await(await reacts.FindAsync(Builders <Reacts> .Filter.Eq(x => x.categoria, ultimoResultadoJogo.nomeDaCategoria))).ToListAsync();

                    Reacts ultimoResultadoReact = resultadoReacts.LastOrDefault();

                    if (resultadoJogos.Count != 0 && resultadoReacts.Count != 0)
                    {
                        DiscordMessage mensagem             = await canalReactRole.GetMessageAsync(ultimoResultadoReact.idDaMensagem);
                        DiscordEmbed embedMensagemReactRole = mensagem.Embeds.LastOrDefault();

                        DiscordEmbedBuilder builder = new DiscordEmbedBuilder(embedMensagemReactRole);

                        DiscordRole cargoJogoEmbed = ctx.Guild.GetRole(ultimoResultadoJogo.idDoCargo);

                        IReadOnlyList <DiscordUser> MembrosReacoes = await mensagem.GetReactionsAsync(emoji);

                        string linhaMensagemEmbed = $"{emoji.ToString()} - {cargoJogoEmbed.Name}";

                        if (embedMensagemReactRole.Description.Contains(linhaMensagemEmbed))
                        {
                            string descricaoEmbed = embedMensagemReactRole.Description;

                            List <string> lista = descricaoEmbed.Split('\n').ToList();
                            lista.RemoveAt(lista.FindIndex(linha => linha.Contains(linhaMensagemEmbed)));

                            StringBuilder strEmbedFinal = new StringBuilder();

                            foreach (string linha in lista)
                            {
                                strEmbedFinal.Append($"{linha}\n");
                            }

                            builder.WithDescription(strEmbedFinal.ToString());
                            builder.WithAuthor(embedMensagemReactRole.Author.Name, null, Values.logoUBGE);
                            builder.WithColor(embedMensagemReactRole.Color.Value);

                            await mensagem.ModifyAsync(embed: builder.Build());
                        }

                        await jogos.DeleteOneAsync(filtroJogos);

                        DiscordMessage msgAguarde = await ctx.RespondAsync($"Aguarde, estou removendo as reações dos membros que está no {canalReactRole.Mention}...");

                        int i = 0;

                        foreach (DiscordUser Membro in MembrosReacoes)
                        {
                            try
                            {
                                await Task.Delay(200);

                                await mensagem.DeleteReactionAsync(emoji, Membro);
                            }
                            catch (Exception)
                            {
                                ++i;
                            }
                        }

                        await msgAguarde.DeleteAsync();

                        if (i != 0)
                        {
                            await ctx.RespondAsync($"Existem **{i}** reações que não foram removidas por que os membros saíram da {ctx.Guild.Name}, por favor, remova-as manualmente. :wink:");
                        }

                        embed.WithAuthor("Jogo removido!", null, Values.logoUBGE)
                        .WithColor(Program.Bot.Utilities.RandomColorEmbed())
                        .WithThumbnailUrl(emoji.Url)
                        .WithDescription($"O cargo: {cargoJogoEmbed.Mention} e a reação: {emoji.ToString()} foram removidos com sucesso!{(i != 0 ? $"\n\n{i} reações restantes para serem removidas manualmente." : string.Empty)}")
                        .WithFooter($"Comando requisitado pelo: {Program.Bot.Utilities.DiscordNick(ctx.Member)}", iconUrl: ctx.Member.AvatarUrl)
                        .WithTimestamp(DateTime.Now);

                        await ctx.RespondAsync(embed: embed.Build());
                    }
                    else if (resultadoReacts.Count == 0)
                    {
                        await ctx.RespondAsync($"{ctx.Member.Mention}, essa categoria não existe!");
                    }
                    else if (resultadoJogos.Count == 0)
                    {
                        await ctx.RespondAsync($"{ctx.Member.Mention}, esse jogo não existe!");
                    }
                }
                catch (ArgumentException)
                {
                    await ctx.RespondAsync($"{ctx.Member.Mention}, este emoji não foi encontrado!");
                }
                catch (Exception exception)
                {
                    await Program.Bot.Logger.Error(Log.TypeError.Commands, exception);
                }
            }).Start();
        }
コード例 #29
0
 public async Task <Entity> FindFirstOneAsync(Expression <Func <Entity, bool> > where)
 {
     return((await mongoCollection.FindAsync(Builders <Entity> .Filter.Where(where)))?.FirstOrDefault());
 }
コード例 #30
0
        public async Task AdicionaCargoReactRoleAsync(CommandContext ctx, DiscordChannel canalReactRole = null, DiscordEmoji emojiServidor = null, DiscordRole cargoServidor = null, [RemainingText] string categoriaReact = null)
        {
            await ctx.TriggerTypingAsync();

            new Thread(async() =>
            {
                try
                {
                    DiscordEmbedBuilder embed = new DiscordEmbedBuilder();

                    if (canalReactRole == null || emojiServidor == null || cargoServidor == null || string.IsNullOrWhiteSpace(categoriaReact))
                    {
                        embed.WithColor(Program.Bot.Utilities.HelpCommandsColor())
                        .WithAuthor("Como executar este comando:", null, Values.infoLogo)
                        .AddField("PC/Mobile", $"{ctx.Prefix}rr cargo.add Canal[Id] Emoji Cargo[Id/Menção/Nome entre \"\"\"] Nome[Categoria]")
                        .WithFooter($"Comando requisitado pelo: {Program.Bot.Utilities.DiscordNick(ctx.Member)}", iconUrl: ctx.Member.AvatarUrl)
                        .WithTimestamp(DateTime.Now);

                        await ctx.RespondAsync(embed: embed.Build());
                        return;
                    }

                    if (string.IsNullOrWhiteSpace(emojiServidor.Url))
                    {
                        embed.WithAuthor("Emoji inválido!", null, Values.infoLogo)
                        .WithColor(Program.Bot.Utilities.RandomColorEmbed())
                        .WithDescription("Digite um emoji válido!")
                        .WithFooter($"Comando requisitado pelo: {Program.Bot.Utilities.DiscordNick(ctx.Member)}", iconUrl: ctx.Member.AvatarUrl)
                        .WithTimestamp(DateTime.Now);

                        await ctx.RespondAsync(embed: embed.Build());
                        return;
                    }

                    IMongoDatabase local = Program.Bot.LocalDB;

                    IMongoCollection <Jogos> jogos   = local.GetCollection <Jogos>(Values.Mongo.jogos);
                    IMongoCollection <Reacts> reacts = local.GetCollection <Reacts>(Values.Mongo.reacts);

                    List <Jogos> respostaJogos   = await(await jogos.FindAsync(Builders <Jogos> .Filter.Eq(x => x.idDoEmoji, emojiServidor.Id))).ToListAsync();
                    List <Reacts> respostaReacts = await(await reacts.FindAsync(Builders <Reacts> .Filter.Eq(x => x.categoria, categoriaReact))).ToListAsync();

                    if (respostaReacts.Count != 0 && respostaJogos.Count == 0)
                    {
                        DiscordMessage mensagem             = await canalReactRole.GetMessageAsync(respostaReacts.LastOrDefault().idDaMensagem);
                        DiscordEmbed embedMensagemReactRole = mensagem.Embeds.LastOrDefault();

                        DiscordEmbedBuilder builder = new DiscordEmbedBuilder(embedMensagemReactRole);

                        if (!embedMensagemReactRole.Description.Contains($"{emojiServidor.ToString()} - {cargoServidor.Name}"))
                        {
                            string descricaoEmbed     = embedMensagemReactRole.Description;
                            string novaDescricaoEmbed = descricaoEmbed += $"\n{emojiServidor.ToString()} - {cargoServidor.Name}";

                            builder.WithDescription(novaDescricaoEmbed);
                            builder.WithAuthor(builder.Author.Name, null, Values.logoUBGE);
                            builder.WithColor(builder.Color.Value);

                            await mensagem.ModifyAsync(embed: builder.Build());
                        }

                        await jogos.InsertOneAsync(new Jogos
                        {
                            nomeDaCategoria = categoriaReact,
                            idDoCargo       = cargoServidor.Id,
                            idDoEmoji       = emojiServidor.Id,
                        });

                        embed.WithAuthor("Jogo Adicionado!", null, Values.logoUBGE)
                        .WithDescription($"Categoria: \"{categoriaReact}\"\n\n" +
                                         $"Cargo do jogo: {cargoServidor.Mention}")
                        .WithThumbnailUrl(emojiServidor.Url)
                        .WithColor(Program.Bot.Utilities.RandomColorEmbed())
                        .WithFooter($"Comando requisitado pelo: {Program.Bot.Utilities.DiscordNick(ctx.Member)}", iconUrl: ctx.Member.AvatarUrl)
                        .WithTimestamp(DateTime.Now);

                        await mensagem.CreateReactionAsync(emojiServidor);
                        await ctx.RespondAsync(embed: embed.Build());
                    }
                    else if (respostaJogos.Count != 0)
                    {
                        await ctx.RespondAsync($"{ctx.Member.Mention}, este jogo já existe!");
                    }
                    else if (respostaReacts.Count == 0)
                    {
                        await ctx.RespondAsync($"{ctx.Member.Mention}, esta categoria não existe!");
                    }
                }
                catch (ArgumentException)
                {
                    await ctx.RespondAsync($"{ctx.Member.Mention}, este emoji não foi encontrado!");
                }
                catch (Exception exception)
                {
                    await Program.Bot.Logger.Error(Log.TypeError.Commands, exception);
                }
            }).Start();
        }
コード例 #31
0
 public override Task <IAsyncCursor <TProjection> > FindAsync <TProjection>(FilterDefinition <TDocument> filter, FindOptions <TDocument, TProjection> options = null, CancellationToken cancellationToken = default(CancellationToken))
 {
     return(_wrappedCollection.FindAsync(CombineFilters(filter), options, cancellationToken));
 }
コード例 #32
0
        public async Task DeletaCategoriaAsync(CommandContext ctx, DiscordChannel canalReactRole = null, [RemainingText] string nomeDaCategoriaReactRole = null)
        {
            await ctx.TriggerTypingAsync();

            new Thread(async() =>
            {
                try
                {
                    DiscordEmbedBuilder embed = new DiscordEmbedBuilder();

                    if (canalReactRole == null || string.IsNullOrWhiteSpace(nomeDaCategoriaReactRole))
                    {
                        embed.WithColor(Program.Bot.Utilities.HelpCommandsColor())
                        .WithAuthor("Como executar este comando:", null, Values.infoLogo)
                        .AddField("PC/Mobile", $"{ctx.Prefix}rr cat.del Canal[Id] Nome[Jogos: FPS]")
                        .WithFooter($"Comando requisitado pelo: {Program.Bot.Utilities.DiscordNick(ctx.Member)}", iconUrl: ctx.Member.AvatarUrl)
                        .WithTimestamp(DateTime.Now);

                        await ctx.RespondAsync(embed: embed.Build());
                        return;
                    }

                    IMongoDatabase local             = Program.Bot.LocalDB;
                    IMongoCollection <Reacts> reacts = local.GetCollection <Reacts>(Values.Mongo.reacts);
                    IMongoCollection <Jogos> jogos   = local.GetCollection <Jogos>(Values.Mongo.jogos);

                    FilterDefinition <Reacts> filtroReacts = Builders <Reacts> .Filter.Eq(x => x.categoria, nomeDaCategoriaReactRole);

                    List <Reacts> resultadoReacts = await(await reacts.FindAsync(filtroReacts)).ToListAsync();

                    if (resultadoReacts.Count != 0)
                    {
                        DiscordMessage msg = await canalReactRole.GetMessageAsync(resultadoReacts.LastOrDefault().idDaMensagem);
                        await msg.DeleteAsync();
                        await reacts.DeleteOneAsync(filtroReacts);
                        await jogos.DeleteManyAsync(Builders <Jogos> .Filter.Eq(x => x.nomeDaCategoria, nomeDaCategoriaReactRole));

                        embed.WithAuthor($"Todos os jogos e a categoria: \"{nomeDaCategoriaReactRole}\" foram apagados!", null, Values.logoUBGE)
                        .WithDescription(Program.Bot.Utilities.FindEmoji(ctx, ":UBGE:"))
                        .WithThumbnailUrl(ctx.Member.AvatarUrl)
                        .WithColor(Program.Bot.Utilities.RandomColorEmbed())
                        .WithFooter($"Comando requisitado pelo: {Program.Bot.Utilities.DiscordNick(ctx.Member)}", iconUrl: ctx.Member.AvatarUrl)
                        .WithTimestamp(DateTime.Now);

                        await ctx.RespondAsync(embed: embed.Build());
                    }
                    else
                    {
                        embed.WithAuthor($"Esta categoria não existe!", null, Values.logoUBGE)
                        .WithDescription(":thinking:")
                        .WithThumbnailUrl(ctx.Member.AvatarUrl)
                        .WithColor(Program.Bot.Utilities.RandomColorEmbed())
                        .WithFooter($"Comando requisitado pelo: {Program.Bot.Utilities.DiscordNick(ctx.Member)}", iconUrl: ctx.Member.AvatarUrl)
                        .WithTimestamp(DateTime.Now);

                        await ctx.RespondAsync(embed: embed.Build());
                    }
                }
                catch (UnauthorizedException)
                {
                    await ctx.RespondAsync($"{ctx.Member.Mention}, não tenho autorização para enviar a mensagem do ReactRole nesse canal, por favor ative-a!");
                }
                catch (Exception exception)
                {
                    await Program.Bot.Logger.Error(Log.TypeError.Commands, exception);
                }
            }).Start();
        }
コード例 #33
0
        public async Task EditCategoriaAsync(CommandContext ctx, DiscordChannel canalReactRole = null, [RemainingText] string nomeDaCategoria = null)
        {
            try
            {
                await ctx.TriggerTypingAsync();

                DiscordEmbedBuilder embed = new DiscordEmbedBuilder();

                if (canalReactRole == null || string.IsNullOrWhiteSpace(nomeDaCategoria))
                {
                    embed.WithAuthor("Como executar este comando:", null, Values.infoLogo)
                    .WithColor(Program.Bot.Utilities.HelpCommandsColor())
                    .AddField("PC/Mobile", $"{ctx.Prefix}rr cat.edit Canal[Id] Nome[Jogos: FPS]")
                    .WithFooter($"Comando requisitado pelo: {Program.Bot.Utilities.DiscordNick(ctx.Member)}", iconUrl: ctx.Member.AvatarUrl)
                    .WithTimestamp(DateTime.Now);

                    await ctx.RespondAsync(embed : embed.Build());

                    return;
                }

                InteractivityExtension Interact = ctx.Client.GetInteractivity();

                IMongoDatabase            local  = Program.Bot.LocalDB;
                IMongoCollection <Reacts> reacts = local.GetCollection <Reacts>(Values.Mongo.reacts);
                IMongoCollection <Jogos>  jogos  = local.GetCollection <Jogos>(Values.Mongo.jogos);

                FilterDefinition <Reacts> filtroMenu = Builders <Reacts> .Filter.Eq(x => x.categoria, nomeDaCategoria);

                FilterDefinition <Jogos> filtroJogos = Builders <Jogos> .Filter.Eq(x => x.nomeDaCategoria, nomeDaCategoria);

                List <Reacts> listaFiltro = await(await reacts.FindAsync(filtroMenu)).ToListAsync();

                if (listaFiltro.Count == 0)
                {
                    embed.WithAuthor("Essa categoria não existe!", null, Values.logoUBGE)
                    .WithColor(Program.Bot.Utilities.HelpCommandsColor())
                    .WithThumbnailUrl(ctx.Member.AvatarUrl)
                    .WithDescription(":thumbsup:")
                    .WithFooter($"Comando requisitado pelo: {Program.Bot.Utilities.DiscordNick(ctx.Member)}", iconUrl: ctx.Member.AvatarUrl)
                    .WithTimestamp(DateTime.Now);

                    await ctx.RespondAsync(embed : embed.Build());

                    return;
                }

                Reacts ultimaRespostaLista = listaFiltro.FirstOrDefault();

                DiscordMessage mensagemEmbed = await canalReactRole.GetMessageAsync(ultimaRespostaLista.idDaMensagem);

                DiscordEmbed embedJogo = mensagemEmbed.Embeds.FirstOrDefault();

                DiscordEmbedBuilder embedNovoReactRole = new DiscordEmbedBuilder(embedJogo);

                embed.WithAuthor($"Digite o novo título da categoria: \"{nomeDaCategoria}\"", null, Values.logoUBGE)
                .WithColor(Program.Bot.Utilities.RandomColorEmbed());

                await ctx.RespondAsync(embed : embed.Build());

                string input = await Program.Bot.Utilities.GetAnswer(Interact, ctx);

                embedNovoReactRole.WithAuthor(input, null, Values.logoUBGE);

                DiscordMessage msgEmbed = await mensagemEmbed.ModifyAsync(embed : embedNovoReactRole.Build());

                await reacts.UpdateManyAsync(filtroMenu, Builders <Reacts> .Update.Set(x => x.categoria, input));

                await jogos.UpdateManyAsync(filtroJogos, Builders <Jogos> .Update.Set(x => x.nomeDaCategoria, input));

                Program.Bot.Utilities.ClearEmbed(embed);

                embed.WithAuthor("Título do embed foi modificado com sucesso!", null, Values.logoUBGE)
                .WithColor(Program.Bot.Utilities.RandomColorEmbed())
                .WithDescription($"Novo título: \"{input}\"")
                .WithThumbnailUrl(ctx.Member.AvatarUrl)
                .WithFooter($"Comando requisitado pelo: {Program.Bot.Utilities.DiscordNick(ctx.Member)}", iconUrl: ctx.Member.AvatarUrl)
                .WithTimestamp(DateTime.Now);

                await ctx.RespondAsync(embed : embed.Build());
            }
            catch (Exception exception)
            {
                await Program.Bot.Logger.Error(Log.TypeError.Commands, exception);
            }
        }
コード例 #34
0
ファイル: Program.cs プロジェクト: johnnytorres/twitterlc
        private static async Task Dr(IMongoCollection<BsonDocument> leaders, BsonDocument filter, IMongoCollection<BsonDocument> users, IMongoCollection<BsonDocument> leadersbak)
        {
            using (var cursor = await leaders.FindAsync(filter))
            {

                while (await cursor.MoveNextAsync())
                {
                    var batch = cursor.Current;
                    foreach (var rt in batch)
                    {
                        BsonArray bRetweeters = rt["retweeters_id"].AsBsonArray;

                        //if (bRetweeters.Count == 0)
                        //    continue;

                        foreach (var bUser in bRetweeters)
                        {
                            var lUser = bUser.ToInt64();
                            try
                            {

                                log.Info("readling retweeter {0}", lUser);
                                var usersFilter = Builders<BsonDocument>.Filter.Eq("id", lUser);
                                var result = await users.Find(usersFilter).ToListAsync();
                                if (result.Count > 0)
                                    continue;

                                log.Info("downloading retweeter {0}", lUser);
                                TwitterProfileHandler profileHandler = new TwitterProfileHandlerMongo();
                                string screenName = profileHandler.Download(lUser);
                                //TwitterHomelineHandler homeHandler = new TwitterHomelineHandlerMongo();
                                //homeHandler.Download(screenName);
                            }
                            catch (Exception ex)
                            {
                                string msg = "Error trying to download profile for user:{0}";
                                msg = string.Format(msg, lUser);
                                log.Error(ex, msg);
                            }
                        }

                        //rt["done"] = true;
                        //var filterupdate = Builders<BsonDocument>.Filter.Eq("_id", rt["_id"]);
                        //var update = Builders<BsonDocument>.Update.Push("done", true);
                        //await leaders.UpdateOneAsync(filterupdate, rt);
                        await leadersbak.InsertOneAsync(rt);
                        var filterbak = Builders<BsonDocument>.Filter.Eq("_id", rt["_id"]);
                        await leaders.DeleteOneAsync(filterbak);
                    }
                }
            }

            Thread.Sleep(5000);
        }