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 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 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 reset_redis_cache(cache_key, value):
"""Delete and then reset a cache value to Redis."""
try:
datastore = RedisStore(redis.StrictRedis.from_url(
current_app.config['CACHE_REDIS_URL']))
datastore.delete(cache_key)
datastore.put(cache_key, value.encode('utf-8'))
except Exception as e:
current_app.logger.error('Could not reset redis value', e)
raise
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 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 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 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_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 confirm_user():
"""Check weko user info.
:return:
"""
try:
if request.form.get('csrf_random', '') != session['csrf_random']:
flash('csrf_random', category='error')
return _redirect_method()
shib_session_id = session['shib_session_id']
if not shib_session_id:
flash('shib_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):
flash('cache_key', category='error')
return _redirect_method()
cache_val = datastore.get(cache_key)
if not cache_val:
flash('cache_val', category='error')
datastore.delete(cache_key)
return _redirect_method()
cache_val = json.loads(str(cache_val, encoding='utf-8'))
shib_user = ShibUser(cache_val)
account = request.form.get('WEKO_ATTR_ACCOUNT', None)
password = request.form.get('WEKO_ATTR_PWD', None)
if not shib_user.check_weko_user(account, password):
flash('check_weko_user', category='error')
datastore.delete(cache_key)
return _redirect_method()
if not shib_user.bind_relation_info(account):
flash('FAILED bind_relation_info!', category='error')
return _redirect_method()
error = shib_user.check_in()
if error:
datastore.delete(cache_key)
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 cache_schema(schema_name, delete=False):
"""
Cache the schema to Redis.
:param schema_name:
:return:
"""
def get_schema():
try:
rec = WekoSchema.get_record_by_name(schema_name)
if rec:
dstore = dict()
dstore['root_name'] = rec.get('root_name')
dstore['target_namespace'] = rec.get('target_namespace')
dstore['schema_location'] = rec.get('schema_location')
dstore['namespaces'] = rec.model.namespaces.copy()
dstore['schema'] = json.loads(rec.model.xsd,
object_pairs_hook=OrderedDict)
rec.model.namespaces.clear()
del rec
return dstore
except BaseException:
return None
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)
data_str = datastore.get(cache_key)
data = json.loads(data_str.decode('utf-8'),
object_pairs_hook=OrderedDict)
if delete:
datastore.delete(cache_key)
except BaseException:
try:
schema = get_schema()
if schema:
datastore.put(cache_key, json.dumps(schema))
except BaseException:
return get_schema()
else:
return schema
return data
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 index(self):
cache_key = current_app.config['WEKO_ADMIN_CACHE_PREFIX'].\
format(name='display_stats')
current_display_setting = True # Default
datastore = RedisStore(
redis.StrictRedis.from_url(current_app.config['CACHE_REDIS_URL']))
if datastore.redis.exists(cache_key):
curr_display_setting = datastore.get(cache_key).decode('utf-8')
current_display_setting = True if curr_display_setting == 'True' \
else False
if request.method == 'POST':
display_setting = request.form.get('record_stats_radio', 'True')
datastore.delete(cache_key)
datastore.put(cache_key, display_setting.encode('utf-8'))
flash(_('Successfully Changed Settings.'))
return redirect(url_for('statssettings.index'))
return self.render(
current_app.config["WEKO_ADMIN_STATS_SETTINGS_TEMPLATE"],
display_stats=current_display_setting)
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 confirm_user():
"""Check weko user info.
:return:
"""
try:
csrf_random = request.form.get('csrf_random', '')
if csrf_random != session['csrf_random']:
return redirect(url_for_security('login'))
shib_session_id = session['shib_session_id']
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)
account = request.form.get('WEKO_ATTR_ACCOUNT', None)
password = request.form.get('WEKO_ATTR_PWD', None)
if not shib_user.check_weko_user(account, password):
datastore.delete(cache_key)
return redirect(url_for_security('login'))
shib_user.bind_relation_info(account)
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 iframe_items_index(pid_value='0'):
"""Iframe items index."""
try:
if pid_value == '0' or 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'
community_id = session.get('itemlogin_community_id')
ctx = {'community': None}
if community_id:
comm = GetCommunity.get_community_by_id(community_id)
ctx = {'community': comm}
if request.method == 'GET':
cur_activity = session['itemlogin_activity']
# If enable auto set index feature
# and activity is usage application item type
steps = session['itemlogin_steps']
contain_application_endpoint = False
for step in steps:
if step.get('ActionEndpoint') == 'item_login_application':
contain_application_endpoint = True
enable_auto_set_index = current_app.config.get(
'WEKO_WORKFLOW_ENABLE_AUTO_SET_INDEX_FOR_ITEM_TYPE')
if enable_auto_set_index and contain_application_endpoint:
index_id = get_index_id(cur_activity.activity_id)
update_index_tree_for_record(pid_value, index_id)
return redirect(url_for('weko_workflow.iframe_success'))
# Get the design for widget rendering
from weko_theme.utils import get_design_layout
page, render_widgets = get_design_layout(
community_id
or current_app.config['WEKO_THEME_DEFAULT_COMMUNITY'])
return render_template('weko_items_ui/iframe/item_index.html',
page=page,
render_widgets=render_widgets,
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=community_id,
**ctx)
if request.headers['Content-Type'] != 'application/json':
flash(_('Invalid Request'), 'error')
from weko_theme.utils import get_design_layout
page, render_widgets = get_design_layout(
current_app.config['WEKO_THEME_DEFAULT_COMMUNITY'])
return render_template('weko_items_ui/iframe/item_index.html',
page=page,
render_widgets=render_widgets,
community_id=community_id,
**ctx)
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))
item = json.loads(item_str)
item['index'] = data
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 next_action(activity_id='0', action_id=0):
"""Next action."""
work_activity = WorkActivity()
history = WorkActivityHistory()
post_json = request.get_json()
activity = dict(activity_id=activity_id,
action_id=action_id,
action_version=post_json.get('action_version'),
action_status=ActionStatusPolicy.ACTION_DONE,
commond=post_json.get('commond'))
action = Action().get_action_detail(action_id)
action_endpoint = action.action_endpoint
if action_endpoint == 'begin_action':
return jsonify(code=0, msg=_('success'))
if action_endpoint == 'end_action':
work_activity.end_activity(activity)
return jsonify(code=0, msg=_('success'))
if action_endpoint == 'item_login':
register_hdl(activity_id)
activity_detail = work_activity.get_activity_detail(activity_id)
item_id = None
recid = None
record = None
pid_without_ver = None
if activity_detail and activity_detail.item_id:
item_id = activity_detail.item_id
current_pid = PersistentIdentifier.get_by_object(pid_type='recid',
object_type='rec',
object_uuid=item_id)
recid = get_record_identifier(current_pid.pid_value)
record = WekoDeposit.get_record(item_id)
if record:
pid_without_ver = get_record_without_version(current_pid)
deposit = WekoDeposit(record, record.model)
if post_json.get('temporary_save') == 1 \
and action_endpoint != 'identifier_grant':
if 'journal' in post_json:
work_activity.create_or_update_action_journal(
activity_id=activity_id,
action_id=action_id,
journal=post_json.get('journal'))
else:
work_activity.upt_activity_action_comment(
activity_id=activity_id,
action_id=action_id,
comment=post_json.get('commond'))
return jsonify(code=0, msg=_('success'))
elif post_json.get('journal'):
work_activity.create_or_update_action_journal(
activity_id=activity_id,
action_id=action_id,
journal=post_json.get('journal'))
if action_endpoint == 'approval' and item_id:
item = ItemsMetadata.get_record(id_=item_id)
pid_identifier = PersistentIdentifier.get_by_object(
pid_type='depid', object_type='rec', object_uuid=item.id)
record_class = import_string('weko_deposit.api:WekoRecord')
resolver = Resolver(pid_type='recid',
object_type='rec',
getter=record_class.get_record)
_pid, _approval_record = resolver.resolve(pid_identifier.pid_value)
action_feedbackmail = work_activity.get_action_feedbackmail(
activity_id=activity_id, action_id=ITEM_REGISTRATION_ACTION_ID)
if action_feedbackmail:
FeedbackMailList.update(
item_id=item_id,
feedback_maillist=action_feedbackmail.feedback_maillist)
if not recid and pid_without_ver:
FeedbackMailList.update(
item_id=pid_without_ver.object_uuid,
feedback_maillist=action_feedbackmail.feedback_maillist)
if record:
deposit.update_feedback_mail()
deposit.update_jpcoar_identifier()
# TODO: Make private as default.
# UpdateItem.publish(pid, approval_record)
if action_endpoint == 'item_link' and record:
current_pid = PersistentIdentifier.get_by_object(pid_type='recid',
object_type='rec',
object_uuid=item_id)
if not pid_without_ver:
pid_without_ver = get_record_without_version(current_pid)
item_link = ItemLink(pid_without_ver.pid_value)
relation_data = post_json.get('link_data')
if relation_data:
errors = item_link.update(relation_data)
if errors:
return jsonify(code=-1, msg=_(errors))
# save pidstore_identifier to ItemsMetadata
identifier_select = post_json.get('identifier_grant')
if 'identifier_grant' == action_endpoint and identifier_select:
idf_grant_jalc_doi_manual = post_json.get(
'identifier_grant_jalc_doi_suffix')
idf_grant_jalc_cr_doi_manual = post_json.get(
'identifier_grant_jalc_cr_doi_suffix')
idf_grant_jalc_dc_doi_manual = post_json.get(
'identifier_grant_jalc_dc_doi_suffix')
idf_grant_ndl_jalc_doi_manual = post_json.get(
'identifier_grant_ndl_jalc_doi_suffix')
# If is action identifier_grant, then save to to database
identifier_grant = {
'action_identifier_select': identifier_select,
'action_identifier_jalc_doi': idf_grant_jalc_doi_manual,
'action_identifier_jalc_cr_doi': idf_grant_jalc_cr_doi_manual,
'action_identifier_jalc_dc_doi': idf_grant_jalc_dc_doi_manual,
'action_identifier_ndl_jalc_doi': idf_grant_ndl_jalc_doi_manual
}
work_activity.create_or_update_action_identifier(
activity_id=activity_id,
action_id=action_id,
identifier=identifier_grant)
error_list = item_metadata_validation(item_id, identifier_select)
if post_json.get('temporary_save') == 1:
return jsonify(code=0, msg=_('success'))
if isinstance(error_list, str):
return jsonify(code=-1, msg=_(error_list))
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 error_list:
sessionstore.put('updated_json_schema_{}'.format(activity_id),
json.dumps(error_list).encode('utf-8'),
ttl_secs=300)
return previous_action(activity_id=activity_id,
action_id=action_id,
req=-1)
else:
if sessionstore.redis.exists(
'updated_json_schema_{}'.format(activity_id)):
sessionstore.delete(
'updated_json_schema_{}'.format(activity_id))
if identifier_select != IDENTIFIER_GRANT_SELECT_DICT['NotGrant'] \
and item_id is not None:
record_without_version = item_id
if record and pid_without_ver and not recid:
record_without_version = pid_without_ver.object_uuid
saving_doi_pidstore(item_id, record_without_version, post_json,
int(identifier_select))
rtn = history.create_activity_history(activity)
if not rtn:
return jsonify(code=-1, msg=_('error'))
# next action
work_activity.upt_activity_action_status(
activity_id=activity_id,
action_id=action_id,
action_status=ActionStatusPolicy.ACTION_DONE)
work_activity.upt_activity_action_comment(activity_id=activity_id,
action_id=action_id,
comment='')
flow = Flow()
next_flow_action = flow.get_next_flow_action(
activity_detail.flow_define.flow_id, action_id)
if next_flow_action and len(next_flow_action) > 0:
next_action_endpoint = next_flow_action[0].action.action_endpoint
if 'end_action' == next_action_endpoint:
new_activity_id = None
if record:
deposit.publish()
updated_item = UpdateItem()
# publish record without version ID when registering newly
if recid:
# new record attached version ID
ver_attaching_record = deposit.newversion(current_pid)
new_activity_id = ver_attaching_record.model.id
ver_attaching_deposit = WekoDeposit(
ver_attaching_record, ver_attaching_record.model)
ver_attaching_deposit.publish()
record_bucket_id = merge_buckets_by_records(
current_pid.object_uuid,
ver_attaching_record.model.id,
sub_bucket_delete=True)
if not record_bucket_id:
return jsonify(code=-1, msg=_('error'))
# Record without version: Make status Public as default
updated_item.publish(record)
else:
# update to record without version ID when editing
new_activity_id = record.model.id
if pid_without_ver:
record_without_ver = WekoDeposit.get_record(
pid_without_ver.object_uuid)
deposit_without_ver = WekoDeposit(
record_without_ver, record_without_ver.model)
deposit_without_ver['path'] = deposit.get('path', [])
parent_record = deposit_without_ver.\
merge_data_to_record_without_version(current_pid)
deposit_without_ver.publish()
set_bucket_default_size(new_activity_id)
merge_buckets_by_records(new_activity_id,
pid_without_ver.object_uuid)
updated_item.publish(parent_record)
delete_unregister_buckets(new_activity_id)
activity.update(
action_id=next_flow_action[0].action_id,
action_version=next_flow_action[0].action_version,
item_id=new_activity_id,
)
work_activity.end_activity(activity)
else:
next_action_id = next_flow_action[0].action_id
work_activity.upt_activity_action(
activity_id=activity_id,
action_id=next_action_id,
action_status=ActionStatusPolicy.ACTION_DOING)
# delete session value
if session.get('itemlogin_id'):
del session['itemlogin_id']
del session['itemlogin_activity']
del session['itemlogin_item']
del session['itemlogin_steps']
del session['itemlogin_action_id']
del session['itemlogin_cur_step']
del session['itemlogin_record']
del session['itemlogin_res_check']
del session['itemlogin_pid']
del session['itemlogin_community_id']
return jsonify(code=0, msg=_('success'))
class DatabaseService(Service):
"""
Database bindings for leveldb
"""
def __init__(self, engine):
Service.__init__(self, name='database')
self.engine = engine
self.DB = None
self.salt = None
self.req_count = 0
self.set_state(Service.INIT)
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
@sync
def get(self, key):
"""gets the key in args[0] using the salt"""
try:
return yaml.load(self.DB.get(self.salt + str(key)).decode())
except Exception as e:
return None
@sync
def put(self, key, value):
"""
Puts the val in args[1] under the key in args[0] with the salt
prepended to the key.
"""
try:
self.DB.put(self.salt + str(key), yaml.dump(value).encode())
return True
except Exception as e:
return False
@sync
def exists(self, key):
"""
Checks if the key in args[0] with the salt prepended is
in the database.
"""
try:
return (self.salt + str(key)) in self.DB
except KeyError:
return False
@sync
def delete(self, key):
"""
Removes the entry in the database under the the key in args[0]
with the salt prepended.
"""
try:
self.DB.delete(self.salt + str(key))
return True
except:
return False
def convert_item_metadata(self, index_obj, data=None):
"""Convert Item Metadat.
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')
if not data:
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.decode('utf-8'))
except BaseException:
abort(500, 'Failed to register item')
# Get index path
index_lst = index_obj.get('index', [])
# Prepare index id list if the current index_lst is a path list
if index_lst:
index_id_lst = []
for index in index_lst:
indexes = str(index).split('/')
index_id_lst.append(indexes[len(indexes) - 1])
index_lst = index_id_lst
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))
# add at 20181121 start
sub_sort = {}
for pth in index_lst:
# es setting
sub_sort[pth[-13:]] = ""
jrc.update(dict(custom_sort=sub_sort))
dc.update(dict(custom_sort=sub_sort))
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
