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 put(self, request, pk=None):
category = self.get_object(pk)
serializer = CategorySerializer(instance=category, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors)
def put(self, request, pk, format=None):
cat = Category.objects.get(id=pk)
serializer = CategorySerializer(cat, 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):
uid = request.data['id']
count = Category.objects.filter(category=request.data['category'], center_id=request.data['center_id']).exclude(id=uid).count()
if count > 0:
response = {
'code': 0,
'message': 'category 已存在',
}
return Response(response)
else:
try:
category = Category.objects.get(id=uid)
except:
response = {
'code': 0,
'message': 'id 不存在',
}
return Response(response)
else:
serializer = CategorySerializer(data=request.data, instance=category)
if serializer.is_valid():
serializer.save()
response = {
'code': 1,
'data': serializer.data,
}
return Response(response)
else:
return Response(serializer.errors)
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.errors})
def put(self, request, category_id=None):
category = self.get_object(category_id)
serializer = CategorySerializer(instance=category, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def dashboard(request):
"""
View used for the dashboard page with the ticket to add more transactions
:param request:
:return:
"""
categories = Category.objects.all()
category_subcategory_item_filter_serializer = CategorySerializer(data=categories, many=True)
category_subcategory_item_filter_serializer.is_valid()
category_subcategory_item_filter_serializer_json = json.dumps(category_subcategory_item_filter_serializer.data)
geos = Geo.objects.all()
geo_filter_serializer = GeoSerializer(data=geos, many=True)
geo_filter_serializer.is_valid()
geo_filter_serializer_json = json.dumps(geo_filter_serializer.data)
target_users = TargetUser.objects.all()
target_user_filter_serializer = TargetUserSerializer(data=target_users, many=True)
target_user_filter_serializer.is_valid()
target_user_filter_serializer_json = json.dumps(target_user_filter_serializer.data)
return render(request, 'dashboard.html', {
'chart_date_format': CHART_DATE_FORMAT_FOR_AMCHARTS,
'categories_subcategories_items_filter_options': category_subcategory_item_filter_serializer_json,
'geo_filter_options': geo_filter_serializer_json,
'target_user_filter_options': target_user_filter_serializer_json,
'refresh_interval_milliseconds': REFRESH_INTERVAL_SECONDS * 1000,
})
def post(self, request: Request):
category_serialized = CategorySerializer(data=request.data)
if category_serialized.is_valid(raise_exception=True):
category_serialized.save()
return Response(data=category_serialized.data)
return Response(status=status.HTTP_400_BAD_REQUEST,
data=category_serialized.errors)
def put(self, request, id, format=None):
try:
item = Category.objects.get(pk=id)
except Category.DoesNotExist:
return Response(status=404)
serializer = CategorySerializer(item, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=400)
def update(self, request, pk=None):
try:
item = Category.objects.get(pk=pk)
except Category.DoesNotExist:
return Response(status=404)
serializer = CategorySerializer(item, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=400)
def test_category_serializer(self):
categories = Category.objects.all()
serializer = CategorySerializer(data=categories, many=True)
serializer.is_valid()
logging.info('Serializer data: %s' % serializer.data)
expected_response = [full_category_expected_response(), ]
logging.info('Expected response: %s' % expected_response)
self.assertEqual(serializer.data, expected_response)
def category_list(request,format=None):
if request.method == 'GET':
snippets = Category.objects.all()
serializer = CategorySerializer(snippets, 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)
def category_list(request):
if request.method == 'GET':
categories = Category.objects.all()
serializer = CategorySerializer(categories, many=True)
return JsonResponse(serializer.data, safe=False, status=200)
elif request.method == 'POST':
data = json.loads(request.body)
serializer = CategorySerializer2(data=data)
if serializer.is_valid():
serializer.save() # create function in serializer class
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors)
def put(self, request, company_id, pk):
if pk == '0' or company_id == '0':
return JsonResponse({'detail': 'ID must be greater than zero.'},
status=status.HTTP_400_BAD_REQUEST)
category = self.get_object(company_id, pk)
request.data["company"] = company_id
serializer = CategorySerializer(category,
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)
def set_categories(request):
dates = pd.read_csv('D:\Programming\PpP\web\cat.csv')
cate = dates['categories']
urls = dates['links']
for i in range(len(cate)):
di = {'name': cate[i], 'image_url': urls[i]}
serializer = CategorySerializer(data=di)
if serializer.is_valid():
serializer.save()
print('Good')
else:
print('Bad' + str(di))
return JsonResponse({'Message': 'All good'})
def put(self, request):
page = request.data['page']
size = request.data['size']
center_id = request.data['center_id']
category = Category.objects.filter(center_id=center_id)[(page-1)*size:page*size]
queryset = Category.objects.filter(center_id=center_id)
serializer = CategorySerializer(category, many=True)
queryset_serializer = CategorySerializer(queryset, many=True)
count = len(queryset_serializer.data)
response = {
'code': 1,
'data': serializer.data,
'count': count
}
return Response(response)
def get(self, request):
try:
categories = Category.objects.all()
serializer = CategorySerializer(categories, many=True)
return JsonResponse(serializer.data, safe=False)
except:
return JsonResponse(serializer.errors, safe=False)
def get(self, request, category_id):
try:
category = Category.objects.get(category_id=category_id)
serializer_element = CategorySerializer(instance=category)
return Response(serializer_element.data)
except Category.DoesNotExist:
return errors.handle(errors.CAT_01)
def get(self, request):
try:
category_list = Category.objects.all()
except:
return JsonResponse({"404": "no categories"}, safe=False)
serializer = CategorySerializer(category_list, many=True)
return JsonResponse(serializer.data, safe=False)
def category_list(request, user_id):
"""
List all code categories, or create a new category.
"""
if request.method == 'GET':
categories = Category.objects.filter(user=user_id)
serializer = CategorySerializer(categories, many=True)
return JSONResponse(serializer.data)
elif request.method == 'POST':
data = JSONParser().parse(request)
serializer = CategorySerializer(data=data)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data, status=201)
return JSONResponse(serializer.errors, status=400)
def get(self, request, format=None):
cats = Category.objects.all()
if request.query_params.get('category_id'):
cats = cats.filter(
category_id__contains=request.query_params.get("category_id"))
serializer = CategorySerializer(cats, many=True)
return Response(serializer.data)
def category_products(request, category_id):
try:
category = Category.objects.get(id=category_id)
except Category.DoesNotExist as e:
return Response({'error': str(e)})
if request.method == 'GET':
products = category.product_list.all()
serializer = ProductSerializer(products, many=True)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = CategorySerializer(instance=category, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response({'error': serializer.errors})
elif request.method == 'POST':
serializer = ProductSerializer(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 get(self, request, id, format=None):
try:
item = Category.objects.get(pk=id)
serializer = CategorySerializer(item)
return Response(serializer.data)
except Category.DoesNotExist:
return Response(status=404)
def test_list_only_parents(self):
url = reverse('api:category-list')
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
categories = Category.objects.active().filter(parent=None)
self.assertEqual(response.data,
CategorySerializer(categories, many=True).data)
def get(self, request):
category = Category.objects.all()
serializer = CategorySerializer(category, many=True)
response = {
'code': 1,
'data': serializer.data,
}
return Response(response)
def show_categories(request):
"""
List all categories.
"""
if request.method == 'GET':
categories = FossSuperCategory.objects.all()
serializer = CategorySerializer(categories, many=True)
return JsonResponse(serializer.data, safe=False)
def category_list(request):
"""
List all categories (with the number of questions per category)
"""
categories = Category.objects.all()
serializer = CategorySerializer(categories, many=True)
return Response(serializer.data)
def create(self, request):
category_data = request.data
category = Category.objects.create(name=category_data['name'])
category.save()
serializer = CategorySerializer(category)
logger.debug(f'Category {serializer.instance} was created')
logger.info(f'Category {serializer.instance} was created')
return Response(serializer.data)
def category_detailed(request, id):
try:
serializer = CategorySerializer(Category.objects.get(id=id))
return Response(serializer.data, status=status.HTTP_200_OK)
except:
return Response(
{"error": "There is an error reading category from database"},
status=status.HTTP_404_NOT_FOUND)
def update(self, request, pk):
category = Category.objects.get(id=pk)
category.name = request.data['name']
category.save()
serializer = CategorySerializer(category)
logger.debug(f'Category {serializer.instance} was updated')
logger.info(f'Category {serializer.instance} was updated')
return Response(serializer.data)
class TitleListSerializer(serializers.ModelSerializer):
category = CategorySerializer(read_only=True)
genre = GenreSerializer(many=True, read_only=True)
rating = serializers.FloatField(read_only=True)
class Meta:
model = Title
fields = '__all__'
def post(self, request, company_id):
try:
if company_id == '0':
return JsonResponse({'detail': 'ID must be greater than zero'},
status=status.HTTP_400_BAD_REQUEST)
request.data['company'] = company_id
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)
except Exception as a:
print(a)
return JsonResponse({'detail': 'An error ocurred on the server'},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class TitleSerializerGet(serializers.ModelSerializer):
rating = serializers.FloatField(read_only=True)
genre = GenreSerializer(many=True)
category = CategorySerializer(read_only=True)
class Meta:
fields = '__all__'
model = Title
def category_detail(request, id,format=None):
try:
snippet = Category.objects.get(id=id)
except Category.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = CategorySerializer(snippet)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = CategorySerializer(snippet, 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':
if not request.user.has_perm('OpsManage.can_delete_wiki_category'):
return Response(status=status.HTTP_403_FORBIDDEN)
snippet.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def category_detail(request, user_id, pk):
"""
functions retrieves, updates or deletes a category.
"""
try:
room = Category.objects.get(user=user_id, pk=pk)
except Category.DoesNotExist:
return HttpResponse(status=404)
if request.method == 'GET':
serializer = CategorySerializer(room)
return JSONResponse(serializer.data)
elif request.method == 'PUT':
data = JSONParser().parse(request)
serializer = CategorySerializer(room, data=data)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data)
return JSONResponse(serializer.errors, status=400)
elif request.method == 'DELETE':
room.delete()
return HttpResponse(status=204)
def create(self, request):
serializer = CategorySerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=201)
return Response(serializer.errors, status=400)
