def create(self, request): Item_all_obj = ItemSerializer(data=request.data) if Item_all_obj.is_valid(): new_obj = Item_all_obj.save() new_obj_ser = ItemSerializer(new_obj) return Response(new_obj_ser.data) else: return Response(new_obj_ser.errors)
class MyItemSerializer(serializers.ModelSerializer): user = UserSerializer(required=False) item = ItemSerializer(read_only=True, required=False) class Meta: model = MyItem fields = "__all__"
def get(self, request, *args, **kwargs): user = self.get_user() ordered_items = list() #orders_ = self.model.objects.all() orders = BuyerOrder.objects.filter(user = user) for i, obj in enumerate(orders) : order_info = obj.item # Every Item has info about the users(field) how posted it # That user info can be used to get sellerprofile seller_info = SellerProfile.objects.get(user = obj.item.user) ordered_items.append( {"placed" : obj.placed, "Order Satus" : obj.order_sat, "Info" : ItemSerializer(order_info).data, "seller" : SellerProfileSerializer(seller_info).data } ) res = { "status": 'success', "code": status.HTTP_200_OK, "message": 'Fteched successfully', "ordered_items" : ordered_items, } return Response(res , status=status.HTTP_200_OK)
class CartItemSerializer(ModelSerializer): total_price = serializers.SerializerMethodField('_get_total_price') item = ItemSerializer(read_only=True) price = serializers.DecimalField(max_digits=10, decimal_places=2, required=False) class Meta: model = CartItem fields = ('id', 'item', 'item_id', 'price', 'quantity', 'total_price') def _get_total_price(self, cart_item): return cart_item.price * int(cart_item.quantity) def create(self, validated_data): request = self.context.get('request') item = Item.objects.get(id=request.data['item']) cart = request.user.current_cart cart_item = CartItem( item=item, price=item.price, cart_id=cart.id, item_id=item.id, quantity=request.data['quantity'], ) cart_item.save() cart.items.add(item) cart.save() return cart_item
def test(self): response = self.client.get(self.url) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual( response.data, ItemSerializer(self.item).data )
def fix(self, request, pk=None): """moves Item from the current state to the next""" item = self.get_object() try: item.fix() except InvalidStateTransitionError as ex: return Response( data={ 'error': str(ex) }, status=status.HTTP_400_BAD_REQUEST, exception=True ) else: # response should have current Item values and success message serializer = ItemSerializer( item, context={ 'request': request } ) response_data = serializer.data response_data['status'] = 'Item fixed' return Response(response_data)
def get(self, request, *args, **kwargs): user = self.get_user() _items = list() #orders_ = self.model.objects.all() orders = Item.objects.filter(user = user) for i, obj in enumerate(orders) : _items.append( { "Info" : ItemSerializer(obj).data, } ) res = { "status": 'success', "code": status.HTTP_200_OK, "message": 'Fteched successfully', "items" : _items, } return Response(res , status=status.HTTP_200_OK)
class PromoSerializer(serializers.ModelSerializer): items = ItemSerializer(many=True) class Meta: model = Promo fields = ('title', 'due_date', 'start_date', 'cashback_rub', 'items', 'lower_bound_rub')
def retrieve(self, request, pk=None): try: item = Item.objects.get(id=pk) except Item.DoesNotExist: return Response(status=status.HTTP_400_BAD_REQUEST) serializer = ItemSerializer(item) return Response(serializer.data)
def update(self, request, pk=None): try: item = Item.objects.get(id=pk) print(item) item.name = request.data.get('name') item.save() except Item.DoesNotExist: return Response(status=status.HTTP_400_BAD_REQUEST) serialized = ItemSerializer(item) return Response(serialized.data)
def __init__(self, *args, **kwargs): # Lazy loading, solving circular import errors from knacks.serializers import KnackSerializer from items.serializers import ItemSerializer self.fields['knacks'] = KnackSerializer(many=True, read_only=True, depth=-1) self.fields['items'] = ItemSerializer(many=True, read_only=True, depth=-1) super(ProfileSerializer, self).__init__(*args, **kwargs)
def category_search(request, pk, format=None): """Retrieve, update or delete a code category.""" try: category = Category.objects.get(name=pk) except Category.DoesNotExist: return Response(status=status.HTTP_404_NOT_FOUND) if request.method == 'GET': items = Item.get_active(category=category) print("items") serializer = ItemSerializer(items, many=True) # serializer = ItemsCategorySerializer(items, many=True) return Response(serializer.data)
def item_list(request, format=None): """List all code items, or create a new item.""" if request.method == 'GET': items = Item.get_active() serializer = ItemSerializer(items, many=True) return Response(serializer.data) elif request.method == 'POST': serializer = ItemSerializer(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 ItemList(request): if request.method == 'GET': items = Items.objects.all() serializer = ItemSerializer(items, many=True) return Response(serializer.data) elif request.method == 'POST': serializer = ItemSerializer(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 create_transaction(self, request, pk=None): """creates a Transaction for the given Item""" item = self.get_object() transaction = item.create_transaction() # response should have current Item values and success message serializer = ItemSerializer( item, context={ 'request': request } ) response_data = serializer.data response_data['status'] = 'Transaction {} created'.format(transaction.id) return Response(response_data)
def post(self, request: Request, product_id: int, format: str = None): try: Product.objects.filter(id=product_id, seller=request.user).exists() except Item.DoesNotExist: return Response(status=status.HTTP_404_NOT_FOUND) request.data.update({"product": product_id}) serializer = ItemSerializer(data=request.data) serializer.is_valid(raise_exception=True) serializer.save() return Response(status=status.HTTP_204_NO_CONTENT)
class CartItemSerializer(serializers.ModelSerializer): item = ItemSerializer(read_only=True) item_id = serializers.PrimaryKeyRelatedField( source='item', queryset=Item.objects.all(), ) class Meta: model = CartItem fields = ( 'id', 'item', 'quantity', 'item_id', 'price', 'total_price', ) read_only_fields = ( 'price', 'total_price', 'item', ) extra_kwargs = { 'quantity': { 'required': True }, } def validate_quantity(self, value): if value <= 0: raise serializers.ValidationError("Not valid") return value def create(self, validated_data): cart_item = CartItem( item=validated_data['item'], cart=self.context['request'].user.current_cart, quantity=validated_data['quantity'], price=validated_data['item'].price, ) cart_item.save() return cart_item
def post(self, request, *args, **kwargs): item_serializer = self.get_serializer(data = request.data ) item_serializer.is_valid(raise_exception=True) item = item_serializer.save(user = self.get_object(), item_name_normalized = normalize_text(request.data["item_name"]), top_product = products_info.IsTopProduct(), featured_product = products_info.IsFeaturedProduct(),) res = { "status": 'success', "code": status.HTTP_200_OK, "message": 'Item Saved Successfully', "item": ItemSerializer(item, context=self.get_serializer_context()).data } return Response(res , status=status.HTTP_200_OK)
def list(self, request, *args, **kwargs): to_be_shown = [] latitude = radians(float(request.query_params.get('latitude'))) longitude = radians(float(request.query_params.get('longitude'))) queryset = Item.objects.all() for i in queryset: lat1 = radians(i.latitude) long1 = radians(i.longitude) dlat = latitude - lat1 dlon = longitude - long1 # a = sin(dlat / 2)**2 + cos(latitude) * cos(i.latitude) * sin(dlong/ 2)**2 a = sin(dlat / 2)**2 + cos(latitude) * cos(lat1) * sin(dlon / 2)**2 c = 2 * atan2(sqrt(a), sqrt(1 - a)) # c = 2 * asin(sqrt(a)) distance = c * 6371 # print(c) print(distance) if distance < 100: to_be_shown.append(i) serializer = ItemSerializer(to_be_shown, many=True) return Response(serializer.data)
def patch( self, request: Request, product_id: int, item_id: int, format: str = None ): try: item = Item.objects.get( id=item_id, product__id=product_id, product__seller=request.user ) except Item.DoesNotExist: return Response(status=status.HTTP_404_NOT_FOUND) serializer = ItemSerializer(item, data=request.data, partial=True) serializer.is_valid(raise_exception=True) serializer.save() return Response(status=status.HTTP_204_NO_CONTENT)
def ItemDetail(request, pk): try: item = Items.objects.get(pk=pk) except Items.DoesNotExist: return Response(status=status.HTTP_404_NOT_FOUND) if request.method == 'GET': serializer = ItemSerializer(item) return Response(serializer.data) elif request.method == 'PUT': serializer = ItemSerializer(item, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) elif request.method == 'DELETE': item.delete() return Response(status=status.HTTP_204_NO_CONTENT)
class BillSerializer(serializers.ModelSerializer): qr = serializers.JSONField() items = ItemSerializer(many=True) class Meta: model = Bill fields = ('dateTime', 'nds18', 'taxation_type', 'ecash_total_sum', 'qr', 'fiscalSign', 'cashTotalSum', 'total_sum', 'operationType', 'items') def create(self, validated_data): """ without data validation - need only qr code :param validated_data: :return: """ items_data = validated_data.pop('items') model_class = self.Meta.model try: instance = model_class.objects.create(**validated_data) except TypeError: msg = ('Got a `TypeError` when calling `%s.objects.create()`. ' '\nOriginal exception was:\n %s' % (model_class.__name__, traceback.format_exc())) raise TypeError(msg) for item_data in items_data: item, created = Item.objects.get_or_create(**item_data) instance.items.add(item) # BillService.determine_cashback(instance) return instance
def item_detail(request, pk, format=None): """Retrieve, update or delete a code item.""" try: item = Item.objects.get(pk=pk) except Item.DoesNotExist: return Response(status=status.HTTP_404_NOT_FOUND) if request.method == 'GET': serializer = ItemSerializer(item) return Response(serializer.data) elif request.method == 'PUT': serializer = ItemSerializer(item, 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': item.delete() return Response(status=status.HTTP_204_NO_CONTENT)
def list(self, request): items = Item.objects.all() serializer = ItemSerializer(items, many=True) return Response(serializer.data)
def get(self, request: Request, product_id: int, format: str = None): queryset = Item.objects.filter( product__seller=self.request.user, product__id=product_id ) return Response(ItemSerializer(queryset, many=True).data)
class ProfileSerializer(serializers.ModelSerializer): social_links = SocialLinkSerializer(source='sociallink', many=False) descriptions = DescriptionSerializer(source='description_set', many=True) feedbacks = FeedbackSerializer(source='feedback_set', many=True) full_name = serializers.CharField(max_length=255, required=True, allow_blank=True) college = serializers.ReadOnlyField(source='college.name') year = serializers.ReadOnlyField(source='year.name') knacks = KnackSerializer(many=True, read_only=True) items = ItemSerializer(many=True, read_only=True) #picture = serializers.SerializerMethodField('get_avatar_thumbnail') reasons = serializers.SerializerMethodField('split') last_seen1 = serializers.SerializerMethodField('get_last_seen') created_date = serializers.SerializerMethodField('get_created_at') class Meta: model = User fields = ('email', 'full_name', 'first_name', 'last_name', 'age', 'college', 'year', 'picture', 'feedbacks', 'grand_total', 'reasons', 'about_me', 'payment_venmo', 'payment_paypal', 'public_profile_url', 'created_date', 'last_seen1', 'social_links', 'descriptions', 'id', 'knacks', 'items') def split(self, obj): if obj.reasons: return obj.reasons else: return None def get_avatar_thumbnail(self, obj): if obj.picture: return obj.picture.url else: return None def get_last_seen(self, obj): mins = (timezone.now() - obj.last_seen).total_seconds() / 60 if mins >= 1440: mins = int(mins) / 1440 unit = ' days ago' elif mins >= 60: mins = int(mins) / 60 unit = ' hours ago' else: mins = int(mins) unit = ' minutes ago' return str(mins) + unit def get_created_at(self, obj): return obj.created_at.strftime('%b %dth, %Y') def update(self, instance, validated_data): instance.age = validated_data.get('age') full_name = validated_data.get('full_name').split(' ') instance.first_name = full_name[0] try: instance.last_name = full_name[1] except: instance.last_name = '' # instance.email = validated_data.get('email', instance.email) instance.save() return instance def to_internal_value(self, data): picture = data.pop('picture')[0] if not isinstance(picture, str) or not isinstance(picture, unicode): self.instance.picture = picture sociallinks = json.loads(data.pop('social_links', None)[0]) if sociallinks: if not hasattr(self.instance, 'sociallink'): self.instance.sociallink = SocialLink() self.instance.sociallink.twitter = sociallinks['twitter'] self.instance.sociallink.instagram = sociallinks['instagram'] self.instance.sociallink.facebook = sociallinks['facebook'] self.instance.sociallink.googleplus = sociallinks['googleplus'] self.instance.sociallink.save() self.instance.description_set.all().delete() descriptions = json.loads(data.pop('descriptions', None)[0]) for desc in descriptions: desc_obj = Description(description=desc['description'], user=self.instance) desc_obj.save() ret = super(ProfileSerializer, self).to_internal_value(data) return ret
def get(self, request): items = Item.objects.all() serialized = ItemSerializer(instance=items) return Response(serialized.data, status=200)
class UserSerializer(serializers.HyperlinkedModelSerializer): items = ItemSerializer(many=True, read_only=False) class Meta: model = User fields = ['url', 'username', 'email', 'groups', 'items']
class FolderSerializer(serializers.ModelSerializer): items = ItemSerializer(many=True, read_only=True) class Meta: model = Folder fields = ('id', 'name', 'isroot', 'idparent', 'created', 'items')
def item_create(request): if request.method == 'PUT': data = JSONParser().parse(request) # create item item = Item() item_data = {} item_data['item_name'] = data['item_name'] item_data['item_price'] = data['item_price'] item_data['frequency'] = data['frequency'] item_data['classify'] = data['classify'] serializer = ItemSerializer(item, data=item_data) if serializer.is_valid(): serializer.save() item_id = item.id # create step step_list = data['steps'] for step_val in step_list: step = Step() step_data = step_val step_data['belong_item'] = item_id serializer = StepSerializer(step, step_data) if serializer.is_valid(): serializer.save() else: return JsonResponse(serializer.errors, status=400) product_list = data['product'] for product_val in product_list: item_product = Item_Product() product_data = product_val product_data['item'] = item_id product_data['product'] = Product.objects.get( name=product_data['name']).id serializer = ItemProductSerializer(item_product, product_data) if serializer.is_valid(): serializer.save() else: return JsonResponse(serializer.errors, status=400) instrument_list = data['instrument'] for instrument_val in instrument_list: item_instrument = Item_Instrument() instrument_data = instrument_val instrument_data['item'] = item_id instrument_data['instrument'] = Instrument.objects.get( name=instrument_data['name']).id serializer = ItemInstrumentSerializer(item_instrument, instrument_data) if serializer.is_valid(): serializer.save() else: return JsonResponse(serializer.errors, status=400) return JsonResponse({"text": "success"}) return JsonResponse(serializer.errors, status=400)