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