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 })