.net - 使用 .Net WebHooks 作为 RESThooks 连接到 Zapier

Question

我正在考虑创建一个“Zap 应用程序”，并且想知道是否有人使用新的 .Net Webhooks 这样做了。他们似乎具有 RESTHooks 所要求的“模式”，即订阅/发布机制。它工作的例子并不多，我想在我花了几天时间实现它并发现它不兼容之前进行检查。

Hook 到 Zapier 的实际代码示例会很棒!

Answer 1

进行了一些研究，但我终于让 Zapier Rest Hooks 工作了。并不像我希望的那样直接(更有可能是我的吸收速度有点慢)。客户支持非常出色且友好，因此请不要犹豫，将您的问题通过电子邮件发送给他们。此外，一旦您开始使用它，它就会非常强大，尽管它们的正常 webhook 机制也可以工作并且不需要您创建 Zap 应用程序。在撰写本文时，我还没有推出该应用程序，尽管它正在本地运行。这假设您已经开始在开发人员仪表板中创建自己的 Zapier 应用程序。这很简单，所以我不会在这里介绍。

此解释仅涵盖创建单个触发器(尽管您创建了 1 个更私有(private)的触发器以支持用户身份验证，而我创建了另一个用于动态下拉目的)并且仅作为具有基本身份验证的 RESThook。基础知识是:

1. 创建网络钩子(Hook) 允许 Zapier 添加、更新和删除对您的操作的订阅。通过“订阅” Zapier 不必轮询您的 webhook，而是当订阅的操作发生在您这边时，您响应 Zapier 在订阅过程中提供给您的 URL。

2. 创建数据库表 记录这些订阅，存储您需要的数据，然后当您这边触发操作时，将响应发布回 Zapier 提供的 URL。

3. 当 Action 被触发时，识别并发布数据 你告诉zapier你会发送。 Zapier 非常聪明，它会为您映射数据(JSON 或 XML)，因此当连接到另一个应用程序时，用户可以在两者之间进行映射。

所以还有一些细节。这是在 .Net 上的 C# 中完成的，但我认为这些概念在任何其他语言或平台中都应该同样适用。

首先是 RESTHook。下面是 RESTHook 方法的示例。请注意，我花了几天时间试图弄清楚 Zapier 脚本方面，所以我对命名约定并不完全满意，但希望您能理解。

在这种情况下，有一个“表单”的概念，它是一块 JSON 保存我关心的数据，用户所属的用户和帐户。它们在系统中都有一个唯一的 ID。最后订阅本身有一个 id。当您订阅时，特定帐户中的特定用户正在订阅特定的表单，当特定的触发器(提交该表单)完成时，将发送给 Zapier。

REST钩子(Hook):

先是RouteConfig它将路径映射到要执行的方法。你可以看到我实现的所有方法。其中一些未使用，只是为了将来可能使用(例如更新订阅)而包含在内。

    // ZAPIER Webhooks
    routes.MapRoute(
       "User_Form_List",
       "api/zapier/user/formlist",
        new { controller = "Zapier", action = "RetrieveFormListForUser" },
        new { httpMethod = new HttpMethodConstraint("GET") }
        );
    routes.MapRoute(
       "Authenticate_Subscription",
       "api/zapier/authenticate",
        new { controller = "Zapier", action = "WebhookAuthenticate" },
        new { httpMethod = new HttpMethodConstraint("GET") }
        );
    routes.MapRoute(
        "Test_Subscription",
        "api/zapier/subscription/testdata",
        new { controller = "Zapier", action = "TestData" },
        new { httpMethod = new HttpMethodConstraint("GET") }
        );
    routes.MapRoute(
        "Create_Submission",
        "api/zapier/subscription/create",
        new { controller = "Zapier", action = "CreateSubscription" },
        new { httpMethod = new HttpMethodConstraint("GET") }
        );
    routes.MapRoute(
       "List_Subscriptions",
       "api/zapier/subscription",
       new { controller = "Zapier", action = "ListSubscriptions" },
       new { httpMethod = new HttpMethodConstraint("GET") }
       );
    routes.MapRoute(
       "Get_Subscriptions",
       "api/zapier/subscription/{id}",
       new { controller = "Zapier", action = "GetSubscription", id = 0 },
       new { httpMethod = new HttpMethodConstraint("GET") }
       );
    routes.MapRoute(
       "Update_Subscription",
       "api/zapier/subscription/{id}",
       new { controller = "Zapier", action = "UpdateSubscription", id = 0 },
       new { httpMethod = new HttpMethodConstraint("PUT") }
       );
    routes.MapRoute(
        "Delete_Subscription",
        "api/zapier/subscription/{id}",
        new { controller = "Zapier", action = "DeleteSubscription", id = 0 },
        new { httpMethod = new HttpMethodConstraint("DELETE") }
    );

与此相对应的代码是(我也拉出了错误处理以减少代码大小):

    public class ZapierController : BaseController //(this inherits from Controller)
    {
        private readonly IMyRepository _DBrepository;

        public ZapierController(IMyRepository repository, ...lots of other autowiring you don't need or care about)
            : base(logger)
        {
            _DBrepository = repository;
         }

        #region Zapier Subscriptions

        // api/zapier/subscription/create  : Creates a subscription
        [HttpGet]
        public ActionResult CreateSubscription()
        {
            ApiResult authresult = Authenticate();
            if (authresult.code != 201)
            {
                return JsonApiResult(authresult);
            }

            // Get the request parameters
            var reqParams = GetParameters();

            // Create the subscription so long as it does not already exist
            WebhookSubscription sub = new WebhookSubscription();
            // _currentUser and _currentAccount are set as part of the authenticate and stored in our base controller
            sub.AccountId = _currentAccount.Id;
            sub.UserId = _currentUser.UserId;
            sub.TargetURL = reqParams["target_url"];
            sub.EventType = reqParams["target_event"];
            sub.FormId = Int32.Parse(reqParams["form_id"]);
            sub.IsActive = true;

            ObjectResult workflowActionRecord = _DBrepository.createWebhookSubscription(sub);
            sub.Id = workflowActionRecord.objectId;

            // return the subscription back to Zapier in the result. Zapier will remember it
            var result = new ApiResult();
            result.data.id = workflowActionRecord.objectId;
            result.data.subscription = sub;
            result.code = 201;
            return JsonApiResult(result);
        }


        // api/zapier/authenticate  : used to test authentication
        [HttpGet]
        public ActionResult WebhookAuthenticate()
        {
            ApiResult authresult = Authenticate();

            var result = new ApiResult();
            result.code = 201;
            return JsonApiResult(result);
        }

        // api/zapier/user/formlist  : returns list of forms for this user
        [HttpGet]
        public ActionResult RetrieveFormListForUser()
        {
            ApiResult authresult = Authenticate();

            var result = new ApiResult();

            List<Form> forms = _DBRepository.FormListRetrieveByUser(_currentUser, false);

            JsonSerializer serializer = new JsonSerializer();
            serializer.Converters.Add(new JavaScriptDateTimeConverter());
            serializer.NullValueHandling = NullValueHandling.Ignore;

            // Again Zapier likes arrays returned
            JArray objarray = JArray.FromObject(forms);
            return JsonApiResultDynamic(objarray);
        }

        // api/zapier/subscription/testdata  : returns test data for zapier
        [HttpGet]
        public ActionResult TestData()
        {

            ApiResult authresult = Authenticate();

            var result = new ApiResult();

            JsonSerializer serializer = new JsonSerializer();
            serializer.Converters.Add(new JavaScriptDateTimeConverter());
            serializer.NullValueHandling = NullValueHandling.Ignore;

            // Get the request parameters
            var reqParams = GetParameters();
            int chosenFormId = -1;
            // We need the form Id to proceed
            if (reqParams != null && reqParams["form_id"] != null)
                chosenFormId = Int32.Parse(reqParams["form_id"]);
            else
                return  JsonApiResult(new ApiResult() { code = 403, error = "Form Id Not Found" });

            // Get the form by Form Id, and return the JSON...I have removed that code, but make sure the result is place in an Array
            var resultdata = new[] { myFinalFormJSON };

            JArray objarray = JArray.FromObject(resultdata);
            return JsonApiResultDynamic(objarray);
        }


        // api/zapier/subscription  : returns list of subscriptions by account
        [HttpGet]
        public ActionResult ListSubscriptions()
        {
            ApiResult authresult = Authenticate();

            // Get a list all subscriptions for the account
            List<WebhookSubscription> actionData = _DBrepository.accountWebhookSubscriptions(_currentAccount.Id);

            var result = new ApiResult();
            result.code = 201;
            result.data.subscriptions = actionData;
            return JsonApiResult(result);
        }

        // api/zapier/subscription/{id}  : Creates a subscription
        [HttpGet]
        public ActionResult GetSubscription(int id)
        {
            ApiResult authresult = Authenticate();

            // Get a list all subscriptions for the account
            WebhookSubscription actionData = _DBrepository.getWebhookSubscription(id);

            var result = new ApiResult();
            result.data.subscription = actionData; ;
            result.code = 201;
            return JsonApiResult(result);
        }

        // api/zapier/subscription/{id}  : updates a subscription
        [HttpPut]
        public ActionResult UpdateSubscription(int id)
        {
            ApiResult authresult = Authenticate();

            // get target url and eventy type from the body of request
            string jsonString = RequestBody();
            var json = CommonUtils.DecodeJson(jsonString);

            // Create the subscription so long as it does not already exist
            WebhookSubscription sub = _DBrepository.getWebhookSubscription(id);

            var result = new ApiResult();
            if (sub != null)
            {
                sub.TargetURL = json.target_url; ;
                sub.EventType = json.eventType;

                ObjectResult objResult = _DBrepository.updateWebhookSubscription(sub);
                result.code = 201;
            }

            return JsonApiResult(result);
        }



        // api/zapier/subscription/{id}  : deletes a subscription
        [HttpDelete]
        public ActionResult DeleteSubscription(int id)
        {
            ApiResult authresult = Authenticate();

            // Delete a subscription
            _DBrepository.deleteWebhookSubscription(id);

            var result = new ApiResult();
            result.code = 201;
            return JsonApiResult(result);
        }

        // We need to Basic Auth for each call to subscription
        public ApiResult Authenticate()
        {
            // get auth from basic authentication header
            var auth = this.BasicAuthHeaderValue();

            // parse credentials from auth
            var userCredentials = Encoding.UTF8.GetString(Convert.FromBase64String(auth));
            var parts = CommonUtils.SplitOnFirst(userCredentials, ":");
            var username = parts[0];
            var password = parts[1];

            // authenticate user against repository
            if (!_DBrepository.UserAuthenticate(username, password))
            {
                _logger.Info("Invalid Authentication: " + username);
                return new ApiResult() { code = 401, error = "invalid authentication" };
            }

            return new ApiResult() { code = 201, error = "successful authentication" };

        }
   }

将保存订阅的 DB 表如下所示。我将省略阅读和写作方面，因为您可能有不同的机制。

   Create.Table("WebhookSubscription")
        .WithColumn("Id").AsInt32().Identity().PrimaryKey().NotNullable()
        .WithColumn("AccountId").AsInt32().NotNullable()
        .WithColumn("UserId").AsInt32().NotNullable()
        .WithColumn("EventType").AsString(256).NotNullable()
        .WithColumn("TargetURL").AsString(1000).NotNullable()
        .WithColumn("IsActive").AsBoolean().NotNullable()
        .WithColumn("CreatedOn").AsDateTime().Nullable()
        .WithColumn("FormId").AsInt32().NotNullable().WithDefaultValue(0);
        .WithColumn("UpdatedAt").AsDateTime().Nullable();

为了清楚起见，以下列的含义/用途:

身份证 - 唯一订阅 ID。将用于退订

账户 ID - 订阅用户的帐户 ID。如果您希望所有这些都在帐户级别上工作，则可以这样做

用户 ID - 订阅用户的 ID

事件类型 - 您的操作要响应的事件类型，例如“new_form_submission”

目标网址 - 订阅时 zapier 给你的目标 URL。将是您在启动 Action 时发布 JSON 的位置

表单 ID - 提交时用户想要操作的表单的 ID

所以这就是订阅所需的代码(显然你不能把它扔在那里然后让它工作 - 为了节省空间而省略了很多)......

触发代码

剩下的唯一代码是实际的触发器代码 - 在代码中遇到要查找的事件时执行的代码。例如，当用户提交“表单”时，我们希望将该表单 JSON 发送给 Zapier。现在我们已经设置了所有其他代码，这部分非常简单。首先是检测我们收到需要 Zapier 响应的提交的代码:

查看表单提交是否已注册/订阅 Zapier 的实际代码:

public BusinessResult FormSubmitted(string jsonString)
{
    var json = CommonUtils.DecodeJson(jsonString);
    var account = _DBrepository.AccountRetrieveById(_currentUser.AccountId.Value); // Assumes user has bee authenticated


    // inject additional meta data into json and retrieve submission/alert settings
    var form = _DBformRepository.FormRetrieveById((int)json.formId);

    // Lookup Subscription Webhooks
    List<WebhookSubscription>  subscriptions = _DBrepository.accountWebhookSubscriptions(account.Id);
    if (subscriptions != null && subscriptions.Count > 0)
    {
        foreach (WebhookSubscription sub in subscriptions)
        {
            if (sub.EventType.Equals("new_form_submission") && sub.FormId == form.Id)
            {
                _webhookService.NewFormSubmission(sub, jsonString, form.Name, account.Name, account.Id);
            }
        }
    }
}

最后是将该响应发布回 Zapier 的代码，Zapier 将解析 JSON 并将其发送给适当的各方:

public class WebhookService : IWebhookService
{
    protected readonly IRepository _DBrepository;

    public WebhookService(IRepository repository)
    {
        _DBrepository = repository;
    }

    public void NewFormSubmission(string formResultJSON)
    {
        throw new NotImplementedException();
    }

    public void NewFormSubmission(WebhookSubscription subscription, string formResultJSON, string formName, string accountName, int accountId)
    {
        // Now post to webhook URL
        string response; 
        using (var client = new WebClient())
        {
            client.Headers[HttpRequestHeader.ContentType] = "application/json";
            // Needs to be an array sent to Zapier
            response = client.UploadString(subscription.TargetURL, "POST", "[" + formResultJSON + "]");
        }
    }
}

好的，这应该可以让您完成大部分工作。但是将代码/网络钩子(Hook)连接到 Zapier 的地方变得有点困难。现在的想法是使用开发仪表板将上面的代码连接到您的 Zapier 应用程序中。您必须开始创建 Zapier 应用程序。您需要两个主要触发器 - 您尝试实现的基本操作(在本例中为“新表单提交”)和身份验证，因此 Zapier 可以在用户创建 Zap 时对其进行身份验证(在本例中为“测试身份验证”) .我正在使用基本身份验证，但支持其他身份验证(OAuth 等)。此外，我添加了一个触发器，它将返回用户有权访问的表单列表。由于不是必需的，因此我不会在屏幕截图中显示该实现:


我不会显示“测试身份验证”的接线，因为它进行得很顺利(如果有人要求，我会添加它 - 天知道是否有人会读到这个)。所以这是“新表格提交”的逐页接线:

第 1 页



第2页

这是我连接表单列表的地方，它提供了创建 Zap 的用户可以从中选择的表单列表。除非您有要显示的动态数据，否则您可能可以跳过此步骤(将其留空)。为了完整起见，我已将其包括在内:


第 3 页

在这里你连接测试数据



第 4 页

此页面允许您输入示例数据。跳过这个，因为它非常简单。

脚本API

所以现在你已经连接了你的第一个 Zap Trigger!但是等等，我们还没有完成。为了使订阅过程工作，我们需要添加一些脚本。这是整个过程中最难的部分，不是很直观。所以在原来的主屏幕上，向下一点你会看到 脚本 API :



现在您必须拥有 RESTHook 订阅的脚本。我不会详细介绍，因为 Zapier 确实有这方面的文档，但很高兴知道 Zapier 确实将数据存储为订阅的一部分。在此之后，我们还需要再做一个接线步骤......

var Zap = {
    pre_subscribe: function(bundle) {
        bundle.request.method = 'GET';
        bundle.request.headers['Content-Type'] = 'application/x-www-form-urlencoded';
        bundle.request.params = {
            target_url: bundle.subscription_url,
            target_event:bundle.event,
            form_id:bundle.trigger_fields.form_id
        };
        bundle.request.data = $.param({
            target_url: bundle.subscription_url,
            target_event:bundle.event,
            form_id:bundle.trigger_fields.form_id
        });
        return bundle.request;
    },
    post_subscribe: function(bundle) {
        // must return a json serializable object for use in pre_unsubscribe
        var data = JSON.parse(bundle.response.content);
        // we need this in order to build the {{webhook_id}}
        // in the rest hook unsubscribe url
        return {webhook_id: data.id};
    },
    pre_unsubscribe: function(bundle) {
        bundle.request.method = 'DELETE';
        bundle.request.data = null;
        return bundle.request;
    },
    new_form_submission_pre_poll: function(bundle) { 
        bundle.request.method = 'GET';
        bundle.request.headers['Content-Type'] = 'application/x-www-form-urlencoded';
        bundle.request.params = bundle.trigger_fields;
        bundle.request.data = $.param({
            form_id:bundle.trigger_fields.form_id
        });
        return bundle.request;
    }
};

这有点……但是看看 Zapier 文档，它应该会有所帮助。或者在这里发布问题，我会尽力回答……这比我预期的要大!

管理触发器设置

最后，我们需要完成订阅的接线......



然后我们设置了我们之前创建的 RESTHook 方法:



就是这样。希望这会为某人节省一些时间和学习类(class)!