added geo module, with region supporting gis data

geo/admin.py

@@ -0,0 +1,10 @@
+from django.contrib import admin
+
+from . import models
+
+# Register your models here.
+
+admin.site.register(models.Country)
+admin.site.register(models.Region)
+admin.site.register(models.City)
+

geo/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class GeoConfig(AppConfig):
+    name = 'geo'

geo/factories.py

@@ -0,0 +1,49 @@
+import random
+
+from factory import LazyAttribute, SubFactory
+from factory.fuzzy import FuzzyText, FuzzyInteger
+from factory.django import DjangoModelFactory
+
+
+class CountryFactory(DjangoModelFactory):
+    """
+    Country model factory
+    """
+    name = FuzzyText(length=12, suffix="_test_name")
+
+    class Meta:
+        model = 'geo.Country'
+
+
+class RegionFactory(DjangoModelFactory):
+    """
+    Region model factory
+    """
+    name = FuzzyText(length=12, suffix="_test_name")
+    country = SubFactory('geo.factories.CountryFactory')
+
+    class Meta:
+        model = 'geo.Region'
+
+
+class ProvinceFactory(DjangoModelFactory):
+    """
+    City model factory
+    """
+    name = FuzzyText(length=12, suffix="_test_name")
+    region = SubFactory('geo.factories.RegionFactory')
+
+    class Meta:
+        model = 'geo.Province'
+
+
+class CityFactory(DjangoModelFactory):
+    """
+    City model factory
+    """
+    name = FuzzyText(length=12, suffix="_test_name")
+    province = SubFactory('geo.factories.ProvinceFactory')
+
+    class Meta:
+        model = 'geo.City'
+

geo/models.py

@@ -0,0 +1,77 @@
+from django.contrib.gis.db import models
+
+
+class Country(models.Model):
+    """
+    Country model
+    """
+    name = models.CharField(max_length = 100)
+
+    # internal
+    created = models.DateTimeField('date of creation', auto_now_add=True)
+    updated = models.DateTimeField('date last update', auto_now=True)
+
+    def __str__(self):
+        return f'{self.name}'
+
+    class Meta:
+        verbose_name = "País"
+        verbose_name_plural = "Paises"
+
+
+class Region(models.Model):
+    """
+    Region model
+    """
+    name = models.CharField(max_length=250)
+    country = models.ForeignKey(Country,on_delete=models.DO_NOTHING,related_name='regions')
+    geo = models.MultiPolygonField(null=True)
+
+    # internal
+    created = models.DateTimeField('date of creation', auto_now_add=True)
+    updated = models.DateTimeField('date last update', auto_now=True)
+
+    def __str__(self):
+        return f'{self.name} [{self.country}]'
+
+    class Meta:
+        verbose_name = "Región"
+        verbose_name_plural = "Regiones"
+
+
+class Province(models.Model):
+    """
+    Country model
+    """
+    name = models.CharField(max_length = 100)
+    region = models.ForeignKey(Region, on_delete=models.DO_NOTHING, related_name='province')
+
+    # internal
+    created = models.DateTimeField('date of creation', auto_now_add=True)
+    updated = models.DateTimeField('date last update', auto_now=True)
+
+    def __str__(self):
+        return f'{self.name} [{self.region}]'
+
+    class Meta:
+        verbose_name = "Provincia"
+        verbose_name_plural = "Provincias"
+
+
+class City(models.Model):
+    """
+    City model
+    """
+    name = models.CharField(max_length = 250)
+    province = models.ForeignKey(Province, on_delete=models.DO_NOTHING, related_name='city', null=True)
+
+    # internal
+    created = models.DateTimeField('date of creation', auto_now_add=True)
+    updated = models.DateTimeField('date last update', auto_now=True)
+
+    def __str__(self):
+        return f'{self.name} [{self.province}]'
+
+    class Meta:
+        verbose_name = "Municipio"
+        verbose_name_plural = "Municipios"

geo/serializers.py

@@ -0,0 +1,68 @@
+from rest_framework import serializers
+
+from . import models
+
+
+class CountryReadSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = models.Country
+        fields = '__all__'
+
+
+class CountryWriteSerializer(CustomWriteSerializer):
+
+    class Meta:
+        model = models.Country
+        fields = '__all__'
+
+
+class RegionWriteSerializer(CustomWriteSerializer):
+    country = serializers.IntegerField()
+
+    def validate_country(self, value):
+        return models.Country.objects.using(self.context['db']).filter(id=value).first()
+
+    class Meta:
+        model = models.Region
+        fields = '__all__'
+
+
+class RegionReadSerializer(serializers.ModelSerializer):
+
+    country = CountryReadSerializer()
+
+    class Meta:
+        model = models.Region
+        fields = '__all__'
+
+
+class ProvinceReadSerializer(serializers.ModelSerializer):
+
+    region = RegionReadSerializer()
+
+    class Meta:
+        model = models.Province
+        fields = '__all__'
+
+
+class CityWriteSerializer(CustomWriteSerializer):
+
+    region = serializers.IntegerField()
+
+    def validate_region(self, value):
+        return models.Region.objects.using(self.context['db']).filter(id=value).first()
+
+    class Meta:
+        model = models.City
+        fields = '__all__'
+
+
+class CityReadSerializer(serializers.ModelSerializer):
+
+    province = ProvinceReadSerializer()
+
+    class Meta:
+        model = models.City
+        fields = '__all__'
+

geo/tests.py

@@ -0,0 +1,712 @@
+import random
+import datetime
+
+from django.urls import reverse
+from django.test import TestCase
+from django.utils import timezone
+
+from rest_framework.test import APITestCase
+from rest_framework import status
+
+import jwt
+
+from tenants.factories import TenantUserFactory
+
+from . import models
+from . import factories
+
+
+# Model Tests
+class CountryTest(TestCase):
+    """Country model tests
+    """
+
+    def setUp(self):
+        """Tests setup
+        """
+        self.model = models.Country
+
+    def test_content(self):
+        """Test content correctly set
+        """
+        # Define instance data
+        data = {
+            'name': 'country name _test_ data'
+        }
+
+        # Create instance
+        instance = self.model.objects.create(**data)
+
+        # Assert content correctly set
+        for field in data.keys():
+            self.assertEqual(getattr(instance, field), data[field])
+
+
+class RegionTest(TestCase):
+    """Region model tests
+    """
+
+    def setUp(self):
+        """Tests setup
+        """
+        self.model = models.Region
+
+    def test_content(self):
+        """Test content correctly set
+        """
+        # Define instance data
+        data = {
+            'name': 'region name _test_ data',
+            'country': factories.CountryFactory(),
+        }
+
+        # Create instance
+        instance = self.model.objects.create(**data)
+
+        # Assert content correctly set
+        for field in data.keys():
+            self.assertEqual(getattr(instance, field), data[field])
+
+
+class CityTest(TestCase):
+    """City model tests
+    """
+
+    def setUp(self):
+        """Tests setup
+        """
+        self.model = models.City
+
+    def test_content(self):
+        """Test content correctly set
+        """
+        # Define instance data
+        data = {
+            'name': 'city name _test_ data',
+            'region': factories.RegionFactory(),
+        }
+
+        # Create instance
+        instance = self.model.objects.create(**data)
+
+        # Assert content correctly set
+        for field in data.keys():
+            self.assertEqual(getattr(instance, field), data[field])
+
+
+class JurisdictionTest(TestCase):
+    """Jurisdiction model tests
+    """
+
+    def setUp(self):
+        """Tests setup
+        """
+        self.model = models.Jurisdiction
+
+    def test_content(self):
+        """Test content correctly set
+        """
+        # Define instance data
+        data = {
+            'name': 'jurisdiction name test data',
+            'region': factories.RegionFactory(),
+        }
+
+        # Create instance
+        instance = self.model.objects.create(**data)
+
+        # Assert content correctly set
+        for field in data.keys():
+            self.assertEqual(getattr(instance, field), data[field])
+
+
+# ViewSet Tests
+class CountryViewSetTest(APITestCase):
+    """Country viewset tests
+    """
+    databases = {'default', 'tenants'}
+
+    def setUp(self):
+        """Tests setup
+        """
+        self.endpoint = '/api/v1/countries/'
+        self.factory = factories.CountryFactory
+        self.model = models.Country
+
+    def test_not_logged_user_cannot_create_country(self):
+        """Not logged-in user cannot create new country
+        """
+        # Query endpoint
+        response = self.client.post(self.endpoint, data={})
+
+        # Assert access is forbidden
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+    def test_not_logged_user_cannot_modify_existing_country(self):
+        """Not logged-in user cannot modify existing country
+        """
+        # Create instance
+        instance = self.factory()
+
+        # Query endpoint
+        url = self.endpoint + f'{instance.pk}/'
+        response = self.client.put(url, {}, format='json')
+
+        # Assert forbidden code
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+    def test_not_logged_user_cannot_delete_existing_country(self):
+        """Not logged-in user cannot delete existing country
+        """
+        # Create instances
+        instance = self.factory()
+
+        # Query endpoint
+        url = self.endpoint + f'{instance.pk}/'
+        response = self.client.delete(url)
+
+        # Assert instance still exists on db
+        self.assertTrue(self.model.objects.get(id=instance.pk))
+
+    def test_not_logged_user_cannot_list_country(self):
+        """Not logged-in user can't read country
+        """
+        # Request list
+        # url = reverse(self.endpoint+'list')
+        response = self.client.get(self.endpoint)
+
+        # Assert access is forbidden
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+    def test_logged_user_can_list_country(self):
+        """Regular logged-in user can list country
+        """
+        # Create instances
+        user = TenantUserFactory()
+        instances = [self.factory() for n in range(random.randint(1,5))]
+
+        # Authenticate user
+        user.db = 'default'
+        self.client.force_authenticate(user=user)
+
+        # Request list
+        response = self.client.get(self.endpoint)
+
+        # Assert access is allowed
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        # Assert all instances are returned
+        self.assertEqual(len(instances), len(response.data['results']))
+
+    def test_logged_user_can_create_country(self):
+        """Regular logged-in user can create new country
+        """
+        # Define request data
+        data = {
+            'name': 'country name _test_ data',
+        }
+
+        # Authenticate user
+        user = TenantUserFactory()
+        user.db = 'default'
+        self.client.force_authenticate(user=user)
+
+        # Query endpoint
+        response = self.client.post(self.endpoint, data=data)
+        # Assert endpoint returns created status
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+
+        # Assert instance exists on db
+        self.assertTrue(self.model.objects.get(id=response.data['id']))
+
+    def test_logged_user_can_modify_existing_country(self):
+        """Regular logged-in user can modify existing country
+        """
+        # Create instances
+        instance = self.factory()
+
+        # Define request data
+        data = {
+            'name': 'country name _test_ data',
+        }
+
+        # Authenticate user
+        user = TenantUserFactory()
+        user.db = 'default'
+        self.client.force_authenticate(user=user)
+
+        # Query endpoint
+        url = self.endpoint + f'{instance.pk}/'
+        response = self.client.put(url, data=data, format='json')
+        # Assert endpoint returns OK code
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        # Assert instance has been modified
+        for key in data:
+            self.assertEqual(data[key], response.data[key])
+
+    def test_logged_user_can_delete_existing_country(self):
+        """Regular logged-in user can delete existing country
+        """
+        # Create instances
+        instance = self.factory()
+
+        # Authenticate user
+        user = TenantUserFactory()
+        user.db = 'default'
+        self.client.force_authenticate(user=user)
+
+        # Query endpoint
+        url = self.endpoint + f'{instance.pk}/'
+        response = self.client.delete(url)
+        # assert 204 no content
+        self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
+        # Assert instance doesn't exists anymore on db
+        self.assertFalse(self.model.objects.filter(id=instance.pk).exists())
+
+
+class RegionViewSetTest(APITestCase):
+    """Region viewset tests
+    """
+    databases = {'default', 'tenants'}
+
+    def setUp(self):
+        """Tests setup
+        """
+        self.endpoint = 'api-v1:region-'
+        self.factory = factories.RegionFactory
+        self.model = models.Region
+
+    def test_not_logged_user_cannot_create_region(self):
+        """Not logged-in user cannot create new region
+        """
+        # Query endpoint
+        url = reverse(self.endpoint+'list')
+        response = self.client.post(url, data={})
+
+        # Assert access is forbidden
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+    def test_not_logged_user_cannot_modify_existing_region(self):
+        """Not logged-in user cannot modify existing region
+        """
+        # Create instance
+        instance = self.factory()
+
+        # Query endpoint
+        url = reverse(self.endpoint+'detail', args=[instance.pk])
+        response = self.client.put(url, {}, format='json')
+
+        # Assert forbidden code
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+    def test_not_logged_user_cannot_delete_existing_region(self):
+        """Not logged-in user cannot delete existing region
+        """
+        # Create instances
+        instance = self.factory()
+
+        # Query endpoint
+        url = reverse(self.endpoint+'detail', args=[instance.pk])
+        response = self.client.delete(url)
+
+        # Assert instance still exists on db
+        self.assertTrue(self.model.objects.get(id=instance.pk))
+
+    def test_not_logged_user_cant_list_region(self):
+        """Not logged-in user can't read region
+        """
+        # Request list
+        url = reverse(self.endpoint+'list')
+        response = self.client.get(url)
+
+        # Assert access is forbidden
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+    def test_logged_user_can_list_region(self):
+        """Regular logged-in user can list region
+        """
+        # Create instances
+        user = TenantUserFactory()
+        instances = [self.factory() for n in range(random.randint(1,5))]
+
+        # Authenticate user
+        user.db = 'default'
+        self.client.force_authenticate(user=user)
+
+        # Request list
+        url = reverse(self.endpoint+'list')
+        response = self.client.get(url)
+
+        # Assert access is allowed
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        # Assert all instances are returned
+        self.assertEqual(len(instances), len(response.data['results']))
+
+    def test_logged_user_can_create_region(self):
+        """Regular logged-in user can create new region
+        """
+        # Define request data
+        data = {
+            'name': 'country name _test_ data',
+            'country': factories.CountryFactory().pk,
+        }
+
+        # Authenticate user
+        user = TenantUserFactory()
+        user.db = 'default'
+        self.client.force_authenticate(user=user)
+
+        # Query endpoint
+        url = reverse(self.endpoint+'list')
+        response = self.client.post(url, data=data)
+
+        # Assert endpoint returns created status
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+
+        # Assert instance exists on db
+        self.assertTrue(self.model.objects.get(id=response.data['id']))
+
+    def test_logged_user_can_modify_existing_region(self):
+        """Regular logged-in user can modify existing region
+        """
+        # Create instances
+        instance = self.factory()
+
+        # Define request data
+        data = {
+            'name': 'country name _test_ data',
+            'country': factories.CountryFactory().pk,
+            }
+
+        # Authenticate user
+        user = TenantUserFactory()
+        user.db = 'default'
+        self.client.force_authenticate(user=user)
+
+        # Query endpoint
+        url = reverse(self.endpoint+'detail', args=[instance.pk])
+        response = self.client.put(url, data, format='json')
+        # Assert endpoint returns OK code
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+    def test_logged_user_can_delete_existing_region(self):
+        """Regular logged-in user can delete existing region
+        """
+        # Create instances
+        instance = self.factory()
+
+        # Authenticate user
+        user = TenantUserFactory()
+        user.db = 'default'
+        self.client.force_authenticate(user=user)
+
+        # Query endpoint
+        url = reverse(self.endpoint+'detail', args=[instance.pk])
+        response = self.client.delete(url)
+
+        # assert 204 no content
+        self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
+        # Assert instance not exists anymore on db
+        self.assertFalse(self.model.objects.filter(id=instance.pk).exists())
+
+
+class CityViewSetTest(APITestCase):
+    """City viewset tests
+    """
+    databases = {'default', 'tenants'}
+
+    def setUp(self):
+        """Tests setup
+        """
+        self.endpoint = 'api-v1:city-'
+        self.factory = factories.CityFactory
+        self.model = models.City
+
+    def test_not_logged_user_cannot_create_city(self):
+        """Not logged-in user cannot create new city
+        """
+        # Query endpoint
+        url = reverse(self.endpoint+'list')
+        response = self.client.post(url, data={})
+
+        # Assert access is forbidden
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+    def test_not_logged_user_cannot_modify_existing_city(self):
+        """Not logged-in user cannot modify existing city
+        """
+        # Create instance
+        instance = self.factory()
+
+        # Query endpoint
+        url = reverse(self.endpoint+'detail', args=[instance.pk])
+        response = self.client.put(url, {}, format='json')
+
+        # Assert forbidden code
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+    def test_not_logged_user_cannot_delete_existing_city(self):
+        """Not logged-in user cannot delete existing city
+        """
+        # Create instances
+        instance = self.factory()
+
+        # Query endpoint
+        url = reverse(self.endpoint+'detail', args=[instance.pk])
+        response = self.client.delete(url)
+
+        # Assert instance still exists on db
+        self.assertTrue(self.model.objects.get(id=instance.pk))
+
+    def test_not_logged_user_cant_list_city(self):
+        """Not logged-in user can't read city
+        """
+        # Request list
+        url = reverse(self.endpoint+'list')
+        response = self.client.get(url)
+
+        # Assert access is forbidden
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+    def test_logged_user_can_list_city(self):
+        """Regular logged-in user can list city
+        """
+        # Create instances
+        user = TenantUserFactory()
+        instances = [self.factory() for n in range(random.randint(1,5))]
+
+        # Authenticate user
+        user.db = 'default'
+        self.client.force_authenticate(user=user)
+
+        # Request list
+        url = reverse(self.endpoint+'list')
+        response = self.client.get(url)
+
+        # Assert access is allowed
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        # Assert all instances are returned
+        self.assertEqual(len(instances), len(response.data['results']))
+
+    def test_logged_user_can_create_city(self):
+        """Regular logged-in user can create new city
+        """
+        # Define request data
+        data = {
+            'name': 'country name _test_ data',
+            'region': factories.RegionFactory().pk,
+        }
+
+        # Authenticate user
+        user = TenantUserFactory()
+        user.db = 'default'
+        self.client.force_authenticate(user=user)
+
+        # Query endpoint
+        url = reverse(self.endpoint+'list')
+        response = self.client.post(url, data=data)
+        # Assert endpoint returns created status
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+
+        # Assert instance exists on db
+        self.assertTrue(self.model.objects.get(id=response.data['id']))
+
+    def test_logged_user_can_modify_existing_city(self):
+        """Regular logged-in user can modify existing citycity
+        """
+        # Create instances
+        instance = self.factory()
+
+        # Define request data
+        data = {
+            'name': 'country name _test_ data',
+            'region': factories.RegionFactory().pk,
+            }
+
+        # Authenticate user
+        user = TenantUserFactory()
+        user.db = 'default'
+        self.client.force_authenticate(user=user)
+
+        # Query endpoint
+        url = reverse(self.endpoint+'detail', args=[instance.pk])
+        response = self.client.put(url, data, format='json')
+
+        # Assert endpoint returns OK code
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+    def test_logged_user_can_delete_existing_city(self):
+        """Regular logged-in user can delete existing city
+        """
+        # Create instances
+        instance = self.factory()
+
+        # Authenticate user
+        user = TenantUserFactory()
+        user.db = 'default'
+        self.client.force_authenticate(user=user)
+
+        # Query endpoint
+        url = reverse(self.endpoint+'detail', args=[instance.pk])
+        response = self.client.delete(url)
+
+        # Assert 204 no content
+        self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
+        # Assert instance doesn't exists on db anymore
+        self.assertFalse(self.model.objects.filter(id=instance.pk).exists())
+
+
+class JurisdictionViewSetTest(APITestCase):
+    """Jurisdiction viewset tests
+    """
+    databases = {'default', 'tenants'}
+
+    def setUp(self):
+        """Tests setup
+        """
+        self.endpoint = 'api-v1:jurisdiction-'
+        self.factory = factories.JurisdictionFactory
+        self.model = models.Jurisdiction
+
+    def test_not_logged_user_cannot_create_jurisdiction(self):
+        """Not logged-in user cannot create new city
+        """
+        # Query endpoint
+        url = reverse(self.endpoint+'list')
+        response = self.client.post(url, data={})
+
+        # Assert access is forbidden
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+    def test_not_logged_user_cannot_modify_existing_jurisdiction(self):
+        """Not logged-in user cannot modify existing city
+        """
+        # Create instance
+        instance = self.factory()
+
+        # Query endpoint
+        url = reverse(self.endpoint+'detail', args=[instance.pk])
+        response = self.client.put(url, {}, format='json')
+
+        # Assert forbidden code
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+    def test_not_logged_user_cannot_delete_existing_jurisdiction(self):
+        """Not logged-in user cannot delete existing city
+        """
+        # Create instances
+        instance = self.factory()
+
+        # Query endpoint
+        url = reverse(self.endpoint+'detail', args=[instance.pk])
+        response = self.client.delete(url)
+
+        # Assert instance still exists on db
+        self.assertTrue(self.model.objects.get(id=instance.pk))
+
+    def test_not_logged_user_cant_list_jurisdiction(self):
+        """Not logged-in user can't read city
+        """
+        # Request list
+        url = reverse(self.endpoint+'list')
+        response = self.client.get(url)
+
+        # Assert access is forbidden
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+    def test_logged_user_can_list_jurisdiction(self):
+        """Regular logged-in user can list city
+        """
+        # Create instances
+        user = TenantUserFactory()
+        instances = [self.factory() for n in range(random.randint(1,5))]
+
+        # Authenticate user
+        user.db = 'default'
+        self.client.force_authenticate(user=user)
+
+        # Request list
+        url = reverse(self.endpoint+'list')
+        response = self.client.get(url)
+
+        # Assert access is allowed
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        # Assert all instances are returned
+        self.assertEqual(len(instances), len(response.data['results']))
+
+    def test_logged_user_can_create_jurisdiction(self):
+        """Regular logged-in user can create new city
+        """
+        # Define request data
+        data = {
+            'name': 'jurisdiction name test data',
+            'region': factories.RegionFactory().pk,
+        }
+
+        # Authenticate user
+        user = TenantUserFactory()
+        user.db = 'default'
+        self.client.force_authenticate(user=user)
+
+        # Query endpoint
+        url = reverse(self.endpoint+'list')
+        response = self.client.post(url, data=data)
+
+        # Assert endpoint returns created status
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+
+        # Assert instance exists on db
+        self.assertTrue(self.model.objects.get(id=response.data['id']))
+
+    def test_logged_user_can_modify_existing_jurisdiction(self):
+        """Regular logged-in user can modify existing citycity
+        """
+        # Create instances
+        instance = self.factory()
+
+        # Define request data
+        data = {
+            'name': 'jurisdiction name test MOD data',
+            'region': factories.RegionFactory().pk,
+        }
+
+        # Authenticate user
+        user = TenantUserFactory()
+        user.db = 'default'
+        self.client.force_authenticate(user=user)
+
+        # Query endpoint
+        url = reverse(self.endpoint+'detail', args=[instance.pk])
+        response = self.client.put(url, data, format='json')
+
+        # Assert endpoint returns OK code
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        # Assert instance has been modified
+        for key in data:
+            self.assertEqual(data[key], response.data[key])
+
+    def test_logged_user_can_delete_existing_jurisdiction(self):
+        """Regular logged-in user can delete existing city
+        """
+        # Create instances
+        instance = self.factory()
+
+        # Authenticate user
+        user = TenantUserFactory()
+        user.db = 'default'
+        self.client.force_authenticate(user=user)
+
+        # Query endpoint
+        url = reverse(self.endpoint+'detail', args=[instance.pk])
+        response = self.client.delete(url)
+
+        # Assert 204 no content
+        self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
+        # Assert instance not exists anymore on db
+        self.assertFalse(self.model.objects.filter(id=instance.pk).exists())
+

geo/views.py

@@ -0,0 +1,72 @@
+from rest_framework.response import Response
+from tenants.views import CustomViewSet, CustomExternalViewSet
+from rest_framework import viewsets, status
+from rest_framework.decorators import permission_classes
+from legalq.permissions import GlobalAccess
+
+from . import models
+from . import serializers
+
+
+class CountryViewSet(CustomExternalViewSet):
+    model = models.Country
+    read_serializer_class = serializers.CountryReadSerializer
+    write_serializer_class = serializers.CountryWriteSerializer
+    model_name = 'country'
+    queryset = models.Country.objects.all()
+    filterset_fields = ('name', )
+
+    def retrieve(self, request, *args, **kwargs):
+        instance = models.Country.objects.filter(pk=kwargs['pk']).first()
+        if instance is not None:
+            serializer = self.read_serializer_class(instance)
+            return Response(serializer.data)
+        return Response(status=status.HTTP_404_NOT_FOUND)
+
+    permission_classes = [GlobalAccess]
+
+
+class RegionViewSet(viewsets.ReadOnlyModelViewSet):
+    model = models.Region
+    serializer_class = serializers.RegionReadSerializer
+    write_serializer_class = serializers.RegionWriteSerializer
+    model_name = 'region'
+    queryset = models.Region.objects.all()
+    filterset_fields = ('name', 'country__name')
+
+    permission_classes = [GlobalAccess]
+
+
+class ProvinceViewSet(CustomExternalViewSet):
+    model = models.Province
+    read_serializer_class = serializers.ProvinceReadSerializer
+    model_name = 'region'
+    queryset = models.Province.objects.all()
+    filterset_fields = ('name', 'region__country__name')
+
+    def retrieve(self, request, *args, **kwargs):
+        instance = models.Province.objects.filter(pk=kwargs['pk']).first()
+        if instance is not None:
+            serializer = self.read_serializer_class(instance)
+            return Response(serializer.data)
+        return Response(status=status.HTTP_404_NOT_FOUND)
+
+    permission_classes = [GlobalAccess]
+
+
+class CityViewSet(CustomExternalViewSet):
+    model = models.City
+    read_serializer_class = serializers.CityReadSerializer
+    write_serializer_class = serializers.CityWriteSerializer
+    model_name = 'city'
+    queryset = models.City.objects.all()
+
+    def retrieve(self, request, *args, **kwargs):
+        instance = models.City.objects.filter(pk=kwargs['pk']).first()
+        if instance is not None:
+            serializer = self.read_serializer_class(instance)
+            return Response(serializer.data)
+        return Response(status=status.HTTP_404_NOT_FOUND)
+
+    permission_classes = [GlobalAccess]
+    filterset_fields = ('name', 'province__name', 'province__region__name')