survey api

account/api.py

@@ -23,7 +23,7 @@ class UserModelViewSet(ModelViewSet):
     serializer_class = UserSerializer
     serializer_classes = {
         "signin": SignInSerializer,
-        "create": SignUpSerializer,
+        #"create": SignUpSerializer,
     }
 
     def get_serializer_class(self):
@@ -71,7 +71,7 @@ def list(self, request, *args, **kwargs):
         return Response(serializer.data, status=status.HTTP_200_OK)
 
     @list_route(methods=['post'])
-    def signin(self, request, version):
+    def signin(self, request):
         print(request.data.get("email"))
         print(request.data.get("password"))
         user = authenticate(

nostromo/api.py

@@ -22,10 +22,19 @@ def create(self, request, *args, **kwargs):
 
         processed = 0
         success = 0
-        converted_data = json.loads(request.data)
+        converted_data = request.data
+        if not isinstance(converted_data,list):
+            converted_data = [converted_data]
+        #converted_data = json.loads(request.data)
         for data in converted_data:
-            start_date = datetime.utcfromtimestamp(data['start']/1000)
-            end_date = datetime.utcfromtimestamp(data['end']/1000)
+            if 'start' in data.keys():
+                start_date = datetime.utcfromtimestamp(int(data['start'])/1000)
+            elif 'start_date' in data.keys():
+                start_date = datetime.strptime(data['start_date'], "%Y-%m-%dT%H:%M")
+            if 'end' in data.keys():
+                start_date = datetime.utcfromtimestamp(int(data['end'])/1000)
+            elif 'end_date' in data.keys():
+                end_date = datetime.strptime(data['end_date'], "%Y-%m-%dT%H:%M")
             data_type = data["type"]
 
             if not DataSet.objects.filter(type=data_type, start_date=start_date, end_date=end_date, user=request.user).exists():

nostromo/api_urls.py

@@ -3,10 +3,13 @@
 from rest_framework import routers
 from account.api import UserModelViewSet
 from nostromo.api import DataSetPushView
+from survey.api import SurveysViewSet,SpecificSurveyViewSet
 
 api_router = routers.DefaultRouter()
 api_router.register(r'account', UserModelViewSet, base_name="account")
 api_router.register(r'push', DataSetPushView, base_name="push")
+api_router.register(r'surveys', SurveysViewSet, base_name="surveys")
+api_router.register(r'survey', SpecificSurveyViewSet, base_name="survey")
 
 urlpatterns = [
     url(r'^auth/', include('rest_framework.urls', namespace='rest_framework')),

survey/api.py

@@ -0,0 +1,64 @@
+import logging
+
+from datetime import datetime
+
+from rest_framework.permissions import IsAuthenticated
+from rest_framework import status, viewsets, mixins
+from rest_framework.response import Response
+
+from survey.models import UserSurvey
+from survey.serializers import UserSurveysSerializer
+import json
+from rest_framework.decorators import detail_route
+
+
+logger = logging.getLogger("api")
+
+class SurveysViewSet(mixins.ListModelMixin,viewsets.GenericViewSet):
+    serializer_class = UserSurveysSerializer
+    def get_permissions(self):
+        return [IsAuthenticated()]
+
+    def list(self, request, *args, **kwargs):
+        k = super().list(request, *args, **kwargs)
+        k.data = k.data['results']
+        return k
+
+
+    def get_queryset(self):
+        if self.request.user.is_authenticated():
+            qs = UserSurvey.objects.filter(user=self.request.user)
+            passed = self.request.query_params.get("passed", None)
+            if passed :
+                if passed == 'true':
+                    qs = qs.filter(passed_at__isnull=False)
+                elif passed == 'false':
+                    qs = qs.filter(passed_at__isnull=True)
+            new = self.request.query_params.get("new", None)
+            if new :
+                if new == 'true':
+                    qs = qs.filter(new=True)
+                elif new == 'false':
+                    qs = qs.filter(new=False)
+            return qs
+
+        return UserSurvey.objects.none()
+
+
+class SpecificSurveyViewSet(mixins.RetrieveModelMixin,viewsets.GenericViewSet):
+    serializer_class = UserSurveysSerializer
+
+    def get_permissions(self):
+        return [IsAuthenticated()]
+
+    def retrieve(self, request,pk=None):
+        if pk:
+            qs = UserSurvey.objects.filter(user=self.request.user,pk=pk)
+            if qs.exists():
+
+                serializer = self.serializer_class(qs.last())
+                return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response({"error": "Wrong input", "error_code": "303"},
+                        status=status.HTTP_400_BAD_REQUEST)
+
+

survey/models.py

@@ -1,17 +1,25 @@
 from django.contrib.postgres.fields import JSONField
 from django.db import models
 
-
 class Survey(models.Model):
     title = models.CharField(max_length=128)
 
+    def __unicode__(self):
+        return '%s' % self.title
+
 
 class UserSurvey(models.Model):
     survey = models.ForeignKey(Survey)
     user = models.ForeignKey("account.User")
     passed_at = models.DateTimeField(null=True, blank=True)
     new = models.BooleanField(default=True)
 
+    def get_questions_count(self):
+        return self.survey.question_set.all().count()
+    def get_questions_list(self):
+        qs = self.survey.question_set.all()
+        return qs
+
 
 class QuestionType(models.Model):
     idx = models.IntegerField(primary_key=True)

survey/serializers.py

@@ -0,0 +1,66 @@
+from rest_framework import serializers
+from survey.models import UserSurvey,Question,Survey,Answer
+
+
+class AnswerSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Answer
+        fields = ('answer_text',)
+
+class QuestionSerializer(serializers.ModelSerializer):
+    question= serializers.ReadOnlyField(source='question_text')
+    type = serializers.ReadOnlyField(source='type.text')
+    #choices = serializers.ReadOnlyField(source='possible_answers')
+    class Meta:
+        model = Question
+        fields = ('id','question','type',)
+
+    def to_representation(self, instance):
+        k = super().to_representation(instance)
+        user_id = self._kwargs['context']['user_id']
+        objs = Answer.objects.filter(user_id=user_id,question=instance)
+        if instance.possible_answers:
+            k['choices'] = instance.possible_answers
+        if objs.exists():
+            serializer = AnswerSerializer(objs.last())
+            k['answer'] = serializer.data['answer_text']
+        return k
+
+
+class SurveysSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Survey
+
+class QuestionRelatedField(serializers.PrimaryKeyRelatedField):
+    def to_representation(self, value):
+        if 'request' in self.root.context.keys():
+            idx = self.root.context['request'].user.id
+            context = {'user_id':idx}
+        else:
+            context = self.root.get_extra_kwargs()
+        serializer = QuestionSerializer(value,context=context)
+        return serializer.data
+
+
+class UserSurveysSerializer(serializers.ModelSerializer):
+
+    title = serializers.ReadOnlyField(source='survey.title')
+    id = serializers.ReadOnlyField(source='survey.id')
+    questions_count = serializers.ReadOnlyField(source='get_questions_count')
+    questions = QuestionRelatedField(source='get_questions_list',read_only=True,many=True)
+
+    class Meta:
+        model = UserSurvey
+        fields = ('id','title','passed_at','questions_count','questions',)
+
+
+    def get_extra_kwargs(self):
+        k = super().get_extra_kwargs()
+        if self.instance:
+            if isinstance(self.instance,list):
+                k['user_id'] = self.instance[0].user.id
+            else:
+                k['user_id'] = self.instance.user.id
+        return k
+
+