def setUp(self):
"creates three feeds, one with a subscriber and two without"
for url in ['slashdot.xml', 'osnews.xml', 'hacker_news.xml']:
logic.pull_feed("http://localhost:8000/endtimes/test/%s" % url,
create_entries=True)
self.feedobj = models.Feed.objects.get(slug='hacker-news')
logic.add_user_feed(self.get_user(), self.feedobj)
def setUp(self):
logic.pull_feed("http://localhost:8000/endtimes/test/slashdot.xml",
user=self.get_user(),
create_entries=True)
self.c = Client()
self.assertTrue(self.c.login(username='******', password='******'))
self.entryobj = logic.user_entry_list(self.get_user())[0]
def test_client_create_many_dummy_entries_in_range(self):
cbit = self.custom_feed_url(9,
dt.today() - timedelta(days=7),
dt.today()).lstrip('/')
logic.pull_feed("http://localhost:8000/endtimes/%s" % cbit,
user=self.get_user(),
create_entries=True)
self.assertEqual(models.Entry.objects.all().count(), 9)
def setUp(self):
# creates 7 entries over 7 days
period = 7
cbit = self.custom_feed_url(period,
date.today() - timedelta(days=period),
date.today()).lstrip('/')
logic.pull_feed("http://localhost:8000/endtimes/%s" % cbit,
create_entries=True)
self.feedobj = models.Feed.objects.all()[0]
# create a digest for the feed
self.digestobj, created = dh.get_create_digest_feed(
self.get_user(), self.feedobj, 'daily')
def setUp(self):
# create 14 entries over the last 7 days
# use yesterday because the date passed to create_prev_entries
# in the view is today's date
today = dt.yesterday()
self.start_dt, self.end_dt = today - timedelta(days=7), today
cbit = self.custom_feed_url(14, self.start_dt, self.end_dt).lstrip('/')
logic.pull_feed("http://localhost:8000/endtimes/%s" % cbit,
create_entries=True)
self.feedobj = models.Feed.objects.get(pk=1)
self.c = Client()
self.assertTrue(self.c.login(username="******", password="******"))
def setUp(self):
# creates 21 objects over 7 days (~3 objects per digest per day)
today_sat = dt.today() + rd.relativedelta(weekday=rd.SA)
start_dt, end_dt = today_sat - timedelta(days=7), today_sat
cbit = self.custom_feed_url(21, start_dt, end_dt).lstrip('/')
logic.pull_feed("http://localhost:8000/endtimes/%s" % cbit,
user=self.get_user(),
create_entries=True)
feedobj = models.Feed.objects.get(pk=1)
digestobj, created = dh.get_create_digest_feed(self.get_user(),
feedobj, 'daily')
dh.create_prev_digest_entries(digestobj, today=end_dt, until=start_dt)
def setUp(self):
self.period = 7
today_sat = datetime.now() + rd.relativedelta(weekday=rd.SA)
cbit = self.custom_feed_url(self.period,
today_sat - timedelta(days=self.period),
today_sat).lstrip('/')
logic.pull_feed("http://localhost:8000/endtimes/%s" % cbit,
create_entries=True)
self.feedobj = models.Feed.objects.get(pk=1)
self.digestobj, created = dh.get_create_digest_feed(
self.get_user(), self.feedobj, 'weekly', 'sat')
self.compobj = dh.create_digest_entry(self.digestobj)
self.assertTrue(isinstance(self.compobj, models.DigestEntry))
self.assertTrue(self.compobj.entries.all().count() > 0)
def setUp(self):
# create 14 entries over the last 14 days
period = 14
today_sat = dt.today(
) # + rd.relativedelta(weekday=rd.SA(-1)) # last sat
self.start_dt, self.end_dt = today_sat - timedelta(
days=period), today_sat
cbit = self.custom_feed_url(period, self.start_dt,
self.end_dt).lstrip('/')
logic.pull_feed("http://localhost:8000/endtimes/%s" % cbit,
create_entries=True)
self.feedobj = models.Feed.objects.get(pk=1)
self.c = Client()
self.assertTrue(self.c.login(username="******", password="******"))
def import_opml(path, create_feed=True, create_entries=False):
res = listparser.parse(path)
ret = []
for feed in res.feeds:
flat_cats = []
for cat_list in feed.categories:
for cat in cat_list:
flat_cats.append(cat) # nested-nested categories? ew.
# feeds can only have one category currently, use the last one found
cat = flat_cats[-1]
logger.debug("all known categories for this feed: %s" % flat_cats)
logger.info("fetching or creating FeedGroup %r" % cat)
feed_group, created = models.FeedGroup.objects.get_or_create(
slug=slugify(cat))
if created:
logger.info("new feed group created %r" % feed_group)
else:
logger.info("found feed group %r" % feed_group)
# pull the feed down
success, data = logic.pull_feed(feed.url, create_feed, create_entries)
ret.append((success, feed.url))
if success:
logger.info("successfully pulled feed, associating with group")
# attach the feed group
feed = data['feed']
feed.group = feed_group
feed.save()
else:
logger.warning("failed to pull feed, error was: %s", data)
return ret
def discover_feeds2(request, url=None):
"Handles the adding and discovering of new feeds. The views discover_feed and add_feed both use this."
logger.info("discover_feed2 view")
action = '/endtimes/feed/add/discovered/'
session_key = 'endtimes_feed_choices'
alt_feeds = []
if url:
logger.debug("url given")
# shortcut the form submission process
success, data = logic.discover_feeds(url)
if success:
alt_feeds = data
logger.debug('discovered these feeds %s' % alt_feeds)
url_choices = forms.gen_url_choices(alt_feeds)
request.session[session_key] = url_choices
form = forms.PickFeedForm(url_choice_list=url_choices)
else:
logger.debug("discovered no feeds")
messages.error(request, "Failed to discover feeds. %s" % data)
return named_redirect('discover-feed')
elif request.POST and request.session.has_key(session_key):
logger.debug("POST request, previous submission detected")
url_choices = request.session[session_key]
form = forms.PickFeedForm(request.POST, url_choice_list=url_choices)
if form.is_valid():
c_data = form.cleaned_data
failures = []
for url in c_data['url_list']:
# import all feeds user selected
success, data = logic.pull_feed(url,
user=request.user,
create_entries=True)
if success:
msg = []
if data['created'] != 0:
msg.append("%s entries created" % data['created'])
if data['updated'] != 0:
msg.append("%s entries updated." % data['updated'])
messages.success(request, "%s." % " and ".join(msg))
else:
failures.append((url, data)) # unfinished?
return named_redirect('dash')
else:
messages.error(request, "There were errors in your submission.")
else:
logger.debug(
"no url given and not a post, return first part of submission")
return discover_feeds(request)
return {'form': form, 'action': action, 'discovered_feeds': alt_feeds}
def _pull_feed(request, feed_url, user=None):
"User friendly wrapper around `logic.pull_feed` where errors are added to the session messages."
success, data = logic.pull_feed(feed_url, user=user)
func, msg = messages.error, "A problem occured pulling feed %s: %s" % (
feed_url, data)
if success:
func, msg = messages.success, "Successfully pulled feed %s (%s added, %s updated)." % (
feed_url, data['created'], data['updated'])
if request.is_ajax():
return {'success': success, 'message': msg, 'data': data}
func(request, msg)
return success
def setUp(self):
# creates 30 entries over 14 days
period = 30
self.entry_count = 14
self.today = dt.today()
self.start_dt = self.today - timedelta(days=period)
self.end_dt = self.today
cbit = self.custom_feed_url(self.entry_count, self.start_dt,
self.end_dt).lstrip('/')
res = logic.pull_feed("http://localhost:8000/endtimes/%s" % cbit,
user=self.get_user(),
create_entries=True)
self.feedobj = models.Feed.objects.get(pk=1)
def setUp(self):
# creates 14 entries over 14 days
self.period = 14
today_sat = dt.today() + rd.relativedelta(weekday=rd.SA)
self.start_dt = dt.min(today_sat - timedelta(days=self.period))
self.end_dt = dt.max(today_sat)
cbit = self.custom_feed_url(self.period, self.start_dt,
self.end_dt).lstrip('/')
res = logic.pull_feed("http://localhost:8000/endtimes/%s" % cbit,
user=self.get_user(),
create_entries=True)
self.feedobj = models.Feed.objects.get(pk=1)
self.digestobj, created = dh.get_create_digest_feed(
self.get_user(), self.feedobj, 'weekly', 'sat')
def setUp(self):
# create 28 entries over 14 days
period = 14
self.today = dt.today() + rd.relativedelta(weekday=rd.SA(-1))
self.start_dt = self.today - timedelta(days=period)
self.end_dt = self.today
cbit = self.custom_feed_url(period * 2, self.start_dt,
self.end_dt).lstrip('/')
res = logic.pull_feed("http://localhost:8000/endtimes/%s" % cbit,
user=self.get_user(),
create_entries=True)
feedobj = models.Feed.objects.get(pk=1)
self.digestobj, created = dh.get_create_digest_feed(
self.get_user(), feedobj, 'weekly', 'sat')
def setUp(self):
# create 14 entries over 7 days
period = 7
self.today = dt.today()
self.start_dt = self.today - timedelta(days=period)
self.end_dt = self.today
cbit = self.custom_feed_url(period * 2, self.start_dt,
self.end_dt).lstrip('/')
res = logic.pull_feed("http://localhost:8000/endtimes/%s" % cbit,
user=self.get_user(),
create_entries=True)
feedobj = models.Feed.objects.get(pk=1)
self.digestobj, created = dh.get_create_digest_feed(
self.get_user(), feedobj, 'daily')
def import_csv(csv_data, create_feed=True, create_entries=False):
results = []
for row in csv_data:
success, data = logic.pull_feed(row['feed_url'], create_feed,
create_entries)
results.append((success, row['feed_url']))
if success:
if create_feed:
feedobj = data['feed']
cat_list = filter(lambda e: not not e,
row['feed_categories'].split('|'))
create_categories(cat_list, feedobj)
else:
logger.warning("failed to pull feed, error was: %s", data)
return results
def test_create_many_dummy_entries(self):
logic.pull_feed("http://localhost:8000/endtimes/test/slashdot.xml",
create_entries=False)
feedobj = models.Feed.objects.all()[0]
logic.create_dummy_entries(feedobj, logic.dummy_entry_data_list(15))
self.assertEqual(models.Entry.objects.all().count(), 15)
def setUp(self):
logic.pull_feed("http://localhost:8000/endtimes/test/slashdot.xml",
user=self.get_user(),
create_entries=True)
def setUp(self):
# creates 15 entries over 7 days
period, entries = 7, 15
cbit = self.custom_feed_url(entries, dt.today() - timedelta(days=period), dt.today()).lstrip('/')
logic.pull_feed("http://localhost:8000/endtimes/%s" % cbit, user=self.get_user(), create_entries=True)
self.c = Client()
def setUp(self):
# create feeds but do not subscribe anyone to them
# do not create any entries
for url in ['slashdot.xml', 'osnews.xml']:
logic.pull_feed("http://localhost:8000/endtimes/test/%s" % url,
create_entries=False)
def setUp(self):
# add feed and subscribe user
logic.pull_feed("http://localhost:8000/endtimes/test/slashdot.xml",
user=self.get_user())
self.entryobj = logic.user_entry_list(self.get_user())[0]
def test_client_create_many_dummy_entries(self):
logic.pull_feed(
"http://localhost:8000/endtimes/test/dummy-feed/9/entries/",
user=self.get_user(),
create_entries=True)
self.assertEqual(models.Entry.objects.all().count(), 9)
def json_add_feed(request):
"Streamlined add/discover feed handling for ajax calls. Fails DRY"
if not request.is_ajax():
raise Http404()
if not request.POST:
return json_error("POST submissions only.")
session_key = 'endtimes_feed_choices'
if request.session.has_key(
session_key) and not request.POST.has_key('url'):
logger.debug("previous form detected")
# a form has been submitted previously, we're now expecting url selections
url_choices = request.session[session_key]
form = forms.PickFeedForm(request.POST, url_choice_list=url_choices)
del request.session[session_key]
if form.is_valid():
c_data = form.cleaned_data
results = {'success': [], 'errors': []}
for url in c_data['url_list']:
# import all feeds user selected
success, data = logic.pull_feed(url,
user=request.user,
create_entries=True)
key = 'success' if success else 'errors'
results[key].append(url)
return json_success("Successfully added feed.")
else:
return json_error("Errors in your form.")
#
form = forms.AddFeedForm(request.POST)
if form.is_valid():
c_data = form.cleaned_data
feed_url = c_data['url']
pull_data = _pull_feed(request, feed_url, request.user)
success = pull_data['success']
if success:
# found the feed perfectly
return json_success("Successfully added feed")
else:
# try the home page for feeds
success, data = logic.discover_feeds(
logic.parse_homepage(feed_url))
if success:
# prompt the user to pick a feed
alt_feeds = data
url_choices = forms.gen_url_choices(alt_feeds)
request.session[session_key] = url_choices
form = forms.PickFeedForm(url_choice_list=url_choices)
t = Template(
"""<form method="POST" action="/endtimes/json/feed/add/">{% csrf_token %}{{ form.as_p }}<input type="submit" /></form>"""
)
html = t.render(RequestContext(request, {'form': form}))
return json_response(
"more", "Feeds found, but a selection is required.",
{'form': html})
else:
# no feeds found, inform the user of the sad news
return json_error(pull_data['message'])
else:
return json_error(
"Errors in your form. A *valid* URL is required. Please try again."
)
def setUp(self):
logic.pull_feed("http://localhost:8000/endtimes/test/slashdot.xml",
user=self.get_user(),
create_entries=True)
self.feedobj = models.Feed.objects.all()[0]
