通过

语言参考指南

  • 项目

Microsoft Dynamics 365 有自己的丰富的表达语言，可帮助你定义和表达欺诈策略。 此语言与 C# 和 SQL 有很多相似之处，旨在提供应对独特业务方案欺诈所需的灵活性。

现在可以使用此语言来定义规则和速度。 有关详细信息，请参阅管理规则和执行速度检查。

此语言参考指南包含构成语言的运算符、函数和语句的完整列表：

本指南还介绍了其他文章。 以下是一些示例：

语句

语句语法 说明 示例
LET VariableName> = <表达式<>

LET 语句用于定义新变量。 变量的范围是在其中定义的规则或速度设置。 变量名称应以美元符号（$）作为前缀。

有关详细信息，请参阅 定义自己的变量。

可以在 Condition 节和所有规则类型和速度集的子句中使用任意数量的 LET 语句。

 LET $fullName = @"user.firstName" + @"user.lastName"

OB标准版RVE

OB标准版RVE ObservationFunction>（<KeyValuePairs>）<
[ WHEN <BooleanExpression>

]

OB标准版RVE 语句不会通过决策终止规则执行。 它只是将键值对记录到 API 响应或跟踪日志。 在达到 RETURN 语句之前，后续规则和规则子句将继续运行。

OB标准版RVE 语句后跟一个或多个观察函数。

如果存在 WHEN 子句且计算结果为 False，则不会记录 OB标准版RVE 语句。

以下规则中每个子句最多可以使用一个子句：

  • 购买规则
  • 自定义评估规则
  • 帐户保护规则

    OB标准版RVE 输出（reason=“high score”）

    OB标准版RVE TRACE（ip=@“device.ipAddress”） WHEN @"riskscore"> 400
    RETURN <DecisionFunction>
    [ ，<ObservationFunction>（<KeyValuePairs>） ]
    [ WHEN <BooleanExpression> ]

    RETURN 语句通过决策终止规则执行。

    该语句必须指定有效的决策函数：Approve（）、Reject（）、Challenge（）或 Review（）。

    该语句还可以指定一个或多个 观察函数： Output（） 或 Trace（）

    最后，该语句可以包含一个 WHEN 子句来指定它应执行上述任一操作的条件。

    在以下规则中，每个子句最多可以使用一个子句：

    • 购买规则
    • 自定义评估规则
    • 帐户保护规则

      RETURN Review（）
      WHEN IsWatch（“设备支持列表”， @"deviceAttributes.deviceId"） ||
      IsWatch（“付款支持列表”， @"paymentInstrumentList.merchantPaymentInstrumentId"）

      RETURN Reject（）， Trace（ip=@“device.ipAddress”） WHEN @"riskscore"> 400
      ROUTETO QUEUE <QueueName>
      [ WHEN <BooleanExpression> ]

      ROUTETO 命令用于路由规则，以将评估定向到案例管理队列。

      可选 WHEN 子句可用于描述命令应执行路由的条件。

      路由规则中每个子句最多可以使用一个子句。

      		 ROUTETO 队列（“高值队列”）
      WHEN @"purchase.request.totalAmount"> 500
      标准版LECT <AggregationFunction>
      AS <VelocityName>
      FROM <AssesmentType>
      GROUPBY <GroupExpression>
      [ WHEN <BooleanExpression> ]

      在速度集中使用 标准版LECT 语句来定义速度。 它必须指定 聚合函数。

      所需的 AS 子句用于为速度创建别名。 然后，可以从规则引用此别名。

      必需的 FROM 子句用于指定要观察速度的评估类型。 有效值为 Purchase、AccountLogin、AccountCreation、Chargeback、BankEvent 和 CustomAssessment。

      所需的 GROUPBY 子句指定属性或表达式。 将计算为 GROUPBY 语句中相同值的所有事件组合在一起，以计算在 标准版LECT 语句中请求的聚合。

      例如，若要计算每个用户的聚合，请使用 GROUPBY @"user.userId"。

      可选 WHEN 子句指定一个布尔表达式，该表达式确定正在处理的评估是否应包含在定义的速度中。

      速度集中每个子句最多可以使用一个子句。

      标准版LECT Count（） AS _Purchase_Rejections_Per_Email
      FROM Purchase
      WHEN @"ruleEvaluation.decision" == “Reject”
      GROUPBY @"user.email"

      标准版LECT DistinctCount（@“purchaseId”）
      AS _BankDeclines_Per_Device
      FROM BankEvent
      WHEN @"status" == “DECLINED”
      GROUPBY @"purchase.deviceContext.externalDeviceId"
      WHEN <BooleanExpression>

      WHEN 语句类似于其他语句上的 WHEN 子句，但它单独位于规则和速度集的 Condition 节中。 它指定一个布尔条件，用于确定是否应运行整个规则、速度集或路由规则。

      所有规则类型和速度集的“条件”部分最多可使用一个。

      		 WHEN @"riskscore"> 400
      DO <操作函数> DO 语句用于在规则执行结束时执行某些操作。 此语句只能在决策后操作中使用，后跟 Action 函数 DO SetResponse（name = @“firstname” + @“lastname”）

      决策函数

      决策函数在规则中用于指定决策。

      决策类型 说明 示例
      批准（）

      此类型指定批准的决定。 它可以包括审批的原因和另一条支持消息。

      重载：

      • 批准（字符串 原因）
      • 批准（字符串 原因，String supportMessage）

      RETURN Approve（）

      RETURN Approve（“on safe list”）

      RETURN Approve （“on safe list”， “do not escalate”）
      拒绝（）

      此类型指定拒绝的决定。 它可以包括拒绝的原因和另一条支持消息。

      重载：

      • Reject（字符串 原因）
      • Reject（字符串 原因，String supportMessage）

      RETURN Reject（）

      RETURN Reject（“禁运国家”）

      返回拒绝（“禁运国家”， “不升级”）
      评论（）

      此类型指定“审阅”决策。 它可以包括评审的原因和另一条支持消息。

      重载：

      • Review（字符串 原因）
      • Review（字符串 原因，String supportMessage）

      RETURN Review（）

      RETURN Review（“监视列表中的用户”）

      RETURN Review（“监视列表中的用户”、“请勿升级”）
      Challenge（String challengeType）

      此类型指定质询和 质询 类型的决策。 它还可能包括挑战的原因和另一条支持消息。

      重载：

      • Challenge（String challengeType，字符串 原因）
      • Challenge（String challengeType、String reason、String supportMessage）

      RETURN 质询 （“SMS”）

      RETURN 挑战（“SMS”、“可疑机器人”）

      RETURN Challenge （“SMS”， suspected bot“， ”do not escalate“）

      操作函数

      操作函数用于指定要在决策后操作规则中执行的操作。

      操作类型 说明 示例
      SetResponse（String sectionName， k=v）

      此函数可用于将键值对传递给 API 响应的 CustomProperties 部分。 可以为要进入的键值对指定子节 sectionName。

      重载：

      • SetResponse（k=v）

      SetResponse（“Scores”， bot = Model.Bot（@deviceContextId）， risk=Model.Risk（））

      SetResponse（test=“123”）

      观察函数

      观察函数可用于从当前上下文中获取数据，并将其写入其他位置。

      返回类型 说明 示例
      Output（k=v） 此函数可用于将键值对传递到 API 响应中。 Output（key=“test”， email=@“user.email”， countryRegion=Geo.CountryRegion（@“device.ipAddress”））
      Trace（k=v） 此函数可用于触发跟踪事件并将键值对发送到 FraudProtection.Trace.Rule 事件跟踪命名空间。 Trace（key=“Manual Review”， ip=@“device.ipAddress”）

      模型函数

      模型函数运行各种欺诈模型，在评估不会自动运行一个或多个欺诈模型时非常有用。 当模型函数运行时，有关在规则评估期间运行的模型的信息是在欺诈评估 API 调用中输出的。 然后，规则可以访问模型结果，包括分数、原因等，这些结果可用于进一步的规则处理和决策。

      模型类型 说明 示例
      风险 评估会话有风险的可能性。 Model.Risk（）
      聊天机器人 评估机器人启动会话的可能性。 传入发送到欺诈保护设备指纹解决方案的设备上下文 ID。 Model.Bot（@deviceContextId）

      Gibberish 检测函数

      这些函数通过快速高效地检测关键用户输入字段（如名称和地址）是否包含巨无奇来帮助防止欺诈。

      函数 说明 示例
      GetPattern（String）。maxConsonants 未用元音分隔的字符串中连续连续的连续连音的最大数量。 例如，字符串“01gggyturah”的 maxConsonants 为 5。 GetPattern（@“user.email”）。maxConsonants
      GetPattern（字符串）。gibberScore 基于 ML 的分数介于 0 和 1 之间;0 表示最有可能是胡言乱语，1 表示不太可能是胡言乱语。 GetPattern（@“user.email”）。gibberScore

      注意

      Gibberish 检测模型基于公开提供的英语文档中连续两个字母数字字符的频率。 假定公共文档中出现两个连续字母数字字符的频率越频繁，不太可能是乱字。 该模型应为英语文本提供合理的分数，并可用于检测姓名或地址是否包含乱字。 但是，模型可能不适合缩写，例如状态（AZ、TX 等）的短格式，也不能用于验证名称或地址。 最后，模型尚未针对非英语文本进行测试。

      设备属性函数

      运算符 说明 示例
      Device.GetAttributes（String sessionId） 从设备指纹返回选定的设备属性。 所选设备属性由欺诈保护进行策展，是规则中常用的一组属性。 Device.GetAttributes（@“deviceContext.deviceContextId）.attribute_name
      Device.GetFullAttributes（String sessionId） 从设备指纹返回一组完整的设备属性。 仅当需要访问完整的设备属性集时，才使用此函数。 若要查看完整的设备属性集，请参阅 “设置设备指纹”。 Device.GetFullAttributes（@“deviceFingerprinting.id”）.attribute_name

      引用属性和变量

      可以使用 at sign （@） 运算符从当前事件引用属性。

      变量 说明 示例
      @

      使用 at sign （@） 从传入事件引用属性。 该属性可以作为请求有效负载的一部分发送，也可以由 Microsoft Dynamics 365 欺诈保护生成。

      在符号 （@）之后，指定要引用的属性的完整路径。 将路径括在引号中（例如 @“address.city”）。

      如果引用的属性不是事件有效负载的一部分，则返回该类型的默认值：0.0 表示双精度值、字符串的空字符串等。

      属性的类型是从其使用的上下文推断的。 如果未提供足够的上下文， 则默认使用字符串 类型。

      有关类型推理的信息，请参阅 属性的类型推理。

      @“address.city”
      $ 美元符号 （$） 用于引用 LET 语句中定义的变量。 有关详细信息，请参阅 定义自己的变量。 $fullName
      @"botScore"

      对于每个帐户创建或帐户登录事件，欺诈保护的 AI 模型都会生成 0 到 999 之间的机器人分数。 更高的分数表示机器人启动事件的概率更高。

      可以使用@botScore在机器人评分后子句和风险后评分子句中引用此分数。

      		 @"botScore"
      @"riskScore"

      对于每个购买或帐户保护事件，欺诈保护的 AI 模型都会生成介于 0 到 999 之间的风险分数。 更高的分数表示风险较高。

      可以使用 @riskScore 在风险评分后子句中引用此分数。

      		 @"riskScore"
      @a[x]

      此变量用于为数组变量编制索引。

      如果评估的请求有效负载包含项数组，则可以使用以下语法访问数组的各个元素：@“productList[0]”。

      若要访问该元素的属性，请使用以下语法： @“productList[0].productId”

      @“productList[0].productId”

      @“paymentInstrumentList[3].type”
      Exists

      此运算符检查事件有效负载中是否存在变量。

      Exists（字符串变量）

      		 Exists（@“user.email”）
      Response.Decision（） 此函数引用正在评估的当前评估的决定。 Response.Decision（） == “批准”
      Request.CorrelationId（） 此函数引用正在计算的事件的唯一关联 ID。 可以使用此函数访问规则体验中事件的关联 ID，并将其作为参数或标头传递给外部调用。 External.MyExternalCall（Request.CorrelationId（））
      .GetDiagnostics（） 此函数可用于从外部调用或外部评估响应中发现重要的诊断和调试信息。 对于外部调用，Diagnostics 对象包含请求有效负载、终结点、HttpStatus 代码、错误消息和延迟。 终结点在诊断对象中不可用，无法用于外部评估响应。 使用相应的扩展方法创建诊断对象后，可以在规则中使用这些字段中的任何一个。GetDiagnostics（）”

      LET $extResponse = 外部。 myCall（@“device.ipAddress”）

      LET $extResponseDiagnostics = $extResponse.GetDiagnostics（）

      OB标准版RVE 输出（诊断 = $extResponseDiagnostics）

      何时$extResponseDiagnostics。 HttpStatusCode ！= 200

      逻辑运算符

      运算符 说明 示例
      和 （&&） 逻辑 和

      @“riskScore” > 500 && @"riskScore"< 800

      @“riskScore” > 500 和 @"riskScore"< 800
      或 （||） 逻辑 或

      @“email.isEmailUsername” == false || @"email.isEmailValidated" == false

      @“email.isEmailUsername” == false 或 @"email.isEmailValidated" == false
      not 逻辑非 @"email.isEmailUsername" not（！） @"email.isEmailUsername"

      列表函数

      利用欺诈保护，可以上传自定义列表，并使用语言引用它们。

      有关如何上传这些列表的信息，请参阅 “管理列表”。 有关如何在规则中使用列表的详细信息，请参阅 本文后面的“使用规则 ”部分中的列表。

      运算符 说明 示例
      ContainsKey（
      String listName，
      String columnName，
      字符串 键）      		 此运算符检查欺诈保护列表中指定列中是否包含密钥。

      ContainsKey（“电子邮件支持列表”、“电子邮件”， @"user.email"）

      此示例检查“电子邮件支持列表”列表中的“Email”列是否包含 @“user.email”变量。
      查找（
      String listName，
      字符串 keyColName，
      字符串 valueColName）

      此运算符在欺诈保护列表中查找密钥的值。 必须指定包含键的列的名称和包含值的列的名称。

      该值始终作为字符串返回。

      如果未找到密钥，并且 未指定 defaultValue 参数，则返回“Unknown”。

      Lookup（“电子邮件支持列表”、“电子邮件”、“ @"user.email"状态”，0）

      本示例在“电子邮件支持列表”列表的“Email”列中查找 @“user.email” 变量，并在“状态”列中返回相应的值。

      如果在列表中找不到密钥，则欺诈保护将返回 0。
      LookupClosest（
      String listName， String keyColumnName， String key，
      String valueColumnName，String defaultValue）

      此运算符在欺诈保护列表中查找密钥的值。 如果未找到该键，则返回键的值（按字母顺序最接近要查找的键）。

      重载：

      • Lookup（String listName、String keyColumnName、String key、String keyColumnName、String valueColumnName、String defaultValue）

      LookupClosest（“IP 地址”、“IP”、“ @"device.ipAddress"City”） == “Seattle”

      本示例在“IP 地址”列表的“IP”列中查找 @ipAddress 变量，并返回“City”列中的相应值。 如果在 列表中找不到@ipAddress ，表达式将返回列表中下一个最近的 IP 地址的值。
      In

      此运算符检查键是否包含在逗号分隔的值列表中。

      In（字符串 键、字符串 列表）

      		 In（@“user.countryRegion”， “US， MX， CA”）

      比较运算符

      欺诈保护支持所有标准 C# 比较 和 相 等操作。 此表包含一些可能有用的运算符示例。 如果将这些运算符应用于字符串，则会发生词法比较。

      运算符 说明 示例
      == 此运算符检查相等。 @"user.countryRegion" == @"shippingAddress.countryRegion"
      != 此运算符检查不相等。 @"user.countryRegion" != @"shippingAddress.countryRegion"
      > 此运算符检查第一个值是否大于第二个值。 @"riskScore"> 500
      < 此运算符检查第一个值是否小于第二个值。 @"riskScore"< 500
      >= 此运算符检查第一个值是否大于或等于第二个值。 @"riskScore">= 500
      <= 此运算符检查第一个值是否小于或等于第二个值。 @"riskScore"<= 500

      BIN 查找函数

      BIN 查找函数根据银行标识号（例如，卡网络、卡类型、卡国家/地区代码、卡类别）提供付款卡帐户信息。 BIN 查找的数据源自领先的第三方 BIN 数据提供程序，然后由欺诈保护进行策划。

      运算符 说明 示例
      站。Lookup（字符串 BIN）。卡网络

      此函数查找 BIN 并返回卡网络（例如 Visa、Master卡）。

      		 站。Lookup（@“卡.bin”），卡网络
      站。Lookup（字符串 BIN）。卡类型

      此运算符查找 BIN 并返回卡类型（例如借记、信用）。

      		 站。Lookup（@“卡.bin”），卡类型
      站。Lookup（字符串 BIN）。颁发者

      此操作员查找 BIN 并返回发证组织。

      		 站。Lookup（@“卡.bin”颁发者）
      站。Lookup（字符串 BIN）。countryCode

      此运算符查找 BIN 并返回卡的 ISO 双字母国家/地区代码。

      		 站。Lookup（@“卡.bin”）。countryCode
      站。Lookup（字符串 BIN）。卡类别

      此操作员查找 BIN 并返回卡类别（例如预付、公司、奖励）。

      		 站。Lookup（@“卡.bin”），卡类别
      站。Lookup（字符串 BIN）。错误

      如果找不到 BIN，此运算符将查找 BIN 并返回错误消息。

      		 站。Lookup（@“卡.bin”）错误

      地理函数

      地理函数通过将 IP 地址转换为地理地址来提供解析。 只有使用属于事务有效负载的 IP 或使用设备指纹保护收集的 IP，才能在规则中调用异地函数。 无法为任意 IP 值调用地理函数。

      运算符 说明 示例
      Geo.RegionCode（字符串 ip）

      此运算符将 IPv4 地址转换为其美国区域代码（即美国州或地区名称的缩写）。

      例如，对于华盛顿州的 IP 地址，将返回“WA”。

      		 Geo.RegionCode（@“device.ipAddress”）
      Geo.Region（字符串 ip）

      此运算符将 IPv4 地址转换为其美国区域（即美国州或地区的名称）。

      例如，对于华盛顿州的 IP 地址，将返回“Washington”。

      		 Geo.Region（@“device.ipAddress”）
      Geo.CountryCode（字符串 ip）

      此运算符将 IPv4 地址转换为其国家/地区代码。

      例如，对于澳大利亚的 IP 地址，将返回“AU”。

      		 Geo.CountryCode（@“device.ipAddress”）
      Geo.CountryRegion（字符串 ip）

      此运算符将 IP 地址转换为区域名称。

      例如，对于澳大利亚的 IP 地址，将返回“澳大利亚”。

      		 Geo.CountryRegion（@“device.ipAddress”）
      Geo.City（字符串 ip）

      此运算符将 IPv4 地址转换为城市名称。

      例如，对于纽约市的 IP 地址，将返回“纽约市”。

      		 Geo.City（@“device.ipAddress”）
      Geo.MarketCode（字符串 ip）

      此运算符将 IPv4 地址转换为 IP 地址的市场代码。

      例如，对于来自加拿大的 IP 地址，将返回“NA”（北美）。

      		 Geo.MarketCode（@“device.ipAddress”）

      字符串函数

      欺诈保护支持标准 C# 字符串类。 此表包含一些可能有用的函数和运算符示例。

      运算符 说明 示例
      Contains（字符串 子字符串）

      此运算符检查字符串是否包含另一个字符串。

      Contains（字符串 子字符串）

      		 @"productList`.productName".Contains（“Xbox”）
      ContainsOnly（CharSet）

      此运算符检查字符串是否仅包含提供的字符集。

      ContainsOnly（Charset1 Charset2 ...等）

      		 @“zipcode”。ContainsOnly（CharSet.Numeric）
      ContainsAll（CharSet）

      此运算符检查字符串是否包含提供的所有字符集。

      ContainsAll（Charset1 Charset2...等）

      		 @“zipcode”。ContainsAll（CharSet.Numeric|CharSet.Hypen）
      ContainsAny（CharSet）

      此运算符检查字符串是否包含提供的任何字符集。

      ContainsAll（Charset1 Charset2...等）

      		 @“zipcode”。ContainsAny（CharSet.Numeric|CharSet.Hypen）
      StartsWith（字符串 前缀）

      此运算符检查字符串是否以指定的前缀开头。

      StartsWith（字符串 前缀）

      		 @"user.phoneNumber".StartsWith（“1-”）
      EndsWith（字符串 后缀）

      此运算符检查字符串是否以指定的后缀结尾。

      EndsWith（字符串 后缀）

      		 @"user.email".EndsWith（“@contoso.com”）
      IsNumeric（）

      此运算符检查字符串是否为数值。

      （字符串）。IsNumeric（）

      		 @"user.email".IsNumeric（）
      长度

      此运算符返回字符串中的字符数。

      		 @"user.username".Length
      Convert.ToDateTime（@“user.creationDate”）。ToString（“yyyy-MM-dd HH：mm：ss”）

      此运算符将字符串转换为 datetime，并使用给定格式将 datetime 转换为字符串。

      		 Convert.ToDateTime（@“user.creationDate”）。ToString（“yyyy-MM-dd”）

      在 ContainsOnly、ContainsAll 和 ContainsAny 中使用 CharSet

      以下字符类型可用于 ContainsOnly、ContainsAll 和 ContainsAny。

      字符类型 说明
      字母顺序 a-z、A-Z
      撇号 “
      Asperand @
      反斜杠 \
      Comma ,
      Hypen -
      Numeric 0-9
      周期 。
      斜杠 /
      下划线 _
      空白 单个空间

      数学函数

      欺诈保护支持所有标准 C# 数学方法和算术运算符。 此表包含一些可能有用的方法示例。

      运算符 说明 示例
      Math.Min（Double value1，Double value2） 此运算符计算两个值的最小值。 Math.Min（@“riskScore”，@"botScore"）
      Math.Max（Double value1，Double value2） 此运算符计算两个值的最大值。 Math.Max（@“riskScore”，@"botScore"）
      RandomInt（整数 最小值、整数 最大值） 此运算符返回提供的区域中的随机整数，包括最小值和不包括最大值。 RandomInt（0、100）

      DateTime 运算符

      欺诈保护支持标准 C# DateTime 属性、方法和运算符。 此表包含一些可能有用的函数和属性示例。

      运算符 说明 示例
      DaysSince（DateTime date） 此运算符返回一个整数，表示在指定的 DateTime 值和当前日期之间传递的天数（表示为协调世界时 [UTC]）。 DaysSince（@“user.CreationDate“）
      UtcNow 此运算符获取一个 DateTime 对象，该对象设置为计算机上的当前日期和时间，以 UTC 表示。 DateTime.UtcNow
      Today 此运算符获取一个对象，该对象设置为当前日期，其中时间组件设置为 00：00：00。 DateTime.Today
      年 此运算符获取此实例所表示日期的年份部分。 @"user.creationDate".年
      日期 此运算符获取与此实例具有相同日期的新对象，但时间值设置为 00：00：00（午夜）。 @"user.creationDate".日期

      类型转换运算符

      有关类型推理的信息，请参阅 本文后面的属性 类型推理部分。

      运算符 说明 示例
      ToDateTime（） 此运算符将字符串转换为 DateTime 对象。 @"user.creationDate".ToDateTime（）
      ToDouble（） 此运算符将字符串转换为 Double 值。 @"productList.purchasePrice".ToDouble（）
      ToInt32（） 此运算符将字符串 转换为 Int32 值。 @"riskScore".ToInt32（）

      聚合函数

      函数 说明 示例
      Count() 此函数返回事件发生的次数。 标准版LECT Count（） AS numPurchases
      DistinctCount（字符串 键） 此函数返回指定属性的非重复值数。 如果传入事件的指定属性为 null 或为空，则该事件不会导致聚合。 标准版LECT DistinctCount（@“device.ipAddress”） AS distinctIPs
      Sum（双 值） 此函数返回指定数值属性的值之和。 标准版LECT Sum（@“totalAmount”） AS totalSpending

      全局变量函数

      全局变量函数可用于在规则、速度、路由规则和决策后操作规则内设置和获取全局变量。 可以从同一环境或堆栈中的环境访问设置的变量。 例如，如果在根环境中的规则中设置全局变量，则可以在同一环境或子环境中访问这些变量。 此外，全局变量特定于评估。 无法从另一个评估访问一个评估中的变量集。

      运算符 说明 示例
      SetVariables（k=v） 此函数可用于设置键值对，即将值设置为变量。 Do SetVariables（key= 123， email=@“user.email”）
      GetVariable（“k”） 此函数可用于访问已设置的变量。 如果访问从未设置的变量，则返回默认值。

      GetVariable（“key”）。AsInt（）

      GetVariable（“email”）。AsString（）

      GetVariable（“key”）。AsDouble（）

      GetVariable（“key”）。AsBool（）

      GetVariable（“key”）。AsDateTime（）

      GetVariable（“key”）。AsJsonObject（）

      GetVariable（“key”）。AsJsonArray（）

      定义自己的变量

      可以使用 LET 关键字 (keyword) 来定义变量。 然后，可以在规则中的其他位置引用该变量。 以美元符号（$）为所有变量添加前缀。

      例如，声明以下变量。

      LET $fullName = @"user.firstName" + @"user.lastName"

      LET 语句中声明的变量只能在定义语句的规则或速度集的范围内使用。

      例如，若要引用上一示例中的变量，可以编写以下语句。

      WHEN $fullName == "Kayla Goderich"

      注意

      定义变量后，不能使用新值更新该变量。

      在规则中使用列表

      可以使用 ContainsKey 和 Lookup 运算符引用上传到欺诈保护的列表。 有关列表的详细信息，请参阅 “管理列表”。

      ContainsKey

      若要检查其中一个列表是否包含特定值，请使用 ContainsKey 运算符。 指定要为其检查的列表名称、列和键。

      例如，上传风险电子邮件地址的单列列表，并将其命名为 Risky 电子邮件列表。

      电子邮件
      Kayla@contoso.com
      Jamie@bellowscollege.com
      Marie@atatum.com

      然后，可以使用以下语法来拒绝此列表中有风险的电子邮件地址的所有事务。

      RETURN Reject("risky email") 
WHEN ContainsKey("Risky email list", "Email", @"user.email")

      此子句检查“风险电子邮件列表”列表中的“电子邮件”列是否包含@email键。 如果这样做，则拒绝事务。

      查找

      对于多列列表，可以使用 Lookup 运算符检查特定键的列的值。

      例如，创建一个列表，其中包含一列用于电子邮件地址，另一列指示这些电子邮件地址的状态。 将此列表 命名为电子邮件列表。

      电子邮件 Status
      Kayla@contoso.com 风险
      Jamie@bellowscollege.com 风险
      Marie@atatum.com 风险
      Camille@fabrikam.com Safe
      Miguel@proseware.com Safe
      Tyler@contoso.com Safe

      然后，可以使用以下语法拒绝此列表中状态为 Risky 的电子邮件地址的所有事务。

      RETURN Reject("risky email") 
WHEN Lookup("Email List", "Email", @"user.email", "Status") == "Risky"

      此子句在“电子邮件列表”列表中的“电子邮件”列中查找 @“user.email”键，并检查“状态”列中的值是否为 Risky。 如果是，则拒绝事务。

      如果在列表中找不到 @“user.email”密钥，则欺诈保护将返回“未知”。

      还可以将自己的默认值指定为第五个参数。 有关详细信息，请参阅 本文前面的“逻辑运算符 ”部分。

      Lookup 运算符始终返回字符串值。 若要将此值转换为 Int、 Double 或 DateTime 值，请使用 类型强制转换运算符。

      使用外部调用、外部评估和速度

      • 若要引用外部调用，请键入 External，后跟要引用的外部调用。 有关详细信息，请参阅 在规则中使用外部调用。
      • 若要引用外部评估，请键入 评估，然后键入要引用的外部评估。 有关详细信息，请参阅 在规则中使用外部评估。
      • 若要引用速度，请键入 “速度”，然后键入要引用的速度。 有关详细信息，请参阅 在规则中使用速度。

      属性的类型推理

      变量类型是从所使用的上下文推断的。 以下是一些示例：

      • 在表达式 WHEN @isEmailValidated中，变量被解释为 布尔 值。
      • 在表达式 @“riskScore” > 500 中，变量解释为 Double 值。
      • 在表达式 @“user.creationDate” 中。Year < DateTime.UtcNow.Year，变量解释为 DateTime 值。

      如果没有足够的上下文来推断变量的类型，则它被视为字符串值。 例如，在表达式 @“riskScore” <@"botScore"中，这两个变量都解释为字符串。

      若要指定非字符串变量的类型，请使用 类型强制转换运算符。

      JSON 数组和对象

      FQL 支持将复杂结构化对象构造为局部变量，这些变量可以通过 JSON 格式传递给外部调用或外部评估。 与 FQL 中的所有其他局部变量一样，创建数组和对象后是不可变的。

      JSON 数组

      数组是通过将表达式括在一对括号中创建的：

      LET $arr1 = [ "hello", "world" ]
LET $arr2 = [
  "this is also an array",
  78.4,
  $arr1,
  @"user.email",
  External.MyExtcall()
]

      JSON 对象

      使用大括号创建对象：

      LET $obj1 = { isObject: true }
LET $obj2 = {
  numberField: 7,
  fieldIs: "string",
  internalObj: $obj1,
  inline: {
    innerInnerField: "hello"
  }
}

      JSON 数组和对象的 FQL 函数

      语法 说明 示例
      myArr[0] 可以使用此语法按其索引访问特定数组元素。 myArr [0].property
      myArr [0][0]
      myArr [0][0].property
      myArr [0].property[0]
      myArr [0].property[0].property[0].property[0].property

      在 上面的示例中，myArr 是一个数组。 此数组的源可以是@@payloadProperty、外部评估响应、外部调用响应、局部变量或全局变量。

      下面是如何使用基于不同数组源的语法的示例：

      • 数组源：Payload
      LET $sample = @@"myArr[0]".AsJsonArray()   
RETURN Approve()   
WHEN $sample[0].AsString() == "a"
      • 数组源：局部变量 
        LET $group1 =["a", "b", "c"]
LET $group1 =[{ item1: "a", item2: "b"}, { item1: "c", item2: "d"}]
LET $group3 =[{ item1: "a", item2: "b", item3: ["c", "d"]}, {{ item1: "e", item2: "f", item3: ["g", "h"]}]
RETURN Approve()
WHEN $group1[0].AsString() == "a" && $group1[0].item2.AsString() == "b" && $group3[0].item3[0].AsString() == "c"
      语法 说明 示例
      Array.GetValue （TargetArray .AsJsonArray（）， matchKey， matchValue， lookupKey） 使用此函数，可以访问与条件匹配的第一个数组元素。

      返回一个值

      		 Array.GetValue（@@“payloadProperty”。AsJsonArray（）， matchKey， matchValue， lookupKey）
      Array.GetValues（TargetArray .AsJsonArray（）， matchKey， matchValue） 使用此函数，可以访问一组与条件匹配的数组元素。

      返回数组

      		 Array.GetValues（@@“payloadProperty”。AsJsonArray（）， matchKey， matchValue）

      下面是有关如何基于不同数组源使用上述语法的一些更详细的示例：

      数组源 Array.GetValue Array.GetValues
      外部评估 LET $a = Assessments.myAssessment.evaluate（）
      LET $sample = Array.GetValue（$a.ruleEvaluations.AsJsonArray（）、“rule”、“Sample Payload Generation”、“clauseNames”）RETURN Approve（）

      WHEN $sample[0]。AsString（） == “TestData”      		 LET $a = Assessments.myAssessment.evaluate（）
      LET $sample = Array.GetValues（$a.ruleEvaluations.AsJsonArray（）、“rule”、“Sample Payload Generation”）
      RETURN Approve（）
      WHEN $sample[0].clauseNames[0]。AsString（） == “TestData”
      有效负载 有效负载示例：{“group”：[{“item1”： “a”， “item2”： “a1”}， {“item1”： “b”， “item2”： “b1”}]}

      LET $sample = Array.GetValue（@@“group”。AsJsonArray（）、“item1”、“a”、“item2”）RETURN Approve（）
      WHEN $sample。AsString（） == “a1”      		 有效负载示例： { “group”：[{“item1”： “a”， “item2”： “a1”}， {“item1”： “b”， “item2”： “b1”}]}

      LET $sample = Array.GetValues（@@“group”。AsJsonArray（）、 “item1”、“a”）
      RETURN Approve（）

      WHEN $sample[0].item2。AsString（） == “a1”
      全局变量 使用与上面相同的有效负载示例

      Do SetVariables（Var=@@“group”）
      LET $group = GetVariable（“Var”）。AsJsonObject（）
      LET $value = Array.GetValue（$group，“item1”， “a”， “item2”）
      RETURN Approve（）
      WHEN $value。AsString（） == “a1”      		 使用与上面相同的有效负载示例

      Do SetVariables（Var=@@“group”）
      LET $group = GetVariable（“Var”）。AsJsonObject（）
      LET $arr = Array.GetValues（$group.AsJsonArray（）、 “item1”、“a”）
      RETURN Approve（）
      外部调用

      外部调用 （myCall） 响应： {“group”：[{“item1”： “a”， “item2”： “a1”}， {“item1”： “b”， “item2”： “b1”}]}

      LET $x = External.myCall（）。AsJsonObject（）
      LET $value = Array.GetValue（$x.group[0]。AsJsonObject（）、“item1”、“a”、“item2”）RETURN Approve（）

      WHEN $value。AsString（） == “a1”

      		 外部调用 （myCall） 响应： {“group”：[{“item1”： “a”， “item2”： “a1”}， {“item1”： “b”， “item2”： “b1”}]}

      LET $x = External.myCall（）。AsJsonObject（）
      LET $arr = Array.GetValues（$x.group[0]。AsJsonObject（）、 “item1”、“a”）RETURN Approve（）
      WHEN $arr[0].item2.AsString（） == “a1”

      JSON 数组和对象的类型强制转换

      • 以下 。JsonObject<支持 Type>（） ：

        • AsString（）
        • AsInt（）
        • AsDouble（）
        • AsDateTime（）
        • AsBool（）
        • AsJsonArray（）
        • AsJsonObject（）

      • 使用两个数组帮助程序方法之一时，GetValue 或 .GetValues，需要使用 ..作为<类型>（）。 示例：

        LET $arr = {myArr:[{item1: "red", number: 45}, {item1: "blue", number: 56}, {item1: "green", number: 33}]}
LET $sample = Array.GetValues($arr.myArr.AsJsonArray(), "item1", "blue")

      • 将数据显式转换为 JSON 对象或数组后，可以使用 。作为<Type>（） 转换为其他数据类型（如果需要）。 示例：

        RETURN Approve()
WHEN $sample[0].number.AsInt() == 56

      • 使用 @@时，数据将隐式类型转换为 JSON 对象。 如果随后想要将 JSON 对象转换为其他数据类型，则必须使用 。作为<类型>（）。 示例：

        LET $sample = @@”user.addresses”.AsJsonArray()

      • 如果要以特定格式输出，则必须使用 。作为<类型>（）。 示例：

        LET $sample = @@”user.addresses”
Output(abc = $sample.AsJsonArray())

      注意

      类型转换最佳做法：

      • 始终在 .chain 的末尾键入强制转换。

      示例：

      LET $sample = External.myCall().data[0].Item1[0].AsJsonArray()

Or

LET $sample = @@”accommodations[0].rooms”.AsJsonArray()
      • 不确定时，始终使用显式类型强制转换。作为<类型>（）。