public override Task ExecuteAsync(string generator, WebHookHandlerContext context)
{
ZendeskPost post = context.GetDataOrDefault<ZendeskPost>();
// Implementation logic goes here
return Task.FromResult(true);
}
public override Task ExecuteAsync(string generator, WebHookHandlerContext context)
{
// For more information about Slack WebHook payloads, please see
// 'https://api.slack.com/outgoing-webhooks'
NameValueCollection entry = context.GetDataOrDefault<NameValueCollection>();
// We can trace to see what is going on.
Trace.WriteLine(entry.ToString());
// Switch over the IDs we used when configuring this WebHook
switch (context.Id)
{
case "trigger":
// Information can be returned using a SlackResponse
var triggerReply = new SlackResponse("Hello trigger!");
context.Response = context.Request.CreateResponse(triggerReply);
break;
case "slash":
// Information can be returned in a plain text response
context.Response = context.Request.CreateResponse();
context.Response.Content = new StringContent("Hello slash command!");
break;
}
return Task.FromResult(true);
}
/// <inheritdoc />
public override Task ExecuteAsync(string receiver, WebHookHandlerContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
string action = context.Actions.First();
JObject data = context.GetDataOrDefault<JObject>();
// Check if a payload is available
JToken payload;
if (data == null || !data.TryGetValue(PayloadPropertyName, out payload))
{
string msg = string.Format(CultureInfo.CurrentCulture, MyGetReceiverResources.Receiver_NoPayload, PayloadPropertyName);
context.RequestContext.Configuration.DependencyResolver.GetLogger().Error(msg);
context.Response = context.Request.CreateErrorResponse(HttpStatusCode.BadRequest, msg);
return Task.FromResult(true);
}
// Cast to correct payload type
switch (action)
{
case "PackageAddedWebHookEventPayloadV1": return ExecuteAsync(receiver, context, payload.ToObject<PackageAddedPayload>());
case "PackageDeletedWebHookEventPayloadV1": return ExecuteAsync(receiver, context, payload.ToObject<PackageDeletedPayload>());
case "PackageListedWebHookEventPayloadV1": return ExecuteAsync(receiver, context, payload.ToObject<PackageListedPayload>());
case "PackagePinnedWebHookEventPayloadV1": return ExecuteAsync(receiver, context, payload.ToObject<PackagePinnedPayload>());
case "PackagePushedWebHookEventPayloadV1": return ExecuteAsync(receiver, context, payload.ToObject<PackagePushedPayload>());
case "BuildQueuedWebHookEventPayloadV1": return ExecuteAsync(receiver, context, payload.ToObject<BuildQueuedPayload>());
case "BuildStartedWebHookEventPayloadV1": return ExecuteAsync(receiver, context, payload.ToObject<BuildStartedPayload>());
case "BuildFinishedWebHookEventPayloadV1": return ExecuteAsync(receiver, context, payload.ToObject<BuildFinishedPayload>());
}
return ExecuteUnknownPayloadAsync(receiver, context, (JObject)payload);
}
public override Task ExecuteAsync(string generator, WebHookHandlerContext context)
{
// For more information about Slack WebHook payloads, please see
// 'https://api.slack.com/outgoing-webhooks'
NameValueCollection entry = context.GetDataOrDefault<NameValueCollection>();
// We can trace to see what is going on.
Trace.WriteLine(entry.ToString());
// Switch over the IDs we used when configuring this WebHook
switch (context.Id)
{
case "disco":
var text = entry.Get("text");
if (string.IsNullOrEmpty(text) == false)
{
text = text.Trim().ToLowerInvariant();
_topicService.AddMessageToTopic(new TopicMessageModel()
{
Message = entry.Get("text").RemoveHtml(),
Sender = entry.Get("user_name"),
Disco = _globalSettings.DiscoTriggers.Any(discoTrigger => text.Contains(discoTrigger))
});
}
break;
}
return Task.FromResult(true);
}
public override Task ExecuteAsync(string generator, WebHookHandlerContext context)
{
// For more information about BitBucket WebHook payloads, please see
// 'https://confluence.atlassian.com/bitbucket/event-payloads-740262817.html#EventPayloads-Push'
JObject entry = context.GetDataOrDefault<JObject>();
// Extract the action -- for Bitbucket we have only one.
string action = context.Actions.First();
switch (action)
{
case "repo:push":
// Extract information about the repository
var repository = entry["repository"].ToObject<BitbucketRepository>();
// Information about the user causing the event
var actor = entry["actor"].ToObject<BitbucketUser>();
// Information about the specific changes
foreach (var change in entry["push"]["changes"])
{
// The previous commit
BitbucketTarget oldTarget = change["old"]["target"].ToObject<BitbucketTarget>();
// The new commit
BitbucketTarget newTarget = change["new"]["target"].ToObject<BitbucketTarget>();
}
break;
default:
Trace.WriteLine(entry.ToString());
break;
}
return Task.FromResult(true);
}
public override async Task ExecuteAsync(string receiver, WebHookHandlerContext context)
{
var client = Dependencies.Client;
var notifications = context.GetDataOrDefault<IEnumerable<InstagramNotification>>();
var repo = new UserRepository();
var user = await repo.GetUser("steve");
var config = Dependencies.GetConfig(context.Request.RequestUri);
var media = new Tags(config, new InstaSharp.Models.Responses.OAuthResponse
{
AccessToken = user.InstagramAccessToken,
User = new InstaSharp.Models.UserInfo
{
Username = "******"
}
});
var result = await media.Recent(notifications.First().ObjectId);
foreach (var image in result.Data)
{
hubContext.Value.Clients.All.showImage(image.Images.LowResolution.Url, image.User.Username, image.Caption.Text);
}
return;
}
/// <inheritdoc />
public override Task ExecuteAsync(string receiver, WebHookHandlerContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
string action = context.Actions.First();
JObject data = context.GetDataOrDefault<JObject>();
// map eventType to corresponding payload
switch (action)
{
case "workitem.updated": return ExecuteAsync(context, data.ToObject<WorkItemUpdatedPayload>());
case "workitem.restored": return ExecuteAsync(context, data.ToObject<WorkItemRestoredPayload>());
case "workitem.deleted": return ExecuteAsync(context, data.ToObject<WorkItemDeletedPayload>());
case "workitem.created": return ExecuteAsync(context, data.ToObject<WorkItemCreatedPayload>());
case "workitem.commented": return ExecuteAsync(context, data.ToObject<WorkItemCommentedOnPayload>());
case "message.posted": return ExecuteAsync(context, data.ToObject<TeamRoomMessagePostedPayload>());
case "tfvc.checkin": return ExecuteAsync(context, data.ToObject<CodeCheckedInPayload>());
case "build.complete": return ExecuteAsync(context, data.ToObject<BuildCompletedPayload>());
case "git.push": return ExecuteAsync(context, data.ToObject<GitPushPayload>());
case "git.pullrequest.created": return ExecuteAsync(context, data.ToObject<GitPullRequestCreatedPayload>());
case "git.pullrequest.updated": return ExecuteAsync(context, data.ToObject<GitPullRequestUpdatedPayload>());
default:
string msg = string.Format(CultureInfo.CurrentCulture, VstsReceiverResources.Handler_NonMappedEventType, action);
context.RequestContext.Configuration.DependencyResolver.GetLogger().Warn(msg);
return ExecuteAsync(context, data);
}
}
public override Task ExecuteAsync(string receiver, WebHookHandlerContext context)
{
string action = context.Actions.First();
JObject data = context.GetDataOrDefault<JObject>();
return AssignPendingToCommit(data);
}
public override Task ExecuteAsync(string generator, WebHookHandlerContext context)
{
// For more information about Dropbox WebHook payloads, please see
// 'https://www.dropbox.com/developers/reference/webhooks'
JObject entry = context.GetDataOrDefault<JObject>();
return Task.FromResult(true);
}
public override Task ExecuteAsync(string generator, WebHookHandlerContext context)
{
// For more information about GitHub WebHook payloads, please see
// 'https://developer.github.com/webhooks/'
JObject entry = context.GetDataOrDefault<JObject>();
return Task.FromResult(true);
}
public override Task ExecuteAsync(string receiver, WebHookHandlerContext context)
{
var action = context.Actions.First();
var obj = context.GetDataOrDefault<JObject>();
Storages.GetJObjectStorage().Save("github", obj);
return Task.FromResult(true);
}
public override Task ExecuteAsync(string receiver, WebHookHandlerContext context)
{
string action = context.Actions.First();
JObject data = context.GetDataOrDefault<JObject>();
WebApiApplication.GitHubMessage = (string)data["comment"]["body"];
return Task.FromResult(true);
}
public override Task ExecuteAsync(string receiver, WebHookHandlerContext context)
{
// Get JSON from WebHook
JObject data = context.GetDataOrDefault<JObject>();
// Get the action for this WebHook coming from the action query parameter in the URI
string action = context.Actions.FirstOrDefault();
return Task.FromResult(true);
}
public override Task ExecuteAsync(string generator, WebHookHandlerContext context)
{
// Get Form data from WebHook
// For more information about MailChimp WebHooks, please see 'https://apidocs.mailchimp.com/webhooks/'
NameValueCollection data = context.GetDataOrDefault<NameValueCollection>();
// Get the action for this WebHook coming from the action query parameter in the URI
string action = context.Actions.FirstOrDefault();
return Task.FromResult(true);
}
public override Task ExecuteAsync(string receiver, WebHookHandlerContext context)
{
// make sure we're only processing the intended type of hook
if("GitHub".Equals(receiver, System.StringComparison.CurrentCultureIgnoreCase))
{
string action = context.Actions.First();
JObject incoming = context.GetDataOrDefault<JObject>();
}
return Task.FromResult(true);
}
public override Task ExecuteAsync(string receiver, WebHookHandlerContext context)
{
// make sure we're only processing the intended type of hook
if("Dropbox".Equals(receiver, System.StringComparison.CurrentCultureIgnoreCase))
{
// todo: replace this placeholder functionality with your own code
string action = context.Actions.First();
JObject incoming = context.GetDataOrDefault<JObject>();
}
return Task.FromResult(true);
}
public override Task ExecuteAsync(string generator, WebHookHandlerContext context)
{
// Get data from WebHook
CustomNotifications data = context.GetDataOrDefault<CustomNotifications>();
// Get data from each notification in this WebHook
foreach (IDictionary<string, object> notification in data.Notifications)
{
// Process data
}
return Task.FromResult(true);
}
public override Task ExecuteAsync(string generator, WebHookHandlerContext context)
{
// For more information about Azure Kudu WebHook payloads, please see
// 'https://github.com/projectkudu/kudu/wiki/Web-hooks'
KuduNotification notification = context.GetDataOrDefault<KuduNotification>();
// Get the notification message
string message = notification.Message;
// Get the notification author
string author = notification.Author;
return Task.FromResult(true);
}
public override Task ExecuteAsync(string receiver, WebHookHandlerContext context)
{
if ("GitHub".Equals(receiver,StringComparison.CurrentCultureIgnoreCase))
{
string action = context.Actions.First();
var message = context.GetDataOrDefault<GitHubMessage>();
message.SetActivityType();
var activityToSave = message.ConvertToActivity();
repository.AddNewActivity(activityToSave);
}
return Task.FromResult(true);
}
public WebHookQueueHandlerTests()
{
_queueHandlerMock = new Mock<WebHookQueueHandler>() { CallBase = true };
_data = new object();
HttpConfiguration config = new HttpConfiguration();
HttpRequestContext context = new HttpRequestContext { Configuration = config, };
HttpRequestMessage request = new HttpRequestMessage();
request.SetRequestContext(context);
_context = new WebHookHandlerContext(_actions)
{
Data = _data,
Request = request
};
}
public override Task ExecuteAsync(string generator, WebHookHandlerContext context)
{
// Convert to POCO type
KuduNotification notification = context.GetDataOrDefault<KuduNotification>();
// Get the notification message
string message = notification.Message;
// Get the notification author
string author = notification.Author;
Trace.TraceInformation($"Author: {author}, message: {message}");
return Task.FromResult(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="WebHookQueueContext"/> with the given <paramref name="context"/>.
/// </summary>
/// <param name="receiver">The name of the <see cref="IWebHookReceiver"/> which processed the incoming WebHook. The
/// receiver can for example be <c>dropbox</c> or <c>github</c>.</param>
/// <param name="context">The <see cref="WebHookHandlerContext"/> instance for this WebHook.</param>
public WebHookQueueContext(string receiver, WebHookHandlerContext context)
{
if (receiver == null)
{
throw new ArgumentNullException("receiver");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
Receiver = receiver;
Data = context.Data;
_actions = context.Actions.ToList();
}
public override Task ExecuteAsync(string generator, WebHookHandlerContext context)
{
// For more information about Azure Alert WebHook payloads, please see
// 'https://azure.microsoft.com/en-us/documentation/articles/insights-webhooks-alerts/'
AzureAlertNotification notification = context.GetDataOrDefault<AzureAlertNotification>();
// Get the notification status
string status = notification.Status;
// Get the notification name
string name = notification.Context.Name;
// Get the name of the metric that caused the event
string author = notification.Context.Condition.MetricName;
return Task.FromResult(true);
}
public override Task ExecuteAsync(string generator, WebHookHandlerContext context)
{
// For more information about Slack WebHook payloads, please see
// 'https://api.slack.com/outgoing-webhooks'
NameValueCollection entry = context.GetDataOrDefault<NameValueCollection>();
// We can trace to see what is going on.
Trace.WriteLine(entry.ToString());
// Switch over the IDs we used when configuring this WebHook
switch (context.Id)
{
case "trigger":
MatchCollection matches = Regex.Matches(entry["text"], pattern);
var spreadsheetService = new GoogleDocService();
foreach (Match match in matches)
{
var insertItem = new Bill
{
Money = match.Groups["money"].Value,
ShopName = match.Groups["shopname"].Value,
Date = DateTime.ParseExact(DateTime.Today.Year + "/" + match.Groups["date"].Value, "yyyy/MM/dd", CultureInfo.InvariantCulture),
UserName = match.Groups["username"].Value
};
spreadsheetService.Insert(insertItem);
}
// Information can be returned using a SlackResponse
var triggerReply = new SlackResponse(
"Update Google SpreadSheet(RTBS 체크카드 사용 내역서)" +
Environment.NewLine +
"누적 " + spreadsheetService.GetTotalMoney() + "원");
context.Response = context.Request.CreateResponse(triggerReply);
break;
case "slash":
// Information can be returned in a plain text response
context.Response = context.Request.CreateResponse();
context.Response.Content = new StringContent("Hello slash command!");
break;
}
return Task.FromResult(true);
}
public override Task ExecuteAsync(string receiver, WebHookHandlerContext context)
{
// Get data from WebHook
CustomNotifications data = context.GetDataOrDefault<CustomNotifications>();
// Get data from each notification in this WebHook
foreach (IDictionary<string, object> notification in data.Notifications)
{
Storages.GetObjectStorage().Save(
"custom",
//data.Id,
Serialize(notification));
}
//var action = context.Actions.First();
//var obj = context.GetDataOrDefault<Object>();
return Task.FromResult(true);
}
public override Task ExecuteAsync(string receiver, WebHookHandlerContext context)
{
if ("GitHub".Equals(receiver, StringComparison.CurrentCultureIgnoreCase))
{
QueueManager queue = null;
try
{
queue = new QueueManager();
string actions = string.Join(", ", context.Actions);
JObject incoming = context.GetDataOrDefault<JObject>();
queue.WriteToQueueStorage("githubqueue", actions, incoming.ToString());
}
catch (Exception ex)
{
queue?.WriteToQueueStorage("githubqueue", "error", ex.Message);
}
}
return Task.FromResult<object>(null);
}
public override async Task ExecuteAsync(string generator, WebHookHandlerContext context)
{
// Convert the incoming data to a collection of InstagramNotifications
var notifications = context.GetDataOrDefault<InstagramNotificationCollection>();
// Get the config used by InstaSharp client
InstagramConfig config = Dependencies.InstagramConfig;
// Access media references in notifications
foreach (var notification in notifications)
{
// If we have an access token then get the media using InstaSharp.
OAuthResponse auth;
if (Dependencies.Tokens.TryGetValue(notification.UserId, out auth))
{
var media = new Media(config, auth);
MediaResponse mediaResponse = await media.Get(notification.Data.MediaId);
}
}
}
public override async Task ExecuteAsync(string generator, WebHookHandlerContext context)
{
// Get the WebHook client
InstagramWebHookClient client = Dependencies.Client;
// Convert the incoming data to a collection of InstagramNotifications
var notifications = context.GetDataOrDefault<IEnumerable<InstagramNotification>>();
foreach (var notification in notifications)
{
// Use WebHook client to get detailed information about the posted media
var entries = await client.GetRecentGeoMedia(context.Id, notification.ObjectId);
foreach (JToken entry in entries)
{
// Get direct links and sizes of media
var thumbnail = entry["images"]["thumbnail"].ToObject<InstagramMedia>();
var lowres = entry["images"]["low_resolution"].ToObject<InstagramMedia>();
var std = entry["images"]["standard_resolution"].ToObject<InstagramMedia>();
}
}
}
public override Task ExecuteAsync(string generator, WebHookHandlerContext context)
{
// For more information about Stripe WebHook payloads, please see
// 'https://stripe.com/docs/webhooks'
StripeEvent entry = context.GetDataOrDefault<StripeEvent>();
// We can trace to see what is going on.
Trace.WriteLine(entry.ToString());
// Switch over the event types if you want to
switch (entry.Type)
{
default:
// Information can be returned in a plain text response
context.Response = context.Request.CreateResponse();
context.Response.Content = new StringContent(string.Format("Hello {0} event!", entry.Type));
break;
}
return Task.FromResult(true);
}
public override async Task ExecuteAsync(string generator, WebHookHandlerContext context)
{
// Get the WebHook client
InstagramWebHookClient client = Dependencies.Client;
// Convert the incoming data to a collection of InstagramNotifications
var notifications = context.GetDataOrDefault<IEnumerable<InstagramNotification>>();
foreach (var notification in notifications)
{
logger.Debug("Received notification: " + notification.ObjectId);
// Use WebHook client to get detailed information about the posted media
var entries = await client.GetRecentGeoMedia(context.Id, notification.ObjectId);
foreach (JToken entry in entries)
{
logger.Debug("Object: " + entry.ToString());
InstagramPost post = entry.ToObject<InstagramPost>();
// Image information
if (post.Images != null)
{
InstagramMedia thumbnail = post.Images.Thumbnail;
InstagramMedia lowRes = post.Images.LowResolution;
InstagramMedia stdRes = post.Images.StandardResolution;
var InstImage = new InstagramImage();
InstImage.Address = stdRes.Address.ToString();
InstImage.Height = stdRes.Height;
InstImage.Width = stdRes.Width;
SaveImage(InstImage);
logger.Debug("Saved image: " + InstImage.Address);
}
}
}
}
/// <summary>
/// Executes the incoming WebHook request.
/// </summary>
/// <param name="receiver">The name of the <see cref="IWebHookReceiver"/> which processed the incoming WebHook. The
/// receiver can for example be <c>dropbox</c> or <c>github</c>.</param>
/// <param name="context">Provides context for the <see cref="IWebHookHandler"/> for further processing the incoming WebHook.</param>
/// <param name="payload">Strong-typed WebHook payload.</param>
public virtual Task ExecuteAsync(string receiver, WebHookHandlerContext context, PackageDeletedPayload payload)
{
return(Task.FromResult(true));
}
/// <inheritdoc />
public override Task ExecuteAsync(string receiver, WebHookHandlerContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var data = context.GetDataOrDefault <JObject>();
//check if data is available
if (data == null)
{
var message = "The WebHook request must contain a valid JSON payload.";
context.RequestContext.Configuration.DependencyResolver.GetLogger().Error(message);
context.Response = context.Request.CreateErrorResponse(HttpStatusCode.BadRequest, message);
return(Task.FromResult(true));
}
//the unix timestamp in milliseconds when the webhook was created. This allows detecting delayed webhooks if necessary.
var createdAt = data.Value <long?>(PusherConstants.EventRequestCreatedAtPropertyName);
if (!createdAt.HasValue)
{
var message = string.Format(CultureInfo.CurrentCulture, "The WebHook request must contain a '{0}' JSON property containing the unix timestamp in milliseconds when the webhook was created.", PusherConstants.EventRequestCreatedAtPropertyName);
context.RequestContext.Configuration.DependencyResolver.GetLogger().Error(message);
context.Response = context.Request.CreateErrorResponse(HttpStatusCode.BadRequest, message);
return(Task.FromResult(true));
}
var events = data.Value <JArray>(PusherConstants.EventRequestPropertyContainerName);
//check if data has events property
if (events == null)
{
var message = string.Format(CultureInfo.CurrentCulture, "The WebHook request must contain a '{0}' JSON property containing the events payload.", PusherConstants.EventRequestPropertyContainerName);
context.RequestContext.Configuration.DependencyResolver.GetLogger().Error(message);
context.Response = context.Request.CreateErrorResponse(HttpStatusCode.BadRequest, message);
return(Task.FromResult(true));
}
//iterate over events, needed for batch events support, see https://blog.pusher.com/batch-webhooks/
foreach (JObject @event in events)
{
var eventName = @event.Value <string>(PusherConstants.EventNamePropertyName);
switch (eventName)
{
case "channel_occupied":
var channelOccupiedPayload = @event.ToObject <ChannelOccupiedPayload>();
channelOccupiedPayload.CreatedAt = createdAt.Value;
ChannelOccupied(context, channelOccupiedPayload);
break;
case "channel_vacated":
var channelVacatedPayload = @event.ToObject <ChannelVacatedPayload>();
channelVacatedPayload.CreatedAt = createdAt.Value;
ChannelVacated(context, channelVacatedPayload);
break;
case "member_added":
var memberAddedPayload = @event.ToObject <MemberAddedPayload>();
memberAddedPayload.CreatedAt = createdAt.Value;
MemberAdded(context, memberAddedPayload);
break;
case "member_removed":
var memberRemovedPayload = @event.ToObject <MemberRemovedPayload>();
memberRemovedPayload.CreatedAt = createdAt.Value;
MemberRemoved(context, memberRemovedPayload);
break;
case "client_event":
var clientEventPayload = @event.ToObject <ClientEventPayload>();
clientEventPayload.CreatedAt = createdAt.Value;
ClientEvent(context, clientEventPayload);
break;
default:
var message = string.Format(CultureInfo.CurrentCulture, "The property 'name' contains unmapped value '{0}'.", eventName);
context.RequestContext.Configuration.DependencyResolver.GetLogger().Warn(message);
UnknownEvent(context, @event);
break;
}
}
return(Task.FromResult(true));
}
/// <summary>
/// Executes the incoming WebHook request for unknown event.
/// </summary>
/// <param name="context">Provides context for the <see cref="IWebHookHandler"/> for further processing the incoming WebHook.</param>
/// <param name="payload">JSON payload.</param>
public virtual void UnknownEvent(WebHookHandlerContext context, JObject payload)
{
}
/// <inheritdoc /> public abstract Task ExecuteAsync(string receiver, WebHookHandlerContext context);
public WebHookHandlerContextExtensionsTests()
{
_actions = new string[] { "a1", "a2" };
_context = new WebHookHandlerContext(_actions);
}
/// <summary>
/// Executes the incoming WebHook request for event '<c>message.posted</c>'.
/// </summary>
/// <param name="context">Provides context for the <see cref="IWebHookHandler"/> for further processing the incoming WebHook.</param>
/// <param name="payload">Strong-typed WebHook payload.</param>
public virtual Task ExecuteAsync(WebHookHandlerContext context, TeamRoomMessagePostedPayload payload)
{
return(Task.FromResult(true));
}
/// <summary>
/// Executes the incoming WebHook request for event '<c>workitem.deleted</c>'.
/// </summary>
/// <param name="context">Provides context for the <see cref="IWebHookHandler"/> for further processing the incoming WebHook.</param>
/// <param name="payload">Strong-typed WebHook payload.</param>
public virtual Task ExecuteAsync(WebHookHandlerContext context, WorkItemDeletedPayload payload)
{
return(Task.FromResult(true));
}
public override Task ExecuteAsync(string receiver, WebHookHandlerContext context)
{
throw new NotImplementedException();
}
/// <summary>
/// Executes the incoming WebHook request for unknown event.
/// </summary>
/// <param name="context">Provides context for the <see cref="IWebHookHandler"/> for further processing the incoming WebHook.</param>
/// <param name="payload">JSON payload.</param>
public virtual Task ExecuteAsync(WebHookHandlerContext context, JObject payload)
{
return(Task.FromResult(true));
}
/// <summary>
/// Executes the incoming WebHook request for event '<c>client_event</c>'.
/// </summary>
/// <param name="context">Provides context for the <see cref="IWebHookHandler"/> for further processing the incoming WebHook.</param>
/// <param name="payload">Strong-typed WebHook payload.</param>
public virtual void ClientEvent(WebHookHandlerContext context, ClientEventPayload payload)
{
}
/// <summary>
/// Executes the incoming WebHook request for an unknown payload.
/// </summary>
/// <param name="receiver">The name of the <see cref="IWebHookReceiver"/> which processed the incoming WebHook. The
/// receiver can for example be <c>dropbox</c> or <c>github</c>.</param>
/// <param name="context">Provides context for the <see cref="IWebHookHandler"/> for further processing the incoming WebHook.</param>
/// <param name="payload">Strong-typed WebHook payload.</param>
public virtual Task ExecuteUnknownPayloadAsync(string receiver, WebHookHandlerContext context, JObject payload)
{
return(Task.FromResult(true));
}
/// <summary>
/// Tries getting the <see cref="WebHookHandlerContext.Data"/> property as type <typeparamref name="T"/>.
/// </summary>
/// <typeparam name="T">The type to convert <see cref="WebHookHandlerContext.Data"/> to.</typeparam>
/// <param name="context">The <see cref="WebHookHandlerContext"/> to operate on.</param>
/// <param name="value">The converted value.</param>
/// <returns>An instance of type <typeparamref name="T"/> or <c>null</c> otherwise.</returns>
public static bool TryGetData <T>(this WebHookHandlerContext context, out T value)
where T : class
{
value = GetDataOrDefault <T>(context);
return(value != default(T));
}
/// <summary>
/// Executes the incoming WebHook request for event '<c>tfvc.checkin</c>'.
/// </summary>
/// <param name="context">Provides context for the <see cref="IWebHookHandler"/> for further processing the incoming WebHook.</param>
/// <param name="payload">Strong-typed WebHook payload.</param>
public virtual Task ExecuteAsync(WebHookHandlerContext context, CodeCheckedInPayload payload)
{
return(Task.FromResult(true));
}
/// <summary>
/// Executes the incoming WebHook request for event '<c>member_removed</c>'.
/// </summary>
/// <param name="context">Provides context for the <see cref="IWebHookHandler"/> for further processing the incoming WebHook.</param>
/// <param name="payload">Strong-typed WebHook payload.</param>
public virtual void MemberRemoved(WebHookHandlerContext context, MemberRemovedPayload payload)
{
}
/// <summary>
///
/// </summary>
/// <param name="context">rovides context for the <see cref="IWebHookHandler"/> for further processing the incoming WebHook.</param>
/// <param name="payload">Strong-typed WebHook payload.</param>
/// <returns></returns>
public virtual Task ExecuteAsync(WebHookHandlerContext context, GitPullRequestUpdatedPayload payload)
{
return(Task.FromResult(true));
}
/// <summary>
/// Executes the incoming WebHook request for event '<c>channel_vacated</c>'.
/// </summary>
/// <param name="context">Provides context for the <see cref="IWebHookHandler"/> for further processing the incoming WebHook.</param>
/// <param name="payload">Strong-typed WebHook payload.</param>
public virtual void ChannelVacated(WebHookHandlerContext context, ChannelVacatedPayload payload)
{
}
