def public_journal_atom(self):
"""
Produce an atom-1.0 feed via feedgenerator module
"""
c.following = self.sa.query(UserFollowing)\
.filter(UserFollowing.user_id == self.rhodecode_user.user_id)\
.options(joinedload(UserFollowing.follows_repository))\
.all()
journal = self._get_journal_data(c.following)
feed = Atom1Feed(title=self.title % 'atom',
link=url('public_journal_atom', qualified=True),
description=_('Public journal'),
language=self.language,
ttl=self.ttl)
for entry in journal[:self.feed_nr]:
#tmpl = h.action_parser(entry)[0]
action, action_extra = h.action_parser(entry, feed=True)
title = "%s - %s %s" % (entry.user.short_contact, action,
entry.repository.repo_name)
desc = action_extra()
feed.add_item(title=title,
pubdate=entry.action_date,
link=url('', qualified=True),
author_email=entry.user.email,
author_name=entry.user.full_contact,
description=desc)
response.content_type = feed.mime_type
return feed.writeString('utf-8')
def atom(self, repo_name):
"""Produce an atom-1.0 feed via feedgenerator module"""
feed = Atom1Feed(title=self.title % repo_name,
link=url('summary_home',
repo_name=repo_name,
qualified=True),
description=self.description % repo_name,
language=self.language,
ttl=self.ttl)
for cs in reversed(list(c.rhodecode_repo[-self.feed_nr:])):
desc_msg = []
desc_msg.append('%s - %s<br/><pre>' % (cs.author, cs.date))
desc_msg.append(self.__changes(cs))
feed.add_item(title=self._get_title(cs),
link=url('changeset_home',
repo_name=repo_name,
revision=cs.raw_id,
qualified=True),
author_name=cs.author,
description=''.join(desc_msg))
response.content_type = feed.mime_type
return feed.writeString('utf-8')
def rss(self, posts):
if not posts:
h.flash('There are no posts to show an RSS Feed for.', 'warning')
redirect(url(controller='blog', action='index'))
author = model.User.first()
host = request_config().host
feed_kwargs = {}
if author.email:
feed_kwargs['author_email'] = author.email
feed = Atom1Feed(
title=config['rss.title'],
description=config['rss.description'],
link=url(host=host, controller='blog', action='index'),
author_name=author.name,
author_link=url(
host=host,
controller='account',
action='profile',
id=author.id
),
**feed_kwargs
)
for post in c.posts:
item_kwargs = {}
if post.user.email:
item_kwargs['author_email'] = post.user.email
if post.summary:
description = post.summary
else:
description = _('No Summary')
feed.add_item(
title=post.title,
link=url(
host=host,
controller='blog',
action='view',
category=post.category.slug,
slug=post.slug
),
description=description,
pubdate=post.posted,
author_name=post.user.name,
author_link=url(
host=host,
controller='account',
action='profile',
id=post.user.id
),
**item_kwargs
)
response.content_type = 'application/atom+xml'
return feed.writeString('utf-8')
def feed(self):
etag_cache(get_last())
alerts = model.Session.query(model.Alert)
alerts = alerts.order_by(model.sa.desc(model.Alert.time)).limit(100)
f = Atom1Feed(
title="Alerts",
link=url_for(),
description="Alerts",
)
for a in alerts:
f.add_item(
title="%s - %s" % (a.addr, a.name),
link=url_for(controller="alerts", action="notes", id=a.id),
description="Down at %s\nUp at %s" % (a.time, a.uptime),
pubdate=a.time,
)
response.content_type = 'application/atom+xml'
return f.writeString('utf-8')
def _atom_feed(self, repos, public=True):
journal = self._get_journal_data(repos)
if public:
_link = url('public_journal_atom', qualified=True)
_desc = '%s %s %s' % (c.rhodecode_name, _('public journal'),
'atom feed')
else:
_link = url('journal_atom', qualified=True)
_desc = '%s %s %s' % (c.rhodecode_name, _('journal'), 'atom feed')
feed = Atom1Feed(title=_desc,
link=_link,
description=_desc,
language=self.language,
ttl=self.ttl)
for entry in journal[:self.feed_nr]:
user = entry.user
if user is None:
#fix deleted users
user = AttributeDict({
'short_contact': entry.username,
'email': '',
'full_contact': ''
})
action, action_extra, ico = h.action_parser(entry, feed=True)
title = "%s - %s %s" % (user.short_contact, action(),
entry.repository.repo_name)
desc = action_extra()
_url = None
if entry.repository is not None:
_url = url('changelog_home',
repo_name=entry.repository.repo_name,
qualified=True)
feed.add_item(title=title,
pubdate=entry.action_date,
link=_url or url('', qualified=True),
author_email=user.email,
author_name=user.full_contact,
description=desc)
response.content_type = feed.mime_type
return feed.writeString('utf-8')
def atom1(self):
"""Produce an atom-1.0 feed via feedgenerator module"""
feed = Atom1Feed(
title=u"Latest notices of pendency",
link=current_url(),
description=
u"These are the latest foreclosures pulled together by the scraper",
language=u"en",
)
latest = model.Foreclosure.query.order_by(
desc(model.Foreclosure.filing_date)).limit(40).all()
for closure in latest:
feed.add_item(title=closure.formatted_address,
link=u"http://monroe-threebean.rhcloud.com/",
description=closure.fancy_format())
response.content_type = 'application/atom+xml'
return feed.writeString('utf-8')
def _get_feed_from_cache(key):
feed = Atom1Feed(
title=self.title % repo_name,
link=url('summary_home', repo_name=repo_name,
qualified=True),
description=self.description % repo_name,
language=self.language,
ttl=self.ttl
)
for cs in reversed(list(c.rhodecode_repo[-self.feed_nr:])):
feed.add_item(title=self._get_title(cs),
link=url('changeset_home', repo_name=repo_name,
revision=cs.raw_id, qualified=True),
author_name=cs.author,
description=''.join(self.__get_desc(cs)),
pubdate=cs.date,
)
response.content_type = feed.mime_type
return feed.writeString('utf-8')
def _generate_feed(cache_key):
feed = Atom1Feed(title=self.title % repo_name,
link=url('summary_home',
repo_name=repo_name,
qualified=True),
description=self.description % repo_name,
language=self.language,
ttl=self.ttl)
for commit in reversed(self._get_commits()):
date = self._set_timezone(commit.date)
feed.add_item(
title=self._get_title(commit),
author_name=commit.author,
description=self._get_description(commit),
link=url('changeset_home',
repo_name=repo_name,
revision=commit.raw_id,
qualified=True),
pubdate=date,
)
return feed.mime_type, feed.writeString('utf-8')
def _get_feed_from_cache(key, kind):
feed = Atom1Feed(title=_('%s %s feed') % (c.site_name, repo_name),
link=h.canonical_url('summary_home',
repo_name=repo_name),
description=_('Changes on %s repository') %
repo_name,
language=language,
ttl=ttl)
rss_items_per_page = safe_int(CONFIG.get('rss_items_per_page', 20))
for cs in reversed(
list(c.db_repo_scm_instance[-rss_items_per_page:])):
feed.add_item(
title=self._get_title(cs),
link=h.canonical_url('changeset_home',
repo_name=repo_name,
revision=cs.raw_id),
author_name=cs.author,
description=''.join(self.__get_desc(cs)),
pubdate=cs.date,
)
response.content_type = feed.mime_type
return feed.writeString('utf-8')
def list(self):
format = request.params.get('format', '')
if format == 'atom':
# Generate and return Atom 1.0 document.
from webhelpers.feedgenerator import Atom1Feed
feed = Atom1Feed(
title=_(u'CKAN Repository Revision History'),
link=h.url_for(controller='revision', action='list', id=''),
description=_(u'Recent changes to the CKAN repository.'),
language=unicode(get_lang()),
)
# TODO: make this configurable?
# we do not want the system to fall over!
maxresults = 200
try:
dayHorizon = int(request.params.get('days', 5))
except:
dayHorizon = 5
ourtimedelta = timedelta(days=-dayHorizon)
since_when = datetime.now() + ourtimedelta
revision_query = model.repo.history()
revision_query = revision_query.filter(
model.Revision.timestamp >= since_when).filter(
model.Revision.id != None)
revision_query = revision_query.limit(maxresults)
for revision in revision_query:
package_indications = []
revision_changes = model.repo.list_changes(revision)
resource_revisions = revision_changes[model.Resource]
resource_group_revisions = \
revision_changes[model.ResourceGroup]
package_extra_revisions = revision_changes[model.PackageExtra]
for package in revision.packages:
if not package:
# package is None sometimes - I don't know why,
# but in the meantime while that is fixed,
# avoid an exception here
continue
if package.private:
continue
number = len(package.all_revisions)
package_revision = None
count = 0
for pr in package.all_revisions:
count += 1
if pr.revision.id == revision.id:
package_revision = pr
break
if package_revision and package_revision.state == \
model.State.DELETED:
transition = 'deleted'
elif package_revision and count == number:
transition = 'created'
else:
transition = 'updated'
for resource_revision in resource_revisions:
if resource_revision.continuity.resource_group.\
package_id == package.id:
transition += ':resources'
break
for resource_group_revision in \
resource_group_revisions:
if resource_group_revision.package_id == \
package.id:
transition += ':resource_group'
break
for package_extra_revision in package_extra_revisions:
if package_extra_revision.package_id == \
package.id:
if package_extra_revision.key == \
'date_updated':
transition += ':date_updated'
break
indication = "%s:%s" % (package.name, transition)
package_indications.append(indication)
pkgs = u'[%s]' % ' '.join(package_indications)
item_title = u'r%s ' % (revision.id)
item_title += pkgs
if revision.message:
item_title += ': %s' % (revision.message or '')
item_link = h.url_for(controller='revision',
action='read',
id=revision.id)
item_description = _('Datasets affected: %s.\n') % pkgs
item_description += '%s' % (revision.message or '')
item_author_name = revision.author
item_pubdate = revision.timestamp
feed.add_item(
title=item_title,
link=item_link,
description=item_description,
author_name=item_author_name,
pubdate=item_pubdate,
)
feed.content_type = 'application/atom+xml'
return feed.writeString('utf-8')
else:
query = model.Session.query(model.Revision)
c.page = h.Page(collection=query,
page=request.params.get('page', 1),
url=h.pager_url,
items_per_page=20)
return base.render('revision/list.html')
abort(404, _('Group not found'))
except NotAuthorized:
abort(
401,
_('User %r not authorized to edit %r') %
(c.user.encode('ascii', 'ignore'), id))
format = request.params.get('format', '')
if format == 'atom':
# Generate and return Atom 1.0 document.
from webhelpers.feedgenerator import Atom1Feed
feed = Atom1Feed(
title=_(u'CKAN Group Revision History'),
link=self._url_for(controller='group',
action='read',
id=c.group_dict['name']),
description=_(u'Recent changes to CKAN Group: ') +
c.group_dict['display_name'],
language=unicode(get_lang()),
)
for revision_dict in c.group_revisions:
revision_date = h.date_str_to_datetime(
revision_dict['timestamp'])
try:
dayHorizon = int(request.params.get('days'))
except:
dayHorizon = 30
dayAge = (datetime.datetime.now() - revision_date).days
if dayAge >= dayHorizon:
break
if revision_dict['message']:
def history(self, id):
group_type = self._ensure_controller_matches_group_type(id)
if 'diff' in request.params or 'selected1' in request.params:
try:
params = {
'id': request.params.getone('group_name'),
'diff': request.params.getone('selected1'),
'oldid': request.params.getone('selected2'),
}
except KeyError:
if 'group_name' in dict(request.params):
id = request.params.getone('group_name')
c.error = \
_('Select two revisions before doing the comparison.')
else:
params['diff_entity'] = 'group'
h.redirect_to(controller='revision', action='diff', **params)
context = {
'model': model,
'session': model.Session,
'user': c.user,
'schema': self._db_to_form_schema()
}
data_dict = {'id': id}
try:
c.group_dict = self._action('group_show')(context, data_dict)
c.group_revisions = self._action('group_revision_list')(context,
data_dict)
#TODO: remove
# Still necessary for the authz check in group/layout.html
c.group = context['group']
except (NotFound, NotAuthorized):
abort(404, _('Group not found'))
format = request.params.get('format', '')
if format == 'atom':
# Generate and return Atom 1.0 document.
from webhelpers.feedgenerator import Atom1Feed
feed = Atom1Feed(
title=_(u'CKAN Group Revision History'),
link=self._url_for_this_controller(action='read',
id=c.group_dict['name']),
description=_(u'Recent changes to CKAN Group: ') +
c.group_dict['display_name'],
language=unicode(get_lang()),
)
for revision_dict in c.group_revisions:
revision_date = h.date_str_to_datetime(
revision_dict['timestamp'])
try:
dayHorizon = int(request.params.get('days'))
except:
dayHorizon = 30
dayAge = (datetime.datetime.now() - revision_date).days
if dayAge >= dayHorizon:
break
if revision_dict['message']:
item_title = u'%s' % revision_dict['message'].\
split('\n')[0]
else:
item_title = u'%s' % revision_dict['id']
item_link = h.url_for(controller='revision',
action='read',
id=revision_dict['id'])
item_description = _('Log message: ')
item_description += '%s' % (revision_dict['message'] or '')
item_author_name = revision_dict['author']
item_pubdate = revision_date
feed.add_item(
title=item_title,
link=item_link,
description=item_description,
author_name=item_author_name,
pubdate=item_pubdate,
)
feed.content_type = 'application/atom+xml'
return feed.writeString('utf-8')
return render(self._history_template(group_type),
extra_vars={'group_type': group_type})
def history(package_type, id):
if u'diff' in request.args or u'selected1' in request.args:
try:
params = {
u'id': request.args.getone(u'pkg_name'),
u'diff': request.args.getone(u'selected1'),
u'oldid': request.args.getone(u'selected2'),
}
except KeyError:
if u'pkg_name' in dict(request.args):
id = request.args.getone(u'pkg_name')
g.error = \
_(u'Select two revisions before doing the comparison.')
else:
params[u'diff_entity'] = u'package'
return h.redirect_to(controller=u'revision',
action=u'diff',
**params)
context = {
u'model': model,
u'session': model.Session,
u'user': g.user,
u'auth_user_obj': g.userobj,
u'for_view': True
}
data_dict = {u'id': id}
try:
g.pkg_dict = get_action(u'package_show')(context, data_dict)
g.pkg_revisions = get_action(u'package_revision_list')(context,
data_dict)
# TODO: remove
# Still necessary for the authz check in group/layout.html
g.pkg = context[u'package']
except NotAuthorized:
return base.abort(403, _(u'Unauthorized to read package %s') % u'')
except NotFound:
return base.abort(404, _(u'Dataset not found'))
format = request.args.get(u'format', u'')
if format == u'atom':
# Generate and return Atom 1.0 document.
from webhelpers.feedgenerator import Atom1Feed
feed = Atom1Feed(
title=_(u'CKAN Dataset Revision History'),
link=h.url_for(controller=u'revision',
action=u'read',
id=g.pkg_dict[u'name']),
description=_(u'Recent changes to CKAN Dataset: ') +
(g.pkg_dict[u'title'] or u''),
language=text_type(i18n.get_lang()),
)
for revision_dict in g.pkg_revisions:
revision_date = h.date_str_to_datetime(revision_dict[u'timestamp'])
try:
dayHorizon = int(request.args.get(u'days'))
except:
dayHorizon = 30
dayAge = (datetime.datetime.now() - revision_date).days
if dayAge >= dayHorizon:
break
if revision_dict[u'message']:
item_title = u'%s' % revision_dict[u'message'].\
split(u'\n')[0]
else:
item_title = u'%s' % revision_dict[u'id']
item_link = h.url_for(controller=u'revision',
action=u'read',
id=revision_dict[u'id'])
item_description = _(u'Log message: ')
item_description += u'%s' % (revision_dict[u'message'] or u'')
item_author_name = revision_dict[u'author']
item_pubdate = revision_date
feed.add_item(
title=item_title,
link=item_link,
description=item_description,
author_name=item_author_name,
pubdate=item_pubdate,
)
response = make_response(feed.writeString(u'utf-8'))
response.headers[u'Content-Type'] = u'application/atom+xml'
return response
package_type = g.pkg_dict[u'type'] or u'dataset'
return base.render(_get_pkg_template(u'history_template',
g.pkg_dict.get(u'type',
package_type)),
extra_vars={u'dataset_type': package_type})
c.pkg = context['package']
except NotAuthorized:
abort(401, _('Unauthorized to read package %s') % '')
except NotFound:
abort(404, _('Package not found'))
format = request.params.get('format', '')
if format == 'atom':
# Generate and return Atom 1.0 document.
from webhelpers.feedgenerator import Atom1Feed
feed = Atom1Feed(
title=_(u'CKAN Package Revision History'),
link=h.url_for(controller='revision',
action='read',
id=c.pkg_dict['name']),
description=_(u'Recent changes to CKAN Package: ') +
(c.pkg_dict['title'] or ''),
language=unicode(get_lang()),
)
for revision_dict in c.pkg_revisions:
revision_date = h.date_str_to_datetime(
revision_dict['timestamp'])
try:
dayHorizon = int(request.params.get('days'))
except:
dayHorizon = 30
dayAge = (datetime.datetime.now() - revision_date).days
if dayAge >= dayHorizon:
break
if revision_dict['message']:
def history(id, group_type, is_organization):
u''' Do we need this? '''
extra_vars = {}
set_org(is_organization)
if u'diff' in request.params or u'selected1' in request.params:
try:
params = {
u'id': request.params.getone(u'group_name'),
u'diff': request.params.getone(u'selected1'),
u'oldid': request.params.getone(u'selected2'),
}
except KeyError:
if u'group_name' in dict(request.params):
id = request.params.getone(u'group_name')
error = \
_(u'Select two revisions before doing the comparison.')
# TODO: Remove
g.error = error
else:
params[u'diff_entity'] = u'group'
return h.redirect_to(controller=u'revision',
action=u'diff',
**params)
context = {
u'model': model,
u'session': model.Session,
u'user': g.user,
u'schema': _db_to_form_schema()
}
data_dict = {u'id': id}
try:
group_dict = _action(u'group_show')(context, data_dict)
group_revisions = _action(u'group_revision_list')(context, data_dict)
# TODO: remove
# Still necessary for the authz check in group/layout.html
group = context['group']
except (NotFound, NotAuthorized):
base.abort(404, _(u'Group not found'))
format = request.params.get(u'format', u'')
if format == u'atom':
# Generate and return Atom 1.0 document.
from webhelpers.feedgenerator import Atom1Feed
feed = Atom1Feed(
title=_(u'CKAN Group Revision History'),
link=h.url_for(group_type + u'.read', id=group_dict[u'name']),
description=_(u'Recent changes to CKAN Group: ') +
group_dict['display_name'],
language=text_type(get_lang()),
)
for revision_dict in group_revisions:
revision_date = h.date_str_to_datetime(revision_dict[u'timestamp'])
try:
dayHorizon = int(request.params.get(u'days'))
except Exception:
dayHorizon = 30
dayAge = (datetime.datetime.now() - revision_date).days
if dayAge >= dayHorizon:
break
if revision_dict['message']:
item_title = u'%s' % revision_dict['message'].\
split(u'\n')[0]
else:
item_title = u'%s' % revision_dict['id']
item_link = h.url_for(controller=u'revision',
action=u'read',
id=revision_dict['id'])
item_description = _(u'Log message: ')
item_description += u'%s' % (revision_dict['message'] or u'')
item_author_name = revision_dict['author']
item_pubdate = revision_date
feed.add_item(
title=item_title,
link=item_link,
description=item_description,
author_name=item_author_name,
pubdate=item_pubdate,
)
feed.content_type = u'application/atom+xml'
return feed.writeString(u'utf-8')
# TODO: Remove
g.group_dict = group_dict
g.group_revisions = group_revisions
g.group = group
extra_vars = {
u"group_dict": group_dict,
u"group_revisions": group_revisions,
u"group": group,
u"group_type": group_type
}
return base.render(_history_template(group_type), extra_vars)
'ckan.locale_default', 'en')
web_schema = ui_util.transform_dcat_schema_to_ui_schema(dataset)
log.info(
'****************** rss3 /history took {0} sec**********************'
.format((time.time() - start)))
start = time.time()
if format == 'atom':
# Generate and return Atom 1.0 document.
start_loop = time.time()
from webhelpers.feedgenerator import Atom1Feed
feed = Atom1Feed(
title=_(u'' + web_schema.get('title', '')),
link=h.url_for(controller='revision',
action='read',
id=web_schema.get('name')),
description=_(u'Recent changes to CKAN Dataset: ') +
(web_schema.get('title', '') or ''),
language=unicode(i18n.get_lang()),
)
for revision_dict in c.pkg_revisions:
revision_date = h.date_str_to_datetime(
revision_dict['timestamp'])
try:
dayHorizon = int(request.params.get('days'))
except:
dayHorizon = 30
dayAge = (datetime.datetime.now() - revision_date).days
if dayAge >= dayHorizon:
break
if revision_dict['message']:
def rss(self, watch, authid, uid, feedType):
if not g.OPT.allowFeeds:
abort(403)
if not self.currentUserIsAuthorized():
user = User.getByUid(uid)
if not user or not int(authid) == user.authid():
return redirect_to('boardBase')
if user.isAdmin() and not checkAdminIP():
return redirect_to('boardBase')
# enable static files downloading
session['feedAuth'] = True
session.save()
self.setCookie()
else:
user = self.userInst
self.userInst = user
title = u''
descr = u'%s News Feed' % g.OPT.baseDomain
posts = []
if re.compile("^\d+$").match(watch):
watch = int(watch)
thePost = Post.getPost(watch)
if not thePost:
abort(404)
title = _(u"%s: thread #%d") % (g.OPT.title, watch)
thread = Post.buildThreadFilter(user, thePost.id).first()
if not thread:
abort(404)
replies = thread.filterReplies().all()
posts = [thread]
if replies:
posts += replies
else:
title = _(u"%s: %s") % (g.OPT.title, watch)
filter = Post.buildMetaboardFilter(watch, user)[0]
tpp = user.threadsPerPage
posts = filter.order_by(Post.bumpDate.desc())[0:tpp]
feed = None
link = h.url_for('feed',
uid=uid,
authid=authid,
watch=watch,
feedType=feedType)
args = dict(
title=title,
link=link,
description=descr,
language=u"en",
)
if feedType == 'rss':
feed = Rss201rev2Feed(**args)
response.content_type = 'application/rss+xml'
else:
feed = Atom1Feed(**args)
response.content_type = 'application/atom+xml'
for post in posts:
parent = post.parentPost
if not parent:
parent = post
parent.enableShortMessages = False
title = None
if not post.parentPost:
post.replies = post.replyCount
title = _(u"Thread #%d") % post.id
else:
post.replies = None
title = _(u"#%d") % post.id
descr = self.render('rssPost',
'std',
thread=parent,
post=post,
disableFiltering=True) #.decode('utf-8')
feed.add_item(title=title,
link=h.url_for('thread', post=post.id),
description=descr)
out = feed.writeString('utf-8')
#css = str(h.staticFile(g.OPT.styles[0] + ".css"))
#out = out.replace('<?xml version="1.0" encoding="utf-8"?>',
# '<?xml version="1.0" encoding="utf-8"?>\n<?xml-stylesheet type="text/css" href="%s"?>' % css)
return out
except NotAuthorized:
abort(401, _('User %r not authorized to edit %r') % (c.user, id))
onlycreated = request.params.get('created', '')
feed_title=u'RSS-Feed - Geänderte Datensätze - %s - data.gv.at' % c.group_dict['display_name']
feed_description=_(u'Letzte Änderungen: ') + c.group_dict['display_name']
if onlycreated == '1':
feed_title=u'RSS-Feed - Neue Datensätze - %s - data.gv.at' % c.group_dict['display_name']
feed_description=_(u'Neue Datensätze: ') + c.group_dict['display_name']
format = request.params.get('format', '')
if format == 'atom':
# Generate and return Atom 1.0 document.
from webhelpers.feedgenerator import Atom1Feed
feed = Atom1Feed(
title=feed_title,
link=h.url_for(controller='group', action='read', id=c.group_dict['name']),
description=feed_description,
language=unicode(get_lang()),
)
for revision_dict in c.group_revisions:
revision_date = h.date_str_to_datetime(revision_dict['timestamp'])
try:
dayHorizon = int(request.params.get('days'))
except:
dayHorizon = 30
dayAge = (datetime.now() - revision_date).days
if dayAge >= dayHorizon:
break
if revision_dict['message']:
item_title = u'%s' % revision_dict['message'].split('\n')[0]
else:
def old_list(self):
format = request.params.get('format', '')
onlycreated = request.params.get('created', '')
organization = request.params.get('organization', '')
feed_title=u'RSS-Feed - Geänderte Datensätze - data.gv.at'
feed_description=_(u'Letzte Änderungen: ')
if onlycreated == '1':
feed_title=u'RSS-Feed - Neue Datensätze - data.gv.at'
feed_description=_(u'Neue Datensätze: ')
log.debug("organization selected: %s" % organization)
lang = get_lang()
if lang[0]:
lang = lang[0]
if format == 'atom':
feed = Atom1Feed(
title=_(feed_title),
link=h.url_for(controller='revision', action='list', id=''),
description=feed_description,
language=unicode(lang),
)
maxresults = 10
#revision_query = model.repo.history()
#revision_query = revision_query.limit(maxresults)
revision_query = model.repo.history()
revision_query = revision_query.order_by(model.Revision.timestamp.desc())
revision_query = revision_query.filter(model.Revision.id!=None)
#revision_query = revision_query.filter(model.Member.group_id=='4a766e5e-89a3-4a16-addd-05fa0b5953c3')
#revision_query = revision_query.limit(maxresults)
maintainer = 'default'
for revision in revision_query:
if(feed.num_items()>=maxresults):
break
transition = ""
packName= ""
package_indications = []
revision_changes = model.repo.list_changes(revision)
resource_revisions = revision_changes[model.Resource]
#package_revisions = revision_changes[model.Package]
resource_group_revisions = revision_changes[model.ResourceGroup]
package_extra_revisions = revision_changes[model.PackageExtra]
group_revisions = revision_changes[model.Group]
tag_revisions = revision_changes[model.PackageTag]
member_revisions = revision_changes[model.Member]
#Skip groups
if (len(group_revisions)>0):
continue
#if (len(member_revisions)>0):
#continue
if len(revision.packages)==0:
continue
if (len(resource_group_revisions) + len(tag_revisions) +len(package_extra_revisions) +len(resource_revisions))==0:
continue
for package in revision.packages:
number = len(package.all_revisions)
package_revision = None
count = 0
for pr in package.all_revisions:
count += 1
if pr.revision.id == revision.id:
package_revision = pr
break
if package_revision and package_revision.state == model.State.DELETED:
transition = 'deleted'
elif package_revision and count == number:
transition = 'created'
else:
transition = 'updated'
for resource_revision in resource_revisions:
if resource_revision.continuity.resource_group.package_id == package.id:
transition += ': Ressourcen'
break
for resource_group_revision in resource_group_revisions:
if resource_group_revision.package_id == package.id:
transition += ' resource_group'
break
for package_extra_revision in package_extra_revisions:
if package_extra_revision.package_id == package.id:
#if package_extra_revision.key == 'date_updated':
transition += ''
break
indication = "%s" % ( transition)
packName = package.name
packId = package.id
packTitle = package.title
maintainer = package.maintainer
package_indications.append(indication)
package = model.Package.get(packId)
packDict = model.Package.as_dict(package)
if (onlycreated == '1') and not(transition.startswith('created')):
continue
log.debug('group found: %s / group wanted: %s' % (packDict.get('groups'), organization))
if (organization != ''):
if not(organization in packDict.get('groups')):
continue
log.critical('CORRECT GROUP FOUND!!')
#if len(package_indications[0]) < 3:
# revision_changes.xxx()
pkgs = u'%s' % ' '.join(package_indications)
#item_title = u'%s ' % (revision.id)
item_title = packTitle
#if revision.message:
# item_title += ': %s' % (revision.message or '')
item_link = '/sucheDetail/?id=' + packId
item_description = indication
#item_description = _('Datasets affected: %s.\n') % pkgs
#item_description += '%s' % (revision.message or '')
#item_author_name = Authorization Group !
item_author_name = maintainer
item_pubdate = revision.timestamp
feed.add_item(
title=item_title,
link=item_link,
description=item_description,
author_name=item_author_name,
pubdate=item_pubdate,
)
log.fatal("feedlength: " + feed.num_items())
feed.content_type = 'application/atom+xml'
return feed.writeString('utf-8')
else:
return RevisionController.list(self);
def list(self):
format = request.params.get('format', '')
onlycreated = request.params.get('created', '')
organization = request.params.get('organization', '')
feed_title=u'RSS-Feed - Geänderte Datensätze - data.gv.at'
feed_description=_(u'Letzte Änderungen: ')
if onlycreated == '1':
feed_title=u'RSS-Feed - Neue Datensätze - data.gv.at'
feed_description=_(u'Neue Datensätze: ')
log.debug("organization selected: %s" % organization)
if format == 'atom':
# Generate and return Atom 1.0 document.
from webhelpers.feedgenerator import Atom1Feed
feed = Atom1Feed(
title=feed_title,
link=h.url_for(controller='revision', action='list', id=''),
description=feed_description,
language=unicode(get_lang()),
)
# TODO: make this configurable?
# we do not want the system to fall over!
maxresults = 200
maxfeedresults = 10
try:
dayHorizon = int(request.params.get('days', 30))
except:
dayHorizon = 30
ourtimedelta = timedelta(days=-dayHorizon)
since_when = datetime.now() + ourtimedelta
querycounter = 0
while querycounter <= 2:
revision_query = model.repo.history()
revision_query = revision_query.filter(
model.Revision.timestamp>=since_when).filter(
model.Revision.id!=None)
revision_query = revision_query.slice(maxresults*querycounter, maxresults*querycounter+maxresults)
for revision in revision_query:
if(feed.num_items()>=maxfeedresults):
break
package_indications = []
revision_changes = model.repo.list_changes(revision)
resource_revisions = revision_changes[model.Resource]
resource_group_revisions = revision_changes[model.ResourceGroup]
package_extra_revisions = revision_changes[model.PackageExtra]
for package in revision.packages:
number = len(package.all_revisions)
package_revision = None
count = 0
for pr in package.all_revisions:
count += 1
if pr.revision.id == revision.id:
package_revision = pr
break
if package_revision and package_revision.state == model.State.DELETED:
transition = 'deleted'
elif package_revision and count == number:
transition = 'created'
else:
transition = 'updated'
for resource_revision in resource_revisions:
if resource_revision.continuity.resource_group.package_id == package.id:
transition += ':resources'
break
for resource_group_revision in resource_group_revisions:
if resource_group_revision.package_id == package.id:
transition += ':resource_group'
break
for package_extra_revision in package_extra_revisions:
if package_extra_revision.package_id == package.id:
if package_extra_revision.key == 'date_updated':
transition += ':date_updated'
break
indication = "%s:%s" % (package.name, transition)
package_indications.append(indication)
packName = package.name
packId = package.id
# packTitle = package.title
# maintainer = package.maintainer
# package_indications.append(indication)
# package = model.Package.get(packId)
# packDict = model.Package.as_dict(package)
if (onlycreated == '1') and not(transition.startswith('created')):
log.fatal("show only created")
log.fatal("transition: %s" % transition)
continue
# log.debug('group found: %s / group wanted: %s' % (packDict.get('groups'), organization))
# if (organization != ''):
# if not(organization in packDict.get('groups')):
# continue
# log.critical('CORRECT GROUP FOUND!!')
pkgs = u'[%s]' % ' '.join(package_indications)
item_title = u'r%s ' % (revision.id)
item_title += pkgs
if revision.message:
item_title += ': %s' % (revision.message or '')
item_link = "/sucheDetail/?id=%s" % packId
item_description = _('Datasets affected: %s.\n') % pkgs
item_description += '%s' % (revision.message or '')
item_author_name = revision.author
item_pubdate = revision.timestamp
feed.add_item(
title=item_title,
link=item_link,
description=item_description,
author_name=item_author_name,
pubdate=item_pubdate,
)
querycounter += 1
feed.content_type = 'application/atom+xml'
return feed.writeString('utf-8')
else:
query = model.Session.query(model.Revision)
c.page = Page(
collection=query,
page=request.params.get('page', 1),
url=h.pager_url,
items_per_page=20
)
return render('revision/list.html')
class feedGroupController(GroupController):
def history(self, id):
if 'diff' in request.params or 'selected1' in request.params:
try:
params = {'id':request.params.getone('group_name'),
'diff':request.params.getone('selected1'),
'oldid':request.params.getone('selected2'),
}
except KeyError, e:
if dict(request.params).has_key('group_name'):
id = request.params.getone('group_name')
c.error = _('Select two revisions before doing the comparison.')
else:
params['diff_entity'] = 'group'
h.redirect_to(controller='revision', action='diff', **params)
context = {'model': model, 'session': model.Session,
'user': c.user or c.author,
'schema': self._form_to_db_schema()}
data_dict = {'id': id}
try:
c.group_dict = get_action('group_show')(context, data_dict)
c.group_revisions = get_action('group_revision_list')(context, data_dict)
c.group = context['group']
except NotFound:
abort(404, _('Group not found'))
except NotAuthorized:
abort(401, _('User %r not authorized to edit %r') % (c.user, id))
onlycreated = request.params.get('created', '')
feed_title=u'RSS-Feed - Geänderte Datensätze - %s - data.gv.at' % c.group_dict['display_name']
feed_description=_(u'Letzte Änderungen: ') + c.group_dict['display_name']
if onlycreated == '1':
feed_title=u'RSS-Feed - Neue Datensätze - %s - data.gv.at' % c.group_dict['display_name']
feed_description=_(u'Neue Datensätze: ') + c.group_dict['display_name']
format = request.params.get('format', '')
if format == 'atom':
# Generate and return Atom 1.0 document.
from webhelpers.feedgenerator import Atom1Feed
feed = Atom1Feed(
title=_(u'CKAN Group Revision History'),
link=h.url_for(controller='group', action='read', id=c.group_dict['name']),
description=_(u'Recent changes to CKAN Group: ') +
c.group_dict['display_name'],
language=unicode(get_lang()),
)
for revision_dict in c.group_revisions:
revision_date = h.date_str_to_datetime(revision_dict['timestamp'])
try:
dayHorizon = int(request.params.get('days'))
except:
dayHorizon = 30
dayAge = (datetime.datetime.now() - revision_date).days
if dayAge >= dayHorizon:
break
if revision_dict['message']:
item_title = u'%s' % revision_dict['message'].split('\n')[0]
else:
item_title = u'%s' % revision_dict['id']
item_link = h.url_for(controller='revision', action='read', id=revision_dict['id'])
item_description = _('Log message: ')
item_description += '%s' % (revision_dict['message'] or '')
item_author_name = revision_dict['author']
item_pubdate = revision_date
feed.add_item(
title=item_title,
link=item_link,
description=item_description,
author_name=item_author_name,
pubdate=item_pubdate,
)
feed.content_type = 'application/atom+xml'
return feed.writeString('utf-8')
return render( self._history_template(c.group_dict['type']) )
