def get(self, request):
if request.method == 'OPTIONS':
return JsonResponse({})
user = request.user
recommendations = get_recommend_books(user)
r1 = BookSerializer(recommendations["desc"], many=True)
r2 = BookSerializer(recommendations["title"], many=True)
r3 = BookSerializer(recommendations["review"], many=True)
r4 = BookSerializer(recommendations["others"], many=True)
r5 = BookSerializer(recommendations["genres"], many=True)
desc = [] if len(r1.data) == 0 else r1.data
title = [] if len(r2.data) == 0 else r2.data
review = [] if len(r3.data) == 0 else r3.data
others = [] if len(r4.data) == 0 else r4.data
genres = [] if len(r5.data) == 0 else r5.data
info = {
"desc": desc,
"title": title,
"review": review,
"others": others,
"genres": genres
}
return JsonResponse(info)
def book_list(request):
if request.method == 'GET':
books = Book.objects.all()
isbn = request.GET.get('isbn', None)
if isbn is not None:
books = books.filter(book__icontains=isbn)
book_serializer = BookSerializer(books, many=True)
return JsonResponse(book_serializer.data, safe=False)
elif request.method == 'POST':
book_data = JSONParser().parse(request)
book_serializer = BookSerializer(data=book_data)
if book_serializer.is_valid():
book_serializer.save()
return JsonResponse(book_serializer.data,
status=status.HTTP_201_CREATED)
return JsonResponse(book_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
count = Book.objects.all().delete()
return JsonResponse(
{
'message': '{} Books were deleted successfully!'.format(
count[0])
},
status=status.HTTP_204_NO_CONTENT)
def book_list(request):
if request.method == 'GET':
books = Book.objects.all()
serializer = BookSerializer(books, many=True)
return Response(serializer.data)
elif request.method == 'POST':
serializer = BookSerializer(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 book_list(request):
if request.method == 'GET':
snippets = Books.objects.all()
serializer = BookSerializer(snippets, many=True)
return JsonResponse(serializer.data, safe=False)
elif request.method == 'POST':
data = JSONParser().parse(request)
serializer = BookSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def book_list(request):
if request.method == 'GET':
books = Book.objects.all()
book_serializer = BookSerializer(books, many=True)
return JSONResponse(book_serializer.data)
elif request.method == 'POST':
book_data = JSONParser().parse(request)
book_serializer = BookSerializer(data=book_data)
if book_serializer.is_valid():
book_serializer.save()
return JSONResponse(book_serializer.data,
status=status.HTTP_201_CREATED)
else:
return JSONResponse(book_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
class RentalSerializer(ModelSerializer):
client = ClientSerializer(read_only=True)
book = BookSerializer(read_only=True)
class Meta:
model = Rental
fields = '__all__'
def get(self, request, format=None):
books = Book.objects.filter(~Q(owner = self.request.user.id))
if request.GET.get('search'):
books = books.filter(title__icontains=self.request.GET['search'])
serializer = BookSerializer(books, many=True)
return Response(serializer.data)
def post(self, request, format=None):
data = JSONParser().parse(request)
serializer = BookSerializer(data=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(self, request):
serializer = BookSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=201)
time.sleep(2)
return Response(serializer.errors, status=400)
def book_list(request, format=None):
if request.method == 'GET':
books = book.objects.all()
serializer = BookSerializer(books, many=True)
return Response(serializer.data)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_ok(self):
book_1 = Books.objects.create(
title='Test1 Titile1',
author_name='Test1 author1',
description='Test1 description1'
)
book_2 = Books.objects.create(
title='Test2 Titile2',
author_name='222aaaaaaaaaaaaaaaa',
description='Test2 description2'
)
data = BookSerializer([book_1, book_2], many=True).data
expected_data = [
{
'id': book_1.id,
'title': 'Test1 Titile1',
'author_name': 'Test1 author1',
'description': 'Test1 description1'
},
{
'id': book_2.id,
'title': 'Test2 Titile2',
'author_name': '222aaaaaaaaaaaaaaaa',
'description': 'Test2 description2',
}
]
self.assertEqual(expected_data, data)
def put(self, request, pk, format=None):
book = self.get_object(pk)
serializer = BookSerializer(book, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class ColumnConfigSerializer(serializers.ModelSerializer):
book = BookSerializer()
topic = TopicDetailSerializer()
class Meta:
model = ColumnConfig
fields = ('book', 'topic')
def book_add(request):
if request.method == 'POST':
serializer = BookSerializer(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 test_view_book_detail(self, book, client):
"""Test retrieve book detail"""
response = client.get(detail_url(book.id))
serializer = BookSerializer(book)
assert response.status_code == status.HTTP_200_OK
assert response.data == serializer.data
def get(self, request, id,format=None):
try:
book = Book.objects.get(id=id)
except Book.DoesNotExist:
return Response("", status=status.HTTP_400_BAD_REQUEST)
serializer = BookSerializer(book)
return Response(serializer.data)
class LibrarySessionSerializer(serializers.ModelSerializer):
book = BookSerializer()
class Meta:
model = LibraryBook
fields = ["id", "book"]
def test_get_book(self):
response = self.client.get(
reverse("book-details", kwargs={"pk": self.book_id}))
expected = Book.objects.get(pk=self.book_id)
serialized = BookSerializer(expected)
self.assertEqual(response.data.get('data'), serialized.data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
class UserSerializer(serializers.ModelSerializer):
book = BookSerializer(many=True)
class Meta:
model = User
#fields = "__all__"
fields = ['id', 'last_name', 'first_name', 'book']
class STUserSerializer(serializers.ModelSerializer):
user = UserSerializer()
bought_books = BookSerializer(many=True)
class Meta:
model = STUser
fields = ('id', 'name', 'user', 'phone', 'bought_books')
class OrderSerializer(serializers.ModelSerializer):
book = BookSerializer()
class Meta:
model = Order
fields = '__all__'
read_only_fields = ('creator', )
def libros(self, request, pk=None):
editorial = self.get_object()
libros = Book.objects.filter(editorial__id=editorial.id)
serialized = BookSerializer(libros, many=True)
if not libros:
return Response(status=status.HTTP_404_NOT_FOUND,
data={'message': 'Esta editorial no tiene libros'})
return Response(status=status.HTTP_200_OK, data=serialized.data)
def post(self, request):
book_serializer = BookSerializer(data=request.data)
if book_serializer.is_valid():
saved_book_data = book_serializer.save()
return Response(book_serializer.data,
status=status.HTTP_201_CREATED)
return Response(book_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def all_books_view(request):
book = Book.objects.all()
if request.method == "GET":
serializer = BookSerializer(book, many=True)
return Response(serializer.data)
def search(self, request):
q = request.query_params.get('q')
queryset = self.get_queryset()
if q is not None:
queryset = queryset.filter(
Q(title__icontains=q) | Q(description__icontains=q))
serializer = BookSerializer(queryset, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
def __serialize_book(self, book, library, request, status=200):
serializer = BookSerializer(book,
context={
'request': request,
'library': library,
'user': request.user,
})
return Response(serializer.data, status=status)
def books(self, request, pk=None):
editorial = self.get_object()
if request.method == 'GET':
books = editorial.pub_books.all()
serialized = BookSerializer(books, many=True)
return Response(status=status.HTTP_200_OK, data=serialized.data)
elif request.method == 'DELETE':
Book.objects.filter(editorial=editorial).delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def test_get_single_book(self):
request = self.factory.get('/api/books/', )
view = BookViewSet.as_view({"get": "retrieve"})
response = view(request, pk=3)
book = Book.objects.filter(pk=3).first()
serializer = BookSerializer(book)
self.assertEqual(response.data, serializer.data)
self.assertEqual(response.status_code, 200)
def test_get_all_books(self):
request = self.factory.get('/api/books/')
view = BookViewSet.as_view({"get": "list"})
response = view(request)
books = Book.objects.all()
serializer = BookSerializer(books, many=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, serializer.data)
def get(self, request, id=None):
if id:
try:
book = Book.objects.get(pk=pk)
except Book.DoesNotExist:
return Response({'message': 'The book does not exist'},
status=status.HTTP_404_NOT_FOUND)
book_serializer = BookSerializer(book)
else:
books = Book.objects.all()
title = request.GET.get('title', None)
if title is not None:
books = books.filter(title__icontains=title)
books_serializer = BookSerializer(books, many=True)
return Response(books_serializer.data)