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 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 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 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 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'))
