PingOne Platform APIs

Create Risk Predictor (Custom - numeric range)

 

POST {{apiPath}}/environments/{{envID}}/riskPredictors

This example uses the riskPredictors endpoint to create a custom predictor that assigns high, medium, or low risk based on the distance between the current location of the device and the location of the device when the last risk evaluation was carried out (distance is given in meters).

The minScore and maxScore properties are used to specify the ranges that should be considered high, medium, and low risk.

Note that the maxScore value for each of the risk categories is used as the minScore for the next risk level. If the distance equals the overlap value, the higher level of risk is assigned. So in this example, a distance of 804672 meters would be considered high risk.

type is set to MAP to indicate that it is a custom predictor.

Prerequisites

Request Model

Refer to Risk Predictors for the complete data models.

Property Type Required?

compactName

String

Required

default

Object

Optional

default.result.level

String

Optional

map.<risk level>.between.minScore

Double

Required

map.<risk level>.between.maxScore

Double

Required

map.<risk level>.contains

Double

Required

name

String

Required

type

String

Required

Headers

Authorization      Bearer {{accessToken}}

Content-Type      application/json

Body

raw ( application/json )

{
  "name": "Device Network Location",
  "compactName": "deviceNetworkLocation",
  "map": {
    "high": {
      "between": {
        "minScore": 804672,
        "maxScore": 12742000
      },
      "contains": "${details.device.estimatedDistance}"
    },
    "medium": {
      "between": {
        "minScore": 321869,
        "maxScore": 804672
      },
      "contains": "${details.device.estimatedDistance}"
    },
    "low": {
      "between": {
        "minScore": 0,
        "maxScore": 321869
      },
      "contains": "${details.device.estimatedDistance}"
    }
  },
  "type": "MAP",
  "default": {
    "result": {
      "level": "LOW"
    }
  }
}

Example Request

  • cURL

  • C#

  • Go

  • HTTP

  • Java

  • jQuery

  • NodeJS

  • Python

  • PHP

  • Ruby

  • Swift

curl --location --globoff '{{apiPath}}/environments/{{envID}}/riskPredictors' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer {{accessToken}}' \
--data '{
  "name": "Device Network Location",
  "compactName": "deviceNetworkLocation",
  "map": {
    "high": {
      "between": {
        "minScore": 804672,
        "maxScore": 12742000
      },
      "contains": "${details.device.estimatedDistance}"
    },
    "medium": {
      "between": {
        "minScore": 321869,
        "maxScore": 804672
      },
      "contains": "${details.device.estimatedDistance}"
    },
    "low": {
      "between": {
        "minScore": 0,
        "maxScore": 321869
      },
      "contains": "${details.device.estimatedDistance}"
    }
  },
  "type": "MAP",
  "default": {
    "result": {
      "level": "LOW"
    }
  }
}'
var options = new RestClientOptions("{{apiPath}}/environments/{{envID}}/riskPredictors")
{
  MaxTimeout = -1,
};
var client = new RestClient(options);
var request = new RestRequest("", Method.Post);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Authorization", "Bearer {{accessToken}}");
var body = @"{" + "\n" +
@"  ""name"": ""Device Network Location""," + "\n" +
@"  ""compactName"": ""deviceNetworkLocation""," + "\n" +
@"  ""map"": {" + "\n" +
@"    ""high"": {" + "\n" +
@"      ""between"": {" + "\n" +
@"        ""minScore"": 804672," + "\n" +
@"        ""maxScore"": 12742000" + "\n" +
@"      }," + "\n" +
@"      ""contains"": ""${details.device.estimatedDistance}""" + "\n" +
@"    }," + "\n" +
@"    ""medium"": {" + "\n" +
@"      ""between"": {" + "\n" +
@"        ""minScore"": 321869," + "\n" +
@"        ""maxScore"": 804672" + "\n" +
@"      }," + "\n" +
@"      ""contains"": ""${details.device.estimatedDistance}""" + "\n" +
@"    }," + "\n" +
@"    ""low"": {" + "\n" +
@"      ""between"": {" + "\n" +
@"        ""minScore"": 0," + "\n" +
@"        ""maxScore"": 321869" + "\n" +
@"      }," + "\n" +
@"      ""contains"": ""${details.device.estimatedDistance}""" + "\n" +
@"    }" + "\n" +
@"  }," + "\n" +
@"  ""type"": ""MAP""," + "\n" +
@"  ""default"": {" + "\n" +
@"    ""result"": {" + "\n" +
@"      ""level"": ""LOW""" + "\n" +
@"    }" + "\n" +
@"  }" + "\n" +
@"}";
request.AddStringBody(body, DataFormat.Json);
RestResponse response = await client.ExecuteAsync(request);
Console.WriteLine(response.Content);
package main

import (
  "fmt"
  "strings"
  "net/http"
  "io"
)

func main() {

  url := "{{apiPath}}/environments/{{envID}}/riskPredictors"
  method := "POST"

  payload := strings.NewReader(`{
  "name": "Device Network Location",
  "compactName": "deviceNetworkLocation",
  "map": {
    "high": {
      "between": {
        "minScore": 804672,
        "maxScore": 12742000
      },
      "contains": "${details.device.estimatedDistance}"
    },
    "medium": {
      "between": {
        "minScore": 321869,
        "maxScore": 804672
      },
      "contains": "${details.device.estimatedDistance}"
    },
    "low": {
      "between": {
        "minScore": 0,
        "maxScore": 321869
      },
      "contains": "${details.device.estimatedDistance}"
    }
  },
  "type": "MAP",
  "default": {
    "result": {
      "level": "LOW"
    }
  }
}`)

  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")
  req.Header.Add("Authorization", "Bearer {{accessToken}}")

  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
POST /environments/{{envID}}/riskPredictors HTTP/1.1
Host: {{apiPath}}
Content-Type: application/json
Authorization: Bearer {{accessToken}}

{
  "name": "Device Network Location",
  "compactName": "deviceNetworkLocation",
  "map": {
    "high": {
      "between": {
        "minScore": 804672,
        "maxScore": 12742000
      },
      "contains": "${details.device.estimatedDistance}"
    },
    "medium": {
      "between": {
        "minScore": 321869,
        "maxScore": 804672
      },
      "contains": "${details.device.estimatedDistance}"
    },
    "low": {
      "between": {
        "minScore": 0,
        "maxScore": 321869
      },
      "contains": "${details.device.estimatedDistance}"
    }
  },
  "type": "MAP",
  "default": {
    "result": {
      "level": "LOW"
    }
  }
}
OkHttpClient client = new OkHttpClient().newBuilder()
  .build();
MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"Device Network Location\",\n  \"compactName\": \"deviceNetworkLocation\",\n  \"map\": {\n    \"high\": {\n      \"between\": {\n        \"minScore\": 804672,\n        \"maxScore\": 12742000\n      },\n      \"contains\": \"${details.device.estimatedDistance}\"\n    },\n    \"medium\": {\n      \"between\": {\n        \"minScore\": 321869,\n        \"maxScore\": 804672\n      },\n      \"contains\": \"${details.device.estimatedDistance}\"\n    },\n    \"low\": {\n      \"between\": {\n        \"minScore\": 0,\n        \"maxScore\": 321869\n      },\n      \"contains\": \"${details.device.estimatedDistance}\"\n    }\n  },\n  \"type\": \"MAP\",\n  \"default\": {\n    \"result\": {\n      \"level\": \"LOW\"\n    }\n  }\n}");
Request request = new Request.Builder()
  .url("{{apiPath}}/environments/{{envID}}/riskPredictors")
  .method("POST", body)
  .addHeader("Content-Type", "application/json")
  .addHeader("Authorization", "Bearer {{accessToken}}")
  .build();
Response response = client.newCall(request).execute();
var settings = {
  "url": "{{apiPath}}/environments/{{envID}}/riskPredictors",
  "method": "POST",
  "timeout": 0,
  "headers": {
    "Content-Type": "application/json",
    "Authorization": "Bearer {{accessToken}}"
  },
  "data": JSON.stringify({
    "name": "Device Network Location",
    "compactName": "deviceNetworkLocation",
    "map": {
      "high": {
        "between": {
          "minScore": 804672,
          "maxScore": 12742000
        },
        "contains": "${details.device.estimatedDistance}"
      },
      "medium": {
        "between": {
          "minScore": 321869,
          "maxScore": 804672
        },
        "contains": "${details.device.estimatedDistance}"
      },
      "low": {
        "between": {
          "minScore": 0,
          "maxScore": 321869
        },
        "contains": "${details.device.estimatedDistance}"
      }
    },
    "type": "MAP",
    "default": {
      "result": {
        "level": "LOW"
      }
    }
  }),
};

$.ajax(settings).done(function (response) {
  console.log(response);
});
var request = require('request');
var options = {
  'method': 'POST',
  'url': '{{apiPath}}/environments/{{envID}}/riskPredictors',
  'headers': {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer {{accessToken}}'
  },
  body: JSON.stringify({
    "name": "Device Network Location",
    "compactName": "deviceNetworkLocation",
    "map": {
      "high": {
        "between": {
          "minScore": 804672,
          "maxScore": 12742000
        },
        "contains": "${details.device.estimatedDistance}"
      },
      "medium": {
        "between": {
          "minScore": 321869,
          "maxScore": 804672
        },
        "contains": "${details.device.estimatedDistance}"
      },
      "low": {
        "between": {
          "minScore": 0,
          "maxScore": 321869
        },
        "contains": "${details.device.estimatedDistance}"
      }
    },
    "type": "MAP",
    "default": {
      "result": {
        "level": "LOW"
      }
    }
  })

};
request(options, function (error, response) {
  if (error) throw new Error(error);
  console.log(response.body);
});
import requests
import json

url = "{{apiPath}}/environments/{{envID}}/riskPredictors"

payload = json.dumps({
  "name": "Device Network Location",
  "compactName": "deviceNetworkLocation",
  "map": {
    "high": {
      "between": {
        "minScore": 804672,
        "maxScore": 12742000
      },
      "contains": "${details.device.estimatedDistance}"
    },
    "medium": {
      "between": {
        "minScore": 321869,
        "maxScore": 804672
      },
      "contains": "${details.device.estimatedDistance}"
    },
    "low": {
      "between": {
        "minScore": 0,
        "maxScore": 321869
      },
      "contains": "${details.device.estimatedDistance}"
    }
  },
  "type": "MAP",
  "default": {
    "result": {
      "level": "LOW"
    }
  }
})
headers = {
  'Content-Type': 'application/json',
  'Authorization': 'Bearer {{accessToken}}'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)
<?php
require_once 'HTTP/Request2.php';
$request = new HTTP_Request2();
$request->setUrl('{{apiPath}}/environments/{{envID}}/riskPredictors');
$request->setMethod(HTTP_Request2::METHOD_POST);
$request->setConfig(array(
  'follow_redirects' => TRUE
));
$request->setHeader(array(
  'Content-Type' => 'application/json',
  'Authorization' => 'Bearer {{accessToken}}'
));
$request->setBody('{\n  "name": "Device Network Location",\n  "compactName": "deviceNetworkLocation",\n  "map": {\n    "high": {\n      "between": {\n        "minScore": 804672,\n        "maxScore": 12742000\n      },\n      "contains": "${details.device.estimatedDistance}"\n    },\n    "medium": {\n      "between": {\n        "minScore": 321869,\n        "maxScore": 804672\n      },\n      "contains": "${details.device.estimatedDistance}"\n    },\n    "low": {\n      "between": {\n        "minScore": 0,\n        "maxScore": 321869\n      },\n      "contains": "${details.device.estimatedDistance}"\n    }\n  },\n  "type": "MAP",\n  "default": {\n    "result": {\n      "level": "LOW"\n    }\n  }\n}');
try {
  $response = $request->send();
  if ($response->getStatus() == 200) {
    echo $response->getBody();
  }
  else {
    echo 'Unexpected HTTP status: ' . $response->getStatus() . ' ' .
    $response->getReasonPhrase();
  }
}
catch(HTTP_Request2_Exception $e) {
  echo 'Error: ' . $e->getMessage();
}
require "uri"
require "json"
require "net/http"

url = URI("{{apiPath}}/environments/{{envID}}/riskPredictors")

http = Net::HTTP.new(url.host, url.port);
request = Net::HTTP::Post.new(url)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer {{accessToken}}"
request.body = JSON.dump({
  "name": "Device Network Location",
  "compactName": "deviceNetworkLocation",
  "map": {
    "high": {
      "between": {
        "minScore": 804672,
        "maxScore": 12742000
      },
      "contains": "\${details.device.estimatedDistance}"
    },
    "medium": {
      "between": {
        "minScore": 321869,
        "maxScore": 804672
      },
      "contains": "\${details.device.estimatedDistance}"
    },
    "low": {
      "between": {
        "minScore": 0,
        "maxScore": 321869
      },
      "contains": "\${details.device.estimatedDistance}"
    }
  },
  "type": "MAP",
  "default": {
    "result": {
      "level": "LOW"
    }
  }
})

response = http.request(request)
puts response.read_body
let parameters = "{\n  \"name\": \"Device Network Location\",\n  \"compactName\": \"deviceNetworkLocation\",\n  \"map\": {\n    \"high\": {\n      \"between\": {\n        \"minScore\": 804672,\n        \"maxScore\": 12742000\n      },\n      \"contains\": \"${details.device.estimatedDistance}\"\n    },\n    \"medium\": {\n      \"between\": {\n        \"minScore\": 321869,\n        \"maxScore\": 804672\n      },\n      \"contains\": \"${details.device.estimatedDistance}\"\n    },\n    \"low\": {\n      \"between\": {\n        \"minScore\": 0,\n        \"maxScore\": 321869\n      },\n      \"contains\": \"${details.device.estimatedDistance}\"\n    }\n  },\n  \"type\": \"MAP\",\n  \"default\": {\n    \"result\": {\n      \"level\": \"LOW\"\n    }\n  }\n}"
let postData = parameters.data(using: .utf8)

var request = URLRequest(url: URL(string: "{{apiPath}}/environments/{{envID}}/riskPredictors")!,timeoutInterval: Double.infinity)
request.addValue("application/json", forHTTPHeaderField: "Content-Type")
request.addValue("Bearer {{accessToken}}", forHTTPHeaderField: "Authorization")

request.httpMethod = "POST"
request.httpBody = postData

let task = URLSession.shared.dataTask(with: request) { data, response, error in
  guard let data = data else {
    print(String(describing: error))
    return
  }
  print(String(data: data, encoding: .utf8)!)
}

task.resume()

Example Response

201 Created

{
    "_links": {
        "self": {
            "href": "https://api.pingone.eu/v1/environments/abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6/riskPredictors/30674bdd-9304-4574-a0e7-d4865bb72b42"
        },
        "environment": {
            "href": "https://api.pingone.eu/v1/environments/abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6"
        }
    },
    "id": "30674bdd-9304-4574-a0e7-d4865bb72b42",
    "environment": {
        "id": "abfba8f6-49eb-49f5-a5d9-80ad5c98f9f6"
    },
    "createdAt": "2023-07-18T13:28:14.971Z",
    "updatedAt": "2023-07-18T13:28:14.971Z",
    "name": "Device Network Location",
    "compactName": "deviceNetworkLocation",
    "licensed": true,
    "deletable": true,
    "map": {
        "high": {
            "between": {
                "minScore": 804672,
                "maxScore": 12742000
            },
            "contains": "${details.device.estimatedDistance}",
            "type": "RANGE"
        },
        "medium": {
            "between": {
                "minScore": 321869,
                "maxScore": 804672
            },
            "contains": "${details.device.estimatedDistance}",
            "type": "RANGE"
        },
        "low": {
            "between": {
                "minScore": 0,
                "maxScore": 321869
            },
            "contains": "${details.device.estimatedDistance}",
            "type": "RANGE"
        }
    },
    "type": "MAP",
    "condition": {
        "scores": [
            {
                "name": "HIGH",
                "value": "HIGH"
            },
            {
                "name": "MEDIUM",
                "value": "MEDIUM"
            },
            {
                "name": "LOW",
                "value": "LOW"
            }
        ]
    },
    "default": {
        "weight": 5,
        "score": 50,
        "result": {
            "level": "LOW",
            "type": "VALUE"
        },
        "evaluated": false
    }
}