Exemple #1
0
        public async Task edit(CommandContext ctx)
        {
            List <EventoModel> eventos = new Evento().FindAll(_ => true);

            if (eventos.Count > 0)
            {
                List <Page> pages = new List <Page>();
                eventos.ForEach(async e => pages.Add(new Page($"", new DiscordEmbedBuilder(await EmbedExtended.AsyncEventoEmbed(e)))));
                PaginationEmojis emojis = new PaginationEmojis
                {
                    Left      = DiscordEmoji.FromName(ctx.Client, ":arrow_left:"),
                    Stop      = DiscordEmoji.FromName(ctx.Client, ":stop_button:"),
                    Right     = DiscordEmoji.FromName(ctx.Client, ":arrow_right:"),
                    SkipLeft  = null,
                    SkipRight = null
                };
                var msg = await ctx.RespondAsync(embed : EmbedBase.InputEmbed($"Selecione o evento a ser apagado, Depois clique em {emojis.Stop.ToString()} para confirmar."));

                await ctx.Channel.SendPaginatedMessageAsync(ctx.User, pages.ToArray(), emojis, PaginationBehaviour.WrapAround, PaginationDeletion.Default, TimeSpan.FromMinutes(30));

                var           lastMsg = (await ctx.Channel.GetMessagesAfterAsync(msg.Id)).ToList().FirstOrDefault(x => x.Author == msg.Author && msg.Embeds.Count > 0);
                var           id      = int.Parse(lastMsg.Embeds[0].Fields.ToList().Find(x => x.Name == "Id").Value);
                var           evento  = eventos.Find(x => x.Id == id);
                List <string> options = new List <string> {
                    "Nome", "Limite de Jogadores/time", "Limite de reservas/time", "Quantidade max. de times"
                };
                await msg.ModifyAsync(embed : EmbedBase.InputEmbed($"Selecionado : {evento.Nome}"));

                await lastMsg.ModifyAsync(embed : EmbedBase.OrderedListEmbed(options, " Selecione o que deseja editar [Número]"));

                var input = await ctx.Message.GetNextMessageAsync();

                switch (input.Result.Content.ToLowerInvariant()[0])
                {
                case '0':
                    await msg.ModifyAsync(embed : EmbedBase.InputEmbed("O novo nome:"));

                    input = await input.Result.GetNextMessageAsync();

                    evento.Nome = input.Result.Content;
                    new Evento().Update(x => x.Id == evento.Id, evento);
                    await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Nome modificado com sucesso!"));

                    break;

                case '1':
                    await msg.ModifyAsync(embed : EmbedBase.InputEmbed("O novo limite (0 para remover):"));

                    input = await input.Result.GetNextMessageAsync();

                    evento.LimiteJogadores = int.Parse(input.Result.Content);
                    new Evento().Update(x => x.Id == evento.Id, evento);
                    await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Limite de jogadores modificado com sucesso!"));

                    break;

                case '2':
                    await msg.ModifyAsync(embed : EmbedBase.InputEmbed("O novo limite (0 para remover):"));

                    input = await input.Result.GetNextMessageAsync();

                    evento.LimiteReservas = int.Parse(input.Result.Content);
                    new Evento().Update(x => x.Id == evento.Id, evento);
                    await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Limite de reservas modificado com sucesso!"));

                    break;

                case '3':
                    await msg.ModifyAsync(embed : EmbedBase.InputEmbed("O novo limite (0 para remover):"));

                    input = await input.Result.GetNextMessageAsync();

                    evento.LimiteTimes = int.Parse(input.Result.Content);
                    new Evento().Update(x => x.Id == evento.Id, evento);
                    await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Limite de times modificado com sucesso!"));

                    break;

                default:
                    await lastMsg.DeleteAsync();

                    await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Comando cancelado. Valor inválido."));

                    break;
                }
                await lastMsg.ModifyAsync(embed : await EmbedExtended.AsyncEventoEmbed(evento));
            }
            else
            {
                await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("Não há eventos cadastrados no sistema. Considere criar alguns!"));
            }
        }
Exemple #2
0
        public async Task apagar(CommandContext ctx)
        {
            List <EventoModel> eventos = new Evento().FindAll(_ => true);

            if (eventos.Count > 0)
            {
                List <Page> pages = new List <Page>();
                eventos.ForEach(async e => pages.Add(new Page($"", new DiscordEmbedBuilder(await EmbedExtended.AsyncEventoEmbed(e)))));
                PaginationEmojis emojis = new PaginationEmojis
                {
                    Left      = DiscordEmoji.FromName(ctx.Client, ":arrow_left:"),
                    Stop      = DiscordEmoji.FromName(ctx.Client, ":stop_button:"),
                    Right     = DiscordEmoji.FromName(ctx.Client, ":arrow_right:"),
                    SkipLeft  = null,
                    SkipRight = null
                };
                var msg = await ctx.RespondAsync(embed : EmbedBase.InputEmbed($"Selecione o evento a ser apagado, Depois clique em {emojis.Stop.ToString()} para confirmar."));

                await ctx.Channel.SendPaginatedMessageAsync(ctx.User, pages.ToArray(), emojis, PaginationBehaviour.WrapAround, PaginationDeletion.Default, TimeSpan.FromMinutes(30));

                var lastMsg = (await ctx.Channel.GetMessagesAfterAsync(msg.Id)).ToList().FirstOrDefault(x => x.Author == msg.Author && msg.Embeds.Count > 0);
                var id      = int.Parse(lastMsg.Embeds[0].Fields.ToList().Find(x => x.Name == "Id").Value);
                var evento  = eventos.Find(x => x.Id == id);
                await lastMsg.DeleteAsync();

                await msg.ModifyAsync(embed : EmbedBase.InputEmbed($"Selecionado : {evento.Nome}, Deseja apagar? [s/n]"));

                var input = await ctx.Message.GetNextMessageAsync();

                switch (input.Result.Content.ToLowerInvariant()[0])
                {
                case 's':
                case 'y':
                    new Evento().Delete(evento);
                    await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Evento apagado com sucesso!"));

                    break;

                case 'n':
                    await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Comando cancelado."));

                    break;
                }
            }
            else
            {
                await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("Não há eventos cadastrados no sistema. Considere criar alguns!"));
            }
        }
Exemple #3
0
        public async Task criar(CommandContext ctx, [Description("Nome do evento"), RemainingText] string nome)
        {
            EventoModel evento = new EventoModel
            {
                Nome = nome
            };
            var dados = await ctx.RespondAsync(embed : await EmbedExtended.AsyncEventoEmbed(evento));

            var msg = await ctx.RespondAsync(embed : EmbedBase.InputEmbed("Número max. de times [(s/n), número]"));

            var input = await ctx.Message.GetNextMessageAsync();

            if (char.IsNumber(input.Result.Content.ToLowerInvariant()[0]))
            {
                Regex getUlong = new Regex(@"([0-9])+");
                Match match    = getUlong.Match(input.Result.Content.ToLowerInvariant());
                int   i        = int.Parse(match.ToString());
                evento.LimiteTimes = i;
            }
            else
            {
                //TODO: Add an yes/no question to the Utils.
                switch (input.Result.Content.ToLowerInvariant()[0])
                {
                case 's':
                case 'y':
                    Regex getUlong = new Regex(@"([0-9])+");
                    if (getUlong.IsMatch(input.Result.Content.ToLowerInvariant()))
                    {
                        Match match = getUlong.Match(input.Result.Content.ToLowerInvariant());
                        int   i     = int.Parse(match.ToString());
                        evento.LimiteTimes = i;
                    }
                    else
                    {
                        await msg.ModifyAsync(embed : EmbedBase.InputEmbed("O Número do limite."));

                        input = await input.Result.GetNextMessageAsync();

                        if (getUlong.IsMatch(input.Result.Content.ToLowerInvariant()))
                        {
                            Match match = getUlong.Match(input.Result.Content.ToLowerInvariant());
                            int   i     = int.Parse(match.ToString());
                            evento.LimiteTimes = i;
                        }
                        else
                        {
                            await dados.DeleteAsync();

                            await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Número inválido. Comando cancelado."));
                        }
                    }

                    break;

                case 'n':
                    evento.LimiteTimes = 0;
                    break;
                }
            }
            await dados.ModifyAsync(embed : await EmbedExtended.AsyncEventoEmbed(evento));

            await msg.ModifyAsync(embed : EmbedBase.InputEmbed("Número max. de jogadores [(s/n), número]"));

            input = await input.Result.GetNextMessageAsync();

            if (char.IsNumber(input.Result.Content.ToLowerInvariant()[0]))
            {
                Regex getUlong = new Regex(@"([0-9])+");
                Match match    = getUlong.Match(input.Result.Content.ToLowerInvariant());
                int   i        = int.Parse(match.ToString());
                evento.LimiteJogadores = i;
            }
            else
            {
                switch (input.Result.Content.ToLowerInvariant()[0])
                {
                case 's':
                case 'y':
                    Regex getUlong = new Regex(@"([0-9])+");
                    if (getUlong.IsMatch(input.Result.Content.ToLowerInvariant()))
                    {
                        Match match = getUlong.Match(input.Result.Content.ToLowerInvariant());
                        int   i     = int.Parse(match.ToString());
                        evento.LimiteJogadores = i;
                    }
                    else
                    {
                        await msg.ModifyAsync(embed : EmbedBase.InputEmbed("O Número do limite."));

                        input = await input.Result.GetNextMessageAsync();

                        if (getUlong.IsMatch(input.Result.Content.ToLowerInvariant()))
                        {
                            Match match = getUlong.Match(input.Result.Content.ToLowerInvariant());
                            int   i     = int.Parse(match.ToString());
                            evento.LimiteJogadores = i;
                        }
                        else
                        {
                            await dados.DeleteAsync();

                            await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Número inválido. Comando cancelado."));
                        }
                    }

                    break;

                case 'n':
                    evento.LimiteJogadores = 0;
                    break;
                }
            }
            await dados.ModifyAsync(embed : await EmbedExtended.AsyncEventoEmbed(evento));

            await msg.ModifyAsync(embed : EmbedBase.InputEmbed("Número max. de reservas [(s/n), número]"));

            input = await input.Result.GetNextMessageAsync();

            if (char.IsNumber(input.Result.Content.ToLowerInvariant()[0]))
            {
                Regex getUlong = new Regex(@"([0-9])+");
                Match match    = getUlong.Match(input.Result.Content.ToLowerInvariant());
                int   i        = int.Parse(match.ToString());
                evento.LimiteReservas = i;
            }
            else
            {
                switch (input.Result.Content.ToLowerInvariant()[0])
                {
                case 's':
                case 'y':
                    Regex getUlong = new Regex(@"([0-9])+");
                    if (getUlong.IsMatch(input.Result.Content.ToLowerInvariant()))
                    {
                        Match match = getUlong.Match(input.Result.Content.ToLowerInvariant());
                        int   i     = int.Parse(match.ToString());
                        evento.LimiteReservas = i;
                    }
                    else
                    {
                        await msg.ModifyAsync(embed : EmbedBase.InputEmbed("O Número do limite."));

                        input = await input.Result.GetNextMessageAsync();

                        if (getUlong.IsMatch(input.Result.Content.ToLowerInvariant()))
                        {
                            Match match = getUlong.Match(input.Result.Content.ToLowerInvariant());
                            int   i     = int.Parse(match.ToString());
                            evento.LimiteReservas = i;
                        }
                        else
                        {
                            await dados.DeleteAsync();

                            await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Número inválido. Comando cancelado."));
                        }
                    }

                    break;

                case 'n':
                    evento.LimiteReservas = 0;
                    break;
                }
            }
            await dados.ModifyAsync(embed : await EmbedExtended.AsyncEventoEmbed(evento));

            new Evento().Insert(evento);
            await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Evento adicionado com sucesso!"));
        }
Exemple #4
0
        public async Task sair(CommandContext ctx)
        {
            List <EventoModel> eventos = new Evento().FindAll(_ => true);

            if (eventos.Count > 0)
            {
                List <Page> pages = new List <Page>();
                eventos.ForEach(async e => pages.Add(new Page($"", new DiscordEmbedBuilder(await EmbedExtended.AsyncEventoEmbed(e)))));
                PaginationEmojis emojis = new PaginationEmojis
                {
                    Left      = DiscordEmoji.FromName(ctx.Client, ":arrow_left:"),
                    Stop      = DiscordEmoji.FromName(ctx.Client, ":stop_button:"),
                    Right     = DiscordEmoji.FromName(ctx.Client, ":arrow_right:"),
                    SkipLeft  = null,
                    SkipRight = null
                };
                var msg = await ctx.RespondAsync(embed : EmbedBase.InputEmbed($"Selecione o evento que deseja participar. Depois clique em {emojis.Stop.ToString()} para confirmar."));

                await ctx.Channel.SendPaginatedMessageAsync(ctx.User, pages.ToArray(), emojis, PaginationBehaviour.WrapAround, PaginationDeletion.Default, TimeSpan.FromMinutes(30));

                var lastMsg = (await ctx.Channel.GetMessagesAfterAsync(msg.Id)).ToList().FirstOrDefault(x => x.Author == msg.Author && msg.Embeds.Count > 0);
                var id      = int.Parse(lastMsg.Embeds[0].Fields.ToList().Find(x => x.Name == "Id").Value);
                var evento  = eventos.Find(x => x.Id == id);
                if (new Time().Find(x => x.EventoId == id && (x.Jogadores.Any(y => y == ctx.Member.Id) || x.Reservas.Any(y => y == ctx.Member.Id))) != null)
                {
                    var time = new Time().Find(x => x.EventoId == id && (x.Jogadores.Any(y => y == ctx.Member.Id) || x.Reservas.Any(y => y == ctx.Member.Id)));
                    await lastMsg.DeleteAsync();

                    if (time.LiderId != ctx.Member.Id)
                    {
                        await msg.ModifyAsync(embed : EmbedBase.InputEmbed($"Você deseja sair de {time.Nome}?.[s/n]"));

                        var input = await ctx.Message.GetNextMessageAsync();

                        switch (input.Result.Content.ToLowerInvariant().Trim()[0])
                        {
                        case 'y':
                        case 's':
                            if (time.Jogadores.Contains(ctx.Member.Id))
                            {
                                time.Jogadores.Remove(ctx.Member.Id);
                            }
                            if (time.Reservas.Contains(ctx.Member.Id))
                            {
                                time.Reservas.Remove(ctx.Member.Id);
                            }
                            new Time().Update(x => x.Id == time.Id, time);
                            await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Você saiu do time com sucesso!"));

                            break;

                        default:
                            await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Comando cancelado."));

                            break;
                        }
                    }
                    else
                    {
                        await msg.ModifyAsync(embed : EmbedBase.InputEmbed($"Você deseja **apagar** {time.Nome}?.[s/n]"));

                        var input = await ctx.Message.GetNextMessageAsync();

                        switch (input.Result.Content.ToLowerInvariant().Trim()[0])
                        {
                        case 'y':
                        case 's':
                            new Time().Delete(time);
                            await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Time apagado com sucesso!"));

                            break;

                        default:
                            await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Comando cancelado."));

                            break;
                        }
                    }
                }
                else
                {
                    await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("Você não participa de nenhum time neste evento."));
                }
            }
            else
            {
                await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("Não há eventos ativos no momento. Inscrição de times foi desativada."));
            }
        }
Exemple #5
0
        public async Task listar(CommandContext ctx)
        {
            List <EventoModel> eventos = new Evento().FindAll(_ => true);

            if (eventos.Count > 0)
            {
                List <Page> pages = new List <Page>();
                eventos.ForEach(async e => pages.Add(new Page($"Lista de eventos ativos", new DiscordEmbedBuilder(await EmbedExtended.AsyncEventoEmbed(e)))));
                PaginationEmojis emojis = new PaginationEmojis
                {
                    Left      = DiscordEmoji.FromName(ctx.Client, ":arrow_left:"),
                    Stop      = DiscordEmoji.FromName(ctx.Client, ":stop_button:"),
                    Right     = DiscordEmoji.FromName(ctx.Client, ":arrow_right:"),
                    SkipLeft  = null,
                    SkipRight = null
                };
                await ctx.Channel.SendPaginatedMessageAsync(ctx.User, pages.ToArray(), emojis, PaginationBehaviour.WrapAround, PaginationDeletion.Default, TimeSpan.FromMinutes(30));
            }
            else
            {
                await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("Não existem eventos ativos no momento."));
            }
        }
Exemple #6
0
        public async Task edit(CommandContext ctx, [Description("O novo nome"), RemainingText] string nome)
        {
            List <EventoModel> eventos = new Evento().FindAll(_ => true);

            if (eventos.Count > 0)
            {
                List <Page> pages = new List <Page>();
                eventos.ForEach(async x => pages.Add(new Page("", new DiscordEmbedBuilder(await EmbedExtended.AsyncEventoEmbed(x)))));
                PaginationEmojis emojis = new PaginationEmojis
                {
                    Left      = DiscordEmoji.FromName(ctx.Client, ":arrow_left:"),
                    Stop      = DiscordEmoji.FromName(ctx.Client, ":stop_button:"),
                    Right     = DiscordEmoji.FromName(ctx.Client, ":arrow_right:"),
                    SkipLeft  = null,
                    SkipRight = null
                };
                var msg = await ctx.RespondAsync(embed : EmbedBase.InputEmbed($"Selecione o evento que deseja adicionar o membro. Depois clique em {emojis.Stop.ToString()} para confirmar."));

                await ctx.Channel.SendPaginatedMessageAsync(ctx.User, pages.ToArray(), emojis, PaginationBehaviour.WrapAround, PaginationDeletion.Default, TimeSpan.FromMinutes(30));

                var lastMsg = (await ctx.Channel.GetMessagesAfterAsync(msg.Id)).ToList().FirstOrDefault(x => x.Author == msg.Author && msg.Embeds.Count > 0);
                var id      = int.Parse(lastMsg.Embeds[0].Fields.ToList().Find(x => x.Name == "Id").Value);
                var evento  = eventos.Find(x => x.Id == id);
                await lastMsg.DeleteAsync();

                List <TimeModel> times = new Time().FindAll(x => x.EventoId == id && x.LiderId == ctx.Member.Id);
                if (times.Count > 0)
                {
                    var time = times[0];
                    time.Nome = nome;
                    new Time().Update(x => x.Id == time.Id, time);
                    await msg.ModifyAsync(embed : EmbedBase.OutputEmbed($"Nome alterado para {time.Nome} com sucesso!"));
                }
                else
                {
                    await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Você não é lider de nenhum time neste evento."));
                }
            }
            else
            {
                await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("Não há eventos ativos no momento. Inscrição de times foi desativada."));
            }
        }
Exemple #7
0
        public async Task create(CommandContext ctx, [Description("Nome do time"), RemainingText] String nome)
        {
            List <EventoModel> eventos = new Evento().FindAll(_ => true);

            if (eventos.Count > 0)
            {
                TimeModel time = new TimeModel
                {
                    Nome      = nome,
                    LiderId   = ctx.Member.Id,
                    Jogadores = new[] { ctx.Member.Id }.ToList()
                };
                List <Page> pages = new List <Page>();
                eventos.ForEach(async e => pages.Add(new Page($"", new DiscordEmbedBuilder(await EmbedExtended.AsyncEventoEmbed(e)))));
                PaginationEmojis emojis = new PaginationEmojis
                {
                    Left      = DiscordEmoji.FromName(ctx.Client, ":arrow_left:"),
                    Stop      = DiscordEmoji.FromName(ctx.Client, ":stop_button:"),
                    Right     = DiscordEmoji.FromName(ctx.Client, ":arrow_right:"),
                    SkipLeft  = null,
                    SkipRight = null
                };
                var msg = await ctx.RespondAsync(embed : EmbedBase.InputEmbed($"Selecione o evento que deseja participar. Depois clique em {emojis.Stop.ToString()} para confirmar."));

                await ctx.Channel.SendPaginatedMessageAsync(ctx.User, pages.ToArray(), emojis, PaginationBehaviour.WrapAround, PaginationDeletion.Default, TimeSpan.FromMinutes(30));

                var lastMsg = (await ctx.Channel.GetMessagesAfterAsync(msg.Id)).ToList().FirstOrDefault(x => x.Author == msg.Author && msg.Embeds.Count > 0);
                var id      = int.Parse(lastMsg.Embeds[0].Fields.ToList().Find(x => x.Name == "Id").Value);
                var evento  = eventos.Find(x => x.Id == id);
                if (new Time().Find(x => x.EventoId == id && x.LiderId == ctx.Member.Id) != null)
                {
                    await lastMsg.DeleteAsync();

                    await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Você já possui um time nesse evento."));
                }
                else
                {
                    time.EventoId = id;
                    await lastMsg.DeleteAsync();

                    if (evento.LimiteTimes == 0 || evento.Times == null || evento.Times.Count < evento.LimiteTimes)
                    {
                        new Time().Insert(time);
                        await msg.ModifyAsync(embed : EmbedBase.OutputEmbed($"Selecionado : {evento.Nome}. Time criado."));
                    }
                    else
                    {
                        await msg.ModifyAsync(embed : EmbedBase.OutputEmbed($"Inscrições para esse evento foram fechadas. Peça uma vaga aos organizadores do evento."));
                    }
                }
            }
            else
            {
                await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("Não há eventos ativos no momento. Inscrição de times foi desativada."));
            }
        }
Exemple #8
0
        public async Task add(CommandContext ctx, [Description("O Membro que será adicionado (Menção/ID) ")] DiscordMember membro)
        {
            List <EventoModel> eventos = new Evento().FindAll(_ => true);

            if (eventos.Count > 0)
            {
                List <Page> pages = new List <Page>();
                eventos.ForEach(async e => pages.Add(new Page($"", new DiscordEmbedBuilder(await EmbedExtended.AsyncEventoEmbed(e)))));
                PaginationEmojis emojis = new PaginationEmojis
                {
                    Left      = DiscordEmoji.FromName(ctx.Client, ":arrow_left:"),
                    Stop      = DiscordEmoji.FromName(ctx.Client, ":stop_button:"),
                    Right     = DiscordEmoji.FromName(ctx.Client, ":arrow_right:"),
                    SkipLeft  = null,
                    SkipRight = null
                };
                var msg = await ctx.RespondAsync(embed : EmbedBase.InputEmbed($"Selecione o evento que deseja adicionar o membro. Depois clique em {emojis.Stop.ToString()} para confirmar."));

                await ctx.Channel.SendPaginatedMessageAsync(ctx.User, pages.ToArray(), emojis, PaginationBehaviour.WrapAround, PaginationDeletion.Default, TimeSpan.FromMinutes(30));

                var lastMsg = (await ctx.Channel.GetMessagesAfterAsync(msg.Id)).ToList().FirstOrDefault(x => x.Author == msg.Author && msg.Embeds.Count > 0);
                var id      = int.Parse(lastMsg.Embeds[0].Fields.ToList().Find(x => x.Name == "Id").Value);
                var evento  = eventos.Find(x => x.Id == id);
                await lastMsg.DeleteAsync();

                if (new Time().Find(x => x.EventoId == id && (x.Jogadores.Any(y => y == membro.Id) || (x.Reservas != null && x.Reservas.Any(y => y == membro.Id)))) != null)
                {
                    await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Esse membro já foi adicionado à um time."));
                }
                else
                {
                    if (new Time().Find(x => x.LiderId == ctx.Member.Id) != null)
                    {
                        var time = new Time().Find(x => x.LiderId == ctx.Member.Id && x.EventoId == evento.Id);
                        if (evento.LimiteJogadores == 0 || time.Jogadores.Count < evento.LimiteJogadores)
                        {
                            time.Jogadores.Add(membro.Id);
                            new Time().Update(x => x.Id == time.Id, time);
                            await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Membro adicionado com sucesso!"));
                        }
                        else if (evento.LimiteJogadores != 0 && time.Reservas != null && time.Reservas.Count < evento.LimiteReservas || time.Reservas == null && evento.LimiteReservas == 0 || time.Reservas == null)
                        {
                            if (!time.Jogadores.Any(x => x == membro.Id))
                            {
                                if (time.Reservas == null)
                                {
                                    time.Reservas = new List <ulong>();
                                }
                                time.Reservas.Add(membro.Id);
                                new Time().Update(x => x.Id == time.Id, time);
                                await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Reserva adicionado com sucesso!"));
                            }
                        }
                        else
                        {
                            await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Limite de membros atingido."));
                        }
                    }
                    else
                    {
                        await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Você não é lider de nenhum time."));
                    }
                }
            }
            else
            {
                await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("Não há eventos ativos no momento. Inscrição de times foi desativada."));
            }
        }
Exemple #9
0
        public async Task apagar(CommandContext ctx)
        {
            List <EventoModel> eventos = new Evento().FindAll(_ => true);

            if (eventos.Count > 0)
            {
                List <Page> pages = new List <Page>();
                eventos.ForEach(async e => pages.Add(new Page($"", new DiscordEmbedBuilder(await EmbedExtended.AsyncEventoEmbed(e)))));
                PaginationEmojis emojis = new PaginationEmojis
                {
                    Left      = DiscordEmoji.FromName(ctx.Client, ":arrow_left:"),
                    Stop      = DiscordEmoji.FromName(ctx.Client, ":stop_button:"),
                    Right     = DiscordEmoji.FromName(ctx.Client, ":arrow_right:"),
                    SkipLeft  = null,
                    SkipRight = null
                };
                var msg = await ctx.RespondAsync(embed : EmbedBase.InputEmbed($"Selecione o evento. Depois clique em {emojis.Stop.ToString()} para confirmar."));

                await ctx.Channel.SendPaginatedMessageAsync(ctx.User, pages.ToArray(), emojis, PaginationBehaviour.WrapAround, PaginationDeletion.Default, TimeSpan.FromMinutes(30));

                var lastMsg = (await ctx.Channel.GetMessagesAfterAsync(msg.Id)).ToList().FirstOrDefault(x => x.Author == msg.Author && msg.Embeds.Count > 0);
                var id      = int.Parse(lastMsg.Embeds[0].Fields.ToList().Find(x => x.Name == "Id").Value);
                var evento  = eventos.Find(x => x.Id == id);
                await lastMsg.DeleteAsync();

                if (evento.Times == null)
                {
                    await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("Não há nenhum time neste evento."));
                }
                else
                {
                    List <TimeModel> times    = new List <TimeModel>();
                    List <string>    nomes    = new List <string>();
                    Regex            getUlong = new Regex(@"(?<!\.)\d+(?!\.)");
                    evento.Times.ForEach(x => times.Add(new Time().Find(y => y.Id == x)));
                    times.ForEach(x => nomes.Add($"{x.Id} - {x.Nome}"));
                    await msg.ModifyAsync(embed : EmbedBase.InputEmbed("Time q será apagado [Número]"));

                    var list = await ctx.RespondAsync(embed : EmbedBase.OrderedListEmbed(nomes, $"Times em {evento.Nome}:"));

                    var responce = await ctx.Message.GetNextMessageAsync();

                    if (getUlong.IsMatch(responce.Result.Content))
                    {
                        int i = int.Parse(getUlong.Match(responce.Result.Content).ToString());
                        if (times.Any(x => x.Id == i))
                        {
                            new Time().Delete(x => x.Id == i);
                            await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Time apagado com sucesso."));
                        }
                        else
                        {
                            await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Número inválido. Comando Cancelado."));
                        }
                    }
                }
            }
            else
            {
                await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("Não há nenhum evento ativo no momento. Considere criar um!"));
            }
        }
Exemple #10
0
        public async Task criar(CommandContext ctx,
                                [Description("O Líder do time (Id/Menção)")] DiscordMember lider,
                                [Description("O Nome do time."), RemainingText] string nome)
        {
            List <EventoModel> eventos = new Evento().FindAll(_ => true);

            if (eventos.Count > 0)
            {
                List <Page> pages = new List <Page>();
                eventos.ForEach(async e => pages.Add(new Page($"", new DiscordEmbedBuilder(await EmbedExtended.AsyncEventoEmbed(e)))));
                PaginationEmojis emojis = new PaginationEmojis
                {
                    Left      = DiscordEmoji.FromName(ctx.Client, ":arrow_left:"),
                    Stop      = DiscordEmoji.FromName(ctx.Client, ":stop_button:"),
                    Right     = DiscordEmoji.FromName(ctx.Client, ":arrow_right:"),
                    SkipLeft  = null,
                    SkipRight = null
                };
                var msg = await ctx.RespondAsync(embed : EmbedBase.InputEmbed($"Selecione o evento. Depois clique em {emojis.Stop.ToString()} para confirmar."));

                await ctx.Channel.SendPaginatedMessageAsync(ctx.User, pages.ToArray(), emojis, PaginationBehaviour.WrapAround, PaginationDeletion.Default, TimeSpan.FromMinutes(30));

                var lastMsg = (await ctx.Channel.GetMessagesAfterAsync(msg.Id)).ToList().FirstOrDefault(x => x.Author == msg.Author && msg.Embeds.Count > 0);
                var id      = int.Parse(lastMsg.Embeds[0].Fields.ToList().Find(x => x.Name == "Id").Value);
                var evento  = eventos.Find(x => x.Id == id);
                await lastMsg.DeleteAsync();

                TimeModel time = new TimeModel();
                time.EventoId  = evento.Id;
                time.Jogadores = new List <ulong> {
                    lider.Id
                };
                time.LiderId = lider.Id;
                time.Nome    = nome;
                new Time().Insert(time);
                await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("Time criado com sucesso!"));
            }
            else
            {
                await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("Não há nenhum evento ativo no momento. Considere criar um!"));
            }
        }