private PullRequestEvent CreatePullRequestEvent(string childTeam, WebhookRequest obj, Team team)
{
var pullRequestEvent = new PullRequestEvent()
{
Action = obj.Action,
Body = obj.PullRequest.Body,
CreatedAt = obj.PullRequest.CreatedAt,
Merged = obj.PullRequest.Merged,
MergedAt = obj.PullRequest.MergedAt,
MergedBy = obj.PullRequest.MergedBy.Login,
RepositoryName = obj.PullRequest.Head.Repo.Name,
Title = obj.PullRequest.Title,
MajorTeam = team.Name,
ChildTeam = team.ChildrenTeams?.FirstOrDefault(x => x.Name == childTeam)?.Name
};
pullRequestEvent.Labels = new List <Label>();
if (obj.PullRequest.Labels != null)
{
foreach (var labelRequest in obj.PullRequest.Labels.Where(x => x.Name.Contains("team:") == false))
{
var label = new Label()
{
Color = labelRequest.Color,
Name = labelRequest.Name
};
pullRequestEvent.Labels.Add(label);
}
}
return(pullRequestEvent);
}
public async Task StartExecutionIsCalled_ForPREvent()
{
var repoName = "name";
var sha = "sha";
var @ref = "ref";
var payload = new PullRequestEvent
{
PullRequest = new PullRequest
{
Head = new PullRequestHead
{
Sha = sha,
Ref = @ref,
}
},
Repository = new Repository
{
Name = repoName
}
};
var serializedPayload = Serialize(payload);
var stepFunctionsClient = Substitute.For <IAmazonStepFunctions>();
var logger = Substitute.For <ILogger <PipelineStarter> >();
var pipelineStarter = new PipelineStarter(stepFunctionsClient, logger);
await pipelineStarter.StartPipelineIfExists(payload);
var StateMachineArn = $"arn:aws:states:us-east-1:5:stateMachine:{repoName}-cicd-pipeline";
await stepFunctionsClient.Received().StartExecutionAsync(Arg.Is <StartExecutionRequest>(req =>
req.StateMachineArn == StateMachineArn &&
req.Name == sha &&
req.Input == serializedPayload
));
}
public async Task <IHttpActionResult> Submit([FromBody] PullRequestEvent pullRequestEvent)
{
if (pullRequestEvent == null)
{
return(BadRequest());
}
if (await _pullRequestService.SendMessage(pullRequestEvent))
{
return(Ok());
}
return(InternalServerError());
}
private async Task <bool> UpdatePrMessageAfterMerge(PullRequestEvent pullRequestEvent)
{
var success = false;
var timestamp = await _messageDatastore.GetPullRequestMessageTimeStamp(pullRequestEvent.PullRequestId,
pullRequestEvent.UserName);
var updateMessage = pullRequestEvent.MergedText("thomas");
var response = await _slackApi.Chat.Update("bot_testing", timestamp, updateMessage);
if (response.Ok)
{
success = await _messageDatastore.DeletePullRequestMessage(pullRequestEvent.PullRequestId, pullRequestEvent.UserName);
}
return(success);
}
private async Task <bool> SendPullRequestOpenedMessage(PullRequestEvent pullRequestEvent)
{
var success = false;
var text = pullRequestEvent.CreatedText();
var response = await _slackApi.Chat.PostMessage("bot_testing", text);
if (response.Ok)
{
var pullRequestMessage = new PullRequestMessage(pullRequestEvent.PullRequestId,
response.Ts,
pullRequestEvent.UserName);
success = await _messageDatastore.StorePullRequestMessage(pullRequestMessage);
}
return(success);
}
public async Task <bool> SendMessage(PullRequestEvent pullRequestEvent)
{
var success = false;
if (pullRequestEvent.Action == PullRequestAction.Opened)
{
success = await SendPullRequestOpenedMessage(pullRequestEvent);
}
else if (pullRequestEvent.Action == PullRequestAction.Closed && pullRequestEvent.PullRequest.Merged)
{
success = await UpdatePrMessageAfterMerge(pullRequestEvent);
}
else if (pullRequestEvent.Action == PullRequestAction.Reopened)
{
success = await SendPullRequestOpenedMessage(pullRequestEvent);
}
return(success);
}
private void Refresh(object sender, ElapsedEventArgs ea)
{
var json = httpSender.SendGet(ApiUrl);
var events = Newtonsoft.Json.JsonConvert.DeserializeObject <List <Event> >(json)
.Where(e => (e.type == "IssuesEvent" || e.type == "PullRequestEvent") && e.created_at.Ticks > lastReceivedTime)
.ToList();
foreach (var item in events.OrderBy(e => e.created_at))
{
lastReceivedTime = item.created_at.Ticks;
if (item.type == "IssuesEvent")
{
IssuesEvent.Invoke(item);
}
if (item.type == "PullRequestEvent")
{
PullRequestEvent.Invoke(item);
}
}
}
public async Task Handle_ShouldStartPipeline_ForAllPrEvents()
{
var requestValidator = Substitute.For <RequestValidator>();
var starter = Substitute.For <PipelineStarter>();
var deployer = Substitute.For <PipelineDeployer>();
var statusNotifier = Substitute.For <GithubStatusNotifier>();
var commitMessageFetcher = Substitute.For <GithubCommitMessageFetcher>();
var logger = Substitute.For <ILogger <Handler> >();
var handler = new Handler(requestValidator, starter, deployer, statusNotifier, commitMessageFetcher, config, logger);
var pushEvent = new PullRequestEvent
{
Repository = new Repository {
Name = repoName, DefaultBranch = "develop"
},
};
requestValidator.Validate(Any <ApplicationLoadBalancerRequest>()).Returns(pushEvent);
var response = await handler.Handle(new ApplicationLoadBalancerRequest { });
await starter.Received().StartPipelineIfExists(Is(pushEvent));
}
private object ConvertPayload()
{
switch (Event)
{
case PingEvent.EventString:
return(PingEvent.FromJson(PayloadText));
case CommitCommentEvent.EventString:
return(CommitCommentEvent.FromJson(PayloadText));
case CreateEvent.EventString:
return(CreateEvent.FromJson(PayloadText));
case DeleteEvent.EventString:
return(DeleteEvent.FromJson(PayloadText));
case DeploymentEvent.EventString:
return(DeploymentEvent.FromJson(PayloadText));
case DeploymentStatusEvent.EventString:
return(DeploymentStatusEvent.FromJson(PayloadText));
case ForkEvent.EventString:
return(ForkEvent.FromJson(PayloadText));
case GollumEvent.EventString:
return(GollumEvent.FromJson(PayloadText));
case InstallationEvent.EventString:
return(InstallationEvent.FromJson(PayloadText));
case InstallationRepositoriesEvent.EventString:
return(InstallationRepositoriesEvent.FromJson(PayloadText));
case IssueCommentEvent.EventString:
return(IssueCommentEvent.FromJson(PayloadText));
case IssuesEvent.EventString:
return(IssuesEvent.FromJson(PayloadText));
case LabelEvent.EventString:
return(LabelEvent.FromJson(PayloadText));
case MemberEvent.EventString:
return(MemberEvent.FromJson(PayloadText));
case MembershipEvent.EventString:
return(MembershipEvent.FromJson(PayloadText));
case MilestoneEvent.EventString:
return(MilestoneEvent.FromJson(PayloadText));
case OrganizationEvent.EventString:
return(OrganizationEvent.FromJson(PayloadText));
case OrgBlockEvent.EventString:
return(OrgBlockEvent.FromJson(PayloadText));
case PageBuildEvent.EventString:
return(PageBuildEvent.FromJson(PayloadText));
case ProjectCardEvent.EventString:
return(ProjectCardEvent.FromJson(PayloadText));
case ProjectColumnEvent.EventString:
return(ProjectColumnEvent.FromJson(PayloadText));
case ProjectEvent.EventString:
return(ProjectEvent.FromJson(PayloadText));
case PublicEvent.EventString:
return(PublicEvent.FromJson(PayloadText));
case PullRequestEvent.EventString:
return(PullRequestEvent.FromJson(PayloadText));
case PullRequestReviewEvent.EventString:
return(PullRequestReviewEvent.FromJson(PayloadText));
case PullRequestReviewCommentEvent.EventString:
return(PullRequestReviewCommentEvent.FromJson(PayloadText));
case PushEvent.EventString:
return(PushEvent.FromJson(PayloadText));
case ReleaseEvent.EventString:
return(ReleaseEvent.FromJson(PayloadText));
case RepositoryEvent.EventString:
return(RepositoryEvent.FromJson(PayloadText));
case StatusEvent.EventString:
return(StatusEvent.FromJson(PayloadText));
case WatchEvent.EventString:
return(WatchEvent.FromJson(PayloadText));
default:
throw new NotImplementedException(
$"Event Type: `{Event}` is not implemented. Want it added? Open an issue at https://github.com/promofaux/GithubWebhooks");
}
}
private static MattermostMessage GetMessagePullRequest(PullRequestEvent payload)
{
var retVal = BaseMessageForRepo(payload.repository.full_name);
MattermostAttachment att = null;
var repoMd = $"[{payload.repository.full_name}]({payload.repository.html_url})";
var titleMd =
$"[#{payload.pull_request.number} {payload.pull_request.title}]({payload.pull_request.html_url})";
var userMd = $"[{payload.sender.login}]({payload.sender.html_url})";
switch (payload.action)
{
case "opened":
retVal.Text = $"{userMd} opened a [new pull request]({payload.pull_request.html_url}) in {repoMd}";
if (!string.IsNullOrEmpty(payload.pull_request.body))
{
att = new MattermostAttachment
{
Title = $"#{payload.pull_request.number} {payload.pull_request.title}",
TitleLink = new Uri(payload.pull_request.html_url),
Text = payload.pull_request.body
}
}
;
break;
case "labeled":
retVal.Text = $"{userMd} added label: `{payload.label.name}` to {titleMd} in {repoMd}";
break;
case "unlabeled":
retVal.Text = $"{userMd} removed label: `{payload.label.name}` from {titleMd} in {repoMd}";
break;
case "closed":
retVal.Text = $"{userMd} closed pull request {titleMd} in {repoMd}";
break;
case "assigned":
var asignMd = $"[{payload.assignee.login}]({payload.assignee.html_url})";
retVal.Text = $"{userMd} assigned {asignMd} to {titleMd} in {repoMd}";
break;
case "unassigned":
var unasignMd = $"[{payload.assignee.login}]({payload.assignee.html_url})";
retVal.Text = $"{userMd} unassigned {unasignMd} from {titleMd} in {repoMd}";
break;
default:
throw new NotImplementedException($"Unhandled Event action: {payload.action}");
}
if (att != null)
{
retVal.Attachments = new List <MattermostAttachment>
{
att
}
}
;
return(retVal);
}
public void Insert(PullRequestEvent pullRequestEvent)
{
collection.InsertOne(pullRequestEvent);
}
private IEnumerable <Task> GetPullRequestEventTasks(PullRequestEvent prEvent)
{
yield return(pipelineStarter.StartPipelineIfExists(prEvent));
}
public async Task <IActionResult> FetchRepoInfo(long repoId)
{
ObjectId currentUser = ObjectId.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
var client = _githubClientService.GetGitHubClient(currentUser);
var mongoDb = _mongoService.GetDb;
var mongoSettings = _mongoService.GetDBSettings;
var repoCollection = mongoDb.GetCollection <Repository>(mongoSettings.ReposCollectionName);
var filterRepo = Builders <Repository> .Filter.Eq(r => r.Id, repoId);
var repo = (await repoCollection.FindAsync <Repository>(filterRepo)).FirstOrDefault();
var userCollection = mongoDb.GetCollection <Models.User>(mongoSettings.UserCollectionName);
var filterUser = Builders <Models.User> .Filter.Eq(u => u.Id, currentUser);
var user = (await userCollection.FindAsync <Models.User>(filterUser)).FirstOrDefault();
var branches = await _githubClientService.GetBranches(currentUser, repo);
var query = _neoContext.Cypher
.Unwind(branches, "branch")
.Match("(r:Repo {Id:" + repo.Id + "})")
.Merge("(b:Branch {Name: branch.Name})")
.OnCreate().Set("b.Name = branch.Name")
.Merge("(r)-[rel:HAS_BRANCH]->(b)")
;
var branchCreate = query.Query.DebugQueryText;
await query.ExecuteWithoutResultsAsync();
List <PullRequestEvent> pullRequestEvents = new List <PullRequestEvent>();
var gitEventsJsonArray = await _githubClientService.GetRepoEvents(user.GithubLogin, repo.Name, user.OAuthToken);
foreach (var a in gitEventsJsonArray)
{
var type = ((JValue)a["type"]).ToString();
var payload = ((JObject)a["payload"]);
var created = a.Value <DateTime>("created_at");
var createdString = created.ToString("yyyy-MM-dd") + "T" + created.ToString("HH:mm:ss") + "Z";
switch (type)
{
case "PushEvent":
var branch = payload["ref"].ToString();
var pom = branch.Split("/");
var branchName = pom[pom.Length - 1]; //
PushEvent pushEvent = new PushEvent
{
Id = ((JValue)a["id"]).ToString(),
Created = createdString
};
List <ComitPushNode> commits = new List <ComitPushNode>();
foreach (var c in (JArray)payload["commits"])
{
var commitAuthor = ((JObject)c["author"]);
ComitPushNode comitPushNode = new ComitPushNode
{
Sha = ((JValue)c["sha"]).ToString(),
Message = ((JValue)c["message"]).ToString(),
Author = commitAuthor["name"].ToString(),
Push_Id = pushEvent.Id
};
commits.Add(comitPushNode);
}
// add to Neo4J
var queryAddPush = _neoContext.Cypher
.Match("(r:Repo {Id: " + repo.Id + $" }})-[rel1:HAS_BRANCH]->(b:Branch {{Name: '{branchName}'}})")
.Merge($"(p:PushEvent {{Id:'{pushEvent.Id}'}})")
.OnCreate().Set($"p.Id = '{pushEvent.Id}'")
.Merge("(b)<-[rel2:PUSHED_TO]-(p)")
.Set($"rel2.Created = datetime('{pushEvent.Created}')")
;
var queryPushText = queryAddPush.Query.DebugQueryText;
await queryAddPush.ExecuteWithoutResultsAsync();
var queryCommitsImport = _neoContext.Cypher
.Unwind(commits, "commit")
.Match($"(p:PushEvent {{Id:'{pushEvent.Id}'}})")
.Merge("(c:CommitPush {Sha: commit.Sha})")
.OnCreate().Set("c.Sha = commit.Sha, c.Author = commit.Author, c.Message = commit.Message, c.Push_Id = commit.Push_Id")
.Merge("(p)-[rel:CONTAINS_COMMIT]->(c)")
;
var queryCommitsText = queryCommitsImport.Query.DebugQueryText;
await queryCommitsImport.ExecuteWithoutResultsAsync();
break;
case "PullRequestEvent":
var pullRequestInfo = (JObject)payload["pull_request"];
JObject headBranch = (JObject)pullRequestInfo["head"], baseBranch = (JObject)pullRequestInfo["base"];
PullRequestEvent pullRequestEvent = new PullRequestEvent
{
Id = ((JValue)a["id"]).ToString(),
Action = ((JValue)payload["action"]).ToString(),
CreatedAt = createdString,
Merged = (bool)pullRequestInfo["merged"],
PullRequestUrl = ((JValue)pullRequestInfo["url"]).ToString(),
BaseBranch = ((JValue)baseBranch["ref"]).ToString(),
HeadBranch = ((JValue)headBranch["ref"]).ToString()
};
if (pullRequestEvent.Action == "closed")
{
var queryPullRequest = _neoContext.Cypher
.Match($"(r {{Id: {repoId} }})-[:HAS_BRANCH]->(b1:Branch {{Name: '{pullRequestEvent.HeadBranch}'}})")
.Match($"(r)-[:HAS_BRANCH]->(b2:Branch {{Name: '{pullRequestEvent.BaseBranch}'}})")
.Merge($"(b1)-" +
$"[rel:MERGED_INTO {{Id: '{pullRequestEvent.Id}', " +
$"CreatedAt:datetime('{pullRequestEvent.CreatedAt}')}}]" +
$"->(b2)")
;
var queryPullRequestText = queryPullRequest.Query.DebugQueryText;
await queryPullRequest.ExecuteWithoutResultsAsync();
}
break;
default:
break;
}
}
await FetchIssues(repoId);
return(Ok());
}
