User Script Data Source

Signature: DataReceiver defineSchema(SchemaBuilder builder)

Defines the schema of the datasource. The script is expected to call the column(...) method on the builder.

Returns: The data receiver which can be used to produce new rows.

Example:

def receiver = dataSource.defineSchema {
  column("ID", ColumnType.Number, Multiplicity.Single)
  column("Name", ColumnType.Text, Multiplicity.Single)
  column("EndOfLife", ColumnType.Date, Multiplicity.Single)
  column("IsVirtualized", ColumnType.Boolean, Multiplicity.Single)
} 

Signature: void column(String name, ColumnType type, Multiplicity multiplicity)

Defines one column in the schema. Can only be used within a dataSource.defineSchema { } context.

Parameters:

• name — The name of the column.
• type — The type of the column. The following values exist for ColumnType: - ColumnType.Text for textual values - ColumnType.Number for numeric values (can be integer or floating point values) - ColumnType.Date for date/time values - ColumnType.Boolean for boolean (true/false) values

Example:

def receiver = dataSource.defineSchema {
  column("ID", ColumnType.Number, Multiplicity.Single)
  column("Name", ColumnType.Text, Multiplicity.Single)
  column("EndOfLife", ColumnType.Date, Multiplicity.Single)
  column("IsVirtualized", ColumnType.Boolean, Multiplicity.Single)
} 

Signature: void addAllODataSchemaColumns(ODataClient client, String serviceURL, String className)

Auto fetch the metadata model of a certain class from the given service url. Can only be used within a dataSource.defineSchema { } context.

Parameters:

• client — The exposed OData client.
• serviceURL — The root url of the OData service.
• className — Only fetch the schema from given className e.g. "Machine", "Person".

Example:

def receiver = dataSource.declareSchema {
  addAllODataSchemaColumns(client, "https://example.org", "Machine")
}

Signature: void addAllODataSchemaColumns(ODataClient client, String serviceURL)

Auto fetch the metadata model from the given service url. Can only be used within a dataSource.defineSchema { } context.

Parameters:

• client — The exposed OData client.
• serviceURL — The root url of the OData service.

Example:

def receiver = dataSource.declareSchema {
  addAllODataSchemaColumns(client, "https://example.org")
}

Signature: Row DataReceiver.addRow()

Adds a new row to the result which can then be consumed by the Txture importer. The new row is initially empty. Use row.setString(...), row.setNumber(...) etc. to fill it with data.

Returns: The new, empty Data Row.

Example:

def row = receiver.addRow()
row.setString("ID", "my-id-1234")

Signature: void mapODataEntityToRow(ClientEntity entity, ImportObjectRow row)

Maps the whole ClientEntity to an empty row, respecting the defined schema. Properties that are not defined in the schema are omitted.

Parameters:

• entity — The single client entity retrieved from OData service.
• row — The new empty row from DataReceiver.

Example:

def entities = responseBody.entities
for (entity in entities) {
  def row = receiver.addRow()
  mapODataEntityToRow(entity, row)
}

Signature: void DataRow.setString(String column, String text)

Sets the value of the given column to the given text in this row.

Parameters:

• The name of the column to assign. Must be one of the columns defined in the schema.
• The text value to assign to the column on this row.

Example:

def row = receiver.addRow()
row.setString("Name", "")

Signature: void DataRow.setStrings(String columnName, String... strings)

Sets multiple string values for the given columnName in this row.

Parameters:

• columnName — The name of the column to assign. Must be one of the columns defined in the schema.
• strings — An array of string values to assign to the column on this row.

Example:

def row = receiver.addRow()
row.setStrings("Tags", "tag1", "tag2", "tag3")

Signature: void DataRow.setStrings(String columnName, Iterable<String> strings)

Sets multiple string values for the given columnName in this row using an iterable of strings.

Parameters:

• columnName — The name of the column to assign. Must be one of the columns defined in the schema.
• strings — An iterable of string values to assign to the column on this row.

Example:

def row = receiver.addRow()
def tagList = ["tag1", "tag2", "tag3"]
row.setStrings("Tags", tagList)


#### `row.setNumber`

**Signature:** `void DataRow.setNumber(String column, Number number)`

Sets the value of the given `column` to the given `number` in this row.

**Parameters:**
- The name of the column to assign. Must be one of the columns defined in the schema.
- The numeric value to assign to the column on this row. Can be an integer or a floating point value.

**Example:**

```groovy
def row = receiver.addRow()
row.setNumber("AccountNumber", 112233)

Signature: void DataRow.setNumbers(String columnName, Number... numbers)

Sets multiple number values for the given columnName in this row.

Parameters:

• columnName — The name of the column to assign. Must be one of the columns defined in the schema.
• numbers — An array of number values to assign to the column on this row.

Example:

def row = receiver.addRow()
row.setNumbers("Values", 1, 2, 3, 4, 5)

Signature: void DataRow.setNumbers(String columnName, Iterable<Number> numbers)

Sets multiple number values for the given columnName in this row using an iterable of numbers.

Parameters:

• columnName — The name of the column to assign. Must be one of the columns defined in the schema.
• numbers — An iterable of number values to assign to the column on this row.

Example:

def row = receiver.addRow()
def numberList = [1, 2, 3, 4, 5]
row.setNumbers("Values", numberList)

Signature: void DataRow.setDate(String column, Date date)

Sets the value of the given column to the given date in this row.

Parameters:

• The name of the column to assign. Must be one of the columns defined in the schema.
• The numeric value to assign to the column on this row.

Example:

def row = receiver.addRow()
row.setNumber("AccountNumber", new SimpleDateFormat("yyyy-MM-dd").parse("2020-09-18"))

Signature: void DataRow.setDates(String columnName, Date... dates)

Sets multiple date values for the given columnName in this row.

Parameters:

• columnName — The name of the column to assign. Must be one of the columns defined in the schema.
• dates — An array of date values to assign to the column on this row.

Example:

def row = receiver.addRow()
def date1 = new Date()
def date2 = new Date()
def date3 = new Date()
row.setDates("EventDates", date1, date2, date3)

Signature: void DataRow.setDates(String columnName, Iterable<Date> dates)

Sets multiple date values for the given columnName in this row using an iterable of dates.

Parameters:

• columnName — The name of the column to assign. Must be one of the columns defined in the schema.
• dates — An iterable of date values to assign to the column on this row.

Example:

def row = receiver.addRow()
def dateList = [new Date(), new Date(), new Date()]
row.setDates("EventDates", dateList)

Signature: void DataRow.setBoolean(String column, Boolean bool)

Sets the value of the given column to the given bool in this row.

Parameters:

• The name of the column to assign. Must be one of the columns defined in the schema.
• The boolean value to assign to the column on this row.

Example:

def row = receiver.addRow()
row.setBoolean("IsVirtualized", true)

Signature: void DataRow.setBooleans(String columnName, Boolean... booleans)

Sets multiple boolean values for the given columnName in this row.

Parameters:

• columnName — The name of the column to assign. Must be one of the columns defined in the schema.
• booleans — An array of boolean values to assign to the column on this row.

Example:

def row = receiver.addRow()
row.setBooleans("IsAdmin", true, false, true)

Signature: void DataRow.setBooleans(String columnName, Iterable<Boolean> booleans)

Sets multiple boolean values for the given columnName in this row using an iterable of booleans.

Parameters:

• columnName — The name of the column to assign. Must be one of the columns defined in the schema.
• booleans — An iterable of boolean values to assign to the column on this row.

Example:

def row = receiver.addRow()
def booleanList = [true, false, true]
row.setBooleans("IsAdmin", booleanList)

Signature: void DataRow.setRange(String column, Range range)

Sets the value of the given column to the given range in this row.

Parameters:

• The name of the column to assign. Must be one of the columns defined in the schema.
• The range value to assign to the column on this row.

Example:

def row = receiver.addRow()
row.setNumber("WorkingHours", Range.createRange(8.00, 17.00))

Signature: void DataRow.setRanges(String columnName, Range... ranges)

Sets multiple range values for the given columnName in this row.

Parameters:

• columnName — The name of the column to assign. Must be one of the columns defined in the schema.
• ranges — An array of range values to assign to the column on this row.

Example:

def row = receiver.addRow()
def range1 = new Range(1, 10)
def range2 = new Range(20, 30)
def range3 = new Range(50, 60)
row.setRanges("ValueRanges", range1, range2, range3)

Signature: void DataRow.setRanges(String columnName, Iterable<Range> ranges)

Sets multiple range values for the given columnName in this row using an iterable of ranges.

Parameters:

• columnName — The name of the column to assign. Must be one of the columns defined in the schema.
• ranges — An iterable of range values to assign to the column on this row.

Example:

def row = receiver.addRow()
def rangeList = [new Range(1, 10), new Range(20, 30), new Range(50, 60)]
row.setRanges("ValueRanges", rangeList)

Signature: HttpResponse RequestBuilder.http(HttpRequest)

Performs a HTTP request. The details of the request are given in curly brackets { }.

Parameters:

• builder — The request builder. You can configure this object between the curly brackets.

Returns: The result of the HTTP call.

Example:

def response = request.http {
    method = HttpMethod.GET
    url = "http://www.example.org"
    headers {
    contentType("text/plain")
    }
}

Signature: FileResponse RequestBuilder.file(FileRequest)

Requests a file from the server's local hard drive. The details of the request are given in curly brackets { }.

Parameters:

• builder — The request builder. You can configure this object between the curly brackets.

Returns: The result of the file lookup.

Example:

def response = request.file {
    path = "/home/john-doe/Documents/my-file.json"
}

Signature: ODataClient RequestBuilder.odata(ODataRequest)

Creates an OData client with specified authentication. The details of the request are given in curly brackets { }.

Parameters:

• builder — The request builder. You can configure this object between the curly brackets.

Returns: The exposed OData client.

Example:

def client = request.odata {
    auth {
    basic("admin","password")
    }
}

Signature: HttpRequestBuilder.url = String

Sets the URL to call. For dynamic URLs, we recommend using template strings (e.g. for a dynamic port, use def myPort = ... and then url = "https://myhost:${myPort}"). Please note that no additional URL encoding is performed; the given string is used as-is.

Parameters:

• value — The new value for the request URL as a String.

Example:

def response = request.http {
    url = "http://www.example.org"
}

Signature: HttpRequestBuilder.method = HttpMethod

Sets the HTTP method to use for the request.

Parameters:

• value — The method to use. The available values are: - HttpMethod.POST - HttpMethod.PUT - HttpMethod.GET - HttpMethod.PATCH - HttpMethod.DELETE - HttpMethod.HEAD - HttpMethod.OPTIONS - HttpMethod.TRACE

Example:

def response = request.http {
    url = "http://www.example.org"
    method = HttpMethod.GET
}

Signature: HttpRequestBuilder.body = String

Sets the body for the HTTP call as a String.

Parameters:

• value — The body to use. Please note that you can use Groovy Multi-Line strings (denoted by """ """) if you need to create a mult-line body.

Example:

def response = request.http {
    url = "http://www.example.org"
    method = HttpMethod.POST
    body = """
      {
        "name": "John Doe"
      }
    """
}

Signature: HttpRequestBuilder.readTimeoutSeconds = int

Sets the read timeout for the request (in seconds) as an integer value.

A read timeout is applied from the moment the connection between a client and a target host has been successfully established. It defines a maximum time of inactivity between two data packets when waiting for the server's response.

The default value is 300 seconds (equals 5 minutes).

Parameters:

• value — The value to assign to the read timeout.

Example:

def response = request.http {
    url = "http://www.example.org"
    method = HttpMethod.GET
    readTimeoutSeconds = 60
}

Signature: HttpRequestBuilder.connectTimeoutSeconds = int

Sets the connect timeout for the request (in seconds) as an integer value.

A connect timeout defines a time period in which our client should establish a connection with a target host.

The default value is 10 seconds.

Parameters:

• value — The value to assign to the connect timeout.

Example:

def response = request.http {
    url = "http://www.example.org"
    method = HttpMethod.GET
    connectTimeoutSeconds = 20
}

Signature: HttpRequestBuilder.callTimeoutSeconds = int

Sets the call timeout for the request (in seconds) as an integer value.

It defines a time limit for a complete HTTP call. This includes resolving DNS, connecting, writing the request body, server processing, as well as reading the response body.

The default value is 300 seconds (equals 5 minutes).

Parameters:

• value — The value to assign to the call timeout.

Example:

def response = request.http {
    url = "http://www.example.org"
    method = HttpMethod.GET
    callTimeoutSeconds = 90
}

Signature: HttpRequestBuilder.headers(HttpRequestHeaderBuilder builder)

Sets the headers for the HTTP request. This is a builder, so use curly braces { } to configure it.

Parameters:

• builder — The builder for the request parameters. Configure it between the curly braces { }.

Example:

def response = request.http {
    url = "http://www.example.org"
    method = HttpMethod.GET
    headers {
    contentType("text/plain")
    }
}

Signature: HttpHeaderBuilder.authorization(String value)

Sets the standard HTTP authorization header to the given value.

The predefined header setters are:

• accept(String value)
• acceptCharset(String value)
• acceptEncoding(String value)
• acceptLanguage(String value)
• acceptRanges(String value)
• accessControlAllowCredentials(String value)
• accessControlAllowHeaders(String value)
• accessControlAllowMethods(String value)
• accessControlAllowOrigin(String value)
• accessControlExposeHeaders(String value)
• accessControlMaxAge(String value)
• accessControlRequestHeaders(String value)
• accessControlRequestMethod(String value)
• age(String value)
• allow(String value)
• authorization(String value)
• cacheControl(String value)
• connection(String value)
• contentEncoding(String value)
• contentDisposition(String value)
• contentLanguage(String value)
• contentLength(String value)
• contentLocation(String value)
• contentRange(String value)
• contentType(String value)
• cookie(String value)
• date(String value)
• etag(String value)
• expect(String value)
• expires(String value)
• from(String value)
• host(String value)
• ifMatch(String value)
• ifModifiedSince(String value)
• ifNoneMatch(String value)
• ifRange(String value)
• ifUnmodifiedSince(String value)
• lastModified(String value)
• link(String value)
• location(String value)
• maxForwards(String value)
• origin(String value)
• pragma(String value)
• proxyAuthenticate(String value)
• proxyAuthorization(String value)
• range(String value)
• referer(String value)
• retryAfter(String value)
• server(String value)
• setCookie(String value)
• setCookie2(String value)
• te(String value)
• trailer(String value)
• transferEncoding(String value)
• upgrade(String value)
• userAgent(String value)
• vary(String value)
• via(String value)
• warning(String value)
• wwwAuthenticate(String value)

Parameters:

• value — The value to assign to the authorization header.

Example:

def response = request.http {
    url = "http://www.example.org"
    method = HttpMethod.GET
    headers {
    contentType("text/plain")
    }
}

Signature: HttpHeaderBuilder.custom(String headerName, String value)

Sets the given custom headerName to the given value. If desired, standard header names can also be used. For example, the following is valid:

headers {
    custom("content-type", "application/json")
}

... and fully equivalent to:

headers {
    contentType("application/json")
}

Parameters:

• headerName — The name of the header to set.
• value — The value to assign to the custom header.

Example:

def response = request.http {
    url = "http://www.example.org"
    method = HttpMethod.GET
    headers {
    custom("my-header", "a value for the header")
    }
}

Signature: HttpResponse.statusCode

Returns the status code of the HTTP response. Notable codes include:

• 200 (OK)
• 400 (Bad Request)
• 401 (Unauthorized)
• 403 (Forbidden)
• 404 (Not found)
• 500 (Internal Server Error)

Please see the Mozilla Wiki for a full list of error codes and their descriptions.

Returns: The HTTP reponse status code, as an integer.

Example:

def response = request.http {
    url = "http://www.example.org"
    method = HttpMethod.GET
}

if(response.statusCode != 200){
    return fail("Request failed")
}

Signature: HttpResponse.message

Returns the message of the HTTP response. This is mostly used for error reporting in cases where the response code is something other than 200. This is not the response body.

Returns: The message of the HTTP response, as a string.

Example:

def response = request.http {
    url = "http://www.example.org"
    method = HttpMethod.GET
}

log.debug("Response message: " + response.message)

Signature: HttpResponse.bodyText

Returns the response body as UTF-8 text. Depending on the requested endpoint, this value may be in JSON format, XML format, HTML or any other plain-text format. Please consult the documentation of the requested endpoint for details.

Returns: The body of the HTTP response, as a UTF-8 string.

Example:

def response = request.http {
    url = "http://www.example.org"
    method = HttpMethod.GET
}

// let's assume we get a JSON array back
def array = parseJsonArray(response.bodyText)

Signature: HttpResponse.bodyBytes

Returns the response body as a raw byte array. This is useful in cases where the response of the external system is not delivered as plain text (e.g. when downoading a file).

Returns: The raw byte array that represents the HTTP response body.

Example:

def response = request.http {
    url = "http://www.example.org"
    method = HttpMethod.GET
}

def bytes = response.bodyBytes

Signature: HttpResponse.headers

Returns the response headers object. To access an individual header, please use response.headers.getFirst("my-header") to retrieve the assigned string value. As a single header in HTTP can have multiple values assigned to it, you can also get all of the assigned values as a list of strings by using response.headers.getAll("my-header") instead.

Returns: The headers object.

Example:

def response = request.http {
    url = "http://www.example.org"
    method = HttpMethod.GET
}

// retrieves the "content-type" header value as a string
def contentType = response.headers.getFirst("content-type")

// retrieves the "cache-control" headers as a list of strings
def cacheControls = response.headers.getAll("cache-control")

Signature: FileResponse.found

Checks if the requested file has been found on the file system.

Returns:true if the file has been found, otherwise false. If the file was a directory, or the file path was syntactically invalid, this method will also return false.

Example:

def response = request.file {
    path = "/home/john-doe/Documents/my-file.json"
}

if(response.found){
    return fail("file not found!")
}

Signature: FileResponse.contentString

Reads the contents of the requested file as a String (using UTF-8 encoding).

Returns: The contents of the file as String. If response.found is false, the empty String is returned.

Example:

    def response = request.file {
    path = "/home/john-doe/Documents/my-file.json"
    }

    def jsonText = response.contentString
    ```

  #### `contentBytes`

**Signature:** `FileResponse.contentBytes`

Returns the contents of the requested file as a raw Byte Array.
  If your file is known to contain plain text data, the method
  `contentString` is usually preferable over raw byte processing.

**Returns:** The contents of the file as Byte Array. If `response.found` is `false`, the empty array is returned.

**Example:**

```groovy
    def response = request.file {
    path = "/home/john-doe/Documents/my-file.json"
    }

    def bytes = response.contentBytes
    ```

### OData Request Builder

#### `auth`

**Signature:** `void ODataRequest.auth(ODataAuth)`

Sets the Authorization for accessing the OData service.

**Example:**

```groovy
    def client = request.odata {
    auth {
      none()
    }
    }
    ```

  ### OData Auth Builder

  #### `none`

**Signature:** `void ODataAuth.none()`

No Authorization given for accessing the OData service.

**Example:**

```groovy
    def client = request.odata {
    auth {
      none()
    }
    }
    ```

#### `basic`

**Signature:** `void ODataAuth.basic(String username, String password)`

Basic Authorization given for accessing the OData service.

**Parameters:**
- `username` — The username for basic authorization.
- `password` — The password for basic authorization.

**Example:**

```groovy
    def client = request.odata {
    auth {
      basic("admin", "password")
    }
    }
    ```

#### `ntlm`

**Signature:** `void ODataAuth.ntlm(String username, String password, String workstation, String domain)`

NTLM Authorization given for accessing the OData service.

**Parameters:**
- `username` — The username for NTLM authorization.
- `password` — The password for NTLM authorization.
- `workstation` — The workstation for NTLM authorization.
- `domain` — The domain for NTLM authorization.

**Example:**

```groovy
    def client = request.odata {
    auth {
      ntlm("admin", "password", "test", "example.org")
    }
    }
    ```

### ImportResult

The `ImportResult` class is the result of a
standard importer request. It provides uniform access
to the returned data.


#### `ImportResult.objects`

**Signature:** `List<UserScriptImportObject> objects`

Retrieves the objects retrieved by the import as a list.

**Returns:** The list of retrieved objects. May be empty.

**Example:**

```groovy
    def importResult = request.importer....
  
    for(def obj : importResult.objects){
     // ... analyze/process "obj" here ...
    }
    ```

#### `ImportResult.schema`

**Signature:** `UserScriptImportSchema schema`

Retrieves the schema of the retrieved objects and grants access to the property names.

**Returns:** The schema of the retrieved objects.

**Example:**

```groovy
    def importResult = request.importer....
  
    for(def propertyName : importResult.schema.propertyNames){
     // use the propertyName
    }
    ```

#### `UserScriptImportObject.getString`

**Signature:** `String getString(String property)`

Extracts the value of the given property from this object.

**Parameters:**
- `property` — The name of the property to retrieve, as a `String`.

**Returns:** The value of the given property as a `String`. Value conversion will be attempted accordingly (e.g. if the actual value is a number, it will automatically be converted into a `String`). If there is no property with the given name, `null` will be returned instead.

**Example:**

```groovy
    def importResult = request.importer....
  
    for(def obj : importResult.objects){
    // assuming that the returned objects have a "Name" property,
    // we can extract it like this:
    def name = obj.getString("Name")   
    }
    ```

#### `UserScriptImportObject.getStrings`

**Signature:** `List<String> getStrings(String property)`

Extracts the value of the given property from this object.

**Parameters:**
- `property` — The name of the property to retrieve, as a `String`.

**Returns:** The value of the given property as a `List<String>`. Value conversion will be attempted accordingly (e.g. if the actual value is single-valued, it will be wrapped in a singleton list). If there is no property with the given name, the empty list will be returned instead.

**Example:**

```groovy
    def importResult = request.importer....
  
    for(def obj : importResult.objects){
    // assuming that the returned objects have a "phoneNumbers" property,
    // we can extract it like this:
    def phoneNumbers = obj.getString("phoneNumbers")
    for(def phoneNumber : phoneNumbers){
      // ... do something with the phoneNumber
    }  
    }
    ```






#### `UserScriptImportObject.getNumber`

**Signature:** `String getNumber(String property)`

Extracts the value of the given property from this object.

**Parameters:**
- `property` — The name of the property to retrieve, as a `Double`.

**Returns:** The value of the given property as a `Double`. Value conversion will be attempted accordingly (e.g. if the actual value is a `String`, it will automatically be parsed into a `Double`). If there is no property with the given name, `null` will be returned instead.

**Example:**

```groovy
    def importResult = request.importer....
  
    for(def obj : importResult.objects){
    // assuming that the returned objects have a "cpuCores" property,
    // we can extract it like this:
    def cpuCores = obj.getNumber("cpuCores")   
    }
    ```

#### `UserScriptImportObject.getNumbers`

**Signature:** `List<String> getNumbers(String property)`

Extracts the value of the given property from this object.

**Parameters:**
- `property` — The name of the property to retrieve, as a `String`.

**Returns:** The value of the given property as a `List<Double>`. Value conversion will be attempted accordingly (e.g. if the actual value is single-valued, it will be wrapped in a singleton list). If there is no property with the given name, the empty list will be returned instead.

**Example:**

```groovy
    def importResult = request.importer....
  
    for(def obj : importResult.objects){
    // assuming that the returned objects have a "ports" property,
    // we can extract it like this:
    def ports = obj.getNumbers("ports")
    for(def port : ports){
      // ... do something with the port
    }  
    }
    ```






#### `UserScriptImportObject.getDate`

**Signature:** `Date getDate(String property)`

Extracts the value of the given property from this object.

**Parameters:**
- `property` — The name of the property to retrieve, as a `Date`.

**Returns:** The value of the given property as a `Date`. Value conversion will be attempted accordingly (e.g. if the actual value is a `String`, it will automatically be parsed into a `Date`). If there is no property with the given name, `null` will be returned instead.

**Example:**

```groovy
    def importResult = request.importer....
  
    for(def obj : importResult.objects){
    // assuming that the returned objects have a "goLiveDate" property,
    // we can extract it like this:
    def goLiveDate = obj.getNumber("goLiveDate")   
    }
    ```

#### `UserScriptImportObject.getDates`

**Signature:** `List<Date> getDates(String property)`

Extracts the value of the given property from this object.

**Parameters:**
- `property` — The name of the property to retrieve, as a `String`.

**Returns:** The value of the given property as a `List<Date>`. Value conversion will be attempted accordingly (e.g. if the actual value is single-valued, it will be wrapped in a singleton list). If there is no property with the given name, the empty list will be returned instead.

**Example:**

```groovy
    def importResult = request.importer....
  
    for(def obj : importResult.objects){
    // assuming that the returned objects have a "maintenanceDates" property,
    // we can extract it like this:
    def maintenanceDates = obj.getNumbers("maintenanceDates")
    for(def maintenanceDate : maintenanceDates){
      // ... do something with the maintenanceDate
    }  
    }
    ```






#### `UserScriptImportObject.getBoolean`

**Signature:** `Boolean getBoolean(String property)`

Extracts the value of the given property from this object.

**Parameters:**
- `property` — The name of the property to retrieve, as a `Boolean`.

**Returns:** The value of the given property as a `Boolean`. Value conversion will be attempted accordingly (e.g. if the actual value is a `String`, it will automatically be parsed into a `Boolean`). If there is no property with the given name, `null` will be returned instead.

**Example:**

```groovy
    def importResult = request.importer....
  
    for(def obj : importResult.objects){
    // assuming that the returned objects have a "isOnline" property,
    // we can extract it like this:
    def isOnline = obj.getBoolean("isOnline")   
    }
    ```

#### `UserScriptImportObject.getBooleans`

**Signature:** `List<Boolean> getBooleans(String property)`

Extracts the value of the given property from this object.

**Parameters:**
- `property` — The name of the property to retrieve, as a `String`.

**Returns:** The value of the given property as a `List<Boolean>`. Value conversion will be attempted accordingly (e.g. if the actual value is single-valued, it will be wrapped in a singleton list). If there is no property with the given name, the empty list will be returned instead.

**Example:**

```groovy
    def importResult = request.importer....
  
    for(def obj : importResult.objects){
    // assuming that the returned objects have a "flags" property,
    // we can extract it like this:
    def flags = obj.getBooleans("flags")
    for(def flag : flags){
      // ... do something with the flag
    }  
    }
    ```




#### `UserScriptImportObject.getRange`

**Signature:** `Range getRange(String property)`

Extracts the value of the given property from this object.

**Parameters:**
- `property` — The name of the property to retrieve, as a `Range`.

**Returns:** The value of the given property as a `Range`. Value conversion will be attempted accordingly (e.g. if the actual value is a `String`, it will automatically be parsed into a `Range`). If there is no property with the given name, `null` will be returned instead.

**Example:**

```groovy
    def importResult = request.importer....
  
    for(def obj : importResult.objects){
    // assuming that the returned objects have a "maintenanceWindow" property,
    // we can extract it like this:
    def maintenanceWindow = obj.getRange("maintenanceWindow")   
    def start = maintenanceWindow.lowerBound
    def end = maintenanceWindow.upperBound
    }
    ```

#### `UserScriptImportObject.getRanges`

**Signature:** `List<Range> getRanges(String property)`

Extracts the value of the given property from this object.

**Parameters:**
- `property` — The name of the property to retrieve, as a `String`.

**Returns:** The value of the given property as a `List<Range>`. Value conversion will be attempted accordingly (e.g. if the actual value is single-valued, it will be wrapped in a singleton list). If there is no property with the given name, the empty list will be returned instead.

**Example:**

```groovy
    def importResult = request.importer....
  
    for(def obj : importResult.objects){
    // assuming that the returned objects have a "maintenanceWindows" property,
    // we can extract it like this:
    def maintenanceWindows = obj.getBooleans("maintenanceWindows")
    for(def maintenanceWindow : maintenanceWindows){
      // ... do something with the maintenanceWindow
      def start = maintenanceWindow.lowerBound
      def end = maintenanceWindow.upperBound
    }  
    }
    ```




#### `UserScriptImportObject.getObject`

**Signature:** `Object getObject(String property)`

Extracts the value of the given property from this object without
  applying any type conversion. This method should be used as a fallback
  for cases where the other methods do not work as intended.

**Parameters:**
- `property` — The name of the property to retrieve, as a `Range`.

**Returns:** The value of the given property, with no type conversion applied to it. The raw object will be returned. The resulting object may be `null`, and will always be `null` if the given property does not exist on the object.

**Example:**

```groovy
    def importResult = request.importer....
  
    for(def obj : importResult.objects){
    // assuming that the returned objects have a "owner" property,
    // we can extract it like this:
    def owner = obj.getObject("owner")   
    // you will likely need to down-cast the object to the
    // expected type, e.g. (String)owner
    }
    ```

#### `UserScriptImportObject.getObjects`

**Signature:** `List<Object> getObjects(String property)`

Extracts the value of the given property from this object.

**Parameters:**
- `property` — The name of the property to retrieve, as a `String`.

**Returns:** The value of the given property as a `List<Object>`. Value conversion will be attempted accordingly (e.g. if the actual value is single-valued, it will be wrapped in a singleton list). If there is no property with the given name, the empty list will be returned instead.

**Example:**

```groovy
    def importResult = request.importer....
  
    for(def obj : importResult.objects){
    // assuming that the returned objects have a "neighbors" property,
    // we can extract it like this:
    def neighbors = obj.getObjects("neighbors")
    for(def neighbor : neighbors){
      // you will likely need to down-cast the object to the
      // expected type, e.g. (String)neighbor
    }  
    }
    ```


#### `UserScriptImportObject.toMap`

**Signature:** `Map<String, Object> toMap()`

Converts this object into a basic map object. The map will
  contain the property names as keys, and the corresponding
  property values as map values. No type conversion will be
  applied to the map values (also, no multiplicity conversion
  will be employed; the values will be inserted into the map
  as-is).

**Returns:** The object converted into a basic map.

**Example:**

```groovy
    def importResult = request.importer....
  
    for(def obj : importResult.objects){
    // convert the object into a basic map for maximum
    // flexibility. Please keep in mind that no type
    // conversion is applied in this case.
    def map = obj.toMap()
    for(def entry : map.entrySet()){
      // the key is the name of the property
      def key = entry.key
      // the value is the value assigned to the property
      def value = entry.value

    }
    }
    ```