def post(request):
"""Creates a tag object
:param name: Name for tag
:type name: str
:returns: json
"""
res = Result()
data = request.POST or json.loads(request.body)['body']
name = data.get('name', None)
if not name:
res.isError = True
res.message = "No name given"
return JsonResponse(res.asDict())
tag, created = Tag.objects.get_or_create(name=name.lower())
if created:
res.message = "Created"
else:
res.isError = True
res.append(tag.json())
return JsonResponse(res.asDict())
def group(request, obj_id=None):
res = Result()
if request.method == "GET":
try:
group = Group.objects.get(pk=obj_id)
res.append(group.json())
except ObjectDoesNotExist as err:
res.isError = True
res.message = str(err)
elif request.method == "POST":
data = json.loads(request.body)["body"]
user = getUser(request)
if user:
items = getObjectsFromGuids(data["guids"])
gallery = data.get("gallery")
g = Group()
g.author = user
g.title = data.get("title", items[0].title)
g.thumbnail = items[0].thumbnail
g.description = data.get("description", items[0].description)
g.save()
g.guid = g.getGuid().guid
g.save()
if gallery:
Gallery.objects.get(pk=gallery).groups.add(g)
for item in items:
g.appendChild(item)
res.append(g.json())
else:
res.isError = True
res.message = "No user found to create group"
elif request.method == "PUT":
data = json.loads(request.body)["body"]
g = Group.objects.get(pk=obj_id)
action = data["action"]
index = data.get("index")
item = Piece.fromGuid(data["guid"])
if action == "append":
g.appendChild(item)
elif action == "insert":
g.insertChild(index, item)
else:
g.removeChild(item)
res.append(g.json())
else:
g = Group.objects.get(pk=obj_id)
g.delete()
return JsonResponse(res.asDict())
def login_(request):
data = request.POST or json.loads(request.body)['body']
email = data['email'].lower()
username = email.split('@')[0]
password = data.get('password')
result = Result()
user = None
if email:
user = authenticate(username=username, password=password)
else:
result.message = 'Please enter an email address'
result.isError = True
if user:
first_name = request.POST.get('first_name')
last_name = request.POST.get('last_name')
if first_name:
user.first_name = first_name
if last_name:
user.last_name = last_name
if not user.is_active:
result.message = 'User account not active'
result.isError = True
else:
result.message = 'Invalid Credentials'
result.isError = True
if result.isError:
if request.is_ajax():
return JsonResponse(result.asDict())
else:
return render(request, INDEX_HTML, result.asDict())
login(request, user)
# -- Create an artist tag for them
Tag.objects.get_or_create(
name=user.get_full_name(),
defaults={'artist': True}
)
# -- Create their personal gallery
Gallery.objects.get_or_create(title=user.username, defaults={'owner': user, 'security': Gallery.PERSONAL})
if request.is_ajax():
return JsonResponse(result.asDict())
return HttpResponseRedirect('/frog/gallery/1')
def post(request):
"""Sets a key to a value on the currently logged in users preferences
:param key: Key to set
:type key: str
:param val: Value to set
:type val: primitive
:returns: json
"""
data = request.POST or json.loads(request.body)['body']
key = data.get('key', None)
val = data.get('val', None)
res = Result()
if key is not None and val is not None:
obj, created = UserPref.objects.get_or_create(user=request.user)
if created:
obj.data = json.dumps(DefaultPrefs.copy())
obj.save()
try:
val = json.loads(val)
except (TypeError, ValueError):
pass
obj.setKey(key, val)
obj.save()
res.append(obj.json())
else:
res.isError = True
res.message = 'No key and value provided'
return JsonResponse(res.asDict())
def post(request):
"""Returns a serialized object"""
data = request.POST or json.loads(request.body)['body']
guid = data.get('guid', None)
res = Result()
if guid:
obj = getObjectsFromGuids([guid,])[0]
comment = Comment()
comment.comment = data.get('comment', 'No comment')
comment.user = request.user
comment.user_name = request.user.get_full_name()
comment.user_email = request.user.email
comment.content_object = obj
comment.site_id = get_current_site(request).id
comment.save()
obj.comment_count += 1
obj.save()
emailComment(comment, obj, request)
res.append(commentToJson(comment))
else:
res.isError = True
res.message = "No guid provided"
return JsonResponse(res.asDict())
def switchArtist(request):
data = request.POST or json.loads(request.body)['body']
artist = data.get('artist', None)
guids = data.get('guids', '').split(',')
res = Result()
if artist:
if isinstance(artist, int):
author = User.objects.get(pk=artist)
tag = Tag.objects.get_or_create(name=author.get_full_name().lower(), defaults={'artist': True})[0]
else:
first, last = artist.lower().split(' ')
author = User.objects.get_or_create(first_name=first, last_name=last, defaults={
'username': '******' % (first[0], last),
})[0]
tag = Tag.objects.get_or_create(name=artist.lower(), defaults={'artist': True})[0]
objects = getObjectsFromGuids(guids)
for n in objects:
n.author = author
n.tagArtist(tag)
res.append(userToJson(author))
res.value['tag'] = tag.id
else:
res.isError = True
res.message = "No artist provided"
return JsonResponse(res.asDict())
def post(request):
"""Creates a tag object
:param name: Name for tag
:type name: str
:returns: json
"""
res = Result()
name = request.POST.get("name", None)
if not name:
res.isError = True
res.message = "No name given"
return JsonResponse(res)
tag, created = Tag.objects.get_or_create(name=name)
res.isSuccess = True
if created:
res.message = "Created"
res.append(tag.json())
return JsonResponse(res)
def post(request):
"""Creates a tag object
:param name: Name for tag
:type name: str
:returns: json
"""
res = Result()
name = request.POST.get('name', None)
if not name:
res.isError = True
res.message = "No name given"
return JsonResponse(res)
tag, created = Tag.objects.get_or_create(name=name)
res.isSuccess = True
if created:
res.message = "Created"
res.append(tag.json())
return JsonResponse(res)
def post(request):
res = Result()
data = json.loads(request.POST["body"])
tag = Tag.objects.get(name=data['tag'])
badge = Badge.objects.get_or_create(tag=tag)[0]
if request.FILES.get("image"):
incomingfilename = pathlib.Path(request.FILES["image"].name)
filename = '{}{}'.format(tag.name, incomingfilename.suffix)
dest = getRoot() / "badges" / filename
if not dest.parent.exists():
dest.parent.makedirs_p()
handle_uploaded_file(dest, request.FILES["image"])
badge.image = "badges/{}".format(filename)
if badge:
badge.save()
res.append(badge.json())
else:
res.isError = True
res.message = "No badge found"
return JsonResponse(res.asDict())
def post(request):
"""Sets a key to a value on the currently logged in users preferences
:param key: Key to set
:type key: str
:param val: Value to set
:type val: primitive
:returns: json
"""
key = request.POST.get('key', None)
val = request.POST.get('val', None)
res = Result()
if key and val:
obj, created = UserPref.objects.get_or_create(user=request.user)
if created:
obj.data = json.dumps(DefaultPrefs.copy())
obj.save()
val = json.loads(val)
obj.setKey(key, val)
obj.save()
res.append(obj.json())
res.isSuccess = True
else:
res.isError = True
res.message = 'No key and value provided'
return JsonResponse(res)
def getUser(request):
res = Result()
data = {}
if request.user.is_anonymous():
res.isError = True
data['prefs'] = DefaultPrefs
elif request.GET.get('q'):
return JsonResponse(res.asDict())
else:
data['user'] = userToJson(request.user)
data['user']['isManager'] = any(request.user.groups.filter(name='manager')) or request.user.is_staff
data['gallery'] = None
personal = Gallery.objects.filter(owner=request.user, security=Gallery.PERSONAL)
if personal:
data['personal_gallery'] = personal[0].json()
data['prefs'] = request.user.frog_prefs.get_or_create(user=request.user)[0].json()
galleryid = request.GET.get('gallery')
if galleryid is not None:
gallery = Gallery.objects.filter(pk=galleryid, owner=request.user)
if gallery:
data['gallery'] = gallery[0].json()
res.append(data)
return JsonResponse(res.asDict())
def isUnique(request):
path = request.GET.get('path', None)
res = Result()
if path:
if request.user.is_anonymous():
username = request.GET.get('user', 'noauthor')
user = User.objects.get(username=username)
else:
user = request.user
uniqueID = Piece.getUniqueID(path, user)
img = Image.objects.filter(unique_id=uniqueID)
vid = Video.objects.filter(unique_id=uniqueID)
if img:
res.append(img[0].json())
elif vid:
res.append(vid[0].json())
else:
res.append(True)
res.isSuccess = True
else:
res.isError = True
res.message = "No path provided"
return JsonResponse(res)
def isUnique(request):
path = request.GET.get('path', None)
res = Result()
if path:
if request.user.is_anonymous():
username = request.GET.get('user', 'noauthor')
user = User.objects.get(username=username)
else:
user = request.user
uniqueID = Piece.getUniqueID(path, user)
img = Image.objects.filter(unique_id=uniqueID)
vid = Video.objects.filter(unique_id=uniqueID)
if img:
res.append(img[0].json())
elif vid:
res.append(vid[0].json())
else:
res.append(True)
res.isSuccess = True
else:
res.isError = True
res.message = "No path provided"
return JsonResponse(res)
def post(request):
"""Returns a serialized object
:param obj_id: ID of comment object
:type obj_id: int
:returns: json
"""
guid = request.POST.get('guid', None)
res = Result()
if guid:
obj = getObjectsFromGuids([
guid,
])[0]
c = Comment()
c.comment = request.POST.get('comment', 'No comment')
c.user = request.user
c.user_name = request.user.get_full_name()
c.user_email = request.user.email
c.content_object = obj
c.site_id = 1
c.save()
obj.comment_count = obj.comment_count + 1
obj.save()
__email(c, obj)
res.append({'id': c.id, 'comment': c.comment})
res.isSuccess = True
else:
res.isError = True
res.message = "No guid provided"
return JsonResponse(res)
def post(request):
"""Returns a serialized object
:param obj_id: ID of comment object
:type obj_id: int
:returns: json
"""
guid = request.POST.get('guid', None)
res = Result()
if guid:
obj = getObjectsFromGuids([guid,])[0]
c = Comment()
c.comment = request.POST.get('comment', 'No comment')
c.user = request.user
c.user_name = request.user.get_full_name()
c.user_email = request.user.email
c.content_object = obj
c.site_id = 1
c.save()
obj.comment_count = obj.comment_count + 1
obj.save()
__email(c, obj)
res.append({'id': c.id, 'comment': c.comment})
res.isSuccess = True
else:
res.isError = True
res.message = "No guid provided"
return JsonResponse(res)
def getUser(request):
res = Result()
data = {}
if request.user.is_anonymous:
res.isError = True
data["prefs"] = DefaultPrefs
elif request.GET.get("q"):
return JsonResponse(res.asDict())
else:
data["user"] = userToJson(request.user)
data["user"]["isManager"] = (any(
request.user.groups.filter(name="manager"))
or request.user.is_staff)
data["gallery"] = None
personal = Gallery.objects.filter(owner=request.user,
security=Gallery.PERSONAL)
if personal:
data["personal_gallery"] = personal[0].json()
data["prefs"] = request.user.frog_prefs.get_or_create(
user=request.user)[0].json()
galleryid = request.GET.get("gallery")
if galleryid is not None:
gallery = Gallery.objects.filter(pk=galleryid, owner=request.user)
if gallery:
data["gallery"] = gallery[0].json()
res.append(data)
return JsonResponse(res.asDict())
def filterObjects(request, obj_id):
"""
Filters Gallery for the requested ImageVideo objects. Returns a Result object with
serialized objects
"""
print obj_id
obj = Gallery.objects.get(pk=obj_id)
if request.user.is_anonymous() and obj.security != Gallery.PUBLIC:
res = Result()
res.isError = True
res.message = 'This gallery is not public'
return JsonResponse(res)
tags = json.loads(request.GET.get('filters', '[[]]'))
rng = request.GET.get('rng', None)
more = json.loads(request.GET.get('more', 'false'))
models = request.GET.get('models', 'image,video')
if models == '':
models = 'image,video'
tags = filter(None, tags)
models = [ContentType.objects.get(app_label='frog', model=x) for x in models.split(',')]
return _filter(request, obj, tags=tags, rng=rng, models=models, more=more)
def resolve(request, name):
res = Result()
tag = Tag.objects.filter(name__iexact=name)
if tag:
res.append(tag[0].json())
else:
res.isError = True
return JsonResponse(res.asDict())
def login_(request):
data = request.POST or json.loads(request.body)["body"]
email = data["email"].lower()
password = data.get("password")
result = Result()
user = None
if email:
user = authenticate(username=email, password=password)
else:
result.message = "Please enter an email address"
result.isError = True
if user:
first_name = request.POST.get("first_name")
last_name = request.POST.get("last_name")
if first_name:
user.first_name = first_name
if last_name:
user.last_name = last_name
if not user.is_active:
result.message = "User account not active"
result.isError = True
else:
result.message = "Invalid Credentials"
result.isError = True
if result.isError:
return JsonResponse(result.asDict())
login(request, user)
# -- Create an artist tag for them
Tag.objects.get_or_create(
name=user.get_full_name(), defaults={"artist": True}
)
usersgroup = Group.objects.get_or_create(name="users")[0]
usersgroup.user_set.add(user)
return JsonResponse(result.asDict())
def like(request, guid):
obj = Piece.fromGuid(guid)
res = Result()
if obj.like(request):
emailLike(request, obj)
else:
res.isError = True
res.message = 'Cannot "like" things more than once'
res.append(obj.json())
return JsonResponse(res.asDict())
def login_(request):
data = request.POST or json.loads(request.body)['body']
email = data['email'].lower()
password = data.get('password')
result = Result()
user = None
if email:
user = authenticate(username=email, password=password)
else:
result.message = 'Please enter an email address'
result.isError = True
if user:
first_name = request.POST.get('first_name')
last_name = request.POST.get('last_name')
if first_name:
user.first_name = first_name
if last_name:
user.last_name = last_name
if not user.is_active:
result.message = 'User account not active'
result.isError = True
else:
result.message = 'Invalid Credentials'
result.isError = True
if result.isError:
return JsonResponse(result.asDict())
login(request, user)
# -- Create an artist tag for them
Tag.objects.get_or_create(
name=user.get_full_name(),
defaults={'artist': True}
)
return JsonResponse(result.asDict())
def login_(request):
data = request.POST or json.loads(request.body)['body']
email = data['email'].lower()
password = data.get('password')
result = Result()
user = None
if email:
user = authenticate(username=email, password=password)
else:
result.message = 'Please enter an email address'
result.isError = True
if user:
first_name = request.POST.get('first_name')
last_name = request.POST.get('last_name')
if first_name:
user.first_name = first_name
if last_name:
user.last_name = last_name
if not user.is_active:
result.message = 'User account not active'
result.isError = True
else:
result.message = 'Invalid Credentials'
result.isError = True
if result.isError:
return JsonResponse(result.asDict())
login(request, user)
# -- Create an artist tag for them
Tag.objects.get_or_create(name=user.get_full_name(),
defaults={'artist': True})
return JsonResponse(result.asDict())
def getUser(request):
res = Result()
if request.user.is_anonymous():
res.isError = True
res.append(DefaultPrefs)
else:
galleryid = request.GET.get('gallery')
if galleryid is not None:
gallery = Gallery.objects.filter(pk=galleryid, owner=request.user)
if gallery:
res.append(gallery[0].json())
res.isSuccess = True
return JsonResponse(res)
def getUser(request):
res = Result()
if request.user.is_anonymous():
res.isError = True
res.append(DefaultPrefs)
else:
galleryid = request.GET.get('gallery')
if galleryid is not None:
gallery = Gallery.objects.filter(pk=galleryid, owner=request.user)
if gallery:
res.append(gallery[0].json())
res.isSuccess = True
return JsonResponse(res)
def put(request, obj_id):
"""Updates the content of a comment
:param obj_id: ID of comment object
:type obj_id: int
:returns: json
"""
res = Result()
c = Comment.objects.get(pk=obj_id)
content = request.PUT.get('comment', None)
if content:
c.comment = content
c.save()
res.append(commentToJson(c))
res.isSuccess = True
else:
res.isError = True
res.message = "No comment provided"
return JsonResponse(res)
def put(request, obj_id):
"""Updates the content of a comment
:param obj_id: ID of comment object
:type obj_id: int
:returns: json
"""
res = Result()
c = Comment.objects.get(pk=obj_id)
data = request.PUT or json.loads(request.body)['body']
content = data.get('comment', None)
if content:
c.comment = content
c.save()
res.append(commentToJson(c))
else:
res.isError = True
res.message = "No comment provided"
return JsonResponse(res.asDict())
def put(request, obj_id):
"""Updates the content of a comment
:param obj_id: ID of comment object
:type obj_id: int
:returns: json
"""
res = Result()
c = Comment.objects.get(pk=obj_id)
content = request.PUT.get('comment', None)
if content:
c.comment = content
c.save()
res.append(commentToJson(c))
res.isSuccess = True
else:
res.isError = True
res.message = "No comment provided"
return JsonResponse(res)
def recordView(request):
res = Result()
data = json.loads(request.body)["body"]
item = getObjectsFromGuids([data["guid"]])
if item:
item = item[0]
created = ViewRecord.objects.get_or_create(
user=request.user, guid=data["guid"]
)[1]
if created:
item.view_count += 1
item.save()
res.append(item.view_count)
else:
res.isError = True
res.message = "No object foudn for guid {}".format(data["guid"])
return JsonResponse(res.asDict())
def commentList(request):
"""Returns a rendered list of comments
:returns: html
"""
if request.method == "POST":
return post(request)
res = Result()
comments = []
guid = request.GET.get("guid", None)
if guid:
obj = getObjectsFromGuids([guid])
if obj:
obj = obj[0]
if obj.AssetType == Image.AssetType:
model = "image"
elif obj.AssetType == Video.AssetType:
model = "video"
elif obj.AssetType == Group.AssetType:
model = "group"
elif obj.AssetType == Marmoset.AssetType:
model = "marmoset"
else:
model = None
if model:
contenttype = ContentType.objects.get(app_label="frog",
model=model)
comments = Comment.objects.filter(object_pk=obj.id,
content_type=contenttype)
else:
res.isError = True
res.message = "Invalid object, could not lookup comments for {}".format(
guid)
for comment in comments:
res.append(commentToJson(comment))
return JsonResponse(res.asDict())
def post(request):
"""Creates a tag object
:param name: Name for tag
:type name: str
:returns: json
"""
res = Result()
data = json.loads(request.body)["body"]
name = data.get("name", None)
if not name:
res.isError = True
res.message = "No name given"
return JsonResponse(res.asDict())
tag = Tag.objects.get_or_create(name=name.lower())[0]
res.append(tag.json())
return JsonResponse(res.asDict())
def switchArtist(request):
artist = request.POST.get('artist', None)
guids = request.POST.get('guids', '').split(',')
res = Result()
if artist:
first, last = artist.lower().split(' ')
author = User.objects.get_or_create(first_name=first, last_name=last, defaults={
'username': '******' % (first[0], last),
})[0]
tag = Tag.objects.get_or_create(name=artist.lower(), defaults={'artist': True})[0]
objects = getObjectsFromGuids(guids)
for n in objects:
n.author = author
n.tagArtist(tag)
res.isSuccess = True
res.append(userToJson(author))
res.value['tag'] = Tag.objects.get(name=artist.lower()).id
else:
res.isError = True
res.message = "No artist provided"
return JsonResponse(res)
def switchArtist(request):
artist = request.POST.get('artist', None)
guids = request.POST.get('guids', '').split(',')
res = Result()
if artist:
first, last = artist.lower().split(' ')
author = User.objects.get_or_create(first_name=first, last_name=last, defaults={
'username': '******' % (first[0], last),
})[0]
tag = Tag.objects.get_or_create(name=artist.lower(), defaults={'artist': True})[0]
objects = getObjectsFromGuids(guids)
for n in objects:
n.author = author
n.tagArtist(tag)
res.isSuccess = True
res.append(userToJson(author))
res.value['tag'] = Tag.objects.get(name=artist.lower()).id
else:
res.isError = True
res.message = "No artist provided"
return JsonResponse(res)
def upload(request):
res = Result()
uploadfile = request.FILES.get('file')
if uploadfile:
filename = uploadfile.name
path = request.POST.get('path', None)
if path:
foreignPath = path.replace("'", "\"")
else:
foreignPath = filename
galleries = request.POST.get('galleries', '1').split(',')
tags = [
_.strip() for _ in request.POST.get('tags', '').split(',') if _
]
title = request.POST.get('title')
try:
username = request.POST.get('user', False)
if username:
user = User.objects.get(username=username)
else:
user = request.user
uniqueName = request.POST.get(
'uid', models.Piece.getUniqueID(foreignPath, user))
if galleries and models.Gallery.objects.filter(
pk__in=[int(g) for g in galleries], uploads=False):
raise PermissionDenied()
extension = Path(filename).ext.lower()
if extension in models.FILE_TYPES['image']:
model = models.Image
elif extension in models.FILE_TYPES['video']:
model = models.Video
else:
raise MediaTypeError(
'{} is not a supported file type'.format(extension))
obj, created = model.objects.get_or_create(
unique_id=uniqueName, defaults={'author': user})
guid = obj.getGuid()
hashVal = getHashForFile(uploadfile)
if hashVal == obj.hash:
for gal in galleries:
g = models.Gallery.objects.get(pk=int(gal))
obj.gallery_set.add(g)
res.append(obj.json())
res.message = "Files were the same"
return JsonResponse(res.asDict())
objPath = models.ROOT
if models.FROG_PATH:
objPath = objPath / models.FROG_PATH
objPath = objPath / guid.guid[-2:] / guid.guid / filename
hashPath = objPath.parent / hashVal + objPath.ext
if not objPath.parent.exists():
objPath.parent.makedirs()
handle_uploaded_file(hashPath, uploadfile)
obj.hash = hashVal
obj.foreign_path = foreignPath
obj.title = title or objPath.namebase
obj.export(hashVal, hashPath, tags=tags, galleries=galleries)
res.append(obj.json())
for key, uploadfile in request.FILES.items():
if key != 'file':
dest = objPath.parent / uploadfile.name
handle_uploaded_file(dest, uploadfile)
except MediaTypeError as err:
res.isError = True
res.message = str(err)
return JsonResponse(res.asDict())
else:
res.isError = True
res.message = "No file found"
return JsonResponse(res.asDict())
def upload(request):
res = Result()
uploadfile = request.FILES.get('file')
if uploadfile:
filename = uploadfile.name
path = request.POST.get('path', None)
if path:
foreignPath = path.replace("'", "\"")
else:
foreignPath = filename
galleries = request.POST.get('galleries', '1').split(',')
tags = [_.strip() for _ in request.POST.get('tags', '').split(',') if _]
title = request.POST.get('title')
try:
username = request.POST.get('user', False)
if username:
user = User.objects.get(username=username)
else:
user = request.user
uniqueName = request.POST.get('uid', models.Piece.getUniqueID(foreignPath, user))
if galleries and models.Gallery.objects.filter(pk__in=[int(g) for g in galleries], uploads=False):
raise PermissionDenied()
extension = Path(filename).ext.lower()
if extension in models.FILE_TYPES['image']:
model = models.Image
elif extension in models.FILE_TYPES['video']:
model = models.Video
else:
raise MediaTypeError('{} is not a supported file type'.format(extension))
obj, created = model.objects.get_or_create(unique_id=uniqueName, defaults={'author': user})
guid = obj.getGuid()
hashVal = getHashForFile(uploadfile)
if hashVal == obj.hash:
for gal in galleries:
g = models.Gallery.objects.get(pk=int(gal))
obj.gallery_set.add(g)
res.append(obj.json())
res.message = "Files were the same"
return JsonResponse(res.asDict())
objPath = models.ROOT
if models.FROG_PATH:
objPath = objPath / models.FROG_PATH
objPath = objPath / guid.guid[-2:] / guid.guid / filename
hashPath = objPath.parent / hashVal + objPath.ext
if not objPath.parent.exists():
objPath.parent.makedirs()
handle_uploaded_file(hashPath, uploadfile)
obj.hash = hashVal
obj.foreign_path = foreignPath
obj.title = title or objPath.namebase
obj.export(hashVal, hashPath, tags=tags, galleries=galleries)
res.append(obj.json())
for key, uploadfile in request.FILES.items():
if key != 'file':
dest = objPath.parent / uploadfile.name
handle_uploaded_file(dest, uploadfile)
except MediaTypeError as err:
res.isError = True
res.message = str(err)
return JsonResponse(res.asDict())
else:
res.isError = True
res.message = "No file found"
return JsonResponse(res.asDict())
def post(request, obj):
try:
data = request.POST or json.loads(request.body)["body"]
except RawPostDataException:
data = request.POST
tags = data.get("tags", "").split(",")
resetthumbnail = data.get("reset-thumbnail", False)
crop = data.get("crop")
res = Result()
for tag in tags:
try:
t = Tag.objects.get(pk=int(tag))
except ValueError:
t, created = Tag.objects.get_or_create(name=tag)
if created:
res.append(t.json())
obj.tags.add(t)
if obj.custom_thumbnail and (crop or request.FILES or resetthumbnail):
try:
os.unlink(getRoot() / obj.custom_thumbnail.name)
except OSError:
pass
if crop:
box = [int(_) for _ in crop]
# -- Handle thumbnail upload
source = Path(obj.source.name)
relativedest = obj.getPath(True) / "{:.0f}{}".format(
time.time(), source.ext
)
dest = getRoot() / relativedest
source = getRoot() / source
if not dest.parent.exists():
dest.parent.makedirs()
source.copy(dest)
obj.custom_thumbnail = relativedest
image = pilImage.open(dest)
# Crop from center
image = image.crop(box)
image.load()
# Resize
image.thumbnail(
(FROG_THUMB_SIZE, FROG_THUMB_SIZE), pilImage.ANTIALIAS
)
image.save(dest)
obj.save()
if request.FILES:
# -- Handle thumbnail upload
f = request.FILES.get("file")
relativedest = obj.getPath(True) / f.name
dest = getRoot() / relativedest
handle_uploaded_file(dest, f)
obj.custom_thumbnail = relativedest
try:
if dest.ext == ".psd":
image = psd_tools.PSDLoad(dest).as_PIL()
else:
image = pilImage.open(dest)
except IOError as err:
res.isError = True
res.message = "{} is not a supported thumbnail image type".format(
f.name
)
return JsonResponse(res.asDict())
box, width, height = cropBox(*image.size)
# Resize
image.thumbnail((width, height), pilImage.ANTIALIAS)
# Crop from center
box = cropBox(*image.size)[0]
image.crop(box).save(dest)
obj.save()
if resetthumbnail:
obj.custom_thumbnail = None
obj.save()
res.value = obj.json()
return JsonResponse(res.asDict())
def upload(request):
res = Result()
uploadfile = request.FILES.get("file")
if uploadfile:
filename = uploadfile.name
path = request.POST.get("path", None)
if path:
foreignPath = path.replace("'", '"')
else:
foreignPath = filename
galleries = request.POST.get("galleries", "1").split(",")
tags = [
_.strip() for _ in request.POST.get("tags", "").split(",") if _
]
title = request.POST.get("title")
description = request.POST.get("description", "")
force = request.POST.get("force")
try:
username = request.POST.get("user", False)
if username:
user = User.objects.get(username=username)
else:
user = request.user
uniqueName = request.POST.get("uid",
Piece.getUniqueID(foreignPath, user))
if galleries and Gallery.objects.filter(
pk__in=[int(g) for g in galleries], uploads=False):
raise PermissionDenied()
extension = Path(filename).ext.lower()
if extension in FILE_TYPES["image"]:
model = Image
elif extension in FILE_TYPES["video"]:
model = Video
elif extension in FILE_TYPES["marmoset"]:
model = Marmoset
else:
raise MediaTypeError(
"{} is not a supported file type".format(extension))
obj, created = model.objects.get_or_create(unique_id=uniqueName,
defaults={
"author": user,
"hidden": False
})
guid = obj.getGuid()
hashVal = getHashForFile(uploadfile)
if hashVal == obj.hash and not force:
for gal in galleries:
g = Gallery.objects.get(pk=int(gal))
obj.gallery_set.add(g)
res.append(obj.json())
res.message = "Files were the same"
return JsonResponse(res.asDict())
objPath = getRoot() / guid.guid[-2:] / guid.guid / filename
hashPath = objPath.parent / hashVal + objPath.ext
if not objPath.parent.exists():
objPath.parent.makedirs()
# Save uploaded files to asset folder
for key, uploadfile in request.FILES.items():
if key == "file":
handle_uploaded_file(hashPath, uploadfile)
else:
dest = objPath.parent / uploadfile.name
handle_uploaded_file(dest, uploadfile)
if key == "thumbnail":
thumbnail = saveAsPng(dest)
# Resize
image = pilImage.open(thumbnail)
width, height = squareCropDimensions(*image.size)
image.thumbnail((width, height), pilImage.ANTIALIAS)
# Crop from center
box = cropBox(*image.size)
image.crop(box).save(thumbnail)
obj.custom_thumbnail = obj.getPath(
True) / thumbnail.name
obj.save()
obj.hash = hashVal
obj.foreign_path = foreignPath
obj.title = title or objPath.namebase
obj.description = description
obj.export(hashVal, hashPath, tags=tags, galleries=galleries)
res.append(obj.json())
except MediaTypeError as err:
res.isError = True
res.message = str(err)
return JsonResponse(res.asDict())
else:
res.isError = True
res.message = "No file found"
return JsonResponse(res.asDict())
