Python script, ASCII text executable
1
import json
2
from datetime import datetime
3
from email.policy import default
4
from time import perf_counter
5
import flask
7
from flask_sqlalchemy import SQLAlchemy
8
from flask_bcrypt import Bcrypt
9
from flask_httpauth import HTTPBasicAuth
10
from markupsafe import escape, Markup
11
from flask_migrate import Migrate, current
12
from jinja2_fragments.flask import render_block
13
from sqlalchemy.orm import backref
14
import sqlalchemy.dialects.postgresql
15
from os import path
16
import os
17
from urllib.parse import urlencode
18
import mimetypes
19
import ruamel.yaml as yaml
20
from PIL import Image
22
from sqlalchemy.orm.persistence import post_update
23
import config
25
import markdown
26
app = flask.Flask(__name__)
29
bcrypt = Bcrypt(app)
30
app.config["SQLALCHEMY_DATABASE_URI"] = config.DB_URI
33
app.config["SECRET_KEY"] = config.DB_PASSWORD
34
db = SQLAlchemy(app)
37
migrate = Migrate(app, db)
38
@app.template_filter("split")
41
def split(value, separator=None, maxsplit=-1):
42
return value.split(separator, maxsplit)
43
@app.template_filter("median")
46
def median(value):
47
value = list(value) # prevent generators
48
return sorted(value)[len(value) // 2]
49
@app.template_filter("set")
52
def set_filter(value):
53
return set(value)
54
@app.template_global()
57
def modify_query(**new_values):
58
args = flask.request.args.copy()
59
for key, value in new_values.items():
60
args[key] = value
61
return f"{flask.request.path}?{urlencode(args)}"
63
@app.context_processor
66
def default_variables():
67
return {
68
"current_user": db.session.get(User, flask.session.get("username")),
69
}
70
with app.app_context():
73
class User(db.Model):
74
username = db.Column(db.String(32), unique=True, nullable=False, primary_key=True)
75
password_hashed = db.Column(db.String(60), nullable=False)
76
admin = db.Column(db.Boolean, nullable=False, default=False, server_default="false")
77
pictures = db.relationship("PictureResource", back_populates="author")
78
joined_timestamp = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
79
galleries = db.relationship("Gallery", back_populates="owner")
80
def __init__(self, username, password):
82
self.username = username
83
self.password_hashed = bcrypt.generate_password_hash(password).decode("utf-8")
84
@property
86
def formatted_name(self):
87
if self.admin:
88
return self.username + "*"
89
return self.username
90
class Licence(db.Model):
93
id = db.Column(db.String(64), primary_key=True) # SPDX identifier
94
title = db.Column(db.UnicodeText, nullable=False) # the official name of the licence
95
description = db.Column(db.UnicodeText, nullable=False) # brief description of its permissions and restrictions
96
info_url = db.Column(db.String(1024), nullable=False) # the URL to a page with general information about the licence
97
url = db.Column(db.String(1024), nullable=True) # the URL to a page with the full text of the licence and more information
98
pictures = db.relationship("PictureLicence", back_populates="licence")
99
free = db.Column(db.Boolean, nullable=False, default=False) # whether the licence is free or not
100
logo_url = db.Column(db.String(1024), nullable=True) # URL to the logo of the licence
101
pinned = db.Column(db.Boolean, nullable=False, default=False) # whether the licence should be shown at the top of the list
102
def __init__(self, id, title, description, info_url, url, free, logo_url=None, pinned=False):
104
self.id = id
105
self.title = title
106
self.description = description
107
self.info_url = info_url
108
self.url = url
109
self.free = free
110
self.logo_url = logo_url
111
self.pinned = pinned
112
class PictureLicence(db.Model):
115
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
116
resource_id = db.Column(db.Integer, db.ForeignKey("picture_resource.id"))
118
licence_id = db.Column(db.String(64), db.ForeignKey("licence.id"))
119
resource = db.relationship("PictureResource", back_populates="licences")
121
licence = db.relationship("Licence", back_populates="pictures")
122
def __init__(self, resource, licence):
124
self.resource = resource
125
self.licence = licence
126
class Resource(db.Model):
129
__abstract__ = True
130
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
132
title = db.Column(db.UnicodeText, nullable=False)
133
description = db.Column(db.UnicodeText, nullable=False)
134
timestamp = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
135
origin_url = db.Column(db.String(2048), nullable=True) # should be left empty if it's original or the source is unknown but public domain
136
class PictureNature(db.Model):
139
# Examples:
140
# "photo", "paper-scan", "2d-art-photo", "sculpture-photo", "computer-3d", "computer-painting",
141
# "computer-line-art", "diagram", "infographic", "text", "map", "chart-graph", "screen-capture",
142
# "screen-photo", "pattern", "collage", "ai", and so on
143
id = db.Column(db.String(64), primary_key=True)
144
description = db.Column(db.UnicodeText, nullable=False)
145
resources = db.relationship("PictureResource", back_populates="nature")
146
def __init__(self, id, description):
148
self.id = id
149
self.description = description
150
class PictureObjectInheritance(db.Model):
153
parent_id = db.Column(db.String(64), db.ForeignKey("picture_object.id"),
154
primary_key=True)
155
child_id = db.Column(db.String(64), db.ForeignKey("picture_object.id"),
156
primary_key=True)
157
parent = db.relationship("PictureObject", foreign_keys=[parent_id],
159
back_populates="child_links")
160
child = db.relationship("PictureObject", foreign_keys=[child_id],
161
back_populates="parent_links")
162
def __init__(self, parent, child):
164
self.parent = parent
165
self.child = child
166
class PictureObject(db.Model):
169
id = db.Column(db.String(64), primary_key=True)
170
description = db.Column(db.UnicodeText, nullable=False)
171
child_links = db.relationship("PictureObjectInheritance",
173
foreign_keys=[PictureObjectInheritance.parent_id],
174
back_populates="parent")
175
parent_links = db.relationship("PictureObjectInheritance",
176
foreign_keys=[PictureObjectInheritance.child_id],
177
back_populates="child")
178
def __init__(self, id, description):
180
self.id = id
181
self.description = description
182
class PictureRegion(db.Model):
185
# This is for picture region annotations
186
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
187
json = db.Column(sqlalchemy.dialects.postgresql.JSONB, nullable=False)
188
resource_id = db.Column(db.Integer, db.ForeignKey("picture_resource.id"), nullable=False)
190
object_id = db.Column(db.String(64), db.ForeignKey("picture_object.id"), nullable=True)
191
resource = db.relationship("PictureResource", backref="regions")
193
object = db.relationship("PictureObject", backref="regions")
194
def __init__(self, json, resource, object):
196
self.json = json
197
self.resource = resource
198
self.object = object
199
class PictureResource(Resource):
202
# This is only for bitmap pictures. Vectors will be stored under a different model
203
# File name is the ID in the picture directory under data, without an extension
204
file_format = db.Column(db.String(64), nullable=False) # MIME type
205
width = db.Column(db.Integer, nullable=False)
206
height = db.Column(db.Integer, nullable=False)
207
nature_id = db.Column(db.String(32), db.ForeignKey("picture_nature.id"), nullable=True)
208
author_name = db.Column(db.String(32), db.ForeignKey("user.username"), nullable=False)
209
author = db.relationship("User", back_populates="pictures")
210
nature = db.relationship("PictureNature", back_populates="resources")
212
replaces_id = db.Column(db.Integer, db.ForeignKey("picture_resource.id"), nullable=True)
214
replaced_by_id = db.Column(db.Integer, db.ForeignKey("picture_resource.id"),
215
nullable=True)
216
replaces = db.relationship("PictureResource", remote_side="PictureResource.id",
218
foreign_keys=[replaces_id], back_populates="replaced_by",
219
post_update=True)
220
replaced_by = db.relationship("PictureResource", remote_side="PictureResource.id",
221
foreign_keys=[replaced_by_id], post_update=True)
222
copied_from_id = db.Column(db.Integer, db.ForeignKey("picture_resource.id"), nullable=True)
224
copied_from = db.relationship("PictureResource", remote_side="PictureResource.id",
225
backref="copies", foreign_keys=[copied_from_id])
226
licences = db.relationship("PictureLicence", back_populates="resource")
228
galleries = db.relationship("PictureInGallery", back_populates="resource")
229
def __init__(self, title, author, description, origin_url, licence_ids, mime, nature=None):
231
self.title = title
232
self.author = author
233
self.description = description
234
self.origin_url = origin_url
235
self.file_format = mime
236
self.width = self.height = 0
237
self.nature = nature
238
db.session.add(self)
239
db.session.commit()
240
for licence_id in licence_ids:
241
joiner = PictureLicence(self, db.session.get(Licence, licence_id))
242
db.session.add(joiner)
243
def put_annotations(self, json):
245
# Delete all previous annotations
246
db.session.query(PictureRegion).filter_by(resource_id=self.id).delete()
247
for region in json:
249
object_id = region["object"]
250
picture_object = db.session.get(PictureObject, object_id)
251
region_data = {
253
"type": region["type"],
254
"shape": region["shape"],
255
}
256
region_row = PictureRegion(region_data, self, picture_object)
258
db.session.add(region_row)
259
class PictureInGallery(db.Model):
262
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
263
resource_id = db.Column(db.Integer, db.ForeignKey("picture_resource.id"), nullable=False)
264
gallery_id = db.Column(db.Integer, db.ForeignKey("gallery.id"), nullable=False)
265
resource = db.relationship("PictureResource")
267
gallery = db.relationship("Gallery")
268
def __init__(self, resource, gallery):
270
self.resource = resource
271
self.gallery = gallery
272
class Gallery(db.Model):
275
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
276
title = db.Column(db.UnicodeText, nullable=False)
277
description = db.Column(db.UnicodeText, nullable=False)
278
pictures = db.relationship("PictureInGallery", back_populates="gallery")
279
owner_name = db.Column(db.String(32), db.ForeignKey("user.username"), nullable=False)
280
owner = db.relationship("User", back_populates="galleries")
281
def __init__(self, title, description, owner):
283
self.title = title
284
self.description = description
285
self.owner = owner
286
@app.route("/")
290
def index():
291
return flask.render_template("home.html", resources=PictureResource.query.order_by(db.func.random()).limit(10).all())
292
@app.route("/accounts/")
295
def accounts():
296
return flask.render_template("login.html")
297
@app.route("/login", methods=["POST"])
300
def login():
301
username = flask.request.form["username"]
302
password = flask.request.form["password"]
303
user = db.session.get(User, username)
305
if user is None:
307
flask.flash("This username is not registered.")
308
return flask.redirect("/accounts")
309
if not bcrypt.check_password_hash(user.password_hashed, password):
311
flask.flash("Incorrect password.")
312
return flask.redirect("/accounts")
313
flask.flash("You have been logged in.")
315
flask.session["username"] = username
317
return flask.redirect("/")
318
@app.route("/logout")
321
def logout():
322
flask.session.pop("username", None)
323
flask.flash("You have been logged out.")
324
return flask.redirect("/")
325
@app.route("/signup", methods=["POST"])
328
def signup():
329
username = flask.request.form["username"]
330
password = flask.request.form["password"]
331
if db.session.get(User, username) is not None:
333
flask.flash("This username is already taken.")
334
return flask.redirect("/accounts")
335
if set(username) > set("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_"):
337
flask.flash("Usernames can only contain the Latin alphabet, digits, hyphens, and underscores.")
338
return flask.redirect("/accounts")
339
if len(username) < 3 or len(username) > 32:
341
flask.flash("Usernames must be between 3 and 32 characters long.")
342
return flask.redirect("/accounts")
343
if len(password) < 6:
345
flask.flash("Passwords must be at least 6 characters long.")
346
return flask.redirect("/accounts")
347
user = User(username, password)
349
db.session.add(user)
350
db.session.commit()
351
flask.session["username"] = username
353
flask.flash("You have been registered and logged in.")
355
return flask.redirect("/")
357
@app.route("/profile", defaults={"username": None})
360
@app.route("/profile/<username>")
361
def profile(username):
362
if username is None:
363
if "username" in flask.session:
364
return flask.redirect("/profile/" + flask.session["username"])
365
else:
366
flask.flash("Please log in to perform this action.")
367
return flask.redirect("/accounts")
368
user = db.session.get(User, username)
370
if user is None:
371
flask.abort(404)
372
return flask.render_template("profile.html", user=user)
374
@app.route("/object/<id>")
377
def has_object(id):
378
object_ = db.session.get(PictureObject, id)
379
if object_ is None:
380
flask.abort(404)
381
query = db.session.query(PictureResource).join(PictureRegion).filter(PictureRegion.object_id == id)
383
page = int(flask.request.args.get("page", 1))
385
per_page = int(flask.request.args.get("per_page", 16))
386
resources = query.paginate(page=page, per_page=per_page)
388
return flask.render_template("object.html", object=object_, resources=resources, page_number=page,
390
page_length=per_page, num_pages=resources.pages, prev_page=resources.prev_num,
391
next_page=resources.next_num, PictureRegion=PictureRegion)
392
@app.route("/upload")
395
def upload():
396
if "username" not in flask.session:
397
flask.flash("Log in to upload pictures.")
398
return flask.redirect("/accounts")
399
licences = Licence.query.order_by(Licence.free.desc(), Licence.pinned.desc(), Licence.title).all()
401
types = PictureNature.query.all()
403
return flask.render_template("upload.html", licences=licences, types=types)
405
@app.route("/upload", methods=["POST"])
408
def upload_post():
409
title = flask.request.form["title"]
410
description = flask.request.form["description"]
411
origin_url = flask.request.form["origin_url"]
412
author = db.session.get(User, flask.session.get("username"))
413
licence_ids = flask.request.form.getlist("licence")
414
nature_id = flask.request.form["nature"]
415
if author is None:
417
flask.abort(401)
418
file = flask.request.files["file"]
420
if not file or not file.filename:
422
flask.flash("Select a file")
423
return flask.redirect(flask.request.url)
424
if not file.mimetype.startswith("image/"):
426
flask.flash("Only images are supported")
427
return flask.redirect(flask.request.url)
428
if not title:
430
flask.flash("Enter a title")
431
return flask.redirect(flask.request.url)
432
if not description:
434
description = ""
435
if not nature_id:
437
flask.flash("Select a picture type")
438
return flask.redirect(flask.request.url)
439
if not licence_ids:
441
flask.flash("Select licences")
442
return flask.redirect(flask.request.url)
443
licences = [db.session.get(Licence, licence_id) for licence_id in licence_ids]
445
if not any(licence.free for licence in licences):
446
flask.flash("Select at least one free licence")
447
return flask.redirect(flask.request.url)
448
resource = PictureResource(title, author, description, origin_url, licence_ids, file.mimetype,
450
db.session.get(PictureNature, nature_id))
451
db.session.add(resource)
452
db.session.commit()
453
file.save(path.join(config.DATA_PATH, "pictures", str(resource.id)))
454
pil_image = Image.open(path.join(config.DATA_PATH, "pictures", str(resource.id)))
455
resource.width, resource.height = pil_image.size
456
db.session.commit()
457
if flask.request.form.get("annotations"):
459
try:
460
resource.put_annotations(json.loads(flask.request.form.get("annotations")))
461
db.session.commit()
462
except json.JSONDecodeError:
463
flask.flash("Invalid annotations")
464
flask.flash("Picture uploaded successfully")
466
return flask.redirect("/picture/" + str(resource.id))
468
@app.route("/picture/<int:id>/")
471
def picture(id):
472
resource = db.session.get(PictureResource, id)
473
if resource is None:
474
flask.abort(404)
475
image = Image.open(path.join(config.DATA_PATH, "pictures", str(resource.id)))
477
current_user = db.session.get(User, flask.session.get("username"))
479
have_permission = current_user and (current_user == resource.author or current_user.admin)
480
return flask.render_template("picture.html", resource=resource,
482
file_extension=mimetypes.guess_extension(resource.file_format),
483
size=image.size, copies=resource.copies, have_permission=have_permission)
484
@app.route("/picture/<int:id>/annotate")
488
def annotate_picture(id):
489
resource = db.session.get(PictureResource, id)
490
if resource is None:
491
flask.abort(404)
492
current_user = db.session.get(User, flask.session.get("username"))
494
if current_user is None:
495
flask.abort(401)
496
if resource.author != current_user and not current_user.admin:
497
flask.abort(403)
498
return flask.render_template("picture-annotation.html", resource=resource,
500
file_extension=mimetypes.guess_extension(resource.file_format))
501
@app.route("/picture/<int:id>/put-annotations-form")
504
def put_annotations_form(id):
505
resource = db.session.get(PictureResource, id)
506
if resource is None:
507
flask.abort(404)
508
current_user = db.session.get(User, flask.session.get("username"))
510
if current_user is None:
511
flask.abort(401)
512
if resource.author != current_user and not current_user.admin:
514
flask.abort(403)
515
return flask.render_template("put-annotations-form.html", resource=resource)
517
@app.route("/picture/<int:id>/put-annotations-form", methods=["POST"])
520
def put_annotations_form_post(id):
521
resource = db.session.get(PictureResource, id)
522
if resource is None:
523
flask.abort(404)
524
current_user = db.session.get(User, flask.session.get("username"))
526
if current_user is None:
527
flask.abort(401)
528
if resource.author != current_user and not current_user.admin:
530
flask.abort(403)
531
resource.put_annotations(json.loads(flask.request.form["annotations"]))
533
db.session.commit()
535
return flask.redirect("/picture/" + str(resource.id))
537
@app.route("/picture/<int:id>/save-annotations", methods=["POST"])
541
def save_annotations(id):
542
resource = db.session.get(PictureResource, id)
543
if resource is None:
544
flask.abort(404)
545
current_user = db.session.get(User, flask.session.get("username"))
547
if resource.author != current_user and not current_user.admin:
548
flask.abort(403)
549
resource.put_annotations(flask.request.json)
551
db.session.commit()
553
response = flask.make_response()
555
response.status_code = 204
556
return response
557
@app.route("/picture/<int:id>/get-annotations")
560
def get_annotations(id):
561
resource = db.session.get(PictureResource, id)
562
if resource is None:
563
flask.abort(404)
564
regions = db.session.query(PictureRegion).filter_by(resource_id=id).all()
566
regions_json = []
568
for region in regions:
570
regions_json.append({
571
"object": region.object_id,
572
"type": region.json["type"],
573
"shape": region.json["shape"],
574
})
575
return flask.jsonify(regions_json)
577
@app.route("/picture/<int:id>/delete")
580
def delete_picture(id):
581
resource = db.session.get(PictureResource, id)
582
if resource is None:
583
flask.abort(404)
584
current_user = db.session.get(User, flask.session.get("username"))
586
if current_user is None:
587
flask.abort(401)
588
if resource.author != current_user and not current_user.admin:
590
flask.abort(403)
591
PictureLicence.query.filter_by(resource=resource).delete()
593
PictureRegion.query.filter_by(resource=resource).delete()
594
if resource.replaces:
595
resource.replaces.replaced_by = None
596
if resource.replaced_by:
597
resource.replaced_by.replaces = None
598
resource.copied_from = None
599
for copy in resource.copies:
600
copy.copied_from = None
601
db.session.delete(resource)
602
db.session.commit()
603
return flask.redirect("/")
605
@app.route("/picture/<int:id>/mark-replacement", methods=["POST"])
608
def mark_picture_replacement(id):
609
resource = db.session.get(PictureResource, id)
610
if resource is None:
611
flask.abort(404)
612
current_user = db.session.get(User, flask.session.get("username"))
614
if current_user is None:
615
flask.abort(401)
616
if resource.copied_from.author != current_user and not current_user.admin:
618
flask.abort(403)
619
resource.copied_from.replaced_by = resource
621
resource.replaces = resource.copied_from
622
db.session.commit()
624
return flask.redirect("/picture/" + str(resource.copied_from.id))
626
@app.route("/picture/<int:id>/remove-replacement", methods=["POST"])
629
def remove_picture_replacement(id):
630
resource = db.session.get(PictureResource, id)
631
if resource is None:
632
flask.abort(404)
633
current_user = db.session.get(User, flask.session.get("username"))
635
if current_user is None:
636
flask.abort(401)
637
if resource.author != current_user and not current_user.admin:
639
flask.abort(403)
640
resource.replaced_by.replaces = None
642
resource.replaced_by = None
643
db.session.commit()
645
return flask.redirect("/picture/" + str(resource.id))
647
@app.route("/picture/<int:id>/edit-metadata")
650
def edit_picture(id):
651
resource = db.session.get(PictureResource, id)
652
if resource is None:
653
flask.abort(404)
654
current_user = db.session.get(User, flask.session.get("username"))
656
if current_user is None:
657
flask.abort(401)
658
if resource.author != current_user and not current_user.admin:
660
flask.abort(403)
661
licences = Licence.query.order_by(Licence.free.desc(), Licence.pinned.desc(), Licence.title).all()
663
types = PictureNature.query.all()
665
return flask.render_template("edit-picture.html", resource=resource, licences=licences, types=types,
667
PictureLicence=PictureLicence)
668
@app.route("/picture/<int:id>/edit-metadata", methods=["POST"])
671
def edit_picture_post(id):
672
resource = db.session.get(PictureResource, id)
673
if resource is None:
674
flask.abort(404)
675
current_user = db.session.get(User, flask.session.get("username"))
677
if current_user is None:
678
flask.abort(401)
679
if resource.author != current_user and not current_user.admin:
681
flask.abort(403)
682
title = flask.request.form["title"]
684
description = flask.request.form["description"]
685
origin_url = flask.request.form["origin_url"]
686
licence_ids = flask.request.form.getlist("licence")
687
nature_id = flask.request.form["nature"]
688
if not title:
690
flask.flash("Enter a title")
691
return flask.redirect(flask.request.url)
692
if not description:
694
description = ""
695
if not nature_id:
697
flask.flash("Select a picture type")
698
return flask.redirect(flask.request.url)
699
if not licence_ids:
701
flask.flash("Select licences")
702
return flask.redirect(flask.request.url)
703
licences = [db.session.get(Licence, licence_id) for licence_id in licence_ids]
705
if not any(licence.free for licence in licences):
706
flask.flash("Select at least one free licence")
707
return flask.redirect(flask.request.url)
708
resource.title = title
710
resource.description = description
711
resource.origin_url = origin_url
712
for licence_id in licence_ids:
713
joiner = PictureLicence(resource, db.session.get(Licence, licence_id))
714
db.session.add(joiner)
715
resource.nature = db.session.get(PictureNature, nature_id)
716
db.session.commit()
718
return flask.redirect("/picture/" + str(resource.id))
720
@app.route("/picture/<int:id>/copy")
723
def copy_picture(id):
724
resource = db.session.get(PictureResource, id)
725
if resource is None:
726
flask.abort(404)
727
current_user = db.session.get(User, flask.session.get("username"))
729
if current_user is None:
730
flask.abort(401)
731
new_resource = PictureResource(resource.title, current_user, resource.description, resource.origin_url,
733
[licence.licence_id for licence in resource.licences], resource.file_format,
734
resource.nature)
735
for region in resource.regions:
737
db.session.add(PictureRegion(region.json, new_resource, region.object))
738
db.session.commit()
740
# Create a hard link for the new picture
742
old_path = path.join(config.DATA_PATH, "pictures", str(resource.id))
743
new_path = path.join(config.DATA_PATH, "pictures", str(new_resource.id))
744
os.link(old_path, new_path)
745
new_resource.width = resource.width
747
new_resource.height = resource.height
748
new_resource.copied_from = resource
749
db.session.commit()
751
return flask.redirect("/picture/" + str(new_resource.id))
753
@app.route("/gallery/<int:id>/")
756
def gallery(id):
757
gallery = db.session.get(Gallery, id)
758
if gallery is None:
759
flask.abort(404)
760
return flask.render_template("gallery.html", gallery=gallery)
762
@app.route("/create-gallery")
765
def create_gallery():
766
if "username" not in flask.session:
767
flask.flash("Log in to create galleries.")
768
return flask.redirect("/accounts")
769
return flask.render_template("create-gallery.html")
771
@app.route("/create-gallery", methods=["POST"])
774
def create_gallery_post():
775
if not flask.session.get("username"):
776
flask.abort(401)
777
if not flask.request.form.get("title"):
779
flask.flash("Enter a title")
780
return flask.redirect(flask.request.url)
781
description = flask.request.form.get("description", "")
783
gallery = Gallery(flask.request.form["title"], description, db.session.get(User, flask.session["username"]))
785
db.session.add(gallery)
786
db.session.commit()
787
return flask.redirect("/gallery/" + str(gallery.id))
789
@app.route("/gallery/<int:id>/add-picture", methods=["POST"])
792
def gallery_add_picture(id):
793
gallery = db.session.get(Gallery, id)
794
if gallery is None:
795
flask.abort(404)
796
if "username" not in flask.session:
798
flask.abort(401)
799
if flask.session["username"] != gallery.owner_name and not db.session.get(User, flask.session["username"]).admin:
801
flask.abort(403)
802
picture_id = flask.request.form.get("picture_id")
804
if "/" in picture_id: # also allow full URLs
805
picture_id = picture_id.rstrip("/").rpartition("/")[1]
806
if not picture_id:
807
flask.flash("Select a picture")
808
return flask.redirect("/gallery/" + str(gallery.id))
809
picture_id = int(picture_id)
810
picture = db.session.get(PictureResource, picture_id)
812
if picture is None:
813
flask.flash("Invalid picture")
814
return flask.redirect("/gallery/" + str(gallery.id))
815
if PictureInGallery.query.filter_by(resource=picture, gallery=gallery).first():
817
flask.flash("This picture is already in the gallery")
818
return flask.redirect("/gallery/" + str(gallery.id))
819
db.session.add(PictureInGallery(picture, gallery))
821
db.session.commit()
823
return flask.redirect("/gallery/" + str(gallery.id))
825
def get_picture_query(query_data):
828
query = db.session.query(PictureResource)
829
requirement_conditions = {
831
"has_object": lambda value: PictureResource.regions.any(
832
PictureRegion.object_id.in_(value)),
833
"nature": lambda value: PictureResource.nature_id.in_(value),
834
"licence": lambda value: PictureResource.licences.any(
835
PictureLicence.licence_id.in_(value)),
836
"author": lambda value: PictureResource.author_name.in_(value),
837
"title": lambda value: PictureResource.title.ilike(value),
838
"description": lambda value: PictureResource.description.ilike(value),
839
"origin_url": lambda value: db.func.lower(db.func.substr(
840
PictureResource.origin_url,
841
db.func.length(db.func.split_part(PictureResource.origin_url, "://", 1)) + 4
842
)).in_(value),
843
"above_width": lambda value: PictureResource.width >= value,
844
"below_width": lambda value: PictureResource.width <= value,
845
"above_height": lambda value: PictureResource.height >= value,
846
"below_height": lambda value: PictureResource.height <= value,
847
"before_date": lambda value: PictureResource.timestamp <= datetime.utcfromtimestamp(
848
value),
849
"after_date": lambda value: PictureResource.timestamp >= datetime.utcfromtimestamp(
850
value)
851
}
852
if "want" in query_data:
853
for i in query_data["want"]:
854
requirement, value = list(i.items())[0]
855
condition = requirement_conditions.get(requirement)
856
if condition:
857
query = query.filter(condition(value))
858
if "exclude" in query_data:
859
for i in query_data["exclude"]:
860
requirement, value = list(i.items())[0]
861
condition = requirement_conditions.get(requirement)
862
if condition:
863
query = query.filter(~condition(value))
864
if not query_data.get("include_obsolete", False):
865
query = query.filter(PictureResource.replaced_by_id.is_(None))
866
return query
868
@app.route("/query-pictures")
871
def graphical_query_pictures():
872
return flask.render_template("graphical-query-pictures.html")
873
@app.route("/query-pictures-results")
876
def graphical_query_pictures_results():
877
query_yaml = flask.request.args.get("query", "")
878
yaml_parser = yaml.YAML()
879
query_data = yaml_parser.load(query_yaml) or {}
880
query = get_picture_query(query_data)
881
page = int(flask.request.args.get("page", 1))
883
per_page = int(flask.request.args.get("per_page", 16))
884
resources = query.paginate(page=page, per_page=per_page)
886
return flask.render_template("graphical-query-pictures-results.html", resources=resources, query=query_yaml,
888
page_number=page, page_length=per_page, num_pages=resources.pages,
889
prev_page=resources.prev_num, next_page=resources.next_num)
890
@app.route("/raw/picture/<int:id>")
893
def raw_picture(id):
894
resource = db.session.get(PictureResource, id)
895
if resource is None:
896
flask.abort(404)
897
response = flask.send_from_directory(path.join(config.DATA_PATH, "pictures"), str(resource.id))
899
response.mimetype = resource.file_format
900
return response
902
@app.route("/object/")
905
def graphical_object_types():
906
return flask.render_template("object-types.html", objects=PictureObject.query.all())
907
@app.route("/api/object-types")
910
def object_types():
911
objects = db.session.query(PictureObject).all()
912
return flask.jsonify({object.id: object.description for object in objects})
913
@app.route("/api/query-pictures", methods=["POST"]) # sadly GET can't have a body
916
def query_pictures():
917
offset = int(flask.request.args.get("offset", 0))
918
limit = int(flask.request.args.get("limit", 16))
919
ordering = flask.request.args.get("ordering", "date-desc")
920
yaml_parser = yaml.YAML()
922
query_data = yaml_parser.load(flask.request.data) or {}
923
query = get_picture_query(query_data)
924
match ordering:
926
case "date-desc":
927
query = query.order_by(PictureResource.timestamp.desc())
928
case "date-asc":
929
query = query.order_by(PictureResource.timestamp.asc())
930
case "title-asc":
931
query = query.order_by(PictureResource.title.asc())
932
case "title-desc":
933
query = query.order_by(PictureResource.title.desc())
934
case "random":
935
query = query.order_by(db.func.random())
936
case "number-regions-desc":
937
query = query.order_by(db.func.count(PictureResource.regions).desc())
938
case "number-regions-asc":
939
query = query.order_by(db.func.count(PictureResource.regions).asc())
940
query = query.offset(offset).limit(limit)
942
resources = query.all()
943
json_response = {
945
"date_generated": datetime.utcnow().timestamp(),
946
"resources": [],
947
"offset": offset,
948
"limit": limit,
949
}
950
json_resources = json_response["resources"]
952
for resource in resources:
954
json_resource = {
955
"id": resource.id,
956
"title": resource.title,
957
"description": resource.description,
958
"timestamp": resource.timestamp.timestamp(),
959
"origin_url": resource.origin_url,
960
"author": resource.author_name,
961
"file_format": resource.file_format,
962
"width": resource.width,
963
"height": resource.height,
964
"nature": resource.nature_id,
965
"licences": [licence.licence_id for licence in resource.licences],
966
"replaces": resource.replaces_id,
967
"replaced_by": resource.replaced_by_id,
968
"regions": [],
969
"download": config.ROOT_URL + flask.url_for("raw_picture", id=resource.id),
970
}
971
for region in resource.regions:
972
json_resource["regions"].append({
973
"object": region.object_id,
974
"type": region.json["type"],
975
"shape": region.json["shape"],
976
})
977
json_resources.append(json_resource)
979
return flask.jsonify(json_response)
981
@app.route("/api/picture/<int:id>/")
984
def api_picture(id):
985
resource = db.session.get(PictureResource, id)
986
if resource is None:
987
flask.abort(404)
988
json_resource = {
990
"id": resource.id,
991
"title": resource.title,
992
"description": resource.description,
993
"timestamp": resource.timestamp.timestamp(),
994
"origin_url": resource.origin_url,
995
"author": resource.author_name,
996
"file_format": resource.file_format,
997
"width": resource.width,
998
"height": resource.height,
999
"nature": resource.nature_id,
1000
"licences": [licence.licence_id for licence in resource.licences],
1001
"replaces": resource.replaces_id,
1002
"replaced_by": resource.replaced_by_id,
1003
"regions": [],
1004
"download": config.ROOT_URL + flask.url_for("raw_picture", id=resource.id),
1005
}
1006
for region in resource.regions:
1007
json_resource["regions"].append({
1008
"object": region.object_id,
1009
"type": region.json["type"],
1010
"shape": region.json["shape"],
1011
})
1012
return flask.jsonify(json_resource)
1014
@app.route("/api/licence/")
1017
def api_licences():
1018
licences = db.session.query(Licence).all()
1019
json_licences = {
1020
licence.id: {
1021
"title": licence.title,
1022
"free": licence.free,
1023
"pinned": licence.pinned,
1024
} for licence in licences
1025
}
1026
return flask.jsonify(json_licences)
1028
@app.route("/api/licence/<id>/")
1031
def api_licence(id):
1032
licence = db.session.get(Licence, id)
1033
if licence is None:
1034
flask.abort(404)
1035
json_licence = {
1037
"id": licence.id,
1038
"title": licence.title,
1039
"description": licence.description,
1040
"info_url": licence.info_url,
1041
"legalese_url": licence.url,
1042
"free": licence.free,
1043
"logo_url": licence.logo_url,
1044
"pinned": licence.pinned,
1045
}
1046
return flask.jsonify(json_licence)
1048
@app.route("/api/nature/")
1051
def api_natures():
1052
natures = db.session.query(PictureNature).all()
1053
json_natures = {
1054
nature.id: nature.description for nature in natures
1055
}
1056
return flask.jsonify(json_natures)
1058
@app.route("/api/user/")
1061
def api_users():
1062
offset = int(flask.request.args.get("offset", 0))
1063
limit = int(flask.request.args.get("limit", 16))
1064
users = db.session.query(User).offset(offset).limit(limit).all()
1066
json_users = {
1068
user.username: {
1069
"admin": user.admin,
1070
} for user in users
1071
}
1072
return flask.jsonify(json_users)
1074
@app.route("/api/user/<username>/")
1077
def api_user(username):
1078
user = db.session.get(User, username)
1079
if user is None:
1080
flask.abort(404)
1081
json_user = {
1083
"username": user.username,
1084
"admin": user.admin,
1085
"joined": user.joined_timestamp.timestamp(),
1086
}
1087
return flask.jsonify(json_user)
1089