def test_delete(self):
publisher, created = Publisher.from_dict({"name": "Publishing House"})
self.assertTrue(created)
self.assertIsNotNone(publisher.id)
deleted = publisher.delete()
self.assertIsNone(publisher.id)
self.assertEquals((1, {"publishers.Publisher": 1}), deleted)
publisher, created = Publisher.from_dict({
"name":
"Publishing House",
"links": [{
"url": "https://publishing.house"
}]
})
self.assertTrue(created)
self.assertIsNotNone(publisher.id)
deleted = publisher.delete()
self.assertIsNone(publisher.id)
self.assertEquals(
(
3,
{
"publishers.Publisher": 1,
"publishers.Publisher_links": 1,
"links.Link": 1,
},
),
deleted,
)
def test_search(self):
publisher, created = Publisher.from_dict({"name": "Publishing House"})
self.assertTrue(created)
self.assertIsNotNone(publisher.id)
publisher, created = Publisher.from_dict({"name": "Old House"})
self.assertTrue(created)
self.assertIsNotNone(publisher.id)
publisher, created = Publisher.from_dict({"name": "Publishing Press"})
self.assertTrue(created)
self.assertIsNotNone(publisher.id)
self.assertEquals(3, Publisher.objects.all().count())
self.assertEquals(2, Publisher.search("pub").count())
self.assertEquals(2, Publisher.search("House").count())
def test_from_to_dict(self):
link, created = Link.objects.get_or_create(link="https://press.org")
self.assertTrue(created)
self.assertIsNotNone(link.id)
publisher, created = Publisher.objects.get_or_create(name="Test Press")
publisher.links.add(link)
self.assertTrue(created)
self.assertIsNotNone(publisher.id)
self.assertEquals(
{
"name": "Test Press",
"links": [{
"url": "https://press.org"
}]
},
publisher.to_dict(),
)
self.assertEquals(
(publisher, False),
Publisher.from_dict({
"name": "Test Press",
"links": [{
"url": "https://press.org"
}]
}),
)
self.assertEquals((publisher, False),
Publisher.from_dict({"name": "Test Press"}))
publisher, created = Publisher.objects.get_or_create(
name="Random Press")
self.assertTrue(created)
self.assertIsNotNone(publisher.id)
self.assertEquals({
"name": "Random Press",
"links": None
}, publisher.to_dict())
self.assertEquals(
(publisher, False),
Publisher.from_dict({
"name": "Random Press",
"links": None
}),
)
self.assertEquals((publisher, False),
Publisher.from_dict({"name": "Random Press"}))
def from_dict(cls: Type[T], data: Dict, book: Book) -> Tuple[T, bool]:
"""Create from dict.
Returns True if was crated, i. e. was not found in the DB.
"""
defaults: Dict = {}
if "alternate_title" in data and data["alternate_title"]:
defaults["alternate_title"] = data["alternate_title"]
if "isbn" in data and data["isbn"]:
defaults["isbn"] = data["isbn"]
if "publishing_date" in data and data["publishing_date"]:
defaults["publishing_date"] = datetime.datetime.strptime(
data["publishing_date"], "%Y-%m-%d").date()
if "publisher" in data and data["publisher"]:
defaults["publisher"] = Publisher.from_dict(data["publisher"])[0]
if "binding" in data and data["binding"]:
defaults["binding"] = Binding.from_dict(data["binding"])[0]
if "bibtex" in data and data["bibtex"]:
defaults["bibtex"] = data["bibtex"]
edition, created = cls.objects.get_or_create(
book=book,
alternate_title=data["alternate_title"]
if "alternate_title" in data else None,
isbn=data["isbn"] if "isbn" in data else None,
publishing_date=data["publishing_date"]
if "publishing_date" in data else None,
defaults=defaults,
)
if "cover_image" in data and data["cover_image"]:
edition.cover_image.save(
os.path.basename(data["cover_image"]),
DJFile(open(data["cover_image"], "rb")),
)
if "languages" in data and data["languages"]:
for i in data["languages"]:
edition.languages.add(Language.from_dict(i)[0])
if "links" in data and data["links"]:
for i in data["links"]:
edition.links.add(Link.from_dict(i)[0])
if "persons" in data and data["persons"]:
for i in data["persons"]:
edition.persons.add(Person.from_dict(i)[0])
if "acquisitions" in data and data["acquisitions"]:
for i in data["acquisitions"]:
Acquisition.from_dict(i, edition)
if "files" in data and data["files"]:
for i in data["files"]:
File.from_dict(i, edition)
if "reads" in data and data["reads"]:
for i in data["reads"]:
Read.from_dict(i, edition)
edition.save()
return edition, created
def test_get(self):
publisher, created = Publisher.from_dict({"name": "Publishing House"})
self.assertTrue(created)
self.assertIsNotNone(publisher.id)
publisher2 = Publisher.get("Publishing House")
self.assertIsNotNone(publisher2)
self.assertEquals(publisher, publisher2)
publisher2 = Publisher.get("house")
self.assertIsNotNone(publisher2)
self.assertEquals(publisher, publisher2)
publisher2 = Publisher.get(str(publisher.id))
self.assertIsNotNone(publisher2)
self.assertEquals(publisher, publisher2)
def test_get_or_create(self):
publisher, created = Publisher.from_dict({"name": "Publishing House"})
self.assertTrue(created)
self.assertIsNotNone(publisher.id)
self.assertEquals(1, Publisher.objects.count())
publisher2 = Publisher.get_or_create("Publishing House")
self.assertIsNotNone(publisher2)
self.assertEquals(publisher, publisher2)
self.assertEquals(1, Publisher.objects.count())
publisher2 = Publisher.get_or_create(str(publisher.id))
self.assertIsNotNone(publisher2)
self.assertEquals(publisher, publisher2)
self.assertEquals(1, Publisher.objects.count())
publisher2 = Publisher.get_or_create("Old House")
self.assertIsNotNone(publisher2)
self.assertNotEquals(publisher, publisher2)
self.assertEquals(2, Publisher.objects.count())
def test_print(self):
publisher, created = Publisher.from_dict({"name": "Publishing House"})
self.assertTrue(created)
self.assertIsNotNone(publisher.id)
with StringIO() as cout:
publisher.print(cout)
self.assertEquals(
"Field Value "
+
" \n=================================="
+
"==================================================================\n"
+
"Id 1 "
+
" \n__________________________________"
+
"__________________________________________________________________\n"
+
"Name Publishing House "
+
" \n__________________________________"
+
"__________________________________________________________________\n"
+
"Links "
+
" \n__________________________________"
+
"__________________________________________________________________\n"
+
"Editions "
+
" \n__________________________________"
+
"__________________________________________________________________\n",
cout.getvalue(),
)
def _publisher(args: Namespace, file: TextIO = sys.stdout):
publisher: Optional[Publisher] = None
if args.subparser == "add":
publisher, created = Publisher.from_dict({
"name":
args.name,
"links":
[Link.get_or_create(link).to_dict() for link in args.link],
})
if created:
stdout.write(
_('Successfully added publisher "%(name)s" with id "%(pk)d".')
% {
"name": publisher.name,
"pk": publisher.pk
},
"=",
file=file,
)
publisher.print(file)
else:
stdout.write(
_('The publisher "%(name)s" already exists with id "%(pk)d", '
+ "aborting...") % {
"name": publisher.name,
"pk": publisher.pk
},
"",
file=file,
)
elif args.subparser == "delete":
publisher = Publisher.get(args.publisher)
if publisher:
publisher.delete()
stdout.write(
_('Successfully deleted publisher with id "%(pk)d".') %
{"pk": publisher.pk},
"",
file=file,
)
else:
stdout.write(_("No publisher found."), "", file=file)
elif args.subparser == "edit":
publisher = Publisher.get(args.publisher)
if publisher:
publisher.edit(args.field, args.value)
stdout.write(
_('Successfully edited publisher "%(name)s" with id "%(pk)d".')
% {
"name": publisher.name,
"pk": publisher.pk
},
"",
file=file,
)
publisher.print(file)
else:
stdout.write(_("No publisher found."), "", file=file)
elif args.subparser == "info":
publisher = Publisher.get(args.publisher)
if publisher:
publisher.print(file)
else:
stdout.write(_("No publisher found."), "", file=file)
elif args.subparser == "list":
if args.search:
publishers = Publisher.search(args.search)
else:
publishers = Publisher.objects.all()
stdout.write(
[_("Id"), _("Name"), _("Number of editions")],
"=", [0.05, 0.8],
file=file)
for i, has_next in lookahead(publishers):
stdout.write(
[i.id, i.name, i.editions.count()],
"_" if has_next else "=",
[0.05, 0.8],
file=file,
)
