def take_data(conn): conn.send(b'Enter login: '******'Enter password safe: ') data = conn.recv(1024).decode("utf-8") password = data result = take_datadb(login.split()[0], password) id = result[0][0] for i in result: for j in i: conn.send(str(j).encode("utf-8")) conn.send(b" ") if result != []: conn.send(b'\nDelete this safe y/n ?\n') data = conn.recv(1024) if data.decode("utf-8") == 'y\n': delete(id) conn.send(b'Your safe has been successfully deleted\n') else: conn.send(b'Incorrect id or password\n') conn.send(b'\nBack to menu y/n ?\n') data = conn.recv(1024) if data.decode("utf-8") == 'y\n': welcome(conn, 1)
def test_name(self): o = database.get("homescreen.name") database.delete("homescreen.name") self.assertEqual(homescreen.name("default"), "default") database.set("homescreen.name", "foo") self.assertEqual(homescreen.name("default"), "foo") database.set("homescreen.name", o)
async def cleanup(self, ctx): res = select(self.conn, 'Settings', ['guild_id', 'last_command']) current_time = datetime.datetime.now().timestamp() cutoff = 3600 * 24 * 90 cutoff_time = current_time - cutoff active = 0 inactive = 0 deleted = 0 for row in res: guild_id = row[0] last_command = row[1] guild = self.bot.get_guild(guild_id) if guild: if last_command and last_command > cutoff_time: active += 1 else: inactive += 1 logger.info("Leaving guild {0}...".format(guild.name)) await guild.leave() ## Don't immediately delete settings in case they rejoin. else: logger.info("We are no longer in {0}".format(guild_id)) delete(self.conn, 'Settings', ['guild_id'], [guild_id]) deleted += 1 self.conn.commit() logger.info("Active guild count: {0}".format(active)) logger.info("Inactive guild count: {0}".format(inactive)) logger.info("Deleted guild count: {0}".format(deleted)) await ctx.send("Active guild count: {0}".format(active)) await ctx.send("Inactive guild count: {0}".format(inactive)) await ctx.send("Deleted guild count: {0}".format(deleted))
def deleteInfo(): if 'g-recaptcha-response' in request.args: g_recaptcha_response = request.args['g-recaptcha-response'] if recaptcha.verify(g_recaptcha_response): u_mail = request.args['mail'] u_password = request.args['password'] if database.is_exist(u_mail): d_status, d_password = database.query_password(u_mail) if d_status: if database.check_password( u_password, base64.b64decode(d_password).decode()): id_status, u_id = database.find_ID(u_mail) if id_status: database.delete(u_id) status, msg = database.reformat_id() if status: return {'status': True, 'data': '重新排序成功'} else: return {'status': True, 'data': msg} return {'status': True, 'data': '删除成功'} else: return {'status': False, 'data': '服务器错误'} else: return {'status': False, 'data': '密码错误'} else: return {'status': False, 'data': '服务器错误'} else: {'status': False, 'data': '邮箱不存在'} else: return errors.recaptcha_verify_failed else: return errors.recaptcha_not_found
def set_factor_address(self): factor_id = self.ids.factor_id_selector.text address = self.ids.address_selector.text customer = self.ids.customer_selector.text if customer != "unregistered user": if address == "Restaurant": postgres_delete_query = """DELETE FROM factor_address WHERE factor_id = %s""" values = (factor_id, ) delete(postgres_delete_query, values, "factor_address") self.address = address postgres_delete_query = """DELETE FROM delivery WHERE factor_id= %s""" values = (factor_id, ) delete(postgres_delete_query, values, "delivery") self.ids.biker_selector.disabled = True self.ids.set_biker.disabled = True else: postgres_insert_query = """INSERT INTO factor_address(factor_id, address_phone) VALUES (%s, %s) ON CONFLICT (factor_id) DO UPDATE SET address_phone = %s WHERE factor_address.factor_id = %s""" values = (factor_id, address, address, factor_id) insert(postgres_insert_query, values, "factor_customer") self.ids.biker_selector.disabled = False self.ids.set_biker.disabled = False self.address = address else: self.address = "Restaurant"
def retrieve(uid): entry = database.read(uid) if _is_expired(entry): database.delete(uid) raise database.NonExistentUID(uid) else: return entry['text']
def delete(self): national_code = self.ids.customer_selector.text postgres_delete_query = """DELETE FROM customer WHERE national_code = %s""" values = (national_code, ) delete(postgres_delete_query, values, "customer") self.update_customer_selector()
def reindex_image_files(): """ Function reindex all Image files in DB Function check if path exist, if not - delete all images from this path Function check if image exist in this folder, if not - make not exist images ID's list and delete them from DB """ image_files = group_image_files() # get path and file name for path, files in image_files.items(): try: # check if path exist if os.path.exists(path): # get path files path_files = os.listdir(path) # filter files # if files not exist in FS but exist in DB - they deleted by user # and we need clean DB deletable_files = (image[1] for image in files if image[0] not in path_files) # looping in cycle and delete already deleted files(in FS) from DB for deleted_file in deletable_files: # delete file selected by ID Image[deleted_file].delete() else: # delete path if not exist delete(image for image in Image if image.image_path == path) except Exception: logger.error(traceback.format_exc()) continue
def delete(self): national_code = self.ids.biker_selector.text postgres_delete_query = """DELETE FROM bike WHERE national_code = %s""" values = (national_code, ) delete(postgres_delete_query, values, "bike") self.update_biker_selector()
async def sign_up_cancel(self, i): await i.response.defer() raid_id = i.message.id timestamp = int(time.time()) assigned_slot = select_one(self.conn, 'Assignment', ['slot_id'], ['player_id', 'raid_id'], [i.user.id, raid_id]) if assigned_slot is not None: class_name = select_one(self.conn, 'Assignment', ['class_name'], ['player_id', 'raid_id'], [i.user.id, raid_id]) error_msg = _( "Dearest raid leader, {0} has cancelled their availability. " "Please note they were assigned to {1} in the raid.").format( i.user.mention, class_name) await i.channel.send(error_msg) class_names = ','.join( self.raid_cog.slots_class_names[assigned_slot]) assign_columns = ['player_id', 'byname', 'class_name'] assign_values = [None, _("<Open>"), class_names] upsert(self.conn, 'Assignment', assign_columns, assign_values, ['raid_id', 'slot_id'], [raid_id, assigned_slot]) r = select_one(self.conn, 'Players', ['byname'], ['player_id', 'raid_id'], [i.user.id, raid_id]) if r: delete(self.conn, 'Players', ['player_id', 'raid_id'], [i.user.id, raid_id]) else: byname = self.process_name(i.guild.id, i.user) upsert(self.conn, 'Players', ['byname', 'timestamp', 'unavailable'], [byname, timestamp, True], ['player_id', 'raid_id'], [i.user.id, raid_id]) self.conn.commit() await self.raid_cog.update_raid_post(raid_id, i.channel)
def cleanOldUsers(): dt = datetime.date.today().toordinal() - objects.DAYS_KEEP_OLD_USERS old = database.select('persons', where= [('start_date', '<', dt), 'and', ('end_date', '<', dt)]) for pid in [tp['pid'] for tp in old]: log(2, 'Removing user %d from database' % (pid,)) database.delete('persons', { 'pid': pid }) database.close()
def delete_menu_item(object_kind, menu_item_id): if request.method == 'DELETE': response = database.delete(api_db_mapping.mapping[object_kind]['object_type'], id=menu_item_id) else: post_data = request.get_json() if post_data['action'] == 'delete': response = database.delete(api_db_mapping.mapping[object_kind]['object_type'], post_data['store']) return jsonify(response)
def delete(message_id): if request.method == "POST": password = request.form.get("password") if password == token: database.delete(message_id) flash("Silme İşlemi Başarılı") return redirect(url_for('home')) return render_template("wipe.html")
def del_model(self): model = self.current_model() if model is not None: self.modellogSignal.emit( "Model {} has been deleted successfully".format(model.name)) database.delete(database, self.current_model()) self.update_model_list() self.model_mog_list.clear() database.modified = True
def delete(call): db.delete(id=aut.check_user(u.multithreading[str(call.message.chat.id)].current_object.summary()), title=aut.check_doc(u.multithreading[str(call.message.chat.id)].current_object.summary())) bot.edit_message_text(chat_id=call.message.chat.id, message_id=call.message.message_id, text="{} is deleted from {}".format( u.multithreading[str(call.message.chat.id)].current_object.get_title() if isinstance(u.multithreading[str(call.message.chat.id)].current_object, Book) or isinstance( u.multithreading[str(call.message.chat.id)].current_object, Article) or isinstance(u.multithreading[str(call.message.chat.id)].current_object, AV_Materials) else u.multithreading[str(call.message.chat.id)].current_object.get_id(), u.multithreading[str(call.message.chat.id)].field)) bot.edit_message_reply_markup(chat_id=call.message.chat.id, message_id=call.message.message_id, reply_markup=bot_features.get_inline_markup(u.keyboard_button_back))
def delete_checkout(): ''' EditCheckout --- delete: description: Deletes the checkout tags: - Payment parameters: - in: path name: checkout_token schema: type: string required: true description: Checkout's ID value given when it is created. responses: 200: description: A JSON containing the result of the proccess. content: application/json: schema: properties: SUCCESS: type: boolean 400: description: A JSON containing a ERROR that identifies the problem content: application/json: schema: properties: ERROR: type: string ''' # request.args looks ugly and takes too much space... args = request.args keys = args.keys() required_keys = ['checkout_token'] # Checking for required arguments if not args or not check_keys(required_keys, keys): return jsonify({'ERROR': error_message('invalid_request')}), 400 # Checking if checkout exists if not db.exists('CHECKOUT', 'id', args['checkout_token']): return jsonify({'ERROR': error_message('invalid_checkout')}), 400 # Delete from database try: db.delete('CHECKOUT', 'id', args['checkout_token']) except Exception as e: print(e) return jsonify({'ERROR': error_message('db_error')}), 500 # Everything went well return jsonify({'SUCCESS': True}), 200
def remove_document(self, title): if self.get_priv() == 3: db.delete(title) id_str = str(self.get_id()) date = get_date() title_str = str(title) db.insert_log(date + " | Librarian(" + id_str + ") removed Document with title: " + title_str) else: return
def stop_alarm(args): db_list = database.read("alarm") found = False alarm = [] for row in db_list: if row[2] == '1': database.delete("alarm", row[0]) found = True if not found: error('I\'m sorry, there are no alarms to stop')
def remove(self, id): if self.get_priv() == 3: db.delete(id=id) id_str = str(self.get_id()) date = get_date() us_id_str = str(id) db.insert_log(date + " | Librarian(" + id_str + ") removed user with id: " + us_id_str) else: return
def delete(self): try: if (self.entry_order_id.get() == ""): tk.messagebox.showerror('Error','Select an entry') else: confirmation = tk.messagebox.askquestion('Delete Data','Are you sure you want to delete this entry') if confirmation == 'yes': data = (self.entry_order_id.get()) database.delete("Orders", "order_id = ?", (data,)) self.load_data() self.reset() except sqlite3.IntegrityError: tk.messagebox.showerror('Error','Deletion Failed')
def delete_menu_item(object_kind, menu_item_id): if request.method == 'DELETE': response = database.delete( api_db_mapping.mapping[object_kind]['object_type'], id=menu_item_id) else: post_data = request.get_json() if post_data['action'] == 'delete': response = database.delete( api_db_mapping.mapping[object_kind]['object_type'], post_data['store']) return jsonify(response)
def del_bhole(self): """ Deletes a borehole instance from boreholes """ item = self.current_borehole() if item: self.bhlogSignal.emit("{} has been deleted".format(item.name)) database.delete(database, item) self.update_List_Widget() self.update_List_Edits() database.modified = True
def delete(call): if users[call.message.chat.id].object.summary()["type"] in [ "Book", "Article", "AV" ]: id_of_user = get_property(users[call.message.chat.id].object, 2) db.delete(id=id_of_user) else: title_of_doc = get_property(users[call.message.chat.id].object, 0) db.delete(id=title_of_doc) bot.edit_message_text(chat_id=call.message.chat.id, message_id=call.message.message_id, text="{} is deleted".format(u.current.name), reply_markup=bot_features.get_inline_markup( u.keyboard_button_back))
def delete(self): try: if (self.entry_delivery_id.get() == ""): tk.messagebox.showerror('Error', 'Select an entry') else: confirmation = tk.messagebox.askquestion( 'Delete Data', 'Are you sure you want to delete this entry') if confirmation == 'yes': data = (self.entry_delivery_id.get(), self.entry_fee.get()) database.delete("delivery ", "delivery_id = ? and delivery_fee = ?", data) self.load_data() except sqlite3.IntegrityError: tk.messagebox.showerror('Error', 'Deletion Failed')
async def timezone(self, ctx, timezone): """Sets the user's default timezone to be used for raid commands.""" conn = self.bot.conn if timezone in [_("delete"), _("reset"), _("default")]: res = delete(conn, 'Timezone', ['player_id'], [ctx.author.id]) if res: conn.commit() await ctx.send( _("Deleted timezone information for {0}.").format( ctx.author.mention)) else: await ctx.send(_("An error occurred.")) return try: tz = pytz.timezone(timezone) except pytz.UnknownTimeZoneError as e: await ctx.send(str(e) + _(" is not a valid timezone!")) else: tz = str(tz) res = upsert(conn, 'Timezone', ['timezone'], [tz], ['player_id'], [ctx.author.id]) if res: conn.commit() await ctx.send( _("Set default timezone for {0} to {1}.").format( ctx.author.mention, tz)) else: await ctx.send(_("An error occurred.")) return
def delete_wallet(): sql = """SELECT my_list.name, value, volume, my_list.id, virtual_id FROM virtual_wallet LEFT JOIN my_list ON my_list.id = virtual_wallet.company_id""" results = database.select(sql) print() i = 1 if results: for result in results: print("{i} - {n} : {p}€ {v}".format(i=i, n=result[0], p=result[1], v=result[2])) i += 1 print("0 - Retour\n") action = input("Quelle action voulez-vous supprimer ?") action = int(action) if action == 0: wallet.virtual() if 0 < action <= len(results): action = results[action - 1] sql = "DELETE FROM virtual_wallet WHERE virtual_id={i}"\ .format(i=action[4]) request = database.delete(sql) if request == "delete": print("----- {n} ({vo}) -----\nValeur: {va}€ supprimé".format(n=action[0], vo=action[2], va=action[1])) else: print("Merci de rentrer une valeur valable") time.sleep(2) delete_wallet() else: print("Pas d'actions") time.sleep(2) wallet.submenu_virtual()
def uncheck(self): """ This method allows to delete the last completion of a task. Returns ------- bool Could the record for the completion be deleted successfully? """ if self.is_completed_today == 1: confirm_removal = input("Do you really want to remove today's" " habit completion? [y/n]") if confirm_removal == "y": query = """ DELETE FROM streak WHERE streak_id= (SELECT max(streak_id) FROM streak WHERE habit_id=?) """ where = (self.habit.habit_id, ) if db.delete(query, where) != 0: print("Today's completion has been deleted!") return True else: return False else: print("Action cancelled!") return False else: print("The habit has not yet been checked off today..." " If not now, when?!")
def eliminar(self): row = self.tableWidget.currentRow() if row >= 0: msg = QMessageBox() msg.setIcon(QMessageBox.Question) msg.setText("Desea eliminar este registro") msg.setStandardButtons(QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel) reply = msg.exec_() if reply == QMessageBox.Yes: pais = (self.tableWidget.item(row, 0).text()) sexo = (self.tableWidget.item(row, 2).text()) edad = (self.tableWidget.item(row, 3).text()) gene = (self.tableWidget.item(row, 8).text()) num = db.delete(pais, sexo, edad, gene) if num > 0: mensaje = QMessageBox() mensaje.setText("Registro eliminado") mensaje.exec_() self.obtener() else: mensaje = QMessageBox() mensaje.setText("Selecciona una fila de la tabla") mensaje.exec_()
def view_user(): if "delete" in request.args: id = request.args['id'] res = db.delete("delete from user where login _id='%s'" % (id)) res1 = db.delete("delete from login where login_id='%s'" % (id)) print(res) if (res > 0): res1 = db.select("select * from user") return render_template('admin/view_user.html', data=res1) if "login_id" in session['login_data']: res = db.select("select * from user") return render_template("admin/view_user.html", data=res) else: return redirect(url_for('public/login'))
def deletedatabase(name, token): if apptoken.verify(token): if db.delete(name): return Response("Database deleted") else: return Response("Error deleting database", status=400) else: return Response("Invalid authorization", status=401)
def cancel_alarm(args): db_list = database.read("alarm") print("cancelling alarm at", args) uid = '' parsed_datetime = get_datetime_from_time(args) for row in db_list: if row[1] == str(parsed_datetime.timestamp()) or row[1] == str( (parsed_datetime - datetime.timedelta(days=1)).timestamp()): uid = row[0] break if uid == '': error('I\'m sorry, there is no alarm set for ' + " ".join(args)) return database.delete("alarm", uid)
def delete(self, email): if not self.isLegalUser(email): self.error(404) else: if self.request.url.endswith('apply'): data = mafDelete(email) else: data = delete(email) self.checkData(data)
def set_factor_customer(self): factor_id = self.ids.factor_id_selector.text customer = self.ids.customer_selector.text if customer == "unregistered user": postgres_insert_query = """DELETE FROM factor_customer WHERE factor_customer.factor_id = %s""" values = (factor_id) delete(postgres_insert_query, values, "factor_customer") else: postgres_insert_query = """INSERT INTO factor_customer(factor_id, customer_national_code) VALUES (%s, %s) ON CONFLICT (factor_id) DO UPDATE SET customer_national_code = %s WHERE factor_customer.factor_id = %s""" values = (factor_id, customer, customer, factor_id) insert(postgres_insert_query, values, "factor_customer") self.address_lister() self.ids.customer_selector.disabled = True
def clear_all(cid = None, table = None, wildcard = False): """ Expire data from the cache. If called without arguments, expirable entries will be cleared from the cache_page and cache_block tables. @param cid If set, the cache ID to delete. Otherwise, all cache entries that can expire are deleted. @param table If set, the table table to delete from. Mandatory argument if cid is set. @param wildcard If set to TRUE, the cid is treated as a substring to match rather than a complete ID. The match is a right hand match. If '*' is given as cid, the table table will be emptied. """ if (cid == None and table == None): # Clear the block cache first, so stale data will # not end up in the page cache. clear_all(None, 'cache_block'); clear_all(None, 'cache_page'); return; if (cid == None): if (variable_get('cache_lifetime', 0)): # We store the time in the current user's user.cache variable which # will be saved into the sessions table by sess_write(). We then # simulate that the cache was flushed for this user by not returning # cached data that was cached before the timestamp. lib_appglobals.user.cache = REQUEST_TIME; cache_flush = variable_get('cache_flush', 0); if (cache_flush == 0): # This is the first request to clear the cache, start a timer. variable_set('cache_flush', REQUEST_TIME); elif (REQUEST_TIME > (cache_flush + variable_get('cache_lifetime', 0))): # Clear the cache for everyone, cache_flush_delay seconds have # passed since the first request to clear the cache. db_query(\ "DELETE FROM {" + table + "} WHERE expire != %d AND expire < %d", \ CACHE_PERMANENT, REQUEST_TIME); variable_set('cache_flush', 0); else: # No minimum cache lifetime, php.flush all temporary cache entries now. db_query(\ "DELETE FROM {" + table + "} WHERE expire != %d AND expire < %d", \ CACHE_PERMANENT, REQUEST_TIME); else: if (wildcard): if (cid == '*'): lib_database.delete(table).execute() else: lib_database.delete(table).condition('cid', cid +'%', 'LIKE').execute() else: lib_database.delete(table).condition('cid', cid).execute()
def do_POST(self): try: parsed_url = urlparse(self.path) self.path = parsed_url.path # initialize mime type to be application/json mime_type = mime_types.get('json') # initialize response to client response = '' # api request if is_api(self.path): api_regex_match = get_api_match(self.path) # extract api call from request api_call = api_regex_match.group(3) api_params = parse_qs(parsed_url.query) # load post data and convert to dict post_data = from_json(self.rfile.read(int(self.headers.getheader('Content-Length')))) if post_data['action'] == 'update': response = to_json(database.update(api_db_mapping.mapping[api_call]['object_type'], from_json(post_data['store']))) elif post_data['action'] == 'delete': response = to_json(database.delete(api_db_mapping.mapping[api_call]['object_type'], from_json(post_data['store']))) self.send_response(200) self.send_header('Content-type', mime_type) self.end_headers() self.wfile.write(response) print response return except IOError: self.send_error(404, 'File not found: %s' % self.path)
if len(sites) == 0: print 'Ce site n\'a pas l\'air d\'exister, navré.' sys.exit() site_id = list(sites)[0].id typed = '' while typed != 'oui, vraiment!' and typed != 'non': typed = text('Voulez vous VRAIMENT supprimer %s ? Ceci est irréversible.\nTapez "oui, vraiment!" si c\'est le cas, ou "non" dans le cas contraire :' % domain) if typed == 'non': sys.exit() path = '/home/%s/%s' % (user, domain) log_path = '/home/%s/logs/%s' % (user, domain) delete_files = choices('Supprimer aussi les fichiers dans %s ?' % path, dict(o=True,n=False), default='n') delete_logs = choices('Supprimer également les logs dans %s ?' % log_path, dict(o=True,n=False), default='n') db.delete('websites', where='id = $site_id', vars=locals()) os.system('/beadmin/restart-lighttpd.sh') if delete_files: os.system('rm -Rf %s' % path) if delete_logs: os.system('rm -Rf %s' % log_path) print '%s a été supprimé !' % domain
def deleteAlarm(): id = request.form['id'] db.delete(id) return redirect("/")
number = input("number: ") database.insert('directory.txt', name, number) if type=="f": name = input("name: ") found = str(database.select_one('directory.txt', name)) if found == "None": print("Name not in directory") else: print(found) if type=="d": name = input("name: ") found = str(database.select_one('directory.txt', name)) if found == "None": print("Name not in directory") else: database.delete('directory.txt', name) if type=="u": name = input("name: ") found = str(database.select_one('directory.txt', name)) if found == "None": print("Name not in directory") else: number = input("new number: ") database.update('directory.txt', name, number) if type=="q": break
def delete(self, email): self.isLegalUser(email) if self.request.url.endswith(email): self.checkData(delete(email)) else: self.abort(404)