instance_status = {
"data_version": fields.Integer(),
"end_production_date": fields.String(),
"is_connected_to_rabbitmq": fields.Boolean(),
"last_load_at": fields.String(),
"last_rt_data_loaded": fields.String(),
"last_load_status": fields.Boolean(),
"kraken_version": fields.String(attribute="navitia_version"),
"nb_threads": fields.Integer(),
"publication_date": fields.String(),
"start_production_date": fields.String(),
"status": fields.String(),
"is_open_data": fields.Boolean(),
"is_realtime_loaded": fields.Boolean(),
"realtime_proxies": fields.Raw(),
}
instance_parameters = {
'scenario': fields.Raw(attribute='_scenario_name'),
'journey_order': fields.Raw,
'max_walking_duration_to_pt': fields.Raw,
'max_bike_duration_to_pt': fields.Raw,
'max_bss_duration_to_pt': fields.Raw,
'max_car_duration_to_pt': fields.Raw,
'max_nb_transfers': fields.Raw,
'walking_speed': fields.Raw,
'bike_speed': fields.Raw,
'bss_speed': fields.Raw,
'car_speed': fields.Raw,
'min_bike': fields.Raw,
instance_status = {
"data_version": fields.Integer(),
"end_production_date": fields.String(),
"is_connected_to_rabbitmq": fields.Boolean(),
"last_load_at": fields.String(),
"last_rt_data_loaded": fields.String(),
"last_load_status": fields.Boolean(),
"kraken_version": fields.String(attribute="navitia_version"),
"nb_threads": fields.Integer(),
"publication_date": fields.String(),
"start_production_date": fields.String(),
"status": fields.String(),
}
instance_parameters = {
'scenario': fields.Raw(attribute='_scenario_name'),
'journey_order': fields.Raw,
'max_walking_duration_to_pt': fields.Raw,
'max_bike_duration_to_pt': fields.Raw,
'max_bss_duration_to_pt': fields.Raw,
'max_car_duration_to_pt': fields.Raw,
'max_nb_transfers': fields.Raw,
'walking_speed': fields.Raw,
'bike_speed': fields.Raw,
'bss_speed': fields.Raw,
'car_speed': fields.Raw,
'min_bike': fields.Raw,
'min_car': fields.Raw,
'min_bss': fields.Raw,
'min_tc_with_bike': fields.Raw,
'min_tc_with_car': fields.Raw,
class upload(DepositionType):
"""
ZENODO deposition workflow
"""
workflow = [
p.IF_ELSE(
has_submission,
# Existing deposition
[
# Load initial record
load_record(draft_id='_edit', post_process=process_draft),
# Render the form and wait until it is completed
render_form(draft_id='_edit'),
],
# New deposition
[
# Load pre-filled data from cache
prefill_draft(draft_id='_default'),
# Render the form and wait until it is completed
render_form(draft_id='_default'),
# Test if all files are available for API
api_validate_files(),
]),
# Create the submission information package by merging data
# from all drafts - i.e. generate the recjson.
prepare_sip(),
p.IF_ELSE(
has_submission,
[
# Process SIP recjson
process_sip_metadata(process_recjson_edit),
# Merge SIP metadata into record and generate MARC
merge_record(
draft_id='_edit',
post_process_load=process_draft,
process_export=process_recjson_edit,
),
# Set file restrictions
process_bibdocfile(process=process_files),
# Merge communities
#merge_communities,
],
[
# Check for reserved recids.
reserved_recid(),
# Reserve a new record id
create_recid(),
# Register DOI in internal pid store.
mint_pid(
pid_field='doi',
pid_store_type='doi',
pid_creator=lambda recjson: create_doi(recid=recjson[
'recid'])['doi'],
existing_pid_checker=check_existing_pid,
),
# Process SIP metadata
process_sip_metadata(process_recjson_new),
]),
# Generate MARC based on recjson structure
finalize_record_sip(),
p.IF_ELSE(
has_submission,
[
# Seal the SIP and write MARCXML file and call bibupload on it
upload_record_sip(),
# Schedule background tasks.
run_tasks(update=True),
],
[
# Note: after upload_record_sip(), has_submission will return
# True no matter if it's a new or editing of a deposition.
upload_record_sip(),
run_tasks(update=False),
]),
]
name = "Upload"
name_plural = "Uploads"
editable = True
stopable = True
enabled = True
default = True
api = True
draft_definitions = {
'_default': ZenodoForm,
'_edit': ZenodoEditForm,
}
marshal_metadata_fields = dict(
access_right=fields.String,
communities=fields.List(fields.Raw),
conference_acronym=fields.String,
conference_dates=fields.String,
conference_place=fields.String,
conference_title=fields.String,
conference_url=fields.String,
creators=fields.Raw(default=[]),
description=fields.String,
doi=fields.String(default=''),
embargo_date=ISODate,
grants=fields.List(fields.Raw),
image_type=fields.String(default=''),
imprint_isbn=fields.String,
imprint_place=fields.String,
imprint_publisher=fields.String,
journal_issue=fields.String,
journal_pages=fields.String,
journal_title=fields.String,
journal_volume=fields.String,
keywords=fields.Raw(default=[]),
license=fields.String,
notes=fields.String(default=''),
partof_pages=fields.String,
partof_title=fields.String,
prereserve_doi=fields.Raw,
publication_date=ISODate,
publication_type=fields.String(default=''),
related_identifiers=fields.Raw(default=[]),
thesis_supervisors=fields.Raw(default=[]),
title=fields.String,
upload_type=fields.String,
)
marshal_metadata_edit_fields = marshal_metadata_fields.copy()
del marshal_metadata_edit_fields['prereserve_doi']
#marshal_metadata_edit_fields.update(dict(
# recid=fields.Integer,
# version_id=UTCISODateTime,
#))
marshal_deposition_fields = DepositionType.marshal_deposition_fields.copy()
del marshal_deposition_fields['drafts']
marshal_draft_fields = DepositionType.marshal_draft_fields.copy()
marshal_draft_fields['metadata'] = fields.Nested(marshal_metadata_fields,
attribute='values')
del marshal_draft_fields['id']
del marshal_draft_fields['completed']
@classmethod
def default_draft_id(cls, deposition):
if deposition.has_sip() and '_edit' in deposition.drafts:
return '_edit'
return '_default'
@classmethod
def marshal_deposition(cls, deposition):
"""
Generate a JSON representation for REST API of a Deposition
"""
# Get draft
if deposition.has_sip() and '_edit' in deposition.drafts:
draft = deposition.get_draft('_edit')
metadata_fields = cls.marshal_metadata_edit_fields
elif deposition.has_sip():
# FIXME: Not based on latest available data in record.
sip = deposition.get_latest_sip(sealed=True)
draft = record_to_draft(create_record(sip.package),
post_process=process_draft)
metadata_fields = cls.marshal_metadata_edit_fields
else:
draft = deposition.get_or_create_draft('_default')
metadata_fields = cls.marshal_metadata_fields
# Fix known differences in marshalling
draft.values = filter_empty_elements(draft.values)
if 'grants' not in draft.values:
draft.values['grants'] = []
# Set disabled values to None in output
for field, flags in draft.flags.items():
if 'disabled' in flags and field in draft.values:
del draft.values[field]
# Marshal deposition
obj = marshal(deposition, cls.marshal_deposition_fields)
# Marshal the metadata attribute
obj['metadata'] = marshal(unicodifier(draft.values), metadata_fields)
# Add record and DOI information from latest SIP
for sip in deposition.sips:
if sip.is_sealed():
recjson = sip.metadata
if recjson.get('recid'):
obj['record_id'] = fields.Integer().format(
recjson.get('recid'))
obj['record_url'] = fields.String().format(
url_for('record.metadata',
recid=recjson.get('recid'),
_external=True))
if recjson.get('doi') and \
recjson.get('doi').startswith(CFG_DATACITE_DOI_PREFIX+"/"):
obj['doi'] = fields.String().format(recjson.get('doi'))
obj['doi_url'] = fields.String().format(
"http://dx.doi.org/%s" % obj['doi'])
break
return obj
@classmethod
def marshal_draft(cls, obj):
"""
Generate a JSON representation for REST API of a DepositionDraft
"""
return marshal(obj, cls.marshal_draft_fields)
@classmethod
def api_action(cls, deposition, action_id):
if action_id == 'publish':
return deposition.run_workflow(headless=True)
elif action_id == 'edit':
# Trick: Works in combination with load_record task to provide
# proper response codes to API clients.
if deposition.state == 'done' or deposition.drafts:
deposition.reinitialize_workflow()
return deposition.run_workflow(headless=True)
elif action_id == 'discard':
deposition.stop_workflow()
deposition.save()
return deposition.marshal(), 201
raise InvalidApiAction(action_id)
@classmethod
def api_metadata_schema(cls, draft_id):
schema = super(upload, cls).api_metadata_schema(draft_id)
if schema and draft_id == '_edit':
if 'recid' in schema['schema']:
del schema['schema']['recid']
if 'version_id' in schema['schema']:
del schema['schema']['version_id']
return schema
@classmethod
def render_completed(cls, d):
"""
Render page when deposition was successfully completed
"""
ctx = dict(
deposition=d,
deposition_type=(None if d.type.is_default() else
d.type.get_identifier()),
uuid=d.id,
my_depositions=Deposition.get_depositions(current_user,
type=d.type),
sip=d.get_latest_sip(),
format_record=format_record,
)
return render_template('webdeposit_completed.html', **ctx)
class upload(DepositionType):
"""
LW DAAP deposition workflow
"""
workflow = [
p.IF_ELSE(has_submission,
[
# existing record, let user edit
load_record(draft_id='_edit',
post_process=process_draft),
render_form(draft_id='_edit'),
],
[
# new deposition
prefill_draft(draft_id='_metadata'),
render_form(draft_id='_metadata'),
],
),
p.IF_NOT(
skip_files,
[
p.IF_ELSE(is_api_request,
# Test all files are availables for API
api_validate_files(),
# ELSE render the files form
render_form(draft_id='_files')),
process_file_descriptions(),
],
),
# merge all drafts (default + files)
prepare_sip(),
p.IF_ELSE(has_submission,
[
# Process SIP recjson
process_sip_metadata(process_recjson_edit),
# Merge SIP metadata into record and generate MARC
merge_record(
draft_id='_edit',
post_process_load=process_draft,
process_export=process_recjson_edit,
merge_func=merge,
),
# Set file restrictions
process_bibdocfile(process=process_files),
],
[
# Create new record ID
create_recid(),
# do some stuff
process_sip_metadata(process_recjson_new),
],
),
# generate MARC
finalize_record_sip(),
# and let bibupload do the magic
upload_record_sip(),
p.IF(has_doi, [run_tasks(update=False)]),
]
name = "Upload"
name_plural = "Uploads"
editable = True
stopable = True
enabled = True
default = True
api = True
marshal_period_fields = dict(
start=ISODate,
end=ISODate
)
marshal_metadata_fields = dict(
access_right=fields.String,
access_conditions=fields.String,
access_groups=fields.List(fields.Raw),
app_env=fields.Raw(),
communities=fields.List(fields.Raw),
creators=fields.Raw(),
description=fields.String,
doi=fields.String(),
embargo_date=ISODate,
flavor=fields.Raw(default=''),
frequency=fields.Raw(),
keywords=fields.Raw(),
license=fields.String,
notes=fields.String(),
os=fields.Raw(),
period=fields.List(fields.Nested(marshal_period_fields)),
project=fields.String,
publication_date=ISODate,
record_selected_for_archive=fields.Boolean,
record_curated_in_project=fields.Boolean,
record_public_from_project=fields.Boolean,
rel_dataset=fields.List(fields.Raw),
rel_software=fields.List(fields.Raw),
related_identifiers=fields.Raw(),
spatial=fields.Raw(),
subjects=fields.Raw(),
title=fields.String,
upload_type=fields.String,
)
marshal_metadata_edit_fields = marshal_metadata_fields.copy()
# marshal_metadata_edit_fields.update(dict(
# recid=fields.Integer,
# version_id=UTCISODateTime,
# ))
marshal_deposition_fields = DepositionType.marshal_deposition_fields.copy()
del marshal_deposition_fields['drafts']
marshal_draft_fields = DepositionType.marshal_draft_fields.copy()
marshal_draft_fields['metadata'] = fields.Nested(
marshal_metadata_fields, attribute='values'
)
del marshal_draft_fields['id']
del marshal_draft_fields['completed']
@classmethod
def default_draft_id(cls, deposition):
if deposition.has_sip() and '_edit' in deposition.drafts:
return '_edit'
return '_metadata'
@classmethod
def marshal_deposition(cls, deposition):
"""
Generate a JSON representation for REST API of a Deposition
"""
# Get draft
if deposition.has_sip() and '_edit' in deposition.drafts:
draft = deposition.get_draft('_edit')
metadata_fields = cls.marshal_metadata_edit_fields
elif deposition.has_sip():
# FIXME: Not based on latest available data in record.
sip = deposition.get_latest_sip(sealed=True)
draft = record_to_draft(
Record.create(sip.package, master_format='marc'),
post_process=process_draft
)
metadata_fields = cls.marshal_metadata_edit_fields
else:
draft = deposition.get_or_create_draft('_metadata')
metadata_fields = cls.marshal_metadata_fields
# Fix known differences in marshalling
current_app.logger.debug(draft.values)
draft.values = filter_empty_elements(draft.values)
current_app.logger.debug(draft.values)
# Set disabled values to None in output
for field, flags in draft.flags.items():
if 'disabled' in flags and field in draft.values:
current_app.logger.debug(field)
del draft.values[field]
# Marshal deposition
obj = marshal(deposition, cls.marshal_deposition_fields)
# Marshal the metadata attribute
obj['metadata'] = marshal(unicodifier(draft.values), metadata_fields)
# Add record and DOI information from latest SIP
for sip in deposition.sips:
if sip.is_sealed():
recjson = sip.metadata
if recjson.get('recid'):
obj['record_id'] = fields.Integer().format(
recjson.get('recid')
)
obj['record_url'] = fields.String().format(url_for(
'record.metadata',
recid=recjson.get('recid'),
_external=True
))
if (recjson.get('doi') and recjson.get('doi').startswith(
cfg['CFG_DATACITE_DOI_PREFIX'] + "/")):
obj['doi'] = fields.String().format(recjson.get('doi'))
obj['doi_url'] = fields.String().format(
"http://dx.doi.org/%s" % obj['doi']
)
break
return obj
@classmethod
def marshal_draft(cls, obj):
"""
Generate a JSON representation for REST API of a DepositionDraft
"""
return marshal(obj, cls.marshal_draft_fields)
@classmethod
def api_action(cls, deposition, action_id):
if action_id == 'publish':
return deposition.run_workflow(headless=True)
elif action_id == '_edit':
# Trick: Works in combination with load_record task to provide
# proper response codes to API clients.
if deposition.state == 'done' or deposition.drafts:
deposition.reinitialize_workflow()
return deposition.run_workflow(headless=True)
elif action_id == 'discard':
deposition.stop_workflow()
deposition.save()
return deposition.marshal(), 201
raise InvalidApiAction(action_id)
@classmethod
def api_metadata_schema(cls, draft_id):
schema = super(upload, cls).api_metadata_schema(draft_id)
if schema and draft_id == '_edit':
if 'recid' in schema['schema']:
del schema['schema']['recid']
if 'modification_date' in schema['schema']:
del schema['schema']['modification_date']
return schema
@classmethod
def render_completed(cls, d):
"""
Render page when deposition was successfully completed
"""
ctx = dict(
deposition=d,
deposition_type=(
None if d.type.is_default() else d.type.get_identifier()
),
uuid=d.id,
my_depositions=Deposition.get_depositions(
current_user, type=d.type
),
sip=d.get_latest_sip(),
format_record=format_record,
)
return render_template('deposit/completed.html', **ctx)
"""
distances = {'bike': fields.Raw, 'car': fields.Raw, 'walking': fields.Raw}
durations = {
'bike': fields.Raw,
'car': fields.Raw,
'total': fields.Raw,
'walking': fields.Raw
}
section = {
"duration": fields.Raw,
"departure_date_time": fields.Raw,
"arrival_date_time": fields.Raw,
'from': fields.Raw(attribute='from.name'),
'to': fields.Raw(attribute='to.name'),
'type': fields.Raw,
}
journey = {
'duration': fields.Raw,
'nb_transfers': fields.Raw,
'departure_date_time': fields.Raw,
'arrival_date_time': fields.Raw,
'distances': fields.Nested(distances),
'durations': fields.Nested(durations),
'sections': fields.List(fields.Nested(section)),
'type': fields.Raw,
}
:license: Apache, see LICENSE for more details.
.. moduleauthor:: Kevin Glisson <*****@*****.**>
"""
from flask import Blueprint
from flask.ext.restful import Api, reqparse, fields
from lemur.notifications import service
from lemur.auth.service import AuthenticatedResource
from lemur.common.utils import paginated_parser, marshal_items
mod = Blueprint('notifications', __name__)
api = Api(mod)
FIELDS = {
'description': fields.String,
'notificationOptions': fields.Raw(attribute='options'),
'pluginName': fields.String(attribute='plugin_name'),
'label': fields.String,
'active': fields.Boolean,
'id': fields.Integer,
}
def notification(value, name):
"""
Validates a given notification exits
:param value:
:param name:
:return:
"""
n = service.get(value)
from flask import Blueprint
from flask.ext.restful import Api, reqparse, fields
from lemur.sources import service
from lemur.auth.service import AuthenticatedResource
from lemur.auth.permissions import admin_permission
from lemur.common.utils import paginated_parser, marshal_items
mod = Blueprint('sources', __name__)
api = Api(mod)
FIELDS = {
'description': fields.String,
'sourceOptions': fields.Raw(attribute='options'),
'pluginName': fields.String(attribute='plugin_name'),
'lastRun': fields.DateTime(attribute='last_run', dt_format='iso8061'),
'label': fields.String,
'id': fields.Integer,
}
class SourcesList(AuthenticatedResource):
""" Defines the 'sources' endpoint """
def __init__(self):
self.reqparse = reqparse.RequestParser()
super(SourcesList, self).__init__()
@marshal_items(FIELDS)
def get(self):
from flask import Blueprint
from flask.ext.restful import Api, reqparse, fields
from lemur.destinations import service
from lemur.auth.service import AuthenticatedResource
from lemur.auth.permissions import admin_permission
from lemur.common.utils import paginated_parser, marshal_items
mod = Blueprint('destinations', __name__)
api = Api(mod)
FIELDS = {
'description': fields.String,
'destinationOptions': fields.Raw(attribute='options'),
'pluginName': fields.String(attribute='plugin_name'),
'label': fields.String,
'id': fields.Integer,
}
class DestinationsList(AuthenticatedResource):
""" Defines the 'destinations' endpoint """
def __init__(self):
self.reqparse = reqparse.RequestParser()
super(DestinationsList, self).__init__()
@marshal_items(FIELDS)
def get(self):
"""
.. moduleauthor:: Kevin Glisson <*****@*****.**>
"""
from flask import Blueprint
from flask.ext.restful import Api, reqparse, fields
from lemur.auth.service import AuthenticatedResource
from lemur.common.utils import marshal_items
from lemur.plugins.base import plugins
mod = Blueprint('plugins', __name__)
api = Api(mod)
FIELDS = {
'title': fields.String,
'pluginOptions': fields.Raw(attribute='options'),
'description': fields.String,
'version': fields.String,
'author': fields.String,
'authorUrl': fields.String,
'type': fields.String,
'slug': fields.String,
}
class PluginsList(AuthenticatedResource):
""" Defines the 'plugins' endpoint """
def __init__(self):
self.reqparse = reqparse.RequestParser()
super(PluginsList, self).__init__()
instance_status = {
"data_version": fields.Integer(),
"end_production_date": fields.String(),
"is_connected_to_rabbitmq": fields.Boolean(),
"last_load_at": fields.String(),
"last_rt_data_loaded": fields.String(),
"last_load_status": fields.Boolean(),
"kraken_version": fields.String(attribute="navitia_version"),
"nb_threads": fields.Integer(),
"publication_date": fields.String(),
"start_production_date": fields.String(),
"status": fields.String(),
"is_open_data": fields.Boolean(),
"is_open_service": fields.Boolean(),
"is_realtime_loaded": fields.Boolean(),
"realtime_proxies": fields.Raw(),
"dataset_created_at": fields.String(),
"autocomplete": fields.Raw(),
"street_networks": fields.Raw(),
"ridesharing_services": fields.Raw()
}
instance_parameters = {
'scenario': fields.Raw(attribute='_scenario_name'),
'journey_order': fields.Raw,
'max_walking_duration_to_pt': fields.Raw,
'max_bike_duration_to_pt': fields.Raw,
'max_bss_duration_to_pt': fields.Raw,
'max_car_duration_to_pt': fields.Raw,
'max_car_no_park_duration_to_pt': fields.Raw,
'max_nb_transfers': fields.Raw,
