def update_persons(self, start, batch_size = 100, verbosity = 1):
'''Updates persons from etvnet.'''
cred = Credentials(ETVNET_PERSONS_PUBLIC_KEY, ETVNET_PERSONS_PRIVATE_KEY)
conn = etvIntegrationConnection(cred, ETVNET_PERSONS_ENDPOINT)
result = conn.make_request(
'GET', '/integration/person_list.json', args={'start': start, 'batch_size': batch_size, 'type': 'person'}
)
data = simplejson.load(result)
result = None
if data:
for p in data:
try:
person = Person.objects.get(external_ident=p.get('id'))
except Person.DoesNotExist:
person = Person(external_ident=p.get('id'))
person.first_name = p.get('first_name')
person.last_name = p.get('last_name')
person.name = p.get('name')
person.birthday = p.get('birthday')
person.death = p.get('death')
person.is_available = p.get('is_approved')
person.updated = result = p.get('updated')
person.url = p.get('url')
if verbosity >= 2:
print(
"id: %s name: %s (%s)" \
% (p.get('id'), p.get('name').encode('utf-8'), person.pk and 'updated' or 'created'))
person.save()
return result
class sPerson:
def __init__(self, surname, name, gender, pseudonym, birth_year,
death_year):
self.last_name = surname
self.first_name = name
self.gender = gender
self.pseudonym = pseudonym
self.birth_year = birth_year
self.death_year = death_year
try:
self.instance = Person.objects.get(first_name=self.first_name,
last_name=self.last_name,
birth_year=birth_year)
self.load = True
except:
self.instance = Person(first_name=self.first_name,
last_name=self.last_name,
birth_year=birth_year)
self.load = False
self.instance.save()
def __repr__(self):
m = str(self.first_name) + ' | ' + str(self.last_name) + ' | ' + str(
self.gender)
m += ' | ' + str(self.pseudonym)
return m
def __eq__(self, other):
return self.__dict__ == other.__dict__
def test_delete(self):
person, created = Person.from_dict({"name": "Hans Müller"})
self.assertTrue(created)
self.assertIsNotNone(person.id)
deleted = person.delete()
self.assertIsNone(person.id)
self.assertEquals((1, {"persons.Person": 1}), deleted)
person, created = Person.from_dict({
"name":
"Hans Müller",
"links": [{
"url": "https://hans-mueller.de"
}]
})
self.assertTrue(created)
self.assertIsNotNone(person.id)
deleted = person.delete()
self.assertIsNone(person.id)
self.assertEquals(
(3, {
"persons.Person": 1,
"persons.Person_links": 1,
"links.Link": 1
}),
deleted,
)
def manage_persons(request):
persons = Person.objects.all()
form_data = request.POST if request.POST else None
if form_data: # debug info
print(form_data) # POST data (for debug)
form_add = AddPersonForm(form_data)
if form_add.is_valid():
new_person = Person(
short_name=form_data.get('short_name'),
full_name=form_data.get('full_name'),
email=form_data.get('email')
)
new_person.save() # write new row to DB
return redirect('/persons/')
form_rem = RemovePersonForm(form_data)
if form_rem.is_valid():
persons_to_be_removed = Person.objects.filter(
short_name__icontains=form_data.get('short_name_substr'))
persons_to_be_removed.delete() # delete row from DB
return redirect('/persons/')
t = loader.get_template('manage.html')
return HttpResponse(t.render(RequestContext(request,
{'form_add' : form_add,
'form_rem' : form_rem,
'persons_count' : len(persons),}
)))
def _person_by_cnd(self, cnd):
''' use the mk_id (if there) or the name to return the person '''
if cnd.mk_id:
try:
return Person.objects.get(mk_id = cnd.mk_id)
except Person.DoesNotExist:
pass
try:
return Person.objects.get_by_name(cnd.name)
except Person.DoesNotExist:
person = Person(name = cnd.name)
if cnd.mk_id:
person.mk_id = mk_id
person.save()
def register(request):
form = UserCreationForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
form.save()
user = form.instance
user.backend = 'django.contrib.auth.backends.ModelBackend'
created_person = Person(user=user)
created_person.populate_notification_settings()
created_person.save()
login(request, user)
return redirect('/register_success/')
csrf(request)
return render(request, 'register.html', locals())
def _person_by_cnd(self, cnd):
''' use the mk_id (if there) or the name to return the person '''
if cnd.mk_id:
try:
return Person.objects.get(mk_id=cnd.mk_id)
except Person.DoesNotExist:
pass
try:
return Person.objects.get_by_name(cnd.name)
except Person.DoesNotExist:
person = Person(name=cnd.name)
if cnd.mk_id:
person.mk_id = mk_id
person.save()
def add_person(request):
if request.method != 'POST':
return HttpResponseBadRequest('You can only use POST')
else:
short_name = request.POST['name']
full_name = request.POST['full_name']
email = request.POST['email']
job = choice(Job.objects.all())
new_person = Person(short_name = short_name,
full_name = full_name,
email = email,
job = job)
new_person.save()
return HttpResponse('new person "%s" is added' %
Person.objects.get(short_name = short_name).short_name)
def add_person(request):
if request.method != 'POST':
return HttpResponseBadRequest('You can only use POST')
else:
short_name = request.POST['name']
full_name = request.POST['full_name']
email = request.POST['email']
job = choice(Job.objects.all())
new_person = Person(short_name=short_name,
full_name=full_name,
email=email,
job=job)
new_person.save()
return HttpResponse(
'new person "%s" is added' %
Person.objects.get(short_name=short_name).short_name)
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 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_get(self):
person, created = Person.from_dict({"name": "Hans Müller"})
self.assertTrue(created)
self.assertIsNotNone(person.id)
person2 = Person.get("Hans Müller")
self.assertIsNotNone(person2)
self.assertEquals(person, person2)
person2 = Person.get("müller")
self.assertIsNotNone(person2)
self.assertEquals(person, person2)
person2 = Person.get(str(person.id))
self.assertIsNotNone(person2)
self.assertEquals(person, person2)
def test_search(self):
person, created = Person.from_dict({"name": "Hans Müller"})
self.assertTrue(created)
self.assertIsNotNone(person.id)
person, created = Person.from_dict({"name": "Maria Müller"})
self.assertTrue(created)
self.assertIsNotNone(person.id)
person, created = Person.from_dict({"name": "Maria Vogel"})
self.assertTrue(created)
self.assertIsNotNone(person.id)
self.assertEquals(3, Person.objects.all().count())
self.assertEquals(2, Person.search("Maria").count())
self.assertEquals(2, Person.search("müller").count())
def test_save(self):
person = Person(name="Hans Müller")
person.save()
self.assertIsNotNone(person.id)
self.assertEquals("hans-muller", person.slug)
person = Person(name="J. T. Do")
person.save()
self.assertIsNotNone(person.id)
self.assertEquals("j-t-do", person.slug)
def test_from_to_dict(self):
link, created = Link.objects.get_or_create(
link="https://hans-mueller.de")
self.assertTrue(created)
self.assertIsNotNone(link.id)
person, created = Person.objects.get_or_create(name="Hans Müller")
person.links.add(link)
self.assertTrue(created)
self.assertIsNotNone(person.id)
self.assertEquals(
{
"name": "Hans Müller",
"links": [{
"url": "https://hans-mueller.de"
}]
},
person.to_dict(),
)
self.assertEquals(
(person, False),
Person.from_dict({
"name": "Hans Müller",
"links": [{
"url": "https://hans-mueller.de"
}]
}),
)
self.assertEquals((person, False),
Person.from_dict({"name": "Hans Müller"}))
person, created = Person.objects.get_or_create(name="Jane Bond")
self.assertTrue(created)
self.assertIsNotNone(person.id)
self.assertEquals({
"name": "Jane Bond",
"links": None
}, person.to_dict())
self.assertEquals((person, False),
Person.from_dict({
"name": "Jane Bond",
"links": None
}))
self.assertEquals((person, False),
Person.from_dict({"name": "Jane Bond"}))
def edit(self: T, field: str, value: str, *args, **kwargs):
"""Change field by given value."""
assert field in [
"alternate_title",
"alternate-title",
"binding",
"cover",
"isbn",
"person",
"publishing_date",
"publishing-date",
"publisher",
"language",
"link",
"file",
]
if field == "alternate_title" or field == "alternate-title":
self.alternate_title = value
elif field == "binding":
self.binding = Binding.get_or_create(value)
elif field == "cover":
self.cover_image.save(os.path.basename(str(value)),
DJFile(open(str(value), "rb")))
elif field == "isbn":
self.isbn = value
elif field == "person":
person = Person.get_or_create(value)
if self.persons.filter(pk=person.pk).exists():
self.persons.remove(person)
else:
self.persons.add(person)
elif field == "publishing_date" or field == "publishing-date":
self.publishing_date = value
elif field == "publisher":
self.publisher = Publisher.get_or_create(value)
elif field == "language":
language = Language.get_or_create(value)
if self.languages.filter(pk=language.pk).exists():
self.languages.remove(language)
else:
self.languages.add(language)
elif field == "link":
link = Link.get_or_create(value)
if self.links.filter(pk=link.pk).exists():
self.links.remove(link)
else:
self.links.add(link)
elif field == "file":
file, created = File.from_dict({"path": value})
if self.files.filter(pk=file.pk).exists():
self.files.remove(file)
file.delete()
else:
self.files.add(file)
self.save(*args, **kwargs)
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 __init__(self, surname, name, gender, pseudonym, birth_year,
death_year):
self.last_name = surname
self.first_name = name
self.gender = gender
self.pseudonym = pseudonym
self.birth_year = birth_year
self.death_year = death_year
try:
self.instance = Person.objects.get(first_name=self.first_name,
last_name=self.last_name,
birth_year=birth_year)
self.load = True
except:
self.instance = Person(first_name=self.first_name,
last_name=self.last_name,
birth_year=birth_year)
self.load = False
self.instance.save()
def test_get_or_create(self):
person, created = Person.from_dict({"name": "Hans Müller"})
self.assertTrue(created)
self.assertIsNotNone(person.id)
self.assertEquals(1, Person.objects.count())
person2 = Person.get_or_create("Hans Müller")
self.assertIsNotNone(person2)
self.assertEquals(person, person2)
self.assertEquals(1, Person.objects.count())
person2 = Person.get_or_create(str(person.id))
self.assertIsNotNone(person2)
self.assertEquals(person, person2)
self.assertEquals(1, Person.objects.count())
person2 = Person.get_or_create("Franz Müller")
self.assertIsNotNone(person2)
self.assertNotEquals(person, person2)
self.assertEquals(2, Person.objects.count())
def edit(self: T, field: str, value: Union[str, datetime.date], *args,
**kwargs):
"""Change field by given value."""
fields = [
"title",
"author",
"publishing_date",
"publishing-date",
"journal",
"volume",
"language",
"file",
"link",
"bibtex",
]
assert field in fields
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 == "publishing_date" or field == "publishing-date":
self.publishing_date = value
elif field == "journal" and isinstance(value, str):
self.journal = Journal.get_or_create(value)
elif field == "volume":
self.volume = value
elif field == "bibtex":
self.bibtex = value
elif field == "language" and isinstance(value, str):
language = Language.get_or_create(value)
if self.languages.filter(pk=language.pk).exists():
self.languages.remove(language)
else:
self.languages.add(language)
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)
elif field == "file":
file, created = File.from_dict({"path": value})
if self.files.filter(pk=file.pk).exists():
self.files.remove(file)
file.delete()
else:
self.files.add(file)
self.save(*args, **kwargs)
def test_print(self):
person, created = Person.from_dict({"name": "Hans Müller"})
self.assertTrue(created)
self.assertIsNotNone(person.id)
with StringIO() as cout:
person.print(cout)
self.assertEquals(
"Field Value "
+
" \n=================================="
+
"==================================================================\n"
+
"Id 1 "
+
" \n__________________________________"
+
"__________________________________________________________________\n"
+
"Name Hans Müller "
+
" \n__________________________________"
+
"__________________________________________________________________\n"
+
"Links "
+
" \n__________________________________"
+
"__________________________________________________________________\n"
+
"Books "
+
" \n__________________________________"
+
"__________________________________________________________________\n"
+
"Editions "
+
" \n__________________________________"
+
"__________________________________________________________________\n"
+
"Papers "
+
" \n__________________________________"
+
"__________________________________________________________________\n",
cout.getvalue(),
)
def make_persons(filename_text='data/Person.xlsx'):
d = pd.read_excel(filename_text)
o = []
for line in d.values:
p_id, lname, fname, func, pseud, sex, dob, dod, pob, pod, res, trav, ac, notes = line
if type(lname) == type(fname) == float: continue
print(lname, fname)
pseud = extract_names(pseud)
pseuds = [
load_model_instance(x, 'Pseudonym', 'persons') for x in pseud
]
by, dy = extract_number(dob), extract_number(dod)
o = Person(first_name=_ms(fname),
last_name=_ms(lname),
sex=set_sex(sex),
birth_year=by,
death_year=dy,
notes=_ms(notes))
s, a, e = save_model([o], 'Persons', verbose=False)
if len(s) != 1: continue
[o.pseudonym.add(pseud) for pseud in pseuds]
o.save()
return o
def handle(self, *args, **options):
objs = [
Person(
name=item['name'],
last_name=item['last_name'],
phone_number=item['phone_number'],
address=item['address'],
) for item in self.people
]
Person.objects.bulk_create(objs)
self.stdout.write("successfully")
def index(request):
today = date.today()
sDate = str(today.year) + '-01-01'
eDate = str(today.year) + '-' + str(today.month) + '-' + str(today.day)
sM = 1
eM = today.month
if request.GET.get('range'):
dates = request.GET.get('range').split(sep=" - ")
sDate = dates[0]
eDate = dates[1]
sM = int(sDate.split('-')[1])
eM = int(eDate.split('-')[1])
if request.user.person:
person = request.user.person
else:
person = Person()
person.name = request.user.username
person.owner = request.user
person.save()
request.user.person = person
request.user.save()
months = []
for i in range(sM, eM + 1):
months.append(getMonthText(i))
# get working
wSales = graphWork(request, Sale, sDate, eDate, months)
wSalesReturns = graphWork(request, SalesReturn, sDate, eDate, months)
wPurchases = graphWork(request, Purchase, sDate, eDate, months)
wPurchasesReturns = graphWork(request, PurchasesReturn, sDate, eDate,
months)
wExpenses = graphWork(request, Expense, sDate, eDate, months)
args = {
'nav': 'charts',
'months': months,
'sales': wSales['list'],
'total_sales': wSales['total'],
'sales_returns': wSalesReturns['list'],
'total_sales_returns': wSalesReturns['total'],
'purchases': wPurchases['list'],
'total_purchases': wPurchases['total'],
'purchases_returns': wPurchasesReturns['list'],
'total_purchases_returns': wPurchasesReturns['total'],
'expenses': wExpenses['list'],
'total_expenses': wExpenses['total'],
'startDate': sDate,
'endDate': eDate,
'range': sDate + ' - ' + eDate,
}
return render(request, 'charts/index.html', args)
def after_user_activation(sender, user, request, **kwargs):
person = Person()
person.owner = user
person.name = user.username
person.save()
groups = Group.objects.all()
if groups:
for group in groups:
if group.name.find('Owner') != -1 or group.name.find('owner') != -1:
user.groups.add(group)
user.person = person
user.save()
def register(request):
form = UserCreationForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
form.save()
user = form.instance
user.backend = 'django.contrib.auth.backends.ModelBackend'
created_person = Person(user=user)
created_person.populate_notification_settings()
created_person.save()
login(request, user)
return redirect('/register_success/')
csrf(request)
return render(request, 'register.html', locals())
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 "journal" in data and data["journal"]:
defaults["journal"] = Journal.from_dict(data["journal"])[0]
if "volume" in data and data["volume"]:
defaults["volume"] = data["volume"]
if "publishing_date" in data and data["publishing_date"]:
defaults["publishing_date"] = datetime.datetime.strptime(
data["publishing_date"], "%Y-%m-%d").date()
if "bibtex" in data and data["bibtex"]:
defaults["bibtex"] = data["bibtex"]
paper, created = Paper.objects.get_or_create(title=data["title"],
defaults=defaults)
if "authors" in data and data["authors"]:
for i in data["authors"]:
paper.authors.add(Person.from_dict(i)[0])
if "languages" in data and data["languages"]:
for i in data["languages"]:
paper.languages.add(Language.from_dict(i)[0])
if "links" in data and data["links"]:
for i in data["links"]:
paper.links.add(Link.from_dict(i)[0])
if "acquisitions" in data and data["acquisitions"]:
for i in data["acquisitions"]:
Acquisition.from_dict(i, paper)
if "files" in data and data["files"]:
for i in data["files"]:
File.from_dict(i, paper)
if "reads" in data and data["reads"]:
for i in data["reads"]:
Read.from_dict(i, paper)
paper.save()
return paper, created
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 _paper(args: Namespace, file: TextIO = sys.stdout):
paper: Optional[Paper] = None
if args.subparser == "acquisition":
paper = Paper.get(args.paper)
acquisition: Optional[Acquisition] = None
if args.acquisition_subparser == "add" and paper:
acquisition, created = Acquisition.from_dict(
{
"date": args.date,
"price": args.price
}, paper)
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 paper:
acquisition = Acquisition.get(args.acquisition, papers=paper)
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 paper:
acquisition = Acquisition.get(args.acquisition, papers=paper)
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 paper found."), "", file=file)
elif args.subparser == "add":
paper, created = Paper.from_dict({
"title":
args.title,
"authors":
[Person.get_or_create(author).to_dict() for author in args.author],
"publishing_date":
args.publishing_date,
"journal":
Journal.get_or_create(args.journal).to_dict()
if args.journal else None,
"volume":
args.volume,
"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],
})
if created:
stdout.write(
_('Successfully added paper "%(title)s" with id "%(pk)d".') % {
"title": paper.title,
"pk": paper.pk
},
"=",
file=file,
)
else:
stdout.write(
_('The paper "%(title)s" already exists with id "%(pk)d".') % {
"title": paper.title,
"pk": paper.pk
},
"",
file=file,
)
paper.print(file)
elif args.subparser == "delete":
paper = Paper.get(args.paper)
if paper:
paper.delete()
stdout.write(
_('Successfully deleted paper with id "%(title)s".') %
{"title": paper.title},
"",
file=file,
)
else:
stdout.write(_("No paper found."), "", file=file)
elif args.subparser == "edit":
paper = Paper.get(args.paper)
if paper:
paper.edit(args.edit_subparser, args.value)
stdout.write(
_('Successfully edited paper "%(title)s" with id "%(pk)d".') %
{
"title": paper.title,
"pk": paper.pk
},
"",
file=file,
)
paper.print(file)
else:
stdout.write(_("No paper found."), "", file=file)
elif args.subparser == "info":
paper = Paper.get(args.paper)
if paper:
paper.print(file)
else:
stdout.write(_("No paper found."), "", file=file)
elif args.subparser == "list":
if args.search:
papers = Paper.search(args.search)
elif args.shelf:
papers = Paper.by_shelf(args.shelf)
else:
papers = Paper.objects.all()
stdout.write(
[_("Id"), _("Name"), _("Journal"),
_("Volume")],
"=",
[0.05, 0.7, 0.85],
file=file,
)
for i, has_next in lookahead(papers):
stdout.write(
[i.pk, i.name, i.journal.name, i.volume],
"_" if has_next else "=",
[0.05, 0.7, 0.85],
file=file,
)
elif args.subparser == "open":
paper = Paper.get(args.paper)
if paper:
paper_file = paper.files.get(pk=args.file)
path = settings.MEDIA_ROOT / paper_file.file.path
if sys.platform == "linux":
os.system(f'xdg-open "{path}"')
else:
os.system(f'open "{path}"')
else:
stdout.write(_("No paper found."), "", file=file)
elif args.subparser == "parse":
for paper, created in Paper.from_bibfile(args.bibfile, args.file):
if created:
stdout.write(
_('Successfully added paper "%(title)s" with id "%(pk)d".')
% {
"title": paper.title,
"pk": paper.pk
},
file=file,
)
if args.acquisition:
acquisition, created = Acquisition.from_dict(
{"date": datetime.date.today()}, paper)
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,
)
else:
stdout.write(
_('The paper "%(title)s" already exists with id "%(pk)d".')
% {
"title": paper.title,
"pk": paper.pk
},
"=",
file=file,
)
paper.print(file)
elif args.subparser == "read":
paper = Paper.get(args.paper)
read: Optional[Read] = None
if args.read_subparser == "add" and paper:
read, created = Read.from_dict(
{
"started": args.started,
"finished": args.finished
}, paper)
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 paper:
read = Read.get(args.read, papers=paper)
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 paper:
read = Read.get(args.read, papers=paper)
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 paper found."), "", file=file)
from sys import argv, path as sys_path
import os
from random import choice
import django
sys_path.append('..')
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "example.settings")
django.setup()
# actual import script:
from persons.models import Person
from jobs.models import Job
if __name__ == '__main__':
if len(argv) != 2:
print('USAGE: $ ./import.py /some/path/file.txt')
else:
imported_persons_count = 0
with open(argv[1], 'r') as input_file:
for line in input_file:
short, full, mail = line.split('\t')
job = choice(Job.objects.all())
person = Person(short_name=short,
full_name=full,
email=mail,
job=job)
person.save() # write new row to DB
imported_persons_count += 1
print('Imported %s persons.' % imported_persons_count)
def _person(args: Namespace, file: TextIO = sys.stdout):
person: Optional[Person] = None
if args.subparser == "add":
person, created = Person.from_dict(
{
"name": args.name,
"links": [Link.get_or_create(link).to_dict() for link in args.link],
}
)
if created:
stdout.write(
_('Successfully added person "%(name)s" with id "%(pk)d".')
% {"name": person.name, "pk": person.pk},
"=",
file=file,
)
person.print(file)
else:
stdout.write(
_('The person "%(name)s" already exists with id "%(pk)d", aborting...')
% {"name": person.name, "pk": person.pk},
"",
file=file,
)
elif args.subparser == "delete":
person = Person.get(args.person)
if person:
person.delete()
stdout.write(
_('Successfully deleted person with id "%(name)s".')
% {"name": person.name},
"",
file=file,
)
else:
stdout.write(_("No person found."), "", file=file)
elif args.subparser == "edit":
person = Person.get(args.person)
if person:
person.edit(args.field, args.value)
stdout.write(
_('Successfully edited person "%(name)s" with id "%(pk)d".')
% {"name": person.name, "pk": person.pk},
"",
file=file,
)
person.print(file)
else:
stdout.write(_("No person found."), "", file=file)
elif args.subparser == "info":
person = Person.get(args.person)
if person:
person.print(file)
else:
stdout.write(_("No person found."), "", file=file)
elif args.subparser == "list":
if args.search:
persons = Person.search(args.search)
else:
persons = Person.objects.all()
stdout.write(
[
_("Id"),
_("Name"),
_("Number of books"),
_("Number of editions"),
_("Number of papers"),
],
"=",
[0.05, 0.4, 0.6, 0.8],
file=file,
)
for i, has_next in lookahead(persons):
stdout.write(
[i.id, i.name, i.books.count(), i.editions.count(), i.papers.count()],
"_" if has_next else "=",
[0.05, 0.4, 0.6, 0.8],
file=file,
)
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 test_from_to_dict(self):
author1, created = Person.from_dict({"name": "John Doe"})
self.assertTrue(created)
self.assertIsNotNone(author1.id)
author2, created = Person.from_dict({"name": "Jane Doe"})
self.assertTrue(created)
self.assertIsNotNone(author2.id)
journal, created = Journal.from_dict({"name": "Science Journal"})
self.assertTrue(created)
self.assertIsNotNone(journal.id)
paper, created = Paper.objects.get_or_create(
title="Random new stuff", journal=journal, volume="1/2021"
)
paper.authors.add(author1)
paper.authors.add(author2)
self.assertTrue(created)
self.assertIsNotNone(paper.id)
self.assertEquals(
{
"title": "Random new stuff",
"authors": [
{"name": "Jane Doe", "links": None},
{"name": "John Doe", "links": None},
],
"journal": {"name": "Science Journal", "links": None},
"volume": "1/2021",
"publishing_date": None,
"languages": None,
"files": None,
"bibtex": None,
"links": None,
"acquisitions": None,
"reads": None,
},
paper.to_dict(),
)
self.assertEquals(
(paper, False),
Paper.from_dict(
{
"title": "Random new stuff",
"authors": [
{"name": "Jane Doe", "links": None},
{"name": "John Doe", "links": None},
],
"journal": {"name": "Science Journal", "links": None},
"volume": "1/2021",
"publishing_date": None,
"languages": None,
"files": None,
"bibtex": None,
"links": None,
"acquisitions": None,
"reads": None,
}
),
)
self.assertEquals(
(paper, False),
Paper.from_dict(
{
"title": "Random new stuff",
"authors": [
{"name": "Jane Doe"},
{"name": "John Doe"},
],
"journal": {"name": "Science Journal"},
"volume": "1/2021",
}
),
)
language, created = Language.from_dict({"name": "Englisch"})
self.assertTrue(created)
self.assertIsNotNone(language.id)
link, created = Link.from_dict({"url": "https://example.com"})
self.assertTrue(created)
self.assertIsNotNone(link.id)
paper, created = Paper.objects.get_or_create(
title="Random Science stuff",
publishing_date=datetime.strptime("2021-01-01", "%Y-%m-%d").date(),
journal=journal,
volume="2/2021",
)
paper.authors.add(author1)
paper.authors.add(author2)
paper.languages.add(language)
paper.links.add(link)
self.assertTrue(created)
self.assertIsNotNone(paper.id)
acquisition, created = Acquisition.from_dict(
{"date": "2021-01-02", "price": 10}, paper
)
self.assertTrue(created)
self.assertIsNotNone(acquisition.id)
read, created = Read.from_dict(
{"started": "2021-01-02", "finished": "2021-01-03"}, paper
)
self.assertTrue(created)
self.assertIsNotNone(read.id)
self.assertEquals(
{
"title": "Random Science stuff",
"authors": [
{"name": "Jane Doe", "links": None},
{"name": "John Doe", "links": None},
],
"journal": {"name": "Science Journal", "links": None},
"volume": "2/2021",
"publishing_date": "2021-01-01",
"languages": [{"name": "Englisch"}],
"files": None,
"bibtex": None,
"links": [{"url": "https://example.com"}],
"acquisitions": [{"date": "2021-01-02", "price": 10.0}],
"reads": [{"started": "2021-01-02", "finished": "2021-01-03"}],
},
paper.to_dict(),
)
self.assertEquals(
(paper, False),
Paper.from_dict(
{
"title": "Random Science stuff",
"authors": [
{"name": "Jane Doe", "links": None},
{"name": "John Doe", "links": None},
],
"journal": {"name": "Science Journal", "links": None},
"volume": "2/2021",
"publishing_date": "2021-01-01",
"languages": [{"name": "Englisch"}],
"files": None,
"bibtex": None,
"links": [{"url": "https://example.com"}],
"acquisitions": [{"date": "2021-01-02", "price": 10.0}],
"reads": [{"started": "2021-01-02", "finished": "2021-01-03"}],
}
),
)
self.assertEquals(
(paper, False),
Paper.from_dict(
{
"title": "Random Science stuff",
"authors": [
{"name": "Jane Doe"},
{"name": "John Doe"},
],
"journal": {"name": "Science Journal"},
"volume": "2/2021",
"publishing_date": "2021-01-01",
"languages": [{"name": "Englisch"}],
"links": [{"url": "https://example.com"}],
"acquisitions": [{"date": "2021-01-02", "price": 10.0}],
"reads": [{"started": "2021-01-02", "finished": "2021-01-03"}],
}
),
)
with NamedTemporaryFile() as f:
f.write(b"Lorem ipsum dolorem")
file, created = File.from_dict({"path": f.name})
self.assertTrue(created)
self.assertIsNotNone(file.id)
self.assertEquals(
os.path.basename(f.name), os.path.basename(file.file.name)
)
paper, created = Paper.objects.get_or_create(
title="Boring Science stuff",
publishing_date=datetime.strptime("2021-02-01", "%Y-%m-%d").date(),
journal=journal,
volume="2/2021",
)
paper.authors.add(author1)
paper.authors.add(author2)
paper.languages.add(language)
paper.links.add(link)
paper.files.add(file)
paper.save()
self.assertTrue(created)
self.assertIsNotNone(paper.id)
self.assertEquals(
{
"title": "Boring Science stuff",
"authors": [
{"name": "Jane Doe", "links": None},
{"name": "John Doe", "links": None},
],
"journal": {"name": "Science Journal", "links": None},
"volume": "2/2021",
"publishing_date": "2021-02-01",
"languages": [{"name": "Englisch"}],
"bibtex": None,
"links": [{"url": "https://example.com"}],
"files": [
{
"path": os.path.join(
settings.MEDIA_ROOT,
"papers",
str(paper.pk),
os.path.basename(f.name),
)
}
],
"acquisitions": None,
"reads": None,
},
paper.to_dict(),
)
#! /usr/bin/env python
# import and setup Django environment (as "./manage.py shell" does):
from sys import argv, path as sys_path
import os
import django
sys_path.append('..')
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "example.settings")
django.setup()
# actual import script:
from persons.models import Person
if __name__ == '__main__':
if len(argv) != 2:
print('USAGE: $ ./import.py /some/path/file.txt')
else:
imported_persons_count = 0
with open(argv[1], 'r') as input_file:
for line in input_file:
short, full, mail = line.split('\t')
person = Person(short_name=short, full_name=full, email=mail)
person.save() # write new row to DB
imported_persons_count += 1
print('Imported %s persons.' % imported_persons_count)
