def post(self, request, *args, **kwargs):
request_data = request.data
print(request_data)
serializer = UserSerialize(data=request_data)
print("okok")
serializer.is_valid(raise_exception=True)
res = serializer.save()
return APIResponse(200, True, results=UserSerialize(res).data)
def title(self, request, pk=None):
"""
修改标题
"""
address = self.get_object()
serializer = serializers.AddressTitleSerializer(instance=address, data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data)
def post(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = serializer.validated_data
return Response({
"user":
UserSerializer(user, context=self.get_serializer_context()).data,
"token":
AuthToken.objects.create(user)[1]
})
def update(self, request, *args, **kwargs):
hall = request.POST.get('hall')
movie = MovieSession.objects.get(pk=kwargs.get('pk'))
print(movie)
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
if len(movie.tickets.all()) >= 1:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
return super().update(request, *args, **kwargs)
def Register(request):
apiresponse = {}
#Getting The Comming Request
data = JSONParser().parse(request)
if ("Users_Email" in data and data['Users_Email'] != ""
and "Users_Password" in data and data['Users_Password'] != ""):
email = data['Users_Email']
password = data['Users_Password']
if is_user_email_exist(email):
serializer = Userserilazers(data=data)
if serializer.is_valid():
serializer.save()
apiresponse['status'] = 102
apiresponse['Details'] = "Registration Complete"
else:
apiresponse['status'] = 103
apiresponse['Details'] = serializer.errors
else:
apiresponse['status'] = 101
apiresponse['Details'] = "Email Id Already Exist"
else:
apiresponse['status'] = 104
apiresponse['Details'] = "Need To Pass User Name And Password"
return Response(apiresponse)
def post(self, request, format=None):
serializer = StockSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
print(serializer)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
serializer = ViewDealerSerializer(data=request.data)
if serializer.is_valid():
dist_posted = serializer.data['district']
queryset = Dealer_Registration.objects.filter(
dist_name=dist_posted)
print("Length of queryset queried is:" + str(len(queryset)))
query_length = len(queryset)
dealer_dist_wise = []
for obj in queryset:
dealer_list = {
"dealer_name": obj.dealer_name,
"contact": obj.contact_num,
"license": obj.license_num,
"shop": obj.shop_name
}
dealer_dist_wise.append(dealer_list, )
if query_length == 0:
return Response({"error": "No data found..."},
status=status.HTTP_204_NO_CONTENT)
else:
return Response(dealer_dist_wise, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def perform_create(self, serializer):
try:
if serializer.is_valid(raise_exception=False):
serializer.save(owner=random_user())
except IntegrityError:
return Response(data={'message': 'That URL already exists'},
status=HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
serializer = MobnumSerializer(data=request.data)
if serializer.is_valid():
#serializer.save()
mob_posted = serializer.data['mobnum']
queryset = Dealer_Registration.objects.all()
dealers = []
mobile_numbers_list = []
for obj in queryset:
mob_num = obj.contact_num
mobile_numbers_list.append(mob_num)
#dealer_list = { "dealer_name" : obj.dealer_name, "license" : obj.license_num, "contact" : obj.contact_num, "block" : obj.block_name }
dealer_list = {"id": obj.id}
dealers.append(dealer_list, )
if mob_posted in mobile_numbers_list:
mob_index = mobile_numbers_list.index(mob_posted)
print("Mobile number matched...")
return Response(dealers[mob_index], status=status.HTTP_200_OK)
else:
print("Mobile number not found...")
no_dealer_data = {
"error_msg": "Not registered...",
}
return Response(no_dealer_data,
status=status.HTTP_204_NO_CONTENT)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk, format=None):
file = self.get_object(pk)
serializer = UrunResimler(file, 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, pk, format=None):
user = self.get_object(pk)
serializer = PilotplotsSerializer(user, 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, format=None):
if not self.request.session.exists(self.request.session.session_key):
self.request.session.create()
serailizer = self.serializer_class(data=request.data)
if serializer.is_valid():
guest_can_pause = serailizer.data.get('guest_can_pause')
votes_to_skip = serializer.data.get('votes_to_skip')
host = self.request.session.session_key
queryset = Room.objects.filter(host=host)
if queryset.exists():
room = queryset[0]
room.guest_can_pause = guest_can_pause
room.votes_to_skip = votes_to_skip
room.save(update_fields=['guest_can_pause', 'votes_to_skip'])
self.request.session['room_code'] = room.code
return Response(RoomSerializer(room).data,
status=status.HTTP_200_OK)
else:
room = Room(host=host,
guest_can_pause=guest_can_pause,
votes_to_skip=votes_to_skip)
room.save()
self.request.session['room_code'] = room.code
return Response(RoomSerializer(room).data,
status=status.HTTP_201_CREATED)
return Response(
{'Bad Request': 'Invalid post data, did not find a code key'},
status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
serializer = PlotsSerializer(data=request.data)
if serializer.is_valid():
dist_posted = serializer.data['dist_name']
block_posted = serializer.data['block_name']
panchayat_posted = serializer.data['panchayat_name']
queryset = Pilotplots.objects.filter(
dist_name=dist_posted,
block_name=block_posted,
panchayat_name=panchayat_posted)
farmer_list_dbp_wise = []
for obj in queryset:
farmer_list = {
"farmer": obj.farmer_name,
"contact": obj.contact_num
}
farmer_list_dbp_wise.append(farmer_list)
print("Farmer List:" + str(farmer_list_dbp_wise))
length_farmer_list = len(farmer_list_dbp_wise)
if (length_farmer_list == 0):
return Response({"no_data": "No data found!!!"},
status=status.HTTP_204_NO_CONTENT)
else:
return Response(farmer_list_dbp_wise,
status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, model_pk, format=None):
try:
model = Model.objects.get(pk=model_pk)
serializer = ModelTrainNotificationSerializer(data=request.data)
message = ''
if serializer.is_valid():
if serializer.validated_data['status'] == 'done':
model.being_trained = False
model.save()
message = f"{model.name} has finished training!"
elif serializer.validated_data['status'] == 'fail':
model.being_trained = False
model.save()
message = f"{model.name} has failed at training ☹"
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
extra = serializer.validated_data.get('extra', {})
extra['id'] = model_pk
extra['owner'] = model.owner.id
extra['status'] = serializer.validated_data['status']
devices = list(
Device.objects.filter(owner=model.owner, logged_in=True))
print({'message': message, 'extra': extra})
push_notification(devices=devices,
title="EasyML",
message=message,
extra=extra)
# TODO: Handle push notification response appropriately
return JsonResponse({"detail": "Done."}, status=status.HTTP_200_OK)
except Model.DoesNotExist: # Model.objects.get(pk=...) couldn't find a model
return JsonResponse({'detail': 'Model not found.'},
status=status.HTTP_404_NOT_FOUND)
def post(self, request, format=None):
serializer = STRAvailabilitySerializer(data=request.data)
if serializer.is_valid():
print("Serializer data:" + str(serializer.data))
variety_posted = serializer.data['variety']
#shop_from_stocks = serializer.data['shop']
#dealer_details = Dealer_Registration.objects.filter(id=shop_from_stocks)
#availability = Stock.objects.filter(variety_name=variety_posted)
dealer_list = []
dealer_ids = []
availability = []
#sub_dealer_list = {}
queryset1 = Stock.objects.filter(variety_name=variety_posted)
for obj1 in queryset1:
dealer_ids.append(obj1.id)
for obj2 in queryset1:
availability.append(obj2.available)
for obj3 in dealer_ids:
queryset2 = Dealer_Registration.objects.filter(id=obj3)
sub_dealer_list = {}
for obj4 in queryset2:
sub_dealer_list['dealer'] = obj4.dealer_name
sub_dealer_list['contact'] = obj4.contact_num
for obj5 in availability:
sub_dealer_list['available'] = obj5
dealer_list.append(sub_dealer_list)
# print("Availability2 is: " + str(availability))
#for obj2 in availability:
# dealer_list['available_from'] = obj2.available
# print("Available is:" + str(availability2))
# availability2 = availability.available
#print("Length of queryset queried is:" + str(len(dealer_details)))
query_length = len(availability)
#print("Dealer Details:" + str(dealer_details))
#print("shop:" + str(shop_from_stocks))
dealer_stock_wise = []
#for obj in dealer_details:
# dealer_list = { "dealer_name" : obj.dealer_name, "contact" : obj.contact_num, "shop_name" : obj.shop_name }
# dealer_list['dealer_name'] = obj.dealer_name
# dealer_list['contact'] = obj.contact_num
# dealer_list['shop_name'] = obj.shop_name
# dealer_list['available'] = availability2
# dealer_stock_wise.append(dealer_list,)
if query_length == 0:
return Response( { "error" : "No data found..." }, status=status.HTTP_204_NO_CONTENT)
else:
return Response(dealer_list, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def drf_article_create(request):
serializer = ArticleCreateSerializer(data=request.data,
context={'writer': request.user})
if serializer.is_valid():
serializer.save()
article_serialized = serializer.data
return Response(article_serialized, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
serializer = UrunResimlerSerializer(data=request.data)
resim_list = request.FILES.getlist('urunresim')
if serializer.is_valid():
for item in resim_list:
f = UrunResimler.objects.create(urun=request.data['urun'], urunresim=item,sliderresim=request.data['sliderresim'],)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def resim_ekle(self, request, pk):
obj = self.get_object()
serializer = self.serializer_class(obj, data=request.data,
partial=True)
if serializer.is_valid():
serializer.save()
return response.Response(serializer.data)
return response.Response(serializer.errors,
status.HTTP_400_BAD_REQUEST)
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
order = self.perform_create(serializer)
shop_carts = self.request.data['goods']
for shop_cart in shop_carts:
good = Good.objects.filter(id=shop_cart['good']['id']).first()
order_goods = OrderGoods()
order_goods.good = good
order_goods.goods_num = shop_cart['good_num']
order_goods.price = shop_cart['good']['salePrice']
# print(order_goods.good)
# print(order_goods.goods_num)
order_goods.order = order
order_goods.save()
Cart.objects.filter(user_id=self.request.user.id,
checked=True).all().delete()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, pk, choice_pk):
voted_by = request.data.get("voted_by")
data = {'choice': choice_pk, 'poll': pk, 'voted_by': voted_by}
serializer = VoteSerializer(data=data)
if serializer.is_valid():
vote = serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def put(self, request, *args, **kwargs):
article = self.get_object()
serializer = ArticleApprovalUpdateSerializer(
instance=article,
data=request.data,
context={'writer': request.user})
if serializer.is_valid():
self.perform_update(serializer)
article_serialized = serializer.data
return Response(article_serialized, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def Submit_Location(request):
if request.method == 'POST':
user_id = request.user.id
print(repr(request.data))
serializer = RecordSerializer(data=request.data,
context={'user_id': request.user.id})
if (serializer.is_valid()):
serializer.save()
content = json.dumps({'status': "success"})
return HttpResponse(content)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
serializer = PlotsSerializer(data=request.data)
if serializer.is_valid():
dist_posted = serializer.data['block_name']
blocks = Panchayats.objects.filter(dist_name=dist_posted)
blocks_list = []
for i in blocks:
blocks_list.append(i.block_name)
return Response(blocks_list, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs):
serializer = EventSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors)
# sample json resonse data
# def test_api(request):
# data = {
# 'title': ' Heading for the best',
# 'description':' we are live now no shaking ',
# 'locaction ':'wembley park',
# 'date': 'December'
# }
# return JsonResponse(data)
def drf_register_view(request):
# print('drf_register_view')
if request.method == 'POST':
serializer = WriterRegistrationSerializer(data=request.data)
data = {}
if serializer.is_valid():
# print('is_valid')
writer = serializer.save()
data['response'] = "Successfully registered a new user."
data['name'] = writer.name
data['is_editor'] = writer.is_editor
token = Token.objects.get(user=writer)
data['token'] = token.key
# print('data', data)
else:
data = serializer.errors
# print(data)
return Response(data)
def post(self, request, format=None):
serializer = VarietynewSerializer(data=request.data)
if serializer.is_valid():
print("Serializer:" + str(serializer.data))
posted_category = serializer.data['category']
queryset = STRVVariety.objects.filter(
category_name=posted_category)
variety_list = []
for obj in queryset:
variety = obj.variety_name
variety_ori = obj.variety_name_oriya
varietycode = obj.variety_code
descriptionn = obj.description
description_ori = obj.description_oriya
duration = obj.duration_in_days
land = obj.suitable_land_type
land_ori = obj.suitable_land_type_oriya
height = obj.plant_height
grain = obj.grain_type
grain_ori = obj.grain_type_ori
yieldin = obj.yield_in_tonne
advantage = obj.yield_advantage
category = obj.category_name
variety_dic = {
"variety_name": variety,
"variety_name_oriya": variety_ori,
"variety_code": varietycode,
"description": descriptionn,
"description_oriya": description_ori,
"duration_in_days": duration,
"suitable_land_type": land,
"suitable_land_type_oriya": land_ori,
"plant_height": height,
"grain_type": grain,
"grain_type_ori": grain_ori,
"yield_in_tonne": yieldin,
"yield_advantage": advantage
}
variety_list.append(variety_dic, )
print("Variety List:" + str(variety_list))
return Response(variety_list, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs):
# print('request.data: ', request.data)
serializer = WriterLoginSerializer(data=request.data,
context={'request': request})
# print(serializer)
# print(dir(serializer))
data = {}
if serializer.is_valid(raise_exception=True):
# print('is_valid')
writer = serializer.validated_data['writer']
# print(writer)
serialized_writer = WriterDetailSerializer(writer).data
# print(serialized_writer)
data['writer'] = serialized_writer
token, created = Token.objects.get_or_create(user=writer)
data['token'] = unicode(token.key)
else:
data = serializer.errors
return Response(data)
def post(self, request):
try:
data = request.data
serializer = self.serializer(data=data)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
user = authenticate(username=serializer.data['email'], password=serializer.data['password'])
if user:
if user.is_active:
login(request, user)
return Response(data={'redirect': data['next'] if data.get('next') else reverse('landing')}, status=status.HTTP_200_OK)
else:
return Response('User not active', status=status.HTTP_403_FORBIDDEN)
else:
if User.objects.filter(email__iexact=serializer.data['email']):
return Response(data='Invalid password', status=status.HTTP_400_BAD_REQUEST)
return Response(data='User not found', status=status.HTTP_404_NOT_FOUND)
except Exception as e:
return Response(data='Something went wrong', status=status.HTTP_500_INTERNAL_SERVER_ERROR, headers={'dev_msg': e.message})
def post(self, request, format=None):
serializer = VAWMobSerializer(data=request.data)
if serializer.is_valid():
mob_posted = serializer.data['vaw_num']
queryset = VAW_Registration.objects.all()
vaws = []
mobile_numbers_list = []
for obj in queryset:
mob_num = obj.VAW_contact_number
mobile_numbers_list.append(mob_num)
vaw_list = {"id": obj.id}
vaws.append(vaw_list, )
if mob_posted in mobile_numbers_list:
mob_index = mobile_numbers_list.index(mob_posted)
print("Mobile number matched...")
return Response(vaws[mob_index], status=status.HTTP_200_OK)
else:
print("Mobile number not found...")
no_vaw_data = {"error_message": "No VAW for this number..."}
return Response(no_vaw_data, status=status.HTTP_204_NO_CONTENT)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def patch(self, request, format=None):
if not self.request.session.exists(self.request.session.session_key):
self.request.session.create()
serializer = self.serializer_class(data=request.data)
if serializer.is_valid():
guest_can_pause = serializer.data.get('get_can_pause')
votes_to_skip = serializer.data.get('votes_to_skip')
code = serializer.data.get('code')
queryset = Room.objects.filter(host=host)
if not queryset.exists():
return Response({'msg': 'Room not found'},
status=status.HTTP_404_NOT_FOUND)
room = queryset[0]
user_id = self.request.session.session_key
if room.host != user_id:
return Response({'msg': 'You are not the host of this room'},
status=status.HTTP_404_NOT_FOUND)
room.guest_can_pause = guest_can_pause
room.votes_to_skip = votes_to_skip
room.save(update_fields=['guest_can_pause', 'votes_to_skip'])
return Response({'Bad': 'Invalid data'},
status=status.HTTP_400_BAD_REQUEST)
