def entity_type_delete(request):
dbsession = DBSession()
name = clean_matchdict_value(request, 'entity_type')
entity_type = dbsession.query(EntityType).filter(EntityType.name == name).one()
dbsession.delete(entity_type)
transaction.commit()
return {'status': 'success'}
def user_delete(request):
dbsession = DBSession()
name = clean_matchdict_value(request, 'user')
user = dbsession.query(User).filter(User.name == name).one()
dbsession.delete(user)
transaction.commit()
return {'status': 'success'}
def action_delete(request):
dbsession = DBSession()
name = clean_matchdict_value(request, 'action')
action = dbsession.query(Action).filter(Action.name == name).one()
dbsession.delete(action)
transaction.commit()
return {'status': 'success'}
def order_delete(request):
dbsession = DBSession()
name = clean_matchdict_value(request, 'order')
order = dbsession.query(Order).filter(Order.id == id).one()
dbsession.delete(order)
transaction.commit()
return {'status': 'success'}
def team_delete(request):
dbsession = DBSession()
name = clean_matchdict_value(request, 'team')
entity = dbsession.query(Entity).filter(Entity.name == name).filter(Entity.parent_id == None).one()
dbsession.delete(entity)
transaction.commit()
return {'status': 'success'}
def delete(self, catid):
session = DBSession()
category = session.query(models.Category).filter_by(id=catid).first()
for item in category.items:
session.delete(item)
session.delete(category)
session.commit()
def group_delete(request):
dbsession = DBSession()
name = clean_matchdict_value(request, 'group')
group = dbsession.query(Group).filter(Group.name == name).one()
dbsession.delete(group)
transaction.commit()
return {'status': 'success'}
def event_delete(request):
dbsession = DBSession()
id = clean_matchdict_value(request, 'event')
event = dbsession.query(Event).filter(Event.id == id).one()
dbsession.delete(event)
transaction.commit()
return {'status': 'success'}
def delete_note(request):
note_id = request.matchdict['note_id']
note = DBSession.query(Note).filter(Note.id == note_id).first()
if request.method == 'POST':
DBSession.delete(note)
request.session.flash(u'Note is successfully deleted', 'success')
return HTTPFound(location=request.route_url('notes'))
return _response_dict(request, note=note)
def load_session(sessionid):
session = DBSession.query(Session).filter(Session.sessionid == sessionid).first()
if session and session.expires < datetime.datetime.now():
logging.debug("session %s expired" % (sessionid))
DBSession.delete(session)
return None
else:
return session
def load_session(sessionid):
session = DBSession.query(Session).filter(
Session.sessionid == sessionid).first()
if session and session.expires < datetime.datetime.now():
logging.debug("session %s expired" % (sessionid))
DBSession.delete(session)
return None
else:
return session
def delete_pad(request):
pad_id = request.matchdict['pad_id']
pad = DBSession.query(Pad).filter(
Pad.id == pad_id,
Pad.user_id == get_current_user(request).id
).first() or raise_404(text='Pad not found')
if request.method == 'POST':
DBSession.delete(pad)
request.session.flash(u'Pad is successfully deleted', 'success')
return HTTPFound(location=request.route_url('notes'))
return _response_dict(request, pad=pad)
def delete_record(self):
"""Delete record based on record_id."""
record_id = self.request.matchdict["record_id"]
# shouldn't be any duplicate record_id since primary key
record = DBSession.query(Record).filter_by(record_id=record_id).first()
if record:
response_json = record.to_json()
with transaction.manager:
DBSession.delete(record)
transaction.commit()
return Response(status=202, json=response_json)
return Response(status=204)
def eventDelete(request):
eventId = int(request.matchdict['event_id'])
event = DBSession.query(Event).filter(Event.id == eventId).first()
if event == None:
return {'status' : 'Event Not Found'}
DBSession.delete(event)
DBSession.commit()
return {'status' : 'Deleted'}
def delete_picture(request):
menu_query = DBSession.query(Menu).filter(Menu.id==request.matchdict['menu_id'])
images_id = menu_query.one().images_id
images_id = images_id.split(' ') if images_id else []
if "data" in request.params:
thumb_url = json.loads(request.params["data"])
image = DBSession.query(Image).filter(Image.thumb_url==thumb_url).filter(Image.id.in_(images_id)).one()
images_id.remove(str(image.id))
images_id = ' '.join([str(i) for i in images_id])
menu_query.update({"images_id": images_id}, synchronize_session=False)
DBSession.delete(image)
return thumb_url
def update_menu_item_allergen(request):
menu_item_query = DBSession.query(MenuItem).filter(MenuItem.id==request.matchdict['menu_item_id'])
allergen_to_add = request.params.get('menu_item_allergen_on', None)
allergen_to_remove = request.params.get('menu_item_allergen_off', None)
if allergen_to_add:
#create a new allergen for the allergen that's turned on
new_allergen = Allergen(menu_item_id=request.matchdict['menu_item_id'], allergen = allergen_to_add)
DBSession.add(new_allergen)
elif allergen_to_remove:
#delete the allergen that was turned off
allergen_to_remove = DBSession.query(Allergen).filter(Allergen.menu_item_id==request.matchdict['menu_item_id']).filter(Allergen.allergen==allergen_to_remove).one()
DBSession.delete(allergen_to_remove)
menu = DBSession.query(Menu).filter(Menu.id==menu_item_query.one().menu_id).one()
update_gcalendar(menu)
return 'ok'
def forget(request):
"""
Forget the users session/ticket
This removes the users session/ticket entirely, unsets the cookie as well
as removing the ticket from the database.
"""
user = request.user
if user.user is None:
return security.forget(request)
DBSession.delete(user.ticket)
return security.forget(request)
def topicUnfollow(request):
currentUser = int(authenticated_userid(request))
topicId = int(request.matchdict['topic_id'])
followed = DBSession.query(UserFollowedTopic).\
filter(and_(UserFollowedTopic.topic_id == topicId,UserFollowedTopic.user_id == currentUser)).\
first()
if followed == None:
return {'status' : 'Not Following'}
DBSession.delete(followed)
DBSession.flush()
DBSession.commit()
return {'status' : 'Unfollowed'}
def delete(cls, id):
ret = True
session = DBSession()
actions = session.query(Action).filter(Action.id == id).all()
if actions:
try:
session.delete(actions[0])
session.commit()
session.close()
except IntegrityError as error:
logging.error(error)
ret = False
else:
logging.error('Action not found')
ret = False
return ret
def delete_menu_item(request):
menu_item_id = request.matchdict['menu_id']
menu_item = DBSession.query(MenuItem).filter(MenuItem.id==menu_item_id).one()
menuQuery = DBSession.query(Menu).filter(Menu.id==menu_item.menu_id)
menu = menuQuery.one()
#build the new list of menu ids
menu_ids = menu.menus.split(' ')
menu_ids = map(int, menu_ids)
menu_ids.remove(int(request.matchdict['menu_id']))
menu_id_string = ' '.join(str(menu_id) for menu_id in menu_ids)
menu.menus = menu_id_string
menuQuery.update({"menus":menu_id_string}, synchronize_session=False)
#delete the menu item
DBSession.delete(menu_item)
#update allergens table
allergens = DBSession.query(Allergen).filter(Allergen.menu_item_id==request.matchdict['menu_id'])
for allergen in allergens:
DBSession.delete(allergen)
update_gcalendar(menu)
return menu_item_id
def delete(self, catid, itemid):
session = DBSession()
item = session.query(models.Item).filter_by(id=itemid).first()
session.delete(item)
session.commit()
def delete_entry(request):
entry = DBSession.query(m.Entry).filter(m.Entry.entry_id == request.matchdict['id']).first()
DBSession.delete(entry)
return {}
def delete(self):
uid = self.request.matchdict['uid']
server = DBSession.query(Server).filter_by(uid=uid).one()
with transaction.manager:
DBSession.delete(server)
return {'deleted': True}
def delete(self):
uid = self.request.matchdict['uid']
server = DBSession.query(Server).filter_by(uid=uid).one()
with transaction.manager:
DBSession.delete(server)
return {'deleted': True}
