Changeset 857:2a85b3f15ff9

Show
Ignore:
Timestamp:
03/10/10 12:40:08 (6 months ago)
Author:
johnbywater
Branch:
default
Parents:
856:53f62c87b551 (diff), 855:68630d75f031 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge.

Location:
ckan
Files:
16 modified

Legend:

Unmodified
Added
Removed
  • ckan/getdata/cospread.py

    r850 r857  
    140140                           _dict['%s - standard' % field] == 'Other (specify)' else \ 
    141141                           _dict['%s - standard' % field] 
    142         if 'HESA' in _dict['licence']: 
    143             license_str = u'OKD Compliant::Higher Education Statistics Agency Copyright with data.gov.uk rights' 
    144         else: 
    145             license_str = u'OKD Compliant::UK Crown Copyright with data.gov.uk rights' 
     142        #if 'HESA' in _dict['licence']: 
     143        #    license_title = u'OKD Compliant::Higher Education Statistics Agency Copyright with data.gov.uk rights' 
     144        #else: 
     145        #    license_title = u'OKD Compliant::UK Crown Copyright with data.gov.uk rights' 
    146146 
    147147        # extras 
     
    240240            pkg.add_resource(resource['url'], format=format, description=resource['description']) 
    241241        pkg.notes=notes 
    242         pkg.license = model.License.by_name(license_str) 
     242        pkg.license_id = u'dsl' # Todo: Fix this. model.License.by_name(license_str) 
    243243        assert pkg.license 
    244244        if not existing_pkg: 
  • ckan/getdata/cospread.py

    r856 r857  
    299299            group = model.Group(name=self._groupname) 
    300300            model.Session.add(group) 
     301            user = model.User.by_name(self._username) 
     302            model.setup_default_user_roles(group, [user]) 
    301303 
    302304    def _new_revision(self): 
  • ckan/getdata/data4nr.py

    r850 r857  
    123123        pkg.add_resource(res_url, description=res_description) 
    124124        pkg.notes=notes 
    125         license_str = u'OKD Compliant::UK Crown Copyright with data.gov.uk rights' 
    126         pkg.license = model.License.by_name(license_str) 
     125        pkg.license_id = u'dsl' # Todo: Fix this. 
    127126        if not existing_pkg: 
    128127            user = model.User.by_name(self._username) 
  • ckan/getdata/data4nr.py

    r856 r857  
    188188            group = model.Group(name=self._groupname) 
    189189            model.Session.add(group) 
     190            user = model.User.by_name(self._username) 
     191            model.setup_default_user_roles(group, [user]) 
    190192 
    191193        self._existing_pkgs = [] 
  • ckan/getdata/ons_import.py

    r850 r857  
    119119        pkg.title = title 
    120120        pkg.notes = '\n\n'.join(notes_list) 
    121         pkg.license = model.Session.query(model.License).get(self._crown_license_id) 
     121        pkg.license_id = self._crown_license_id 
    122122        pkg.extras = extras 
    123123        if extras['department']: 
     
    190190        self._item_count = 0 
    191191        self._new_package_count = 0 
    192         license_str = u'OKD Compliant::UK Crown Copyright with data.gov.uk rights' 
    193         self._crown_license_id = model.License.by_name(license_str).id 
     192        self._crown_license_id = u'dsl' # Todo: Fix this. 
    194193 
    195194 
  • ckan/getdata/ons_import.py

    r856 r857  
    208208            group = model.Group(name=groupname) 
    209209            model.Session.add(group) 
     210            user = model.User.by_name(username) 
     211            model.setup_default_user_roles(group, [user]) 
    210212 
    211213        if model.Session.new: 
  • ckan/lib/create_test_data.py

    r850 r857  
    108108                        pkg.groups.append(group) 
    109109                elif attr == 'license': 
    110                     license = model.License.by_name(val) 
    111                     pkg.license = license 
     110                    pkg.license_id = val 
    112111                elif attr == 'license_id': 
    113                     license = model.Session.query(model.License).get(val) 
    114                     pkg.license = license 
     112                    pkg.license_id = val 
    115113                elif attr == 'extras': 
    116114                    pkg.extras = val 
     
    204202        pkg2.tags = [ tag1 ] 
    205203        self.tag_names = [u'russian', u'tolstoy'] 
    206         license1 = model.License.by_name(u'OKD Compliant::Other') 
    207         pkg1.license = license1 
     204        pkg1.license_id = u'agpl-v3' 
    208205        pkg2.title = u'A Wonderful Story' 
    209206        genre_extra = model.PackageExtra(key=u'genre', value='romantic novel') 
     
    284281              'tags':'registry  country-usa  government  federal  gov  workshop-20081101', 
    285282              'groups':'ukgov test1 test2 penguin', 
    286               'license':'OKD Compliant::Other', 
     283              'license':'agpl-v3', 
    287284              'notes':'''From <http://www.gpoaccess.gov/gils/about.html> 
    288285               
     
    297294              'tags':'images  graphics  photographs  photos  pictures  us  usa  america  history  wildlife  nature  war  military  todo-split  gov', 
    298295              'groups':'ukgov test1 penguin', 
    299               'license':'OKD Compliant::Other', 
     296              'license':'agpl-v3', 
    300297              'notes':'''## About 
    301298 
     
    313310              'tags':'us  courts  case-law  us  courts  case-law  gov  legal  law  access-bulk  penguins penguin', 
    314311              'groups':'ukgov test2 penguin', 
    315               'license':'OKD Compliant::Creative Commons CCZero', 
     312              'license':'cc-zero', 
    316313              'notes':'''### Description 
    317314 
     
    335332              'groups':'penguin',               
    336333              'tags':'country-sweden  format-pdf  access-www  documents  publications  government  eutransparency', 
    337               'license':'Other::License Not Specified', 
     334              'license':'', 
    338335              'notes':'''### About 
    339336 
     
    351348              'download_url':'http://www.opengov.se/data/open/', 
    352349              'tags':'country-sweden  government  data', 
    353               'license':'OKD Compliant::Creative Commons Attribution-ShareAlike', 
     350              'license':'cc-by-sa', 
    354351              'notes':'''### About 
    355352 
     
    379376     'author':'DCSF Data Services Group', 
    380377     'author_email':'statistics@dcsf.gsi.gov.uk', 
    381      'license':'Non-OKD Compliant::Crown Copyright', 
     378     'license':'dsl', 
    382379     'tags':'children fostering', 
    383380     'extras':{ 
     
    406403     'author':'DECC Energy Statistics Team', 
    407404     'author_email':'energy.stats@decc.gsi.gov.uk', 
    408      'license':'Non-OKD Compliant::Crown Copyright', 
     405     'license':'dsl', 
    409406     'tags':'fuel prices', 
    410407     'extras':{ 
  • ckan/lib/create_test_data.py

    r856 r857  
    5656        self.pkg_names = [] 
    5757        self.tag_names = [] 
    58         self.group_names = [] 
     58        self.group_names = set() 
    5959        self.user_names = extra_user_names 
    6060        admins_list = [] # list of (package_name, admin_names) 
     
    104104                        if not group: 
    105105                            group = model.Group(name=group_name) 
    106                             self.group_names.append(group_name) 
     106                            self.group_names.add(group_name) 
    107107                            model.Session.add(group) 
    108108                        pkg.groups.append(group) 
     
    129129            user = model.User(name=unicode(user_name)) 
    130130            model.Session.add(user) 
     131        for group_name in self.group_names: 
     132            model.setup_default_user_roles(group) 
    131133        model.repo.commit_and_remove() 
    132134 
  • ckan/lib/package_saver.py

    r854 r857  
    7373        # remove everything from session so nothing can get saved accidentally 
    7474        model.Session.clear() 
    75         # license field's _id only updated, not object.id, so cludge that: 
    76         if fs.model.license_id: 
    77             fs.model.license = model.Session.query(model.License).get(fs.model.license_id) 
    7875        return out 
    7976 
  • ckan/lib/package_saver.py

    r856 r857  
    1717                       log_message=None, 
    1818                       author=None): 
    19         'Renders a package on the basis of a fieldset - perfect for preview' 
     19        '''Renders a package on the basis of a fieldset - perfect for 
     20        preview of form data. 
     21        Note that the actual calling of render('package/read') is left 
     22        to the caller.''' 
    2023        pkg = cls._preview_pkg(fs, original_name, record_id, 
    2124                               log_message, author) 
     
    2528    @classmethod 
    2629    def render_package(cls, pkg): 
    27         'Renders a package' 
     30        '''Prepares for rendering a package. Takes a Package object and 
     31        formats it for the various context variables required to call 
     32        render.  
     33        Note that the actual calling of render('package/read') is left 
     34        to the caller.''' 
    2835        c.pkg = pkg 
    2936        notes_formatted = ckan.misc.MarkdownFormat().to_html(pkg.notes) 
     
    3340        c.pkg_author_link = cls._person_email_link(c.pkg.author, c.pkg.author_email, "Author") 
    3441        c.pkg_maintainer_link = cls._person_email_link(c.pkg.maintainer, c.pkg.maintainer_email, "Maintainer") 
     42        c.package_relationships = pkg.relationships_printable() 
    3543        # c.auth_for_change_state and c.auth_for_edit may also used 
    3644        # return render('package/read') 
     
    5765            fs.model.groups 
    5866            fs.model.ratings 
     67            fs.model.relationships_as_subject 
     68            fs.model.relationships_as_object 
    5969        except ValidationException, e: 
    6070            # remove everything from session so nothing can get saved accidentally 
  • ckan/lib/search.py

    r848 r857  
    55 
    66import ckan.model as model 
    7 from licenses import LicenseList 
     7 
    88from ckan import authz 
    99 
     
    277277        return query 
    278278         
    279     def _update_open_licenses(self): 
     279    def _update_open_licenses(self):  # Update, or init? 
    280280        self._open_licenses = [] 
    281         for license_name in LicenseList.all_formatted: 
    282             _license = model.License.by_name(license_name, autoflush=False) 
    283             if _license and _license.isopen():                 
    284                 self._open_licenses.append(_license.id) 
     281        for license in model.Package.get_license_register().values(): 
     282            if license and license.isopen(): 
     283                self._open_licenses.append(license.id) 
    285284 
    286285    def _format_results(self): 
  • ckan/lib/search.py

    r856 r857  
    55 
    66import ckan.model as model 
     7 
     8from ckan import authz 
    79 
    810ENABLE_CACHING = bool(config.get('enable_caching', '')) 
     
    6062        return self.run(options) 
    6163 
    62     def query(self, options): 
     64    def query(self, options, username=None): 
    6365        '''For the given search options, returns a query object.''' 
    6466        self._options = options 
     
    7072 
    7173        if self._options.entity == 'package': 
    72             query = self._build_package_query(general_terms, field_specific_terms) 
     74            query = authz.Authorizer().authorized_query(username, model.Package) 
     75            query = self._build_package_query(query, general_terms, field_specific_terms) 
    7376        elif self._options.entity == 'tag': 
    7477            query = self._build_tags_query(general_terms) 
    7578        elif self._options.entity == 'group': 
    76             query = self._build_groups_query(general_terms) 
     79            query = authz.Authorizer().authorized_query(username, model.Group) 
     80            query = self._build_groups_query(query, general_terms) 
    7781        else: 
    7882            # error 
     
    8084        return query 
    8185 
    82     def run(self, options): 
     86    def run(self, options, username=None): 
    8387        '''For the given search options, returns query results.''' 
    84         query = self.query(options) 
     88        query = self.query(options, username) 
    8589 
    8690        self._results = {} 
     
    151155        return general_terms, field_specific_terms 
    152156 
    153     def _build_package_query(self, general_terms, field_specific_terms): 
     157    def _build_package_query(self, authorized_package_query, 
     158                             general_terms, field_specific_terms): 
    154159        make_like = lambda x,y: x.ilike('%' + y + '%') 
    155         query = model.Session.query(model.Package) 
     160        query = authorized_package_query 
    156161        query = query.filter(model.package_search_table.c.package_id==model.Package.id) 
    157162 
     
    206211 
    207212        query = query.distinct() 
    208         query = query.filter(model.Package.state == model.State.ACTIVE) 
    209213        return query 
    210214 
     
    215219        return query 
    216220 
    217     def _build_groups_query(self, general_terms): 
    218         query = model.Session.query(model.Group) 
     221    def _build_groups_query(self, authorized_package_query, general_terms): 
     222        query = authorized_package_query 
    219223        for term in general_terms: 
    220224            query = query.filter(model.Group.name.contains(term.lower())) 
  • ckan/model/core.py

    r854 r857  
    77from types import make_uuid 
    88import full_search 
     9from license import License, LicenseRegister 
    910 
    1011## VDM-specific tables 
     
    1314 
    1415## Our Domain Object Tables 
    15  
    16 license_table = Table('license', metadata, 
    17         Column('id', types.Integer, primary_key=True), 
    18         Column('name', types.Unicode(100)), 
    19         ) 
    2016 
    2117package_table = Table('package', metadata, 
     
    3026        Column('maintainer_email', types.UnicodeText),                       
    3127        Column('notes', types.UnicodeText), 
    32         Column('license_id', types.Integer, ForeignKey('license.id')), 
     28        Column('license_id', types.UnicodeText), 
    3329) 
    3430 
     
    4541 
    4642 
    47 vdm.sqlalchemy.make_table_stateful(license_table) 
    4843vdm.sqlalchemy.make_table_stateful(package_table) 
    4944vdm.sqlalchemy.make_table_stateful(package_tag_table) 
     
    117112        return self.__unicode__() 
    118113 
    119          
    120 class License(DomainObject): 
    121     def isopen(self): 
    122         if self.name and \ 
    123            (self.name.startswith('OKD Compliant') 
    124             or 
    125             self.name.startswith('OSI Approved') 
    126             ): 
    127             return True 
    128         return False 
    129114 
    130115class Package(vdm.sqlalchemy.RevisionedObjectMixin, 
     
    181166        _dict['groups'] = [group.name for group in self.groups] 
    182167        if self.license: 
    183             _dict['license'] = self.license.name 
     168            _dict['license'] = self.license.id 
    184169        else: 
    185170            _dict['license'] = '' 
     
    207192        else: 
    208193            raise NotImplementedError, 'Package relationship type: %r' % type_ 
    209  
     194             
     195             
    210196        rel = package_relationship.PackageRelationship( 
    211197            subject=subject, 
     
    252238                    rel_list.append((child_pkg, type_printable)) 
    253239        return rel_list 
     240    # 
     241    ## Licenses are currently integrated into the domain model here.    
     242  
     243    @classmethod 
     244    def get_license_register(self): 
     245        if not hasattr(self, '_license_register'): 
     246            self._license_register = LicenseRegister() 
     247        return self._license_register 
     248 
     249    @classmethod 
     250    def get_license_options(self): 
     251        register = self.get_license_register() 
     252        return [(l.title, l.id) for l in register.values()] 
     253 
     254    def get_license(self): 
     255        license = None 
     256        if self.license_id: 
     257            license = self.get_license_register()[self.license_id] 
     258        return license 
     259 
     260    def set_license(self, license): 
     261        if type(license) == License: 
     262            self.license_id = license.id 
     263        elif type(license) == dict: 
     264            self.license_id = license['id'] 
     265        else: 
     266            msg = "Value not a license object or entity: %s" % repr(license) 
     267            raise Exception, msg 
     268 
     269    license = property(get_license, set_license) 
     270 
    254271 
    255272class Tag(DomainObject): 
     
    299316Revision = vdm.sqlalchemy.make_Revision(mapper, revision_table) 
    300317 
    301 mapper(License, license_table, 
    302     order_by=license_table.c.id) 
    303  
    304318mapper(Package, package_table, properties={ 
    305     'license':relation(License), 
    306319    # delete-orphan on cascade does NOT work! 
    307320    # Why? Answer: because of way SQLAlchemy/our code works there are points 
  • ckan/model/core.py

    r856 r857  
    205205        return self.relationships_as_subject + self.relationships_as_object 
    206206 
     207    def relationships_printable(self): 
     208        '''Returns a list of tuples describing related packages, including 
     209        non-direct relationships (such as siblings). 
     210        @return: e.g. [(annakarenina, u"is a parent"), ...] 
     211        ''' 
     212        from package_relationship import PackageRelationship 
     213        rel_list = [] 
     214        # forward types 
     215        for rel_as_subject in self.relationships_as_subject: 
     216            type_printable = PackageRelationship.make_type_printable(rel_as_subject.type) 
     217            rel_list.append((rel_as_subject.object, type_printable)) 
     218        # reverse types 
     219        for rel_as_object in self.relationships_as_object: 
     220            type_printable = PackageRelationship.make_type_printable(\ 
     221                PackageRelationship.forward_to_reverse_type( 
     222                    rel_as_object.type) 
     223                ) 
     224            rel_list.append((rel_as_object.subject, type_printable)) 
     225        # sibling types 
     226        # e.g. 'gary' is a child of 'mum', looking for 'bert' is a child of 'mum' 
     227        # i.e. for each 'child_of' type relationship ... 
     228        for rel_as_subject in self.relationships_as_subject: 
     229            # ... parent is the object 
     230            parent_pkg = rel_as_subject.object 
     231            # Now look for the parent's other relationships as object ... 
     232            for parent_rel_as_object in parent_pkg.relationships_as_object: 
     233                # and check children 
     234                child_pkg = parent_rel_as_object.subject 
     235                if child_pkg != self and \ 
     236                       parent_rel_as_object.type == rel_as_subject.type: 
     237                    type_printable = PackageRelationship.inferred_types_printable['sibling'] 
     238                    rel_list.append((child_pkg, type_printable)) 
     239        return rel_list 
    207240    # 
    208241    ## Licenses are currently integrated into the domain model here.    
  • ckan/templates/package/read_core.html

    r854 r857  
    2020        <dt>${package_license_icon(c.pkg)}</dt> 
    2121        <py:choose test=""> 
    22           <dd py:when="c.pkg.license">${c.pkg.license.name} 
    23           </dd> 
     22          <dd py:when="c.pkg.license">${c.pkg.license.title}</dd> 
    2423          <dd py:otherwise=""> 
    2524            License not given 
     
    7675          <p py:when="c.pkg.license"> 
    7776            This package is licensed 
    78             <strong>${c.pkg.license.name}</strong>. 
     77            <strong>${c.pkg.license.title}</strong>. 
    7978          </p> 
    8079          <p py:otherwise=""> 
  • ckan/templates/package/read_core.html

    r856 r857  
    2828        <dd>${"Resources available for download" if c.pkg.resources else "No resources given"}</dd> 
    2929      </dl> 
     30        <py:if test="c.package_relationships"> 
     31          <h3>Related packages</h3> 
     32          <ul> 
     33            <py:for each="pkg, relationship_str in c.package_relationships"> 
     34              <li>${h.literal(relationship_str % (h.link_to(pkg.name, h.url_for(controller="package", action="read", id=pkg.name))))}</li> 
     35            </py:for> 
     36          </ul> 
     37        </py:if> 
    3038    </div> 
    3139 

0.9.0.3 © 2008-2010 agile42 all rights reserved (this page was served in: 1.70753 sec.)