Esempio n. 1
0
        public async Task CanCreateFromStackAsync(Version version, bool expectData)
        {
            var settings = GetService <JsonSerializerSettings>();

            settings.Formatting = Formatting.Indented;
            var data = await _webHookData.CreateFromStackAsync(GetWebHookDataContext(version));

            if (expectData)
            {
                string filePath = $@"..\..\Plugins\WebHookData\v{version}.stack.expected.json";
                ApprovalsUtility.VerifyFile(filePath, JsonConvert.SerializeObject(data, settings));
            }
            else
            {
                Assert.Null(data);
            }
        }
Esempio n. 2
0
        public async Task CanCreateFromStackAsync(Version version, bool expectData)
        {
            var settings = GetService <JsonSerializerSettings>();

            settings.Formatting = Formatting.Indented;
            object data = await _webHookData.CreateFromStackAsync(GetWebHookDataContext(version));

            if (expectData)
            {
                string filePath        = Path.GetFullPath(Path.Combine("..", "..", "..", "Plugins", "WebHookData", $"v{version}.stack.expected.json"));
                string expectedContent = File.ReadAllText(filePath);
                Assert.Equal(expectedContent, JsonConvert.SerializeObject(data, settings));
            }
            else
            {
                Assert.Null(data);
            }
        }
Esempio n. 3
0
    public async Task <IActionResult> PromoteAsync(string id)
    {
        if (String.IsNullOrEmpty(id))
        {
            return(NotFound());
        }

        var stack = await _stackRepository.GetByIdAsync(id);

        if (stack == null || !CanAccessOrganization(stack.OrganizationId))
        {
            return(NotFound());
        }

        if (!await _billingManager.HasPremiumFeaturesAsync(stack.OrganizationId))
        {
            return(PlanLimitReached("Promote to External is a premium feature used to promote an error stack to an external system. Please upgrade your plan to enable this feature."));
        }

        var promotedProjectHooks = (await _webHookRepository.GetByProjectIdAsync(stack.ProjectId)).Documents.Where(p => p.EventTypes.Contains(WebHookRepository.EventTypes.StackPromoted)).ToList();

        if (!promotedProjectHooks.Any())
        {
            return(NotImplemented("No promoted web hooks are configured for this project. Please add a promoted web hook to use this feature."));
        }

        foreach (var hook in promotedProjectHooks)
        {
            var context = new WebHookDataContext(hook.Version, stack, isNew: stack.TotalOccurrences == 1, isRegression: stack.Status == StackStatus.Regressed);
            await _webHookNotificationQueue.EnqueueAsync(new WebHookNotification {
                OrganizationId = stack.OrganizationId,
                ProjectId      = stack.ProjectId,
                WebHookId      = hook.Id,
                Url            = hook.Url,
                Type           = WebHookType.General,
                Data           = await _webHookDataPluginManager.CreateFromStackAsync(context)
            });
        }

        return(Ok());
    }