def person(person_id):
if request.method == 'GET':
if person_id is not None:
p = session.query(Person).get(person_id)
return jsonify(AjaxResult(True, '{0} retrieved successfully'.format(p.Name), p.to_json()).to_json())
else:
return jsonify(AjaxResult(False, 'No person was found'))
if request.method == 'DELETE':
p = session.query(Person).get(person_id)
session.delete(p)
session.commit()
return jsonify({'result': 'Person deleted successfully'})
if request.method == 'PUT':
p = session.query(Person).get(person_id)
if request.form['name'] is not None and request.form['name'] != '':
p.Name = request.form['name']
if request.form['facebook'] is not None and request.form['facebook'] != '':
p.FacebookUserName = request.form['facebook']
if request.form['instagram'] is not None and request.form['instagram'] != '':
p.InstagramUserName = request.form['instagram']
if request.form['twitter'] is not None and request.form['twitter'] != '':
p.TwitterUserName = request.form['twitter']
session.commit()
return jsonify(AjaxResult(True, 'Person updated successfully!').to_json())
def index():
req_tags = None
req_people = None
orderby = None
favorites = False
tags = []
people = []
if request.args.get('tags') is not None:
req_tags = request.args.getlist('tags')
if request.args.get('person') is not None:
req_people = request.args.getlist('person')
for p in req_people:
people.append(session.query(Person).get(p))
if request.args.get('orderBy') is not None:
orderby = request.args.get('orderBy')
if request.args.get('favorites') is not None:
favorites = request.args.get('favorites')
if request.args.get('next') is not None:
page = int(request.args.get('next'))
elif request.args.get('previous') is not None:
page = int(request.args.get('previous'))
elif request.args.get('first') is not None:
page = int(request.args.get('first'))
elif request.args.get('last') is not None:
page = int(request.args.get('last'))
else:
page = int(request.args.get('currentPage'))
query = build_query(req_tags, req_people, orderby, favorites, int(page))
p_query = query[:-(len(query) - query.index('LIMIT'))]
pages = math.ceil(
len(session.query(Image).from_statement(text(p_query)).all()) / 50)
if page > pages:
page = pages
query = build_query(req_tags, req_people, orderby, favorites, int(page))
new_imgs = session.query(Image).from_statement(text(query)).all()
ajax = {
'template': render_template('main/includes/viewImages.jade', title='Search For Images',
images=new_imgs, tags=tags,
people=people,
orderby=orderby,
favorites=favorites,
page=page,
pages=pages),
'page': page,
'pages': pages
}
return jsonify(ajax)
def __init__(self, avg=None, median=None, mode=None, stddev=None, var=None, lower=None, higher=None,
top_people=None):
super().__init__(avg, median, mode, stddev, var, lower, higher)
if top_people is None:
top_people = []
self.People = session.query(Person).filter(Person.Images.any()).count()
self.Images = Stats.get_images_with_people()
self.TopPeople = top_people
def image(image_id):
if request.method == 'GET':
img = session.query(Image).get(image_id)
img.Tags.sort(key=lambda x: x.TagName)
return render_template('images/editImage.jade', title='Edit Image', img=img)
if request.method == 'DELETE':
img = session.query(Image).get(image_id)
img_path = os.path.join(config.STORAGE_CONTAINER, img.Image_Name)
# Delete file
if os.path.exists(img_path):
os.remove(img_path)
# Delete record from database
session.query(Image).filter(Image.ImageId == image_id).delete()
session.commit()
engine.execute('DELETE FROM images_tags WHERE ImageId = {0}'.format(image_id))
engine.execute('DELETE FROM images_people WHERE ImageId = {0}'.format(image_id))
# Delete from images albums
# Delete from images collections
return jsonify(AjaxResult(True, 'Image was deleted successfully').to_json())
def favorite_image():
img_id = request.form.get('imgId')
fav = request.form.get('favorite')
if fav == 'true':
fav = 0
elif fav == 'false':
fav = 1
img = session.query(Image).get(int(img_id))
img.Favorite = fav
session.commit()
return jsonify({'result': fav})
def people():
if request.method == 'GET':
q = request.args.get('q')
if q is None:
p = session.query(Person).order_by(Person.Name).all()
else:
p = session.query(Person).order_by(Person.Name).filter(Person.Name.like('%' + q + '%'))
return jsonify({'people': JsonSerialize.convert_list_to_json(p)})
if request.method == 'POST':
directory = request.form['directory']
result = AjaxResult().to_json()
new_count = 0
folders = os.listdir(directory)
for folder in folders:
# Check if person already exists in database
exists = session.query(Person).filter(Person.Name == folder).count()
# If they don't exist, add them to database
if exists == 0:
p = Person()
p.Name = folder
session.add(p)
session.commit()
new_count += 1
if new_count == 0:
result = {'message': 'No new people were added to the database', 'count': new_count}
elif new_count == 1:
result = {'message': 'One new person was added to the database', 'count': new_count}
else:
result = {'message': '{} new people were added to the database'.format(new_count), 'count': new_count}
return jsonify(result)
def edit_person(person_id):
p = session.query(Person).get(person_id)
img = (session.query(Image).from_statement(text('SELECT * '
'FROM image '
' INNER JOIN images_people '
' ON image.ImageId = images_people.ImageId '
' INNER JOIN person ON images_people.PersonId = person.PersonId '
' WHERE person.PersonId = {0}'
' ORDER BY RANDOM()'.format(person_id))).first()).File_Path
instagram_feed = get_instagram(p.InstagramUserName)
if not instagram_feed:
instagram_feed = []
num_images = Stats.get_images_with_person(p.PersonId)
percentage = Stats.get_images_with_person_percent(p.PersonId)
ranking = Stats.get_person_ranking(p.PersonId)
return render_template('people/editPerson.jade', title='Edit ' + p.Name,
person=p,
instagram=instagram_feed,
img=img,
images=num_images,
percentage=percentage,
ranking=ranking)
def index():
page = request.args.get('page')
person = request.args.get('person')
num_items = 20
if page is None:
page = 1
else:
page = int(page)
if person is None or person == 'None':
query = 'SELECT * FROM person ORDER BY Name LIMIT {0} OFFSET {1}'.format(num_items, (num_items * (page - 1)))
else:
query = 'SELECT * FROM person WHERE Name like "{0}" ORDER BY Name LIMIT {1} OFFSET {2}'\
.format("%" + person + "%", num_items, (num_items * (page - 1)))
p = session.query(Person).from_statement(text(query)).all()
if person is None:
pages = math.ceil(len(session.query(Person).all()) / num_items)
else:
pages = math.ceil(len(p) / num_items)
return render_template('people/people.jade', title='People', people=p, person=person, pages=pages, page=page)
def get_stats_images_people():
query = 'SELECT images_people.PersonId, COUNT(image.ImageId) AS [NumImages]' \
' FROM image' \
' INNER JOIN images_people ON image.ImageId = images_people.ImageId' \
' INNER JOIN person ON images_people.PersonId = person.PersonId' \
' GROUP BY images_people.PersonId' \
' ORDER BY NumImages DESC, person.Name'
result = engine.execute(query)
counts = []
people = []
max = 0
for row in result:
if max < 25:
p = PeopleStats()
rp = session.query(Person).get(int(row[0]))
p.PersonId = rp.PersonId
p.Name = rp.Name
p.Images = (int(row[1]))
p.Percentage = Stats.get_images_with_person_percent(int(row[0]))
people.append(p)
counts.append(int(row[1]))
max += 1
stats = ImageStats()
if max > 0:
stats.Average = statistics.mean(counts)
stats.Median = statistics.median(counts)
try:
stats.Mode = statistics.mode(counts)
except statistics.StatisticsError:
stats.Mode = 'N/A'
stats.StdDev = statistics.pstdev(counts)
stats.Variance = statistics.pvariance(counts)
stats.Lower = stats.Average - (2 * stats.StdDev)
stats.Higher = stats.Average + (2 * stats.StdDev)
stats.TopPeople = people
return stats
def get_image_count():
count = session.query(Image).count()
return jsonify(AjaxResult(True, 'Number of images retrieved', count).to_json())
def index():
t = session.query(Tag).order_by(Tag.TagName).all()
return render_template('tags/tags.jade', title='Tags', tags=t)
def get_images_with_person(person_id):
count = session.query(Image).filter(Image.People.any(Person.PersonId == person_id)).count()
return count
def get_images_with_people():
count = session.query(Image).filter(Image.People.any()).count()
return count
def get_total_people():
count = session.query(Person).count()
return count
def __init__(self, avg=None, median=None, mode=None, stddev=None, var=None, lower=None, higher=None, top_tags=None):
super().__init__(avg, median, mode, stddev, var, lower, higher)
self.Tags = session.query(Tag).filter(Tag.Images.any()).count()
self.Images = Stats.get_images_with_tags()
self.TopTags = top_tags
def get_total_tags():
count = session.query(Tag).count()
return count
def get_images_with_tag(tag_id):
count = session.query(Image).filter(Image.Tags.any(Tag.TagId == tag_id)).count()
return count
def get_images_with_tags():
count = session.query(Image).filter(Image.Tags.any()).count()
return count
def get_total_images():
count = session.query(Image).count()
return count
