예제 #1
0
        public async Task DelCommand(CommandContext ctx)
        {
            var msg = await ctx.RespondAsync(embed : EmbedBase.InputEmbed("# of Pair to delete"));

            var list = await ctx.RespondAsync(embed : EmbedBase.OrderedListEmbed(Program.pairs, "Pairs"));

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

            Regex d       = new Regex(@"\d+");
            var   numbers = d.Split(inpt.Result.Content).ToList();
            var   i       = int.Parse(numbers[0]);
            var   pair    = Program.pairs[i];
            await list.DeleteAsync();

            await msg.ModifyAsync(embed : EmbedBase.InputEmbed($"Do you want to delete {pair.Name}? [y/n]"));

            var ipt2 = await inpt.Result.GetNextMessageAsync();

            if (ipt2.Result.Content.ToLowerInvariant().Contains("y"))
            {
                Program.pairs.Remove(pair);
                File.WriteAllText(Directory.GetCurrentDirectory() + "/Pairs.json", JsonConvert.SerializeObject(Program.pairs, Formatting.Indented));

                await msg.ModifyAsync(embed : EmbedBase.OutputEmbed($"{pair.Name} Removed with sucess."));
            }
            else
            {
                await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("Command Cancelled."));
            }
        }
예제 #2
0
        public async Task Remove(CommandContext ctx, [Description("Membro (ID/Menção)")] DiscordMember membro)
        {
            var infras = new Infracao().FindAll(x => x.IdInfrator == membro.Id);

            if (infras.Count == 0)
            {
                await ctx.RespondAsync(embed : EmbedBase.OutputEmbed($"O Membro {membro.Mention} possui uma ficha limpa!"));
            }
            else
            {
                var briefing = await ctx.RespondAsync(embed : await EmbedExtended.MemberBriefing(infras));

                var message = await ctx.RespondAsync(embed : EmbedBase.InputEmbed("# da infração que será apagada"));

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

                var num = int.Parse(input.Result.Content.Split(" ")[0]);
                if (infras.Any(x => x.Id == num))
                {
                    var infra = infras.Find(x => x.Id == num);
                    new Infracao().Delete(infra);
                    await briefing.ModifyAsync(embed : EmbedBase.OutputEmbed($"Infração Apagada com sucesso.\n Dados :"));

                    await message.ModifyAsync(embed : EmbedExtended.AsyncInfracaoEmbed(infra));
                }
                else
                {
                    await briefing.DeleteAsync();

                    await message.ModifyAsync(embed : EmbedBase.OutputEmbed($"Numero inválido, Comando cancelado."));
                }
            }
        }
예제 #3
0
파일: time.cs 프로젝트: joaodev123/CSUB
        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."));
            }
        }
예제 #4
0
        public async Task PrefixSuccess(CommandContext ctx, [DSharpPlus.CommandsNext.Attributes.Description("The operation to be executed [add/list/del] ")]
                                        string operation)
        {
            switch (operation.ToLowerInvariant())
            {
            case "add":
                var msg = await ctx.RespondAsync(embed : EmbedBase.InputEmbed("Prefix to be added"));

                InteractivityResult <DiscordMessage> response = await ctx.Message.GetNextMessageAsync();

                var prefix = response.Result.Content;
                if (Program.Config.Prefixes.Contains(prefix.ToLowerInvariant()))
                {
                    await msg.ModifyAsync(embed : EmbedBase.OutputEmbed($"This prefix is already added."));
                }
                else
                {
                    Program.Config.Prefixes.Add(prefix.ToLowerInvariant());
                    File.WriteAllText(Directory.GetCurrentDirectory() + "/Config.json",
                                      JsonConvert.SerializeObject(Program.Config, Formatting.Indented));
                    await msg.ModifyAsync(embed : EmbedBase.OutputEmbed($"Prefix added without errors."));
                }

                break;

            case "del":
                var msg2 = await ctx.RespondAsync(embed : EmbedBase.InputEmbed("Prefix to be removed"));

                InteractivityResult <DiscordMessage> response2 = await ctx.Message.GetNextMessageAsync();

                var prefix2 = response2.Result.Content;
                if (!Program.Config.Prefixes.Contains(prefix2.ToLowerInvariant()))
                {
                    await msg2.ModifyAsync(embed : EmbedBase.OutputEmbed($"This prefix doesn't exists."));
                }
                else
                {
                    Program.Config.Prefixes.Remove(prefix2.ToLowerInvariant());
                    File.WriteAllText(Directory.GetCurrentDirectory() + "/Config.json",
                                      JsonConvert.SerializeObject(Program.Config, Formatting.Indented));
                    await msg2.ModifyAsync(embed : EmbedBase.OutputEmbed($"Prefix removed without errors."));
                }
                break;

            case "list":
                await ctx.RespondAsync(embed : EmbedBase.OrderedListEmbed(Program.Config.Prefixes, "Prefixes"));

                break;

            default:
                var embed = EmbedBase.CommandHelpEmbed(ctx.Command);
                await ctx.RespondAsync(embed : embed);

                break;
            }
        }
예제 #5
0
파일: evento.cs 프로젝트: joaodev123/CSUB
        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!"));
            }
        }
예제 #6
0
        public async Task AddCommand(CommandContext ctx)
        {
            Pair p   = new Pair();
            var  msg = await ctx.RespondAsync(embed : EmbedBase.InputEmbed("Input Channel"));

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

            var channel = ctx.Guild.Channels.ToList().Find(x => inpt.Result.Content.Contains(x.Value.Mention));

            if (channel.Value != null)
            {
                p.InputPair = channel.Key;
                await msg.ModifyAsync(embed : EmbedBase.InputEmbed("Output Channel"));

                var outp = await inpt.Result.GetNextMessageAsync();

                var ch = ctx.Guild.Channels.ToList().Find(x => outp.Result.Content.Contains(x.Value.Mention));
                if (ch.Value != null)
                {
                    p.OutputPair = ch.Key;
                    await msg.ModifyAsync(embed : EmbedBase.InputEmbed("Name"));

                    var namaeha = await outp.Result.GetNextMessageAsync();

                    p.Name = namaeha.Result.Content;
                    if (Program.pairs.Any(x => x.InputPair == p.InputPair && x.OutputPair == p.OutputPair))
                    {
                        await ctx.RespondAsync(embed : EmbedBase.OutputEmbed($"Command Failed.\n**A Pair is already configured with** <#{p.InputPair}> *->* <#{p.OutputPair}>.\n\nName : {p.Name}"));
                    }
                    else
                    {
                        Program.pairs.Add(p);
                        File.WriteAllText(Directory.GetCurrentDirectory() + "/Pairs.json", JsonConvert.SerializeObject(Program.pairs, Formatting.Indented));
                        await msg.ModifyAsync(embed : EmbedBase.OutputEmbed($"Pair {p.Name} added sucessefully."));
                    }
                }
                else
                {
                    await ctx.RespondAsync(embed : EmbedBase.OutputEmbed($"Command Failed.\n**Output Channel Not recognized.**\n\nMake sure the cannel is mentioned like in <#{ctx.Channel.Id}>"));
                }
            }
            else
            {
                await ctx.RespondAsync(embed : EmbedBase.OutputEmbed($"Command Failed.\n**Input Channel Not recognized.**\n\nMake sure the cannel is mentioned like in <#{ctx.Channel.Id}>"));
            }
        }
예제 #7
0
파일: time.cs 프로젝트: joaodev123/CSUB
        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."));
            }
        }
예제 #8
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!"));
            }
        }
예제 #9
0
파일: evento.cs 프로젝트: joaodev123/CSUB
        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!"));
            }
        }
예제 #10
0
파일: evento.cs 프로젝트: joaodev123/CSUB
        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!"));
        }
예제 #11
0
파일: react.cs 프로젝트: joaodev123/CSUB
        public async Task role(CommandContext ctx, [Description("Operação (add/del)")] string operation)
        {
            switch (operation)
            {
            case "add":
                var message = await ctx.RespondAsync(embed : EmbedBase.InputEmbed("Canal do discord (ID/Menção)"));

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

                Regex getUlong = new Regex(@"(?<!\.)\d+(?!\.)");
                var   match    = getUlong.Match(responce.Result.Content).ToString();
                if (!String.IsNullOrWhiteSpace(match))
                {
                    ulong id = ulong.Parse(match);
                    if (new ReactChannel().Find(x => x.DiscordID == id) != null)
                    {
                        DiscordChannel ch    = ctx.Guild.GetChannel(id);
                        var            cat   = new ReactCategory().FindAll(_ => true);
                        List <string>  names = new List <string>();
                        cat.ForEach(x => names.Add(x.Name));
                        await message.ModifyAsync(embed : EmbedBase.InputEmbed("Numero da categoria que você quer apagar"));

                        var list = await ctx.RespondAsync(embed : EmbedBase.OrderedListEmbed(names, "Categorias"));

                        responce = await responce.Result.GetNextMessageAsync();

                        match = getUlong.Match(responce.Result.Content).ToString();
                        if (!String.IsNullOrWhiteSpace(match))
                        {
                            var i = int.Parse(match);
                            if (i <= names.Count)
                            {
                                var category = cat[i];
                                await list.DeleteAsync();

                                await message.ModifyAsync(embed : EmbedBase.InputEmbed("Emoji (Id/Menção)"));

                                responce = await responce.Result.GetNextMessageAsync();

                                var getEmoji = new Regex(@"(\:\w*\:)");
                                match = getEmoji.Match(responce.Result.Content).ToString();
                                if (!String.IsNullOrWhiteSpace(match))
                                {
                                    var emoji = DiscordEmoji.FromName(ctx.Client, match);
                                    await message.ModifyAsync(embed : EmbedBase.InputEmbed("Cargo (Id/Menção)"));

                                    responce = await responce.Result.GetNextMessageAsync();

                                    match = getUlong.Match(responce.Result.Content).ToString();
                                    if (!String.IsNullOrWhiteSpace(match))
                                    {
                                        id = ulong.Parse(match);
                                        var            role      = ctx.Guild.GetRole(id);
                                        ReactRoleModel roleModel = new ReactRoleModel
                                        {
                                            RoleId     = role.Id,
                                            EmojiId    = emoji.Id,
                                            CategoryId = category.Id
                                        };
                                        new ReactRole().Insert(roleModel);
                                        var catmsg = await ch.GetMessageAsync(category.MessageId);

                                        await catmsg.CreateReactionAsync(emoji);

                                        category = new ReactCategory().Find(x => x.Id == category.Id);
                                        await catmsg.ModifyAsync(embed : await EmbedExtended.ReactCategory(category));

                                        await message.ModifyAsync(embed : EmbedBase.OutputEmbed("Cargo adicionado com sucesso!"));
                                    }
                                    else
                                    {
                                        await message.ModifyAsync(embed : EmbedBase.OutputEmbed("Mensagem inválida. Comando Cancelado"));
                                    }
                                }
                                else
                                {
                                    await message.ModifyAsync(embed : EmbedBase.OutputEmbed("Mensagem inválida. Comando Cancelado"));
                                }
                            }
                        }
                        else
                        {
                            await message.ModifyAsync(embed : EmbedBase.OutputEmbed("Número inválido. Comando Cancelado"));
                        }
                    }
                }
                else
                {
                    await message.ModifyAsync(embed : EmbedBase.OutputEmbed("Mensagem inválida. Comando Cancelado"));
                }
                break;

            case "del":
                message = await ctx.RespondAsync(embed : EmbedBase.InputEmbed("Canal do discord (ID/Menção)"));

                responce = await ctx.Message.GetNextMessageAsync();

                getUlong = new Regex(@"(?<!\.)\d+(?!\.)");
                match    = getUlong.Match(responce.Result.Content).ToString();
                if (!String.IsNullOrWhiteSpace(match))
                {
                    ulong id = ulong.Parse(match);
                    if (new ReactChannel().Find(x => x.DiscordID == id) != null)
                    {
                        DiscordChannel ch    = ctx.Guild.GetChannel(id);
                        var            cat   = new ReactCategory().FindAll(_ => true);
                        List <string>  names = new List <string>();
                        cat.ForEach(x => names.Add(x.Name));
                        await message.ModifyAsync(embed : EmbedBase.InputEmbed("Numero da categoria que você quer apagar"));

                        var list = await ctx.RespondAsync(embed : EmbedBase.OrderedListEmbed(names, "Categorias"));

                        responce = await responce.Result.GetNextMessageAsync();

                        match = getUlong.Match(responce.Result.Content).ToString();
                        if (!String.IsNullOrWhiteSpace(match))
                        {
                            var i = int.Parse(match);
                            if (i <= names.Count)
                            {
                                var category = cat[i];
                                List <ReactRoleModel> roles = new List <ReactRoleModel>();
                                if (category.Roles != null)
                                {
                                    category.Roles.ForEach(x => roles.Add(new ReactRole().Find(y => y.Id == x)));
                                }
                                if (roles.Count > 0)
                                {
                                    List <string> role_string = new List <string>();
                                    foreach (var r in roles)
                                    {
                                        var role  = ctx.Guild.GetRole(r.RoleId);
                                        var emoji = DiscordEmoji.FromGuildEmote(ctx.Client, r.EmojiId);
                                        role_string.Add($"{emoji} - {role.Name}");
                                    }
                                    await list.ModifyAsync(embed : EmbedBase.OrderedListEmbed(role_string, "Cargos"));

                                    await message.ModifyAsync(embed : EmbedBase.InputEmbed("Numero do cargo à ser deletado"));

                                    responce = await responce.Result.GetNextMessageAsync();

                                    match = getUlong.Match(responce.Result.Content).ToString();
                                    if (!String.IsNullOrWhiteSpace(match))
                                    {
                                        i = int.Parse(match);
                                        if (roles.Count >= i)
                                        {
                                            var rr = roles[i];
                                            await list.DeleteAsync();

                                            var emoji = DiscordEmoji.FromGuildEmote(ctx.Client, rr.EmojiId);
                                            new ReactRole().Delete(rr);
                                            category = new ReactCategory().Find(x => x.Id == category.Id);
                                            var catmsg = await ch.GetMessageAsync(category.MessageId);

                                            var members = await catmsg.GetReactionsAsync(emoji);

                                            members.ToList().ForEach(async x => await catmsg.DeleteReactionAsync(emoji, x));
                                            await catmsg.ModifyAsync(embed : await EmbedExtended.ReactCategory(category));

                                            await message.ModifyAsync(embed : EmbedBase.OutputEmbed("Cargo apagado com sucesso!"));
                                        }
                                    }
                                }
                                else
                                {
                                    await list.DeleteAsync();

                                    await message.ModifyAsync(embed : EmbedBase.OutputEmbed("Essa categoria não possui cargos."));
                                }
                            }
                        }
                    }
                }
                break;
            }
        }
예제 #12
0
파일: time.cs 프로젝트: joaodev123/CSUB
        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."));
            }
        }
예제 #13
0
파일: time.cs 프로젝트: joaodev123/CSUB
        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."));
            }
        }
예제 #14
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!"));
            }
        }
예제 #15
0
        public async Task Add(CommandContext ctx,
                              [Description("Membro que será punido (Menção / ID)")] DiscordMember membro)
        {
            InfracaoModel infra = new InfracaoModel
            {
                IdInfrator = membro.Id,
                IdStaff    = ctx.Member.Id,
            };
            var info = await ctx.RespondAsync(embed : EmbedExtended.AsyncInfracaoEmbed(infra));

            var botMsg = await ctx.RespondAsync(embed : EmbedBase.InputEmbed("Motivo"));

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

            infra.MotivoInfracao = result.Result.Content;
            await info.ModifyAsync(embed : EmbedExtended.AsyncInfracaoEmbed(infra));

            await botMsg.ModifyAsync(embed : EmbedBase.InputEmbed("Será Preso? [s/n]"));

            result = await result.Result.GetNextMessageAsync();

            infra.Preso = result.Result.Content.ToLowerInvariant()[0] == 'y' || result.Result.Content.ToLowerInvariant()[0] == 's';
            await info.ModifyAsync(embed : EmbedExtended.AsyncInfracaoEmbed(infra));

            PrisaoModel prisao = new PrisaoModel();

            if (infra.Preso)
            {
                await botMsg.ModifyAsync(embed : EmbedBase.InputEmbed("Tempo [xM, xH]"));

                result = await result.Result.GetNextMessageAsync();

                prisao = new PrisaoModel
                {
                    Data   = DateTime.Now.ToUniversalTime(),
                    Cargos = membro.Roles.Select(x => x.Id).ToList(),
                };

                if (result.Result.Content.ToLowerInvariant().Contains("h"))
                {
                    Regex getUlong = new Regex(@"([0-9])+");
                    int   i        = 0;
                    if (getUlong.IsMatch(result.Result.Content))
                    {
                        i = int.Parse(getUlong.Match(result.Result.Content).ToString());
                    }
                    TimeSpan s = TimeSpan.FromHours(i);
                    prisao.Duracao = s;
                    prisao.GuildId = ctx.Guild.Id;
                    await Prender(membro, ctx.Guild);

                    prisao.Elapsed = false;
                }
                else if (result.Result.Content.ToLowerInvariant().Contains("m"))
                {
                    Regex getUlong = new Regex(@"([0-9])+");
                    int   i        = 0;
                    if (getUlong.IsMatch(result.Result.Content))
                    {
                        i = int.Parse(getUlong.Match(result.Result.Content).ToString());
                    }
                    TimeSpan s = TimeSpan.FromMinutes(i);
                    prisao.Duracao = s;
                    prisao.GuildId = ctx.Guild.Id;
                    await Prender(membro, ctx.Guild);

                    prisao.Elapsed = false;
                }
            }
            await info.ModifyAsync(embed : EmbedExtended.AsyncInfracaoEmbed(infra));

            await botMsg.DeleteAsync();

            new Infracao().Insert(infra);
            prisao.InfraId = new Infracao().FindAll(x => x.IdInfrator == membro.Id).Last().Id;
            new Prisao().Insert(prisao);
            await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("Infração Adicionada com Sucesso."));
        }
예제 #16
0
파일: react.cs 프로젝트: joaodev123/CSUB
        public async Task categoria(CommandContext ctx, [Description("Operação (add/del/edit)")] string operation)
        {
            switch (operation)
            {
            case "add":
                var message = await ctx.RespondAsync(embed : EmbedBase.InputEmbed("Canal do discord (ID/Menção)"));

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

                Regex getUlong = new Regex(@"(?<!\.)\d+(?!\.)");
                var   match    = getUlong.Match(responce.Result.Content).ToString();
                if (!String.IsNullOrWhiteSpace(match))
                {
                    ulong id = ulong.Parse(match);
                    if (new ReactChannel().Find(x => x.DiscordID == id) != null)
                    {
                        DiscordChannel ch = ctx.Guild.GetChannel(id);

                        await message.ModifyAsync(embed : EmbedBase.InputEmbed("Nome da Categoria"));

                        responce = await responce.Result.GetNextMessageAsync();

                        string nome     = responce.Result.Content;
                        string mensagem = "";
                        await message.ModifyAsync(embed : EmbedBase.InputEmbed("Gostaria de adicionar uma mensagem na categoria? [s/n]"));

                        responce = await responce.Result.GetNextMessageAsync();

                        if (responce.Result.Content.ToLowerInvariant()[0] == 's')
                        {
                            await message.ModifyAsync(embed : EmbedBase.InputEmbed("Mensagem (Sobre :)"));

                            responce = await responce.Result.GetNextMessageAsync();

                            mensagem = responce.Result.Content;
                        }
                        ReactCategoryModel cat = new ReactCategoryModel
                        {
                            ChannelId   = ch.Id,
                            Name        = nome,
                            Description = mensagem,
                        };
                        var msg = await ch.SendMessageAsync(embed : await EmbedExtended.ReactCategory(cat));

                        cat.MessageId = msg.Id;
                        new ReactCategory().Insert(cat);
                        await message.ModifyAsync(embed : EmbedBase.OutputEmbed("Categoria adicionada com sucesso!"));
                    }
                    else
                    {
                        await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("Esse canal não foi configurado."));
                    }
                }
                else
                {
                    await message.ModifyAsync(embed : EmbedBase.OutputEmbed("Mensagem inválida. Comando Cancelado"));
                }
                break;

            case "del":
                message = await ctx.RespondAsync(embed : EmbedBase.InputEmbed("Canal do discord (ID/Menção)"));

                responce = await ctx.Message.GetNextMessageAsync();

                getUlong = new Regex(@"(?<!\.)\d+(?!\.)");
                match    = getUlong.Match(responce.Result.Content).ToString();
                if (!String.IsNullOrWhiteSpace(match))
                {
                    ulong id = ulong.Parse(match);
                    if (new ReactChannel().Find(x => x.DiscordID == id) != null)
                    {
                        DiscordChannel ch    = ctx.Guild.GetChannel(id);
                        var            cat   = new ReactCategory().FindAll(_ => true);
                        List <string>  names = new List <string>();
                        cat.ForEach(x => names.Add(x.Name));
                        await message.ModifyAsync(embed : EmbedBase.InputEmbed("Numero da categoria que você quer apagar"));

                        var list = await ctx.RespondAsync(embed : EmbedBase.OrderedListEmbed(names, "Categorias"));

                        responce = await responce.Result.GetNextMessageAsync();

                        match = getUlong.Match(responce.Result.Content).ToString();
                        if (!String.IsNullOrWhiteSpace(match))
                        {
                            var i = int.Parse(match);
                            if (i <= names.Count)
                            {
                                var category = cat[i];
                                var catmsg   = await ch.GetMessageAsync(category.MessageId);

                                await message.ModifyAsync(embed : EmbedBase.InputEmbed($"Gostaria de apagar a categoria {category.Name}? [s/n]"));

                                await list.ModifyAsync(embed : await EmbedExtended.ReactCategory(category));

                                responce = await ctx.Message.GetNextMessageAsync();

                                if (responce.Result.Content.ToLowerInvariant()[0] == 's')
                                {
                                    new ReactCategory().Delete(category);
                                    await list.DeleteAsync();

                                    await catmsg.DeleteAsync();

                                    await message.ModifyAsync(embed : EmbedBase.OutputEmbed($"Categoria {category.Name} apagada com sucesso!"));
                                }
                            }
                            else
                            {
                                await list.DeleteAsync();

                                await message.ModifyAsync(embed : EmbedBase.OutputEmbed("Número maior que o maximo da lista. Comando Cancelado."));
                            }
                        }
                    }
                    else
                    {
                        await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("Esse canal não foi configurado."));
                    }
                }
                else
                {
                    await message.ModifyAsync(embed : EmbedBase.OutputEmbed("Mensagem inválida. Comando Cancelado"));
                }
                break;

            case "edit":
                message = await ctx.RespondAsync(embed : EmbedBase.InputEmbed("Canal do discord (ID/Menção)"));

                responce = await ctx.Message.GetNextMessageAsync();

                getUlong = new Regex(@"(?<!\.)\d+(?!\.)");
                match    = getUlong.Match(responce.Result.Content).ToString();
                if (!String.IsNullOrWhiteSpace(match))
                {
                    ulong id = ulong.Parse(match);
                    if (new ReactChannel().Find(x => x.DiscordID == id) != null)
                    {
                        DiscordChannel ch    = ctx.Guild.GetChannel(id);
                        var            cat   = new ReactCategory().FindAll(_ => true);
                        List <string>  names = new List <string>();
                        cat.ForEach(x => names.Add(x.Name));
                        await message.ModifyAsync(embed : EmbedBase.InputEmbed("Numero da categoria que você quer editar"));

                        var list = await ctx.RespondAsync(embed : EmbedBase.OrderedListEmbed(names, "Categorias"));

                        responce = await responce.Result.GetNextMessageAsync();

                        match = getUlong.Match(responce.Result.Content).ToString();
                        if (!String.IsNullOrWhiteSpace(match))
                        {
                            var i = int.Parse(match);
                            if (i <= names.Count)
                            {
                                var           category = cat[i];
                                List <string> options  = new List <string> {
                                    "nome", "mensagem"
                                };
                                await message.ModifyAsync(embed : EmbedBase.InputEmbed("Numero da opção a ser editada"));

                                await list.ModifyAsync(embed : EmbedBase.OrderedListEmbed(options, "Opções"));

                                responce = await responce.Result.GetNextMessageAsync();

                                match = getUlong.Match(responce.Result.Content).ToString();
                                if (!String.IsNullOrWhiteSpace(match))
                                {
                                    i = int.Parse(match);
                                    if (i <= options.Count)
                                    {
                                        switch (i)
                                        {
                                        case 0:
                                            await list.DeleteAsync();

                                            await message.ModifyAsync(embed : EmbedBase.InputEmbed("O novo nome da categoria"));

                                            responce = await responce.Result.GetNextMessageAsync();

                                            category.Name = responce.Result.Content;
                                            var catmsg = await ch.GetMessageAsync(category.MessageId);

                                            await catmsg.ModifyAsync(embed : await EmbedExtended.ReactCategory(category));

                                            new ReactCategory().Update(x => x.Id == category.Id, category);
                                            await message.ModifyAsync(embed : EmbedBase.OutputEmbed("Categoria modificada com sucesso!"));

                                            break;

                                        case 1:
                                            await list.DeleteAsync();

                                            await message.ModifyAsync(embed : EmbedBase.InputEmbed("A nova mensagem da categoria"));

                                            responce = await responce.Result.GetNextMessageAsync();

                                            category.Description = responce.Result.Content;
                                            catmsg = await ch.GetMessageAsync(category.MessageId);

                                            await catmsg.ModifyAsync(embed : await EmbedExtended.ReactCategory(category));

                                            new ReactCategory().Update(x => x.Id == category.Id, category);
                                            await message.ModifyAsync(embed : EmbedBase.OutputEmbed("Categoria modificada com sucesso!"));

                                            break;
                                        }
                                    }
                                    else
                                    {
                                        await list.DeleteAsync();

                                        await message.ModifyAsync(embed : EmbedBase.OutputEmbed("Número maior que o maximo da lista. Comando Cancelado."));
                                    }
                                }
                                else
                                {
                                    await list.DeleteAsync();

                                    await message.ModifyAsync(embed : EmbedBase.OutputEmbed("Mensagem inválida. Comando Cancelado"));
                                }
                            }
                            else
                            {
                                await list.DeleteAsync();

                                await message.ModifyAsync(embed : EmbedBase.OutputEmbed("Número maior que o maximo da lista. Comando Cancelado."));
                            }
                        }
                    }
                    else
                    {
                        await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("Esse canal não foi configurado."));
                    }
                }
                else
                {
                    await message.ModifyAsync(embed : EmbedBase.OutputEmbed("Mensagem inválida. Comando Cancelado"));
                }
                break;

            default:
                break;
            }
        }
예제 #17
0
파일: censo.cs 프로젝트: joaodev123/CSUB
        public async Task censo(CommandContext ctx, [Description("editar/fazer")] string operacao = "fazer")
        {
            switch (operacao)
            {
            case "fazer":
                MembroModel membro = new Membro().Find(x => x.DiscordId == ctx.Member.Id);
                if (membro == null)
                {
                    membro = new MembroModel
                    {
                        DiscordId = ctx.Member.Id
                    };
                    new Membro().Insert(membro);
                }
                if (membro.Censo != 0)
                {
                    await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("Um censo comunitário já existe.\n" +
                                                                         $"Use `{ctx.Prefix}{ctx.Command.Name} editar` para editar o seu censo!"));
                }
                else
                {
                    await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("O censo será feito **no privado**. Uma mensagem com mais detalhes será enviada."));

                    var Dm = await ctx.Member.CreateDmChannelAsync();

                    CensoModel _Censo = new CensoModel
                    {
                        Timestamp = DateTime.Now,
                        DiscordId = ctx.Member.Id
                    };
                    var msg = await Dm.SendMessageAsync(embed : EmbedBase.InputEmbed("Idade"));

                    var responce = await Dm.GetNextMessageAsync(x => x.Author == ctx.User, TimeSpan.FromMinutes(30));

                    int idade = 0;
                    responce.Result.Content.Split(" ").ToList().ForEach(x => int.TryParse(x, out idade));
                    if (idade != 0)
                    {
                        _Censo.Idade = idade;
                    }
                    int.TryParse(responce.Result.Content, out idade);
                    if (idade != 0)
                    {
                        _Censo.Idade = idade;
                    }
                    await msg.ModifyAsync(embed : EmbedBase.InputEmbed("Email"));

                    responce = await responce.Result.GetNextMessageAsync();

                    string email = "";
                    Regex  check = new Regex(@"[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*");
                    email = check.Match(responce.Result.Content).ToString();
                    if (!string.IsNullOrWhiteSpace(email))
                    {
                        _Censo.Email = email;
                    }
                    await msg.ModifyAsync(embed : EmbedBase.InputEmbed("Jogos"));

                    responce = await responce.Result.GetNextMessageAsync();

                    _Censo.Jogos = responce.Result.Content;
                    await msg.ModifyAsync(embed : EmbedBase.InputEmbed("Você é brasileiro(a) ? Responda com [sim/não]"));

                    responce = await responce.Result.GetNextMessageAsync();

                    if (responce.Result.Content.ToLowerInvariant()[0] == 's')
                    {
                        await msg.ModifyAsync(embed : EmbedBase.InputEmbed("Sigla do seu estado"));

                        responce = await responce.Result.GetNextMessageAsync();

                        if (Enum.GetNames(typeof(Estado)).Contains(responce.Result.Content.ToUpperInvariant()))
                        {
                            _Censo.UF = (Estado)Enum.Parse(typeof(Estado), responce.Result.Content.ToUpperInvariant());
                        }
                        else
                        {
                            _Censo.UF = Estado.OTHER;
                        }
                    }
                    else
                    {
                        _Censo.UF = Estado.OTHER;
                    }
                    await msg.ModifyAsync(embed : EmbedBase.InputEmbed("Como chegou à UBGE"));

                    responce = await responce.Result.GetNextMessageAsync();

                    _Censo.Origem = responce.Result.Content;
                    await msg.ModifyAsync(embed : EmbedBase.InputEmbed("Fala alguma outra língua alem do português?"));

                    responce = await responce.Result.GetNextMessageAsync();

                    _Censo.Idiomas = responce.Result.Content;
                    new Logic.Censo().Insert(_Censo);
                    await msg.ModifyAsync(embed : EmbedBase.OutputEmbed("Censo Concluído."));
                }
                break;

            case "editar":
                CensoModel censo = new Logic.Censo().Find(x => x.DiscordId == ctx.Member.Id);
                if (censo == null)
                {
                    await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("Você não fez o censo ainda.\n" +
                                                                         "Faça-o com {ctx.Prefix}`{ctx.Command.Name} fazer`"));
                }
                else
                {
                    await ctx.RespondAsync(embed : EmbedBase.OutputEmbed("O censo será editado no privado. Uma mensagem será enviada em breve!"));

                    var Dm = await ctx.Member.CreateDmChannelAsync();

                    List <string> options = new List <string> {
                        "Email", "Idade", "Idiomas", "Jogos", "Como chegou à UBGE"
                    };
                    var message = await Dm.SendMessageAsync(embed : EmbedBase.OrderedListEmbed(options, "Selecione uma das opções"));

                    var responce = await Dm.GetNextMessageAsync(x => x.Author.Id == ctx.Member.Id);

                    if (char.IsDigit(responce.Result.Content[0]))
                    {
                        var value = int.Parse(responce.Result.Content[0].ToString());
                        await message.ModifyAsync(embed : EmbedBase.InputEmbed($"Digite o(s) novo(s) {options[value]}:"));

                        responce = await responce.Result.GetNextMessageAsync();
                        await Modify(censo, value, message, responce);
                    }
                    else
                    {
                        var option = options.Find(x => x.ToLowerInvariant().Contains(responce.Result.Content.ToLowerInvariant()));
                        if (!String.IsNullOrWhiteSpace(option))
                        {
                            var value = options.IndexOf(option);
                            await message.ModifyAsync(embed : EmbedBase.InputEmbed($"Digite o(s) novo(s) {options[value]}:"));

                            responce = await responce.Result.GetNextMessageAsync();
                            await Modify(censo, value, message, responce);
                        }
                    }
                }
                break;
            }
        }