def new_promotion(title, url, selftext, user, ip):
"""
Creates a new promotion with the provided title, etc, and sets it
status to be 'unpaid'.
"""
sr = Subreddit._byID(get_promote_srid())
l = Link._submit(title, url, user, sr, ip)
l.promoted = True
l.disable_comments = False
PromotionLog.add(l, "promotion created")
if url == "self":
l.url = l.make_permalink_slow()
l.is_self = True
l.selftext = selftext
l._commit()
update_promote_status(l, PROMOTE_STATUS.unpaid)
# the user has posted a promotion, so enable the promote menu unless
# they have already opted out
if user.pref_show_promote is not False:
user.pref_show_promote = True
user._commit()
# notify of new promo
emailer.new_promo(l)
return l
def submit_all():
from r2.models import Subdigg, Account, Link, NotFound
from r2.lib.media import set_media
from r2.lib.db import queries
sr = Subdigg._by_name('testmedia')
author = Account._by_name('testmedia')
links = []
for url in test_urls:
try:
# delete any existing version of the link
l = Link._by_url(url, sr)
print "Deleting %s" % l
l._deleted = True
l._commit()
except NotFound:
pass
l = Link._submit(url, url, author, sr, '0.0.0.0')
try:
set_media(l)
except Exception, e:
print e
if g.write_query_queue:
queries.new_link(l)
links.append(l)
def dfp_creative_to_link(creative, link=None):
from r2.models import (
Link,
PROMOTE_STATUS,
)
user = get_dfp_user()
sr = get_dfp_subreddit()
attributes = dfp_template_to_dict(
creative.creativeTemplateVariableValues)
kind = "self" if attributes["selftext"] else "link"
url = attributes["url"] if kind == "link" else "self"
if not link:
link = Link._submit(
attributes["title"], url, user, sr,
ip="127.0.0.1", sendreplies=False,
)
if kind == "self":
link.url = link.make_permalink_slow()
link.is_self = True
link.selftext = attributes["selftext"]
link.promoted = True
link.promote_status = PROMOTE_STATUS.promoted
link.thumbnail_url = attributes["thumbnail_url"]
link.mobile_ad_url = attributes["mobile_ad_url"]
link.third_party_tracking = attributes["third_party_tracking"]
link.third_party_tracking_2 = attributes["third_party_tracking_2"]
link.dfp_creative_id = creative["id"]
link._commit()
return link
def submit_link(user, subreddit, title, url, thumb_url):
account = Account._by_name(user)
subreddit = Subreddit._by_name(subreddit)
ip = '127.0.0.1'
# submit the link
link = Link._submit(
is_self=False,
title=title,
content=url,
author=account,
sr=subreddit,
ip=ip,
spam=False,
)
try:
# force the thumbnail before scraper_q gets in the mix
image_data = urllib.urlopen(thumb_url).read()
force_thumbnail(link, image_data)
except:
pass
# various backend processing things
queries.new_link(link)
link.update_search_index()
# wait for the amqp worker to finish up
worker.join()
print link.make_permalink_slow()
def _create_link(creative):
"""
Creates a link to allow third party voting/commenting
"""
user = _get_user()
sr = _get_subreddit()
attributes = _template_to_dict(creative)
kind = "self" if attributes["selftext"] else "link"
url = attributes["url"] if kind == "link" else "self"
link = Link._submit(
attributes["title"], url, user, sr,
ip="127.0.0.1", sendreplies=False,
)
if kind == "self":
link.url = link.make_permalink_slow()
link.is_self = True
link.selftext = attributes["selftext"]
link.promoted = True
link.third_party_promo = True
link.thumbnail_url = attributes["thumbnail_url"]
link.mobile_ad_url = attributes["mobile_ad_url"]
link.third_party_tracking = attributes["third_party_tracking"]
link.third_party_tracking_2 = attributes["third_party_tracking_2"]
link.external_id = creative["id"]
link._commit()
return link
def new_promotion(is_self, title, content, author, ip):
"""
Creates a new promotion with the provided title, etc, and sets it
status to be 'unpaid'.
"""
sr = Subreddit._byID(Subreddit.get_promote_srid())
l = Link._submit(
is_self=is_self,
title=title,
content=content,
author=author,
sr=sr,
ip=ip,
)
l.promoted = True
l.disable_comments = False
l.sendreplies = True
PromotionLog.add(l, 'promotion created')
update_promote_status(l, PROMOTE_STATUS.unpaid)
# the user has posted a promotion, so enable the promote menu unless
# they have already opted out
if author.pref_show_promote is not False:
author.pref_show_promote = True
author._commit()
# notify of new promo
emailer.new_promo(l)
return l
def new_promotion(is_self, title, content, author, ip):
"""
Creates a new promotion with the provided title, etc, and sets it
status to be 'unpaid'.
"""
sr = Subreddit._byID(Subreddit.get_promote_srid())
l = Link._submit(
is_self=is_self,
title=title,
content=content,
author=author,
sr=sr,
ip=ip,
)
l.promoted = True
l.disable_comments = False
l.sendreplies = True
PromotionLog.add(l, 'promotion created')
update_promote_status(l, PROMOTE_STATUS.unpaid)
# the user has posted a promotion, so enable the promote menu unless
# they have already opted out
if author.pref_show_promote is not False:
author.pref_show_promote = True
author._commit()
# notify of new promo
emailer.new_promo(l)
return l
def submit_rss_links(srname,rss,user,titlefield='title',linkfield='link'):
#F**k the API, let's just do it the way we would if we were really doing it. This avoids screwing around with cookies and so forth...
feed=fetch_feed(rss)
if feed is None:
return
ac=Account._byID(user)
sr=Subsciteit._by_name(srname)
ip='0.0.0.0'
niceify=False
if domain(rss)=="arxiv.org":
niceify=dict(find="\(arXiv:.*?\)",replace="")
#Let's randomize why not...
random.shuffle(feed.entries)
for article in feed.entries:
#This can take all night if it has to, we don't want to hammer the server into oblivios
sleep(1)
kw = fetch_article(article,titlefield=titlefield,linkfield=linkfield,niceify=niceify)
if kw is None:
continue
l = Link._submit(kw['title'],kw['link'],ac,sr,ip,spam=False)
l._commit()
l.set_url_cache()
#We don't really need auto-submitted links to be vote on...
queries.queue_vote(ac,l,True,ip,cheater=False)
queries.new_link(l)
changed(l)
print "Submitted %s" % article[titlefield]
sleep(.1)
return
def new_promotion(title, url, selftext, user, ip):
"""
Creates a new promotion with the provided title, etc, and sets it
status to be 'unpaid'.
"""
sr = Subreddit._byID(get_promote_srid())
l = Link._submit(title, url, user, sr, ip)
l.promoted = True
l.disable_comments = False
PromotionLog.add(l, 'promotion created')
if url == 'self':
l.url = l.make_permalink_slow()
l.is_self = True
l.selftext = selftext
l._commit()
# set the status of the link, populating the query queue
if c.user_is_sponsor or user.trusted_sponsor:
set_promote_status(l, PROMOTE_STATUS.accepted)
else:
set_promote_status(l, PROMOTE_STATUS.unpaid)
# the user has posted a promotion, so enable the promote menu unless
# they have already opted out
if user.pref_show_promote is not False:
user.pref_show_promote = True
user._commit()
# notify of new promo
emailer.new_promo(l)
return l
def new_promotion(title, url, selftext, user, ip):
"""
Creates a new promotion with the provided title, etc, and sets it
status to be 'unpaid'.
"""
sr = Subreddit._byID(Subreddit.get_promote_srid())
l = Link._submit(title, url, user, sr, ip)
l.promoted = True
l.disable_comments = False
l.sendreplies = True
PromotionLog.add(l, 'promotion created')
if url == 'self':
l.url = l.make_permalink_slow()
l.is_self = True
l.selftext = selftext
l._commit()
update_promote_status(l, PROMOTE_STATUS.unpaid)
# the user has posted a promotion, so enable the promote menu unless
# they have already opted out
if user.pref_show_promote is not False:
user.pref_show_promote = True
user._commit()
# notify of new promo
emailer.new_promo(l)
return l
def process_post(self, post_data, sr):
# Prepare data for import
title = self.kill_tags_re.sub('', post_data['title'])
article = u'%s%s' % (post_data['description'],
Link._more_marker + post_data['mt_text_more']
if post_data['mt_text_more'] else u'')
ip = '127.0.0.1'
tags = [
self.transform_categories_re.sub('_', tag.lower())
for tag in post_data.get('category', [])
]
naive_date = datetime.datetime.strptime(post_data['dateCreated'],
DATE_FORMAT)
local_date = INPUT_TIMEZONE.localize(
naive_date, is_dst=False) # Pick the non daylight savings time
utc_date = local_date.astimezone(pytz.utc)
# Determine account to use for this post
account = self._get_or_create_account(post_data['author'],
post_data['authorEmail'])
# Look for an existing post created due to a previous import
post = self._query_post(Link.c.ob_permalink == post_data['permalink'])
if not post:
# Create new post
post = Link._submit(title,
article,
account,
sr,
ip,
tags,
date=utc_date)
post.blessed = True
post.comment_sort_order = 'old'
post.ob_permalink = post_data['permalink']
post._commit()
else:
# Update existing post
post.title = title
post.article = article
post.author_id = account._id
post.sr_id = sr._id
post.ip = ip
post.set_tags(tags)
post._date = utc_date
post.blessed = True
post.comment_sort_order = 'old'
post._commit()
# Process each comment for this post
comment_dictionary = {}
comments = self._query_comments(Comment.c.link_id == post._id,
Comment.c.ob_imported == True)
[
self.process_comment(comment_data, comment, post,
comment_dictionary)
for comment_data, comment in map(None, post_data.get(
'comments', []), comments)
]
def new_promotion(title, url, user, ip):
"""
Creates a new promotion with the provided title, etc, and sets it
status to be 'unpaid'.
"""
sr = Subreddit._byID(get_promote_srid())
l = Link._submit(title, url, user, sr, ip)
l.promoted = True
l.disable_comments = False
PromotionLog.add(l, 'promotion created')
l._commit()
# set the status of the link, populating the query queue
if c.user_is_sponsor or user.trusted_sponsor:
set_promote_status(l, PROMOTE_STATUS.accepted)
else:
set_promote_status(l, PROMOTE_STATUS.unpaid)
# the user has posted a promotion, so enable the promote menu unless
# they have already opted out
if user.pref_show_promote is not False:
user.pref_show_promote = True
user._commit()
# notify of new promo
emailer.new_promo(l)
return l
def post_if_goal_reached(date):
# bail out if this day's already been submitted
for link in get_recent_name_submissions():
if link.revenue_date == date:
return
revenue = gold_revenue_multi([date]).get(date, 0)
goal = gold_goal_on(date)
percent = revenue / float(goal)
bucket = int(percent)
if bucket == 0:
return
buyer_count = len(gold_buyers_on(date))
template_wp = WikiPage.get(SERVERNAME_SR, "templates/selftext")
template = random.choice(template_wp._get("content").split("\r\n---\r\n"))
boilerplate = WikiPage.get(SERVERNAME_SR,
"templates/boilerplate")._get("content")
selftext_template = template + "\n\n---\n\n" + boilerplate
link = Link._submit(
is_self=True,
title=date.strftime("%a %Y-%m-%d"),
content=selftext_template % {
"percent": int(percent * 100),
"buyers": buyer_count,
},
author=SYSTEM_ACCOUNT,
sr=SERVERNAME_SR,
ip="127.0.0.1",
spam=False,
)
link.flair_text = "Name pending..."
link.flair_css_class = "goal-bucket-%d-active" % bucket
link.revenue_date = date
link.revenue_bucket = bucket
link.server_names = []
link._commit()
queries.new_link(link)
link.update_search_index()
template = WikiPage.get(SERVERNAME_SR,
"templates/notification-message")._get("content")
subject_template, sep, body_template = template.partition("\r\n")
for id in gold_buyers_on(date):
recipient = Account._byID(id, data=True)
send_system_message(
recipient,
subject_template,
body_template % {
"percent": int(percent * 100),
"buyers": buyer_count,
"user": recipient.name,
"link": link.url,
},
)
def post_if_goal_reached(date):
# bail out if this day's already been submitted
for link in get_recent_name_submissions():
if link.revenue_date == date:
return
revenue = gold_revenue_multi([date]).get(date, 0)
goal = gold_goal_on(date)
percent = revenue / float(goal)
bucket = int(percent)
if bucket == 0:
return
buyer_count = len(gold_buyers_on(date))
template_wp = WikiPage.get(SERVERNAME_SR, "templates/selftext")
template = random.choice(template_wp._get("content").split("\r\n---\r\n"))
boilerplate = WikiPage.get(SERVERNAME_SR, "templates/boilerplate")._get("content")
selftext_template = template + "\n\n---\n\n" + boilerplate
link = Link._submit(
is_self=True,
title=date.strftime("%a %Y-%m-%d"),
content=selftext_template % {
"percent": int(percent * 100),
"buyers": buyer_count,
},
author=SYSTEM_ACCOUNT,
sr=SERVERNAME_SR,
ip="127.0.0.1",
spam=False,
)
link.flair_text = "Name pending..."
link.flair_css_class = "goal-bucket-%d-active" % bucket
link.revenue_date = date
link.revenue_bucket = bucket
link.server_names = []
link._commit()
UPVOTE = True
queries.queue_vote(SYSTEM_ACCOUNT, link, UPVOTE, "127.0.0.1")
queries.new_link(link)
link.update_search_index()
template = WikiPage.get(SERVERNAME_SR, "templates/notification-message")._get("content")
subject_template, sep, body_template = template.partition("\r\n")
for id in gold_buyers_on(date):
recipient = Account._byID(id, data=True)
send_system_message(
recipient,
subject_template,
body_template % {
"percent": int(percent * 100),
"buyers": buyer_count,
"user": recipient.name,
"link": link.url,
},
)
def test_get_links(self):
from r2.lib.db import queries
from r2.models import Subreddit, Account, Link, Thing
account = Account._byID(1, data=True)
sr = Subreddit._by_name("reddit_test0")
link_url = self.make_unique_url()
new_link = Link._submit("test_get_links", link_url, account, sr, "127.0.0.1", kind="link")
queries.new_link(new_link, foreground=True)
res = Thing._by_fullname(queries.get_links(sr, "new", "all"), return_dict=False)
self.assert_true(len(res) > 0, "no links returned")
self.assert_equal(new_link._id, res[0]._id)
def POST_create(self, res, title, description, location, latitude, longitude, timestamp, tzoffset, ip):
if res._chk_error(errors.NO_TITLE):
res._chk_error(errors.TITLE_TOO_LONG)
res._focus('title')
res._chk_errors((errors.NO_LOCATION,
errors.NO_DESCRIPTION,
errors.INVALID_DATE,
errors.NO_DATE))
if res.error: return
meetup = Meetup(
author_id = c.user._id,
title = title,
description = description,
location = location,
latitude = latitude,
longitude = longitude,
timestamp = timestamp,
tzoffset = tzoffset
)
# Expire all meetups in the render cache
g.rendercache.invalidate_key_group(Meetup.group_cache_key())
meetup._commit()
l = Link._submit(meetup_article_title(meetup), meetup_article_text(meetup),
c.user, Subreddit._by_name('meetups'),ip, [])
l.meetup = meetup._id36
l._commit()
meetup.assoc_link = l._id
meetup._commit()
when = datetime.now(g.tz) + timedelta(0, 3600) # Leave a short window of time before notification, in case
# the meetup is edited/deleted soon after its creation
PendingJob.store(when, 'process_new_meetup', {'meetup_id': meetup._id})
#update the queries
if g.write_query_queue:
queries.new_link(l)
res._redirect(url_for(action='show', id=meetup._id36))
def test_sending_an_email(self):
sr = Subreddit._by_name('reddit_test0')
account = self.get_test_user()
sr.add_subscriber(account)
self.assertIn(sr._id, account.spaces)
summary_email.reset_last_email_sent_at_for_all_accounts()
assert summary_email.should_send_activity_summary_email(account)
link_url = self.make_unique_url()
new_link = Link._submit("test_get_links", link_url, account, sr, '127.0.0.1', kind='link')
queries.new_link(new_link, foreground=True)
send_email = Mock()
summary_email.send_account_summary_email(1, send_email=send_email)
self.assert_equal(1, send_email.call_count)
self.assert_equal('*****@*****.**', send_email.call_args[0][0])
def submit_link(user, subreddit, title, url, thumb_url):
account = Account._by_name(user)
subreddit = Subreddit._by_name(subreddit)
ip = '127.0.0.1'
# submit the link
link = Link._submit(title, url, account, subreddit, ip, spam=False)
# force the thumbnail before scraper_q gets in the mix
image_data = urllib.urlopen(thumb_url).read()
force_thumbnail(link, image_data)
# various backend processing things
queries.queue_vote(account, link, True, ip)
queries.new_link(link)
queries.changed(link)
print link.make_permalink_slow()
def POST_create(self, res, title, description, location, latitude, longitude, timestamp, tzoffset, ip):
if res._chk_error(errors.NO_TITLE):
res._chk_error(errors.TITLE_TOO_LONG)
res._focus('title')
res._chk_errors((errors.NO_LOCATION,
errors.NO_DESCRIPTION,
errors.INVALID_DATE,
errors.NO_DATE))
if res.error: return
meetup = Meetup(
author_id = c.user._id,
title = title,
description = description,
location = location,
latitude = latitude,
longitude = longitude,
timestamp = timestamp,
tzoffset = tzoffset
)
# Expire all meetups in the render cache
g.rendercache.invalidate_key_group(Meetup.group_cache_key())
meetup._commit()
l = Link._submit(meetup_article_title(meetup), meetup_article_text(meetup),
c.user, Subreddit._by_name('discussion'),ip, [])
l.meetup = meetup._id36
l._commit()
meetup.assoc_link = l._id
meetup._commit()
#update the queries
if g.write_query_queue:
queries.new_link(l)
res._redirect(url_for(action='show', id=meetup._id36))
def process_post(self, post_data, sr):
# Prepare data for import
title = self.kill_tags_re.sub('', post_data['title'])
article = u'%s%s' % (post_data['description'],
Link._more_marker + post_data['mt_text_more'] if post_data['mt_text_more'] else u'')
ip = '127.0.0.1'
tags = [self.transform_categories_re.sub('_', tag.lower()) for tag in post_data.get('category', [])]
naive_date = datetime.datetime.strptime(post_data['dateCreated'], DATE_FORMAT)
local_date = INPUT_TIMEZONE.localize(naive_date, is_dst=False) # Pick the non daylight savings time
utc_date = local_date.astimezone(pytz.utc)
# Determine account to use for this post
account = self._get_or_create_account(post_data['author'], post_data['authorEmail'])
# Look for an existing post created due to a previous import
post = self._query_post(Link.c.ob_permalink == post_data['permalink'])
if not post:
# Create new post
post = Link._submit(title, article, account, sr, ip, tags, date=utc_date)
post.blessed = True
post.comment_sort_order = 'old'
post.ob_permalink = post_data['permalink']
post._commit()
else:
# Update existing post
post.title = title
post.article = article
post.author_id = account._id
post.sr_id = sr._id
post.ip = ip
post.set_tags(tags)
post._date = utc_date
post.blessed = True
post.comment_sort_order = 'old'
post._commit()
# Process each comment for this post
comment_dictionary = {}
comments = self._query_comments(Comment.c.link_id == post._id, Comment.c.ob_imported == True)
[self.process_comment(comment_data, comment, post, comment_dictionary)
for comment_data, comment in map(None, post_data.get('comments', []), comments)]
def test_get_files(self):
from r2.lib.db import queries
from r2.models import Subreddit, Account, Link, Thing
account = Account._byID(1, data=True)
sr = Subreddit._by_name("reddit_test0")
link_url = self.make_unique_url()
new_link = Link._submit("test_get_files", link_url, account, sr, "127.0.0.1", kind="file")
queries.new_link(new_link, foreground=True)
# make sure it returns like a normal link
res = Thing._by_fullname(queries.get_links(sr, "new", "all"), return_dict=False)
self.assert_true(len(res) > 0, "no links returned")
self.assert_equal(new_link._id, res[0]._id)
# should return with a kind = 'file' filter
res = list(queries.get_files(sr))
self.assert_true(len(res) > 0, "no links returned")
self.assert_equal(new_link._id, res[0]._id)
def submit_link(user, subreddit, title, url, thumb_url):
account = Account._by_name(user)
subreddit = Subreddit._by_name(subreddit)
ip = '127.0.0.1'
# submit the link
link = Link._submit(title, url, account, subreddit, ip, spam=False)
# force the thumbnail before scraper_q gets in the mix
image_data = urllib.urlopen(thumb_url).read()
force_thumbnail(link, image_data)
# various backend processing things
queries.queue_vote(account, link, UPVOTE, ip)
queries.new_link(link)
link.update_search_index()
# wait for the amqp worker to finish up
worker.join()
print link.make_permalink_slow()
def submit_link(user, subreddit, title, url, thumb_url):
account = Account._by_name(user)
subreddit = Subreddit._by_name(subreddit)
ip = '127.0.0.1'
# submit the link
link = Link._submit(title, url, account, subreddit, ip, spam=False)
# force the thumbnail before scraper_q gets in the mix
image_data = urllib.urlopen(thumb_url).read()
force_thumbnail(link, image_data)
# various backend processing things
queries.queue_vote(account, link, UPVOTE, ip)
queries.new_link(link)
link.update_search_index()
# wait for the amqp worker to finish up
worker.join()
print link.make_permalink_slow()
def POST_create(self, res, title, description, location, latitude,
longitude, timestamp, tzoffset, ip):
if res._chk_error(errors.NO_TITLE):
res._chk_error(errors.TITLE_TOO_LONG)
res._focus('title')
res._chk_errors((errors.NO_LOCATION, errors.NO_DESCRIPTION,
errors.INVALID_DATE, errors.NO_DATE))
if res.error: return
meetup = Meetup(
author_id=c.user._id,
title=title,
description=description,
location=location,
latitude=latitude,
longitude=longitude,
timestamp=timestamp / 1000, # Value from form is in ms UTC
tzoffset=tzoffset)
# Expire all meetups in the render cache
g.rendercache.invalidate_key_group(Meetup.group_cache_key())
meetup._commit()
l = Link._submit(meetup_article_title(meetup),
meetup_article_text(meetup), c.user,
Subreddit._by_name('discussion'), ip, [])
l.meetup = meetup._id36
l._commit()
meetup.assoc_link = l._id
meetup._commit()
#update the queries
if g.write_query_queue:
queries.new_link(l)
res._redirect(url_for(action='show', id=meetup._id36))
def dfp_creative_to_link(creative, link=None):
from r2.models import (
Link,
PROMOTE_STATUS,
)
user = get_dfp_user()
sr = get_dfp_subreddit()
attributes = dfp_template_to_dict(creative.creativeTemplateVariableValues)
kind = "self" if attributes["selftext"] else "link"
url = attributes["url"] if kind == "link" else "self"
if not link:
link = Link._submit(
attributes["title"],
url,
user,
sr,
ip="127.0.0.1",
sendreplies=False,
)
if kind == "self":
link.url = link.make_permalink_slow()
link.is_self = True
link.selftext = attributes["selftext"]
link.promoted = True
link.promote_status = PROMOTE_STATUS.promoted
link.thumbnail_url = attributes["thumbnail_url"]
link.mobile_ad_url = attributes["mobile_ad_url"]
link.third_party_tracking = attributes["third_party_tracking"]
link.third_party_tracking_2 = attributes["third_party_tracking_2"]
link.dfp_creative_id = creative["id"]
link._commit()
return link
def inject_test_data(num_links=25, num_comments=25, num_votes=5):
"""Flood your reddit install with test data based on reddit.com."""
print ">>>> Ensuring configured objects exist"
system_user = ensure_account(g.system_user)
ensure_account(g.automoderator_account)
ensure_subreddit(g.default_sr, system_user)
ensure_subreddit(g.takedown_sr, system_user)
ensure_subreddit(g.beta_sr, system_user)
ensure_subreddit(g.promo_sr_name, system_user)
print
print
print ">>>> Fetching real data from reddit.com"
modeler = Modeler()
subreddits = [
modeler.model_subreddit("pics"),
modeler.model_subreddit("worldnews"),
modeler.model_subreddit("gaming"),
]
extra_settings = {
"worldnews": {
"show_media": True,
},
"pics": {
"show_media": True,
},
}
print
print
print ">>>> Generating test data"
print ">>> Accounts"
account_query = Account._query(sort="_date", limit=500, data=True)
accounts = [a for a in account_query if a.name != g.system_user]
accounts.extend(
ensure_account(modeler.generate_username())
for i in xrange(50 - len(accounts)))
print ">>> Content"
things = []
for sr_model in subreddits:
sr_author = random.choice(accounts)
sr = ensure_subreddit(sr_model.name, sr_author)
# make the system user subscribed for easier testing
if sr.add_subscriber(system_user):
sr._incr("_ups", 1)
# apply any custom config we need for this sr
for setting, value in extra_settings.get(sr.name, {}).iteritems():
setattr(sr, setting, value)
sr._commit()
for i in xrange(num_links):
link_author = random.choice(accounts)
url = sr_model.generate_link_url()
is_self = (url == "self")
content = sr_model.generate_selfpost_body() if is_self else url
link = Link._submit(
is_self=is_self,
title=sr_model.generate_link_title(),
content=content,
author=link_author,
sr=sr,
ip="127.0.0.1",
)
queries.new_link(link)
things.append(link)
comments = [None]
for i in xrange(fuzz_number(num_comments)):
comment_author = random.choice(accounts)
comment, inbox_rel = Comment._new(
comment_author,
link,
parent=random.choice(comments),
body=sr_model.generate_comment_body(),
ip="127.0.0.1",
)
queries.new_comment(comment, inbox_rel)
comments.append(comment)
things.append(comment)
for thing in things:
for i in xrange(fuzz_number(num_votes)):
direction = random.choice([
Vote.DIRECTIONS.up,
Vote.DIRECTIONS.unvote,
Vote.DIRECTIONS.down,
])
voter = random.choice(accounts)
cast_vote(voter, thing, direction)
amqp.worker.join()
srs = [Subreddit._by_name(n) for n in ("worldnews", "pics")]
LocalizedDefaultSubreddits.set_global_srs(srs)
LocalizedFeaturedSubreddits.set_global_srs(
[Subreddit._by_name('worldnews')])
def inject_test_data(num_links=25, num_comments=25, num_votes=5):
"""Flood your reddit install with test data based on reddit.com."""
print ">>>> Ensuring configured objects exist"
system_user = ensure_account(g.system_user)
ensure_account(g.automoderator_account)
ensure_subreddit(g.default_sr, system_user)
ensure_subreddit(g.takedown_sr, system_user)
print
print
print ">>>> Fetching real data from reddit.com"
modeler = Modeler()
subreddits = [
modeler.model_subreddit("pics"),
modeler.model_subreddit("videos"),
modeler.model_subreddit("askhistorians"),
]
extra_settings = {
"pics": {
"show_media": True,
},
"videos": {
"show_media": True,
},
}
print
print
print ">>>> Generating test data"
print ">>> Accounts"
account_query = Account._query(sort="_date", limit=500, data=True)
accounts = [a for a in account_query if a.name != g.system_user]
accounts.extend(
ensure_account(modeler.generate_username())
for i in xrange(50 - len(accounts)))
print ">>> Content"
things = []
for sr_model in subreddits:
sr_author = random.choice(accounts)
sr = ensure_subreddit(sr_model.name, sr_author)
# make the system user subscribed for easier testing
if sr.add_subscriber(system_user):
sr._incr("_ups", 1)
# apply any custom config we need for this sr
for setting, value in extra_settings.get(sr.name, {}).iteritems():
setattr(sr, setting, value)
sr._commit()
for i in xrange(num_links):
link_author = random.choice(accounts)
link = Link._submit(
title=sr_model.generate_link_title(),
url=sr_model.generate_link_url(),
author=link_author,
sr=sr,
ip="127.0.0.1",
)
if link.url == "self":
link.url = link.make_permalink(sr)
link.is_self = True
link.selftext = sr_model.generate_selfpost_body()
link._commit()
queries.queue_vote(link_author, link, dir=True, ip="127.0.0.1")
queries.new_link(link)
things.append(link)
comments = [None]
for i in xrange(fuzz_number(num_comments)):
comment_author = random.choice(accounts)
comment, inbox_rel = Comment._new(
comment_author,
link,
parent=random.choice(comments),
body=sr_model.generate_comment_body(),
ip="127.0.0.1",
)
queries.queue_vote(comment_author,
comment,
dir=True,
ip="127.0.0.1")
queries.new_comment(comment, inbox_rel)
comments.append(comment)
things.append(comment)
for thing in things:
for i in xrange(fuzz_number(num_votes)):
direction = random.choice([True, None, False])
voter = random.choice(accounts)
queries.queue_vote(voter, thing, dir=direction, ip="127.0.0.1")
amqp.worker.join()
def create_about_post():
user = Account._by_name('Eliezer_Yudkowsky')
sr = Subreddit._by_name('admin')
link = Link._submit('About LessWrong', 'TBC', user, sr, '::1', [])
def inject_test_data(num_links=25, num_comments=25, num_votes=5):
"""Flood your reddit install with test data based on reddit.com."""
print ">>>> Ensuring configured objects exist"
system_user = ensure_account(g.system_user)
ensure_account(g.automoderator_account)
ensure_subreddit(g.default_sr, system_user)
ensure_subreddit(g.takedown_sr, system_user)
ensure_subreddit(g.beta_sr, system_user)
ensure_subreddit(g.promo_sr_name, system_user)
print
print
print ">>>> Fetching real data from reddit.com"
modeler = Modeler()
subreddits = [
modeler.model_subreddit("pics"),
modeler.model_subreddit("videos"),
modeler.model_subreddit("askhistorians"),
]
extra_settings = {
"pics": {
"show_media": True,
},
"videos": {
"show_media": True,
},
}
print
print
print ">>>> Generating test data"
print ">>> Accounts"
account_query = Account._query(sort="_date", limit=500, data=True)
accounts = [a for a in account_query if a.name != g.system_user]
accounts.extend(
ensure_account(modeler.generate_username())
for i in xrange(50 - len(accounts)))
print ">>> Content"
things = []
for sr_model in subreddits:
sr_author = random.choice(accounts)
sr = ensure_subreddit(sr_model.name, sr_author)
# make the system user subscribed for easier testing
if sr.add_subscriber(system_user):
sr._incr("_ups", 1)
# apply any custom config we need for this sr
for setting, value in extra_settings.get(sr.name, {}).iteritems():
setattr(sr, setting, value)
sr._commit()
for i in xrange(num_links):
link_author = random.choice(accounts)
url = sr_model.generate_link_url()
is_self = (url == "self")
content = sr_model.generate_selfpost_body() if is_self else url
link = Link._submit(
is_self=is_self,
title=sr_model.generate_link_title(),
content=content,
author=link_author,
sr=sr,
ip="127.0.0.1",
)
queries.new_link(link)
things.append(link)
comments = [None]
for i in xrange(fuzz_number(num_comments)):
comment_author = random.choice(accounts)
comment, inbox_rel = Comment._new(
comment_author,
link,
parent=random.choice(comments),
body=sr_model.generate_comment_body(),
ip="127.0.0.1",
)
queries.new_comment(comment, inbox_rel)
comments.append(comment)
things.append(comment)
for thing in things:
for i in xrange(fuzz_number(num_votes)):
direction = random.choice([
Vote.DIRECTIONS.up,
Vote.DIRECTIONS.unvote,
Vote.DIRECTIONS.down,
])
voter = random.choice(accounts)
cast_vote(voter, thing, direction)
amqp.worker.join()
srs = [Subreddit._by_name(n) for n in ("pics", "videos", "askhistorians")]
LocalizedDefaultSubreddits.set_global_srs(srs)
def create_about_post():
user = Account._by_name('Eliezer_Yudkowsky')
sr = Subreddit._by_name('admin')
link = Link._submit('About LessWrong', 'TBC', user, sr, '::1', [])
