def post(self, request, format=None):
data = request.data
serializer = CardSerializer(data=data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
# Provide error message code with request header
request.META['error_message'] = 'BAD_REQUEST'
def patch(self, request, pk):
cardmodel = self.get_object(pk)
serializer = CardSerializer(
cardmodel, data=request.data,
partial=True) # set partial=True to update a data partially
if serializer.is_valid():
serializer.save()
return Response(code=201, data=serializer.data)
return Response(code=400, data="wrong parameters")
def post(self, request, **kwargs):
new_card = Card.objects.create()
new_card = self.update_card(request, new_card)
new_card.save()
self.context['data'] = CardSerializer(new_card).data
return Response(self.context, self.status_code)
class UserSerializer(ModelSerializer):
# cards = CardSerializer(many=True, read_only=True, source='card_set')
# cards = PrimaryKeyRelatedField(many=True, read_only=True)
cards = CardSerializer(many=True, read_only=True)
class Meta:
model = User
fields = ('id', 'username', 'cards')
class ListSerializer(serializers.ModelSerializer):
cards = CardSerializer(many=True, read_only=True)
class Meta:
model = List
fields = '__all__'
read_only_fields = [
'created_by', 'modified_at', 'modified_by', 'archived'
]
def to_representation(self, instance):
response = super().to_representation(instance)
response['cards'] = CardSerializer(instance.cards,
many=True,
context={
'request':
self.context.get('request')
}).data
return response
class UserSerializer(serializers.ModelSerializer):
cards = CardSerializer(many=True, read_only=True)
class Meta:
model = User
fields = (
'id',
'username',
'cards',
)
def followed_users_cards(self, request):
cards = Card.objects.filter(author__fans=self.request.user)
page = self.paginate_queryset(cards)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = CardSerializer(cards,
many=True,
context={'request': request})
return Response(serializer.data)
def put(self, request, pk, format=None):
card = self.get_object(pk)
current_card_author = card.author.lower()
data = request.data
serializer = CardSerializer(card, data=data)
if serializer.is_valid():
# Check author field in request data and see whether it is provided or not.
if 'author' in data:
incoming_card_author = data['author'].lower()
# Check card's author whether it is correct or not.
if incoming_card_author == current_card_author:
serializer.save()
return Response(serializer.data)
else:
request.META['error_message'] = 'FORBIDDEN'
return
request.META['error_message'] = 'BAD_REQUEST'
def my_cards(self, request):
cards = request.user.cards.all()
page = self.paginate_queryset(cards)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = CardSerializer(cards,
many=True,
context={'request': request})
return Response(serializer.data)
class DeckCardSerializer(serializers.ModelSerializer):
quantity = serializers.IntegerField(read_only=True)
golden = serializers.BooleanField(read_only=True)
card = CardSerializer(read_only=True)
class Meta:
model = DeckCard
fields = [
"quantity",
"golden",
"card",
]
def post(self, request, *args, **kwargs):
search_query = self.request.POST.get('search_field', None)
status_query = self.request.POST.get('search_status_field', None)
cards_pk = Card.objects.filter(
Q(card_series__icontains=search_query) | Q(card_number__icontains=search_query) | Q(
card_issue_datetime__icontains=search_query) | Q(
card_activity_end_datetime__icontains=search_query))
if status_query:
cards_pk = cards_pk.filter(Q(card_status=status_query))
cards = Card.objects.filter(pk__in=cards_pk.distinct().values_list('pk', flat=True))
self.context['data'] = CardSerializer(cards, many=True).data
return Response(self.context, status=self.status_code)
class UserCardSerializer(serializers.ModelSerializer):
card = CardSerializer()
user = UserSerializer()
class Meta:
model = UserCard
fields = ('id', 'status', 'card', 'user')
def update(self, instance, validated_data):
instance.status = validated_data['status']
instance.save()
return instance
class UserSerializer(serializers.ModelSerializer):
card = CardSerializer(many=True, read_only=True, source='card_sets')
content = ContentSerializer(many=True,
read_only=True,
source='content_sets')
class Meta:
model = User
fields = ('id', 'username', 'email', 'card', 'content', 'password')
extra_kwargs = {'password': {'write_only': True}}
def create(self, validated_data):
user = User(username=validated_data['username'])
user.set_password(validated_data['password'])
user.save()
return user
class UserSerializer(serializers.ModelSerializer):
card = CardSerializer(
source='card_set',
many=True,
)
class Meta:
model = User
fields = [
'id',
'username',
'password',
'card',
'email',
]
extra_kwargs = {'password': {'write_only': True}}
def get_cards(self, list):
cards = list.card_set.all()
serializers = CardSerializer(cards, many=True)
return serializers.data
class ListSerializer(serializers.ModelSerializer):
cards = CardSerializer(many=True, required=False)
class Meta:
model = List
fields = '__all__'
def get(self, request, pk, format=None):
card = self.get_object(pk)
serializer = CardSerializer(card)
return Response(serializer.data)
def cards(self, request):
mywallet = Wallet.objects.get(owner_id=request.user.id)
mycards = Cards.objects.filter(wallet_id=mywallet.id)
return Response([CardSerializer(card).data for card in mycards])
def get(self, request, format=None):
cards = Card.objects.all()
serializer = CardSerializer(cards, many=True)
return Response(serializer.data)
class ListSerializer(serializers.ModelSerializer):
cards = CardSerializer(many=True, read_only=True)
class Meta:
model = List
fields = ('id', 'name', 'cards_order', 'board', 'cards')
def load_cards():
num_pagina = 1
while True:
url_pagina = "https://www.solosagrado.com.br/categorias/114/Avulso-Portugues/pagina/{}/view/vertical/ord/2/qtdview/36".format(
num_pagina)
page = requests.get(url_pagina)
soup = BeautifulSoup(page.content.decode('utf-8', 'ignore'),
'html.parser')
card_items = soup.find_all('div', class_='product_item')
if card_items is None or len(card_items) == 0:
break
for card in card_items:
card_data = {}
a_tag = card.find('h5', class_='m_bottom_10').find('a')
card_data['url_carta'] = "https://www.solosagrado.com.br{}".format(
a_tag.get('href'))
card_data[
'url_imagem_carta'] = 'https://www.solosagrado.com.br/images/produtos/w200/h292/{}'.format(
card.find('img',
class_='tr_all_hover').get('src').split('/')[-1])
card_data['titulo'] = a_tag.contents[0].strip()
preco_div = card.find('div', class_='clearfix m_bottom_10')
card_data['estoque'] = preco_div.find(
'p', class_='produto-qtd').find('span').contents[0].strip()
card_data['estoque'] = ''.join([
estoque for estoque in card_data['estoque']
if estoque != '\r' and estoque != '\n'
])
card_data['estoque'] = ' '.join([
estoque for estoque in card_data['estoque'].split(' ')
if len(estoque) > 0
])
card_data['disponivel'] = not 'indisponível' in card_data[
'estoque'].lower()
card_data['preco'] = preco_div.find(
'p', class_='scheme_color f_size_large').find(
'span', class_='bold').contents[0].strip().split(' ')[-1]
card_data['preco'] = '.'.join(card_data['preco'].split(','))
serializer = CardSerializer(data=card_data)
if serializer.is_valid():
serializer.save()
num_pagina += 1
def get(self, request):
card = Card.objects.all()
self.context['data'] = CardSerializer(card, many=True).data
return Response(self.context, status=self.status_code)
def test_create_card(self, expansion_1):
values_error = {"expansion": {"id": 9}, "name": "Vellen", "cost": 2}
serializer = CardSerializer(data=values_error)
serializer.is_valid()
with pytest.raises(Expansion.DoesNotExist):
serializer.save()
values = {
"expansion": {
"id": expansion_1.id
},
"name": "Vellen",
"cost": 2
}
serializer = CardSerializer(data=values)
assert serializer.is_valid()
serializer.save()
assert Card.objects.filter(name=values["name"])
def cardqueryslug(request, slug):
card = Card.objects.get(tarife_slug=slug)
serializer = CardSerializer(card, many=False)
return Response(serializer.data)
