def post_movie(token):
post_data = request.get_json()
if 'title' in post_data and 'release_date' in post_data:
try:
new_movie = Movies(title=post_data['title'],
release_date=post_data['release_date'])
if 'actors' in post_data:
actors_list = post_data['actors']
for actor in actors_list:
actor_id = actor['id']
actor_data = Actors.query.get(actor_id)
if actor_data:
movie_set = Sets(movie_id=new_movie.id,
actor_id=actor_id)
movie_set.insert()
new_movie.insert()
return jsonify({
'id': new_movie.id,
'success': True
})
except SQLAlchemyError:
print(sys.exc_info())
db.session.rollback()
abort(400)
abort(400)
def patch_movie(token, movie_id):
movie = Movies.query.get(movie_id)
if not movie:
abort(404)
if request.method == 'PATCH':
post_data = request.get_json()
if 'title' in post_data:
movie.title = post_data.get('title')
if 'release_date' in post_data:
movie.release_date = post_data.get('release_date')
if 'actors' in post_data:
actors_list = post_data['actors'] # list of actors for this movie
for actor_id in actors_list:
actor_data = Actors.query.get(actor_id)
if actor_data:
movie_set = Sets(movie_id=movie.id, actor_id=actor_id)
movie_set.insert()
try:
movie.update()
return jsonify({
'id': movie.id,
'success': True
})
except SQLAlchemyError:
db.session.rollback()
abort(400)
def steperr(row, set_iter, e):
# set_model[set_iter][1] = Status.ERROR #active
set_model[set_iter][7] += 1
Sets.update(error=set_model[set_iter][7]).where(
Sets.id == row['set']).execute()
Urls.update(status=str(e)).where(
Urls.id == row['id']).execute()
def on_set_delete_activated(self, widget, view):
selection = view.get_selection()
model, paths = selection.get_selected_rows()
for path in paths:
iter = model.get_iter(path)
id = model[iter][0]
#
tarname = make_tarname(model[iter][2])
tarpath = pathlib.Path(CONFIG['save_location'], tarname)
target = pathlib.Path(CONFIG['complete_path'], tarname)
# tarpath = os.path.join(CONFIG['save_location'], tarname)
if tarpath.is_file():
try:
if target.exists():
raise Exception(f'target already exist: {target}')
tarpath.replace(target)
# shutil.move(tarpath, CONFIG['complete_path'])
Sets.delete().where(Sets.id == id).execute()
Urls.delete().where(Urls.set_id == id).execute()
model.remove(iter)
print(target)
except Exception as e:
print(e)
else:
Sets.delete().where(Sets.id == id).execute()
Urls.delete().where(Urls.set_id == id).execute()
model.remove(iter)
def load_sets(self):
if CONFIG['filter']:
qu = Sets.select().where(Sets.setname**f"%{CONFIG['filter']}%")
else:
qu = Sets.select()
for i, q in enumerate(qu, start=1):
self.append((q.id, Status.SLEEP, q.setname, q.host, q.done,
q.count, i, q.error))
def init_sets(self, model):
# i = 1
if CONFIG['filter']:
qu = Sets.select().where(Sets.setname**f"%{CONFIG['filter']}%")
else:
qu = Sets.select()
# qu = DownList.select(DownList, fn.COUNT(DownList.id).alias('m_count')).order_by(DownList.id).group_by(DownList.uid).objects()
for i, q in enumerate(qu, start=1):
# host = urlparse(q.raw)[1]
model.append((q.id, Status.SLEEP, q.setname, q.host, q.done,
q.count, i, q.error))
def finish(self, set_iter, row, tarpath):
set_model[set_iter][4] += 1
count = set_model[set_iter][5]
done = set_model[set_iter][4]
Sets.update(done=done).where(Sets.id == row['set']).execute()
if done == count:
set_model.remove(set_iter)
# move file
shutil.move(tarpath, CONFIG['complete_path'])
# clean set in db
Sets.delete().where(Sets.id == row['set']).execute()
# register archive database?
Urls.delete().where(Urls.id == row['id']).execute()
def sets_query(id):
if request.method == 'GET':
get_sets = session.query(Sets).filter_by(id=id).first()
if not get_sets:
set_error = jsonify(
{"Error": "No sets with id {} found".format(id)})
set_error.error_code = 400
else:
set_error = jsonify({
"id": str(get_sets.id),
"lift": str(get_sets.lift),
"set_ord": str(get_sets.set_ord),
"set_count": str(get_sets.set_count),
"rep_count": str(get_sets.rep_count),
"weight": str(get_sets.weight),
"warm_up": get_sets.warm_up,
"notes": get_sets.notes
})
return set_error
elif request.method == 'DELETE':
delete_set = session.query(Sets).filter_by(id=id).first()
session.query(Sets).filter_by(id=id).delete()
session.commit()
return jsonify({
"id": str(delete_set.id),
"lift": str(delete_set.lift),
"set_ord": str(delete_set.set_ord),
"set_count": str(delete_set.set_count),
"rep_count": str(delete_set.rep_count),
"weight": str(delete_set.weight),
"warm_up": delete_set.warm_up,
"notes": delete_set.notes
})
elif request.method == 'PUT':
put_set = session.query(Sets).filter_by(id=id).first()
set_req = request.get_json(force=True)
updated_sets = session.query(Sets) \
.filter_by(id=id).update(set_req)
session.commit()
return jsonify({
"id": str(put_set.id),
"lift": str(put_set.lift),
"set_ord": str(put_set.set_ord),
"set_count": str(put_set.set_count),
"rep_count": str(put_set.rep_count),
"weight": str(put_set.weight),
"warm_up": put_set.warm_up,
"notes": put_set.notes
})
elif request.method == 'POST':
post_set = session.query(Sets).first()
new_set = request.get_json(force=True)
set_result = Sets(lift=new_set["lift"], set_ord=new_set["set_ord"] \
, set_count=new_set["set_count"], rep_count=new_set["rep_count"] \
, weight=new_set["weight"], warm_up=new_set["warm_up"] \
, notes=new_set["notes"])
session.add(set_result)
session.commit
return jsonify({
"id": str(set_result.id),
"lift": str(set_result.lift),
"set_ord": str(set_result.set_ord),
"set_count": str(set_result.set_count),
"rep_count": str(set_result.rep_count),
"weight": str(set_result.weight),
"warm_up": set_result.warm_up,
"notes": set_result.notes
})
# create db session
Session = sessionmaker(db)
session = Session()
# connect to the PostgreSQL server
print('Connecting to the PostgreSQL database...')
# create
leg_day = Workouts(id=1, day='2017-2-3')
squats = Lifts(id=2,
workout=0,
warm_up=True,
name="Squat",
lift_ord=1,
workout_ord=1)
set_rep = Sets(id=3, lift=0, set_count=1, rep_count=1, weight=200, lift_ord=1)
session.add(leg_day)
session.add(squats)
session.add(set_rep)
# read
workouts = session.query(Workouts)
for workout in workouts:
print(workout.day)
swole = session.query(Lifts)
for get in swole:
print(get.name)
huge = session.query(Sets)
for makeme in huge: