def post(self, request, *args, **kwargs): try: serializer = ImageSerializer(data=request.data) serializer.is_valid(raise_exception=True) remove_image(get_full_url(serializer.data["image_url"])) except FileNotFoundError as e: logging.error(f"Remove image view: {e}") return HttpResponse("Obraz nie istnieje.", status=404) return Response("Usunięto pomyślnie.")
def get_slideshow_images(self, obj): images = Image.active.get_images_for_news(obj.id) if images: final_images = ImageSerializer(instance=images, user=self.user, token=self.auth_token, many=True) final_images.include_fields( ('id', 'title', 'description', 'url', 'image', 'auth_token', 'data_content_type')) return final_images.data else: return None
def post(self, request, *args, **kwargs): image_data = request.data["images"] del request.data["images"] serializer = ProductsSerializer(data=request.data) if serializer.is_valid(): serializer.save() last_product = Products.objects.latest("created_date") update_image_data = self.get_Image_data(image_data, last_product.product_id) for single_image_data in update_image_data: serializer_image = ImageSerializer(data=single_image_data) if serializer_image.is_valid(): serializer_image.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class PostSerializer(serializers.ModelSerializer): image_set = ImageSerializer(many=True, required=False) class Meta: model = Post fields = [ 'id', 'content', 'image_set', 'number_of_likes', 'number_of_comments', 'parent_post' ] def create(self, validated_data): images = [] if "image_set" in validated_data: images = validated_data.pop('image_set') post = Post.objects.create(**validated_data) for image in images: Image.objects.create(post=post, **image) return post def update(self, post, validated_data): if "image_set" in validated_data: images = validated_data.pop('image_set') post.image_set.all().delete() for image in images: Image.objects.create(post=post, **image) instance = super().update(post, validated_data) return instance
def put(self, request, image_id): print(image_id) image = MyImage.objects.get(id=image_id) new_image_type = request.GET.get('type', '') print(new_image_type) # Move in the file system new_image_folder = settings.MEDIA_ROOT + image.project.location + "images/" + new_image_type + "/" old_image_folder = settings.MEDIA_ROOT + image.project.location + "images/" + image.type + "/" new_image_path = settings.MEDIA_ROOT + image.project.location + "images/" + new_image_type + "/" + image.title old_image_path = settings.MEDIA_ROOT + image.project.location + "images/" + image.type + "/" + image.title print("new_image_path: " + new_image_path) print("old_image_path: " + old_image_path) if not os.path.exists(new_image_folder): os.makedirs(new_image_folder) os.rename(old_image_path, new_image_path) if not os.listdir(old_image_folder): print("Empty dir") os.rmdir(old_image_folder) # Update database: image.type = new_image_type image.location = image.project.location + "images/" + new_image_type + "/" + image.title image.url = settings.MEDIA_URL_DATADASE + image.project.location + "images/" + new_image_type + "/" + image.title image.save() serializer = ImageSerializer(image, many=False) return JsonResponse(serializer.data, safe=False)
def get(self, request, format=None): user = request.user following_users = user.following.all() image_list = [] for following_user in following_users: user_images = following_user.images.all()[:2] for image in user_images: image_list.append(image) my_images = user.images.all()[:2] for image in my_images: image_list.append(image) sorted_list = sorted(image_list, key=lambda image: image.created_at, reverse=True) serializer = ImageSerializer(sorted_list, many=True) return Response(serializer.data)
def get_random_image(self, request): page = int(request.query_params.get('page')) start = (page - 1) * 10 end = page * 10 image = Image.objects.all().order_by('-id')[start:end] result = ImageSerializer(image, many=True) return Response(result.data, status=status.HTTP_200_OK)
class CourseModuleSerializer(CreatedModifiedByModelSerializerV2): class Meta: model = CourseModule fields = '__all__' image = ImageSerializer(read_only=True) image_id = serializers.UUIDField(read_only=False)
class UserProfileSerializer(serializers.ModelSerializer): image = ImageSerializer(read_only=True) class Meta: model = User fields = ('phone', 'first_name', 'last_name', 'image', 'patronymic', 'email', 'city', 'date_of_birth')
def get(self, request): user_id = request.GET.get('user_id', '') project_id = request.GET.get('project_id', '') user = User.objects.get(id=user_id) project = Project.objects.get(id=project_id) images = MyImage.objects.filter(user=user, project=project) image_type_dict = dict() for image in images: if image.type in image_type_dict: image_type_dict[image.type] = image_type_dict[image.type] + 1 else: image_type_dict[image.type] = 1 print(image_type_dict) response_data = list() for key in image_type_dict: item = dict() item["name"] = key item["count"] = image_type_dict[key] avatar_Image = MyImage.objects.filter(user=user, project=project, type=key)[0] item["avatarImage"] = ImageSerializer(avatar_Image, many=False).data print(item) response_data.append(item) print(response_data) return HttpResponse(json.dumps(response_data))
class PostDetailSerializer(serializers.HyperlinkedModelSerializer): owner = serializers.ReadOnlyField(source='owner.username') images = ImageSerializer(many=True, read_only=True) class Meta: model = Post fields = ['id', 'owner', 'created_at', 'title', 'status', 'images']
class CommentSerializer(serializers.ModelSerializer): image_set = ImageSerializer(many=True, required=False) class Meta: model = Comment fields = [ 'id', 'content', 'image_set', 'number_of_likes', 'number_of_comments', 'post_id', 'parent_comment_id', 'user_id' ] def create(self, validated_data): print(validated_data) images = [] if "image_set" in validated_data: images = validated_data.pop('image_set') comment = Comment.objects.create(**validated_data) for image in images: Image.objects.create(comment=comment, **image) return comment def update(self, comment, validated_data): if "image_set" in validated_data: images = validated_data.pop('image_set') comment.image_set.all().delete() for image in images: Image.objects.create(comment=comment, **image) instance = super().update(comment, validated_data) return instance
def post(self, request, image_tag): print("tags") user_id = request.GET.get('user_id', '') project_id = request.GET.get('project_id', '') uploaded_files = request.FILES.getlist('files') image_tag = image_tag.lower() user = User.objects.get(id=user_id) project = Project.objects.get(id=project_id) timestamp = datetime.datetime.now().strftime("%Y-%m-%d-%H:%M:%S") + "-" image_folder = settings.MEDIA_ROOT + project.location + "images/" + image_tag.lower( ) + "/" if not os.path.exists(image_folder): os.makedirs(image_folder) fs = FileSystemStorage(location=image_folder) index = 0 for image in uploaded_files: image_title = timestamp + str(index) + ".jpg" fs.save(image_title, image) new_image = MyImage(title=image_title, location=project.location + "images/" + image_tag.lower() + "/" + image_title, url=settings.MEDIA_URL_DATADASE + project.location + "images/" + image_tag.lower() + "/" + image_title, description="default", type=image_tag.lower(), user=user, project=project, isTrain=True) new_image.save() index = index + 1 all_New_Images = MyImage.objects.filter(title__startswith=timestamp) serializer = ImageSerializer(all_New_Images, many=True) return JsonResponse(serializer.data, safe=False)
def get(self, request): user_id = request.GET.get('user_id', '') project_id = request.GET.get('project_id', '') user = User.objects.get(id=user_id) project = Project.objects.get(id=project_id) images = MyImage.objects.filter(user=user, project=project) serializer = ImageSerializer(images, many=True) return JsonResponse(serializer.data, safe=False)
async def is_image_available_for_recovery(self, request, image_id): try: image = ImageModel.objects.get(image_id=image_id, status=ImageModel.UNDEFINED) serializer = ImageSerializer(image) request.ret(serializer.data) except ImageModel.DoesNotExist: request.ret_error(IMAGE_IS_NOT_AVAILABLE_FOR_RECOVERY)
class SectionImageSerializer(P33ModelSerializer): class Meta: model = SectionImage fields = ('id', 'title', 'text', 'html', 'image', 'image_id', 'type') image = ImageSerializer(read_only=True) image_id = serializers.UUIDField() type = serializers.CharField(source="get_type", read_only=True)
def get(self, request, *args, **kwargs): # get image ranking dictionary image_ranking = r.zrange('image_ranking', 0, -1, desc=True) image_ranking_ids = [int(id) for id in image_ranking] # get most viewed images most_viewed = list(Image.objects.filter(id__in=image_ranking_ids)) most_viewed.sort(key=lambda x: image_ranking_ids.index(x.id)) x = ImageSerializer(most_viewed, many=True) return Response(x.data, status=status.HTTP_200_OK)
def post(self, request): print("receiving images....") model_id = request.data['model_id'] uploaded_files = request.FILES.getlist('files') user_id = request.GET.get('user_id', '') project_id = request.GET.get('project_id', '') user = User.objects.get(id=user_id) project = Project.objects.get(id=project_id) timestamp = datetime.datetime.now().strftime("%Y-%m-%d-%H:%M:%S") + "-" # https://stackoverflow.com/questions/13821866/queryset-object-has-no-attribute-name # model = Model.objects.filter(title=model_title) return a collection model = Model.objects.get(id=model_id) model_path = settings.MEDIA_ROOT + model.location print(model_path) # https://github.com/qubvel/efficientnet/issues/62 to fix ValueError: Unknown activation function:swish keras_model = tf.keras.models.load_model(model_path) index = 0 for unPredictedImage in uploaded_files: # Get the predict result: label_path = settings.MEDIA_ROOT + model.label_location print("***********************************************") print(label_path) print(model_path) fr = open(label_path) dic = eval(fr.read()) print(dic) label = predictLabel(unPredictedImage, keras_model, label_path, False) # Save the image to file-system according to the label: image_path = settings.MEDIA_ROOT + project.location + "images/" + label + "/" if not os.path.exists(image_path): os.makedirs(image_path) fs = FileSystemStorage(location=image_path) image_title = timestamp + "-" + str(index) + ".jpg" fs.save(image_title, unPredictedImage) # Save the image to database: new_image = MyImage(title=timestamp + "-" + str(index) + ".jpg", location=project.location + "images/" + label + "/" + image_title, url=settings.MEDIA_URL_DATADASE + project.location + "images/" + label + "/" + image_title, description="default", type=label, user=user, project=project, isTrain=True) new_image.save() index = index + 1 predictedImage = MyImage.objects.filter(title__startswith=timestamp) serializer = ImageSerializer(predictedImage, many=True) return JsonResponse(serializer.data, safe=False)
def get_slideshow_images(self, obj): images = None if hasattr(obj, "gallery_id") and obj.gallery_id is not None: if hasattr(self, "host_det") and self.host_det == "app": images = Image.active.filter( gallery=obj.gallery, parent_id__isnull=True).order_by('sequence') else: images = Image.active.get_images_for_news(obj.id) if images: final_images = ImageSerializer(instance=images, user=self.user, token=self.auth_token, many=True, image_type=self.image_type) final_images.include_fields(('id', 'title', 'description', 'image', 'thumb', 'source', 'source_url')) return final_images.data else: return None
class CourseSerializerForPost(P33ModelSerializer): class Meta: model = Course fields = ('id', 'image_id', 'category_id', 'authors', 'tags', 'title', 'description', 'state', 'deleted', 'color', 'image', 'category', 'authors_json', 'vimeo_id') image = ImageSerializer(read_only=True) image_id = serializers.UUIDField(read_only=False) category = serializers.CharField(read_only=True) category_id = serializers.UUIDField(read_only=False)
class PostSerializer(serializers.ModelSerializer): author = UserSerializer(read_only=True) fk_image_post = ImageSerializer(many=True, required=False) likes_counter = serializers.SerializerMethodField() def get_likes_counter(self, post): return post.like_post.all().count() class Meta: model = Post fields = '__all__'
class CourseSerializer(P33ModelSerializer): class Meta: model = Course exclude = ('authors', 'tags') image = ImageSerializer(read_only=True) image_id = serializers.UUIDField(read_only=False) category = serializers.CharField(read_only=True) category_id = serializers.UUIDField(read_only=False) is_started = serializers.BooleanField(read_only=True) is_completed = serializers.BooleanField(read_only=True) vimeo = serializers.DictField(source='get_video', read_only=True)
def get(self, request, image_id, format=None): user = request.user try: image = Image.objects.get(id=image_id) except Image.DoesNotExist: return Response(status=status.HTTP_404_NOT_FOUND) serializer = ImageSerializer(image) return Response(data=serializer.data, status=status.HTTP_200_OK)
def get(self, request, video_id): video = Video.objects.get(id=video_id) videoSerializer = VideoSerializer(video, many=False) response = dict() print("^^^^^^^^^^^^^^^^^^^^^^^^^") images = MyImage.objects.filter(video=video) # images = MyImage.objects.filter(user=user, project=project) print("^^^^^^^^^^^^^^^^^^^^^^^^^") response['images'] = ImageSerializer(images, many=True).data print("^^^^^^^^^^^^^^^^^^^^^^^^^") response['video'] = VideoSerializer(video, many=False).data print("^^^^^^^^^^^^^^^^^^^^^^^^^") print(response) return HttpResponse(json.dumps(response))
class ProductsListSerializer(serializers.ModelSerializer): race = serializers.StringRelatedField() state = serializers.StringRelatedField() category = serializers.StringRelatedField() images = ImageSerializer(many=True) seller = UserPublicListSerializer() class Meta: model = Product fields = ('id', 'name', 'race', 'gender', 'seller', 'sterile', 'description', 'state', 'price', 'category', 'active', 'latitude', 'longitude', 'created_at', 'updated_at', 'images', 'raceid', 'stateid', 'categoryid')
def get(self, request, video_id): print(video_id) video = Video.objects.get(id=video_id) images = MyImage.objects.filter(video=video) serializer = ImageSerializer(images, many=True) response = dict() print("^^^^^^^^^^^^^^^^^^^^^^^^^") if video.project.type == "Classification": response['type'] = "Classification" else: response['type'] = "Detection" response['date'] = serializer.data return HttpResponse(json.dumps(response))
class RestaurantSerializer(serializers.ModelSerializer): owner = UserSerializer(read_only=True) fk_image_restaurant = ImageSerializer(many=True, required=False) fk_timetable_restaurant = TimeTableSerializer(many=True, required=False) m2m_restaurant_cat = CategorySerializer(many=True, required=True) # fk_review_restaurant = ReviewSerializer(many=True) rating = serializers.SerializerMethodField() def get_rating(self, instance): return instance.fk_review_restaurant.all().aggregate(Avg('rating')) class Meta: model = Restaurant fields = ['name', 'country', 'street', 'city', 'zip', 'website', 'phone', 'email', 'price_level', 'owner', 'fk_image_restaurant', 'fk_timetable_restaurant', 'm2m_restaurant_cat', 'rating']
class FooterSerializer(serializers.ModelSerializer): items = StreamField(source='menu_items') social_media = StreamField(source='follow_us') image = ImageSerializer() class Meta: model = apps.get_model('dctcmsbase', 'Footer') fields = ( 'items', 'social_media', 'image', 'show_sitemap', 'heading', 'number_per_column', )
def partial_update(self, request, pk=None, **kwargs): image = get_object_or_404(self.queryset, pk=pk) serializer = ImageSerializer(instance=image, data=request.data, partial=True) serializer.is_valid(raise_exception=True) serializer.save() return Response(status=status.HTTP_200_OK)
def upload_base64(self, request, *args, **kwargs): if request.user.is_verified: data = request.data extension = 'jpg' if 'image' in data: if len(data['image']) > 0: if re.compile('^data:image/jpeg;').match( data['image']) is not None: image_type = 'image/jpeg' extension = 'jpg' if re.compile('^data:image/png;').match( data['image']) is not None: image_type = 'image/png' extension = 'png' image_data = binascii.a2b_base64(data['image'].replace( 'data:' + image_type + ';base64,', '')) f = BytesIO(image_data) pil_image = PilImage.open(f) f.seek(0) # TODO: make them all jpegs average_color = average_image_color(pil_image) color = "rgb(%s,%s,%s)" % (average_color['R'], average_color['G'], average_color['B']) image = Image(width=pil_image.width, height=pil_image.height, created_by=request.user, modified_by=request.user, color=color) image.image = UploadedFile(file=f, name='%s.%s' % (image.id, extension), content_type=image_type, size=len(image_data)) image.save() f.close() return Response(ImageSerializer(image).data) raise NotFound()
def post(self, request, format=None): serializer = ImageSerializer(data=request.DATA, files=request.FILES) 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)