def content(bid, cid):
book = Book.get(bid)
chapter = Chapter.get(cid, bid)
if not (book and chapter):
abort(404)
# NOTE read/set cookies for recent reading
recent_reading = request.cookies.get('recent_reading')
rec_book_chapters = []
if recent_reading:
for bid_cid in recent_reading.split('|'):
_bid, _cid = [int(id) for id in bid_cid.split(':', 1)]
if not _bid == bid:
if Book.get(_bid) and Chapter.get(_cid, _bid):
rec_book_chapters.append(
(Book.get(_bid), Chapter.get(_cid, _bid))
)
rec_book_chapters.insert(0, (book, chapter))
rec_book_chapters = rec_book_chapters[:10]
resp = make_response(render_template('content.html', **locals()))
recent_reading_str = '|'.join(['%s:%s' % (book.id, chapter.id)
for book, chapter in rec_book_chapters])
resp.set_cookie('recent_reading', recent_reading_str)
return resp
def fav_update(session, novel):
send_notice = False
logger.info("更新用户收藏小说[{0}]开始...".format(novel.novel_name))
start_time = time.time()
try:
parser_obj = novel_parser[novel.spider_name]
except KeyError as e:
logger.error("不存在的解析器:{0}".format(novel.spider_name))
logger.info("更新用户收藏小说[{0}]结束, 耗时:{1}".format(novel.novel_name,
time.time() - start_time))
return
try:
chapters = Chapter.select(
Chapter.chapter_url).where(Chapter.novel_id == novel.id)
html = parser_obj.get_html(session,
novel.url,
delay_time=settings.DOWNLOAD_DELAY,
headers=headers)
urls = parser_obj.parse_novel(html, novel.novel_name)
filter_urls = set([chapter.chapter_url for chapter in chapters])
for url in urls:
url = parse.urljoin(novel.url, url)
if url in filter_urls:
continue
html = parser_obj.get_html(session,
url,
delay_time=settings.DOWNLOAD_DELAY,
headers=headers)
chapter_name = parser_obj.parse_chapter(html, novel.novel_name)
chapter_index = utils.get_index_by_chapter(url)
try:
Chapter.create(chapter_url=url,
chapter_name=chapter_name,
chapter_index=chapter_index,
novel_id=novel.id)
logger.info("保存[{0}:{1}]到数据库成功.".format(
novel.novel_name, chapter_name))
send_notice = True
except Exception as e:
logger.error("保存[{0}:{1}:{2}]到数据库失败, 原因:{3}".format(
novel.novel_name, chapter_index, url, e))
except Exception as e:
logger.error("更新用户收藏小说[{0}]失败, 原因:{1}".format(novel.novel_name, e))
logger.info("更新用户收藏小说[{0}]结束, 耗时:{1}".format(novel.novel_name,
time.time() - start_time))
try:
if send_notice:
update_notice(novel)
else:
logger.info("小说[{0}]无更新.".format(novel.novel_name))
except Exception as e:
logger.error("发送小说[{0}]更新同时失败, 原因:{1}".format(novel.novel_name, e))
def test_index_ordering(self) -> None:
"""Tests Chapter.index property and how that affects ordering in Story.chapters."""
chapter1 = Chapter.new(self.teststory)
chapter2 = Chapter.new(self.teststory)
self.assertEqual(self.teststory.chapters[0], chapter1)
self.assertEqual(self.teststory.chapters[1], chapter2)
chapter1.index = 1
chapter2.index = 0
db.session.commit()
self.assertEqual(self.teststory.chapters[0], chapter2)
self.assertEqual(self.teststory.chapters[1], chapter1)
def do_registrar():
_auth = Auth()
if _auth.is_login():
#field validation
_name = request.forms.get('name')
_day = request.forms.get('day')
_url = request.forms.get('url')
_chapter_url = request.forms.get('chapter_url')
_num_chapters = request.forms.get('mun_chapters')
_old_chapter = request.forms.get('old_chapter')
#el usuario existe se supone que esta logueado sino cagada jaaj
_user = db.GqlQuery("SELECT * FROM User WHERE username = :1", _auth.is_login()).fetch(1)[0]
if _num_chapters <= _old_chapter:
_old_chapter = _num_chapters
_enabled = False
else:
_enabled = True
serie = Serie(
user = _user,
name = _name,
day = _day,
url = _url,
chapter_url = _chapter_url,
num_chapters = int(_num_chapters),
old_chapter = int(_old_chapter), #ultimo capitulo que salio
enabled = _enabled
)
serie.put()
# Registro los capitulos
n = int(_old_chapter) + 1
for num in range(1, n):
chapter = Chapter(
serie = serie,
number = num,
url = serie.chapter_url %num,
show = False
)
chapter.put()
return "Serie Registrada"
#return template("series/registrar.html")
else:
return template("sin-permisos.html")
def CheckChapter(self, *args):
from models import Chapter
bookname = args[0].replace('%20', ' ')
chapter = args[1].replace('%20', ' ')
user = users.get_current_user()
q = Chapter.all().filter('user ==',user).filter('book ==',bookname).filter('title ==',chapter)
results = q.fetch(1)
if len(results) == 0:
chapter = chapter+" "
q = Chapter.all().filter('user ==',user).filter('book ==',bookname).filter('title ==',chapter)
results = q.fetch(1)
for result in results:
result.state = "Fertig"
result.put()
break
return self.ShowBook(bookname,args[2])
def add_chapter(manga, chapter_name, chapter_num, pages):
# Ensure that chapter_num is a float
chapter_num = float(chapter_num)
# Ensure that the manga does not have a chapter with the same number
if manga.chapters.filter_by(num=chapter_num).first():
return
new_chapter = Chapter(chapter_name, chapter_num, manga)
# Representation is different if its an integer
num_string = chapter_to_string(chapter_num)
# Make a new folder for the chapter
url = new_chapter.manga.url + "/Chapter_" + num_string
# Rename and add all the chapter pages
curr_page = 1
for page in pages:
# Skip resource forks
if "__MACOSX" in page.filename:
continue
filename = rename(page, "%03d" % curr_page)
# Make sure nothing that isn't an image file doesn't get through.
if not allowed_file(page.filename):
continue
new_page = Page(curr_page, save_file(page, url, filename), new_chapter)
db.session.add(new_page)
# Remember to increment curr_page
curr_page += 1
zip_directory(manga, num_string, url)
# Manga has been updated, so update the last updated date
manga.last_updated = datetime.utcnow()
# Add and commit to the database
db.session.add(new_chapter)
db.session.commit()
def DeleteClass(self, *args):
from google.appengine.ext import db
from models import Task, Class, Book, Chapter
from google.appengine.api import users
user = users.get_current_user()
classname = args[0].replace('%20', ' ')
#Deleting all Tasks for this Module
q = Task.all().filter('user ==',user).filter('classname ==',classname)
results = q.fetch(10)
for result in results:
result.delete()
#Deleting all the Scripts and Chapters from this Module
qq = Book.all().filter('user ==',user).filter('classname ==',classname)
books = qq.fetch(10)
for book in books:
qqq = Chapter.all().filter('book ==', book.title).filter('user ==',user)
for chapter in qqq:
chapter.delete()
book.delete()
#Deleting the Module itself
qqqq = Class.all().filter('user ==',user).filter('name ==',classname)
results = qqqq.fetch(10)
for result in results:
result.delete()
return self.RefreshClasses()
def fake_chapter(count=1000):
fake = Faker()
course_count = Course.query.count()
for i in range(count):
u = Course.query.offset(randint(0, course_count - 1)).first()
c = Chapter(name=fake.name(), course=u)
db.session.add(c)
db.session.commit()
def m_chapter_modal(bid, cid):
chapter = Chapter.get(cid, bid)
if request.method == 'POST':
title = request.form.get('title')
content = request.form.get('content')
chapter.update(title, content)
return redirect(request.referrer)
return render_template('admin/chapter_modal.html', **locals())
def list_chapters(self):
course = Course(self.api_client.client, self.args.course)
book = Book(course, self.args.book)
print_list(
[
"{}. {}".format(str(float(c["rank"])).rstrip("0").rstrip("."), c["title"])
for c in Chapter.list(course, book)
]
)
def ShowBook(self, *args):
from models import Chapter
user = users.get_current_user()
chapters = Chapter.all().filter('user ==',user).filter('book ==',args[0]).order('number')
done = Chapter.all().filter('user ==',user).filter('book ==',args[0]).filter('state =', "Fertig")
try:
percent = done.count() * 100 / chapters.count()
except:
percent = 0
template_values = { 'classcolor': args[1],
'bookname' : args[0],
'percent' : percent,
'chapters' : chapters
}
path = os.path.join(os.path.dirname(__file__), "templates", "showindex.html")
code = template.render(path, template_values).decode('utf-8')
return code
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 get_chapter_list(cls, links):
chapters = []
for url in links:
soup = get_soup(url)
html = cls.get_chapter_html(soup)
chapter_title = cls.get_chapter_title(html)
print('Retrieving contents of Chapter %s""', chapter_title)
chapter_text = cls.get_chapter_contents(html)
chapters.append(Chapter(chapter_title, chapter_text))
return chapters
async def novel_update(novel):
async with async_semaphore:
send_notice = False
logger.info("更新小说【{0}】开始...".format(novel.novel_name))
start_time = time.time()
try:
parser_obj = novel_parser[novel.spider_name]
except KeyError as e:
logger.error("不存在的解析器:{0}".format(novel.spider_name))
logger.info("更新小说【{0}】结束, 耗时:{1}".format(novel.novel_name,
time.time() - start_time))
return
try:
chapters = await objects.execute(
Chapter.select(
Chapter.chapter_url).where(Chapter.novel_id == novel.id))
filter_urls = set([chapter.chapter_url for chapter in chapters])
html = await parser_obj.async_get_html(
novel.url, delay_time=settings.DOWNLOAD_DELAY, headers=headers)
urls = parser_obj.parse_novel(html)
for url in urls:
url = parse.urljoin(novel.url, url)
if url in filter_urls:
continue
try:
html = await parser_obj.async_get_html(
url,
delay_time=settings.DOWNLOAD_DELAY,
headers=headers)
chapter_name = parser_obj.parse_chapter(html)
except Exception as e:
logger.error(
f"解析小说【{novel.novel_name}】章节【{url}】失败, 原因:{e}")
continue
chapter_index = get_index_by_chapter(url)
try:
await objects.create(Chapter,
chapter_url=url,
chapter_name=chapter_name,
chapter_index=chapter_index,
novel_id=novel.id)
logger.info("保存【{0}:{1}】到数据库成功.".format(
novel.novel_name, chapter_name))
except Exception as e:
logger.error("保存[{0}:{1}:{2}]到数据库失败, 原因:{3}".format(
novel.novel_name, chapter_index, url, e))
except Exception as e:
logger.error("更新小说【{0}】失败, 原因:{1}".format(novel.novel_name, e))
logger.info("更新小说【{0}】结束, 耗时:{1}".format(novel.novel_name,
time.time() - start_time))
def test_flags(self) -> None:
"""Tests Chapter flag getters & setters."""
chapter = Chapter.new(self.teststory, "test")
chapter.flags = 0
self.assertFalse(chapter.private)
chapter.private = True
self.assertTrue(chapter.private)
self.assertEqual(chapter.flags, Story.Flags.PRIVATE)
def recent_reading(request):
recent_reading = request.cookies.get('recent_reading')
recent_book_chapters = []
if recent_reading:
for bid_cid in recent_reading.split('|'):
bid, cid = [int(id) for id in bid_cid.split(':', 1)]
book = Book.get(bid)
chapter = Chapter.get(cid, bid)
if (book and chapter):
recent_book_chapters.append((book, chapter))
recent_book_chapters = recent_book_chapters[:10]
return recent_book_chapters
def get_chapter(html):
soup = BeautifulSoup(html, 'html.parser')
list = soup.find_all('li', class_="c3")
session = Session_class()
for i in list:
body = get_context("http://www.quanben5.com" + i.a['href'])
chapter = Chapter(href="http://www.quanben5.com" + i.a['href'],
name=i.a.span.get_text(),
chapter_text=body)
print(i.a.span.get_text())
session.add(chapter)
session.commit()
def update_book(bid):
data = json.loads(request.data)
assert data, 'no data...'
chapter = data.get('chapter')
crawler = data.get('crawler', '')
title = chapter.get('title', '')
type = chapter.get('type', 'text')
if type == 'text':
content = chapter.get('content', '')
elif type == 'image':
content = ''
chapter = Chapter.add(bid, title, content)
log = UpdateLog.add(bid, chapter.id, crawler)
return jsonify(status='success', log=log.id)
def add_chapter(story_id):
new_chapter_data = json.loads(request.data)
new_chapter = Chapter(number=new_chapter_data['number'],
title=new_chapter_data['title'],
synopsis=new_chapter_data['synopsis'],
story_id=story_id)
# Try to add the new chapter
try:
insert(new_chapter)
except Exception as e:
abort(500)
return jsonify({'success': True, 'updated': return_object})
def test_order_properties(self) -> None:
"""Tests Chapter.number, Chapter.previous, and Chapter.next properties."""
chapter1 = Chapter.new(self.teststory)
chapter2 = Chapter.new(self.teststory)
chapter3 = Chapter.new(self.teststory)
self.teststory.private = False
chapter1.private = False
chapter3.private = False
self.assertIsNone(chapter1.previous)
self.assertEqual(chapter1.next, chapter3)
self.assertEqual(chapter1.number, 1)
# private chapters aren't given an order, previous, or next; they're used solely
# for public chapter navigation
self.assertIsNone(chapter2.previous)
self.assertIsNone(chapter2.next)
self.assertIsNone(chapter2.number)
self.assertEqual(chapter3.previous, chapter1)
self.assertIsNone(chapter3.next)
self.assertEqual(chapter3.number, 2)
# private stories don't have a public ordering for chapters
self.teststory.private = True
self.assertIsNone(chapter1.previous)
self.assertIsNone(chapter1.next)
self.assertIsNone(chapter1.number)
self.assertIsNone(chapter2.previous)
self.assertIsNone(chapter2.next)
self.assertIsNone(chapter2.number)
self.assertIsNone(chapter3.previous)
self.assertIsNone(chapter3.next)
self.assertIsNone(chapter3.number)
def post(self):
title = self.request.get('title')
content = self.request.get('content')
image_url = '/img/' + self.request.POST.multi['photo'].filename
pet_id = self.request.get('pet_id')
chapter = Chapter.create(title=title,
content=content,
image_url=image_url)
pet = Pet.get_by_id(long(pet_id))
pet.chapters.append(chapter)
pet.put()
self.redirect('/pet/' + pet_id)
def test_visibility(self) -> None:
"""Tests chapter visibility based on privacy & NSFW flags."""
self.teststory.private = False
chapter1 = Chapter.new(self.teststory, "private chapter", "Text")
chapter2 = Chapter.new(self.teststory, "visible chapter", "Text")
chapter2.private = False
# private chapters are visible only to the author
self.assertTrue(chapter1.visible(self.testuser))
self.assertFalse(chapter1.visible(self.testuser2))
# public chapters are visible to anyone
self.assertTrue(chapter2.visible(self.testuser))
self.assertTrue(chapter2.visible(self.testuser2))
self.teststory.private = True
# all chapters are visible only to the author for private stories
self.assertTrue(chapter1.visible(self.testuser))
self.assertFalse(chapter1.visible(self.testuser2))
self.assertTrue(chapter2.visible(self.testuser))
self.assertFalse(chapter2.visible(self.testuser2))
def DeleteBook(self, *args):
from google.appengine.ext import db
from models import Class, Book, Chapter
from google.appengine.api import users
user = users.get_current_user()
classname = args[0].replace('%20', ' ')
bookname = args[1].replace('%20', ' ')
qq = Book.all().filter('user ==',user).filter('classname ==',classname).filter('title ==',bookname)
books = qq.fetch(10)
for book in books:
qqq = Chapter.all().filter('book ==', book.title).filter('user ==',user)
for chapter in qqq:
chapter.delete()
book.delete()
break
return self.RefreshClasses()
def parseChapter(url, titleFilter=""):
soup = getSoup(url)
title = str(soup.find(class_='entry-title').string)
post = soup.find(class_='entry-content')
title = title.replace(titleFilter, "")
print('Parsing Chapter at %s: "%s"' % (url, title))
elements = []
for e in post.find_all():
elements.append(e)
doc = buildChapterContent(title, elements)
return Chapter(title, doc)
def scrape_chapters(page):
url = self.url + f'/novel/{novel_id}?tab=chapters&page={page}&chorder=asc'
chapters_raw = BeautifulSoup(scraper.get(url).content, 'lxml')
chapters_html = chapters_raw.select('ul.chapter-list > li')
has_more_pages = len(chapters_raw.select('div.pagination-container > ul.pagination > li.PagedList-skipToNext')) > 0
for item in chapters_html:
title = item.select('a')[0].get('title')
link = self.url + item.select('a')[0].get('href')
chapter_number = item.get('data-chapterno')
text = get_chapter_contnent(link)
print(Style.RESET_ALL + Style.BRIGHT + Fore.GREEN + title + Style.RESET_ALL)
chapters.append(Chapter(title, link, chapter_number, text))
time.sleep(3)
if has_more_pages:
scrape_chapters(page + 1)
def setUp(self) -> None:
super().setUp()
db.drop_all()
db.create_all()
self.testuser = User.register(username='******',
password='******',
email='*****@*****.**',
birthdate=date(1997, 3, 16))
self.testuser.allow_risque = True
self.testuser2 = User.register(username='******',
password='******',
email='*****@*****.**',
birthdate=date(1997, 3, 17))
self.teststory = Story.new(self.testuser, "Hello world")
self.testchapter = Chapter.new(self.teststory, None,
"This is a test from Speakonia")
self.testchapter.private = False
db.session.commit()
def insert_course(course_id):
chapter = Chapter(parent_id=0, course_id=course_id)
db.session.add(chapter)
db.session.commit()
return redirect(url_for('modify_chapter', course_id=course_id))
"title": "Unsafe for Work Story",
"summary": "How scandalous!! *shocked face*",
"posted": datetime(2021, 2, 9, 4, 24, 11, 911000, timezone.utc),
"modified": datetime(2021, 2, 9, 5, 11, 55, 911000, timezone.utc),
"flags": Story.Flags.IS_RISQUE
}
)
CHAPTERDATA1 = (
{
"name": None,
"text": "Hello **world**! I'm a test chapter's text contents! Wheeeeee",
"author_notes": "Just explainin what this is.",
"posted": STORYDATA[0]['posted'],
"modified": STORYDATA[0]['modified'],
"flags": Chapter.Flags(0)
},
{
"name": "Chapter 2",
"text": "More text lol",
"author_notes": None,
"posted": STORYDATA[0]['posted'],
"modified": STORYDATA[0]['modified'],
"flags": Chapter.Flags(0),
"index": 1
}
)
CHAPTERDATA2 = (
{
"name": None,
def upload_book(self):
file_path = expand_file_path(self.args.upload_data)
if not os.path.exists(file_path):
exit_with_error("input file path {} does not exist".format(file_path))
with open(file_path, "rb") as schema:
try:
book_data = json.load(schema)
except Exception as e:
exit_with_error("Failed loading json schema with error: {}".format(e))
def get_or_none(obj, field):
if field in obj:
return obj[field]
return None
file_prefix = os.path.dirname(file_path)
def adjust_search_path(path):
if path is None:
return None
return os.path.join(file_prefix, path)
# Collect the necessary Diderot objects.
course = Course(self.api_client.client, self.args.course)
book_label = get_or_none(book_data, "book")
# Try out "label", more consistent with Diderot terminology
if book_label is None:
book_label = get_or_none(book_data, "label")
# If book label is still None, then error out.
if book_label is None:
exit_with_error("Please specify a valid book to upload into")
book = Book(course, book_label)
# If the upload contains parts, create them.
parts = get_or_none(book_data, "parts")
if parts is not None:
for part in parts:
if not Part.exists(course, book, get_or_none(part, "number")):
self.api_client.create_part(
course.label,
book.label,
get_or_none(part, "number"),
get_or_none(part, "title"),
get_or_none(part, "label"),
)
# Upload and maybe create the chapters in the input.
chapters = get_or_none(book_data, "chapters")
if chapters is None:
exit_with_error("invalid JSON: could not find field 'chapters'")
for chapter in chapters:
# Extract data from chapter json
number = get_or_none(chapter, "number")
label = get_or_none(chapter, "label")
title = get_or_none(chapter, "title")
attachments = get_or_none(chapter, "attachments")
self.args.pdf = adjust_search_path(get_or_none(chapter, "pdf"))
self.args.slides = adjust_search_path(get_or_none(chapter, "slides"))
self.args.video_url = adjust_search_path(get_or_none(chapter, "video"))
self.args.xml = adjust_search_path(get_or_none(chapter, "xml"))
self.args.xml_pdf = adjust_search_path(get_or_none(chapter, "xml_pdf"))
if number is None:
exit_with_error(f"invalid JSON: must provide field 'number' for chapter {chapter}")
# If the target chapter does not exist, then create it.
if not Chapter.exists(course, book, number):
part_num = get_or_none(chapter, "part")
# Non-booklets need parts for their chapters.
if not book.is_booklet and part_num is None:
exit_with_error("Chapter creation in a book requires 'part' field for chapters")
self.api_client.create_chapter(course.label, book.label, part_num, number, title, label)
print(f"Successfully created chapter number ({number}), label ({label}, title ({title}).")
# Upload the target files to the chapter now.
self.args.attach = None
if attachments is not None:
self.args.attach = [adjust_search_path(path) for path in attachments]
# Set default arguments that we wont use, but upload_chapter expects.
print(f"Uploading chapter number: {number}...")
try:
self.api_client.upload_chapter(
course.label, book.label, number, None, self.args, sleep_time=self.sleep_time,
)
except APIError as e:
exit_with_error("Failure uploading chapter. Aborting")
print("Successfully uploaded chapter.")
def chapters(bid):
book = Book.get(bid)
if not book:
abort(404)
chapters = Chapter.get_id_titles(book.id)
return render_template('chapters.html', **locals())
def test_update(self) -> None:
"""Tests the Story.update function."""
story = Story.new(self.testuser, "test")
# empty update has no effect
self.assertEqual(len(story.update()), 0)
self.assertEqual(story.title, "test")
self.assertEqual(story.summary, "")
self.assertTrue(story.private)
self.assertTrue(story.can_comment)
self.assertFalse(story.is_risque)
self.assertEqual(story.thumbnail.url, Story.DEFAULT_THUMBNAIL_URI)
self.assertEqual(len(story.update(title=123)), 1)
self.assertEqual(story.title, "test")
self.assertEqual(len(story.update(title=False)), 1)
self.assertEqual(story.title, "test")
self.assertEqual(len(story.update(title=15.5)), 1)
self.assertEqual(story.title, "test")
self.assertEqual(len(story.update(title=[])), 1)
self.assertEqual(story.title, "test")
self.assertEqual(len(story.update(title=[1, 2, 3])), 1)
self.assertEqual(story.title, "test")
self.assertEqual(len(story.update(title={})), 1)
self.assertEqual(story.title, "test")
self.assertEqual(len(story.update(title=" Test ")), 0)
self.assertEqual(story.title, "Test")
self.assertEqual(len(story.update(title=122, thumbnail=5)), 2)
self.assertEqual(story.title, "Test")
self.assertEqual(story.thumbnail.url, Story.DEFAULT_THUMBNAIL_URI)
self.assertEqual(len(story.update(private="hello")), 1)
self.assertTrue(story.private)
self.assertEqual(len(story.update(private=3)), 1)
self.assertTrue(story.private)
self.assertEqual(len(story.update(private=15.8)), 1)
self.assertTrue(story.private)
self.assertEqual(len(story.update(private="off")), 1)
self.assertTrue(story.private)
self.assertEqual(len(story.update(private=[])), 1)
self.assertTrue(story.private)
self.assertEqual(len(story.update(private={'1': 2})), 1)
self.assertTrue(story.private)
# cannot public a story with no chapters
self.assertEqual(len(story.update(private=False)), 0)
self.assertTrue(story.private)
# cannot public a story with no public chapters
chapter = Chapter.new(story, None, "")
self.assertEqual(len(story.update(private=False)), 0)
self.assertTrue(story.private)
# can only public a story with public chapters with visible text
chapter.update(text="Hello world", private=False)
self.assertEqual(len(story.update(private=False)), 0)
self.assertFalse(story.private)
self.assertEqual(len(story.update(private=True)), 0)
self.assertTrue(story.private)
self.assertEqual(len(story.update(can_comment=1.9)), 1)
self.assertTrue(story.can_comment)
self.assertEqual(len(story.update(can_comment=-2)), 1)
self.assertTrue(story.can_comment)
self.assertEqual(len(story.update(can_comment="go")), 1)
self.assertTrue(story.can_comment)
self.assertEqual(len(story.update(can_comment=[True])), 1)
self.assertTrue(story.can_comment)
self.assertEqual(len(story.update(can_comment={})), 1)
self.assertTrue(story.can_comment)
self.assertEqual(len(story.update(can_comment=False)), 0)
self.assertFalse(story.can_comment)
self.assertEqual(len(story.update(can_comment=True)), 0)
self.assertTrue(story.can_comment)
self.assertEqual(len(story.update(is_risque=5)), 1)
self.assertFalse(story.is_risque)
self.assertEqual(len(story.update(is_risque=0.001)), 1)
self.assertFalse(story.is_risque)
self.assertEqual(len(story.update(is_risque="test")), 1)
self.assertFalse(story.is_risque)
self.assertEqual(len(story.update(is_risque=[])), 1)
self.assertFalse(story.is_risque)
self.assertEqual(len(story.update(is_risque={"test": 55})), 1)
self.assertFalse(story.is_risque)
self.assertEqual(len(story.update(is_risque=True)), 0)
self.assertTrue(story.is_risque)
self.assertEqual(len(story.update(is_risque=False)), 0)
self.assertFalse(story.is_risque)
self.assertEqual(len(story.update(thumbnail=False)), 1)
self.assertEqual(story.thumbnail.url, Story.DEFAULT_THUMBNAIL_URI)
self.assertEqual(len(story.update(thumbnail=125)), 1)
self.assertEqual(story.thumbnail.url, Story.DEFAULT_THUMBNAIL_URI)
self.assertEqual(len(story.update(thumbnail=-0.8)), 1)
self.assertEqual(story.thumbnail.url, Story.DEFAULT_THUMBNAIL_URI)
self.assertEqual(len(story.update(thumbnail=[])), 1)
self.assertEqual(story.thumbnail.url, Story.DEFAULT_THUMBNAIL_URI)
self.assertEqual(len(story.update(thumbnail={})), 1)
self.assertEqual(story.thumbnail.url, Story.DEFAULT_THUMBNAIL_URI)
self.assertEqual(len(story.update(thumbnail="abc")), 0)
self.assertEqual(story.thumbnail.url, "abc")
self.assertEqual(len(story.update(thumbnail="")), 0)
self.assertEqual(story.thumbnail.url, Story.DEFAULT_THUMBNAIL_URI)
self.assertEqual(len(story.update(summary=True)), 1)
self.assertEqual(story.summary, "")
self.assertEqual(len(story.update(summary=12)), 1)
self.assertEqual(story.summary, "")
self.assertEqual(len(story.update(summary=0.1)), 1)
self.assertEqual(story.summary, "")
self.assertEqual(len(story.update(summary=[])), 1)
self.assertEqual(story.summary, "")
self.assertEqual(len(story.update(summary={})), 1)
self.assertEqual(story.summary, "")
self.assertEqual(len(story.update(summary="foobar")), 0)
self.assertEqual(story.summary, "foobar")
self.assertEqual(len(story.update(summary=" hello world ! ")), 0)
self.assertEqual(story.summary, "hello world !")
self.assertEqual(len(story.update(summary=" ")), 0)
self.assertEqual(story.summary, "")
def test_update(self) -> None:
"""Tests the Chapter.update method."""
chapter = Chapter.new(self.teststory, None, "Text")
chapter2 = Chapter.new(self.teststory, None, "Text")
chapter3 = Chapter.new(self.teststory, None, "Text")
chapter.private = False
chapter2.private = False
chapter3.private = False
self.assertEqual(len(chapter.update()), 0)
self.assertIsNone(chapter.name)
self.assertEqual(chapter.text, "Text")
self.assertEqual(chapter.index, 0)
self.assertFalse(chapter.private)
self.assertIsNone(chapter.author_notes)
self.assertEqual(len(chapter.update(name=True)), 1)
self.assertIsNone(chapter.name)
self.assertEqual(len(chapter.update(name=-5)), 1)
self.assertIsNone(chapter.name)
self.assertEqual(len(chapter.update(name=123.456)), 1)
self.assertIsNone(chapter.name)
self.assertEqual(len(chapter.update(name=[])), 1)
self.assertIsNone(chapter.name)
self.assertEqual(len(chapter.update(name={'a': True, 'b': True})), 1)
self.assertIsNone(chapter.name)
self.assertEqual(len(chapter.update(name="abc")), 0)
self.assertEqual(chapter.name, "abc")
self.assertEqual(len(chapter.update(name=" abc")), 0)
self.assertEqual(chapter.name, "abc")
self.assertEqual(len(chapter.update(name="")), 0)
self.assertIsNone(chapter.name)
self.assertEqual(len(chapter.update(name=" ")), 0)
self.assertIsNone(chapter.name)
self.assertEqual(len(chapter.update(author_notes=False)), 1)
self.assertIsNone(chapter.author_notes)
self.assertEqual(len(chapter.update(author_notes=2)), 1)
self.assertIsNone(chapter.author_notes)
self.assertEqual(len(chapter.update(author_notes=3.6)), 1)
self.assertIsNone(chapter.author_notes)
self.assertEqual(len(chapter.update(author_notes=[])), 1)
self.assertIsNone(chapter.author_notes)
self.assertEqual(len(chapter.update(author_notes={})), 1)
self.assertIsNone(chapter.author_notes)
self.assertEqual(len(chapter.update(author_notes="test notes")), 0)
self.assertEqual(chapter.author_notes, "test notes")
self.assertEqual(
len(chapter.update(author_notes="more test notes ")), 0)
self.assertEqual(chapter.author_notes, "more test notes")
self.assertEqual(len(chapter.update(author_notes="")), 0)
self.assertIsNone(chapter.author_notes)
self.assertEqual(len(chapter.update(text=True)), 1)
self.assertEqual(chapter.text, "Text")
self.assertEqual(len(chapter.update(text=17)), 1)
self.assertEqual(chapter.text, "Text")
self.assertEqual(len(chapter.update(text=-5.5)), 1)
self.assertEqual(chapter.text, "Text")
self.assertEqual(len(chapter.update(text=["hi", 'there'])), 1)
self.assertEqual(chapter.text, "Text")
self.assertEqual(len(chapter.update(text={"go": 'away'})), 1)
self.assertEqual(chapter.text, "Text")
self.assertEqual(len(chapter.update(text="# hello\nlolololo")), 0)
self.assertEqual(chapter.text, "# hello\nlolololo")
self.assertEqual(len(chapter.update(text="abc abc")), 0)
self.assertEqual(chapter.text, "abc abc")
self.assertEqual(len(chapter.update(text="\n\nabc\n\nabc\n\n")), 0)
self.assertEqual(chapter.text, "abc\n\nabc")
# chapter with no visible text must be private
self.assertEqual(len(chapter.update(text="")), 0)
self.assertEqual(chapter.text, "")
self.assertTrue(chapter.private)
self.assertEqual(len(chapter.update(text=" # \n> > - []() ")), 0)
self.assertEqual(chapter.text, "# \n> > - []()")
chapter.update(private=False)
self.assertTrue(chapter.private)
self.assertEqual(len(chapter.update(text="Text")), 0)
self.assertEqual(chapter.text, "Text")
self.assertTrue(chapter.private)
chapter.update(private=False)
self.assertFalse(chapter.private)
self.assertEqual(len(chapter.update(index=False)), 1)
self.assertEqual(chapter.index, 0)
self.assertEqual(len(chapter.update(index=1.5)), 1)
self.assertEqual(chapter.index, 0)
self.assertEqual(len(chapter.update(index="hello world")), 1)
self.assertEqual(chapter.index, 0)
self.assertEqual(len(chapter.update(index=[0, 1, 2, 'test'])), 1)
self.assertEqual(chapter.index, 0)
self.assertEqual(len(chapter.update(index={})), 1)
self.assertEqual(chapter.index, 0)
self.assertEqual(len(chapter.update(index=-1)), 1)
self.assertEqual(chapter.index, 0)
self.assertEqual(len(chapter.update(index=3)), 1)
self.assertEqual(chapter.index, 0)
self.assertEqual(len(chapter.update(index=1)), 0)
self.assertEqual(chapter.index, 1)
self.assertEqual(chapter2.index, 0)
self.assertEqual(chapter3.index, 2)
self.assertEqual(len(chapter.update(index=2)), 0)
self.assertEqual(chapter.index, 2)
self.assertEqual(chapter2.index, 0)
self.assertEqual(chapter3.index, 1)
self.assertEqual(len(chapter.update(index=0)), 0)
self.assertEqual(chapter.index, 0)
self.assertEqual(chapter2.index, 1)
self.assertEqual(chapter3.index, 2)
self.assertEqual(len(chapter.update(private=0)), 1)
self.assertFalse(chapter.private)
self.assertEqual(len(chapter.update(private=1.5)), 1)
self.assertFalse(chapter.private)
self.assertEqual(len(chapter.update(private="")), 1)
self.assertFalse(chapter.private)
self.assertEqual(len(chapter.update(private=[55])), 1)
self.assertFalse(chapter.private)
self.assertEqual(len(chapter.update(private={'str': 'abc'})), 1)
self.assertFalse(chapter.private)
self.assertEqual(len(chapter.update(private=True)), 0)
self.assertTrue(chapter.private)
self.assertEqual(len(chapter.update(private=False)), 0)
self.assertFalse(chapter.private)
# chapter with no text must be private
chapter.update(text="")
self.assertEqual(len(chapter.update(private=False)), 0)
self.assertTrue(chapter.private)
self.assertEqual(len(chapter.update(private=True)), 0)
self.assertTrue(chapter.private)
def insert_chapter(chapter_id):
chapter1 = Chapter.query.filter_by(id=chapter_id).first_or_404()
course_id = chapter1.course_id
chapter = Chapter(parent_id=chapter_id, course_id=course_id)
chapter.insert()
return redirect(url_for('modify_chapter', course_id=course_id))
def test_new(self) -> None:
"""Tests the Chapter.new class method."""
# name must be a string with at least one non-whitespace character or null
self.assertRaises(ValueError, Chapter.new, self.teststory, 1.5)
self.assertRaises(ValueError, Chapter.new, self.teststory, True)
self.assertRaises(ValueError, Chapter.new, self.teststory, -5)
self.assertRaises(ValueError, Chapter.new, self.teststory, [])
self.assertRaises(ValueError, Chapter.new, self.teststory, {})
self.assertRaises(ValueError, Chapter.new, self.teststory, "")
self.assertRaises(ValueError, Chapter.new, self.teststory, " ")
# text must be a string
self.assertRaises(ValueError, Chapter.new, self.teststory, text=None)
self.assertRaises(ValueError, Chapter.new, self.teststory, text=125)
self.assertRaises(ValueError, Chapter.new, self.teststory, text=False)
self.assertRaises(ValueError, Chapter.new, self.teststory, text=-6.28)
self.assertRaises(ValueError, Chapter.new, self.teststory, text=[])
self.assertRaises(ValueError, Chapter.new, self.teststory, text={})
# author_notes must be a string or null
self.assertRaises(ValueError,
Chapter.new,
self.teststory,
author_notes=3.6)
self.assertRaises(ValueError,
Chapter.new,
self.teststory,
author_notes=True)
self.assertRaises(ValueError,
Chapter.new,
self.teststory,
author_notes=1)
self.assertRaises(ValueError,
Chapter.new,
self.teststory,
author_notes=[])
self.assertRaises(ValueError,
Chapter.new,
self.teststory,
author_notes={})
chapter1 = Chapter.new(self.teststory)
self.assertEqual(chapter1.story_id, self.teststory.id)
self.assertEqual(chapter1.story, self.teststory)
self.assertEqual(chapter1.flags, Chapter.Flags.DEFAULT)
self.assertIsNone(chapter1.name)
self.assertIsNone(chapter1.author_notes)
self.assertEqual(chapter1.text, "")
self.assertEqual(chapter1.index, 0)
self.assertIsNone(chapter1.number)
self.assertEqual(len(chapter1.comments), 0)
self.assertEqual(len(chapter1.reports), 0)
self.assertEqual(chapter1.posted, chapter1.modified)
chapter2 = Chapter.new(self.teststory, " Test Chapter")
self.assertEqual(chapter2.story_id, self.teststory.id)
self.assertEqual(chapter2.story, self.teststory)
self.assertEqual(chapter2.flags, Chapter.Flags.DEFAULT)
self.assertEqual(chapter2.name, "Test Chapter")
self.assertIsNone(chapter2.author_notes)
self.assertEqual(chapter2.text, "")
self.assertEqual(chapter2.index, 1)
self.assertIsNone(chapter2.number)
self.assertEqual(len(chapter2.comments), 0)
self.assertEqual(len(chapter2.reports), 0)
self.assertEqual(chapter2.posted, chapter2.modified)
def m_chapter_delete():
bid = request.form.get('bid')
cid = request.form.get('cid')
Chapter.delete(bid, cid)
return redirect(request.referrer)
