def edit_job(job_id: int) -> "render_template('job/add_job.html')": edit = True job = Job.find_job_by_id(job_id) form = JobForm(obj=job) if request.method == "POST" and form.validate_on_submit(): job_id = str(job_id) form.populate_obj(job) job.last_edited = get_date_now() cache.delete(job_id) cache.set(key=job_id, value=job) job.save() log = f"You successful edited a job with ID {job_id} on the {format_date(job.applied_date)}" log_account_activity(session["username"], log) flash("You have successfully edited your job", "success") return secure_redirect_or_403( url_for('job_app.get_job_with_id', job_id=job_id)) return render_template("job/add_job.html", form=form, login_form=LoginForm(), edit=edit, job_id=job_id)
def delete(self): ''' 删除回复 ''' if 'manager_id' not in session: return {'status_code': 400, 'message': 'illegal request'}, 400 manager_id = session['manager_id'] parser = reqparse.RequestParser() parser.add_argument('token') parser.add_argument('reply_id', type=int) parser.add_argument('comment_id', type=int) parser.add_argument('blog_id', type=int) args = parser.parse_args() token = args['token'] reply_id = args['reply_id'] comment_id = args['comment_id'] blog_id = args['blog_id'] if not token: return {'status_code': 400, 'message': 'bad requests'}, 400 cache.delete(('blog_id_%s' % blog_id)) ###清除blog的缓存 user_message = cache.get(token) if user_message is None: return {'status_code': 400, 'message': '登陆已过期'}, 400 user_id = user_message['id'] if deleteReply(reply_id=reply_id, comment_id=comment_id, user_id=user_id, manager_id=manager_id, blog_id=blog_id): cache.delete('blog_id_%s_comment' % blog_id) return {'status_code': 200, 'message': '删除成功'} return {'status_code': 400, 'message': '删除失败'}, 400
def delete_from_cache(cls, key): """delete_from_cache(str) -> returns None `key`: Takes a key and deletes the value associated with that key from the cache """ cache.delete(key)
def syncScrumInfo(data): try: # data = request.get_json('data') vers = data['vers'] # print(vers) # 一共2个看板,线上团队一个看板,度假三个团队一个看板 #删除版本号相同的信息 Scrumteam.query.filter(Scrumteam.vers == vers).delete() db.session.commit() GetJ = GetJira() msg = GetJ.save_Excel(vers) # print("+++++++++++++++++++++++++=============") #保存信息 # engine = create_engine('mysql+mysqlconnector://root:tuniu520@localhost/maxdata') # fp.to_sql(Scrumteam.__tablename__, con=engine, schema="maxdata", index=False, index_label=False, if_exists='append', chunksize=1000) response = ({"success": "true", "msg": msg}) except Exception as e: raise e db.session.rollback() response = ({"success": "true", "msg": "同步失败~"}) response = json.dumps(response) cache.delete('getScrumInfo') return response
def clear_teams_cache(self): from app import cache try: cache.delete('all_teams') flash("successfully deleted team cache", category="success") except Exception as e: flash(f"An error occurred: {e}", category="error") return redirect('/admin/utilities')
def get_movies(): """This function is collecting movies and refreshes cache""" logger.info('Movie update task started!') cache.delete('movies_info') info = collect_movies() socketio.emit('update_movies', info, namespace='/movies/stream') logger.info('Movies updated!')
def begCache(params, user_info): """ 获取添加好友缓存 """ data = cache.get('@broadcast.beg'+str(user_info['data']['id'])) if data is None: return Utils.formatBody() else: cache.delete('@broadcast.beg'+str(user_info['data']['id'])) return Utils.formatBody(data)
def delete(base): """Delete a cached url Args: base (str): The base of the cached url to delete """ url = request.url.replace('delete/', '') cache.delete(url) return jsonify(objects='Key: {} deleted'.format(url))
def delete(resource): """ Deletes the cache of a given resource Args: resource (str): The resource to delete. """ url = request.url.replace('delete/', '') cache.delete(url) return jsonify(result='Key: %s deleted' % url)
def add_property(): cache.delete('property') # # 新增传进来的form # form = {'prop_name': '肤色', 'label_type_id': 1, 'prop_type': 1, 'property_value': # [{'option_value': 2, 'option_name': '黄'}, # {'option_value': 1, 'option_name': '黑'}, # {'option_value': 3, 'option_name': '白'}]} # # # 修改传进来的form # form = {'prop_id':12, 'property_value': # [{'option_id': 16, 'option_value': 4, 'option_name': '吧lue皮'}, # {'option_value': 5, 'option_name': '花皮'}, # {'option_id':30,'delete':1}]} form = json.loads(request.data) if request.method == 'POST': # 1.将prop_name、label_type、prop_type 插入到property表中 with db.auto_commit(): property = Property() # 如果是修改,form['prop_id']值不为空,则不执行下面的语句 if form.get('prop_id') == None: property.set_attrs(form) db.session.add(property) # 将propery_value中的值插入到property_value表中 with db.auto_commit(): for value in form['property_value']: property_value = Property_value() prop_id = '' # 如果是修改,property.id为空,需要使用传进来的prop_id if property.id is None: prop_id = form['prop_id'] else: prop_id = property.id value['prop_id'] = prop_id # 修改property_value if value.get('option_id'): id = value['option_id'] already_exist = property_value.query.filter_by( id=id).first() # 判断是否要删除 if value.get('delete'): db.session.delete(already_exist) else: already_exist.option_value = value['option_value'] already_exist.option_name = value['option_name'] else: property_value.set_attrs(value) db.session.add(property_value) print('继续执行') return json.dumps({'status': 'success'})
def delete_all(cls): """Delete all matching items""" # Method - get all keys using wildcard search, # then delete key by key. redis_keys = cache.keys(cls.KEY % "*") for key in redis_keys: cache.delete(key) current_app.logger.info("Flushed %s keys for %s" % (len(redis_keys), cls.__name__))
def delete_by_id(id): deleted_user = load_user(id) if deleted_user is None: raise BadRequest("None exist user") cache.delete(str(id)) db.session.delete(deleted_user) db.session.commit() return jsonify(deleted_user=deleted_user.serialize)
def delete(self, path=None): if path: url = f"{PREFIX}/{path}" cache.delete(url) message = f"Deleted cache for {url}" else: cache.clear() message = "Caches cleared!" response = {"message": message} return jsonify(**response)
def post(self): ''' 提交回复 ''' if 'manager_id' not in session: return {'status_code': 400, 'message': 'illegal request'}, 400 manager_id = session['manager_id'] parser = reqparse.RequestParser() parser.add_argument('token', type=str) parser.add_argument('comment_id', type=int) parser.add_argument('content', type=str) parser.add_argument('blog_id', type=int) parser.add_argument('replied_id') parser.add_argument('replied_user_id') args = parser.parse_args() token = args['token'] if not token: return {'status_code': 400, 'message': 'bad requests'}, 400 comment_id = args['comment_id'] content = args['content'] blog_id = args['blog_id'] replied_id = args['replied_id'] if not replied_id: replied_id = None replied_user_id = args['replied_user_id'] if not replied_user_id: replied_user_id = None user_message = cache.get(token) if user_message is None: return {'status_code': 400, 'message': '登陆已过期'}, 400 user_id = user_message['id'] reply_message = addReply(comment_id=comment_id, user_id=user_id, content=content, manager_id=manager_id, blog_id=blog_id, replied_id=replied_id, replied_user_id=replied_user_id) if reply_message is not None: # 删除该blog_id下的comment_list缓存 cache.delete('blog_id_%s_comment' % blog_id) return { 'status_code': 200, 'message': 'add successfully', 'data': { 'reply_message': reply_message } } else: return { 'status_code': 400, 'message': 'some error happened, please check log' }, 400
def delete(self): ''' ''' parser = reqparse.RequestParser() parser.add_argument('token', type=str) args = parser.parse_args() token = args['token'] cache.delete(token) # 删除缓存中的用户信息 return { 'status_code': 200, 'message': '' }
def delete(self, path=None): if path: url = f"{PREFIX}/{path}" cache.delete(url) message = f"Deleted cache for {url}" else: cache.clear() message = "Caches cleared!" response = { "links": get_links(app.url_map.iter_rules()), "message": message } return jsonify(**response)
def post(self): ''' 提交评论,清除blog_id_{blog_id}的缓存 改用token验证 user_id通过缓存获取 ''' if 'manager_id' not in session: return {'status_code': 400, 'message': 'illegal request'}, 400 manager_id = session['manager_id'] parser = reqparse.RequestParser() parser.add_argument('token', type=str) parser.add_argument('blog_id', type=int) parser.add_argument('content', type=str) args = parser.parse_args() token = args['token'] if not token: return {'status_code': 400, 'message': 'bad requests'}, 400 blog_id = args['blog_id'] content = args['content'] cache.delete(('blog_id_%s' % blog_id)) ###清除blog的缓存 user_message = cache.get(token) ### 从缓存中获取用户信息 if user_message is None: return {'status_code': 400, 'message': '登陆已过期'}, 400 user_id = user_message['id'] post_time = cache.get('%s_comment_post' % user_id) if post_time: return {'status_code': 400, 'message': '请求频繁'}, 400 else: cache.set('%s_comment_post' % user_id, 1, timeout=30) comment_message = addComment(blog_id=blog_id, user_id=user_id, content=content, manager_id=manager_id) if comment_message is not None: # 删除该blog_id下的comment_list缓存 cache.delete('blog_id_%s_comment' % blog_id) return { 'status_code': 200, 'message': 'add successfully', 'data': { 'comment_message': comment_message } } else: return { 'status_code': 400, 'message': 'some error happened, please check log' }, 400
def delete_user(): """Delete current User and all his data""" username = current_user.username logout() user = User.query.filter(User.username == username).first_or_404() # TODO: delete_attachments(username) db.session.delete(user) db.session.commit() cache.delete("my_chats_by_" + username) return jsonify({"result": True}), 200
def get(self): query_args = self.parser.parse_args() email = query_args['email'] authcode = query_args['authcode'] res_from_cache = cache.get('auth_key:{}'.format(email)) if res_from_cache is None: raise CommonException('Timed out : re-authentication is needed') else: auth_code_from_cache = res_from_cache['code'] if authcode == auth_code_from_cache: cache.delete('auth_key:{}'.format(email)) from_db_user = User.query.filter(User.email == email).first() if from_db_user is None: res_from_cache['status'] = 'CONFIRM' res_from_cache['usertype'] = 'NEW' cache.set('auth_key:{}'.format(email), res_from_cache, timeout=1800) domain = email.split('@')[-1] university_from_db = University.query.filter( domain == domain).first() new_user = User() new_user.email = email new_user.password = '******' # TODO: username uniqueness check is needed new_user.username = random_digit_with_number() new_user.university = university_from_db.id db.session.add(new_user) try: db.session.commit() except Exception as e: return bad_request('internal error') else: res_from_cache['status'] = 'CONFIRM' res_from_cache['usertype'] = 'OLD' cache.set('auth_key:{}'.format(email), res_from_cache, timeout=1800) return ResponseWrapper.ok() else: return ResponseWrapper.ok('invalid auth_code', data={'errors': 'auth code check'})
def cached(base=None): """Reset all caches or remove a cached url by base Args: base (str): The base of the cached url to remove, e.g., 'lorem' Return: str: Response message """ if base: url = request.url.replace('delete/', '') msg = 'Cached URL "{}" deleted!'.format(url) cache.delete(url) else: msg = 'Caches reset!' cache.clear() return jsonify(status=204, objects=msg)
def delete_pkgs(pkgs): pkgs = json.loads(pkgs) try: db.session.query(Package).filter( Package.user_id == current_user.id, Package.track_no.in_(pkgs)).delete(synchronize_session='fetch') db.session.commit() # When user remove packages clear the cache cache.delete(current_user.username) flash('Package/s removed successfully.', 'info') return "OK" except Exception: db.session.rollback()
def download(filename): if not cache.has(filename): cache.delete(filename) abort(404) response = None try: output_file, data = cache.get(filename) response = make_response(data) response.headers[ "Content-Disposition"] = "attachment;filename={0}".format( output_file) except Exception as e: app.logger.error("failed to download: %s" % e) finally: cache.delete(filename) if not response: abort(500) return response
def wrapper(*args, **kwargs): lock_id = "celery-single-instance-" + func.__name__ check_lock = lambda: cache.get(lock_id) acquire_lock = lambda: cache.set(lock_id, True) release_lock = lambda: cache.delete(lock_id) if check_lock: acquire_lock() try: func(*args, **kwargs) finally: release_lock()
def add_pgp_key(armored: str) -> tuple: """ Adds a key to the database. :param armored: The armored key data to add to the keyring. :return: True and the keyid if the import succeeded, or: False and -1 if it was invalid, False and -2 if it already existed or False and -3 if it's a private key. """ if not '-----BEGIN PGP PUBLIC KEY BLOCK-----' in armored: return False, -3 # Dump the key data. newkey = keyinfo.KeyInfo.pgp_dump(armored) # You tried, pgpdump. And that's more than we could ever ask of you. if not isinstance(newkey, keyinfo.KeyInfo): return False, -1, None # Put the data into the database. # Show me on the doll where redis touched you. exists = db.Key.query.filter(db.Key.key_fp_id == newkey.shortid).first() if exists: if keyinfo.KeyInfo.from_database_object(exists) == newkey: return False, -2, None else: use_id = exists.id else: use_id = None key = db.Key.from_keyinfo(newkey) if not newkey.armored: key.armored = armored if use_id: key.id = use_id db.db.session.merge(key) db.db.session.commit() if cache.exists(key.key_fp_id + "-armor"): cache.delete(key.key_fp_id + "-armor") return True, newkey.shortid, key
def delete(domain, id, file): def _make_cache_key_query_string(args): args_as_sorted_tuple = tuple() if args: args_as_sorted_tuple = tuple( sorted((pair for pair in args.items()))) args_as_bytes = str(args_as_sorted_tuple).encode() hashed_args = str(hashlib.md5(args_as_bytes).hexdigest()) cache_key = request.path + hashed_args return cache_key if domain not in config.sites.values(): return jsonify({ 'status': 400, 'message': 'Domain is not available.' }), 400 secret = get_secret(request.headers) if config.sites.get(secret) != domain: return jsonify({ 'status': 400, 'message': 'You do not have access to this domain.' }), 400 image = Image.query.filter_by(domain=domain).filter_by(id=id).filter_by( filename=file).first() if not image: return jsonify({'status': 404, 'message': 'No image found.'}), 404 os.remove(image.get_path()) db.session.delete(image) db.session.commit() for size in sizes: cache.delete(_make_cache_key_query_string({'size': size})) cache.delete( _make_cache_key_query_string({ 'size': size, 'crop': 'true' })) cache.delete(_make_cache_key_query_string(dict())) return jsonify({"msg": "OK"}), 200
def delete(cls, cache_id): cache.delete(cls.KEY % cache_id)
def delete_session(cls, user_id, session_id): cache.delete(cls.KEY % {"user_id": user_id, "session_id": session_id})
def delete_all_sessions(cls, user_id): keys = cls.get_all_sessions(user_id) for key in keys: cache.delete(cls.KEY % {"user_id": user_id, "session_id": key})
def receive_after_category_event(mapper, category, target): print("receive_after_category_event for %(target)s" % { 'target': target }) cache.delete(cache_key_prefix(GET_CATEGORIES_PATH)) cache.delete(cache_key_prefix(GET_CONNECTIONS_PATH)) cache.delete(cache_key_prefix(GET_ENTITIES_PATH))
def receive_after_entity_event(mapper, connection, target): print("receive_after_entity_event for %(target)s" % { 'target': target }) cache.delete(cache_key_prefix(GET_CONNECTIONS_PATH)) cache.delete(cache_key_prefix(GET_ENTITIES_PATH))
def _clear_cache(): cache.delete(f"GET:{PREFIX}/data")
def create_model(question_id): from app import cache question = Question.query.filter_by(id=question_id).first() manager = Manager(question) manager.create_model() cache.delete('{0}_question_status')
def add_pkgs(): form = PackageForm() upload_form = UploadForm() if form.validate_on_submit(): try: package = Package(track_no=form.track_no.data, shipped_on=form.shipped_on.data, name=form.name.data, user=current_user) db.session.add(package) db.session.commit() # When user add new package clean cache cache.delete(current_user.username) flash('Package created successfully.', 'info') return redirect(url_for('info')) except IntegrityError: db.session.rollback() flash( 'There is package with tracking number: %s.' % form.track_no.data, 'warning') return redirect(url_for('info')) if 'file' in request.files: uploaded_file = request.files['file'] if uploaded_file: try: err_occ = False file_content = uploaded_file.read().decode('utf8') pkgs = [item.split(' - ') for item in file_content.split('\n')] total = 0 for track_no, shipped_on, pkg_name in pkgs: try: package = Package(track_no=track_no, shipped_on=parse(shipped_on, dayfirst=True), name=pkg_name, user=current_user) db.session.add(package) db.session.flush() total += 1 except IntegrityError: db.session.rollback() continue except Exception as ex: err_occ = True db.session.rollback() flash('Error occurred while syncing data.', 'warning') break if not err_occ: db.session.commit() if total: flash('Sync %s packages.' % total, 'info') return redirect(url_for('info')) else: flash('There is no packages for sync.', 'info') except Exception as ex: flash( 'Error occurred while reading file or invalid data format.', 'warning') return redirect(url_for('info'))