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)
