def logout():
# 如果用户名存在，则从会话中移除该用户名
session.pop('user_id', None)
session.pop('username', None)
# 清除缓存
cache.clear()
return redirect(url_for('app_front.login'))
def update():
'''
新增/编辑用户
'''
name = request.json.get('name')
permissions = request.json.get('permissions', 0)
id = request.json.get('id')
if not name:
raise JsonOutputException('请输入用户名');
if not id:
role = Role(
name=name,
permissions=permissions)
msg = '新增成功'
else:
role = Role.query.get_or_404(id)
role.name = name
role.permissions = permissions
msg = '编辑成功'
db.session.add(role)
try:
db.session.commit()
cache.clear()
except IntegrityError:
raise JsonOutputException('该用户名已被使用')
res = {'item': role.to_dict(), 'msg': msg}
return jsonify(res)
def test_endpoints(client):
"""Basic validation of endpoints integrity"""
res = client.get("/api/products/")
assert res.status_code == 200
filename = "test_products.csv"
create_product_data(filename)
assert len(Product.query.all()) == 5
# Clear cache to overcome 60s cache timeout
cache.clear()
res = client.get("/api/products/")
assert len(res.json["products"]) == 5
assert b"ABCDE00001" in res.data
res = client.get("/api/products/1")
assert res.status_code == 200
# Check PUT endpoint for review exists and handles empty data
res = client.put("/api/products/1")
assert res.status_code == 400
# Clean up temp data
os.remove(filename)
def test_same_post_database(self):
"""
Check that an error will be thrown if the
datetime primary key is already in the database
"""
user = User(email='yoda@' + current_app.config['MAIL_DOMAIN'],
password='******',
confirmed=True)
db.session.add(user)
db.session.commit()
response = self.client.post(
url_for('api_0_1.new_post'),
headers=self.get_api_headers(
'yoda@' + current_app.config['MAIL_DOMAIN'], 'DoOrDoNot',
True),
data=json.dumps(self.EXAMPLE_JSON_MESSAGE))
self.assertTrue(response.status_code == 201)
try:
cache.clear()
except RedisError:
print('Redis port is closed, the redis server '
'does not appear to be running.')
response = self.client.post(
url_for('api_0_1.new_post'),
headers=self.get_api_headers(
'yoda@' + current_app.config['MAIL_DOMAIN'], 'DoOrDoNot',
True),
data=json.dumps(self.EXAMPLE_JSON_MESSAGE))
self.assertTrue(
b'This datetime is already in the database.' in response.data)
self.assertTrue(response.status_code == 406)
def review_add(asin=None):
if request.method == 'PUT':
product = Product.query.filter(Product.asin == asin).first()
if not product:
return jsonify(status='error', errors=[{'message': ['No such product asin found']}])
try:
title = request.json.get('title')
review = request.json.get('review')
except AttributeError:
return jsonify(status='error', errors=[{'validation': ['Check out your JSON and headers']}])
if not title or not review:
return jsonify(status='error', errors=[{'validation': ['Fill title & review fields']}])
new_review = Review()
new_review.title = title
new_review.review = review
product.reviews.append(new_review)
db.session.add(new_review)
db.session.commit()
# TODO :)
cache.clear()
return jsonify(status='success')
return jsonify(status='error', errors=[{'message': 'Wrong request format'}])
def app():
os.environ['STAGE'] = 'test'
app = create_app()
user0 = User("Son", "*****@*****.**",
bcrypt.generate_password_hash("1234567aA").decode('utf8'))
user1 = User("Hoan", "*****@*****.**",
bcrypt.generate_password_hash("1234567bB").decode('utf8'))
user2 = User("Lam", "*****@*****.**",
bcrypt.generate_password_hash("1234567cC").decode('utf8'))
user3 = User("Hung", "*****@*****.**",
bcrypt.generate_password_hash("1234567dD").decode('utf8'))
user4 = User("Nam", "*****@*****.**",
bcrypt.generate_password_hash("1234567eE").decode('utf8'))
user5 = User("Viet", "*****@*****.**",
bcrypt.generate_password_hash("1234567fF").decode('utf8'))
user2.activated = True
user_list = [user0, user1, user2, user3, user4, user5]
for i in range(6):
db.session.add(user_list[i])
db.session.commit()
yield app
cache.clear()
db.session.remove()
db.drop_all()
def setUp(self):
cache.clear()
db.init_app(app)
db.create_all()
self.user = User.create(email="m",
name="m",
password=encrypt_password("m"),
active=True)
def accomplishment():
# handle case of employee not found in database
if g.employee is None:
flash('Not registered as a Product team member yet. Check back later!')
return redirect(url_for('index'))
cache.clear()
personstats = factory_accomplishment(u=g.employee.id)
return render_template('accomplishment.html', personstats=personstats)
def enstw_cache_clear():
password = request.values.get('password')
if password == 'bigdata123':
cache.clear()
datas = {'msg': 'Succeed to clear all'}
else:
datas = {'msg': 'Error, Password was wrong!'}
return jsonify(datas)
def reset():
"""Delete all cached urls
Return:
str: Caches reset
"""
cache.clear()
return jsonify(objects='Caches reset')
def stw_cache_clear():
password = request.values.get('password')
if password == 'bigdata123':
cache.clear()
data = {'msg': 'Successful! Clear All'}
else:
data = {'msg': 'Error, Password was wrong!'}
return jsonify(data)
def reset():
"""Delete all cached urls
Return:
str: Caches reset
"""
cache.clear()
return jsonify(objects='Caches reset')
def setUp(self):
super().setUp()
app.testing = True
cache.clear()
self.client = app.test_client()
# clear datastore
requests.post('http://%s/reset' % ndb_client.host)
self.ndb_context = ndb_client.context()
self.ndb_context.__enter__()
def tearDown(self):
"""Clost test environment"""
try:
cache.clear()
except RedisError:
print('Redis port is closed, the redis server '
'does not appear to be running.')
db.session.remove()
db.drop_all()
self.app_context.pop()
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 login():
if current_user.is_authenticated():
return abort(404)
form = LoginForm()
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data).first()
if user is not None and user.verify_password(form.password.data):
login_user(user, form.remember_me.data)
cache.clear()
return redirect(request.args.get('next') or url_for('main.index'))
flash(_('Mật khẩu và email không khớp'))
return render_template('auth/login.html', form=form)
def client():
"""Basic pytest fixture for Flask test client"""
app.config["TESTING"] = True
with app.test_client() as client:
cache.clear()
app_ctx = app.app_context()
app_ctx.push()
db.drop_all()
db.create_all()
yield client
db.session.remove()
db.drop_all()
app_ctx.pop()
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 save():
entity = None
data = json.loads(request.data)['entity']
if data['id']:
entity = Entity.query.get(data['id'])
elif data['name']:
entity = Entity(data['name'])
db.add(entity)
db.commit()
if entity:
update(entity, data)
cache.clear()
else:
print 'NO UPDATE'
return get_entities()
def delete():
app.secret_key = flask_session_secret_key
method = request.form.get('_method')
id = request.args.get('id')
if method == 'DELETE':
db.query(Collaboration) \
.filter(or_(Collaboration.entity_id1 == id, Collaboration.entity_id2 == id)) \
.delete(synchronize_session='evaluate')
db.query(Dataconnection) \
.filter(or_(Dataconnection.giver_id == id, Dataconnection.receiver_id == id)) \
.delete(synchronize_session='evaluate')
db.query(Employment) \
.filter(or_(Employment.entity_id1 == id, Employment.entity_id2 == id)) \
.delete(synchronize_session='evaluate')
db.query(Revenue).filter(Revenue.entity_id == id).delete(
synchronize_session='evaluate')
db.query(Expense).filter(Expense.entity_id == id).delete(
synchronize_session='evaluate')
db.query(Relation) \
.filter(or_(Relation.entity_id1 == id, Relation.entity_id2 == id)) \
.delete(synchronize_session='evaluate')
db.query(Fundingconnection) \
.filter(or_(Fundingconnection.giver_id == id, Fundingconnection.receiver_id == id)) \
.delete(synchronize_session='evaluate')
db.query(Edit).filter(Edit.entity_id == id).delete(
synchronize_session='evaluate')
db.execute("DELETE FROM location_table WHERE entity_id=" + id + ";")
db.execute("DELETE FROM category_table WHERE entity_id=" + id + ";")
db.execute("DELETE FROM keypeople_table WHERE entity_id=" + id + ";")
db.query(Entity).filter(Entity.id == id).delete(
synchronize_session='evaluate')
db.commit()
cache.clear()
flash("Delete was successful")
return redirect('/admin')
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 save():
app.logger.debug('SAVING')
app.logger.debug(request.data)
entity = None
data = json.loads(request.data)['entity']
if data['id']:
entity = Entity.query.get(data['id'])
elif data['name']:
app.logger.debug('ADDING NEW ENTITY ' + str(data['name']))
entity = Entity(str(data['name']))
db.add(entity)
db.commit()
if entity:
app.logger.debug('UPDATING ENTITY ' + entity.name)
update(entity, data)
cache.clear()
else:
app.logger.debug('NO UPDATE')
return get_entities()
def save():
app.logger.debug('SAVING')
app.logger.debug(request.data)
entity = None
data = json.loads(request.data)['entity']
if data['id']:
entity = Entity.query.get(data['id'])
elif data['name']:
app.logger.debug('ADDING NEW ENTITY ' + str(data['name']))
entity = Entity(str(data['name']))
db.add(entity)
db.commit()
if entity:
app.logger.debug('UPDATING ENTITY ' + entity.name)
update(entity, data)
cache.clear()
else:
app.logger.debug('NO UPDATE')
return get_entities()
def delete():
app.secret_key = flask_session_secret_key
method = request.form.get('_method')
id = request.args.get('id')
if method == 'DELETE':
db.query(Collaboration) \
.filter(or_(Collaboration.entity_id1 == id, Collaboration.entity_id2 == id)) \
.delete(synchronize_session='evaluate')
db.query(Dataconnection) \
.filter(or_(Dataconnection.giver_id == id, Dataconnection.receiver_id == id)) \
.delete(synchronize_session='evaluate')
db.query(Employment) \
.filter(or_(Employment.entity_id1 == id, Employment.entity_id2 == id)) \
.delete(synchronize_session='evaluate')
db.query(Revenue).filter(Revenue.entity_id == id).delete(synchronize_session='evaluate')
db.query(Expense).filter(Expense.entity_id == id).delete(synchronize_session='evaluate')
db.query(Relation) \
.filter(or_(Relation.entity_id1 == id, Relation.entity_id2 == id)) \
.delete(synchronize_session='evaluate')
db.query(Fundingconnection) \
.filter(or_(Fundingconnection.giver_id == id, Fundingconnection.receiver_id == id)) \
.delete(synchronize_session='evaluate')
db.query(Edit).filter(Edit.entity_id == id).delete(synchronize_session='evaluate')
db.execute("DELETE FROM location_table WHERE entity_id=" + id + ";")
db.execute("DELETE FROM category_table WHERE entity_id=" + id + ";")
db.execute("DELETE FROM keypeople_table WHERE entity_id=" + id + ";")
db.query(Entity).filter(Entity.id == id).delete(synchronize_session='evaluate')
db.commit()
cache.clear()
flash("Delete was successful")
return redirect('/admin')
def save():
app.logger.debug('SAVING')
app.logger.debug(request.data)
entity = None
data = json.loads(request.data)['entity']
data["ip"] = request.remote_addr
data["edit_type"] = None
if data['id']:
entity = Entity.query.get(data['id'])
elif data['name']:
app.logger.debug('ADDING NEW ENTITY ' + data['name'])
data["edit_type"] = "create"
entity = Entity(data['name'])
db.add(entity)
db.commit()
if entity:
if not data["edit_type"]:
data["edit_type"] = "update"
app.logger.debug('UPDATING ENTITY ' + entity.name)
update(entity, data)
cache.clear()
else:
app.logger.debug('NO UPDATE')
return get_entities()
def save():
jsonData = json.loads(request.data)
app.logger.debug(jsonData)
if 'Event-Name' in request.headers:
save_event_data(request)
if 'optOut' in jsonData and jsonData['optOut']:
return get_entities(request)
entity = None
data = jsonData['entity']
data["ip"] = request.remote_addr
data["edit_type"] = None
if data['id']:
entity = Entity.query.get(data['id'])
elif data['name']:
data["edit_type"] = "create"
entity = Entity(data['name'])
db.add(entity)
db.commit()
if entity:
if not data["edit_type"]:
data["edit_type"] = "update"
update(entity, data)
cache.clear()
return get_entities()
def save():
# app.logger.debug(request.data)
jsonData = json.loads(request.data)
if 'Event-Name' in request.headers:
save_event_data(request)
if 'optOut' in jsonData and jsonData['optOut']:
return get_entities()
entity = None
data = jsonData['entity']
data["ip"] = request.remote_addr
data["edit_type"] = None
if data['id']:
entity = Entity.query.get(data['id'])
elif data['name']:
data["edit_type"] = "create"
entity = Entity(data['name'])
db.add(entity)
db.commit()
if entity:
if not data["edit_type"]:
data["edit_type"] = "update"
update(entity, data)
cache.clear()
return get_entities()
def tearDown(self):
cache.clear()
patch.stopall()
def clear_cache(self):
from app import cache
cache.clear()
return redirect_back(u'缓存已经成功更新。')
import sys
import os
sys.path.insert(1, os.path.join(sys.path[0], '..'))
from app import app as application
from app import cache
if __name__ == '__main__':
if len(sys.argv) > 1:
if sys.argv[1] == '--clearcache':
cache.clear()
print "Cleared the cache"
exit()
application.run(debug=application.config['DEBUG'],
port=application.config['PORT'],
host=application.config['HOST'])
def logout():
logout_user()
cache.clear()
flash(_('Bạn đã đăng xuất thành công'))
return redirect(url_for('main.index'))
def claerCache():
cache.clear()
return 'is over'
import apps
from modules.environment import DEBUG_MODE, SERVER_HOST, SERVER_PORT
from modules.logging import logging
logging.info('main.py - DEBUG_MODE: %s', DEBUG_MODE)
logging.info('main.py - SERVER_HOST: %s', SERVER_HOST)
logging.info('main.py - SERVER_PORT: %s\n', SERVER_PORT)
app.layout = Div([Location(id='url', refresh=False), Div(id='page-content')])
@app.callback(Output('page-content', 'children'), [Input('url', 'pathname')])
def display_page(pathname):
if pathname == '{}/'.format(url_base_pathname):
return apps.layout_index
if pathname == '{}/download'.format(url_base_pathname):
return apps.layout_download
elif pathname == '{}/scene'.format(url_base_pathname):
return apps.layout_scene
else:
return apps.layout_error_404
if __name__ == '__main__':
# clear cache at the beginning
with server.app_context():
logging.info('main.py - clearing cache...')
cache.clear()
app.run_server(debug=DEBUG_MODE, host=SERVER_HOST, port=SERVER_PORT)
def clearCache():
cache.clear()
return "cache is clear"
def save_event_data(request):
eventName = request.headers['Event-Name']
data = json.loads(request.data)['entity']
app.logger.debug(data)
setEventData(eventName, data)
cache.clear()
def clearCache():
cache.clear()
return 'cache is cleared'
def reset():
""" Deletes the entire cache
"""
cache.clear()
return jsonify(result='Caches reset')
def delete_cache(n):
if n == 0:
return
cache.clear()
def tearDown(self):
cache.clear()
db.drop_all()
patch.stopall()
def setUp(self):
cache.clear()
db.init_app(app)
db.create_all()
self.user = User.create(email="m", name="m", password=encrypt_password("m"), active=True)
if '-Pos-' in hash_guide:
return results_page.clusterPage(job_id, hash_guide.split('#')[1]), URL + '/load' + search
return results_page.resultPage(job_id), URL + '/load' + search
# if path == '/genome-dictionary-management':
# return personalization_page.genomeAndDictionaryManagement(), URL + '/load' + search
if path == '/user-guide':
return help_page.helpPage(), URL + '/load' + search
if path == '/contacts':
return contacts_page.contactPage(), URL + '/load' + search
if path == '/history':
return history_page.historyPage(), URL + '/load' + search
# if path == '/genomes':
# genomes_page = html.Div(genome_database.get_genomes(
# current_working_directory), style={'margin': '1%'})
# return genomes_page, URL + '/load' + search
if path == '/index':
return main_page.indexPage(), '/index'
return main_page.indexPage(), '/index'
if __name__ == '__main__':
directoryCheck()
# if '--debug' in sys.argv[1:]:
app.run_server(host='0.0.0.0', port=8080, debug=False,
dev_tools_ui=False, dev_tools_props_check=False)
cache.clear() # delete cache when server is closed
# else:
# app.run_server(host='0.0.0.0', port=80, debug=False,
# dev_tools_ui=False, dev_tools_props_check=False)
# cache.clear() # delete cache when server is closed
def logout():
logout_user()
cache.clear()
return redirect(url_for('main.index'))
def clear_cache_before_shutdown():
cache.clear()
def save_event_data(request):
eventName = request.headers['Event-Name']
data = json.loads(request.data)['entity']
# app.logger.debug(data)
setEventData(eventName, data)
cache.clear()
def reset():
""" Deletes the entire cache
"""
cache.clear()
return jsonify(result='Caches reset')
def tearDown(self):
cache.clear()
