def auto_create_project_for_user(sender, user, *args, **kwargs):
"""
On post_auth, automatically create a project on login (if the user does not have any)
:param sender:
:param user:
:param args:
:param kwargs:
:return:
"""
# set current requests user (as during auth, that user is not set yet)
request = get_current_request()
if request and (not hasattr(request, 'user') or request.user.is_anonymous):
request.user = user
if Project.objects.viewable().count() == 0:
# no projects found, check if user has add_project permission
if user.has_perm(get_permission_name(Project, 'add')):
logger.info(
"Auto-creating project {project_name} for user {user_name}".
format(project_name=_("My Project"), user_name=user.username))
Project.objects.create(name=_("My Project"),
start_date=timezone.now(),
description="<div>%s</div>" %
_("Automatically generated project"))
def get_request_cache():
"""
Return the current requests cache
:return:
"""
from django_userforeignkey.request import get_current_request
return getattr(get_current_request(), "cache", None)
def __init__(self, path, **kwargs):
if path == "/":
request = get_current_request()
obj = Directory.objects.filter(drive=request.drive, is_virtual_root=True).first()
kwargs["obj"] = obj
super(MyDriveDavResource, self).__init__(path, **kwargs)
def auto_create_calendar_access_privileges(sender, user, *args, **kwargs):
"""
On post_auth, automatically create the calendar access privileges (if the user does not have any) and give
the user full_access_privilege for his calendar.
This is needed so new users get to have the Calendar Access Privileges. There is also a migration operation that
does the same for existing users, but that won't work for users that come after the migration.
"""
# set current requests user (as during auth, that user is not set yet)
request = get_current_request()
if request and (not hasattr(request, 'user') or request.user.is_anonymous):
request.user = user
# make sure the user has a calendar access object
own_calendar_access, created = CalendarAccess.objects.get_or_create(
created_by=user)
if created:
# make sure the user has full access to his own calendar
ModelPrivilege.objects.get_or_create(
user=user,
content_type=CalendarAccess.get_content_type(),
object_id=own_calendar_access.pk,
defaults={
'full_access_privilege': ModelPrivilege.ALLOW,
})
def get_short_url(self):
"""
Returns the actual short url, based on the current request and the short-url view
:return:
"""
request = get_current_request()
return reverse('short-url', kwargs={'pk': self.pk}, request=request)
def get_download_background_image_thumbnail(self, obj):
if not obj.background_image_thumbnail:
return None
request = get_current_request()
path = reverse('kanbanboard-background-image-thumbnail.png',
kwargs={'pk': obj.pk})
return build_expiring_jwt_url(request, path)
def build_download_url_with_token(picture, reverse_url_name):
request = get_current_request()
if picture.uploaded_picture_entry is None:
raise IntegrityError("uploaded_picture_entry is not referenced")
path = reverse(reverse_url_name,
kwargs={'pk': picture.uploaded_picture_entry.pk})
return build_expiring_jwt_url(request, path)
def get_download_directory(self, obj):
""" Builds a string for downloading the directory with a jwt token """
request = get_current_request()
path = reverse('drive-sub_directories-download',
kwargs={
'drive_pk': obj.drive.pk,
'pk': obj.pk
})
return build_expiring_jwt_url(request, path)
def is_authenticated(user, password):
user = authenticate(username=user, password=password)
request = get_current_request()
if user is not None:
if user.is_active:
# make sure to set the current user on the current request
request.user = user
return True
request.user = AnonymousUser()
return False
def create_collection_in_db(self, parent, name):
"""
Create a collection within the database
:param parent: the parent object
:param name: the name of the new collection
:return:
"""
request = get_current_request()
if not parent:
# if parent is not set, set it to the virtual root
parent = Directory.objects.filter(drive=request.drive, is_virtual_root=True).first()
self.collection_model.objects.create(
drive=request.drive, **{self.collection_attribute: parent, 'name': name}
)
def create_menu_entries_on_auth(sender, user, *args, **kwargs):
"""
Creates menu_entries for the current user on first auth (if no menu entries exists)
:param sender:
:param user:
:param args:
:param kwargs:
:return:
"""
# set current requests user
request = get_current_request()
if request and (not hasattr(request, 'user') or request.user.is_anonymous):
request.user = user
# check if menu entries exist for the current user
if not MenuEntry.objects.viewable().exists():
if 'default_menu_entries' not in settings.WORKBENCH_SETTINGS:
logger.debug("No default menu entries found in WORKBENCH_SETTINGS")
else:
logger.debug("Bulk creating menu entries")
menu_entries = []
menu_entry_parameters = []
# copy settings
from copy import deepcopy
for menu_entry_dict in deepcopy(
settings.WORKBENCH_SETTINGS['default_menu_entries']):
menu_entry_paramter_list = []
if 'menu_entry_parameters' in menu_entry_dict:
menu_entry_paramter_list = menu_entry_dict.pop(
'menu_entry_parameters')
# create menu entry
menu_entry = MenuEntry(**menu_entry_dict)
menu_entries.append(menu_entry)
for menu_entry_parameter_dict in menu_entry_paramter_list:
menu_entry_parameters.append(
MenuEntryParameter(menu_entry=menu_entry,
**menu_entry_parameter_dict))
MenuEntry.objects.bulk_create(menu_entries)
MenuEntryParameter.objects.bulk_create(menu_entry_parameters)
def get_webdav_url(self, obj):
"""
Returns the webdav URL for the current drive
:param obj:
:return:
"""
request = get_current_request()
# strip all non-confirming characters from drive title
pat = re.compile(r'[\W \-]+')
stripped_title = re.sub(pat, ' ', obj.title)
# temporarily remove webdav_url for DSS drives
if not obj.is_dss_drive:
return reverse('webdav-drive',
request=request,
kwargs={
'drive': obj.pk,
'path': '/',
'drive_title': stripped_title
})
return None
def get_auth_url(self, plugin_instance):
user = get_current_user()
path = reverse('plugininstance-detail',
kwargs={'pk': plugin_instance.pk})
plugin_token_validity = timedelta(
hours=settings.
PLUGINS_SETTINGS['plugin_api_token_validity_in_hours'])
token = build_expiring_jwt_token(user,
path,
validity=plugin_token_validity)
api_base_url = get_current_request().build_absolute_uri(
'/api/plugininstances/')
# add or replace existing parameters from the plugin path
query = "jwt={token}&pk={pk}&apiBaseUrl={apiBaseUrl}".format(
token=token,
pk=plugin_instance.pk,
apiBaseUrl=urllib.parse.quote(api_base_url, safe=''))
old_path_parts = urlparse(plugin_instance.plugin.path)
new_path_parts = old_path_parts._replace(query=query)
return new_path_parts.geturl()
def get_children(self):
"""Return an iterator of all direct children of this resource."""
# get all drives
drives = Drive.objects.viewable().not_deleted()
request = get_current_request()
# if this request is project specific, filter projects
if hasattr(request, 'project'):
drives = drives.filter(projects=request.project)
for child in drives:
# strip all non-confirming characters from drive title
pat = re.compile(r'[\W \-]+')
stripped_title = re.sub(pat, ' ', child.title)
# temporarily exclude DSS drives from the list
if not child.is_dss_drive:
yield self.clone(
"/" + stripped_title + " (" + str(child.pk) + ")",
obj=child # Sending ready object to reduce db requests
)
def convert_text_with_base64_images_to_file_references(source, source_field):
"""
Parse content, find base64 references, upload image files to system and convert references to image URLs.
:param source: Source object
:param source_field: Field of source object
:return:
"""
request = get_current_request()
content = getattr(source, source_field)
image_references = convert_base64_image_strings_to_file_references(content)
for image_reference in image_references:
image = upload_and_create_extracted_image(
file_name=image_reference['file_name'],
binary=image_reference['binary'],
mime_type=image_reference['mime_type'],
source=source,
source_field=source_field)
if image:
image_url = get_uri_for_extracted_image(image, True, request)
content = content.replace(image_reference['base64'], image_url)
return content
def build_download_url_with_token(plugin, reverse_url_name):
request = get_current_request()
path = reverse(reverse_url_name, kwargs={'pk': plugin.pk})
return build_expiring_jwt_url(request, path)
def get_download(self, file):
request = get_current_request()
path = reverse("file-download",
kwargs={'pk': file.uploaded_file_entry.pk})
return request.build_absolute_uri(path)
def object_model_qs(self):
request = get_current_request()
return File.objects.viewable().filter(
directory__drive=request.drive).not_deleted()
def collection_model_qs(self):
request = get_current_request()
return Directory.objects.viewable().filter(drive=request.drive)
def build_download_url(picture, reverse_url_name):
request = get_current_request()
path = reverse(reverse_url_name,
kwargs={'pk': picture.uploaded_picture_entry.pk})
return request.build_absolute_uri(path)
