Ejemplo n.º 1
0
        public static GitPullRequestStatus GenerateSampleStatus(int?iterationId = null, bool includeProperties = false)
        {
            var status = new GitPullRequestStatus
            {
                Context = new GitStatusContext
                {
                    Name  = $"sample-status-{Rng.Next(1, 5)}",
                    Genre = "vsts-samples"
                },
                TargetUrl   = "http://fabrikam-fiber-inc.com/CI/builds/1",
                State       = GitStatusState.Succeeded,
                Description = "Sample status succeeded",
                IterationId = iterationId
            };

            if (includeProperties)
            {
                status.Properties                    = new PropertiesCollection();
                status.Properties["sampleId"]        = Rng.Next(1, 10);
                status.Properties["customInfo"]      = "Custom status information";
                status.Properties["startedDateTime"] = DateTime.UtcNow;
                status.Properties["weight"]          = 1.75;
                status.Properties["bytes"]           = Encoding.UTF8.GetBytes("this is sample base64 encoded string");
                status.Properties["globalId"]        = Guid.NewGuid();
            }

            return(status);
        }
Ejemplo n.º 2
0
        public void UpdatePullRequestIterationStatuses()
        {
            VssConnection connection = this.Context.Connection;
            GitHttpClient gitClient  = connection.GetClient <GitHttpClient>();

            TeamProjectReference project     = ClientSampleHelpers.FindAnyProject(this.Context);
            GitRepository        repo        = GitSampleHelpers.FindAnyRepository(this.Context, project.Id);
            GitPullRequest       pullRequest = GitSampleHelpers.CreatePullRequest(this.Context, repo);

            GitPullRequestStatus status1 = GitSampleHelpers.CreatePullRequestStatus(this.Context, repo.Id, pullRequest.PullRequestId, 1);
            GitPullRequestStatus status2 = GitSampleHelpers.CreatePullRequestStatus(this.Context, repo.Id, pullRequest.PullRequestId, 1);

            Console.WriteLine($"project {project.Name}, repo {repo.Name}, pullRequestId {pullRequest.PullRequestId}");

            var patch = new JsonPatchDocument();

            patch.Add(new JsonPatchOperation()
            {
                Operation = VisualStudio.Services.WebApi.Patch.Operation.Remove, Path = $"/{status1.Id}"
            });
            patch.Add(new JsonPatchOperation()
            {
                Operation = VisualStudio.Services.WebApi.Patch.Operation.Remove, Path = $"/{status2.Id}"
            });

            gitClient.UpdatePullRequestIterationStatusesAsync(patch, repo.Id, pullRequest.PullRequestId, 1).SyncResult();

            Console.WriteLine($"Statuses {status1.Id}, and {status2.Id} deleted from the pull request {pullRequest.PullRequestId}, iteration {1}");

            GitSampleHelpers.AbandonPullRequest(this.Context, repo, pullRequest.PullRequestId);
        }
        public async Task HandleNewPr(PullRequest prRequest, string pat, Uri projectCollectionUri)
        {
            var creds      = new VssBasicCredential(string.Empty, pat);
            var connection = new VssConnection(new Uri(projectCollectionUri, "DefaultCollection"), creds);

            var gitClient = connection.GetClient <GitHttpClient>();

            var pr = await gitClient.GetPullRequestByIdAsync(prRequest.PullrequestId);

            var iterations = await gitClient.GetPullRequestIterationsAsync(pr.Repository.Id, prRequest.PullrequestId, true);

            var prStatus = new GitPullRequestStatus
            {
                State       = GitStatusState.NotSet,
                Description = "No finished Build",
                Context     = new GitStatusContext {
                    Genre = "continous-integration", Name = "PrAnnotator"
                }
            };

            //var status = await gitClient.CreatePullRequestStatusAsync(prStatus, prRequest.TeamProject, pr.Repository.Id, pr.PullRequestId).ConfigureAwait(false);

            var id = iterations.Last()?.Id;

            if (id != null)
            {
                prStatus.Description = $"Update {id.Value}: {prStatus.Description}";
                await gitClient.CreatePullRequestIterationStatusAsync(prStatus, pr.Repository.Id, pr.PullRequestId, id.Value);
            }
        }
Ejemplo n.º 4
0
 public static Task <GitPullRequestStatus> AddToCurrentPullRequest(VssConnection connection, Guid repositoryId,
                                                                   GitPullRequestStatus status)
 {
     return(AddToPullRequest(
                connection, repositoryId,
                int.Parse(Environment.GetEnvironmentVariable("System.PullRequest.PullRequestId")),
                status));
 }
Ejemplo n.º 5
0
        public async Task ReportBackToPullRequest(VstsRequest req, AzureValidationResult result)
        {
            var gitClient = _getGitClient(req);

            var repoId  = req.resource.repository.id;
            var gRepoId = new Guid(repoId);

            var projectId = req.resourceContainers.project.id;

            var pr = await gitClient.GetPullRequestAsync(repoId, req.resource.pullRequestId);

            var its = await gitClient.GetPullRequestIterationsAsync(repoId, pr.PullRequestId);

            var it = its.Last();

            var prStatus = new GitPullRequestStatus();

            prStatus.Context = new GitStatusContext {
                Genre = _settings.Value.Genre, Name = _settings.Value.Name
            };
            prStatus.IterationId = it.Id;

            if (result.Failed)
            {
                prStatus.State       = GitStatusState.Failed;
                prStatus.Description = "Failed ARM Template Checks";

                var failed = result.ValidatedFiles.FirstOrDefault(_ => _.Failed);

                var message = "";

                if (failed == null)
                {
                    _logService.TrackException(new Exception("Failed happened but not failed item found!"));
                    message = $"## ARM Validation Failed on Update {it.Id} \r\n Failed checks on Update {it.Id}";
                    //should not be able to do this:/
                }
                else
                {
                    message =
                        $"## ARM Validation Failed on Update {it.Id}\r\n**File:** {failed.FilePath}\r\n**Message:** {failed.Message}";
                }

                await _createComment(message, pr, gitClient, repoId);
            }
            else
            {
                var message = $"## ARM Validation Passed on Update {it.Id}\r\n Scanned {result.ValidatedFiles.Count} files.";
                await _createComment(message, pr, gitClient, repoId);

                prStatus.State       = GitStatusState.Succeeded;
                prStatus.Description = "ARM Template Checks Pass";
            }

            await gitClient.CreatePullRequestIterationStatusAsync(prStatus, new Guid(repoId), pr.PullRequestId, it.Id.Value);
        }
Ejemplo n.º 6
0
        public static GitPullRequestStatus CreatePullRequestStatus(ClientSampleContext context, Guid repositoryId, int pullRequestId, int?iterationId = null)
        {
            VssConnection connection = context.Connection;
            GitHttpClient gitClient  = connection.GetClient <GitHttpClient>();

            using (new ClientSampleHttpLoggerOutputSuppression())
            {
                GitPullRequestStatus status        = GenerateSampleStatus(iterationId);
                GitPullRequestStatus createdStatus = gitClient.CreatePullRequestStatusAsync(status, repositoryId, pullRequestId).Result;

                return(createdStatus);
            }
        }
Ejemplo n.º 7
0
        public async Task CreatePRStatus()
        {
            var data = File.ReadAllText("SerialisedObjects\\req6.json");

            var obj = JsonConvert.DeserializeObject <VstsRequest>(data);


            //  VssConnection connection = new VssConnection(new Uri(collectionUri), new VssBasicCredential(string.Empty, pat));

            var collectionId = AppSettings.AzureDevOpsCollectionName;


            var connection = new VssConnection(new Uri(collectionId),
                                               new VssBasicCredential(string.Empty, SecretOptions.Value.PAT));

            var gitClient = connection.GetClient <GitHttpClient>();

            var repoId  = obj.resource.repository.id;
            var gRepoId = new Guid(repoId);
            var pr      = await gitClient.GetPullRequestAsync(obj.resource.repository.id, obj.resource.pullRequestId);

            var its = await gitClient.GetPullRequestIterationsAsync(repoId, pr.PullRequestId);

            var it       = its.Last();
            var prStatus = new GitPullRequestStatus();

            prStatus.Context = new GitStatusContext {
                Genre = AppSettings.Genre, Name = AppSettings.Name
            };
            prStatus.State       = GitStatusState.Succeeded;
            prStatus.Description = "All seems good dude6.";
            prStatus.IterationId = it.Id;

            var comment = new Comment();

            comment.Content = "This was done okay cool yeah *bold* **something** \r\n # test \r\n omething";

            var cThread = new GitPullRequestCommentThread
            {
                Comments = new List <Comment>()
            };

            cThread.Comments.Add(comment);

            await gitClient.CreateThreadAsync(cThread, repoId, pr.PullRequestId);

            await gitClient.CreatePullRequestIterationStatusAsync(prStatus, new Guid(repoId), pr.PullRequestId, it.Id.Value);
        }
        public async Task HandleBuild(BuildRequest build, string pat, Uri projectCollectionUri)
        {
            if (string.IsNullOrEmpty(build.SourceBranch))
            {
                return;
            }

            var creds      = new VssBasicCredential(string.Empty, pat);
            var connection = new VssConnection(new Uri(projectCollectionUri, "DefaultCollection"), creds);

            var gitClient = connection.GetClient <GitHttpClient>();

            var prs = await gitClient.GetPullRequestsAsync(build.TeamProject, build.RepositoryId,
                                                           new GitPullRequestSearchCriteria { SourceRefName = build.SourceBranch, Status = PullRequestStatus.Active });

            foreach (var pr in prs)
            {
                // Delete Status from PRCreate
                var oldstatuses = await gitClient.GetPullRequestStatusesAsync(build.TeamProject, build.RepositoryId, pr.PullRequestId);

                var toDeleteStatuses = oldstatuses.Where(s => s.Context.Name == "PrAnnotator");
                foreach (var oldstatus in toDeleteStatuses)
                {
                    await gitClient.DeletePullRequestStatusAsync(build.TeamProject, build.RepositoryId, pr.PullRequestId, oldstatus.Id);
                }

                var prStatus = new GitPullRequestStatus
                {
                    State       = build.Status == "completed" ? GitStatusState.Succeeded : GitStatusState.Failed,
                    Description = $"{build.DefinitionName}: Build {build.Status}",
                    Context     = new GitStatusContext {
                        Genre = "Build", Name = build.DefinitionName
                    },
                    TargetUrl = build.BuildUri
                };

                //await gitClient.CreatePullRequestStatusAsync(prStatus, build.TeamProject, pr.Repository.Id, pr.PullRequestId).ConfigureAwait(false);

                var iterations = await gitClient.GetPullRequestIterationsAsync(pr.Repository.Id, pr.PullRequestId);

                var id = iterations.Last(i => i.SourceRefCommit.CommitId == build.SourceVersion).Id;
                if (id != null)
                {
                    prStatus.Description = $"Update {id.Value}: {prStatus.Description}";
                    await gitClient.CreatePullRequestIterationStatusAsync(prStatus, pr.Repository.Id, pr.PullRequestId, id.Value);
                }
            }
        }
Ejemplo n.º 9
0
        protected async Task UpdateStatusAsync(GitStatusState state, string description)
        {
            var client = await ServiceFactory.GetClientAsync <GitHttpClient>();

            var status = new GitPullRequestStatus
            {
                State       = state,
                Description = description,
                TargetUrl   = TargetUrl,
                Context     = new GitStatusContext
                {
                    Genre = "ait-policy",
                    Name  = GetName()
                }
            };

            await client.CreatePullRequestStatusAsync(status, PullRequest.Repository.Id, PullRequest.PullRequestId);
        }
Ejemplo n.º 10
0
        public void DeletePullRequestIterationStatus()
        {
            VssConnection connection = this.Context.Connection;
            GitHttpClient gitClient  = connection.GetClient <GitHttpClient>();

            TeamProjectReference project     = ClientSampleHelpers.FindAnyProject(this.Context);
            GitRepository        repo        = GitSampleHelpers.FindAnyRepository(this.Context, project.Id);
            GitPullRequest       pullRequest = GitSampleHelpers.CreatePullRequest(this.Context, repo);

            GitPullRequestStatus status = GitSampleHelpers.CreatePullRequestStatus(this.Context, repo.Id, pullRequest.PullRequestId, 1);

            Console.WriteLine($"project {project.Name}, repo {repo.Name}, pullRequestId {pullRequest.PullRequestId}");

            gitClient.DeletePullRequestIterationStatusAsync(repo.Id, pullRequest.PullRequestId, 1, status.Id).SyncResult();

            Console.WriteLine($"Status {status.Id} deleted from pull request {pullRequest.PullRequestId}, iteration {1}");

            GitSampleHelpers.AbandonPullRequest(this.Context, repo, pullRequest.PullRequestId);
        }
Ejemplo n.º 11
0
        public GitPullRequestStatus GetPullRequestIterationStatus()
        {
            VssConnection connection = this.Context.Connection;
            GitHttpClient gitClient  = connection.GetClient <GitHttpClient>();

            TeamProjectReference project         = ClientSampleHelpers.FindAnyProject(this.Context);
            GitRepository        repo            = GitSampleHelpers.FindAnyRepository(this.Context, project.Id);
            GitPullRequest       pullRequest     = GitSampleHelpers.CreatePullRequest(this.Context, repo);
            GitPullRequestStatus generatedStatus = GitSampleHelpers.CreatePullRequestStatus(this.Context, repo.Id, pullRequest.PullRequestId, 1);

            Console.WriteLine($"project {project.Name}, repo {repo.Name}, pullRequestId {pullRequest.PullRequestId}");

            GitPullRequestStatus status = gitClient.GetPullRequestIterationStatusAsync(repo.Id, pullRequest.PullRequestId, 1, generatedStatus.Id).Result;

            Console.WriteLine($"{status.Description}({status.Context.Genre}/{status.Context.Name}) with id {status.Id}");

            GitSampleHelpers.AbandonPullRequest(this.Context, repo, pullRequest.PullRequestId);

            return(status);
        }
        public GitPullRequestStatus CreatePullRequestStatusWithCustomProperties()
        {
            VssConnection connection = this.Context.Connection;
            GitHttpClient gitClient  = connection.GetClient <GitHttpClient>();

            TeamProjectReference project     = ClientSampleHelpers.FindAnyProject(this.Context);
            GitRepository        repo        = GitSampleHelpers.FindAnyRepository(this.Context, project.Id);
            GitPullRequest       pullRequest = GitSampleHelpers.CreatePullRequest(this.Context, repo);

            Console.WriteLine("project {0}, repo {1}, pullRequestId {2}", project.Name, repo.Name, pullRequest.PullRequestId);

            GitPullRequestStatus status = GitSampleHelpers.GenerateSampleStatus(includeProperties: true);

            GitPullRequestStatus createdStatus = gitClient.CreatePullRequestStatusAsync(status, repo.Id, pullRequest.PullRequestId).Result;

            Console.WriteLine($"{createdStatus.Description}({createdStatus.Context.Genre}/{createdStatus.Context.Name}) with id {createdStatus.Id} created");

            GitSampleHelpers.AbandonPullRequest(this.Context, repo, pullRequest.PullRequestId);

            return(createdStatus);
        }
Ejemplo n.º 13
0
        public override Task RegisterHooks()
        {
            ServiceHookManager.Instance.RegisterTaskHook(TaskServiceHookType.TaskCompleted, task =>
            {
                var errorOccurred = task.IsFaulted;
                var pluginResult  = ((Task <PluginResult>)task).Result;

                var status = new GitPullRequestStatus
                {
                    State = errorOccurred ? GitStatusState.Succeeded : GitStatusState.Failed
                };

                if (IsBuildingPullRequest)
                {
                    VssConnection connection = null;
                    var repositoryId         = Guid.NewGuid();
                    AddToCurrentPullRequest(connection, repositoryId, status);
                }
            });

            return(Task.FromResult(0));
        }
Ejemplo n.º 14
0
        public async Task SetToPending(VstsRequest req)
        {
            var gitClient = _getGitClient(req);
            var prStatus  = new GitPullRequestStatus();

            prStatus.Context = new GitStatusContext {
                Genre = _settings.Value.Genre, Name = _settings.Value.Name
            };
            prStatus.State = GitStatusState.Pending;
            var repoId  = req.resource.repository.id;
            var gRepoId = new Guid(repoId);

            var projectId = req.resourceContainers.project.id;

            var pr = await gitClient.GetPullRequestAsync(repoId, req.resource.pullRequestId);

            var its = await gitClient.GetPullRequestIterationsAsync(repoId, pr.PullRequestId);

            var it = its.Last();

            prStatus.IterationId = it.Id;

            await gitClient.CreatePullRequestIterationStatusAsync(prStatus, new Guid(repoId), pr.PullRequestId, it.Id.Value);
        }
        public async Task HandleRelease(ReleaseRequest releaseRequest, string pat, Uri projectCollectionUri)
        {
            var creds      = new VssBasicCredential(string.Empty, pat);
            var connection = new VssConnection(new Uri(projectCollectionUri, "DefaultCollection"), creds);

            var gitClient     = connection.GetClient <GitHttpClient>();
            var buildClient   = connection.GetClient <BuildHttpClient>();
            var releaseClient = connection.GetClient <ReleaseHttpClient>();


            var release = await releaseClient.GetReleaseAsync(releaseRequest.TeamProject, releaseRequest.ReleaseId);

            var buildArtifact = release.Artifacts.First(a => a.Type == "Build").DefinitionReference;
            var branch        = buildArtifact["branch"].Name;

            var build = await buildClient.GetBuildAsync(buildArtifact["project"].Id, int.Parse(buildArtifact["version"].Id));

            var envStatus = release.Environments.ToDictionary(e => e.Name, e => e.Status);

            var repos = await gitClient.GetRepositoriesAsync(releaseRequest.TeamProject);

            var prs = await gitClient.GetPullRequestsAsync(
                releaseRequest.TeamProject,
                repos.First(r => r.Name == releaseRequest.TeamProject).Id,
                new GitPullRequestSearchCriteria { Status = PullRequestStatus.Active, SourceRefName = branch });

            foreach (var pr in prs)
            {
                var iterations = await gitClient.GetPullRequestIterationsAsync(pr.Repository.Id, pr.PullRequestId);

                var id = iterations.Last(i => i.SourceRefCommit.CommitId == build.SourceVersion).Id;

                foreach (var env in envStatus)
                {
                    var prStatus = new GitPullRequestStatus
                    {
                        State       = GetEnvState(env.Value),
                        Description = $"Deploy {env.Key} {env.Value}",
                        TargetUrl   = (release.Links.Links["web"] as ReferenceLink)?.Href,
                        Context     = new GitStatusContext {
                            Genre = "release", Name = env.Key
                        }
                    };

                    if (id != null)
                    {
                        prStatus.Description = $"Update {id.Value}: {prStatus.Description}";
                        await gitClient.CreatePullRequestIterationStatusAsync(prStatus, pr.Repository.Id, pr.PullRequestId, id.Value);
                    }
                }

                if (envStatus.All(e => GetEnvState(e.Value) == GitStatusState.Succeeded))
                {
                    var prStatus = new GitPullRequestStatus
                    {
                        State       = GitStatusState.Succeeded,
                        Description = $"Last Complete Deploy: Update {id}",
                        TargetUrl   = (release.Links.Links["web"] as ReferenceLink)?.Href,
                        Context     = new GitStatusContext {
                            Genre = "release", Name = "lastComplete"
                        }
                    };

                    await gitClient.CreatePullRequestStatusAsync(prStatus, releaseRequest.TeamProject, pr.Repository.Id, pr.PullRequestId).ConfigureAwait(false);
                }
            }
        }
Ejemplo n.º 16
0
        public static async Task <GitPullRequestStatus> AddToPullRequest(VssConnection connection, Guid repositoryId,
                                                                         int pullRequestId, GitPullRequestStatus status)
        {
            var gitClient = connection.GetClient <GitHttpClient>();

            return(await gitClient.CreatePullRequestStatusAsync(
                       status,
                       repositoryId,
                       pullRequestId));
        }
Ejemplo n.º 17
0
        public async Task Check(string projectId, string repoId, int pullRequestId, Dictionary <string, string> args = null)
        {
            try
            {
                _logger.LogInformation($"[{nameof(Check)}] START {{pullRequestId:{pullRequestId}}}");
                GitHttpClient gitClient = _connection.GetClient <GitHttpClient>();
                var           resState  = GitStatusState.NotApplicable;
                string        description;

                var pr = await gitClient.GetPullRequestByIdAsync(projectId, pullRequestId);

                if (pr == null)
                {
                    _logger.LogWarning($"[{nameof(Check)}] GetPullRequestByIdAsync: PullRequest not found");
                    return;
                }

                var author = pr.CreatedBy.UniqueName;
                _logger.LogInformation($"[{nameof(Check)}] GetPullRequestByIdAsync(project:{projectId}, pullRequestId:{pullRequestId}) success: {{author:{author}}}");

                var reviewer = pr.Reviewers.FirstOrDefault(v => v.UniqueName == author);

                switch (reviewer?.Vote)
                {
                case 10:     // Approved
                case 5:      // Approved with suggestions
                {
                    resState    = GitStatusState.Succeeded;
                    description = "Готово для ревью";
                    break;
                }

                case 0:      // No vote
                {
                    resState    = GitStatusState.NotSet;
                    description = "Ожидает подтверждения автора";
                    break;
                }

                default:
                {
                    resState    = GitStatusState.NotSet;
                    description = "Готовность к ревью не подтверждена";
                    break;
                }
                }

                // New status
                var status = new GitPullRequestStatus()
                {
                    State       = resState,
                    Description = description,
                    Context     = new GitStatusContext()
                    {
                        Name  = "CheckAuthorReview",
                        Genre = "PullRequestCheckService"
                    }
                };
                _logger.LogInformation($"[{nameof(Check)}] created new status: " +
                                       $"{{pullRequestId:{pullRequestId}," +
                                       $"author:{author}," +
                                       $"status:{{" +
                                       $"state:{status.State}," +
                                       $"description:{status.Description},context:{{name:{status.Context.Name},genre:{status.Context.Genre}}}" +
                                       $"}}" +
                                       $"}}");
                // set PR status
                var prStatus = await gitClient.CreatePullRequestStatusAsync(status, repoId, pullRequestId);

                _logger.LogInformation($"[{nameof(Check)}] CreatePullRequestStatusAsync(status:{status}, repositoryId:{repoId}, pullRequestId:{pullRequestId}) success: {JsonConvert.SerializeObject(prStatus)}");
            }
            catch (Exception e)
            {
                _logger.LogError($"Check FAILED: {e.ToString()}");
            }
            finally
            {
                _logger.LogInformation($"[{nameof(Check)}] COMPLETED");
            }
        }
Ejemplo n.º 18
0
        public async Task Check(string projectId, string repoId, int pullRequestId, Dictionary <string, string> args = null)
        {
            try
            {
                const string evaluationConfigurationType = "Build";
                string artifactId(string projectId, int pullRequestId) => $"vstfs:///CodeReview/CodeReviewId/{projectId}/{pullRequestId}";

                string buildUrl   = $"{_config.URL}/{_config.Collection}/{projectId}/_build";
                string statusName = (args != null) && args.TryGetValue("name", out string name) ? name : "CheckCodeCoverage";

                _logger.LogInformation($"[{nameof(Check)}] BEGIN {{pullRequestId:{pullRequestId}}}");

                GitHttpClient    gitClient    = _connection.GetClient <GitHttpClient>();
                PolicyHttpClient policyClient = _connection.GetClient <PolicyHttpClient>();

                // получить политики для ПР
                var evaluations = await policyClient.GetPolicyEvaluationsAsync(projectId, artifactId(projectId, pullRequestId));

                _logger.LogInformation($"[{nameof(Check)}] GetPolicyEvaluationsAsync(project:{projectId}, artifactId:{artifactId(projectId, pullRequestId)}) success: {{evaluations count:{evaluations.Count}}}");

                var policy = evaluations.FirstOrDefault(x => x.Configuration.Settings.TryGetValue("statusName", out JToken name) &&
                                                        name.ToString().Equals(statusName, StringComparison.OrdinalIgnoreCase));

                // Если у полученного PullRequest не найдена политика для правила с заданным именем, то не создаем статуса.
                if (policy == null)
                {
                    _logger.LogInformation($"[{nameof(Check)}] SKIPPED. Pullrequest({pullRequestId}) has no this policy");
                    return;
                }

                var evaluation = evaluations.FirstOrDefault(x => x.Configuration.Type.DisplayName.Equals(evaluationConfigurationType, StringComparison.OrdinalIgnoreCase));
                _logger.LogInformation($"[{nameof(Check)}] build evaluation: {JsonConvert.SerializeObject(evaluation)}");

                var    resState = GitStatusState.NotApplicable;
                string description;
                string targetUrl;

                switch (evaluation?.Status)
                {
                case PolicyEvaluationStatus.Running:
                case PolicyEvaluationStatus.Queued:
                case PolicyEvaluationStatus.Rejected:
                {
                    var buildId = evaluation.Context?.Value <int>("buildId");
                    resState    = GitStatusState.NotSet;
                    description = "Ожидаение успешной сборки";
                    targetUrl   = buildId != null ? $"{buildUrl}/results?buildId={buildId}&view=results" : null;
                    break;
                }

                case PolicyEvaluationStatus.Approved:
                {
                    var buildId = evaluation.Context.Value <int>("buildId");
                    var cover   = await GetCodeCoverageForBuild(projectId, buildId);

                    int quality = 0;
                    if (args != null && args.TryGetValue("quality", out string qualityStr) && (cover != null))
                    {
                        if (!int.TryParse(qualityStr, out quality))
                        {
                            _logger.LogWarning(message: $"[{nameof(Check)}] param \"Quality\"({qualityStr}) is not parse to int");
                        }
                        resState = (quality <= cover)
                                    ? GitStatusState.Succeeded
                                    : GitStatusState.Error;
                    }
                    else
                    {
                        resState = GitStatusState.Succeeded;
                    }

                    description = cover != null ? $"CodeCoverage = {cover:F2}%" : "CodeCoverage = (не определен)";
                    targetUrl   = $"{buildUrl}/results?buildId={buildId}&view=results";
                    break;
                }

                case PolicyEvaluationStatus.NotApplicable:
                default:
                    resState    = GitStatusState.Succeeded;
                    description = "CodeCoverage = (Build not used)";
                    targetUrl   = null;
                    break;
                }
                // New status
                var status = new GitPullRequestStatus()
                {
                    State       = resState,
                    Description = description,
                    TargetUrl   = targetUrl,
                    Context     = new GitStatusContext()
                    {
                        Name  = statusName,
                        Genre = "PullRequestCheckService"
                    }
                };
                _logger.LogInformation($"[{nameof(Check)}] created new status: " +
                                       $"{{pullRequestId:{pullRequestId}," +
                                       $"status:{{" +
                                       $"state:{status.State}," +
                                       $"description:{status.Description},context:{{name:{status.Context.Name},genre:{status.Context.Genre}}}" +
                                       $"}}" +
                                       $"}}");

                // set PR status
                var prStatus = await gitClient.CreatePullRequestStatusAsync(status, repoId, pullRequestId);

                _logger.LogInformation($"[{nameof(Check)}] CreatePullRequestStatusAsync(status:{status}, repositoryId:{repoId}, pullRequestId:{pullRequestId}) success: {JsonConvert.SerializeObject(prStatus)}");
            }
            catch (Exception e)
            {
                _logger.LogError($"Check FAILED: {e.ToString()}");
            }
            finally
            {
                _logger.LogInformation($"[{nameof(Check)}] COMPLETED");
            }
        }