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)
