def test_delete(self):
series, created = Series.from_dict({"name": "Secret Files"})
self.assertTrue(created)
self.assertIsNotNone(series.id)
deleted = series.delete()
self.assertIsNone(series.id)
self.assertEquals((1, {"series.Series": 1}), deleted)
series, created = Series.from_dict({
"name":
"Secret Files",
"links": [{
"url": "https://secrectfiles.com"
}]
})
self.assertTrue(created)
self.assertIsNotNone(series.id)
deleted = series.delete()
self.assertIsNone(series.id)
self.assertEquals(
(3, {
"series.Series": 1,
"series.Series_links": 1,
"links.Link": 1
}),
deleted,
)
def create_series(self, form):
"""Set the creator_id of the newly created series to the user that's
currently logged in and also fills in the title and description fields
"""
series = Series(title=form.cleaned_data['title'], description=form.cleaned_data['description'],
creator_id=self.request.user.id, site_id=self.kwargs['website_id'])
series.save()
return series
def test_reading_days_ahead_by_month_one(self): from datetime import date FakeDate.today = classmethod(lambda cls: date(2011, 7, 4)) s = Series() s.day_of_week = DayOfWeek() s.day_of_week.day = "SU" s.week_within_month = WeekWithinMonth() s.week_within_month.week_within_month = "1" # Test first Sunday self.assertEquals(s.reading_days_ahead_by_month(1), [date(2011, 8, 7)])
def test_next_reading_day_thismonth(self): from datetime import date FakeDate.today = classmethod(lambda cls: date(2011, 7, 4)) s = Series() s.day_of_week = DayOfWeek() s.day_of_week.day = "MO" s.week_within_month = WeekWithinMonth() s.week_within_month.week_within_month = "1" # Test first Sunday after Monday July 4, 2011 self.assertEquals(s.next_reading_day(), date(2011, 7, 4))
def create_series(self, form):
"""Set the creator_id of the newly created series to the user that's
currently logged in and also fills in the title and description fields
"""
series = Series(title=form.cleaned_data['title'],
description=form.cleaned_data['description'],
creator_id=self.request.user.id,
site_id=self.kwargs['website_id'])
series.save()
return series
def edit(self: T, field: str, value: Union[str, float], *args, **kwargs):
"""Change field by given value."""
assert field in [
"title", "author", "series", "volume", "genre", "link"
]
if field == "title":
self.title = value
elif field == "author" and isinstance(value, str):
author = Person.get_or_create(value)
if self.authors.filter(pk=author.pk).exists():
self.authors.remove(author)
else:
self.authors.add(author)
elif field == "series" and isinstance(value, str):
self.series = Series.get_or_create(value)
elif field == "volume":
self.volume = value
elif field == "genre" and isinstance(value, str):
genre = Genre.get_or_create(value)
if self.genres.filter(pk=genre.pk).exists():
self.genres.remove(genre)
else:
self.genres.add(genre)
elif field == "link" and isinstance(value, str):
link = Link.get_or_create(value)
if self.links.filter(pk=link.pk).exists():
self.links.remove(link)
else:
self.links.add(link)
self.save(*args, **kwargs)
def test_get(self):
series, created = Series.from_dict({"name": "Secret Files"})
self.assertTrue(created)
self.assertIsNotNone(series.id)
series2 = Series.get("Secret Files")
self.assertIsNotNone(series2)
self.assertEquals(series, series2)
series2 = Series.get("files")
self.assertIsNotNone(series2)
self.assertEquals(series, series2)
series2 = Series.get(str(series.id))
self.assertIsNotNone(series2)
self.assertEquals(series, series2)
def test_search(self):
series, created = Series.from_dict({"name": "Secret Files"})
self.assertTrue(created)
self.assertIsNotNone(series.id)
series, created = Series.from_dict({"name": "Ran"})
self.assertTrue(created)
self.assertIsNotNone(series.id)
series, created = Series.from_dict({"name": "Random Files"})
self.assertTrue(created)
self.assertIsNotNone(series.id)
self.assertEquals(3, Series.objects.all().count())
self.assertEquals(2, Series.search("files").count())
self.assertEquals(2, Series.search("ran").count())
def from_dict(cls: Type[T], data: Dict) -> Tuple[T, bool]:
"""Create from dict.
Returns True if was crated, i. e. was not found in the DB.
"""
defaults: Dict = {}
if "series" in data and data["series"]:
defaults["series"] = Series.from_dict(data["series"])[0]
if "volume" in data and data["volume"]:
defaults["volume"] = data["volume"]
book, created = Book.objects.get_or_create(title=data["title"],
defaults=defaults)
if "authors" in data and data["authors"]:
for i in data["authors"]:
book.authors.add(Person.from_dict(i)[0])
if "genres" in data and data["genres"]:
for i in data["genres"]:
book.genres.add(Genre.from_dict(i)[0])
if "links" in data and data["links"]:
for i in data["links"]:
book.links.add(Link.from_dict(i)[0])
return book, created
def test_save(self):
series = Series(name="Some Series")
series.save()
self.assertIsNotNone(series.id)
self.assertEquals("some-series", series.slug)
series = Series(name="Deep Space")
series.save()
self.assertIsNotNone(series.id)
self.assertEquals("deep-space", series.slug)
def mutate_and_get_payload(cls, root, info, **input):
# проверяет токен
token = input.get('token', None)
if token != '******************':
return "Invalid token"
series = Series(title=input.get('title'),
description=input.get('description'),
image=input.get('image'),
rating=input.get('rating', 0),
show_counter=input.get('show_counter', 0),
date_create=input.get('date_create', 0),
date_update=datetime.datetime.utcnow())
if input.get('pk'):
series.pk = input.get('pk')
series.save()
return AddSeries(series=series)
def test_from_to_dict(self):
link, created = Link.objects.get_or_create(
link="https://secrectfiles.com")
self.assertTrue(created)
self.assertIsNotNone(link.id)
series, created = Series.objects.get_or_create(name="Secret Files")
series.links.add(link)
self.assertTrue(created)
self.assertIsNotNone(series.id)
self.assertEquals(
{
"name": "Secret Files",
"links": [{
"url": "https://secrectfiles.com"
}]
},
series.to_dict(),
)
self.assertEquals(
(series, False),
Series.from_dict({
"name": "Secret Files",
"links": [{
"url": "https://secrectfiles.com"
}]
}),
)
self.assertEquals((series, False),
Series.from_dict({"name": "Secret Files"}))
series, created = Series.objects.get_or_create(name="Random")
self.assertTrue(created)
self.assertIsNotNone(series.id)
self.assertEquals({"name": "Random", "links": None}, series.to_dict())
self.assertEquals((series, False),
Series.from_dict({
"name": "Random",
"links": None
}))
self.assertEquals((series, False), Series.from_dict({"name":
"Random"}))
def test_get_or_create(self):
series, created = Series.from_dict({"name": "Secret Files"})
self.assertTrue(created)
self.assertIsNotNone(series.id)
self.assertEquals(1, Series.objects.count())
series2 = Series.get_or_create("Secret Files")
self.assertIsNotNone(series2)
self.assertEquals(series, series2)
self.assertEquals(1, Series.objects.count())
series2 = Series.get_or_create(str(series.id))
self.assertIsNotNone(series2)
self.assertEquals(series, series2)
self.assertEquals(1, Series.objects.count())
series2 = Series.get_or_create("Secret Papers")
self.assertIsNotNone(series2)
self.assertNotEquals(series, series2)
self.assertEquals(2, Series.objects.count())
def save(self):
name = self.validated_data['name']
alt_id = self.validated_data['alt_id']
publisher = self.validated_data['publisher']
imprint = self.validated_data['imprint']
genre = self.validated_data['genre']
years = self.validated_data['years']
is_one_shot = self.validated_data['is_one_shot']
is_mini_series = self.validated_data['is_mini_series']
mini_series_limit = self.validated_data['mini_series_limit']
series = Series(alt_id=alt_id,
name=name,
publisher=publisher,
imprint=imprint,
genre=genre,
years=years,
is_one_shot=is_one_shot,
is_mini_series=is_mini_series,
mini_series_limit=mini_series_limit)
series.save()
return series
def test_reading_days_ahead_by_month_twelve(self): from datetime import date FakeDate.today = classmethod(lambda cls: date(2011, 7, 4)) s = Series() s.day_of_week = DayOfWeek() s.day_of_week.day = "SU" s.week_within_month = WeekWithinMonth() s.week_within_month.week_within_month = "1" # Test first Sunday self.assertEquals(s.reading_days_ahead_by_month(12), [ date(2011, 8, 7), date(2011, 9, 4), date(2011, 10, 2), date(2011, 11, 6), date(2011, 12, 4), date(2012, 1, 1), date(2012, 2, 5), date(2012, 3, 4), date(2012, 4, 1), date(2012, 5, 6), date(2012, 6, 3), date(2012, 7, 1), date(2012, 8, 5), ])
def test_print(self):
series, created = Series.from_dict({"name": "Secret Files"})
self.assertTrue(created)
self.assertIsNotNone(series.id)
with StringIO() as cout:
series.print(cout)
self.assertEquals(
"Field Value "
+
" \n=================================="
+
"==================================================================\n"
+
"Id 1 "
+
" \n__________________________________"
+
"__________________________________________________________________\n"
+
"Name Secret Files "
+
" \n__________________________________"
+
"__________________________________________________________________\n"
+
"Links "
+
" \n__________________________________"
+
"__________________________________________________________________\n"
+
"Books "
+
" \n__________________________________"
+
"__________________________________________________________________\n",
cout.getvalue(),
)
def _series(args: Namespace, file: TextIO = sys.stdout):
series: Optional[Series] = None
if args.subparser == "add":
series, created = Series.from_dict({
"name":
args.name,
"links":
[Link.get_or_create(link).to_dict() for link in args.link],
})
if created:
stdout.write(
_('Successfully added series "%(name)s" with id "%(pk)d".') % {
"name": series.name,
"pk": series.pk
},
"=",
file=file,
)
series.print(file)
else:
stdout.write(
_('The series "%(name)s" already exists with id "%(pk)d", aborting...'
) % {
"name": series.name,
"pk": series.pk
},
"",
file=file,
)
elif args.subparser == "delete":
series = Series.get(args.series)
if series:
series.delete()
stdout.write(
_('Successfully deleted series with id "%(pk)d".') %
{"pk": series.pk},
"",
file=file,
)
else:
stdout.write(_("No series found."), "", file=file)
elif args.subparser == "edit":
series = Series.get(args.series)
if series:
series.edit(args.field, args.value)
stdout.write(
_('Successfully edited series "%(name)s" with id "%(pk)d".') %
{
"name": series.name,
"pk": series.pk
},
"",
file=file,
)
series.print(file)
else:
stdout.write(_("No series found."), "", file=file)
elif args.subparser == "info":
series = Series.get(args.series)
if series:
series.print(file)
else:
stdout.write(_("No series found."), "", file=file)
elif args.subparser == "list":
if args.search:
series = Series.search(args.search)
else:
series = Series.objects.all()
stdout.write(
[_("Id"), _("Name"), _("Number of books")],
"=", [0.05, 0.8],
file=file)
for i, has_next in lookahead(series):
stdout.write(
[i.id, i.name, i.books.count()],
"_" if has_next else "=",
[0.05, 0.8],
file=file,
)
def test_from_to_dict(self):
book, created = Book.objects.get_or_create(title="Cool")
self.assertTrue(created)
self.assertIsNotNone(book.id)
self.assertEquals(
{
"title": "Cool",
"authors": None,
"series": None,
"volume": 0,
"genres": None,
"links": None,
},
book.to_dict(),
)
self.assertEquals((book, False), Book.from_dict(book.to_dict()))
self.assertEquals((book, False), Book.from_dict({"title": "Cool"}))
author, created = Person.from_dict({"name": "Max Mustermann"})
self.assertTrue(created)
self.assertIsNotNone(author.id)
series, created = Series.from_dict({"name": "Secret Files"})
self.assertTrue(created)
self.assertIsNotNone(series.id)
genre, created = Genre.from_dict({"name": "Fiction"})
self.assertTrue(created)
self.assertIsNotNone(genre.id)
link, created = Link.from_dict({"url": "https://example.com"})
self.assertTrue(created)
self.assertIsNotNone(link.id)
book, created = Book.objects.get_or_create(title="Example",
series=series,
volume=1)
book.authors.add(author)
book.genres.add(genre)
book.links.add(link)
self.assertTrue(created)
self.assertIsNotNone(book.id)
self.assertEquals(
{
"title": "Example",
"authors": [{
"name": "Max Mustermann",
"links": None
}],
"series": {
"name": "Secret Files",
"links": None
},
"volume": 1,
"genres": [{
"name": "Fiction"
}],
"links": [{
"url": "https://example.com"
}],
},
book.to_dict(),
)
self.assertEquals((book, False), Book.from_dict(book.to_dict()))
def test_edit(self):
series, created = Series.from_dict({"name": "Test Series"})
self.assertTrue(created)
self.assertIsNotNone(series.id)
person, created = Person.from_dict({"name": "John Do"})
self.assertTrue(created)
self.assertIsNotNone(person.id)
book, created = Book.from_dict({
"title": "Test2 Book",
"authors": [person.to_dict()],
"series": series.to_dict(),
"volume": 1.0,
"genres": [{
"name": "Romance"
}],
})
self.assertTrue(created)
self.assertIsNotNone(book.id)
self.assertEquals(series, book.series)
self.assertEquals(person, book.authors.first())
book.edit("title", "IEEE Test Book")
self.assertEquals("IEEE Test Book", book.title)
book.edit("author", "Jane Do")
self.assertEquals(2, book.authors.count())
self.assertEquals("Jane Do", str(book.authors.all()[0]))
self.assertEquals("John Do", str(book.authors.all()[1]))
book.edit("author", str(person.id))
self.assertEquals(1, book.authors.count())
self.assertEquals("Jane Do", str(book.authors.all()[0]))
series, created = Series.from_dict({"name": "Space Series"})
self.assertTrue(created)
self.assertIsNotNone(series.id)
book.edit("series", str(series.id))
self.assertEquals(series, book.series)
book.edit("volume", 0.75)
self.assertEquals(0.75, book.volume)
series, created = Series.from_dict({"name": "Deep Space Series"})
self.assertTrue(created)
self.assertIsNotNone(series.id)
book.edit("series", "Deep Space")
self.assertEquals(series, book.series)
book.edit("genre", "SciFi")
self.assertEquals(2, book.genres.count())
self.assertEquals("Romance", book.genres.first().name)
self.assertEquals("SciFi", book.genres.last().name)
book.edit("genre", "1")
self.assertEquals(1, book.genres.count())
self.assertEquals("SciFi", book.genres.first().name)
book.edit("link", "https://deep.space")
self.assertEquals(1, book.links.count())
self.assertEquals("https://deep.space", book.links.first().link)
book.edit("link", "https://janedo.com/test2book")
self.assertEquals(2, book.links.count())
self.assertEquals("https://janedo.com/test2book",
book.links.last().link)
book.edit("link", "https://deep.space")
self.assertEquals(1, book.links.count())
self.assertEquals("https://janedo.com/test2book",
book.links.first().link)
def post_create(request):
form = PostForm()
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
post.score += 1 # self upvote
post.save()
# request.user.upvoted.add(post)
# Add tags
tags = request.POST.get('tags')
if tags:
tags = tags.split(",")
for tag in tags:
title = tag.strip()
slug = slugify(title)
# Get tag by slug. Create tag if it doesn't exist.
try:
tag = Tag.objects.get(slug=slug)
except:
tag = Tag.objects.create(title=tag)
post.tags.add(tag)
# Add category
category = request.POST.get('post_category')
if category:
category = Category.objects.get(slug=category)
post.category = category
# Add series
series = request.GET.get('series')
if series == "new":
# If I'm being sent from a post that doesn't have series
# (by clicking "Add Chapter")
# I create series
first_chapter = Post.objects.get(slug=request.GET.get('post'))
series_title = first_chapter.body.splitlines()[0][:100]
series = Series(slug=first_chapter.slug, title=series_title)
series.save()
# Add the original post to it
first_chapter.series = series
first_chapter.save()
# Add the post I've just created to it
post.series = series
elif series:
series = Series.objects.get(pk=series)
post.series = series
post.save()
wordcount = len(re.findall(r'\w+', post.body))
update_wordcount(wordcount, post.author)
# post.hubs.add(*form.cleaned_data['tags'])
# hubs = post.hubs.all()
return HttpResponseRedirect('/post/' + post.slug + '/edit')
else:
form = PostForm()
categories = Category.objects.all()
today = time.strftime("%Y-%m-%d")
if today in request.user.calendar:
wordcount = eval(request.user.calendar)[today]
else:
wordcount = 0
return render(request, 'posts/edit.html', {
'form': form,
'wordcount': wordcount,
'categories': categories
})
def post_create(request):
form = PostForm()
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
post.score += 1 # self upvote
post.save()
# request.user.upvoted.add(post)
# Add tags
tags = request.POST.get('tags')
if tags:
tags = tags.split(",")
for tag in tags:
title = tag.strip()
slug = slugify(title)
# Get tag by slug. Create tag if it doesn't exist.
try:
tag = Tag.objects.get(slug=slug)
except:
tag = Tag.objects.create(title=tag)
post.tags.add(tag)
# Add category
category = request.POST.get('post_category')
if category:
category = Category.objects.get(slug=category)
post.category = category
# Add series
series = request.GET.get('series')
if series == "new":
# If I'm being sent from a post that doesn't have series
# (by clicking "Add Chapter")
# I create series
first_chapter = Post.objects.get(slug=request.GET.get('post'))
series_title = first_chapter.body.splitlines()[0][:100]
series = Series(slug = first_chapter.slug, title = series_title)
series.save()
# Add the original post to it
first_chapter.series = series
first_chapter.save()
# Add the post I've just created to it
post.series = series
elif series:
series = Series.objects.get(pk=series)
post.series = series
post.save()
wordcount = len(re.findall(r'\w+', post.body))
update_wordcount(wordcount, post.author)
# post.hubs.add(*form.cleaned_data['tags'])
# hubs = post.hubs.all()
return HttpResponseRedirect('/post/'+post.slug+'/edit')
else:
form = PostForm()
categories = Category.objects.all()
today = time.strftime("%Y-%m-%d")
if today in request.user.calendar:
wordcount = eval(request.user.calendar)[today]
else:
wordcount = 0
return render(request, 'posts/edit.html', {
'form':form,
'wordcount':wordcount,
'categories': categories
})
def _book(args: Namespace, file: TextIO = sys.stdout):
book: Optional[Book] = None
if args.subparser == "add":
book, created = Book.from_dict({
"title":
args.title,
"authors":
[Person.get_or_create(author).to_dict() for author in args.author],
"series":
Series.get_or_create(args.series).to_dict()
if args.series else None,
"volume":
args.volume,
"genres":
[Genre.get_or_create(genre).to_dict() for genre in args.genre],
"links":
[Link.get_or_create(link).to_dict() for link in args.link],
})
if created:
stdout.write(
_('Successfully added book "%(title)s" with id "%(pk)d".') % {
"title": book.title,
"pk": book.pk
},
"=",
file=file,
)
book.print(file)
else:
stdout.write(
_('The book "%(title)s" already exists with id "%(pk)d", aborting...'
) % {
"title": book.title,
"pk": book.pk
},
"",
file=file,
)
elif args.subparser == "delete":
book = Book.get(args.book)
if book:
book.delete()
stdout.write(
_('Successfully deleted book "%(title)s" with id "%(pk)d".') %
{
"title": book.title,
"pk": book.pk
},
"",
file=file,
)
else:
stdout.write(_("No book found."), "", file=file)
elif args.subparser == "edit":
book = Book.get(args.book)
if book:
book.edit(args.edit_subparser, args.value)
stdout.write(
_('Successfully edited book "%(title)s" with id "%(pk)d".') % {
"title": book.title,
"pk": book.pk
},
"=",
file=file,
)
book.print(file)
else:
stdout.write(_("No book found."), "", file=file)
elif args.subparser == "edition":
book = Book.get(args.book)
if book:
if args.edition_subparser == "acquisition" and book:
edition = Edition.get(args.edition, book)
acquisition: Optional[Acquisition] = None
if args.acquisition_subparser == "add" and edition:
acquisition, created = Acquisition.from_dict(
{
"date": args.date,
"price": args.price
}, edition)
if created:
stdout.write(
_('Successfully added acquisition with id "%(pk)d".'
) % {"pk": acquisition.pk},
"=",
file=file,
)
else:
stdout.write(
_('The acquisition already exists with id "%(pk)d".'
) % {"pk": acquisition.pk},
"",
file=file,
)
acquisition.print(file)
elif args.acquisition_subparser == "delete" and edition:
acquisition = Acquisition.get(args.acquisition,
editions=edition)
if acquisition:
acquisition.delete(acquisition)
stdout.write(
_('Successfully deleted acquisition with id "%(pk)d".'
) % {"pk": acquisition.pk},
"",
file=file,
)
else:
stdout.write(_("No acquisition found."), "", file=file)
elif args.acquisition_subparser == "edit" and edition:
acquisition = Acquisition.get(args.acquisition,
editions=edition)
if acquisition:
acquisition.edit(args.field, args.value)
stdout.write(
_('Successfully edited acquisition with id "%(pk)d".'
) % {"pk": acquisition.pk},
"=",
file=file,
)
acquisition.print(file)
else:
stdout.write(_("No acquisition found."), "", file=file)
else:
stdout.write([_("No edition found.")], "", file=file)
elif args.edition_subparser == "add" and book:
edition, created = Edition.from_dict(
{
"alternate_title":
args.alternate_title,
"isbn":
args.isbn,
"publishing_date":
args.publishing_date,
"cover":
args.cover,
"binding":
Binding.get_or_create(args.binding).to_dict()
if args.binding else None,
"publisher":
Publisher.get_or_create(args.publisher).to_dict()
if args.publisher else None,
"persons": [
Person.get_or_create(person).to_dict()
for person in args.person
],
"languages": [
Language.get_or_create(language).to_dict()
for language in args.language
],
"links": [
Link.get_or_create(link).to_dict()
for link in args.link
],
"files": [{
"path": file
} for file in args.file],
},
book,
)
if created:
stdout.write(
_('Successfully added edition "%(edition)s" with id "%(pk)d".'
) % {
"edition": edition,
"pk": edition.pk
},
"=",
file=file,
)
edition.print(file)
else:
stdout.write(
_('The edition "%(edition)s" already exists with id "%(pk)d",'
+ " aborting...") % {
"edition": edition,
"pk": edition.pk
},
"",
file=file,
)
elif args.edition_subparser == "edit" and book:
edition = Edition.get(args.edition, book)
if edition:
edition.edit(args.edit_subparser, args.value)
stdout.write(
_('Successfully edited edition "%(edition)s" with id "%(pk)d".'
) % {
"edition": edition,
"pk": edition.pk
},
"=",
file=file,
)
edition.print(file)
else:
stdout.write(_("No edition found."), "", file=file)
elif args.edition_subparser == "info" and book:
edition = Edition.get(args.edition, book)
if edition:
edition.print(file)
else:
stdout.write(_("No edition found."), "", file=file)
elif args.edition_subparser == "list" and book:
if args.shelf:
editions = Edition.list.by_shelf(args.shelf, book)
elif args.search:
editions = Edition.list.by_term(args.search, book)
else:
editions = Edition.objects.filter(book=book)
stdout.write(
[
_("Id"),
_("Title"),
_("Binding"),
_("ISBN"),
_("Publishing date"),
],
"=",
[0.05, 0.55, 0.7, 0.85],
file=file,
)
for i, has_next in lookahead(editions):
stdout.write(
[
i.pk,
i.get_title(), i.binding, i.isbn, i.publishing_date
],
"_" if has_next else "=",
[0.05, 0.55, 0.7, 0.85],
file=file,
)
elif args.edition_subparser == "open" and book:
edition = Edition.get(args.edition, book)
if edition:
edition_file = edition.files.get(pk=args.file)
path = settings.MEDIA_ROOT / edition_file.file.path
if sys.platform == "linux":
os.system(f'xdg-open "{path}"')
else:
os.system(f'open "{path}"')
else:
stdout.write(_("No edition found."), "", file=file)
elif args.edition_subparser == "read" and book:
edition = Edition.get(args.edition, book)
read: Optional[Read] = None
if args.read_subparser == "add" and edition:
read, created = Read.from_dict(
{
"started": args.started,
"finished": args.finished
}, edition)
if created:
stdout.write(
_('Successfully added read with id "%(pk)d".') %
{"pk": read.pk},
"=",
file=file,
)
else:
stdout.write(
_('The read already exists with id "%(pk)d".') %
{"pk": read.pk},
"",
file=file,
)
read.print(file)
elif args.read_subparser == "delete" and edition:
read = Read.get(args.read, editions=edition)
if read:
read.delete()
stdout.write(
_('Successfully deleted read with id "%(pk)d".') %
{"pk": read.pk},
"",
file=file,
)
else:
stdout.write(_("No read found."), "", file=file)
elif args.read_subparser == "edit" and edition:
read = Read.get(args.read, editions=edition)
if read:
read.edit(args.field, args.value)
stdout.write(
_('Successfully edited read with id "%(pk)d".') %
{"pk": read.pk},
"=",
file=file,
)
read.info(file)
else:
stdout.write(_("No read found."), "", file=file)
else:
stdout.write(_("No edition found."), "", file=file)
else:
stdout.write(_("No book found."), "", file=file)
elif args.subparser == "info":
book = Book.get(args.book)
if book:
book.print(file)
else:
stdout.write(_("No book found."), "", file=file)
elif args.subparser == "list":
if args.search:
books = Book.search(args.search)
elif args.shelf:
books = Book.by_shelf(args.shelf)
else:
books = Book.objects.all()
stdout.write(
[_("Id"), ("Title"),
_("Authors"),
_("Series"),
_("Volume")],
"=",
[0.05, 0.5, 0.75, 0.9],
file=file,
)
for i, has_next in lookahead(books):
stdout.write(
[
i.pk,
i.title,
" ,".join(f"{a}" for a in i.authors.all()),
i.series.name if i.series else "",
i.volume,
],
"_" if has_next else "=",
[0.05, 0.5, 0.75, 0.9],
file=file,
)
def import_from_litres(hour=23, minutes=59):
image_template = 'https://partnersdnld.litres.ru/static/bookimages/{0}/{1}/{2}/{3}.bin.dir/{3}.cover.{4}'
d = datetime.date.today()
api = LitresApi(secret_key='D7psdo2s*Xjsoq3WdsoSWWvoo', partner_id='YABK')
lazy_books = api.get_fresh_book(
start_date=datetime.datetime(d.year, d.month, d.day - 1, 0, 0),
end_date=datetime.datetime(d.year, d.month, d.day - 1, hour, minutes))
for lazy_book in lazy_books:
if lazy_book.get('@lang') == 'ru':
litres_id = lazy_book.get('@id')
litres_file_id = lazy_book.get('@file_id')
litres_book = lazy_book.get('title-info')
litres_authors = litres_book.get('author')
litres_genres = lazy_book.get('genres')
litres_series = lazy_book.get('sequences')
title = litres_book.get('book-title')
description = litres_book.get('annotation')
age = lazy_book.get('@adult')
try:
publish_info = lazy_book.get('publish-info')
if publish_info:
year = publish_info.get('year', 0)
isbn = publish_info.get('isbn', '').replace('-', '')
else:
date = litres_book.get('date', 0)
if type(date) is str:
year = date
elif type(date) is list:
if date.get('#text'):
year = date.get('#text', 0)
if lazy_book.get('@isbn'):
isbn = lazy_book.get('@isbn', '').replace('-', '')
else:
isbn = lazy_book.get('@litres_isbn',
'').replace('-', '')
except Exception as e:
print('Exception {}'.format(e))
print(json.dumps(lazy_book, indent=4, ensure_ascii=False))
ext = lazy_book.get('@cover')
rating = decimal.Decimal(lazy_book.get('@rating', 0))
# Импорт автора
libs_authors = []
for litres_author in litres_authors:
try:
author = Author.objects.get(
litres_id=litres_author.get('id'))
libs_authors.append(author.id)
except Author.DoesNotExist:
fi = "{} {}".format(litres_author.get('last-name'),
litres_author.get('first-name'))
fi = fi.replace('None', '').strip()
authors = Author.objects.filter(name__icontains=fi)
if len(authors) == 1:
author = authors[0]
libs_authors.append(author.id)
author.litres_id = litres_author.get('id')
author.save(update_fields=['litres_id'])
print("Обновил litres_id для автора {} {}".format(
author.id, author.name))
elif len(authors) > 1:
print("Множество совпадений авторов {} для книги {}".
format(litres_authors, litres_book))
else:
fi = "{} {}".format(litres_author.get('first-name'),
litres_author.get('last-name'))
fi = fi.replace('None', '').strip()
authors = Author.objects.filter(name__icontains=fi)
if len(authors) == 1:
author = authors[0]
libs_authors.append(author.id)
author.litres_id = litres_author.get('id')
author.save(update_fields=['litres_id'])
print("Обновил litres_id для автора {} {}".format(
author.id, author.name))
elif len(authors) > 1:
print(
"Множество совпадений авторов {} для книги {}".
format(litres_authors, litres_book))
else:
# Добавляет нового автора
fi = "{} {}".format(
litres_author.get('last-name'),
litres_author.get('first-name'))
fio = "{} {} {}".format(
litres_author.get('last-name', ''),
litres_author.get('first-name', ''),
litres_author.get('middle-name', ''))
author = Author(
name=fi.replace('None', '').strip(),
litres_name=fio.replace('None', '').strip(),
)
author.save()
libs_authors.append(author.id)
# Опрееление жанра
libs_genres = []
if litres_genres:
litres_genres = litres_genres['genre']
for litres_genre in litres_genres:
genres_new = GenreNew.objects.filter(
genre_litres__icontains=litres_genre['@id'])
for genre_new in genres_new:
libs_genres.append(genre_new.id)
if not len(genres_new):
print("Жанр {} {} не найден".format(
litres_genre['@title'], litres_genre['@id']))
# Если есть серия
libs_series = None
if litres_series:
litres_series = litres_series.get('sequence')[0]
try:
# Проверяет по id
libs_series = Series.objects.get(
litres_id=litres_series['@uuid'])
except Series.DoesNotExist:
try:
# проверяет по названию
libs_series = Series.objects.get(
title=litres_series['@name'])
libs_series.litres_id = litres_series['@uuid']
libs_series.save(update_fields=['litres_id'])
print("Обновил litres_id для серии {} {}".format(
libs_series.id, libs_series.title))
except Series.MultipleObjectsReturned:
print("Задвоилась серия {} {}".format(
libs_series.id, libs_series.title))
except Series.DoesNotExist:
# Добавляет новую серию
libs_series = Series(title=litres_series['@name'],
litres_id=litres_series['@uuid'])
libs_series.save()
# Ипорт книги
try:
book = Book.objects.get(litres_id=litres_id)
except Book.MultipleObjectsReturned:
print("Затроило книги litres_id {} isbn {}".format(
litres_id, isbn))
except Book.DoesNotExist:
# Проверяет по isbn
try:
if len(isbn):
book = Book.objects.get(isbn=isbn)
book.litres_id = litres_id
book.save(update_fields=['litres_id'])
print("Обновил litres_id для книги {} {}".format(
book.id, book.title))
else:
print("Пустой isbn litres_id {} isbn {}".format(
litres_id, isbn))
except Book.MultipleObjectsReturned:
print("Затроило книги litres_id {} isbn {}".format(
litres_id, isbn))
except Book.DoesNotExist:
# Проверяет совпадение по назанию
if title and litres_author.get('last-name'):
book = Book.objects.filter(
title__icontains=title,
author__name__icontains=litres_author.get(
'last-name'))
if len(book) == 1:
b = book[0]
b.litres_id = litres_id
b.isbn = isbn
b.save(update_fields=['litres_id', 'isbn'])
print("Обновил litres_id и isbn для книги {} {}".
format(b.id, b.title))
elif len(book) > 1:
print("Множество совпадений c книгой {}".format(
litres_book))
else:
litres_file_id_str = "{0:08d}".format(
int(litres_file_id))
xx = litres_file_id_str[0:2]
yy = litres_file_id_str[2:4]
zz = litres_file_id_str[4:6]
image = image_template.format(
xx, yy, zz, litres_file_id, ext)
if rating >= 4:
rating = 4
book = Book(title=title,
description=description,
age=age,
year=year,
isbn=isbn,
litres_id=litres_id,
image=image,
rating=rating)
if decimal.Decimal(rating) > 0:
book.rating_partner_votes = 1
if libs_series:
book.series = libs_series
try:
book.save()
except decimal.InvalidOperation:
book.rating = 0
book.save()
book.genre_new.set(libs_genres)
book.author.set(libs_authors)
# Find parent
for p in posts:
if p["pk"] == post["fields"]["parent"]:
parent = p
# Modify slug to parent-slug-chapter-slug.
slug = parent["fields"]["slug"] + "-" + slug
# Create series for a parent
series_title = parent["fields"]["title"]
series_slug = parent["fields"]["slug"]
# Get or create series
try:
series = Series.objects.get(slug=series_slug)
except:
series = Series(title=series_title, slug=series_slug)
series.save()
# If the story is a parent, find series with matching slug and add it to it.
try:
series = Series.objects.get(slug=slug)
except:
pass
try:
# Check if post already exists
post = Post.objects.get(slug=slug)
# On a second run, making sure to add series to parent posts
post.series = series
post.save()
except:
# Create post if it doesnt exist yet
