projects / ckanext-datagovau.git / commitdiff
search:
summary | shortlog | log | commit | commitdiff | tree
unified | plain
initial commit
initial commit

file:b/.idea/other.xml (new)
  <?xml version="1.0" encoding="UTF-8"?>
  <project version="4">
  <component name="PyDocumentationSettings">
  <option name="myDocStringFormat" value="Plain" />
  </component>
  </project>
 
 
file:b/.idea/testrunner.xml (new)
  <?xml version="1.0" encoding="UTF-8"?>
  <project version="4">
  <component name="TestRunnerService">
  <option name="projectConfiguration" value="Unittests" />
  <option name="PROJECT_TEST_RUNNER" value="Unittests" />
  </component>
  </project>
 
 
file:a/README.rst -> file:b/README.rst
This CKAN Extension demonstrates some common patterns for customising a CKAN instance. This CKAN Extension customises a CKAN instance for the hosting of data.gov.au.
   
It comprises: It comprises:
   
* A CKAN Extension "plugin" at ``ckanext/example/plugin.py`` which, when * A CKAN Extension "plugin" at ``ckanext/datagovau/plugin.py`` which, when
loaded, overrides various settings in the core ``ini``-file to provide: loaded, overrides various settings in the core ``ini``-file to provide:
  * A path to local customisations of the core templates and available licenses database
* A path to local customisations of the core templates and stylesheets * A custom Package edit form
* A "stream filter" that replaces arbitrary strings in rendered templates * A custom n3/rdf output format
* A "route" to override and extend the default behaviour of a core CKAN page  
   
* A custom Pylons controller for overriding some core CKAN behaviour  
   
* A custom Package edit form  
   
* A custom User registration and edition form  
   
* Some simple template customisations  
   
Installation Installation
============ ============
   
To install this package, from your CKAN virtualenv, run the following from your CKAN base folder (e.g. ``pyenv/``):: To install this package, from your CKAN virtualenv, run the following from your CKAN base folder (e.g. ``pyenv/``)::
   
pip install -e git+https://github.com/okfn/ckanext-example#egg=ckanext-example pip install -e git+https://github.com/okfn/ckanext-datagovau#egg=ckanext-datagovau
   
Then activate it by setting ``ckan.plugins = example`` in your main ``ini``-file. Then activate it by setting ``ckan.plugins = datagovau`` in your main ``ini``-file.
   
   
Orientation  
===========  
   
* Examine the source code, starting with ``ckanext/example/plugin.py``  
   
* To understand the nuts and bolts of this file, which is a CKAN  
*Extension*, read in conjunction with the "Extension  
documentation": http://docs.ckan.org/en/latest/plugins.html  
   
* One thing the extension does is set the values of  
``extra_public_paths`` and ``extra_template_paths`` in the CKAN  
config, which are "documented  
here": http://docs.ckan.org/en/latest/configuration.html#extra-template-paths  
   
* These are set to point at directories within  
``ckanext/example/theme/`` (in this package). Here we:  
* override the home page HTML ``ckanext/example/theme/templates/home/index.html``  
* provide some extra style by serving ``extra.css`` (which is loaded using the ``ckan.template_head_end`` option  
* customise the navigation and header of the main template in the file ``layout.html``.  
   
The latter file is a great place to make global theme alterations.  
It uses the _layout template_ pattern "described in the Genshi  
documentation":http://genshi.edgewall.org/wiki/GenshiTutorial#AddingaLayoutTemplate.  
This allows you to use Xpath selectors to override snippets of HTML  
globally.  
   
* The custom package edit form at ``package_form.py`` follows a deprecated  
way to make a form (using FormAlchemy). This part of the Example Theme needs  
updating. In the meantime, follow the instructions at:  
http://readthedocs.org/docs/ckan/en/latest/forms.html  
   
   
file:b/ckanext-datagovau.iml (new)
  <?xml version="1.0" encoding="UTF-8"?>
  <module type="PYTHON_MODULE" version="4">
  <component name="NewModuleRootManager" inherit-compiler-output="true">
  <exclude-output />
  <content url="file://$MODULE_DIR$">
  <sourceFolder url="file://$MODULE_DIR$" isTestSource="false" />
  </content>
  <orderEntry type="inheritedJdk" />
  <orderEntry type="sourceFolder" forTests="false" />
  </component>
  </module>
 
 
file:b/ckanext/datagovau/templates/package/read_base.html (new)
  {% ckan_extends %}
 
  {% block subtitle %}{{ pkg.title or pkg.name }}{% endblock %}
 
  {% block links -%}
  {{ super() }}
  <link rel="lol" type="test"/>
  {% endblock -%}
 
  {% block head_extras -%}
  {{ super() }}
  <meta property="og:gon" content="lol">
  {% endblock -%}
 
 
file:a/ckanext/example/__init__.py (deleted)
# package  
 
file:a/ckanext/example/controller.py (deleted)
import sys  
from ckan.lib.base import request  
from ckan.lib.base import c, g, h  
from ckan.lib.base import model  
from ckan.lib.base import render  
from ckan.lib.base import _  
 
from ckan.lib.navl.validators import not_empty  
 
from ckan.controllers.user import UserController  
 
 
class CustomUserController(UserController):  
"""This controller is an example to show how you might extend or  
override core CKAN behaviour from an extension package.  
 
It overrides 2 method hooks which the base class uses to create the  
validation schema for the creation and editing of a user; to require  
that a fullname is given.  
"""  
 
new_user_form = 'user/register.html'  
 
def _add_requires_full_name_to_schema(self, schema):  
"""  
Helper function that modifies the fullname validation on an existing schema  
"""  
schema['fullname'] = [not_empty, unicode]  
 
def _new_form_to_db_schema(self):  
"""  
Defines a custom schema that requires a full name to be supplied  
 
This method is a hook that the base class calls for the validation  
schema to use when creating a new user.  
"""  
schema = super(CustomUserController, self)._new_form_to_db_schema()  
self._add_requires_full_name_to_schema(schema)  
return schema  
 
def _edit_form_to_db_schema(self):  
"""  
Defines a custom schema that requires a full name cannot be removed  
when editing the user.  
 
This method is a hook that the base class calls for the validation  
schema to use when editing an exiting user.  
"""  
schema = super(CustomUserController, self)._edit_form_to_db_schema()  
self._add_requires_full_name_to_schema(schema)  
return schema  
 
 
file:a/ckanext/example/controller_plugin.py (deleted)
import logging  
from ckan.lib.base import BaseController, render, c, model, abort, request  
from ckan.lib.base import redirect, _, config, h  
import ckan.logic.action.create as create  
import ckan.logic.action.update as update  
import ckan.logic.action.get as get  
from ckan.logic.converters import date_to_db, date_to_form, convert_to_extras, convert_from_extras  
from ckan.lib.navl.dictization_functions import DataError, flatten_dict, unflatten  
from ckan.logic import NotFound, NotAuthorized, ValidationError  
from ckan.logic import tuplize_dict, clean_dict, parse_params  
from ckan.logic.schema import package_form_schema  
from ckan.plugins import IDatasetForm  
from ckan.plugins import implements, SingletonPlugin  
from ckan.lib.package_saver import PackageSaver  
from ckan.lib.field_types import DateType, DateConvertError  
from ckan.authz import Authorizer  
from ckan.lib.navl.dictization_functions import Invalid  
from ckanext.dgu.forms.package_gov_fields import GeoCoverageType  
from ckan.lib.navl.dictization_functions import validate, missing  
import ckan.logic.validators as val  
import ckan.logic.schema as default_schema  
from ckan.lib.navl.validators import (ignore_missing,  
not_empty,  
empty,  
ignore,  
keep_extras,  
)  
 
log = logging.getLogger(__name__)  
 
geographic_granularity = [('', ''),  
('national', 'national'),  
('regional', 'regional'),  
('local authority', 'local authority'),  
('ward', 'ward'),  
('point', 'point'),  
('other', 'other - please specify')]  
 
update_frequency = [('', ''),  
('never', 'never'),  
('discontinued', 'discontinued'),  
('annual', 'annual'),  
('quarterly', 'quarterly'),  
('monthly', 'monthly'),  
('other', 'other - please specify')]  
 
temporal_granularity = [("",""),  
("year","year"),  
("quarter","quarter"),  
("month","month"),  
("week","week"),  
("day","day"),  
("hour","hour"),  
("point","point"),  
("other","other - please specify")]  
 
 
class ExamplePackageController(SingletonPlugin):  
 
implements(IDatasetForm, inherit=True)  
 
def package_form(self):  
return 'controller/package_plugin.html'  
 
def is_fallback(self):  
"""  
Returns true iff this provides the fallback behaviour, when no other  
plugin instance matches a package's type.  
 
As this is not the fallback controller we should return False. If  
we were wanting to act as the fallback, we'd return True  
"""  
return False  
 
def package_types(self):  
"""  
Returns an iterable of package type strings.  
 
If a request involving a package of one of those types is made, then  
this plugin instance will be delegated to.  
 
There must only be one plugin registered to each package type. Any  
attempts to register more than one plugin instance to a given package  
type will raise an exception at startup.  
"""  
return ["example"]  
 
def _setup_template_variables(self, context, data_dict=None):  
c.licences = [('', '')] + model.Package.get_license_options()  
c.geographic_granularity = geographic_granularity  
c.update_frequency = update_frequency  
c.temporal_granularity = temporal_granularity  
 
c.publishers = self.get_publishers()  
 
c.is_sysadmin = Authorizer().is_sysadmin(c.user)  
c.resource_columns = model.Resource.get_columns()  
 
## This is messy as auths take domain object not data_dict  
pkg = context.get('package') or c.pkg  
if pkg:  
c.auth_for_change_state = Authorizer().am_authorized(  
c, model.Action.CHANGE_STATE, pkg)  
 
def _form_to_db_schema(self):  
 
schema = {  
'title': [not_empty, unicode],  
'name': [not_empty, unicode, val.name_validator, val.package_name_validator],  
'notes': [not_empty, unicode],  
 
'date_released': [date_to_db, convert_to_extras],  
'date_updated': [date_to_db, convert_to_extras],  
'date_update_future': [date_to_db, convert_to_extras],  
'update_frequency': [use_other, unicode, convert_to_extras],  
'update_frequency-other': [],  
'precision': [unicode, convert_to_extras],  
'geographic_granularity': [use_other, unicode, convert_to_extras],  
'geographic_granularity-other': [],  
'geographic_coverage': [ignore_missing, convert_geographic_to_db, convert_to_extras],  
'temporal_granularity': [use_other, unicode, convert_to_extras],  
'temporal_granularity-other': [],  
'temporal_coverage-from': [date_to_db, convert_to_extras],  
'temporal_coverage-to': [date_to_db, convert_to_extras],  
'url': [unicode],  
'taxonomy_url': [unicode, convert_to_extras],  
 
'resources': default_schema.default_resource_schema(),  
 
'published_by': [not_empty, unicode, convert_to_extras],  
'published_via': [ignore_missing, unicode, convert_to_extras],  
'author': [ignore_missing, unicode],  
'author_email': [ignore_missing, unicode],  
'mandate': [ignore_missing, unicode, convert_to_extras],  
'license_id': [ignore_missing, unicode],  
'tag_string': [ignore_missing, val.tag_string_convert],  
'national_statistic': [ignore_missing, convert_to_extras],  
'state': [val.ignore_not_admin, ignore_missing],  
 
'log_message': [unicode, val.no_http],  
 
'__extras': [ignore],  
'__junk': [empty],  
}  
return schema  
 
def _db_to_form_schema(data):  
schema = {  
'date_released': [convert_from_extras, ignore_missing, date_to_form],  
'date_updated': [convert_from_extras, ignore_missing, date_to_form],  
'date_update_future': [convert_from_extras, ignore_missing, date_to_form],  
'update_frequency': [convert_from_extras, ignore_missing, extract_other(update_frequency)],  
'precision': [convert_from_extras, ignore_missing],  
'geographic_granularity': [convert_from_extras, ignore_missing, extract_other(geographic_granularity)],  
'geographic_coverage': [convert_from_extras, ignore_missing, convert_geographic_to_form],  
'temporal_granularity': [convert_from_extras, ignore_missing, extract_other(temporal_granularity)],  
'temporal_coverage-from': [convert_from_extras, ignore_missing, date_to_form],  
'temporal_coverage-to': [convert_from_extras, ignore_missing, date_to_form],  
'taxonomy_url': [convert_from_extras, ignore_missing],  
 
'resources': default_schema.default_resource_schema(),  
'extras': {  
'key': [],  
'value': [],  
'__extras': [keep_extras]  
},  
'tags': {  
'__extras': [keep_extras]  
},  
 
'published_by': [convert_from_extras, ignore_missing],  
'published_via': [convert_from_extras, ignore_missing],  
'mandate': [convert_from_extras, ignore_missing],  
'national_statistic': [convert_from_extras, ignore_missing],  
'__extras': [keep_extras],  
'__junk': [ignore],  
}  
return schema  
 
def _check_data_dict(self, data_dict):  
return  
 
def get_publishers(self):  
return [('pub1', 'pub2')]  
 
 
def use_other(key, data, errors, context):<