API Rest Cadastre

Adresse

getAdresse

Trouve une adresse en fonction de son ID RVA

Retourne une adresse RVA


/epsg:{typeProjection}/adresses/{idAdresse}

Utilisation

curl -X GET "https://api-cadastre.sig.rennesmetropole.fr/v1/epsg:{typeProjection}/adresses/{idAdresse}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AdresseApi;

import java.io.File;
import java.util.*;

public class AdresseApiExample {

    public static void main(String[] args) {
        
        AdresseApi apiInstance = new AdresseApi();
        Integer typeProjection = 56; // Integer | Type de projection demandé
        Long idAdresse = 789; // Long | L'ID de l'adresse à retourner
        try {
            Adresse result = apiInstance.getAdresse(typeProjection, idAdresse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdresseApi#getAdresse");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AdresseApi;

public class AdresseApiExample {

    public static void main(String[] args) {
        AdresseApi apiInstance = new AdresseApi();
        Integer typeProjection = 56; // Integer | Type de projection demandé
        Long idAdresse = 789; // Long | L'ID de l'adresse à retourner
        try {
            Adresse result = apiInstance.getAdresse(typeProjection, idAdresse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdresseApi#getAdresse");
            e.printStackTrace();
        }
    }
}
Integer *typeProjection = 56; // Type de projection demandé
Long *idAdresse = 789; // L'ID de l'adresse à retourner

AdresseApi *apiInstance = [[AdresseApi alloc] init];

// Trouve une adresse en fonction de son ID RVA
[apiInstance getAdresseWith:typeProjection
    idAdresse:idAdresse
              completionHandler: ^(Adresse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ApiRestCadastre = require('api_rest_cadastre');

var api = new ApiRestCadastre.AdresseApi()

var typeProjection = 56; // {Integer} Type de projection demandé

var idAdresse = 789; // {Long} L'ID de l'adresse à retourner


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAdresse(typeProjection, idAdresse, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getAdresseExample
    {
        public void main()
        {
            
            var apiInstance = new AdresseApi();
            var typeProjection = 56;  // Integer | Type de projection demandé
            var idAdresse = 789;  // Long | L'ID de l'adresse à retourner

            try
            {
                // Trouve une adresse en fonction de son ID RVA
                Adresse result = apiInstance.getAdresse(typeProjection, idAdresse);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdresseApi.getAdresse: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\AdresseApi();
$typeProjection = 56; // Integer | Type de projection demandé
$idAdresse = 789; // Long | L'ID de l'adresse à retourner

try {
    $result = $api_instance->getAdresse($typeProjection, $idAdresse);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdresseApi->getAdresse: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::AdresseApi;

my $api_instance = WWW::SwaggerClient::AdresseApi->new();
my $typeProjection = 56; # Integer | Type de projection demandé
my $idAdresse = 789; # Long | L'ID de l'adresse à retourner

eval { 
    my $result = $api_instance->getAdresse(typeProjection => $typeProjection, idAdresse => $idAdresse);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdresseApi->getAdresse: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.AdresseApi()
typeProjection = 56 # Integer | Type de projection demandé
idAdresse = 789 # Long | L'ID de l'adresse à retourner

try: 
    # Trouve une adresse en fonction de son ID RVA
    api_response = api_instance.get_adresse(typeProjection, idAdresse)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdresseApi->getAdresse: %s\n" % e)

Paramètres

Paramètres d'URL
Name Description
typeProjection*
Integer
Type de projection demandé
Required
idAdresse*
Long (int64)
L'ID de l'adresse à retourner
Required

Réponse

Statut: 200 - OK

Statut: 400 - ID invalide

Statut: 404 - Adresse non trouvée


Commune

getCommune

Trouve une commune en fonction de son ID

Retourne une commune


/epsg:{typeProjection}/communes/{idCommune}

Utilisation

curl -X GET "https://api-cadastre.sig.rennesmetropole.fr/v1/epsg:{typeProjection}/communes/{idCommune}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CommuneApi;

import java.io.File;
import java.util.*;

public class CommuneApiExample {

    public static void main(String[] args) {
        
        CommuneApi apiInstance = new CommuneApi();
        Integer typeProjection = 56; // Integer | Type de projection demandé
        String idCommune = idCommune_example; // String | L'ID de la commune à retourner
        try {
            Commune result = apiInstance.getCommune(typeProjection, idCommune);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommuneApi#getCommune");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.CommuneApi;

public class CommuneApiExample {

    public static void main(String[] args) {
        CommuneApi apiInstance = new CommuneApi();
        Integer typeProjection = 56; // Integer | Type de projection demandé
        String idCommune = idCommune_example; // String | L'ID de la commune à retourner
        try {
            Commune result = apiInstance.getCommune(typeProjection, idCommune);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommuneApi#getCommune");
            e.printStackTrace();
        }
    }
}
Integer *typeProjection = 56; // Type de projection demandé
String *idCommune = idCommune_example; // L'ID de la commune à retourner

CommuneApi *apiInstance = [[CommuneApi alloc] init];

// Trouve une commune en fonction de son ID
[apiInstance getCommuneWith:typeProjection
    idCommune:idCommune
              completionHandler: ^(Commune output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ApiRestCadastre = require('api_rest_cadastre');

var api = new ApiRestCadastre.CommuneApi()

var typeProjection = 56; // {Integer} Type de projection demandé

var idCommune = idCommune_example; // {String} L'ID de la commune à retourner


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getCommune(typeProjection, idCommune, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getCommuneExample
    {
        public void main()
        {
            
            var apiInstance = new CommuneApi();
            var typeProjection = 56;  // Integer | Type de projection demandé
            var idCommune = idCommune_example;  // String | L'ID de la commune à retourner

            try
            {
                // Trouve une commune en fonction de son ID
                Commune result = apiInstance.getCommune(typeProjection, idCommune);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommuneApi.getCommune: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\CommuneApi();
$typeProjection = 56; // Integer | Type de projection demandé
$idCommune = idCommune_example; // String | L'ID de la commune à retourner

try {
    $result = $api_instance->getCommune($typeProjection, $idCommune);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CommuneApi->getCommune: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CommuneApi;

my $api_instance = WWW::SwaggerClient::CommuneApi->new();
my $typeProjection = 56; # Integer | Type de projection demandé
my $idCommune = idCommune_example; # String | L'ID de la commune à retourner

eval { 
    my $result = $api_instance->getCommune(typeProjection => $typeProjection, idCommune => $idCommune);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CommuneApi->getCommune: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.CommuneApi()
typeProjection = 56 # Integer | Type de projection demandé
idCommune = idCommune_example # String | L'ID de la commune à retourner

try: 
    # Trouve une commune en fonction de son ID
    api_response = api_instance.get_commune(typeProjection, idCommune)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommuneApi->getCommune: %s\n" % e)

Paramètres

Paramètres d'URL
Name Description
typeProjection*
Integer
Type de projection demandé
Required
idCommune*
String
L'ID de la commune à retourner
Required

Réponse

Statut: 200 - OK

Statut: 400 - ID invalide

Statut: 404 - Commune non trouvée


getCommunes

Récupère les communes de Rennes Metropole

Retourne la liste des communes de Rennes Metropole


/communes

Utilisation

curl -X GET "https://api-cadastre.sig.rennesmetropole.fr/v1/communes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.CommuneApi;

import java.io.File;
import java.util.*;

public class CommuneApiExample {

    public static void main(String[] args) {
        
        CommuneApi apiInstance = new CommuneApi();
        try {
            array[LightCommune] result = apiInstance.getCommunes();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommuneApi#getCommunes");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.CommuneApi;

public class CommuneApiExample {

    public static void main(String[] args) {
        CommuneApi apiInstance = new CommuneApi();
        try {
            array[LightCommune] result = apiInstance.getCommunes();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommuneApi#getCommunes");
            e.printStackTrace();
        }
    }
}

CommuneApi *apiInstance = [[CommuneApi alloc] init];

// Récupère les communes de Rennes Metropole
[apiInstance getCommunesWithCompletionHandler: 
              ^(array[LightCommune] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ApiRestCadastre = require('api_rest_cadastre');

var api = new ApiRestCadastre.CommuneApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getCommunes(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getCommunesExample
    {
        public void main()
        {
            
            var apiInstance = new CommuneApi();

            try
            {
                // Récupère les communes de Rennes Metropole
                array[LightCommune] result = apiInstance.getCommunes();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommuneApi.getCommunes: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\CommuneApi();

try {
    $result = $api_instance->getCommunes();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CommuneApi->getCommunes: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::CommuneApi;

my $api_instance = WWW::SwaggerClient::CommuneApi->new();

eval { 
    my $result = $api_instance->getCommunes();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CommuneApi->getCommunes: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.CommuneApi()

try: 
    # Récupère les communes de Rennes Metropole
    api_response = api_instance.get_communes()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommuneApi->getCommunes: %s\n" % e)

Paramètres

Réponse

Statut: 200 - OK


Parcelle

getLightParcelles

Trouve les numéros de parcelle d'une section

Retourne les numéros de parcelle en fonction d'un ID de section


/sections/{idSection}/parcelles

Utilisation

curl -X GET "https://api-cadastre.sig.rennesmetropole.fr/v1/sections/{idSection}/parcelles"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParcelleApi;

import java.io.File;
import java.util.*;

public class ParcelleApiExample {

    public static void main(String[] args) {
        
        ParcelleApi apiInstance = new ParcelleApi();
        String idSection = idSection_example; // String | ID de la section
        try {
            LightParcelle result = apiInstance.getLightParcelles(idSection);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParcelleApi#getLightParcelles");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ParcelleApi;

public class ParcelleApiExample {

    public static void main(String[] args) {
        ParcelleApi apiInstance = new ParcelleApi();
        String idSection = idSection_example; // String | ID de la section
        try {
            LightParcelle result = apiInstance.getLightParcelles(idSection);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParcelleApi#getLightParcelles");
            e.printStackTrace();
        }
    }
}
String *idSection = idSection_example; // ID de la section

ParcelleApi *apiInstance = [[ParcelleApi alloc] init];

// Trouve les numéros de parcelle d'une section
[apiInstance getLightParcellesWith:idSection
              completionHandler: ^(LightParcelle output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ApiRestCadastre = require('api_rest_cadastre');

var api = new ApiRestCadastre.ParcelleApi()

var idSection = idSection_example; // {String} ID de la section


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getLightParcelles(idSection, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getLightParcellesExample
    {
        public void main()
        {
            
            var apiInstance = new ParcelleApi();
            var idSection = idSection_example;  // String | ID de la section

            try
            {
                // Trouve les numéros de parcelle d'une section
                LightParcelle result = apiInstance.getLightParcelles(idSection);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParcelleApi.getLightParcelles: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ParcelleApi();
$idSection = idSection_example; // String | ID de la section

try {
    $result = $api_instance->getLightParcelles($idSection);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ParcelleApi->getLightParcelles: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParcelleApi;

my $api_instance = WWW::SwaggerClient::ParcelleApi->new();
my $idSection = idSection_example; # String | ID de la section

eval { 
    my $result = $api_instance->getLightParcelles(idSection => $idSection);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParcelleApi->getLightParcelles: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ParcelleApi()
idSection = idSection_example # String | ID de la section

try: 
    # Trouve les numéros de parcelle d'une section
    api_response = api_instance.get_light_parcelles(idSection)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParcelleApi->getLightParcelles: %s\n" % e)

Paramètres

Paramètres d'URL
Name Description
idSection*
String
ID de la section
Required

Réponse

Statut: 200 - OK

Statut: 400 - ID invalide

Statut: 404 - Numéros de parcelle non trouvés


getParcelle

Trouve une parcelle en fonction de son ID

Retourne une parcelle


/epsg:{typeProjection}/parcelles/{idParcelle}

Utilisation

curl -X GET "https://api-cadastre.sig.rennesmetropole.fr/v1/epsg:{typeProjection}/parcelles/{idParcelle}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParcelleApi;

import java.io.File;
import java.util.*;

public class ParcelleApiExample {

    public static void main(String[] args) {
        
        ParcelleApi apiInstance = new ParcelleApi();
        Integer typeProjection = 56; // Integer | Type de projection demandé
        String idParcelle = idParcelle_example; // String | L'ID de la parcelle à retourner
        try {
            Parcelle result = apiInstance.getParcelle(typeProjection, idParcelle);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParcelleApi#getParcelle");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ParcelleApi;

public class ParcelleApiExample {

    public static void main(String[] args) {
        ParcelleApi apiInstance = new ParcelleApi();
        Integer typeProjection = 56; // Integer | Type de projection demandé
        String idParcelle = idParcelle_example; // String | L'ID de la parcelle à retourner
        try {
            Parcelle result = apiInstance.getParcelle(typeProjection, idParcelle);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParcelleApi#getParcelle");
            e.printStackTrace();
        }
    }
}
Integer *typeProjection = 56; // Type de projection demandé
String *idParcelle = idParcelle_example; // L'ID de la parcelle à retourner

ParcelleApi *apiInstance = [[ParcelleApi alloc] init];

// Trouve une parcelle en fonction de son ID
[apiInstance getParcelleWith:typeProjection
    idParcelle:idParcelle
              completionHandler: ^(Parcelle output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ApiRestCadastre = require('api_rest_cadastre');

var api = new ApiRestCadastre.ParcelleApi()

var typeProjection = 56; // {Integer} Type de projection demandé

var idParcelle = idParcelle_example; // {String} L'ID de la parcelle à retourner


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getParcelle(typeProjection, idParcelle, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getParcelleExample
    {
        public void main()
        {
            
            var apiInstance = new ParcelleApi();
            var typeProjection = 56;  // Integer | Type de projection demandé
            var idParcelle = idParcelle_example;  // String | L'ID de la parcelle à retourner

            try
            {
                // Trouve une parcelle en fonction de son ID
                Parcelle result = apiInstance.getParcelle(typeProjection, idParcelle);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParcelleApi.getParcelle: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ParcelleApi();
$typeProjection = 56; // Integer | Type de projection demandé
$idParcelle = idParcelle_example; // String | L'ID de la parcelle à retourner

try {
    $result = $api_instance->getParcelle($typeProjection, $idParcelle);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ParcelleApi->getParcelle: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParcelleApi;

my $api_instance = WWW::SwaggerClient::ParcelleApi->new();
my $typeProjection = 56; # Integer | Type de projection demandé
my $idParcelle = idParcelle_example; # String | L'ID de la parcelle à retourner

eval { 
    my $result = $api_instance->getParcelle(typeProjection => $typeProjection, idParcelle => $idParcelle);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParcelleApi->getParcelle: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ParcelleApi()
typeProjection = 56 # Integer | Type de projection demandé
idParcelle = idParcelle_example # String | L'ID de la parcelle à retourner

try: 
    # Trouve une parcelle en fonction de son ID
    api_response = api_instance.get_parcelle(typeProjection, idParcelle)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParcelleApi->getParcelle: %s\n" % e)

Paramètres

Paramètres d'URL
Name Description
typeProjection*
Integer
Type de projection demandé
Required
idParcelle*
String
L'ID de la parcelle à retourner
Required

Réponse

Statut: 200 - OK

Statut: 400 - ID invalide

Statut: 404 - Parcelle non trouvée


getParcelleAdresse

Trouve une parcelle en fonction d'un ID adresse Rva

Retourne une parcelle


/epsg:{typeProjection}/parcelles/adresses/{idAdresse}

Utilisation

curl -X GET "https://api-cadastre.sig.rennesmetropole.fr/v1/epsg:{typeProjection}/parcelles/adresses/{idAdresse}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParcelleApi;

import java.io.File;
import java.util.*;

public class ParcelleApiExample {

    public static void main(String[] args) {
        
        ParcelleApi apiInstance = new ParcelleApi();
        Integer typeProjection = 56; // Integer | Type de projection demandé
        Long idAdresse = 789; // Long | L'ID de l'adresse de la parcelle à retourner
        try {
            Parcelle result = apiInstance.getParcelleAdresse(typeProjection, idAdresse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParcelleApi#getParcelleAdresse");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ParcelleApi;

public class ParcelleApiExample {

    public static void main(String[] args) {
        ParcelleApi apiInstance = new ParcelleApi();
        Integer typeProjection = 56; // Integer | Type de projection demandé
        Long idAdresse = 789; // Long | L'ID de l'adresse de la parcelle à retourner
        try {
            Parcelle result = apiInstance.getParcelleAdresse(typeProjection, idAdresse);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParcelleApi#getParcelleAdresse");
            e.printStackTrace();
        }
    }
}
Integer *typeProjection = 56; // Type de projection demandé
Long *idAdresse = 789; // L'ID de l'adresse de la parcelle à retourner

ParcelleApi *apiInstance = [[ParcelleApi alloc] init];

// Trouve une parcelle en fonction d'un ID adresse Rva
[apiInstance getParcelleAdresseWith:typeProjection
    idAdresse:idAdresse
              completionHandler: ^(Parcelle output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ApiRestCadastre = require('api_rest_cadastre');

var api = new ApiRestCadastre.ParcelleApi()

var typeProjection = 56; // {Integer} Type de projection demandé

var idAdresse = 789; // {Long} L'ID de l'adresse de la parcelle à retourner


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getParcelleAdresse(typeProjection, idAdresse, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getParcelleAdresseExample
    {
        public void main()
        {
            
            var apiInstance = new ParcelleApi();
            var typeProjection = 56;  // Integer | Type de projection demandé
            var idAdresse = 789;  // Long | L'ID de l'adresse de la parcelle à retourner

            try
            {
                // Trouve une parcelle en fonction d'un ID adresse Rva
                Parcelle result = apiInstance.getParcelleAdresse(typeProjection, idAdresse);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParcelleApi.getParcelleAdresse: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ParcelleApi();
$typeProjection = 56; // Integer | Type de projection demandé
$idAdresse = 789; // Long | L'ID de l'adresse de la parcelle à retourner

try {
    $result = $api_instance->getParcelleAdresse($typeProjection, $idAdresse);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ParcelleApi->getParcelleAdresse: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParcelleApi;

my $api_instance = WWW::SwaggerClient::ParcelleApi->new();
my $typeProjection = 56; # Integer | Type de projection demandé
my $idAdresse = 789; # Long | L'ID de l'adresse de la parcelle à retourner

eval { 
    my $result = $api_instance->getParcelleAdresse(typeProjection => $typeProjection, idAdresse => $idAdresse);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParcelleApi->getParcelleAdresse: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ParcelleApi()
typeProjection = 56 # Integer | Type de projection demandé
idAdresse = 789 # Long | L'ID de l'adresse de la parcelle à retourner

try: 
    # Trouve une parcelle en fonction d'un ID adresse Rva
    api_response = api_instance.get_parcelle_adresse(typeProjection, idAdresse)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParcelleApi->getParcelleAdresse: %s\n" % e)

Paramètres

Paramètres d'URL
Name Description
typeProjection*
Integer
Type de projection demandé
Required
idAdresse*
Long (int64)
L'ID de l'adresse de la parcelle à retourner
Required

Réponse

Statut: 200 - OK

Statut: 400 - ID invalide

Statut: 404 - Parcelle non trouvée


getParcelleLatLng

Trouve une parcelle en fonction d'une latitude et longitude

Retourne une parcelle


/epsg:{typeProjection}/parcelles/{lng}/{lat}

Utilisation

curl -X GET "https://api-cadastre.sig.rennesmetropole.fr/v1/epsg:{typeProjection}/parcelles/{lng}/{lat}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParcelleApi;

import java.io.File;
import java.util.*;

public class ParcelleApiExample {

    public static void main(String[] args) {
        
        ParcelleApi apiInstance = new ParcelleApi();
        Integer typeProjection = 56; // Integer | Type de projection demandé
        String lng = lng_example; // String | Longitude de la parcelle recherchée
        String lat = lat_example; // String | Latitude de la parcelle recherchée
        try {
            Parcelle result = apiInstance.getParcelleLatLng(typeProjection, lng, lat);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParcelleApi#getParcelleLatLng");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ParcelleApi;

public class ParcelleApiExample {

    public static void main(String[] args) {
        ParcelleApi apiInstance = new ParcelleApi();
        Integer typeProjection = 56; // Integer | Type de projection demandé
        String lng = lng_example; // String | Longitude de la parcelle recherchée
        String lat = lat_example; // String | Latitude de la parcelle recherchée
        try {
            Parcelle result = apiInstance.getParcelleLatLng(typeProjection, lng, lat);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParcelleApi#getParcelleLatLng");
            e.printStackTrace();
        }
    }
}
Integer *typeProjection = 56; // Type de projection demandé
String *lng = lng_example; // Longitude de la parcelle recherchée
String *lat = lat_example; // Latitude de la parcelle recherchée

ParcelleApi *apiInstance = [[ParcelleApi alloc] init];

// Trouve une parcelle en fonction d'une latitude et longitude
[apiInstance getParcelleLatLngWith:typeProjection
    lng:lng
    lat:lat
              completionHandler: ^(Parcelle output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ApiRestCadastre = require('api_rest_cadastre');

var api = new ApiRestCadastre.ParcelleApi()

var typeProjection = 56; // {Integer} Type de projection demandé

var lng = lng_example; // {String} Longitude de la parcelle recherchée

var lat = lat_example; // {String} Latitude de la parcelle recherchée


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getParcelleLatLng(typeProjection, lng, lat, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getParcelleLatLngExample
    {
        public void main()
        {
            
            var apiInstance = new ParcelleApi();
            var typeProjection = 56;  // Integer | Type de projection demandé
            var lng = lng_example;  // String | Longitude de la parcelle recherchée
            var lat = lat_example;  // String | Latitude de la parcelle recherchée

            try
            {
                // Trouve une parcelle en fonction d'une latitude et longitude
                Parcelle result = apiInstance.getParcelleLatLng(typeProjection, lng, lat);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParcelleApi.getParcelleLatLng: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ParcelleApi();
$typeProjection = 56; // Integer | Type de projection demandé
$lng = lng_example; // String | Longitude de la parcelle recherchée
$lat = lat_example; // String | Latitude de la parcelle recherchée

try {
    $result = $api_instance->getParcelleLatLng($typeProjection, $lng, $lat);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ParcelleApi->getParcelleLatLng: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParcelleApi;

my $api_instance = WWW::SwaggerClient::ParcelleApi->new();
my $typeProjection = 56; # Integer | Type de projection demandé
my $lng = lng_example; # String | Longitude de la parcelle recherchée
my $lat = lat_example; # String | Latitude de la parcelle recherchée

eval { 
    my $result = $api_instance->getParcelleLatLng(typeProjection => $typeProjection, lng => $lng, lat => $lat);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ParcelleApi->getParcelleLatLng: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ParcelleApi()
typeProjection = 56 # Integer | Type de projection demandé
lng = lng_example # String | Longitude de la parcelle recherchée
lat = lat_example # String | Latitude de la parcelle recherchée

try: 
    # Trouve une parcelle en fonction d'une latitude et longitude
    api_response = api_instance.get_parcelle_lat_lng(typeProjection, lng, lat)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParcelleApi->getParcelleLatLng: %s\n" % e)

Paramètres

Paramètres d'URL
Name Description
typeProjection*
Integer
Type de projection demandé
Required
lng*
String
Longitude de la parcelle recherchée
Required
lat*
String
Latitude de la parcelle recherchée
Required

Réponse

Statut: 200 - OK

Statut: 400 - Paramètres invalides

Statut: 404 - Parcelle non trouvée


Section

getSections

Trouve les sections d'une commune

Retourne la liste des sections d'une commune en fonction de son ID


/communes/{idCommune}/sections

Utilisation

curl -X GET "https://api-cadastre.sig.rennesmetropole.fr/v1/communes/{idCommune}/sections"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SectionApi;

import java.io.File;
import java.util.*;

public class SectionApiExample {

    public static void main(String[] args) {
        
        SectionApi apiInstance = new SectionApi();
        String idCommune = idCommune_example; // String | ID de la commune
        try {
            Section result = apiInstance.getSections(idCommune);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SectionApi#getSections");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SectionApi;

public class SectionApiExample {

    public static void main(String[] args) {
        SectionApi apiInstance = new SectionApi();
        String idCommune = idCommune_example; // String | ID de la commune
        try {
            Section result = apiInstance.getSections(idCommune);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SectionApi#getSections");
            e.printStackTrace();
        }
    }
}
String *idCommune = idCommune_example; // ID de la commune

SectionApi *apiInstance = [[SectionApi alloc] init];

// Trouve les sections d'une commune
[apiInstance getSectionsWith:idCommune
              completionHandler: ^(Section output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var ApiRestCadastre = require('api_rest_cadastre');

var api = new ApiRestCadastre.SectionApi()

var idCommune = idCommune_example; // {String} ID de la commune


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSections(idCommune, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getSectionsExample
    {
        public void main()
        {
            
            var apiInstance = new SectionApi();
            var idCommune = idCommune_example;  // String | ID de la commune

            try
            {
                // Trouve les sections d'une commune
                Section result = apiInstance.getSections(idCommune);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SectionApi.getSections: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\SectionApi();
$idCommune = idCommune_example; // String | ID de la commune

try {
    $result = $api_instance->getSections($idCommune);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SectionApi->getSections: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SectionApi;

my $api_instance = WWW::SwaggerClient::SectionApi->new();
my $idCommune = idCommune_example; # String | ID de la commune

eval { 
    my $result = $api_instance->getSections(idCommune => $idCommune);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SectionApi->getSections: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.SectionApi()
idCommune = idCommune_example # String | ID de la commune

try: 
    # Trouve les sections d'une commune
    api_response = api_instance.get_sections(idCommune)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SectionApi->getSections: %s\n" % e)

Paramètres

Paramètres d'URL
Name Description
idCommune*
String
ID de la commune
Required

Réponse

Statut: 200 - OK

Statut: 400 - ID invalide

Statut: 404 - Sections non trouvées


Documentatioon auto-générée le 28-12-2017 à 15:53:50