def create_listing_visit_count(profile, listing, count, last_visit_date=None): """ Set initial visit count for a given profile and listing. Ensures that there is only one visit count object per profile/listing combination. """ if not last_visit_date: last_visit_date = utils.get_now_utc() filtered_counts = models.ListingVisitCount.objects.filter(profile=profile, listing=listing) if filtered_counts.count() > 1: raise errors.RequestException( 'Only one visit count object can exist for profile {0} and listing {1}' .format(profile.display_name, listing.title)) elif filtered_counts.count() == 1: return update_listing_visit_count(filtered_counts.first(), count, last_visit_date) else: visit_count = models.ListingVisitCount(profile=profile, listing=listing) visit_count.count = count visit_count.last_visit_date = last_visit_date visit_count.save() return visit_count
def create(self, request, bookmark_pk=None): """ Add Permission to BookmarkEntry API: Add OWNER {username} to {bookmark_id} BookmarkEntry ``` POST /api/bookmark/{bookmark_id}/permission/ { "user_type":"OWNER", "profile":{ "user":{ "username":{username} } } } ``` Add VIEWER {username} to {bookmark_id} BookmarkEntry ``` POST /api/bookmark/{bookmark_id}/permission/ { "user_type":"VIEWER", "profile":{ "user":{ "username":{username} } } } ``` API Errors: When the Profile is not found via username ``` { "detail": "Valid User is Required", "error": true, "error_code": "validation_error" } ``` """ current_request_profile = request.user.profile bookmark_entry = model_access.get_bookmark_entry_by_id( current_request_profile, bookmark_pk) serializer = serializers.BookmarkPermissionSerializer( data=request.data, context={ 'request': request, 'bookmark_entry': bookmark_entry }, partial=True) if not serializer.is_valid(): logger.error('{0!s}'.format(serializer.errors)) raise errors.RequestException('{0!s}'.format(serializer.errors)) serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED)
def create(self, request): """ Bookmark a Listing for the current user. POST JSON data: { "listing": { "id": 1 }, "folder": "folderName" (optonal) } --- parameters: - name: body required: true paramType: body parameters_strategy: form: replace query: replace omit_serializer: true """ serializer = serializers.UserLibrarySerializer( data=request.data, context={'request': request}) if not serializer.is_valid(): logger.error('{0!s}'.format(serializer.errors)) raise errors.RequestException('{0!s}'.format(serializer.errors)) serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED)
def update(self, request, bookmark_pk=None, pk=None): """ Updating Bookmark Permission * Use to convert OWNER User Permission to VIEWER User Permission * Use to convert VIEWER User Permission to OWNER User Permission Rules: * The request profile that is a VIEWER can't self promote to OWNER * The request profile that is a OWNER can't self demote to VIEWER API: Change permission for profile to VIEWER ``` PUT /api/bookmark/{bookmark_id}/permission/{permission_id} { "user_type":"VIEWER" } ``` Change permission for profile to OWNER ``` PUT /api/bookmark/{bookmark_id}/permission/{permission_id} { "user_type":"OWNER" } ``` API Error: Can only update permissions for other users """ request_profile = request.user.profile bookmark_entry = model_access.get_bookmark_entry_by_id( request_profile, bookmark_pk) bookmark_permission = model_access.get_bookmark_permission_by_id( request_profile, bookmark_entry, pk) serializer = serializers.BookmarkPermissionSerializer( bookmark_permission, data=request.data, context={ 'request': request, 'bookmark_entry': bookmark_entry }, partial=True) if not serializer.is_valid(): logger.error('{0!s}'.format(serializer.errors)) raise errors.RequestException('{0!s}'.format(serializer.errors)) serializer.save() return Response(serializer.data, status=status.HTTP_200_OK)
def create(self, request, listing_pk=None): try: user = generic_model_access.get_profile(request.user.username) listing = model_access.get_listing_by_id(request.user.username, listing_pk) rejection_description = request.data['description'] listing = model_access.reject_listing(user, listing, rejection_description) return Response(data={"listing": {"id": listing.id}}, status=status.HTTP_201_CREATED) except Exception as e: logger.error('Exception: {}'.format(e), extra={'request': request}) raise errors.RequestException('Error rejecting listing')
def update(self, request, pk=None): """ Updating bookmarks API: Move a folder/listing bookmark to a different folder ``` PUT /api/bookmark/{bookmark_id}/ { "bookmark_parent":[{"id":40}] } ``` Move a folder/listing bookmark to a user's root folder ``` PUT /api/bookmark/{bookmark_id}/ { "bookmark_parent":[] } ``` Rename a folder bookmark folder ``` PUT /api/bookmark/{folder_bookmark_id}/ { "title": "new title" } ``` Error: A folder with that name already exist (TODO) """ current_request_profile = request.user.profile bookmark_entry = model_access.get_bookmark_entry_by_id( current_request_profile, pk) serializer = serializers.BookmarkSerializer( bookmark_entry, data=request.data, context={'request': request}, partial=True) if not serializer.is_valid(): logger.error('{0!s}'.format(serializer.errors)) raise errors.RequestException('{0!s}'.format(serializer.errors)) serializer.save() return Response(serializer.data, status=status.HTTP_200_OK)
def update(self, request, pk=None): current_request_profile = model_access.get_self(request.user.username) if current_request_profile.highest_role() != 'APPS_MALL_STEWARD': raise errors.PermissionDenied profile_instance = self.get_queryset().get(pk=pk) serializer = serializers.ProfileSerializer(profile_instance, data=request.data, context={'request': request}, partial=True) if not serializer.is_valid(): logger.error('{0!s}'.format(serializer.errors)) raise errors.RequestException('{0!s}'.format(serializer.errors)) serializer.save() return Response(serializer.data, status=status.HTTP_200_OK)
def import_bookmarks(self, request): """ Import Bookmarks """ current_request_username = request.user.username bookmark_notification_id = request.data.get('bookmark_notification_id') error, data = model_access.import_bookmarks(current_request_username, bookmark_notification_id) if error: raise errors.RequestException('{0!s}'.format(error)) else: serializer = serializers.UserLibrarySerializer( data, many=True, context={'request': request}) return Response(serializer.data, status=status.HTTP_201_CREATED)
def update_all(self, request): """ Update ALL of the user's library entries Used to move library entries into different folders for HUD Notes: This method is different than most. The ViewSet update method only works on a single instance, hence the use of a special update_all method. Serializers must be customized to support nested writable representations, and even after doing so, the input data validation didn't seem acceptable. Hence this customized method [ { "listing": { "id": 1 }, "folder": "folderName" (or null), "id": 2 }, { "listing": { "id": 2 }, "folder": "folderName" (or null), "id": 1 } ] --- parameters: - name: body required: true paramType: body parameters_strategy: form: replace query: replace omit_serializer: true """ current_request_username = request.user.username error, data = model_access.batch_update_user_library_entry( current_request_username, request.data) if error: raise errors.RequestException('{0!s}'.format(errors)) else: return Response(data, status=status.HTTP_200_OK)
def create(self, request, listing_pk=None): try: user = generic_model_access.get_profile(request.user.username) listing = model_access.get_listing_by_id(request.user.username, listing_pk) description = request.data[ 'description'] if 'description' in request.data else None if not description: raise errors.InvalidInput( 'Description is required when pending a listing for deletion' ) listing = model_access.pending_delete_listing( user, listing, description) return Response(data={"listing": { "id": listing.id }}, status=status.HTTP_201_CREATED) except Exception as e: logger.error('Exception: {}'.format(e), extra={'request': request}) raise errors.RequestException('Error pending listing for deletion')
def create(self, request): """ Bookmark a Listing for the current user. API: Create a Listing Bookmark under user's root folder. ``` POST /api/bookmark/ { "type":"LISTING", "listing":{"id":1} } ``` Create a Listing Bookmark under different folder for user ``` POST /api/bookmark/ { "type":"LISTING", "listing":{"id":1}, "bookmark_parent":[{"id":40}] } ``` Create a 'Empty' Folder bookmark under root folder for user: ``` POST /api/bookmark/ { "title": "Folder 1", "type": "FOLDER" } ``` Create a 'Merged' Folder bookmark under root folder for user with 2 children: ``` POST /api/bookmark/ { "title": "Folder 2", "type": "FOLDER", "children":[ {"id":16}, {"id":17} ] } ``` Error: A folder with that name already exist (TODO) """ serializer = serializers.BookmarkSerializer( data=request.data, context={'request': request}) if not serializer.is_valid(): logger.error('{0!s}'.format(serializer.errors)) raise errors.RequestException('{0!s}'.format(serializer.errors)) serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED)