Example #1
0
        private async Task TriggerBadArgEmbed(string commandExecuted, SocketCommandContext context, string finalPrefix)
        {
            EmbedService embedService = Provider.GetService <EmbedService>();
            CommandInfo  cmd          = Commands.FindInfoByName(commandExecuted);

            if (cmd.Parameters.Count == 0)
            {
                await context.Channel.SendMessageAsync("", embed : Provider.GetService <EmbedService>().MakeFailFeedbackEmbed("That command takes no arguments."), lifeTime : Config.FeedbackMessageLifeTime);

                return;
            }
            EmbedBuilder badArgEmbed = new EmbedBuilder();
            string       errorString = $"You used the wrong amount of arguments.\nCheck below for the correct syntax.\n\n{finalPrefix}{cmd.Name.Bold()}\n";

            embedService.BuildFailEmbed(badArgEmbed);
            badArgEmbed.AppendEmbedDescription(errorString);
            foreach (var arg in cmd.Parameters)
            {
                badArgEmbed.AddField(x =>
                {
                    x.Name  = $"{arg.Name} - {arg.Type.ToString().Bold()}{(arg.IsOptional ? " - Optional" : "")}";
                    x.Value = arg.Summary;
                });
            }
            await context.Channel.SendMessageAsync("", embed : badArgEmbed, lifeTime : Config.FeedbackMessageLifeTime);
        }
Example #2
0
 public MagickModule(HttpService httpService, ImageService imageService, EmbedService embedService, Config config)
 {
     HttpService  = httpService;
     ImageService = imageService;
     EmbedService = embedService;
     Config       = config;
 }
Example #3
0
 public VoiceModule(AudioService audioService, EmbedService embedService, Config config, MathService mathService) : base(mathService)
 {
     AudioService = audioService;
     EmbedService = embedService;
     MathService  = mathService;
     Config       = config;
 }
Example #4
0
 public ImageModule(HttpService httpService, ImageService imageService, EmbedService embedService, MathService mathService, Config config) : base(mathService)
 {
     HttpService  = httpService;
     ImageService = imageService;
     EmbedService = embedService;
     Config       = config;
 }
Example #5
0
        public async Task SystemFrontPercent([Remainder] string durationStr = "30d")
        {
            var system = ContextEntity ?? Context.SenderSystem;

            if (system == null)
            {
                throw Errors.NoSystemError;
            }

            var now = SystemClock.Instance.GetCurrentInstant();

            var rangeStart = PluralKit.Utils.ParseDateTime(durationStr);

            if (rangeStart == null)
            {
                throw Errors.InvalidDateTime(durationStr);
            }
            if (rangeStart.Value.ToInstant() > now)
            {
                throw Errors.FrontPercentTimeInFuture;
            }

            var frontpercent = await Switches.GetPerMemberSwitchDuration(system, rangeStart.Value.ToInstant(), now);

            await Context.Channel.SendMessageAsync(embed : await EmbedService.CreateFrontPercentEmbed(frontpercent, system.Zone));
        }
Example #6
0
 public Member(EmbedService embeds, HttpClient client,
               DispatchService dispatch)
 {
     _embeds   = embeds;
     _client   = client;
     _dispatch = dispatch;
 }
Example #7
0
 public BetCommands(IBetRepository betRepository, IPlacedUserBetRepository placedUserBetRepository, EmbedService embedService, IBetUserRepository betUserRepository)
 {
     _betRepository           = betRepository;
     _placedUserBetRepository = placedUserBetRepository;
     _embedService            = embedService;
     _betUserRepository       = betUserRepository;
 }
Example #8
0
 public AdminModule(CommandService commandService, MathService mathService, EmbedService embedService, ExecuteService executeService, Config config) : base(mathService)
 {
     CommandService = commandService;
     EmbedService   = embedService;
     ExecuteService = executeService;
     Config         = config;
 }
Example #9
0
 public ReflinksCommands(IRefUserRepository refUserRepository, EmbedService embedService, IRefExchangeRepository refExchangeRepository, IReflinkRepository reflinkRepository)
 {
     _refUserRepository     = refUserRepository;
     _embedService          = embedService;
     _refExchangeRepository = refExchangeRepository;
     _reflinkRepository     = reflinkRepository;
 }
Example #10
0
 public MemberCommands(SystemStore systems, MemberStore members, EmbedService embeds, ProxyCacheService proxyCache)
 {
     _systems    = systems;
     _members    = members;
     _embeds     = embeds;
     _proxyCache = proxyCache;
 }
Example #11
0
 public MashapeModule(EmbedService embedService, HttpService httpService, MathService mathService, Config config) : base(mathService)
 {
     EmbedService = embedService;
     HttpService  = httpService;
     MathService  = mathService;
     Config       = config;
 }
Example #12
0
 public SystemCommands(SystemStore systems, MemberStore members, SwitchStore switches, EmbedService embeds, ProxyCacheService proxyCache)
 {
     _systems    = systems;
     _members    = members;
     _switches   = switches;
     _embeds     = embeds;
     _proxyCache = proxyCache;
 }
Example #13
0
 public SubscriptionsModule(DBContextFactory factory, EmbedService embedService, Config config, CNNService cnnService, RedditService redditService, MathService mathService) : base(mathService)
 {
     DBFactory     = factory;
     EmbedService  = embedService;
     Config        = config;
     CNNService    = cnnService;
     RedditService = redditService;
 }
 public PriceCheckCommands(IMiraiexAPIService miraiexService, EmbedService embedService, ICoinGeckoAPIService coinGeckoAPI, INBXAPIService nBXAPIService, IOptions <ExchangesConfiguration> options)
 {
     _miraiexService = miraiexService;
     _embedService   = embedService;
     _coinGeckoAPI   = coinGeckoAPI;
     _nBXAPIService  = nBXAPIService;
     _options        = options.Value;
 }
 public TickerCheckCommands(IMiraiexAPIService miraiexService, EmbedService embedService, INBXAPIService nBXAPIService, IBitmyntAPIService bitmyntAPIService, IOptions <ExchangesConfiguration> options)
 {
     _miraiexService    = miraiexService;
     _embedService      = embedService;
     _nBXAPIService     = nBXAPIService;
     _bitmyntAPIService = bitmyntAPIService;
     _options           = options.Value;
 }
		public PowerBiController(EmbedService embedService, ExportService exportService, IMemoryCache cache, ILogger<PowerBiController> logger)
		{
			this.embedService = embedService;
			this.exportService = exportService;

			// Get service cache
			this.cache = cache;
			this.logger = logger;
		}
Example #17
0
 public StatsModule(EmbedService embedService, Config config, TrackingService trackingService, MathService mathService, ImageService imageService, DBContextFactory dbFactory) : base(mathService)
 {
     EmbedService    = embedService;
     Config          = config;
     TrackingService = trackingService;
     MathService     = mathService;
     ImageService    = imageService;
     DBFactory       = dbFactory;
 }
Example #18
0
 public DataModule(HttpService httpService, EmbedService embedService, TrackingService trackingService, ImageService imageService, DBContextFactory dbFactory, Config config, MathService mathService) : base(mathService)
 {
     HttpService     = httpService;
     EmbedService    = embedService;
     TrackingService = trackingService;
     ImageService    = imageService;
     DBFactory       = dbFactory;
     Config          = config;
 }
Example #19
0
 public Misc(BotConfig botConfig, IMetrics metrics, CpuStatService cpu, ShardInfoService shards, IDataStore data, EmbedService embeds)
 {
     _botConfig = botConfig;
     _metrics   = metrics;
     _cpu       = cpu;
     _shards    = shards;
     _data      = data;
     _embeds    = embeds;
 }
Example #20
0
 public LearnModule(ContextService contextService,
                    EmbedService embeds,
                    LearnModuleService learnService,
                    ClientService clientService)
 {
     _contextService = contextService;
     _embeds         = embeds;
     _learnService   = learnService;
     _clientService  = clientService;
 }
Example #21
0
 public LearnModuleService(ContextService contextService,
                           EmbedService embeds,
                           LearnModuleParserService parserService,
                           LearnModuleFilterService filterService)
 {
     _contextService = contextService;
     _embeds         = embeds;
     _parserService  = parserService;
     _filterService  = filterService;
 }
Example #22
0
        public static async Task <IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
            ILogger log)
        {
            try
            {
                log.LogInformation("Power BI Report Token Requested");
                // string reportId = "0c94ccca-55f8-4cd8-95c4-2ce136ec5e22";

                string reportId = req.Query["reportid"];

                string  requestBody = await new StreamReader(req.Body).ReadToEndAsync();
                dynamic data        = JsonConvert.DeserializeObject(requestBody);
                reportId = reportId ?? data?.reportId;

                log.LogInformation("reportId: " + reportId);

                if (!String.IsNullOrWhiteSpace(reportId))
                {
                    string username = null;
                    string roles    = null;


                    IEmbedService m_embedService = new EmbedService();
                    var           embedResult    = await m_embedService.EmbedReport(username, roles, reportId);

                    if (embedResult)
                    {
                        ResultJson resultJson = new ResultJson()
                        {
                            EmbedToken = m_embedService.EmbedConfig.EmbedToken.Token,
                            EmbedUrl   = m_embedService.EmbedConfig.EmbedUrl,
                            ReportId   = reportId
                        };

                        string resultString = JsonConvert.SerializeObject(resultJson);

                        return((ActionResult) new OkObjectResult(resultString));
                    }
                    else
                    {
                        return((ActionResult) new BadRequestObjectResult("Could not generate a token."));
                    }
                }
                else
                {
                    return((ActionResult) new BadRequestObjectResult("Report Id is empty or null."));
                }
            }
            catch (Exception ex)
            {
                log.LogInformation("Exception: " + ex.ToString());
                return((ActionResult) new BadRequestObjectResult("An Exception has occurred."));
            }
        } // Run
Example #23
0
 public LogChannelService(EmbedService embed, ILogger logger, IDatabase db, ModelRepository repo,
                          IDiscordCache cache, DiscordApiClient rest, Bot bot)
 {
     _embed  = embed;
     _db     = db;
     _repo   = repo;
     _cache  = cache;
     _rest   = rest;
     _bot    = bot;
     _logger = logger.ForContext <LogChannelService>();
 }
        public async Task UpdateOneEmbed(SaasafrasGoogleDriveService saasyDrive, Embed embed, List <Embed> embeds, string subfolderId, Podio podio, RoutedPodioEvent e)
        {
            try
            {
                var id       = saasyDrive.GetFileId(embed.OriginalUrl);
                var original = await saasyDrive.GetFileMicro(id, "name, parents");

                if (original.Parents == null)
                {
                    original.Parents = new List <string>();
                }
                Console.WriteLine($"{e.podioEvent.item_id} - Old File ID: {original.Id}, Name: {original.Name}");
                original.Parents.Clear();
                original.Parents.Add(subfolderId);
                original.Name = e.environmentId + " " + original.Name;

                var clone = await saasyDrive.CopyFile(id);

                var permissionsAdded = await saasyDrive.SetPermissions(id, "writer", "anyone");

                await Task.Run(() =>
                {
                    var embedServ = new EmbedService(podio);;

                    Console.WriteLine($"{e.podioEvent.item_id} - CloneID: {clone.Id}");
                    //runs 130x approx
                    var waitSeconds = 5;
CallPodio:
                    Embed em;
                    try
                    {
                        em = embedServ.AddAnEmbed(clone.WebViewLink).Result;
                    }
                    catch (PodioUnavailableException ex)
                    {
                        Console.WriteLine($"{ex.Message}");
                        Console.WriteLine($"Trying again in {waitSeconds} seconds.");
                        for (var i = 0; i < waitSeconds; i++)
                        {
                            System.Threading.Thread.Sleep(1000);
                            Console.WriteLine(".");
                        }
                        waitSeconds *= 2;
                        goto CallPodio;
                    }
                    //Console.WriteLine($"{e.podioEvent.item_id} - WebViewLink: {clone.WebViewLink}");
                    embeds.Add(em);
                });
            }
            catch (Exception ex)
            {
                Console.WriteLine($"{e.podioEvent.item_id} - {ex.Message} - {ex.StackTrace} - {ex.InnerException}");
            }
        }
Example #25
0
 public ProxiedMessage(EmbedService embeds, IClock clock,
                       DiscordApiClient rest,
                       WebhookExecutorService webhookExecutor, LogChannelService logChannel, IDiscordCache cache)
 {
     _embeds          = embeds;
     _clock           = clock;
     _rest            = rest;
     _webhookExecutor = webhookExecutor;
     _logChannel      = logChannel;
     // _cache = cache;
 }
 public async Task StatusAsync( )
 {
     foreach (var monitor in MonitorService.Monitors.Values)
     {
         var embed = EmbedService.GetEmbed(monitor.Port);
         if (embed != null)
         {
             await Context.User.SendMessageAsync(embed : embed);
         }
     }
 }
Example #27
0
 public ProxiedMessage(EmbedService embeds,
                       DiscordApiClient rest, IMetrics metrics, ModelRepository repo, ProxyService proxy,
                       WebhookExecutorService webhookExecutor, LogChannelService logChannel, IDiscordCache cache)
 {
     _embeds          = embeds;
     _rest            = rest;
     _webhookExecutor = webhookExecutor;
     _repo            = repo;
     _logChannel      = logChannel;
     // _cache = cache;
     _metrics = metrics;
     _proxy   = proxy;
 }
Example #28
0
        public async Task Invite(CommandContext ctx)
        {
            await ctx.TriggerTypingAsync();

            var embed = EmbedService.GetBaseEmbed(Discord, ctx: ctx);

            embed.Title = "Awe, you want me to come with you?\n" +
                          "Let's go!";
            embed.WithThumbnail(new Uri("https://imgflip.com/s/meme/Happy-Guy-Rage-Face.jpg"));
            embed.WithUrl(
                "https://discord.com/oauth2/authorize?client_id=747611613569220660&scope=bot&permissions=268499969");
            await ctx.RespondAsync(embed : embed);
        }
Example #29
0
        public async Task Query(PKSystem system = null)
        {
            if (system == null)
            {
                system = Context.SenderSystem;
            }
            if (system == null)
            {
                throw Errors.NoSystemError;
            }

            await Context.Channel.SendMessageAsync(embed : await EmbedService.CreateSystemEmbed(system));
        }
Example #30
0
        public ActionResult Index()
        {
            try
            {
                var settingsGroupId = Request.QueryString["sid"];
                if (string.IsNullOrEmpty(settingsGroupId))
                {
                    var defaultPbiSettingsGroupId = (string)ModuleContext.Settings["PowerBIEmbedded_SettingsGroupId"];
                    var pbiSettings = SharedSettingsRepository.Instance.GetSettings(ModuleContext.PortalId).RemoveUnauthorizedItems(User);
                    if (!string.IsNullOrEmpty(defaultPbiSettingsGroupId) && pbiSettings.Any(x => x.SettingsGroupId == defaultPbiSettingsGroupId))
                    {
                        settingsGroupId = defaultPbiSettingsGroupId;
                    }
                    else
                    {
                        settingsGroupId = pbiSettings.FirstOrDefault(x => !string.IsNullOrEmpty(x.SettingsGroupId))?.SettingsGroupId;
                    }
                }
                var embedService = new EmbedService(ModuleContext.PortalId, ModuleContext.TabModuleId, settingsGroupId);

                var model = embedService.GetContentListAsync(ModuleContext.PortalSettings.UserId).Result;
                if (model != null)
                {
                    // Remove other culture contents
                    model = model.RemoveOtherCultureItems();

                    // Remove the objects without permissions
                    model = model.RemoveUnauthorizedItems(User);

                    // Sets the reports page on the viewbag
                    var reportsPage = embedService.Settings.ContentPageUrl;
                    if (!reportsPage.StartsWith("http"))
                    {
                        reportsPage = Globals.AddHTTP(PortalSettings.PortalAlias.HTTPAlias) + reportsPage;
                    }

                    ViewBag.ReportsPage     = reportsPage;
                    ViewBag.SettingsGroupId = settingsGroupId;

                    return(View(model));
                }

                return(View());
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                return(View());
            }
        }