def create(self, request, *args, **kargs):
serializer = FeedSerializer(data=request.data)
if serializer.is_valid():
feed = serializer.save()
return response_gen(data=FeedSerializer(feed).data, message="success")
else:
return response_gen(errorCode=status.HTTP_400_BAD_REQUEST, message='invalid data')
def log_out(self, request):
try:
refresh_token = request.data["refresh_token"]
token = RefreshToken(refresh_token)
token.blacklist()
return response_gen(status=status.HTTP_205_RESET_CONTENT)
except Exception as err:
return response_gen(status=status.HTTP_400_BAD_REQUEST)
def update(self, request, *args, **kargs):
feed_uuid = request.data.pop('uuid')
feed = Feed.objects.get(uuid= feed_uuid)
serializer = FeedSerializer(feed, request.data)
if serializer.is_valid():
serializer.save()
return response_gen(data= serializer.data)
else:
return response_gen(status=400, message='INVALID DATA')
def create(self, request, *args, **kargs):
serializer = FarmCreateSerializer(data=request.data, context={
'exclude': ['created_at']})
if serializer.is_valid():
farm = serializer.save()
user_farm = UserFarm(
farm=farm, user=request.user.profile, role=UserRole.OWNER)
user_farm.save()
return response_gen(data=FarmSerializer(farm).data, message="success")
else:
return response_gen(errorCode=status.HTTP_400_BAD_REQUEST, message='invalid data')
def update(self, request, *args, **kargs):
data = request.data.dict()
print(data)
if data.get("id"):
data.pop("id")
if data.get("uuid"):
data.pop("id")
profile = request.user.profile
serializer = self.serializer_class(instance=profile, data=data)
if serializer.is_valid():
serializer.save()
else:
return response_gen(message=str(serializer.errors),
status=status.HTTP_406_NOT_ACCEPTABLE)
return response_gen(data=serializer.data)
def field_get(request: Request, *args, **kargs):
uuid = request.query_params.get('uuid')
field = Field.objects.get(uuid=uuid)
if is_field_related(request.user, field):
data = FieldSerializer(field).data
else:
raise PermissionDenied()
return response_gen(data=data)
def read(self, request, *args, **kargs):
url_name = resolve(request.path_info).url_name
if url_name == 'read_farm':
many = False
query_set = self.get_object_or_404()
elif url_name == 'matrix_farm':
many = True
query_set = self.get_queryset()
return response_gen(data=FarmSerializer(query_set, many=many).data)
def irrigation_get(request, *args, **kwargs):
uuid = request.query_params.get('uuid')
irrigation = Irrigation.objects.get(uuid=uuid)
if not is_irrigation_related(request.user, irrigation):
raise exceptions.PermissionDenied()
data = IrrigationSerializer(irrigation).data
return response_gen(data=data)
def fields_list(request: Request, *args, **kargs):
farm_uuid = request.data.get('farm_uuid')
farm = Farm.objects.get(uuid=farm_uuid)
if not is_farm_related(request.user, farm): raise PermissionDenied()
fields = farm.field_farm.all()
serializer = FieldSerializer(fields, many=True)
data = serializer.data
return response_gen(data=data)
def field_create(request, *args, **kargs):
data = request.data
data['farm'] = Farm.objects.get(uuid=data['farm'])
if not is_farm_related(request.user, data['farm']):
raise PermissionDenied()
serializer = FieldSerializer(data=data)
if serializer.is_valid(raise_exception=True):
field = serializer.save()
return response_gen(FieldSerializer(field).data)
def field_toggle(request, *args, **kargs):
try:
data = request.data
relay = data.get('relay')
field: Field = Field.objects.get(uuid=data.get('uuid', None))
farm: Farm = field.farm
if not is_field_related(request.user, field): raise PermissionDenied()
if farm.auto_mode:
data = field.latest_data()
crop: Crop = field.current_crop()
if crop:
suggest = crop.suggest(data)
if not suggest ^ relay:
field.toggle_relay(data.get('relay'))
else:
field.toggle_relay(data.get('relay'))
data = FieldSerializer(field).data
return response_gen(data)
except Exception as exception:
print(exception)
return response_gen(data='Fail')
def irrigation_matrix(request, *args, **kwargs):
field_uuid = request.data.get('field_uuid', None)
field = Field.objects.filter(uuid=field_uuid).first()
crop_uuid = request.data.get('crop_uuid', None)
crop = Crop.objects.filter(uuid=crop_uuid).first()
if field and not is_field_related(request.user, field):
raise exceptions.PermissionDenied()
if crop and not is_crop_related(request.user, crop):
raise exceptions.PermissionDenied()
data = {
'crop': crop,
'field': field,
}
qs = IrrigationFilter(data=data, queryset=Irrigation.objects.all()).qs
qs = qs.order_by('-created_at')
data = IrrigationSerializer(qs, many=True).data
return response_gen(data)
def update(self, request, *args, **kargs):
serializer = self.serializer_class()
user = serializer.update(request.user, validated_data=request.data)
return response_gen(data=self.serializer_class(user).data)
def get(self, request, *args, **kargs):
uuid = request.query_params.get('uuid', None)
feed = Feed.objects.get(uuid = uuid)
return response_gen(data = FeedSerializer(feed).data)
def list(self, request, *args, **kargs):
farm_uuid = request.data.pop('farm_uuid')
feeds = Feed.objects.filter(farm__uuid = farm_uuid)
return response_gen(data = FeedSerializer(feeds,many = True).data)
def list(self, request, *args, **kargs):
qs = Production.objects.all()
data = ProductionSerializer(qs, many = True).data
return response_gen(data = data)
def get(self, request, *args, **kwargs):
product_uid = request.query_params.get('uuid')
product = Production.objects.get(uuid = product_uid)
return response_gen(data= ProductionSerializer(product).data)
def check_access_token(request, *args, **kargs):
return response_gen()
def post(self, request, *args, **kwargs):
data = super().post(request, *args, **kwargs).data
return response_gen(data=data)
def retrieve(self, request, *args, **kargs):
return response_gen(data=self.serializer_class(request.user).data)
def create(self, request, *args, **kargs):
user = User.objects.create_user(**request.data)
return response_gen(data=self.serializer_class(user).data)
def delete(self, request, *args, **kargs):
request.user.delete()
return response_gen()
def post(self, request, *args, **kwargs):
resp = super().post(request, *args, **kwargs)
return response_gen(data=resp.data, status=resp.status_code)
def post(self, request, *args, **kwargs):
raise Exception("hello")
resp = super().post(request, *args, **kwargs)
return response_gen(data=resp.data, status=resp.status_code)