def delete_message(message_id):
message = Message.query.get_or_404(message_id)
if current_user != message.author and not current_user.is_admin:
abort(403)
db_session.delete(message)
db_session.commit()
return '', 204
def mutate(self, info, title):
book = Book.query.filter_by(title=title).first()
if book is None:
raise Exception('book does not exist in the catalogue!')
db_session.delete(book)
db_session.commit()
return DeleteBook(book=book)
def delete_users(user):
print user
## Checks if the user is an admin
if current_user.is_admin(current_user.username):
u = User.query.filter_by(username=user).first()
us = UserStatistics.query.filter_by(userId=u.id).first()
## Checks if the user tries to delete itself
if current_user.username == u.username:
flash('Sorry, but you cannot delete yourself. Think about those people who love you more than their world mi amigo.')
return redirect(url_for('Users.set_roles'))
# loads the supervisor and deletes the user
load_supervisor = u.supervisor
supervisor = User.query.filter_by(username=load_supervisor).first()
load_supervisees = supervisor.supervisee
print "Load supervisee before split: " + str(load_supervisees)
load_supervisees = load_supervisees.split(' ')
print "Load supervisee after split: " + str(load_supervisees)
load_supervisees.remove(u.username)
supervisor.supervisee = ' '.join(load_supervisees)
print supervisor.supervisee
db_session.delete(u)
db_session.add(supervisor)
db_session.commit()
flash('User Deleted')
return redirect(url_for('Users.set_roles'))
flash('USER UNAUTHORIZED')
return redirect(url_for('Home.show_home'))
def kill():
if request.method == "POST":
book_id = request.json
book = db_session.query(Book).filter_by(id=book_id).first()
db_session.delete(book)
db_session.commit()
return redirect(url_for('odminko'))
def todos(id): """ Need a todo id pased by url, Provide: - /api/todo/x PATCH and DELETE routes PATCH require title, content, done as arg DELETE is without arg """ todo = Todo.query.get(id) if not todo: abort(400) elif request.method == 'PATCH': print todo print request.json # uggly, how to factorise ? if not request.json or not 'content' in request.json or not 'done' in request.json or not 'title' in request.json: abort(400) todo.title = request.json['title'] todo.content = request.json['content'] todo.done = request.json['done'] db_session.add(todo) db_session.commit() return jsonify(ok=todo.serealize) elif request.method == 'DELETE': db_session.delete(todo) db_session.commit() return jsonify(deleted=todo.serealize) else: abort(400)
def edit_preset(id):
error = None
data = Preset.query.get(id)
if data is None:
abort(404)
form = dict(name=data.name,
r_code = data.r_code,
g_code = data.g_code,
b_code = data.b_code,
id = data.id)
if request.method == 'POST':
if 'delete' in request.form:
db_session.delete(data)
db_session.commit()
flash(u'Deleting preset: %s' % data.name)
return redirect(url_for('presets.index'))
elif 'submit' in request.form:
data.name = request.form.get('name', type=str)
data.r_code = request.form.get('r_code', type=int)
data.g_code = request.form.get('g_code', type=int)
data.b_code = request.form.get('b_code', type=int)
db_session.commit()
flash(u'Saving modifications for %s' % data.name)
return redirect(url_for('presets.index'))
else:
flash(u'Nothing changed')
return render_template(url_for('presets.index'))
if request.method == 'GET':
flash(u'Editing preset: %s' % data.name)
return render_template('presets/edit.html',
form=form)
def edit_wifidomo(id):
error = None
data = WiFiDomo.query.get(id)
if data is None:
abort(404)
form = dict(name=data.name,
ip4 = data.ip4,
ip6 = data.ip6,
port = data.port,
mac = data.MAC,
fqdn = data.fqdn,
location = data.locationid,
status = data.status)
if app.debug:
print(data.name)
print(data.ip4)
print(data.ip6)
print(data.fqdn)
print(data.port)
print(data.locationid)
tempList = get_location_list()
if request.method == 'POST':
if 'delete' in request.form:
db_session.delete(data)
db_session.commit()
flash(u'Deleting wifidomo: %s' % data.name)
return redirect(url_for('wifidomos.index'))
elif 'submit' in request.form:
data.name = request.form.get('name', type=str)
data.fqdn = request.form.get('fqdn', type=str)
data.status = request.form.get('status', type=bool)
data.MAC = request.form.get('mac', type=str)
data.ip4 = request.form.get('ip4', type=str)
data.ip6 = request.form.get('ip6', type=str)
data.port = request.form.get('port', type=int)
data.locationid = int(request.form.get('location', type=int))
if app.debug:
print(data.name)
print(data.ip4)
print(data.ip6)
print(data.fqdn)
print(data.locationid)
db_session.commit()
flash(u'Saving modifications for %s' % data.name)
return redirect(url_for('wifidomos.index'))
else:
flash(u'Nothing changed')
return redirect(url_for('wifidomos.index'))
if request.method == 'GET':
flash(u'Editing wifidomo: %s' % data.name)
return render_template('wifidomos/edit.html',
form=form,
wifidomo_locations=tempList)
def delete_payslip(file_name):
user = Payslip.query.filter_by(filename=file_name).first() # Checks the filename to be deleted
db_session.delete(user)
db_session.commit()# and poof
os.remove(current_app.config['UPLOADS_FILES_DEST'] +'//'+ file_name) # Remove it also from its storage
flash('Payslip deleted.')
return redirect(url_for('.payslip_base'))
def delete_movie(id):
movie = Movies.query.get(id)
db_session.delete(movie)
db_session.commit()
return (jsonify(movie.to_json()), 200, {
'Location': url_for('api.get_movie', id=movie.id, _external=True)
})
def delete_task(task_id):
task = Task.query.filter(Task.id == task_id).first()
if task:
db_session.delete(task)
db_session.commit()
return redirect(url_for('planner.show_index'))
else:
abort(404)
def delete_task(task_id):
task = Task.query.filter(Task.id == task_id).first()
if task:
db_session.delete(task)
db_session.commit()
return redirect(url_for('planner.show_index'))
else:
abort(404)
def delete(self, user_id):
if not current_user.is_admin:
abort(403)
user = User.query.get(user_id)
if user.is_admin:
abort(400)
db_session.delete(user)
db_session.commit()
return '', 204
def delete_roles(whatrole):
print whatrole
if current_user.is_admin(current_user.username):
role = Role.query.filter_by(name=whatrole).first()
db_session.delete(role)
db_session.commit()
flash('Role deleted.')
return redirect(url_for('Users.change_permissions'))
flash('USER UNAUTHORIZED')
return redirect(url_for('Home.show_home'))
def delete():
try:
data = request.get_json()['ids']
ts = Tire.query.filter(Tire.id.in_(data))
for t in ts:
sess.delete(t)
sess.commit()
except:
return Response(status=503)
return Response(status=200)
def mutate(self, info, group_id, id_from_token):
group_id = int(group_id)
group = db.query(Group).filter_by(id=group_id).first()
if group is None:
raise Exception("No group with this ID found!")
if group.admin_id != id_from_token:
return DeleteGroup(ok=False, message="Access denied!")
try:
db.delete(group)
commit_with_check(db)
except:
db.rollback()
return EditGroup(ok=True, message="Group was deleted!")
def mutate(self, info, item_id, id_from_token):
item = db.query(Item).filter_by(id=item_id).first()
if item is None:
raise Exception("No item was found with this ID!")
if item.owner_id != id_from_token:
return DeleteItem(ok=False, message="Access denied!")
# TODO если не работают Cascade, то нужно удалять в остальных таблицах вручную
try:
db.delete(item)
commit_with_check(db)
except:
db.rollback()
return DeleteItem(ok=True, message="Item deleted!")
def delete(id):
user = db_session.query(RegisteredUser).filter(
RegisteredUser.id == id).first()
if not user:
output = redirect(
url_for('error',
message='User with id = {} does not exist'.format(id)))
else:
if request.method == 'GET':
output = render_template("user/delete.html", object=user)
else:
db_session.delete(user)
output = redirect(url_for('mod_user.show'))
return output
def test_can_save_tasks(self):
response = self.client.get("/planner/")
assert "no tasks to show" in str(response.data)
task = Task(name="task1", priority=0, done=False, date=datetime.utcnow().date())
db_session.add(task)
db_session.commit()
assert task in db_session
response = self.client.get("/planner/")
assert "no tasks to show" not in str(response.data)
task = Task.query.filter(Task.name=="task1").first()
db_session.delete(task)
db_session.commit()
response = self.client.get("/planner/")
assert "no tasks to show" in str(response.data)
def mutate(self, info, from_user_id, id_from_token):
fr = db.query(FR).filter_by(user_id_from=from_user_id,
user_id_to=id_from_token).first()
if fr is not None:
try:
db.delete(fr)
commit_with_check(db)
except:
db.rollback()
return RejectFriendRequest(
ok=True, message="Friend request has been rejected!")
else:
return RejectFriendRequest(
ok=False, message="Friend request hasn't been rejected!")
def mutate(self, info, to_user_id, from_user_id, id_from_token):
if id_from_token != int(from_user_id):
return CancelFriendRequest(ok=False, message="Access denied!")
fr = db.query(FR).filter_by(user_id_from=id_from_token,
user_id_to=to_user_id).first()
if fr is not None:
try:
db.delete(fr)
commit_with_check(db)
except:
db.rollback()
return CancelFriendRequest(
ok=True, message="Friend request has been canceled!")
else:
return CancelFriendRequest(
ok=True, message="Friend request hasn't been canceled!")
def mutate(self, info, from_user_id, id_from_token):
fr = db.query(FR).filter_by(user_id_from=from_user_id,
user_id_to=id_from_token).first()
if (fr is not None) and \
(db.query(FS).filter_by(user_id_1=id_from_token, user_id_2=from_user_id).first() is None):
try:
db.add(FS(user_id_1=from_user_id, user_id_2=id_from_token))
db.add(FS(user_id_2=from_user_id, user_id_1=id_from_token))
db.delete(fr)
commit_with_check(db)
except:
db.rollback()
return AcceptFriendRequest(
ok=True, message="Friend request has been accepted!")
else:
return AcceptFriendRequest(
ok=False, message="Friend request hasn't been accepted!")
def mutate(self, info, urls, id_from_token):
if len(urls) == 0:
return RemovePictures(ok=False,
message="No URLs to delete pictures!")
for pic in urls:
item_path = db.query(ItemPicture).filter_by(
path_to_picture=pic).first()
item = db.query(Item).filter_by(id=item_path.item_id).first()
if item.owner_id != id_from_token:
raise Exception("Access denied!")
if delete_file(Config.bucket, item_path.path_to_picture):
try:
db.delete(item_path)
commit_with_check(db)
except:
db.rollback()
return RemovePictures(ok=True, message="Pictures have been deleted!")
def mutate(self, info, friend_id, id_from_token):
fr1 = db.query(FS).filter_by(user_id_1=id_from_token,
user_id_2=friend_id).first()
fr2 = db.query(FS).filter_by(user_id_2=id_from_token,
user_id_1=friend_id).first()
if fr1 is not None and fr2 is not None:
try:
db.delete(fr1)
db.delete(fr2)
commit_with_check(db)
except:
db.rollback()
return RemoveFromFriends(ok=True,
message="Friend has been removed :-(")
else:
return RemoveFromFriends(ok=True,
message="Friend hasn't been removed :-)")
def review_location(location_id):
"""한 공부 장소에 대한 평점과 한줄평을 남기거나, 기존의 평점/한줄평을 수정/삭제할 수 있다."""
from datetime import datetime
#user = User.query.filter_by(user_id = )
location = Location.query.filter_by(
id=location_id).first() #TODO 존재하지 않는 location일 경우 처리
my_review = Review.query.filter_by(user_id=current_user.get_id(),
location_id=location_id).first()
form = ReviewForm()
if request.method == 'POST':
if form.submit_save.data:
# 이미 저장한 review가 없으면 새로 생성한다.
if not my_review:
my_review = Review(user_id=current_user.get_id(),
location_id=location_id)
my_review.like_score = form.like_score.data
my_review.crowded_score = form.crowded_score.data
my_review.comment = form.comment.data
my_review.timestamp = datetime.now()
db_session.add(my_review)
db_session.commit()
elif form.submit_delete:
if my_review:
db_session.delete(my_review)
db_session.commit()
return redirect(url_for('view_location', location_id=location_id))
# 저장한 리뷰가 있으면 그 내용을 불러온다.
if my_review:
form.comment.data = my_review.comment
form.like_score.data = str(my_review.like_score)
form.crowded_score.data = str(my_review.crowded_score)
return render_template('location-review.html',
title=location.name,
form=form)
def edit_location(id):
error = None
location_id = None
tempList = []
data = Locations.query.get(id)
if data is None:
abort(404)
form = dict(name=data.location_name,
body=data.location_description,
location_id=data.location_code)
if request.method == 'POST':
form['name'] = request.form['name']
form['location_code'] = request.form['location_code']
form['body'] = request.form['body']
if 'delete' in request.form:
db_session.delete(data)
db_session.commit()
flash(u'Deleting location: %s' % data.location_name)
return redirect(url_for('locations.index'))
elif 'submit' in request.form:
data.location_name = form['name']
data.location_code = form['location_code']
data.location_description = form['body']
db_session.commit()
flash(u'Saving modifications for %s' % data.location_name)
return redirect(url_for('locations.index'))
else:
flash(u'Nothing changed')
return redirect(url_for('locations.index'))
if request.method == 'GET':
print(id)
flash(u'Editing location: %s' % data.location_name)
form = dict(name=data.location_name,
body=data.location_description,
location_code=data.location_code)
return render_template('locations/edit_location.html',
form=form)
def mutate(self, info, list_id, id_from_token, with_items):
wlist = db.query(Wishlist).filter_by(id=list_id).first()
if wlist is None:
raise Exception("No wishlist with this ID found!")
if wlist.user_id != id_from_token:
return DeleteWishList(ok=False, message="Access denied!")
if with_items:
# TODO если не работают Cascade, то нужно удалять в остальных таблицах вручную
try:
db.delete(wlist)
commit_with_check(db)
except:
db.rollback()
return DeleteWishList(ok=True,
message="Wishlist deleted with items!")
else:
items_in_list = db.query(Item).filter_by(list_id=list_id).all()
for item in items_in_list:
item.list_id = None
return DeleteWishList(
ok=True,
message="Wishlist was deleted! Items are in default wishlist")
def delete(product_id):
"""
http://192.168.25.20:9098/api/product/1
:param product_id: Product identify
:return: {"result": "product has been removed","status_code": 202}
"""
try:
product = Product.query.get(product_id)
if not product:
return json_response(
status_=StatusCodeEnum.HTTP_404_NOT_FOUND,
result=get_messages("PRODUCT_NOT_FOUND_COD").format(id),
)
db_session.delete(product)
db_session.commit()
return json_response(
status_=StatusCodeEnum.HTTP_202_ACCEPTED,
result=get_messages("PRODUCT_REMOVED"),
)
except ValueError as ex:
db_session.rollback()
raise ex
finally:
db_session.close()
def edit_model():
model_id = request.args.get("id")
model = Model.query.filter_by(id=model_id).first()
form = Form(**model.__dict__)
if request.method == 'POST' and form.validate():
form = Form(request.form)
if form.delete.data == True:
db_session.delete(model)
db_session.commit()
flash("Model deleted", "primary")
return redirect(url_for(".view_all"))
for field in form:
if field.type == "SubmitField":
continue
if field.data == "":
continue
setattr(model, field.name.lower(), field.data)
try:
db_session.commit()
flash("Model updated", "primary")
except (sqlalchemy.exc.IntegrityError,
sqlalchemy.orm.exc.FlushError) as e:
flash(str(e), "danger")
return redirect(url_for(".view_all"))
return render_template("form_view.html", title=title, form=form)
)
parser.set_defaults(sep='\t', confirmed=False)
args = parser.parse_args()
init_session()
mol_db = MolecularDB.find_by_name_version(db_session, args.name,
args.version)
if mol_db and not args.drop:
LOG.info('Molecular DB already exists: {} {}'.format(
args.name, args.version))
else:
if mol_db:
LOG.info('Deleting molecular DB: {} {}'.format(
args.name, args.version))
db_session.delete(mol_db)
db_session.commit()
mol_db = MolecularDB(id=mol_db.id,
name=args.name,
version=args.version)
else:
mol_db = MolecularDB(name=args.name, version=args.version)
db_session.add(mol_db)
db_session.commit()
LOG.info('Appending molecules to Mol DB: {} {}'.format(
args.name, args.version))
import_molecules(mol_db, args.csv_file, args.sep)
db_session.commit()
def view_location_slots(location_id):
"""공부 장소 내의 세미나실의 예약 상태를 조회한다."""
from datetime import date, datetime, timedelta
""" 수정 시의 에약을 삭제하기 위해 구현한 부분입니다."""
begin_date = request.args.get('begin_date')
slot_id = request.args.get('slot_id')
if begin_date and slot_id:
my_reservation = Reservation.query.filter(
and_(Reservation.begin_date == begin_date,
Reservation.slot_id == slot_id,
Reservation.user_id == current_user.get_id())).first()
flash('기존 예약이 삭제되었습니다. 새로운 예약을 진행해주세요.')
db_session.delete(my_reservation)
db_session.commit()
def datetimerange(begin, end, step_minutes):
begin_minutes = round(
(begin.hour * 60 + begin.minute) / step_minutes) * step_minutes
dt = begin.replace(hour=begin_minutes // 60,
minute=begin_minutes % 60,
second=0,
microsecond=0)
delta = timedelta(minutes=step_minutes)
while dt < end:
yield dt
dt = dt + delta
form = SlotDateForm()
if not form.date.data:
form.date.data = date.today()
current_date = form.date.data
location = Location.query.filter_by(id=location_id).first()
#주중/주말에 따른 예약 가능 시간대를 확인한다.
if current_date.weekday == 5 or current_date.weekday == 6:
available_begin = location.available_begin_weekend
available_end = location.available_end_weekend
else:
available_begin = location.available_begin_weekday
available_end = location.available_end_weekday
#예약 가능한 시간대를 datetime 형식으로 변환한다
available_begin = datetime.combine(current_date, available_begin)
available_end = datetime.combine(current_date, available_end)
SEGMENT_SIZE = app.config['RESERVATION_SEGMENT_SIZE']
for slot in location.slots:
segments = dict()
for dt in datetimerange(available_begin, available_end, SEGMENT_SIZE):
segments[dt] = {'is_reserved': False}
#예약 가능한 시간대에 놓인 예약 항목을 불러온다
reservations = Reservation.query \
.filter(Reservation.slot_id == slot.id) \
.filter(Reservation.begin_date < available_end) \
.filter(Reservation.end_date > available_begin) \
.all()
for reservation in reservations:
for dt in datetimerange(reservation.begin_date,
reservation.end_date, SEGMENT_SIZE):
if dt in segments:
segments[dt]['is_reserved'] = True
segments[dt]['person_name'] = reservation.user.person_name
if segments:
slot.segments = segments
return render_template('location-slots.html',
title=location.name + ' 예약하기',
slots=location.slots,
form=form)
def delete(self):
db_session.delete(self)
db_session.flush()
db_session.commit()