async def schedule_new_post(story: Story) -> None:
img_links = json.loads(story.img_links)
keyboard = get_story_keyboard(story)
if len(img_links) == 1:
response = await bot.send_photo(ADMIN_CHANNEL,
photo=img_links[0],
caption=story.title,
reply_markup=keyboard)
elif len(img_links) > 1:
media = await prepare_media(img_links)
# text may be added to the message only by
# adding it to the first item in MediaGroup
media[0].caption = story.title
response = await bot.send_media_group(ADMIN_CHANNEL, media)
response = await bot.send_message(
ADMIN_CHANNEL,
story.title,
reply_to_message_id=response[0].message_id,
reply_markup=keyboard)
else:
response = await bot.send_message(ADMIN_CHANNEL,
story.title,
reply_markup=keyboard,
parse_mode='Markdown')
story.admin_message_id = response['message_id']
story.save()
def story(id):
st = Story.query.filter_by(id=id).first_or_404()
temp_st = Story()
temp_st.title = str(st.title)
temp_st.slug = str(st.slug)
print st.title
print "is the title before POST"
form = StoryForm(obj=st)
form.populate_obj(st)
if request.method == "POST":
print temp_st.title
print "is temp_st.title"
st.text = form.text.data
st.title = temp_st.title
st.slug = temp_st.slug
print st.title
print "is the title after POST"
if request.form.get('submit_button')== "Save":
flash("Story saved.", 'success')
if request.form.get('submit_button')== "Translate":
flash("Story Ready To Translate.", 'success')
st.ready_to_translate = True
db.session.add(st)
db.session.commit()
return render_template("stories/story.html", story=st, form=form)
def post(self, id):
import os, static, hashlib
from models import StoryAuthor, Story, StoryDocument
from django.template.defaultfilters import slugify
from google.appengine.runtime.apiproxy_errors import RequestTooLargeError
content = self.request.get('content')
title = self.request.get('title')
story = Story.get_by_id(int(id, 10))
story.content = content
story.title = title
story.put()
try:
request_document = self.request.get('document')
document_file = self.request.POST['document']
if request_document:
document_body = document_file.value
document_digest = hashlib.sha1(document_body).hexdigest()
split_name = os.path.splitext(os.path.basename(document_file.filename))
filename = slugify(split_name[0]) or document_digest
document_name = filename + split_name[1]
document_path = '/story/%d/document/%s/%s' % (story.key().id(), document_digest, document_name)
logging.info(document_path)
story_document = StoryDocument(story=story, path=document_path, name=document_name)
story_document.put()
document = static.set(document_path, document_body, document_file.type)
self.get(id)
except RequestTooLargeError, message:
self.render_to_response("story_edit.html",
story=Story.get_by_id(int(id, 10)),
request_too_large_error=True)
def new_story(payload):
data = request.get_json()
if data is None:
return abort(400)
authors = Author.query.all()
for author in authors:
#Checks if the logged-in user is the one posting
if payload['sub'].split("auth0|")[1] == author.user_id:
if 'title' in data and 'type' in data and 'category' in data and 'content' in data:
story = Story(title=data['title'],
type=data['type'],
category=data['category'],
content=data['content'],
author=author.id)
story.insert()
temp_res = story.format()
res = {
'success':
True,
'code':
200,
'message':
'Story {} written by {} {} was successfully added'.
format(story.title, author.fname, author.lname)
}
return jsonify(res)
msg = 'Some information is missing or a wrong formed request.'
return abort(400, msg)
return abort(401)
def post(self):
step_template = jinjaEnv.get_template("newStep.html")
self.response.write(step_template.render())
tStory = Story(title=self.request.get("adventure_name"))
print("THE TITLE OF THE STORY IS" + tStory.title)
tStory.put()
def api_create_game(request,*,process,stagename,story,chose,refstoryid,author):
check_admin(request)
#若无 stagename 则不创建stage
tagid=next_id()
if not story or not story.strip():
raise APIValueError("story",'story cannot be empty.')
if not process or not process.strip():
raise APIValueError('process','process cannot be empty.')
if not chose or not chose.strip():
raise APIValueError('chose','chose cannot be empty.')
if not refstoryid or not refstoryid.strip():
raise APIValueError('refstoryid','refstoryid cannot be empty.')
story = Story(tagid = tagid,process=process.strip(),story=story.strip(),author=author.strip())
storyid =yield from Story.findbycolumnname("tagid",'00151272809336730536a55a20d4b01b4853c53a08639f2000')
# print(storyid.id)
yield from story.save()
l_chose = chose.split("#")
l_refstoryid = refstoryid.split("#")
for c in l_chose:
i=0
tagid = next_id()
choose = Chose(tagid=tagid,storyid=storyid.id,choose = c)
yield from choose.save()
chooseid= yield from Chose.findbycolumnname("tagid",tagid)
refstory = refStory(tagid = next_id(),chooseid=chooseid.id,refstoryid=l_refstoryid[i])
i=i+1
yield from refstory.save()
return story
def randomstory():
while True:
num = Story.count()
id = random.choice([i for i in range(1,num+1)])
story = Story.find(id)
if story.islook is 1:
continue
content = story.content
content.replace('<br>', '\n')
soup = BeautifulSoup(content, 'lxml')
story.islook = 1;
story.update()
return story.get('question')+'?\n'+soup.get_text()
def add(request):
url = request.POST['url']
parsed = urlparse(url)
if parsed.scheme =='':
url = 'http://' + url
domain = urlparse(url)[1]
soup = BeautifulSoup.BeautifulSoup(urllib.urlopen(url))
title = soup.title.string
s = Story(link=url, domain=domain, title=title, user=request.user)
s.save()
return redirect('/list.html')
async def schedule_trigger():
while True:
now = datetime.now()
now = now.replace(second=0, microsecond=0)
for story in Story.select().where(Story.scheduled_datetime == now,
Story.prod_message_id == None):
img_links = json.loads(story.img_links)
if len(img_links) == 1:
response = await bot.send_photo(MEMOTRON_CHANNEL,
photo=img_links[0],
caption=story.title)
elif len(img_links) > 1:
medias = [InputMediaPhoto(url) for url in img_links]
if len(medias) > 10: # TG limit
return
response = await bot.send_media_group(MEMOTRON_CHANNEL, medias)
response = response[0]
else:
response = await bot.send_message(MEMOTRON_CHANNEL,
text=story.text)
logger.info(response)
story.prod_message_id = response['message_id']
story.save()
await sleep(1)
await sleep(1)
def createStory():
story_name = request.form['story_name']
rowcount = request.form['rowcount']
story_obj = Story(name=story_name)
db.session.add(story_obj)
db.session.commit()
story_obj_id = Story.query.filter_by(name=story_name).first().id
for i in range(int(rowcount)):
foo = request.form['row' + str(i)]
if (foo.split()[0] == 'intent'):
foobar = StoryStep(isIntent=1,
story_id=story_obj_id,
int_or_temp_id=int(foo.split()[1]))
db.session.add(foobar)
db.session.commit()
elif (foo.split()[0] == 'template'):
foobar = StoryStep(isIntent=2,
story_id=story_obj_id,
int_or_temp_id=int(foo.split()[1]))
db.session.add(foobar)
db.session.commit()
else:
foobar = StoryStep(isIntent=3,
story_id=story_obj_id,
int_or_temp_id=int(foo.split()[1]))
db.session.add(foobar)
db.session.commit()
return render_template("success.html", message="Story created")
def test_flags(self) -> None:
"""Tests Story flag getters & setters."""
story = Story.new(self.testuser, "test")
story.flags = 0
self.assertFalse(story.private)
self.assertFalse(story.can_comment)
self.assertFalse(story.is_risque)
story.private = True
self.assertTrue(story.private)
self.assertEqual(story.flags, Story.Flags.PRIVATE)
story.can_comment = True
self.assertTrue(story.can_comment)
self.assertEqual(story.flags,
Story.Flags.PRIVATE | Story.Flags.CAN_COMMENT)
story.can_comment = False
story.is_risque = True
self.assertFalse(story.can_comment)
self.assertTrue(story.is_risque)
self.assertEqual(story.flags,
Story.Flags.PRIVATE | Story.Flags.IS_RISQUE)
def get(self):
allStories = Story.query().fetch()
print("***********************************")
print(allStories[0].key.id())
all_dict = {"theStories": allStories}
all_stories_template = jinjaEnv.get_template("browse.html")
self.response.write(all_stories_template.render(all_dict))
def test_visibility(self) -> None:
"""Tests story visibility based on privacy & NSFW flags."""
story = Story.new(self.testuser, "test")
# private stories are visible only to the author
self.assertTrue(story.visible(self.testuser))
self.assertFalse(story.visible(self.testuser2))
self.assertFalse(story.visible(self.testuser3))
self.assertFalse(story.visible())
# public stories are visible to all
story.private = False
self.assertTrue(story.visible(self.testuser))
self.assertTrue(story.visible(self.testuser2))
self.assertTrue(story.visible(self.testuser3))
self.assertTrue(story.visible())
# risque stories are visible only to those who allow themselves to view them
story.is_risque = True
self.assertTrue(story.visible(self.testuser))
self.assertFalse(story.visible(self.testuser2))
self.assertTrue(story.visible(self.testuser3))
self.assertFalse(story.visible())
# user should not have access to stories which are risque, even if they created them
self.testuser.allow_risque = False
self.assertFalse(story.visible(self.testuser))
self.assertFalse(story.visible(self.testuser2))
self.assertTrue(story.visible(self.testuser3))
self.assertFalse(story.visible())
def story(self, story_id, is_author=False):
story = Story.get_by_id(int(story_id))
if not story:
self.abort(404)
if is_author and story.author != self.user:
self.abort(401)
return story
def _update_story_name(self, event):
story = Story.get_by_story_id(event.story_id)
if story:
logging.info("Updating story name to: " + event.story_title)
story.name = event.story_title
story.put()
else:
logging.info("Cannot update story name (" + event.story_id + "): story does not exist")
def create_story(payload):
data = request.get_json()
# DONE: get user e-mail from JWT token & allow only owner to edit post
# https://stackoverflow.com/questions/3368969/find-string-between-two-substrings
get_email = json.dumps(payload['https://tellatale.com/email'])
email = (get_email.split('"')[1].split('"')[0])
user_exists = User.query.filter_by(email=email).first()
if not user_exists:
temp_name = (email.split("@")[0])
new_user = User(email=email, name=temp_name)
new_user.insert()
author_id = new_user.id
else:
author_id = user_exists.id
title = data.get('title')
cover_image = data.get('cover_image')
genre = data.get('genre')
content = data.get('content')
release_date = data.get('release_date')
release_status = data.get('released')
read_time = data.get('read_time')
if (not title or not content or not genre or not release_date
or not release_status):
abort(422)
try:
new_story = Story(title=title,
cover_image=cover_image,
genre=genre,
content=content,
release_date=release_date,
release_status=release_status,
read_time=read_time,
author_id=author_id)
new_story.insert()
return jsonify({
'success': True,
'message': 'Your story has been Created'
}), 201
except Exception:
print(sys.exc_info())
abort(422)
def get(self, story_id, line_id):
story = Story.get_by_story_id(story_id)
story_line = StoryLine.get_by_id(int(line_id), parent=story)
story_line.is_deleted = True
story_line.deleted_by_user = users.get_current_user()
story_line.put()
self.redirect('/s/' + story_id)
def scrape_spreadsheet(self, filename):
stories = []
spreadsheet = copytext.Copy(filename)
data = spreadsheet['Form Responses 1']
for row in data:
story = Story(row)
stories.append(story)
return stories
def create():
""" Populates new stories from HN """
hn = HackerNewsParser()
posts = hn.get_hacker_json()
data = [{key: item[key]
for key in ['title', 'url', 'time']} for item in posts]
try:
for story in data:
model = Story(title=story['title'],
url=story['url'],
created_at=story['time'])
model.save()
except Exception as e:
abort(500, str(e))
return
def edit_story(story_id):
if request.method == 'GET':
story = Story.get(Story.id == story_id)
return render_template('form.html',
us_story=story,
header="Edit Story",
button="Update")
else:
edit_story = Story.update(
story_title=request.form['story_title'],
user_story=request.form['user_story'],
acceptance_criteria=request.form['acceptance_criteria'],
business_value=request.form['business_value'],
estimation=request.form['estimation'],
status=request.form['status']).where(Story.id == story_id)
edit_story.execute()
return redirect(url_for('show_stories'))
def decorate(self, entity_id=None):
entity = None
if entity_id:
entity = Story.get_by_id(int(entity_id))
if not entity:
self.error(404)
return
fun(self, entity)
def test_new(self) -> None:
"""Tests the Story.new class method."""
# title must be a string with at least one non-whitespace character
self.assertRaises(ValueError, Story.new, self.testuser, None)
self.assertRaises(ValueError, Story.new, self.testuser, 123)
self.assertRaises(ValueError, Story.new, self.testuser, True)
self.assertRaises(ValueError, Story.new, self.testuser, -1.5)
self.assertRaises(ValueError, Story.new, self.testuser, "")
self.assertRaises(ValueError, Story.new, self.testuser, " ")
# summary must be a string
self.assertRaises(ValueError, Story.new, self.testuser, "test", 321)
self.assertRaises(ValueError, Story.new, self.testuser, "test", False)
self.assertRaises(ValueError, Story.new, self.testuser, "test", 3.2)
story1 = Story.new(self.testuser, "test")
self.assertEqual(story1.author, self.testuser)
self.assertEqual(story1.flags, Story.Flags.DEFAULT)
self.assertEqual(story1.title, "test")
self.assertEqual(story1.summary, "")
self.assertEqual(story1.thumbnail.url, Story.DEFAULT_THUMBNAIL_URI)
self.assertIn(story1, self.testuser.stories)
self.assertEqual(len(self.testuser.stories), 1)
self.assertEqual(len(story1.tags), 0)
self.assertEqual(len(story1.favorited_by), 0)
self.assertEqual(len(story1.followed_by), 0)
self.assertEqual(len(story1.reports), 0)
self.assertEqual(story1.posted, story1.modified)
story2summary = "This is a test from Speakonia."
story2 = Story.new(self.testuser, " test 2 ", story2summary)
self.assertEqual(story2.author, self.testuser)
self.assertEqual(story2.flags, Story.Flags.DEFAULT)
self.assertEqual(story2.title, "test 2")
self.assertEqual(story2.summary, story2summary)
self.assertEqual(story2.thumbnail.url, Story.DEFAULT_THUMBNAIL_URI)
self.assertIn(story1, self.testuser.stories)
self.assertIn(story2, self.testuser.stories)
self.assertEqual(len(self.testuser.stories), 2)
self.assertEqual(len(story2.tags), 0)
self.assertEqual(len(story2.favorited_by), 0)
self.assertEqual(len(story2.followed_by), 0)
self.assertEqual(len(story2.reports), 0)
self.assertEqual(story2.posted, story2.modified)
def add_story():
new_story = Story.create(
story_title=request.form['story_title'],
user_story=request.form['user_story'],
acceptance_criteria=request.form['acceptance_criteria'],
business_value=request.form['business_value'],
estimation=request.form['estimation'],
status=request.form['status'])
return redirect(url_for('show_stories'))
def add_story():
new_story = Story.create(story_title=request.form['story_title'],
user_story=request.form['user_story'],
criteria=request.form['criteria'],
business_value=request.form['business_value'],
estimation=request.form['estimation'],
status=request.form['status'])
new_story.save()
return redirect(url_for('display_stories'))
def get(self, id):
user = users.get_current_user()
if not user:
self.redirect(users.create_login_url(self.request.uri))
return
logging.warn("Logged in as %s (%s)", user.nickname(), user.user_id())
self.render_to_response("story_edit.html",
story=Story.get_by_id(int(id, 10)),
request_too_large_error=False)
def _extract_stories(self, story_elements):
stories = []
for story_el in story_elements:
story_el = PyQuery(story_el, parser='xml')
story = Story(story_el, self.run_time)
stories.append(story)
logger.info('Scraped %s from Seamus API (%s)' % (story.story_id, story.title))
return stories
def update_story(story_id):
update = Story.update(
story_title=request.form["story_title"],
user_story=request.form["user_story"],
criteria=request.form["criteria"],
business_value=request.form["business_value"],
estimation=request.form["estimation"],
status=request.form["status"]).where(Story.id == story_id)
update.execute()
return redirect(url_for('display_stories'))
def post(self, story_id):
story = Story.get_by_story_id(story_id)
story.name = self.request.get('name')
story.java_estimate = int(self.request.get('java_estimate'))
story.cs_estimate = int(self.request.get('cs_estimate'))
story.user = users.get_current_user()
story.put()
self.redirect('/s/' + story.story_id)
def _create_new_story(self, event):
logging.info('Creating story')
story = Story(story_id=event.story_id, name=event.story_title)
story.put()
project = Project.get()
api_url = 'http://www.pivotaltracker.com/services/v3/projects/{PROJECT_ID}/stories/{STORY_ID}/notes'.replace('{PROJECT_ID}', project.project_id).replace('{STORY_ID}', story.story_id)
comment_xml = '<note><text>http://{APP_ID}.appspot.com/s/{STORY_ID}</text></note>'.replace('{APP_ID}', os.environ['APPLICATION_ID']).replace('{STORY_ID}', story.story_id)
logging.info('Api url: ' + api_url)
logging.info('Comment xml: ' + comment_xml)
#post a comment back to pivotal tracker
result = urlfetch.fetch(url=api_url,
payload=comment_xml,
method=urlfetch.POST,
headers={'Content-Type': 'application/xml', 'X-TrackerToken': project.api_token})
logging.info('Result of API call: ' + result.content)
def setUp(self) -> None:
super().setUp()
for img in RefImage.query.filter(~RefImage.id.in_({1, 2})).all():
db.session.delete(img)
StoryTag.query.delete()
Tag.query.delete()
Story.query.delete()
User.query.delete()
users = [User(**data) for data in USERDATA]
db.session.add_all(users)
tags = (Tag.new("category", "fanfiction", commit=False),
Tag.new("category", "original", commit=False),
Tag.new("category", "crossover",
commit=False), Tag.new("genre", "action",
commit=False),
Tag.new("genre", "adventure",
commit=False), Tag.new("genre",
"romance",
commit=False),
Tag.new("genre", "suspense", commit=False),
Tag.new("genre", "thriller", commit=False),
Tag.new("generic", "abcdef", commit=False))
db.session.add_all(tags)
db.session.commit()
self.tags = [(tag.url_safe_query_name, tag.name, tag.type)
for tag in tags]
self.user_ids = [id for id in map(lambda user: user.id, users)]
stories = [
Story(**STORYDATA[i], author_id=self.user_ids[i])
for i in range(len(STORYDATA))
]
db.session.add_all(stories)
db.session.commit()
self.story_ids = [id for id in map(lambda story: story.id, stories)]
stories[0].tags.append(tags[0])
stories[0].tags.append(tags[4])
stories[1].tags.append(tags[1])
stories[1].tags.append(tags[6])
stories[2].tags.append(tags[2])
stories[2].tags.append(tags[4])
stories[2].tags.append(tags[7])
stories[2].tags.append(tags[8])
db.session.commit()
self.client = app.test_client()
def addStory():
new_story_data = json.loads(request.data)
new_story = Story(title=new_story_data['title'],
synopsis=new_story_data['synopsis'])
# Try to add the new story
try:
insert(new_story)
except:
abort(500)
return jsonify({'success': True})
async def watch_new_stories() -> None:
while True:
unpublished_stories = Story.select().where(
Story.admin_message_id.is_null(), Story.text == "")
for story in unpublished_stories:
try:
await schedule_new_post(story)
except Exception as e:
logger.exception(e)
await sleep(1)
await sleep(1)
def create_new_story(request):
if request.method == "POST":
# They attempted to create a story
story_form = forms.NewStoryForm(request.POST)
frag_form = forms.AddFragmentForm(request.POST)
if story_form.is_valid() and frag_form.is_valid():
# Store the new story and the fragment
story = Story(
name = story_form.cleaned_data['story_name'],
last_update_date = datetime.datetime.now()
)
# Give 'er a slug!
story.slug = slugify(story.name, instance=story)
story.save()
story.add_fragment(frag_form.cleaned_data['fragment_text'], request.user)
return HttpResponseRedirect(reverse('story_detail', kwargs={'slug':story.slug}))
else:
# Return a blank form page
story_form = forms.NewStoryForm()
frag_form = forms.AddFragmentForm()
return render_to_response("stories/add_new_story.html",
RequestContext(request, {
'story_form':story_form,
'frag_form':frag_form,
})
)
def get_schedule_button_text(story: Story) -> str:
"""If story is not scheduled we offer the nearest available time,
in other way we display scheduled time"""
if story.scheduled_datetime:
story_time = story.scheduled_datetime
scheduled_flag = '✅'
else:
story_time = Story.get_available_time()
scheduled_flag = ''
schedule_button_text = f'🗓 {story_time.strftime("%H:%M")} {scheduled_flag}'
return schedule_button_text
def test_visible_stories(self):
"""Tests the User.visible_stories method."""
bday = date.today() + relativedelta(years=-20, months=-3, days=-11)
user1 = User.register("testuser", "abcdefg", "*****@*****.**", bday)
user2 = User.register("testuser2", "abcdefg", "*****@*****.**", bday)
user2.allow_risque = True
story1 = Story.new(user2, "Test")
story1.is_risque = True
story1.private = False
story2 = Story.new(user2, "Test")
story2.private = False
story3 = Story.new(user2, "Test")
stories = user2.visible_stories().all()
self.assertNotIn(story1, stories)
self.assertIn(story2, stories)
self.assertNotIn(story3, stories)
stories = user2.visible_stories(user1).all()
self.assertNotIn(story1, stories)
self.assertIn(story2, stories)
self.assertNotIn(story3, stories)
stories = user2.visible_stories(user2).all()
self.assertIn(story1, stories)
self.assertIn(story2, stories)
self.assertNotIn(story3, stories)
stories = user1.visible_stories()
self.assertNotIn(story1, stories)
self.assertNotIn(story2, stories)
self.assertNotIn(story3, stories)
async def update_keyboards() -> None:
"""Updates message keyboards in admin channel"""
while True:
for story in Story.select().\
where(Story.scheduled_datetime.is_null()).\
order_by(Story.post_datetime.desc()):
keyboard = get_story_keyboard(story)
try:
await bot.edit_message_reply_markup(
ADMIN_CHANNEL,
message_id=story.admin_message_id,
reply_markup=keyboard)
except (MessageToEditNotFound, MessageNotModified) as e:
logger.debug(e)
await sleep(3)
def update_story():
id = request.form['id']
storytitle = request.form['storytitle']
userstory = request.form['userstory']
criteria = request.form['criteria']
businessvalue = request.form['businessvalue']
estimation = request.form['estimation']
status = request.form['status']
user_story = Story.update(storytitle=storytitle,
userstory=userstory,
criteria=criteria,
businessvalue=businessvalue,
estimation=estimation,
status=status).where(Story.id == id)
user_story.execute()
return redirect(url_for('list'))
def test_favorites(self) -> None:
"""Tests favoriting & following stories."""
story = Story.new(self.testuser, "test")
story.favorited_by.append(self.testuser2)
self.assertEqual(len(story.favorited_by), 1)
self.assertEqual(len(story.favorited_by), story.favorites)
self.assertIn(story, self.testuser2.favorite_stories)
self.assertEqual(len(self.testuser2.favorite_stories), 1)
story.followed_by.append(self.testuser3)
self.assertEqual(len(story.followed_by), 1)
self.assertEqual(len(story.followed_by), story.follows)
self.assertIn(story, self.testuser3.followed_stories)
self.assertEqual(len(self.testuser3.followed_stories), 1)
def add_stories():
storytitle = request.form['storytitle']
userstory = request.form['userstory']
criteria = request.form['criteria']
businessvalue = request.form['businessvalue']
estimation = request.form['estimation']
status = request.form['status']
new_stories = Story.create(storytitle=storytitle,
userstory=userstory,
criteria=criteria,
businessvalue=businessvalue,
estimation=estimation,
status=status)
new_stories.save()
flash('New entry was successfully posted')
return redirect(url_for('list'))
def post(self):
import os, static, hashlib
from models import StoryAuthor, Story, StoryDocument
from django.template.defaultfilters import slugify
from google.appengine.runtime.apiproxy_errors import RequestTooLargeError
title = self.request.get('title')
content = self.request.get('content')
full_name = self.request.get('full_name')
mobile_number = self.request.get('mobile_number')
email = self.request.get('email')
author = StoryAuthor(full_name=full_name, email=email, mobile_number=mobile_number)
author.put()
story = Story(title=title)
if content:
story.content = content
story.author = author
story.put()
try:
request_document = self.request.get('document')
if request_document:
document_file = self.request.POST['document']
document_body = document_file.value
document_digest = hashlib.sha1(document_body).hexdigest()
split_name = os.path.splitext(os.path.basename(document_file.filename))
filename = slugify(split_name[0]) or document_digest
document_name = filename + split_name[1]
document_path = '/story/%d/document/%s/%s' % (story.key().id(), document_digest, document_name)
logging.info(document_path)
story_document = StoryDocument(story=story, path=document_path, name=document_name)
story_document.put()
document = static.set(document_path, document_body, document_file.type, name=document_name)
self.render_to_response("thanks/story.html", document=story_document, story=story)
else:
self.render_to_response("thanks/story.html", story=story)
except RequestTooLargeError, message:
from api_preferences import facebook as fb_prefs, google_friend_connect as gfc
self.render_to_response("start.html",
FACEBOOK_API_KEY=fb_prefs.get('api_key'),
FACEBOOK_CROSS_DOMAIN_RECEIVER_URL=fb_prefs.get('cross_domain_receiver_url'),
GOOGLE_FRIEND_CONNECT_SITE_ID=gfc.get('site_id'),
request_too_large_error=True,
title=title,
content=content,
full_name=full_name,
email=email,
mobile_number=mobile_number)
def setUp(self) -> None:
super().setUp()
for img in RefImage.query.filter(~RefImage.id.in_({1, 2})).all():
db.session.delete(img)
FavoriteStory.query.delete()
FollowingStory.query.delete()
Chapter.query.delete()
Story.query.delete()
User.query.delete()
users = [User(**data) for data in USERDATA]
db.session.add_all(users)
db.session.commit()
self.user_ids = [id for id in map(lambda user: user.id, users)]
stories = [
Story(**STORYDATA[i], author_id=self.user_ids[i])
for i in range(len(STORYDATA))
]
db.session.add_all(stories)
db.session.commit()
self.story_ids = [id for id in map(lambda story: story.id, stories)]
chapters = [
Chapter(**data, story_id=self.story_ids[0])
for data in CHAPTERDATA1
]
chapters += [
Chapter(**data, story_id=self.story_ids[1])
for data in CHAPTERDATA2
]
chapters += [
Chapter(**data, story_id=self.story_ids[2])
for data in CHAPTERDATA3
]
db.session.add_all(chapters)
db.session.commit()
self.chapter_ids = [
id for id in map(lambda chapter: chapter.id, chapters)
]
self.client = app.test_client()
def download_user_story(username):
profile = instaloader.Profile.from_username(L.context, username)
for story in L.get_stories(userids=[profile.userid]):
for item in story.get_items():
folder_name = item.date_local.strftime("%Y-%m-%d")
preview_file_name = item.date_utc.strftime(
"%Y-%m-%d_%H-%M-%S_UTC.jpg")
preview_src = 'http://localhost:3000/stories/{}/{}/{}'.format(
item.owner_username, folder_name, preview_file_name)
if item.is_video:
story_type = 'video'
length = 0
file_name = item.date_utc.strftime("%Y-%m-%d_%H-%M-%S_UTC.mp4")
src = 'http://localhost:3000/stories/{}/{}/{}'.format(
item.owner_username, folder_name, file_name)
else:
story_type = 'photo'
length = 3
file_name = item.date_utc.strftime("%Y-%m-%d_%H-%M-%S_UTC.jpg")
src = 'http://localhost:3000/stories/{}/{}/{}'.format(
item.owner_username, folder_name, file_name)
try:
story = session.query(Story).filter(
Story.username == item.owner_profile.username,
Story.time == datetime.date(item.date_local)).one()
except NoResultFound:
story = Story(item.owner_profile.username,
datetime.date(item.date_local))
session.add(story)
session.commit()
story_item = StoryItem(item.owner_id,
item.owner_profile.profile_pic_url,
item.owner_profile.username, item.mediaid,
story.id, story_type, length, src,
preview_src, '', '', item.date_local, False)
session.add(story_item)
session.commit()
L.download_storyitem(
item,
Path('stories/{}/{}'.format(item.owner_username, folder_name)))
def get(self, story_id):
story = Story.get_by_story_id(story_id)
if story is None:
logging.info('creating story ' + story_id)
story = Story(story_id=story_id, user = users.get_current_user(), name=story_id)
story.put()
story_lines = story.story_lines()
java_days = story.actual_java_days()
cs_days = story.actual_cs_days()
appengineutils.render_template(self.response, 'story_history.html', {'story_lines': story_lines,
'dates': last_five_days(),
'java_days': java_days,
'cs_days': cs_days,
'story': story})
def post(self, story_id):
story = Story.get_by_story_id(story_id)
date_match = re.search(r'(\d\d\d\d)-(\d\d)-(\d\d)', self.request.get('date'))
year = int(date_match.group(1))
month = int(date_match.group(2))
day = int(date_match.group(3))
date = datetime.date(year, month, day)
java_hours = int(self.request.get('java_hours'))
cs_hours = int(self.request.get('cs_hours'))
comment = self.request.get('comment')
story_line = StoryLine(story_id=story_id,
comment=comment,
date=date,
user=users.get_current_user(),
java_hours=java_hours,
cs_hours=cs_hours,
parent=story)
story_line.put()
story.last_updated = story_line.date
story.put()
java_days = story.actual_java_days()
cs_days = story.actual_cs_days()
if story.java_estimate > 0 and story.java_estimate < java_days:
logging.warn("Over java estimate")
if story.cs_estimate > 0 and story.cs_estimate < cs_days:
logging.warn("Over cs estimate")
self.redirect('/s/' + story_id)
def get(self, story_id):
story = Story.get_by_story_id(story_id)
appengineutils.render_template(self.response, 'story.html', {"story" : story,
"estimate_options": range(0, 11)})
def get(self):
stories = Story.query().fetch()
self.render_html('home.html',
stories=stories)
def _accept_story(self, event):
logging.info('Accepting story: ' + event.story_id)
story = Story.get_by_story_id(event.story_id)
story.date_accepted = event.accepted_date
story.put()
def items(self):
return Story.objects.filter(Story.permission_to_view_Q())
def post(self):
if not self.user:
self.redirect(users.create_login_url(path_for('Home')))
return
story = Story.create(self.user)
self.redirect(path_for('EditPage', story.key.id(), story.page1_key.id()))
