public WebHookRepository(WebHookContext context = null)
{
if (WebHookContext == null)
{
WebHookContext = new WebHookContext();
}
}
public override void ProcessMessage(WebHookContext context)
{
var response = context.Response;
StringBuilder builder = new StringBuilder();
builder.Append("Here's my info!");
builder.Append("\r\n");
builder.Append("OS Version: ");
builder.Append(Environment.OSVersion.ToString());
builder.Append("\r\n");
builder.Append("Processors: ");
builder.Append(Environment.ProcessorCount);
builder.Append("\r\n");
builder.Append("Machine Name: ");
builder.Append(Environment.MachineName);
builder.Append("\r\n");
builder.Append(".NET Version: ");
builder.Append(Environment.Version.ToString());
//builder.Append("\r\n");
//builder.Append("Memory used: ");
//builder.Append(Environment.WorkingSet);
builder.Append("\r\n");
builder.Append("Uptime: ");
builder.Append(new TimeSpan(0, 0, 0, 0, Environment.TickCount).ToString());
response.Values.Add("Response", builder.ToString());
}
/// <summary>
/// Demonstrates binding to <see cref="WebHookContext"/> which enables you to
/// control the response returned.
/// </summary>
public static void HookD([WebHookTrigger] WebHookContext context)
{
context.Response = new HttpResponseMessage(HttpStatusCode.Accepted)
{
Content = new StringContent("Custom Response!")
};
}
public async Task SlackIniatedWebHook([WebHookTrigger("packer/webhook")] WebHookContext context, [Queue("PackerWork")] ICollector <SlackWork> messages)
{
string body = await context.Request.Content.ReadAsStringAsync();
context.Response = new HttpResponseMessage(HttpStatusCode.Accepted);
context.Response.Content = new StringContent("Message received! Hello world!");
}
public WebHookRequestValueBinder(ParameterInfo parameter, WebHookContext context, string invokeString)
: base(parameter)
{
_parameter = parameter;
_context = context;
_invokeString = invokeString;
}
public static void CustomResponse_Success([WebHookTrigger] WebHookContext context)
{
InvokeData = context;
context.Response = new HttpResponseMessage(HttpStatusCode.Accepted)
{
Content = new StringContent("Custom Response Data")
};
}
public void Execute(IExecutionRequest request)
{
var context = new WebHookContext(
request.Adapter,
null,
request.GetDataSource<HttpListenerContext>());
_contextCallback(context);
}
public static void CustomResponse_Failure([WebHookTrigger] WebHookContext context)
{
InvokeData = context;
context.Response = new HttpResponseMessage(HttpStatusCode.NotImplemented)
{
Content = new StringContent("Does Not Compute!")
};
throw new Exception("Kaboom!");
}
public async Task CustomResponse_Failure_ReturnsExpectedResponses()
{
string testData = Guid.NewGuid().ToString();
HttpResponseMessage response = await _fixture.Client.PostAsync("WebHookTestFunctions/CustomResponse_Failure", new StringContent(testData));
Assert.Equal(HttpStatusCode.NotImplemented, response.StatusCode);
WebHookContext context = (WebHookContext)WebHookTestFunctions.InvokeData;
string result = await context.Response.Content.ReadAsStringAsync();
Assert.Equal("Does Not Compute!", result);
}
// Workflow via Slack
public async Task SlackIniatedWebHook([WebHookTrigger("slack/webhook")] WebHookContext context,
[Queue("SlackWork")] ICollector <SlackWork> messages
)
{
// Try and parse the Slack Message Body with simple helper method
NameValueCollection nvc;
if (TryParseSlackBody(await context.Request.Content.ReadAsStringAsync(), out nvc))
{
Regex rgx = new Regex("(\\d+) (\\d+)");
Match match = rgx.Match(nvc["text"]);
int count;
int work;
if (int.TryParse(match.Groups[1].Value, out count) && int.TryParse(match.Groups[2].Value, out work))
{
for (int i = 0; i < count; i++)
{
messages.Add(new SlackWork {
id = i, work = work, replyUrl = nvc["response_url"], username = nvc["user_name"]
});
}
// All good, quickly send an affirmative response
context.Response = new HttpResponseMessage(HttpStatusCode.Accepted)
{
Content = new StringContent("Message received! Processing ...")
};
}
else
{
// Not good, quick send a negative response
context.Response = new HttpResponseMessage(HttpStatusCode.Accepted)
{
Content = new StringContent("Incorrect format - please pass two numbers along - i.e. /cmd 2 30")
};
// We can stop here for the failure case
return;
}
}
else
{
// Not good, quick send a negative response
context.Response = new HttpResponseMessage(HttpStatusCode.Accepted)
{
Content = new StringContent("Something went wrong. :(")
};
// We can stop here for the failure case
return;
}
}
public override void ProcessMessage(WebHookContext context)
{
var request = context.Request;
var response = context.Response;
var database = context.Database;
var computer = context.Computer;
var user = context.User;
var responseText = new StringBuilder();
if (!request.Values.ContainsKey("NetworkAddress"))
{
response.ErrorMessage = "NetworkAddress not set";
return;
}
var networkAddress = request.Values["NetworkAddress"];
var network = database.Networks.Get(user, networkAddress);
if (network == null)
{
//responseText.Append("Adding network '" + networkAddress + "'");
network = Network.Create(networkAddress, user, networkAddress);
database.Networks.Add(network);
}
computer.UpdatePing();
database.Computers.Update(computer);
network.UpdatePing(computer);
database.Networks.Update(network);
//responseText.Append("network: " + network);
var sentDevices = ProcessSentDevices(request, response, user, network, database).ToList();
var existingDevices = database.Devices.Get(network);
UpdateDevices(sentDevices, existingDevices, network, database);
var devicesToRemove = GetRemovedDevices(sentDevices, existingDevices);
RemoveDevices(devicesToRemove, database);
AddDevicesToResponse(response, existingDevices);
response.Values.Add("Response", responseText.ToString());
}
public override object GetValue()
{
if (_parameter.ParameterType == typeof(HttpRequestMessage))
{
return(_request);
}
else if (_parameter.ParameterType == typeof(WebHookContext))
{
// when binding to WebHookContext, we add the context to the request
// property bag so we can pull it out later in the WebHookDispatcher to access
// the response value, etc.
WebHookContext context = new WebHookContext(_request);
_request.Properties.Add(WebHookContextRequestKey, context);
return(context);
}
return(base.GetValue());
}
public async Task <ITriggerData> BindAsync(object value, ValueBindingContext context)
{
HttpRequestMessage request = value as HttpRequestMessage;
WebHookContext webHookContext = value as WebHookContext;
if (request == null && webHookContext != null)
{
request = webHookContext.Request;
}
if (request == null && value != null && value.GetType() == typeof(string))
{
// We've received an invoke string (e.g. from a Dashboard replay/invoke
// so convert to a request
request = FromInvokeString((string)value);
}
if (webHookContext == null)
{
webHookContext = new WebHookContext(request);
}
IValueProvider valueProvider = null;
IReadOnlyDictionary <string, object> bindingData = null;
string invokeString = ToInvokeString(request);
if (_isUserTypeBinding)
{
valueProvider = await CreateUserTypeValueProvider(request, invokeString);
if (_bindingDataProvider != null)
{
// the provider might be null if the Type is invalid, or if the Type
// has no public properties to bind to
bindingData = _bindingDataProvider.GetBindingData(valueProvider.GetValue());
}
}
else
{
valueProvider = new WebHookRequestValueBinder(_parameter, webHookContext, invokeString);
}
return(new TriggerData(valueProvider, bindingData));
}
public async Task DirectInvoke_Succeeds()
{
string testData = Guid.NewGuid().ToString();
HttpRequestMessage request = new HttpRequestMessage
{
RequestUri = new Uri(string.Format("{0}{1}", _fixture.BaseUrl, "WebHookTestFunctions/CustomResponse_Success")),
Method = HttpMethod.Get,
Content = new StringContent(testData)
};
WebHookContext webHookContext = new WebHookContext(request);
MethodInfo method = typeof(WebHookTestFunctions).GetMethod("CustomResponse_Success");
await _fixture.Host.CallAsync(method, new { context = webHookContext });
HttpResponseMessage response = webHookContext.Response;
Assert.Equal(HttpStatusCode.Accepted, response.StatusCode);
string body = await response.Content.ReadAsStringAsync();
Assert.Equal("Custom Response Data", body);
}
public override void ProcessMessage(WebHookContext context)
{
var request = context.Request;
var response = context.Response;
var database = context.Database;
var user = context.User;
var computer = context.Computer;
if (!request.Values.ContainsKey("TargetComputerName"))
{
response.ErrorMessage = "Target Computer Name not set.";
return;
}
if (!request.Values.ContainsKey("ScriptText"))
{
response.ErrorMessage = "ScriptText not set";
return;
}
var targetComputer = database.Computers.Get(user, request.Values["TargetComputerName"]);
if(targetComputer == null)
{
response.ErrorMessage = "Could not find computer \"" + request.Values["TargetComputerName"] + "\".";
return;
}
var script = Script.Create(false, request.Values["ScriptText"]);
database.Scripts.Add(script);
var task = Task.Create(user, "WebHook, " + computer.Name, targetComputer, script);
database.Tasks.Add(task);
response.Values.Add("Response", "Script queued for delivery to " + targetComputer.Name);
}
private async Task <HttpResponseMessage> ProcessRequest(HttpRequestMessage request)
{
// First check if we have a WebHook function registered for this route
string routeKey = request.RequestUri.LocalPath.ToLowerInvariant();
ITriggeredFunctionExecutor executor = null;
HttpResponseMessage response = null;
if (!_functions.TryGetValue(routeKey, out executor))
{
if (request.Method != HttpMethod.Post)
{
return(new HttpResponseMessage(HttpStatusCode.MethodNotAllowed));
}
// No WebHook function is registered for this route
// See see if there is a job function that matches based
// on name, and if so invoke it directly
response = await TryInvokeNonWebHook(routeKey, request);
}
else
{
// Define a function to invoke the job function that we can reuse below
Func <HttpRequestMessage, Task <HttpResponseMessage> > invokeJobFunction = async(req) =>
{
TriggeredFunctionData data = new TriggeredFunctionData
{
TriggerValue = req
};
FunctionResult result = await executor.TryExecuteAsync(data, CancellationToken.None);
object value = null;
if (request.Properties.TryGetValue(WebHookTriggerBinding.WebHookContextRequestKey, out value))
{
// If this is a WebHookContext binding, see if a custom response has been set.
// If so, we'll return that.
WebHookContext context = (WebHookContext)value;
if (context.Response != null)
{
response = context.Response;
response.RequestMessage = request;
}
}
if (response != null)
{
return(response);
}
else
{
return(new HttpResponseMessage(result.Succeeded ? HttpStatusCode.OK : HttpStatusCode.InternalServerError));
}
};
// See if there is a WebHookReceiver registered for this request
// Note: receivers will do their own HttpMethod validation (e.g. some
// support HEAD/GET/etc.
response = await _webHookReceiverManager.TryHandle(request, invokeJobFunction);
if (response == null)
{
if (request.Method != HttpMethod.Post)
{
return(new HttpResponseMessage(HttpStatusCode.MethodNotAllowed));
}
// No WebHook receivers have been registered for this request, so dispatch
// it directly.
response = await invokeJobFunction(request);
}
}
return(response);
}
public static void CustomResponse_NoResponseSet([WebHookTrigger] WebHookContext context)
{
InvokeData = context;
// intentionally don't set a response
}
public TemplateNotificationRepository(WebHookContext context)
{
_context = context;
}
public override void ProcessMessage(WebHookContext context, Message request, Message response)
{
if (!request.Values.ContainsKey("HomeID"))
{
response.ErrorMessage = "Home ID not set.";
return;
}
//read input
uint homeId;
try
{
homeId = Convert.ToUInt32(request.Values["HomeID"]);
}
catch
{
response.ErrorMessage = "Error parsing input. (1283)";
return;
}
var database = context.Database;
var computer = context.Computer;
var user = context.User;
var network = (from n in database.HomeAutomationNetwork
where
//n.HomeId == homeId &&
n.Owner.Id == user.Id
select n).First();
// database.ZWaveNetworks
//.FirstOrDefault(n => n.HomeId == homeId && n.Owner.Id == user.Id);
if (network == null)
{
response.ErrorMessage = "ZWave network with Home ID " + homeId + " not found.";
return;
}
network.AttatchedComputer = computer;
network.UpdatePing();
StringBuilder builder = new StringBuilder();
builder.Append("<DeviceList>");
foreach (var device in network.Devices)
{
builder.Append("<Device Address=\"");
builder.Append(device.Address);
builder.Append("\" DeviceName=\"");
builder.Append(device.Name);
builder.Append("\" DeviceType=\"");
builder.Append(device.Type);
builder.Append("\" />");
}
try
{
builder.Append("</DeviceList>");
response.Payload.Add(XmlUtilities.StringToXml(builder.ToString()));
}
catch (XmlException)
{
response.ErrorMessage = "Error building response XML. (8472)";
return;
}
try
{
response.Values.Add("Response", network.Devices.Count + " devices sent");
}
catch
{
response.ErrorMessage = "Server error: exception parsing XML. (error code 19382)";
}
}
public override void ProcessMessage(WebHookContext context)
{
var response = context.Response;
var computer = context.Computer;
var database = context.Database;
//TODO: how big can I make this?
// well, not as big as three minutes
DateTime endTime = DateTime.Now.AddSeconds(90);
Task[] tasks = null;
//tasks = new List<TaskModel>
//{
// new TaskModel
// {
// Script = new ScriptModel
// {
// Text = @"<Output.Speak Text=""Hello there!"" />"
// }
// }
//};
while ((tasks == null || tasks.Length == 0) && DateTime.Now <= endTime)
{
computer.UpdatePing();
database.Computers.Update(computer);
var now = DateTime.UtcNow;
try
{
tasks = database.Tasks.ForComputer(computer, now);
if (tasks.Length == 0)
{
System.Threading.Thread.Sleep(250);
}
}
catch (Exception exception)
{
response.ErrorMessage = "Exception while getting tasks: " + exception;
return;
}
}
//tasks have been found or the timer has run out
if (tasks == null || tasks.Length == 0)
{
response.Values.Add("Response", "no tasks.");
}
else
{
//add tasks to the response message and mark the tasks as sent
foreach (var task in tasks)
{
try
{
response.Payload.Add(
new XElement("Script",
new XAttribute("Text", task.Script.Text)
));
task.MarkAsReceived();
database.Tasks.Update(task);
}
catch
{ }
}
response.Values.Add("Response", "added " + tasks.Length + " task(s)");
}
}
