From f835bed50f34653c5226ed6da1feddc373cbfb4d Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Tue, 24 Jan 2012 18:40:55 +0100
Subject: [PATCH 01/72] [#1705] Begin implementing vocabularies model

Add new domain class ckan/model/vocabulary.py:Vocabulary, maps to new
vocabulary table in db.

Add vocabulary_dictize() and vocabulary_list_dictize() functions to
model_dictize.py.

Add vocabulary_dict_save() function to model_save.py

Add vocabulary_create() logic function to logic/action/create.py. Needs
authorization.

Add vocabulary_list() and vocabulary_show() logic functions to
logic/action/get.py. These need authorization as well.

Add 'vocabulary_id' column to tag.

Add the beginnings of tests for the new vocabulary model in
ckan/tests/functional/api/model/test_vocabulary.py.
---
 ckan/lib/dictization/model_dictize.py         |  9 +++
 ckan/lib/dictization/model_save.py            | 11 +++
 ckan/logic/action/create.py                   | 19 +++++-
 ckan/logic/action/get.py                      | 29 +++++++-
 ckan/model/__init__.py                        |  1 +
 ckan/model/vocabulary.py                      | 29 ++++++++
 .../functional/api/model/test_vocabulary.py   | 68 +++++++++++++++++++
 7 files changed, 162 insertions(+), 4 deletions(-)
 create mode 100644 ckan/model/vocabulary.py
 create mode 100644 ckan/tests/functional/api/model/test_vocabulary.py

diff --git a/ckan/lib/dictization/model_dictize.py b/ckan/lib/dictization/model_dictize.py
index 7a9a71c79c0..43826b89092 100644
--- a/ckan/lib/dictization/model_dictize.py
+++ b/ckan/lib/dictization/model_dictize.py
@@ -441,3 +441,12 @@ def package_to_api2(pkg, context):
     dictized['relationships'] = relationships 
     return dictized
 
+def vocabulary_dictize(vocabulary, context):
+    vocabulary_dict = table_dictize(vocabulary, context)
+    return vocabulary_dict
+
+def vocabulary_list_dictize(vocabulary_list, context):
+    list_of_dicts = []
+    for vocabulary in vocabulary_list:
+        list_of_dicts.append(vocabulary_dictize(vocabulary, context))
+    return list_of_dicts
diff --git a/ckan/lib/dictization/model_save.py b/ckan/lib/dictization/model_save.py
index aaa4569fc12..14eb6c5464a 100644
--- a/ckan/lib/dictization/model_save.py
+++ b/ckan/lib/dictization/model_save.py
@@ -440,3 +440,14 @@ def task_status_dict_save(task_status_dict, context):
 
     task_status = table_dict_save(task_status_dict, model.TaskStatus, context)
     return task_status
+
+def vocabulary_dict_save(vocabulary_dict, context):
+
+    model = context['model']
+    session = context['session']
+
+    vocabulary_name = vocabulary_dict['name']
+    vocabulary_obj = model.Vocabulary(vocabulary_name)
+    session.add(vocabulary_obj)
+
+    return vocabulary_obj
diff --git a/ckan/logic/action/create.py b/ckan/logic/action/create.py
index 48dc13d4567..e0bee99198c 100644
--- a/ckan/logic/action/create.py
+++ b/ckan/logic/action/create.py
@@ -16,12 +16,13 @@
                                              group_dict_save,
                                              package_api_to_dict,
                                              package_dict_save,
-                                             user_dict_save)
+                                             user_dict_save,
+                                             vocabulary_dict_save)
 
 from ckan.lib.dictization.model_dictize import (group_dictize,
                                                 package_dictize,
-                                                user_dictize)
-
+                                                user_dictize,
+                                                vocabulary_dictize)
 
 from ckan.logic.schema import default_create_package_schema, default_resource_schema
 
@@ -278,3 +279,15 @@ def group_create_rest(context, data_dict):
 
     return group_dict
 
+def vocabulary_create(context, data_dict):
+    '''Add a new vocabulary to the site.'''
+
+    model = context['model']
+    vocabulary_dict = data_dict['vocabulary']
+    vocabulary = vocabulary_dict_save(vocabulary_dict, context)
+
+    if not context.get('defer_commit'):
+        model.repo.commit()
+
+    log.debug("Created vocabulary '%s'" % vocabulary.name)
+    return vocabulary_dictize(vocabulary, context)
diff --git a/ckan/logic/action/get.py b/ckan/logic/action/get.py
index ab2d4e2a48c..2812cdd76dd 100644
--- a/ckan/logic/action/get.py
+++ b/ckan/logic/action/get.py
@@ -20,7 +20,9 @@
                                                 group_list_dictize,
                                                 tag_dictize,
                                                 task_status_dictize,
-                                                user_dictize)
+                                                user_dictize,
+                                                vocabulary_dictize,
+                                                vocabulary_list_dictize)
 
 from ckan.lib.dictization.model_dictize import (package_to_api1,
                                                 package_to_api2,
@@ -28,6 +30,7 @@
                                                 group_to_api2,
                                                 tag_to_api1,
                                                 tag_to_api2)
+
 from ckan.lib.search import query_for, SearchError
 import logging
 
@@ -872,3 +875,27 @@ def status_show(context, data_dict):
         'locale_default': config.get('ckan.locale_default'),
         'extensions': config.get('ckan.plugins').split(),
         }
+
+def vocabulary_list(context, data_dict):
+    model = context['model']
+    vocabulary_objects = model.Session.query(model.Vocabulary).all()
+    return vocabulary_list_dictize(vocabulary_objects, context)
+
+def vocabulary_show(context, data_dict):
+    model = context['model']
+
+    if data_dict.has_key('id'):
+        vocabulary = model.Vocabulary.get(data_dict['id'])
+        if vocabulary is None:
+            raise NotFound
+    elif data_dict.has_key('name'):
+        vocabulary = model.Vocabulary.get(data_dict['name'])
+        if vocabulary is None:
+            raise NotFound
+    else:
+        raise NotFound
+
+    # TODO: check_access('vocabulary_show', context, data_dict)
+
+    vocabulary_dict = vocabulary_dictize(vocabulary, context)
+    return vocabulary_dict
diff --git a/ckan/model/__init__.py b/ckan/model/__init__.py
index cd0ba3f03c1..36509fe3e20 100644
--- a/ckan/model/__init__.py
+++ b/ckan/model/__init__.py
@@ -23,6 +23,7 @@
 from rating import *
 from package_relationship import *
 from task_status import *
+from vocabulary import *
 import ckan.migration
 from ckan.lib.helpers import OrderedDict, datetime_to_date_str
 from vdm.sqlalchemy.base import SQLAlchemySession
diff --git a/ckan/model/vocabulary.py b/ckan/model/vocabulary.py
new file mode 100644
index 00000000000..45ff3603e19
--- /dev/null
+++ b/ckan/model/vocabulary.py
@@ -0,0 +1,29 @@
+from meta import Table, types, Session
+from core import metadata, Column, DomainObject, mapper
+from types import make_uuid
+
+MAX_VOCAB_NAME_LENGTH = 100
+
+vocabulary_table = Table(
+    'vocabulary', metadata,
+    Column('id', types.UnicodeText, primary_key=True, default=make_uuid),
+    Column('name', types.Unicode(MAX_VOCAB_NAME_LENGTH), nullable=False, unique=True),
+    )
+
+class Vocabulary(DomainObject):
+
+    def __init__(self, name):
+        self.id = make_uuid()
+        self.name = name
+
+    @classmethod
+    def get(cls, reference):
+        """Return a Vocabulary object referenced by its id or name."""
+
+        query = Session.query(cls).filter(cls.id==reference)
+        vocab = query.first()
+        if vocab is None:
+            vocab = cls.by_name(reference)            
+        return vocab
+
+mapper(Vocabulary, vocabulary_table)
diff --git a/ckan/tests/functional/api/model/test_vocabulary.py b/ckan/tests/functional/api/model/test_vocabulary.py
new file mode 100644
index 00000000000..276f583bad8
--- /dev/null
+++ b/ckan/tests/functional/api/model/test_vocabulary.py
@@ -0,0 +1,68 @@
+import ckan
+from pylons.test import pylonsapp
+import paste.fixture
+from ckan.lib.helpers import json
+
+class TestVocabulary(object):
+
+    @classmethod
+    def setup_class(cls):
+        cls.app = paste.fixture.TestApp(pylonsapp)
+        ckan.tests.CreateTestData.create()
+
+    @classmethod
+    def teardown_class(cls):
+        ckan.model.repo.rebuild_db()
+
+    def post(self, url, param_dict=None):
+        if param_dict is None:
+            param_dict = {}
+        param_string = json.dumps(param_dict)
+        response = self.app.post(url, params=param_string)
+        assert not response.errors
+        return response.json
+
+    def test_vocabulary_create(self):
+
+        # Create a new vocabulary.
+        vocab_name = "Genre"
+        params = {'vocabulary': {'name': vocab_name}}
+        response = self.post('/api/action/vocabulary_create', params)
+        # Check the values of the response.
+        assert response['success'] == True
+        assert response['result']
+        created_vocab = response['result']
+        assert created_vocab['name'] == vocab_name
+        assert created_vocab['id']
+
+        # Get the list of vocabularies.
+        response = self.post('/api/action/vocabulary_list')
+        # Check that the vocabulary we created is in the list.
+        assert response['success'] == True
+        assert response['result']
+        assert response['result'].count(created_vocab) == 1
+
+        # Get the created vocabulary.
+        params = {'id': created_vocab['id']}
+        response = self.post('/api/action/vocabulary_show', params)
+        # Check that retrieving the vocab by name gives the same result.
+        by_name_params = {'name': created_vocab['name']}
+        assert response == self.post('/api/action/vocabulary_show',
+                by_name_params)
+        # Check that it matches what we created.
+        assert response['success'] == True
+        assert response['result'] == created_vocab
+
+    def test_vocabulary_update(self):
+        # Create a vocab.
+        # Update the vocab via the API.
+        # List vocabs
+        # Get vocab, assert fields correct.
+        raise NotImplementedError
+
+    def test_vocabulary_delete(self):
+        # Create a vocab.
+        # Delete a vocab via the API
+        # List vocabs, assert that it's gone.
+        raise NotImplementedError
+

From 3a5cc5e356b404fec8e1bf923a766cd61be2b3e7 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Thu, 26 Jan 2012 17:43:29 +0100
Subject: [PATCH 02/72] [#1705] Finish up Vocabulary model, API and tests

Add validation and authorization to vocabulary_create() logic action
function. Add new vocabulary_update() and vocabulary_delete() logic
action functions.

Add vocabulary_create(), vocabulary_update() and vocabulary_delete()
logic auth functions. These just authorize sysadmins only.

Add default_create_vocabulary_schema() and
default_update_vocabulary_schema(), and vocabulary_name_validator() and
vocabulary_id_not_changed() validators.

Add tests for creating, updating, deleting, listing and getting
vocabularies via the API.
---
 ckan/lib/dictization/model_save.py            |  10 +
 ckan/logic/action/create.py                   |  32 +-
 ckan/logic/action/delete.py                   |  18 ++
 ckan/logic/action/update.py                   |  43 ++-
 ckan/logic/auth/create.py                     |   4 +
 ckan/logic/auth/delete.py                     |   4 +
 ckan/logic/auth/update.py                     |   4 +
 ckan/logic/schema.py                          |  21 +-
 ckan/logic/validators.py                      |  27 +-
 ckan/model/vocabulary.py                      |   6 +-
 .../functional/api/model/test_vocabulary.py   | 299 ++++++++++++++++--
 11 files changed, 429 insertions(+), 39 deletions(-)

diff --git a/ckan/lib/dictization/model_save.py b/ckan/lib/dictization/model_save.py
index 14eb6c5464a..ecdad95287e 100644
--- a/ckan/lib/dictization/model_save.py
+++ b/ckan/lib/dictization/model_save.py
@@ -451,3 +451,13 @@ def vocabulary_dict_save(vocabulary_dict, context):
     session.add(vocabulary_obj)
 
     return vocabulary_obj
+
+def vocabulary_dict_update(vocabulary_dict, context):
+
+    model = context['model']
+    session = context['session']
+
+    vocabulary_obj = model.Vocabulary.get(vocabulary_dict['id'])
+    vocabulary_obj.name = vocabulary_dict['name']
+
+    return vocabulary_obj
diff --git a/ckan/logic/action/create.py b/ckan/logic/action/create.py
index e0bee99198c..ce06e8ed419 100644
--- a/ckan/logic/action/create.py
+++ b/ckan/logic/action/create.py
@@ -24,7 +24,9 @@
                                                 user_dictize,
                                                 vocabulary_dictize)
 
-from ckan.logic.schema import default_create_package_schema, default_resource_schema
+from ckan.logic.schema import (default_create_package_schema,
+                               default_resource_schema,
+                               default_create_vocabulary_schema)
 
 from ckan.logic.schema import default_group_schema, default_user_schema
 from ckan.lib.navl.dictization_functions import validate 
@@ -280,14 +282,34 @@ def group_create_rest(context, data_dict):
     return group_dict
 
 def vocabulary_create(context, data_dict):
-    '''Add a new vocabulary to the site.'''
 
     model = context['model']
-    vocabulary_dict = data_dict['vocabulary']
-    vocabulary = vocabulary_dict_save(vocabulary_dict, context)
+    user = context['user']
+    schema = context.get('schema') or default_create_vocabulary_schema()
+
+    model.Session.remove()
+    model.Session()._context = context
+
+    check_access('vocabulary_create', context, data_dict)
+
+    data, errors = validate(data_dict, schema, context)
+
+    if errors:
+        model.Session.rollback()
+        raise ValidationError(errors, package_error_summary(errors))
+
+    rev = model.repo.new_revision()
+    rev.author = user
+    if 'message' in context:
+        rev.message = context['message']
+    else:
+        rev.message = _(u'API: Create Vocabulary %s') % data.get('name')
+
+    vocabulary = vocabulary_dict_save(data, context)
 
     if not context.get('defer_commit'):
         model.repo.commit()
 
-    log.debug("Created vocabulary '%s'" % vocabulary.name)
+    log.debug('Created Vocabulary %s' % str(vocabulary.name))
+
     return vocabulary_dictize(vocabulary, context)
diff --git a/ckan/logic/action/delete.py b/ckan/logic/action/delete.py
index 498e70f7f32..ebb25547d05 100644
--- a/ckan/logic/action/delete.py
+++ b/ckan/logic/action/delete.py
@@ -103,3 +103,21 @@ def task_status_delete(context, data_dict):
 
     entity.delete()
     model.Session.commit()
+
+def vocabulary_delete(context, data_dict):
+    model = context['model']
+    user = context['user']
+    vocab_id = data_dict['id']
+
+    vocab_obj = model.Vocabulary.get(vocab_id)
+    if vocab_obj is None:
+        raise NotFound
+
+    check_access('vocabulary_delete', context, data_dict)
+
+    rev = model.repo.new_revision()
+    rev.author = user
+    rev.message = _(u'REST API: Delete Vocabulary: %s') % vocab_obj.name
+
+    vocab_obj.delete()
+    model.repo.commit()
diff --git a/ckan/logic/action/update.py b/ckan/logic/action/update.py
index 4d913365384..8e9888cb49d 100644
--- a/ckan/logic/action/update.py
+++ b/ckan/logic/action/update.py
@@ -16,19 +16,22 @@
                                                 group_dictize,
                                                 group_to_api1,
                                                 group_to_api2,
-                                                user_dictize)
+                                                user_dictize,
+                                                vocabulary_dictize)
 from ckan.lib.dictization.model_save import (group_api_to_dict,
                                              package_api_to_dict,
                                              group_dict_save,
                                              user_dict_save,
                                              task_status_dict_save,
                                              package_dict_save,
-                                             resource_dict_save)
+                                             resource_dict_save,
+                                             vocabulary_dict_update)
 from ckan.logic.schema import (default_update_group_schema,
                                default_update_package_schema,
                                default_update_user_schema,
                                default_update_resource_schema,
-                               default_task_status_schema)
+                               default_task_status_schema,
+                               default_update_vocabulary_schema)
 from ckan.lib.navl.dictization_functions import validate
 log = logging.getLogger(__name__)
 
@@ -470,3 +473,37 @@ def group_update_rest(context, data_dict):
         group_dict = group_to_api2(group, context)
 
     return group_dict
+
+def vocabulary_update(context, data_dict):
+    model = context['model']
+    user = context['user']
+    vocab_id = data_dict['id']
+
+    model.Session.remove()
+    model.Session()._context = context
+
+    vocab = model.Vocabulary.get(vocab_id)
+    if vocab is None:
+        raise NotFound(_('Vocabulary was not found.'))
+
+    check_access('vocabulary_update', context, data_dict)
+
+    schema = context.get('schema') or default_update_vocabulary_schema()
+    data, errors = validate(data_dict, schema, context)
+
+    if errors:
+        model.Session.rollback()
+        raise ValidationError(errors)
+
+    rev = model.repo.new_revision()
+    rev.author = user
+    if 'message' in context:
+        rev.message = context['message']
+    else:
+        rev.message = _(u'API: Update Vocabulary %s') % data.get('name')
+
+    updated_vocab = vocabulary_dict_update(data, context)
+
+    if not context.get('defer_commit'):
+        model.repo.commit()
+    return vocabulary_dictize(updated_vocab, context)
diff --git a/ckan/logic/auth/create.py b/ckan/logic/auth/create.py
index 80702bf176f..5840097e3f0 100644
--- a/ckan/logic/auth/create.py
+++ b/ckan/logic/auth/create.py
@@ -129,3 +129,7 @@ def group_create_rest(context, data_dict):
         return {'success': False, 'msg': _('Valid API key needed to create a group')}
 
     return group_create(context, data_dict)
+
+def vocabulary_create(context, data_dict):
+    user = context['user']
+    return {'success': Authorizer.is_sysadmin(user)}
diff --git a/ckan/logic/auth/delete.py b/ckan/logic/auth/delete.py
index 7dd762fc2e8..0e54c4844b0 100644
--- a/ckan/logic/auth/delete.py
+++ b/ckan/logic/auth/delete.py
@@ -55,3 +55,7 @@ def task_status_delete(context, data_dict):
         return {'success': False, 'msg': _('User %s not authorized to delete task_status') % str(user)}
     else:
         return {'success': True}
+
+def vocabulary_delete(context, data_dict):
+    user = context['user']
+    return {'success': Authorizer.is_sysadmin(user)}
diff --git a/ckan/logic/auth/update.py b/ckan/logic/auth/update.py
index b2b15fc6831..54a4230560c 100644
--- a/ckan/logic/auth/update.py
+++ b/ckan/logic/auth/update.py
@@ -159,6 +159,10 @@ def task_status_update(context, data_dict):
     else:
         return {'success': True}
 
+def vocabulary_update(context, data_dict):
+    user = context['user']
+    return {'success': Authorizer.is_sysadmin(user)}
+
 ## Modifications for rest api
 
 def package_update_rest(context, data_dict):
diff --git a/ckan/logic/schema.py b/ckan/logic/schema.py
index 3142df75a95..8cbeef63ad2 100644
--- a/ckan/logic/schema.py
+++ b/ckan/logic/schema.py
@@ -30,7 +30,9 @@
                                    user_password_not_empty,
                                    isodate,
                                    int_validator,
-                                   user_about_validator)
+                                   user_about_validator,
+                                   vocabulary_name_validator,
+                                   vocabulary_id_not_changed)
 from formencode.validators import OneOf
 import ckan.model
 
@@ -265,3 +267,20 @@ def default_task_status_schema():
         'error': [ignore_missing]
     }
     return schema
+
+def default_vocabulary_schema():
+    schema = {
+        'id': [ignore_empty, ignore_missing, unicode],
+        'name': [not_empty, unicode, vocabulary_name_validator],
+    }
+    return schema
+
+def default_create_vocabulary_schema():
+    schema = default_vocabulary_schema()
+    schema['id'] = [empty]
+    return schema
+
+def default_update_vocabulary_schema():
+    schema = default_vocabulary_schema()
+    schema['id'] = schema['id'] + [vocabulary_id_not_changed]
+    return schema
diff --git a/ckan/logic/validators.py b/ckan/logic/validators.py
index 08aba5fdf8a..f93586f7c42 100644
--- a/ckan/logic/validators.py
+++ b/ckan/logic/validators.py
@@ -7,7 +7,9 @@
 from ckan.lib.helpers import date_str_to_datetime
 from ckan.model import (MAX_TAG_LENGTH, MIN_TAG_LENGTH,
                         PACKAGE_NAME_MIN_LENGTH, PACKAGE_NAME_MAX_LENGTH,
-                        PACKAGE_VERSION_MAX_LENGTH)
+                        PACKAGE_VERSION_MAX_LENGTH,
+                        VOCABULARY_NAME_MAX_LENGTH,
+                        VOCABULARY_NAME_MIN_LENGTH)
 
 def package_id_not_changed(value, context):
 
@@ -318,3 +320,26 @@ def user_about_validator(value,context):
         raise Invalid(_('Edit not allowed as it looks like spam. Please avoid links in your description.'))
 
     return value
+
+def vocabulary_name_validator(name, context):
+    model = context['model']
+    session = context['session']
+
+    if len(name) < VOCABULARY_NAME_MIN_LENGTH:
+        raise Invalid(_('Name must be at least %s characters long') %
+            VOCABULARY_NAME_MIN_LENGTH)
+    if len(name) > VOCABULARY_NAME_MAX_LENGTH:
+        raise Invalid(_('Name must be a maximum of %i characters long') %
+                      VOCABULARY_NAME_MAX_LENGTH)
+    query = session.query(model.Vocabulary.name).filter_by(name=name)
+    result = query.first()
+    if result:
+        raise Invalid(_('That vocabulary name is already in use.'))
+    return name
+
+def vocabulary_id_not_changed(value, context):
+    vocabulary = context.get('vocabulary')
+    if vocabulary and value != vocabulary.id:
+        raise Invalid(_('Cannot change value of key from %s to %s. '
+                        'This key is read-only') % (vocabulary.id, value))
+    return value
diff --git a/ckan/model/vocabulary.py b/ckan/model/vocabulary.py
index 45ff3603e19..c1d5b27d750 100644
--- a/ckan/model/vocabulary.py
+++ b/ckan/model/vocabulary.py
@@ -2,12 +2,14 @@
 from core import metadata, Column, DomainObject, mapper
 from types import make_uuid
 
-MAX_VOCAB_NAME_LENGTH = 100
+VOCABULARY_NAME_MIN_LENGTH = 2
+VOCABULARY_NAME_MAX_LENGTH = 100
 
 vocabulary_table = Table(
     'vocabulary', metadata,
     Column('id', types.UnicodeText, primary_key=True, default=make_uuid),
-    Column('name', types.Unicode(MAX_VOCAB_NAME_LENGTH), nullable=False, unique=True),
+    Column('name', types.Unicode(VOCABULARY_NAME_MAX_LENGTH), nullable=False,
+        unique=True),
     )
 
 class Vocabulary(DomainObject):
diff --git a/ckan/tests/functional/api/model/test_vocabulary.py b/ckan/tests/functional/api/model/test_vocabulary.py
index 276f583bad8..cd61e21ae06 100644
--- a/ckan/tests/functional/api/model/test_vocabulary.py
+++ b/ckan/tests/functional/api/model/test_vocabulary.py
@@ -2,32 +2,46 @@
 from pylons.test import pylonsapp
 import paste.fixture
 from ckan.lib.helpers import json
+import sqlalchemy
+from nose.tools import raises, assert_raises
 
 class TestVocabulary(object):
 
-    @classmethod
-    def setup_class(cls):
-        cls.app = paste.fixture.TestApp(pylonsapp)
+    def setup(self):
+        self.app = paste.fixture.TestApp(pylonsapp)
         ckan.tests.CreateTestData.create()
+        self.sysadmin_user = ckan.model.User.get('testsysadmin')
+        self.normal_user = ckan.model.User.get('annafan')
+        # Make a couple of test vocabularies needed later.
+        self.genre_vocab = self._create_vocabulary(vocab_name="Genre",
+                user=self.sysadmin_user)
+        self.timeperiod_vocab = self._create_vocabulary(
+                vocab_name="Time Period", user=self.sysadmin_user)
+        self.composers_vocab = self._create_vocabulary(vocab_name="Composers",
+                user=self.sysadmin_user)
 
-    @classmethod
-    def teardown_class(cls):
+    def teardown(self):
         ckan.model.repo.rebuild_db()
 
-    def post(self, url, param_dict=None):
-        if param_dict is None:
-            param_dict = {}
-        param_string = json.dumps(param_dict)
-        response = self.app.post(url, params=param_string)
+    def _post(self, url, params=None, extra_environ=None):
+        if params is None:
+            params = {}
+        param_string = json.dumps(params)
+        response = self.app.post(url, params=param_string,
+                extra_environ=extra_environ)
         assert not response.errors
         return response.json
 
-    def test_vocabulary_create(self):
-
+    def _create_vocabulary(self, vocab_name=None, user=None):
         # Create a new vocabulary.
-        vocab_name = "Genre"
-        params = {'vocabulary': {'name': vocab_name}}
-        response = self.post('/api/action/vocabulary_create', params)
+        params = {'name': vocab_name}
+        if user:
+            extra_environ = {'Authorization' : str(user.apikey)}
+        else:
+            extra_environ = None
+        response = self._post('/api/action/vocabulary_create', params=params,
+                extra_environ=extra_environ)
+
         # Check the values of the response.
         assert response['success'] == True
         assert response['result']
@@ -36,7 +50,7 @@ def test_vocabulary_create(self):
         assert created_vocab['id']
 
         # Get the list of vocabularies.
-        response = self.post('/api/action/vocabulary_list')
+        response = self._post('/api/action/vocabulary_list')
         # Check that the vocabulary we created is in the list.
         assert response['success'] == True
         assert response['result']
@@ -44,25 +58,256 @@ def test_vocabulary_create(self):
 
         # Get the created vocabulary.
         params = {'id': created_vocab['id']}
-        response = self.post('/api/action/vocabulary_show', params)
+        response = self._post('/api/action/vocabulary_show', params)
         # Check that retrieving the vocab by name gives the same result.
         by_name_params = {'name': created_vocab['name']}
-        assert response == self.post('/api/action/vocabulary_show',
+        assert response == self._post('/api/action/vocabulary_show',
                 by_name_params)
         # Check that it matches what we created.
         assert response['success'] == True
         assert response['result'] == created_vocab
 
+        return created_vocab
+
+    def _update_vocabulary(self, params, user=None):
+        if user:
+            extra_environ = {'Authorization' : str(user.apikey)}
+        else:
+            extra_environ = None
+        response = self._post('/api/action/vocabulary_update', params=params,
+                extra_environ=extra_environ)
+
+        # Check the values of the response.
+        assert response['success'] == True
+        assert response['result']
+        updated_vocab = response['result']
+        if params.has_key('id'):
+            assert updated_vocab['id'] == params['id']
+        else:
+            assert updated_vocab['id']
+        if params.has_key('name'):
+            assert updated_vocab['name'] == params['name']
+        else:
+            assert updated_vocab['name']
+
+        # Get the list of vocabularies.
+        response = self._post('/api/action/vocabulary_list')
+        # Check that the vocabulary we created is in the list.
+        assert response['success'] == True
+        assert response['result']
+        assert response['result'].count(updated_vocab) == 1
+
+        # Get the created vocabulary.
+        params = {'id': updated_vocab['id']}
+        response = self._post('/api/action/vocabulary_show', params)
+        # Check that retrieving the vocab by name gives the same result.
+        by_name_params = {'name': updated_vocab['name']}
+        assert response == self._post('/api/action/vocabulary_show',
+                by_name_params)
+        # Check that it matches what we created.
+        assert response['success'] == True
+        assert response['result'] == updated_vocab
+
+        return updated_vocab
+
+    def _delete_vocabulary(self, vocab_id, user=None):
+        if user:
+            extra_environ = {'Authorization' : str(user.apikey)}
+        else:
+            extra_environ = None
+        params = {'id': vocab_id}
+        response = self._post('/api/action/vocabulary_delete', params=params,
+                extra_environ=extra_environ)
+
+        # Check the values of the response.
+        assert response['success'] == True
+        assert response['result'] is None
+        response['result']
+
+        # Get the list of vocabularies.
+        response = self._post('/api/action/vocabulary_list')
+        assert response['success'] == True
+        assert response['result']
+        # Check that the vocabulary we deleted is not in the list.
+        assert vocab_id not in [vocab['id'] for vocab in response['result']]
+
+        # Check that the deleted vocabulary can no longer be retrieved.
+        response = self.app.post('/api/action/vocabulary_show',
+                params=json.dumps(params),
+                extra_environ = {'Authorization':
+                    str(self.sysadmin_user.apikey)},
+                status=404)
+        assert response.json['success'] == False
+
+    def test_vocabulary_create(self):
+        '''Test adding a new vocabulary to a CKAN instance via the action
+        API.
+
+        '''
+        self._create_vocabulary(vocab_name="My cool vocab",
+                user=self.sysadmin_user)
+
+    def test_vocabulary_create_id(self):
+        '''Test error response when user tries to supply their own ID when
+        creating a vocabulary.
+        
+        '''
+        params = {'id': 'xxx', 'name': 'foobar'}
+        param_string = json.dumps(params)
+        response = self.app.post('/api/action/vocabulary_create',
+                params=param_string,
+                extra_environ = {'Authorization':
+                    str(self.sysadmin_user.apikey)},
+                status=409)
+        assert response.json['success'] == False
+
+    def test_vocabulary_create_no_name(self):
+        '''Test error response when user tries to create a vocab without a
+        name.
+
+        '''
+        params = {}
+        param_string = json.dumps(params)
+        response = self.app.post('/api/action/vocabulary_create',
+                params=param_string,
+                extra_environ = {'Authorization':
+                    str(self.sysadmin_user.apikey)},
+                status=409)
+        assert response.json['success'] == False
+
+    def test_vocabulary_create_invalid_name(self):
+        '''Test error response when user tries to create a vocab with an
+        invalid name.
+
+        '''
+        for name in (None, '', 'a', 'foobar'*100):
+            params = {'name': name}
+            param_string = json.dumps(params)
+            response = self.app.post('/api/action/vocabulary_create',
+                    params=param_string,
+                    extra_environ = {'Authorization':
+                        str(self.sysadmin_user.apikey)},
+                    status=409)
+            assert response.json['success'] == False
+
+    def test_vocabulary_create_exists(self):
+        '''Test error response when user tries to create a vocab that already
+        exists.
+
+        '''
+        params = {'name': self.genre_vocab['name']}
+        param_string = json.dumps(params)
+        response = self.app.post('/api/action/vocabulary_create',
+                params=param_string,
+                extra_environ = {'Authorization':
+                    str(self.sysadmin_user.apikey)},
+                status=409)
+        assert response.json['success'] == False
+
+    def test_vocabulary_create_not_logged_in(self):
+        '''Test that users who are not logged in cannot create vocabularies.'''
+
+        params = {'name':
+            "Spam Vocabulary: SpamCo Duck Rental: Rent Your Ducks From Us!"}
+        param_string = json.dumps(params)
+        response = self.app.post('/api/action/vocabulary_create',
+                params=param_string,
+                status=403)
+        assert response.json['success'] == False
+
+    def test_vocabulary_create_not_authorized(self):
+        '''Test that users who are not authorized cannot create vocabs.'''
+
+        params = {'name': 'My Unauthorised Vocabulary'}
+        param_string = json.dumps(params)
+        response = self.app.post('/api/action/vocabulary_create',
+                params=param_string,
+                extra_environ = {'Authorization':
+                    str(self.normal_user.apikey)},
+                status=403)
+        assert response.json['success'] == False
+
     def test_vocabulary_update(self):
-        # Create a vocab.
-        # Update the vocab via the API.
-        # List vocabs
-        # Get vocab, assert fields correct.
-        raise NotImplementedError
+        self._update_vocabulary({'id': self.genre_vocab['id'],
+            'name': 'updated_name'}, self.sysadmin_user)
+
+    def test_vocabulary_update_not_exists(self):
+        '''Test the error response given when a user tries to update a
+        vocabulary that doesn't exist.
+
+        '''
+        params = {'id': 'xxxxxxx', 'name': 'updated_name'}
+        param_string = json.dumps(params)
+        response = self.app.post('/api/action/vocabulary_update',
+                params=param_string,
+                extra_environ = {'Authorization':
+                    str(self.sysadmin_user.apikey)},
+                status=404)
+        assert response.json['success'] == False
+
+    def test_vocabulary_update_no_name(self):
+        params = {'id': self.genre_vocab['id']}
+        param_string = json.dumps(params)
+        response = self.app.post('/api/action/vocabulary_update',
+                params=param_string,
+                extra_environ = {'Authorization':
+                    str(self.sysadmin_user.apikey)},
+                status=409)
+        assert response.json['success'] == False
+
+    def test_vocabulary_update_not_logged_in(self):
+        '''Test that users who are not logged in cannot update vocabularies.'''
+        params = {'id': self.genre_vocab['id']}
+        param_string = json.dumps(params)
+        response = self.app.post('/api/action/vocabulary_update',
+                params=param_string,
+                status=403)
+        assert response.json['success'] == False
+
+    def test_vocabulary_update_not_authorized(self):
+        '''Test that users who are not authorized cannot update vocabs.'''
+        params = {'id': self.genre_vocab['id']}
+        param_string = json.dumps(params)
+        response = self.app.post('/api/action/vocabulary_update',
+                params=param_string,
+                extra_environ = {'Authorization':
+                    str(self.normal_user.apikey)},
+                status=403)
+        assert response.json['success'] == False
 
     def test_vocabulary_delete(self):
-        # Create a vocab.
-        # Delete a vocab via the API
-        # List vocabs, assert that it's gone.
-        raise NotImplementedError
+        self._delete_vocabulary(self.genre_vocab['id'], self.sysadmin_user)
+
+    def test_vocabulary_delete_not_exists(self):
+        '''Test the error response given when a user tries to delete a
+        vocabulary that doesn't exist.
+
+        '''
+        params = {'id': 'xxxxxxx'}
+        param_string = json.dumps(params)
+        response = self.app.post('/api/action/vocabulary_delete',
+                params=param_string,
+                extra_environ = {'Authorization':
+                    str(self.sysadmin_user.apikey)},
+                status=404)
+        assert response.json['success'] == False
+
+    def test_vocabulary_delete_not_logged_in(self):
+        '''Test that users who are not logged in cannot delete vocabularies.'''
+        params = {'id': self.genre_vocab['id']}
+        param_string = json.dumps(params)
+        response = self.app.post('/api/action/vocabulary_delete',
+                params=param_string,
+                status=403)
+        assert response.json['success'] == False
 
+    def test_vocabulary_delete_not_authorized(self):
+        '''Test that users who are not authorized cannot delete vocabs.'''
+        params = {'id': self.genre_vocab['id']}
+        param_string = json.dumps(params)
+        response = self.app.post('/api/action/vocabulary_delete',
+                params=param_string,
+                extra_environ = {'Authorization':
+                    str(self.normal_user.apikey)},
+                status=403)
+        assert response.json['success'] == False

From ba1f50e6dac78265102c00e1f072603a251b20e1 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Mon, 30 Jan 2012 18:34:11 +0100
Subject: [PATCH 03/72] [#1705] Add vocabulary column to tag table

---
 ckan/model/tag.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/ckan/model/tag.py b/ckan/model/tag.py
index b73dcb3d0ef..69f7aac974f 100644
--- a/ckan/model/tag.py
+++ b/ckan/model/tag.py
@@ -7,6 +7,7 @@
 from domain_object import DomainObject
 from package import Package
 from core import *
+import vocabulary
 
 __all__ = ['tag_table', 'package_tag_table', 'Tag', 'PackageTag',
            'PackageTagRevision', 'package_tag_revision_table',
@@ -17,7 +18,11 @@
 
 tag_table = Table('tag', metadata,
         Column('id', types.UnicodeText, primary_key=True, default=make_uuid),
-        Column('name', types.Unicode(MAX_TAG_LENGTH), nullable=False, unique=True),
+        Column('name', types.Unicode(MAX_TAG_LENGTH), nullable=False,
+            unique=True),
+        Column('vocabulary_id',
+            types.Unicode(vocabulary.VOCABULARY_NAME_MAX_LENGTH),
+            ForeignKey('vocabulary.id'))
 )
 
 package_tag_table = Table('package_tag', metadata,

From 74ed1a2913b035e549135bce3af506b6dac09e9e Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Mon, 30 Jan 2012 19:03:27 +0100
Subject: [PATCH 04/72] [#1705] Update tag column unique constraint

Tag names are no longer unique, instead (name, vocabulary_id) column pairs
in the tag table are unique. CKAN can now have two tags with the same
name, as long as they belong to different vocabularies. Each tag still
has a unique ID as its primary key.
---
 ckan/model/tag.py | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/ckan/model/tag.py b/ckan/model/tag.py
index 69f7aac974f..691eadb4260 100644
--- a/ckan/model/tag.py
+++ b/ckan/model/tag.py
@@ -1,5 +1,4 @@
-from sqlalchemy.orm import eagerload_all
-from sqlalchemy import and_
+import sqlalchemy
 import vdm.sqlalchemy
 
 from types import make_uuid
@@ -18,11 +17,11 @@
 
 tag_table = Table('tag', metadata,
         Column('id', types.UnicodeText, primary_key=True, default=make_uuid),
-        Column('name', types.Unicode(MAX_TAG_LENGTH), nullable=False,
-            unique=True),
+        Column('name', types.Unicode(MAX_TAG_LENGTH), nullable=False),
         Column('vocabulary_id',
             types.Unicode(vocabulary.VOCABULARY_NAME_MAX_LENGTH),
-            ForeignKey('vocabulary.id'))
+            ForeignKey('vocabulary.id')),
+        sqlalchemy.UniqueConstraint('name', 'vocabulary_id')
 )
 
 package_tag_table = Table('package_tag', metadata,
@@ -47,7 +46,7 @@ def delete(self):
     def get(cls, reference):
         '''Returns a tag object referenced by its id or name.'''
         query = Session.query(cls).filter(cls.id==reference)
-        query = query.options(eagerload_all('package_tags'))
+        query = query.options(sqlalchemy.orm.eagerload_all('package_tags'))
         tag = query.first()
         if tag == None:
             tag = cls.by_name(reference)
@@ -71,7 +70,7 @@ def search_by_name(cls, text_query):
     def all(cls):
         q = Session.query(cls)
         q = q.distinct().join(PackageTagRevision)
-        q = q.filter(and_(
+        q = q.filter(sqlalchemy.and_(
             PackageTagRevision.state == 'active', PackageTagRevision.current == True
         ))
         return q
@@ -81,7 +80,7 @@ def packages_ordered(self):
         q = Session.query(Package)
         q = q.join(PackageTagRevision)
         q = q.filter(PackageTagRevision.tag_id == self.id)
-        q = q.filter(and_(
+        q = q.filter(sqlalchemy.and_(
             PackageTagRevision.state == 'active', PackageTagRevision.current == True
         ))
         packages = [p for p in q]

From 2227d512809bcab9221327e99b3f8c2361ec3f35 Mon Sep 17 00:00:00 2001
From: David Read <david.read@okfn.org>
Date: Tue, 31 Jan 2012 11:34:12 +0000
Subject: [PATCH 05/72] [master][#1725][logic/validators]: Ignore trailing
 commas in tag list (created by tag autocomplete).

---
 ckan/logic/validators.py            | 17 +++++++--------
 ckan/tests/logic/test_validators.py | 32 +++++++++++++++++++++++++++++
 2 files changed, 39 insertions(+), 10 deletions(-)
 create mode 100644 ckan/tests/logic/test_validators.py

diff --git a/ckan/logic/validators.py b/ckan/logic/validators.py
index f93586f7c42..c272fc9502c 100644
--- a/ckan/logic/validators.py
+++ b/ckan/logic/validators.py
@@ -195,18 +195,15 @@ def tag_not_uppercase(value, context):
     return value
 
 def tag_string_convert(key, data, errors, context):
+    '''Takes a list of tags that is a comma-separated string (in data[key])
+    and parses tag names. These are added to the data dict, enumerated. They
+    are also validated.'''
+    tag_string = data[key]
 
-    value = data[key]
-
-    # Ensure a tag string with only whitespace
-    # is converted to the empty list of tags.
-    # If we were to split(',') on this string,
-    # we'd get the non-empty list, [''].
-    if not value.strip():
-        return
+    tags = [tag.strip() \
+            for tag in tag_string.split(',') \
+            if tag.strip()]
 
-    tags = map(lambda s: s.strip(),
-               value.split(','))
     for num, tag in enumerate(tags):
         data[('tags', num, 'name')] = tag
 
diff --git a/ckan/tests/logic/test_validators.py b/ckan/tests/logic/test_validators.py
new file mode 100644
index 00000000000..aab45038ef7
--- /dev/null
+++ b/ckan/tests/logic/test_validators.py
@@ -0,0 +1,32 @@
+from nose.tools import assert_equal
+
+from ckan import model
+from ckan.logic.validators import tag_string_convert
+
+class TestValidators:
+    def test_01_tag_string_convert(self):
+        def convert(tag_string):
+            key = 'tag_string'
+            data = {key: tag_string}
+            errors = []
+            context = {'model': model, 'session': model.Session}
+            tag_string_convert(key, data, errors, context)
+            tags = []
+            i = 0
+            while True:
+                tag = data.get(('tags', i, 'name'))
+                if not tag:
+                    break
+                tags.append(tag)
+                i += 1
+            return tags
+        assert_equal(convert('big, good'), ['big', 'good'])
+        assert_equal(convert('one, several word tag, with-hyphen'),
+                     ['one', 'several word tag', 'with-hyphen'])
+        assert_equal(convert(''),
+                     [])
+        assert_equal(convert('trailing comma,'),
+                     ['trailing comma'])
+        assert_equal(convert('trailing comma space, '),
+                     ['trailing comma space'])
+

From a411b14b90db68569e177158908f6b6902f6559c Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Tue, 31 Jan 2012 15:26:44 +0000
Subject: [PATCH 06/72] [logic/converters] Add converter for tag string to tag
 with vocab

---
 ckan/logic/converters.py            | 37 +++++++++++++++++++++++++----
 ckan/tests/logic/test_converters.py | 20 ++++++++++++++++
 2 files changed, 52 insertions(+), 5 deletions(-)
 create mode 100644 ckan/tests/logic/test_converters.py

diff --git a/ckan/logic/converters.py b/ckan/logic/converters.py
index 540ee5a07e6..18a2ad50619 100644
--- a/ckan/logic/converters.py
+++ b/ckan/logic/converters.py
@@ -1,18 +1,14 @@
 from ckan.lib.navl.dictization_functions import Invalid
 from ckan.lib.field_types import DateType, DateConvertError
-
-
+from ckan.logic.validators import tag_length_validator, tag_name_validator
 
 def convert_to_extras(key, data, errors, context):
-
     extras = data.get(('extras',), [])
     if not extras:
         data[('extras',)] = extras
-
     extras.append({'key': key[-1], 'value': data[key]})
 
 def convert_from_extras(key, data, errors, context):
-
     for data_key, data_value in data.iteritems():
         if (data_key[0] == 'extras'
             and data_key[-1] == 'key'
@@ -33,3 +29,34 @@ def date_to_form(value, context):
         raise Invalid(str(e))
     return value
 
+def convert_to_tags(vocab):
+    def callable(key, data, errors, context):
+        tag_string = data.get(key)
+        new_tags = [tag.strip() for tag in tag_string.split(',') if tag.strip()]
+
+        if not new_tags:
+            return
+
+        # get current number of tags
+        n = 0
+        for k in data.keys():
+            if k[0] == 'tags':
+                n = max(n, k[1] + 1)
+
+        # validate
+        for tag in new_tags:
+            tag_length_validator(tag, context)
+            tag_name_validator(tag, context)
+
+        # add new tags
+        for num, tag in enumerate(new_tags):
+            data[('tags', num+n, 'name')] = tag
+            data[('tags', num+n, 'vocabulary')] = vocab
+
+    return callable
+
+def convert_from_tags(vocab):
+    def callable(key, data, errors, context):
+        pass
+    return callable
+
diff --git a/ckan/tests/logic/test_converters.py b/ckan/tests/logic/test_converters.py
new file mode 100644
index 00000000000..9e9e06337bc
--- /dev/null
+++ b/ckan/tests/logic/test_converters.py
@@ -0,0 +1,20 @@
+from ckan import model
+from ckan.logic.converters import convert_to_tags
+from ckan.lib.navl.dictization_functions import unflatten
+
+class TestConverters:
+    def test_convert_to_tags(self):
+        def convert(tag_string, vocab):
+            key = 'vocab_tag_string'
+            data = {key: tag_string}
+            errors = []
+            context = {'model': model, 'session': model.Session}
+            convert_to_tags('vocab')(key, data, errors, context)
+            del data[key]
+            return data
+
+        data = unflatten(convert('tag1, tag2', 'vocab'))
+        for tag in data['tags']:
+            assert tag['name'] in ['tag1', 'tag2']
+            assert tag['vocabulary'] == 'vocab'
+

From f7810165b73adb3db3ed60d771bc5b4c37d77751 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Tue, 31 Jan 2012 16:33:09 +0100
Subject: [PATCH 07/72] [#1705] Add optional vocab argument to Tag.get() and
 Tag.by_name()

With the default value for the new vocab argument (None) Tag.get() and
Tag.by_name() will return only free tags (tags that don't belong to any
vocabulary). If a vocab argument is given they'll only return tags from
that vocab.

All the tests still pass, but new tests will need to be added for this.
---
 ckan/model/tag.py        | 92 ++++++++++++++++++++++++++++++++++------
 ckan/model/vocabulary.py |  6 +--
 2 files changed, 81 insertions(+), 17 deletions(-)

diff --git a/ckan/model/tag.py b/ckan/model/tag.py
index 691eadb4260..e67acbba3e2 100644
--- a/ckan/model/tag.py
+++ b/ckan/model/tag.py
@@ -7,6 +7,7 @@
 from package import Package
 from core import *
 import vocabulary
+from vocabulary import Vocabulary
 
 __all__ = ['tag_table', 'package_tag_table', 'Tag', 'PackageTag',
            'PackageTagRevision', 'package_tag_revision_table',
@@ -35,23 +36,92 @@
 package_tag_revision_table = make_revisioned_table(package_tag_table)
 
 class Tag(DomainObject):
-    def __init__(self, name=''):
+    def __init__(self, name='', vocabulary_id=None):
         self.name = name
+        self.vocabulary_id = vocabulary_id
 
     # not stateful so same as purge
     def delete(self):
         self.purge()
 
     @classmethod
-    def get(cls, reference):
-        '''Returns a tag object referenced by its id or name.'''
-        query = Session.query(cls).filter(cls.id==reference)
-        query = query.options(sqlalchemy.orm.eagerload_all('package_tags'))
+    def by_id(cls, tag_id, autoflush=True, vocab=None):
+        """Return the tag object with the given id, or None if there is no
+        tag with that id.
+
+        By default only free tags (tags which do not belong to any vocabulary)
+        are returned. If the optional argument vocab is given then only tags
+        from that vocabulary are returned, or None if there is no tag with that
+        id in that vocabulary.
+
+        Arguments:
+        tag_id -- The id of the tag to return.
+        vocab -- A Vocabulary object for the vocabulary to look in (optional).
+
+        """
+        if vocab:
+            query = Session.query(Tag).filter(Tag.id==tag_id).filter(
+                Tag.vocabulary_id==vocab.id)
+        else:
+            query = Session.query(Tag).filter(Tag.id==tag_id).filter(
+                Tag.vocabulary_id==None)
+        query = query.autoflush(autoflush)
         tag = query.first()
-        if tag == None:
-            tag = cls.by_name(reference)
         return tag
-    # Todo: Make sure tag names can't be changed to look like tag IDs?
+
+    @classmethod
+    def by_name(cls, name, autoflush=True, vocab=None):
+        """Return the tag object with the given name, or None if there is no
+        tag with that name.
+
+        By default only free tags (tags which do not belong to any vocabulary)
+        are returned. If the optional argument vocab is given then only tags
+        from that vocabulary are returned, or None if there is no tag with that
+        name in that vocabulary.
+
+        Arguments:
+        name -- The name of the tag to return.
+        vocab -- A Vocabulary object for the vocabulary to look in (optional).
+
+        """
+        if vocab:
+            query = Session.query(Tag).filter(Tag.name==name).filter(
+                Tag.vocabulary_id==vocab.id)
+        else:
+            query = Session.query(Tag).filter(Tag.name==name).filter(
+                Tag.vocabulary_id==None)
+        query = query.autoflush(autoflush)
+        tag = query.first()
+        return tag
+
+    @classmethod
+    def get(cls, tag_id_or_name, vocab_id_or_name=None):
+        """Return the tag object with the given id or name, or None if there is
+        no tag with that id or name.
+
+        By default only free tags (tags which do not belong to any vocabulary)
+        are returned. If the optional argument vocab_id_or_name is given then
+        only tags that belong to that vocabulary will be returned, and None
+        will be returned if there is no vocabulary with that vocabulary id or
+        name or if there is no tag with that tag id or name in that vocabulary.
+
+        Arguments:
+        tag_id_or_name -- The id or name of the tag to return.
+        vocab_id_or_name -- The id or name of the vocabulary to look in.
+
+        """
+        if vocab_id_or_name:
+            vocab = Vocabulary.get(vocab_id_or_name)
+            if vocab is None:
+                # The user specified an invalid vocab.
+                return None
+        else:
+            vocab = None
+        tag = Tag.by_id(tag_id_or_name, vocab=vocab)
+        if not tag:
+            tag = Tag.by_name(tag_id_or_name, vocab=vocab)
+        return tag
+        # Todo: Make sure tag names can't be changed to look like tag IDs?
 
     @classmethod
     def search_by_name(cls, text_query):
@@ -60,12 +130,6 @@ def search_by_name(cls, text_query):
         q = q.distinct().join(cls.package_tags)
         return q
         
-    #@classmethod
-    #def by_name(self, name, autoflush=True):
-    #    q = Session.query(self).autoflush(autoflush).filter_by(name=name)
-    #    q = q.distinct().join(self.package_tags)
-    #    return q.first()
-        
     @classmethod
     def all(cls):
         q = Session.query(cls)
diff --git a/ckan/model/vocabulary.py b/ckan/model/vocabulary.py
index c1d5b27d750..2505d39a28a 100644
--- a/ckan/model/vocabulary.py
+++ b/ckan/model/vocabulary.py
@@ -19,13 +19,13 @@ def __init__(self, name):
         self.name = name
 
     @classmethod
-    def get(cls, reference):
+    def get(cls, id_or_name):
         """Return a Vocabulary object referenced by its id or name."""
 
-        query = Session.query(cls).filter(cls.id==reference)
+        query = Session.query(cls).filter(cls.id==id_or_name)
         vocab = query.first()
         if vocab is None:
-            vocab = cls.by_name(reference)            
+            vocab = cls.by_name(id_or_name)
         return vocab
 
 mapper(Vocabulary, vocabulary_table)

From 343c8c5a93fafdd76e94fbc7ee84bdc777131d89 Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Wed, 1 Feb 2012 10:03:41 +0000
Subject: [PATCH 08/72] [logic/converters] get vocab ID in convert_to_tags

---
 ckan/logic/converters.py            | 13 +++++++------
 ckan/tests/logic/test_converters.py | 16 ++++++++++++----
 2 files changed, 19 insertions(+), 10 deletions(-)

diff --git a/ckan/logic/converters.py b/ckan/logic/converters.py
index 18a2ad50619..9b8659cb799 100644
--- a/ckan/logic/converters.py
+++ b/ckan/logic/converters.py
@@ -1,3 +1,4 @@
+from ckan import model
 from ckan.lib.navl.dictization_functions import Invalid
 from ckan.lib.field_types import DateType, DateConvertError
 from ckan.logic.validators import tag_length_validator, tag_name_validator
@@ -33,26 +34,26 @@ def convert_to_tags(vocab):
     def callable(key, data, errors, context):
         tag_string = data.get(key)
         new_tags = [tag.strip() for tag in tag_string.split(',') if tag.strip()]
-
         if not new_tags:
             return
-
         # get current number of tags
         n = 0
         for k in data.keys():
             if k[0] == 'tags':
                 n = max(n, k[1] + 1)
-
         # validate
         for tag in new_tags:
             tag_length_validator(tag, context)
             tag_name_validator(tag, context)
-
+        # get the vocab
+        v = model.Vocabulary.get(vocab)
+        if not v:
+            # TODO: raise an exception here
+            pass
         # add new tags
         for num, tag in enumerate(new_tags):
             data[('tags', num+n, 'name')] = tag
-            data[('tags', num+n, 'vocabulary')] = vocab
-
+            data[('tags', num+n, 'vocabulary_id')] = v.id
     return callable
 
 def convert_from_tags(vocab):
diff --git a/ckan/tests/logic/test_converters.py b/ckan/tests/logic/test_converters.py
index 9e9e06337bc..f45bd1e95f2 100644
--- a/ckan/tests/logic/test_converters.py
+++ b/ckan/tests/logic/test_converters.py
@@ -3,18 +3,26 @@
 from ckan.lib.navl.dictization_functions import unflatten
 
 class TestConverters:
+    @classmethod
+    def setup_class(cls):
+        # create a new vocabulary
+        cls.vocab = model.Vocabulary('test-vocab') 
+        model.Session.add(cls.vocab)
+        model.Session.commit()
+        model.Session.remove()
+
     def test_convert_to_tags(self):
         def convert(tag_string, vocab):
             key = 'vocab_tag_string'
             data = {key: tag_string}
             errors = []
             context = {'model': model, 'session': model.Session}
-            convert_to_tags('vocab')(key, data, errors, context)
+            convert_to_tags(vocab)(key, data, errors, context)
             del data[key]
             return data
 
-        data = unflatten(convert('tag1, tag2', 'vocab'))
+        data = unflatten(convert('tag1, tag2', 'test-vocab'))
         for tag in data['tags']:
-            assert tag['name'] in ['tag1', 'tag2']
-            assert tag['vocabulary'] == 'vocab'
+            assert tag['name'] in ['tag1', 'tag2'], tag['name']
+            assert tag['vocabulary_id'] == self.vocab.id, tag['vocabulary_id']
 

From 685acdc99d7429556b98ff2534ab54af50a06e98 Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Wed, 1 Feb 2012 10:06:58 +0000
Subject: [PATCH 09/72] [logic/converters] raise exception for unknown vocab

---
 ckan/logic/converters.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/ckan/logic/converters.py b/ckan/logic/converters.py
index 9b8659cb799..ef415cae98c 100644
--- a/ckan/logic/converters.py
+++ b/ckan/logic/converters.py
@@ -1,3 +1,4 @@
+from pylons.i18n import _
 from ckan import model
 from ckan.lib.navl.dictization_functions import Invalid
 from ckan.lib.field_types import DateType, DateConvertError
@@ -45,11 +46,9 @@ def callable(key, data, errors, context):
         for tag in new_tags:
             tag_length_validator(tag, context)
             tag_name_validator(tag, context)
-        # get the vocab
         v = model.Vocabulary.get(vocab)
         if not v:
-            # TODO: raise an exception here
-            pass
+            raise Invalid(_('Tag vocabulary "%s" does not exist') % vocab)
         # add new tags
         for num, tag in enumerate(new_tags):
             data[('tags', num+n, 'name')] = tag

From fa89fe606ad38f995e367d18b43b6e4282c43a08 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Wed, 1 Feb 2012 12:31:21 +0100
Subject: [PATCH 10/72] [#1705] Add vocab_id_or_name=None args to some
 model/tag.py methods.

Change the behaviour of the methods so that they should return only free
tags (tags without a vocabulary) when called with no vocab_id_or_name
argument. With a vocab_id_or_name they return only tags belonging to
that vocab.

The existing tests still work but new tests for the new argument need to
be added.

Also added docstrings to these methods because it wasn't too obvious
what they did.
---
 ckan/model/tag.py | 98 ++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 76 insertions(+), 22 deletions(-)

diff --git a/ckan/model/tag.py b/ckan/model/tag.py
index e67acbba3e2..d480e028912 100644
--- a/ckan/model/tag.py
+++ b/ckan/model/tag.py
@@ -124,29 +124,63 @@ def get(cls, tag_id_or_name, vocab_id_or_name=None):
         # Todo: Make sure tag names can't be changed to look like tag IDs?
 
     @classmethod
-    def search_by_name(cls, text_query):
-        text_query = text_query.strip().lower()
-        q = Session.query(cls).filter(cls.name.contains(text_query))
-        q = q.distinct().join(cls.package_tags)
-        return q
-        
+    def search_by_name(cls, search_term, vocab_id_or_name=None):
+        """Return all tags that match the given search term.
+
+        By default only free tags (tags which do not belong to any vocabulary)
+        are returned. If the optional argument vocab_id_or_name is given then
+        only tags from that vocabulary are returned.
+
+        """
+        if vocab_id_or_name:
+            vocab = Vocabulary.get(vocab_id_or_name)
+            if vocab is None:
+                # The user specified an invalid vocab.
+                return None
+            query = Session.query(Tag).filter(Tag.vocabulary_id==vocab.id)
+        else:
+            query = Session.query(Tag)
+        search_term = search_term.strip().lower()
+        query = query.filter(Tag.name.contains(search_term))
+        query = query.distinct().join(Tag.package_tags)
+        return query
+
     @classmethod
-    def all(cls):
-        q = Session.query(cls)
-        q = q.distinct().join(PackageTagRevision)
-        q = q.filter(sqlalchemy.and_(
-            PackageTagRevision.state == 'active', PackageTagRevision.current == True
-        ))
-        return q
+    def all(cls, vocab_id_or_name=None):
+        """Return all tags that are currently applied to a package.
+
+        By default only free tags (tags which do not belong to any vocabulary)
+        are returned. If the optional argument vocab_id_or_name is given then
+        only tags from that vocabulary are returned.
+
+        """
+        if vocab_id_or_name:
+            vocab = Vocabulary.get(vocab_id_or_name)
+            if vocab is None:
+                # The user specified an invalid vocab.
+                return None
+            query = Session.query(Tag).filter(Tag.vocabulary_id==vocab.id)
+        else:
+            query = Session.query(Tag)
+        query = query.distinct().join(PackageTagRevision)
+        query = query.filter(sqlalchemy.and_(
+            PackageTagRevision.state == 'active',
+            PackageTagRevision.current == True))
+        return query
 
     @property
-    def packages_ordered(self):
+    def packages_ordered(self, vocab_id_or_name=None):
+        """Return a list of all packages currently tagged with this tag.
+
+        The list is sorted by package name.
+
+        """
         q = Session.query(Package)
         q = q.join(PackageTagRevision)
         q = q.filter(PackageTagRevision.tag_id == self.id)
         q = q.filter(sqlalchemy.and_(
-            PackageTagRevision.state == 'active', PackageTagRevision.current == True
-        ))
+            PackageTagRevision.state == 'active',
+            PackageTagRevision.current == True))
         packages = [p for p in q]
         ourcmp = lambda pkg1, pkg2: cmp(pkg1.name, pkg2.name)
         return sorted(packages, cmp=ourcmp)
@@ -169,12 +203,32 @@ def __repr__(self):
         return '<PackageTag package=%s tag=%s>' % (self.package.name, self.tag.name)
 
     @classmethod
-    def by_name(self, package_name, tag_name, autoflush=True):
-        q = Session.query(self).autoflush(autoflush).\
-            join('package').filter(Package.name==package_name).\
-            join('tag').filter(Tag.name==tag_name)
-        assert q.count() <= 1, q.all()
-        return q.first()
+    def by_name(self, package_name, tag_name, vocab_id_or_name=None,
+            autoflush=True):
+        """Return the one PackageTag for the given package and tag names, or
+        None if there is no PackageTag for that package and tag.
+
+        By default only PackageTags for free tags (tags which do not belong to
+        any vocabulary) are returned. If the optional argument vocab_id_or_name
+        is given then only PackageTags for tags from that vocabulary are
+        returned.
+
+        """
+        if vocab_id_or_name:
+            vocab = Vocabulary.get(vocab_id_or_name)
+            if vocab is None:
+                # The user specified an invalid vocab.
+                return None
+            query = (Session.query(PackageTag, Tag, Package)
+                    .filter(Tag.vocabulary_id == vocab.id)
+                    .filter(Package.name==package_name)
+                    .filter(Tag.name==tag_name))
+        else:
+            query = (Session.query(PackageTag)
+                    .filter(Package.name==package_name)
+                    .filter(Tag.name==tag_name))
+        query = query.autoflush(autoflush)
+        return query.one()[0]
 
     def related_packages(self):
         return [self.package]

From b3e72c93ba71290d7dccc8afbc9d3f5f0d7fb3ac Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Wed, 1 Feb 2012 12:40:45 +0100
Subject: [PATCH 11/72] [#1705] Remove an arg that I added by accident

---
 ckan/model/tag.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ckan/model/tag.py b/ckan/model/tag.py
index d480e028912..1eab9104dd0 100644
--- a/ckan/model/tag.py
+++ b/ckan/model/tag.py
@@ -169,7 +169,7 @@ def all(cls, vocab_id_or_name=None):
         return query
 
     @property
-    def packages_ordered(self, vocab_id_or_name=None):
+    def packages_ordered(self):
         """Return a list of all packages currently tagged with this tag.
 
         The list is sorted by package name.

From d1dbaeb10477216e43b4459ffbcd358bb1368c25 Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Wed, 1 Feb 2012 12:33:29 +0000
Subject: [PATCH 12/72] [dictization] Deduplicate/sort tags by (name, vocab)
 before saving

---
 ckan/lib/dictization/model_save.py | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/ckan/lib/dictization/model_save.py b/ckan/lib/dictization/model_save.py
index ecdad95287e..c1e82bfec88 100644
--- a/ckan/lib/dictization/model_save.py
+++ b/ckan/lib/dictization/model_save.py
@@ -132,7 +132,6 @@ def group_extras_save(extras_dicts, context):
     return result_dict
 
 def package_tag_list_save(tag_dicts, package, context):
-    
     allow_partial_update = context.get("allow_partial_update", False)
     if not tag_dicts and allow_partial_update:
         return
@@ -150,13 +149,13 @@ def package_tag_list_save(tag_dicts, package, context):
             pt.state in ['deleted', 'pending-deleted'] ]
         )
 
-    tag_names = set()
+    tag_name_vocab = set()
     tags = set()
     for tag_dict in tag_dicts:
-        if tag_dict.get('name') not in tag_names:
+        if (tag_dict.get('name'), tag_dict.get('vocabulary_id')) not in tag_name_vocab:
             tag_obj = table_dict_save(tag_dict, model.Tag, context)
             tags.add(tag_obj)
-            tag_names.add(tag_obj.name)
+            tag_name_vocab.add((tag_obj.name, tag_obj.vocabulary_id))
 
     # 3 cases
     # case 1: currently active but not in new list
@@ -167,14 +166,14 @@ def package_tag_list_save(tag_dicts, package, context):
         else:
             package_tag.state = 'deleted'
 
-    # in new list but never used before
+    # case 2: in new list but never used before
     for tag in tags - set(tag_package_tag.keys()):
         state = 'pending' if pending else 'active'
         package_tag_obj = model.PackageTag(package, tag, state)
         session.add(package_tag_obj)
         tag_package_tag[tag] = package_tag_obj
 
-    # in new list and already used but in deleted state
+    # case 3: in new list and already used but in deleted state
     for tag in tags.intersection(set(tag_package_tag_inactive.keys())):
         state = 'pending' if pending else 'active'
         package_tag = tag_package_tag[tag]

From 84386d7dfd9b8751627c9e2ce94b0f538bb0fc11 Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Wed, 1 Feb 2012 12:34:29 +0000
Subject: [PATCH 13/72] [logic/converters] add converter to remove a vocab tag
 from the list of all tags

---
 ckan/logic/converters.py | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/ckan/logic/converters.py b/ckan/logic/converters.py
index ef415cae98c..853778b7699 100644
--- a/ckan/logic/converters.py
+++ b/ckan/logic/converters.py
@@ -42,6 +42,7 @@ def callable(key, data, errors, context):
         for k in data.keys():
             if k[0] == 'tags':
                 n = max(n, k[1] + 1)
+
         # validate
         for tag in new_tags:
             tag_length_validator(tag, context)
@@ -49,14 +50,29 @@ def callable(key, data, errors, context):
         v = model.Vocabulary.get(vocab)
         if not v:
             raise Invalid(_('Tag vocabulary "%s" does not exist') % vocab)
-        # add new tags
+
         for num, tag in enumerate(new_tags):
             data[('tags', num+n, 'name')] = tag
             data[('tags', num+n, 'vocabulary_id')] = v.id
+
     return callable
 
 def convert_from_tags(vocab):
     def callable(key, data, errors, context):
-        pass
+        v = model.Vocabulary.get(vocab)
+        if not v:
+            raise Invalid(_('Tag vocabulary "%s" does not exist') % vocab)
+
+        tags = {}
+        for k in data.keys():
+            if k[0] == 'tags':
+                if data[k].get('vocabulary_id') == v.id:
+                    tags[k] = data[k]
+
+        # TODO: vocab tags should be removed in a separate converter (and by default) 'tags'
+        for k in tags.keys():
+            del data[k]
+        data[key] = ', '.join([t['name'] for t in tags.values()])
+
     return callable
 

From ea4541ac0311bc9f9f1472998479d17d54484c31 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Wed, 1 Feb 2012 18:12:35 +0100
Subject: [PATCH 14/72] [#1705] Add vocab=None argument to
 Package.add_tag_by_name()

And change the method to use free tags only if no vocab is given,
otherwise use tags from the given vocab only.
---
 ckan/model/package.py | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/ckan/model/package.py b/ckan/model/package.py
index bdbd8d7d49a..7c787ba98f0 100644
--- a/ckan/model/package.py
+++ b/ckan/model/package.py
@@ -159,13 +159,25 @@ def add_resource(self, url, format=u'', description=u'', hash=u'', **kw):
             hash=hash,
             **kw))
 
-    def add_tag_by_name(self, tagname, autoflush=True):
+    def add_tag_by_name(self, tag_name, vocab=None, autoflush=True):
+        """Add a tag with the given name to this package's tags.
+
+        By default only free tags (tags which do not belong to any vocabulary)
+        are used. If the optional argument vocab is given then only tags
+        belonging to that vocabulary will be used.
+
+        If no tag with the given name exists, one will be created. If the
+        optional argument vocab is given and no tag with the given name exists
+        in the given vocabulary, then a new tag will be created and added to
+        the vocabulary.
+
+        """
         from tag import Tag
-        if not tagname:
+        if not tag_name:
             return
-        tag = Tag.by_name(tagname, autoflush=autoflush)
+        tag = Tag.by_name(tag_name, vocab=vocab, autoflush=autoflush)
         if not tag:
-            tag = Tag(name=tagname)
+            tag = Tag(name=tag_name, vocabulary=vocab)
         if not tag in self.tags:
             self.tags.append(tag)
 

From c6a14378114e3ae4617eed9619fa69ead1298117 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Wed, 1 Feb 2012 18:36:34 +0100
Subject: [PATCH 15/72] Tidy up Package.tags_ordered()

Add a docstring, and use key= and attrgetter instead of cmp= and lambda
---
 ckan/model/package.py | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/ckan/model/package.py b/ckan/model/package.py
index 7c787ba98f0..856483165f5 100644
--- a/ckan/model/package.py
+++ b/ckan/model/package.py
@@ -1,6 +1,7 @@
 import datetime
 from time import gmtime
 from calendar import timegm
+from operator import attrgetter
 
 from sqlalchemy.sql import select, and_, union, expression, or_
 from sqlalchemy.orm import eagerload_all
@@ -84,7 +85,7 @@ def resources(self):
 
         assert len(self.resource_groups_all) == 1, "can only use resources on packages if there is only one resource_group"
         return self.resource_groups_all[0].resources
-    
+
     def update_resources(self, res_dicts, autoflush=True):
         '''Change this package\'s resources.
         @param res_dicts - ordered list of dicts, each detailing a resource
@@ -183,8 +184,14 @@ def add_tag_by_name(self, tag_name, vocab=None, autoflush=True):
 
     @property
     def tags_ordered(self):
-        ourcmp = lambda tag1, tag2: cmp(tag1.name, tag2.name)
-        return sorted(self.tags, cmp=ourcmp)
+        """Return a sorted list of this package's tags
+
+        Tags are sorted by the names of the vocabularies that they belong to
+        and then (within vocabularies) by their tag names
+
+        """
+        sorted_tags = sorted(self.tags, key=attrgetter('name'))
+        return sorted_tags
 
     def isopen(self):
         if self.license and self.license.isopen():

From 9f5d62bdbd2d33a6dea28be3ce3ab9c8fedc29af Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Wed, 1 Feb 2012 18:45:19 +0100
Subject: [PATCH 16/72] [#1705] Tidy up order of keyword args in Tag.by_name()

---
 ckan/model/tag.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ckan/model/tag.py b/ckan/model/tag.py
index 1eab9104dd0..b1f5063e4d4 100644
--- a/ckan/model/tag.py
+++ b/ckan/model/tag.py
@@ -70,7 +70,7 @@ def by_id(cls, tag_id, autoflush=True, vocab=None):
         return tag
 
     @classmethod
-    def by_name(cls, name, autoflush=True, vocab=None):
+    def by_name(cls, name, vocab=None, autoflush=True):
         """Return the tag object with the given name, or None if there is no
         tag with that name.
 

From 7ea9e639547d37326dfc3c36d4aedd2af9b963e0 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Wed, 1 Feb 2012 18:59:58 +0100
Subject: [PATCH 17/72] [#1705] Make vocabulary.get() a module function

...no longer a classmethod. It doesn't seem to need to be a classmethod,
and this way you can do:

    import vocabulary
    some_vocab = vocabulary.get(some_name)

Instead of having to do: `vocabulary.Vocabulary.get(some_name)`, which
looks too much like Java.
---
 ckan/lib/dictization/model_save.py |  2 +-
 ckan/logic/action/delete.py        |  2 +-
 ckan/logic/action/get.py           |  4 ++--
 ckan/logic/action/update.py        |  2 +-
 ckan/model/tag.py                  |  9 ++++-----
 ckan/model/vocabulary.py           | 19 +++++++++----------
 6 files changed, 18 insertions(+), 20 deletions(-)

diff --git a/ckan/lib/dictization/model_save.py b/ckan/lib/dictization/model_save.py
index ecdad95287e..55d9358d83f 100644
--- a/ckan/lib/dictization/model_save.py
+++ b/ckan/lib/dictization/model_save.py
@@ -457,7 +457,7 @@ def vocabulary_dict_update(vocabulary_dict, context):
     model = context['model']
     session = context['session']
 
-    vocabulary_obj = model.Vocabulary.get(vocabulary_dict['id'])
+    vocabulary_obj = model.vocabulary.get(vocabulary_dict['id'])
     vocabulary_obj.name = vocabulary_dict['name']
 
     return vocabulary_obj
diff --git a/ckan/logic/action/delete.py b/ckan/logic/action/delete.py
index d3b01c3885c..219e756ec79 100644
--- a/ckan/logic/action/delete.py
+++ b/ckan/logic/action/delete.py
@@ -108,7 +108,7 @@ def vocabulary_delete(context, data_dict):
     user = context['user']
     vocab_id = data_dict['id']
 
-    vocab_obj = model.Vocabulary.get(vocab_id)
+    vocab_obj = model.vocabulary.get(vocab_id)
     if vocab_obj is None:
         raise NotFound
 
diff --git a/ckan/logic/action/get.py b/ckan/logic/action/get.py
index 2812cdd76dd..8e1d6203f32 100644
--- a/ckan/logic/action/get.py
+++ b/ckan/logic/action/get.py
@@ -885,11 +885,11 @@ def vocabulary_show(context, data_dict):
     model = context['model']
 
     if data_dict.has_key('id'):
-        vocabulary = model.Vocabulary.get(data_dict['id'])
+        vocabulary = model.vocabulary.get(data_dict['id'])
         if vocabulary is None:
             raise NotFound
     elif data_dict.has_key('name'):
-        vocabulary = model.Vocabulary.get(data_dict['name'])
+        vocabulary = model.vocabulary.get(data_dict['name'])
         if vocabulary is None:
             raise NotFound
     else:
diff --git a/ckan/logic/action/update.py b/ckan/logic/action/update.py
index 43375e8832a..b274640ef29 100644
--- a/ckan/logic/action/update.py
+++ b/ckan/logic/action/update.py
@@ -500,7 +500,7 @@ def vocabulary_update(context, data_dict):
     model.Session.remove()
     model.Session()._context = context
 
-    vocab = model.Vocabulary.get(vocab_id)
+    vocab = model.vocabulary.get(vocab_id)
     if vocab is None:
         raise NotFound(_('Vocabulary was not found.'))
 
diff --git a/ckan/model/tag.py b/ckan/model/tag.py
index b1f5063e4d4..2894015d55d 100644
--- a/ckan/model/tag.py
+++ b/ckan/model/tag.py
@@ -7,7 +7,6 @@
 from package import Package
 from core import *
 import vocabulary
-from vocabulary import Vocabulary
 
 __all__ = ['tag_table', 'package_tag_table', 'Tag', 'PackageTag',
            'PackageTagRevision', 'package_tag_revision_table',
@@ -111,7 +110,7 @@ def get(cls, tag_id_or_name, vocab_id_or_name=None):
 
         """
         if vocab_id_or_name:
-            vocab = Vocabulary.get(vocab_id_or_name)
+            vocab = vocabulary.get(vocab_id_or_name)
             if vocab is None:
                 # The user specified an invalid vocab.
                 return None
@@ -133,7 +132,7 @@ def search_by_name(cls, search_term, vocab_id_or_name=None):
 
         """
         if vocab_id_or_name:
-            vocab = Vocabulary.get(vocab_id_or_name)
+            vocab = vocabulary.get(vocab_id_or_name)
             if vocab is None:
                 # The user specified an invalid vocab.
                 return None
@@ -155,7 +154,7 @@ def all(cls, vocab_id_or_name=None):
 
         """
         if vocab_id_or_name:
-            vocab = Vocabulary.get(vocab_id_or_name)
+            vocab = vocabulary.get(vocab_id_or_name)
             if vocab is None:
                 # The user specified an invalid vocab.
                 return None
@@ -215,7 +214,7 @@ def by_name(self, package_name, tag_name, vocab_id_or_name=None,
 
         """
         if vocab_id_or_name:
-            vocab = Vocabulary.get(vocab_id_or_name)
+            vocab = vocabulary.get(vocab_id_or_name)
             if vocab is None:
                 # The user specified an invalid vocab.
                 return None
diff --git a/ckan/model/vocabulary.py b/ckan/model/vocabulary.py
index 2505d39a28a..af1749930f4 100644
--- a/ckan/model/vocabulary.py
+++ b/ckan/model/vocabulary.py
@@ -12,20 +12,19 @@
         unique=True),
     )
 
+def get(id_or_name):
+    """Return a Vocabulary object referenced by its id or name."""
+
+    query = Session.query(Vocabulary).filter(Vocabulary.id==id_or_name)
+    vocab = query.first()
+    if vocab is None:
+        vocab = Vocabulary.by_name(id_or_name)
+    return vocab
+
 class Vocabulary(DomainObject):
 
     def __init__(self, name):
         self.id = make_uuid()
         self.name = name
 
-    @classmethod
-    def get(cls, id_or_name):
-        """Return a Vocabulary object referenced by its id or name."""
-
-        query = Session.query(cls).filter(cls.id==id_or_name)
-        vocab = query.first()
-        if vocab is None:
-            vocab = cls.by_name(id_or_name)
-        return vocab
-
 mapper(Vocabulary, vocabulary_table)

From d5dd1a5fe6abb35e10ec19c5b5e83d77416c82db Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Wed, 1 Feb 2012 19:01:58 +0100
Subject: [PATCH 18/72] [#1705] Fix Package.tags_ordered()

Broken since commit c6a1437
---
 ckan/model/package.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/ckan/model/package.py b/ckan/model/package.py
index 856483165f5..a2849024a5c 100644
--- a/ckan/model/package.py
+++ b/ckan/model/package.py
@@ -178,7 +178,10 @@ def add_tag_by_name(self, tag_name, vocab=None, autoflush=True):
             return
         tag = Tag.by_name(tag_name, vocab=vocab, autoflush=autoflush)
         if not tag:
-            tag = Tag(name=tag_name, vocabulary=vocab)
+            if vocab:
+                tag = Tag(name=tag_name, vocabulary_id=vocab.id)
+            else:
+                tag = Tag(name=tag_name)
         if not tag in self.tags:
             self.tags.append(tag)
 

From 17b3d10a3c4abe5a0ea68ba0f7aff596065a8527 Mon Sep 17 00:00:00 2001
From: kindly <kindly@gmail.com>
Date: Thu, 2 Feb 2012 11:10:06 +0000
Subject: [PATCH 19/72] [#1741] fix license in template and dictization

---
 ckan/lib/dictization/model_dictize.py |  9 +++++++++
 ckan/logic/action/get.py              | 22 ----------------------
 ckan/templates/package/read.html      | 11 +++++------
 ckan/tests/lib/test_dictization.py    |  4 ++++
 4 files changed, 18 insertions(+), 28 deletions(-)

diff --git a/ckan/lib/dictization/model_dictize.py b/ckan/lib/dictization/model_dictize.py
index 7a9a71c79c0..422c2111a86 100644
--- a/ckan/lib/dictization/model_dictize.py
+++ b/ckan/lib/dictization/model_dictize.py
@@ -194,6 +194,15 @@ def package_dictize(pkg, context):
     # type
     result_dict['type']= pkg.type
 
+    # licence
+    if pkg.license and pkg.license.url:
+        result_dict['license_url']= pkg.license.url
+        result_dict['license_title']= pkg.license.title.split('::')[-1]
+    elif pkg.license:
+        result_dict['license_title']= pkg.license.title
+    else:
+        result_dict['license_title']= pkg.license_id
+
     # creation and modification date
     result_dict['metadata_modified'] = pkg.metadata_modified.isoformat() \
         if pkg.metadata_modified else None
diff --git a/ckan/logic/action/get.py b/ckan/logic/action/get.py
index ab2d4e2a48c..7036ca0de4f 100644
--- a/ckan/logic/action/get.py
+++ b/ckan/logic/action/get.py
@@ -713,28 +713,6 @@ def package_search(context, data_dict):
 
     return search_results
 
-def _extend_package_dict(package_dict,context):
-    model = context['model']
-
-    resources = model.Session.query(model.Resource)\
-                .join(model.ResourceGroup)\
-                .filter(model.ResourceGroup.package_id == package_dict['id'])\
-                .all()
-    if resources:
-        package_dict['resources'] = resource_list_dictize(resources, context)
-    else:
-        package_dict['resources'] = []
-    license_id = package_dict.get('license_id')
-    if license_id:
-        try:
-            isopen = model.Package.get_license_register()[license_id].isopen()
-        except KeyError:
-            isopen = False
-        package_dict['isopen'] = isopen
-    else:
-        package_dict['isopen'] = False
-
-    return package_dict
 
 def resource_search(context, data_dict):
     model = context['model']
diff --git a/ckan/templates/package/read.html b/ckan/templates/package/read.html
index c5dad62261e..3403c7cb342 100644
--- a/ckan/templates/package/read.html
+++ b/ckan/templates/package/read.html
@@ -23,18 +23,17 @@
     <li py:if="c.pkg.license_id" id="dataset-license" class="sidebar-section">
       <strong>License:</strong>
         <py:choose test="">
-          <span py:when="c.pkg.license and c.pkg.license.url"><a
-              href="${c.pkg.license.url}" rel="dc:rights">${c.pkg.license.title.split('::')[-1]}</a></span>
-          <span py:when="c.pkg.license" property="dc:rights">${c.pkg.license.title}</span>
-          <span py:when="c.pkg.license_id" property="dc:rights">${c.pkg.license_id}</span>
+          <span py:when="c.pkg_dict.get('license_url')"><a
+              href="${c.pkg_dict.get('license_url')}" rel="dc:rights">${c.pkg_dict.get('license_title')}</a></span>
+          <span py:when="c.pkg.license" property="dc:rights">${c.pkg_dict.get('license_title')}</span>
         </py:choose>
 
-        <py:if test="c.pkg.isopen()">
+        <py:if test="c.pkg_dict.get('isopen')">
             <a href="http://opendefinition.org/okd/" title="This dataset satisfies the Open Definition.">
               <img class="open-data" src="http://assets.okfn.org/images/ok_buttons/od_80x15_blue.png" alt="[Open Data]" />
             </a>
         </py:if>
-        <py:if test="not c.pkg.isopen()">
+        <py:if test="not c.pkg_dict.get('isopen')">
             <span class="closed">
               ${h.icon('lock')}
             </span>
diff --git a/ckan/tests/lib/test_dictization.py b/ckan/tests/lib/test_dictization.py
index 3d13ce07244..00c401a76e6 100644
--- a/ckan/tests/lib/test_dictization.py
+++ b/ckan/tests/lib/test_dictization.py
@@ -47,6 +47,7 @@ def setup_class(cls):
                         'title': u"Roger's books"}],
             'isopen': True,
             'license_id': u'other-open',
+            'license_title': u'OKD Compliant::Other (Open)',
             'maintainer': None,
             'maintainer_email': None,
             'type': None,
@@ -227,6 +228,7 @@ def test_03_package_to_api1(self):
         pprint(pkg.as_dict())
         asdict = pkg.as_dict()
         asdict['download_url'] = asdict['resources'][0]['url']
+        asdict['license_title'] = u'OKD Compliant::Other (Open)'
 
         assert package_to_api1(pkg, context) == asdict
 
@@ -241,6 +243,7 @@ def test_04_package_to_api1_with_relationship(self):
         pkg = model.Session.query(model.Package).filter_by(name='homer').one()
 
         as_dict = pkg.as_dict()
+        as_dict['license_title'] = None
         dictize = package_to_api1(pkg, context)
 
         as_dict["relationships"].sort(key=lambda x:x.items())
@@ -278,6 +281,7 @@ def test_06_package_to_api2_with_relationship(self):
         pkg = model.Session.query(model.Package).filter_by(name='homer').one()
 
         as_dict = pkg.as_dict(ref_package_by='id', ref_group_by='id')
+        as_dict['license_title'] = None
         dictize = package_to_api2(pkg, context)
 
         as_dict["relationships"].sort(key=lambda x:x.items())

From 78656f3f20450798b3c377df02ab44634f21142a Mon Sep 17 00:00:00 2001
From: kindly <kindly@gmail.com>
Date: Thu, 2 Feb 2012 14:09:50 +0000
Subject: [PATCH 20/72] [#1741] make sure template uses group dicts instead of
 objects in templates

---
 ckan/templates/package/read.html | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/ckan/templates/package/read.html b/ckan/templates/package/read.html
index 3403c7cb342..b7b08153cad 100644
--- a/ckan/templates/package/read.html
+++ b/ckan/templates/package/read.html
@@ -45,11 +45,11 @@ <h3>Tags</h3>
       ${tag_list(c.pkg_dict.get('tags', ''))}
     </li>
 
-    <li py:if="c.pkg.get_groups()" class="sidebar-section">
+    <li py:if="c.pkg_dict.groups" class="sidebar-section">
       <h3>Groups</h3>
       <ul class="groups">
-        <li py:for="group in sorted(c.pkg.get_groups(), key=lambda g: g.display_name)">
-            <a href="${h.url_for(controller='group', action='read', id=group.name)}">${group.display_name}</a>
+        <li py:for="group in sorted(c.pkg_dict.groups, key=lambda g: g['title'] or g['name'])">
+        <a href="${h.url_for(controller='group', action='read', id=group['name'])}">${group.get('title') or group.get('name')}</a>
         </li>
       </ul>
     </li>

From 5903a01eb28374f084854b30af5442e315a65900 Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Mon, 6 Feb 2012 10:32:27 +0000
Subject: [PATCH 21/72] [1698][logic/converters] Update as location of
 vocabulary get function has changed

---
 ckan/logic/converters.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/ckan/logic/converters.py b/ckan/logic/converters.py
index 853778b7699..80fb6379bbd 100644
--- a/ckan/logic/converters.py
+++ b/ckan/logic/converters.py
@@ -1,5 +1,6 @@
 from pylons.i18n import _
 from ckan import model
+from ckan.model import vocabulary
 from ckan.lib.navl.dictization_functions import Invalid
 from ckan.lib.field_types import DateType, DateConvertError
 from ckan.logic.validators import tag_length_validator, tag_name_validator
@@ -47,7 +48,7 @@ def callable(key, data, errors, context):
         for tag in new_tags:
             tag_length_validator(tag, context)
             tag_name_validator(tag, context)
-        v = model.Vocabulary.get(vocab)
+        v = vocabulary.get(vocab)
         if not v:
             raise Invalid(_('Tag vocabulary "%s" does not exist') % vocab)
 
@@ -59,7 +60,7 @@ def callable(key, data, errors, context):
 
 def convert_from_tags(vocab):
     def callable(key, data, errors, context):
-        v = model.Vocabulary.get(vocab)
+        v = vocabulary.get(vocab)
         if not v:
             raise Invalid(_('Tag vocabulary "%s" does not exist') % vocab)
 

From 0ad2fc3515f9afeb92339094cbbd3335b3f351af Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Mon, 6 Feb 2012 16:51:35 +0100
Subject: [PATCH 22/72] Revert 7ea9e639

Make Vocabulary.get() a @classmethod again, not a module function, just
to be consistent with the other model classes.
---
 ckan/lib/dictization/model_save.py |  2 +-
 ckan/logic/action/delete.py        |  2 +-
 ckan/logic/action/get.py           |  4 ++--
 ckan/logic/action/update.py        |  2 +-
 ckan/model/tag.py                  |  8 ++++----
 ckan/model/vocabulary.py           | 21 ++++++++++++---------
 6 files changed, 21 insertions(+), 18 deletions(-)

diff --git a/ckan/lib/dictization/model_save.py b/ckan/lib/dictization/model_save.py
index 93a1a5460fa..01d7a688120 100644
--- a/ckan/lib/dictization/model_save.py
+++ b/ckan/lib/dictization/model_save.py
@@ -456,7 +456,7 @@ def vocabulary_dict_update(vocabulary_dict, context):
     model = context['model']
     session = context['session']
 
-    vocabulary_obj = model.vocabulary.get(vocabulary_dict['id'])
+    vocabulary_obj = model.vocabulary.Vocabulary.get(vocabulary_dict['id'])
     vocabulary_obj.name = vocabulary_dict['name']
 
     return vocabulary_obj
diff --git a/ckan/logic/action/delete.py b/ckan/logic/action/delete.py
index 219e756ec79..2542c44b579 100644
--- a/ckan/logic/action/delete.py
+++ b/ckan/logic/action/delete.py
@@ -108,7 +108,7 @@ def vocabulary_delete(context, data_dict):
     user = context['user']
     vocab_id = data_dict['id']
 
-    vocab_obj = model.vocabulary.get(vocab_id)
+    vocab_obj = model.vocabulary.Vocabulary.get(vocab_id)
     if vocab_obj is None:
         raise NotFound
 
diff --git a/ckan/logic/action/get.py b/ckan/logic/action/get.py
index 8e1d6203f32..df34ae6178d 100644
--- a/ckan/logic/action/get.py
+++ b/ckan/logic/action/get.py
@@ -885,11 +885,11 @@ def vocabulary_show(context, data_dict):
     model = context['model']
 
     if data_dict.has_key('id'):
-        vocabulary = model.vocabulary.get(data_dict['id'])
+        vocabulary = model.vocabulary.Vocabulary.get(data_dict['id'])
         if vocabulary is None:
             raise NotFound
     elif data_dict.has_key('name'):
-        vocabulary = model.vocabulary.get(data_dict['name'])
+        vocabulary = model.vocabulary.Vocabulary.get(data_dict['name'])
         if vocabulary is None:
             raise NotFound
     else:
diff --git a/ckan/logic/action/update.py b/ckan/logic/action/update.py
index b274640ef29..a13bd8615d8 100644
--- a/ckan/logic/action/update.py
+++ b/ckan/logic/action/update.py
@@ -500,7 +500,7 @@ def vocabulary_update(context, data_dict):
     model.Session.remove()
     model.Session()._context = context
 
-    vocab = model.vocabulary.get(vocab_id)
+    vocab = model.vocabulary.Vocabulary.get(vocab_id)
     if vocab is None:
         raise NotFound(_('Vocabulary was not found.'))
 
diff --git a/ckan/model/tag.py b/ckan/model/tag.py
index 2894015d55d..ecd1a2ab9f9 100644
--- a/ckan/model/tag.py
+++ b/ckan/model/tag.py
@@ -110,7 +110,7 @@ def get(cls, tag_id_or_name, vocab_id_or_name=None):
 
         """
         if vocab_id_or_name:
-            vocab = vocabulary.get(vocab_id_or_name)
+            vocab = vocabulary.Vocabulary.get(vocab_id_or_name)
             if vocab is None:
                 # The user specified an invalid vocab.
                 return None
@@ -132,7 +132,7 @@ def search_by_name(cls, search_term, vocab_id_or_name=None):
 
         """
         if vocab_id_or_name:
-            vocab = vocabulary.get(vocab_id_or_name)
+            vocab = vocabulary.Vocabulary.get(vocab_id_or_name)
             if vocab is None:
                 # The user specified an invalid vocab.
                 return None
@@ -154,7 +154,7 @@ def all(cls, vocab_id_or_name=None):
 
         """
         if vocab_id_or_name:
-            vocab = vocabulary.get(vocab_id_or_name)
+            vocab = vocabulary.Vocabulary.get(vocab_id_or_name)
             if vocab is None:
                 # The user specified an invalid vocab.
                 return None
@@ -214,7 +214,7 @@ def by_name(self, package_name, tag_name, vocab_id_or_name=None,
 
         """
         if vocab_id_or_name:
-            vocab = vocabulary.get(vocab_id_or_name)
+            vocab = vocabulary.Vocabulary.get(vocab_id_or_name)
             if vocab is None:
                 # The user specified an invalid vocab.
                 return None
diff --git a/ckan/model/vocabulary.py b/ckan/model/vocabulary.py
index af1749930f4..c4d2dec401a 100644
--- a/ckan/model/vocabulary.py
+++ b/ckan/model/vocabulary.py
@@ -12,19 +12,22 @@
         unique=True),
     )
 
-def get(id_or_name):
-    """Return a Vocabulary object referenced by its id or name."""
-
-    query = Session.query(Vocabulary).filter(Vocabulary.id==id_or_name)
-    vocab = query.first()
-    if vocab is None:
-        vocab = Vocabulary.by_name(id_or_name)
-    return vocab
-
 class Vocabulary(DomainObject):
 
     def __init__(self, name):
         self.id = make_uuid()
         self.name = name
 
+    @classmethod
+    def get(cls, id_or_name):
+        """Return a Vocabulary object referenced by its id or name, or None if
+        there is no vocabulary with the given id or name.
+        
+        """
+        query = Session.query(Vocabulary).filter(Vocabulary.id==id_or_name)
+        vocab = query.first()
+        if vocab is None:
+            vocab = Vocabulary.by_name(id_or_name)
+        return vocab
+
 mapper(Vocabulary, vocabulary_table)

From 431a3b9ab4053791c45929f2a2bcf921aafed6a1 Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Tue, 7 Feb 2012 13:19:27 +0000
Subject: [PATCH 23/72] [1720][logic/converters] Update for change in location
 of Vocabulary get function

---
 ckan/logic/converters.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/ckan/logic/converters.py b/ckan/logic/converters.py
index 80fb6379bbd..112179b4752 100644
--- a/ckan/logic/converters.py
+++ b/ckan/logic/converters.py
@@ -44,23 +44,21 @@ def callable(key, data, errors, context):
             if k[0] == 'tags':
                 n = max(n, k[1] + 1)
 
-        # validate
         for tag in new_tags:
             tag_length_validator(tag, context)
             tag_name_validator(tag, context)
-        v = vocabulary.get(vocab)
+        v = model.Vocabulary.get(vocab)
         if not v:
             raise Invalid(_('Tag vocabulary "%s" does not exist') % vocab)
 
         for num, tag in enumerate(new_tags):
             data[('tags', num+n, 'name')] = tag
             data[('tags', num+n, 'vocabulary_id')] = v.id
-
     return callable
 
 def convert_from_tags(vocab):
     def callable(key, data, errors, context):
-        v = vocabulary.get(vocab)
+        v = model.Vocabulary.get(vocab)
         if not v:
             raise Invalid(_('Tag vocabulary "%s" does not exist') % vocab)
 

From 55754884f640a2db921b923b6f694388e8e77943 Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Tue, 7 Feb 2012 13:20:55 +0000
Subject: [PATCH 24/72] [1720][logic, dictization, templates] Don't show tags
 with vocabularies in normal 'tags' list in WUI and API

---
 ckan/lib/dictization/model_dictize.py        |  4 ++--
 ckan/logic/converters.py                     | 15 ++++++++++-----
 ckan/logic/schema.py                         |  5 +++--
 ckan/logic/validators.py                     |  8 ++++++++
 ckan/templates/_util.html                    |  4 +++-
 ckan/templates/package/new_package_form.html |  2 +-
 6 files changed, 27 insertions(+), 11 deletions(-)

diff --git a/ckan/lib/dictization/model_dictize.py b/ckan/lib/dictization/model_dictize.py
index 43826b89092..f044c0187a5 100644
--- a/ckan/lib/dictization/model_dictize.py
+++ b/ckan/lib/dictization/model_dictize.py
@@ -340,7 +340,7 @@ def package_to_api1(pkg, context):
     dictized.pop("revision_timestamp")
 
     dictized["groups"] = [group["name"] for group in dictized["groups"]]
-    dictized["tags"] = [tag["name"] for tag in dictized["tags"]]
+    dictized["tags"] = [tag["name"] for tag in dictized["tags"] if not tag.get('vocabulary_id')]
     dictized["extras"] = dict((extra["key"], json.loads(extra["value"])) 
                               for extra in dictized["extras"])
     dictized['notes_rendered'] = ckan.misc.MarkdownFormat().to_html(pkg.notes)
@@ -397,7 +397,7 @@ def package_to_api2(pkg, context):
     dictized["groups"] = [group["id"] for group in dictized["groups"]]
     dictized.pop("revision_timestamp")
     
-    dictized["tags"] = [tag["name"] for tag in dictized["tags"]]
+    dictized["tags"] = [tag["name"] for tag in dictized["tags"] if not tag.get('vocabulary_id')]
     dictized["extras"] = dict((extra["key"], json.loads(extra["value"])) 
                               for extra in dictized["extras"])
 
diff --git a/ckan/logic/converters.py b/ckan/logic/converters.py
index 112179b4752..829b78a977c 100644
--- a/ckan/logic/converters.py
+++ b/ckan/logic/converters.py
@@ -32,6 +32,16 @@ def date_to_form(value, context):
         raise Invalid(str(e))
     return value
 
+def free_tags_only(key, data, errors, context):
+    tag_number = key[1]
+    to_delete = []
+    if data.get(('tags', tag_number, 'vocabulary_id')):
+        to_delete.append(tag_number)
+    for k in data.keys():
+        for n in to_delete:
+            if k[0] == 'tags' and k[1] == n:
+                del data[k]
+
 def convert_to_tags(vocab):
     def callable(key, data, errors, context):
         tag_string = data.get(key)
@@ -67,11 +77,6 @@ def callable(key, data, errors, context):
             if k[0] == 'tags':
                 if data[k].get('vocabulary_id') == v.id:
                     tags[k] = data[k]
-
-        # TODO: vocab tags should be removed in a separate converter (and by default) 'tags'
-        for k in tags.keys():
-            del data[k]
         data[key] = ', '.join([t['name'] for t in tags.values()])
-
     return callable
 
diff --git a/ckan/logic/schema.py b/ckan/logic/schema.py
index 84ec4d79351..5cfd1021cc8 100644
--- a/ckan/logic/schema.py
+++ b/ckan/logic/schema.py
@@ -32,7 +32,8 @@
                                    int_validator,
                                    user_about_validator,
                                    vocabulary_name_validator,
-                                   vocabulary_id_not_changed)
+                                   vocabulary_id_not_changed,
+                                   vocabulary_id_exists)
 from formencode.validators import OneOf
 import ckan.model
 
@@ -71,13 +72,13 @@ def default_update_resource_schema():
     return schema
 
 def default_tags_schema():
-
     schema = {
         'name': [not_empty,
                  unicode,
                  tag_length_validator,
                  tag_name_validator,
                 ],
+        'vocabulary_id': [ignore_missing, unicode, vocabulary_id_exists],
         'revision_timestamp': [ignore],
         'state': [ignore],
     }
diff --git a/ckan/logic/validators.py b/ckan/logic/validators.py
index c272fc9502c..ea7702398d9 100644
--- a/ckan/logic/validators.py
+++ b/ckan/logic/validators.py
@@ -340,3 +340,11 @@ def vocabulary_id_not_changed(value, context):
         raise Invalid(_('Cannot change value of key from %s to %s. '
                         'This key is read-only') % (vocabulary.id, value))
     return value
+
+def vocabulary_id_exists(value, context):
+    model = context['model']
+    session = context['session']
+    result = session.query(model.Vocabulary).get(value)
+    if not result:
+        raise Invalid(_('Tag vocabulary was not found.'))
+    return value
diff --git a/ckan/templates/_util.html b/ckan/templates/_util.html
index a04268eca70..bfdf9b2c503 100644
--- a/ckan/templates/_util.html
+++ b/ckan/templates/_util.html
@@ -26,9 +26,11 @@
   <!--! List of tags: pass in a collection of tags and this renders the standard
         tag listing -->
   <ul py:def="tag_list(tags)" class="tags clearfix">
-    <li py:for="tag in tags">
+    <py:for each="tag in tags">
+    <li py:if="not tag.get('vocabulary_id')">
       ${h.link_to(tag['name'], h.url_for(controller='tag', action='read', id=tag['name']))}
     </li>
+    </py:for>
   </ul>
 
   <!--! List of tags: pass in a list of tag name and this renders the standard
diff --git a/ckan/templates/package/new_package_form.html b/ckan/templates/package/new_package_form.html
index 718ee1356f3..810081fe017 100644
--- a/ckan/templates/package/new_package_form.html
+++ b/ckan/templates/package/new_package_form.html
@@ -137,7 +137,7 @@ <h3>Tags</h3>
     <dt class="tags-label"><label class="field_opt" for="tags">Tags</label></dt>
     <dd class="tags-field">
       <input class="long autocomplete-tag" id="tag_string" name="tag_string" size="60" type="text" 
-               value="${data.get('tag_string') or ', '.join([tag['name'] for tag in data.get('tags', [])])}" />
+               value="${data.get('tag_string') or ', '.join([tag['name'] for tag in data.get('tags', []) if not tag.get('vocabulary_id')])}" />
     </dd>
     <dd class="tags-instructions instructions basic" i18n:msg="">Comma-separated terms that may link this dataset to similar ones. For more information on conventions, see <a href="http://wiki.okfn.org/ckan/doc/faq#TagConventions">this wiki page</a>.</dd>
     <dd class="tags-instructions hints">e.g. pollution, rivers, water quality</dd>

From 6636957d0ba40fab5f60c154b5344eabe01307d8 Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Tue, 7 Feb 2012 13:49:43 +0000
Subject: [PATCH 25/72] [1720][tests] Rename test_converters to test_tag_vocab

---
 ckan/tests/logic/{test_converters.py => test_tag_vocab.py} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename ckan/tests/logic/{test_converters.py => test_tag_vocab.py} (100%)

diff --git a/ckan/tests/logic/test_converters.py b/ckan/tests/logic/test_tag_vocab.py
similarity index 100%
rename from ckan/tests/logic/test_converters.py
rename to ckan/tests/logic/test_tag_vocab.py

From 7adca281ff0c8164d69ba852f9a400d3cc344b8d Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Tue, 7 Feb 2012 14:28:24 +0000
Subject: [PATCH 26/72] [1720][tests] add tests for convert_from_tags and
 free_tags_only converters

---
 ckan/tests/logic/test_tag_vocab.py | 28 +++++++++++++++++++++++++++-
 1 file changed, 27 insertions(+), 1 deletion(-)

diff --git a/ckan/tests/logic/test_tag_vocab.py b/ckan/tests/logic/test_tag_vocab.py
index f45bd1e95f2..c35548c0ae5 100644
--- a/ckan/tests/logic/test_tag_vocab.py
+++ b/ckan/tests/logic/test_tag_vocab.py
@@ -1,5 +1,5 @@
 from ckan import model
-from ckan.logic.converters import convert_to_tags
+from ckan.logic.converters import convert_to_tags, convert_from_tags, free_tags_only
 from ckan.lib.navl.dictization_functions import unflatten
 
 class TestConverters:
@@ -26,3 +26,29 @@ def convert(tag_string, vocab):
             assert tag['name'] in ['tag1', 'tag2'], tag['name']
             assert tag['vocabulary_id'] == self.vocab.id, tag['vocabulary_id']
 
+    def test_convert_from_tags(self):
+        key = 'tags'
+        data = {
+            ('tags', 0, '__extras'): {'name': 'tag1', 'vocabulary_id': self.vocab.id},
+            ('tags', 1, '__extras'): {'name': 'tag2', 'vocabulary_id': self.vocab.id}
+        }
+        errors = []
+        context = {'model': model, 'session': model.Session}
+        convert_from_tags(self.vocab.name)(key, data, errors, context)
+        assert 'tag1' in data['tags']
+        assert 'tag2' in data['tags']
+
+    def test_free_tags_only(self):
+        key = ('tags', 0, '__extras')
+        data = {
+            ('tags', 0, '__extras'): {'name': 'tag1', 'vocabulary_id': self.vocab.id},
+            ('tags', 0, 'vocabulary_id'): self.vocab.id,
+            ('tags', 1, '__extras'): {'name': 'tag2', 'vocabulary_id': None},
+            ('tags', 1, 'vocabulary_id'): None
+        }
+        errors = []
+        context = {'model': model, 'session': model.Session}
+        free_tags_only(key, data, errors, context)
+        assert len(data) == 2
+        assert ('tags', 1, 'vocabulary_id') in data.keys()
+        assert ('tags', 1, '__extras') in data.keys()

From 335535b646adf983d1d19bf19613712099db1f5e Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Tue, 7 Feb 2012 17:03:35 +0000
Subject: [PATCH 27/72] [1724][logic, tests] update tag_list to filter by
 vocabulary

---
 ckan/logic/action/get.py           |  9 ++++++++
 ckan/tests/logic/test_tag_vocab.py | 33 +++++++++++++++++++++++++++++-
 2 files changed, 41 insertions(+), 1 deletion(-)

diff --git a/ckan/logic/action/get.py b/ckan/logic/action/get.py
index df34ae6178d..49d606a235c 100644
--- a/ckan/logic/action/get.py
+++ b/ckan/logic/action/get.py
@@ -216,6 +216,15 @@ def tag_list(context, data_dict):
     else:
         tags = model.Session.query(model.Tag).all()
 
+    # filter by vocabulary
+    if data_dict.get('vocabulary_name'):
+        vocab = model.Vocabulary.get(data_dict['vocabulary_name'])
+        if not vocab:
+            raise NotFound
+        tags = [tag for tag in tags if tag.vocabulary_id == vocab.id]
+    else:
+        tags = [tag for tag in tags if not tag.vocabulary_id]
+
     tag_list = []
     if all_fields:
         for tag in tags:
diff --git a/ckan/tests/logic/test_tag_vocab.py b/ckan/tests/logic/test_tag_vocab.py
index c35548c0ae5..d042d23e2e6 100644
--- a/ckan/tests/logic/test_tag_vocab.py
+++ b/ckan/tests/logic/test_tag_vocab.py
@@ -1,8 +1,12 @@
+import json
 from ckan import model
 from ckan.logic.converters import convert_to_tags, convert_from_tags, free_tags_only
 from ckan.lib.navl.dictization_functions import unflatten
+from ckan.lib.create_test_data import CreateTestData
+from ckan.tests import WsgiAppCase
+from ckan.tests.functional.api import assert_dicts_equal_ignoring_ordering
 
-class TestConverters:
+class TestConverters(object):
     @classmethod
     def setup_class(cls):
         # create a new vocabulary
@@ -52,3 +56,30 @@ def test_free_tags_only(self):
         assert len(data) == 2
         assert ('tags', 1, 'vocabulary_id') in data.keys()
         assert ('tags', 1, '__extras') in data.keys()
+
+class TestAPI(WsgiAppCase):
+    @classmethod
+    def setup_class(cls):
+        CreateTestData.create()
+        cls.vocab = model.Vocabulary('test-vocab') 
+        model.Session.add(cls.vocab)
+        cls.vocab_tag = model.Tag('vocab-tag', cls.vocab.id)
+        model.Session.add(cls.vocab_tag)
+        model.Session.commit()
+        model.Session.remove()
+
+    def test_tag_list(self):
+        postparams = '%s=1' % json.dumps({'vocabulary_name': self.vocab.name})
+        res = self.app.post('/api/action/tag_list', params=postparams)
+        body = json.loads(res.body)
+        assert_dicts_equal_ignoring_ordering(
+            json.loads(res.body),
+            {'help': 'Returns a list of tags',
+             'success': True,
+             'result': [self.vocab_tag.name]}
+        )
+
+    def test_tag_list_invalid_vocab_name_404(self):
+        postparams = '%s=1' % json.dumps({'vocabulary_name': 'invalid-vocab-name'})
+        res = self.app.post('/api/action/tag_list', params=postparams, status=404)
+

From 2044924b6d1f0b0b53c396a2343795e32c7f3d1d Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Wed, 8 Feb 2012 11:48:55 +0000
Subject: [PATCH 28/72] [1730][validators, converters] Update convert_to_tags
 to take input from a html select instead of a tag string.

Add additional validator to check that a tag belongs
to a given vocab.
---
 ckan/logic/converters.py | 19 ++++++++++++-------
 ckan/logic/validators.py | 16 +++++++++++++++-
 2 files changed, 27 insertions(+), 8 deletions(-)

diff --git a/ckan/logic/converters.py b/ckan/logic/converters.py
index 829b78a977c..8801387da2a 100644
--- a/ckan/logic/converters.py
+++ b/ckan/logic/converters.py
@@ -1,9 +1,9 @@
 from pylons.i18n import _
 from ckan import model
-from ckan.model import vocabulary
 from ckan.lib.navl.dictization_functions import Invalid
 from ckan.lib.field_types import DateType, DateConvertError
-from ckan.logic.validators import tag_length_validator, tag_name_validator
+from ckan.logic.validators import tag_length_validator, tag_name_validator, \
+    tag_in_vocabulary_validator
 
 def convert_to_extras(key, data, errors, context):
     extras = data.get(('extras',), [])
@@ -44,22 +44,27 @@ def free_tags_only(key, data, errors, context):
 
 def convert_to_tags(vocab):
     def callable(key, data, errors, context):
-        tag_string = data.get(key)
-        new_tags = [tag.strip() for tag in tag_string.split(',') if tag.strip()]
+        new_tags = data.get(key)
         if not new_tags:
             return
+        if isinstance(new_tags, basestring):
+            new_tags = [new_tags]
+
         # get current number of tags
         n = 0
         for k in data.keys():
             if k[0] == 'tags':
                 n = max(n, k[1] + 1)
 
-        for tag in new_tags:
-            tag_length_validator(tag, context)
-            tag_name_validator(tag, context)
         v = model.Vocabulary.get(vocab)
         if not v:
             raise Invalid(_('Tag vocabulary "%s" does not exist') % vocab)
+        context['vocabulary'] = v
+
+        for tag in new_tags:
+            tag_length_validator(tag, context)
+            tag_name_validator(tag, context)
+            tag_in_vocabulary_validator(tag, context)
 
         for num, tag in enumerate(new_tags):
             data[('tags', num+n, 'name')] = tag
diff --git a/ckan/logic/validators.py b/ckan/logic/validators.py
index ea7702398d9..faab53c0d41 100644
--- a/ckan/logic/validators.py
+++ b/ckan/logic/validators.py
@@ -1,6 +1,6 @@
 import re
 import datetime
-from pylons.i18n import _, ungettext, N_, gettext
+from pylons.i18n import _
 from ckan.lib.navl.dictization_functions import Invalid, Missing, missing, unflatten
 from ckan.authz import Authorizer
 from ckan.logic import check_access, NotAuthorized
@@ -348,3 +348,17 @@ def vocabulary_id_exists(value, context):
     if not result:
         raise Invalid(_('Tag vocabulary was not found.'))
     return value
+
+def tag_in_vocabulary_validator(value, context):
+    model = context['model']
+    session = context['session']
+    vocabulary = context.get('vocabulary')
+    if vocabulary:
+        query = session.query(model.Tag)\
+            .filter(model.Tag.vocabulary_id==vocabulary.id)\
+            .filter(model.Tag.name==value)\
+            .count()
+        if not query:
+            raise Invalid(_('Tag %s does not belong to vocabulary %s') % (value, vocabulary.name))
+    return value
+

From 496452cb43590f7b9be6a4fb6135a5d226dc4391 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Wed, 8 Feb 2012 13:02:14 +0100
Subject: [PATCH 29/72] [#1765] Replace the `tags` property of Package

Remove the `tags` property from Package and the `packages` property from
Tag. These were implemented with lines like:

`vdm.sqlalchemy.add_stateful_versioned_m2m()`

at the bottom of tag.py.

Remove the `tags_ordered` property from Package.

Add methods add_tag(), add_tags(), get_tags() and remove_tag() to
Package. get_tags() has an optional `vocab` argument.

Rename Tag.packages_ordered @property to Tag.packages.

Add 'vocabulary' property to Tag (SQLAlchemy backref).

Replace calls to my_package_obj.tags with my_package_obj.get_tags().

Replace calls to my_package_obj.tags.append(tag) with
my_package_obj.add_tag(tag).

Replace assignments like my_package_obj.tags = [...] with calls to
remove_tag(), add_tag(), add_tags().
---
 ckan/forms/common.py                          |  6 +-
 ckan/forms/package_dict.py                    |  2 +-
 ckan/lib/create_test_data.py                  |  6 +-
 ckan/lib/dictization/model_dictize.py         |  2 +-
 ckan/model/package.py                         | 58 +++++++++++++++----
 ckan/model/tag.py                             | 20 +++----
 ckan/tests/forms/test_package.py              |  8 +--
 .../functional/api/model/test_package.py      |  6 +-
 ckan/tests/functional/test_package.py         | 10 ++--
 ckan/tests/lib/test_dictization.py            |  5 +-
 ckan/tests/models/test_package.py             | 30 +++++-----
 ckan/tests/models/test_purge_revision.py      |  9 +--
 12 files changed, 93 insertions(+), 69 deletions(-)

diff --git a/ckan/forms/common.py b/ckan/forms/common.py
index 7bd0db97e63..e106984f5b6 100644
--- a/ckan/forms/common.py
+++ b/ckan/forms/common.py
@@ -452,16 +452,12 @@ def get_configured(self):
     class TagField(formalchemy.Field):
         @property
         def raw_value(self):
-            tag_objects = self.model.tags
+            tag_objects = self.model.get_tags()
             tag_names = [tag.name for tag in tag_objects]
             return tag_names
         
         def sync(self):
             if not self.is_readonly():
-                # Note: You might think that you could just assign
-                # self.model.tags with tag objects, but the model 
-                # (add_stateful_versioned_m2m) doesn't support this -
-                # you must edit each PackageTag individually.
                 self._update_tags()
 
         def _update_tags(self):
diff --git a/ckan/forms/package_dict.py b/ckan/forms/package_dict.py
index 347ebcbab69..e830cd928f8 100644
--- a/ckan/forms/package_dict.py
+++ b/ckan/forms/package_dict.py
@@ -47,7 +47,7 @@ def get_package_dict(pkg=None, blank=False, fs=None, user_editable_groups=None):
                 if field.renderer.name.endswith('-extras'):
                     indict[field.renderer.name] = dict(pkg.extras) if pkg else {}
                 if field.renderer.name.endswith('-tags'):
-                    indict[field.renderer.name] = ','.join([tag.name for tag in pkg.tags]) if pkg else ''
+                    indict[field.renderer.name] = ','.join([tag.name for tag in pkg.get_tags()]) if pkg else ''
                 if field.renderer.name.endswith('-resources'):
                     indict[field.renderer.name] = [dict([(key, getattr(res, key)) for key in model.Resource.get_columns()]) for res in pkg.resources] if pkg else []
         
diff --git a/ckan/lib/create_test_data.py b/ckan/lib/create_test_data.py
index 1a45b9ad86c..2fe86c307c3 100644
--- a/ckan/lib/create_test_data.py
+++ b/ckan/lib/create_test_data.py
@@ -161,7 +161,7 @@ def create_arbitrary(cls, package_dicts, relationships=[],
                                 tag = model.Tag(name=tag_name)
                                 cls.tag_names.append(tag_name)
                                 model.Session.add(tag)    
-                            pkg.tags.append(tag)
+                            pkg.add_tag(tag)
                             model.Session.flush()
                     elif attr == 'groups':
                         model.Session.flush()
@@ -379,8 +379,8 @@ def create(cls):
 
         for obj in [pkg2, tag1, tag2, tag3]:
             model.Session.add(obj)
-        pkg1.tags = [tag1, tag2, tag3]
-        pkg2.tags = [ tag1, tag3 ]
+        pkg1.add_tags([tag1, tag2, tag3])
+        pkg2.add_tags([ tag1, tag3 ])
         cls.tag_names = [ t.name for t in (tag1, tag2, tag3) ]
         pkg1.license_id = u'other-open'
         pkg2.license_id = u'cc-nc' # closed license
diff --git a/ckan/lib/dictization/model_dictize.py b/ckan/lib/dictization/model_dictize.py
index 43826b89092..ea5a4bcaf7d 100644
--- a/ckan/lib/dictization/model_dictize.py
+++ b/ckan/lib/dictization/model_dictize.py
@@ -262,7 +262,7 @@ def tag_dictize(tag, context):
     result_dict = table_dictize(tag, context)
 
     result_dict["packages"] = obj_list_dictize(
-        tag.packages_ordered, context)
+        tag.packages, context)
     
     return result_dict 
 
diff --git a/ckan/model/package.py b/ckan/model/package.py
index a2849024a5c..d65a3c6c091 100644
--- a/ckan/model/package.py
+++ b/ckan/model/package.py
@@ -3,7 +3,7 @@
 from calendar import timegm
 from operator import attrgetter
 
-from sqlalchemy.sql import select, and_, union, expression, or_
+from sqlalchemy.sql import select, and_, union, expression, or_, desc
 from sqlalchemy.orm import eagerload_all
 from sqlalchemy import types, Column, Table
 from pylons import config
@@ -48,11 +48,10 @@
 ## -------------------
 ## Mapped classes
 
-
 class Package(vdm.sqlalchemy.RevisionedObjectMixin,
         vdm.sqlalchemy.StatefulObjectMixin,
         DomainObject):
-    
+
     text_search_fields = ['name', 'title']
 
     def __init__(self, **kw):
@@ -160,6 +159,19 @@ def add_resource(self, url, format=u'', description=u'', hash=u'', **kw):
             hash=hash,
             **kw))
 
+    def add_tag(self, tag):
+        import ckan.model as model
+        if tag in self.get_tags(tag.vocabulary):
+            return
+        else:
+            package_tag = model.PackageTag(self, tag)
+            model.Session.add(package_tag)
+            model.Session.commit()
+
+    def add_tags(self, tags):
+        for tag in tags:
+            self.add_tag(tag)
+
     def add_tag_by_name(self, tag_name, vocab=None, autoflush=True):
         """Add a tag with the given name to this package's tags.
 
@@ -176,25 +188,47 @@ def add_tag_by_name(self, tag_name, vocab=None, autoflush=True):
         from tag import Tag
         if not tag_name:
             return
+        # Get the named tag.
         tag = Tag.by_name(tag_name, vocab=vocab, autoflush=autoflush)
         if not tag:
+            # Tag doesn't exist yet, make a new one.
             if vocab:
                 tag = Tag(name=tag_name, vocabulary_id=vocab.id)
             else:
                 tag = Tag(name=tag_name)
-        if not tag in self.tags:
-            self.tags.append(tag)
+        assert tag is not None
+        self.add_tag(tag)
 
-    @property
-    def tags_ordered(self):
+    def get_tags(self, vocab=None):
         """Return a sorted list of this package's tags
 
-        Tags are sorted by the names of the vocabularies that they belong to
-        and then (within vocabularies) by their tag names
+        Tags are sorted by their names.
 
         """
-        sorted_tags = sorted(self.tags, key=attrgetter('name'))
-        return sorted_tags
+        import ckan.model as model
+        query = model.Session.query(model.Tag)
+        query = query.join(model.PackageTagRevision)
+        query = query.filter(model.PackageTagRevision.tag_id == model.Tag.id)
+        query = query.filter(model.PackageTagRevision.package_id == self.id)
+        query = query.filter(and_(
+            model.PackageTagRevision.state == 'active',
+            model.PackageTagRevision.current == True))
+        if vocab:
+            query = query.filter(model.Tag.vocabulary_id == vocab.id)
+        else:
+            query = query.filter(model.Tag.vocabulary_id == None)
+        query = query.order_by(model.Tag.name)
+        tags = query.all()
+        return tags
+
+    def remove_tag(self, tag):
+        import ckan.model as model
+        query = model.Session.query(model.PackageTag)
+        query = query.filter(model.PackageTag.package_id == self.id)
+        query = query.filter(model.PackageTag.tag_id == tag.id)
+        package_tag = query.one()
+        package_tag.delete()
+        model.Session.commit()
 
     def isopen(self):
         if self.license and self.license.isopen():
@@ -216,7 +250,7 @@ def as_dict(self, ref_package_by='name', ref_group_by='name'):
         # Todo: Remove from Version 2?
         _dict['license'] = self.license.title if self.license else _dict.get('license_id', '')
         _dict['isopen'] = self.isopen()
-        tags = [tag.name for tag in self.tags]
+        tags = [tag.name for tag in self.get_tags()]
         tags.sort() # so it is determinable
         _dict['tags'] = tags
         groups = [getattr(group, ref_group_by) for group in self.get_groups()]
diff --git a/ckan/model/tag.py b/ckan/model/tag.py
index ecd1a2ab9f9..addcf43019c 100644
--- a/ckan/model/tag.py
+++ b/ckan/model/tag.py
@@ -168,7 +168,7 @@ def all(cls, vocab_id_or_name=None):
         return query
 
     @property
-    def packages_ordered(self):
+    def packages(self):
         """Return a list of all packages currently tagged with this tag.
 
         The list is sorted by package name.
@@ -180,14 +180,13 @@ def packages_ordered(self):
         q = q.filter(sqlalchemy.and_(
             PackageTagRevision.state == 'active',
             PackageTagRevision.current == True))
-        packages = [p for p in q]
-        ourcmp = lambda pkg1, pkg2: cmp(pkg1.name, pkg2.name)
-        return sorted(packages, cmp=ourcmp)
+        q = q.order_by(Package.name)
+        packages = q.all()
+        return packages
 
     def __repr__(self):
         return '<Tag %s>' % self.name
 
-
 class PackageTag(vdm.sqlalchemy.RevisionedObjectMixin,
         vdm.sqlalchemy.StatefulObjectMixin,
         DomainObject):
@@ -233,9 +232,11 @@ def related_packages(self):
         return [self.package]
 
 mapper(Tag, tag_table, properties={
-    'package_tags':relation(PackageTag, backref='tag',
+    'package_tags': relation(PackageTag, backref='tag',
         cascade='all, delete, delete-orphan',
         ),
+    'vocabulary': relation(vocabulary.Vocabulary, backref='tags',
+        order_by=tag_table.c.name)
     },
     order_by=tag_table.c.name,
     )
@@ -258,10 +259,3 @@ def related_packages(self):
         package_tag_revision_table)
 
 PackageTagRevision.related_packages = lambda self: [self.continuity.package]
-
-from vdm.sqlalchemy.base import add_stateful_versioned_m2m 
-vdm.sqlalchemy.add_stateful_versioned_m2m(Package, PackageTag, 'tags', 'tag',
-        'package_tags')
-vdm.sqlalchemy.add_stateful_versioned_m2m_on_version(PackageRevision, 'tags')
-vdm.sqlalchemy.add_stateful_versioned_m2m(Tag, PackageTag, 'packages', 'package',
-        'package_tags')
diff --git a/ckan/tests/forms/test_package.py b/ckan/tests/forms/test_package.py
index 057c0d2d8e4..3480b465811 100644
--- a/ckan/tests/forms/test_package.py
+++ b/ckan/tests/forms/test_package.py
@@ -153,7 +153,7 @@ def test_3_sync_new(self):
         assert outpkg.notes == indict['Package--notes']
 
         # test tags
-        taglist = [ tag.name for tag in outpkg.tags ]
+        taglist = [ tag.name for tag in outpkg.get_tags() ]
         assert u'russian' in taglist, taglist
         assert u'tolstoy' in taglist, taglist
         assert newtagname in taglist
@@ -205,7 +205,7 @@ def test_4_sync_update(self):
         assert outpkg.notes == indict[prefix+'notes']
 
         # test tags
-        taglist = [ tag.name for tag in outpkg.tags ]
+        taglist = [ tag.name for tag in outpkg.get_tags() ]
         assert u'russian' in taglist, taglist
         assert u'tolstoy' not in taglist, taglist
         assert newtagname in taglist
@@ -382,7 +382,7 @@ def test_2_tag_names_are_stripped_of_leading_and_trailing_spaces(self):
             fs.sync()
             model.repo.commit_and_remove()
             anna = model.Package.by_name(u'annakarenina')
-            taglist = [ tag.name for tag in anna.tags ]
+            taglist = [ tag.name for tag in anna.get_tags() ]
             assert len(taglist) == 1
             assert u'tag name' in taglist
 
@@ -404,7 +404,7 @@ def test_3_tag_names_are_split_by_commas(self):
         fs.sync()
         model.repo.commit_and_remove()
         anna = model.Package.by_name(u'annakarenina')
-        taglist = [ tag.name for tag in anna.tags ]
+        taglist = [ tag.name for tag in anna.get_tags() ]
         assert len(taglist) == 2
         assert u'tag name one' in taglist
         assert u'tag name two' in taglist
diff --git a/ckan/tests/functional/api/model/test_package.py b/ckan/tests/functional/api/model/test_package.py
index 9da65586940..eed3e1a2cf6 100644
--- a/ckan/tests/functional/api/model/test_package.py
+++ b/ckan/tests/functional/api/model/test_package.py
@@ -77,7 +77,7 @@ def test_register_post_ok(self):
         self.assert_equal(package.title, self.package_fixture_data['title'])
         self.assert_equal(package.url, self.package_fixture_data['url'])
         self.assert_equal(package.license_id, self.testpackage_license_id)
-        self.assert_equal(len(package.tags), 2)
+        self.assert_equal(len(package.get_tags()), 2)
         self.assert_equal(len(package.extras), 2)
         for key, value in self.package_fixture_data['extras'].items():
             self.assert_equal(package.extras[key], value)
@@ -451,7 +451,7 @@ def assert_package_update_ok(self, package_ref_attribute,
             # - title
             self.assert_equal(package.title, new_fixture_data['title'])
             # - tags
-            package_tagnames = [tag.name for tag in package.tags]
+            package_tagnames = [tag.name for tag in package.get_tags()]
             for tagname in new_fixture_data['tags']:
                 assert tagname in package_tagnames, 'tag %r not in %r' % (tagname, package_tagnames)
             # - resources
@@ -619,7 +619,7 @@ def test_entity_update_readd_tag(self):
         assert_equal(pkg['tags'], ['tag 1.'])
 
         package = self.get_package_by_name(new_fixture_data['name'])
-        assert len(package.tags) == 1, package.tags
+        assert len(package.get_tags()) == 1, package.get_tags()
 
         # now reinstate the tag
         params = '%s=1' % self.dumps(old_fixture_data)
diff --git a/ckan/tests/functional/test_package.py b/ckan/tests/functional/test_package.py
index cc075f97743..85b8d36468b 100644
--- a/ckan/tests/functional/test_package.py
+++ b/ckan/tests/functional/test_package.py
@@ -698,8 +698,8 @@ def test_edit_2_tags_and_groups(self):
         res = res.follow()
         assert '%s - Datasets' % self.editpkg_name in res
         pkg = model.Package.by_name(self.editpkg.name)
-        assert len(pkg.tags) == len(newtagnames)
-        outtags = [ tag.name for tag in pkg.tags ]
+        assert len(pkg.get_tags()) == len(newtagnames)
+        outtags = [ tag.name for tag in pkg.get_tags() ]
         for tag in newtags:
             assert tag in outtags
         rev = model.Revision.youngest(model.Session)
@@ -752,7 +752,7 @@ def test_edit_all_fields(self):
             pkg.version = u'2.2'
             t1 = model.Tag(name=u'one')
             t2 = model.Tag(name=u'two words')
-            pkg.tags = [t1, t2]
+            pkg.add_tags([t1, t2])
             pkg.state = model.State.DELETED
             pkg.license_id = u'other-open'
             extras = {'key1':'value1', 'key2':'value2', 'key3':'value3'}
@@ -834,7 +834,7 @@ def test_edit_all_fields(self):
             #        assert getattr(pkg.resources[res_index], res_field) == resource[field_index]
             assert pkg.notes == notes
             assert pkg.license.id == license_id
-            saved_tagnames = [str(tag.name) for tag in pkg.tags]
+            saved_tagnames = [str(tag.name) for tag in pkg.get_tags()]
             saved_tagnames.sort()
             expected_tagnames = list(tags)
             expected_tagnames.sort()
@@ -1162,7 +1162,7 @@ def test_new_all_fields(self):
         #assert pkg.resources[0].url == download_url
         assert pkg.notes == notes
         assert pkg.license.id == license_id
-        saved_tagnames = [str(tag.name) for tag in pkg.tags]
+        saved_tagnames = [str(tag.name) for tag in pkg.get_tags()]
         saved_tagnames.sort()
         expected_tagnames = sorted(tags)
         assert saved_tagnames == expected_tagnames, '%r != %r' % (saved_tagnames, expected_tagnames)
diff --git a/ckan/tests/lib/test_dictization.py b/ckan/tests/lib/test_dictization.py
index 3d13ce07244..188b31aaa3e 100644
--- a/ckan/tests/lib/test_dictization.py
+++ b/ckan/tests/lib/test_dictization.py
@@ -947,7 +947,8 @@ def test_18_package_tag_list_save(self):
         model.repo.commit_and_remove()
 
         pkg = model.Package.by_name(name)
-        assert_equal(set([tag.name for tag in pkg.tags]), set(('tag1', 'tag2')))
+        assert_equal(set([tag.name for tag in pkg.get_tags()]),
+                set(('tag1', 'tag2')))
 
     def test_19_package_tag_list_save_duplicates(self):
         name = u'testpkg19'
@@ -963,4 +964,4 @@ def test_19_package_tag_list_save_duplicates(self):
         model.repo.commit_and_remove()
 
         pkg = model.Package.by_name(name)
-        assert_equal(set([tag.name for tag in pkg.tags]), set(('tag1',)))
+        assert_equal(set([tag.name for tag in pkg.get_tags()]), set(('tag1',)))
diff --git a/ckan/tests/models/test_package.py b/ckan/tests/models/test_package.py
index 8371f226f7d..ce6ec56833e 100644
--- a/ckan/tests/models/test_package.py
+++ b/ckan/tests/models/test_package.py
@@ -105,7 +105,7 @@ def test_as_dict(self):
         assert out['name'] == pkg.name
         assert out['license'] == pkg.license.title
         assert out['license_id'] == pkg.license.id
-        assert out['tags'] == [tag.name for tag in pkg.tags]
+        assert out['tags'] == [tag.name for tag in pkg.get_tags()]
         assert out['metadata_modified'] == pkg.metadata_modified.isoformat()
         assert out['metadata_created'] == pkg.metadata_created.isoformat()
         assert_equal(out['notes'], pkg.notes)
@@ -212,7 +212,7 @@ def setup_class(self):
         self.tag = model.Tag(name=self.tagname)
         self.tag2 = model.Tag(name=self.tagname2)
         pkg2tag = model.PackageTag(package=pkg, tag=self.tag)
-        pkg.tags.append(self.tag2)
+        pkg.add_tag(self.tag2)
         model.Session.add_all([pkg,self.tag,self.tag2,pkg2tag])
         model.Session.commit()
         self.pkg2tag_id = pkg2tag.id
@@ -224,7 +224,7 @@ def teardown_class(self):
 
     def test_1(self):
         pkg = model.Package.by_name(self.pkgname)
-        assert len(pkg.tags) == 2
+        assert len(pkg.get_tags()) == 2
         # pkg2tag = model.Session.query(model.PackageTag).get(self.pkg2tag_id)
         # assert pkg2tag.package.name == self.pkgname
 
@@ -245,7 +245,7 @@ def test_add_tag_by_name(self):
         except AttributeError: # sqlalchemy 0.4
             model.Session.clear()
         outpkg = model.Package.by_name(self.pkgname)
-        assert len(outpkg.tags) == 3
+        assert len(outpkg.get_tags()) == 3
         t1 = model.Tag.by_name(self.tagname)
         assert len(t1.package_tags) == 1
 
@@ -255,9 +255,9 @@ def test_add_tag_by_name_existing(self):
         except AttributeError: # sqlalchemy 0.4
             model.Session.clear()
         pkg = model.Package.by_name(self.pkgname)
-        assert len(pkg.tags) == 3
+        assert len(pkg.get_tags()) == 3, len(pkg.get_tags())
         pkg.add_tag_by_name(self.tagname)
-        assert len(pkg.tags) == 3
+        assert len(pkg.get_tags()) == 3
 
 
 class TestPackageTagSearch:
@@ -271,20 +271,18 @@ def setup_class(self):
         self.tagname = u'russian-tag-we-will-delete'
         tag3 = model.Tag(name=self.tagname)
         pkg = model.Package.by_name(u'annakarenina')
-        pkg.tags.append(tag3)
+        pkg.add_tag(tag3)
         model.repo.commit_and_remove()
 
         model.repo.new_revision()
         pkg = model.Package.by_name(u'annakarenina')
-        # we aren't guaranteed it is last ...
-        idx = [ t.name for t in pkg.tags].index(self.tagname)
-        del pkg.tags[idx]
+        pkg.remove_tag(tag3)
         # now do a tag for ordering
         tagordered = model.Tag(name=self.orderedfirst)
         wap = model.Package.by_name(u'warandpeace')
         # do them the wrong way round
-        tagordered.packages.append(wap)
-        tagordered.packages.append(pkg)
+        wap.add_tag(tagordered)
+        pkg.add_tag(tagordered)
         model.repo.commit_and_remove()
 
     @classmethod 
@@ -295,7 +293,7 @@ def teardown_class(self):
     def test_0_deleted_package_tags(self):
         pkg = model.Package.by_name(u'annakarenina')
         tag = model.Tag.by_name(self.tagname)
-        assert len(pkg.tags) == 4
+        assert len(pkg.get_tags()) == 4, len(pkg.get_tags())
         assert len(tag.packages) == 0
 
     def test_1_tag_search_1(self):
@@ -313,9 +311,9 @@ def test_1_tag_search_3(self):
     
     def test_alphabetical_ordering(self):
         pkg = model.Package.by_name(u'annakarenina')
-        tag = pkg.tags_ordered[0]
-        assert tag.name == self.orderedfirst, pkg.tags
-        assert tag.packages_ordered[0].name == 'annakarenina', tag.packages
+        tag = pkg.get_tags()[0]
+        assert tag.name == self.orderedfirst
+        assert tag.packages[0].name == 'annakarenina', tag.packages
 
 
 class TestPackageRevisions:
diff --git a/ckan/tests/models/test_purge_revision.py b/ckan/tests/models/test_purge_revision.py
index b8442e4a24e..a96bfeb2936 100644
--- a/ckan/tests/models/test_purge_revision.py
+++ b/ckan/tests/models/test_purge_revision.py
@@ -22,15 +22,16 @@ def setup(self):
         self.pkg.url = self.old_url
         tag1 = model.Tag.by_name(u'russian')
         tag2 = model.Tag.by_name(u'tolstoy')
-        self.pkg.tags.append(tag1)
-        self.pkg.tags.append(tag2)
+        self.pkg.add_tag(tag1)
+        self.pkg.add_tag(tag2)
         model.repo.commit_and_remove()
 
         txn2 = model.repo.new_revision()
         pkg = model.Package.by_name(self.pkgname)
         newurl = u'blah.com'
         pkg.url = newurl
-        pkg.tags = []
+        for tag in pkg.get_tags():
+            pkg.remove_tag(tag)
         self.pkgname2 = u'revision-purge-test-2'
         self.pkg_new = model.Package(name=self.pkgname2)
         model.repo.commit_and_remove()
@@ -56,7 +57,7 @@ def test_1(self):
         assert pkg.url == self.old_url
         pkg2 = model.Package.by_name(self.pkgname2)
         assert pkg2 is None, 'pkgname2 should no longer exist'
-        assert len(pkg.tags) == 2
+        assert len(pkg.get_tags()) == 2
 
     def test_2(self):
         rev = model.repo.youngest_revision()

From 6f7b965d39534bfaa80e7ad3f638d8b4b46010e1 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Wed, 8 Feb 2012 16:24:59 +0100
Subject: [PATCH 30/72] [#1775,#1776] Add tag_create() logic action function.

Lets you create either a free tag or a tag that belongs to a vocab.

Add tag_dict_save() to model_save.py.

Add tag_create() to logic/action/create.py and logic/auth/create.py.

Add default_create_tags_schema() to schema.py.

Add a simple functional test to test_vocabulary.py. More tests needed.
---
 ckan/lib/dictization/model_save.py            |  8 +++++
 ckan/logic/action/create.py                   | 25 +++++++++++++-
 ckan/logic/auth/create.py                     |  4 +++
 ckan/logic/schema.py                          |  4 +++
 .../functional/api/model/test_vocabulary.py   | 34 +++++++++++++++++++
 5 files changed, 74 insertions(+), 1 deletion(-)

diff --git a/ckan/lib/dictization/model_save.py b/ckan/lib/dictization/model_save.py
index 407ea4cfbda..cc72a08a0b9 100644
--- a/ckan/lib/dictization/model_save.py
+++ b/ckan/lib/dictization/model_save.py
@@ -489,3 +489,11 @@ def vocabulary_dict_update(vocabulary_dict, context):
     vocabulary_obj.name = vocabulary_dict['name']
 
     return vocabulary_obj
+
+def tag_dict_save(tag_dict, context):
+    model = context['model']
+    tag = context.get('tag')
+    if tag:
+        tag_dict['id'] = tag.id
+    tag = table_dict_save(tag_dict, model.Tag, context)
+    return tag
diff --git a/ckan/logic/action/create.py b/ckan/logic/action/create.py
index 5309ace0c71..f30f3f59002 100644
--- a/ckan/logic/action/create.py
+++ b/ckan/logic/action/create.py
@@ -19,19 +19,22 @@
                                              package_dict_save,
                                              user_dict_save,
                                              vocabulary_dict_save,
+                                             tag_dict_save,
                                              activity_dict_save)
 
 from ckan.lib.dictization.model_dictize import (group_dictize,
                                                 package_dictize,
                                                 user_dictize,
                                                 vocabulary_dictize,
+                                                tag_dictize,
                                                 activity_dictize)
 
 from ckan.logic.schema import (default_create_package_schema,
                                default_resource_schema,
                                default_create_relationship_schema,
                                default_create_vocabulary_schema,
-                               default_create_activity_schema)
+                               default_create_activity_schema,
+                               default_create_tag_schema)
 
 from ckan.logic.schema import default_group_schema, default_user_schema
 from ckan.lib.navl.dictization_functions import validate 
@@ -409,3 +412,23 @@ def package_relationship_create_rest(context, data_dict):
 
     relationship_dict = package_relationship_create(context, data_dict)
     return relationship_dict
+
+def tag_create(context, tag_dict):
+    '''Create a new tag and return a dictionary representation of it.'''
+
+    model = context['model']
+
+    check_access('tag_create', context, tag_dict)
+
+    schema = context.get('schema') or default_create_tag_schema()
+    data, errors = validate(tag_dict, schema, context)
+    if errors:
+        raise ValidationError(errors)
+
+    tag = tag_dict_save(tag_dict, context)
+
+    if not context.get('defer_commit'):
+        model.repo.commit()
+
+    log.debug("Created tag '%s' " % tag)
+    return tag_dictize(tag, context)
diff --git a/ckan/logic/auth/create.py b/ckan/logic/auth/create.py
index 270af74c6e6..eaf845e0c06 100644
--- a/ckan/logic/auth/create.py
+++ b/ckan/logic/auth/create.py
@@ -137,3 +137,7 @@ def vocabulary_create(context, data_dict):
 def activity_create(context, data_dict):
     user = context['user']
     return {'success': Authorizer.is_sysadmin(user)}
+
+def tag_create(context, data_dict):
+    user = context['user']
+    return {'success': Authorizer.is_sysadmin(user)}
diff --git a/ckan/logic/schema.py b/ckan/logic/schema.py
index 6012c108153..03c5575eaaa 100644
--- a/ckan/logic/schema.py
+++ b/ckan/logic/schema.py
@@ -86,6 +86,10 @@ def default_tags_schema():
     }
     return schema
 
+def default_create_tag_schema():
+    schema = default_tags_schema()
+    return schema
+
 def default_package_schema():
 
     schema = {
diff --git a/ckan/tests/functional/api/model/test_vocabulary.py b/ckan/tests/functional/api/model/test_vocabulary.py
index cd61e21ae06..a4d036d95a7 100644
--- a/ckan/tests/functional/api/model/test_vocabulary.py
+++ b/ckan/tests/functional/api/model/test_vocabulary.py
@@ -139,6 +139,30 @@ def _delete_vocabulary(self, vocab_id, user=None):
                 status=404)
         assert response.json['success'] == False
 
+    def _list_tags(self, vocabulary, user=None):
+        params = {'vocabulary_name': vocabulary['name']}
+        if user:
+            extra_environ = {'Authorization' : str(user.apikey)}
+        else:
+            extra_environ = None
+        response = self._post('/api/action/tag_list', params=params,
+                extra_environ=extra_environ)
+        assert response['success'] == True
+        return response['result']
+
+    def _create_tag(self, user, tag_name, vocabulary=None):
+        tag_dict = {'name': tag_name}
+        if vocabulary:
+            tag_dict['vocabulary_id'] = vocabulary['id']
+        if user:
+            extra_environ = {'Authorization' : str(user.apikey)}
+        else:
+            extra_environ = None
+        response = self._post('/api/action/tag_create', params=tag_dict,
+                extra_environ=extra_environ)
+        assert response['success'] == True
+        return response['result']
+
     def test_vocabulary_create(self):
         '''Test adding a new vocabulary to a CKAN instance via the action
         API.
@@ -311,3 +335,13 @@ def test_vocabulary_delete_not_authorized(self):
                     str(self.normal_user.apikey)},
                 status=403)
         assert response.json['success'] == False
+
+    def test_add_tag_to_vocab(self):
+        vocab = self._create_vocabulary(vocab_name="Musical Genres",
+                user=self.sysadmin_user)
+        tags_before = self._list_tags(vocab)
+        assert len(tags_before) == 0, tags_before
+        tag_created = self._create_tag(self.sysadmin_user, 'noise', vocab)
+        tags_after = self._list_tags(vocab)
+        assert len(tags_after) == 1
+        assert tag_created['name'] in tags_after

From 2d4cc504fae163b3bcc48813828c7591dfb327b7 Mon Sep 17 00:00:00 2001
From: kindly <kindly@gmail.com>
Date: Wed, 8 Feb 2012 16:57:33 +0000
Subject: [PATCH 31/72] [1741] move plugin point to dictization add test

---
 ckan/controllers/package.py           |  7 ++++---
 ckan/lib/dictization/model_dictize.py |  6 ++++++
 ckan/plugins/interfaces.py            |  7 +++++++
 ckan/tests/functional/test_package.py |  4 ++++
 ckan/tests/logic/test_action.py       | 19 +++++++++++++++++++
 5 files changed, 40 insertions(+), 3 deletions(-)

diff --git a/ckan/controllers/package.py b/ckan/controllers/package.py
index 1e4725a6d16..c7687cad2a2 100644
--- a/ckan/controllers/package.py
+++ b/ckan/controllers/package.py
@@ -24,7 +24,7 @@
 from ckan.logic import tuplize_dict, clean_dict, parse_params, flatten_to_string_key
 from ckan.lib.dictization import table_dictize
 from ckan.lib.i18n import get_lang
-from ckan.plugins import PluginImplementations, IDatasetForm
+from ckan.plugins import PluginImplementations, IDatasetForm, IPackageController
 import ckan.forms
 import ckan.authz
 import ckan.rating
@@ -255,7 +255,7 @@ def pager_url(q=None, page=None):
                         search_extras[param] = value
 
             context = {'model': model, 'session': model.Session,
-                       'user': c.user or c.author}
+                       'user': c.user or c.author, 'for_view': True}
 
             data_dict = {
                 'q':q,
@@ -289,7 +289,8 @@ def read(self, id):
         package_type = self._get_package_type(id.split('@')[0])
         context = {'model': model, 'session': model.Session,
                    'user': c.user or c.author, 'extras_as_string': True,
-                   'schema': self._form_to_db_schema(package_type=package_type)}
+                   'schema': self._form_to_db_schema(package_type=package_type),
+                   'for_view': True}
         data_dict = {'id': id}
 
         # interpret @<revision_id> or @<date> suffix
diff --git a/ckan/lib/dictization/model_dictize.py b/ckan/lib/dictization/model_dictize.py
index 422c2111a86..8855ca815d1 100644
--- a/ckan/lib/dictization/model_dictize.py
+++ b/ckan/lib/dictization/model_dictize.py
@@ -1,5 +1,6 @@
 from pylons import config
 from sqlalchemy.sql import select, and_
+from ckan.plugins import PluginImplementations, IDatasetForm, IPackageController
 import datetime
 
 from ckan.model import PackageRevision
@@ -209,6 +210,11 @@ def package_dictize(pkg, context):
     result_dict['metadata_created'] = pkg.metadata_created.isoformat() \
         if pkg.metadata_created else None
 
+    if context.get('for_view'):
+        for item in PluginImplementations(IPackageController):
+            result_dict = item.before_view(result_dict)
+
+
     return result_dict
 
 def _get_members(context, group, member_type):
diff --git a/ckan/plugins/interfaces.py b/ckan/plugins/interfaces.py
index d18452f599f..5c87b4953a3 100644
--- a/ckan/plugins/interfaces.py
+++ b/ckan/plugins/interfaces.py
@@ -270,6 +270,13 @@ def before_index(self, pkg_dict):
              an altered version.
         '''
         return pkg_dict
+
+    def before_view(self, pkg_dict):
+        '''
+             Extensions will recieve this before the dataset gets displayed. The dictionary
+             passed will be the one that gets sent to the template.
+        '''
+        return pkg_dict
         
 
 class IPluginObserver(Interface):
diff --git a/ckan/tests/functional/test_package.py b/ckan/tests/functional/test_package.py
index 81c67d93a2d..5a31289b005 100644
--- a/ckan/tests/functional/test_package.py
+++ b/ckan/tests/functional/test_package.py
@@ -61,6 +61,10 @@ def before_index(self, search_params):
         self.calls['before_index'] += 1
         return search_params
 
+    def before_view(self, search_params):
+        self.calls['before_view'] += 1
+        return search_params
+
 
 existing_extra_html = ('<label class="field_opt" for="Package-%(package_id)s-extras-%(key)s">%(capitalized_key)s</label>', '<input id="Package-%(package_id)s-extras-%(key)s" name="Package-%(package_id)s-extras-%(key)s" size="20" type="text" value="%(value)s">')
 
diff --git a/ckan/tests/logic/test_action.py b/ckan/tests/logic/test_action.py
index 37ed555beeb..6b631de2cef 100644
--- a/ckan/tests/logic/test_action.py
+++ b/ckan/tests/logic/test_action.py
@@ -1225,6 +1225,12 @@ def after_search(self, search_results, search_params):
 
         return search_results
 
+    def before_view(self, data_dict):
+        
+        data_dict['title'] = 'string_not_found_in_rest_of_template'
+
+        return data_dict
+
 class TestSearchPluginInterface(WsgiAppCase):
 
     @classmethod
@@ -1297,3 +1303,16 @@ def test_before_index(self):
         res_dict = json.loads(res.body)['result']
         assert res_dict['count'] == 2
         assert len(res_dict['results']) == 2
+
+    def test_before_view(self):
+        plugin = MockPackageSearchPlugin()
+        plugins.load(plugin)
+        res = self.app.get('/dataset/annakarenina')
+
+        assert 'string_not_found_in_rest_of_template' in res.body
+        
+        res = self.app.get('/dataset?q=')
+        assert res.body.count('string_not_found_in_rest_of_template') == 2
+        
+        plugins.unload(plugin)
+

From 8853b0401d9f1b529da3932a88afd687445ba782 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Wed, 8 Feb 2012 19:17:54 +0100
Subject: [PATCH 32/72] [#1775,#1776] Add more tests for tag_create() logic
 action function

---
 ckan/logic/schema.py                          |  13 +-
 ckan/logic/validators.py                      |  20 +++
 .../functional/api/model/test_vocabulary.py   | 142 +++++++++++++++++-
 3 files changed, 167 insertions(+), 8 deletions(-)

diff --git a/ckan/logic/schema.py b/ckan/logic/schema.py
index 03c5575eaaa..0b135c2aa99 100644
--- a/ckan/logic/schema.py
+++ b/ckan/logic/schema.py
@@ -36,7 +36,8 @@
                                    vocabulary_id_exists,
                                    user_id_exists,
                                    object_id_validator,
-                                   activity_type_exists)
+                                   activity_type_exists,
+                                   tag_not_in_vocabulary)
 from formencode.validators import OneOf
 import ckan.model
 
@@ -75,7 +76,8 @@ def default_update_resource_schema():
 
 def default_tags_schema():
     schema = {
-        'name': [not_empty,
+        'name': [not_missing,
+                 not_empty,
                  unicode,
                  tag_length_validator,
                  tag_name_validator,
@@ -88,6 +90,13 @@ def default_tags_schema():
 
 def default_create_tag_schema():
     schema = default_tags_schema()
+    # When creating a tag via the create_tag() logic action function, a
+    # vocabulary_id _must_ be given (you cannot create free tags via this
+    # function).
+    schema['vocabulary_id'] = [not_missing, not_empty, unicode,
+            vocabulary_id_exists, tag_not_in_vocabulary]
+    # You're not allowed to specify your own ID when creating a tag.
+    schema['id'] = [empty]
     return schema
 
 def default_package_schema():
diff --git a/ckan/logic/validators.py b/ckan/logic/validators.py
index f02467fc30e..28a3b278a84 100644
--- a/ckan/logic/validators.py
+++ b/ckan/logic/validators.py
@@ -446,3 +446,23 @@ def tag_in_vocabulary_validator(value, context):
             raise Invalid(_('Tag %s does not belong to vocabulary %s') % (value, vocabulary.name))
     return value
 
+def tag_not_in_vocabulary(key, tag_dict, errors, context):
+    tag_name = tag_dict[('name',)]
+    if not tag_name:
+        raise Invalid(_('No tag name'))
+    if tag_dict.has_key(('vocabulary_id',)):
+        vocabulary_id = tag_dict[('vocabulary_id',)]
+    else:
+        vocabulary_id = None
+    model = context['model']
+    session = context['session']
+
+    query = session.query(model.Tag)
+    query = query.filter(model.Tag.vocabulary_id==vocabulary_id)
+    query = query.filter(model.Tag.name==tag_name)
+    count = query.count()
+    if count > 0:
+        raise Invalid(_('Tag %s already belongs to vocabulary %s') %
+                (tag_name, vocabulary_id))
+    else:
+        return
diff --git a/ckan/tests/functional/api/model/test_vocabulary.py b/ckan/tests/functional/api/model/test_vocabulary.py
index a4d036d95a7..025507ba128 100644
--- a/ckan/tests/functional/api/model/test_vocabulary.py
+++ b/ckan/tests/functional/api/model/test_vocabulary.py
@@ -174,7 +174,7 @@ def test_vocabulary_create(self):
     def test_vocabulary_create_id(self):
         '''Test error response when user tries to supply their own ID when
         creating a vocabulary.
-        
+
         '''
         params = {'id': 'xxx', 'name': 'foobar'}
         param_string = json.dumps(params)
@@ -337,11 +337,141 @@ def test_vocabulary_delete_not_authorized(self):
         assert response.json['success'] == False
 
     def test_add_tag_to_vocab(self):
-        vocab = self._create_vocabulary(vocab_name="Musical Genres",
-                user=self.sysadmin_user)
+        '''Test that a tag can be added to and then retrieved from a vocab.'''
+        vocab = self.genre_vocab
         tags_before = self._list_tags(vocab)
-        assert len(tags_before) == 0, tags_before
         tag_created = self._create_tag(self.sysadmin_user, 'noise', vocab)
         tags_after = self._list_tags(vocab)
-        assert len(tags_after) == 1
-        assert tag_created['name'] in tags_after
+        new_tag_names = [tag_name for tag_name in tags_after if tag_name not in 
+                tags_before]
+        assert len(new_tag_names) == 1
+        assert tag_created['name'] in new_tag_names
+
+    def test_add_tag_no_vocab(self):
+        '''Test the error response when a user tries to create a tab without
+        specifying a vocab.
+
+        '''
+        tag_dict = {'name': 'noise'}
+        tag_string = json.dumps(tag_dict)
+        response = self.app.post('/api/action/tag_create',
+                params=tag_string,
+                extra_environ = {'Authorization':
+                    str(self.sysadmin_user.apikey)},
+                status=409)
+        assert response.json['success'] == False
+
+    def test_add_tag_vocab_not_exists(self):
+        '''Test the error response when a user tries to add a tag to a vocab
+        that doesn't exist.
+
+        '''
+        tag_dict = {'name': 'noise', 'vocabulary_id': 'does not exist'}
+        tag_string = json.dumps(tag_dict)
+        response = self.app.post('/api/action/tag_create',
+                params=tag_string,
+                extra_environ = {'Authorization':
+                    str(self.sysadmin_user.apikey)},
+                status=409)
+        assert response.json['success'] == False
+
+    def test_add_tag_already_added(self):
+        '''Test the error response when a user tries to add a tag to a vocab 
+        that already has a tag with the same name.
+
+        '''
+        self.test_add_tag_to_vocab()
+        vocab = self.genre_vocab
+        tag_dict = {'name': 'noise', 'vocabulary_id': vocab['id']}
+        tag_string = json.dumps(tag_dict)
+        response = self.app.post('/api/action/tag_create',
+                params=tag_string,
+                extra_environ = {'Authorization':
+                    str(self.sysadmin_user.apikey)},
+                status=409)
+        assert response.json['success'] == False
+
+    def test_add_tag_with_id(self):
+        '''Test the error response when a user tries to specify the tag ID when
+        adding a tag to a vocab.
+
+        '''
+        tag_dict = {
+                'id': 'dsagdsgsgsd',
+                'name': 'noise',
+                'vocabulary_id': self.genre_vocab['id']
+                }
+        tag_string = json.dumps(tag_dict)
+        response = self.app.post('/api/action/tag_create',
+                params=tag_string,
+                extra_environ = {'Authorization':
+                    str(self.sysadmin_user.apikey)},
+                status=409)
+        assert response.json['success'] == False
+
+    def test_add_tag_without_name(self):
+        '''Test the error response when a user tries to create a tag without a
+        name.
+
+        '''
+        tag_dict = {
+                'vocabulary_id': self.genre_vocab['id']
+                }
+        tag_string = json.dumps(tag_dict)
+        response = self.app.post('/api/action/tag_create',
+                params=tag_string,
+                extra_environ = {'Authorization':
+                    str(self.sysadmin_user.apikey)},
+                status=409)
+        assert response.json['success'] == False
+
+    def test_add_tag_invalid_name(self):
+        for name in ('Not a valid tag name!', '', None):
+            tag_dict = {
+                    'name': name,
+                    'vocabulary_id': self.genre_vocab['id']
+                    }
+            tag_string = json.dumps(tag_dict)
+            response = self.app.post('/api/action/tag_create',
+                    params=tag_string,
+                    extra_environ = {'Authorization':
+                        str(self.sysadmin_user.apikey)},
+                    status=409)
+            assert response.json['success'] == False
+
+    def test_add_tag_invalid_vocab_id(self):
+        tag_dict = {
+                'name': 'noise',
+                'vocabulary_id': 'xxcxzczxczxc',
+                }
+        tag_string = json.dumps(tag_dict)
+        response = self.app.post('/api/action/tag_create',
+                params=tag_string,
+                extra_environ = {'Authorization':
+                    str(self.sysadmin_user.apikey)},
+                status=409)
+        assert response.json['success'] == False
+
+    def test_add_tag_not_logged_in(self):
+        tag_dict = {
+                'name': 'noise',
+                'vocabulary_id': self.genre_vocab['id']
+                }
+        tag_string = json.dumps(tag_dict)
+        response = self.app.post('/api/action/tag_create',
+                params=tag_string,
+                status=403)
+        assert response.json['success'] == False
+
+    def test_add_tag_not_authorized(self):
+        tag_dict = {
+                'name': 'noise',
+                'vocabulary_id': self.genre_vocab['id']
+                }
+        tag_string = json.dumps(tag_dict)
+        response = self.app.post('/api/action/tag_create',
+                params=tag_string,
+                    extra_environ = {'Authorization':
+                        str(self.normal_user.apikey)},
+                status=403)
+        assert response.json['success'] == False

From a680cd696a44887539c2d1256b37560c2046611a Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Wed, 8 Feb 2012 20:49:47 +0100
Subject: [PATCH 33/72] [#1765] Fix Tag.get() by ID

Tag IDs are still unqiue even across vocabularies, so when getting a tag
object by ID there's no need to consider what vocab the tag belongs to.
---
 ckan/model/tag.py | 37 +++++++++++++++----------------------
 1 file changed, 15 insertions(+), 22 deletions(-)

diff --git a/ckan/model/tag.py b/ckan/model/tag.py
index 81822306bee..51027e7c622 100644
--- a/ckan/model/tag.py
+++ b/ckan/model/tag.py
@@ -45,26 +45,15 @@ def delete(self):
         self.purge()
 
     @classmethod
-    def by_id(cls, tag_id, autoflush=True, vocab=None):
+    def by_id(cls, tag_id, autoflush=True):
         """Return the tag object with the given id, or None if there is no
         tag with that id.
 
-        By default only free tags (tags which do not belong to any vocabulary)
-        are returned. If the optional argument vocab is given then only tags
-        from that vocabulary are returned, or None if there is no tag with that
-        id in that vocabulary.
-
         Arguments:
         tag_id -- The id of the tag to return.
-        vocab -- A Vocabulary object for the vocabulary to look in (optional).
 
         """
-        if vocab:
-            query = Session.query(Tag).filter(Tag.id==tag_id).filter(
-                Tag.vocabulary_id==vocab.id)
-        else:
-            query = Session.query(Tag).filter(Tag.id==tag_id).filter(
-                Tag.vocabulary_id==None)
+        query = Session.query(Tag).filter(Tag.id==tag_id)
         query = query.autoflush(autoflush)
         tag = query.first()
         return tag
@@ -110,17 +99,21 @@ def get(cls, tag_id_or_name, vocab_id_or_name=None):
         vocab_id_or_name -- The id or name of the vocabulary to look in.
 
         """
-        if vocab_id_or_name:
-            vocab = vocabulary.Vocabulary.get(vocab_id_or_name)
-            if vocab is None:
-                # The user specified an invalid vocab.
-                return None
+        # First try to get the tag by ID.
+        tag = Tag.by_id(tag_id_or_name)
+        if tag:
+            return tag
         else:
-            vocab = None
-        tag = Tag.by_id(tag_id_or_name, vocab=vocab)
-        if not tag:
+            # If that didn't work, try to get the tag by name and vocabulary.
+            if vocab_id_or_name:
+                vocab = vocabulary.Vocabulary.get(vocab_id_or_name)
+                if vocab is None:
+                    # The user specified an invalid vocab.
+                    return None
+            else:
+                vocab = None
             tag = Tag.by_name(tag_id_or_name, vocab=vocab)
-        return tag
+            return tag
         # Todo: Make sure tag names can't be changed to look like tag IDs?
 
     @classmethod

From cccfef890e91d20c2e9fe3a10bafe6d7d045d78d Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Thu, 9 Feb 2012 12:49:27 +0100
Subject: [PATCH 34/72] [#1775,#1776] Add tag_delete() logic action function

and authorization and tests.
---
 ckan/logic/action/delete.py                   |  23 ++-
 ckan/logic/auth/delete.py                     |   4 +
 .../functional/api/model/test_vocabulary.py   | 184 +++++++++++++++++-
 3 files changed, 207 insertions(+), 4 deletions(-)

diff --git a/ckan/logic/action/delete.py b/ckan/logic/action/delete.py
index 2542c44b579..555dd7b04ef 100644
--- a/ckan/logic/action/delete.py
+++ b/ckan/logic/action/delete.py
@@ -1,4 +1,4 @@
-from ckan.logic import NotFound
+from ckan.logic import NotFound, ParameterError, ValidationError
 from ckan.lib.base import _
 from ckan.logic import check_access
 from ckan.logic.action import rename_keys
@@ -121,6 +121,27 @@ def vocabulary_delete(context, data_dict):
     vocab_obj.delete()
     model.repo.commit()
 
+def tag_delete(context, data_dict):
+    model = context['model']
+    user = context['user']
+
+    if not data_dict.has_key('tag_name'):
+        raise ParameterError(_("Missing 'tag_name' parameter."))
+
+    if not data_dict.has_key('vocabulary_name'):
+        raise ParameterError(_("Missing 'vocabulary_name' parameter."))
+
+    tag_obj = model.tag.Tag.get(data_dict['tag_name'],
+            data_dict['vocabulary_name'])
+
+    if tag_obj is None:
+        raise NotFound
+
+    check_access('tag_delete', context, data_dict)
+
+    tag_obj.delete()
+    model.repo.commit()
+
 def package_relationship_delete_rest(context, data_dict):
 
     # rename keys
diff --git a/ckan/logic/auth/delete.py b/ckan/logic/auth/delete.py
index d20a32bf73c..12937c284d9 100644
--- a/ckan/logic/auth/delete.py
+++ b/ckan/logic/auth/delete.py
@@ -60,3 +60,7 @@ def task_status_delete(context, data_dict):
 def vocabulary_delete(context, data_dict):
     user = context['user']
     return {'success': Authorizer.is_sysadmin(user)}
+
+def tag_delete(context, data_dict):
+    user = context['user']
+    return {'success': Authorizer.is_sysadmin(user)}
diff --git a/ckan/tests/functional/api/model/test_vocabulary.py b/ckan/tests/functional/api/model/test_vocabulary.py
index 025507ba128..8429788b93c 100644
--- a/ckan/tests/functional/api/model/test_vocabulary.py
+++ b/ckan/tests/functional/api/model/test_vocabulary.py
@@ -139,8 +139,10 @@ def _delete_vocabulary(self, vocab_id, user=None):
                 status=404)
         assert response.json['success'] == False
 
-    def _list_tags(self, vocabulary, user=None):
-        params = {'vocabulary_name': vocabulary['name']}
+    def _list_tags(self, vocabulary=None, user=None):
+        params = {}
+        if vocabulary:
+            params['vocabulary_name'] = vocabulary['name']
         if user:
             extra_environ = {'Authorization' : str(user.apikey)}
         else:
@@ -163,6 +165,18 @@ def _create_tag(self, user, tag_name, vocabulary=None):
         assert response['success'] == True
         return response['result']
 
+    def _delete_tag(self, user, tag, vocabulary):
+        params = {'tag_name': tag['name'],
+                'vocabulary_name': vocabulary['name']}
+        if user:
+            extra_environ = {'Authorization' : str(user.apikey)}
+        else:
+            extra_environ = None
+        response = self._post('/api/action/tag_delete', params=params,
+                extra_environ=extra_environ)
+        assert response['success'] == True
+        return response['result']
+
     def test_vocabulary_create(self):
         '''Test adding a new vocabulary to a CKAN instance via the action
         API.
@@ -348,7 +362,7 @@ def test_add_tag_to_vocab(self):
         assert tag_created['name'] in new_tag_names
 
     def test_add_tag_no_vocab(self):
-        '''Test the error response when a user tries to create a tab without
+        '''Test the error response when a user tries to create a tag without
         specifying a vocab.
 
         '''
@@ -475,3 +489,167 @@ def test_add_tag_not_authorized(self):
                         str(self.normal_user.apikey)},
                 status=403)
         assert response.json['success'] == False
+
+    def test_delete_tag_from_vocab(self):
+        '''Test that a tag can be deleted from a vocab.'''
+
+        vocab = self.genre_vocab
+
+        # First add a tag to the vocab.
+        tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
+
+        # Now delete the tag from the vocab.
+        tags_before = self._list_tags(vocab)
+        self._delete_tag(self.sysadmin_user, tag, vocab)
+        tags_after = self._list_tags(vocab)
+
+        assert len(tags_after) == len(tags_before) - 1
+        assert tag['name'] not in tags_after
+        difference = [tag_name for tag_name in tags_before if tag_name not in
+                tags_after]
+        assert len(difference) == 1
+        assert tag['name'] in difference
+
+    def test_delete_tag_no_name(self):
+        '''Test the error response when a user tries to delete a tag without
+        giving the tag name.
+
+        '''
+        vocab = self.genre_vocab
+        tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
+
+        # Now try to delete the tag from the vocab.
+        params = {'vocab_name': vocab['name']}
+        response = self.app.post('/api/action/tag_delete',
+                params=json.dumps(params),
+                extra_environ = {'Authorization':
+                    str(self.sysadmin_user.apikey)},
+                status=409)
+        assert response.json['success'] == False
+        assert (response.json['error']['message'] ==
+                u"Parameter Error: Missing 'tag_name' parameter.")
+
+    def test_delete_tag_no_vocab(self):
+        '''Test the error response when a user tries to delete a tag without
+        giving the vocab name.
+
+        '''
+        vocab = self.genre_vocab
+        tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
+
+        # Now try to delete the tag from the vocab.
+        params = {'tag_name': tag['name']}
+        response = self.app.post('/api/action/tag_delete',
+                params=json.dumps(params),
+                extra_environ = {'Authorization':
+                    str(self.sysadmin_user.apikey)},
+                status=409)
+        assert response.json['success'] == False
+        assert (response.json['error']['message'] ==
+                u"Parameter Error: Missing 'vocabulary_name' parameter.")
+
+    def test_delete_tag_not_exists(self):
+        '''Test the error response when a user tries to delete a from a vocab
+        but there is no tag with that name in the vocab.
+
+        '''
+        vocab = self.genre_vocab
+        tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
+
+        params = {'tag_name': 'nonexistent',
+                'vocabulary_name': self.genre_vocab['name']}
+        response = self.app.post('/api/action/tag_delete',
+                params=json.dumps(params),
+                extra_environ = {'Authorization':
+                    str(self.sysadmin_user.apikey)},
+                status=404)
+        assert response.json['success'] == False
+        assert (response.json['error']['message'] ==
+                u"Not found")
+
+    def test_delete_tag_vocab_not_exists(self):
+        '''Test the error response when a user tries to delete a from a vocab
+        but there is no vocab with that name.
+
+        '''
+        vocab = self.genre_vocab
+        tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
+
+        params = {'tag_name': tag['name'],
+                'vocabulary_name': 'nonexistent'}
+        response = self.app.post('/api/action/tag_delete',
+                params=json.dumps(params),
+                extra_environ = {'Authorization':
+                    str(self.sysadmin_user.apikey)},
+                status=404)
+        assert response.json['success'] == False
+        assert (response.json['error']['message'] ==
+                u"Not found")
+
+    def test_delete_tag_invalid_tag(self):
+        '''Test the error response when a user tries to delete a tag but gives
+        an invalid tag name.
+
+        '''
+        vocab = self.genre_vocab
+        tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
+
+        for tag_name in ('Invalid!', '', None):
+            params = {'tag_name': tag_name,
+                    'vocabulary_name': self.genre_vocab['name']}
+            response = self.app.post('/api/action/tag_delete',
+                    params=json.dumps(params),
+                    extra_environ = {'Authorization':
+                        str(self.sysadmin_user.apikey)},
+                    status=404)
+            assert response.json['success'] == False
+            assert (response.json['error']['message'] ==
+                    u"Not found")
+
+    def test_delete_tag_invalid_vocab(self):
+        '''Test the error response when a user tries to delete a tag but gives
+        an invalid vocab name.
+
+        '''
+        vocab = self.genre_vocab
+        tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
+
+        for vocab_name in ('Invalid!', '', None):
+            params = {'tag_name': tag['name'],
+                    'vocabulary_name': vocab_name}
+            response = self.app.post('/api/action/tag_delete',
+                    params=json.dumps(params),
+                    extra_environ = {'Authorization':
+                        str(self.sysadmin_user.apikey)},
+                    status=404)
+            assert response.json['success'] == False
+            assert (response.json['error']['message'] ==
+                    u"Not found")
+
+    def test_delete_tag_not_logged_in(self):
+        vocab = self.genre_vocab
+        tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
+
+        params = {'tag_name': tag['name'],
+                'vocabulary_name': self.genre_vocab['name']}
+        response = self.app.post('/api/action/tag_delete',
+                params=json.dumps(params),
+                status=403)
+        assert response.json['success'] == False
+        assert (response.json['error']['message'] ==
+                u"Access denied")
+
+    def test_delete_tag_not_authorized(self):
+        vocab = self.genre_vocab
+        tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
+
+        params = {'tag_name': tag['name'],
+                'vocabulary_name': self.genre_vocab['name']}
+        response = self.app.post('/api/action/tag_delete',
+                params=json.dumps(params),
+                extra_environ = {'Authorization':
+                    str(self.normal_user.apikey)},
+                status=403)
+        assert response.json['success'] == False
+        assert (response.json['error']['message'] ==
+                u"Access denied")

From 0721f8c9dbf3ee622fdbb476a0de9b247729d1cd Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Thu, 9 Feb 2012 15:18:43 +0100
Subject: [PATCH 35/72] Make *_list_dictize() functions more concise

---
 ckan/lib/dictization/model_dictize.py | 20 +++++---------------
 1 file changed, 5 insertions(+), 15 deletions(-)

diff --git a/ckan/lib/dictization/model_dictize.py b/ckan/lib/dictization/model_dictize.py
index c7fe29222ad..07dec7a6221 100644
--- a/ckan/lib/dictization/model_dictize.py
+++ b/ckan/lib/dictization/model_dictize.py
@@ -446,29 +446,19 @@ def vocabulary_dictize(vocabulary, context):
     return vocabulary_dict
 
 def vocabulary_list_dictize(vocabulary_list, context):
-    list_of_dicts = []
-    for vocabulary in vocabulary_list:
-        list_of_dicts.append(vocabulary_dictize(vocabulary, context))
-    return list_of_dicts
+    return [vocabulary_dictize(vocabulary, context)
+            for vocabulary in vocabulary_list]
 
 def activity_dictize(activity, context):
     activity_dict = table_dictize(activity, context)
     return activity_dict
 
 def activity_list_dictize(activity_list, context):
-    activity_dicts = []
-    for activity in activity_list:
-        activity_dict = activity_dictize(activity, context)
-        activity_dicts.append(activity_dict)
-    return activity_dicts
+    return [activity_dictize(activity, context) for activity in activity_list]
 
 def activity_detail_dictize(activity_detail, context):
     return table_dictize(activity_detail, context)
 
 def activity_detail_list_dictize(activity_detail_list, context):
-    activity_detail_dicts = []
-    for activity_detail in activity_detail_list:
-        activity_detail_dict = activity_detail_dictize(activity_detail,
-            context)
-        activity_detail_dicts.append(activity_detail_dict)
-    return activity_detail_dicts
+    return [activity_detail_dictize(activity_detail, context)
+            for activity_detail in activity_detail_list]

From f26b9fb0bfcca4bf5d3f2c82b2c5450a58c0f4bc Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Thu, 9 Feb 2012 15:45:13 +0100
Subject: [PATCH 36/72] Removed a #TODO comment

Don't see any reason to do it
---
 ckan/logic/action/get.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/ckan/logic/action/get.py b/ckan/logic/action/get.py
index 363ae926a9d..c3cc0444493 100644
--- a/ckan/logic/action/get.py
+++ b/ckan/logic/action/get.py
@@ -978,8 +978,6 @@ def vocabulary_show(context, data_dict):
     else:
         raise NotFound
 
-    # TODO: check_access('vocabulary_show', context, data_dict)
-
     vocabulary_dict = vocabulary_dictize(vocabulary, context)
     return vocabulary_dict
 

From c297d65316e9f0d7118beea82b2f733b10a3c174 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Thu, 9 Feb 2012 15:45:39 +0100
Subject: [PATCH 37/72] Tweak a docstring

---
 ckan/model/package.py | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/ckan/model/package.py b/ckan/model/package.py
index a87abdcb968..871a08353a2 100644
--- a/ckan/model/package.py
+++ b/ckan/model/package.py
@@ -178,14 +178,15 @@ def add_tags(self, tags):
     def add_tag_by_name(self, tag_name, vocab=None, autoflush=True):
         """Add a tag with the given name to this package's tags.
 
-        By default only free tags (tags which do not belong to any vocabulary)
-        are used. If the optional argument vocab is given then only tags
-        belonging to that vocabulary will be used.
-
-        If no tag with the given name exists, one will be created. If the
-        optional argument vocab is given and no tag with the given name exists
-        in the given vocabulary, then a new tag will be created and added to
-        the vocabulary.
+        By default the given tag_name will be searched for among the free tags
+        (tags which do not belong to any vocabulary) only. If the optional
+        argument `vocab` is given then the named vocab will be searched for the
+        tag name instead.
+
+        If no tag with the given name is found, one will be created. If the
+        optional argument vocab is given and there is no tag with the given
+        name in the given vocabulary, then a new tag will be created and added
+        to the vocabulary.
 
         """
         from tag import Tag

From 72ab7ca24dd8eda9b0b334e03bda9d0587ba52c2 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Thu, 9 Feb 2012 16:25:20 +0100
Subject: [PATCH 38/72] [#1705] Don't revision vocabs

---
 ckan/logic/action/create.py | 7 -------
 ckan/logic/action/delete.py | 4 ----
 ckan/logic/action/update.py | 8 --------
 3 files changed, 19 deletions(-)

diff --git a/ckan/logic/action/create.py b/ckan/logic/action/create.py
index f30f3f59002..3cf2bc2f2a4 100644
--- a/ckan/logic/action/create.py
+++ b/ckan/logic/action/create.py
@@ -354,13 +354,6 @@ def vocabulary_create(context, data_dict):
         model.Session.rollback()
         raise ValidationError(errors, package_error_summary(errors))
 
-    rev = model.repo.new_revision()
-    rev.author = user
-    if 'message' in context:
-        rev.message = context['message']
-    else:
-        rev.message = _(u'API: Create Vocabulary %s') % data.get('name')
-
     vocabulary = vocabulary_dict_save(data, context)
 
     if not context.get('defer_commit'):
diff --git a/ckan/logic/action/delete.py b/ckan/logic/action/delete.py
index 555dd7b04ef..0b26c15b79a 100644
--- a/ckan/logic/action/delete.py
+++ b/ckan/logic/action/delete.py
@@ -114,10 +114,6 @@ def vocabulary_delete(context, data_dict):
 
     check_access('vocabulary_delete', context, data_dict)
 
-    rev = model.repo.new_revision()
-    rev.author = user
-    rev.message = _(u'REST API: Delete Vocabulary: %s') % vocab_obj.name
-
     vocab_obj.delete()
     model.repo.commit()
 
diff --git a/ckan/logic/action/update.py b/ckan/logic/action/update.py
index 4f2fce2ca63..247892d9b1c 100644
--- a/ckan/logic/action/update.py
+++ b/ckan/logic/action/update.py
@@ -565,13 +565,6 @@ def vocabulary_update(context, data_dict):
         model.Session.rollback()
         raise ValidationError(errors)
 
-    rev = model.repo.new_revision()
-    rev.author = user
-    if 'message' in context:
-        rev.message = context['message']
-    else:
-        rev.message = _(u'API: Update Vocabulary %s') % data.get('name')
-
     updated_vocab = vocabulary_dict_update(data, context)
 
     if not context.get('defer_commit'):
@@ -679,4 +672,3 @@ def user_role_bulk_update(context, data_dict):
                              'domain_object': data_dict['domain_object']}
             user_role_update(context, uro_data_dict)
     return roles_show(context, data_dict)
-

From 1cd78d0802c4553a1ffa1ce8390f570c4a2abaf6 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Thu, 9 Feb 2012 16:50:29 +0100
Subject: [PATCH 39/72] Add tests for adding/removing vocab tags to/from
 datasets

---
 .../functional/api/model/test_vocabulary.py   | 75 ++++++++++++++++++-
 1 file changed, 74 insertions(+), 1 deletion(-)

diff --git a/ckan/tests/functional/api/model/test_vocabulary.py b/ckan/tests/functional/api/model/test_vocabulary.py
index 8429788b93c..8c6c293daef 100644
--- a/ckan/tests/functional/api/model/test_vocabulary.py
+++ b/ckan/tests/functional/api/model/test_vocabulary.py
@@ -490,6 +490,49 @@ def test_add_tag_not_authorized(self):
                 status=403)
         assert response.json['success'] == False
 
+    def test_add_vocab_tag_to_dataset(self):
+        '''Test that a tag belonging to a vocab can be added to a dataset,
+        retrieved from the dataset, and then removed from the dataset.'''
+
+        # First add a tag to the vocab.
+        vocab = self.genre_vocab
+        tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
+
+        # Get a package from the API.
+        package = (self._post('/api/action/package_show',
+            {'id': self._post('/api/action/package_list')['result'][0]})
+            ['result'])
+
+        # Add the new vocab tag to the package.
+        package['tags'].append(tag)
+        updated_package = (self._post('/api/action/package_update',
+                params={'id': package['id'], 'tags': package['tags']},
+                extra_environ={'Authorization': str(self.sysadmin_user.apikey)})
+                ['result'])
+
+        # Test that the new vocab tag was added to the package.
+        tags_in_pkg = [tag_in_pkg for tag_in_pkg in updated_package['tags'] if
+                tag_in_pkg['name'] == tag['name'] and
+                tag_in_pkg['vocabulary_id'] == tag['vocabulary_id']]
+        assert len(tags_in_pkg) == 1
+
+        # Remove the new vocab tag from the package.
+        package['tags'].remove(tag)
+        updated_package = (self._post('/api/action/package_update',
+                params={'id': package['id'], 'tags': package['tags']},
+                extra_environ={'Authorization': str(self.sysadmin_user.apikey)})
+                ['result'])
+
+        # Test that the tag no longer appears in the list of tags for the
+        # package.
+        package = (self._post('/api/action/package_show',
+            {'id': self._post('/api/action/package_list')['result'][0]})
+            ['result'])
+        tags_in_pkg = [tag_in_pkg for tag_in_pkg in package['tags'] if
+                tag_in_pkg['name'] == tag['name'] and
+                tag_in_pkg['vocabulary_id'] == tag['vocabulary_id']]
+        assert len(tags_in_pkg) == 0
+
     def test_delete_tag_from_vocab(self):
         '''Test that a tag can be deleted from a vocab.'''
 
@@ -498,11 +541,31 @@ def test_delete_tag_from_vocab(self):
         # First add a tag to the vocab.
         tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
 
+        # Get a package from the API.
+        package = (self._post('/api/action/package_show',
+            {'id': self._post('/api/action/package_list')['result'][0]})
+            ['result'])
+
+        # Add the new vocab tag to the package.
+        package['tags'].append(tag)
+        updated_package = (self._post('/api/action/package_update',
+                params={'id': package['id'], 'tags': package['tags']},
+                extra_environ={'Authorization': str(self.sysadmin_user.apikey)})
+                ['result'])
+
+        # Test that the new vocab tag was added to the package.
+        tags_in_pkg = [tag_in_pkg for tag_in_pkg in updated_package['tags'] if
+                tag_in_pkg['name'] == tag['name'] and
+                tag_in_pkg['vocabulary_id'] == tag['vocabulary_id']]
+        assert len(tags_in_pkg) == 1
+
         # Now delete the tag from the vocab.
         tags_before = self._list_tags(vocab)
         self._delete_tag(self.sysadmin_user, tag, vocab)
-        tags_after = self._list_tags(vocab)
 
+        # Test that the tag no longer appears in the list of tags for the
+        # vocab.
+        tags_after = self._list_tags(vocab)
         assert len(tags_after) == len(tags_before) - 1
         assert tag['name'] not in tags_after
         difference = [tag_name for tag_name in tags_before if tag_name not in
@@ -510,6 +573,16 @@ def test_delete_tag_from_vocab(self):
         assert len(difference) == 1
         assert tag['name'] in difference
 
+        # Test that the tag no longer appears in the list of tags for the
+        # package.
+        package = (self._post('/api/action/package_show',
+            {'id': self._post('/api/action/package_list')['result'][0]})
+            ['result'])
+        tags_in_pkg = [tag_in_pkg for tag_in_pkg in package['tags'] if
+                tag_in_pkg['name'] == tag['name'] and
+                tag_in_pkg['vocabulary_id'] == tag['vocabulary_id']]
+        assert len(tags_in_pkg) == 0
+
     def test_delete_tag_no_name(self):
         '''Test the error response when a user tries to delete a tag without
         giving the tag name.

From bf3c85fbf9c72c0e8ac27d2079c20e07b6c7c668 Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Mon, 13 Feb 2012 11:23:43 +0000
Subject: [PATCH 40/72] [1721][migration] Add migration for tag vocabularies

---
 .../versions/049_add_tag_vocabulary.py        | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 ckan/migration/versions/049_add_tag_vocabulary.py

diff --git a/ckan/migration/versions/049_add_tag_vocabulary.py b/ckan/migration/versions/049_add_tag_vocabulary.py
new file mode 100644
index 00000000000..548f7b383eb
--- /dev/null
+++ b/ckan/migration/versions/049_add_tag_vocabulary.py
@@ -0,0 +1,29 @@
+from sqlalchemy import *
+from migrate import *
+
+def upgrade(migrate_engine):
+    migrate_engine.execute('''
+        ALTER TABLE tag
+            DROP CONSTRAINT tag_name_key;
+
+        CREATE TABLE vocabulary (
+            id text NOT NULL,
+            name character varying(100) NOT NULL
+        );
+
+        ALTER TABLE tag
+            ADD COLUMN vocabulary_id character varying(100);
+
+        ALTER TABLE vocabulary
+            ADD CONSTRAINT vocabulary_pkey PRIMARY KEY (id);
+
+        ALTER TABLE tag
+            ADD CONSTRAINT tag_name_vocabulary_id_key UNIQUE (name, vocabulary_id);
+
+        ALTER TABLE tag
+            ADD CONSTRAINT tag_vocabulary_id_fkey FOREIGN KEY (vocabulary_id) REFERENCES vocabulary(id);
+
+        ALTER TABLE vocabulary
+            ADD CONSTRAINT vocabulary_name_key UNIQUE (name);
+    '''
+    )

From 053cb27fe43c4a59211ad43e3aace7f84c7ad4c9 Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Mon, 13 Feb 2012 11:38:15 +0000
Subject: [PATCH 41/72] [1720][tests] Update converter tests, format of values
 passed to convert_to_tags has changed

---
 ckan/tests/logic/test_tag_vocab.py | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/ckan/tests/logic/test_tag_vocab.py b/ckan/tests/logic/test_tag_vocab.py
index d042d23e2e6..2def4bc56ed 100644
--- a/ckan/tests/logic/test_tag_vocab.py
+++ b/ckan/tests/logic/test_tag_vocab.py
@@ -13,11 +13,20 @@ def setup_class(cls):
         cls.vocab = model.Vocabulary('test-vocab') 
         model.Session.add(cls.vocab)
         model.Session.commit()
+        vocab_tag_1 = model.Tag('tag1', cls.vocab.id)
+        vocab_tag_2 = model.Tag('tag2', cls.vocab.id)
+        model.Session.add(vocab_tag_1)
+        model.Session.add(vocab_tag_2)
+        model.Session.commit()
         model.Session.remove()
 
+    @classmethod
+    def teardown_class(cls):
+        model.repo.rebuild_db()
+
     def test_convert_to_tags(self):
         def convert(tag_string, vocab):
-            key = 'vocab_tag_string'
+            key = 'vocab_tags'
             data = {key: tag_string}
             errors = []
             context = {'model': model, 'session': model.Session}
@@ -25,7 +34,7 @@ def convert(tag_string, vocab):
             del data[key]
             return data
 
-        data = unflatten(convert('tag1, tag2', 'test-vocab'))
+        data = unflatten(convert(['tag1', 'tag2'], 'test-vocab'))
         for tag in data['tags']:
             assert tag['name'] in ['tag1', 'tag2'], tag['name']
             assert tag['vocabulary_id'] == self.vocab.id, tag['vocabulary_id']
@@ -68,6 +77,10 @@ def setup_class(cls):
         model.Session.commit()
         model.Session.remove()
 
+    @classmethod
+    def teardown_class(cls):
+        model.repo.rebuild_db()
+
     def test_tag_list(self):
         postparams = '%s=1' % json.dumps({'vocabulary_name': self.vocab.name})
         res = self.app.post('/api/action/tag_list', params=postparams)

From c99ff1bee53cf16e33800c131951afd11fa961c2 Mon Sep 17 00:00:00 2001
From: kindly <kindly@gmail.com>
Date: Mon, 13 Feb 2012 12:57:11 +0000
Subject: [PATCH 42/72] [1781] add migration and tables

---
 .../versions/049_term_translation_table.py    | 20 +++++++++++++++++++
 ckan/model/__init__.py                        |  1 +
 ckan/model/term_translation.py                | 14 +++++++++++++
 3 files changed, 35 insertions(+)
 create mode 100644 ckan/migration/versions/049_term_translation_table.py
 create mode 100644 ckan/model/term_translation.py

diff --git a/ckan/migration/versions/049_term_translation_table.py b/ckan/migration/versions/049_term_translation_table.py
new file mode 100644
index 00000000000..074da9b3ca3
--- /dev/null
+++ b/ckan/migration/versions/049_term_translation_table.py
@@ -0,0 +1,20 @@
+from sqlalchemy import *
+from migrate import *
+
+def upgrade(migrate_engine):
+    migrate_engine.execute('''
+        CREATE TABLE term_translation (
+            term text NOT NULL,
+            term_translation text NOT NULL,
+            lang_code text NOT NULL
+        );
+
+        create index term_lang on term_translation(term, lang_code);
+        create index term on term_translation(term);
+    '''
+    )
+
+
+
+  
+
diff --git a/ckan/model/__init__.py b/ckan/model/__init__.py
index d2b5d839305..2a18f60a68c 100644
--- a/ckan/model/__init__.py
+++ b/ckan/model/__init__.py
@@ -24,6 +24,7 @@
 from package_relationship import *
 from task_status import *
 from activity import *
+from term_translation import *
 import ckan.migration
 from ckan.lib.helpers import OrderedDict, datetime_to_date_str
 from vdm.sqlalchemy.base import SQLAlchemySession
diff --git a/ckan/model/term_translation.py b/ckan/model/term_translation.py
new file mode 100644
index 00000000000..394754cceed
--- /dev/null
+++ b/ckan/model/term_translation.py
@@ -0,0 +1,14 @@
+import sqlalchemy as sa
+from meta import *
+from core import *
+from types import make_uuid
+from datetime import datetime
+
+__all__ = ['term_translation_table']
+
+term_translation_table = Table('term_translation', metadata,
+    Column('term', UnicodeText, nullable=False),
+    Column('term_translation', UnicodeText, nullable=False),
+    Column('lang_code', UnicodeText, nullable=False),
+)
+

From bf88c4ce26eba30efa03281771f56387481d722a Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Mon, 13 Feb 2012 16:52:28 +0000
Subject: [PATCH 43/72] [1767][tests] move test_tag_list_vocab to
 test_action.py.

Update it to use action API.
---
 ckan/tests/logic/test_action.py    | 36 +++++++++++++++++++++++++++++-
 ckan/tests/logic/test_tag_vocab.py | 31 -------------------------
 2 files changed, 35 insertions(+), 32 deletions(-)

diff --git a/ckan/tests/logic/test_action.py b/ckan/tests/logic/test_action.py
index 8e74da110df..50c105d0e0f 100644
--- a/ckan/tests/logic/test_action.py
+++ b/ckan/tests/logic/test_action.py
@@ -269,7 +269,7 @@ def test_05b_user_show_datasets(self):
         dataset = result['datasets'][0]
         assert_equal(dataset['name'], u'annakarenina')
 
-    def test_06_tag_list(self):
+    def test_06a_tag_list(self):
         postparams = '%s=1' % json.dumps({})
         res = self.app.post('/api/action/tag_list', params=postparams)
         assert_dicts_equal_ignoring_ordering(
@@ -308,6 +308,40 @@ def test_06_tag_list(self):
         assert 'id' in res_obj['result'][1]
         assert 'id' in res_obj['result'][2]
 
+    def test_06b_tag_list_vocab(self):
+        vocab_name = 'test-vocab'
+        tag_name = 'test-vocab-tag'
+
+        # create vocab
+        params = json.dumps({'name': vocab_name})
+        extra_environ = {'Authorization' : str(self.sysadmin_user.apikey)}
+        response = self.app.post('/api/action/vocabulary_create', params=params,
+                                 extra_environ=extra_environ)
+        assert response.json['success']
+        vocab_id = response.json['result']['id']
+
+        # create new tag with vocab
+        params = json.dumps({'name': tag_name, 'vocabulary_id': vocab_id})
+        extra_environ = {'Authorization' : str(self.sysadmin_user.apikey)}
+        response = self.app.post('/api/action/tag_create', params=params,
+                                 extra_environ=extra_environ)
+        assert response.json['success'] == True
+
+        # check that tag shows up in list
+        params = '%s=1' % json.dumps({'vocabulary_name': vocab_name})
+        res = self.app.post('/api/action/tag_list', params=params)
+        body = json.loads(res.body)
+        assert_dicts_equal_ignoring_ordering(
+            json.loads(res.body),
+            {'help': 'Returns a list of tags',
+             'success': True,
+             'result': [tag_name]}
+        )
+
+        # check that invalid vocab name results in a 404
+        params = '%s=1' % json.dumps({'vocabulary_name': 'invalid-vocab-name'})
+        res = self.app.post('/api/action/tag_list', params=params, status=404)
+
     def test_07_tag_show(self):
         postparams = '%s=1' % json.dumps({'id':'russian'})
         res = self.app.post('/api/action/tag_show', params=postparams)
diff --git a/ckan/tests/logic/test_tag_vocab.py b/ckan/tests/logic/test_tag_vocab.py
index 2def4bc56ed..eeb4b5c5537 100644
--- a/ckan/tests/logic/test_tag_vocab.py
+++ b/ckan/tests/logic/test_tag_vocab.py
@@ -65,34 +65,3 @@ def test_free_tags_only(self):
         assert len(data) == 2
         assert ('tags', 1, 'vocabulary_id') in data.keys()
         assert ('tags', 1, '__extras') in data.keys()
-
-class TestAPI(WsgiAppCase):
-    @classmethod
-    def setup_class(cls):
-        CreateTestData.create()
-        cls.vocab = model.Vocabulary('test-vocab') 
-        model.Session.add(cls.vocab)
-        cls.vocab_tag = model.Tag('vocab-tag', cls.vocab.id)
-        model.Session.add(cls.vocab_tag)
-        model.Session.commit()
-        model.Session.remove()
-
-    @classmethod
-    def teardown_class(cls):
-        model.repo.rebuild_db()
-
-    def test_tag_list(self):
-        postparams = '%s=1' % json.dumps({'vocabulary_name': self.vocab.name})
-        res = self.app.post('/api/action/tag_list', params=postparams)
-        body = json.loads(res.body)
-        assert_dicts_equal_ignoring_ordering(
-            json.loads(res.body),
-            {'help': 'Returns a list of tags',
-             'success': True,
-             'result': [self.vocab_tag.name]}
-        )
-
-    def test_tag_list_invalid_vocab_name_404(self):
-        postparams = '%s=1' % json.dumps({'vocabulary_name': 'invalid-vocab-name'})
-        res = self.app.post('/api/action/tag_list', params=postparams, status=404)
-

From fb967293b5935671c32e93a557a4b42dbeead865 Mon Sep 17 00:00:00 2001
From: kindly <kindly@gmail.com>
Date: Tue, 14 Feb 2012 11:29:59 +0000
Subject: [PATCH 44/72] [1781] change migration number due to merge

---
 ...49_term_translation_table.py => 050_term_translation_table.py} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename ckan/migration/versions/{049_term_translation_table.py => 050_term_translation_table.py} (100%)

diff --git a/ckan/migration/versions/049_term_translation_table.py b/ckan/migration/versions/050_term_translation_table.py
similarity index 100%
rename from ckan/migration/versions/049_term_translation_table.py
rename to ckan/migration/versions/050_term_translation_table.py

From ed7145269ea39332f7598f3bc13cd70ce8e4be42 Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Tue, 14 Feb 2012 11:32:45 +0000
Subject: [PATCH 45/72] [1767][tests] test that vocab tags are passed to
 dataset view page

---
 ckan/tests/logic/test_tag_vocab.py | 102 ++++++++++++++++++++++++++++-
 1 file changed, 101 insertions(+), 1 deletion(-)

diff --git a/ckan/tests/logic/test_tag_vocab.py b/ckan/tests/logic/test_tag_vocab.py
index eeb4b5c5537..0415f01253e 100644
--- a/ckan/tests/logic/test_tag_vocab.py
+++ b/ckan/tests/logic/test_tag_vocab.py
@@ -1,10 +1,14 @@
 import json
+from pylons import request, tmpl_context as c
+from genshi.input import HTML
+from genshi.filters import Transformer
 from ckan import model
 from ckan.logic.converters import convert_to_tags, convert_from_tags, free_tags_only
 from ckan.lib.navl.dictization_functions import unflatten
 from ckan.lib.create_test_data import CreateTestData
+import ckan.lib.helpers as h
+from ckan import plugins
 from ckan.tests import WsgiAppCase
-from ckan.tests.functional.api import assert_dicts_equal_ignoring_ordering
 
 class TestConverters(object):
     @classmethod
@@ -65,3 +69,99 @@ def test_free_tags_only(self):
         assert len(data) == 2
         assert ('tags', 1, 'vocabulary_id') in data.keys()
         assert ('tags', 1, '__extras') in data.keys()
+
+
+class MockVocabTagsPlugin(plugins.SingletonPlugin):
+    plugins.implements(plugins.IDatasetForm, inherit=True)
+    plugins.implements(plugins.IGenshiStreamFilter)
+
+    def is_fallback(self):
+        return True
+
+    def package_types(self):
+        return ["mock_vocab_tags_plugin"]
+
+    def setup_template_variables(self, context, data_dict=None):
+        # c.vocab_tags = get_action('tag_list')(context, {'vocabulary_name': self.vocab_name})
+        pass
+
+    def form_to_db_schema(self):
+        # schema = package_form_schema()
+        # schema.update({
+        #     'vocab_tags': [ignore_missing, convert_to_tags(self.vocab_name)],
+        # })
+        # return schema
+        pass
+
+    def db_to_form_schema(self):
+        # schema = package_form_schema()
+        # schema.update({
+        #     'tags': {
+        #         '__extras': [keep_extras, free_tags_only]
+        #     },
+        #     'vocab_tags_selected': [convert_from_tags(self.vocab_name), ignore_missing],
+        # })
+        # return schema
+        pass
+
+    def filter(self, stream):
+        routes = request.environ.get('pylons.routes_dict')
+        if routes.get('controller') == 'package' \
+            and routes.get('action') == 'read':
+                # add vocab tags to the bottom of the page
+                tags = c.pkg_dict.get('tags', [])
+                for tag in tags:
+                    if tag.get('vocabulary_id'):
+                        stream = stream | Transformer('body')\
+                            .append(HTML('<p>%s</p>' % tag.get('name')))
+        return stream
+
+
+class TestWUI(WsgiAppCase):
+    @classmethod
+    def setup_class(cls):
+        CreateTestData.create()
+        cls.sysadmin_user = model.User.get('testsysadmin')
+        cls.dset = model.Package.get('warandpeace')
+        cls.vocab_name = 'vocab'
+        cls.tag_name = 'vocab-tag'
+
+    @classmethod
+    def teardown_class(cls):
+        model.repo.rebuild_db()
+
+    def _create_vocabulary(self, vocab_name):
+        params = json.dumps({'name': vocab_name})
+        extra_environ = {'Authorization' : str(self.sysadmin_user.apikey)}
+        response = self.app.post('/api/action/vocabulary_create', params=params,
+                                 extra_environ=extra_environ)
+        assert json.loads(response.body)['success']
+        return json.loads(response.body)['result']['id']
+
+    def _add_vocab_tag(self, vocab_id, tag_name):
+        params = json.dumps({'name': tag_name, 'vocabulary_id': vocab_id})
+        extra_environ = {'Authorization' : str(self.sysadmin_user.apikey)}
+        response = self.app.post('/api/action/tag_create', params=params,
+                                 extra_environ=extra_environ)
+        assert response.json['success']
+
+    def _add_vocab_tag_to_dataset(self, dataset_id, vocab_id, tag_name):
+        params = json.dumps({'id': dataset_id})
+        response = self.app.post('/api/action/package_show', params=params)
+        dataset = json.loads(response.body)['result']
+        dataset['tags'].append({'name': tag_name, 'vocabulary_id': vocab_id})
+        params = json.dumps(dataset)
+        response = self.app.post('/api/action/package_update', params=params,
+                                 extra_environ={'Authorization': str(self.sysadmin_user.apikey)})
+        assert response.json['success']
+
+    def test_01_dataset_view(self):
+        plugin = MockVocabTagsPlugin()
+        plugins.load(plugin)
+        vocab_id = self._create_vocabulary(self.vocab_name)
+        self._add_vocab_tag(vocab_id, self.tag_name)
+        self._add_vocab_tag_to_dataset(self.dset.id, vocab_id, self.tag_name)
+        response = self.app.get(h.url_for(controller='package', action='read', id=self.dset.id))
+        assert self.vocab_name in response.body
+
+

From 44f2aec004122081e651519703c8363943199720 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Tue, 14 Feb 2012 13:42:16 +0100
Subject: [PATCH 46/72] [#1723] Update tag_search() and tag_autocomplete() for
 vocabularies.

Update tag_search() logic action function to filter by vocabulary.

Update tag_autocomplete() logic action function to filter by vocabulary.
Removed most of the code from this method as it seemed unnecessary, it just
calls tag_search() after doing its own auth check and then transforms the
result a little and returns it.

test_action.py: Add tests for tag_autocomplete() with vocabs.

Fix a mistake in model.Tag.all(), if no vocab specified return only free tags.
---
 ckan/logic/action/get.py        |  40 ++++++-------
 ckan/model/tag.py               |   2 +-
 ckan/tests/logic/test_action.py | 103 ++++++++++++++++++++++++++++++--
 3 files changed, 119 insertions(+), 26 deletions(-)

diff --git a/ckan/logic/action/get.py b/ckan/logic/action/get.py
index c3cc0444493..cdcd27e4201 100644
--- a/ckan/logic/action/get.py
+++ b/ckan/logic/action/get.py
@@ -609,27 +609,13 @@ def package_autocomplete(context, data_dict):
 
 def tag_autocomplete(context, data_dict):
     '''Returns tags containing the provided string'''
-
-    model = context['model']
-    session = context['session']
-    user = context['user']
-
     check_access('tag_autocomplete', context, data_dict)
-
-    q = data_dict.get('q', None)
-    if not q:
+    matching_tags = tag_search(context, data_dict)
+    if matching_tags:
+        return [tag.name for tag in matching_tags['results']]
+    else:
         return []
 
-    limit = data_dict.get('limit',10)
-
-    query = query_for('tag')
-    query.run(query=q,
-              return_objects=True,
-              limit=10,
-              username=user)
-
-    return [tag.name for tag in query.results]
-
 def format_autocomplete(context, data_dict):
     '''Returns formats containing the provided string'''
     model = context['model']
@@ -819,9 +805,8 @@ def resource_search(context, data_dict):
 
 def tag_search(context, data_dict):
     model = context['model']
-    session = context['session']
 
-    query = data_dict.get('query')
+    query = data_dict.get('query') or data_dict.get('q')
     terms = [query] if query else []
 
     fields = data_dict.get('fields', {})
@@ -830,7 +815,20 @@ def tag_search(context, data_dict):
 
     # TODO: should we check for user authentication first?
     q = model.Session.query(model.Tag)
-    q = q.distinct().join(model.Tag.package_tags)
+
+    if data_dict.has_key('vocabulary_name'):
+        # Filter by vocabulary.
+        vocab = model.Vocabulary.get(data_dict['vocabulary_name'])
+        if not vocab:
+            raise NotFound
+        q = q.filter(model.Tag.vocabulary_id == vocab.id)
+    else:
+        # If no vocabulary_name in data dict then show free tags only.
+        q = q.filter(model.Tag.vocabulary_id == None)
+        # If we're searching free tags, limit results to tags that are
+        # currently applied to a package.
+        q = q.distinct().join(model.Tag.package_tags)
+
     for field, value in fields.items():
         if field in ('tag', 'tags'):
             terms.append(value)
diff --git a/ckan/model/tag.py b/ckan/model/tag.py
index 51027e7c622..365c67cacf7 100644
--- a/ckan/model/tag.py
+++ b/ckan/model/tag.py
@@ -154,7 +154,7 @@ def all(cls, vocab_id_or_name=None):
                 return None
             query = Session.query(Tag).filter(Tag.vocabulary_id==vocab.id)
         else:
-            query = Session.query(Tag)
+            query = Session.query(Tag).filter(Tag.vocabulary_id == None)
         query = query.distinct().join(PackageTagRevision)
         query = query.filter(sqlalchemy.and_(
             PackageTagRevision.state == 'active',
diff --git a/ckan/tests/logic/test_action.py b/ckan/tests/logic/test_action.py
index 8e74da110df..7641a00f788 100644
--- a/ckan/tests/logic/test_action.py
+++ b/ckan/tests/logic/test_action.py
@@ -31,15 +31,61 @@ class TestAction(WsgiAppCase):
     normal_user = None
 
     @classmethod
-    def setup_class(self):
+    def setup_class(cls):
         CreateTestData.create()
-        self.sysadmin_user = model.User.get('testsysadmin')
-        self.normal_user = model.User.get('annafan')
+        cls.sysadmin_user = model.User.get('testsysadmin')
+        cls.normal_user = model.User.get('annafan')
+        cls.make_some_vocab_tags()
 
     @classmethod
-    def teardown_class(self):
+    def teardown_class(cls):
         model.repo.rebuild_db()
 
+    @classmethod
+    def make_some_vocab_tags(cls):
+        model.repo.new_revision()
+
+        # Create a couple of vocabularies.
+        genre_vocab = model.Vocabulary(u'genre')
+        model.Session.add(genre_vocab)
+        composers_vocab = model.Vocabulary(u'composers')
+        model.Session.add(composers_vocab)
+
+        # Create some tags that belong to vocabularies.
+        sonata_tag = model.Tag(name=u'sonata', vocabulary_id=genre_vocab.id)
+        model.Session.add(sonata_tag)
+
+        bach_tag = model.Tag(name=u'Bach', vocabulary_id=composers_vocab.id)
+        model.Session.add(bach_tag)
+
+        neoclassical_tag = model.Tag(name='neoclassical',
+                vocabulary_id=genre_vocab.id)
+        model.Session.add(neoclassical_tag)
+
+        neofolk_tag = model.Tag(name='neofolk', vocabulary_id=genre_vocab.id)
+        model.Session.add(neofolk_tag)
+
+        neomedieval_tag = model.Tag(name='neomedieval',
+                vocabulary_id=genre_vocab.id)
+        model.Session.add(neomedieval_tag)
+
+        neoprog_tag = model.Tag(name='neoprog',
+                vocabulary_id=genre_vocab.id)
+        model.Session.add(neoprog_tag)
+
+        neopsychedelia_tag = model.Tag(name='neopsychedelia',
+                vocabulary_id=genre_vocab.id)
+        model.Session.add(neopsychedelia_tag)
+
+        neosoul_tag = model.Tag(name='neosoul', vocabulary_id=genre_vocab.id)
+        model.Session.add(neosoul_tag)
+
+        nerdcore_tag = model.Tag(name='nerdcore', vocabulary_id=genre_vocab.id)
+        model.Session.add(nerdcore_tag)
+
+        model.Package.get('warandpeace').add_tag(bach_tag)
+        model.Package.get('annakarenina').add_tag(sonata_tag)
+
     def _add_basic_package(self, package_name=u'test_package', **kwargs):
         package = {
             'name': package_name,
@@ -793,6 +839,55 @@ def test_15_tag_autocomplete_is_case_insensitive(self):
         assert res_obj['success']
         assert 'MIX of CAPITALS and LOWER case' in res_obj['result'], res_obj['result']
 
+    def test_15_tag_autocomplete_with_vocab_and_empty_query(self):
+        for q in ('missing', None, '', '  '):
+            paramd = {'vocabulary_name': u'genre'}
+            if q != 'missing':
+                paramd['q'] = q
+            params = json.dumps(paramd)
+            res = self.app.post('/api/action/tag_autocomplete', params=params)
+            assert res.json['success'] is True
+            assert res.json['result'] == []
+
+    def test_15_tag_autocomplete_with_vocab_and_single_match(self):
+        paramd = {'vocabulary_name': u'genre', 'q': 'son'}
+        params = json.dumps(paramd)
+        res = self.app.post('/api/action/tag_autocomplete', params=params)
+        assert res.json['success'] is True
+        assert res.json['result'] == ['sonata'], res.json['result']
+
+    def test_15_tag_autocomplete_with_vocab_and_multiple_matches(self):
+        paramd = {'vocabulary_name': 'genre', 'q': 'neo'}
+        params = json.dumps(paramd)
+        res = self.app.post('/api/action/tag_autocomplete', params=params)
+        assert res.json['success'] is True
+        assert res.json['result'] == ['neoclassical', 'neofolk', 'neomedieval',
+                'neoprog', 'neopsychedelia', 'neosoul'], res.json['result']
+
+    def test_15_tag_autocomplete_with_vocab_and_no_matches(self):
+        paramd = {'vocabulary_name': 'composers', 'q': 'Jonny Greenwood'}
+        params = json.dumps(paramd)
+        res = self.app.post('/api/action/tag_autocomplete', params=params)
+        assert res.json['success'] is True
+        assert res.json['result'] == []
+
+    def test_15_tag_autocomplete_with_vocab_that_does_not_exist(self):
+        for q in ('', 'neo'):
+            paramd = {'vocabulary_name': 'does_not_exist', 'q': q}
+            params = json.dumps(paramd)
+            res = self.app.post('/api/action/tag_autocomplete', params=params,
+                    status=404)
+            assert res.json['success'] is False
+
+    def test_15_tag_autocomplete_with_invalid_vocab(self):
+        for vocab_name in (None, '', 'a', 'e'*200):
+            for q in (None, '', 'son'):
+                paramd = {'vocabulary_name': vocab_name, 'q': q}
+                params = json.dumps(paramd)
+                res = self.app.post('/api/action/tag_autocomplete', params=params,
+                        status=404)
+                assert res.json['success'] is False
+
     def test_16_user_autocomplete(self):
         #Empty query
         postparams = '%s=1' % json.dumps({})

From c02e9104a850ae26aa6b5e8e46a4a4a0af7391ae Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Tue, 14 Feb 2012 15:38:37 +0000
Subject: [PATCH 47/72] [1720][converters] return a list of tags instead of a
 tag string from convert_from_tags

---
 ckan/logic/converters.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/ckan/logic/converters.py b/ckan/logic/converters.py
index 8801387da2a..066520cc1e8 100644
--- a/ckan/logic/converters.py
+++ b/ckan/logic/converters.py
@@ -77,11 +77,11 @@ def callable(key, data, errors, context):
         if not v:
             raise Invalid(_('Tag vocabulary "%s" does not exist') % vocab)
 
-        tags = {}
+        tags = []
         for k in data.keys():
             if k[0] == 'tags':
                 if data[k].get('vocabulary_id') == v.id:
-                    tags[k] = data[k]
-        data[key] = ', '.join([t['name'] for t in tags.values()])
+                    tags.append(data[k]['name'])
+        data[key] = tags
     return callable
 

From a0a2d67c8970cd825dddce3ce17343012390c04f Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Tue, 14 Feb 2012 15:40:42 +0000
Subject: [PATCH 48/72] [1767][tests] Add vocab tag select to edit form in
 plugin. Tidy up TestWUI.

---
 ckan/tests/logic/test_tag_vocab.py | 93 +++++++++++++++++++++---------
 1 file changed, 65 insertions(+), 28 deletions(-)

diff --git a/ckan/tests/logic/test_tag_vocab.py b/ckan/tests/logic/test_tag_vocab.py
index 0415f01253e..dde07f96089 100644
--- a/ckan/tests/logic/test_tag_vocab.py
+++ b/ckan/tests/logic/test_tag_vocab.py
@@ -3,18 +3,22 @@
 from genshi.input import HTML
 from genshi.filters import Transformer
 from ckan import model
+from ckan.logic import get_action
 from ckan.logic.converters import convert_to_tags, convert_from_tags, free_tags_only
+from ckan.logic.schema import package_form_schema
 from ckan.lib.navl.dictization_functions import unflatten
+from ckan.lib.navl.validators import ignore_missing, keep_extras
 from ckan.lib.create_test_data import CreateTestData
 import ckan.lib.helpers as h
 from ckan import plugins
 from ckan.tests import WsgiAppCase
 
+TEST_VOCAB_NAME = 'test-vocab'
+
 class TestConverters(object):
     @classmethod
     def setup_class(cls):
-        # create a new vocabulary
-        cls.vocab = model.Vocabulary('test-vocab') 
+        cls.vocab = model.Vocabulary(TEST_VOCAB_NAME) 
         model.Session.add(cls.vocab)
         model.Session.commit()
         vocab_tag_1 = model.Tag('tag1', cls.vocab.id)
@@ -81,9 +85,11 @@ def is_fallback(self):
     def package_types(self):
         return ["mock_vocab_tags_plugin"]
 
+    def package_form(self):
+        return 'package/new_package_form.html'
+
     def setup_template_variables(self, context, data_dict=None):
-        # c.vocab_tags = get_action('tag_list')(context, {'vocabulary_name': self.vocab_name})
-        pass
+        c.vocab_tags = get_action('tag_list')(context, {'vocabulary_name': TEST_VOCAB_NAME})
 
     def form_to_db_schema(self):
         # schema = package_form_schema()
@@ -94,15 +100,14 @@ def form_to_db_schema(self):
         pass
 
     def db_to_form_schema(self):
-        # schema = package_form_schema()
-        # schema.update({
-        #     'tags': {
-        #         '__extras': [keep_extras, free_tags_only]
-        #     },
-        #     'vocab_tags_selected': [convert_from_tags(self.vocab_name), ignore_missing],
-        # })
-        # return schema
-        pass
+        schema = package_form_schema()
+        schema.update({
+            'tags': {
+                '__extras': [keep_extras, free_tags_only]
+            },
+            'vocab_tags_selected': [convert_from_tags(TEST_VOCAB_NAME), ignore_missing],
+        })
+        return schema
 
     def filter(self, stream):
         routes = request.environ.get('pylons.routes_dict')
@@ -114,6 +119,18 @@ def filter(self, stream):
                     if tag.get('vocabulary_id'):
                         stream = stream | Transformer('body')\
                             .append(HTML('<p>%s</p>' % tag.get('name')))
+        if routes.get('controller') == 'package' \
+            and routes.get('action') == 'edit':
+                # add vocabs tag select box to edit page
+                html = '<select id="vocab_tags" name="vocab_tags" size="60" multiple="multiple">'
+                selected_tags = c.pkg_dict.get('vocab_tags_selected', [])
+                for tag in c.vocab_tags:
+                    if tag in selected_tags:
+                        html += '<option selected="selected" value="%s">%s</option>' % (tag, tag)
+                    else:
+                        html += '<option value="%s">%s</option>' % (tag, tag)
+                html += '</select>'
+                stream = stream | Transformer('fieldset[@id="groups"]').append(HTML(html))
         return stream
 
 
@@ -123,18 +140,32 @@ def setup_class(cls):
         CreateTestData.create()
         cls.sysadmin_user = model.User.get('testsysadmin')
         cls.dset = model.Package.get('warandpeace')
-        cls.vocab_name = 'vocab'
-        cls.tag_name = 'vocab-tag'
+        cls.tag1_name = 'vocab-tag-1'
+        cls.tag2_name = 'vocab-tag-2'
+
+        cls.plugin = MockVocabTagsPlugin()
+        plugins.load(cls.plugin)
+
+        # this is a hack so that the plugin is properly registered with
+        # the package controller class.
+        from ckan.controllers import package as package_controller
+        package_controller._default_controller_behaviour = cls.plugin
+
+        # create a test vocab
+        params = json.dumps({'name': TEST_VOCAB_NAME})
+        extra_environ = {'Authorization' : str(cls.sysadmin_user.apikey)}
+        response = cls.app.post('/api/action/vocabulary_create', params=params,
+                                extra_environ=extra_environ)
+        assert json.loads(response.body)['success']
 
     @classmethod
     def teardown_class(cls):
+        plugins.unload(cls.plugin)
         model.repo.rebuild_db()
 
-    def _create_vocabulary(self, vocab_name):
+    def _get_vocab_id(self, vocab_name):
         params = json.dumps({'name': vocab_name})
-        extra_environ = {'Authorization' : str(self.sysadmin_user.apikey)}
-        response = self.app.post('/api/action/vocabulary_create', params=params,
-                                 extra_environ=extra_environ)
+        response = self.app.post('/api/action/vocabulary_show', params=params)
         assert json.loads(response.body)['success']
         return json.loads(response.body)['result']['id']
 
@@ -143,7 +174,7 @@ def _add_vocab_tag(self, vocab_id, tag_name):
         extra_environ = {'Authorization' : str(self.sysadmin_user.apikey)}
         response = self.app.post('/api/action/tag_create', params=params,
                                  extra_environ=extra_environ)
-        assert response.json['success']
+        assert json.loads(response.body)['success']
 
     def _add_vocab_tag_to_dataset(self, dataset_id, vocab_id, tag_name):
         params = json.dumps({'id': dataset_id})
@@ -153,15 +184,21 @@ def _add_vocab_tag_to_dataset(self, dataset_id, vocab_id, tag_name):
         params = json.dumps(dataset)
         response = self.app.post('/api/action/package_update', params=params,
                                  extra_environ={'Authorization': str(self.sysadmin_user.apikey)})
-        assert response.json['success']
+        assert json.loads(response.body)['success']
 
     def test_01_dataset_view(self):
-        plugin = MockVocabTagsPlugin()
-        plugins.load(plugin)
-        vocab_id = self._create_vocabulary(self.vocab_name)
-        self._add_vocab_tag(vocab_id, self.tag_name)
-        self._add_vocab_tag_to_dataset(self.dset.id, vocab_id, self.tag_name)
+        vocab_id = self._get_vocab_id(TEST_VOCAB_NAME)
+        self._add_vocab_tag(vocab_id, self.tag1_name)
+        self._add_vocab_tag_to_dataset(self.dset.id, vocab_id, self.tag1_name)
         response = self.app.get(h.url_for(controller='package', action='read', id=self.dset.id))
-        assert self.vocab_name in response.body
-
+        assert self.tag1_name in response.body
+
+    def test_02_dataset_edit_add_tag(self):
+        vocab_id = self._get_vocab_id(TEST_VOCAB_NAME)
+        self._add_vocab_tag(vocab_id, self.tag2_name)
+        response = self.app.get(h.url_for(controller='package', action='edit', id=self.dset.id))
+        # fv = response.forms['dataset-edit']
+        # fv['vocab_tags'] = ['']
+        # response = fv.submit('save')
+        # response = response.follow()
 

From 6ec1e6445b787bbd0686c42c8e2d034f89d1fe7d Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Tue, 14 Feb 2012 17:31:28 +0100
Subject: [PATCH 49/72] [#1724] Add tests for tag_search() logic action
 function

And fix a couple of bugs found in tag_search() and tag_list() in the process,
and factor out some code repetition, and add some docstrings.
---
 ckan/logic/action/get.py        |  79 ++++++++++++++--------
 ckan/tests/logic/test_action.py | 112 ++++++++++++++++++++++++++++++--
 2 files changed, 161 insertions(+), 30 deletions(-)

diff --git a/ckan/logic/action/get.py b/ckan/logic/action/get.py
index cdcd27e4201..342ed45216e 100644
--- a/ckan/logic/action/get.py
+++ b/ckan/logic/action/get.py
@@ -203,23 +203,13 @@ def tag_list(context, data_dict):
     model = context['model']
     user = context['user']
 
-    all_fields = data_dict.get('all_fields',None)
+    all_fields = data_dict.get('all_fields', None)
 
     check_access('tag_list',context, data_dict)
 
     q = data_dict.get('q','')
     if q:
-        limit = data_dict.get('limit',25)
-        offset = data_dict.get('offset',0)
-        return_objects = data_dict.get('return_objects',True)
-
-        query = query_for(model.Tag)
-        query.run(query=q,
-                  limit=limit,
-                  offset=offset,
-                  return_objects=return_objects,
-                  username=user)
-        tags = query.results
+        tags = _tag_search(context, data_dict)
     else:
         tags = model.Session.query(model.Tag).all()
 
@@ -607,15 +597,6 @@ def package_autocomplete(context, data_dict):
 
     return pkg_list
 
-def tag_autocomplete(context, data_dict):
-    '''Returns tags containing the provided string'''
-    check_access('tag_autocomplete', context, data_dict)
-    matching_tags = tag_search(context, data_dict)
-    if matching_tags:
-        return [tag.name for tag in matching_tags['results']]
-    else:
-        return []
-
 def format_autocomplete(context, data_dict):
     '''Returns formats containing the provided string'''
     model = context['model']
@@ -803,10 +784,22 @@ def resource_search(context, data_dict):
 
     return {'count': count, 'results': results}
 
-def tag_search(context, data_dict):
+def _tag_search(context, data_dict):
+    '''Return a list of tag objects that contain the given string.
+
+    The query string should be provided in the data_dict with key 'query' or
+    'q'.
+
+    By default only free tags (tags that don't belong to a vocabulary) are
+    searched. If a 'vocabulary_name' is provided in the data_dict then tags
+    belonging to the named vocabulary will be searched instead.
+
+    '''
     model = context['model']
 
     query = data_dict.get('query') or data_dict.get('q')
+    if query:
+        query = query.strip()
     terms = [query] if query else []
 
     fields = data_dict.get('fields', {})
@@ -834,17 +827,51 @@ def tag_search(context, data_dict):
             terms.append(value)
 
     if not len(terms):
-        return
+        return []
 
     for term in terms:
         escaped_term = misc.escape_sql_like_special_characters(term, escape='\\')
         q = q.filter(model.Tag.name.ilike('%' + escaped_term + '%'))
 
-    count = q.count()
     q = q.offset(offset)
     q = q.limit(limit)
-    results = [r for r in q]
-    return {'count': count, 'results': results}
+    return q.all()
+
+def tag_search(context, data_dict):
+    '''Return a list of tag dictionaries that contain the given string.
+
+    The query string should be provided in the data_dict with key 'query' or
+    'q'.
+
+    By default only free tags (tags that don't belong to a vocabulary) are
+    searched. If a 'vocabulary_name' is provided in the data_dict then tags
+    belonging to the named vocabulary will be searched instead.
+
+    Returns a dictionary with keys 'count' (the number of tags in the result)
+    and 'results' (the list of tag dicts).
+
+    '''
+    tags = _tag_search(context, data_dict)
+    return {'count': len(tags),
+            'results': [table_dictize(tag, context) for tag in tags]}
+
+def tag_autocomplete(context, data_dict):
+    '''Return a list of tag names that contain the given string.
+
+    The query string should be provided in the data_dict with key 'query' or
+    'q'.
+
+    By default only free tags (tags that don't belong to a vocabulary) are
+    searched. If a 'vocabulary_name' is provided in the data_dict then tags
+    belonging to the named vocabulary will be searched instead.
+
+    '''
+    check_access('tag_autocomplete', context, data_dict)
+    matching_tags = _tag_search(context, data_dict)
+    if matching_tags:
+        return [tag.name for tag in matching_tags]
+    else:
+        return []
 
 def task_status_show(context, data_dict):
     model = context['model']
diff --git a/ckan/tests/logic/test_action.py b/ckan/tests/logic/test_action.py
index 946018b9ab7..38f05635fc3 100644
--- a/ckan/tests/logic/test_action.py
+++ b/ckan/tests/logic/test_action.py
@@ -51,6 +51,19 @@ def make_some_vocab_tags(cls):
         composers_vocab = model.Vocabulary(u'composers')
         model.Session.add(composers_vocab)
 
+        # Create some additional free tags for tag search tests.
+        tolkien_tag = model.Tag(name="tolkien")
+        model.Session.add(tolkien_tag)
+        toledo_tag = model.Tag(name="toledo")
+        model.Session.add(toledo_tag)
+        tolerance_tag = model.Tag(name="tolerance")
+        model.Session.add(tolerance_tag)
+        tollbooth_tag = model.Tag(name="tollbooth")
+        model.Session.add(tollbooth_tag)
+        # We have to add free tags to a package or they won't show up in tag results.
+        model.Package.get('warandpeace').add_tags((tolkien_tag, toledo_tag,
+            tolerance_tag, tollbooth_tag))
+
         # Create some tags that belong to vocabularies.
         sonata_tag = model.Tag(name=u'sonata', vocabulary_id=genre_vocab.id)
         model.Session.add(sonata_tag)
@@ -322,7 +335,8 @@ def test_06a_tag_list(self):
             json.loads(res.body),
             {'help': 'Returns a list of tags',
              'success': True,
-             'result': ['russian', 'tolstoy', u'Flexible \u30a1']})
+             'result': ['russian', 'tolstoy', u'Flexible \u30a1', 'tollbooth',
+                 'tolkien', 'toledo', 'tolerance']})
         #Get all fields
         postparams = '%s=1' % json.dumps({'all_fields':True})
         res = self.app.post('/api/action/tag_list', params=postparams)
@@ -709,6 +723,96 @@ def test_14_group_show(self):
             'success': False
         }
 
+    def test_15a_tag_search_with_empty_query(self):
+        for q in ('missing', None, '', '  '):
+            paramd = {}
+            if q != 'missing':
+                paramd['q'] = q
+            params = json.dumps(paramd)
+            res = self.app.post('/api/action/tag_search', params=params)
+            assert res.json['success'] is True
+            assert res.json['result']['count'] == 0
+            assert res.json['result']['results'] == []
+
+    def test_15a_tag_search_with_no_matches(self):
+        paramd = {'q': 'no matches' }
+        params = json.dumps(paramd)
+        res = self.app.post('/api/action/tag_search', params=params)
+        assert res.json['success'] is True
+        assert res.json['result']['count'] == 0
+        assert res.json['result']['results'] == []
+
+    def test_15a_tag_search_with_one_match(self):
+        paramd = {'q': 'russ' }
+        params = json.dumps(paramd)
+        res = self.app.post('/api/action/tag_search', params=params)
+        assert res.json['success'] is True
+        assert res.json['result']['count'] == 1
+        tag_dicts = res.json['result']['results']
+        assert len(tag_dicts) == 1
+        assert tag_dicts[0]['name'] == 'russian'
+
+    def test_15a_tag_search_with_many_matches(self):
+        paramd = {'q': 'tol' }
+        params = json.dumps(paramd)
+        res = self.app.post('/api/action/tag_search', params=params)
+        assert res.json['success'] is True
+        assert res.json['result']['count'] == 5
+        tag_dicts = res.json['result']['results']
+        assert ([tag['name'] for tag in tag_dicts] ==
+                sorted(['tolkien', 'toledo', 'tolerance', 'tollbooth', 'tolstoy']))
+
+    def test_15a_tag_search_with_vocab_and_empty_query(self):
+        for q in ('missing', None, '', '  '):
+            paramd = {'vocabulary_name': 'genre'}
+            if q != 'missing':
+                paramd['q'] = q
+            params = json.dumps(paramd)
+            res = self.app.post('/api/action/tag_search', params=params)
+            assert res.json['success'] is True
+            assert res.json['result']['count'] == 0
+            assert res.json['result']['results'] == []
+
+    def test_15a_tag_search_with_vocab_and_one_match(self):
+        paramd = {'q': 'son', 'vocabulary_name': 'genre' }
+        params = json.dumps(paramd)
+        res = self.app.post('/api/action/tag_search', params=params)
+        assert res.json['success'] is True
+        assert res.json['result']['count'] == 1
+        tag_dicts = res.json['result']['results']
+        assert len(tag_dicts) == 1
+        assert tag_dicts[0]['name'] == 'sonata'
+
+    def test_15a_tag_search_with_vocab_and_multiple_matches(self):
+        paramd = {'q': 'neo', 'vocabulary_name': 'genre' }
+        params = json.dumps(paramd)
+        res = self.app.post('/api/action/tag_search', params=params)
+        assert res.json['success'] is True
+        assert res.json['result']['count'] == 6
+        tag_dicts = res.json['result']['results']
+        assert [tag['name'] for tag in tag_dicts] == sorted(('neoclassical',
+            'neofolk', 'neomedieval', 'neoprog', 'neopsychedelia', 'neosoul'))
+
+    def test_15a_tag_search_with_vocab_and_no_matches(self):
+        paramd = {'q': 'xxxxxxx', 'vocabulary_name': 'genre' }
+        params = json.dumps(paramd)
+        res = self.app.post('/api/action/tag_search', params=params)
+        assert res.json['success'] is True
+        assert res.json['result']['count'] == 0
+        tag_dicts = res.json['result']['results']
+        assert tag_dicts == []
+
+    def test_15a_tag_search_with_vocab_that_does_not_exist(self):
+        paramd = {'q': 'neo', 'vocabulary_name': 'xxxxxx' }
+        params = json.dumps(paramd)
+        self.app.post('/api/action/tag_search', params=params, status=404)
+
+    def test_15a_tag_search_with_invalid_vocab(self):
+        for vocab_name in (None, '', 'a', 'e'*200):
+            paramd = {'q': 'neo', 'vocabulary_name': vocab_name }
+            params = json.dumps(paramd)
+            self.app.post('/api/action/tag_search', params=params, status=404)
+
     def test_15_tag_autocomplete(self):
         #Empty query
         postparams = '%s=1' % json.dumps({})
@@ -726,7 +830,7 @@ def test_15_tag_autocomplete(self):
         res_obj = json.loads(res.body)
         assert res_obj == {
             'help': 'Returns tags containing the provided string',
-            'result': ['russian'],
+            'result': ['russian', 'tolerance'],
             'success': True
         }
 
@@ -895,8 +999,8 @@ def test_15_tag_autocomplete_with_vocab_and_multiple_matches(self):
         params = json.dumps(paramd)
         res = self.app.post('/api/action/tag_autocomplete', params=params)
         assert res.json['success'] is True
-        assert res.json['result'] == ['neoclassical', 'neofolk', 'neomedieval',
-                'neoprog', 'neopsychedelia', 'neosoul'], res.json['result']
+        assert res.json['result'] == sorted(('neoclassical', 'neofolk',
+            'neomedieval', 'neoprog', 'neopsychedelia', 'neosoul'))
 
     def test_15_tag_autocomplete_with_vocab_and_no_matches(self):
         paramd = {'vocabulary_name': 'composers', 'q': 'Jonny Greenwood'}

From 771187624ed2562c0cd61cc2a241a41e08dcdf71 Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Tue, 14 Feb 2012 17:35:20 +0000
Subject: [PATCH 50/72] [1767][tests] add WUI test for changing the vocab tags
 on a dataset

---
 ckan/tests/logic/test_tag_vocab.py | 66 ++++++++++++++++++++++++------
 1 file changed, 54 insertions(+), 12 deletions(-)

diff --git a/ckan/tests/logic/test_tag_vocab.py b/ckan/tests/logic/test_tag_vocab.py
index dde07f96089..9dce455ef85 100644
--- a/ckan/tests/logic/test_tag_vocab.py
+++ b/ckan/tests/logic/test_tag_vocab.py
@@ -2,6 +2,7 @@
 from pylons import request, tmpl_context as c
 from genshi.input import HTML
 from genshi.filters import Transformer
+import paste.fixture
 from ckan import model
 from ckan.logic import get_action
 from ckan.logic.converters import convert_to_tags, convert_from_tags, free_tags_only
@@ -92,12 +93,11 @@ def setup_template_variables(self, context, data_dict=None):
         c.vocab_tags = get_action('tag_list')(context, {'vocabulary_name': TEST_VOCAB_NAME})
 
     def form_to_db_schema(self):
-        # schema = package_form_schema()
-        # schema.update({
-        #     'vocab_tags': [ignore_missing, convert_to_tags(self.vocab_name)],
-        # })
-        # return schema
-        pass
+        schema = package_form_schema()
+        schema.update({
+            'vocab_tags': [ignore_missing, convert_to_tags(TEST_VOCAB_NAME)],
+        })
+        return schema
 
     def db_to_form_schema(self):
         schema = package_form_schema()
@@ -134,6 +134,45 @@ def filter(self, stream):
         return stream
 
 
+# paste.fixture.Field.Select does not handle multiple selects currently,
+# so replace with our own implementation here
+#
+# TODO: this still only handles a single value, fix and test multiple
+class Select(paste.fixture.Field):
+    def __init__(self, *args, **attrs):
+        super(Select, self).__init__(*args, **attrs)
+        self.options = []
+        self.selectedIndex = None
+
+    def value__set(self, value):
+        for i, (option, checked) in enumerate(self.options):
+            if option == str(value):
+                self.selectedIndex = i
+                break
+        else:
+            raise ValueError(
+                "Option %r not found (from %s)"
+                % (value, ', '.join(
+                [repr(o) for o, c in self.options])))
+
+    def value__get(self):
+        if self.selectedIndex is not None:
+            return self.options[self.selectedIndex][0]
+        else:
+            for option, checked in self.options:
+                if checked:
+                    return option
+            else:
+                if self.options:
+                    return self.options[0][0]
+                else:
+                    return None
+
+    value = property(value__get, value__set)
+
+paste.fixture.Field.classes['select'] = Select
+
+
 class TestWUI(WsgiAppCase):
     @classmethod
     def setup_class(cls):
@@ -193,12 +232,15 @@ def test_01_dataset_view(self):
         response = self.app.get(h.url_for(controller='package', action='read', id=self.dset.id))
         assert self.tag1_name in response.body
 
-    def test_02_dataset_edit_add_tag(self):
+    def test_02_dataset_edit_change_vocab_tag(self):
         vocab_id = self._get_vocab_id(TEST_VOCAB_NAME)
         self._add_vocab_tag(vocab_id, self.tag2_name)
-        response = self.app.get(h.url_for(controller='package', action='edit', id=self.dset.id))
-        # fv = response.forms['dataset-edit']
-        # fv['vocab_tags'] = ['']
-        # response = fv.submit('save')
-        # response = response.follow()
+        url = h.url_for(controller='package', action='edit', id=self.dset.id)
+        response = self.app.get(url)
+        fv = response.forms['dataset-edit']
+        fv['vocab_tags'] = self.tag2_name
+        response = fv.submit('save')
+        response = response.follow()
+        assert not self.tag1_name in response.body
+        assert self.tag2_name in response.body
 

From 4f64b254fa02010b0713dab79c32edcd3493cc9e Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Wed, 15 Feb 2012 10:06:53 +0000
Subject: [PATCH 51/72] [1767][tests] update tag vocab WUI tests - remove vocab
 tags after each test

---
 ckan/tests/logic/test_tag_vocab.py | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/ckan/tests/logic/test_tag_vocab.py b/ckan/tests/logic/test_tag_vocab.py
index 9dce455ef85..cc5e6b34d2a 100644
--- a/ckan/tests/logic/test_tag_vocab.py
+++ b/ckan/tests/logic/test_tag_vocab.py
@@ -225,15 +225,35 @@ def _add_vocab_tag_to_dataset(self, dataset_id, vocab_id, tag_name):
                                  extra_environ={'Authorization': str(self.sysadmin_user.apikey)})
         assert json.loads(response.body)['success']
 
+    def _remove_vocab_tags(self, dataset_id, vocab_id, tag_name):
+        params = json.dumps({'id': dataset_id})
+        response = self.app.post('/api/action/package_show', params=params)
+        dataset = json.loads(response.body)['result']
+        dataset['tags'] = [t for t in dataset['tags'] if not t['name'] == tag_name]
+        params = json.dumps(dataset)
+        response = self.app.post('/api/action/package_update', params=params,
+                                 extra_environ={'Authorization': str(self.sysadmin_user.apikey)})
+        assert json.loads(response.body)['success']
+
+        # TODO: should really be able to delete a tag with tag name and vocab ID,
+        # update tag_delete then change this
+        params = json.dumps({'tag_name': tag_name, 'vocabulary_name': TEST_VOCAB_NAME})
+        extra_environ = {'Authorization' : str(self.sysadmin_user.apikey)}
+        response = self.app.post('/api/action/tag_delete', params=params,
+                                 extra_environ=extra_environ)
+        assert json.loads(response.body)['success']
+
     def test_01_dataset_view(self):
         vocab_id = self._get_vocab_id(TEST_VOCAB_NAME)
         self._add_vocab_tag(vocab_id, self.tag1_name)
         self._add_vocab_tag_to_dataset(self.dset.id, vocab_id, self.tag1_name)
         response = self.app.get(h.url_for(controller='package', action='read', id=self.dset.id))
         assert self.tag1_name in response.body
+        self._remove_vocab_tags(self.dset.id, vocab_id, self.tag1_name)
 
     def test_02_dataset_edit_change_vocab_tag(self):
         vocab_id = self._get_vocab_id(TEST_VOCAB_NAME)
+        self._add_vocab_tag(vocab_id, self.tag1_name)
         self._add_vocab_tag(vocab_id, self.tag2_name)
         url = h.url_for(controller='package', action='edit', id=self.dset.id)
         response = self.app.get(url)
@@ -243,4 +263,6 @@ def test_02_dataset_edit_change_vocab_tag(self):
         response = response.follow()
         assert not self.tag1_name in response.body
         assert self.tag2_name in response.body
+        self._remove_vocab_tags(self.dset.id, vocab_id, self.tag1_name)
+        self._remove_vocab_tags(self.dset.id, vocab_id, self.tag2_name)
 

From 5cfdb52c5f3b123d6854f55c9818a95d4f0b4b7f Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Wed, 15 Feb 2012 10:17:30 +0000
Subject: [PATCH 52/72] [1767][tests] update tag vocab tests - rename test

---
 ckan/tests/logic/test_tag_vocab.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ckan/tests/logic/test_tag_vocab.py b/ckan/tests/logic/test_tag_vocab.py
index cc5e6b34d2a..8446fd3fcfa 100644
--- a/ckan/tests/logic/test_tag_vocab.py
+++ b/ckan/tests/logic/test_tag_vocab.py
@@ -251,7 +251,7 @@ def test_01_dataset_view(self):
         assert self.tag1_name in response.body
         self._remove_vocab_tags(self.dset.id, vocab_id, self.tag1_name)
 
-    def test_02_dataset_edit_change_vocab_tag(self):
+    def test_02_dataset_edit_add_vocab_tag(self):
         vocab_id = self._get_vocab_id(TEST_VOCAB_NAME)
         self._add_vocab_tag(vocab_id, self.tag1_name)
         self._add_vocab_tag(vocab_id, self.tag2_name)

From be5d7ec1098070d3ead48a42fb1f85560db7530f Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Wed, 15 Feb 2012 11:48:11 +0000
Subject: [PATCH 53/72] [1767][tests] update tag vocab tests - add WUI tests
 for removing and changing vocab tags

---
 ckan/tests/logic/test_tag_vocab.py | 66 +++++++++++++++++++-----------
 1 file changed, 43 insertions(+), 23 deletions(-)

diff --git a/ckan/tests/logic/test_tag_vocab.py b/ckan/tests/logic/test_tag_vocab.py
index 8446fd3fcfa..966f323dca5 100644
--- a/ckan/tests/logic/test_tag_vocab.py
+++ b/ckan/tests/logic/test_tag_vocab.py
@@ -145,6 +145,11 @@ def __init__(self, *args, **attrs):
         self.selectedIndex = None
 
     def value__set(self, value):
+        if not value:
+            self.selectedIndex = None
+            self.options = [(option, False) for (option, checked) in self.options]
+            return
+
         for i, (option, checked) in enumerate(self.options):
             if option == str(value):
                 self.selectedIndex = i
@@ -162,11 +167,7 @@ def value__get(self):
             for option, checked in self.options:
                 if checked:
                     return option
-            else:
-                if self.options:
-                    return self.options[0][0]
-                else:
-                    return None
+            return None
 
     value = property(value__get, value__set)
 
@@ -196,6 +197,18 @@ def setup_class(cls):
         response = cls.app.post('/api/action/vocabulary_create', params=params,
                                 extra_environ=extra_environ)
         assert json.loads(response.body)['success']
+        vocab_id = json.loads(response.body)['result']['id']
+
+        # add tags to the vocab
+        extra_environ = {'Authorization' : str(cls.sysadmin_user.apikey)}
+        params = json.dumps({'name': cls.tag1_name, 'vocabulary_id': vocab_id})
+        response = cls.app.post('/api/action/tag_create', params=params,
+                                 extra_environ=extra_environ)
+        assert json.loads(response.body)['success']
+        params = json.dumps({'name': cls.tag2_name, 'vocabulary_id': vocab_id})
+        response = cls.app.post('/api/action/tag_create', params=params,
+                                 extra_environ=extra_environ)
+        assert json.loads(response.body)['success']
 
     @classmethod
     def teardown_class(cls):
@@ -208,13 +221,6 @@ def _get_vocab_id(self, vocab_name):
         assert json.loads(response.body)['success']
         return json.loads(response.body)['result']['id']
 
-    def _add_vocab_tag(self, vocab_id, tag_name):
-        params = json.dumps({'name': tag_name, 'vocabulary_id': vocab_id})
-        extra_environ = {'Authorization' : str(self.sysadmin_user.apikey)}
-        response = self.app.post('/api/action/tag_create', params=params,
-                                 extra_environ=extra_environ)
-        assert json.loads(response.body)['success']
-
     def _add_vocab_tag_to_dataset(self, dataset_id, vocab_id, tag_name):
         params = json.dumps({'id': dataset_id})
         response = self.app.post('/api/action/package_show', params=params)
@@ -235,17 +241,8 @@ def _remove_vocab_tags(self, dataset_id, vocab_id, tag_name):
                                  extra_environ={'Authorization': str(self.sysadmin_user.apikey)})
         assert json.loads(response.body)['success']
 
-        # TODO: should really be able to delete a tag with tag name and vocab ID,
-        # update tag_delete then change this
-        params = json.dumps({'tag_name': tag_name, 'vocabulary_name': TEST_VOCAB_NAME})
-        extra_environ = {'Authorization' : str(self.sysadmin_user.apikey)}
-        response = self.app.post('/api/action/tag_delete', params=params,
-                                 extra_environ=extra_environ)
-        assert json.loads(response.body)['success']
-
     def test_01_dataset_view(self):
         vocab_id = self._get_vocab_id(TEST_VOCAB_NAME)
-        self._add_vocab_tag(vocab_id, self.tag1_name)
         self._add_vocab_tag_to_dataset(self.dset.id, vocab_id, self.tag1_name)
         response = self.app.get(h.url_for(controller='package', action='read', id=self.dset.id))
         assert self.tag1_name in response.body
@@ -253,8 +250,6 @@ def test_01_dataset_view(self):
 
     def test_02_dataset_edit_add_vocab_tag(self):
         vocab_id = self._get_vocab_id(TEST_VOCAB_NAME)
-        self._add_vocab_tag(vocab_id, self.tag1_name)
-        self._add_vocab_tag(vocab_id, self.tag2_name)
         url = h.url_for(controller='package', action='edit', id=self.dset.id)
         response = self.app.get(url)
         fv = response.forms['dataset-edit']
@@ -266,3 +261,28 @@ def test_02_dataset_edit_add_vocab_tag(self):
         self._remove_vocab_tags(self.dset.id, vocab_id, self.tag1_name)
         self._remove_vocab_tags(self.dset.id, vocab_id, self.tag2_name)
 
+    def test_03_dataset_edit_remove_vocab_tag(self):
+        vocab_id = self._get_vocab_id(TEST_VOCAB_NAME)
+        self._add_vocab_tag_to_dataset(self.dset.id, vocab_id, self.tag1_name)
+        url = h.url_for(controller='package', action='edit', id=self.dset.id)
+        response = self.app.get(url)
+        fv = response.forms['dataset-edit']
+        fv['vocab_tags'] = ''
+        response = fv.submit('save')
+        response = response.follow()
+        assert not self.tag1_name in response.body
+        self._remove_vocab_tags(self.dset.id, vocab_id, self.tag1_name)
+
+    def test_04_dataset_edit_change_vocab_tag(self):
+        vocab_id = self._get_vocab_id(TEST_VOCAB_NAME)
+        self._add_vocab_tag_to_dataset(self.dset.id, vocab_id, self.tag1_name)
+        url = h.url_for(controller='package', action='edit', id=self.dset.id)
+        response = self.app.get(url)
+        fv = response.forms['dataset-edit']
+        fv['vocab_tags'] = self.tag2_name
+        response = fv.submit('save')
+        response = response.follow()
+        assert not self.tag1_name in response.body
+        assert self.tag2_name in response.body
+        self._remove_vocab_tags(self.dset.id, vocab_id, self.tag2_name)
+

From b950d222d9e539aa94a627be8633db6712020bce Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Wed, 15 Feb 2012 11:55:59 +0000
Subject: [PATCH 54/72] [1767][tests] Move tag vocab WUI tests to
 tests/functional

---
 ckan/tests/functional/test_tag_vocab.py | 227 ++++++++++++++++++++++++
 ckan/tests/logic/test_tag_vocab.py      | 223 -----------------------
 2 files changed, 227 insertions(+), 223 deletions(-)
 create mode 100644 ckan/tests/functional/test_tag_vocab.py

diff --git a/ckan/tests/functional/test_tag_vocab.py b/ckan/tests/functional/test_tag_vocab.py
new file mode 100644
index 00000000000..f059eee72e3
--- /dev/null
+++ b/ckan/tests/functional/test_tag_vocab.py
@@ -0,0 +1,227 @@
+import json
+from pylons import request, tmpl_context as c
+from genshi.input import HTML
+from genshi.filters import Transformer
+import paste.fixture
+from ckan import model
+from ckan.logic import get_action
+from ckan.logic.converters import convert_to_tags, convert_from_tags, free_tags_only
+from ckan.logic.schema import package_form_schema
+from ckan.lib.navl.validators import ignore_missing, keep_extras
+from ckan.lib.create_test_data import CreateTestData
+import ckan.lib.helpers as h
+from ckan import plugins
+from ckan.tests import WsgiAppCase
+
+TEST_VOCAB_NAME = 'test-vocab'
+
+class MockVocabTagsPlugin(plugins.SingletonPlugin):
+    plugins.implements(plugins.IDatasetForm, inherit=True)
+    plugins.implements(plugins.IGenshiStreamFilter)
+
+    def is_fallback(self):
+        return True
+
+    def package_types(self):
+        return ["mock_vocab_tags_plugin"]
+
+    def package_form(self):
+        return 'package/new_package_form.html'
+
+    def setup_template_variables(self, context, data_dict=None):
+        c.vocab_tags = get_action('tag_list')(context, {'vocabulary_name': TEST_VOCAB_NAME})
+
+    def form_to_db_schema(self):
+        schema = package_form_schema()
+        schema.update({
+            'vocab_tags': [ignore_missing, convert_to_tags(TEST_VOCAB_NAME)],
+        })
+        return schema
+
+    def db_to_form_schema(self):
+        schema = package_form_schema()
+        schema.update({
+            'tags': {
+                '__extras': [keep_extras, free_tags_only]
+            },
+            'vocab_tags_selected': [convert_from_tags(TEST_VOCAB_NAME), ignore_missing],
+        })
+        return schema
+
+    def filter(self, stream):
+        routes = request.environ.get('pylons.routes_dict')
+        if routes.get('controller') == 'package' \
+            and routes.get('action') == 'read':
+                # add vocab tags to the bottom of the page
+                tags = c.pkg_dict.get('tags', [])
+                for tag in tags:
+                    if tag.get('vocabulary_id'):
+                        stream = stream | Transformer('body')\
+                            .append(HTML('<p>%s</p>' % tag.get('name')))
+        if routes.get('controller') == 'package' \
+            and routes.get('action') == 'edit':
+                # add vocabs tag select box to edit page
+                html = '<select id="vocab_tags" name="vocab_tags" size="60" multiple="multiple">'
+                selected_tags = c.pkg_dict.get('vocab_tags_selected', [])
+                for tag in c.vocab_tags:
+                    if tag in selected_tags:
+                        html += '<option selected="selected" value="%s">%s</option>' % (tag, tag)
+                    else:
+                        html += '<option value="%s">%s</option>' % (tag, tag)
+                html += '</select>'
+                stream = stream | Transformer('fieldset[@id="groups"]').append(HTML(html))
+        return stream
+
+
+# paste.fixture.Field.Select does not handle multiple selects currently,
+# so replace with our own implementation here
+#
+# TODO: this still only handles a single value, fix and test multiple
+class Select(paste.fixture.Field):
+    def __init__(self, *args, **attrs):
+        super(Select, self).__init__(*args, **attrs)
+        self.options = []
+        self.selectedIndex = None
+
+    def value__set(self, value):
+        if not value:
+            self.selectedIndex = None
+            self.options = [(option, False) for (option, checked) in self.options]
+            return
+
+        for i, (option, checked) in enumerate(self.options):
+            if option == str(value):
+                self.selectedIndex = i
+                break
+        else:
+            raise ValueError(
+                "Option %r not found (from %s)"
+                % (value, ', '.join(
+                [repr(o) for o, c in self.options])))
+
+    def value__get(self):
+        if self.selectedIndex is not None:
+            return self.options[self.selectedIndex][0]
+        else:
+            for option, checked in self.options:
+                if checked:
+                    return option
+            return None
+
+    value = property(value__get, value__set)
+
+paste.fixture.Field.classes['select'] = Select
+
+
+class TestWUI(WsgiAppCase):
+    @classmethod
+    def setup_class(cls):
+        CreateTestData.create()
+        cls.sysadmin_user = model.User.get('testsysadmin')
+        cls.dset = model.Package.get('warandpeace')
+        cls.tag1_name = 'vocab-tag-1'
+        cls.tag2_name = 'vocab-tag-2'
+
+        cls.plugin = MockVocabTagsPlugin()
+        plugins.load(cls.plugin)
+
+        # this is a hack so that the plugin is properly registered with
+        # the package controller class.
+        from ckan.controllers import package as package_controller
+        package_controller._default_controller_behaviour = cls.plugin
+
+        # create a test vocab
+        params = json.dumps({'name': TEST_VOCAB_NAME})
+        extra_environ = {'Authorization' : str(cls.sysadmin_user.apikey)}
+        response = cls.app.post('/api/action/vocabulary_create', params=params,
+                                extra_environ=extra_environ)
+        assert json.loads(response.body)['success']
+        vocab_id = json.loads(response.body)['result']['id']
+
+        # add tags to the vocab
+        extra_environ = {'Authorization' : str(cls.sysadmin_user.apikey)}
+        params = json.dumps({'name': cls.tag1_name, 'vocabulary_id': vocab_id})
+        response = cls.app.post('/api/action/tag_create', params=params,
+                                 extra_environ=extra_environ)
+        assert json.loads(response.body)['success']
+        params = json.dumps({'name': cls.tag2_name, 'vocabulary_id': vocab_id})
+        response = cls.app.post('/api/action/tag_create', params=params,
+                                 extra_environ=extra_environ)
+        assert json.loads(response.body)['success']
+
+    @classmethod
+    def teardown_class(cls):
+        plugins.unload(cls.plugin)
+        model.repo.rebuild_db()
+
+    def _get_vocab_id(self, vocab_name):
+        params = json.dumps({'name': vocab_name})
+        response = self.app.post('/api/action/vocabulary_show', params=params)
+        assert json.loads(response.body)['success']
+        return json.loads(response.body)['result']['id']
+
+    def _add_vocab_tag_to_dataset(self, dataset_id, vocab_id, tag_name):
+        params = json.dumps({'id': dataset_id})
+        response = self.app.post('/api/action/package_show', params=params)
+        dataset = json.loads(response.body)['result']
+        dataset['tags'].append({'name': tag_name, 'vocabulary_id': vocab_id})
+        params = json.dumps(dataset)
+        response = self.app.post('/api/action/package_update', params=params,
+                                 extra_environ={'Authorization': str(self.sysadmin_user.apikey)})
+        assert json.loads(response.body)['success']
+
+    def _remove_vocab_tags(self, dataset_id, vocab_id, tag_name):
+        params = json.dumps({'id': dataset_id})
+        response = self.app.post('/api/action/package_show', params=params)
+        dataset = json.loads(response.body)['result']
+        dataset['tags'] = [t for t in dataset['tags'] if not t['name'] == tag_name]
+        params = json.dumps(dataset)
+        response = self.app.post('/api/action/package_update', params=params,
+                                 extra_environ={'Authorization': str(self.sysadmin_user.apikey)})
+        assert json.loads(response.body)['success']
+
+    def test_01_dataset_view(self):
+        vocab_id = self._get_vocab_id(TEST_VOCAB_NAME)
+        self._add_vocab_tag_to_dataset(self.dset.id, vocab_id, self.tag1_name)
+        response = self.app.get(h.url_for(controller='package', action='read', id=self.dset.id))
+        assert self.tag1_name in response.body
+        self._remove_vocab_tags(self.dset.id, vocab_id, self.tag1_name)
+
+    def test_02_dataset_edit_add_vocab_tag(self):
+        vocab_id = self._get_vocab_id(TEST_VOCAB_NAME)
+        url = h.url_for(controller='package', action='edit', id=self.dset.id)
+        response = self.app.get(url)
+        fv = response.forms['dataset-edit']
+        fv['vocab_tags'] = self.tag2_name
+        response = fv.submit('save')
+        response = response.follow()
+        assert not self.tag1_name in response.body
+        assert self.tag2_name in response.body
+        self._remove_vocab_tags(self.dset.id, vocab_id, self.tag1_name)
+        self._remove_vocab_tags(self.dset.id, vocab_id, self.tag2_name)
+
+    def test_03_dataset_edit_remove_vocab_tag(self):
+        vocab_id = self._get_vocab_id(TEST_VOCAB_NAME)
+        self._add_vocab_tag_to_dataset(self.dset.id, vocab_id, self.tag1_name)
+        url = h.url_for(controller='package', action='edit', id=self.dset.id)
+        response = self.app.get(url)
+        fv = response.forms['dataset-edit']
+        fv['vocab_tags'] = ''
+        response = fv.submit('save')
+        response = response.follow()
+        assert not self.tag1_name in response.body
+        self._remove_vocab_tags(self.dset.id, vocab_id, self.tag1_name)
+
+    def test_04_dataset_edit_change_vocab_tag(self):
+        vocab_id = self._get_vocab_id(TEST_VOCAB_NAME)
+        self._add_vocab_tag_to_dataset(self.dset.id, vocab_id, self.tag1_name)
+        url = h.url_for(controller='package', action='edit', id=self.dset.id)
+        response = self.app.get(url)
+        fv = response.forms['dataset-edit']
+        fv['vocab_tags'] = self.tag2_name
+        response = fv.submit('save')
+        response = response.follow()
+        assert not self.tag1_name in response.body
+        assert self.tag2_name in response.body
+        self._remove_vocab_tags(self.dset.id, vocab_id, self.tag2_name)
+
diff --git a/ckan/tests/logic/test_tag_vocab.py b/ckan/tests/logic/test_tag_vocab.py
index 966f323dca5..4500ea69a7f 100644
--- a/ckan/tests/logic/test_tag_vocab.py
+++ b/ckan/tests/logic/test_tag_vocab.py
@@ -1,18 +1,6 @@
-import json
-from pylons import request, tmpl_context as c
-from genshi.input import HTML
-from genshi.filters import Transformer
-import paste.fixture
 from ckan import model
-from ckan.logic import get_action
 from ckan.logic.converters import convert_to_tags, convert_from_tags, free_tags_only
-from ckan.logic.schema import package_form_schema
 from ckan.lib.navl.dictization_functions import unflatten
-from ckan.lib.navl.validators import ignore_missing, keep_extras
-from ckan.lib.create_test_data import CreateTestData
-import ckan.lib.helpers as h
-from ckan import plugins
-from ckan.tests import WsgiAppCase
 
 TEST_VOCAB_NAME = 'test-vocab'
 
@@ -75,214 +63,3 @@ def test_free_tags_only(self):
         assert ('tags', 1, 'vocabulary_id') in data.keys()
         assert ('tags', 1, '__extras') in data.keys()
 
-
-class MockVocabTagsPlugin(plugins.SingletonPlugin):
-    plugins.implements(plugins.IDatasetForm, inherit=True)
-    plugins.implements(plugins.IGenshiStreamFilter)
-
-    def is_fallback(self):
-        return True
-
-    def package_types(self):
-        return ["mock_vocab_tags_plugin"]
-
-    def package_form(self):
-        return 'package/new_package_form.html'
-
-    def setup_template_variables(self, context, data_dict=None):
-        c.vocab_tags = get_action('tag_list')(context, {'vocabulary_name': TEST_VOCAB_NAME})
-
-    def form_to_db_schema(self):
-        schema = package_form_schema()
-        schema.update({
-            'vocab_tags': [ignore_missing, convert_to_tags(TEST_VOCAB_NAME)],
-        })
-        return schema
-
-    def db_to_form_schema(self):
-        schema = package_form_schema()
-        schema.update({
-            'tags': {
-                '__extras': [keep_extras, free_tags_only]
-            },
-            'vocab_tags_selected': [convert_from_tags(TEST_VOCAB_NAME), ignore_missing],
-        })
-        return schema
-
-    def filter(self, stream):
-        routes = request.environ.get('pylons.routes_dict')
-        if routes.get('controller') == 'package' \
-            and routes.get('action') == 'read':
-                # add vocab tags to the bottom of the page
-                tags = c.pkg_dict.get('tags', [])
-                for tag in tags:
-                    if tag.get('vocabulary_id'):
-                        stream = stream | Transformer('body')\
-                            .append(HTML('<p>%s</p>' % tag.get('name')))
-        if routes.get('controller') == 'package' \
-            and routes.get('action') == 'edit':
-                # add vocabs tag select box to edit page
-                html = '<select id="vocab_tags" name="vocab_tags" size="60" multiple="multiple">'
-                selected_tags = c.pkg_dict.get('vocab_tags_selected', [])
-                for tag in c.vocab_tags:
-                    if tag in selected_tags:
-                        html += '<option selected="selected" value="%s">%s</option>' % (tag, tag)
-                    else:
-                        html += '<option value="%s">%s</option>' % (tag, tag)
-                html += '</select>'
-                stream = stream | Transformer('fieldset[@id="groups"]').append(HTML(html))
-        return stream
-
-
-# paste.fixture.Field.Select does not handle multiple selects currently,
-# so replace with our own implementation here
-#
-# TODO: this still only handles a single value, fix and test multiple
-class Select(paste.fixture.Field):
-    def __init__(self, *args, **attrs):
-        super(Select, self).__init__(*args, **attrs)
-        self.options = []
-        self.selectedIndex = None
-
-    def value__set(self, value):
-        if not value:
-            self.selectedIndex = None
-            self.options = [(option, False) for (option, checked) in self.options]
-            return
-
-        for i, (option, checked) in enumerate(self.options):
-            if option == str(value):
-                self.selectedIndex = i
-                break
-        else:
-            raise ValueError(
-                "Option %r not found (from %s)"
-                % (value, ', '.join(
-                [repr(o) for o, c in self.options])))
-
-    def value__get(self):
-        if self.selectedIndex is not None:
-            return self.options[self.selectedIndex][0]
-        else:
-            for option, checked in self.options:
-                if checked:
-                    return option
-            return None
-
-    value = property(value__get, value__set)
-
-paste.fixture.Field.classes['select'] = Select
-
-
-class TestWUI(WsgiAppCase):
-    @classmethod
-    def setup_class(cls):
-        CreateTestData.create()
-        cls.sysadmin_user = model.User.get('testsysadmin')
-        cls.dset = model.Package.get('warandpeace')
-        cls.tag1_name = 'vocab-tag-1'
-        cls.tag2_name = 'vocab-tag-2'
-
-        cls.plugin = MockVocabTagsPlugin()
-        plugins.load(cls.plugin)
-
-        # this is a hack so that the plugin is properly registered with
-        # the package controller class.
-        from ckan.controllers import package as package_controller
-        package_controller._default_controller_behaviour = cls.plugin
-
-        # create a test vocab
-        params = json.dumps({'name': TEST_VOCAB_NAME})
-        extra_environ = {'Authorization' : str(cls.sysadmin_user.apikey)}
-        response = cls.app.post('/api/action/vocabulary_create', params=params,
-                                extra_environ=extra_environ)
-        assert json.loads(response.body)['success']
-        vocab_id = json.loads(response.body)['result']['id']
-
-        # add tags to the vocab
-        extra_environ = {'Authorization' : str(cls.sysadmin_user.apikey)}
-        params = json.dumps({'name': cls.tag1_name, 'vocabulary_id': vocab_id})
-        response = cls.app.post('/api/action/tag_create', params=params,
-                                 extra_environ=extra_environ)
-        assert json.loads(response.body)['success']
-        params = json.dumps({'name': cls.tag2_name, 'vocabulary_id': vocab_id})
-        response = cls.app.post('/api/action/tag_create', params=params,
-                                 extra_environ=extra_environ)
-        assert json.loads(response.body)['success']
-
-    @classmethod
-    def teardown_class(cls):
-        plugins.unload(cls.plugin)
-        model.repo.rebuild_db()
-
-    def _get_vocab_id(self, vocab_name):
-        params = json.dumps({'name': vocab_name})
-        response = self.app.post('/api/action/vocabulary_show', params=params)
-        assert json.loads(response.body)['success']
-        return json.loads(response.body)['result']['id']
-
-    def _add_vocab_tag_to_dataset(self, dataset_id, vocab_id, tag_name):
-        params = json.dumps({'id': dataset_id})
-        response = self.app.post('/api/action/package_show', params=params)
-        dataset = json.loads(response.body)['result']
-        dataset['tags'].append({'name': tag_name, 'vocabulary_id': vocab_id})
-        params = json.dumps(dataset)
-        response = self.app.post('/api/action/package_update', params=params,
-                                 extra_environ={'Authorization': str(self.sysadmin_user.apikey)})
-        assert json.loads(response.body)['success']
-
-    def _remove_vocab_tags(self, dataset_id, vocab_id, tag_name):
-        params = json.dumps({'id': dataset_id})
-        response = self.app.post('/api/action/package_show', params=params)
-        dataset = json.loads(response.body)['result']
-        dataset['tags'] = [t for t in dataset['tags'] if not t['name'] == tag_name]
-        params = json.dumps(dataset)
-        response = self.app.post('/api/action/package_update', params=params,
-                                 extra_environ={'Authorization': str(self.sysadmin_user.apikey)})
-        assert json.loads(response.body)['success']
-
-    def test_01_dataset_view(self):
-        vocab_id = self._get_vocab_id(TEST_VOCAB_NAME)
-        self._add_vocab_tag_to_dataset(self.dset.id, vocab_id, self.tag1_name)
-        response = self.app.get(h.url_for(controller='package', action='read', id=self.dset.id))
-        assert self.tag1_name in response.body
-        self._remove_vocab_tags(self.dset.id, vocab_id, self.tag1_name)
-
-    def test_02_dataset_edit_add_vocab_tag(self):
-        vocab_id = self._get_vocab_id(TEST_VOCAB_NAME)
-        url = h.url_for(controller='package', action='edit', id=self.dset.id)
-        response = self.app.get(url)
-        fv = response.forms['dataset-edit']
-        fv['vocab_tags'] = self.tag2_name
-        response = fv.submit('save')
-        response = response.follow()
-        assert not self.tag1_name in response.body
-        assert self.tag2_name in response.body
-        self._remove_vocab_tags(self.dset.id, vocab_id, self.tag1_name)
-        self._remove_vocab_tags(self.dset.id, vocab_id, self.tag2_name)
-
-    def test_03_dataset_edit_remove_vocab_tag(self):
-        vocab_id = self._get_vocab_id(TEST_VOCAB_NAME)
-        self._add_vocab_tag_to_dataset(self.dset.id, vocab_id, self.tag1_name)
-        url = h.url_for(controller='package', action='edit', id=self.dset.id)
-        response = self.app.get(url)
-        fv = response.forms['dataset-edit']
-        fv['vocab_tags'] = ''
-        response = fv.submit('save')
-        response = response.follow()
-        assert not self.tag1_name in response.body
-        self._remove_vocab_tags(self.dset.id, vocab_id, self.tag1_name)
-
-    def test_04_dataset_edit_change_vocab_tag(self):
-        vocab_id = self._get_vocab_id(TEST_VOCAB_NAME)
-        self._add_vocab_tag_to_dataset(self.dset.id, vocab_id, self.tag1_name)
-        url = h.url_for(controller='package', action='edit', id=self.dset.id)
-        response = self.app.get(url)
-        fv = response.forms['dataset-edit']
-        fv['vocab_tags'] = self.tag2_name
-        response = fv.submit('save')
-        response = response.follow()
-        assert not self.tag1_name in response.body
-        assert self.tag2_name in response.body
-        self._remove_vocab_tags(self.dset.id, vocab_id, self.tag2_name)
-

From f6def610df457620ad06530b2a3be7d26141415c Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Wed, 15 Feb 2012 13:53:30 +0100
Subject: [PATCH 55/72] [#1776] Fix tag_delete() arguments

Accept an 'id' key  that can be either the tag id or the tag name, and a
'vocabulary_id' that can be the vocab id or the vocab name.

Update the tests.
---
 ckan/logic/action/delete.py                   |  15 +-
 .../functional/api/model/test_vocabulary.py   | 155 ++++++++++--------
 2 files changed, 93 insertions(+), 77 deletions(-)

diff --git a/ckan/logic/action/delete.py b/ckan/logic/action/delete.py
index 0b26c15b79a..ed5f338c8dd 100644
--- a/ckan/logic/action/delete.py
+++ b/ckan/logic/action/delete.py
@@ -119,16 +119,17 @@ def vocabulary_delete(context, data_dict):
 
 def tag_delete(context, data_dict):
     model = context['model']
-    user = context['user']
 
-    if not data_dict.has_key('tag_name'):
-        raise ParameterError(_("Missing 'tag_name' parameter."))
+    if not data_dict.has_key('id') or not data_dict['id']:
+        raise ParameterError(_("Missing 'id' parameter."))
+    tag_id_or_name = data_dict['id']
 
-    if not data_dict.has_key('vocabulary_name'):
-        raise ParameterError(_("Missing 'vocabulary_name' parameter."))
+    if (not data_dict.has_key('vocabulary_id') or not
+            data_dict['vocabulary_id']):
+        raise ParameterError(_("Missing 'vocabulary_id' parameter."))
+    vocab_id_or_name = data_dict['vocabulary_id']
 
-    tag_obj = model.tag.Tag.get(data_dict['tag_name'],
-            data_dict['vocabulary_name'])
+    tag_obj = model.tag.Tag.get(tag_id_or_name, vocab_id_or_name)
 
     if tag_obj is None:
         raise NotFound
diff --git a/ckan/tests/functional/api/model/test_vocabulary.py b/ckan/tests/functional/api/model/test_vocabulary.py
index 8c6c293daef..5b8e5cbaaa7 100644
--- a/ckan/tests/functional/api/model/test_vocabulary.py
+++ b/ckan/tests/functional/api/model/test_vocabulary.py
@@ -165,9 +165,8 @@ def _create_tag(self, user, tag_name, vocabulary=None):
         assert response['success'] == True
         return response['result']
 
-    def _delete_tag(self, user, tag, vocabulary):
-        params = {'tag_name': tag['name'],
-                'vocabulary_name': vocabulary['name']}
+    def _delete_tag(self, user, tag_id_or_name, vocab_id_or_name):
+        params = {'id': tag_id_or_name, 'vocabulary_id': vocab_id_or_name}
         if user:
             extra_environ = {'Authorization' : str(user.apikey)}
         else:
@@ -538,69 +537,82 @@ def test_delete_tag_from_vocab(self):
 
         vocab = self.genre_vocab
 
-        # First add a tag to the vocab.
-        tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
+        # First add some tags to the vocab.
+        noise_tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
+        ragga_tag = self._create_tag(self.sysadmin_user, 'ragga', vocab)
+        grunge_tag = self._create_tag(self.sysadmin_user, 'grunge', vocab)
+        funk_tag = self._create_tag(self.sysadmin_user, 'funk', vocab)
+        tags = (noise_tag, ragga_tag, grunge_tag, funk_tag)
 
         # Get a package from the API.
         package = (self._post('/api/action/package_show',
             {'id': self._post('/api/action/package_list')['result'][0]})
             ['result'])
 
-        # Add the new vocab tag to the package.
-        package['tags'].append(tag)
+        # Add the new vocab tags to the package.
+        for tag in tags:
+            package['tags'].append(tag)
         updated_package = (self._post('/api/action/package_update',
                 params={'id': package['id'], 'tags': package['tags']},
                 extra_environ={'Authorization': str(self.sysadmin_user.apikey)})
                 ['result'])
 
-        # Test that the new vocab tag was added to the package.
-        tags_in_pkg = [tag_in_pkg for tag_in_pkg in updated_package['tags'] if
-                tag_in_pkg['name'] == tag['name'] and
-                tag_in_pkg['vocabulary_id'] == tag['vocabulary_id']]
-        assert len(tags_in_pkg) == 1
+        # Test that the new vocab tags were added to the package.
+        for tag in tags:
+            tags_in_pkg = [tag_in_pkg for tag_in_pkg in
+                    updated_package['tags'] if tag_in_pkg['name'] ==
+                    tag['name'] and tag_in_pkg['vocabulary_id'] ==
+                    tag['vocabulary_id']]
+            assert len(tags_in_pkg) == 1
 
-        # Now delete the tag from the vocab.
+        # Now delete the tags from the vocab.
         tags_before = self._list_tags(vocab)
-        self._delete_tag(self.sysadmin_user, tag, vocab)
+        self._delete_tag(self.sysadmin_user, noise_tag['name'], vocab['name'])
+        self._delete_tag(self.sysadmin_user, ragga_tag['id'], vocab['name'])
+        self._delete_tag(self.sysadmin_user, grunge_tag['id'], vocab['id'])
+        self._delete_tag(self.sysadmin_user, funk_tag['name'], vocab['id'])
 
-        # Test that the tag no longer appears in the list of tags for the
+        # Test that the tags no longer appear in the list of tags for the
         # vocab.
         tags_after = self._list_tags(vocab)
-        assert len(tags_after) == len(tags_before) - 1
+        assert len(tags_after) == len(tags_before) - 4
         assert tag['name'] not in tags_after
         difference = [tag_name for tag_name in tags_before if tag_name not in
                 tags_after]
-        assert len(difference) == 1
-        assert tag['name'] in difference
+        assert sorted(difference) == sorted([tag['name'] for tag in tags])
 
-        # Test that the tag no longer appears in the list of tags for the
+        # Test that the tags no longer appear in the list of tags for the
         # package.
         package = (self._post('/api/action/package_show',
             {'id': self._post('/api/action/package_list')['result'][0]})
             ['result'])
-        tags_in_pkg = [tag_in_pkg for tag_in_pkg in package['tags'] if
-                tag_in_pkg['name'] == tag['name'] and
-                tag_in_pkg['vocabulary_id'] == tag['vocabulary_id']]
-        assert len(tags_in_pkg) == 0
+        for tag in tags:
+            tags_in_pkg = [tag_in_pkg for tag_in_pkg in package['tags'] if
+                    tag_in_pkg['name'] == tag['name'] and
+                    tag_in_pkg['vocabulary_id'] == tag['vocabulary_id']]
+            assert len(tags_in_pkg) == 0
 
-    def test_delete_tag_no_name(self):
+    def test_delete_tag_no_id(self):
         '''Test the error response when a user tries to delete a tag without
-        giving the tag name.
+        giving the tag id.
 
         '''
         vocab = self.genre_vocab
         tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
 
-        # Now try to delete the tag from the vocab.
-        params = {'vocab_name': vocab['name']}
-        response = self.app.post('/api/action/tag_delete',
-                params=json.dumps(params),
-                extra_environ = {'Authorization':
-                    str(self.sysadmin_user.apikey)},
-                status=409)
-        assert response.json['success'] == False
-        assert (response.json['error']['message'] ==
-                u"Parameter Error: Missing 'tag_name' parameter.")
+        for tag_id in ('missing', '', None):
+            # Now try to delete the tag from the vocab.
+            params = {'vocabulary_id': vocab['name']}
+            if tag_id != 'missing':
+                params['id'] = tag_id
+            response = self.app.post('/api/action/tag_delete',
+                    params=json.dumps(params),
+                    extra_environ = {'Authorization':
+                        str(self.sysadmin_user.apikey)},
+                    status=409)
+            assert response.json['success'] == False
+            msg = response.json['error']['message']
+            assert msg == u"Parameter Error: Missing 'id' parameter.", msg
 
     def test_delete_tag_no_vocab(self):
         '''Test the error response when a user tries to delete a tag without
@@ -611,15 +623,19 @@ def test_delete_tag_no_vocab(self):
         tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
 
         # Now try to delete the tag from the vocab.
-        params = {'tag_name': tag['name']}
-        response = self.app.post('/api/action/tag_delete',
-                params=json.dumps(params),
-                extra_environ = {'Authorization':
-                    str(self.sysadmin_user.apikey)},
-                status=409)
-        assert response.json['success'] == False
-        assert (response.json['error']['message'] ==
-                u"Parameter Error: Missing 'vocabulary_name' parameter.")
+        for vocab_name in ('', None, 'missing'):
+            params = {'id': tag['name']}
+            if vocab_name != 'missing':
+                params['vocabulary_id'] = vocab_name
+            response = self.app.post('/api/action/tag_delete',
+                    params=json.dumps(params),
+                    extra_environ = {'Authorization':
+                        str(self.sysadmin_user.apikey)},
+                    status=409)
+            assert response.json['success'] == False
+            msg = response.json['error']['message']
+            assert msg == \
+                    u"Parameter Error: Missing 'vocabulary_id' parameter.", msg
 
     def test_delete_tag_not_exists(self):
         '''Test the error response when a user tries to delete a from a vocab
@@ -629,16 +645,16 @@ def test_delete_tag_not_exists(self):
         vocab = self.genre_vocab
         tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
 
-        params = {'tag_name': 'nonexistent',
-                'vocabulary_name': self.genre_vocab['name']}
+        params = {'id': 'nonexistent',
+                'vocabulary_id': self.genre_vocab['name']}
         response = self.app.post('/api/action/tag_delete',
                 params=json.dumps(params),
                 extra_environ = {'Authorization':
                     str(self.sysadmin_user.apikey)},
                 status=404)
         assert response.json['success'] == False
-        assert (response.json['error']['message'] ==
-                u"Not found")
+        msg = response.json['error']['message']
+        assert msg == u"Not found", msg
 
     def test_delete_tag_vocab_not_exists(self):
         '''Test the error response when a user tries to delete a from a vocab
@@ -648,16 +664,16 @@ def test_delete_tag_vocab_not_exists(self):
         vocab = self.genre_vocab
         tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
 
-        params = {'tag_name': tag['name'],
-                'vocabulary_name': 'nonexistent'}
+        params = {'id': tag['name'],
+                'vocabulary_id': 'nonexistent'}
         response = self.app.post('/api/action/tag_delete',
                 params=json.dumps(params),
                 extra_environ = {'Authorization':
                     str(self.sysadmin_user.apikey)},
                 status=404)
         assert response.json['success'] == False
-        assert (response.json['error']['message'] ==
-                u"Not found")
+        msg = response.json['error']['message']
+        assert msg == u"Not found", msg
 
     def test_delete_tag_invalid_tag(self):
         '''Test the error response when a user tries to delete a tag but gives
@@ -667,17 +683,17 @@ def test_delete_tag_invalid_tag(self):
         vocab = self.genre_vocab
         tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
 
-        for tag_name in ('Invalid!', '', None):
-            params = {'tag_name': tag_name,
-                    'vocabulary_name': self.genre_vocab['name']}
+        for tag_name in ('Invalid!', ' '):
+            params = {'id': tag_name,
+                    'vocabulary_id': self.genre_vocab['name']}
             response = self.app.post('/api/action/tag_delete',
                     params=json.dumps(params),
                     extra_environ = {'Authorization':
                         str(self.sysadmin_user.apikey)},
                     status=404)
             assert response.json['success'] == False
-            assert (response.json['error']['message'] ==
-                    u"Not found")
+            msg = response.json['error']['message']
+            assert msg == u"Not found", msg
 
     def test_delete_tag_invalid_vocab(self):
         '''Test the error response when a user tries to delete a tag but gives
@@ -687,42 +703,41 @@ def test_delete_tag_invalid_vocab(self):
         vocab = self.genre_vocab
         tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
 
-        for vocab_name in ('Invalid!', '', None):
-            params = {'tag_name': tag['name'],
-                    'vocabulary_name': vocab_name}
+        for vocab_name in ('Invalid!', ' '):
+            params = {'id': tag['name'], 'vocabulary_id': vocab_name}
             response = self.app.post('/api/action/tag_delete',
                     params=json.dumps(params),
                     extra_environ = {'Authorization':
                         str(self.sysadmin_user.apikey)},
                     status=404)
             assert response.json['success'] == False
-            assert (response.json['error']['message'] ==
-                    u"Not found")
+            msg = response.json['error']['message']
+            assert msg == u"Not found", msg
 
     def test_delete_tag_not_logged_in(self):
         vocab = self.genre_vocab
         tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
 
-        params = {'tag_name': tag['name'],
-                'vocabulary_name': self.genre_vocab['name']}
+        params = {'id': tag['name'],
+                'vocabulary_id': self.genre_vocab['name']}
         response = self.app.post('/api/action/tag_delete',
                 params=json.dumps(params),
                 status=403)
         assert response.json['success'] == False
-        assert (response.json['error']['message'] ==
-                u"Access denied")
+        msg = response.json['error']['message']
+        assert msg == u"Access denied", msg
 
     def test_delete_tag_not_authorized(self):
         vocab = self.genre_vocab
         tag = self._create_tag(self.sysadmin_user, 'noise', vocab)
 
-        params = {'tag_name': tag['name'],
-                'vocabulary_name': self.genre_vocab['name']}
+        params = {'id': tag['name'],
+                'vocabulary_id': self.genre_vocab['name']}
         response = self.app.post('/api/action/tag_delete',
                 params=json.dumps(params),
                 extra_environ = {'Authorization':
                     str(self.normal_user.apikey)},
                 status=403)
         assert response.json['success'] == False
-        assert (response.json['error']['message'] ==
-                u"Access denied")
+        msg = response.json['error']['message']
+        assert msg == u"Access denied"

From 0446c0c5e21944df9aa2d68c22edbe989e6c4d0a Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Wed, 15 Feb 2012 13:06:16 +0000
Subject: [PATCH 56/72] [1767][tests] Update tag vocab WUI tests - handle
 multiple values from select object. Add test for adding multiple tags.

---
 ckan/tests/functional/test_tag_vocab.py | 84 ++++++++++++++++++-------
 1 file changed, 61 insertions(+), 23 deletions(-)

diff --git a/ckan/tests/functional/test_tag_vocab.py b/ckan/tests/functional/test_tag_vocab.py
index f059eee72e3..a7f23a6e530 100644
--- a/ckan/tests/functional/test_tag_vocab.py
+++ b/ckan/tests/functional/test_tag_vocab.py
@@ -74,12 +74,38 @@ def filter(self, stream):
 
 
 # paste.fixture.Field.Select does not handle multiple selects currently,
-# so replace with our own implementation here
-#
-# TODO: this still only handles a single value, fix and test multiple
+# so replace with our own implementations of Form and Select
+class Form(paste.fixture.Form):
+    def __init__(self, response, text):
+        paste.fixture.Form.__init__(self, response, text)
+
+    def submit_fields(self, name=None, index=None):
+        """
+        Return a list of ``[(name, value), ...]`` for the current
+        state of the form.
+        """
+        submit = []
+        if name is not None:
+            field = self.get(name, index=index)
+            submit.append((field.name, field.value_if_submitted()))
+        for name, fields in self.fields.items():
+            if name is None:
+                continue
+            for field in fields:
+                value = field.value
+                if value is None:
+                    continue
+                if isinstance(value, list):
+                    for v in value:
+                        submit.append((name, v))
+                else:
+                    submit.append((name, value))
+        return submit
+
+
 class Select(paste.fixture.Field):
     def __init__(self, *args, **attrs):
-        super(Select, self).__init__(*args, **attrs)
+        paste.fixture.Field.__init__(self, *args, **attrs)
         self.options = []
         self.selectedIndex = None
 
@@ -89,24 +115,19 @@ def value__set(self, value):
             self.options = [(option, False) for (option, checked) in self.options]
             return
 
-        for i, (option, checked) in enumerate(self.options):
-            if option == str(value):
-                self.selectedIndex = i
-                break
-        else:
-            raise ValueError(
-                "Option %r not found (from %s)"
-                % (value, ', '.join(
-                [repr(o) for o, c in self.options])))
+        for v in value:
+            if not v in [option for (option, checked) in self.options]:
+                raise ValueError("Option %r not found (from %s)"
+                    % (value, ', '.join(
+                    [repr(o) for o, c in self.options]))
+                )
+
+        new_options = [(option, True) for (option, checked) in self.options if option in value]
+        new_options += [(option, False) for (option, checked) in self.options if not option in value]
+        self.options = new_options
 
     def value__get(self):
-        if self.selectedIndex is not None:
-            return self.options[self.selectedIndex][0]
-        else:
-            for option, checked in self.options:
-                if checked:
-                    return option
-            return None
+        return [option for (option, checked) in self.options if checked]
 
     value = property(value__get, value__set)
 
@@ -192,7 +213,8 @@ def test_02_dataset_edit_add_vocab_tag(self):
         url = h.url_for(controller='package', action='edit', id=self.dset.id)
         response = self.app.get(url)
         fv = response.forms['dataset-edit']
-        fv['vocab_tags'] = self.tag2_name
+        fv = Form(fv.response, fv.text)
+        fv['vocab_tags'] = [self.tag2_name]
         response = fv.submit('save')
         response = response.follow()
         assert not self.tag1_name in response.body
@@ -206,7 +228,8 @@ def test_03_dataset_edit_remove_vocab_tag(self):
         url = h.url_for(controller='package', action='edit', id=self.dset.id)
         response = self.app.get(url)
         fv = response.forms['dataset-edit']
-        fv['vocab_tags'] = ''
+        fv = Form(fv.response, fv.text)
+        fv['vocab_tags'] = []
         response = fv.submit('save')
         response = response.follow()
         assert not self.tag1_name in response.body
@@ -218,10 +241,25 @@ def test_04_dataset_edit_change_vocab_tag(self):
         url = h.url_for(controller='package', action='edit', id=self.dset.id)
         response = self.app.get(url)
         fv = response.forms['dataset-edit']
-        fv['vocab_tags'] = self.tag2_name
+        fv = Form(fv.response, fv.text)
+        fv['vocab_tags'] = [self.tag2_name]
         response = fv.submit('save')
         response = response.follow()
         assert not self.tag1_name in response.body
         assert self.tag2_name in response.body
         self._remove_vocab_tags(self.dset.id, vocab_id, self.tag2_name)
 
+    def test_05_dataset_edit_add_multiple_vocab_tags(self):
+        vocab_id = self._get_vocab_id(TEST_VOCAB_NAME)
+        url = h.url_for(controller='package', action='edit', id=self.dset.id)
+        response = self.app.get(url)
+        fv = response.forms['dataset-edit']
+        fv = Form(fv.response, fv.text)
+        fv['vocab_tags'] = [self.tag1_name, self.tag2_name]
+        response = fv.submit('save')
+        response = response.follow()
+        assert self.tag1_name in response.body
+        assert self.tag2_name in response.body
+        self._remove_vocab_tags(self.dset.id, vocab_id, self.tag1_name)
+        self._remove_vocab_tags(self.dset.id, vocab_id, self.tag2_name)
+

From 40d3f5a0363658e48b74a43bb693f285082de973 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Wed, 15 Feb 2012 15:05:51 +0100
Subject: [PATCH 57/72] [#1776] Allow deleting free tags via tag_delete()

---
 ckan/logic/action/delete.py                   |  5 +-
 .../functional/api/model/test_vocabulary.py   | 65 +++++++++++++++++--
 2 files changed, 59 insertions(+), 11 deletions(-)

diff --git a/ckan/logic/action/delete.py b/ckan/logic/action/delete.py
index ed5f338c8dd..d3e15ec3139 100644
--- a/ckan/logic/action/delete.py
+++ b/ckan/logic/action/delete.py
@@ -124,10 +124,7 @@ def tag_delete(context, data_dict):
         raise ParameterError(_("Missing 'id' parameter."))
     tag_id_or_name = data_dict['id']
 
-    if (not data_dict.has_key('vocabulary_id') or not
-            data_dict['vocabulary_id']):
-        raise ParameterError(_("Missing 'vocabulary_id' parameter."))
-    vocab_id_or_name = data_dict['vocabulary_id']
+    vocab_id_or_name = data_dict.get('vocabulary_id')
 
     tag_obj = model.tag.Tag.get(tag_id_or_name, vocab_id_or_name)
 
diff --git a/ckan/tests/functional/api/model/test_vocabulary.py b/ckan/tests/functional/api/model/test_vocabulary.py
index 5b8e5cbaaa7..7814815e141 100644
--- a/ckan/tests/functional/api/model/test_vocabulary.py
+++ b/ckan/tests/functional/api/model/test_vocabulary.py
@@ -165,8 +165,10 @@ def _create_tag(self, user, tag_name, vocabulary=None):
         assert response['success'] == True
         return response['result']
 
-    def _delete_tag(self, user, tag_id_or_name, vocab_id_or_name):
-        params = {'id': tag_id_or_name, 'vocabulary_id': vocab_id_or_name}
+    def _delete_tag(self, user, tag_id_or_name, vocab_id_or_name=None):
+        params = {'id': tag_id_or_name}
+        if vocab_id_or_name:
+            params['vocabulary_id'] = vocab_id_or_name
         if user:
             extra_environ = {'Authorization' : str(user.apikey)}
         else:
@@ -592,6 +594,56 @@ def test_delete_tag_from_vocab(self):
                     tag_in_pkg['vocabulary_id'] == tag['vocabulary_id']]
             assert len(tags_in_pkg) == 0
 
+    def test_delete_free_tag(self):
+        '''Test that a free tag can be deleted via the API, and is
+        automatically removed from datasets.
+
+        '''
+        # Get a package from the API.
+        package = (self._post('/api/action/package_show',
+            {'id': self._post('/api/action/package_list')['result'][0]})
+            ['result'])
+        package_id = package['id']
+
+        # Add some new free tags to the package.
+        tags = package['tags']
+        tags.append({'name': 'ducks'})
+        tags.append({'name': 'birds'})
+        self._post('/api/action/package_update',
+                params={'id': package['id'], 'tags': tags},
+                extra_environ={'Authorization':
+                    str(self.sysadmin_user.apikey)})
+
+        # Test that the new tags appear in the list of tags.
+        tags = self._list_tags()
+        assert [tag for tag in tags].count('ducks') == 1
+        assert [tag for tag in tags].count('birds') == 1
+
+        # Test that the new tags appear in the package's list of tags.
+        package = (self._post('/api/action/package_show',
+            {'id': package_id})['result'])
+        packages_tags = [tag['name'] for tag in package['tags']]
+        assert [tag for tag in packages_tags].count('ducks') == 1
+        assert [tag for tag in packages_tags].count('birds') == 1
+
+        # Now delete the tags.
+        self._delete_tag(self.sysadmin_user, 'ducks')
+        birds_tag_id = self._post('/api/action/tag_show',
+                {'id': 'birds'})['result']['id']
+        self._delete_tag(self.sysadmin_user, birds_tag_id)
+
+        # Test that the tags no longer appear in the list of tags.
+        tags = self._list_tags()
+        assert [tag for tag in tags].count('ducks') == 0
+        assert [tag for tag in tags].count('birds') == 0
+
+        # Test that the tags no longer appear in the package's list of tags.
+        package = (self._post('/api/action/package_show',
+            {'id': package_id})['result'])
+        packages_tags = [tag['name'] for tag in package['tags']]
+        assert [tag for tag in packages_tags].count('ducks') == 0
+        assert [tag for tag in packages_tags].count('birds') == 0
+
     def test_delete_tag_no_id(self):
         '''Test the error response when a user tries to delete a tag without
         giving the tag id.
@@ -615,8 +667,8 @@ def test_delete_tag_no_id(self):
             assert msg == u"Parameter Error: Missing 'id' parameter.", msg
 
     def test_delete_tag_no_vocab(self):
-        '''Test the error response when a user tries to delete a tag without
-        giving the vocab name.
+        '''Test the error response when a user tries to delete a vocab tag
+        without giving the vocab name.
 
         '''
         vocab = self.genre_vocab
@@ -631,11 +683,10 @@ def test_delete_tag_no_vocab(self):
                     params=json.dumps(params),
                     extra_environ = {'Authorization':
                         str(self.sysadmin_user.apikey)},
-                    status=409)
+                    status=404)
             assert response.json['success'] == False
             msg = response.json['error']['message']
-            assert msg == \
-                    u"Parameter Error: Missing 'vocabulary_id' parameter.", msg
+            assert msg == u"Not found", msg
 
     def test_delete_tag_not_exists(self):
         '''Test the error response when a user tries to delete a from a vocab

From d4c5870a96ff326f4e8798229e4fe203a069e2d9 Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Wed, 15 Feb 2012 14:07:30 +0000
Subject: [PATCH 58/72] [1767][tests] quick fix for problem that
 plugins.unload() does not remove a plugin from the
 plugins.PluginImplementations(IDatasetForm) list.

---
 ckan/tests/functional/test_tag_vocab.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/ckan/tests/functional/test_tag_vocab.py b/ckan/tests/functional/test_tag_vocab.py
index a7f23a6e530..4423676f804 100644
--- a/ckan/tests/functional/test_tag_vocab.py
+++ b/ckan/tests/functional/test_tag_vocab.py
@@ -20,7 +20,7 @@ class MockVocabTagsPlugin(plugins.SingletonPlugin):
     plugins.implements(plugins.IGenshiStreamFilter)
 
     def is_fallback(self):
-        return True
+        return False
 
     def package_types(self):
         return ["mock_vocab_tags_plugin"]
@@ -149,6 +149,7 @@ def setup_class(cls):
         # this is a hack so that the plugin is properly registered with
         # the package controller class.
         from ckan.controllers import package as package_controller
+        cls.old_default_controller = package_controller._default_controller_behaviour
         package_controller._default_controller_behaviour = cls.plugin
 
         # create a test vocab
@@ -174,6 +175,8 @@ def setup_class(cls):
     def teardown_class(cls):
         plugins.unload(cls.plugin)
         model.repo.rebuild_db()
+        from ckan.controllers import package as package_controller
+        package_controller._default_controller_behaviour = cls.old_default_controller
 
     def _get_vocab_id(self, vocab_name):
         params = json.dumps({'name': vocab_name})

From 66993a277fcc2876be82f91cee81b382801373fc Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Wed, 15 Feb 2012 14:13:57 +0000
Subject: [PATCH 59/72] [1767][tests] bug fix: only use custom select class for
 TestWUI

---
 ckan/tests/functional/test_tag_vocab.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/ckan/tests/functional/test_tag_vocab.py b/ckan/tests/functional/test_tag_vocab.py
index 4423676f804..ddef22b0692 100644
--- a/ckan/tests/functional/test_tag_vocab.py
+++ b/ckan/tests/functional/test_tag_vocab.py
@@ -131,7 +131,6 @@ def value__get(self):
 
     value = property(value__get, value__set)
 
-paste.fixture.Field.classes['select'] = Select
 
 
 class TestWUI(WsgiAppCase):
@@ -152,6 +151,10 @@ def setup_class(cls):
         cls.old_default_controller = package_controller._default_controller_behaviour
         package_controller._default_controller_behaviour = cls.plugin
 
+        # use our custom select class for this test suite
+        cls.old_select = paste.fixture.Field.classes['select']
+        paste.fixture.Field.classes['select'] = Select
+
         # create a test vocab
         params = json.dumps({'name': TEST_VOCAB_NAME})
         extra_environ = {'Authorization' : str(cls.sysadmin_user.apikey)}
@@ -174,9 +177,10 @@ def setup_class(cls):
     @classmethod
     def teardown_class(cls):
         plugins.unload(cls.plugin)
-        model.repo.rebuild_db()
         from ckan.controllers import package as package_controller
         package_controller._default_controller_behaviour = cls.old_default_controller
+        paste.fixture.Field.classes['select'] = cls.old_select
+        model.repo.rebuild_db()
 
     def _get_vocab_id(self, vocab_name):
         params = json.dumps({'name': vocab_name})

From 3c5e5a268ac5dc69dfe00dcb034e7d456062ddd6 Mon Sep 17 00:00:00 2001
From: John Glover <j@johnglover.net>
Date: Wed, 15 Feb 2012 16:31:26 +0000
Subject: [PATCH 60/72] [1767][controllers][tests] fix issues with tag vocab
 test mock plugin interfering with other tests

update package controller register pluggable behaviour function to clear controller behaviour list and default behaviour at the start of each run
---
 ckan/controllers/package.py             | 10 +----
 ckan/tests/functional/test_tag_vocab.py | 50 +++++++++++++------------
 2 files changed, 29 insertions(+), 31 deletions(-)

diff --git a/ckan/controllers/package.py b/ckan/controllers/package.py
index 89f7beb10c6..c647d4080b0 100644
--- a/ckan/controllers/package.py
+++ b/ckan/controllers/package.py
@@ -66,14 +66,9 @@ def register_pluggable_behaviour(map):
     exception will be raised.
     """
     global _default_controller_behaviour
+    _default_controller_behaviour = None
+    _controller_behaviour_for.clear()
     
-    # Check this method hasn't been invoked already.
-    # TODO: This method seems to be being invoked more than once during running of
-    #       the tests.  So I've disbabled this check until I figure out why.
-    #if _default_controller_behaviour is not None:
-        #raise ValueError, "Pluggable package controller behaviour is already defined "\
-                          #"'%s'" % _default_controller_behaviour
-
     # Create the mappings and register the fallback behaviour if one is found.
     for plugin in PluginImplementations(IDatasetForm):
         if plugin.is_fallback():
@@ -84,7 +79,6 @@ def register_pluggable_behaviour(map):
 
         for package_type in plugin.package_types():
             # Create a connection between the newly named type and the package controller
-            # but first we need to make sure we are not clobbering an existing domain
             map.connect('/%s/new' % (package_type,), controller='package', action='new')    
             map.connect('%s_read' % (package_type,), '/%s/{id}' %  (package_type,), controller='package', action='read')                        
             map.connect('%s_action' % (package_type,),
diff --git a/ckan/tests/functional/test_tag_vocab.py b/ckan/tests/functional/test_tag_vocab.py
index ddef22b0692..b2c05577186 100644
--- a/ckan/tests/functional/test_tag_vocab.py
+++ b/ckan/tests/functional/test_tag_vocab.py
@@ -19,6 +19,8 @@ class MockVocabTagsPlugin(plugins.SingletonPlugin):
     plugins.implements(plugins.IDatasetForm, inherit=True)
     plugins.implements(plugins.IGenshiStreamFilter)
 
+    active = False
+
     def is_fallback(self):
         return False
 
@@ -49,27 +51,28 @@ def db_to_form_schema(self):
         return schema
 
     def filter(self, stream):
-        routes = request.environ.get('pylons.routes_dict')
-        if routes.get('controller') == 'package' \
-            and routes.get('action') == 'read':
-                # add vocab tags to the bottom of the page
-                tags = c.pkg_dict.get('tags', [])
-                for tag in tags:
-                    if tag.get('vocabulary_id'):
-                        stream = stream | Transformer('body')\
-                            .append(HTML('<p>%s</p>' % tag.get('name')))
-        if routes.get('controller') == 'package' \
-            and routes.get('action') == 'edit':
-                # add vocabs tag select box to edit page
-                html = '<select id="vocab_tags" name="vocab_tags" size="60" multiple="multiple">'
-                selected_tags = c.pkg_dict.get('vocab_tags_selected', [])
-                for tag in c.vocab_tags:
-                    if tag in selected_tags:
-                        html += '<option selected="selected" value="%s">%s</option>' % (tag, tag)
-                    else:
-                        html += '<option value="%s">%s</option>' % (tag, tag)
-                html += '</select>'
-                stream = stream | Transformer('fieldset[@id="groups"]').append(HTML(html))
+        if self.active:
+            routes = request.environ.get('pylons.routes_dict')
+            if routes.get('controller') == 'package' \
+                and routes.get('action') == 'read':
+                    # add vocab tags to the bottom of the page
+                    tags = c.pkg_dict.get('tags', [])
+                    for tag in tags:
+                        if tag.get('vocabulary_id'):
+                            stream = stream | Transformer('body')\
+                                .append(HTML('<p>%s</p>' % tag.get('name')))
+            if routes.get('controller') == 'package' \
+                and routes.get('action') == 'edit':
+                    # add vocabs tag select box to edit page
+                    html = '<select id="vocab_tags" name="vocab_tags" size="60" multiple="multiple">'
+                    selected_tags = c.pkg_dict.get('vocab_tags_selected', [])
+                    for tag in c.vocab_tags:
+                        if tag in selected_tags:
+                            html += '<option selected="selected" value="%s">%s</option>' % (tag, tag)
+                        else:
+                            html += '<option value="%s">%s</option>' % (tag, tag)
+                    html += '</select>'
+                    stream = stream | Transformer('fieldset[@id="groups"]').append(HTML(html))
         return stream
 
 
@@ -119,7 +122,7 @@ def value__set(self, value):
             if not v in [option for (option, checked) in self.options]:
                 raise ValueError("Option %r not found (from %s)"
                     % (value, ', '.join(
-                    [repr(o) for o, c in self.options]))
+                    [repr(o) for o, checked in self.options]))
                 )
 
         new_options = [(option, True) for (option, checked) in self.options if option in value]
@@ -132,7 +135,6 @@ def value__get(self):
     value = property(value__get, value__set)
 
 
-
 class TestWUI(WsgiAppCase):
     @classmethod
     def setup_class(cls):
@@ -144,6 +146,7 @@ def setup_class(cls):
 
         cls.plugin = MockVocabTagsPlugin()
         plugins.load(cls.plugin)
+        cls.plugin.active = True
 
         # this is a hack so that the plugin is properly registered with
         # the package controller class.
@@ -177,6 +180,7 @@ def setup_class(cls):
     @classmethod
     def teardown_class(cls):
         plugins.unload(cls.plugin)
+        cls.plugin.active = False
         from ckan.controllers import package as package_controller
         package_controller._default_controller_behaviour = cls.old_default_controller
         paste.fixture.Field.classes['select'] = cls.old_select

From 1a61d3e6c470009136448becc27bc247e19c4286 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Wed, 15 Feb 2012 18:30:44 +0100
Subject: [PATCH 61/72] Import tag and vocab logic/auth functions in
 logic/auth/publisher modules

---
 ckan/logic/auth/publisher/create.py | 3 +++
 ckan/logic/auth/publisher/delete.py | 4 ++++
 ckan/logic/auth/publisher/update.py | 4 ++++
 3 files changed, 11 insertions(+)

diff --git a/ckan/logic/auth/publisher/create.py b/ckan/logic/auth/publisher/create.py
index c87f8637243..e0136cb8861 100644
--- a/ckan/logic/auth/publisher/create.py
+++ b/ckan/logic/auth/publisher/create.py
@@ -5,6 +5,9 @@
 from ckan.authz import Authorizer
 from ckan.lib.base import _
 
+# FIXME: Which is worse, 'from module import foo' or duplicating these
+# functions in this module?
+from ckan.logic.auth.create import vocabulary_create, tag_create
 
 def package_create(context, data_dict=None):
     model = context['model']
diff --git a/ckan/logic/auth/publisher/delete.py b/ckan/logic/auth/publisher/delete.py
index 57c9ee84260..28a129819a9 100644
--- a/ckan/logic/auth/publisher/delete.py
+++ b/ckan/logic/auth/publisher/delete.py
@@ -6,6 +6,10 @@
 from ckan.authz import Authorizer
 from ckan.lib.base import _
 
+# FIXME: Which is worse, 'from module import foo' or duplicating these
+# functions in this module?
+from ckan.logic.auth.delete import vocabulary_delete, tag_delete
+
 def package_delete(context, data_dict):
     """
     Delete a package permission. User must be in at least one group that that 
diff --git a/ckan/logic/auth/publisher/update.py b/ckan/logic/auth/publisher/update.py
index cc8ca288f9b..c74f1c50f21 100644
--- a/ckan/logic/auth/publisher/update.py
+++ b/ckan/logic/auth/publisher/update.py
@@ -5,6 +5,10 @@
 from ckan.authz import Authorizer
 from ckan.lib.base import _
 
+# FIXME: Which is worse, 'from module import foo' or duplicating these
+# functions in this module?
+from ckan.logic.auth.update import vocabulary_update
+
 def make_latest_pending_package_active(context, data_dict):
     return package_update(context, data_dict)
 

From 22a2ea2ffd240ecc98ca4fbb1a25d2403db7634a Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Wed, 15 Feb 2012 18:39:58 +0100
Subject: [PATCH 62/72] Rename tag vocab migration script

It clashed with the group approval status migration script
---
 .../{049_add_tag_vocabulary.py => 050_add_tag_vocabulary.py}      | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename ckan/migration/versions/{049_add_tag_vocabulary.py => 050_add_tag_vocabulary.py} (100%)

diff --git a/ckan/migration/versions/049_add_tag_vocabulary.py b/ckan/migration/versions/050_add_tag_vocabulary.py
similarity index 100%
rename from ckan/migration/versions/049_add_tag_vocabulary.py
rename to ckan/migration/versions/050_add_tag_vocabulary.py

From 5075ed268dd4bf5c7c498947ccf081f27a2ac721 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Thu, 16 Feb 2012 12:44:00 +0100
Subject: [PATCH 63/72] [#1698] Fix some failing psql tests

---
 ckan/lib/search/query.py                   | 2 +-
 ckan/model/package.py                      | 1 -
 ckan/tests/functional/test_authz.py        | 4 ++--
 ckan/tests/lib/test_solr_package_search.py | 4 ++--
 4 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/ckan/lib/search/query.py b/ckan/lib/search/query.py
index 3e1904c3921..3ad1608f4ea 100644
--- a/ckan/lib/search/query.py
+++ b/ckan/lib/search/query.py
@@ -171,7 +171,7 @@ def run(self, query=[], fields={}, options=None, **kwargs):
             if options.all_fields:
                 results['results'] = [r.as_dict() for r in results['results']]
             else:
-                results['results'] = [r.name for r in results['results']]
+                results['results'] = [r['name'] for r in results['results']]
         
         self.count = results['count']
         self.results = results['results']
diff --git a/ckan/model/package.py b/ckan/model/package.py
index 556dd071926..4e4a62b97f3 100644
--- a/ckan/model/package.py
+++ b/ckan/model/package.py
@@ -169,7 +169,6 @@ def add_tag(self, tag):
         else:
             package_tag = model.PackageTag(self, tag)
             model.Session.add(package_tag)
-            model.Session.commit()
 
     def add_tags(self, tags):
         for tag in tags:
diff --git a/ckan/tests/functional/test_authz.py b/ckan/tests/functional/test_authz.py
index a8fb338d15c..436f9cffa10 100644
--- a/ckan/tests/functional/test_authz.py
+++ b/ckan/tests/functional/test_authz.py
@@ -229,7 +229,7 @@ def _create_test_data(cls):
         for mode in cls.roles:
             pkg = model.Package(name=unicode(mode))
             model.Session.add(pkg)
-            pkg.tags.append(tag)
+            pkg.add_tag(tag)
             model.Session.add(model.Group(name=unicode(mode)))
         entities_to_test_deleting = []
         for interface in cls.INTERFACES:
@@ -525,7 +525,7 @@ def _create_test_data(cls):
         pkg = model.Package.by_name(cls.ENTITY_NAME)
         group = model.Group.by_name(cls.ENTITY_NAME)
         tag = model.Tag.by_name(cls.ENTITY_NAME)
-        pkg.tags.append(tag)
+        pkg.add_tag(tag)
         model.add_user_to_role(site_reader, cls.TRUSTED_ROLE, model.System())
         model.add_user_to_role(site_reader, cls.TRUSTED_ROLE, pkg)
         model.add_user_to_role(site_reader, cls.TRUSTED_ROLE, group)
diff --git a/ckan/tests/lib/test_solr_package_search.py b/ckan/tests/lib/test_solr_package_search.py
index 570d504f94c..e530a15173e 100644
--- a/ckan/tests/lib/test_solr_package_search.py
+++ b/ckan/tests/lib/test_solr_package_search.py
@@ -45,8 +45,8 @@ def setup_class(cls):
         gils = model.Package.by_name(u'gils')
         # an existing tag used only by gils
         cls.tagname = u'registry'
-        idx = [t.name for t in gils.tags].index(cls.tagname)
-        del gils.tags[idx]
+        idx = [t.name for t in gils.get_tags()].index(cls.tagname)
+        gils.remove_tag(gils.get_tags()[idx])
         model.repo.commit_and_remove()
 
     @classmethod

From 6acb26385688367e86af0a37c905cc4e61c660d0 Mon Sep 17 00:00:00 2001
From: kindly <kindly@gmail.com>
Date: Thu, 16 Feb 2012 11:47:17 +0000
Subject: [PATCH 64/72] [1781]  add api and tests

---
 ckan/logic/action/get.py            | 28 ++++++++-
 ckan/logic/action/update.py         | 55 ++++++++++++++++
 ckan/logic/auth/publisher/update.py | 19 ++++++
 ckan/logic/auth/update.py           | 14 +++++
 ckan/tests/logic/test_action.py     | 97 +++++++++++++++++++++++++++++
 5 files changed, 212 insertions(+), 1 deletion(-)

diff --git a/ckan/logic/action/get.py b/ckan/logic/action/get.py
index 8ff532b746b..97e0f052b17 100644
--- a/ckan/logic/action/get.py
+++ b/ckan/logic/action/get.py
@@ -7,7 +7,7 @@
 
 import ckan
 from ckan.lib.base import _
-from ckan.logic import NotFound, ParameterError
+from ckan.logic import NotFound, ParameterError, ValidationError
 from ckan.logic import check_access
 from ckan.model import misc
 from ckan.plugins import (PluginImplementations,
@@ -861,6 +861,32 @@ def task_status_show(context, data_dict):
     task_status_dict = task_status_dictize(task_status, context)
     return task_status_dict
 
+
+def term_translation_show(context, data_dict):
+    model = context['model']
+
+    trans_table = model.term_translation_table 
+
+    q = select([trans_table])
+
+    if 'term' not in data_dict:
+        raise ValidationError({'term': 'term not it data'})
+    
+    q = q.where(trans_table.c.term == data_dict['term'])
+
+    if 'lang_code' in data_dict:
+        q = q.where(trans_table.c.lang_code == data_dict['lang_code'])
+
+    conn = model.Session.connection()
+    cursor = conn.execute(q)
+
+    results = []
+
+    for row in cursor:
+        results.append(table_dictize(row, context))
+
+    return results
+
 def get_site_user(context, data_dict):
     check_access('get_site_user', context, data_dict)
     model = context['model']
diff --git a/ckan/logic/action/update.py b/ckan/logic/action/update.py
index fe835fdcf5b..6d6cc43385d 100644
--- a/ckan/logic/action/update.py
+++ b/ckan/logic/action/update.py
@@ -32,6 +32,7 @@
                                default_update_relationship_schema,
                                default_task_status_schema)
 from ckan.lib.navl.dictization_functions import validate
+import ckan.lib.navl.validators as validators
 from ckan.logic.action import rename_keys, get_domain_object
 from ckan.logic.action.get import roles_show
 
@@ -492,6 +493,60 @@ def task_status_update_many(context, data_dict):
         model.Session.commit()
     return {'results': results}
 
+def term_translation_update(context, data_dict):
+    model = context['model']
+
+    check_access('term_translation_update', context, data_dict)
+
+    schema = {'term': [validators.not_empty, unicode],
+              'term_translation': [validators.not_empty, unicode],
+              'lang_code': [validators.not_empty, unicode]}
+
+    data, errors = validate(data_dict, schema, context)
+
+    if errors:
+        model.Session.rollback()
+        raise ValidationError(errors)
+
+    trans_table = model.term_translation_table 
+
+    update = trans_table.update()
+    update = update.where(trans_table.c.term == data['term'])
+    update = update.where(trans_table.c.lang_code == data['lang_code'])
+    update = update.values(term_translation = data['term_translation'])
+
+    conn = model.Session.connection()
+    result = conn.execute(update)
+
+    # insert if not updated
+    if not result.rowcount:
+        conn.execute(trans_table.insert().values(**data))
+
+    if not context.get('defer_commit'):
+        model.Session.commit()
+
+    return data
+    
+def term_translation_update_many(context, data_dict):
+    model = context['model']
+    
+
+    if not data_dict.get('data') and isinstance(data_dict, list):
+        raise ValidationError(
+            {'error': 
+             'term_translation_update_many needs to have a list of dicts in field data'}
+        )
+
+    context['defer_commit'] = True
+
+    for num, row in enumerate(data_dict['data']):
+        term_translation_update(context, row)
+
+    model.Session.commit()
+
+    return {'success': '%s rows updated' % (num + 1)}
+
+
 ## Modifications for rest api
 
 def package_update_rest(context, data_dict):
diff --git a/ckan/logic/auth/publisher/update.py b/ckan/logic/auth/publisher/update.py
index cc8ca288f9b..444935a2c89 100644
--- a/ckan/logic/auth/publisher/update.py
+++ b/ckan/logic/auth/publisher/update.py
@@ -117,12 +117,31 @@ def task_status_update(context, data_dict):
     model = context['model']
     user = context['user']
 
+    if 'ignore_auth' in context and context['ignore_auth']:
+        return {'success': True}
+
     authorized =  Authorizer().is_sysadmin(unicode(user))
     if not authorized:
         return {'success': False, 'msg': _('User %s not authorized to update task_status table') % str(user)}
     else:
         return {'success': True}
 
+def term_translation_update(context, data_dict):
+
+    model = context['model']
+    user = context['user']
+
+    if 'ignore_auth' in context and context['ignore_auth']:
+        return {'success': True}
+
+    authorized =  Authorizer().is_sysadmin(unicode(user))
+    if not authorized:
+        return {'success': False, 'msg': _('User %s not authorized to update term_translation table') % str(user)}
+    else:
+        return {'success': True}
+
+
+
 ## Modifications for rest api
 
 def package_update_rest(context, data_dict):
diff --git a/ckan/logic/auth/update.py b/ckan/logic/auth/update.py
index 7b84b430f2e..c1aa7fbabdc 100644
--- a/ckan/logic/auth/update.py
+++ b/ckan/logic/auth/update.py
@@ -159,6 +159,20 @@ def task_status_update(context, data_dict):
     else:
         return {'success': True}
 
+def term_translation_update(context, data_dict):
+
+    model = context['model']
+    user = context['user']
+
+    if 'ignore_auth' in context and context['ignore_auth']:
+        return {'success': True}
+
+    authorized =  Authorizer().is_sysadmin(unicode(user))
+    if not authorized:
+        return {'success': False, 'msg': _('User %s not authorized to update term_translation table') % str(user)}
+    else:
+        return {'success': True}
+
 ## Modifications for rest api
 
 def package_update_rest(context, data_dict):
diff --git a/ckan/tests/logic/test_action.py b/ckan/tests/logic/test_action.py
index 82fbeef5ad4..220c0caaaa6 100644
--- a/ckan/tests/logic/test_action.py
+++ b/ckan/tests/logic/test_action.py
@@ -1309,6 +1309,103 @@ def test_38_user_role_bulk_update(self):
                        {'domain_object': anna.id})
         assert_equal(results['roles'], roles_after['roles'])
 
+class TestActionTermTranslation(WsgiAppCase):
+
+    @classmethod
+    def setup_class(self):
+        CreateTestData.create()
+        self.sysadmin_user = model.User.get('testsysadmin')
+        self.normal_user = model.User.get('annafan')
+
+    @classmethod
+    def teardown_class(self):
+        model.repo.rebuild_db()
+
+    def test_1_update_single(self):
+        postparams = '%s=1' % json.dumps(
+            {"term" : "moo",
+             "term_translation": "moo",
+             "lang_code" : "fr"
+            }
+        )
+
+        res = self.app.post('/api/action/term_translation_update', params=postparams,
+                            extra_environ={'Authorization': str(self.sysadmin_user.apikey)},
+                            status=200)
+
+        assert json.loads(res.body)['success']
+
+        postparams = '%s=1' % json.dumps(
+            {"term" : "moo",
+             "term_translation": "moomoo",
+             "lang_code" : "fr"
+            }
+        )
+
+        res = self.app.post('/api/action/term_translation_update', params=postparams,
+                            extra_environ={'Authorization': str(self.sysadmin_user.apikey)},
+                            status=200)
+
+        assert json.loads(res.body)['success']
+
+        postparams = '%s=1' % json.dumps(
+            {"term" : "moo",
+             "term_translation": "moomoo",
+             "lang_code" : "en"
+            }
+        )
+
+        res = self.app.post('/api/action/term_translation_update', params=postparams,
+                            extra_environ={'Authorization': str(self.sysadmin_user.apikey)},
+                            status=200)
+
+        assert json.loads(res.body)['success']
+
+        postparams = '%s=1' % json.dumps({"term" : "moo"})
+
+        res = self.app.post('/api/action/term_translation_show', params=postparams,
+                            extra_environ={'Authorization': str(self.sysadmin_user.apikey)},
+                            status=200)
+
+        assert json.loads(res.body)['success']
+        assert json.loads(res.body)['result'] == [{u'lang_code': u'fr', u'term': u'moo', u'term_translation': u'moomoo'},
+                                                  {u'lang_code': u'en', u'term': u'moo', u'term_translation': u'moomoo'}], json.loads(res.body)
+
+    def test_2_update_many(self):
+
+        postparams = '%s=1' % json.dumps({'data': [
+             {"term" : "many",
+              "term_translation": "manymoo",
+              "lang_code" : "fr"
+             },
+             {"term" : "many",
+              "term_translation": "manymoo",
+              "lang_code" : "en"
+             },
+             {"term" : "many",
+              "term_translation": "manymoomoo",
+              "lang_code" : "en"
+             }
+            ]
+        }
+        )
+        res = self.app.post('/api/action/term_translation_update_many', params=postparams,
+                            extra_environ={'Authorization': str(self.sysadmin_user.apikey)},
+                            status=200)
+
+        assert json.loads(res.body)['result']['success'] == '3 rows updated', json.loads(res.body)
+
+        postparams = '%s=1' % json.dumps({"term" : "many"})
+        res = self.app.post('/api/action/term_translation_show', params=postparams,
+                            extra_environ={'Authorization': str(self.sysadmin_user.apikey)},
+                            status=200)
+
+        assert json.loads(res.body)['result'] == [{u'lang_code': u'fr', u'term': u'many', u'term_translation': u'manymoo'},
+                                                  {u'lang_code': u'en', u'term': u'many', u'term_translation': u'manymoomoo'}], json.loads(res.body)
+
+
+
+
 class TestActionPackageSearch(WsgiAppCase):
 
     @classmethod

From 7825caed3361e88a245b5dd2f946da8bedb160e0 Mon Sep 17 00:00:00 2001
From: kindly <kindly@gmail.com>
Date: Thu, 16 Feb 2012 13:56:16 +0000
Subject: [PATCH 65/72] [1741] add group view, fix tests

---
 ckan/controllers/group.py             | 3 ++-
 ckan/lib/dictization/model_dictize.py | 6 +++++-
 ckan/plugins/interfaces.py            | 7 +++++++
 ckan/tests/functional/test_group.py   | 4 ++++
 ckan/tests/lib/test_dictization.py    | 7 +++----
 5 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/ckan/controllers/group.py b/ckan/controllers/group.py
index b962a8d7c99..22397c4160e 100644
--- a/ckan/controllers/group.py
+++ b/ckan/controllers/group.py
@@ -205,7 +205,8 @@ def read(self, id):
         group_type = self._get_group_type(id.split('@')[0])
         context = {'model': model, 'session': model.Session,
                    'user': c.user or c.author,
-                   'schema': self._form_to_db_schema(group_type=type)}
+                   'schema': self._form_to_db_schema(group_type=type),
+                   'for_view': True}
         data_dict = {'id': id}
         q = c.q = request.params.get('q', '') # unicode format (decoded from utf8)
 
diff --git a/ckan/lib/dictization/model_dictize.py b/ckan/lib/dictization/model_dictize.py
index 083bea1b600..4f18ebb8234 100644
--- a/ckan/lib/dictization/model_dictize.py
+++ b/ckan/lib/dictization/model_dictize.py
@@ -1,6 +1,6 @@
 from pylons import config
 from sqlalchemy.sql import select, and_
-from ckan.plugins import PluginImplementations, IDatasetForm, IPackageController
+from ckan.plugins import PluginImplementations, IDatasetForm, IPackageController, IGroupController
 import datetime
 
 from ckan.model import PackageRevision
@@ -257,6 +257,10 @@ def group_dictize(group, context):
 
     context['with_capacity'] = False
 
+    if context.get('for_view'):
+        for item in PluginImplementations(IGroupController):
+            result_dict = item.before_view(result_dict)
+
     return result_dict
 
 def tag_list_dictize(tag_list, context):
diff --git a/ckan/plugins/interfaces.py b/ckan/plugins/interfaces.py
index 5c87b4953a3..2f5252d808d 100644
--- a/ckan/plugins/interfaces.py
+++ b/ckan/plugins/interfaces.py
@@ -207,6 +207,13 @@ def authz_remove_role(self, object_role):
     def delete(self, entity):
         pass
 
+    def before_view(self, pkg_dict):
+        '''
+             Extensions will recieve this before the group gets displayed. The dictionary
+             passed will be the one that gets sent to the template.
+        '''
+        return pkg_dict
+
 class IPackageController(Interface):
     """
     Hook into the package controller.
diff --git a/ckan/tests/functional/test_group.py b/ckan/tests/functional/test_group.py
index 9707e8889af..05be9188a4b 100644
--- a/ckan/tests/functional/test_group.py
+++ b/ckan/tests/functional/test_group.py
@@ -40,6 +40,10 @@ def authz_remove_role(self, object_role):
     def delete(self, entity):
         self.calls['delete'] += 1
 
+    def before_view(self, data_dict):
+        self.calls['before_view'] += 1
+        return data_dict
+
 class TestGroup(FunctionalTestCase):
 
     @classmethod
diff --git a/ckan/tests/lib/test_dictization.py b/ckan/tests/lib/test_dictization.py
index 74018cb9ed3..680024b1d50 100644
--- a/ckan/tests/lib/test_dictization.py
+++ b/ckan/tests/lib/test_dictization.py
@@ -52,7 +52,7 @@ def setup_class(cls):
                         "approval_status": u"approved"}],
             'isopen': True,
             'license_id': u'other-open',
-            'license_title': u'OKD Compliant::Other (Open)',
+            'license_title': u'Other (Open)',
             'maintainer': None,
             'maintainer_email': None,
             'type': None,
@@ -216,12 +216,11 @@ def test_02_package_dictize(self):
 
         pprint(result)
         pprint(self.package_expected)
+        print "\n".join(unified_diff(pformat(result).split("\n"), pformat(self.package_expected).split("\n")))
 
         assert sorted(result.values()) == sorted(self.package_expected.values())
         assert result == self.package_expected
 
-
-
     def test_03_package_to_api1(self):
 
         context = {"model": model,
@@ -233,7 +232,7 @@ def test_03_package_to_api1(self):
         pprint(pkg.as_dict())
         asdict = pkg.as_dict()
         asdict['download_url'] = asdict['resources'][0]['url']
-        asdict['license_title'] = u'OKD Compliant::Other (Open)'
+        asdict['license_title'] = u'Other (Open)'
 
         assert package_to_api1(pkg, context) == asdict
 

From b24205ba741d9fed847175992823c681b5583ccd Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Thu, 16 Feb 2012 15:49:20 +0100
Subject: [PATCH 66/72] [#1698] Tag and vocab logic functions tweaks

Fix tag_list() and Tag.all() to handle both the optional query and
vocabulary_id correctly, and change 'vocabulary_name' arguments in tag
and vocab logic functions to 'vocabulary_id' arguments that can be
either name or ID (to be consistent with other logic functions).
---
 ckan/logic/action/get.py                      | 60 ++++++++--------
 ckan/model/tag.py                             | 15 ++--
 .../functional/api/model/test_vocabulary.py   |  8 ++-
 ckan/tests/functional/test_tag_vocab.py       |  2 +-
 ckan/tests/logic/test_action.py               | 70 +++++++++----------
 5 files changed, 81 insertions(+), 74 deletions(-)

diff --git a/ckan/logic/action/get.py b/ckan/logic/action/get.py
index 342ed45216e..9513adf946e 100644
--- a/ckan/logic/action/get.py
+++ b/ckan/logic/action/get.py
@@ -198,37 +198,41 @@ def licence_list(context, data_dict):
     return licences
 
 def tag_list(context, data_dict):
-    '''Returns a list of tags'''
+    '''Return a list of tag dictionaries.
 
+    If a query is provided in the data_dict with key 'query' or 'q', then only
+    tags whose names match the given query will be returned. Otherwise, all
+    tags will be returned.
+
+    By default only free tags (tags that don't belong to a vocabulary) are
+    returned. If a 'vocabulary_id' is provided in the data_dict then tags
+    belonging to the given vocabulary (id or name) will be returned instead.
+
+    '''
     model = context['model']
     user = context['user']
 
+    vocab_id_or_name = data_dict.get('vocabulary_id')
+    query = data_dict.get('query') or data_dict.get('q')
+    if query:
+        query = query.strip()
     all_fields = data_dict.get('all_fields', None)
 
-    check_access('tag_list',context, data_dict)
+    check_access('tag_list', context, data_dict)
 
-    q = data_dict.get('q','')
-    if q:
+    if query:
         tags = _tag_search(context, data_dict)
     else:
-        tags = model.Session.query(model.Tag).all()
-
-    # filter by vocabulary
-    if data_dict.get('vocabulary_name'):
-        vocab = model.Vocabulary.get(data_dict['vocabulary_name'])
-        if not vocab:
-            raise NotFound
-        tags = [tag for tag in tags if tag.vocabulary_id == vocab.id]
-    else:
-        tags = [tag for tag in tags if not tag.vocabulary_id]
+        tags = model.Tag.all(vocab_id_or_name)
 
     tag_list = []
-    if all_fields:
-        for tag in tags:
-            result_dict = tag_dictize(tag, context)
-            tag_list.append(result_dict)
-    else:
-        tag_list = [tag.name for tag in tags]
+    if tags:
+        if all_fields:
+            for tag in tags:
+                result_dict = tag_dictize(tag, context)
+                tag_list.append(result_dict)
+        else:
+            tag_list.extend([tag.name for tag in tags])
 
     return tag_list
 
@@ -791,8 +795,8 @@ def _tag_search(context, data_dict):
     'q'.
 
     By default only free tags (tags that don't belong to a vocabulary) are
-    searched. If a 'vocabulary_name' is provided in the data_dict then tags
-    belonging to the named vocabulary will be searched instead.
+    searched. If a 'vocabulary_id' is provided in the data_dict then tags
+    belonging to the given vocabulary (id or name) will be searched instead.
 
     '''
     model = context['model']
@@ -809,9 +813,9 @@ def _tag_search(context, data_dict):
     # TODO: should we check for user authentication first?
     q = model.Session.query(model.Tag)
 
-    if data_dict.has_key('vocabulary_name'):
+    if data_dict.has_key('vocabulary_id'):
         # Filter by vocabulary.
-        vocab = model.Vocabulary.get(data_dict['vocabulary_name'])
+        vocab = model.Vocabulary.get(data_dict['vocabulary_id'])
         if not vocab:
             raise NotFound
         q = q.filter(model.Tag.vocabulary_id == vocab.id)
@@ -844,8 +848,8 @@ def tag_search(context, data_dict):
     'q'.
 
     By default only free tags (tags that don't belong to a vocabulary) are
-    searched. If a 'vocabulary_name' is provided in the data_dict then tags
-    belonging to the named vocabulary will be searched instead.
+    searched. If a 'vocabulary_id' is provided in the data_dict then tags
+    belonging to the given vocabulary (id or name) will be searched instead.
 
     Returns a dictionary with keys 'count' (the number of tags in the result)
     and 'results' (the list of tag dicts).
@@ -862,8 +866,8 @@ def tag_autocomplete(context, data_dict):
     'q'.
 
     By default only free tags (tags that don't belong to a vocabulary) are
-    searched. If a 'vocabulary_name' is provided in the data_dict then tags
-    belonging to the named vocabulary will be searched instead.
+    searched. If a 'vocabulary_id' is provided in the data_dict then tags
+    belonging to the given vocabulary (id or name) will be searched instead.
 
     '''
     check_access('tag_autocomplete', context, data_dict)
diff --git a/ckan/model/tag.py b/ckan/model/tag.py
index 365c67cacf7..009b47395f0 100644
--- a/ckan/model/tag.py
+++ b/ckan/model/tag.py
@@ -8,6 +8,7 @@
 from core import *
 import vocabulary
 import activity
+import ckan
 
 __all__ = ['tag_table', 'package_tag_table', 'Tag', 'PackageTag',
            'PackageTagRevision', 'package_tag_revision_table',
@@ -109,7 +110,8 @@ def get(cls, tag_id_or_name, vocab_id_or_name=None):
                 vocab = vocabulary.Vocabulary.get(vocab_id_or_name)
                 if vocab is None:
                     # The user specified an invalid vocab.
-                    return None
+                    raise ckan.logic.NotFound("could not find vocabulary '%s'"
+                            % vocab_id_or_name)
             else:
                 vocab = None
             tag = Tag.by_name(tag_id_or_name, vocab=vocab)
@@ -151,14 +153,15 @@ def all(cls, vocab_id_or_name=None):
             vocab = vocabulary.Vocabulary.get(vocab_id_or_name)
             if vocab is None:
                 # The user specified an invalid vocab.
-                return None
+                raise ckan.logic.NotFound("could not find vocabulary '%s'"
+                        % vocab_id_or_name)
             query = Session.query(Tag).filter(Tag.vocabulary_id==vocab.id)
         else:
             query = Session.query(Tag).filter(Tag.vocabulary_id == None)
-        query = query.distinct().join(PackageTagRevision)
-        query = query.filter(sqlalchemy.and_(
-            PackageTagRevision.state == 'active',
-            PackageTagRevision.current == True))
+            query = query.distinct().join(PackageTagRevision)
+            query = query.filter(sqlalchemy.and_(
+                PackageTagRevision.state == 'active',
+                PackageTagRevision.current == True))
         return query
 
     @property
diff --git a/ckan/tests/functional/api/model/test_vocabulary.py b/ckan/tests/functional/api/model/test_vocabulary.py
index 7814815e141..b351eabea06 100644
--- a/ckan/tests/functional/api/model/test_vocabulary.py
+++ b/ckan/tests/functional/api/model/test_vocabulary.py
@@ -142,7 +142,7 @@ def _delete_vocabulary(self, vocab_id, user=None):
     def _list_tags(self, vocabulary=None, user=None):
         params = {}
         if vocabulary:
-            params['vocabulary_name'] = vocabulary['name']
+            params['vocabulary_id'] = vocabulary['id']
         if user:
             extra_environ = {'Authorization' : str(user.apikey)}
         else:
@@ -724,7 +724,8 @@ def test_delete_tag_vocab_not_exists(self):
                 status=404)
         assert response.json['success'] == False
         msg = response.json['error']['message']
-        assert msg == u"Not found", msg
+        assert msg == u"Not found: could not find vocabulary 'nonexistent'", \
+                msg
 
     def test_delete_tag_invalid_tag(self):
         '''Test the error response when a user tries to delete a tag but gives
@@ -763,7 +764,8 @@ def test_delete_tag_invalid_vocab(self):
                     status=404)
             assert response.json['success'] == False
             msg = response.json['error']['message']
-            assert msg == u"Not found", msg
+            assert msg == u"Not found: could not find vocabulary '%s'" \
+                    % vocab_name, msg
 
     def test_delete_tag_not_logged_in(self):
         vocab = self.genre_vocab
diff --git a/ckan/tests/functional/test_tag_vocab.py b/ckan/tests/functional/test_tag_vocab.py
index b2c05577186..976a8122edf 100644
--- a/ckan/tests/functional/test_tag_vocab.py
+++ b/ckan/tests/functional/test_tag_vocab.py
@@ -31,7 +31,7 @@ def package_form(self):
         return 'package/new_package_form.html'
 
     def setup_template_variables(self, context, data_dict=None):
-        c.vocab_tags = get_action('tag_list')(context, {'vocabulary_name': TEST_VOCAB_NAME})
+        c.vocab_tags = get_action('tag_list')(context, {'vocabulary_id': TEST_VOCAB_NAME})
 
     def form_to_db_schema(self):
         schema = package_form_schema()
diff --git a/ckan/tests/logic/test_action.py b/ckan/tests/logic/test_action.py
index f96869f5ceb..899bef48b79 100644
--- a/ckan/tests/logic/test_action.py
+++ b/ckan/tests/logic/test_action.py
@@ -99,6 +99,8 @@ def make_some_vocab_tags(cls):
         model.Package.get('warandpeace').add_tag(bach_tag)
         model.Package.get('annakarenina').add_tag(sonata_tag)
 
+        model.Session.commit()
+
     def _add_basic_package(self, package_name=u'test_package', **kwargs):
         package = {
             'name': package_name,
@@ -331,12 +333,13 @@ def test_05b_user_show_datasets(self):
     def test_06a_tag_list(self):
         postparams = '%s=1' % json.dumps({})
         res = self.app.post('/api/action/tag_list', params=postparams)
-        assert_dicts_equal_ignoring_ordering(
-            json.loads(res.body),
-            {'help': 'Returns a list of tags',
-             'success': True,
-             'result': ['russian', 'tolstoy', u'Flexible \u30a1', 'tollbooth',
-                 'tolkien', 'toledo', 'tolerance']})
+        resbody = json.loads(res.body)
+        assert resbody['success'] is True
+        assert sorted(resbody['result']) == sorted(['russian', 'tolstoy',
+                u'Flexible \u30a1', 'tollbooth', 'tolkien', 'toledo',
+                'tolerance'])
+        assert resbody['help'].startswith(
+                'Return a list of tag dictionaries.')
         #Get all fields
         postparams = '%s=1' % json.dumps({'all_fields':True})
         res = self.app.post('/api/action/tag_list', params=postparams)
@@ -388,18 +391,15 @@ def test_06b_tag_list_vocab(self):
         assert response.json['success'] == True
 
         # check that tag shows up in list
-        params = '%s=1' % json.dumps({'vocabulary_name': vocab_name})
+        params = '%s=1' % json.dumps({'vocabulary_id': vocab_name})
         res = self.app.post('/api/action/tag_list', params=params)
         body = json.loads(res.body)
-        assert_dicts_equal_ignoring_ordering(
-            json.loads(res.body),
-            {'help': 'Returns a list of tags',
-             'success': True,
-             'result': [tag_name]}
-        )
+        assert body['success'] is True
+        assert body['result'] == [tag_name]
+        assert body['help'].startswith('Return a list of tag dictionaries.')
 
         # check that invalid vocab name results in a 404
-        params = '%s=1' % json.dumps({'vocabulary_name': 'invalid-vocab-name'})
+        params = '%s=1' % json.dumps({'vocabulary_id': 'invalid-vocab-name'})
         res = self.app.post('/api/action/tag_list', params=params, status=404)
 
     def test_07_tag_show(self):
@@ -763,7 +763,7 @@ def test_15a_tag_search_with_many_matches(self):
 
     def test_15a_tag_search_with_vocab_and_empty_query(self):
         for q in ('missing', None, '', '  '):
-            paramd = {'vocabulary_name': 'genre'}
+            paramd = {'vocabulary_id': 'genre'}
             if q != 'missing':
                 paramd['q'] = q
             params = json.dumps(paramd)
@@ -773,7 +773,7 @@ def test_15a_tag_search_with_vocab_and_empty_query(self):
             assert res.json['result']['results'] == []
 
     def test_15a_tag_search_with_vocab_and_one_match(self):
-        paramd = {'q': 'son', 'vocabulary_name': 'genre' }
+        paramd = {'q': 'son', 'vocabulary_id': 'genre' }
         params = json.dumps(paramd)
         res = self.app.post('/api/action/tag_search', params=params)
         assert res.json['success'] is True
@@ -783,7 +783,7 @@ def test_15a_tag_search_with_vocab_and_one_match(self):
         assert tag_dicts[0]['name'] == 'sonata'
 
     def test_15a_tag_search_with_vocab_and_multiple_matches(self):
-        paramd = {'q': 'neo', 'vocabulary_name': 'genre' }
+        paramd = {'q': 'neo', 'vocabulary_id': 'genre' }
         params = json.dumps(paramd)
         res = self.app.post('/api/action/tag_search', params=params)
         assert res.json['success'] is True
@@ -793,7 +793,7 @@ def test_15a_tag_search_with_vocab_and_multiple_matches(self):
             'neofolk', 'neomedieval', 'neoprog', 'neopsychedelia', 'neosoul'))
 
     def test_15a_tag_search_with_vocab_and_no_matches(self):
-        paramd = {'q': 'xxxxxxx', 'vocabulary_name': 'genre' }
+        paramd = {'q': 'xxxxxxx', 'vocabulary_id': 'genre' }
         params = json.dumps(paramd)
         res = self.app.post('/api/action/tag_search', params=params)
         assert res.json['success'] is True
@@ -802,13 +802,13 @@ def test_15a_tag_search_with_vocab_and_no_matches(self):
         assert tag_dicts == []
 
     def test_15a_tag_search_with_vocab_that_does_not_exist(self):
-        paramd = {'q': 'neo', 'vocabulary_name': 'xxxxxx' }
+        paramd = {'q': 'neo', 'vocabulary_id': 'xxxxxx' }
         params = json.dumps(paramd)
         self.app.post('/api/action/tag_search', params=params, status=404)
 
     def test_15a_tag_search_with_invalid_vocab(self):
         for vocab_name in (None, '', 'a', 'e'*200):
-            paramd = {'q': 'neo', 'vocabulary_name': vocab_name }
+            paramd = {'q': 'neo', 'vocabulary_id': vocab_name }
             params = json.dumps(paramd)
             self.app.post('/api/action/tag_search', params=params, status=404)
 
@@ -817,21 +817,19 @@ def test_15_tag_autocomplete(self):
         postparams = '%s=1' % json.dumps({})
         res = self.app.post('/api/action/tag_autocomplete', params=postparams)
         res_obj = json.loads(res.body)
-        assert res_obj == {
-            'help': 'Returns tags containing the provided string',
-            'result': [],
-            'success': True
-        }
+        assert res_obj['success'] == True
+        assert res_obj['result'] == []
+        assert res_obj['help'].startswith(
+                'Return a list of tag names that contain the given string.')
 
         #Normal query
         postparams = '%s=1' % json.dumps({'q':'r'})
         res = self.app.post('/api/action/tag_autocomplete', params=postparams)
         res_obj = json.loads(res.body)
-        assert res_obj == {
-            'help': 'Returns tags containing the provided string',
-            'result': ['russian', 'tolerance'],
-            'success': True
-        }
+        assert res_obj['success'] == True
+        assert res_obj['result'] == ['russian', 'tolerance']
+        assert res_obj['help'].startswith(
+                'Return a list of tag names that contain the given string.')
 
     def test_15_tag_autocomplete_tag_with_spaces(self):
         """Asserts autocomplete finds tags that contain spaces"""
@@ -978,7 +976,7 @@ def test_15_tag_autocomplete_is_case_insensitive(self):
 
     def test_15_tag_autocomplete_with_vocab_and_empty_query(self):
         for q in ('missing', None, '', '  '):
-            paramd = {'vocabulary_name': u'genre'}
+            paramd = {'vocabulary_id': u'genre'}
             if q != 'missing':
                 paramd['q'] = q
             params = json.dumps(paramd)
@@ -987,14 +985,14 @@ def test_15_tag_autocomplete_with_vocab_and_empty_query(self):
             assert res.json['result'] == []
 
     def test_15_tag_autocomplete_with_vocab_and_single_match(self):
-        paramd = {'vocabulary_name': u'genre', 'q': 'son'}
+        paramd = {'vocabulary_id': u'genre', 'q': 'son'}
         params = json.dumps(paramd)
         res = self.app.post('/api/action/tag_autocomplete', params=params)
         assert res.json['success'] is True
         assert res.json['result'] == ['sonata'], res.json['result']
 
     def test_15_tag_autocomplete_with_vocab_and_multiple_matches(self):
-        paramd = {'vocabulary_name': 'genre', 'q': 'neo'}
+        paramd = {'vocabulary_id': 'genre', 'q': 'neo'}
         params = json.dumps(paramd)
         res = self.app.post('/api/action/tag_autocomplete', params=params)
         assert res.json['success'] is True
@@ -1002,7 +1000,7 @@ def test_15_tag_autocomplete_with_vocab_and_multiple_matches(self):
             'neomedieval', 'neoprog', 'neopsychedelia', 'neosoul'))
 
     def test_15_tag_autocomplete_with_vocab_and_no_matches(self):
-        paramd = {'vocabulary_name': 'composers', 'q': 'Jonny Greenwood'}
+        paramd = {'vocabulary_id': 'composers', 'q': 'Jonny Greenwood'}
         params = json.dumps(paramd)
         res = self.app.post('/api/action/tag_autocomplete', params=params)
         assert res.json['success'] is True
@@ -1010,7 +1008,7 @@ def test_15_tag_autocomplete_with_vocab_and_no_matches(self):
 
     def test_15_tag_autocomplete_with_vocab_that_does_not_exist(self):
         for q in ('', 'neo'):
-            paramd = {'vocabulary_name': 'does_not_exist', 'q': q}
+            paramd = {'vocabulary_id': 'does_not_exist', 'q': q}
             params = json.dumps(paramd)
             res = self.app.post('/api/action/tag_autocomplete', params=params,
                     status=404)
@@ -1019,7 +1017,7 @@ def test_15_tag_autocomplete_with_vocab_that_does_not_exist(self):
     def test_15_tag_autocomplete_with_invalid_vocab(self):
         for vocab_name in (None, '', 'a', 'e'*200):
             for q in (None, '', 'son'):
-                paramd = {'vocabulary_name': vocab_name, 'q': q}
+                paramd = {'vocabulary_id': vocab_name, 'q': q}
                 params = json.dumps(paramd)
                 res = self.app.post('/api/action/tag_autocomplete', params=params,
                         status=404)

From aac7586db1178df5bc9996704357f4cfdffbdc2b Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Fri, 17 Feb 2012 10:58:57 +0100
Subject: [PATCH 67/72] Tweak vocabulary_show() arguments

Be consistent with other *_show() logic functions: accept an 'id'
argument that can be either the vocab ID or the name.
---
 ckan/logic/action/get.py                       | 18 ++++++------------
 .../functional/api/model/test_vocabulary.py    |  4 ++--
 ckan/tests/functional/test_tag_vocab.py        |  2 +-
 3 files changed, 9 insertions(+), 15 deletions(-)

diff --git a/ckan/logic/action/get.py b/ckan/logic/action/get.py
index aeeabc9e8e2..99e5491f653 100644
--- a/ckan/logic/action/get.py
+++ b/ckan/logic/action/get.py
@@ -999,18 +999,12 @@ def vocabulary_list(context, data_dict):
 
 def vocabulary_show(context, data_dict):
     model = context['model']
-
-    if data_dict.has_key('id'):
-        vocabulary = model.vocabulary.Vocabulary.get(data_dict['id'])
-        if vocabulary is None:
-            raise NotFound
-    elif data_dict.has_key('name'):
-        vocabulary = model.vocabulary.Vocabulary.get(data_dict['name'])
-        if vocabulary is None:
-            raise NotFound
-    else:
-        raise NotFound
-
+    vocab_id = data_dict.get('id')
+    if not vocab_id:
+        raise ValidationError({'id': _('id not in data')})
+    vocabulary = model.vocabulary.Vocabulary.get(vocab_id)
+    if vocabulary is None:
+        raise NotFound(_('Could not find vocabulary "%s"') % vocab_id)
     vocabulary_dict = vocabulary_dictize(vocabulary, context)
     return vocabulary_dict
 
diff --git a/ckan/tests/functional/api/model/test_vocabulary.py b/ckan/tests/functional/api/model/test_vocabulary.py
index b351eabea06..608f98698fa 100644
--- a/ckan/tests/functional/api/model/test_vocabulary.py
+++ b/ckan/tests/functional/api/model/test_vocabulary.py
@@ -60,7 +60,7 @@ def _create_vocabulary(self, vocab_name=None, user=None):
         params = {'id': created_vocab['id']}
         response = self._post('/api/action/vocabulary_show', params)
         # Check that retrieving the vocab by name gives the same result.
-        by_name_params = {'name': created_vocab['name']}
+        by_name_params = {'id': created_vocab['name']}
         assert response == self._post('/api/action/vocabulary_show',
                 by_name_params)
         # Check that it matches what we created.
@@ -101,7 +101,7 @@ def _update_vocabulary(self, params, user=None):
         params = {'id': updated_vocab['id']}
         response = self._post('/api/action/vocabulary_show', params)
         # Check that retrieving the vocab by name gives the same result.
-        by_name_params = {'name': updated_vocab['name']}
+        by_name_params = {'id': updated_vocab['name']}
         assert response == self._post('/api/action/vocabulary_show',
                 by_name_params)
         # Check that it matches what we created.
diff --git a/ckan/tests/functional/test_tag_vocab.py b/ckan/tests/functional/test_tag_vocab.py
index 976a8122edf..226f018544f 100644
--- a/ckan/tests/functional/test_tag_vocab.py
+++ b/ckan/tests/functional/test_tag_vocab.py
@@ -187,7 +187,7 @@ def teardown_class(cls):
         model.repo.rebuild_db()
 
     def _get_vocab_id(self, vocab_name):
-        params = json.dumps({'name': vocab_name})
+        params = json.dumps({'id': vocab_name})
         response = self.app.post('/api/action/vocabulary_show', params=params)
         assert json.loads(response.body)['success']
         return json.loads(response.body)['result']['id']

From 0e892f8cbfbc95d0754a9bd781586fd46053bd3b Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Fri, 17 Feb 2012 11:01:08 +0100
Subject: [PATCH 68/72] Tweak vocab API error messages

Make them all use the same string, easier to translate
---
 ckan/logic/action/delete.py | 3 +--
 ckan/logic/action/update.py | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/ckan/logic/action/delete.py b/ckan/logic/action/delete.py
index d3e15ec3139..cdc1703a5d4 100644
--- a/ckan/logic/action/delete.py
+++ b/ckan/logic/action/delete.py
@@ -105,12 +105,11 @@ def task_status_delete(context, data_dict):
 
 def vocabulary_delete(context, data_dict):
     model = context['model']
-    user = context['user']
     vocab_id = data_dict['id']
 
     vocab_obj = model.vocabulary.Vocabulary.get(vocab_id)
     if vocab_obj is None:
-        raise NotFound
+        raise NotFound(_('Could not find vocabulary "%s"') % vocab_id)
 
     check_access('vocabulary_delete', context, data_dict)
 
diff --git a/ckan/logic/action/update.py b/ckan/logic/action/update.py
index 66616487409..cf16ae87645 100644
--- a/ckan/logic/action/update.py
+++ b/ckan/logic/action/update.py
@@ -615,7 +615,6 @@ def group_update_rest(context, data_dict):
 
 def vocabulary_update(context, data_dict):
     model = context['model']
-    user = context['user']
     vocab_id = data_dict['id']
 
     model.Session.remove()
@@ -623,7 +622,7 @@ def vocabulary_update(context, data_dict):
 
     vocab = model.vocabulary.Vocabulary.get(vocab_id)
     if vocab is None:
-        raise NotFound(_('Vocabulary was not found.'))
+        raise NotFound(_('Could not find vocabulary "%s"') % vocab_id)
 
     check_access('vocabulary_update', context, data_dict)
 

From 05f1273389b0ba8ef94dd4a461ef082631fd8378 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Fri, 17 Feb 2012 11:06:41 +0100
Subject: [PATCH 69/72] Fix vocabulary_update() when no id given

---
 ckan/logic/action/update.py                        |  4 +++-
 ckan/tests/functional/api/model/test_vocabulary.py | 12 ++++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/ckan/logic/action/update.py b/ckan/logic/action/update.py
index cf16ae87645..53dd049f018 100644
--- a/ckan/logic/action/update.py
+++ b/ckan/logic/action/update.py
@@ -615,7 +615,9 @@ def group_update_rest(context, data_dict):
 
 def vocabulary_update(context, data_dict):
     model = context['model']
-    vocab_id = data_dict['id']
+    vocab_id = data_dict.get('id')
+    if not vocab_id:
+        raise ValidationError({'id': _('id not in data')})
 
     model.Session.remove()
     model.Session()._context = context
diff --git a/ckan/tests/functional/api/model/test_vocabulary.py b/ckan/tests/functional/api/model/test_vocabulary.py
index 608f98698fa..6528297ed4b 100644
--- a/ckan/tests/functional/api/model/test_vocabulary.py
+++ b/ckan/tests/functional/api/model/test_vocabulary.py
@@ -294,6 +294,18 @@ def test_vocabulary_update_no_name(self):
                 status=409)
         assert response.json['success'] == False
 
+    def test_vocabulary_update_no_id(self):
+        params = {'name': 'bagel radio'}
+        param_string = json.dumps(params)
+        response = self.app.post('/api/action/vocabulary_update',
+                params=param_string,
+                extra_environ = {'Authorization':
+                    str(self.sysadmin_user.apikey)},
+                status=409)
+        assert response.json['success'] == False
+        assert response.json['error'].has_key('id')
+        assert response.json['error']['id'] == 'id not in data'
+
     def test_vocabulary_update_not_logged_in(self):
         '''Test that users who are not logged in cannot update vocabularies.'''
         params = {'id': self.genre_vocab['id']}

From 9e6872aa80adc911d4e17a28c862e2956db6c506 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Fri, 17 Feb 2012 11:16:19 +0100
Subject: [PATCH 70/72] Fix vocabulary_delete() when no id given

---
 ckan/logic/action/delete.py                      |  5 ++++-
 .../functional/api/model/test_vocabulary.py      | 16 ++++++++++++++++
 2 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/ckan/logic/action/delete.py b/ckan/logic/action/delete.py
index cdc1703a5d4..ab35bcf3101 100644
--- a/ckan/logic/action/delete.py
+++ b/ckan/logic/action/delete.py
@@ -105,7 +105,10 @@ def task_status_delete(context, data_dict):
 
 def vocabulary_delete(context, data_dict):
     model = context['model']
-    vocab_id = data_dict['id']
+
+    vocab_id = data_dict.get('id')
+    if not vocab_id:
+        raise ValidationError({'id': _('id not in data')})
 
     vocab_obj = model.vocabulary.Vocabulary.get(vocab_id)
     if vocab_obj is None:
diff --git a/ckan/tests/functional/api/model/test_vocabulary.py b/ckan/tests/functional/api/model/test_vocabulary.py
index 6528297ed4b..d537bf44e5d 100644
--- a/ckan/tests/functional/api/model/test_vocabulary.py
+++ b/ckan/tests/functional/api/model/test_vocabulary.py
@@ -343,6 +343,22 @@ def test_vocabulary_delete_not_exists(self):
                 status=404)
         assert response.json['success'] == False
 
+    def test_vocabulary_delete_no_id(self):
+        '''Test the error response given when a user tries to delete a
+        vocabulary without giving the vocabulary id.
+
+        '''
+        params = {}
+        param_string = json.dumps(params)
+        response = self.app.post('/api/action/vocabulary_delete',
+                params=param_string,
+                extra_environ = {'Authorization':
+                    str(self.sysadmin_user.apikey)},
+                status=409)
+        assert response.json['success'] == False
+        assert response.json['error'].has_key('id')
+        assert response.json['error']['id'] == 'id not in data'
+
     def test_vocabulary_delete_not_logged_in(self):
         '''Test that users who are not logged in cannot delete vocabularies.'''
         params = {'id': self.genre_vocab['id']}

From 8b20b91da9e238fd7142d4a120ac87d591c9d1b7 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Fri, 17 Feb 2012 11:49:56 +0100
Subject: [PATCH 71/72] Tweak tag_delete() error messages

Make them more consistent with those of other logic functions
---
 ckan/logic/action/delete.py                        |  4 ++--
 ckan/tests/functional/api/model/test_vocabulary.py | 12 +++++++-----
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/ckan/logic/action/delete.py b/ckan/logic/action/delete.py
index ab35bcf3101..df89cc85e6f 100644
--- a/ckan/logic/action/delete.py
+++ b/ckan/logic/action/delete.py
@@ -123,7 +123,7 @@ def tag_delete(context, data_dict):
     model = context['model']
 
     if not data_dict.has_key('id') or not data_dict['id']:
-        raise ParameterError(_("Missing 'id' parameter."))
+        raise ValidationError({'id': _('id not in data')})
     tag_id_or_name = data_dict['id']
 
     vocab_id_or_name = data_dict.get('vocabulary_id')
@@ -131,7 +131,7 @@ def tag_delete(context, data_dict):
     tag_obj = model.tag.Tag.get(tag_id_or_name, vocab_id_or_name)
 
     if tag_obj is None:
-        raise NotFound
+        raise NotFound(_('Could not find tag "%s"') % tag_id_or_name)
 
     check_access('tag_delete', context, data_dict)
 
diff --git a/ckan/tests/functional/api/model/test_vocabulary.py b/ckan/tests/functional/api/model/test_vocabulary.py
index d537bf44e5d..77c0f18062a 100644
--- a/ckan/tests/functional/api/model/test_vocabulary.py
+++ b/ckan/tests/functional/api/model/test_vocabulary.py
@@ -691,8 +691,8 @@ def test_delete_tag_no_id(self):
                         str(self.sysadmin_user.apikey)},
                     status=409)
             assert response.json['success'] == False
-            msg = response.json['error']['message']
-            assert msg == u"Parameter Error: Missing 'id' parameter.", msg
+            assert response.json['error'].has_key('id')
+            assert response.json['error']['id'] == 'id not in data'
 
     def test_delete_tag_no_vocab(self):
         '''Test the error response when a user tries to delete a vocab tag
@@ -714,7 +714,8 @@ def test_delete_tag_no_vocab(self):
                     status=404)
             assert response.json['success'] == False
             msg = response.json['error']['message']
-            assert msg == u"Not found", msg
+            assert msg == u'Not found: Could not find tag "%s"' % tag['name'], \
+                    msg
 
     def test_delete_tag_not_exists(self):
         '''Test the error response when a user tries to delete a from a vocab
@@ -733,7 +734,8 @@ def test_delete_tag_not_exists(self):
                 status=404)
         assert response.json['success'] == False
         msg = response.json['error']['message']
-        assert msg == u"Not found", msg
+        assert msg == u'Not found: Could not find tag "%s"' % 'nonexistent', \
+                msg
 
     def test_delete_tag_vocab_not_exists(self):
         '''Test the error response when a user tries to delete a from a vocab
@@ -773,7 +775,7 @@ def test_delete_tag_invalid_tag(self):
                     status=404)
             assert response.json['success'] == False
             msg = response.json['error']['message']
-            assert msg == u"Not found", msg
+            assert msg == u'Not found: Could not find tag "%s"' % tag_name, msg
 
     def test_delete_tag_invalid_vocab(self):
         '''Test the error response when a user tries to delete a tag but gives

From 277dc15a60bdd9f9355b3b7614cd87f07eb57806 Mon Sep 17 00:00:00 2001
From: Sean Hammond <seanhammond@lavabit.com>
Date: Fri, 17 Feb 2012 11:50:29 +0100
Subject: [PATCH 72/72] Remove some unnecessary lines of code

---
 ckan/logic/action/get.py    | 2 --
 ckan/logic/action/update.py | 5 ++---
 2 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/ckan/logic/action/get.py b/ckan/logic/action/get.py
index 99e5491f653..edd56409190 100644
--- a/ckan/logic/action/get.py
+++ b/ckan/logic/action/get.py
@@ -210,7 +210,6 @@ def tag_list(context, data_dict):
 
     '''
     model = context['model']
-    user = context['user']
 
     vocab_id_or_name = data_dict.get('vocabulary_id')
     query = data_dict.get('query') or data_dict.get('q')
@@ -448,7 +447,6 @@ def tag_show(context, data_dict):
     '''Shows tag details'''
 
     model = context['model']
-    api = context.get('api_version') or '1'
     id = data_dict['id']
 
     tag = model.Tag.get(id)
diff --git a/ckan/logic/action/update.py b/ckan/logic/action/update.py
index 53dd049f018..84793fae2b6 100644
--- a/ckan/logic/action/update.py
+++ b/ckan/logic/action/update.py
@@ -615,13 +615,11 @@ def group_update_rest(context, data_dict):
 
 def vocabulary_update(context, data_dict):
     model = context['model']
+
     vocab_id = data_dict.get('id')
     if not vocab_id:
         raise ValidationError({'id': _('id not in data')})
 
-    model.Session.remove()
-    model.Session()._context = context
-
     vocab = model.vocabulary.Vocabulary.get(vocab_id)
     if vocab is None:
         raise NotFound(_('Could not find vocabulary "%s"') % vocab_id)
@@ -639,6 +637,7 @@ def vocabulary_update(context, data_dict):
 
     if not context.get('defer_commit'):
         model.repo.commit()
+
     return vocabulary_dictize(updated_vocab, context)
 
 def package_relationship_update_rest(context, data_dict):