Skip to content

Plugin

DOIPlugin

Bases: SingletonPlugin, DefaultDatasetForm

CKAN DOI Extension.

Source code in ckanext/doi/plugin.py 
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
class DOIPlugin(SingletonPlugin, toolkit.DefaultDatasetForm):
    """
    CKAN DOI Extension.
    """

    implements(interfaces.IConfigurer)
    implements(interfaces.IPackageController, inherit=True)
    implements(interfaces.ITemplateHelpers, inherit=True)
    implements(interfaces.IClick)

    ## IClick
    def get_commands(self):
        return cli.get_commands()

    ## IConfigurer
    def update_config(self, config):
        """
        Adds templates.
        """
        toolkit.add_template_directory(config, 'theme/templates')

    ## IPackageController
    def after_dataset_create(self, context, pkg_dict):
        """
        A new dataset has been created, so we need to create a new DOI.

        NB: This is called after creation of a dataset, before resources have been
        added, so state = draft.
        """
        DOIQuery.read_package(pkg_dict['id'], create_if_none=True)

    ## IPackageController
    def after_dataset_update(self, context, pkg_dict):
        """
        Dataset has been created/updated.

        Check status of the dataset to determine if we should publish DOI to datacite
        network.
        """
        # Is this active and public? If so we need to make sure we have an active DOI
        if pkg_dict.get('state', 'active') == 'active' and not pkg_dict.get(
            'private', False
        ):
            package_id = pkg_dict['id']

            # remove user-defined update schemas first (if needed)
            context.pop('schema', None)

            # Load the package_show version of the dict
            pkg_show_dict = toolkit.get_action('package_show')(
                context, {'id': package_id}
            )

            # Load or create the local DOI (package may not have a DOI if extension was loaded
            # after package creation)
            doi = DOIQuery.read_package(package_id, create_if_none=True)

            metadata_dict = build_metadata_dict(pkg_show_dict)
            xml_dict = build_xml_dict(metadata_dict)

            client = DataciteClient()

            if doi.published is None:
                # metadata gets created before minting
                client.set_metadata(doi.identifier, xml_dict)
                client.mint_doi(doi.identifier, package_id)
                toolkit.h.flash_success('DataCite DOI created')
            else:
                same = client.check_for_update(doi.identifier, xml_dict)
                if not same:
                    # Not the same, so we want to update the metadata
                    client.set_metadata(doi.identifier, xml_dict)
                    toolkit.h.flash_success('DataCite DOI metadata updated')

        return pkg_dict

    # IPackageController
    def after_dataset_show(self, context, pkg_dict):
        """
        Add the DOI details to the pkg_dict so it can be displayed.
        """
        doi = DOIQuery.read_package(pkg_dict['id'])
        if doi:
            pkg_dict['doi'] = doi.identifier
            pkg_dict['doi_status'] = True if doi.published else False
            pkg_dict['domain'] = get_site_url().replace('http://', '')
            pkg_dict['doi_date_published'] = (
                datetime.strftime(doi.published, '%Y-%m-%d') if doi.published else None
            )
            pkg_dict['doi_publisher'] = toolkit.config.get('ckanext.doi.publisher')

    def after_create(self, *args, **kwargs):
        """
        CKAN 2.9 compat version of after_dataset_create.
        """
        return self.after_dataset_create(*args, **kwargs)

    def after_update(self, *args, **kwargs):
        """
        CKAN 2.9 compat version of after_dataset_update.
        """
        return self.after_dataset_update(*args, **kwargs)

    def after_show(self, *args, **kwargs):
        """
        CKAN 2.9 compat version of after_dataset_show.
        """
        return self.after_dataset_show(*args, **kwargs)

    # ITemplateHelpers
    def get_helpers(self):
        return {
            'package_get_year': package_get_year,
            'now': datetime.now,
            'get_site_title': get_site_title,
            'doi_test_mode': doi_test_mode,
        }

after_create(*args, **kwargs)

CKAN 2.9 compat version of after_dataset_create.

Source code in ckanext/doi/plugin.py 
117
118
119
120
121
def after_create(self, *args, **kwargs):
    """
    CKAN 2.9 compat version of after_dataset_create.
    """
    return self.after_dataset_create(*args, **kwargs)

after_dataset_create(context, pkg_dict)

A new dataset has been created, so we need to create a new DOI.

NB: This is called after creation of a dataset, before resources have been added, so state = draft.

Source code in ckanext/doi/plugin.py 
48
49
50
51
52
53
54
55
def after_dataset_create(self, context, pkg_dict):
    """
    A new dataset has been created, so we need to create a new DOI.

    NB: This is called after creation of a dataset, before resources have been
    added, so state = draft.
    """
    DOIQuery.read_package(pkg_dict['id'], create_if_none=True)

after_dataset_show(context, pkg_dict)

Add the DOI details to the pkg_dict so it can be displayed.

Source code in ckanext/doi/plugin.py 
103
104
105
106
107
108
109
110
111
112
113
114
115
def after_dataset_show(self, context, pkg_dict):
    """
    Add the DOI details to the pkg_dict so it can be displayed.
    """
    doi = DOIQuery.read_package(pkg_dict['id'])
    if doi:
        pkg_dict['doi'] = doi.identifier
        pkg_dict['doi_status'] = True if doi.published else False
        pkg_dict['domain'] = get_site_url().replace('http://', '')
        pkg_dict['doi_date_published'] = (
            datetime.strftime(doi.published, '%Y-%m-%d') if doi.published else None
        )
        pkg_dict['doi_publisher'] = toolkit.config.get('ckanext.doi.publisher')

after_dataset_update(context, pkg_dict)

Dataset has been created/updated.

Check status of the dataset to determine if we should publish DOI to datacite network.

Source code in ckanext/doi/plugin.py 
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
def after_dataset_update(self, context, pkg_dict):
    """
    Dataset has been created/updated.

    Check status of the dataset to determine if we should publish DOI to datacite
    network.
    """
    # Is this active and public? If so we need to make sure we have an active DOI
    if pkg_dict.get('state', 'active') == 'active' and not pkg_dict.get(
        'private', False
    ):
        package_id = pkg_dict['id']

        # remove user-defined update schemas first (if needed)
        context.pop('schema', None)

        # Load the package_show version of the dict
        pkg_show_dict = toolkit.get_action('package_show')(
            context, {'id': package_id}
        )

        # Load or create the local DOI (package may not have a DOI if extension was loaded
        # after package creation)
        doi = DOIQuery.read_package(package_id, create_if_none=True)

        metadata_dict = build_metadata_dict(pkg_show_dict)
        xml_dict = build_xml_dict(metadata_dict)

        client = DataciteClient()

        if doi.published is None:
            # metadata gets created before minting
            client.set_metadata(doi.identifier, xml_dict)
            client.mint_doi(doi.identifier, package_id)
            toolkit.h.flash_success('DataCite DOI created')
        else:
            same = client.check_for_update(doi.identifier, xml_dict)
            if not same:
                # Not the same, so we want to update the metadata
                client.set_metadata(doi.identifier, xml_dict)
                toolkit.h.flash_success('DataCite DOI metadata updated')

    return pkg_dict

after_show(*args, **kwargs)

CKAN 2.9 compat version of after_dataset_show.

Source code in ckanext/doi/plugin.py 
129
130
131
132
133
def after_show(self, *args, **kwargs):
    """
    CKAN 2.9 compat version of after_dataset_show.
    """
    return self.after_dataset_show(*args, **kwargs)

after_update(*args, **kwargs)

CKAN 2.9 compat version of after_dataset_update.

Source code in ckanext/doi/plugin.py 
123
124
125
126
127
def after_update(self, *args, **kwargs):
    """
    CKAN 2.9 compat version of after_dataset_update.
    """
    return self.after_dataset_update(*args, **kwargs)

update_config(config)

Adds templates.

Source code in ckanext/doi/plugin.py 
41
42
43
44
45
def update_config(self, config):
    """
    Adds templates.
    """
    toolkit.add_template_directory(config, 'theme/templates')