def package_dictize(pkg, context): model = context['model'] #package package_rev = model.package_revision_table q = select([package_rev]).where(package_rev.c.id == pkg.id) result = _execute_with_revision(q, package_rev, context).first() if not result: raise NotFound result_dict = table_dictize(result, context) #resources res_rev = model.resource_revision_table resource_group = model.resource_group_table q = select([res_rev], from_obj = res_rev.join(resource_group, resource_group.c.id == res_rev.c.resource_group_id)) q = q.where(resource_group.c.package_id == pkg.id) result = _execute_with_revision(q, res_rev, context) result_dict["resources"] = resource_list_dictize(result, context) #tags tag_rev = model.package_tag_revision_table tag = model.tag_table q = select([tag, tag_rev.c.state, tag_rev.c.revision_timestamp], from_obj=tag_rev.join(tag, tag.c.id == tag_rev.c.tag_id) ).where(tag_rev.c.package_id == pkg.id) result = _execute_with_revision(q, tag_rev, context) result_dict["tags"] = obj_list_dictize(result, context, lambda x: x["name"]) #extras extra_rev = model.extra_revision_table q = select([extra_rev]).where(extra_rev.c.package_id == pkg.id) result = _execute_with_revision(q, extra_rev, context) result_dict["extras"] = extras_list_dictize(result, context) #groups group_rev = model.package_group_revision_table group = model.group_table q = select([group], from_obj=group_rev.join(group, group.c.id == group_rev.c.group_id) ).where(group_rev.c.package_id == pkg.id) result = _execute_with_revision(q, group_rev, context) result_dict["groups"] = obj_list_dictize(result, context) #relations rel_rev = model.package_relationship_revision_table q = select([rel_rev]).where(rel_rev.c.subject_package_id == pkg.id) result = _execute_with_revision(q, rel_rev, context) result_dict["relationships_as_subject"] = obj_list_dictize(result, context) q = select([rel_rev]).where(rel_rev.c.object_package_id == pkg.id) result = _execute_with_revision(q, rel_rev, context) result_dict["relationships_as_object"] = obj_list_dictize(result, context) #isopen # Get an actual Package object, not a PackageRevision pkg_object = model.Package.get(pkg.id) result_dict['isopen'] = pkg_object.isopen if isinstance(pkg_object.isopen,bool) else pkg_object.isopen() return result_dict
def group_dictize(group, context): model = context['model'] result_dict = d.table_dictize(group, context) result_dict['display_name'] = group.display_name result_dict['extras'] = extras_dict_dictize( group._extras, context) context['with_capacity'] = True result_dict['packages'] = d.obj_list_dictize( _get_members(context, group, 'packages'), context) result_dict['tags'] = tag_list_dictize( _get_members(context, group, 'tags'), context) result_dict['groups'] = group_list_dictize( _get_members(context, group, 'groups'), context) result_dict['users'] = user_list_dictize( _get_members(context, group, 'users'), context) context['with_capacity'] = False if context.get('for_view'): for item in plugins.PluginImplementations(plugins.IGroupController): result_dict = item.before_view(result_dict) return result_dict
def tag_dictize(tag, context): result_dict = table_dictize(tag, context) result_dict["packages"] = obj_list_dictize(tag.packages, context) return result_dict
def group_dictize(group, context): model = context["model"] result_dict = table_dictize(group, context) result_dict["display_name"] = group.display_name result_dict["extras"] = extras_dict_dictize(group._extras, context) context["with_capacity"] = True result_dict["packages"] = obj_list_dictize(_get_members(context, group, "packages"), context) result_dict["tags"] = tag_list_dictize(_get_members(context, group, "tags"), context) result_dict["groups"] = group_list_dictize(_get_members(context, group, "groups"), context) result_dict["users"] = user_list_dictize(_get_members(context, group, "users"), 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 group_dictize(group, context): model = context['model'] result_dict = table_dictize(group, context) result_dict['display_name'] = group.display_name result_dict['extras'] = extras_dict_dictize( group._extras, context) context['with_capacity'] = True result_dict['packages'] = obj_list_dictize( _get_members(context, group, 'packages'), context) result_dict['tags'] = tag_list_dictize( _get_members(context, group, 'tags'), context) result_dict['groups'] = group_list_dictize( _get_members(context, group, 'groups'), context) result_dict['users'] = user_list_dictize( _get_members(context, group, 'users'), context) context['with_capacity'] = False return result_dict
def after_show(self, context, pkg_dict): try: cookies = tk.request.cookies except TypeError: # TypeError: No object (name: request) has been registered for this thread. cookies = None if cookies is not None: territory_json_str = cookies.get('territory') if territory_json_str: c = tk.c try: c.territory = json.loads(territory_json_str) except ValueError: pass else: full_name = c.territory.get('full_name') if full_name is not None: c.territory['full_name_slug'] = strings.slugify(full_name) # Add supplier to pkg_dict from ckan.lib.dictization import model_dictize supplier_id = pkg_dict.get('supplier_id') if supplier_id is not None: # Code derivated from model_dictize.package_dictize. model = context['model'] group_rev = model.group_revision_table q = select([group_rev]) \ .where(group_rev.c.id == supplier_id) \ .where(group_rev.c.state == 'active') result = model_dictize._execute_with_revision(q, group_rev, context) organizations = dictization.obj_list_dictize(result, context) pkg_dict['supplier'] = organizations[0] if organizations else None
def group_dictize(group, context): model = context['model'] result_dict = d.table_dictize(group, context) result_dict['display_name'] = group.display_name result_dict['extras'] = extras_dict_dictize( group._extras, context) context['with_capacity'] = True result_dict['packages'] = d.obj_list_dictize( _get_members(context, group, 'packages'), context) query = search.PackageSearchQuery() if group.is_organization: q = {'q': 'owner_org:"%s" +capacity:public' % group.id, 'rows': 1} else: q = {'q': 'groups:"%s" +capacity:public' % group.name, 'rows': 1} package_count = query.run(q)['count'] result_dict['package_count'] = package_count # if group.is_organization: # q = {'q': 'owner_org:"%s" +capacity:public' % group.id, 'rows': package_count} # packages = query.run(q)['results'] ## log.error(str(packages)) # result_dict['packages'] = packages result_dict['tags'] = tag_list_dictize( _get_members(context, group, 'tags'), context) result_dict['groups'] = group_list_dictize( _get_members(context, group, 'groups'), context) if context.get('for_view'): context['user'] = '******' result_dict['users'] = user_list_dictize( _get_members(context, group, 'users'), context) context['with_capacity'] = False if context.get('for_view'): if result_dict['is_organization']: plugin = plugins.IOrganizationController else: plugin = plugins.IGroupController for item in plugins.PluginImplementations(plugin): result_dict = item.before_view(result_dict) return result_dict
def group_dictize(group, context): model = context['model'] result_dict = d.table_dictize(group, context) result_dict['display_name'] = group.display_name result_dict['extras'] = extras_dict_dictize( group._extras, context) context['with_capacity'] = True result_dict['packages'] = d.obj_list_dictize( _get_members(context, group, 'packages'), context) query = search.PackageSearchQuery() if group.is_organization: q = {'q': 'owner_org:"%s" +capacity:public' % group.id, 'rows': 1} else: q = {'q': 'groups:"%s" +capacity:public' % group.name, 'rows': 1} result_dict['package_count'] = query.run(q)['count'] result_dict['tags'] = tag_list_dictize( _get_members(context, group, 'tags'), context) result_dict['groups'] = group_list_dictize( _get_members(context, group, 'groups'), context) result_dict['users'] = user_list_dictize( _get_members(context, group, 'users'), context) context['with_capacity'] = False if context.get('for_view'): if result_dict['is_organization']: plugin = plugins.IOrganizationController else: plugin = plugins.IGroupController for item in plugins.PluginImplementations(plugin): result_dict = item.before_view(result_dict) image_url = result_dict.get('image_url') result_dict['image_display_url'] = image_url if image_url and not image_url.startswith('http'): #munge here should not have an effect only doing it incase #of potential vulnerability of dodgy api input image_url = munge.munge_filename(image_url) result_dict['image_display_url'] = h.url_for_static( 'uploads/group/%s' % result_dict.get('image_url'), qualified = True ) return result_dict
def group_dictize(group, context): result_dict = table_dictize(group, context) result_dict["extras"] = extras_dict_dictize( group._extras, context) result_dict["packages"] = obj_list_dictize( group.packages, context) return result_dict
def group_dictize(group, context): result_dict = table_dictize(group, context) result_dict['display_name'] = group.display_name result_dict['extras'] = extras_dict_dictize( group._extras, context) result_dict['packages'] = obj_list_dictize( group.packages, context) return result_dict
def tag_dictize(tag, context): result_dict = d.table_dictize(tag, context) result_dict["packages"] = d.obj_list_dictize(tag.packages, context) # Add display_names to tags. At first a tag's display_name is just the # same as its name, but the display_name might get changed later (e.g. # translated into another language by the multilingual extension). assert not result_dict.has_key('display_name') result_dict['display_name'] = result_dict['name'] if context.get('for_view'): for item in plugins.PluginImplementations( plugins.ITagController): result_dict = item.before_view(result_dict) return result_dict
def dump_groups(date, options): from ckan import model # column headings header = ['name', 'id', 'title'] headings_all = set(header) headings_main = set() headings_extra = set() # get the groups group_rev_table = model.group_revision_table q = select([group_rev_table]) if options.organization: q = q.where(group_rev_table.c.name==options.organization) context = {'model': model, 'session': model.Session, 'revision_date': date} result = model_dictize._execute_with_revision(q, group_rev_table, context) groups = obj_list_dictize(result, context) # just double check there are no deleted ones in the list for group in groups: assert group['state'] == 'active' print '%i groups' % len(groups) for group in groups: # get the group extras group_extra_rev_table = model.group_extra.group_extra_revision_table q = select([group_extra_rev_table]) \ .where(group_extra_rev_table.c.group_id == group['id']) result = model_dictize._execute_with_revision(q, group_extra_rev_table, context) extras = result.fetchall() for extra in extras: if extra['state'] == 'active': group['extra-%s' % extra['key']] = extra['value'] #group['extras'] = model_dictize.extras_list_dictize(result, context) for delete_property in ['revision_timestamp', 'revision_id']: del group[delete_property] # get the parent group member_rev_table = model.member_revision_table q = select([member_rev_table]) \ .where(member_rev_table.c.group_id == group['id']) \ .where(member_rev_table.c.table_name == 'group') result = model_dictize._execute_with_revision(q, member_rev_table, context) parents = result.fetchall() for parent in parents: if parent['state'] == 'active': parent_group = model.Group.get(parent['table_id']) group['parent'] = parent_group.name # member revisions seem to miss a good number, so default to the current parent if 'parent' not in group: members = model.Session.query(model.Member) \ .filter_by(group_id=group['id']) \ .filter_by(table_name='group') \ .all() if members: parent_group = model.Group.get(members[0].table_id) if parent_group: group['parent'] = parent_group.name # column headings for key in group.keys(): if key not in headings_all: if key.startswith('extra-'): headings_extra.add(key) else: headings_main.add(key) headings_all.add(key) groups.sort(key=lambda g: g['name']) header += sorted(headings_main) + sorted(headings_extra) # write CSV csv_filepath = date.strftime(options.filename or 'groups-%Y-%m-%d.csv') #csv_filepath = options.filename or 'groups.csv' print 'Writing %s' % csv_filepath with open(csv_filepath, 'w') as f: w = UnicodeDictWriter(f, header, encoding='utf8') w.writerow(dict(zip(header, header))) w.writerows(groups)
def package_dictize(pkg, context): ''' Given a Package object, returns an equivalent dictionary. Normally this is the current revision (most recent moderated version), but you can provide revision_id, revision_date or pending in the context and it will filter to an earlier time or the latest unmoderated object revision. May raise NotFound. TODO: understand what the specific set of circumstances are that cause this. ''' model = context['model'] #package package_rev = model.package_revision_table q = select([package_rev]).where(package_rev.c.id == pkg.id) result = _execute_with_revision(q, package_rev, context).first() if not result: raise NotFound result_dict = table_dictize(result, context) #resources res_rev = model.resource_revision_table resource_group = model.resource_group_table q = select([res_rev], from_obj = res_rev.join(resource_group, resource_group.c.id == res_rev.c.resource_group_id)) q = q.where(resource_group.c.package_id == pkg.id) result = _execute_with_revision(q, res_rev, context) result_dict["resources"] = resource_list_dictize(result, context) #tags tag_rev = model.package_tag_revision_table tag = model.tag_table q = select([tag, tag_rev.c.state, tag_rev.c.revision_timestamp], from_obj=tag_rev.join(tag, tag.c.id == tag_rev.c.tag_id) ).where(tag_rev.c.package_id == pkg.id) result = _execute_with_revision(q, tag_rev, context) result_dict["tags"] = obj_list_dictize(result, context, lambda x: x["name"]) #extras extra_rev = model.extra_revision_table q = select([extra_rev]).where(extra_rev.c.package_id == pkg.id) result = _execute_with_revision(q, extra_rev, context) result_dict["extras"] = extras_list_dictize(result, context) #groups member_rev = model.member_revision_table group = model.group_table q = select([group], from_obj=member_rev.join(group, group.c.id == member_rev.c.group_id) ).where(member_rev.c.table_id == pkg.id) result = _execute_with_revision(q, member_rev, context) result_dict["groups"] = obj_list_dictize(result, context) #relations rel_rev = model.package_relationship_revision_table q = select([rel_rev]).where(rel_rev.c.subject_package_id == pkg.id) result = _execute_with_revision(q, rel_rev, context) result_dict["relationships_as_subject"] = obj_list_dictize(result, context) q = select([rel_rev]).where(rel_rev.c.object_package_id == pkg.id) result = _execute_with_revision(q, rel_rev, context) result_dict["relationships_as_object"] = obj_list_dictize(result, context) # Extra properties from the domain object # We need an actual Package object for this, not a PackageRevision if isinstance(pkg,PackageRevision): pkg = model.Package.get(pkg.id) # isopen result_dict['isopen'] = pkg.isopen if isinstance(pkg.isopen,bool) else pkg.isopen() # creation and modification date result_dict['metadata_modified'] = pkg.metadata_modified.isoformat() \ if pkg.metadata_modified else None result_dict['metadata_created'] = pkg.metadata_created.isoformat() \ if pkg.metadata_created else None return result_dict
def package_dictize(pkg, context): ''' Given a Package object, returns an equivalent dictionary. Normally this is the current revision (most recent moderated version), but you can provide revision_id, revision_date or pending in the context and it will filter to an earlier time or the latest unmoderated object revision. May raise NotFound. TODO: understand what the specific set of circumstances are that cause this. ''' model = context['model'] #package package_rev = model.package_revision_table q = select([package_rev]).where(package_rev.c.id == pkg.id) result = _execute_with_revision(q, package_rev, context).first() if not result: raise logic.NotFound result_dict = d.table_dictize(result, context) #strip whitespace from title if result_dict.get('title'): result_dict['title'] = result_dict['title'].strip() #resources res_rev = model.resource_revision_table resource_group = model.resource_group_table q = select([res_rev], from_obj = res_rev.join(resource_group, resource_group.c.id == res_rev.c.resource_group_id)) q = q.where(resource_group.c.package_id == pkg.id) result = _execute_with_revision(q, res_rev, context) result_dict["resources"] = resource_list_dictize(result, context) result_dict['num_resources'] = len(result_dict.get('resources', [])) #tags tag_rev = model.package_tag_revision_table tag = model.tag_table q = select([tag, tag_rev.c.state, tag_rev.c.revision_timestamp], from_obj=tag_rev.join(tag, tag.c.id == tag_rev.c.tag_id) ).where(tag_rev.c.package_id == pkg.id) result = _execute_with_revision(q, tag_rev, context) result_dict["tags"] = d.obj_list_dictize(result, context, lambda x: x["name"]) result_dict['num_tags'] = len(result_dict.get('tags', [])) # Add display_names to tags. At first a tag's display_name is just the # same as its name, but the display_name might get changed later (e.g. # translated into another language by the multilingual extension). for tag in result_dict['tags']: assert not tag.has_key('display_name') tag['display_name'] = tag['name'] #extras extra_rev = model.extra_revision_table q = select([extra_rev]).where(extra_rev.c.package_id == pkg.id) result = _execute_with_revision(q, extra_rev, context) result_dict["extras"] = extras_list_dictize(result, context) #groups member_rev = model.member_revision_table group = model.group_table q = select([group, member_rev.c.capacity], from_obj=member_rev.join(group, group.c.id == member_rev.c.group_id) ).where(member_rev.c.table_id == pkg.id)\ .where(member_rev.c.state == 'active') \ .where(group.c.is_organization == False) result = _execute_with_revision(q, member_rev, context) context['with_capacity'] = False ## no package counts as cannot fetch from search index at the same ## time as indexing to it. result_dict["groups"] = group_list_dictize(result, context, with_package_counts=False) #owning organization group_rev = model.group_revision_table q = select([group_rev] ).where(group_rev.c.id == pkg.owner_org) \ .where(group_rev.c.state == 'active') result = _execute_with_revision(q, group_rev, context) organizations = d.obj_list_dictize(result, context) if organizations: result_dict["organization"] = organizations[0] else: result_dict["organization"] = None #relations rel_rev = model.package_relationship_revision_table q = select([rel_rev]).where(rel_rev.c.subject_package_id == pkg.id) result = _execute_with_revision(q, rel_rev, context) result_dict["relationships_as_subject"] = d.obj_list_dictize(result, context) q = select([rel_rev]).where(rel_rev.c.object_package_id == pkg.id) result = _execute_with_revision(q, rel_rev, context) result_dict["relationships_as_object"] = d.obj_list_dictize(result, context) # Extra properties from the domain object # We need an actual Package object for this, not a PackageRevision if isinstance(pkg, model.PackageRevision): pkg = model.Package.get(pkg.id) # isopen result_dict['isopen'] = pkg.isopen if isinstance(pkg.isopen,bool) else pkg.isopen() # type # if null assign the default value to make searching easier result_dict['type']= pkg.type or u'dataset' # license 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() result_dict['metadata_created'] = pkg.metadata_created.isoformat() \ if pkg.metadata_created else None return result_dict
def package_dictize(pkg, context): ''' Given a Package object, returns an equivalent dictionary. Normally this is the current revision (most recent moderated version), but you can provide revision_id, revision_date or pending in the context and it will filter to an earlier time or the latest unmoderated object revision. May raise NotFound. TODO: understand what the specific set of circumstances are that cause this. ''' model = context['model'] #package package_rev = model.package_revision_table q = select([package_rev]).where(package_rev.c.id == pkg.id) result = _execute_with_revision(q, package_rev, context).first() if not result: raise logic.NotFound result_dict = d.table_dictize(result, context) #resources res_rev = model.resource_revision_table resource_group = model.resource_group_table q = select([res_rev], from_obj = res_rev.join(resource_group, resource_group.c.id == res_rev.c.resource_group_id)) q = q.where(resource_group.c.package_id == pkg.id) result = _execute_with_revision(q, res_rev, context) result_dict["resources"] = resource_list_dictize(result, context) #tags tag_rev = model.package_tag_revision_table tag = model.tag_table q = select([tag, tag_rev.c.state, tag_rev.c.revision_timestamp], from_obj=tag_rev.join(tag, tag.c.id == tag_rev.c.tag_id) ).where(tag_rev.c.package_id == pkg.id) result = _execute_with_revision(q, tag_rev, context) result_dict["tags"] = d.obj_list_dictize(result, context, lambda x: x["name"]) #extras extra_rev = model.extra_revision_table q = select([extra_rev]).where(extra_rev.c.package_id == pkg.id) result = _execute_with_revision(q, extra_rev, context) result_dict["extras"] = extras_list_dictize(result, context) #groups member_rev = model.member_revision_table group = model.group_table q = select([group, member_rev.c.capacity], from_obj=member_rev.join(group, group.c.id == member_rev.c.group_id) ).where(member_rev.c.table_id == pkg.id)\ .where(member_rev.c.state == 'active') result = _execute_with_revision(q, member_rev, context) result_dict["groups"] = d.obj_list_dictize(result, context) #relations rel_rev = model.package_relationship_revision_table q = select([rel_rev]).where(rel_rev.c.subject_package_id == pkg.id) result = _execute_with_revision(q, rel_rev, context) result_dict["relationships_as_subject"] = d.obj_list_dictize(result, context) q = select([rel_rev]).where(rel_rev.c.object_package_id == pkg.id) result = _execute_with_revision(q, rel_rev, context) result_dict["relationships_as_object"] = d.obj_list_dictize(result, context) # Extra properties from the domain object # We need an actual Package object for this, not a PackageRevision if isinstance(pkg, ckan.model.PackageRevision): pkg = model.Package.get(pkg.id) # isopen result_dict['isopen'] = pkg.isopen if isinstance(pkg.isopen,bool) else pkg.isopen() # 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'] = context.pop('metadata_modified') result_dict['metadata_created'] = pkg.metadata_created.isoformat() \ if pkg.metadata_created else None if context.get('for_view'): for item in plugins.PluginImplementations(plugins.IPackageController): result_dict = item.before_view(result_dict) return result_dict
def package_dictize(pkg, context): ''' Given a Package object, returns an equivalent dictionary. ''' model = context['model'] assert not (context.get('revision_id') or context.get('revision_date')), \ 'Revision functionality is moved to migrate_package_activity' execute = _execute # package if not pkg: raise logic.NotFound result_dict = d.table_dictize(pkg, context) # strip whitespace from title if result_dict.get('title'): result_dict['title'] = result_dict['title'].strip() # resources res = model.resource_table q = select([res]).where(res.c.package_id == pkg.id) result = execute(q, res, context) result_dict["resources"] = resource_list_dictize(result, context) result_dict['num_resources'] = len(result_dict.get('resources', [])) # tags tag = model.tag_table pkg_tag = model.package_tag_table q = select([tag, pkg_tag.c.state], from_obj=pkg_tag.join(tag, tag.c.id == pkg_tag.c.tag_id) ).where(pkg_tag.c.package_id == pkg.id) result = execute(q, pkg_tag, context) result_dict["tags"] = d.obj_list_dictize(result, context, lambda x: x["name"]) result_dict['num_tags'] = len(result_dict.get('tags', [])) # Add display_names to tags. At first a tag's display_name is just the # same as its name, but the display_name might get changed later (e.g. # translated into another language by the multilingual extension). for tag in result_dict['tags']: assert 'display_name' not in tag tag['display_name'] = tag['name'] # extras - no longer revisioned, so always provide latest extra = model.package_extra_table q = select([extra]).where(extra.c.package_id == pkg.id) result = execute(q, extra, context) result_dict["extras"] = extras_list_dictize(result, context) # groups member = model.member_table group = model.group_table q = select([group, member.c.capacity], from_obj=member.join(group, group.c.id == member.c.group_id) ).where(member.c.table_id == pkg.id)\ .where(member.c.state == 'active') \ .where(group.c.is_organization == False) result = execute(q, member, context) context['with_capacity'] = False # no package counts as cannot fetch from search index at the same # time as indexing to it. # tags, extras and sub-groups are not included for speed result_dict["groups"] = group_list_dictize(result, context, with_package_counts=False) # owning organization group = model.group_table q = select([group] ).where(group.c.id == pkg.owner_org) \ .where(group.c.state == 'active') result = execute(q, group, context) organizations = d.obj_list_dictize(result, context) if organizations: result_dict["organization"] = organizations[0] else: result_dict["organization"] = None # relations rel = model.package_relationship_table q = select([rel]).where(rel.c.subject_package_id == pkg.id) result = execute(q, rel, context) result_dict["relationships_as_subject"] = \ d.obj_list_dictize(result, context) q = select([rel]).where(rel.c.object_package_id == pkg.id) result = execute(q, rel, context) result_dict["relationships_as_object"] = \ d.obj_list_dictize(result, context) # Extra properties from the domain object # isopen result_dict['isopen'] = pkg.isopen if isinstance(pkg.isopen, bool) \ else pkg.isopen() # type # if null assign the default value to make searching easier result_dict['type'] = pkg.type or u'dataset' # license 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() result_dict['metadata_created'] = pkg.metadata_created.isoformat() \ if pkg.metadata_created else None return result_dict
def package_dictize(pkg, context): ''' Given a Package object, returns an equivalent dictionary. ''' model = context['model'] assert not (context.get('revision_id') or context.get('revision_date')), \ 'Revision functionality is moved to migrate_package_activity' assert not isinstance(pkg, model.PackageRevision), \ 'Revision functionality is moved to migrate_package_activity' execute = _execute # package if not pkg: raise logic.NotFound result_dict = d.table_dictize(pkg, context) # strip whitespace from title if result_dict.get('title'): result_dict['title'] = result_dict['title'].strip() # resources res = model.resource_table q = select([res]).where(res.c.package_id == pkg.id) result = execute(q, res, context) result_dict["resources"] = resource_list_dictize(result, context) result_dict['num_resources'] = len(result_dict.get('resources', [])) # tags tag = model.tag_table pkg_tag = model.package_tag_table q = select([tag, pkg_tag.c.state], from_obj=pkg_tag.join(tag, tag.c.id == pkg_tag.c.tag_id) ).where(pkg_tag.c.package_id == pkg.id) result = execute(q, pkg_tag, context) result_dict["tags"] = d.obj_list_dictize(result, context, lambda x: x["name"]) result_dict['num_tags'] = len(result_dict.get('tags', [])) # Add display_names to tags. At first a tag's display_name is just the # same as its name, but the display_name might get changed later (e.g. # translated into another language by the multilingual extension). for tag in result_dict['tags']: assert 'display_name' not in tag tag['display_name'] = tag['name'] # extras - no longer revisioned, so always provide latest extra = model.package_extra_table q = select([extra]).where(extra.c.package_id == pkg.id) result = _execute(q, extra, context) result_dict["extras"] = extras_list_dictize(result, context) # groups member = model.member_table group = model.group_table q = select([group, member.c.capacity], from_obj=member.join(group, group.c.id == member.c.group_id) ).where(member.c.table_id == pkg.id)\ .where(member.c.state == 'active') \ .where(group.c.is_organization == False) result = execute(q, member, context) context['with_capacity'] = False # no package counts as cannot fetch from search index at the same # time as indexing to it. # tags, extras and sub-groups are not included for speed result_dict["groups"] = group_list_dictize(result, context, with_package_counts=False) # owning organization group = model.group_table q = select([group] ).where(group.c.id == pkg.owner_org) \ .where(group.c.state == 'active') result = execute(q, group, context) organizations = d.obj_list_dictize(result, context) if organizations: result_dict["organization"] = organizations[0] else: result_dict["organization"] = None # relations rel = model.package_relationship_table q = select([rel]).where(rel.c.subject_package_id == pkg.id) result = execute(q, rel, context) result_dict["relationships_as_subject"] = \ d.obj_list_dictize(result, context) q = select([rel]).where(rel.c.object_package_id == pkg.id) result = execute(q, rel, context) result_dict["relationships_as_object"] = \ d.obj_list_dictize(result, context) # Extra properties from the domain object # isopen result_dict['isopen'] = pkg.isopen if isinstance(pkg.isopen, bool) \ else pkg.isopen() # type # if null assign the default value to make searching easier result_dict['type'] = pkg.type or u'dataset' # license 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() result_dict['metadata_created'] = pkg.metadata_created.isoformat() \ if pkg.metadata_created else None return result_dict
def package_dictize(pkg, context): ''' Given a Package object, returns an equivalent dictionary. Normally this is the most recent version, but you can provide revision_id or revision_date in the context and it will filter to an earlier time. May raise NotFound if: * the specified revision_id doesn't exist * the specified revision_date was before the package was created ''' model = context['model'] is_latest_revision = not(context.get('revision_id') or context.get('revision_date')) execute = _execute if is_latest_revision else _execute_with_revision #package if is_latest_revision: if isinstance(pkg, model.PackageRevision): pkg = model.Package.get(pkg.id) result = pkg else: package_rev = model.package_revision_table q = select([package_rev]).where(package_rev.c.id == pkg.id) result = execute(q, package_rev, context).first() if not result: raise logic.NotFound result_dict = d.table_dictize(result, context) #strip whitespace from title if result_dict.get('title'): result_dict['title'] = result_dict['title'].strip() #resources if is_latest_revision: res = model.resource_table else: res = model.resource_revision_table q = select([res]).where(res.c.package_id == pkg.id) result = execute(q, res, context) result_dict["resources"] = resource_list_dictize(result, context) result_dict['num_resources'] = len(result_dict.get('resources', [])) #tags tag = model.tag_table if is_latest_revision: pkg_tag = model.package_tag_table else: pkg_tag = model.package_tag_revision_table q = select([tag, pkg_tag.c.state], from_obj=pkg_tag.join(tag, tag.c.id == pkg_tag.c.tag_id) ).where(pkg_tag.c.package_id == pkg.id) result = execute(q, pkg_tag, context) result_dict["tags"] = d.obj_list_dictize(result, context, lambda x: x["name"]) result_dict['num_tags'] = len(result_dict.get('tags', [])) # Add display_names to tags. At first a tag's display_name is just the # same as its name, but the display_name might get changed later (e.g. # translated into another language by the multilingual extension). for tag in result_dict['tags']: assert not 'display_name' in tag tag['display_name'] = tag['name'] #extras if is_latest_revision: extra = model.package_extra_table else: extra = model.extra_revision_table q = select([extra]).where(extra.c.package_id == pkg.id) result = execute(q, extra, context) result_dict["extras"] = extras_list_dictize(result, context) #groups if is_latest_revision: member = model.member_table else: member = model.member_revision_table group = model.group_table q = select([group, member.c.capacity], from_obj=member.join(group, group.c.id == member.c.group_id) ).where(member.c.table_id == pkg.id)\ .where(member.c.state == 'active') \ .where(group.c.is_organization == False) result = execute(q, member, context) context['with_capacity'] = False ## no package counts as cannot fetch from search index at the same ## time as indexing to it. ## tags, extras and sub-groups are not included for speed result_dict["groups"] = group_list_dictize(result, context, with_package_counts=False) #owning organization if is_latest_revision: group = model.group_table else: group = model.group_revision_table q = select([group] ).where(group.c.id == pkg.owner_org) \ .where(group.c.state == 'active') result = execute(q, group, context) organizations = d.obj_list_dictize(result, context) if organizations: result_dict["organization"] = organizations[0] else: result_dict["organization"] = None #relations if is_latest_revision: rel = model.package_relationship_table else: rel = model.package_relationship_revision_table q = select([rel]).where(rel.c.subject_package_id == pkg.id) result = execute(q, rel, context) result_dict["relationships_as_subject"] = \ d.obj_list_dictize(result, context) q = select([rel]).where(rel.c.object_package_id == pkg.id) result = execute(q, rel, context) result_dict["relationships_as_object"] = \ d.obj_list_dictize(result, context) # Extra properties from the domain object # We need an actual Package object for this, not a PackageRevision if isinstance(pkg, model.PackageRevision): pkg = model.Package.get(pkg.id) # isopen result_dict['isopen'] = pkg.isopen if isinstance(pkg.isopen, bool) \ else pkg.isopen() # type # if null assign the default value to make searching easier result_dict['type'] = pkg.type or u'dataset' # license 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() result_dict['metadata_created'] = pkg.metadata_created.isoformat() \ if pkg.metadata_created else None return result_dict
def package_dictize(pkg, context): ''' Given a Package object, returns an equivalent dictionary. Normally this is the current revision (most recent moderated version), but you can provide revision_id, revision_date or pending in the context and it will filter to an earlier time or the latest unmoderated object revision. May raise NotFound. TODO: understand what the specific set of circumstances are that cause this. ''' model = context['model'] #package package_rev = model.package_revision_table q = select([package_rev]).where(package_rev.c.id == pkg.id) result = _execute_with_revision(q, package_rev, context).first() if not result: raise logic.NotFound result_dict = d.table_dictize(result, context) #strip whitespace from title if result_dict.get('title'): result_dict['title'] = result_dict['title'].strip() #resources res_rev = model.resource_revision_table resource_group = model.resource_group_table q = select([res_rev], from_obj = res_rev.join(resource_group, resource_group.c.id == res_rev.c.resource_group_id)) q = q.where(resource_group.c.package_id == pkg.id) result = _execute_with_revision(q, res_rev, context) result_dict["resources"] = resource_list_dictize(result, context) result_dict['num_resources'] = len(result_dict.get('resources', [])) #tags tag_rev = model.package_tag_revision_table tag = model.tag_table q = select([tag, tag_rev.c.state, tag_rev.c.revision_timestamp], from_obj=tag_rev.join(tag, tag.c.id == tag_rev.c.tag_id) ).where(tag_rev.c.package_id == pkg.id) result = _execute_with_revision(q, tag_rev, context) result_dict["tags"] = d.obj_list_dictize(result, context, lambda x: x["name"]) result_dict['num_tags'] = len(result_dict.get('tags', [])) # Add display_names to tags. At first a tag's display_name is just the # same as its name, but the display_name might get changed later (e.g. # translated into another language by the multilingual extension). for tag in result_dict['tags']: assert not tag.has_key('display_name') tag['display_name'] = tag['name'] #extras extra_rev = model.extra_revision_table q = select([extra_rev]).where(extra_rev.c.package_id == pkg.id) result = _execute_with_revision(q, extra_rev, context) result_dict["extras"] = extras_list_dictize(result, context) #groups member_rev = model.member_revision_table group = model.group_table q = select([group, member_rev.c.capacity], from_obj=member_rev.join(group, group.c.id == member_rev.c.group_id) ).where(member_rev.c.table_id == pkg.id)\ .where(member_rev.c.state == 'active') \ .where(group.c.is_organization == False) result = _execute_with_revision(q, member_rev, context) context['with_capacity'] = False ## no package counts as cannot fetch from search index at the same ## time as indexing to it. ## tags, extras and sub-groups are not included for speed result_dict["groups"] = group_list_dictize(result, context, with_package_counts=False) #owning organization group_rev = model.group_revision_table q = select([group_rev] ).where(group_rev.c.id == pkg.owner_org) \ .where(group_rev.c.state == 'active') result = _execute_with_revision(q, group_rev, context) organizations = d.obj_list_dictize(result, context) if organizations: result_dict["organization"] = organizations[0] else: result_dict["organization"] = None #relations rel_rev = model.package_relationship_revision_table q = select([rel_rev]).where(rel_rev.c.subject_package_id == pkg.id) result = _execute_with_revision(q, rel_rev, context) result_dict["relationships_as_subject"] = d.obj_list_dictize(result, context) q = select([rel_rev]).where(rel_rev.c.object_package_id == pkg.id) result = _execute_with_revision(q, rel_rev, context) result_dict["relationships_as_object"] = d.obj_list_dictize(result, context) # Extra properties from the domain object # We need an actual Package object for this, not a PackageRevision if isinstance(pkg, model.PackageRevision): pkg = model.Package.get(pkg.id) # isopen result_dict['isopen'] = pkg.isopen if isinstance(pkg.isopen,bool) else pkg.isopen() # type # if null assign the default value to make searching easier result_dict['type']= pkg.type or u'dataset' # license 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() result_dict['metadata_created'] = pkg.metadata_created.isoformat() \ if pkg.metadata_created else None return result_dict