def get_shared_image_detail(request):
user_id = get_user_id_from_jwt(request)
image_id = request.data['image_id']
try:
image = Images.objects.get(id=image_id)
except ObjectDoesNotExist:
return JsonResponse({'message': 'Image not found'},
status=status.HTTP_404_NOT_FOUND)
try:
Shared_Images.objects.get(image_id=image_id, shared_user_id=user_id)
except ObjectDoesNotExist:
folder_id = image.folder_id
while folder_id != 0:
try:
Shared_Folders.objects.get(folder_id=folder_id,
shared_user_id=user_id)
except ObjectDoesNotExist:
folder_id = Folders.objects.get(id=folder_id).parent_id
else:
serializer = DetailedImageSerializer(image, many=False)
return JsonResponse(serializer.data, status=status.HTTP_200_OK)
return JsonResponse({'message': 'Shared image not found'},
status=status.HTTP_404_NOT_FOUND)
serializer = DetailedImageSerializer(image, many=False)
return JsonResponse(serializer.data, status=status.HTTP_200_OK)
def delete_image(request, image_id):
image = get_image_by_id(image_id)
if image is None:
return HttpResponse(status=status.HTTP_404_NOT_FOUND)
user_id = get_user_id_from_jwt(request)
if not is_owner(image.owner.id, user_id):
return JsonResponse({'message': "permission denied"},
status=status.HTTP_403_FORBIDDEN)
# image.delete()
try:
Albums_Images.objects.get(image_id=image.id).delete()
# message = "Successfully"
except ObjectDoesNotExist:
print("This image {} does not exist in album!".format(image.id))
try:
Images_Tags.objects.get(image_id=image.id).delete()
# message = "Successfully"
except ObjectDoesNotExist:
print("This image {} does not have tag!".format(image.id))
try:
Shared_Images.objects.get(image_id=image.id).delete()
# message = "Successfully"
except ObjectDoesNotExist:
print("This image {} is not shared!".format(image.id))
try:
img = image.image
image.delete()
img.delete()
# message = "Successfully"
except ObjectDoesNotExist:
print("This image {} does not exist!".format(image.id))
except ProtectedError:
print("This image {} can't be deleted!!".format(image.id))
return HttpResponse(status=status.HTTP_200_OK)
def upload_image(request):
if not request.FILES['images']:
return JsonResponse({'message': 'no images uploaded'},
status=status.HTTP_400_BAD_REQUEST)
serializer = UploadImagesSerializer(data=request.data)
if not serializer.is_valid():
return JsonResponse({'message': 'no given folder id'},
status=status.HTTP_400_BAD_REQUEST)
folder_id = serializer.data['folder_id']
owner_id = get_user_id_from_jwt(request)
try:
owner = get_user_from_id(owner_id)
except Exception:
return JsonResponse({'message': 'no owner found'},
status=status.HTTP_403_FORBIDDEN)
for img in request.FILES.getlist('images'):
title = img.name
new_img = Images.objects.create(owner=owner,
folder_id=folder_id,
image=img,
size=img.size,
title=title)
print(new_img.thumbnail.url)
return JsonResponse({'message': 'successfully uploaded'},
status=status.HTTP_200_OK)
def filter_image_by_tag(request):
serializer = ImageFilteringByTagSerializer(data=request.data)
if not serializer.is_valid():
return JsonResponse({
'message': 'Invalid'
}, status=status.HTTP_400_BAD_REQUEST)
owner_id = get_user_id_from_jwt(request)
user_images = Images.objects.filter(owner_id=owner_id)
image_list = []
for image in user_images:
image_list.append(image.id)
tag_list = serializer.data['tag_list']
for tag_id in tag_list:
if Tags.objects.get(id=tag_id).owner_id != owner_id:
return JsonResponse({
'message': 'Inappropriate tag'
}, status=status.HTTP_400_BAD_REQUEST)
for tag_id in tag_list:
for image_id in image_list:
try:
Images_Tags.objects.get(tag_id=tag_id, image_id=image_id)
except ObjectDoesNotExist:
image_list.remove(image_id)
filtered_list = []
for image_id in image_list:
filtered_list. append(Images.objects.get(id=image_id))
result = ImageSerializer(filtered_list, many=True)
return JsonResponse(result.data, status=status.HTTP_200_OK, safe=False)
def share_folder(request):
owner_id = get_user_id_from_jwt(request)
serializer = SharingFolderSerializer(data=request.data)
if not serializer.is_valid():
return JsonResponse({'message': 'Invalid'},
status=status.HTTP_400_BAD_REQUEST)
folder_id = serializer.data['folder_id']
try:
Folders.objects.get(id=folder_id, owner_id=owner_id)
except ObjectDoesNotExist:
return JsonResponse({'message': 'Folder not found'},
status=status.HTTP_404_NOT_FOUND)
user_id_list = serializer.data['user_id']
for user_id in user_id_list:
try:
Users.objects.get(id=user_id)
except ObjectDoesNotExist:
return JsonResponse({'message': 'User not found'},
status=status.HTTP_404_NOT_FOUND)
for user_id in user_id_list:
created_at = datetime.datetime.now()
updated_at = datetime.datetime.now()
Shared_Folders.objects.create(folder_id=folder_id,
shared_user_id=user_id,
created_at=created_at,
updated_at=updated_at)
return JsonResponse({'message': 'Folders shared'},
status=status.HTTP_200_OK)
def get_all_shared_image(request):
user_id = get_user_id_from_jwt(request)
shared_images = Shared_Images.objects.filter(shared_user_id=user_id)
image_list = []
for pair in shared_images:
image = Images.objects.get(id=pair.image_id)
image_list.append(image)
serializer = DetailedImageSerializer(shared_images, many=True)
return JsonResponse(serializer.data, status=status.HTTP_200_OK, safe=False)
def list_album(request):
owner_id = get_user_id_from_jwt(request)
data_albums = []
try:
# albums = Albums.objects.all().filter(owner_id=owner_id).order_by('-created_at')
albums = Albums.objects.filter(owner_id=owner_id)
for album in albums:
data_images = {}
try:
album_id = AlbumsSerializer(instance=album).data['id']
images = Images.objects.all().raw(
"SELECT id FROM images WHERE id IN (SELECT image_id FROM albums_have_images WHERE album_id = {}) "
"AND is_trashed=false".format(album_id))
serializer = AlbumsSerializer(instance=album)
user_id = get_user_id_from_jwt(request)
for image in images:
if not is_owner(image.owner.id, user_id):
return JsonResponse({"message": "permission denied"},
status=status.HTTP_403_FORBIDDEN)
break
data_for_album = serializer.data
data_for_album["total_images"] = len(images)
data_images['info'] = data_for_album
if len(images) > 0:
for image in images:
data_images['thumbnail'] = DetailedImageSerializer(
instance=image).data['image']
else:
data_images['thumbnail'] = ''
except ObjectDoesNotExist:
return JsonResponse({"message": "image not found"},
status=status.HTTP_404_NOT_FOUND)
# print(data_albums[0])
data_albums.append(data_images)
except ObjectDoesNotExist:
return JsonResponse({"message": "album not found"},
status=status.HTTP_404_NOT_FOUND)
return JsonResponse({"albums": json.loads(json.dumps(data_albums))},
status=status.HTTP_200_OK)
def add_image_to_collection(request):
user_id = get_user_id_from_jwt(request)
# serializer = AddImgToCollectionSerializer(data=request.data)
# if not serializer.is_valid():
# return JsonResponse({
# 'message': 'Invalid serializer'
# }, status=status.HTTP_400_BAD_REQUEST)
folder_id = request.data['folder_id']
if folder_id != 0:
try:
Folders.objects.get(id=folder_id, owner_id=user_id)
except ObjectDoesNotExist:
return JsonResponse({'message': 'Folder not found'},
status=status.HTTP_404_NOT_FOUND)
select_all = request.data['select_all']
if select_all:
try:
shared_list = Shared_Images.objects.filter(shared_user_id=user_id)
except ObjectDoesNotExist:
return JsonResponse({'message': 'Shared image not found'},
status=status.HTTP_404_NOT_FOUND)
for connection in shared_list:
img = Images.objects.get(id=connection.image_id)
new_image = img
new_image.pk = None
new_image.owner = get_user_from_id(user_id)
new_image.folder_id = folder_id
new_image.image.save(img.title, img.image, True)
new_image.star = new_image.is_trashed = False
new_image.trashed_at = None
new_image.created_at = new_image.updated_at = datetime.datetime.now(
)
new_image.is_public = False
new_image.save()
else:
image_id = request.data['image_id']
for iterator in image_id:
img = Images.objects.get(id=iterator)
new_image = img
new_image.pk = None
new_image.owner = get_user_from_id(user_id)
new_image.folder_id = folder_id
new_image.image.save(img.title, img.image, True)
new_image.star = new_image.is_trashed = False
new_image.trashed_at = None
new_image.created_at = new_image.updated_at = datetime.datetime.now(
)
new_image.is_public = False
new_image.save()
return JsonResponse(
{'message': 'Added to user {} collection'.format(user_id)},
status=status.HTTP_200_OK)
def upload_avatar(request):
user_id = get_user_id_from_jwt(request)
if not request.FILES['avatar']:
return JsonResponse({
'message': 'no images uploaded'
}, status=status.HTTP_400_BAD_REQUEST)
avatar = request.FILES['avatar']
user = Users.objects.get(id=user_id)
user.avatar = avatar
user.save()
return HttpResponse(status=status.HTTP_200_OK)
def get_detailed_user(request):
user_id = get_user_id_from_jwt(request)
try:
user = Users.objects.get(id=user_id)
except ObjectDoesNotExist:
return JsonResponse({
'message': 'User does not exist!'
}, status=status.HTTP_404_NOT_FOUND)
serializer = GetAllDetailedUserSerializer(instance=user)
return JsonResponse({
'user': serializer.data
}, status=status.HTTP_200_OK)
def update_album_unstar(request, album_id):
try:
album = Albums.objects.get(id=album_id)
user_id = get_user_id_from_jwt(request)
if not is_owner(album.owner.id, user_id):
return JsonResponse({"message": "permission denied"},
status=status.HTTP_403_FORBIDDEN)
change_album_star_status(album, 0)
return JsonResponse({"message": "successfully"},
status=status.HTTP_200_OK)
except ObjectDoesNotExist:
return HttpResponse(status=status.HTTP_404_NOT_FOUND)
def get_shared_folder_detail(request):
user_id = get_user_id_from_jwt(request)
shared_id = folder_id = request.data['folder_id']
while shared_id != 0:
try:
Shared_Folders.objects.get(folder_id=shared_id,
shared_user_id=user_id)
except ObjectDoesNotExist:
shared_id = Folders.objects.get(id=shared_id).parent_id
else:
folder = Folders.objects.get(id=folder_id)
serializer = FolderDetailSerializer(folder, many=False)
return JsonResponse(serializer.data, status=status.HTTP_200_OK)
return JsonResponse({'message': 'Shared folder not found'},
status=status.HTTP_404_NOT_FOUND)
def restore_image(request, image_id):
image = get_image_by_id(image_id)
if image is None:
return HttpResponse(status=status.HTTP_404_NOT_FOUND)
user_id = get_user_id_from_jwt(request)
if not is_owner(image.owner.id, user_id):
return JsonResponse({'message': "permission denied"},
status=status.HTTP_403_FORBIDDEN)
image = change_image_trash_status(image, False)
return JsonResponse({
'image_id': image.id,
'is_trashed': image.is_trashed
},
status=status.HTTP_400_BAD_REQUEST)
def delete_album(request, album_id):
try:
album = Albums.objects.get(id=album_id)
user_id = get_user_id_from_jwt(request)
if not is_owner(album.owner.id, user_id):
return JsonResponse({"message": "permission denied"},
status=status.HTTP_403_FORBIDDEN)
Albums_Images.objects.filter(id=album_id).update(id=-1)
album.delete()
return JsonResponse({"message": "successfully"},
status=status.HTTP_200_OK)
except ObjectDoesNotExist:
return HttpResponse(status=status.HTTP_404_NOT_FOUND)
def set_image_tag(request):
user_id = get_user_id_from_jwt(request)
serializer = SetImageTagSerializer(data=request.data)
if not serializer.is_valid():
return JsonResponse({
'message': 'Invalid serializer'
}, status=status.HTTP_400_BAD_REQUEST)
select_all = serializer.data['select_all']
if select_all:
try:
image_list = Images.objects.filter(owner_id=user_id)
except ObjectDoesNotExist:
return JsonResponse({
'message': 'Image does not exist'
}, status=status.HTTP_404_NOT_FOUND)
else:
image_id = serializer.data['image_id']
image_list = []
for id in image_id:
try:
image = Images.objects.get(id=id)
except ObjectDoesNotExist:
return JsonResponse({
'message': 'Image does not exist'
}, status=status.HTTP_404_NOT_FOUND)
image_list.append(image)
tag_id = serializer.data['tag_id']
tag_list = []
for id in tag_id:
try:
tag = Tags.objects.get(id=id)
except ObjectDoesNotExist:
return JsonResponse({
'message': 'Tag does not exist'
}, status=status.HTTP_404_NOT_FOUND)
tag_list.append(tag)
for image in image_list:
for tag in tag_list:
try:
Images_Tags.objects.get(image=image, tag=tag)
except ObjectDoesNotExist:
Images_Tags.objects.create(image=image, tag=tag)
else:
pass
return JsonResponse({
'message': 'Tag added'
}, status=status.HTTP_200_OK)
def update_detailed_user(request):
user_id = get_user_id_from_jwt(request)
try:
user = Users.objects.get(id=user_id)
except ObjectDoesNotExist:
return JsonResponse({
'message': 'User does not exist!'
}, status=status.HTTP_404_NOT_FOUND)
serializer = UpdateDetailedUserSerializer(user, data=request.data)
if not serializer.is_valid():
return JsonResponse({
'message': 'invalid update'
}, status=status.HTTP_400_BAD_REQUEST)
updated_user = serializer.save()
return Response({
'user_id': updated_user.id
}, status=status.HTTP_200_OK)
def find_folder_and_check_permission(request, folder_id):
try:
folder = Folders.objects.get(id=folder_id)
except ObjectDoesNotExist:
return None, JsonResponse(
{
'message': 'no folder with id {} found'.format(folder_id),
},
status=status.HTTP_404_NOT_FOUND)
user_id = get_user_id_from_jwt(request)
if not is_owner(folder, user_id):
return None, JsonResponse({
'message': 'permission denied',
},
status=status.HTTP_403_FORBIDDEN)
return folder, None
def get_albums_filter_by_star_status(request, star):
try:
albums = Albums.objects.filter(star=star)
user_id = get_user_id_from_jwt(request)
for album in albums:
if not is_owner(album.owner.id, user_id):
return JsonResponse({"message": "permission denied"},
status=status.HTTP_403_FORBIDDEN)
json_result = {}
for album in albums:
serializer = DetailedAlbumSerializer(instance=album)
json_result[album.title] = serializer.data
return JsonResponse({"albums": json.loads(json.dumps(json_result))},
status=status.HTTP_200_OK)
except ObjectDoesNotExist:
return HttpResponse(status=status.HTTP_404_NOT_FOUND)
def tag_create(request):
serializer = TagCreateSerializer(data=request.data)
if not serializer.is_valid():
return JsonResponse({
'message': 'Invalid'
}, status=status.HTTP_400_BAD_REQUEST)
tag_name = serializer.data['name']
try:
Tags.objects.get(name=tag_name)
except ObjectDoesNotExist:
owner_id = get_user_id_from_jwt(request)
Tags.objects.create(name=tag_name, owner_id=owner_id)
return JsonResponse({
'message': 'Tag created'
}, status=status.HTTP_200_OK)
return JsonResponse({
'message': 'Tag existed'
}, status=status.HTTP_400_BAD_REQUEST)
def move_image_to_folder(request):
user_id = get_user_id_from_jwt(request)
serializer = MoveImageToFolderSerializer(data=request.data)
if not serializer.is_valid():
return JsonResponse({'message': 'Invalid'},
status=status.HTTP_400_BAD_REQUEST)
dest_folder_id = serializer.data['dest_folder_id']
if dest_folder_id != 0:
try:
Folders.objects.get(id=dest_folder_id, owner_id=user_id)
except ObjectDoesNotExist:
return JsonResponse({'message': 'Destination folder not found'},
status=status.HTTP_404_NOT_FOUND)
select_all = serializer.data['select_all']
if select_all:
src_folder_id = serializer.data['src_folder_id']
if src_folder_id != 0:
try:
Folders.objects.get(id=src_folder_id, owner_id=user_id)
except ObjectDoesNotExist:
return JsonResponse({'message': 'Source folder not found'},
status=status.HTTP_404_NOT_FOUND)
try:
images = Images.objects.filter(folder_id=src_folder_id)
except ObjectDoesNotExist:
return JsonResponse({'message': 'No images selected'},
status=status.HTTP_404_NOT_FOUND)
else:
images = []
image_id = serializer.data['image_id']
for id in image_id:
try:
images.append(Images.objects.get(id=id))
except ObjectDoesNotExist:
return JsonResponse({'message': 'Image not found'},
status=status.HTTP_404_NOT_FOUND)
for image in images:
image.folder_id = dest_folder_id
image.updated_at = datetime.now()
image.save()
return JsonResponse({'message': 'Image moved'}, status=status.HTTP_200_OK)
def add_image_to_album(request, album_id):
owner_id = get_user_id_from_jwt(request)
serializer = SelectImages(data=request.data)
album = get_album_by_id(album_id)
if not is_owner(album.owner.id, owner_id):
return JsonResponse({"message": "permission denied"},
status=status.HTTP_403_FORBIDDEN)
if not serializer.is_valid():
return JsonResponse({"message": "Invalid serializer"},
status=status.HTTP_400_BAD_REQUEST)
images = []
select_all = serializer.data['select_all']
if select_all:
try:
images = Images.objects.all().filter(owner_id=owner_id)
except ObjectDoesNotExist:
return JsonResponse({"message": "Invalid image"})
else:
image_id = serializer.data['image_id']
try:
for id in image_id:
images.append(Images.objects.get(id=id, owner_id=owner_id))
except ObjectDoesNotExist:
return JsonResponse({"message": "Image not found"})
already_images = []
for image in images:
try:
Albums_Images.objects.get(album_id=album_id, image_id=image.id)
already_images.append(image.id)
except ObjectDoesNotExist:
Albums_Images.objects.create(album=album, image_id=image.id)
# return JsonResponse({
# "message": "Album already had this image"
# }, status=status.HTTP_400_BAD_REQUEST)
if len(already_images) == 0:
return JsonResponse({"message": "successfully"},
status=status.HTTP_200_OK)
else:
return JsonResponse({
"message":
"Album already had image id {}".format(already_images)
})
def get_detailed_image(request, image_id):
# os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = 'ServiceAccountToken.json'
# image = get_image_by_id(image_id)
# if image is None:
# return HttpResponse(status=status.HTTP_404_NOT_FOUND)
#
# user_id = get_user_id_from_jwt(request)
#
# if not is_owner(image.owner.id, user_id):
# return JsonResponse({
# 'message': "permission denied"
# }, status=status.HTTP_403_FORBIDDEN)
#
# serializer = DetailedImageSerializer(instance=image)
#
# tag = Tags.objects.raw("select id from tags where id in (select tag_id from images_tags where image_id = 1)")
#
# tag_serializer = TagSerializer(tag, many=True)
#
# data = serializer.data
# data['tags'] = tag_serializer.data
#
# # image_cloud = vision.Image(content=image)
#
#
# # client = vision.ImageAnnotatorClient()
# # response = client.label_detection(image=image_cloud)
# # data['tag'] = response
# return JsonResponse({
# 'image': data
# }, status=status.HTTP_200_OK)
image = get_image_by_id(image_id)
if image is None:
return HttpResponse(status=status.HTTP_404_NOT_FOUND)
user_id = get_user_id_from_jwt(request)
if not is_owner(image.owner.id, user_id):
return JsonResponse({'message': "permission denied"},
status=status.HTTP_403_FORBIDDEN)
serializer = DetailedImageSerializer(instance=image)
return JsonResponse({'image': serializer.data}, status=status.HTTP_200_OK)
def trash_multiple_image(request):
user_id = get_user_id_from_jwt(request)
serializer = MultiplIDsSerializer(data=request.data)
if not serializer.is_valid():
return HttpResponse(status=status.HTTP_400_BAD_REQUEST)
image_ids = serializer.data['ids']
for image_id in image_ids:
image = get_image_by_id(image_id)
if image is None:
return HttpResponse(status=status.HTTP_404_NOT_FOUND)
if not is_owner(image.owner.id, user_id):
return JsonResponse(
{
'message':
"permission denied for image id {}".format(image_id)
},
status=status.HTTP_403_FORBIDDEN)
change_image_trash_status(image, True)
return HttpResponse(status=status.HTTP_200_OK)
def create_album(request):
serializer = UpdateOrCreateAlbumSerializer(data=request.data)
if not serializer.is_valid():
return JsonResponse({"message": "invalid album information"},
status=status.HTTP_400_BAD_REQUEST)
try:
owner_id = get_user_id_from_jwt(request)
except Exception:
return JsonResponse({"message": "no owner found"},
status=status.HTTP_403_FORBIDDEN)
title = serializer.data['title']
if is_album_title_duplicate(owner_id, title):
title = title + "_duplicated"
new_album = Albums.objects.create(title=title, owner_id=owner_id)
return JsonResponse({
"message": "successfully created",
},
status=status.HTTP_200_OK)
def delete_multiple_image(request):
user_id = get_user_id_from_jwt(request)
serializer = MultipleImageIDsSerializer(data=request.data)
if not serializer.is_valid():
print("something")
return HttpResponse(status=status.HTTP_400_BAD_REQUEST)
image_ids = serializer.data['ids']
for image_id in image_ids:
image = get_image_by_id(image_id)
if image is None:
return HttpResponse(status=status.HTTP_404_NOT_FOUND)
if not is_owner(image.owner.id, user_id):
return JsonResponse(
{
'message':
"permission denied for image id {}".format(image_id)
},
status=status.HTTP_403_FORBIDDEN)
try:
Albums_Images.objects.filter(image_id=image_id).delete()
# message = "Successfully"
except ObjectDoesNotExist:
print("This image {} does not exist in album!".format(image.id))
try:
Images_Tags.objects.filter(image_id=image_id).delete()
# message = "Successfully"
except ObjectDoesNotExist:
print("This image {} does not have tag!".format(image.id))
try:
Shared_Images.objects.filter(image_id=image_id).delete()
# message = "Successfully"
except ObjectDoesNotExist:
print("This image {} is not shared!".format(image.id))
try:
image.delete()
# message = "Successfully"
except ObjectDoesNotExist:
print("This image {} does not exist!".format(image.id))
except ProtectedError:
print("This image {} can't be deleted!!".format(image.id))
return HttpResponse(status=status.HTTP_200_OK)
def share_image(request):
owner_id = get_user_id_from_jwt(request)
serializer = SharingImageSerializer(data=request.data)
if not serializer.is_valid():
return JsonResponse({'message': 'Invalid'},
status=status.HTTP_400_BAD_REQUEST)
user_id_list = serializer.data['user_id']
select_all = serializer.data['select_all']
if select_all:
folder_id = serializer.data['folder_id']
try:
image_list = Images.objects.filter(owner_id=owner_id,
folder_id=folder_id)
except ObjectDoesNotExist:
return JsonResponse({'message': 'Images not found'},
status=status.HTTP_404_NOT_FOUND)
else:
image_id_list = serializer.data['image_id']
image_list = []
for image_id in image_id_list:
try:
image = Images.objects.get(id=image_id, owner_id=owner_id)
except ObjectDoesNotExist:
return JsonResponse({'message': 'Image not found'},
status=status.HTTP_404_NOT_FOUND)
image_list.append(image)
for user_id in user_id_list:
try:
Users.objects.get(id=user_id)
except ObjectDoesNotExist:
return JsonResponse({'message': 'User not found'},
status=status.HTTP_404_NOT_FOUND)
for user_id in user_id_list:
for image in image_list:
created_at = datetime.datetime.now()
updated_at = datetime.datetime.now()
Shared_Images.objects.create(image=image,
shared_user_id=user_id,
created_at=created_at,
updated_at=updated_at)
return JsonResponse({'message': 'Image shared'}, status=status.HTTP_200_OK)
def delete_image_in_album(request, album_id):
owner_id = get_user_id_from_jwt(request)
serializer = SelectImages(data=request.data)
album = get_album_by_id(album_id)
if not is_owner(album.owner.id, owner_id):
return JsonResponse({"message": "permission denied"},
status=status.HTTP_403_FORBIDDEN)
if not serializer.is_valid():
return JsonResponse({"message": "Invalid image information"},
status=status.HTTP_400_BAD_REQUEST)
select_all = serializer.data['select_all']
invalid_image = []
if select_all:
try:
images = Albums_Images.objects.all().filter(album_id=album_id)
except ObjectDoesNotExist:
return JsonResponse({"message": "Invalid image"})
for image in images:
Albums_Images.objects.get(album_id=album_id,
image_id=image.images_id).delete()
return JsonResponse({"message": "successfully"})
else:
image_id = serializer.data['images_id']
for id in image_id:
try:
Albums_Images.objects.get(album_id=album_id,
image_id=id).delete()
except ObjectDoesNotExist:
invalid_image.append(id)
if len(invalid_image) > 0:
return JsonResponse({
"message":
"Album doesn't have image id {}".format(invalid_image)
})
else:
return JsonResponse({"message": "successfully"})
def get_detailed_album(request, album_id):
album = Albums.objects.get(id=album_id)
if album is None:
return HttpResponse(status=status.HTTP_404_NOT_FOUND)
user_id = get_user_id_from_jwt(request)
if not is_owner(album.owner.id, user_id):
return JsonResponse({"message": "permission denied"},
status=status.HTTP_403_FORBIDDEN)
serializer = DetailedAlbumSerializer(instance=album)
image = Images.objects.raw(
"SELECT id FROM images WHERE id IN (SELECT image_id FROM albums_have_images WHERE album_id = {}) AND "
"is_trashed = false".format(album_id))
image_id_serializer = DetailedImageSerializer(image, many=True)
data = serializer.data
data['total_images'] = len(image)
data['images'] = image_id_serializer.data
return JsonResponse({"album": data}, status=status.HTTP_200_OK)
def add_multiple_images_to_multiple_albums(request):
owner_id = get_user_id_from_jwt(request)
serializer = AddMultipleImagesToMultipleAlbumsSerializer(data=request.data)
if not serializer.is_valid():
return JsonResponse({"message": "Invalid Serializer"},
status=status.HTTP_400_BAD_REQUEST)
albums_id = serializer.data['albums_id']
for album_id in albums_id:
try:
Albums.objects.get(id=album_id, owner_id=owner_id)
except ObjectDoesNotExist:
return JsonResponse({"message": "Album not found"},
status=status.HTTP_404_NOT_FOUND)
images = []
select_all = serializer.data['select_all']
if select_all:
try:
images = Images.objects.all().filter(owner_id=owner_id)
except ObjectDoesNotExist:
return JsonResponse({"message": "Invalid image"})
else:
image_id = serializer.data['images_id']
try:
for id in image_id:
images.append(Images.objects.get(id=id, owner_id=owner_id))
except ObjectDoesNotExist:
return JsonResponse({"message": "Image not found"})
for album_id in albums_id:
for image in images:
try:
Albums_Images.objects.get(album_id=album_id, image_id=image.id)
except ObjectDoesNotExist:
Albums_Images.objects.create(album_id=album_id,
image_id=image.id)
return JsonResponse({"message": "successfully"})
def create_folder(request):
serializer = CreateOrUpdateFolderSerializer(data=request.data)
if not serializer.is_valid():
return JsonResponse({'message': 'invalid folder information'},
status=status.HTTP_400_BAD_REQUEST)
owner_id = get_user_id_from_jwt(request)
try:
owner = get_user_from_id(owner_id)
except Exception:
return JsonResponse({'message': 'no owner found'},
status=status.HTTP_403_FORBIDDEN)
title = serializer.data['title']
parent_id = serializer.data['parent_id']
if is_folder_title_duplicate(owner_id, title):
title = title + "_duplicated"
new_folder = Folders.objects.create(title=title,
parent_id=parent_id,
owner=owner)
return JsonResponse(
{
'message': 'successfully created',
'folder_id': new_folder.id
},
status=status.HTTP_200_OK)
