""" Marketplace serializers. Covers: - Category, SubCategory, Brand - ProductVariant, VariantAttribute - ProductImage (marketplace extension), ProductVideo - ProductSpecification, ProductTag - Vendor (public-facing summary) - ProductReview - ShoppingCart, CartItem - Wishlist, WishlistItem - OrderItem, OrderShipment, OrderStatusHistory - FlashOffer, CouponCode - PincodeServiceability, DeliveryEstimation """ from rest_framework import serializers from django.contrib.auth import get_user_model from apps.business.marketplace.models_part1 import ( Category, SubCategory, Brand, ProductVariant, VariantAttribute, ProductImage as MarketplaceProductImage, ProductVideo, ProductSpecification, ProductTag, Vendor, VendorDocument, ) from apps.business.marketplace.models_part2 import ( ShoppingCart, CartItem, CartPromotion, Wishlist, WishlistItem, OrderItem, OrderShipment, OrderStatusHistory, FlashOffer, CouponCode, ) from apps.business.marketplace.models_part3 import ( ProductReview, PincodeServiceability, DeliveryEstimation, LowStockAlert, ) from apps.business.products.models import Product User = get_user_model() # --------------------------------------------------------------------------- # Catalog serializers # --------------------------------------------------------------------------- class SubCategorySerializer(serializers.ModelSerializer): class Meta: model = SubCategory fields = ['id', 'name', 'slug', 'description', 'image_url', 'is_active', 'display_order'] class CategorySerializer(serializers.ModelSerializer): subcategories = SubCategorySerializer(many=True, read_only=True) class Meta: model = Category fields = [ 'id', 'name', 'slug', 'description', 'icon_url', 'image_url', 'is_active', 'display_order', 'seo_title', 'subcategories', ] class CategoryMinimalSerializer(serializers.ModelSerializer): class Meta: model = Category fields = ['id', 'name', 'slug', 'icon_url', 'image_url'] class BrandSerializer(serializers.ModelSerializer): class Meta: model = Brand fields = ['id', 'name', 'slug', 'logo_url', 'description', 'is_active'] # --------------------------------------------------------------------------- # Product extension serializers # --------------------------------------------------------------------------- class VariantAttributeSerializer(serializers.ModelSerializer): class Meta: model = VariantAttribute fields = ['id', 'attribute_name', 'attribute_value'] class ProductVariantSerializer(serializers.ModelSerializer): attributes = VariantAttributeSerializer(many=True, read_only=True) class Meta: model = ProductVariant fields = [ 'id', 'sku', 'name', 'mrp', 'selling_price', 'stock', 'is_active', 'attributes', ] class MarketplaceProductImageSerializer(serializers.ModelSerializer): sort_order = serializers.SerializerMethodField() class Meta: model = MarketplaceProductImage fields = ['id', 'image_url', 'alt_text', 'is_primary', 'sort_order'] def get_sort_order(self, obj): return obj.display_order class ProductVideoSerializer(serializers.ModelSerializer): thumbnail_url = serializers.SerializerMethodField() sort_order = serializers.SerializerMethodField() class Meta: model = ProductVideo fields = ['id', 'video_url', 'thumbnail_url', 'title', 'sort_order'] def get_thumbnail_url(self, obj): return None def get_sort_order(self, obj): return obj.display_order class ProductSpecificationSerializer(serializers.ModelSerializer): spec_group = serializers.SerializerMethodField() spec_key = serializers.SerializerMethodField() spec_value = serializers.SerializerMethodField() class Meta: model = ProductSpecification fields = ['id', 'spec_group', 'spec_key', 'spec_value', 'display_order'] def get_spec_group(self, obj): return 'General' def get_spec_key(self, obj): return obj.key def get_spec_value(self, obj): return obj.value class ProductTagSerializer(serializers.ModelSerializer): class Meta: model = ProductTag fields = ['id', 'tag'] # --------------------------------------------------------------------------- # Vendor serializers # --------------------------------------------------------------------------- class VendorPublicSerializer(serializers.ModelSerializer): """Public-facing vendor summary (browsing context).""" business_name = serializers.SerializerMethodField() business_type = serializers.SerializerMethodField() logo_url = serializers.SerializerMethodField() rating = serializers.SerializerMethodField() verified_at = serializers.SerializerMethodField() class Meta: model = Vendor fields = [ 'id', 'business_name', 'business_type', 'logo_url', 'city', 'state', 'rating', 'is_active', 'verified_at', ] def get_business_name(self, obj): return obj.store_name or obj.company_name def get_business_type(self, obj): return 'VENDOR_STORE' def get_logo_url(self, obj): return obj.store_logo_url def get_rating(self, obj): return '0.0' def get_verified_at(self, obj): return obj.approval_date class VendorDetailSerializer(serializers.ModelSerializer): """Full vendor info for vendor dashboard.""" business_name = serializers.SerializerMethodField() logo_url = serializers.SerializerMethodField() verified_at = serializers.SerializerMethodField() class Meta: model = Vendor fields = [ 'id', 'user', 'business_name', 'company_name', 'company_registration_number', 'tax_id', 'business_email', 'business_phone', 'business_address', 'city', 'state', 'pincode', 'country', 'store_name', 'store_description', 'logo_url', 'store_banner_url', 'status', 'is_active', 'verified_at', 'created_at', ] read_only_fields = ['id', 'user', 'verified_at', 'created_at'] def get_business_name(self, obj): return obj.store_name or obj.company_name def get_logo_url(self, obj): return obj.store_logo_url def get_verified_at(self, obj): return obj.approval_date # --------------------------------------------------------------------------- # Marketplace product card serializer (list context) # --------------------------------------------------------------------------- class MarketplaceProductCardSerializer(serializers.ModelSerializer): """ Compact product representation for listing / search pages. Does not include specs, videos, or full description. """ category_name = serializers.SerializerMethodField() brand_name = serializers.SerializerMethodField() vendor_name = serializers.SerializerMethodField() primary_image = serializers.SerializerMethodField() selling_price = serializers.SerializerMethodField() discount_percent = serializers.SerializerMethodField() is_bundle_product = serializers.SerializerMethodField() bundle_name = serializers.SerializerMethodField() in_stock = serializers.SerializerMethodField() class Meta: model = Product fields = [ 'id', 'name', 'slug', 'sku', 'description', 'base_cost', 'mrp', 'selling_price', 'discount_percent', 'average_rating', 'gst_percentage', 'marketplace_status', 'marketplace_category', 'category_name', 'brand', 'brand_name', 'vendor', 'vendor_name', 'primary_image', 'is_bundle_product', 'bundle_name', 'in_stock', 'allow_supercoins', 'allow_main_wallet', ] def get_category_name(self, obj): return obj.marketplace_category.name if obj.marketplace_category else None def get_brand_name(self, obj): return obj.brand.name if obj.brand else None def get_vendor_name(self, obj): if not obj.vendor: return None return obj.vendor.store_name or obj.vendor.company_name def get_primary_image(self, obj): # Try marketplace images first, then legacy product images from apps.business.marketplace.models_part1 import ProductImage as MPImage mp_img = MPImage.objects.filter(product=obj, is_primary=True).first() if mp_img: return mp_img.image_url legacy = obj.images.filter(is_primary=True).first() or obj.images.first() if legacy and legacy.image: request = self.context.get('request') return request.build_absolute_uri(legacy.image.url) if request else legacy.image.url return None def get_selling_price(self, obj): # selling_price = mrp or base_cost (mrp takes priority for display) return str(obj.mrp or obj.base_cost) def get_discount_percent(self, obj): if obj.mrp and obj.base_cost and obj.mrp > 0: discount = ((obj.mrp - obj.base_cost) / obj.mrp) * 100 return round(float(discount), 1) return 0 def get_is_bundle_product(self, obj): return obj.opportunity_bundle_id is not None def get_bundle_name(self, obj): return obj.opportunity_bundle.name if obj.opportunity_bundle else None def get_in_stock(self, obj): # Stock check: look at variants or assume in-stock if no variant system from apps.business.marketplace.models_part1 import ProductVariant variants = ProductVariant.objects.filter(product=obj, is_active=True) if variants.exists(): return variants.filter(stock__gt=0).exists() return True # no variant system = assume in stock class MarketplaceProductDetailSerializer(MarketplaceProductCardSerializer): """Full product detail for PDP.""" images = serializers.SerializerMethodField() videos = serializers.SerializerMethodField() specifications = serializers.SerializerMethodField() tags = serializers.SerializerMethodField() variants = serializers.SerializerMethodField() vendor_info = serializers.SerializerMethodField() category_info = serializers.SerializerMethodField() reviews_summary = serializers.SerializerMethodField() opportunity_bundle_info = serializers.SerializerMethodField() class Meta(MarketplaceProductCardSerializer.Meta): fields = MarketplaceProductCardSerializer.Meta.fields + [ 'category', 'product_type', 'hsn_code', 'allow_repurchase', 'allow_twm', 'twm_max_percentage', 'allow_part_payment', 'part_payment_percentage', 'part_payment_cooling_days', 'images', 'videos', 'specifications', 'tags', 'variants', 'vendor_info', 'category_info', 'reviews_summary', 'opportunity_bundle_info', ] def get_images(self, obj): from apps.business.marketplace.models_part1 import ProductImage as MPImage mp_images = MPImage.objects.filter(product=obj).order_by('display_order') if mp_images.exists(): return MarketplaceProductImageSerializer(mp_images, many=True).data # Fallback to legacy images from apps.business.products.models import ProductImage legacy = obj.images.all().order_by('sort_order') request = self.context.get('request') return [ { 'id': str(img.id), 'image_url': request.build_absolute_uri(img.image.url) if request and img.image else None, 'alt_text': img.alt_text or obj.name, 'is_primary': img.is_primary, 'sort_order': getattr(img, 'sort_order', 0), } for img in legacy if img.image ] def get_videos(self, obj): from apps.business.marketplace.models_part1 import ProductVideo as MPVideo videos = MPVideo.objects.filter(product=obj).order_by('display_order') return ProductVideoSerializer(videos, many=True).data def get_specifications(self, obj): from apps.business.marketplace.models_part1 import ProductSpecification as MPSpec specs = MPSpec.objects.filter(product=obj).order_by('display_order') return ProductSpecificationSerializer(specs, many=True).data def get_tags(self, obj): from apps.business.marketplace.models_part1 import ProductTag as MPTag tags = MPTag.objects.filter(product=obj) return [t.tag for t in tags] def get_variants(self, obj): from apps.business.marketplace.models_part1 import ProductVariant variants = ProductVariant.objects.filter(product=obj, is_active=True).prefetch_related('attributes') return ProductVariantSerializer(variants, many=True).data def get_vendor_info(self, obj): if obj.vendor: return VendorPublicSerializer(obj.vendor).data return None def get_category_info(self, obj): if obj.marketplace_category: return CategoryMinimalSerializer(obj.marketplace_category).data return None def get_reviews_summary(self, obj): from apps.business.marketplace.models_part3 import ProductReview reviews = ProductReview.objects.filter(product=obj, moderation_status='APPROVED') count = reviews.count() avg = float(obj.average_rating or 0) dist = {str(i): reviews.filter(rating=i).count() for i in range(1, 6)} return {'average': avg, 'count': count, 'distribution': dist} def get_opportunity_bundle_info(self, obj): if not obj.opportunity_bundle: return None ob = obj.opportunity_bundle return { 'id': str(ob.id), 'name': ob.name, 'amount': str(ob.opportunity_bundle_amount) if ob.opportunity_bundle_amount else None, } # --------------------------------------------------------------------------- # Review serializers # --------------------------------------------------------------------------- class ProductReviewSerializer(serializers.ModelSerializer): user_name = serializers.SerializerMethodField() user_avatar = serializers.SerializerMethodField() class Meta: model = ProductReview fields = [ 'id', 'user', 'user_name', 'user_avatar', 'rating', 'title', 'content', 'quality_rating', 'value_rating', 'delivery_rating', 'helpful_votes', 'moderation_status', 'created_at', ] read_only_fields = ['id', 'user', 'helpful_votes', 'moderation_status', 'created_at'] def get_user_name(self, obj): u = obj.user name = (u.get_full_name() or '').strip() return name if name else (u.mobile[:6] + '****' if hasattr(u, 'mobile') else 'User') def get_user_avatar(self, obj): return None # can be extended to return avatar URL class CreateReviewSerializer(serializers.ModelSerializer): class Meta: model = ProductReview fields = ['product', 'rating', 'title', 'content', 'quality_rating', 'value_rating', 'delivery_rating'] def validate_rating(self, value): if not (1 <= value <= 5): raise serializers.ValidationError("Rating must be between 1 and 5.") return value def validate(self, data): user = self.context['request'].user product = data['product'] if ProductReview.objects.filter(product=product, user=user).exists(): raise serializers.ValidationError("You have already reviewed this product.") return data def create(self, validated_data): validated_data['user'] = self.context['request'].user validated_data['moderation_status'] = 'PENDING' return super().create(validated_data) # --------------------------------------------------------------------------- # Cart serializers # --------------------------------------------------------------------------- class CartItemSerializer(serializers.ModelSerializer): product_name = serializers.SerializerMethodField() product_image = serializers.SerializerMethodField() product_slug = serializers.SerializerMethodField() unit_price = serializers.SerializerMethodField() total_price = serializers.SerializerMethodField() variant_name = serializers.SerializerMethodField() in_stock = serializers.SerializerMethodField() allow_main_wallet = serializers.SerializerMethodField() allow_repurchase = serializers.SerializerMethodField() allow_supercoins = serializers.SerializerMethodField() class Meta: model = CartItem fields = [ 'id', 'product', 'variant', 'quantity', 'product_name', 'product_image', 'product_slug', 'unit_price', 'total_price', 'variant_name', 'in_stock', 'allow_main_wallet', 'allow_repurchase', 'allow_supercoins', ] def get_product_name(self, obj): return obj.product.name def get_product_image(self, obj): from apps.business.marketplace.models_part1 import ProductImage as MPImage mp_img = MPImage.objects.filter(product=obj.product, is_primary=True).first() if mp_img: return mp_img.image_url legacy = obj.product.images.filter(is_primary=True).first() or obj.product.images.first() if legacy and legacy.image: return legacy.image.url return None def get_product_slug(self, obj): return obj.product.slug def get_unit_price(self, obj): if obj.variant and obj.variant.selling_price: return str(obj.variant.selling_price) return str(obj.product.mrp or obj.product.base_cost) def get_total_price(self, obj): if obj.variant and obj.variant.selling_price: return str(obj.variant.selling_price * obj.quantity) price = obj.product.mrp or obj.product.base_cost return str(price * obj.quantity) def get_variant_name(self, obj): return obj.variant.name if obj.variant else None def get_in_stock(self, obj): if obj.variant: return obj.variant.stock >= obj.quantity return True def get_allow_main_wallet(self, obj): return bool(obj.product.allow_main_wallet) def get_allow_repurchase(self, obj): return bool(obj.product.allow_repurchase) def get_allow_supercoins(self, obj): return bool(obj.product.allow_supercoins) class CartSerializer(serializers.ModelSerializer): items = CartItemSerializer(many=True, read_only=True) subtotal = serializers.SerializerMethodField() item_count = serializers.SerializerMethodField() class Meta: model = ShoppingCart fields = ['id', 'items', 'subtotal', 'item_count', 'updated_at'] def get_subtotal(self, obj): from decimal import Decimal total = Decimal('0.00') for item in obj.items.select_related('product', 'variant'): if item.variant and item.variant.selling_price: total += item.variant.selling_price * item.quantity else: price = item.product.mrp or item.product.base_cost total += price * item.quantity return str(total) def get_item_count(self, obj): return obj.items.count() class AddToCartSerializer(serializers.Serializer): product_id = serializers.UUIDField() variant_id = serializers.UUIDField(required=False, allow_null=True) quantity = serializers.IntegerField(min_value=1, max_value=100) def validate_product_id(self, value): try: product = Product.objects.get(id=value, is_active=True, marketplace_status='ACTIVE') except Product.DoesNotExist: raise serializers.ValidationError("Product not available.") return value class UpdateCartItemSerializer(serializers.Serializer): quantity = serializers.IntegerField(min_value=0, max_value=100) # --------------------------------------------------------------------------- # Wishlist serializers # --------------------------------------------------------------------------- class WishlistItemSerializer(serializers.ModelSerializer): product_name = serializers.SerializerMethodField() product_slug = serializers.SerializerMethodField() product_image = serializers.SerializerMethodField() product_price = serializers.SerializerMethodField() class Meta: model = WishlistItem fields = ['id', 'product', 'product_name', 'product_slug', 'product_image', 'product_price', 'added_at'] def get_product_name(self, obj): return obj.product.name def get_product_slug(self, obj): return obj.product.slug def get_product_image(self, obj): from apps.business.marketplace.models_part1 import ProductImage as MPImage mp_img = MPImage.objects.filter(product=obj.product, is_primary=True).first() if mp_img: return mp_img.image_url legacy = obj.product.images.filter(is_primary=True).first() return legacy.image.url if legacy and legacy.image else None def get_product_price(self, obj): return str(obj.product.mrp or obj.product.base_cost) # --------------------------------------------------------------------------- # Order management serializers # --------------------------------------------------------------------------- class OrderItemSerializer(serializers.ModelSerializer): product_name = serializers.SerializerMethodField() product_slug = serializers.SerializerMethodField() status = serializers.CharField(source='item_status', read_only=True) created_at = serializers.SerializerMethodField() class Meta: model = OrderItem fields = [ 'id', 'product', 'product_name', 'product_slug', 'variant', 'quantity', 'unit_price', 'total_price', 'discount_amount', 'tax_amount', 'fulfillment_mode', 'status', 'created_at', ] def get_product_name(self, obj): return obj.product.name def get_product_slug(self, obj): return obj.product.slug def get_created_at(self, obj): return getattr(obj.order, 'created_at', None) class OrderShipmentSerializer(serializers.ModelSerializer): class Meta: model = OrderShipment fields = [ 'id', 'tracking_number', 'carrier_name', 'tracking_url', 'status', 'estimated_delivery', 'actual_delivery', 'picked_up_at', 'delivered_at', ] class OrderStatusHistorySerializer(serializers.ModelSerializer): class Meta: model = OrderStatusHistory fields = ['id', 'status', 'description', 'location', 'failure_reason', 'recorded_by', 'created_at'] # --------------------------------------------------------------------------- # Flash offers & Coupon serializers # --------------------------------------------------------------------------- class FlashOfferSerializer(serializers.ModelSerializer): product_name = serializers.SerializerMethodField() product_slug = serializers.SerializerMethodField() product_image = serializers.SerializerMethodField() offer_type = serializers.CharField(source='discount_type', read_only=True) start_datetime = serializers.DateTimeField(source='valid_from', read_only=True) end_datetime = serializers.DateTimeField(source='valid_until', read_only=True) class Meta: model = FlashOffer fields = [ 'id', 'product', 'product_name', 'product_slug', 'product_image', 'offer_type', 'discount_value', 'start_datetime', 'end_datetime', 'is_active', ] def get_product_name(self, obj): return obj.product.name def get_product_slug(self, obj): return obj.product.slug def get_product_image(self, obj): from apps.business.marketplace.models_part1 import ProductImage as MPImage mp_img = MPImage.objects.filter(product=obj.product, is_primary=True).first() if mp_img: return mp_img.image_url return None class CouponValidateSerializer(serializers.Serializer): code = serializers.CharField(max_length=50) cart_total = serializers.DecimalField(max_digits=12, decimal_places=2) # --------------------------------------------------------------------------- # Delivery & serviceability serializers # --------------------------------------------------------------------------- class PincodeServiceabilitySerializer(serializers.ModelSerializer): class Meta: model = PincodeServiceability fields = [ 'pincode', 'is_serviceable', 'estimated_days_min', 'estimated_days_max', 'cod_available', ] class DeliveryEstimationSerializer(serializers.ModelSerializer): class Meta: model = DeliveryEstimation fields = [ 'product', 'pincode', 'is_serviceable', 'estimated_days_min', 'estimated_days_max', 'delivery_charge', 'cod_available', 'franchise_available', 'franchise_store', ] # --------------------------------------------------------------------------- # Checkout serializers # --------------------------------------------------------------------------- class RetailCheckoutSerializer(serializers.Serializer): """ Payload for placing a retail marketplace order. Validates wallet payment split, shipping address, and pincode serviceability. """ shipping_address_id = serializers.IntegerField() pincode = serializers.CharField(max_length=10) payment_split = serializers.DictField( child=serializers.DecimalField(max_digits=12, decimal_places=2), required=False, default=dict, ) coupon_code = serializers.CharField(max_length=50, required=False, allow_blank=True) notes = serializers.CharField(max_length=500, required=False, allow_blank=True) def validate_payment_split(self, value): allowed_keys = {'main_wallet', 'repurchase_wallet', 'super_coins', 'razorpay'} for key in value: if key not in allowed_keys: raise serializers.ValidationError(f"Unknown payment method: {key}") return value # --------------------------------------------------------------------------- # Vendor dashboard serializers # --------------------------------------------------------------------------- class VendorOrderItemSerializer(serializers.ModelSerializer): """Order item view for vendors (includes order reference).""" product_name = serializers.SerializerMethodField() order_reference = serializers.SerializerMethodField() customer_pincode = serializers.SerializerMethodField() status = serializers.CharField(source='item_status', read_only=True) created_at = serializers.SerializerMethodField() class Meta: model = OrderItem fields = [ 'id', 'order', 'order_reference', 'product', 'product_name', 'quantity', 'unit_price', 'total_price', 'status', 'customer_pincode', 'created_at', ] def get_product_name(self, obj): return obj.product.name def get_order_reference(self, obj): return obj.order.reference_id if obj.order else None def get_customer_pincode(self, obj): # Try to get pincode from the order's shipment address try: from apps.business.invoice.models import ShippingAddress addr = ShippingAddress.objects.filter(user=obj.order.user, is_default=True).first() return addr.pincode if addr else None except Exception: return None def get_created_at(self, obj): return getattr(obj.order, 'created_at', None) class VendorProductSerializer(serializers.ModelSerializer): """Product list for vendor dashboard.""" category_name = serializers.SerializerMethodField() brand_name = serializers.SerializerMethodField() variants_count = serializers.SerializerMethodField() primary_image = serializers.SerializerMethodField() selling_price = serializers.SerializerMethodField() class Meta: model = Product fields = [ 'id', 'name', 'slug', 'sku', 'base_cost', 'mrp', 'selling_price', 'marketplace_status', 'average_rating', 'is_active', 'vendor_managed', 'franchise_fulfilled', 'category_name', 'brand_name', 'variants_count', 'primary_image', 'created_at', ] def get_category_name(self, obj): return obj.marketplace_category.name if obj.marketplace_category else None def get_brand_name(self, obj): return obj.brand.name if obj.brand else None def get_variants_count(self, obj): return obj.variants.filter(is_active=True).count() def get_primary_image(self, obj): from apps.business.marketplace.models_part1 import ProductImage as MPImage mp_img = MPImage.objects.filter(product=obj, is_primary=True).first() if mp_img: return mp_img.image_url legacy = obj.images.filter(is_primary=True).first() return legacy.image.url if legacy and legacy.image else None def get_selling_price(self, obj): return str(obj.mrp or obj.base_cost or 0) class VendorAnalyticsSummarySerializer(serializers.Serializer): total_orders = serializers.IntegerField() total_revenue = serializers.DecimalField(max_digits=14, decimal_places=2) pending_orders = serializers.IntegerField() completed_orders = serializers.IntegerField() top_products = serializers.ListField(child=serializers.DictField()) low_stock_products = serializers.ListField(child=serializers.DictField()) monthly_revenue = serializers.ListField(child=serializers.DictField())