def delete_account(user_data): """Delete user transaction""" session = Session() response = None try: user = session.query(User).filter(User.email == user_data['email'] ).first() if user is not None: if __hash_pass(user_data['password']) == user.password: session.delete(user) session.commit() # TRANSACTION SUCCESSFUL response = success_response(user, 'delete') else: response = error_response(err_concept='bad_credentials') else: response = error_response(err_concept='non_user') except exc.DBAPIError as e: session.rollback() response = error_response(e.code, e.orig, 'transaction') finally: if response is not None: return response
def _prune_dir(path, prune_modified=False): """Prunes songs in directory and returns set of remaining songs.""" session = Session() songs = session.query(Song).filter(Song.path.like(path + '%')).all() remaining_paths = set() for song in songs: if not isfile(song.path): session.delete(song) print 'Pruned (deleted): ' + song.path continue if prune_modified: with open(song.path, 'rb') as f: if song.checksum != md5_for_file(f): session.delete(song) print 'Pruned (modified or no checksum): ' + song.path continue else: remaining_paths.add(song.path) else: remaining_paths.add(song.path) session.commit() return remaining_paths
def deleteShiftDutyRecord(shift_duty_date, shift_duty_period=DutyPeriod.NightDuty): session = Session() duty_shift_chain = DBOperation.getDutyShiftChain( shift_duty_date, shift_duty_period) if duty_shift_chain is None: print("无日期为{}的值班记录".format(shift_duty_date)) return shift_chain_list = duty_shift_chain.shift_chain shift_count = len(shift_chain_list) - 1 try: if shift_count == 0: print("can not delete origin duty.") return elif shift_count == 1: session.query(OriginDuty).filter( OriginDuty == shift_chain_list[-2]).update( {OriginDuty.shift_duty_id: None}) else: session.query(ShiftDuty).filter( ShiftDuty == shift_chain_list[-2]).update( {ShiftDuty.next_shift_duty_id: None}) session.delete(shift_chain_list[-1]) session.commit() except Exception as e: print(e) session.rollback() finally: session.close()
def delete_report_card(): #call this so the records are fetched to show to the user result = view_report_card(mode='delete') no_of_records = len(result) if no_of_records == 0: print("No Records Found To Delete") return choice = pyip.inputYesNo( prompt= f"Found { no_of_records }. Are you sure you want to delete all of the above? (yes/no)" ) if choice == 'no': print("Skipping Delete...") return session = Session() for card in result: session.delete(card) session.commit() print(f"Deleted { no_of_records } records") return
def remove(file_id): try: session_obj = Session() ret = session_obj.query(file_list).filter_by(id=file_id).first() if not ret: Session.remove() return -1 tmp = session_obj.query(file_list).get(ret.id) folder_path = config.ROOTDIR + tmp.user.username + config.BLACKBOXFOLDER file_path = os.path.join(folder_path, tmp.file_name) if os.path.exists(file_path): try: os.remove(file_path) except Exception as e: Session.remove() Logger().get_logger().error(str(e)) session_obj.rollback() return -2 session_obj.delete(tmp) session_obj.commit() Session.remove() return 0 except Exception as e: Logger().get_logger().error(str(e)) session_obj.rollback() return -2
def cleaning_del(message, user_name, day_of_week): """指定した曜日の掃除当番からユーザーを削除する :param message: slackbot.dispatcher.Message :param str user_name: 掃除当番から削除するユーザー名 :param str day_of_week: 削除する掃除当番が登録されている曜日 """ if day_of_week not in DAY_OF_WEEK: botsend(message, '曜日には `月` 、 `火` 、 `水` 、 `木` 、 `金` のいずれかを指定してください') return s = Session() slack_id = get_slack_id(s, user_name) if not slack_id: botsend(message, '{}はSlackのユーザーとして存在しません'.format(user_name)) return cleaning_user = (s.query(Cleaning).filter( Cleaning.slack_id == slack_id).filter( Cleaning.day_of_week == DAY_OF_WEEK.index( day_of_week)).one_or_none()) if cleaning_user: s.delete(cleaning_user) s.commit() botsend(message, '{}を{}曜日の掃除当番から削除しました'.format(user_name, day_of_week)) else: botsend(message, '{}は{}曜日の掃除当番に登録されていません'.format(user_name, day_of_week))
def unalias_name(message, user_name, alias_name=None): """ユーザーに紐づくエイリアス名を削除する :param message: slackbotの各種パラメータを保持したclass :param str user_name: 削除するエイリアス名を持つSlackユーザー :param str alias_name: 削除するエイリアス名 alias_nameがNoneの場合、user_nameをalias_nameとして扱う 上記の場合user_nameは投稿者となる """ if alias_name: # ユーザー名とエイリアス名が指定されているパターン slack_id = get_slack_id_by_name(user_name) else: # 投稿者のエイリアス名を更新するパターン alias_name = user_name slack_id = message.body['user'] user_name = get_user_name(slack_id) if not slack_id: botsend(message, '{}に紐づくSlackのuser_idは存在しません'.format(user_name)) return s = Session() alias_user_name = (s.query(UserAliasName).filter( UserAliasName.slack_id == slack_id).filter( UserAliasName.alias_name == alias_name).one_or_none()) if alias_user_name: s.delete(alias_user_name) s.commit() botsend(message, '{}のエイリアス名から `{}` を削除しました'.format(user_name, alias_name)) else: botsend(message, '{}のエイリアス名 `{}` は登録されていません'.format(user_name, alias_name))
def upload(user_id, package_name, version, time, remark): try: session_obj = Session() tmp = session_obj.query(user_info).filter_by(id=user_id).first() if (tmp == None): Session.remove() return -1 tmp = session_obj.query(package_info).options( subqueryload(package_info.user)).filter_by( package_name=package_name).filter_by( user_id=user_id).first() if tmp is not None: tmp = session_obj.query(package_info).get(tmp.id) session_obj.delete(tmp) session_obj.commit() package_obj = package_info(user_id=user_id, package_name=package_name, version=version, time=time, remarks=remark) session_obj.add(package_obj) session_obj.commit() Session.remove() return 0 except Exception as e: Logger().get_logger().error(str(e)) session_obj.rollback() return -2
class TestItem(TestCase): def setUp(self): reset_db() self.sess = Session() def tearDown(self): self.sess.close() def test_crud(self): store = StoreModel('testStore') item = ItemModel(name='test', price=12.99, store_id=1) self.assertEqual( self.sess.query(ItemModel).filter( ItemModel.name == 'test').count(), 0) self.sess.add(store) self.sess.add(item) self.sess.commit() self.assertEqual( self.sess.query(ItemModel).filter( ItemModel.name == 'test').count(), 1) self.sess.delete(item) self.sess.commit() self.assertEqual( self.sess.query(ItemModel).filter( ItemModel.name == 'test').count(), 0) self.sess.delete(store) self.sess.commit()
def remove(package_id): try: session_obj = Session() ret = session_obj.query(package_info).filter_by( id=package_id).first() if not ret: Session.remove() return -1 tmp = session_obj.query(package_info).get(ret.id) folder_path = config.ROOTDIR + tmp.user.username + config.PATCHFOLDER file_path = os.path.join(folder_path, tmp.package_name) if is_file_open(file_path) or is_package_in_task(package_id): Session.remove() return -4 if os.path.exists(file_path): try: os.remove(file_path) except Exception as e: Logger().get_logger().error(str(e)) session_obj.rollback() Session.remove() return -2 session_obj.delete(tmp) session_obj.commit() Session.remove() return 0 except Exception as e: Logger().get_logger().error(str(e)) session_obj.rollback() return -3
def delete(self, id): rack = Session.query(Rack).filter(Rack.id == id).first() if not rack: abort(404, message="Rack id={} doesn't exist".format(id)) Session.delete(rack) Session.commit() log.info("Rack id={} deleted".format(id)) return {}, 204
def delete(self, id): server = Session.query(Server).filter(Server.id == id).first() if not server: abort(404, message="Server {} doesn't exist".format(id)) Session.delete(server) Session.commit() log.info("Server id={} deleted".format(id)) return {}, 204
def remove_beer(beer_name): session = Session() beer = session.query(Beer).filter_by(name=beer_name.lower()).one() session.delete(beer) session.commit() response = jsonify() response.status_code = 201 return response
def delete(self, model, id): s = Session() m = s.query(model).filter(model.id == id).one() s.delete(m) s.commit() s.close()
def on_post(self, req, resp): doc = req.context['doc'] users=Session.query(User).all() unique=True for user in users: if doc['email'] == user.email: unique=False if unique: user = User(name=doc['name'], email=doc['email'].lower(), signedin=False,registerTime=datetime.datetime.today()) print(datetime.datetime.today()) user.salt = bcrypt.gensalt() user.pw_hash = bcrypt.hashpw(doc['password'].encode('utf-8'), user.salt) s=smtplib.SMTP_SSL('smtp.gmail.com',465) s.ehlo() s.login('*****@*****.**','helloworld@ppclub') code=randint(1000000,10000000) user.code=code msg=MIMEText('Hi '+user.name+', your verification URL is: '+'http://192.168.1.127:8000/confirmation/'+str(code)) msg['From']='*****@*****.**' msg['To']=user.email msg['Subject']='PhoenixNow Account Confirmation' s.send_message(msg) s.close() Session.add(user) Session.flush() Session.commit() req.context['user'] = user.id req.context['result'] = {"result": "success", "action": "register"} else: user=get_user(req,resp) td=datetime.timedelta(minutes=30) if datetime.datetime.today()-td<user.registerTime or user.emailVerified==True: description = "User was already made" title = "User creation conflict" raise falcon.HTTPConflict(title=title, description=description) else: Session.delete(user) Session.flush() user = User(name=doc['name'], email=doc['email'], signedin=False,registerTime=datetime.datetime.today()) print(datetime.datetime.today()) user.salt = bcrypt.gensalt() user.pw_hash = bcrypt.hashpw(doc['password'].encode('utf-8'), user.salt) s=smtplib.SMTP_SSL('smtp.gmail.com',465) s.ehlo() s.login('*****@*****.**','helloworld@ppclub') code=randint(1000000,10000000) user.code=code msg=MIMEText('Hi '+user.name+', your verification URL is: '+'http://192.168.1.127:8000/confirmation/'+str(code)) msg['From']='*****@*****.**' msg['To']=user.email msg['Subject']='PhoenixNow Account Confirmation' s.send_message(msg) s.close() Session.add(user) Session.flush() Session.commit() req.context['user'] = user.id req.context['result'] = {"result": "success", "action": "register"}
def note_remove(note_id=None): s = get_session() if not s.get('authenticated') or not note_id: return bottle.redirect('/login') db_session = Session() note = db_session.query(Note).get(note_id) db_session.delete(note) db_session.commit() bottle.redirect(bottle.url('note-list'))
def deletePost(): print 'Method=' + request.method id = request.form.get('id') session = Session() movies = session.query(Movie).filter(Movie.id == id).first() print movies.id session.delete(movies) session.commit() return redirect('/')
def remove(self, alias): try: suite = Session.query(TestSuite).get(alias) if suite: Session.delete(suite) Session.commit() except: Session.rollback() Session.commit()
def remove(self, hostname): try: agent = Session.query(Agent).get(hostname) if not agent: raise KeyError("%s not found" % hostname) Session.delete(agent) Session.commit() except: Session.rollback() raise
def remove_song(self, song_id, skip=False): """Removes the packet with the given id""" session = Session() packet = session.query(Packet).filter_by(song_id=song_id).first() if isinstance(player.now_playing, Song) and player.now_playing.id == song_id: player.stop() if skip: self.virtual_time = packet.finish_time session.delete(packet) session.commit() self._update_active_sessions() return self.get_queue()
def remove_video(self, url, skip=False): """Removes the packet with the given video_url""" session = Session() packet = session.query(Packet).filter_by(video_url=url).first() if isinstance(player.now_playing, YouTubeVideo) and player.now_playing.url == url: player.stop() if skip: self.virtual_time = packet.finish_time session.delete(packet) session.commit() self._update_active_sessions() return self.get_queue()
def deleteUser(cookie, uid): session = Session() u = usermanagment.getUser(cookie) if not u.admin: raise Exception("Invalid access %s %s" % (uid, u.id)) q = session.query(User).filter_by(id=uid) if q.count() == 0: raise Exception("User not found") cu = q.one() session.delete(cu) session.commit()
def rmpost(pid): try: if escape(session["username"]) != config.username or escape(session["password"]) != config.password: raise except: abort(404) s = Session() try: s.delete(s.query(Blog).filter_by(pid = pid).first()) s.commit() except: abort(404) return redirect(url_for("blog.blogindex"))
def remove_song(self, song_id, skip=False): """Removes the packet with the given id""" session = Session() packet = session.query(Packet).filter_by( song_id=song_id, player_name=PLAYER_NAME).first() if (isinstance(player.now_playing, Song) and player.now_playing.id == song_id): player.stop() if skip: self.virtual_time = packet.finish_time session.delete(packet) session.commit() self._update_active_sessions() return self.get_queue()
class TestStore(TestCase): def setUp(self): reset_db() self.sess = Session() def tearDown(self): self.sess.close() def test_create_store(self): store = StoreModel('testStore') self.assertEqual(store.items.count(), 0) def test_crud(self): store = StoreModel('testStore') self.assertEqual( self.sess.query(StoreModel).filter( StoreModel.name == 'testStore').count(), 0) self.sess.add(store) self.sess.commit() self.assertEqual( self.sess.query(StoreModel).filter( StoreModel.name == 'testStore').count(), 1) self.sess.delete(store) self.sess.commit() self.assertEqual( self.sess.query(StoreModel).filter( StoreModel.name == 'testStore').count(), 0) def test_store_relationship(self): store = StoreModel('testStore') item = ItemModel('testItem', 12.99, 1) self.sess.add(store) self.sess.add(item) self.sess.commit() items = self.sess.query(ItemModel).filter( ItemModel.store_id == 1).all() self.assertEqual(len(items), 1) self.assertEqual(items[0].name, 'testItem') def test_store_json(self): store = StoreModel('testStore') expected = { 'name': 'testStore', 'items': [], } self.assertEqual(store.json(), expected)
def delete_item(item_id, redirect_url): """Delete an item from database""" # Create DB session db_session = Session() # Delete corresponding item try: item = db_session.query(Item).filter_by(id=item_id).one() db_session.delete(item) db_session.commit() except exc.SQLAlchemyError: flash("There was an error. Please try again.", "danger") return redirect(redirect_url) # Close DB session db_session.close()
def del_term(message, command, word): """コマンドから語録を削除する :param message: slackbot.dispatcher.Message :param str command: 登録済のコマンド名 :param str word: 削除する語録 """ s = Session() term = (s.query(Term).filter(Term.create_command == command.id).filter( Term.word == word).one_or_none()) name = command.name if term: s.delete(term) s.commit() botsend(message, 'コマンド `${}` から「{}」を削除しました'.format(name, word)) else: botsend(message, 'コマンド `${}` に「{}」は登録されていません'.format(name, word))
def on_delete(self, req, resp, item_id): event = Session.query(Event).get(item_id) from_date = event.from_date.strftime("%Y-%m-%d") to_date = event.to_date.strftime("%Y-%m-%d") req.context['result'] = { 'action': 'delete event', 'result': 'success', 'event': { 'id': event.id, 'from_date': from_date, 'to_date': to_date, 'title': event.title, 'description': event.description } } resp.status = falcon.HTTP_200 Session.delete(event) Session.commit()
def remove_resource(message, _, name): """リソースの削除 :param message: slackbot.dispatcher.Message :param str name: リソース名 """ channel_id = message.body["channel"] s = Session() resource = s.query(Resource).filter( Resource.channel_id == channel_id, Resource.name == name, ).one_or_none() if resource: s.delete(resource) s.commit() show_resources(message)
def remove(user_id) -> int: try: session_obj = Session() ret = session_obj.query(user_info).filter_by(id=user_id).first() if not ret: Session.remove() return -1 #删除用户 tmp = session_obj.query(user_info).get(ret.id) session_obj.delete(tmp) session_obj.commit() Session.remove() except Exception as e: Logger().get_logger().error(str(e)) session_obj.rollback() return -2 return 0
class TestUser(TestCase): def setUp(self): reset_db() self.sess = Session() def tearDown(self): self.sess.close() def test_crud(self): user = UserModel(name='testUser', password='******') self.assertEqual(self.sess.query(UserModel).count(), 0) self.sess.add(user) self.sess.commit() self.assertEqual(self.sess.query(UserModel).count(), 1) self.sess.delete(user) self.sess.commit() self.assertEqual(self.sess.query(UserModel).count(), 0)
def pop_term(message, command): """用語コマンドで最後に登録された応答を削除する :param message: slackbot.dispatcher.Message :param str command: 登録済のコマンド名 """ s = Session() term = (s.query(Term).filter(Term.create_command == command.id).filter( Term.creator == message.body['user']).order_by(Term.id.desc()).first()) name = command.name if term: s.delete(term) s.commit() botsend(message, 'コマンド `${}` から「{}」を削除しました'.format(name, term.word)) else: msg = ('コマンド `${0}` にあなたは語録を登録していません\n' '`${0} add (語録)` で語録を登録してください'.format(name)) botsend(message, msg)
def remove_temps(temps_id): try: session_obj = Session() ret = session_obj.query(blackbox_temps).filter_by( id=temps_id).first() if not ret: Session.remove() return -1 tmp = session_obj.query(blackbox_temps).get(ret.id) session_obj.delete(tmp) session_obj.commit() Session.remove() return 0 except Exception as e: Logger().get_logger().error(str(e)) session_obj.rollback() return -2
def remove_video(self, url, skip=False): """Removes the packet with the given stream_url""" session = Session() packet = session.query(Packet).filter_by( stream_url=url, player_name=PLAYER_NAME).first() if (isinstance(player.now_playing, YouTubeVideo) and player.now_playing.url == url): player.stop() if skip: self.virtual_time = packet.finish_time elif (isinstance(player.now_playing, SoundCloudMusic) and player.now_playing.url == url): player.stop() if skip: self.virtual_time = packet.finish_time session.delete(packet) session.commit() self._update_active_sessions() return self.get_queue()
async def unsubscribe(message: types.Message): session = Session() if "reply_to_message" in message: res = session.query(BD_Subs_SMS).filter_by(sms_id=message["reply_to_message"]["message_id"]).all() if len(res) > 0: row_1 = res[0] print("Result subs_id:", row_1.subs_id) row_2 = session.query(BD_Subs).filter_by(id=row_1.subs_id).all()[0] await message.answer("Удалил подписку: "+row_2.sub_name) session.delete(row_2) session.delete(row_1) else: await message.answer("Я не нашёл подписку") else: txt = "" for (sub_name,) in session.query(BD_Subs.sub_name).filter_by(user_id=message.from_user.id): txt += "\n" + str(sub_name) await message.answer("Вы успешно отписаны от рассылки сайта:" + txt) q = session.query(BD_Subs).filter(BD_Subs.user_id == message.from_user.id)\ .delete() session.commit() await message.reply("Ну и ладно!")
def merge_organisations(this_id, that_id): """remove organisation with that_id""" success = True s = Session() this = _get_organisation(s, this_id) if not this: return False that = _get_organisation(s, that_id) if not that: return False # name, org_type, core if not is_blank(that.name) and len(that.name) < len(this.name): this.name = that.name # if this.org_type and that.org_type and this.org_type != that.org_type: # print("Organisation %s with different type: old: '%s'; new: '%s'"\ # %(this.name, this.org_type, that.org_type)) # success = False # else: # this.org_type = this.org_type or that.org_type if this.core and that.core and this.core != that.core: print("Organisation %s with different core: old: '%s'; new: '%s'"\ %(this.name, this.core, that.core)) success = False else: this.core = this.core or that.core # accounts, aliases #this.aliases = this.aliases + that.aliases this.aliases = _merge_aliases(s, this.aliases, that.aliases) this.accounts = this.accounts + that.accounts s.delete(that) s.commit() s.close() return success
os.unlink( os.path.join(DATA_DIR, 'additional/%s_changes.json-lines' % crawl_id)) except OSError: pass try: os.unlink(os.path.join(DATA_DIR, '%s_errors.csv' % crawl_id)) except OSError: pass db_session = Session() accounts = db_session.query(Account).filter(Account.enabled == False).all() print str(len(accounts)), "disabled accounts to clean" for a in accounts: print "Account", a.name spiders = db_session.query(Spider).filter(Spider.account_id == a.id).all() for spider in spiders: print "Spider", spider.name last_crawl = db_session.query(Crawl).filter( Crawl.spider_id == spider.id).order_by(desc( Crawl.crawl_date)).first() if last_crawl and last_crawl.crawl_date.year < 2014: print "Removing crawls" crawls = db_session.query(Crawl).filter( Crawl.spider_id == spider.id).all() for crawl in crawls: _delete_crawl_files(crawl.id) db_session.delete(crawl)
class ChannelManager: def __init__(self): self.session = Session() def add_channel(self, id, parent=None, name=None, links=None, description=None, links_add=None, links_remove=None, temporary=None, position=None, description_hash=None): c = self.session.query(Channel).get(id) if c: debug("Updating channel {} ({})".format(c.name, id)) self.update_channel(id, parent, name, links, description, links_add, links_remove, temporary, position, description_hash) else: c = Channel(id=id, parent_id=parent, name=name, links="", description=description, links_add="",links_remove="", temporary=temporary, position=position, description_hash=description_hash) self.session.add(c) if parent is not None and parent != 0: p = self.session.query(Channel).get(parent) if p is None: raise KeyError("Got a child channel without a root channel (?)") def del_channel(self, id): try: c = self.session.query(Channel).get(id) self.session.delete(c) info("Deleted channel with ID {0}", id) except KeyError: warning("Server removed channel with ID {}, " "but we haven't seen it before!", id) except: pass def get_by_name(self, name): return self.session.query(Channel).filter_by(name=name).first() def get(self, id): if not isinstance(id, int): if not id.isdigit(): id = self.get_by_name(id).id else: id = int(id) return self.session.query(Channel).get(id) def update_channel(self, *args): # id, parent, name, links, description, links_add, #links_remove, temporary, position, description_hash): pass def add_from_message(self, message): args = [] for m in ( 'channel_id', 'parent', 'name', 'links', 'description', 'links_add', 'links_remove', 'temporary', 'position', 'description_hash'): args.append(getattr(message, m, None)) self.add_channel(*args)
def delete(self): sess = Session() sess.delete(self) sess.commit() sess.close()