def get_journals(): """Get journals.""" key = request.values.get('key') if not key: return jsonify({}) datastore = RedisStore( redis.StrictRedis.from_url(current_app.config['CACHE_REDIS_URL'])) cache_key = current_app.config['WEKO_WORKFLOW_OAPOLICY_SEARCH'].format( keyword=key) if datastore.redis.exists(cache_key): data = datastore.get(cache_key) multiple_result = json.loads(data.decode('utf-8'), object_pairs_hook=OrderedDict) else: multiple_result = search_romeo_jtitles(key, 'starts') if key else {} try: datastore.put( cache_key, json.dumps(multiple_result).encode('utf-8'), ttl_secs=int( current_app.config['WEKO_WORKFLOW_OAPOLICY_CACHE_TTL'])) except Exception: pass return jsonify(multiple_result)
def test_sessionstore_default_ttl_secs(app): """Test the `default_ttl_secs` field for simplekv sessionstore backends using the TimeToLive-mixin (http://pythonhosted.org/simplekv/index.html#simplekv.TimeToLiveMixin)""" ttl_seconds = 1 ttl_delta = datetime.timedelta(0, ttl_seconds) sessionstore = RedisStore(redis.StrictRedis()) sessionstore.default_ttl_secs = ttl_seconds ext = InvenioAccounts(app, sessionstore=sessionstore) app.register_blueprint(blueprint) # Verify that the backend supports ttl assert ext.sessionstore.ttl_support user = testutils.create_test_user() with app.test_client() as client: testutils.login_user_via_view(client, user=user) sid = testutils.unserialize_session(flask.session.sid_s) while not sid.has_expired(ttl_delta): pass # When we get here the session should have expired. # But the client is still authenticated. assert testutils.client_authenticated(client)
def shib_login(): """Get shibboleth user login page. :return: confirm user page when relation is empty """ try: shib_session_id = request.args.get('SHIB_ATTR_SESSION_ID', None) if shib_session_id is None or len(shib_session_id) == 0: return redirect(url_for_security('login')) datastore = RedisStore( redis.StrictRedis.from_url(current_app.config['CACHE_REDIS_URL'])) cache_key = config.SHIB_CACHE_PREFIX + shib_session_id if not datastore.redis.exists(cache_key): return redirect(url_for_security('login')) cache_val = datastore.get(cache_key) if cache_val is None: datastore.delete(cache_key) return redirect(url_for_security('login')) cache_val = json.loads(str(cache_val, encoding='utf-8')) session['shib_session_id'] = shib_session_id csrf_random = generate_random_str(length=64) session['csrf_random'] = csrf_random return render_template(config.WEKO_ACCOUNTS_CONFIRM_USER_TEMPLATE, csrf_random=csrf_random, email=cache_val['shib_mail'] if len(cache_val['shib_mail']) > 0 else '') except BaseException: current_app.logger.error('Unexpected error: ', sys.exc_info()[0]) return abort(400)
def on_register(self): # TODO: Add authentication support for redis try: redis_instance = redis.StrictRedis( host=os.environ.get('REDIS_URL', 'localhost'), db=self.engine.config['database']['index']) redis_instance.ping() self.DB = RedisStore(redis_instance) except Exception as e: tools.log(e) sys.stderr.write( 'Redis connection cannot be established!\nFalling to SQLAlchemy' ) return False try: self.salt = self.DB.get('salt').decode() if self.salt is None: raise Exception except Exception as e: self.salt = ''.join( random.choice(string.ascii_uppercase + string.digits) for _ in range(5)) self.DB.put('salt', self.salt.encode()) return True
def shib_sp_login(): """The request from shibboleth sp. :return: confirm page when relation is empty """ try: if not current_app.config['SHIB_ACCOUNTS_LOGIN_ENABLED']: return url_for_security('login') shib_session_id = request.form.get('SHIB_ATTR_SESSION_ID', None) if shib_session_id is None or len(shib_session_id) == 0: return url_for_security('login') shib_attr, error = parse_attributes() if error: return url_for_security('login') datastore = RedisStore( redis.StrictRedis.from_url(current_app.config['CACHE_REDIS_URL'])) ttl_sec = int(current_app.config['SHIB_ACCOUNTS_LOGIN_CACHE_TTL']) datastore.put(config.SHIB_CACHE_PREFIX + shib_session_id, bytes(json.dumps(shib_attr), encoding='utf-8'), ttl_secs=ttl_sec) shib_user = ShibUser(shib_attr) rst = shib_user.get_relation_info() """ check the relation of shibboleth user with weko account""" next_url = 'weko_accounts.shib_auto_login' if rst is None: """relation is not existed, cache shibboleth info to redis.""" next_url = 'weko_accounts.shib_login' query_string = { 'SHIB_ATTR_SESSION_ID': shib_session_id, '_method': 'GET' } return url_for(next_url, **query_string) except BaseException: current_app.logger.error('Unexpected error: ', sys.exc_info()[0]) return url_for_security('login')
def get_redis_cache(cache_key): """Check and then retrieve the value of a Redis cache key.""" try: datastore = RedisStore(redis.StrictRedis.from_url( current_app.config['CACHE_REDIS_URL'])) if datastore.redis.exists(cache_key): return datastore.get(cache_key).decode('utf-8') except Exception as e: current_app.logger.error('Could get value for ' + cache_key, e) return None
def convert_item_metadata(self, index_obj): """ 1. Convert Item Metadata 2. Inject index tree id to dict 3. Set Publish Status :param index_obj: :return: dc """ # if this item has been deleted self.delete_es_index_attempt(self.pid) try: actions = index_obj.get('actions', 'private') datastore = RedisStore(redis.StrictRedis.from_url( current_app.config['CACHE_REDIS_URL'])) cache_key = current_app.config[ 'WEKO_DEPOSIT_ITEMS_CACHE_PREFIX'].format( pid_value=self.pid.pid_value) data_str = datastore.get(cache_key) datastore.delete(cache_key) data = json.loads(data_str) except: abort(500, 'Failed to register item') # Get index path index_lst = index_obj.get('index', []) plst = Indexes.get_path_list(index_lst) if not plst or len(index_lst) != len(plst): raise PIDResolveRESTError(description='Any tree index has been deleted') index_lst.clear() for lst in plst: index_lst.append(lst.path) # convert item meta data dc, jrc, is_edit = json_loader(data, self.pid) self.data = data self.jrc = jrc self.is_edit = is_edit # Save Index Path on ES jrc.update(dict(path=index_lst)) dc.update(dict(path=index_lst)) pubs = '1' if 'private' in actions else '0' ps = dict(publish_status=pubs) jrc.update(ps) dc.update(ps) return dc
def iframe_index(item_type_id=0): """Renders an item register view. :param item_type_id: Item type ID. (Default: 0) :return: The rendered template. """ try: item_type = ItemTypes.get_by_id(item_type_id) if item_type is None: return render_template('weko_items_ui/iframe/error.html', error_type='no_itemtype') json_schema = '/items/jsonschema/{}'.format(item_type_id) schema_form = '/items/schemaform/{}'.format(item_type_id) sessionstore = RedisStore(redis.StrictRedis.from_url( 'redis://{host}:{port}/1'.format( host=os.getenv('INVENIO_REDIS_HOST', 'localhost'), port=os.getenv('INVENIO_REDIS_PORT', '6379')))) record = {} files = [] endpoints = {} activity_session = session['activity_info'] activity_id = activity_session.get('activity_id', None) if activity_id and sessionstore.redis.exists( 'activity_item_'+activity_id): item_str = sessionstore.get('activity_item_'+activity_id) item_json = json.loads(item_str) if 'metainfo' in item_json: record = item_json.get('metainfo') if 'files' in item_json: files = item_json.get('files') if 'endpoints' in item_json: endpoints = item_json.get('endpoints') need_file = False if 'filename' in json.dumps(item_type.schema): need_file = True return render_template( 'weko_items_ui/iframe/item_edit.html', need_file=need_file, record=record, jsonschema=json_schema, schemaform=schema_form, id=item_type_id, item_save_uri=url_for('.iframe_save_model'), files=files, endpoints=endpoints ) except: current_app.logger.error('Unexpected error: ', sys.exc_info()[0]) return abort(400)
def delete_schema_cache(schema_name): """ delete schema cache on redis :param schema_name: :return: """ try: # schema cached on Redis by schema name datastore = RedisStore(redis.StrictRedis.from_url( current_app.config['CACHE_REDIS_URL'])) cache_key = current_app.config[ 'WEKO_SCHEMA_CACHE_PREFIX'].format(schema_name=schema_name) datastore.delete(cache_key) except BaseException: pass
def shib_sp_login(): """The request from shibboleth sp. :return: confirm page when relation is empty """ _shib_enable = current_app.config['WEKO_ACCOUNTS_SHIB_LOGIN_ENABLED'] _shib_username_config = current_app.config[ 'WEKO_ACCOUNTS_SHIB_ALLOW_USERNAME_INST_EPPN'] try: shib_session_id = request.form.get('SHIB_ATTR_SESSION_ID', None) if not shib_session_id and not _shib_enable: flash(_("Missing SHIB_ATTR_SESSION_ID!"), category='error') return redirect(url_for_security('login')) shib_attr, error = parse_attributes() # Check SHIB_ATTR_EPPN and SHIB_ATTR_USER_NAME: if error or not (shib_attr.get('shib_eppn', None) or _shib_username_config and shib_attr.get('shib_user_name')): flash(_("Missing SHIB_ATTRs!"), category='error') return _redirect_method() datastore = RedisStore( redis.StrictRedis.from_url(current_app.config['CACHE_REDIS_URL'])) ttl_sec = int(current_app.config['WEKO_ACCOUNTS_SHIB_LOGIN_CACHE_TTL']) datastore.put(current_app.config['WEKO_ACCOUNTS_SHIB_CACHE_PREFIX'] + shib_session_id, bytes(json.dumps(shib_attr), encoding='utf-8'), ttl_secs=ttl_sec) shib_user = ShibUser(shib_attr) # Check the relation of shibboleth user with weko account. rst = shib_user.get_relation_info() next_url = 'weko_accounts.shib_auto_login' if not rst: # Relation is not existed, cache shibboleth info to redis. next_url = 'weko_accounts.shib_login' query_string = { 'SHIB_ATTR_SESSION_ID': shib_session_id, '_method': 'GET' } return url_for(next_url, **query_string) except BaseException: current_app.logger.error('Unexpected error: ', sys.exc_info()[0]) return _redirect_method()
def extensions_load(app): db.init_app(app) migrate.init_app(app, db) JWTManager(app) redis_store = FlaskRedis() redis_store.init_app(app) app.config['JWT_BLACKLIST_STORE'] = RedisStore(redis_store)
def create_app(): """Application creation factory.""" from myweatherapp.views import ui_blueprint from myweatherapp.api import api_blueprint # Config app._static_folder = 'static' app.config.update(CFG_SITE_NAME='myweatherapp', ) app.config.from_pyfile('config.py', silent=True) app.config['cache'] = RedisStore(redis.StrictRedis()) @app.errorhandler(404) def page_not_found(e): return render_template('404.html'), 404 @app.context_processor def override_url_for(): return dict(url_for=dated_url_for) def dated_url_for(endpoint, **values): if endpoint == 'static': filename = values.get('filename', None) if filename: file_path = os.path.join(app.root_path, endpoint, filename) values['q'] = int(os.stat(file_path).st_mtime) return url_for(endpoint, **values) # Blueprints app.register_blueprint(ui_blueprint) app.register_blueprint(api_blueprint, url_prefix='/api') return app
def shib_login(): """Get shibboleth user login page. :return: confirm user page when relation is empty """ try: shib_session_id = request.args.get('SHIB_ATTR_SESSION_ID', None) if not shib_session_id: current_app.logger.error(_("Missing SHIB_ATTR_SESSION_ID!")) flash(_("Missing SHIB_ATTR_SESSION_ID!"), category='error') return _redirect_method() datastore = RedisStore( redis.StrictRedis.from_url(current_app.config['CACHE_REDIS_URL'])) cache_key = current_app.config[ 'WEKO_ACCOUNTS_SHIB_CACHE_PREFIX'] + shib_session_id if not datastore.redis.exists(cache_key): current_app.logger.error(_("Missing SHIB_CACHE_PREFIX!")) flash(_("Missing SHIB_CACHE_PREFIX!"), category='error') return _redirect_method() cache_val = datastore.get(cache_key) if not cache_val: current_app.logger.error(_("Missing SHIB_ATTR!")) flash(_("Missing SHIB_ATTR!"), category='error') datastore.delete(cache_key) return _redirect_method() cache_val = json.loads(str(cache_val, encoding='utf-8')) session['shib_session_id'] = shib_session_id csrf_random = generate_random_str(length=64) session['csrf_random'] = csrf_random _datastore = LocalProxy( lambda: current_app.extensions['security'].datastore) user = _datastore.find_user(email=cache_val.get('shib_mail')) return render_template( current_app.config['WEKO_ACCOUNTS_CONFIRM_USER_TEMPLATE'], csrf_random=csrf_random, email=user.email if user else '') except BaseException: current_app.logger.error('Unexpected error: ', sys.exc_info()[0]) return abort(400)
def setUp(self): self.redis = redis.StrictRedis( host=testconf.get('redis', 'host'), port=int(testconf.get('redis', 'port')) ) self.redis.flushdb() self.store = RedisStore(self.redis)
def shib_auto_login(): """Create new account and auto login when shibboleth user first login. :return: next url """ try: is_auto_bind = False shib_session_id = request.args.get('SHIB_ATTR_SESSION_ID', None) if not shib_session_id: shib_session_id = session['shib_session_id'] is_auto_bind = True if not shib_session_id: return _redirect_method() datastore = RedisStore( redis.StrictRedis.from_url(current_app.config['CACHE_REDIS_URL'])) cache_key = current_app.config[ 'WEKO_ACCOUNTS_SHIB_CACHE_PREFIX'] + shib_session_id if not datastore.redis.exists(cache_key): return _redirect_method() cache_val = datastore.get(cache_key) if not cache_val: datastore.delete(cache_key) return _redirect_method() cache_val = json.loads(str(cache_val, encoding='utf-8')) shib_user = ShibUser(cache_val) if not is_auto_bind: shib_user.get_relation_info() else: shib_user.new_relation_info() error = shib_user.check_in() if error: datastore.delete(cache_key) current_app.logger.error(error) flash(error, category='error') return _redirect_method() if shib_user.shib_user: shib_user.shib_user_login() datastore.delete(cache_key) return redirect(session['next'] if 'next' in session else '/') except BaseException: current_app.logger.error('Unexpected error: ', sys.exc_info()[0]) return abort(400)
def __init__(self, app=None): """Extension initialization.""" if app: self.init_app(app) store = RedisStore( redis.StrictRedis(host=app.config.get( 'ACCESS_SESSION_REDIS_HOST', 'localhost'))) KVSessionExtension(store, app)
def iframe_items_index(pid_value=0): try: if pid_value == 0: return redirect(url_for('.iframe_index')) if request.method == 'GET': return render_template( 'weko_items_ui/iframe/item_index.html', pid_value=pid_value) if request.headers['Content-Type'] != 'application/json': flash(_('invalide request'), 'error') return render_template( 'weko_items_ui/iframe/item_index.html') data = request.get_json() sessionstore = RedisStore(redis.StrictRedis.from_url( 'redis://{host}:{port}/1'.format( host=os.getenv('INVENIO_REDIS_HOST', 'localhost'), port=os.getenv('INVENIO_REDIS_PORT', '6379')))) if request.method == 'PUT': """update index of item info.""" item_str = sessionstore.get('item_index_{}'.format(pid_value)) sessionstore.delete('item_index_{}'.format(pid_value)) current_app.logger.debug(item_str) item = json.loads(item_str) item['index'] = data current_app.logger.debug(item) elif request.method == 'POST': """update item data info.""" current_app.logger.debug(data) sessionstore.put('item_index_{}'.format(pid_value), json.dumps(data), ttl_secs=300) return jsonify(data) except: current_app.logger.error('Unexpected error: ', sys.exc_info()[0]) return abort(400)
def shib_auto_login(): """Create new account and auto login when shibboleth user first login. :return: next url """ try: is_auto_bind = False shib_session_id = request.args.get('SHIB_ATTR_SESSION_ID', None) if shib_session_id is None: shib_session_id = session['shib_session_id'] is_auto_bind = True if shib_session_id is None or len(shib_session_id) == 0: return redirect(url_for_security('login')) datastore = RedisStore( redis.StrictRedis.from_url(current_app.config['CACHE_REDIS_URL'])) cache_key = config.SHIB_CACHE_PREFIX + shib_session_id if not datastore.redis.exists(cache_key): return redirect(url_for_security('login')) cache_val = datastore.get(cache_key) if cache_val is None: datastore.delete(cache_key) return redirect(url_for_security('login')) cache_val = json.loads(str(cache_val, encoding='utf-8')) shib_user = ShibUser(cache_val) if not is_auto_bind: shib_user.get_relation_info() else: shib_user.new_relation_info() if shib_user.shib_user is not None: shib_user.shib_user_login() datastore.delete(cache_key) return redirect(session['next'] if 'next' in session else '/') except BaseException: current_app.logger.error('Unexpected error: ', sys.exc_info()[0]) return abort(400)
def create_app(config_name): application = Flask(__name__, static_folder='static/', static_url_path=configs[config_name].ASSET_PATH) init_app(application, configs[config_name], bootstrap=bootstrap, data_api_client=data_api_client, login_manager=login_manager) if application.config['REDIS_SESSIONS']: vcap_services = parse_vcap_services() redis_opts = { 'ssl': application.config['REDIS_SSL'], 'ssl_ca_certs': application.config['REDIS_SSL_CA_CERTS'], 'ssl_cert_reqs': application.config['REDIS_SSL_HOST_REQ'] } if vcap_services and 'redis' in vcap_services: redis_opts['host'] = vcap_services['redis'][0]['credentials'][ 'hostname'] redis_opts['port'] = vcap_services['redis'][0]['credentials'][ 'port'] redis_opts['password'] = vcap_services['redis'][0]['credentials'][ 'password'] else: redis_opts['host'] = application.config['REDIS_SERVER_HOST'] redis_opts['port'] = application.config['REDIS_SERVER_PORT'] redis_opts['password'] = application.config[ 'REDIS_SERVER_PASSWORD'] session_store = RedisStore(redis.StrictRedis(**redis_opts)) KVSessionExtension(session_store, application) application.permanent_session_lifetime = timedelta(hours=12) from .main import main as main_blueprint from .status import status as status_blueprint url_prefix = application.config['URL_PREFIX'] application.register_blueprint(status_blueprint, url_prefix=url_prefix) application.register_blueprint(main_blueprint, url_prefix=url_prefix) login_manager.login_view = 'main.render_login' main_blueprint.config = application.config.copy() init_frontend_app(application, data_api_client, login_manager) application.add_template_filter(parse_document_upload_time) @application.context_processor def extra_template_variables(): return { 'generic_contact_email': application.config['GENERIC_CONTACT_EMAIL'], } return application
def item_login(item_type_id=0): """Return information that item register need. :param item_type_id: Item type ID. (Default: 0) """ template_url = 'weko_items_ui/iframe/item_edit.html' need_file = False record = {} json_schema = '' schema_form = '' item_save_uri = url_for('weko_items_ui.iframe_save_model') files = [] endpoints = {} try: item_type = ItemTypes.get_by_id(item_type_id) if item_type is None: template_url = 'weko_items_ui/iframe/error.html' json_schema = '/items/jsonschema/{}'.format(item_type_id) schema_form = '/items/schemaform/{}'.format(item_type_id) sessionstore = RedisStore(redis.StrictRedis.from_url( 'redis://{host}:{port}/1'.format( host=os.getenv('INVENIO_REDIS_HOST', 'localhost'), port=os.getenv('INVENIO_REDIS_PORT', '6379')))) activity_session = session['activity_info'] activity_id = activity_session.get('activity_id', None) if activity_id and sessionstore.redis.exists( 'activity_item_' + activity_id): item_str = sessionstore.get('activity_item_' + activity_id) item_json = json.loads(item_str) if 'metainfo' in item_json: record = item_json.get('metainfo') if 'files' in item_json: files = item_json.get('files') if 'endpoints' in item_json: endpoints = item_json.get('endpoints') if 'filename' in json.dumps(item_type.schema): need_file = True except Exception as e: template_url = 'weko_items_ui/iframe/error.html' current_app.logger.debug(str(e)) return template_url, need_file, record, json_schema, \ schema_form, item_save_uri, files, endpoints
def create_app(self): from app.app import create_app app = create_app(__name__) app.config['TESTING'] = True self.r = fakeredis.FakeStrictRedis() app.extensions['redis'] = self.r app.config['JWT_BLACKLIST_STORE'] = RedisStore(self.r) return app
def put(self, **kwargs): """""" try: data = request.get_json() pid = kwargs.get('pid_value').value # item metadata cached on Redis by pid import redis from simplekv.memory.redisstore import RedisStore datastore = RedisStore(redis.StrictRedis.from_url( current_app.config['CACHE_REDIS_URL'])) cache_key = current_app.config[ 'WEKO_DEPOSIT_ITEMS_CACHE_PREFIX'].format(pid_value=pid) ttl_sec = int(current_app.config['WEKO_DEPOSIT_ITEMS_CACHE_TTL']) datastore.put(cache_key, json.dumps(data), ttl_secs=ttl_sec) except BaseException: abort(400, "Failed to register item") return jsonify({'status': 'success'})
def iframe_save_model(): """Renders an item register view. :return: The rendered template. """ try: data = request.get_json() activity_session = session['activity_info'] activity_id = activity_session.get('activity_id', None) if activity_id: sessionstore = RedisStore( redis.StrictRedis.from_url('redis://{host}:{port}/1'.format( host=os.getenv('INVENIO_REDIS_HOST', 'localhost'), port=os.getenv('INVENIO_REDIS_PORT', '6379')))) sessionstore.put('activity_item_' + activity_id, json.dumps(data).encode('utf-8'), ttl_secs=60 * 60 * 24 * 7) except Exception as ex: current_app.logger.exception(str(ex)) return jsonify(code=1, msg='Model save error') return jsonify(code=0, msg='Model save success')
def upt_activity_item(app, item_id): """ Connect to the item_created signal. :param app: :param item_id: :return: """ if 'activity_info' in session: activity = session['activity_info'] workactivity = WorkActivity() rtn = workactivity.upt_activity_item(activity, item_id.object_uuid) if rtn: del session['activity_info'] sessionstore = RedisStore( redis.StrictRedis.from_url('redis://{host}:{port}/1'.format( host=os.getenv('INVENIO_REDIS_HOST', 'localhost'), port=os.getenv('INVENIO_REDIS_PORT', '6379')))) activity_id = activity.get('activity_id', None) if activity_id and sessionstore.redis.exists('activity_item_' + activity_id): sessionstore.delete('activity_item_' + activity_id)
def run_server(): print "Starting server..." if not app.debug: Flask.logger = getLogger("production") else: Flask.logger = getLogger("develop") app.logger.info("Starting server on: " + app.config['address'] + ":" + str(app.config['port'])) app.storekv = RedisStore(redis.StrictRedis()) http_server = WSGIServer((app.config['address'], app.config['port']), app, handler_class=WebSocketHandler) # @IgnorePep8 http_server.serve_forever()
def store(self): from simplekv.memory.redisstore import RedisStore r = StrictRedis() try: r.get('anything') except ConnectionError: pytest.skip('Could not connect to redis server') r.flushdb() yield RedisStore(r) r.flushdb()
def iframe_items_index(pid_value=0): """Iframe items index.""" try: if pid_value == 0: return redirect(url_for('.iframe_index')) record = WekoRecord.get_record_by_pid(pid_value) action = 'private' if record.get('publish_status', '1') == '1' \ else 'publish' if request.method == 'GET': return render_template( 'weko_items_ui/iframe/item_index.html', render_widgets=True, pid_value=pid_value, action=action, activity=session['itemlogin_activity'], item=session['itemlogin_item'], steps=session['itemlogin_steps'], action_id=session['itemlogin_action_id'], cur_step=session['itemlogin_cur_step'], record=session['itemlogin_record'], histories=session['itemlogin_histories'], res_check=session['itemlogin_res_check'], pid=session['itemlogin_pid'], community_id=session['itemlogin_community_id']) if request.headers['Content-Type'] != 'application/json': flash(_('Invalid Request'), 'error') return render_template('weko_items_ui/iframe/item_index.html', render_widgets=True) data = request.get_json() sessionstore = RedisStore( redis.StrictRedis.from_url('redis://{host}:{port}/1'.format( host=os.getenv('INVENIO_REDIS_HOST', 'localhost'), port=os.getenv('INVENIO_REDIS_PORT', '6379')))) if request.method == 'PUT': """update index of item info.""" item_str = sessionstore.get('item_index_{}'.format(pid_value)) sessionstore.delete('item_index_{}'.format(pid_value)) current_app.logger.debug(item_str) item = json.loads(item_str) item['index'] = data current_app.logger.debug(item) elif request.method == 'POST': """update item data info.""" sessionstore.put('item_index_{}'.format(pid_value), json.dumps(data), ttl_secs=300) return jsonify(data) except BaseException: current_app.logger.error('Unexpected error: ', sys.exc_info()[0]) return abort(400)
def items_index(pid_value='0'): """Items index.""" try: if pid_value == '0' or pid_value == 0: return redirect(url_for('.index')) record = WekoRecord.get_record_by_pid(pid_value) action = 'private' if record.get('publish_status', '1') == '1' \ else 'publish' from weko_theme.utils import get_design_layout # Get the design for widget rendering page, render_widgets = get_design_layout( current_app.config['WEKO_THEME_DEFAULT_COMMUNITY']) if request.method == 'GET': return render_template( current_app.config['WEKO_ITEMS_UI_INDEX_TEMPLATE'], page=page, render_widgets=render_widgets, pid_value=pid_value, action=action) if request.headers['Content-Type'] != 'application/json': flash(_('Invalid request'), 'error') return render_template( current_app.config['WEKO_ITEMS_UI_INDEX_TEMPLATE'], page=page, render_widgets=render_widgets) data = request.get_json() sessionstore = RedisStore( redis.StrictRedis.from_url('redis://{host}:{port}/1'.format( host=os.getenv('INVENIO_REDIS_HOST', 'localhost'), port=os.getenv('INVENIO_REDIS_PORT', '6379')))) if request.method == 'PUT': """update index of item info.""" item_str = sessionstore.get('item_index_{}'.format(pid_value)) sessionstore.delete('item_index_{}'.format(pid_value)) current_app.logger.debug(item_str) item = json.loads(item_str) item['index'] = data current_app.logger.debug(item) elif request.method == 'POST': """update item data info.""" sessionstore.put('item_index_{}'.format(pid_value), json.dumps(data), ttl_secs=300) return jsonify(data) except BaseException: current_app.logger.error('Unexpected error: ', sys.exc_info()[0]) return abort(400)
def check_validation_error_msg(activity_id): """Check whether sessionstore('updated_json_schema_') is exist. :param activity_id: The identify of Activity. :return: Show error message """ sessionstore = RedisStore( redis.StrictRedis.from_url('redis://{host}:{port}/1'.format( host=os.getenv('INVENIO_REDIS_HOST', 'localhost'), port=os.getenv('INVENIO_REDIS_PORT', '6379')))) if sessionstore.redis.exists( 'updated_json_schema_{}'.format(activity_id)) \ and sessionstore.get('updated_json_schema_{}'.format(activity_id)): session_data = sessionstore.get( 'updated_json_schema_{}'.format(activity_id)) error_list = json.loads(session_data.decode('utf-8')) msg = [] if error_list.get('error_type'): if error_list.get('error_type') == 'no_resource_type': msg.append(_(error_list.get('msg', ''))) else: msg.append(_('PID does not meet the conditions.')) if error_list.get('pmid'): msg.append( _('Since PMID is not subject to DOI registration, please ' 'select another type.')) if error_list.get('doi'): msg.append( _('Prefix/Suffix of Identifier is not consistency with' ' content of Identifier Registration.')) if error_list.get('url'): msg.append( _('Please input location information (URL) for Identifier.')) return jsonify(code=1, msg=msg, error_list=error_list) else: return jsonify(code=0)
def default_session_store_factory(app): """Session store factory. If ``ACCOUNTS_SESSION_REDIS_URL`` is set, it returns a :class:`simplekv.memory.redisstore.RedisStore` otherwise a :class:`simplekv.memory.DictStore`. """ accounts_session_redis_url = app.config.get('ACCOUNTS_SESSION_REDIS_URL') if accounts_session_redis_url: import redis from simplekv.memory.redisstore import RedisStore return RedisStore( redis.StrictRedis.from_url(accounts_session_redis_url)) from simplekv.memory import DictStore return DictStore()