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,