def ready(self):
super().ready()
if 'runserver' not in sys.argv:
return True
else:
from products.serializers import ProductSerializer
call_command('migrate',
app_label='products',
verbosity=0,
interactive=True,
database='default')
call_command('dumpdata',
'products',
output='products.json',
verbosity=0,
database='storage',
format='json')
if os.path.exists('products.json'):
with open('products.json', 'r') as myfile:
data=json.loads(myfile.read())
for item in data:
if item['model'] == 'products.product':
serializer = ProductSerializer(data=item['fields'])
if serializer.is_valid():
serializer.save_to_memory(item['fields'])
else:
print(serializer.errors)
def product_detail(request, id, format=None):
"""
Retrieve, update or delete a product instance.
"""
try:
product = Product.objects.get(id=id)
except Product.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = ProductSerializer(product)
return Response(serializer.data)
elif request.method == 'PUT':
if 'ordered' in request.DATA:
del request.DATA['ordered']
serializer = ProductSerializer(product, data=request.DATA, partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
if product.ordered:
return Response('Cannot delete ordered product')
product.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def put(self, request, id, format=None):
product = self.get_object(id)
serializer = ProductSerializer(product, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
serializer = ProductSerializer(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 post(self, request):
serializer = ProductSerializer(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 add_product_list(request):
if request.method == 'POST':
product_data = JSONParser().parse(request)
product_serializer = ProductSerializer(data=product_data)
if product_serializer.is_valid():
product_serializer.save()
return JsonResponse(product_serializer.data, status=status.HTTP_201_CREATED)
return JsonResponse(product_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
product_serializer = ProductSerializer(data=request.data['data'])
if product_serializer.is_valid():
product_serializer.save()
return Response(product_serializer.data,
status=status.HTTP_201_CREATED)
return Response(product_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def mutate(cls, root, info, **kwargs):
serializer = ProductSerializer(data=kwargs)
if serializer.is_valid():
product = serializer.save()
msg = "success"
else:
msg = serializer.errors
product = None
return cls(product=product, message=msg, status=201)
def test_object_is_not_created_without_required_fields(self):
"""
Tests that product is not created if title, description or price
return:
"""
data1 = self.data.copy()
del data1["title"]
serializer = ProductSerializer(data=data1)
self.assertFalse(serializer.is_valid())
self.assertEqual(serializer.errors.get("title")[0], self.error_message)
data2 = self.data.copy()
del data2["description"]
serializer = ProductSerializer(data=data2)
self.assertFalse(serializer.is_valid())
self.assertEqual(
serializer.errors.get("description")[0], self.error_message)
data3 = self.data.copy()
del data3["price"]
serializer = ProductSerializer(data=data3)
self.assertFalse(serializer.is_valid())
self.assertEqual(serializer.errors.get("price")[0], self.error_message)
def product_rud(request, id=None):
"""
Retrieve, update or delete a product
"""
try:
product = Product.objects.get(pk=id)
except Product.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
if product:
serializer = ProductSerializer(product)
return Response(serializer.data)
else:
#id = None
product1 = Product.objects.all(id=None)
serializer = ProductSerializer(product1, many=True)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = ProductSerializer(product, data=request.data)
if serializer.is_valid():
serializer.save()
print('&&&&&&&&&&&', serializer.data)
return Response(serializer.data)
return Response(status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
product.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def mutate(cls, root, info, product_id, **kwargs):
product = Product.objects.get(id=product_id)
serializer = ProductSerializer(instance=product,
data=kwargs,
partial=True)
if serializer.is_valid():
serializer.save()
msg = "success"
else:
product = None
msg = serializer.errors
return cls(product=product, message=msg, status=204)
def add_product(data):
"""
Utility function to add product
:param data: JSON object in the format of products model to add in product.
:return response status 201 and serialized data, if data passed is valid,
otherwise return error with status 400.
"""
serializer = ProductSerializer(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):
today = datetime.date.today()
todays_records = Product.objects.filter(created__gt=today)[:10]
if todays_records.count() > 10:
raise APIException("today limit reached")
data = request.data.copy()
serializer = ProductSerializer(data=data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
else:
return Response(serializer.errors)
def test_object_creation(self):
"""
Test that product can be created with title, description and price as mandatory fields
return:
"""
serializer = ProductSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
product = serializer.save()
self.assertEqual(product.title, self.title)
self.assertEqual(product.description, self.description)
self.assertEqual(product.price, self.price)
self.assertTrue(product.is_active)
self.assertTrue(product.available)
def save(self, request):
serializer = ProductSerializer(data=request.data)
if serializer.is_valid(raise_exception=True):
product_save = Product.objects.create(
title=request.data.get('title'),
excerpt=request.data.get('excerpt'),
description=request.data.get('description'),
price=request.data.get('price'),
descount=request.data.get('descount'),
coupon=request.data.get('coupon'),
stock=request.data.get('stock'),
stock_min=request.data.get('stock_min'),
stock_max=request.data.get('stock_max'),
users=request.user)
return product_save
def update(self, request, pk):
product_save = Product.objects.get(id=pk, users=request.user)
serializer = ProductSerializer(data=request.data, partial=True)
if serializer.is_valid(raise_exception=True):
product_save.title = request.data.get('title')
product_save.excerpt = request.data.get('excerpt')
product_save.description = request.data.get('description')
product_save.price = request.data.get('price')
product_save.descount = request.data.get('descount')
product_save.coupon = request.data.get('coupon')
product_save.stock = request.data.get('stock')
product_save.stock_min = request.data.get('stock_min')
product_save.stock_max = request.data.get('stock_max')
product_save.save()
return product_save
def test_deserialize_properties(transactional_db):
from products.models import Product
# create
data = {'summary': u'Orange',
'deposit_amount': 10.00,
'currency': u'EUR',
'description': u'',
'address': _location('address-detail', pk=1),
'category': _location('category-detail', pk=1),
'owner': _location('patron-detail', pk=1),
'eloue_color': u'cyan',
'eloue_size': 25}
ps = ProductSerializer(data=data)
assert not ps.errors
ps.save()
p = Product.objects.get(pk=ps.object.pk)
assert p.properties.count() == 3
assert p.properties.filter(property_type__attr_name='color', value_str='cyan').exists()
assert p.properties.filter(property_type__attr_name='size', value_str='25').exists()
assert p.properties.filter(property_type__attr_name='default_value', value_str='5').exists()
# update
data = {'summary': u'Banana',
'deposit_amount': 40.00,
'currency': u'EUR',
'description': u'',
'address': _location('address-detail', pk=1),
'category': _location('category-detail', pk=1),
'owner': _location('patron-detail', pk=1),
'eloue_color': u'yellow',
'eloue_size': 1}
ps = ProductSerializer(Product.objects.get(pk=1), data=data)
assert not ps.errors
ps.save(force_update=True)
p = Product.objects.get(pk=1)
assert p.properties.count() == 3
assert p.properties.filter(property_type__attr_name='color', value_str='yellow').exists()
assert p.properties.filter(property_type__attr_name='size', value_str='1').exists()
assert p.properties.filter(property_type__attr_name='default_value', value_str='5').exists()
assert PropertyValue.objects.count() == 6
assert Property.objects.count() == 4
assert Product.objects.count() == 2
class ExpectedArrivalEntrySerializer(serializers.ModelSerializer):
expected_arrival = ExpectedArrivalSrializer(read_only=True, many=False)
product = ProductSerializer(read_only=True, many=False)
class Meta:
model = ExpectedArrivalEntry
fields = ("id", "expected_arrival", "product", "quantity")
class OrderSerializer(serializers.ModelSerializer):
order_products = ProductSerializer(source='get_order_products',
many=True,
required=False,
read_only=True)
total_price = serializers.SerializerMethodField('get_total_price')
stamp_cost = serializers.SerializerMethodField('get_stamp_cost')
order_products_set = OrderProductSerializer(many=True, required=False)
def create(self, validated_data):
order_products_data = validated_data.pop('order_products_set')
order = Order.objects.create(**validated_data)
for d in order_products_data:
OrderProduct.objects.create(
order=order,
product=d['product'],
message=d['message'],
color=d['color'],
font=d['font'],
return_address=d['return_address'],
recipient_address=d['recipient_address'])
return order
class Meta:
model = Order
fields = [
'id', 'user', 'email', 'order_products_set', 'order_products',
'updated_at', 'created_at', 'total_price', 'status', 'stamp_cost'
]
def get_stamp_cost(self, instance):
return instance.order_products.count() * 0.55
def get_total_price(self, instance):
return instance.order_products.aggregate(Sum('price'))
class WishlistSerializer(serializers.ModelSerializer):
user = UserSerializer(required=False)
products = ProductSerializer(many=True, required=False)
class Meta:
model = Wishlist
fields = '__all__'
class OrderDetail(serializers.ModelSerializer):
"""detail order model"""
products = ProductSerializer(many=True, read_only=True)
class Meta:
model = Order
fields = ('id', 'title', 'description', 'enable', 'products')
class SaleProSerializer(serializers.ModelSerializer):
product_sale_rel = ProductSerializer()
class Meta:
model = SaleProductInline
fields = ('id', 'supplier_type', 'apply_discount', 'arrival_date',
'product_sale_rel')
class OrderDetailSerializer(serializers.ModelSerializer):
product = ProductSerializer(read_only=True)
class Meta:
model = OrderDetail
fields = ('id', 'product', 'order', 'product_quantity')
read_only_fields = ('id', )
class OrderSerializer(serializers.ModelSerializer):
products = ProductSerializer(many=True, read_only=True)
class Meta:
model = Order
fields = ('id', 'buyer', 'products', 'address', 'phone_number',
'delivery_date', 'total_price_before_sale', 'total_price')
def setUp(self):
self.URL = '/products?departure_region=김포&arrive_region=울산&departure_date=2020-12-17'
# 위 self.URL의 쿼리스트링은 get요청이 아닌 다른 요청이면 무시되어 url이 '/products' 상태가 된다
self.client = Client()
SeatType.objects.bulk_create([
SeatType(name='비즈니스석'),
])
Region.objects.bulk_create([
Region(name='김포', region_code='GMP', image_url=''),
Region(name='울산', region_code='USN', image_url='')
])
Airline.objects.bulk_create([
Airline(name='진에어', image_url='rud123213jkjdk'),
])
Airplane.objects.create(
airline=Airline.objects.get(name='진에어'),
from_region=Region.objects.get(name='김포'),
to_region=Region.objects.get(name='울산'),
from_date=datetime.datetime(2020, 12, 17, 10, 15, 30),
to_date=datetime.datetime(2020, 12, 17, 10, 16, 30),
airplane_numbers="KP665")
Product.objects.create(id=1,
airplane=Airplane.objects.all().first(),
price=5000,
seat_type=SeatType.objects.all().first(),
remaining_seat=170,
total_seats=300)
product = Product.objects.all()
self.serializer = ProductSerializer(product, many=True)
def delete(self, request, slug):
user_id = request.user.id
quantity = ItemQuantitySerializer(data=request.data)
if not quantity.is_valid():
return Response(data=quantity.errors,
status=status.HTTP_400_BAD_REQUEST)
product = get_object_or_404(Product, slug=slug.lower())
productSerializer = ProductSerializer(product)
user = get_object_or_404(User, id=user_id)
cart = get_object_or_404(Cart, user=user)
removed = cart.delete_item(product=product,
quantity=quantity.data['quantity'])
if not removed:
return Response(data={
'msg':
"Product doesn't exist in cart or quantity not acceptable"
},
status=status.HTTP_400_BAD_REQUEST)
total = 0
for item in cart.item_set.all():
total += item.subtotal
cart.total = total
cart.save()
return Response(status=status.HTTP_200_OK)
class RequestSerializierRead(serializers.ModelSerializer):
product = ProductSerializer(read_only=True)
error = ErrorSerializer(read_only=True)
class Meta:
model = Request
fields = ('__all__')
class CartItemListSerializer(serializers.ModelSerializer):
item = ProductSerializer(read_only=True)
class Meta:
model = CartItem
fields = ('id', 'quantity', 'item', 'size')
def post(self, request, slug):
user_id = request.user.id
quantity = ItemQuantitySerializer(data=request.data)
if not quantity.is_valid():
return Response(data=quantity.errors,
status=status.HTTP_400_BAD_REQUEST)
product = get_object_or_404(Product, slug=slug.lower())
productSerializer = ProductSerializer(product)
user = get_object_or_404(User, id=user_id)
cart = Cart.objects.get_or_create(user=user)[0]
item, added = cart.add_item(product=product,
quantity=quantity.data['quantity'])
if not added:
return Response(data={'msg:': 'Out of stock range'},
status=status.HTTP_401_UNAUTHORIZED)
total = 0
for item in cart.item_set.all():
print(item)
total += item.subtotal
cart.total = total
cart.save()
serializer = ItemSerializer(item)
return Response(data=serializer.data, status=status.HTTP_200_OK)
class OrderItemDetailSerializer(serializers.ModelSerializer):
item = ProductSerializer(read_only=True)
class Meta:
model = OrderItem
fields = "__all__"
class OrderDetailSerializer(serializers.ModelSerializer):
order = OrderSmallSerializer(many=False)
product = ProductSerializer(many=False)
def validate_cuantity(self, value):
if value < 1:
raise serializers.ValidationError(
"La cantidad debe ser mayor que cero.")
return value
def validate_product(self, value):
if value.stock < 1:
raise serializers.ValidationError(
"El producto no tiene stock disponible.")
return value
class Meta:
model = OrderDetail
fields = ('uuid', 'order', 'cuantity', 'product')
extra_kwargs = {
'order': {
'allow_null': False,
'required': True
},
'cuantity': {
'allow_null': False,
'required': True
},
'product': {
'allow_null': False,
'required': True
}
}
def retrieve(self, request, *args, **kwargs):
limit = self.request.query_params.get("limit", 10)
page_no = int(self.request.query_params.get("pageNo", 0)) + 1
order = self.request.query_params.get("order")
order_by = self.request.query_params.get("orderBy")
products = Product.objects.all()
if order is not None and order_by is not None:
products = products.order_by(order_by)
if order == "desc":
products = products.reverse()
paginator = Paginator(products, limit)
try:
data = paginator.page(page_no)
except PageNotAnInteger:
data = paginator.page(1)
except EmptyPage:
data = paginator.page(paginator.num_pages)
serialized = []
for v in data:
serialized.append(ProductSerializer(v).data)
result = {"data": serialized, "total": products.count()}
return Response(data=result, status=status.HTTP_200_OK)
def product_list(request, format=None):
"""
List all products, or create a new product.
"""
if request.method == 'GET':
products = Product.objects.all()
serializer = ProductSerializer(products, many=True)
return Response(serializer.data)
elif request.method == 'POST':
if 'id' in request.DATA:
del request.DATA['id']
if 'ordered' in request.DATA:
del request.DATA['ordered']
serializer = ProductSerializer(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 put(self, request, pk):
if int(pk) != int(request.data['id']):
return Response(
"Product ID %s doesn't match to edit product's %s" % (
str(pk),
str(request.data['id'])
),
status=status.HTTP_400_BAD_REQUEST
)
try:
product = Product.objects.get(pk=int(request.data['id']))
except Product.DoesNotExist:
serializer = ProductSerializer(data=request.data)
code = status.HTTP_201_CREATED
else:
serializer = ProductSerializer(product, data=request.data)
code = status.HTTP_200_OK
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=code)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def handle(self, *args, **options):
json_products = json.loads(urlopen(DATA_SOURCE).read())
for product_json in json_products['products']:
product_json['price'] = product_json['price'].replace('.', '').replace(',', '.')
product_json['price_old'] = product_json['price_old'].replace('.', '').replace(',', '.')
serializer = ProductSerializer(data=product_json)
if serializer.is_valid():
serializer.save()
else:
product = Product.objects.get(pk=int(product_json['id']))
serializer = ProductSerializer(product, data=product_json)
if serializer.is_valid():
serializer.save()
self.stdout.write(self.style.SUCCESS('Successfully populated database.'))
def retrieve(self, request, pk):
product = get_object_or_404(Product, pk=pk)
# compruebo si el usuario autenticado puede hacer GET en este product
self.check_object_permissions(request, product)
serializer = ProductSerializer(product)
return Response(data=serializer.get_images(product), status=status.HTTP_200_OK)
