def validate(self, data):
"""
validate
"""
request_profile = self.context['request'].user.profile
username = self.context['request'].user.username
if 'bookmark_parent' in data:
bookmark_parent_len = len(data['bookmark_parent'])
if bookmark_parent_len > 1:
raise errors.ValidationException(
'bookmark_parent has more than one folder')
elif bookmark_parent_len == 1:
bookmark_parent_id = data['bookmark_parent'][0]['id']
data[
'bookmark_parent_object'] = model_access.get_bookmark_entry_by_id(
request_profile, bookmark_parent_id)
if data['bookmark_parent_object'].type != 'FOLDER':
raise errors.ValidationException(
'bookmark_parent entry must be FOLDER')
elif bookmark_parent_len < 1:
data[
'bookmark_parent_object'] = model_access.create_get_user_root_bookmark_folder(
request_profile)
if 'children' in data:
bookmark_children_ids = []
for child in data['children']:
if 'id' in child:
bookmark_children_ids.append(child['id'])
data['bookmark_children'] = bookmark_children_ids
return data
def create(self, validated_data):
"""
Create BookmarkPermission entry
Required Fields:
pass
"""
username = self.context['request'].user.username
request_profile = self.context['request'].user.profile
bookmark_entry = self.context['bookmark_entry']
user_type = validated_data.get('user_type')
target_username = validated_data.get('profile',
{}).get('user',
{}).get('username')
if not target_username:
raise errors.ValidationException('Valid Username is Required')
target_profile = generic_model_access.get_profile(target_username)
if not target_profile:
raise errors.ValidationException('Valid User is Required')
return model_access.share_bookmark_entry(request_profile,
bookmark_entry,
target_profile, None,
user_type)
def to_internal_value(self, data):
ret = super(BookmarkSerializer, self).to_internal_value(data)
ret['children'] = data.get('children', [])
if 'children' in ret:
for child in ret['children']:
if not isinstance(child, dict):
raise errors.ValidationException(
'children has to be a list of dictionaries')
if 'id' not in child:
raise errors.ValidationException(
'child in children list of dictionaries is mising id field'
)
return ret
def update(self, request, pk=None, listing_pk=None):
"""
Update an existing review
"""
listing = model_access.get_listing_by_id(request.user.username,
listing_pk, True)
custom_field = model_access.get_custom_field_value_by_id(pk)
if model_access.is_listing_owner_or_admin(request.user.username,
listing):
serializer = serializers.CustomFieldValueSerializer(
custom_field,
data=request.data,
context={
'request': request,
'listing': listing
},
partial=True)
if not serializer.is_valid():
logger.error('{0!s}'.format(serializer.errors),
extra={'request': request})
raise errors.ValidationException('{0}'.format(
serializer.errors))
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(status=status.HTTP_403_FORBIDDEN)
def create(self, request):
"""
Upload an image
Use content_type = `application/form-data`
Data (key = value) example:
```
security_marking = UNCLASSIFIED
image_type = listing_small_screenshot
file_extension = jpg
image = <file>
```
"""
# This is a long story. The short version is that, when using HTTP
# Basic Auth, the client makes a request w/o auth credentials, and the
# server returns a 401, instructing the client to make the request with
# auth credentials. This usually works just fine under the covers, but
# in this particular case (using multipart/form-data with a file
# attachement), IE croaks. This dummy endpoint is used to 'prep' the
# client so that when it makes the real request to this endpoint, it
# already knows to set the necessary authentication header
if 'cuz_ie' in request.data:
return Response('IE made me do this', status=status.HTTP_200_OK)
serializer = serializers.ImageCreateSerializer(
data=request.data, context={'request': request})
if not serializer.is_valid():
raise errors.ValidationException('{0!s}'.format(serializer.errors))
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def update(self, request, pk=None, profile_pk=None):
"""
Update an existing listing visit count
"""
if profile_pk == 'self':
profile = model_access.get_self(request.user.username)
else:
profile = model_access.get_profile_by_id(profile_pk)
if 'listing' in request.data and 'id' in request.data['listing']:
listing = listing_model_access.get_listing_by_id(
request.user.username, request.data['listing']['id'], True)
else:
listing = None
visit_count = model_access.get_visit_count_by_id(pk)
serializer = listing_serializers.ListingVisitCountSerializer(
visit_count,
data=request.data,
context={
'request': request,
'profile': profile,
'listing': listing
},
partial=True)
if not serializer.is_valid():
logger.error('{0!s}'.format(serializer.errors),
extra={'request': request})
raise errors.ValidationException('{0}'.format(serializer.errors))
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
def create(self, request, category_pk=None):
"""
ModelViewSet for Bulk Update (Post)
[
{
"id": 7,
"categories": [
{
"title": "Business",
},
{
"title": "Finance",
}
]
},
{
"id": 65,
"categories": [
{
"title": "Finance",
}
]
}
]
"""
serializer = serializers.CreateCategoryListingSerializer(
data=request.data, context={'request': request}, many=True)
if not serializer.is_valid():
raise errors.ValidationException('{0}'.format(serializer.errors))
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def create(self, validated_data):
"""
Create BOOKMARK entry
Required Fields:
* Type
* `listing id` if type is LISTING
* `title` if type is folder
"""
username = self.context['request'].user.username
request_profile = self.context['request'].user.profile
bookmark_parent_object = validated_data.get('bookmark_parent_object')
type = validated_data.get('type')
bookmark_children = validated_data.get('bookmark_children')
listing_id = validated_data.get('listing', {}).get('id')
if type == model_access.LISTING_TYPE:
if not listing_id:
raise errors.ValidationException('Listing id entry not found')
listing = listing_model_access.get_listing_by_id(
username, listing_id)
if not listing:
raise errors.ValidationException('Listing id entry not found')
return model_access.create_listing_bookmark_for_profile(
request_profile, listing, bookmark_parent_object)
elif type == model_access.FOLDER_TYPE:
if 'title' not in validated_data:
raise errors.ValidationException('No title provided')
listing = None
if listing_id:
listing = listing_model_access.get_listing_by_id(
username, listing_id)
if not listing:
raise errors.ValidationException(
'Listing id entry not found')
return model_access.create_folder_bookmark_for_profile(
request_profile, validated_data['title'],
bookmark_parent_object, bookmark_children, listing)
else:
raise errors.ValidationException('No valid type provided')
def update(self, request):
current_request_profile = model_access.get_self(request.user.username)
serializer = serializers.ProfileSerializer(current_request_profile,
data=request.data, context={'request': request}, partial=True)
if not serializer.is_valid():
logger.error('{0!s}'.format(serializer.errors))
raise errors.ValidationException('{0!s}'.format(serializer.errors))
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
def create(self, request):
serializer = serializers.NotificationSerializer(data=request.data,
context={'request': request}, partial=True)
if not serializer.is_valid():
logger.error('{0!s}'.format(serializer.errors))
raise errors.ValidationException('{0!s}'.format(serializer.errors))
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def validate(self, data):
"""
validate
"""
request_profile = self.context['request'].user.profile
# data: {'user_type': 'OWNER', 'profile': OrderedDict([('id', 1)])}
user_type = data.get('user_type')
# user_type is required field, choices are validate via django non_field_errors
if not user_type:
raise errors.ValidationException('user_type field is missing')
return data
def update(self, request, pk=None):
"""
Update is used only change the expiration date of the message
"""
instance = self.get_queryset().get(pk=pk)
serializer = serializers.NotificationSerializer(instance,
data=request.data, context={'request': request}, partial=True)
if not serializer.is_valid():
logger.error('{0!s}'.format(serializer.errors))
raise errors.ValidationException('{0!s}'.format(serializer.errors))
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
def create(self, request, listing_pk=None):
listing = model_access.get_listing_by_id(request.user.username,
listing_pk, True)
serializer = serializers.RecommendationFeedbackSerializer(
data=request.data,
context={
'request': request,
'listing': listing
})
if not serializer.is_valid():
logger.error('{0!s}'.format(serializer.errors),
extra={'request': request})
raise errors.ValidationException('{0}'.format(serializer.errors))
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def create(self, request, listing_pk=None):
listing = model_access.get_listing_by_id(request.user.username,
listing_pk, True)
if model_access.is_listing_owner_or_admin(request.user.username,
listing):
serializer = serializers.CustomFieldValueSerializer(
data=request.data,
context={
'request': request,
'listing': listing
})
if not serializer.is_valid():
logger.error('{0!s}'.format(serializer.errors),
extra={'request': request})
raise errors.ValidationException('{0}'.format(
serializer.errors))
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(status=status.HTTP_403_FORBIDDEN)
def update(self, request, pk=None, listing_pk=None):
"""
Update an existing review
"""
listing = model_access.get_listing_by_id(request.user.username,
listing_pk, True)
review = model_access.get_review_by_id(pk)
serializer = serializers.ReviewSerializer(review,
data=request.data,
context={
'request': request,
'listing': listing
},
partial=True)
if not serializer.is_valid():
logger.error('{0!s}'.format(serializer.errors),
extra={'request': request})
raise errors.ValidationException('{0}'.format(serializer.errors))
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
def create(self, request):
"""
Save a new Listing - only title is required
Sample Payload:
{
"title":"My Test App",
"description":"This is the full description of my app",
"descriptionShort":"short app description",
"contacts":[
{
"type":"Technical Support",
"name":"Tech Support Contact",
"organization":"ABC Inc",
"email":"*****@*****.**",
"securePhone":"555-555-5555",
"unsecurePhone":"111-222-3454"
}
],
"tags":[
"tag1",
"tag2"
],
"type":"Web Application",
"usage_requirements":"None",
"system_requirements":"None",
"versionName":"1.0.0",
"launchUrl":"http://www.google.com/myApp",
"whatIsNew":"Nothing is new",
"owners":[
{
"username":"******"
}
],
"agency":"Test Organization",
"categories":[
"Entertainment",
"Media and Video"
],
"intents":[
"application/json/edit",
"application/json/view"
],
"docUrls":[
{
"name":"wiki",
"url":"http://www.wikipedia.com/myApp"
}
],
"smallIconId":"b0b54993-0668-4419-98e8-787e4c3a2dc2",
"largeIconId":"e94128ab-d32d-4241-8820-bd2c69a64a87",
"bannerIconId":"ecf79771-79a0-4884-a36d-5820c79c6d72",
"featuredBannerIconId":"c3e6a369-4773-485e-b369-5cebaa331b69",
"changeLogs":[
],
"screenshots":[
{
"smallImageId":"0b8db892-b669-4e86-af23-d899cb4d4d91",
"largeImageId":"80957d25-f34b-48bc-b860-b353cfd9e101"
}
]
}
---
parameters:
- name: body
required: true
paramType: body
parameters_strategy:
form: replace
query: replace
omit_serializer: true
"""
# logger.debug('inside ListingViewSet.create', extra={'request': request})
serializer = serializers.ListingSerializer(
data=request.data, context={'request': request}, partial=True)
if not serializer.is_valid():
logger.error('{0!s}'.format(serializer.errors),
extra={'request': request})
raise errors.ValidationException('{0}'.format(serializer.errors))
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def update(self, request, pk=None):
"""
Update a Listing
Sample payload:
{
"id":45,
"title":"My Test App",
"description":"This is the full description of my app",
"descriptionShort":"short app description",
"contacts":[
{
"securePhone":"555-555-5555",
"unsecurePhone":"111-222-3454",
"email":"*****@*****.**",
"organization":"ABC Inc",
"name":"Tech Support Contact",
"type":"Technical Support"
}
],
"totalReviews":0,
"avgRate":0,
"totalRate1":0,
"totalRate2":0,
"totalRate3":0,
"totalRate4":0,
"height":null,
"width":null,
"totalRate5":0,
"totalVotes":0,
"tags":[
"tag2",
"tag1"
],
"type":"Web Application",
"uuid":"e378c427-bba6-470c-b2f3-e550b9129504",
"usage_requirements":"None",
"system_requirements":"None",
"iframe_compatible":false,
"versionName":"1.0.0",
"launchUrl":"http://www.google.com/myApp",
"whatIsNew":"Nothing is new",
"owners":[
{
"displayName":"kevink",
"username":"******",
"id":5
}
],
"agency":"Test Organization",
"agencyShort":"TO",
"currentRejection":null,
"isEnabled":true,
"categories":[
"Media and Video",
"Entertainment"
],
"editedDate":"2015-08-12T10:53:47.036+0000",
"intents":[
"application/json/edit",
"application/json/view"
],
"docUrls":[
{
"url":"http://www.wikipedia.com/myApp",
"name":"wiki"
}
],
"approvalStatus":"IN_PROGRESS",
"isFeatured":false,
"smallIconId":"b0b54993-0668-4419-98e8-787e4c3a2dc2",
"largeIconId":"e94128ab-d32d-4241-8820-bd2c69a64a87",
"bannerIconId":"ecf79771-79a0-4884-a36d-5820c79c6d72",
"featuredBannerIconId":"c3e6a369-4773-485e-b369-5cebaa331b69",
"changeLogs":[
],
"screenshots":[
{
"largeImageId":"80957d25-f34b-48bc-b860-b353cfd9e101",
"smallImageId":"0b8db892-b669-4e86-af23-d899cb4d4d91"
}
]
}
"""
# logger.debug('inside ListingViewSet.update', extra={'request': request})
instance = self.get_queryset().get(pk=pk)
serializer = serializers.ListingSerializer(
instance,
data=request.data,
context={'request': request},
partial=True)
# logger.debug('created ListingSerializer', extra={'request': request})
if not serializer.is_valid():
logger.error('{0!s}'.format(serializer.errors),
extra={'request': request})
raise errors.ValidationException('{0}'.format(serializer.errors))
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
