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 get(request, obj_id=None):
"""Lists all tags
:returns: json
"""
res = Result()
if obj_id:
if obj_id == '0':
obj = {
'id': 0,
'name': 'TAGLESS',
'artist': False,
}
else:
obj = get_object_or_404(Tag, pk=obj_id).json()
res.append(obj)
return JsonResponse(res.asDict())
else:
if request.GET.get('count'):
itags = Tag.objects.all().annotate(icount=Count('image'))
vtags = Tag.objects.all().annotate(vcount=Count('video'))
for i, tag in enumerate(itags):
tag.count = itags[i].icount + vtags[i].vcount
res.append(tag.json())
else:
for tag in Tag.objects.all():
res.append(tag.json())
return JsonResponse(res.asDict())
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 manage(request):
if request.method == 'GET':
guids = request.GET.get('guids', '').split(',')
guids = [guid for guid in guids if guid]
objects = getObjectsFromGuids(guids)
ids = [o.id for o in objects]
imgtags = list(Tag.objects.filter(image__id__in=ids).exclude(artist=True))
vidtags = list(Tag.objects.filter(video__id__in=ids).exclude(artist=True))
tags = list(set(imgtags + vidtags))
if request.GET.get('json', False):
res = Result()
data = {
'queries': connection.queries,
}
res.append(data)
return JsonResponse(res.asDict())
return render(request, 'frog/tag_manage.html', {'tags': tags})
else:
res = Result()
data = request.POST or json.loads(request.body)['body']
add = data.get('add', '').split(',')
rem = data.get('rem', '').split(',')
guids = data.get('guids', '').split(',')
add = [a for a in add if a]
rem = [r for r in rem if r]
addList = []
for t in add:
try:
addList.append(int(t))
except ValueError:
tag = Tag.objects.get_or_create(name=t.lower())[0]
tag.save()
addList.append(tag.id)
objects = getObjectsFromGuids(guids)
addTags = Tag.objects.filter(id__in=addList)
remTags = Tag.objects.filter(id__in=rem)
for o in objects:
for a in addTags:
o.tags.add(a)
for r in remTags:
o.tags.remove(r)
res.append(o.json())
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 delete(request, obj_id=None):
"""Removes tags from objects resolved from guids
:param tags: Tags to remove
:type tags: list
:param guids: Guids to remove tags from
:type guids: list
:returns: json
"""
res = Result()
if obj_id:
# -- Delete the tag itself
tag = Tag.objects.get(pk=obj_id)
guids = []
images = Image.objects.filter(tags__id=obj_id)
guids += [_.guid for _ in images]
videos = Video.objects.filter(tags__id=obj_id)
guids += [_.guid for _ in videos]
# -- Remove all tags from objects
_manageTags([tag.id], guids, add=False)
# -- Delete old tags
tag.delete()
else:
tags = [_ for _ in request.DELETE.get('tags', '').split(',') if _]
guids = [_ for _ in request.DELETE.get('guids', '').split(',') if _]
_manageTags(tags, guids, add=False)
return JsonResponse(res.asDict())
def get(request, obj_id=None):
if obj_id:
obj = Gallery.objects.get(pk=obj_id)
if obj.security != Gallery.PUBLIC and request.user.is_anonymous():
return HttpResponseRedirect('/frog/access_denied')
return render(request, 'frog/gallery.html', {'object': obj, 'branding': getBranding()})
else:
res = Result()
flat = bool(request.GET.get('flat'))
if request.user.is_authenticated():
objects = Gallery.objects.filter(Q(security__lte=Gallery.PRIVATE) | Q(owner=request.user))
else:
objects = Gallery.objects.filter(security=Gallery.PUBLIC)
objects = objects.filter(parent__isnull=True)
for obj in objects:
if flat:
res.append({'title': obj.title, 'id': obj.id});
for child in obj.gallery_set.all().order_by('title'):
res.append({'title': '-- %s' % child.title, 'id': child.id});
else:
res.append(obj.json())
return JsonResponse(res.asDict())
def post(request):
""" Create a Gallery """
defaultname = 'New Gallery %i' % Gallery.objects.all().count()
data = request.POST or json.loads(request.body)['body']
title = data.get('title', defaultname)
description = data.get('description', '')
security = int(data.get('security', Gallery.PUBLIC))
parentid = data.get('parent')
if parentid:
parent = Gallery.objects.get(pk=int(parentid))
g, created = parent.gallery_set.get_or_create(title=title)
g.security = parent.security
else:
g, created = Gallery.objects.get_or_create(title=title)
g.security = security
g.description = description
g.owner = request.user
g.save()
res = Result()
res.append(g.json())
res.message = 'Gallery created' if created else ''
return JsonResponse(res.asDict())
def delete(request, obj):
obj.deleted = True
obj.save()
res = Result()
res.append(obj.json())
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)
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 request.FILES:
# -- Handle thumbnail upload
f = request.FILES.get('file')
relativedest = Path(obj.source.name).parent / f.name
dest = getRoot() / relativedest
handle_uploaded_file(dest, f)
obj.custom_thumbnail = relativedest
obj.save()
if resetthumbnail:
obj.custom_thumbnail = None
obj.save()
res.value = obj.json()
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
"""
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())
return JsonResponse(res.asDict())
def userList(request):
res = Result()
for user in User.objects.filter(is_active=True).order_by('first_name'):
res.append(userToJson(user))
return JsonResponse(res.asDict())
def csrf(request):
res = Result()
try:
res.append(request.COOKIES['csrftoken'])
except KeyError:
pass
return JsonResponse(res.asDict())
def isUnique(request):
data = request.POST or json.loads(request.body)['body']
paths = data.get('paths', [])
res = Result()
if data.get('user'):
user = User.objects.get(username=data['user'])
elif request.user.is_anonymous():
raise HttpResponseForbidden
else:
user = request.user
for path in paths:
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)
return JsonResponse(res.asDict())
def get(request, obj_id=None):
if obj_id:
obj = Gallery.objects.get(pk=obj_id)
if obj.security != Gallery.PUBLIC and request.user.is_anonymous():
raise PermissionDenied
else:
res = Result()
flat = bool(request.GET.get('flat'))
if request.user.is_authenticated():
objects = Gallery.objects.filter(Q(security__lte=Gallery.PRIVATE) | Q(owner=request.user))
else:
objects = Gallery.objects.filter(security=Gallery.PUBLIC)
objects = objects.filter(parent__isnull=True)
for obj in objects:
if flat:
res.append({'title': obj.title, 'id': obj.id});
for child in obj.gallery_set.all().order_by('title'):
res.append({'title': '-- %s' % child.title, 'id': child.id});
else:
res.append(obj.json())
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
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)
else:
res.isError = True
res.message = "No path provided"
return JsonResponse(res.asDict())
def commentList(request):
"""Returns a rendered list of comments
:returns: html
"""
if request.method == 'POST':
return post(request)
comments = []
guid = request.GET.get('guid', None)
id = request.GET.get('id', 0)
if guid:
obj = getObjectsFromGuids([guid])[0]
if obj.AssetType == 1:
model = 'image'
else:
model = 'video'
contentType = ContentType.objects.get(app_label="frog", model=model)
comments = Comment.objects.filter(object_pk=obj.id, content_type=contentType)
if request.GET.get('json'):
res = Result()
for comment in comments:
res.append(commentToJson(comment))
return JsonResponse(res.asDict())
return render(request, 'frog/comment_list.html', {'comments': comments, 'guid': guid, 'id': id})
def put(request, obj_id=None):
""" Adds Image and Video objects to Gallery based on GUIDs """
data = request.PUT or json.loads(request.body)['body']
guids = data.get('guids', '').split(',')
move = data.get('from')
security = request.PUT.get('security')
gallery = Gallery.objects.get(pk=obj_id)
if guids:
objects = getObjectsFromGuids(guids)
images = filter(lambda x: isinstance(x, Image), objects)
videos = filter(lambda x: isinstance(x, Video), objects)
gallery.images.add(*images)
gallery.videos.add(*videos)
if move:
fromgallery = Gallery.objects.get(pk=move)
fromgallery.images.remove(*images)
fromgallery.videos.remove(*videos)
if security is not None:
gallery.security = json.loads(security)
gallery.save()
for child in gallery.gallery_set.all():
child.security = gallery.security
child.save()
res = Result()
res.append(gallery.json())
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 getGuids(request):
res = Result()
data = {}
guids = request.GET.get('guids', '').split(',')
for _ in getObjectsFromGuids(guids):
res.append(_.json())
return JsonResponse(res.asDict())
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 put(request, obj):
data = request.POST or json.loads(request.body)['body']
obj.title = data.get('title', obj.title)
obj.description = data.get('description', obj.description)
obj.save()
res = Result()
res.append(obj.json())
return JsonResponse(res.asDict())
def get(request):
"""Gets the currently logged in users preferences
:returns: json
"""
res = Result()
obj, created = UserPref.objects.get_or_create(user=request.user, defaults={'data': json.dumps(DefaultPrefs.copy())})
res.append(obj.json())
return JsonResponse(res.asDict())
def get(request, obj_id):
"""Returns a serialized object
:param obj_id: ID of comment object
:type obj_id: int
:returns: json
"""
res = Result()
c = Comment.objects.get(pk=obj_id)
res.append(commentToJson(c))
return JsonResponse(res.asDict())
def releaseNotes(request):
res = Result()
lastid = request.GET.get('lastid', 0)
today = datetime.datetime.today()
relevent = today - datetime.timedelta(days=30)
notes = ReleaseNotes.objects.filter(date__gte=relevent, pk__gt=lastid).order_by('-id')
for note in notes:
res.append(note.json())
return JsonResponse(res.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 get(request, obj_id=None):
"""Lists all tags
:returns: json
"""
res = Result()
if obj_id:
if obj_id == '0':
obj = {
'id': 0,
'name': 'TAGLESS',
'artist': False,
}
else:
obj = get_object_or_404(Tag, pk=obj_id).json()
res.append(obj)
return JsonResponse(res.asDict())
else:
for n in Tag.objects.all():
res.append(n.json())
return JsonResponse(res.asDict())
def get(request):
"""Gets the currently logged in users preferences
:returns: json
"""
res = Result()
obj, created = UserPref.objects.get_or_create(user=request.user, defaults={'data': json.dumps(DefaultPrefs.copy())})
data = obj.json()
data['subscriptions'] = [_.json() for _ in GallerySubscription.objects.filter(user=request.user)]
res.append(data)
return JsonResponse(res.asDict())
def merge(request, obj_id):
"""Merges multiple tags into a single tag and all related objects are reassigned"""
res = Result()
if request.POST:
tags = json.loads(request.POST["tags"])
else:
tags = json.loads(request.body)["body"]["tags"]
guids = []
images = Image.objects.filter(tags__id__in=tags)
guids += [_.guid for _ in images]
videos = Video.objects.filter(tags__id__in=tags)
guids += [_.guid for _ in videos]
# -- Remove all tags from objects
_manageTags(tags, guids, add=False)
# -- Add merged tag to all objects
_manageTags([obj_id], guids, add=True)
# -- Delete old tags
Tag.objects.filter(pk__in=tags).delete()
return JsonResponse(res.asDict())
def post(request):
""" Create a Gallery """
defaultname = "New Gallery %i" % Gallery.objects.all().count()
data = json.loads(request.body)["body"]
title = data.get("title", defaultname)
description = data.get("description", "")
security = int(
data.get("security",
request.user.frog_prefs.first().clearance))
g, created = Gallery.objects.get_or_create(title=title)
g.security = security
g.description = description
g.owner = request.user
g.save()
res = Result()
res.append(g.json())
res.message = "Gallery created" if created else ""
return JsonResponse(res.asDict())
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 get(request, obj_id=None):
if obj_id:
obj = Gallery.objects.get(pk=obj_id)
if obj.security != Gallery.PUBLIC and request.user.is_anonymous:
raise PermissionDenied
else:
res = Result()
personal = []
clearance = Gallery.PUBLIC
if request.user.is_authenticated:
personal = Gallery.objects.filter(security=Gallery.PERSONAL,
owner=request.user)
try:
clearance = request.user.frog_prefs.first().clearance
except AttributeError:
clearance = Gallery.PUBLIC
# Staff members should see everything
if request.user.is_staff:
clearance = Gallery.GUARDED
objects = Gallery.objects.filter(security__lte=clearance)
ids = []
for gallery in objects:
if gallery.security == Gallery.PERSONAL:
continue
if gallery.id in ids:
continue
ids.append(gallery.id)
res.append(gallery.json())
for gallery in personal:
res.append(gallery.json())
return JsonResponse(res.asDict())
def commentList(request):
"""Returns a rendered list of comments
:returns: html
"""
if request.method == 'POST':
return post(request)
comments = []
guid = request.GET.get('guid', None)
if guid:
obj = getObjectsFromGuids([guid])[0]
if obj.AssetType == 1:
model = 'image'
else:
model = 'video'
contenttype = ContentType.objects.get(app_label="frog", model=model)
comments = Comment.objects.filter(object_pk=obj.id, content_type=contenttype)
res = Result()
for comment in comments:
res.append(commentToJson(comment))
return JsonResponse(res.asDict())
def put(request, obj_id=None):
"""Adds tags from objects resolved from guids
:param tags: Tags to add
:type tags: list
:param guids: Guids to add tags from
:type guids: list
:returns: json
"""
res = Result()
data = json.loads(request.body)["body"]
if obj_id:
# -- Edit the tag
tag = Tag.objects.get(pk=obj_id)
tag.name = data.get("name", tag.name)
tag.artist = data.get("artist", tag.artist)
tag.save()
else:
tags = [_ for _ in data.get("tags", "").split(",") if _]
guids = [_ for _ in data.get("guids", "").split(",") if _]
_manageTags(tags, guids)
return JsonResponse(res.asDict())
def put(request, obj_id=None):
"""Adds tags from objects resolved from guids
:param tags: Tags to add
:type tags: list
:param guids: Guids to add tags from
:type guids: list
:returns: json
"""
res = Result()
data = request.PUT or json.loads(request.body)['body']
if obj_id:
# -- Edit the tag
tag = Tag.objects.get(pk=obj_id)
tag.name = data.get('name', tag.name)
tag.artist = data.get('artist', tag.artist)
tag.save()
else:
tags = [_ for _ in data.get('tags', '').split(',') if _]
guids = [_ for _ in data.get('guids', '').split(',') if _]
_manageTags(tags, guids)
return JsonResponse(res.asDict())
def _filter(request, object_, tags=None, more=False, orderby="created"):
"""Filters Piece objects from self based on filters, search, and range
:param tags: List of tag IDs to filter
:type tags: list
:param more -- bool, Returns more of the same filtered set of images based on session range
return list, Objects filtered
"""
res = Result()
idDict = {}
objDict = {}
data = {}
modelmap = {}
# Get all IDs for each model
for m in QUERY_MODELS:
modelmap[m.model_class()] = m.model
if object_:
idDict[m.model] = m.model_class().objects.filter(gallery=object_)
else:
idDict[m.model] = m.model_class().objects.all()
if idDict[m.model] is None:
continue
if tags:
for bucket in tags:
searchQuery = ""
o = None
for item in bucket:
if item == 0:
# filter by tagless
idDict[m.model].annotate(num_tags=Count("tags"))
if not o:
o = Q()
o |= Q(num_tags__lte=1)
break
elif isinstance(item, six.integer_types):
# filter by tag
if not o:
o = Q()
o |= Q(tags__id=item)
else:
# add to search string
searchQuery += item + " "
if not HAYSTACK:
if not o:
o = Q()
# use a basic search
o |= Q(title__icontains=item)
if HAYSTACK and searchQuery != "":
# once all tags have been filtered, filter by search
searchIDs = search(searchQuery, m.model_class())
if searchIDs:
if not o:
o = Q()
o |= Q(id__in=searchIDs)
if o:
# apply the filters
idDict[m.model] = (idDict[m.model].annotate(
num_tags=Count("tags")).filter(o))
else:
idDict[m.model] = idDict[m.model].none()
# Remove hidden items before slicing so we get an accurate count
idDict[m.model] = idDict[m.model].exclude(hidden=True)
# Remove deleted items before slicing so we get an accurate count
idDict[m.model] = idDict[m.model].exclude(deleted=True)
# Get all ids of filtered objects, this will be a very fast query
idDict[m.model] = list(idDict[m.model].order_by(
"-{}".format(orderby)).values_list("id", flat=True))
lastid = request.session.get("last_{}".format(m.model), 0)
if not idDict[m.model]:
continue
if not more:
lastid = idDict[m.model][0]
try:
index = idDict[m.model].index(lastid)
except ValueError:
index = 0
if more and lastid != 0:
index += 1
idDict[m.model] = idDict[m.model][index:index + BATCH_LENGTH]
# perform the main query to retrieve the objects we want
objDict[m.model] = m.model_class().objects.filter(
id__in=idDict[m.model])
objDict[m.model] = (objDict[m.model].select_related(
"author").prefetch_related("tags").order_by("-{}".format(orderby)))
objDict[m.model] = list(objDict[m.model])
# combine and sort all objects by date
objects = _sortObjects(orderby, **objDict)
objects = objects[:BATCH_LENGTH]
# Find out last ids
lastids = {}
for obj in objects:
lastids["last_{}".format(modelmap[obj.__class__])] = obj.id
for key, value in lastids.items():
request.session[key] = value
# serialize objects
for i in objects:
res.append(i.json())
data["count"] = len(objects)
if settings.DEBUG:
data["queries"] = connection.queries
res.value = data
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 = source.parent / '{:.0f}{}'.format(
time.time(), source.ext)
dest = getRoot() / relativedest
source = getRoot() / source
source.copy(dest)
obj.custom_thumbnail = relativedest
image = pilImage.open(dest)
# Crop from center
image = image.crop(box)
image.load()
# Resize
size = abs(box[2] - box[0])
image.thumbnail((FROG_THUMB_SIZE, FROG_THUMB_SIZE), pilImage.ANTIALIAS)
image.resize((size, size)).save(dest)
obj.save()
if request.FILES:
# -- Handle thumbnail upload
f = request.FILES.get('file')
relativedest = Path(obj.source.name).parent / f.name
dest = getRoot() / relativedest
handle_uploaded_file(dest, f)
obj.custom_thumbnail = relativedest
image = pilImage.open(dest)
sizeinterface = namedtuple('sizeinterface', 'width,height')
size = sizeinterface(*image.size)
box, width, height = cropBox(size)
# Resize
image.thumbnail((width, height), pilImage.ANTIALIAS)
# Crop from center
image.crop(box).save(dest)
obj.save()
if resetthumbnail:
obj.custom_thumbnail = None
obj.save()
res.value = obj.json()
return JsonResponse(res.asDict())
def _filter(request,
object_,
tags=None,
models=(Image, Video),
more=False,
orderby='created'):
"""Filters Piece objects from self based on filters, search, and range
:param tags: List of tag IDs to filter
:type tags: list
:param models: List of model classes to filter on
:type models: list
:param more -- bool, Returns more of the same filtered set of images based on session range
return list, Objects filtered
"""
res = Result()
idDict = {}
objDict = {}
data = {}
length = 300
if more:
# -- This is a request for more results
mult = request.session.get('mult', 0) + 1
request.session['mult'] = mult
else:
mult = 0
request.session['mult'] = 0
start = length * mult
end = start + length
LOGGER.debug('{} : {}'.format(start, end))
# -- Gat all IDs for each model
for m in models:
idDict[m.model] = m.model_class().objects.filter(gallery=object_)
if tags:
for bucket in tags:
searchQuery = ""
o = None
for item in bucket:
if item == 0:
# -- filter by tagless
idDict[m.model].annotate(num_tags=Count('tags'))
if not o:
o = Q()
o |= Q(num_tags__lte=1)
break
elif isinstance(item, six.integer_types):
# -- filter by tag
if not o:
o = Q()
o |= Q(tags__id=item)
else:
# -- add to search string
searchQuery += item + ' '
if not HAYSTACK:
if not o:
o = Q()
# -- use a basic search
o |= Q(title__icontains=item)
if HAYSTACK and searchQuery != "":
# -- once all tags have been filtered, filter by search
searchIDs = search(searchQuery, m.model_class())
if searchIDs:
if not o:
o = Q()
o |= Q(id__in=searchIDs)
if o:
# -- apply the filters
idDict[m.model] = idDict[m.model].annotate(
num_tags=Count('tags')).filter(o)
else:
idDict[m.model] = idDict[m.model].none()
# -- Get all ids of filtered objects, this will be a very fast query
idDict[m.model] = list(idDict[m.model].order_by(
'-{}'.format(orderby))[:end].values_list('id', flat=True))
# -- perform the main query to retrieve the objects we want
objDict[m.model] = m.model_class().objects.filter(
id__in=idDict[m.model]).select_related('author').prefetch_related(
'tags').order_by('-{}'.format(orderby))
objDict[m.model] = objDict[m.model][start:end]
objDict[m.model] = list(objDict[m.model])
# -- combine and sort all objects by date
objects = _sortObjects(orderby, **
objDict) if len(models) > 1 else objDict.values()[0]
objects = objects[:length]
# -- serialize objects
for i in objects:
res.append(i.json())
data['count'] = len(objects)
if settings.DEBUG:
data['queries'] = connection.queries
res.value = data
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())
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 siteConfig(request):
res = Result()
res.append(getSiteConfig())
return JsonResponse(res.asDict())
def get(request):
res = Result()
res.append(SiteConfig.getSiteConfig().json())
return JsonResponse(res.asDict())
