Dataset versions API

ckanext/versions/helpers.py

@@ -78,3 +78,25 @@ def download_url(resource_url, version_id):
         )
 
     return url
+
+
+def dataset_version_for_activity_id(dataset_id, activity_id):
+    """Return dataset version created for given activity.
+
+    :param dataset_id: the id or name of the dataset
+    :type dataset_id: string
+    :param activity_id: the id of the activity
+    :type activity_id: string
+    :returns: version, None if no version created for the given activity.
+    :rtype: dictionary
+    """
+    # TODO: Think if instead `IPackageController.after_show` could be
+    # used to include version dict in package_dict
+    context = {'user': toolkit.g.user}
+    versions = toolkit.get_action('dataset_version_list')(
+        context, {'dataset_id': dataset_id}
+    )
+    for version in versions:
+        if version['activity_id'] == activity_id:
+            return version
+    return None

ckanext/versions/logic/action.py

@@ -18,8 +18,6 @@
 def version_update(context, data_dict):
     """Update a version from the current dataset.
 
-    :param package_id: the id the dataset
-    :type package_id: string
     :param version_id: the id of the version
     :type version_id: string
     :param name: A short name for the version
@@ -30,7 +28,7 @@ def version_update(context, data_dict):
     :rtype: dictionary
     """
     model = context.get('model', core_model)
-    version_id, name = toolkit.get_or_bust(data_dict, ['version', 'name'])
+    version_id, name = toolkit.get_or_bust(data_dict, ['version_id', 'name'])
 
     # I'll create my own session! With Blackjack! And H**kers!
     session = model.meta.create_local_session()
@@ -42,11 +40,11 @@ def version_update(context, data_dict):
     if not version:
         raise toolkit.ObjectNotFound('Version not found')
 
-    toolkit.check_access('dataset_version_create', context, data_dict)
+    toolkit.check_access('version_create', context, data_dict)
     assert context.get('auth_user_obj')  # Should be here after `check_access`
 
     version.name = name
-    version.description = data_dict.get('description', None)
+    version.notes = data_dict.get('notes', None)
 
     session.add(version)
 
@@ -228,14 +226,26 @@ def version_delete(context, data_dict):
 def version_show(context, data_dict):
     """Show a specific version object
 
-    :param version_id: the id of the version
+    :param version_id: the id or name of the version
     :type version_id: string
+    :param dataset_id: [Optional] the id or name of a dataset. Mandatory
+    if version name provided as version_id
+    :type dataset_id: string
     :returns: the version dictionary
     :rtype: dict
     """
     model = context.get('model', core_model)
-    version_id = toolkit.get_or_bust(data_dict, ['version_id'])
-    version = model.Session.query(Version).get(version_id)
+    version_name_or_id = toolkit.get_or_bust(data_dict, ['version_id'])
+    version = model.Session.query(Version).get(version_name_or_id)
+    if not version:
+        version_name = version_name_or_id
+        dataset_name_or_id = data_dict.get('dataset_id')
+        dataset = model.Package.get(dataset_name_or_id)
+        if dataset:
+            dataset_id = dataset.id
+            version = model.Session.query(Version). \
+                filter(Version.package_id == dataset_id). \
+                filter(Version.name == version_name).one_or_none()
     if not version:
         raise toolkit.ObjectNotFound('Version not found')
 

ckanext/versions/logic/dataset_version_action.py

@@ -0,0 +1,226 @@
+import logging
+
+from datetime import datetime
+from sqlalchemy.exc import IntegrityError
+
+from ckan import model as core_model
+from ckan.plugins import toolkit
+from ckanext.versions.logic.action import version_show
+from ckanext.versions.model import Version
+
+log = logging.getLogger(__name__)
+
+
+def dataset_version_create(context, data_dict):
+    """Create a new version from the current dataset's activity_id
+
+    Currently you must have editor level access on the dataset
+    to create a version. If creator_user_id is not present, it will be set as
+    the logged it user.
+
+    :param dataset_id: the id of the dataset
+    :type dataset_id: string
+    :param name: A short name for the version, e.g. v1.0
+    :type name: string
+    :param notes optional: Notes about the version
+    :type notes: string
+    :returns: the newly created version
+    :rtype: dictionary
+    """
+    model = context.get('model', core_model)
+    dataset_name_or_id, name = toolkit.get_or_bust(
+        data_dict, ['dataset_id', 'name'])
+    activity_id = data_dict.get('activity_id')
+
+    dataset = model.Package.get(dataset_name_or_id)
+    if not dataset:
+        raise toolkit.ObjectNotFound("Dataset not found")
+    dataset_id = dataset.id
+    toolkit.check_access('version_create',
+                         context,
+                         {"package_id": dataset_id})
+    creator_user_id = context['auth_user_obj'].id
+
+    if activity_id:
+        activity = model.Activity.get(activity_id)
+    else:
+        activity = model.Session.query(model.Activity). \
+            filter_by(object_id=dataset_id). \
+            order_by(model.Activity.timestamp.desc()). \
+            first()
+    if not activity:
+        raise toolkit.ObjectNotFound('Activity not found')
+
+    version_for_activity = model.Session.query(Version). \
+        filter_by(activity_id=activity.id). \
+        first()
+    if version_for_activity:
+        raise toolkit.ValidationError("Version already exists for this activity")
+
+    version = Version(
+        package_id=dataset_id,
+        activity_id=activity.id,
+        name=name,
+        notes=data_dict.get('notes', None),
+        created=datetime.utcnow(),
+        creator_user_id=creator_user_id)
+
+    model.Session.add(version)
+    try:
+        model.Session.commit()
+    except IntegrityError as e:
+        #  Name not unique, or foreign key constraint violated
+        model.Session.rollback()
+        log.debug("DB integrity error (version name not unique?): %s", e)
+        raise toolkit.ValidationError(
+            'Version names must be unique per dataset'
+        )
+
+    log.info(
+        'Version "%s" created for dataset %s',
+        name,
+        dataset_id
+    )
+
+    return version.as_dict()
+
+
+def dataset_version_restore(context, data_dict):
+    """Restores dataset version by restoring dataset
+    metadata and creating a new version with it
+
+    :param dataset_id: the id or name of the dataset
+    :type dataset_id: string
+    :param version_id: the id or name of the dataset
+    :type version_id: string
+    :returns: restored dataset
+    :rtype: dict
+    """
+    model = context.get('model', core_model)
+    dataset_name_or_id, version_name_or_id = toolkit.get_or_bust(
+        data_dict, ['dataset_id', 'version_id'])
+
+    dataset = model.Package.get(dataset_name_or_id)
+    if not dataset:
+        raise toolkit.ObjectNotFound("Dataset not found")
+    dataset_id = dataset.id
+    toolkit.check_access('version_create',
+                         context,
+                         {"package_id": dataset_id})
+
+    version = version_show(context, data_dict)
+    if not version:
+        raise toolkit.ObjectNotFound("Version not found")
+    v_name = "restored_{}".format(version['name'])
+    v_notes = "Restored from version: {}".format(version['name'])
+    old_dataset = activity_dataset_show(
+        context,
+        {
+            'activity_id': version['activity_id'],
+            'dataset_id': dataset_id
+        }
+    )
+    restored_dataset = toolkit.get_action('package_update')(context, old_dataset)
+    dataset_version_create(context, {'dataset_id': dataset.id, 'name': v_name, 'notes': v_notes})
+
+    return restored_dataset
+
+
+@toolkit.side_effect_free
+def dataset_version_list(context, data_dict):
+    """List versions of a given dataset
+
+    :param dataset_id: the id of the dataset
+    :type dataset_id: string
+    :returns: list of versions created for the dataset
+    :rtype: list
+    """
+    model = context.get('model', core_model)
+    dataset_id = toolkit.get_or_bust(data_dict, ['dataset_id'])
+    dataset = model.Package.get(dataset_id)
+    if not dataset:
+        raise toolkit.ObjectNotFound('Dataset not found')
+
+    toolkit.check_access('version_list', context,
+                         {"package_id": dataset_id})
+
+    versions = model.Session.query(Version). \
+        filter(Version.package_id == dataset.id). \
+        order_by(Version.created.desc())
+
+    return [v.as_dict() for v in versions]
+
+
+@toolkit.side_effect_free
+def dataset_version_latest(context, data_dict):
+    ''' Show the latest version for a dataset
+
+    :param dataset_id: the if of the dataset
+    :type dataset_id: string
+    :returns the version dictionary
+    :rtype dict
+    '''
+    version_list = dataset_version_list(context, data_dict)
+    if len(version_list) < 1:
+        raise toolkit.ObjectNotFound("Versions not found for this dataset")
+    return version_list[0]
+
+
+def activity_dataset_show(context, data_dict):
+    ''' Returns a dataset from the activity object.
+
+    :param activity_id: the id of the activity
+    :type activity_id: string
+    :param dataset_id: the id of the resource
+    :type dataset_id: string
+    :returns: The dataset in the activity
+    :rtype: dict
+    '''
+    activity_id, dataset_id = toolkit.get_or_bust(
+        data_dict,
+        ['activity_id', 'dataset_id']
+    )
+    dataset = toolkit.get_action('activity_data_show')(
+        context,
+        {'id': activity_id, 'object_type': 'package'}
+    )
+    if not dataset or dataset['id'] != dataset_id:
+        raise toolkit.ObjectNotFound('Dataset not found in the activity object.')
+
+    return dataset
+
+
+def get_activity_id_from_dataset_version_name(context, data_dict):
+    ''' Returns the activity_id for the dataset version
+
+    :param dataset_id: the id of the dataset
+    :type dataset_id: string
+    :param version: the name or id of the version
+    :type version: string
+    :returns: The activity_id of the version
+    :rtype: string
+    '''
+    version_name, dataset_id = toolkit.get_or_bust(
+        data_dict,
+        ['version', 'dataset_id']
+    )
+    version_list = dataset_version_list(context, data_dict)
+    for version in version_list:
+        if version_name in {version['name'], version['id']}:
+            return version['activity_id']
+
+    raise toolkit.ObjectNotFound('Version not found in the dataset.')
+
+
+def dataset_has_versions(context, data_dict):
+    """Check if the dataset has versions.
+
+    :param dataset_id: the id the dataset
+    :type dataset_id: string
+    :returns: True if the dataset has at least 1 version
+    :rtype: boolean
+    """
+    version_list = dataset_version_list(context, data_dict)
+    if not version_list:
+        return False
+    return True

ckanext/versions/plugin.py

@@ -6,7 +6,7 @@
 
 from ckanext.versions import cli, helpers
 from ckanext.versions.blueprints import blueprint
-from ckanext.versions.logic import action, auth
+from ckanext.versions.logic import action, auth, dataset_version_action
 from ckanext.versions.model import tables_exist
 
 log = logging.getLogger(__name__)
@@ -51,8 +51,13 @@ def get_actions(self):
             'resource_version_current': action.resource_version_current,
             'resource_version_clear': action.resource_version_clear,
             'version_show': action.version_show,
+            'version_update': action.version_update,
             'version_delete': action.version_delete,
             'resource_view_list': action.resource_view_list,
+            'dataset_version_create': dataset_version_action.dataset_version_create,
+            'dataset_version_restore': dataset_version_action.dataset_version_restore,
+            'dataset_version_list': dataset_version_action.dataset_version_list,
+            'dataset_version_latest': dataset_version_action.dataset_version_latest
         }
 
     # IAuthFunctions
@@ -75,6 +80,7 @@ def get_helpers(self):
             'versions_resource_version_from_activity_id': helpers.resource_version_from_activity_id,
             'versions_resource_current_version': helpers.resource_current_version,
             'versions_download_url': helpers.download_url,
+            'dataset_version_for_activity_id': helpers.dataset_version_for_activity_id,
         }
         return helper_functions
 

ckanext/versions/tests/__init__.py

@@ -1,8 +1,33 @@
 from ckan import model
+from ckanext.versions.logic.dataset_version_action import dataset_version_create, dataset_version_restore
 
 
 def get_context(user):
     return {
         'model': model,
         'user': user if isinstance(user, str) else user['name']
     }
+
+
+def assert_version(version, checks):
+    assert version
+    for k, v in checks.items():
+        assert version[k] == v, "found incorrect %s of version" % k
+
+
+def create_version(dataset_id, user, version_name="Default Name"):
+    return dataset_version_create(
+        get_context(user),
+        {
+            "dataset_id": dataset_id,
+            "name": version_name
+        }
+    )
+
+
+def restore_version(dataset_id, version_id, user):
+    context = get_context(user)
+    return dataset_version_restore(context, {
+        'dataset_id': dataset_id,
+        'version_id': version_id
+    })