def put(self, request, pk, format=None): category = self.get_object(pk) serializer = CategorySerializer(category, 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 = CategorySerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response({'error': serializer.errors},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def post(self, request, format=None): serializer = CategorySerializer(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, format=None):
category = self.get_object(pk)
serializer = CategorySerializer(category, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, category_id):
category = self.get_object(category_id)
serializer = CategorySerializer(instance=category, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response({'error': serializer.data})
def category_create(request):
if request.method == 'POST':
data = {'name': request.DATA.get('name'),
}
serializer = CategorySerializer(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 category(request): if request.method == 'GET': category=Category.objects.all() serializer=CategorySerializer(category,many=True) return Response(serializer.data) elif request.method == 'POST': serializer=CategorySerializer(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)
class VideoSerializer(serializers.ModelSerializer):
channel = ChannelSerializer()
category = CategorySerializer(read_only = True)
class Meta:
model = Video
fields = ("id", 'title', "view", 'channel', 'thumbnail', 'created_at', 'updated_at', 'video_num', 'topic', 'category', 'url', 'natural_time')
def categorys_list(request):
"""
List all code category mapping.
"""
try:
if request.method == 'GET':
category = Category.objects.all()
serializer = CategorySerializer(category, many=True)
if serializer:
return JSONResponse({
"m": "success",
"s": 1,
"d": serializer.data
})
else:
return JSONResponse(
{
"m": "fail",
"s": 0,
"d": "No data available."
},
status=200)
else:
return JSONResponse(
{
"m": "fail",
"s": 0,
"d": "Requset Method must be GET"
},
status=200)
except Exception as e:
return JSONResponse({"m": "fail", "s": 0, "d": e}, status=200)
def category_list(request):
"""
List all snippets, or create a new article.
"""
if request.method == 'GET':
category = Category.objects.all()
serializer = CategorySerializer(category, many=True)
return Response(serializer.data)
elif request.method == 'POST':
serializer = CategorySerializer(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)
class EntrySerializer(serializers.ModelSerializer):
is_delete = serializers.HiddenField(
default=False)
category = CategorySerializer(read_only=True)
category_Id = serializers.SlugRelatedField(write_only=True,
slug_field="id", queryset=Category.objects.all())
entrys = DicEntrySerializer(many=True, read_only=True)
entry_Ids = serializers.SlugRelatedField(
many=True, write_only=True, slug_field="id", queryset=Entry.objects.all())
# entrys = serializers.PrimaryKeyRelatedField(
# many=True, queryset=Entry.objects.all())
class Meta:
model = Entry
# fields = '__all__' # 序列化全部字段，实际中不建议使用，因为像password等字段是不应该返回给前端的
fields = ('id', 'title', 'remark', 'entrys',
'is_delete', 'category', 'sort', 'category_Id', 'entry_Ids') # 指定序列化的字段
def validate(self, attrs):
# del attrs['entry_Ids']
return attrs
def create(self, validated_data):
entry_Ids = validated_data.pop('entry_Ids')
category_Id = validated_data.pop('category_Id')
entry = Entry.objects.create(**validated_data, category=category_Id)
for entry_Id in entry_Ids:
# entry = Entryship.objects.filter(id=entry_Ids)
Entryship.objects.create(
from_entry=entry, to_entry=entry_Id, category=entry_Id.category)
return entry
def category_detail(request, pk, format=None):
"""
Retrieve, update or delete a code snippet.
"""
try:
snippet = Category.objects.get(pk=pk)
print('pk=' + pk)
except Category.DoesNotExist:
return HttpResponse(status=404)
if request.method == 'GET':
serializer = CategorySerializer(snippet)
return JsonResponse(serializer.data)
elif request.method == 'PUT':
#data = JSONParser().parse(request)
print(request.data)
serializer = CategorySerializer(snippet, data=request.data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data)
return JsonResponse(serializer.errors, status=400)
elif request.method == 'DELETE':
snippet.delete()
return HttpResponse(status=204)
def detail(request, pk):
"""
Retrieve, update or delete a code category.
"""
try:
category = Category.objects.get(pk=pk)
except Category.DoesNotExist:
response = {"message": "category not exists"}
return Response(response, status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = CategorySerializer(category)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = CategorySerializer(category, 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':
category.delete()
response = {
"message": "bạn đã xóa thành công category id = " + str(pk)
}
return Response(response, status=status.HTTP_204_NO_CONTENT)
class PostDetailSerializer(serializers.ModelSerializer):
category = CategorySerializer()
author = CustomUserSerializer()
class Meta:
model = Post
fields = [
'id', 'title', 'summary', 'html_post', 'category', 'created_at',
'author', 'just_users', 'main_image'
]
class GroupSerializer(serializers.ModelSerializer):
categories = CategorySerializer(many=True, read_only=True)
class Meta:
model = Group
fields = (
'id',
'name',
'categories',
)
class DicEntrySerializer(serializers.ModelSerializer):
is_delete = serializers.HiddenField(
default=False)
category = CategorySerializer()
class Meta:
model = Entry
# fields = '__all__' # 序列化全部字段，实际中不建议使用，因为像password等字段是不应该返回给前端的
fields = ('id', 'title', 'remark', 'is_delete',
'sort', 'category') # 指定序列化的字段
class OrgSerializer(serializers.ModelSerializer):
officers = OfficerSerializer(read_only=True)
categories = CategorySerializer(read_only=True)
members = UserSerializer(read_only=True)
class Meta:
model = Org
fields = ('name', 'created_date', 'description', 'categories',
'members', 'officers')
lookup_field = 'name'
class ItemDetailSerializer(serializers.ModelSerializer):
category = CategorySerializer()
user = UserDetailSerializer()
created_date = serializers.SerializerMethodField()
class Meta:
model = Item
fields = [
'id', 'title', 'description', 'category', 'user', 'created_date'
]
def get_created_date(self, obj):
return datetime.strftime(obj.created_date, "%b %d %Y %H:%M:%S")
class EntryInfoListSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
is_delete = serializers.HiddenField(default=False)
category = CategorySerializer(many=False, read_only=False)
title = TitleSerializer(many=False, read_only=False)
# title=TitleSerializer()
class Meta:
model = EntryInfo
# fields = '__all__' # 序列化全部字段，实际中不建议使用，因为像password等字段是不应该返回给前端的
fields = ('id', 'user', 'title', 'is_delete', 'category') # 指定序列化的字段
def category_list(request, format=None):
if request.method == 'GET':
categorys = Category.objects.all()
serializer = CategorySerializer(categorys, many=True)
return JsonResponse(serializer.data, safe=False)
elif request.method == 'POST':
serializer = CategorySerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def category_detail(request, pk):
"""
Retrieve, update or delete a snippet instance.
"""
try:
cat1 = Category.objects.get(pk=pk)
except Category.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = CategorySerializer(cat1)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = CategorySerializer(cat1, 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':
cat1.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def get_categories(self, obj):
user = self.context['request'].user
categories = Category.objects.filter(owner=user)
added = categories.extra(select={
'added': '1'
}).filter(outfits__pk=obj.pk)
added = list(added.values('added', 'name', 'id', 'only_me'))
added_f = categories.extra(select={
'added': '0'
}).exclude(outfits__pk=obj.pk)
added_f = list(added_f.values('added', 'name', 'id', 'only_me'))
categories = added + added_f
return CategorySerializer(categories, many=True,
context=self.context).data
def search_in_categories(request):
category_text = request.query_params.get('key', None)
if category_text == "": category_text = None
if category_text is None:
return JsonResponse(
{"error": get_error_serialized(103, 'key parameter is required')},
status=HTTPStatus.BAD_REQUEST)
data = [(cat[1], cat[0]) for cat in categories]
finded_ids = search(category_text, data)
finded_categories = Category.objects.filter(Q(name__in=finded_ids))
return JsonResponse(
{"categories": CategorySerializer(finded_categories, many=True).data})
def list(request):
"""
List all code category, or create a new category.
"""
if request.method == 'GET':
category = Category.objects.all()
serializer = CategorySerializer(category, many=True)
return Response(serializer.data)
elif request.method == 'POST':
category = CategorySerializer(data=request.data)
if category.is_valid():
category.save()
return Response(category.data, status=status.HTTP_201_CREATED)
def categorys_detail(request, pk):
"""
List specific code category mapping.
"""
try:
categorys = Category.objects.get(pk=pk)
except Category.DoesNotExist:
return JSONResponse(
{
"m": "fail",
"s": 0,
"d": "Requseted entity does not exists."
},
status=200)
try:
if request.method == 'GET':
serializer = CategorySerializer(categorys)
if serializer:
return JSONResponse({
"m": "success",
"s": 1,
"d": serializer.data
})
else:
return JSONResponse(
{
"m": "fail",
"s": 0,
"d": "No data available."
},
status=200)
else:
return JSONResponse(
{
"m": "fail",
"s": 0,
"d": "Requset Method must be GET"
},
status=200)
except Exception as e:
return JSONResponse({"m": "fail", "s": 0, "d": e}, status=200)
class EntryInfoSerializer(serializers.ModelSerializer):
user = serializers.HiddenField(default=serializers.CurrentUserDefault())
is_delete = serializers.HiddenField(default=False)
entrys = serializers.SerializerMethodField()
category = CategorySerializer(many=False, read_only=False)
title = TitleSerializer(many=False, read_only=False)
# title=TitleSerializer()
class Meta:
model = EntryInfo
# fields = '__all__' # 序列化全部字段，实际中不建议使用，因为像password等字段是不应该返回给前端的
fields = ('id', 'user', 'title', 'entrys', 'is_delete', 'category'
) # 指定序列化的字段
def get_entrys(self, obj):
entrys = Entry.objects.filter(category=obj.category)
entrys_serializer = DicEntrySerializer(
entrys, many=True, context={'request': self.context['request']})
return entrys_serializer.data
class BookSerializer(serializers.ModelSerializer):
authors = AuthorSerializer(many=True, read_only=True)
categories = CategorySerializer(many=True, read_only=True)
class Meta:
model = Book
fields = (
"id",
"title",
"subtitle",
"isbn",
"publisher",
"pages",
"description",
"thumbnail",
"language",
"avg_ratings",
"raters",
"authors",
"categories",
)
class ServicesSerializer(serializers.ModelSerializer):
category_id = serializers.IntegerField()
username = serializers.CharField(max_length=16)
age = serializers.IntegerField()
edu_background = serializers.CharField(max_length=50)
marital_status = serializers.CharField(max_length=20)
native_place = serializers.CharField(max_length=20)
height = serializers.FloatField()
weight = serializers.FloatField()
experience = serializers.IntegerField()
work_status = serializers.CharField(max_length=20,
allow_null=True,
required=False)
information = serializers.CharField(max_length=1000,
allow_null=True,
required=False)
training_record = serializers.CharField(max_length=1000,
allow_null=True,
required=False)
work_record = serializers.CharField(max_length=1000,
allow_null=True,
required=False)
servicesUrl = serializers.CharField(max_length=1000)
userid = serializers.IntegerField(label='用户id', read_only=True)
s_category = CategorySerializer(read_only=True)
class Meta:
model = Services
fields = get_model_fields(Services, add_list=['userid'])
def create(self, validated_data):
category = Category.objects.filter(
id=validated_data['category_id']).first()
service_obj = None
if category:
service_obj = Services.objects.create(**validated_data,
s_category=category)
return service_obj
def categorys_create(request):
"""
Create a new category mapping.
"""
try:
if request.method == 'POST':
data = JSONParser().parse(request)
serializer = CategorySerializer(data=data)
listing_page_type_flag = False
international_url_flag = False
if serializer.is_valid():
for index in serializer.initial_data:
if index == 'domestic_url':
return JSONResponse(
{
"m": "fail",
"s": 0,
"d":
"Cannot have access to modify domestic_url"
},
status=200)
elif index == 'int_cat_map_id':
return JSONResponse(
{
"m": "fail",
"s": 0,
"d":
"Cannot have access to modify int_cat_map_id"
},
status=200)
elif index == 'is_active':
return JSONResponse(
{
"m": "fail",
"s": 0,
"d": "Cannot have access to modify is_active"
},
status=200)
elif index == 'is_updated':
return JSONResponse(
{
"m": "fail",
"s": 0,
"d": "Cannot have access to modify is_updated"
},
status=200)
elif index == 'listing_page_type':
listing_page_type_flag = True
elif index == 'international_url':
international_url_flag = True
if listing_page_type_flag and international_url_flag:
if serializer.is_valid():
serializer.save()
return JSONResponse(
{
"m": "success",
"s": 1,
"d": serializer.data
},
status=200)
return JSONResponse(
{
"m": "fail",
"s": 0,
"d": serializer.errors
},
status=200)
return JSONResponse(
{
"m":
"fail",
"s":
0,
"d":
"Inconsistent Input: Please provide listing_page_type and international_url"
},
status=200)
return JSONResponse({
"m": "fail",
"s": 0,
"d": serializer.errors
},
status=200)
else:
return JSONResponse(
{
"m": "fail",
"s": 0,
"d": "Requset Method must be POST"
},
status=200)
except Exception as e:
return JSONResponse({"m": "fail", "s": 0, "d": e}, status=200)
def categorys_soft_delete(request, pk):
"""
Soft delete category mapping.
"""
try:
categorys = Category.objects.get(pk=pk)
except Category.DoesNotExist:
return JSONResponse(
{
"m": "fail",
"s": 0,
"d": "Requseted entity does not exists."
},
status=200)
try:
if request.method == 'PUT':
data = JSONParser().parse(request)
serializer = CategorySerializer(categorys, data=data)
if serializer.is_valid():
for index in serializer.initial_data:
if index == 'international_url':
return JSONResponse(
{
"m":
"fail",
"s":
0,
"d":
"Cannot have access to modify international_url"
},
status=200)
elif index == 'int_cat_map_id':
return JSONResponse(
{
"m": "fail",
"s": 0,
"d":
"Cannot have access to modify int_cat_map_id"
},
status=200)
elif index == 'domestic_url':
return JSONResponse(
{
"m": "fail",
"s": 0,
"d":
"Cannot have access to modify domestic_url"
},
status=200)
elif index == 'listing_page_type':
return JSONResponse(
{
"m":
"fail",
"s":
0,
"d":
"Cannot have access to modify listing_page_type"
},
status=200)
elif index == 'is_updated':
return JSONResponse(
{
"m": "fail",
"s": 0,
"d": "Cannot have access to modify is_updated"
},
status=200)
if serializer.is_valid():
serializer.save()
return JSONResponse(
{
"m": "success",
"s": 1,
"d": serializer.data
},
status=200)
return JSONResponse(
{
"m": "fail",
"s": 0,
"d": serializer.errors
}, status=200)
return JSONResponse({
"m": "fail",
"s": 0,
"d": serializer.errors
},
status=200)
else:
return JSONResponse(
{
"m": "fail",
"s": 0,
"d": "Requset Method must be PUT"
},
status=200)
except Exception as e:
return JSONResponse({"m": "fail", "s": 0, "d": e}, status=200)
def categories(self, request, pk=None):
product = self.get_object()
queryset = product.categories.all()
data = CategorySerializer(queryset, many=True).data
return Response(data)
def get_category(self, instance):
if instance.category is None:
return None
category_id = instance.category_id
return CategorySerializer(Category.objects.get(name = category_id)).data
def get(self, request, category_id):
category = self.get_object(category_id)
serializer = CategorySerializer(category)
return Response(serializer.data)
def to_representation(self, instance):
self.fields['category'] = CategorySerializer(read_only=True, many=True)
return super().to_representation(instance)
class MusicListSerializer(serializers.ModelSerializer):
category = CategorySerializer()
class Meta:
model = Music
fields = ('id', 'title', 'singer', 'album', 'category')
def get(self, request):
categories = Category.objects.all()
serializer = CategorySerializer(categories, many=True)
return Response(serializer.data)
