def key_delete(request, fingerprint, key_type): check_permissions(request.user, [PERMISSION_KEY_DELETE]) secret = key_type == 'sec' key = Key.get(gpg, fingerprint, secret=secret) post_action_redirect = None previous = request.POST.get( 'previous', request.GET.get('previous', request.META.get('HTTP_REFERER', '/'))) next = request.POST.get( 'next', request.GET.get( 'next', post_action_redirect if post_action_redirect else request.META.get( 'HTTP_REFERER', '/'))) if request.method == 'POST': try: gpg.delete_key(key) messages.success( request, _(u'Key: %s, deleted successfully.') % fingerprint) return HttpResponseRedirect(next) except Exception, msg: messages.error(request, msg) return HttpResponseRedirect(previous)
def user_delete(request, user_id=None, user_id_list=None): check_permissions(request.user, [PERMISSION_USER_DELETE]) post_action_redirect = None if user_id: users = [get_object_or_404(User, pk=user_id)] post_action_redirect = reverse('user_list') elif user_id_list: users = [get_object_or_404(User, pk=user_id) for user_id in user_id_list.split(',')] else: messages.error(request, _(u'Must provide at least one user.')) return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/')) previous = request.POST.get('previous', request.GET.get('previous', request.META.get('HTTP_REFERER', '/'))) next = request.POST.get('next', request.GET.get('next', post_action_redirect if post_action_redirect else request.META.get('HTTP_REFERER', '/'))) if request.method == 'POST': for user in users: try: if user.is_superuser or user.is_staff: messages.error(request, _(u'Super user and staff user deleting is not allowed, use the admin interface for these cases.')) else: user.delete() messages.success(request, _(u'User "%s" deleted successfully.') % user) except Exception, e: messages.error(request, _(u'Error deleting user "%(user)s": %(error)s') % { 'user': user, 'error': e }) return HttpResponseRedirect(next)
def setup_source_transformation_create(request, source_type, source_id): check_permissions(request.user, [PERMISSION_SOURCES_SETUP_EDIT]) if source_type == SOURCE_CHOICE_WEB_FORM: cls = WebForm elif source_type == SOURCE_CHOICE_STAGING: cls = StagingFolder elif source_type == SOURCE_CHOICE_WATCH: cls = WatchFolder source = get_object_or_404(cls, pk=source_id) redirect_view = reverse('setup_source_transformation_list', args=[source.source_type, source.pk]) if request.method == 'POST': form = SourceTransformationForm_create(request.POST) if form.is_valid(): try: source_tranformation = form.save(commit=False) source_tranformation.content_object = source source_tranformation.save() messages.success( request, _(u'Source transformation created successfully')) return HttpResponseRedirect(redirect_view) except Exception, e: messages.error( request, _(u'Error creating source transformation; %s') % e)
def expired_remider_list(request, expiration_date=datetime.datetime.now().date(), view_all=False): if view_all: check_permissions(request.user, [PERMISSION_REMINDER_VIEW_ALL]) expired_reminders = Reminder.objects.filter( datetime_expire__lt=expiration_date) else: check_permissions(request.user, [PERMISSION_REMINDER_VIEW]) expired_reminders = Reminder.objects.filter( participant__user=request.user).filter( datetime_expire__lt=expiration_date) return render_to_response('generic_list.html', { 'object_list': expired_reminders.order_by('datetime_expire'), 'title': _(u'expired reminders to the date: %(date)s %(all)s') % { 'date': formats.date_format(expiration_date, u'DATE_FORMAT'), 'all': _(u'(all)') if view_all else u'' }, 'multi_select_as_buttons': True, 'hide_links': True, 'extra_columns': [{ 'name': _('days expired'), 'attribute': lambda x: (expiration_date - x.datetime_expire).days }] }, context_instance=RequestContext(request))
def setup_source_transformation_delete(request, transformation_id): check_permissions(request.user, [PERMISSION_SOURCES_SETUP_EDIT]) source_transformation = get_object_or_404(SourceTransformation, pk=transformation_id) redirect_view = reverse( 'setup_source_transformation_list', args=[ source_transformation.content_object.source_type, source_transformation.content_object.pk ]) previous = request.POST.get( 'previous', request.GET.get('previous', request.META.get('HTTP_REFERER', redirect_view))) if request.method == 'POST': try: source_transformation.delete() messages.success(request, _(u'Source transformation deleted successfully.')) except Exception, e: messages.error( request, _(u'Error deleting source transformation; %(error)s') % {'error': e}) return HttpResponseRedirect(redirect_view)
def setup_source_edit(request, source_type, source_id): check_permissions(request.user, [PERMISSION_SOURCES_SETUP_EDIT]) if source_type == SOURCE_CHOICE_WEB_FORM: cls = WebForm form_class = WebFormSetupForm elif source_type == SOURCE_CHOICE_STAGING: cls = StagingFolder form_class = StagingFolderSetupForm elif source_type == SOURCE_CHOICE_WATCH: cls = WatchFolder form_class = WatchFolderSetupForm source = get_object_or_404(cls, pk=source_id) next = request.POST.get( 'next', request.GET.get('next', request.META.get('HTTP_REFERER', '/'))) if request.method == 'POST': form = form_class(instance=source, data=request.POST) if form.is_valid(): try: form.save() messages.success(request, _(u'Source edited successfully')) return HttpResponseRedirect(next) except Exception, e: messages.error(request, _(u'Error editing source; %s') % e)
def smart_link_condition_delete(request, smart_link_condition_pk): check_permissions( request.user, [PERMISSION_SMART_LINK_CREATE, PERMISSION_SMART_LINK_EDIT]) smart_link_condition = get_object_or_404(SmartLinkCondition, pk=smart_link_condition_pk) next = request.POST.get( 'next', request.GET.get('next', request.META.get('HTTP_REFERER', '/'))) previous = request.POST.get( 'previous', request.GET.get('previous', request.META.get('HTTP_REFERER', '/'))) if request.method == 'POST': try: smart_link_condition.delete() messages.success( request, _(u'Smart link condition: "%s" deleted successfully.') % smart_link_condition) except Exception, error: messages.error( request, _(u'Error deleting smart link condition: %(smart_link_condition)s; %(error)s.' ) % { 'smart_link_condition': smart_link_condition, 'error': error }) return HttpResponseRedirect(next)
def participant_list(request, reminder_id): try: check_permissions(request.user, [PERMISSION_REMINDER_VIEW_ALL]) reminder = get_object_or_404(Reminder, pk=reminder_id) except PermissionDenied: check_permissions(request.user, [PERMISSION_REMINDER_VIEW]) try: reminder = get_object_or_404(Reminder.objects.filter( participant__user=request.user).filter(participant__role__in=[ PARTICIPANT_ROLE_CREATOR, PARTICIPANT_ROLE_EDITOR, PARTICIPANT_ROLE_WATCHER ]).distinct(), pk=reminder_id) except Http404: raise PermissionDenied return render_to_response('generic_list.html', { 'object_list': reminder.participant_set.all(), 'title': _(u'participants'), 'object': reminder, 'object_name': _(u'reminder'), 'hide_link': True, 'hide_object': True, }, context_instance=RequestContext(request))
def document_signature_upload(request, document_pk): check_permissions(request.user, [PERMISSION_SIGNATURE_UPLOAD]) document = get_object_or_404(Document, pk=document_pk) RecentDocument.objects.add_document_for_user(request.user, document) post_action_redirect = None previous = request.POST.get( 'previous', request.GET.get('previous', request.META.get('HTTP_REFERER', '/'))) next = request.POST.get( 'next', request.GET.get( 'next', post_action_redirect if post_action_redirect else request.META.get( 'HTTP_REFERER', '/'))) if request.method == 'POST': form = DetachedSignatureForm(request.POST, request.FILES) if form.is_valid(): try: document.add_detached_signature(request.FILES['file']) messages.success( request, _(u'Detached signature uploaded successfully.')) return HttpResponseRedirect(next) except Exception, msg: messages.error(request, msg) return HttpResponseRedirect(previous)
def smart_link_list(request): check_permissions(request.user, [PERMISSION_SMART_LINK_CREATE]) return render_to_response('generic_list.html', { 'title': _(u'smart links'), 'object_list': SmartLink.objects.all(), 'extra_columns': [ { 'name': _(u'dynamic title'), 'attribute': 'dynamic_title' }, { 'name': _(u'enabled'), 'attribute': encapsulate(lambda x: two_state_template(x.enabled)) }, ], 'hide_link': True, 'list_object_variable_name': 'smart_link', }, context_instance=RequestContext(request))
def document_delete(request, document_id=None, document_id_list=None): check_permissions(request.user, [PERMISSION_DOCUMENT_DELETE]) post_action_redirect = None if document_id: documents = [get_object_or_404(Document, pk=document_id)] post_action_redirect = reverse('document_list') elif document_id_list: documents = [get_object_or_404(Document, pk=document_id) for document_id in document_id_list.split(',')] else: messages.error(request, _(u'Must provide at least one document.')) return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/')) previous = request.POST.get('previous', request.GET.get('previous', request.META.get('HTTP_REFERER', '/'))) next = request.POST.get('next', request.GET.get('next', post_action_redirect if post_action_redirect else request.META.get('HTTP_REFERER', '/'))) if request.method == 'POST': for document in documents: try: warnings = delete_indexes(document) if request.user.is_staff or request.user.is_superuser: for warning in warnings: messages.warning(request, warning) document.delete() #create_history(HISTORY_DOCUMENT_DELETED, data={'user': request.user, 'document': document}) messages.success(request, _(u'Document: %s deleted successfully.') % document) except Exception, e: messages.error(request, _(u'Document: %(document)s delete error: %(error)s') % { 'document': document, 'error': e }) return HttpResponseRedirect(next)
def document_page_transformation_edit(request, document_page_transformation_id): check_permissions(request.user, [PERMISSION_DOCUMENT_TRANSFORM]) document_page_transformation = get_object_or_404(DocumentPageTransformation, pk=document_page_transformation_id) if request.method == 'POST': form = DocumentPageTransformationForm(request.POST, instance=document_page_transformation) if form.is_valid(): document_page_transformation.document_page.document.invalidate_cached_image(document_page_transformation.document_page.page_number) form.save() messages.success(request, _(u'Document page transformation edited successfully.')) return HttpResponseRedirect(reverse('document_page_transformation_list', args=[document_page_transformation.document_page_id])) else: form = DocumentPageTransformationForm(instance=document_page_transformation) return render_to_response('generic_form.html', { 'form': form, 'transformation': document_page_transformation, 'page': document_page_transformation.document_page, 'navigation_object_list': [ {'object': 'page'}, {'object': 'transformation', 'name': _(u'transformation')} ], 'title': _(u'Edit transformation "%(transformation)s" for: %(document_page)s') % { 'transformation': document_page_transformation.get_transformation_display(), 'document_page': document_page_transformation.document_page}, 'web_theme_hide_menus': True, }, context_instance=RequestContext(request))
def node_active_list(request): check_permissions(request.user, [PERMISSION_OCR_DOCUMENT]) i = inspect() active_tasks = [] try: active_nodes = i.active() if active_nodes: for node, tasks in active_nodes.items(): for task in tasks: task_info = { 'node': node, 'task_name': task['name'], 'task_id': task['id'], 'related_object': None, } if task['name'] == u'ocr.tasks.task_process_queue_document': task_info['related_object'] = QueueDocument.objects.get(pk=eval(task['args'])[0]).document active_tasks.append(task_info) except socket.error: active_tasks = [] return render_to_response('generic_list.html', { 'object_list': active_tasks, 'title': _(u'active tasks'), 'hide_links': True, 'hide_object': True, 'extra_columns': [ {'name': _(u'node'), 'attribute': 'node'}, {'name': _(u'task id'), 'attribute': 'task_id'}, {'name': _(u'task name'), 'attribute': 'task_name'}, {'name': _(u'related object'), 'attribute': lambda x: display_link(x['related_object']) if x['related_object'] else u''} ], }, context_instance=RequestContext(request))
def queue_document_delete(request, queue_document_id=None, queue_document_id_list=None): check_permissions(request.user, [PERMISSION_OCR_DOCUMENT_DELETE]) if queue_document_id: queue_documents = [get_object_or_404(QueueDocument, pk=queue_document_id)] elif queue_document_id_list: queue_documents = [get_object_or_404(QueueDocument, pk=queue_document_id) for queue_document_id in queue_document_id_list.split(',')] else: messages.error(request, _(u'Must provide at least one queue document.')) return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/')) next = request.POST.get('next', request.GET.get('next', request.META.get('HTTP_REFERER', None))) previous = request.POST.get('previous', request.GET.get('previous', request.META.get('HTTP_REFERER', None))) if request.method == 'POST': for queue_document in queue_documents: try: if queue_document.state == QUEUEDOCUMENT_STATE_PROCESSING: messages.error(request, _(u'Document: %s is being processed and can\'t be deleted.') % queue_document) else: queue_document.delete() messages.success(request, _(u'Queue document: %(document)s deleted successfully.') % { 'document': queue_document.document}) except Exception, e: messages.error(request, _(u'Error deleting document: %(document)s; %(error)s') % { 'document': queue_document, 'error': e}) return HttpResponseRedirect(next)
def smart_link_condition_list(request, smart_link_pk): check_permissions( request.user, [PERMISSION_SMART_LINK_CREATE, PERMISSION_SMART_LINK_EDIT]) smart_link = get_object_or_404(SmartLink, pk=smart_link_pk) return render_to_response('generic_list.html', { 'title': _(u'conditions for smart link: %s') % smart_link, 'object_list': smart_link.smartlinkcondition_set.all(), 'extra_columns': [ { 'name': _(u'enabled'), 'attribute': encapsulate(lambda x: two_state_template(x.enabled)) }, ], 'hide_link': True, 'smart_link': smart_link, 'navigation_object_name': 'smart_link', 'list_object_variable_name': 'condition', }, context_instance=RequestContext(request))
def key_list(request, secret=True): check_permissions(request.user, [PERMISSION_KEY_VIEW]) if secret: object_list = Key.get_all(gpg, secret=True) title = _(u'private keys') else: object_list = Key.get_all(gpg) title = _(u'public keys') return render_to_response('generic_list.html', { 'object_list': object_list, 'title': title, 'hide_object': True, 'extra_columns': [ { 'name': _(u'Key ID'), 'attribute': 'key_id', }, { 'name': _(u'Owner'), 'attribute': encapsulate(lambda x: u', '.join(x.uids)), }, ] }, context_instance=RequestContext(request))
def history_list(request): check_permissions(request.user, [PERMISSION_HISTORY_VIEW]) context = { 'object_list': History.objects.all(), 'title': _(u'history events'), 'extra_columns': [ { 'name': _(u'date and time'), 'attribute': 'datetime' }, { 'name': _(u'object'), 'attribute': lambda x: history_entry_object_link(x) }, { 'name': _(u'summary'), 'attribute': lambda x: history_entry_summary(x) } ], 'hide_object': True, } return render_to_response('generic_list.html', context, context_instance=RequestContext(request))
def document_page_view(request, document_page_id): check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW]) document_page = get_object_or_404(DocumentPage, pk=document_page_id) zoom = int(request.GET.get('zoom', DEFAULT_ZOOM_LEVEL)) rotation = int(request.GET.get('rotation', DEFAULT_ROTATION)) document_page_form = DocumentPageForm(instance=document_page, zoom=zoom, rotation=rotation) base_title = _(u'details for: %s') % document_page if zoom != DEFAULT_ZOOM_LEVEL: zoom_text = u'(%d%%)' % zoom else: zoom_text = u'' if rotation != 0 and rotation != 360: rotation_text = u'(%d°)' % rotation else: rotation_text = u'' return render_to_response('generic_detail.html', { 'page': document_page, 'navigation_object_name': 'page', 'web_theme_hide_menus': True, 'form': document_page_form, 'title': u' '.join([base_title, zoom_text, rotation_text]), 'zoom': zoom, 'rotation': rotation, }, context_instance=RequestContext(request))
def key_receive(request, key_id): check_permissions(request.user, [PERMISSION_KEY_RECEIVE]) post_action_redirect = None previous = request.POST.get('previous', request.GET.get('previous', request.META.get('HTTP_REFERER', '/'))) next = request.POST.get('next', request.GET.get('next', post_action_redirect if post_action_redirect else request.META.get('HTTP_REFERER', '/'))) if request.method == 'POST': try: term = request.GET.get('term') results = gpg.query(term) keys_dict = dict([(key.keyid, key) for key in results]) key = gpg.import_key(keys_dict[key_id].key) messages.success(request, _(u'Key: %s, imported successfully.') % key) return HttpResponseRedirect(next) except (KeyImportError, KeyError, TypeError): messages.error(request, _(u'Unable to import key id: %s') % key_id) return HttpResponseRedirect(previous) return render_to_response('generic_confirm.html', { 'title': _(u'Import key'), 'message': _(u'Are you sure you wish to import key id: %s?') % key_id, 'form_icon': 'key_add.png', 'next': next, 'previous': previous, 'submit_method': 'GET', }, context_instance=RequestContext(request))
def setup_queue_transformation_edit(request, transformation_id): check_permissions(request.user, [PERMISSION_OCR_QUEUE_EDIT]) transformation = get_object_or_404(QueueTransformation, pk=transformation_id) redirect_view = reverse('setup_queue_transformation_list', args=[transformation.content_object.pk]) next = request.POST.get( 'next', request.GET.get('next', request.META.get('HTTP_REFERER', redirect_view))) if request.method == 'POST': form = QueueTransformationForm(instance=transformation, data=request.POST) if form.is_valid(): try: form.save() messages.success( request, _(u'Queue transformation edited successfully')) return HttpResponseRedirect(next) except Exception, e: messages.error( request, _(u'Error editing queue transformation; %s') % e)
def all_document_ocr_cleanup(request): check_permissions(request.user, [PERMISSION_OCR_CLEAN_ALL_PAGES]) previous = request.POST.get( 'previous', request.GET.get('previous', request.META.get('HTTP_REFERER', None))) next = request.POST.get( 'next', request.GET.get('next', request.META.get('HTTP_REFERER', None))) if request.method != 'POST': return render_to_response('generic_confirm.html', { 'previous': previous, 'next': next, 'title': _(u'Are you sure you wish to clean up all the pages content?'), 'message': _(u'On large databases this operation may take some time to execute.' ), 'form_icon': u'text_strikethroungh.png', }, context_instance=RequestContext(request)) else: try: clean_pages() messages.success(request, _(u'Document pages content clean up complete.')) except Exception, e: messages.error(request, _(u'Document pages content clean up error: %s') % e) return HttpResponseRedirect(next)
def tag_remove(request, document_id, tag_id=None, tag_id_list=None): check_permissions(request.user, [PERMISSION_TAG_REMOVE]) post_action_redirect = None if tag_id: tags = [get_object_or_404(Tag, pk=tag_id)] elif tag_id_list: tags = [get_object_or_404(Tag, pk=tag_id) for tag_id in tag_id_list.split(',')] else: messages.error(request, _(u'Must provide at least one tag.')) return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/')) document = get_object_or_404(Document, pk=document_id) previous = request.POST.get('previous', request.GET.get('previous', request.META.get('HTTP_REFERER', '/'))) next = request.POST.get('next', request.GET.get('next', post_action_redirect if post_action_redirect else request.META.get('HTTP_REFERER', '/'))) if request.method == 'POST': for tag in tags: try: document.tags.remove(tag) messages.success(request, _(u'Tag "%s" removed successfully.') % tag) except Exception, e: messages.error(request, _(u'Error deleting tag "%(tag)s": %(error)s') % { 'tag': tag, 'error': e }) return HttpResponseRedirect(next)
def document_page_transformation_delete(request, document_page_transformation_id): check_permissions(request.user, [PERMISSION_DOCUMENT_TRANSFORM]) document_page_transformation = get_object_or_404(DocumentPageTransformation, pk=document_page_transformation_id) redirect_view = reverse('document_page_transformation_list', args=[document_page_transformation.document_page_id]) previous = request.POST.get('previous', request.GET.get('previous', request.META.get('HTTP_REFERER', redirect_view))) if request.method == 'POST': document_page_transformation.document_page.document.invalidate_cached_image(document_page_transformation.document_page.page_number) document_page_transformation.delete() messages.success(request, _(u'Document page transformation deleted successfully.')) return HttpResponseRedirect(redirect_view) return render_to_response('generic_confirm.html', { 'delete_view': True, 'page': document_page_transformation.document_page, 'transformation': document_page_transformation, 'navigation_object_list': [ {'object': 'page'}, {'object': 'transformation', 'name': _(u'transformation')} ], 'title': _(u'Are you sure you wish to delete transformation "%(transformation)s" for: %(document_page)s') % { 'transformation': document_page_transformation.get_transformation_display(), 'document_page': document_page_transformation.document_page}, 'web_theme_hide_menus': True, 'previous': previous, 'form_icon': u'pencil_delete.png', }, context_instance=RequestContext(request))
def history_for_object(request, app_label, module_name, object_id): check_permissions(request.user, [PERMISSION_HISTORY_VIEW]) model = get_model(app_label, module_name) if not model: raise Http404 content_object = get_object_or_404(model, pk=object_id) content_type = ContentType.objects.get_for_model(model) context = { 'object_list': History.objects.filter(content_type=content_type, object_id=object_id), 'title': _(u'history events for: %s') % content_object, 'object': content_object, 'extra_columns': [ { 'name': _(u'date and time'), 'attribute': 'datetime' }, { 'name': _(u'summary'), 'attribute': lambda x: history_entry_summary(x) } ], 'hide_object': True, } return render_to_response('generic_list.html', context, context_instance=RequestContext(request))
def document_clear_transformations(request, document_id=None, document_id_list=None): check_permissions(request.user, [PERMISSION_DOCUMENT_TRANSFORM]) if document_id: documents = [get_object_or_404(Document.objects, pk=document_id)] post_redirect = reverse('document_view_simple', args=[documents[0].pk]) elif document_id_list: documents = [get_object_or_404(Document, pk=document_id) for document_id in document_id_list.split(',')] post_redirect = None else: messages.error(request, _(u'Must provide at least one document.')) return HttpResponseRedirect(request.META.get('HTTP_REFERER', u'/')) previous = request.POST.get('previous', request.GET.get('previous', request.META.get('HTTP_REFERER', post_redirect or reverse('document_list')))) next = request.POST.get('next', request.GET.get('next', request.META.get('HTTP_REFERER', post_redirect or reverse('document_list')))) if request.method == 'POST': for document in documents: try: for document_page in document.documentpage_set.all(): document_page.document.invalidate_cached_image(document_page.page_number) for transformation in document_page.documentpagetransformation_set.all(): transformation.delete() messages.success(request, _(u'All the page transformations for document: %s, have been deleted successfully.') % document) except Exception, e: messages.error(request, _(u'Error deleting the page transformations for document: %(document)s; %(error)s.') % { 'document': document, 'error': e}) return HttpResponseRedirect(next)
def re_queue_document(request, queue_document_id=None, queue_document_id_list=None): check_permissions(request.user, [PERMISSION_OCR_DOCUMENT]) if queue_document_id: queue_documents = [get_object_or_404(QueueDocument, pk=queue_document_id)] elif queue_document_id_list: queue_documents = [get_object_or_404(QueueDocument, pk=queue_document_id) for queue_document_id in queue_document_id_list.split(',')] else: messages.error(request, _(u'Must provide at least one queue document.')) return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/')) next = request.POST.get('next', request.GET.get('next', request.META.get('HTTP_REFERER', None))) previous = request.POST.get('previous', request.GET.get('previous', request.META.get('HTTP_REFERER', None))) if request.method == 'POST': for queue_document in queue_documents: try: queue_document.document if queue_document.state == QUEUEDOCUMENT_STATE_PROCESSING: messages.warning(request, _(u'Document: %s is already being processed and can\'t be re-queded.') % queue_document) else: queue_document.datetime_submitted = datetime.datetime.now() queue_document.state = QUEUEDOCUMENT_STATE_PENDING queue_document.delay = False queue_document.result = None queue_document.node_name = None queue_document.save() messages.success(request, _(u'Document: %(document)s was re-queued to the OCR queue: %(queue)s') % { 'document': queue_document.document, 'queue': queue_document.document_queue.label}) except Document.DoesNotExist: messages.error(request, _(u'Document id#: %d, no longer exists.') % queue_document.document_id) except Exception, e: messages.error(request, e) return HttpResponseRedirect(next)
def document_page_navigation_last(request, document_page_id): check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW]) view = resolve_to_name(urlparse.urlparse(request.META.get('HTTP_REFERER', u'/')).path) document_page = get_object_or_404(DocumentPage, pk=document_page_id) document_page = get_object_or_404(DocumentPage, document=document_page.document, page_number=document_page.document.documentpage_set.count()) return HttpResponseRedirect(reverse(view, args=[document_page.pk]))
def document_queue_enable(request, document_queue_id): check_permissions(request.user, [PERMISSION_OCR_QUEUE_ENABLE_DISABLE]) next = request.POST.get('next', request.GET.get('next', request.META.get('HTTP_REFERER', None))) previous = request.POST.get('previous', request.GET.get('previous', request.META.get('HTTP_REFERER', None))) document_queue = get_object_or_404(DocumentQueue, pk=document_queue_id) if document_queue.state == DOCUMENTQUEUE_STATE_ACTIVE: messages.warning(request, _(u'Document queue: %s, already active.') % document_queue) return HttpResponseRedirect(previous) if request.method == 'POST': document_queue.state = DOCUMENTQUEUE_STATE_ACTIVE document_queue.save() messages.success(request, _(u'Document queue: %s, activated successfully.') % document_queue) return HttpResponseRedirect(next) return render_to_response('generic_confirm.html', { 'queue': document_queue, 'navigation_object_name': 'queue', 'title': _(u'Are you sure you wish to activate document queue: %s') % document_queue, 'next': next, 'previous': previous, 'form_icon': u'control_play_blue.png', }, context_instance=RequestContext(request))
def smart_link_condition_create(request, smart_link_pk): check_permissions( request.user, [PERMISSION_SMART_LINK_CREATE, PERMISSION_SMART_LINK_EDIT]) smart_link = get_object_or_404(SmartLink, pk=smart_link_pk) if request.method == 'POST': form = SmartLinkConditionForm(request.POST) if form.is_valid(): new_smart_link_condition = form.save(commit=False) new_smart_link_condition.smart_link = smart_link new_smart_link_condition.save() messages.success( request, _(u'Smart link condition: "%s" created successfully.') % new_smart_link_condition) return HttpResponseRedirect( reverse('smart_link_condition_list', args=[smart_link.pk])) else: form = SmartLinkConditionForm(initial={'smart_link': smart_link}) return render_to_response( 'generic_form.html', { 'form': form, 'title': _(u'Add new conditions to smart link: "%s"') % smart_link, 'navigation_object_name': 'smart_link', 'smart_link': smart_link, }, context_instance=RequestContext(request))
def role_create(request): check_permissions(request.user, [PERMISSION_ROLE_CREATE]) return create_object(request, model=Role, template_name='generic_form.html', post_save_redirect=reverse('role_list'))
def user_list(request): check_permissions(request.user, [PERMISSION_USER_VIEW]) return object_list( request, queryset=User.objects.exclude(is_superuser=True).exclude(is_staff=True).order_by('username'), template_name='generic_list.html', extra_context={ 'title': _(u'users'), 'hide_link': True, 'extra_columns': [ { 'name': _(u'full name'), 'attribute': 'get_full_name' }, { 'name': _(u'email'), 'attribute': 'email' }, { 'name': _(u'active'), 'attribute': lambda x: two_state_template(x.is_active), } ], 'multi_select_as_buttons': True, }, )
def rebuild_index_instances(request): check_permissions(request.user, [PERMISSION_DOCUMENT_INDEXING_REBUILD_INDEXES]) previous = request.POST.get('previous', request.GET.get('previous', request.META.get('HTTP_REFERER', None))) next = request.POST.get('next', request.GET.get('next', request.META.get('HTTP_REFERER', None))) if request.method != 'POST': return render_to_response('generic_confirm.html', { 'previous': previous, 'next': next, 'title': _(u'Are you sure you wish to rebuild all indexes?'), 'message': _(u'On large databases this operation may take some time to execute.'), 'form_icon': u'folder_page.png', }, context_instance=RequestContext(request)) else: try: warnings = do_rebuild_all_indexes() messages.success(request, _(u'Index rebuild completed successfully.')) for warning in warnings: messages.warning(request, warning) except Exception, e: messages.error(request, _(u'Index rebuild error: %s') % e) return HttpResponseRedirect(next)
def tag_edit(request, tag_id): check_permissions(request.user, [PERMISSION_TAG_EDIT]) tag = get_object_or_404(Tag, pk=tag_id) if request.method == 'POST': form = TagForm(request.POST) if form.is_valid(): tag.name = form.cleaned_data['name'] tag.save() tag_properties = tag.tagproperties_set.get() tag_properties.color = form.cleaned_data['color'] tag_properties.save() messages.success(request, _(u'Tag updated succesfully.')) return HttpResponseRedirect(reverse('tag_list')) else: form = TagForm(initial={ 'name': tag.name, 'color': tag.tagproperties_set.get().color }) return render_to_response('generic_form.html', { 'title': _(u'edit tag: %s') % tag, 'form': form, 'object': tag, 'object_name': _(u'tag'), }, context_instance=RequestContext(request))
def setup_metadata_set_delete(request, metadata_set_id): check_permissions(request.user, [PERMISSION_METADATA_SET_DELETE]) metadata_set = get_object_or_404(MetadataSet, pk=metadata_set_id) post_action_redirect = reverse('setup_metadata_set_list') previous = request.POST.get( 'previous', request.GET.get('previous', request.META.get('HTTP_REFERER', post_action_redirect))) next = request.POST.get( 'next', request.GET.get('next', request.META.get('HTTP_REFERER', post_action_redirect))) if request.method == 'POST': try: metadata_set.delete() messages.success( request, _(u'Metadata set: %s deleted successfully.') % metadata_set) return HttpResponseRedirect(post_action_redirect) except Exception, e: messages.error( request, _(u'Metadata set: %(metadata_set)s delete error: %(error)s') % { 'metadata_set': metadata_set, 'error': e }) return HttpResponseRedirect(previous)
def comment_add(request, document_id): check_permissions(request.user, [PERMISSION_COMMENT_CREATE]) document = get_object_or_404(Document, pk=document_id) post_action_redirect = None next = request.POST.get( 'next', request.GET.get( 'next', post_action_redirect if post_action_redirect else request.META.get( 'HTTP_REFERER', '/'))) if request.method == 'POST': form = CommentForm(request.POST) if form.is_valid(): comment = form.save(commit=False) comment.user = request.user comment.content_type = ContentType.objects.get_for_model(document) comment.object_pk = document.pk comment.site = Site.objects.get_current() comment.save() messages.success(request, _(u'Comment added successfully.')) return HttpResponseRedirect(next) else: form = CommentForm() return render_to_response('generic_form.html', { 'form': form, 'title': _(u'Add comment to document: %s') % document, 'next': next, 'object': document, }, context_instance=RequestContext(request))
def user_edit(request, user_id): check_permissions(request.user, [PERMISSION_USER_EDIT]) user = get_object_or_404(User, pk=user_id) if user.is_superuser or user.is_staff: messages.error( request, _(u'Super user and staff user editing is not allowed, use the admin interface for these cases.' )) return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/')) if request.method == 'POST': form = UserForm(instance=user, data=request.POST) if form.is_valid(): form.save() messages.success(request, _(u'User "%s" updated successfully.') % user) return HttpResponseRedirect(reverse('user_list')) else: form = UserForm(instance=user) return render_to_response('generic_form.html', { 'title': _(u'edit user: %s') % user, 'form': form, 'object': user, 'object_name': _(u'user'), }, context_instance=RequestContext(request))
def setup_document_type_metadata(request, document_type_id): check_permissions(request.user, [PERMISSION_DOCUMENT_TYPE_EDIT]) document_type = get_object_or_404(DocumentType, pk=document_type_id) # Initialize defaults DocumentTypeDefaults.objects.get_or_create(document_type=document_type) return assign_remove( request, left_list=lambda: generate_choices_w_labels( get_document_type_metadata_non_members(document_type)), right_list=lambda: generate_choices_w_labels( get_document_type_metadata_members(document_type)), add_method=lambda x: add_document_type_metadata(document_type, x), remove_method=lambda x: remove_document_type_metadata( document_type, x), left_list_title=_(u'non members of document type: %s') % document_type, right_list_title=_(u'members of document type: %s') % document_type, extra_context={ 'document_type': document_type, 'navigation_object_name': 'document_type', 'object_name': _(u'document type'), }, )
def document_clear_transformations(request, document_id): check_permissions(request.user, "documents", [PERMISSION_DOCUMENT_TRANSFORM]) previous = request.POST.get("previous", request.GET.get("previous", request.META.get("HTTP_REFERER", None))) document = get_object_or_404(Document, pk=document_id) if request.method == "POST": for document_page in document.documentpage_set.all(): for transformation in document_page.documentpagetransformation_set.all(): transformation.delete() messages.success( request, _(u"All the page transformations for document: %s, have been deleted successfully.") % document ) return HttpResponseRedirect(reverse("document_view", args=[document.pk])) return render_to_response( "generic_confirm.html", { "object_name": _(u"document transformation"), "delete_view": True, "object": document, "title": _(u"Are you sure you with to clear all the page transformations for document: %s?") % document, "previous": previous, }, context_instance=RequestContext(request), )
def history_list(request): check_permissions(request.user, [PERMISSION_HISTORY_VIEW]) context = { 'object_list': History.objects.all(), 'title': _(u'history events'), 'extra_columns': [{ 'name': _(u'date and time'), 'attribute': 'datetime' }, { 'name': _(u'object'), 'attribute': encapsulate(lambda x: history_entry_object_link(x)) }, { 'name': _(u'summary'), 'attribute': encapsulate(lambda x: history_entry_summary(x)) }], 'hide_object': True, } return render_to_response('generic_list.html', context, context_instance=RequestContext(request))
def document_page_transformation_edit(request, document_page_transformation_id): check_permissions(request.user, "documents", [PERMISSION_DOCUMENT_TRANSFORM]) document_page_transformation = get_object_or_404(DocumentPageTransformation, pk=document_page_transformation_id) return update_object( request, template_name="generic_form.html", form_class=DocumentPageTransformationForm, object_id=document_page_transformation_id, post_save_redirect=reverse("document_page_view", args=[document_page_transformation.document_page.id]), extra_context={"object_name": _(u"transformation")}, ) return render_to_response( "generic_form.html", { "form": form, "object": document_page_transformation.document_page, "title": _(u'Edit transformation "%(transformation)s" for page: %(page)s of document: %(document)s') % { "transformation": document_page_transformation.get_transformation_display(), "page": document_page_transformation.document_page.page_number, "document": document_page_transformation.document_page.document, }, }, context_instance=RequestContext(request), )
def document_page_transformation_delete(request, document_page_transformation_id): check_permissions(request.user, "documents", [PERMISSION_DOCUMENT_TRANSFORM]) previous = request.POST.get("previous", request.GET.get("previous", request.META.get("HTTP_REFERER", None))) document_page_transformation = get_object_or_404(DocumentPageTransformation, pk=document_page_transformation_id) return delete_object( request, model=DocumentPageTransformation, object_id=document_page_transformation_id, template_name="generic_confirm.html", post_delete_redirect=reverse("document_page_view", args=[document_page_transformation.document_page.id]), extra_context={ "delete_view": True, "object": document_page_transformation, "object_name": _(u"document transformation"), "title": _( u'Are you sure you wish to delete transformation "%(transformation)s" for page: %(page)s of document: %(document)s' ) % { "transformation": document_page_transformation.get_transformation_display(), "page": document_page_transformation.document_page.page_number, "document": document_page_transformation.document_page.document, }, "previous": previous, }, )
def reminder_add(request, form_class=ReminderForm): check_permissions(request.user, [PERMISSION_REMINDER_CREATE]) next = request.POST.get("next", request.GET.get("next", request.META.get("HTTP_REFERER", u"/"))) if request.method == "POST": form = form_class(request.POST) if form.is_valid(): if form_class == ReminderForm_days: reminder = form.save(commit=False) reminder.datetime_expire = reminder.datetime_created + datetime.timedelta( days=int(form.cleaned_data["days"]) ) reminder.save() else: reminder = form.save() participant = Participant(reminder=reminder, user=request.user, role=PARTICIPANT_ROLE_CREATOR) participant.save() messages.success(request, _(u'Reminder "%s" created successfully.') % reminder) return HttpResponseRedirect(reverse("reminder_list")) else: form = form_class() return render_to_response( "generic_form.html", { "title": _(u"create reminder (%s)") % (_(u"calendar") if form_class == ReminderForm else _(u"days")), "form": form, "next": next, }, context_instance=RequestContext(request), )
def folder_add_document_sidebar(request, document_id): check_permissions(request.user, [PERMISSION_DOCUMENT_VIEW]) document = get_object_or_404(Document, pk=document_id) previous = request.META.get('HTTP_REFERER', '/') if request.method == 'POST': form = AddDocumentForm(request.POST, user=request.user) if form.is_valid(): if form.cleaned_data['existing_folder']: folder = form.cleaned_data['existing_folder'] elif form.cleaned_data['title']: folder, created = Folder.objects.get_or_create(user=request.user, title=form.cleaned_data['title']) if created: messages.success(request, _(u'Folder created successfully')) else: messages.error(request, _(u'A folder named: %s, already exists.') % form.cleaned_data['title']) return HttpResponseRedirect(previous) else: messages.error(request, _(u'Must specify a new folder or an existing one.')) return HttpResponseRedirect(previous) folder_document, created = FolderDocument.objects.get_or_create(folder=folder, document=document) if created: messages.success(request, _(u'Document: %(document)s added to folder: %(folder)s successfully.') % { 'document': document, 'folder': folder}) else: messages.warning(request, _(u'Document: %(document)s is already in folder: %(folder)s.') % { 'document': document, 'folder': folder}) return HttpResponseRedirect(previous)
def history_for_object(request, app_label, module_name, object_id): check_permissions(request.user, [PERMISSION_HISTORY_VIEW]) model = get_model(app_label, module_name) if not model: raise Http404 content_object = get_object_or_404(model, pk=object_id) content_type = ContentType.objects.get_for_model(model) context = { 'object_list': History.objects.filter(content_type=content_type, object_id=object_id), 'title': _(u'history events for: %s') % content_object, 'object': content_object, 'extra_columns': [{ 'name': _(u'date and time'), 'attribute': 'datetime' }, { 'name': _(u'summary'), 'attribute': encapsulate(lambda x: history_entry_summary(x)) }], 'hide_object': True, } return render_to_response('generic_list.html', context, context_instance=RequestContext(request))
def role_permissions(request, role_id): check_permissions(request.user, [PERMISSION_PERMISSION_GRANT, PERMISSION_PERMISSION_REVOKE]) role = get_object_or_404(Role, pk=role_id) form = RoleForm_view(instance=role) role_permissions_list = Permission.objects.get_for_holder(role) subtemplates_list = [ { 'name': u'generic_list_subtemplate.html', 'context': { 'title': _(u'permissions'), 'object_list': Permission.objects.all(), 'extra_columns': [ {'name': _(u'namespace'), 'attribute': lambda x: namespace_titles[x.namespace] if x.namespace in namespace_titles else x.namespace}, {'name': _(u'name'), 'attribute': u'label'}, { 'name':_(u'state'), 'attribute': lambda x: _role_permission_link(role, x, role_permissions_list), } ], 'hide_link': True, 'hide_object': True, } }, ] return render_to_response('generic_detail.html', { 'form': form, 'object': role, 'object_name': _(u'role'), 'subtemplates_list': subtemplates_list, }, context_instance=RequestContext(request))
def participant_list(request, reminder_id): try: check_permissions(request.user, [PERMISSION_REMINDER_VIEW_ALL]) reminder = get_object_or_404(Reminder, pk=reminder_id) except PermissionDenied: check_permissions(request.user, [PERMISSION_REMINDER_VIEW]) try: reminder = get_object_or_404( Reminder.objects.filter(participant__user=request.user) .filter( participant__role__in=[PARTICIPANT_ROLE_CREATOR, PARTICIPANT_ROLE_EDITOR, PARTICIPANT_ROLE_WATCHER] ) .distinct(), pk=reminder_id, ) except Http404: raise PermissionDenied return render_to_response( "generic_list.html", { "object_list": reminder.participant_set.all(), "title": _(u"participants"), "object": reminder, "object_name": _(u"reminder"), "hide_link": True, "hide_object": True, }, context_instance=RequestContext(request), )
def user_list(request): check_permissions(request.user, [PERMISSION_USER_VIEW]) return object_list( request, queryset=User.objects.exclude(is_superuser=True).exclude( is_staff=True).order_by('username'), template_name='generic_list.html', extra_context={ 'title': _(u'users'), 'hide_link': True, 'extra_columns': [{ 'name': _(u'full name'), 'attribute': 'get_full_name' }, { 'name': _(u'email'), 'attribute': 'email' }, { 'name': _(u'active'), 'attribute': encapsulate(lambda x: two_state_template(x.is_active)), }], 'multi_select_as_buttons': True, }, )
def group_delete(request, group_id=None, group_id_list=None): check_permissions(request.user, [PERMISSION_GROUP_DELETE]) post_action_redirect = None if group_id: groups = [get_object_or_404(Group, pk=group_id)] post_action_redirect = reverse('group_list') elif group_id_list: groups = [get_object_or_404(Group, pk=group_id) for group_id in group_id_list.split(',')] else: messages.error(request, _(u'Must provide at least one group.')) return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/')) previous = request.POST.get('previous', request.GET.get('previous', request.META.get('HTTP_REFERER', '/'))) next = request.POST.get('next', request.GET.get('next', post_action_redirect if post_action_redirect else request.META.get('HTTP_REFERER', '/'))) if request.method == 'POST': for group in groups: try: group.delete() messages.success(request, _(u'Group "%s" deleted successfully.') % group) except Exception, e: messages.error(request, _(u'Error deleting group "%(group)s": %(error)s') % { 'group': group, 'error': e }) return HttpResponseRedirect(next)
def role_edit(request, role_id): check_permissions(request.user, [PERMISSION_ROLE_EDIT]) return update_object(request, template_name='generic_form.html', form_class=RoleForm, object_id=role_id, extra_context={ 'template_id': u'role_edit', 'object_name': _(u'role')})
def user_edit(request, user_id): check_permissions(request.user, [PERMISSION_USER_EDIT]) user = get_object_or_404(User, pk=user_id) if user.is_superuser or user.is_staff: messages.error( request, _(u"Super user and staff user editing is not allowed, use the admin interface for these cases.") ) return HttpResponseRedirect(request.META.get("HTTP_REFERER", "/")) if request.method == "POST": form = UserForm(instance=user, data=request.POST) if form.is_valid(): form.save() messages.success(request, _(u'User "%s" updated successfully.') % user) return HttpResponseRedirect(reverse("user_list")) else: form = UserForm(instance=user) return render_to_response( "generic_form.html", { "template_id": u"user_edit", "title": _(u"edit user: %s") % user, "form": form, "object": user, "object_name": _(u"user"), }, context_instance=RequestContext(request), )
def group_delete(request, group_id=None, group_id_list=None): check_permissions(request.user, [PERMISSION_GROUP_DELETE]) post_action_redirect = None if group_id: groups = [get_object_or_404(Group, pk=group_id)] post_action_redirect = reverse("group_list") elif group_id_list: groups = [get_object_or_404(Group, pk=group_id) for group_id in group_id_list.split(",")] else: messages.error(request, _(u"Must provide at least one group.")) return HttpResponseRedirect(request.META.get("HTTP_REFERER", "/")) previous = request.POST.get("previous", request.GET.get("previous", request.META.get("HTTP_REFERER", "/"))) next = request.POST.get( "next", request.GET.get( "next", post_action_redirect if post_action_redirect else request.META.get("HTTP_REFERER", "/") ), ) if request.method == "POST": for group in groups: try: group.delete() messages.success(request, _(u'Group "%s" deleted successfully.') % group) except Exception, e: messages.error( request, _(u'Error deleting group "%(group)s": %(error)s') % {"group": group, "error": e} ) return HttpResponseRedirect(next)
def submit_document(request, document_id): check_permissions(request.user, 'ocr', [PERMISSION_OCR_DOCUMENT]) document = get_object_or_404(Document, pk=document_id) return submit_document_to_queue( request, document=document, post_submit_redirect=request.META['HTTP_REFERER'])
def role_edit(request, role_id): check_permissions(request.user, [PERMISSION_ROLE_EDIT]) return update_object(request, template_name='generic_form.html', form_class=RoleForm, object_id=role_id, extra_context={'object_name': _(u'role')})
def button_navigation_widget(request, link): if 'permissions' in link: try: check_permissions(request.user, link['permissions']) return render_widget(link) except PermissionDenied: return u'' else: return render_widget(link)
def user_set_password(request, user_id=None, user_id_list=None): check_permissions(request.user, [PERMISSION_USER_EDIT]) post_action_redirect = None if user_id: users = [get_object_or_404(User, pk=user_id)] post_action_redirect = reverse('user_list') elif user_id_list: users = [ get_object_or_404(User, pk=user_id) for user_id in user_id_list.split(',') ] else: messages.error(request, _(u'Must provide at least one user.')) return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/')) next = request.POST.get( 'next', request.GET.get( 'next', post_action_redirect if post_action_redirect else request.META.get( 'HTTP_REFERER', '/'))) if request.method == 'POST': form = PasswordForm(request.POST) if form.is_valid(): password_1 = form.cleaned_data['new_password_1'] password_2 = form.cleaned_data['new_password_2'] if password_1 != password_2: messages.error(request, _(u'Passwords do not match, try again.')) else: for user in users: try: if user.is_superuser or user.is_staff: messages.error( request, _(u'Super user and staff user password reseting is not allowed, use the admin interface for these cases.' )) else: user.set_password(password_1) user.save() messages.success( request, _(u'Successfull password reset for user: %s.') % user) except Exception, e: messages.error( request, _(u'Error reseting password for user "%(user)s": %(error)s' ) % { 'user': user, 'error': e }) return HttpResponseRedirect(next)
def smart_link_action(request): check_permissions(request.user, [PERMISSION_SMART_LINK_VIEW]) action = request.GET.get('action', None) if not action: messages.error(request, _(u'No action selected.')) return HttpResponseRedirect(request.META.get('HTTP_REFERER', u'/')) return HttpResponseRedirect(action)
def document_list(request): check_permissions(request.user, 'documents', [PERMISSION_DOCUMENT_VIEW]) return object_list( request, queryset=Document.objects.all(), template_name='generic_list.html', extra_context={ 'title':_(u'documents'), }, )