class OrderListLocationsSerializer(serializers.ModelSerializer): origin = LocationSerializer() destiny = LocationSerializer() class Meta: model = Order fields = ('origin', 'destiny')
def test_wifi_location_from_json(self): """Test that a wifi location can be deserialized from json""" location_name = "Arco do CegoS" request = { "name": location_name, "creation_date": "2017-04-30T14:19:35.505954Z", "coordinate": { "wifiSSIDs": [{ "name": "edurom" }, { "name": "thompson" }, { "name": "house" }], "type": "WIFI" } } #data = JSONParser().parse(json) serializer = LocationSerializer(data=request) if serializer.is_valid(): u1 = User.objects.get(username="******") serializer.save(user=u1) l = Location.objects.get(name=location_name) self.assertEqual(l.name, location_name, "Correct location created") self.assertEqual(l.coordinate.type, "WIFI", "Correct coordinate added") for ssid in l.coordinate.wificoordinate.ssid_set.all(): self.assertIn(ssid.name, self.ssids_arco, "The ssids are persisted") else: self.fail(serializer.errors)
def put(self, request, pk, format=None): location = self.get_object(pk) serializer = LocationSerializer(location, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): serializer = LocationSerializer(data=request.data, many=True) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.error_messages, status=status.HTTP_400_BAD_REQUEST)
class OrderListSerializer(serializers.ModelSerializer): driver = DriverListSerializer() truck = TruckSerializer() origin = LocationSerializer() destiny = LocationSerializer() class Meta: model = Order exclude = ('created', 'updated')
def post(self, request, format=None): ##############JSON_GEO Post data###################### new_location = GeojsonParser(request.data) new_data = new_location.set() ###################################################### serializer = LocationSerializer(data=new_data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create_location(request): serializer = LocationSerializer(data=request.data["data"]) if serializer.is_valid(): serializer.save(user=request.user) return Response(JSONResponse().addData("Location", serializer.data).addData( "status", "Location created!").send(), status=status.HTTP_201_CREATED) else: return Response(JSONResponse().addError( 0, "Location could not be created").addError( 1, serializer.errors).send(), status=status.HTTP_400_BAD_REQUEST)
class UpdateUserSerializer(serializers.ModelSerializer): current_location = LocationSerializer(many=False) other_user = SimpleUserSerializer(many=False) class Meta: model = User fields = ['matchable', 'current_location', 'other_user']
class DetailUserSerializer(serializers.ModelSerializer): current_location = LocationSerializer(many=False, read_only=True) other_user = SimpleUserSerializer(many=False, read_only=True) class Meta: model = User fields = ['username', 'email', 'matchable', 'current_location', 'other_user']
def get_proposed_locations(self, match): proposed_locations = [] for location in match.proposed_locations.all(): proposed_locations.append(LocationSerializer(location).data) if proposed_locations == []: return None return proposed_locations
class UserSerializer(serializers.ModelSerializer): sub_categories = SubCategoriesSerializer(many=True, read_only=True) current_location = LocationSerializer(many=False, read_only=True) avatar_url = serializers.SerializerMethodField('validate_avatar_url') # document_proof = serializers.SerializerMethodField('validate_document_url') class Meta: model = User # depth = 1 fields = [ 'id', 'mobile_no', 'rating', 'name', 'avatar_url', 'is_vendor', 'business_name', 'business_description', 'is_admin', 'current_location', 'sub_categories' ] def validate_avatar_url(self, user): image = user.avatar_url if image: new_url = image.url if "?" in new_url: new_url = image.url[:image.url.rfind("?")] return new_url else: image = None return image
def post(self, request, pk): # Add location Data location_data = { "location": request.data['location'], "address": request.data['address'], "x_coord": request.data['x_coord'], "y_coord": request.data['y_coord'], } location_serializer = LocationSerializer(data=location_data) location_in_db = Location.objects.filter( location=request.data['location']) if not location_in_db: if location_serializer.is_valid(): location_serializer.save() location_id = location_serializer.data['id'] else: return Response(location_serializer.errors, status=status.HTTP_400_BAD_REQUEST) else: location_id = location_in_db.get().id # Add Case location visit history Data case_locations_data = { 'case': pk, 'location': location_id, 'date_from': request.data['date_from'], 'date_to': request.data['date_to'], 'category': request.data['category'] } case_locations_serializer = CaseLocationSerializer( data=case_locations_data) if case_locations_serializer.is_valid(): case_locations_serializer.save() return Response(case_locations_serializer.data, status=status.HTTP_201_CREATED) else: return Response(case_locations_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class PostRetrieveSerializer(serializers.ModelSerializer): image = serializers.SerializerMethodField() def get_image(self, post): return get_absolute_uri(self, post) location = LocationSerializer() class Meta: model = Post fields = [ 'id', 'user', 'image', 'description', 'location', 'like', 'slug' ]
def post(self, request, pk): # Add location Data location_data = { "location": request.data['location'], "address": request.data['address'], "x_coord": request.data['x_coord'], "y_coord": request.data['y_coord'], } location_serializer = LocationSerializer(data=location_data) if location_serializer.is_valid(): location_serializer.save() else: return Response(location_serializer.errors, status=status.HTTP_400_BAD_REQUEST) # Add Case location visit history Data location_history_data = { 'case': pk, 'location': location_serializer.data['id'], 'date_from': request.data['date_from'], 'date_to': request.data['date_to'], 'category': request.data['category'] } location_history_serializer = LocationVisitHistorySerializer( data=location_history_data) if location_history_serializer.is_valid(): location_history_serializer.save() return Response(location_history_serializer.data, status=status.HTTP_201_CREATED) else: return Response(location_history_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class ProjectSerializer(serializers.ModelSerializer): descriptions = serializers.SerializerMethodField() members = serializers.SerializerMethodField() media = MediaSerializer(many=True, ) contacts = ContactSerializer(many=True, ) abilities = AbilitySerializer(many=True, ) keywords = KeywordSerializer(many=True, ) schedule = ProjectScheduleSerializer() location = LocationSerializer() class Meta: model = Project fields = ( 'id', 'title', 'descriptions', 'profile_image', 'started_at', 'ends_at', 'media', 'contacts', 'abilities', 'keywords', 'schedule', 'location', 'members', ) def get_descriptions(self, obj): descriptions = ProjectDescription.objects.filter(project=obj.id) return ProjectDescriptionSerializer(descriptions, many=True).data def get_members(self, obj): members = ProjectMember.objects.filter( project=obj.id, is_active=True, ) return ProjectMemberSerializer(members, many=True).data
class UserSerializer(serializers.ModelSerializer): """Serializer with current match.""" net_id = serializers.CharField(source="person.net_id") majors = MajorSerializer(source="person.majors", many=True) hometown = serializers.CharField(source="person.hometown") profile_pic_url = serializers.CharField(source="person.profile_pic_url") facebook_url = serializers.CharField(source="person.facebook_url") instagram_username = serializers.CharField( source="person.instagram_username") graduation_year = serializers.CharField(source="person.graduation_year") pronouns = serializers.CharField(source="person.pronouns") purposes = PurposeSerializer(source="person.purposes", many=True) availability = SerializerMethodField("get_availability") locations = LocationSerializer(source="person.locations", many=True) interests = InterestSerializer(source="person.interests", many=True) groups = GroupSerializer(source="person.groups", many=True) prompts = SerializerMethodField("get_prompts") has_onboarded = serializers.BooleanField(source="person.has_onboarded") pending_feedback = serializers.BooleanField( source="person.pending_feedback") current_match = serializers.SerializerMethodField("get_current_match") deleted = serializers.BooleanField(source="person.soft_deleted") blocked_users = SerializerMethodField("get_blocked_users") is_paused = serializers.BooleanField(source="person.is_paused") pause_expiration = serializers.DateTimeField( source="person.pause_expiration") last_active = serializers.DateTimeField(source="person.last_active") def get_availability(self, user): if user.person.availability is None: return [] availability = json.loads(user.person.availability) return availability def get_current_match(self, user): blocked_ids = user.person.blocked_users.values_list("id", flat=True) matches = Match.objects.filter(Q(user_1=user) | Q( user_2=user)).order_by("-created_date") if (len(matches) == 0 or matches[0].user_1.id in blocked_ids or matches[0].user_2.id in blocked_ids): return None return MatchSerializer(matches.first(), user=user).data def get_prompts(self, user): prompt_questions = user.person.prompt_questions.all() prompt_answers = user.person.prompt_answers if prompt_answers is None: return [] prompt_answers = json.loads(prompt_answers) prompts = [] for question_index in range(len(prompt_questions)): prompts.append({ "id": prompt_questions[question_index].id, "question_name": prompt_questions[question_index].question_name, "question_placeholder": prompt_questions[question_index].question_placeholder, "answer": prompt_answers[question_index], }) return prompts def get_blocked_users(self, user): return map(lambda u: u.id, user.person.blocked_users.all()) class Meta: model = User fields = ( "id", "net_id", "first_name", "last_name", "majors", "hometown", "profile_pic_url", "facebook_url", "instagram_username", "graduation_year", "pronouns", "purposes", "availability", "locations", "interests", "groups", "prompts", "has_onboarded", "deleted", "pending_feedback", "current_match", "blocked_users", "is_paused", "pause_expiration", "last_active", ) read_only_fields = fields
class SimpleUserSerializer(serializers.ModelSerializer): current_location = LocationSerializer(many=False) class Meta: model = User fields = ['matchable', 'current_location', 'id', 'email']
def get_meeting_location(self, match): meeting_location = LocationSerializer(match.meeting_location).data if meeting_location == {}: return None return meeting_location
def get(self, request): locations = Location.objects.all() serializer = LocationSerializer(locations, many=True) return Response({"data": serializer.data}, status=status.HTTP_200_OK)
def get_location(self, obj): if obj.location: return LocationSerializer(obj.location.all(), many=True).data return None
def post(self, request, format=None): serializer = LocationSerializer(data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request): last = Location.objects.last() serializer = LocationSerializer(last) return Response(serializer.data, status=status.HTTP_200_OK)
def list_locations(request): serializer = LocationSerializer(Location.objects.all(), many=True) return Response(JSONResponse().addData("Locations", serializer.data).send(), status=status.HTTP_200_OK)
def get_proposed_locations(self, match): return (LocationSerializer(match.proposed_locations.all(), many=True).data or None)
def get_meeting_location(self, match): meeting_location = LocationSerializer(match.meeting_location).data return meeting_location or None
def post(self, request): user_field = [ 'id', 'username', 'password', 'email', 'first_name', 'last_name', 'date_joined', 'last_login', 'user_type', 'bazaar_point', 'company' ] user_dict = {} location_dict = {} for fields in request.data: if fields in user_field: user_dict[fields] = request.data[fields] else: location_dict[fields] = request.data[fields] serializer = UserSerializer(data=user_dict) if serializer.is_valid(): # There error handling part might not be required, additional test is needed if not "user_type" in serializer.validated_data.keys(): return Response({"user_type": ["This field is required."]}, status=status.HTTP_400_BAD_REQUEST) if not "username" in serializer.validated_data.keys(): return Response({"username": ["This field is required."]}, status=status.HTTP_400_BAD_REQUEST) if not "password" in serializer.validated_data.keys(): return Response({"password": ["This field is required."]}, status=status.HTTP_400_BAD_REQUEST) email = serializer.validated_data['username'] serializer.save() user = User.objects.get(username=email) if request.data['user_type'] == 2 or request.data[ 'user_type'] == '2': if not "company" in request.data: user.delete() return Response({"company": ["This field is required."]}, status=status.HTTP_400_BAD_REQUEST) location_dict['user'] = user.id serializer2 = LocationSerializer(data=location_dict) if serializer2.is_valid(): serializer2.save() else: user.delete() return Response({"location": ["bad location request."]}, status=status.HTTP_400_BAD_REQUEST) user.is_active = False user.save() uidb64 = urlsafe_base64_encode(force_bytes(user.pk)) domain = get_current_site(request).domain # link = reverse('activate', kwargs={'uidb64': uidb64}) activate_url = 'http://' + "3.121.223.52:3000" + "/activate=" + str( uidb64) email_subject = 'Activate' email_body = 'Hi,\nPlease use this link to verify your account:\n' + activate_url email = EmailMessage( email_subject, email_body, '*****@*****.**', [email], ) try: email.send(fail_silently=False) return Response( { "message": "An mail has been sent to your email, please check it" }, status=status.HTTP_201_CREATED) except: user.delete() return Response({"email": ["Couldn't send email"]}, status=status.HTTP_400_BAD_REQUEST) else: return Response(serializer._errors, status=status.HTTP_400_BAD_REQUEST)
def ws_message(message): ls = LocationSerializer(data=json.loads(message['text'])) if ls.is_valid(raise_exception=True): ls.save(owner=message.user) else: pass # TODO Send error message