def webfinger_view(request):
"""Generate a webfinger document."""
q = request.GET.get("q")
if not q:
raise Http404()
username = q.split("@")[0]
if username.startswith("acct:"):
username = username.replace("acct:", "", 1)
user = get_object_or_404(User, username=username)
# Create webfinger document
webfinger = generate_legacy_webfinger(
"diaspora",
handle="{username}@{domain}".format(username=user.username, domain=settings.SOCIALHOME_DOMAIN),
host=settings.SOCIALHOME_URL,
guid=str(user.profile.guid),
public_key=user.profile.rsa_public_key
)
return HttpResponse(webfinger, content_type="application/xrd+xml")
python类get_object_or_404()的实例源码
def hcard_view(request, guid):
"""Generate a hcard document.
For local users only.
"""
try:
profile = get_object_or_404(Profile, guid=guid, user__isnull=False)
except ValueError:
raise Http404()
hcard = generate_hcard(
"diaspora",
hostname=settings.SOCIALHOME_URL,
fullname=profile.name,
firstname=profile.get_first_name(),
lastname=profile.get_last_name(),
photo300=profile.safer_image_url_large,
photo100=profile.safer_image_url_medium,
photo50=profile.safer_image_url_small,
searchable="true" if profile.public else "false",
guid=profile.guid,
username=profile.user.username,
public_key=profile.rsa_public_key,
)
return HttpResponse(hcard)
def get(self, request, *args, **kwargs):
"""Redirect to user detail view if root page is a profile or if the user is logged in"""
if settings.SOCIALHOME_HOME_VIEW:
p, m = settings.SOCIALHOME_HOME_VIEW.rsplit('.', 1)
return getattr(import_module(p), m).as_view()(request)
if request.user.is_authenticated:
landing_page = request.user.preferences.get("generic__landing_page")
if landing_page == "profile":
return ProfileDetailView.as_view()(request, guid=request.user.profile.guid)
elif landing_page == "profile_all":
return ProfileAllContentView.as_view()(request, guid=request.user.profile.guid)
elif landing_page == "followed":
return FollowedStreamView.as_view()(request)
elif landing_page == "public":
return PublicStreamView.as_view()(request)
else:
# Fallback to profile view
return ProfileDetailView.as_view()(request, guid=request.user.profile.guid)
if settings.SOCIALHOME_ROOT_PROFILE:
profile = get_object_or_404(Profile, user__username=settings.SOCIALHOME_ROOT_PROFILE)
return ProfileDetailView.as_view()(request, guid=profile.guid)
return super(HomeView, self).get(request, *args, **kwargs)
def post_create_with_video(request):
# POST???? video_pk?? ??
video_pk = request.POST['video_pk']
# ?? video_pk? ???? Video????
video = get_object_or_404(Video, pk=video_pk)
# ?? video? ?? Post??
post = Post.objects.create(
author=request.user,
video=video,
)
# ??? Post??? my_comment? ???? Comment??
post.my_comment = Comment.objects.create(
post=post,
author=request.user,
content=video.title
)
return redirect('post:post_detail', post_pk=post.pk)
def restore_data(request):
"""
Restores the password for user.
"""
if request.method == 'POST':
forgot_form = ForgotPasswordForm(request.POST)
if forgot_form.is_valid():
with transaction.atomic():
temp_password = generate_password()
user = get_object_or_404(User, email=forgot_form.cleaned_data['email'])
user.set_password(temp_password)
user.save()
restore_account.delay(user.username, temp_password, forgot_form.cleaned_data['email'])
logger.info("The password for user: '{}' restored successfully.".format(user))
return HttpResponse(json.dumps(True), content_type='application/json')
def find_book(request):
"""
Generates list with books of data which user entered. At first it check full equality in name,
after tries to check if contains some part of entered data.
"""
user = get_object_or_404(TheUser, auth_token=request.data.get('user_token'))
search_data = request.data.get('search_term')
filtered_books = Book.exclude_private_books(user.id_user, Book.fetch_books(search_data))
paginator = Paginator(filtered_books, OUTPUT_BOOKS_PER_PAGE)
page = paginator.page(request.data.get('page'))
next_page = page.has_next()
page_books = page.object_list
return Response({'status': 200,
'detail': 'successful',
'data': {'books': [BookSerializer(book).data for book in page_books],
'next_page': page.next_page_number() if next_page else 0}})
def add_book_to_home(request):
"""
Adds book to list of user's added books.
"""
user = get_object_or_404(TheUser, auth_token=request.data.get('user_token'))
book = get_object_or_404(Book, id=request.data.get('book_id'))
if book.private_book and book.who_added != user:
return Response({}, status=404)
if AddedBook.objects.filter(id_user=user, id_book=book).exists():
return Response({}, status=404)
AddedBook.objects.create(id_user=user, id_book=book)
logger.info("User '{}' added book with id: '{}' to his own library.".format(user.id_user.id, book.id))
return Response({'status': 200,
'detail': 'success',
'data': {}})
# ----------------------------------------------------------------------------------------------------------------------
def remove_book_from_home(request):
"""
Removes book from list of user's reading books.
"""
user = get_object_or_404(TheUser, auth_token=request.data.get('user_token'))
book = get_object_or_404(Book, id=request.data.get('book_id'))
added_book = get_object_or_404(AddedBook, id_user=user, id_book=book)
added_book.delete()
logger.info("User '{}' removed book with id: '{}' from his own library."
.format(request.user, request.data.get('book_id')))
return Response({'status': 200,
'detail': 'success',
'data': {}})
# ----------------------------------------------------------------------------------------------------------------------
def open_book(request):
"""
Returns the book of last readed page.
"""
user = get_object_or_404(TheUser, auth_token=request.data.get('user_token'))
book = get_object_or_404(Book, id=request.data.get('book_id'))
added_book = get_object_or_404(AddedBook, id_book=book, id_user=user)
added_book.last_read = added_book.last_read.now()
added_book.save()
logger.info("User '{}' opened book with id: '{}'.".format(user, book.id))
return Response({'status': 200,
'detail': 'successful',
'data': {'last_page': added_book.last_page}})
# ----------------------------------------------------------------------------------------------------------------------
def set_current_page(request):
"""
Changes current readed page for book of the user.
"""
user = get_object_or_404(TheUser, auth_token=request.data.get('user_token'))
book = get_object_or_404(Book, id=request.data.get('book_id'))
current_page = request.data.get('current_page')
if not isinstance(current_page, int):
return Response({'status': 400,
'detail': 'current page not a number',
'data': {}}, status=400)
added_book = AddedBook.objects.get(id_book=book, id_user=user)
added_book.last_page = current_page
added_book.save()
logger.info("User '{}' on book with id: '{}' changed page to: '{}'."
.format(user, book.id, current_page))
return Response({'status': 200,
'detail': 'successful',
'data': {}})
def category_detail(request, category_id):
"""
Category detail
---
serializer: categories.serializers.CategorySerializer
responseMessages:
- code: 400
message: Bad request.
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden.
- code: 404
message: Not found
"""
category = get_object_or_404(Category, pk=category_id)
if request.method == 'GET':
serializer = CategorySerializer(category)
return Response(serializer.data, status=status.HTTP_200_OK)
def keyword_detail(request, keyword_id):
"""
Keyword detail
---
serializer: categories.serializers.KeywordSerializer
responseMessages:
- code: 400
message: Bad request.
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden.
- code: 404
message: Not found
"""
keyword = get_object_or_404(Keyword, pk=keyword_id)
if request.method == 'GET':
serializer = KeywordSerializer(keyword)
return Response(serializer.data, status=status.HTTP_200_OK)
def employee(request, employee_id):
"""
Returns employee details
---
serializer: employees.serializers.EmployeeSerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden.
- code: 404
message: Not found
"""
if request.method == 'GET':
employee = get_object_or_404(Employee, pk=employee_id)
serializer = EmployeeSerializer(employee)
return Response(serializer.data, status=status.HTTP_200_OK)
def employee_activate(request, employee_id, action):
"""
Activate employee account, action could be true or false
---
response_serializer: employees.serializers.EmployeeSerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden.
- code: 404
message: Not found
"""
if request.method == 'PATCH':
employee = get_object_or_404(Employee, pk=employee_id)
if action == 'true':
employee.is_active = True
elif action == 'false':
employee.is_active = False
else:
pass
employee.save()
serializer = EmployeeSerializer(employee)
return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
def employee_block(request, employee_id, action):
"""
Block employee account, action could be true or false
---
response_serializer: employees.serializers.EmployeeSerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden.
- code: 404
message: Not found
"""
if request.method == 'PATCH':
employee = get_object_or_404(Employee, pk=employee_id)
if action == 'true':
employee.is_blocked = True
elif action == 'false':
employee.is_blocked = False
else:
pass
employee.save()
serializer = EmployeeSerializer(employee)
return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
def star(request, star_id):
"""
Returns star detail
---
serializer: stars.serializers.StarSerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden, authentication credentials were not provided
- code: 404
message: Not found
"""
if request.method == 'GET':
star = get_object_or_404(Star, pk=star_id)
serializer = StarSerializer(star)
return Response(serializer.data, status=status.HTTP_200_OK)
def stars_employee_list(request, employee_id):
"""
Returns stars list from employee
---
serializer: stars.serializers.StarSerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden, authentication credentials were not provided
- code: 404
message: Not found
"""
if request.method == 'GET':
employee = get_object_or_404(Employee, pk=employee_id)
employee_stars = Star.objects.filter(to_user=employee)
paginator = PageNumberPagination()
results = paginator.paginate_queryset(employee_stars, request)
serializer = StarSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def stars_employee_list_group_by_category(request, employee_id):
"""
Returns stars list from employee grouped by categories
---
serializer: stars.serializers.StarEmployeeCategoriesSerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden, authentication credentials were not provided
- code: 404
message: Not found
"""
if request.method == 'GET':
employee = get_object_or_404(Employee, pk=employee_id)
employee_stars = Star.objects.filter(to_user=employee).values(
'category__pk',
'category__name').annotate(num_stars=Count('category')).order_by('-num_stars', 'category__name')
paginator = PageNumberPagination()
result = paginator.paginate_queryset(employee_stars, request)
serializer = StarEmployeeCategoriesSerializer(result, many=True)
return paginator.get_paginated_response(serializer.data)
def stars_employee_list_group_by_category_detail(request, employee_id, category_id):
"""
Returns stars list detail from employee divided by category
---
serializer: stars.serializers.StarSmallSerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden, authentication credentials were not provided
- code: 404
message: Not found
"""
if request.method == 'GET':
employee = get_object_or_404(Employee, pk=employee_id)
category = get_object_or_404(Category, pk=category_id)
stars = Star.objects.filter(to_user=employee, category=category).order_by('-date')
paginator = PageNumberPagination()
results = paginator.paginate_queryset(stars, request)
serializer = StarSmallSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def stars_employee_list_group_by_keyword_detail(request, employee_id, keyword_id):
"""
Returns stars list detail from employee divided by keyword
---
serializer: stars.serializers.StarSmallSerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden, authentication credentials were not provided
- code: 404
message: Not found
"""
if request.method == 'GET':
employee = get_object_or_404(Employee, pk=employee_id)
keyword = get_object_or_404(Keyword, pk=keyword_id)
stars = Star.objects.filter(to_user=employee, keyword=keyword).order_by('-date')
paginator = PageNumberPagination()
results = paginator.paginate_queryset(stars, request)
serializer = StarSmallSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def badges_employee_list(request, employee_id):
"""
Returns badge list from employee
---
response_serializer: stars.serializers.EmployeeBadgeSerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden, authentication credentials were not provided
- code: 404
message: Not found
"""
if request.method == 'GET':
employee = get_object_or_404(Employee, pk=employee_id)
employee_bages = EmployeeBadge.objects.filter(to_user=employee)
paginator = PageNumberPagination()
results = paginator.paginate_queryset(employee_bages, request)
serializer = EmployeeBadgeSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def get_messages(request, employee_id):
"""
Get all messages for employee id
---
response_serializer: activities.serializers.MessageSerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden.
- code: 404
message: Not found
- code: 500
message: Internal Server Error
"""
if request.method == 'GET':
employee = get_object_or_404(Employee, pk=employee_id)
messages = Message.objects.filter(
Q(to_user='all') |
Q(to_user=employee.location.name) |
Q(to_user=employee.username))
paginator = PageNumberPagination()
results = paginator.paginate_queryset(messages, request)
serializer = MessageSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def get_messages_from(request, employee_id):
"""
Get all messages sent from employee id
---
response_serializer: activities.serializers.MessageSerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden.
- code: 404
message: Not found
- code: 500
message: Internal Server Error
"""
if request.method == 'GET':
employee = get_object_or_404(Employee, pk=employee_id)
messages = Message.objects.filter(from_user=employee)
paginator = PageNumberPagination()
results = paginator.paginate_queryset(messages, request)
serializer = MessageSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def get(self, request, event_id, format=None):
"""
List all activities for an event
---
serializer: administrator.serializers.EventActivitySerializer
parameters:
- name: pagination
required: false
type: string
paramType: query
"""
event = get_object_or_404(Event, pk=event_id)
activities = EventActivity.objects.filter(event=event)
if request.GET.get('pagination'):
pagination = request.GET.get('pagination')
if pagination == 'true':
paginator = AdministratorPagination()
results = paginator.paginate_queryset(activities, request)
serializer = EventActivitySerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
else:
serializer = EventActivitySerializer(activities, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
def get(self, request, employee_id, format=None):
"""
List all messages from employee
---
serializer: administrator.serializers.MessageSerializer
parameters:
- name: pagination
required: false
type: string
paramType: query
"""
employee = get_object_or_404(Employee, pk=employee_id)
messages = get_list_or_404(Message, from_user=employee)
if request.GET.get('pagination'):
pagination = request.GET.get('pagination')
if pagination == 'true':
paginator = AdministratorPagination()
results = paginator.paginate_queryset(messages, request)
serializer = MessageSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
else:
serializer = MessageSerializer(messages, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
def delete(self, request, id, kind, format=None):
"""
WARNING: Force delete
"""
if kind == 'badge':
kind = get_object_or_404(Badge, pk=id)
elif kind == 'category':
kind = get_object_or_404(Category, pk=id)
elif kind == 'event':
kind = get_object_or_404(Event, pk=id)
elif kind == 'keyword':
kind = get_object_or_404(Keyword, pk=id)
elif kind == 'location':
kind = get_object_or_404(Location, pk=id)
elif kind == 'position':
kind = get_object_or_404(Position, pk=id)
elif kind == 'role':
kind = get_object_or_404(Role, pk=id)
else:
return Response(status=status.HTTP_404_NOT_FOUND)
kind.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def local_events(request, employee_id):
"""
Returns the full upcoming events list for employee location
---
serializer: events.serializers.EventSerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden.
- code: 404
message: Not found
"""
if request.method == 'GET':
employee = get_object_or_404(Employee, pk=employee_id)
events = Event.objects.filter(location=employee.location, is_active=True)
paginator = PageNumberPagination()
results = paginator.paginate_queryset(events, request)
serializer = EventSerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def event_activities(request, event_id):
"""
Returns activity list for event
---
serializer: events.serializers.EventActivitySerializer
responseMessages:
- code: 401
message: Unauthorized. Authentication credentials were not provided. Invalid token.
- code: 403
message: Forbidden.
- code: 404
message: Not found
"""
if request.method == 'GET':
event = get_object_or_404(Event, pk=event_id)
activities = EventActivity.objects.filter(event=event)
paginator = PageNumberPagination()
results = paginator.paginate_queryset(activities, request)
serializer = EventActivitySerializer(results, many=True)
return paginator.get_paginated_response(serializer.data)
def family_detail(request, family_id):
family = get_object_or_404(ProductFamily, pk=family_id)
files = File.objects.filter(product_family_id= family.id).order_by("-posted_date", "description")
file_languages = Language.objects.filter(file__product_family_id= family.id).order_by('name').distinct()
lang = request.GET.get('lang')
if lang:
files = files.filter(language__code=lang)
context = {
'family': family,
'files': files,
'file_languages': file_languages,
'selected_language': lang,
}
return render(request, 'msdn/family_detail.html', context)
def retrieve(self, request, parent_lookup_torrent=None, *args, **kwargs):
"""
Retrieve a file of the user.
:return: Response
"""
if parent_lookup_torrent:
# Retrieve a file of the torrent.
torrent = get_object_or_404(Torrent, pk=parent_lookup_torrent)
if not torrent.finished:
return Response({
'detail': "The torrent hasn't finished downloading yet.",
'progress': torrent.progress
}, status=status.HTTP_400_BAD_REQUEST)
file_obj = get_object_or_404(File, torrent__pk=parent_lookup_torrent, pk=kwargs.get('pk'))
serializer = self.serializer_class(file_obj)
return Response(serializer.data)
return super(FileViewSet, self).retrieve(request, *args, **kwargs)
