diff --git a/ckan/model/modification.py b/ckan/model/modification.py index 1cd7b2ea6f9..ad48b4f023e 100644 --- a/ckan/model/modification.py +++ b/ckan/model/modification.py @@ -3,7 +3,6 @@ import ckan.plugins as plugins import extension import domain_object - import package as _package import resource diff --git a/ckan/model/package.py b/ckan/model/package.py index 17d869df3c8..8cd682d0466 100644 --- a/ckan/model/package.py +++ b/ckan/model/package.py @@ -1,23 +1,22 @@ import datetime -from time import gmtime from calendar import timegm -from operator import attrgetter import logging logger = logging.getLogger(__name__) -from sqlalchemy.sql import select, and_, union, expression, or_, desc +from sqlalchemy.sql import select, and_, union, or_ from sqlalchemy.orm import eagerload_all from sqlalchemy import types, Column, Table -from pylons import config, session, c, request -from meta import metadata, Session +from pylons import config import vdm.sqlalchemy -from core import make_revisioned_table, Revision, State -from license import License, LicenseRegister +import meta +import core +import license as _license import types as _types import domain_object import ckan.misc -from activity import Activity, ActivityDetail +import activity +import ckan.lib.dictization __all__ = ['Package', 'package_table', 'package_revision_table', 'PACKAGE_NAME_MAX_LENGTH', 'PACKAGE_NAME_MIN_LENGTH', @@ -28,7 +27,7 @@ PACKAGE_VERSION_MAX_LENGTH = 100 ## Our Domain Object Tables -package_table = Table('package', metadata, +package_table = Table('package', meta.metadata, Column('id', types.UnicodeText, primary_key=True, default=_types.make_uuid), Column('name', types.Unicode(PACKAGE_NAME_MAX_LENGTH), nullable=False, unique=True), @@ -46,7 +45,7 @@ vdm.sqlalchemy.make_table_stateful(package_table) -package_revision_table = make_revisioned_table(package_table) +package_revision_table = core.make_revisioned_table(package_table) ## ------------------- ## Mapped classes @@ -66,12 +65,12 @@ def __init__(self, **kw): @classmethod def search_by_name(cls, text_query): text_query = text_query - return Session.query(cls).filter(cls.name.contains(text_query.lower())) + return meta.Session.query(cls).filter(cls.name.contains(text_query.lower())) @classmethod def get(cls, reference): '''Returns a package object referenced by its id or name.''' - query = Session.query(cls).filter(cls.id==reference) + query = meta.Session.query(cls).filter(cls.id==reference) query = query.options(eagerload_all('package_tags.tag')) query = query.options(eagerload_all('resource_groups_all.resources_all')) pkg = query.first() @@ -121,7 +120,7 @@ def get_resource_identity(resource_obj_or_dict): assert isinstance(res_dict, dict) id = res_dict.get('id') if id: - res = Session.query(model.Resource).autoflush(autoflush).get(id) + res = meta.Session.query(model.Resource).autoflush(autoflush).get(id) if res: index_to_res[i] = res else: @@ -145,7 +144,7 @@ def get_resource_identity(resource_obj_or_dict): for key in set(res_dict.keys()) & set(('id', 'position')): del res_dict[key] res = model.Resource(**res_dict) - model.Session.add(res) + meta.Session.add(res) new_res_list.append(res) self.resource_groups[0].resources = new_res_list @@ -168,7 +167,7 @@ def add_tag(self, tag): return else: package_tag = model.PackageTag(self, tag) - model.Session.add(package_tag) + meta.Session.add(package_tag) def add_tags(self, tags): for tag in tags: @@ -209,7 +208,7 @@ def get_tags(self, vocab=None): """ import ckan.model as model - query = model.Session.query(model.Tag) + query = meta.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) @@ -226,12 +225,12 @@ def get_tags(self, vocab=None): def remove_tag(self, tag): import ckan.model as model - query = model.Session.query(model.PackageTag) + query = meta.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() + meta.Session.commit() def isopen(self): if self.license and self.license.isopen(): @@ -282,7 +281,6 @@ def add_relationship(self, type_, related_package, comment=u''): Raises KeyError if the type_ is invalid. ''' import package_relationship - from ckan import model if type_ in package_relationship.PackageRelationship.get_forward_types(): subject = self object_ = related_package @@ -300,7 +298,7 @@ def add_relationship(self, type_, related_package, comment=u''): rel = rels[0] if comment: rel.comment=comment - if rel.state == model.State.DELETED: + if rel.state == core.State.DELETED: rel.undelete() else: rel = package_relationship.PackageRelationship( @@ -308,7 +306,7 @@ def add_relationship(self, type_, related_package, comment=u''): object=object_, type=type_, comment=comment) - Session.add(rel) + meta.Session.add(rel) return rel def get_relationships(self, with_package=None, type=None, active=True, @@ -325,13 +323,13 @@ def get_relationships(self, with_package=None, type=None, active=True, forward_filters.append(PackageRelationship.object==with_package) reverse_filters.append(PackageRelationship.subject==with_package) if active: - forward_filters.append(PackageRelationship.state==State.ACTIVE) - reverse_filters.append(PackageRelationship.state==State.ACTIVE) + forward_filters.append(PackageRelationship.state==core.State.ACTIVE) + reverse_filters.append(PackageRelationship.state==core.State.ACTIVE) if type: forward_filters.append(PackageRelationship.type==type) reverse_type = PackageRelationship.reverse_type(type) reverse_filters.append(PackageRelationship.type==reverse_type) - q = Session.query(PackageRelationship) + q = meta.Session.query(PackageRelationship) if direction == 'both': q = q.filter(or_( and_(*forward_filters), @@ -369,19 +367,19 @@ def get_relationships_printable(self): # e.g. 'gary' is a child of 'mum', looking for 'bert' is a child of 'mum' # i.e. for each 'child_of' type relationship ... for rel_as_subject in self.get_relationships(direction='forward'): - if rel_as_subject.state != State.ACTIVE: + if rel_as_subject.state != core.State.ACTIVE: continue # ... parent is the object parent_pkg = rel_as_subject.object # Now look for the parent's other relationships as object ... for parent_rel_as_object in parent_pkg.get_relationships(direction='reverse'): - if parent_rel_as_object.state != State.ACTIVE: + if parent_rel_as_object.state != core.State.ACTIVE: continue # and check children child_pkg = parent_rel_as_object.subject if (child_pkg != self and parent_rel_as_object.type == rel_as_subject.type and - child_pkg.state == State.ACTIVE): + child_pkg.state == core.State.ACTIVE): type_printable = PackageRelationship.inferred_types_printable['sibling'] rel_list.append((child_pkg, type_printable, None)) return sorted(list(set(rel_list))) @@ -391,7 +389,7 @@ def get_relationships_printable(self): @classmethod def get_license_register(cls): if not hasattr(cls, '_license_register'): - cls._license_register = LicenseRegister() + cls._license_register = _license.LicenseRegister() return cls._license_register @classmethod @@ -410,7 +408,7 @@ def get_license(self): return license def set_license(self, license): - if type(license) == License: + if type(license) == _license.License: self.license_id = license.id elif type(license) == dict: self.license_id = license['id'] @@ -441,11 +439,11 @@ def all_related_revisions(self): for class_ in [ResourceGroup, Resource, PackageExtra, PackageTag]: rev_class = class_.__revision_class__ if class_ == Resource: - q = Session.query(rev_class).join('continuity', + q = meta.Session.query(rev_class).join('continuity', 'resource_group') obj_revisions = q.filter(ResourceGroup.package_id == self.id).all() else: - obj_revisions = Session.query(rev_class).filter_by(package_id=self.id).all() + obj_revisions = meta.Session.query(rev_class).filter_by(package_id=self.id).all() for obj_rev in obj_revisions: if not results.has_key(obj_rev.revision): results[obj_rev.revision] = [] @@ -476,16 +474,16 @@ def diff(self, to_revision=None, from_revision=None): obj_rev_class = obj_class.__revision_class__ # Query for object revisions related to this package if obj_class == Resource: - obj_rev_query = Session.query(obj_rev_class).\ + obj_rev_query = meta.Session.query(obj_rev_class).\ join('continuity', 'resource_group').\ join('revision').\ filter(ResourceGroup.package_id == self.id).\ - order_by(Revision.timestamp.desc()) + order_by(core.Revision.timestamp.desc()) else: - obj_rev_query = Session.query(obj_rev_class).\ + obj_rev_query = meta.Session.query(obj_rev_class).\ filter_by(package_id=self.id).\ join('revision').\ - order_by(Revision.timestamp.desc()) + order_by(core.Revision.timestamp.desc()) # Columns to include in the diff cols_to_diff = obj_class.revisioned_fields() cols_to_diff.remove('id') @@ -550,7 +548,7 @@ def metadata_modified(self): # Use current connection because we might be in a 'before_commit' of # a SessionExtension - only by using the current connection can we get # at the newly created revision etc. objects. - conn = model.Session.connection() + conn = meta.Session.connection() result = conn.execute(query).fetchone() if result: @@ -567,7 +565,7 @@ def is_in_group(self, group): def get_groups(self, group_type=None, capacity=None): import ckan.model as model if '_groups' not in self.__dict__: - self._groups = model.Session.query(model.Group).\ + self._groups = meta.Session.query(model.Group).\ join(model.Member, model.Member.group_id == model.Group.id and \ model.Member.table_name == 'package' ).\ join(model.Package, model.Package.id == model.Member.table_id).\ @@ -584,7 +582,7 @@ def get_groups(self, group_type=None, capacity=None): @property def metadata_created(self): import ckan.model as model - q = model.Session.query(model.PackageRevision.revision_timestamp)\ + q = meta.Session.query(model.PackageRevision.revision_timestamp)\ .filter(model.PackageRevision.id == self.id)\ .order_by(model.PackageRevision.revision_timestamp.asc()) ts = q.first() @@ -612,7 +610,6 @@ def get_fields(core_only=False, fields_to_ignore=None): def activity_stream_item(self, activity_type, revision, user_id): import ckan.model - import ckan.lib.dictization import ckan.logic assert activity_type in ("new", "changed"), ( str(activity_type)) @@ -622,7 +619,7 @@ def activity_stream_item(self, activity_type, revision, user_id): # a 'changed' package activity. We detect this and change it to a # 'deleted' activity. if activity_type == 'changed' and self.state == u'deleted': - if ckan.model.Session.query(ckan.model.Activity).filter_by( + if meta.Session.query(activity.Activity).filter_by( object_id=self.id, activity_type='deleted').all(): # A 'deleted' activity for this object has already been emitted # FIXME: What if the object was deleted and then activated @@ -635,7 +632,7 @@ def activity_stream_item(self, activity_type, revision, user_id): try: d = {'package': ckan.lib.dictization.table_dictize(self, context={'model': ckan.model})} - return Activity(user_id, self.id, revision.id, + return activity.Activity(user_id, self.id, revision.id, "%s package" % activity_type, d) except ckan.logic.NotFound: # This happens if this package is being purged and therefore has no @@ -646,7 +643,6 @@ def activity_stream_item(self, activity_type, revision, user_id): def activity_stream_detail(self, activity_id, activity_type): import ckan.model - import ckan.lib.dictization # Handle 'deleted' objects. # When the user marks a package as deleted this comes through here as @@ -657,5 +653,5 @@ def activity_stream_detail(self, activity_id, activity_type): package_dict = ckan.lib.dictization.table_dictize(self, context={'model':ckan.model}) - return ActivityDetail(activity_id, self.id, u"Package", activity_type, + return activity.ActivityDetail(activity_id, self.id, u"Package", activity_type, {'package': package_dict })