LocationService / Client / put_geofence

put_geofence#

LocationService.Client.put_geofence(**kwargs)#

Stores a geofence geometry in a given geofence collection, or updates the geometry of an existing geofence if a geofence ID is included in the request.

Request Syntax

response = client.put_geofence(
    CollectionName='string',
    GeofenceId='string',
    Geometry={
        'Polygon': [
            [
                [
                    123.0,
                ],
            ],
        ],
        'Circle': {
            'Center': [
                123.0,
            ],
            'Radius': 123.0
        },
        'Geobuf': b'bytes'
    },
    GeofenceProperties={
        'string': 'string'
    }
)

Parameters:

CollectionName (string) –
[REQUIRED]

The geofence collection to store the geofence in.
GeofenceId (string) –
[REQUIRED]

An identifier for the geofence. For example, ExampleGeofence-1.
Geometry (dict) –
[REQUIRED]

Contains the details to specify the position of the geofence. Can be a polygon, a circle or a polygon encoded in Geobuf format. Including multiple selections will return a validation error.

Note
The geofence polygon format supports a maximum of 1,000 vertices. The Geofence Geobuf format supports a maximum of 100,000 vertices.
- Polygon (list) –
  
  A polygon is a list of linear rings which are each made up of a list of vertices.
  
  Each vertex is a 2-dimensional point of the form: [longitude, latitude]. This is represented as an array of doubles of length 2 (so [double, double]).
  
  An array of 4 or more vertices, where the first and last vertex are the same (to form a closed boundary), is called a linear ring. The linear ring vertices must be listed in counter-clockwise order around the ring’s interior. The linear ring is represented as an array of vertices, or an array of arrays of doubles ( [[double, double], ...]).
  
  A geofence consists of a single linear ring. To allow for future expansion, the Polygon parameter takes an array of linear rings, which is represented as an array of arrays of arrays of doubles ( [[[double, double], ...], ...]).
  
  A linear ring for use in geofences can consist of between 4 and 1,000 vertices.
  - (list) –
    - (list) –
      - (float) –
- Circle (dict) –
  
  A circle on the earth, as defined by a center point and a radius.
  - Center (list) – [REQUIRED]
    
    A single point geometry, specifying the center of the circle, using WGS 84 coordinates, in the form [longitude, latitude].
    - (float) –
  - Radius (float) – [REQUIRED]
    
    The radius of the circle in meters. Must be greater than zero and no larger than 100,000 (100 kilometers).
- Geobuf (bytes) –
  
  Geobuf is a compact binary encoding for geographic data that provides lossless compression of GeoJSON polygons. The Geobuf must be Base64-encoded.
  
  A polygon in Geobuf format can have up to 100,000 vertices.
GeofenceProperties (dict) –
Associates one of more properties with the geofence. A property is a key-value pair stored with the geofence and added to any geofence event triggered with that geofence.

Format: "key" : "value"
- (string) –
  - (string) –

Return type:

dict

Returns:

Response Syntax

{
    'GeofenceId': 'string',
    'CreateTime': datetime(2015, 1, 1),
    'UpdateTime': datetime(2015, 1, 1)
}

Response Structure

(dict) –
- GeofenceId (string) –
  
  The geofence identifier entered in the request.
- CreateTime (datetime) –
  
  The timestamp for when the geofence was created in ISO 8601 format: YYYY-MM-DDThh:mm:ss.sssZ
- UpdateTime (datetime) –
  
  The timestamp for when the geofence was last updated in ISO 8601 format: YYYY-MM-DDThh:mm:ss.sssZ

Exceptions

LocationService.Client.exceptions.InternalServerException
LocationService.Client.exceptions.ResourceNotFoundException
LocationService.Client.exceptions.ConflictException
LocationService.Client.exceptions.AccessDeniedException
LocationService.Client.exceptions.ValidationException
LocationService.Client.exceptions.ThrottlingException