def _get_unlock_link(self, obj, request):
"""
Generate an unlock link for the Versioning Admin
"""
# If the version is not draft no action should be present
if obj.state != constants.DRAFT or not version_is_locked(obj):
return ""
disabled = True
# Check whether the lock can be removed
# Check that the user has unlock permission
if version_is_locked(obj) and request.user.has_perm(
'djangocms_version_locking.delete_versionlock'):
disabled = False
unlock_url = reverse('admin:{app}_{model}_unlock'.format(
app=obj._meta.app_label,
model=self.model._meta.model_name,
),
args=(obj.pk, ))
return render_to_string('djangocms_version_locking/admin/unlock_icon.html',
{
'unlock_url': unlock_url,
'disabled': disabled
})
def locked(self, version):
"""
Generate an locked field for Versioning Admin
"""
if version.state == constants.DRAFT and version_is_locked(version):
return render_to_string(
'djangocms_version_locking/admin/locked_icon.html')
return ""
def add_alias_version_lock(obj, field):
version = obj.versions.all()[0]
lock_icon = ""
if version.state == DRAFT and version_is_locked(version):
lock_icon = render_to_string("djangocms_version_locking/admin/locked_mixin_icon.html")
return format_html(
"{is_locked}{field_value}",
is_locked=lock_icon,
field_value=getattr(obj, field),
)
def inner(version, **kwargs):
old_save(version, **kwargs)
# A draft version is locked by default
if version.state == constants.DRAFT:
if not version_is_locked(version):
# create a lock
create_version_lock(version, version.created_by)
# A any other state than draft has no lock, an existing lock should be removed
else:
remove_version_lock(version)
return version
def inner(version, user):
try:
# if there's a prepoluated field on version object
# representing a draft lock, use it
cached_draft_version_user_id = getattr(version,
"_draft_version_user_id")
if cached_draft_version_user_id and cached_draft_version_user_id != user.pk:
raise ConditionFailed(
message.format(
user="******".format(cached_draft_version_user_id)))
except AttributeError:
draft_version = get_latest_draft_version(version)
lock = version_is_locked(draft_version)
if lock and lock.created_by != user:
raise ConditionFailed(message.format(user=lock.created_by))
def test_version_is_unlocked_for_archived(self):
"""
A version lock is not present when a content version is in an archived state
"""
poll_version = factories.PollVersionFactory(state=constants.DRAFT)
archive_url = self.get_admin_url(self.versionable.version_model_proxy, 'archive', poll_version.pk)
version_lock = version_is_locked(poll_version)
user = self.get_superuser()
version_lock.created_by = user
version_lock.save()
with self.login_user_context(user):
self.client.post(archive_url)
updated_poll_version = Version.objects.get(pk=poll_version.pk)
# The state is now ARCHIVED
self.assertEqual(updated_poll_version.state, constants.ARCHIVED)
# Version lock does not exist
self.assertFalse(hasattr(updated_poll_version, 'versionlock'))
def is_locked(self, obj):
version = self.get_version(obj)
if version.state == DRAFT and version_is_locked(version):
return render_to_string(
"djangocms_version_locking/admin/locked_icon.html")
return ""
def inner(version, user):
draft_version = get_latest_draft_version(version)
lock = version_is_locked(draft_version)
if lock and lock.created_by != user:
raise ConditionFailed(message.format(user=lock.created_by))
def inner(version, user):
lock = version_is_locked(version)
if lock and lock.created_by != user:
raise ConditionFailed(message.format(user=lock.created_by))
