Feature/initial project

.dockerignore

@@ -0,0 +1,28 @@
+**/__pycache__
+**/.venv
+**/.classpath
+**/.dockerignore
+**/.env
+**/.git
+**/.gitignore
+**/.project
+**/.settings
+**/.toolstarget
+**/.vs
+**/.vscode
+**/*.*proj.user
+**/*.dbmdl
+**/*.jfm
+**/bin
+**/charts
+**/docker-compose*
+**/compose*
+**/Dockerfile*
+**/node_modules
+**/npm-debug.log
+**/obj
+**/secrets.dev.yaml
+**/values.dev.yaml
+LICENSE
+README.md
+/postgres-data/

.github/workflows/run-tests.yml

@@ -16,26 +16,23 @@ jobs:
 
 
     steps:
-    - uses: actions/checkout@v2
-    - name: Set up Python 
-      uses: actions/setup-python@v2
+    - uses: actions/checkout@v3
+    - name: Set up Python
+      uses: actions/setup-python@v3
       with:
         python-version: 3.10.4
     - name: Install required Ubuntu packages
       run: |
-        sudo apt-get install gdal-bin
-
-    # - name: Create needed postgis extensions
-    #  run: |
-    #    psql -h localhost -U postgres template1 -c 'create extension postgis;'
+        sudo apt-get update && sudo apt-get install gdal-bin
+
     - name: Install PyPI dependencies
       run: |
         python -m pip install --upgrade pip
         pip install -r requirements.txt
     - name: Run Python side code neatness tests
       run: |
         flake8
-        black --check .
+        # black --check .
         isort . -c
     - name: Run pytest code functionality tests
       run: |
@@ -45,7 +42,7 @@ jobs:
         pip install coverage
         coverage report -m
     - name: Upload Coverage to Codecov
-      uses: codecov/codecov-action@v2  
+      uses: codecov/codecov-action@v3 
     # Majority of the tests require database
     services:
       # Label used to access the service container

.gitignore

@@ -127,3 +127,9 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+
+# static files
+static/
+
+# Django project
+.django_secret

README.md

@@ -1,2 +1,54 @@
-# mpbackend
-Mobility Profile Backend
+# Mobility Profile Backend
+This is the backend for the Mobility Profile
+
+## Installation with Docker Compose
+First configure development environment settings as stated in `config_dev.env.example`. 
+
+### Running the application
+Run application with `docker-compose up`
+This will startup and bind local postgres and mobilityprofile backend. 
+
+### Runnig the application in production
+docker-compose -f docker-compose.yml -f docker-compose.prod.yml up
+
+### Importing questions
+To import questions run: `docker-compose run mpbackend import_questions`
+
+
+## Installation without Docker
+1.
+First, install the necessary Debian packages.
+TODO, add packages.
+
+2. Clone the repository.
+```
+git clone https://github.com/City-of-Turku/mpbackend.git
+```
+3. Install python 3.10 and  pip requiremends
+Be sure to load the **environment** before installing the requirements.
+```
+pip install pip-tools
+pip install -r requirements.txt
+```
+4. Setup the PostGIS database.
+
+Please note, we recommend PostgreSQL version 13 or higher.
+Local setup:
+
+```
+sudo su postgres
+psql template1 -c 'CREATE EXTENSION IF NOT EXISTS postgis;'
+createuser -RSPd mobilityprofile
+createdb -O mobilityprofile -T template1 -l fi_FI.UTF-8 -E utf8 mobilityprofile
+```
+
+5. Create database tables.
+```
+./manage.py migrate
+```
+
+6. Import questions
+```
+./manage.py import_questions
+```
+

account/admin.py

@@ -0,0 +1,54 @@
+from django import forms
+from django.contrib import admin
+
+from .models import MailingList, Profile, User
+
+admin.site.register(User)
+
+
+class ProfileAdmin(admin.ModelAdmin):
+    list_display = ("user", "result")
+
+    def result(self, obj):
+        if obj.user.result:
+            return obj.user.result.value
+        else:
+            return None
+
+
+class MailingListAdminForm(forms.ModelForm):
+    csv_emails = forms.CharField(widget=forms.Textarea(attrs={"rows": 20, "cols": 120}))
+
+    class Meta:
+        model = MailingList
+        fields = ["result"]
+
+
+class MailingListAdmin(admin.ModelAdmin):
+    list_display = ("result", "csv_emails")
+
+    readonly_fields = ("result",)
+    form = MailingListAdminForm
+
+    def csv_emails(self, obj):
+        return obj.csv_emails
+
+    def get_form(self, request, obj=None, **kwargs):
+        form = super().get_form(request, obj, **kwargs)
+        form.base_fields["csv_emails"].initial = self.csv_emails(obj)
+        return form
+
+    def change_view(self, request, object_id, form_url="", extra_context=None):
+        extra_context = extra_context or {}
+        extra_context["show_save_and_add_another"] = False
+        extra_context["show_save_and_continue"] = False
+        return super().change_view(
+            request, object_id, form_url, extra_context=extra_context
+        )
+
+    def has_delete_permission(self, request, obj=None):
+        return False
+
+
+admin.site.register(Profile, ProfileAdmin)
+admin.site.register(MailingList, MailingListAdmin)

account/api/serializers.py

@@ -0,0 +1,55 @@
+from django.contrib.auth import get_user_model
+from rest_framework import serializers
+
+from account.models import MailingListEmail, Profile
+
+
+class SubscribeSerializer(serializers.Serializer):
+    email = serializers.CharField()
+    result = serializers.IntegerField()
+
+
+class UnSubscribeSerializer(serializers.Serializer):
+    email = serializers.CharField()
+
+
+class PublicUserSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = get_user_model()
+        fields = ["id"]
+
+
+class UserSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = get_user_model()
+        fields = [
+            "id",
+            "username",
+            "email",
+            "first_name",
+            "last_name",
+            "last_login",
+            "date_joined",
+            "is_staff",
+            "is_active",
+            "email_verified",
+        ]
+
+
+class ProfileSerializer(serializers.HyperlinkedModelSerializer):
+    class Meta:
+        model = Profile
+        fields = [
+            "id",
+            "year_of_birth",
+            "postal_code",
+            "optional_postal_code",
+            "is_filled_for_fun",
+            "result_can_be_used",
+        ]
+
+
+class MailingListEmailSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = MailingListEmail
+        fields = "__all__"

account/api/urls.py

@@ -0,0 +1,13 @@
+from django.urls import include, path
+from rest_framework import routers
+
+from . import views
+
+app_name = "account"
+
+# Create a router and register our viewsets with it.
+router = routers.DefaultRouter()
+router.register("profile", views.ProfileViewSet, "profiles")
+
+# The API URLs are now determined automatically by the router.
+urlpatterns = [path("", include(router.urls), name="account")]

account/api/views.py

@@ -0,0 +1,122 @@
+from django import db
+from django.core.exceptions import ValidationError
+from django.core.validators import validate_email
+from drf_spectacular.utils import extend_schema, OpenApiResponse
+from rest_framework import status, viewsets
+from rest_framework.decorators import action
+from rest_framework.mixins import UpdateModelMixin
+from rest_framework.permissions import AllowAny, IsAuthenticated
+from rest_framework.response import Response
+from rest_framework.throttling import AnonRateThrottle
+
+from account.models import MailingList, MailingListEmail, Profile
+from profiles.models import Result
+
+from .serializers import ProfileSerializer, SubscribeSerializer, UnSubscribeSerializer
+
+all_views = []
+
+
+class UnsubscribeRateThrottle(AnonRateThrottle):
+    """
+    The AnonRateThrottle will only ever throttle unauthenticated users.
+    The IP address of the incoming request is used to generate a unique key to throttle against.
+    """
+
+    rate = "10/day"
+
+
+class ProfileViewSet(UpdateModelMixin, viewsets.GenericViewSet):
+    queryset = Profile.objects.all().select_related("user").order_by("id")
+    serializer_class = ProfileSerializer
+
+    def get_permissions(self):
+        if self.action in ["unsubscribe"]:
+            permission_classes = [AllowAny]
+        else:
+            permission_classes = [IsAuthenticated]
+
+        return [permission() for permission in permission_classes]
+
+    def update(self, request, *args, **kwargs):
+        user = request.user
+        instance = user.profile
+        serializer = self.serializer_class(
+            instance=instance, data=request.data, partial=True
+        )
+        if serializer.is_valid():
+            serializer.save()
+            return Response(data=serializer.data, status=status.HTTP_200_OK)
+        else:
+            return Response(data=serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @extend_schema(
+        description="Subscribe the email to the mailing list attached to the result.",
+        request=SubscribeSerializer,
+        responses={
+            201: OpenApiResponse(description="subscribed"),
+            400: OpenApiResponse(
+                description="Validation error, detailed information in response"
+            ),
+        },
+    )
+    @action(
+        detail=False,
+        methods=["POST"],
+        permission_classes=[IsAuthenticated],
+    )
+    @db.transaction.atomic
+    def subscribe(self, request):
+        result = Result.objects.filter(id=request.data.get("result", None)).first()
+        if not result:
+            return Response("'result' not found", status=status.HTTP_400_BAD_REQUEST)
+
+        email = request.data.get("email", None)
+        if not email:
+            return Response("No 'email' provided", status=status.HTTP_400_BAD_REQUEST)
+        if MailingListEmail.objects.filter(email=email).count() > 0:
+            return Response("'email' exists", status=status.HTTP_400_BAD_REQUEST)
+        try:
+            validate_email(email)
+        except ValidationError as e:
+            return Response(f"Invalid email: {e}", status=status.HTTP_400_BAD_REQUEST)
+        mailing_list = MailingList.objects.filter(result=result).first()
+        if not mailing_list:
+            # In case mailing list is not created for the result, it is created.
+            mailing_list = MailingList.objects.create(result=result)
+
+        MailingListEmail.objects.create(mailing_list=mailing_list, email=email)
+        return Response("subscribed", status=status.HTTP_201_CREATED)
+
+    @extend_schema(
+        description="Unaubscribe the email from the mailing list attached to the result."
+        f"Note, there is a rate-limit of {UnsubscribeRateThrottle.rate} requests.",
+        request=UnSubscribeSerializer,
+        responses={
+            200: OpenApiResponse(description="unsubscribed"),
+            400: OpenApiResponse(
+                description="Validation error, detailed information in response"
+            ),
+        },
+    )
+    @action(
+        detail=False,
+        methods=["POST"],
+        permission_classes=[AllowAny],
+        throttle_classes=[UnsubscribeRateThrottle],
+    )
+    def unsubscribe(self, request):
+        email = request.data.get("email", None)
+        if not email:
+            return Response("No 'email' provided", status=status.HTTP_400_BAD_REQUEST)
+        qs = MailingListEmail.objects.filter(email=email)
+        if not qs.exists():
+            return Response(
+                f"{email} does not exists", status=status.HTTP_400_BAD_REQUEST
+            )
+
+        qs.delete()
+        return Response(f"unsubscribed {email}", status=status.HTTP_200_OK)
+
+
+all_views.append({"class": ProfileViewSet, "name": "profile"})

account/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class AccountConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "account"