def request_all_view(request, pk):
if request.method == 'POST':
form = RequestAllConfirm(request.POST)
if form.is_valid():
request_all(request, pk, form.cleaned_data['reason'])
document = get_object_or_404(Document, id=pk)
from library.logger import create_log
create_log(request, "Requested All copies", document)
from django.http import HttpResponseRedirect
return HttpResponseRedirect('/library/document/' + str(pk))
# if a GET (or any other method) we'll create a blank form
else:
form = RequestAllConfirm(initial={
'librarian_confirmation': False,
'reason': '',
})
return render(request, 'library/request_all.html', {
'form': form,
'userid': pk
})
def instance_update(request, id):
instance = get_object_or_404(DocumentInstance, id=id)
instance.document.quantity_synced = False
instance.document.save()
old_status = instance.status
form = DocumentInstanceUpdate(request.POST or None, instance=instance)
addfield = instance.document.type.fields
addfield = addfield.split(';')
if form.is_valid():
form.save()
if old_status == 'r':
if form.instance.status != 'r':
reservations = Reservation.objects.all()
for log in reservations:
if log.document_copy.id == form.instance.id:
log.delete()
from library.logger import create_log
create_log(request, "Updated", instance)
return redirect('document-detail', id=instance.document.pk)
return render(request, 'documentinstance_update.html', {
'form': form,
'addfield': addfield
})
def instance_create(request, pk):
instance = DocumentInstance.objects.create()
docs = Document.objects.all()
current_doc = None
for doc in docs:
if str(doc.pk) == pk:
current_doc = doc
addfield = current_doc.type.fields.split(';')
form = DocumentInstanceCreate(request.POST or None, instance=instance)
if form.is_valid():
form.instance.document = current_doc
form.save()
doc_id = form.instance.document.id
current_doc.quantity_synced = False
current_doc.save()
if instance.status == 'a':
instance.reserve_from_queue(request)
from library.logger import create_log
create_log(request, "Created", instance)
return redirect('document-detail', id=doc_id)
instance.delete()
return render(request, 'documentinstance_create.html',
{'form': form, 'addfield': addfield, 'current_doc': current_doc})
def request_document(request, document_id):
user = auth.get_user(request)
document = Document.objects.get(id=document_id)
if document.quantity() > 0:
redirect('document-detail', id=document_id)
if user.is_authenticated and user.is_active and user.is_patron:
requested = DocumentRequest.objects.filter(user_id=user.id,
document_id=document_id)
reserved = Reservation.objects.filter(user_id=user.id,
document_id=document_id)
checked_out = GiveOut.objects.filter(user=user, document=document)
if requested:
instance = requested.first()
from library.logger import create_log
create_log(request, "Canceled", instance)
requested.delete()
elif not checked_out and not reserved and not document.is_reference:
DocumentRequest.objects.create(user=user, document=document).save()
from library.logger import create_log
create_log(request, "Requested", document)
return redirect('document-detail', id=document_id)
def type_delete(request, id):
instance = get_object_or_404(DocType, id=id)
from library.logger import create_log
create_log(request, "Removed", instance)
instance = get_object_or_404(DocType, id=id).delete()
return redirect('types')
def location_delete(request, id):
instance = get_object_or_404(LibraryLocation, id=id)
from library.logger import create_log
create_log(request, "Removed", instance)
instance.delete()
return redirect('location_list')
def tag_delete(request, id):
instance = get_object_or_404(Tag, id=id)
from library.logger import create_log
create_log(request, "Removed", instance)
instance.delete()
return redirect('tags')
def author_delete(request, id):
instance = get_object_or_404(Author, id=id)
from library.logger import create_log
create_log(request, "Deleted", instance)
instance = get_object_or_404(Author, id=id).delete()
return redirect('authors')
def renew_document(request, id):
user = auth.get_user(request)
giveout = GiveOut.objects.get(id=id)
if not user.has_perm("library.change_giveout") and user != giveout.user:
return HttpResponseForbidden()
document = giveout.document
doc_instance = giveout.document_instance
patron_user = giveout.user
max_renew_times = patron_user.patron_type.max_renew_times
outstanding_requests = DocumentRequest.objects.filter(document=document,
outstanding=True)
error_limit_of_renewals = False
error_outstanding_request = False
max_days = document.days_available(patron_user)
if outstanding_requests:
error_outstanding_request = True
if giveout.renewed_times >= max_renew_times:
error_limit_of_renewals = True
if request.method == 'POST':
form = RenewDocumentForm(request.POST)
form.max_days = max_days
form.error_limit_of_renewals = error_limit_of_renewals
form.error_outstanding_request = error_outstanding_request
form.return_date = doc_instance.due_back
if form.is_valid():
doc_instance.due_back = form.clean_due_date()
giveout.renewed_times = giveout.renewed_times + 1
doc_instance.save()
giveout.save()
from library.logger import create_log
create_log(request, "Renewed", doc_instance)
return HttpResponseRedirect('/library/patrons/' +
str(patron_user.id))
else:
proposed_renewal_date = doc_instance.due_back + datetime.timedelta(
max_days)
form = RenewDocumentForm(initial={
"due_date": proposed_renewal_date,
})
return render(request,
'library/renew_details.html',
context={
'giveout': giveout,
'patron_type': patron_user.patron_type,
'form': form,
'outstanding_requests': error_outstanding_request
})
def author_update(request, id):
instance = get_object_or_404(Author, id=id)
form = AuthorUpdate(request.POST or None, instance=instance)
if form.is_valid():
form.save()
from library.logger import create_log
create_log(request, "Updated", instance)
return redirect('author-detail', pk=form.instance.id)
return render(request, 'author_update.html', {'form': form})
def instance_delete(request, id):
instance = get_object_or_404(DocumentInstance, id=id)
instance.document.quantity_synced = False
instance.document.save()
copy = instance.document.id
from library.logger import create_log
create_log(request, "Removed", instance)
instance = get_object_or_404(DocumentInstance, id=id).delete()
return redirect('document-detail', id=copy)
def create_location(request):
instance = LibraryLocation.objects.create()
form = LocationCreate(request.POST or None, instance=instance)
if form.is_valid():
form.save()
from library.logger import create_log
create_log(request, "Create", instance)
return redirect('location_list')
instance.delete()
return render(request, 'library/location_create.html', {'form': form})
def location_update(request, id):
instance = get_object_or_404(LibraryLocation, id=id)
form = LocationUpdate(request.POST or None, instance=instance)
if form.is_valid():
form.save()
from library.logger import create_log
create_log(request, "Changed", instance)
return redirect('location_list')
return render(request, 'library/location_update.html', {'form': form})
def type_create(request):
instance = DocType.objects.create()
form = TypeCreate(request.POST or None, instance=instance)
if form.is_valid():
form.save()
from library.logger import create_log
create_log(request, "Created", instance)
return redirect('types')
instance.delete()
return render(request, 'type_create.html', {'form': form})
def add_patron(request):
if request.method == 'POST':
form = AddPatron(request.POST)
if form.is_valid():
password = User.objects.make_random_password()
created_user = User.objects.create_user(
username=form.cleaned_data['username'],
email=form.cleaned_data['email'],
password=password,
first_name=form.cleaned_data['name'],
last_name=form.cleaned_data['surname'],
is_patron=True,
phone_number=form.cleaned_data['phone_number'],
address=form.cleaned_data['address'],
telegram=form.cleaned_data['telegram'],
patron_type=form.cleaned_data['type'])
from library.logger import create_log
create_log(request, "Registered", created_user)
return render(
request, 'library/registration_info.html', {
'username': created_user.username,
'password': password,
'email': created_user.email,
'patron_id': created_user.id,
'full_name':
created_user.first_name + " " + created_user.last_name,
'phone': created_user.phone_number,
'address': created_user.address,
'telegram': created_user.telegram,
'patron_type': created_user.patron_type
})
# if a GET (or any other method) we'll create a blank form
else:
form = AddPatron(
initial={
'name': "",
'surname': "",
'email': "",
'telegram': "@",
'password': ''
})
return render(request, 'library/patron_add.html', {'form': form})
def edit_patron(request, pk):
if request.method == 'POST':
form = EditPatron(request.POST)
if form.is_valid():
edited_patron = User.objects.get(id=pk)
edited_patron.email = form.cleaned_data['email']
edited_patron.first_name = form.cleaned_data['name']
edited_patron.last_name = form.cleaned_data['surname']
edited_patron.phone_number = form.cleaned_data['phone_number']
edited_patron.address = form.cleaned_data['address']
edited_patron.telegram = form.cleaned_data['telegram']
edited_patron.is_patron = form.cleaned_data['is_patron']
edited_patron.patron_type = form.cleaned_data['type']
edited_patron.is_limited = form.cleaned_data['is_limited']
edited_patron.save()
from library.logger import create_log
create_log(request, "Updated", edited_patron)
return HttpResponseRedirect('/library/patrons/' + str(pk))
# if a GET (or any other method) we'll create a blank form
else:
patron = User.objects.get(id=pk)
form = EditPatron(
initial={
'username': patron.username,
'name': patron.first_name,
'surname': patron.last_name,
'email': patron.email,
'phone_number': patron.phone_number,
'telegram': patron.telegram,
'address': patron.address,
'type': patron.patron_type,
'is_limited': patron.is_limited,
'is_patron': patron.is_patron,
})
return render(request, 'library/patron_edit.html', {
'form': form,
'userid': pk
})
def giveout_confirmation(request, id):
reservation = Reservation.objects.get(id=id)
copy = reservation.document_copy
patron = reservation.user
max_days = copy.document.days_available(patron)
if request.method == 'POST':
form = DueDateForm(request.POST)
form.max_days = max_days
if form.is_valid():
copy.due_back = form.clean_due_date()
copy.document.quantity_synced = False
copy.document.save()
copy.status = 'g'
copy.holder = patron
copy.save()
GiveOut.objects.create(user=patron,
document=reservation.document,
document_instance=copy)
from library.logger import create_log
create_log(request, "GaveOut", copy)
reservation.delete()
return HttpResponseRedirect(reverse('reservation-list'))
else:
proposed_renewal_date = datetime.date.today() + datetime.timedelta(
max_days)
form = DueDateForm(initial={
"due_date": proposed_renewal_date,
"max_date": max_days
})
return render(request,
'library/giveout_details.html',
context={
'reservation': reservation,
'patron_type': patron.patron_type,
'form': form
})
def upload(request):
unsigned = request.GET.get("unsigned") == "true"
if (unsigned):
# For the sake of simplicity of the sample site, we generate the preset on the fly. It only needs to be created once, in advance.
try:
api.upload_preset(ImageUnsignedDirectForm.upload_preset_name)
except api.NotFound:
api.create_upload_preset(name=ImageUnsignedDirectForm.upload_preset_name, unsigned=True,
folder="preset_folder")
direct_form = ImageUnsignedDirectForm() if unsigned else ImageDirectForm()
context = dict(
# Form demonstrating backend upload
backend_form=DocImageForm(),
# Form demonstrating direct upload
direct_form=direct_form,
# Should the upload form be unsigned
unsigned=unsigned,
)
# When using direct upload - the following call is necessary to update the
# form's callback url
cl_init_js_callbacks(context['direct_form'], request)
instance = Document.objects.create()
if request.method == 'POST':
# Only backend upload should be posting here
form = DocImageForm(request.POST, request.FILES, instance=instance)
context['posted'] = form.instance
if form.is_valid():
# Uploads image and creates a model instance for it
from library.logger import create_log
create_log(request, "Created", instance)
form.save()
return redirect('document')
instance.delete()
return render(request, 'upload.html', context)
def reserve_document(request, copy_id):
user = auth.get_user(request)
copy = DocumentInstance.objects.get(id=str(copy_id))
document = Document.objects.get(id=copy.document_id)
if user.is_authenticated and user.is_active and not user.is_limited and user.is_patron:
reserved = Reservation.objects.filter(user_id=user.id, document_copy_id=copy.id)
checked_out = GiveOut.objects.filter(user=user, document=document)
if reserved:
reserved.delete()
copy.status = "a"
copy.reserve_from_queue(request)
elif not checked_out:
copy.reserve(request, user, False)
document.quantity_synced = False
copy.save()
document.save()
from library.logger import create_log
create_log(request, "Reserved", copy)
return redirect('document-detail', id=document.id)
def edit_user_perms(request, pk):
all_groups = Group.objects.all()
edited_user = User.objects.get(id=pk)
perms = []
for group in all_groups:
perms.append([group.name, [x.name for x in group.permissions.all()]])
if request.method == 'POST':
form = EditUserPerms(request.POST)
if form.is_valid():
for group in edited_user.groups.all():
group.user_set.remove(edited_user)
for group in form.cleaned_data['groups']:
edited_user.groups.add(group)
edited_user.save()
from library.logger import create_log
if edited_user.is_patron:
create_log(request, "Redefine Group", edited_user)
return HttpResponseRedirect('/library/patrons/' + str(pk))
# if a GET (or any other method) we'll create a blank form
else:
form = EditUserPerms(initial={'groups': edited_user.groups.all()})
print(perms)
return render(request, 'library/edit_user_perms.html', {
'form': form,
'edited_user': edited_user,
'perms': perms
})
def return_document(request, id):
giveout = GiveOut.objects.get(id=id)
copy = giveout.document_instance
document = giveout.document
patron_user = giveout.user
patron_type = patron_user.patron_type
if request.method == 'POST':
form = ReturnDocumentForm(request.POST)
if form.is_valid():
GiveOutLogEntry.objects.create(
timestamp_given_out=giveout.timestamp,
timestamp_due_back=copy.due_back,
user=copy.holder,
patron_information=patron_user,
document_instance_summary=copy.summary())
copy.clean_giveout(request)
from library.logger import create_log
create_log(request, "Accepted Return", copy)
giveout.delete()
return redirect('patron-details', id=patron_user.id)
else:
form = ReturnDocumentForm(initial={"librarian_confirm": False})
return render(request,
'library/document_return.html',
context={
'giveout': giveout,
'patron_type': patron_type,
'overdue_days': giveout.document_instance.overdue_days(),
'fine': giveout.document_instance.fine(),
'form': form
})
def edit_document_request(request, id, action):
return_user_id = -1
if action == 'outstanding':
current_request = DocumentRequest.objects.filter(id=id)
if current_request:
current_request = current_request.first()
return_user_id = current_request.user_id
if current_request.outstanding:
current_request.outstanding = False
current_request.save()
from library.logger import create_log
create_log(request, "Removed Outstanding Request",
current_request.document)
else:
outstanding_requests = DocumentRequest.objects.filter(
document_id=current_request.document_id, outstanding=True)
if not outstanding_requests:
current_request.outstanding = True
current_request.save()
from library.logger import create_log
create_log(request, "Created Outstanding Request",
current_request.document)
giveouts = GiveOut.objects.filter(
document=current_request.document)
for x in giveouts:
mail_subject = 'Touch of Library: Please return document'
message = render_to_string(
'mails/return_request.html', {
'document': x.document_instance.summary(),
'user': x.user,
})
to_email = x.user.email
email = EmailMultiAlternatives(mail_subject,
message,
to=[to_email])
email.attach_alternative(message, "text/html")
email.send()
elif action == 'delete':
current_request = DocumentRequest.objects.filter(id=id)
if current_request:
current_request = current_request.first()
return_user_id = current_request.user_id
from library.logger import create_log
create_log(request, "Removed Request", current_request.document)
current_request.delete()
if return_user_id == -1:
return redirect('patrons-list')
else:
return redirect('patron-details', id=return_user_id)
def delete_patron(request, pk):
user = auth.get_user(request)
user_to_delete = User.objects.get(id=pk)
# User of lower rank can not delete user of higher rank
user_rank = 0
user_to_delete_rank = 0
if user.has_perm("library.change_user"):
user_rank += 1
if user_to_delete.has_perm("library.change_user"):
user_to_delete_rank += 1
if user.is_staff:
user_rank = 100
if user_to_delete.is_staff:
user_to_delete_rank = 100
if user.is_superuser:
user_rank = 999
if user_to_delete.is_superuser:
user_to_delete_rank = 999
if request.method == 'POST':
form = DeletePatron(request.POST)
if form.is_valid():
if (not user_to_delete.is_patron and not user.has_perm("library.change_user")) or \
(user_rank < user_to_delete_rank):
return HttpResponse("This action is forbidden!")
giveouts = GiveOut.objects.filter(user=user_to_delete).all()
if giveouts:
return HttpResponseRedirect('/library/patrons/')
reservations = Reservation.objects.filter(
user=user_to_delete).all()
for r in reservations:
r.document_copy.status = 'a'
r.document.quantity_synced = False
r.document_copy.save()
r.document.save()
message = render_to_string('mails/acc_delete_email.html', {
'user': user_to_delete,
'reason': form.cleaned_data['reason'],
})
user_to_delete.email_user('Touch of Library: Account deletion',
message)
from library.logger import create_log
create_log(request, "Disabled", user_to_delete)
user_to_delete.is_active = False
user_to_delete.save()
return HttpResponseRedirect('/library/patrons/')
else:
form = DeletePatron(initial={'comment': ''})
return render(request,
'library/patron_delete.html',
context={
'form': form,
'patron': user_to_delete
})