def __init__(self):
self.clear()
request_finished.connect(self._request_finished_receiver)
if 'reversion' in django_settings.INSTALLED_APPS:
from reversion.signals import post_revision_commit
post_revision_commit.connect(self._post_revision_commit)
def testRevisionSignals(self):
pre_revision_receiver_called = []
def pre_revision_receiver(**kwargs):
self.assertEqual(kwargs["instances"], [self.test11])
self.assertTrue(isinstance(kwargs["revision"], Revision))
self.assertEqual(len(kwargs["versions"]), 1)
pre_revision_receiver_called.append(True)
post_revision_receiver_called = []
def post_revision_receiver(**kwargs):
self.assertEqual(kwargs["instances"], [self.test11])
self.assertTrue(isinstance(kwargs["revision"], Revision))
self.assertEqual(len(kwargs["versions"]), 1)
post_revision_receiver_called.append(True)
pre_revision_commit.connect(pre_revision_receiver)
post_revision_commit.connect(post_revision_receiver)
# Create a revision.
with create_revision():
self.test11.save()
# Check the signals were called.
self.assertTrue(pre_revision_receiver_called)
self.assertTrue(post_revision_receiver_called)
def setup(self):
from aristotle_mdr.models import _concept, Workgroup, ReviewRequest, concept_visibility_updated
# post_save.connect(self.handle_concept_save, sender=_concept)
post_revision_commit.connect(self.handle_concept_revision)
pre_delete.connect(self.handle_concept_delete, sender=_concept)
post_save.connect(self.update_visibility_review_request,
sender=ReviewRequest)
m2m_changed.connect(self.update_visibility_review_request,
sender=ReviewRequest.concepts.through)
concept_visibility_updated.connect(self.handle_concept_recache)
super(AristotleSignalProcessor, self).setup()
def setup_signals():
Team = apps.get_model(app_label='team', model_name='Team')
Step = apps.get_model(app_label='project', model_name='Step')
UserTeamRole = apps.get_model(app_label='team', model_name='UserTeamRole')
post_save.connect(post_save_step_handler, sender=Step)
post_save.connect(post_save_team_handler, sender=Team)
post_save.connect(post_save_user_team_role, sender=UserTeamRole)
post_delete.connect(post_delete_user_team_role, sender=UserTeamRole)
post_revision_commit.connect(post_save_team)
def __init__(self,
id=None,
parent_log=undefined,
related_objects=None,
slug=None,
extra_data=None,
start=None,
stop=None,
error_message=None,
time=None,
release=None):
self.id = id or (uuid4() if self.logger_name else None)
self.parent = SecurityLogger.loggers[
-1] if SecurityLogger.loggers else None
self.related_objects = set()
if related_objects:
self.add_related_objects(*related_objects)
self.start = start
self.stop = stop
self.error_message = error_message
self.release = release or settings.RELEASE
self.slug = slug
if self.parent:
self.related_objects |= self.parent.related_objects
if not self.slug:
self.slug = self.parent.slug
parent_with_id = self._get_parent_with_id()
self.parent_log = (
'{}|{}'.format(parent_with_id.logger_name, parent_with_id.id)
if parent_with_id else
None) if parent_log is undefined else parent_log
self._extra_data = extra_data
if self._extra_data is None:
self._extra_data = self.parent.extra_data if self.parent else {}
if self.store:
SecurityLogger.loggers.append(self)
if 'reversion' in django_settings.INSTALLED_APPS:
from reversion.signals import post_revision_commit
post_revision_commit.connect(self._post_revision_commit,
weak=False)
self.backend_logs = AttrDict()
self.stream = None
def _create_revision(self):
post_revision_commit.connect(self._handle_revision_commit, dispatch_uid='handle_revision_commit')
with reversion.create_revision():
reversion.set_comment(self.comment)
reversion.set_user(self.user)
# revision plugins and title for given language
for plugin_instance in self.get_plugin_instances():
reversion.add_to_revision(plugin_instance)
reversion.add_to_revision(self.get_page_title())
post_revision_commit.disconnect(dispatch_uid='handle_revision_commit')
try:
assert self._revision is not None
except AssertionError:
raise PageRevisionError(_(u'Revision creation failed'))
return self._revision
def save_model(self, request, obj, form, change):
"""
In case new_version button is ticked, the new revision is created;
in case that new_version button IS NOT ticked, there is no new
revision created, only the data in Probe table in db is updated.
"""
sh = SharedInfo()
if obj and sh.getgroup():
obj.group = sh.getgroup().name
sh.delgroup()
elif not obj and sh.getgroup():
obj.group = sh.getgroup()
sh.delgroup()
if request.user.has_perm('poem.groupown_probe') \
or request.user.is_superuser:
obj.user = request.user.username
if form.cleaned_data['new_version'] and change or not change:
obj.save()
if form.cleaned_data['update_metric']:
post_revision_commit.connect(update_metric)
return
elif not form.cleaned_data['new_version'] and change:
version = Version.objects.get_for_object(obj)
pk = version[0].object_id
pk0 = version[0].id
data = json.loads(Version.objects.get(pk=pk0).serialized_data)
new_serialized_field = {
'name': form.cleaned_data['name'],
'version': form.cleaned_data['version'],
'description': form.cleaned_data['description'],
'comment': form.cleaned_data['comment'],
'repository': form.cleaned_data['repository'],
'docurl': form.cleaned_data['docurl'],
'group': obj.group,
'user': obj.user
}
data[0]['fields'] = new_serialized_field
Version.objects.filter(pk=pk0).update(
serialized_data=json.dumps(data))
Probe.objects.filter(pk=pk).update(**new_serialized_field)
else:
raise PermissionDenied()
def testRevisionSignals(self):
pre_revision_receiver_called = []
def pre_revision_receiver(**kwargs):
self.assertEqual(kwargs["instances"], [self.test11])
self.assertTrue(isinstance(kwargs["revision"], Revision))
self.assertEqual(len(kwargs["versions"]), 1)
pre_revision_receiver_called.append(True)
post_revision_receiver_called = []
def post_revision_receiver(**kwargs):
self.assertEqual(kwargs["instances"], [self.test11])
self.assertTrue(isinstance(kwargs["revision"], Revision))
self.assertEqual(len(kwargs["versions"]), 1)
post_revision_receiver_called.append(True)
pre_revision_commit.connect(pre_revision_receiver)
post_revision_commit.connect(post_revision_receiver)
# Create a revision.
with create_revision():
self.test11.save()
# Check the signals were called.
self.assertTrue(pre_revision_receiver_called)
self.assertTrue(post_revision_receiver_called)
for version in versions:
instance = version.object
model = instance.__class__
if not auditlog.is_enabled(model):
continue
tag = auditlog.model_tag(model)
action = f"{tag}:save"
with auditlog.Context() as ctx:
ctx.log(action, log_object=instance)
post_revision_commit.connect(auditlog_on_save)
@receiver(post_delete)
def auditlog_on_delete(sender, **kwargs):
"""
auditlog object deletions
"""
if not reversion.is_registered(sender):
return
if not auditlog.is_enabled(sender):
return
tag = auditlog.model_tag(sender)
from django.contrib.contenttypes.models import ContentType
class ExtRevision(models.Model):
class Meta:
app_label = 'poem'
version = models.CharField(max_length=128, null=False, help_text='Version')
probeid = models.BigIntegerField()
revision = models.OneToOneField(Revision, on_delete=models.CASCADE)
def on_revision_commit(revision, sender, signal, versions, **kwargs):
if len(versions) == 1:
version = versions[0]
ct = ContentType.objects.get_for_id(version.content_type_id)
model_changed = ct.model_class()
instance = ct.get_object_for_this_type(id=int(version.object_id))
if (len(versions) == 1 and isinstance(instance, Probe)):
ExtRevision.objects.create(probeid=instance.id,
version=instance.version,
revision=revision)
instance.datetime = revision.date_created
instance.save()
# delete extra revision that plugin creates with empty comment
if revision.id and not revision.comment:
revision.delete()
post_revision_commit.connect(on_revision_commit)
if 'security.reversion_log' in django_settings.INSTALLED_APPS:
if 'reversion' not in django_settings.INSTALLED_APPS:
raise ImproperlyConfigured('For reversion log is necessary install "django-reversion"')
# Supports two version of reversion library
try:
from reversion.signals import post_revision_commit
def create_revision_request_log(sender, revision, versions, **kwargs):
from security.reversion_log.models import InputRequestRevision
connection = get_connection()
if getattr(connection, 'input_logged_request', False):
InputRequestRevision.objects.create(logged_request=connection.input_logged_request, revision=revision)
post_revision_commit.connect(create_revision_request_log)
except ImportError:
pass
class LogMiddleware(MiddlewareMixin):
response_redirect_class = http.HttpResponsePermanentRedirect
def process_request(self, request):
connection = get_connection()
view = get_view_from_request_or_none(request)
if (get_ip(request) not in settings.LOG_REQUEST_IGNORE_IP
and request.path not in settings.LOG_REQUEST_IGNORE_URL_PATHS
and not getattr(view, 'log_exempt', False)):
def setup(self):
from aristotle_mdr.models import _concept, Workgroup
# post_save.connect(self.handle_concept_save, sender=_concept)
post_revision_commit.connect(self.handle_concept_revision)
pre_delete.connect(self.handle_concept_delete, sender=_concept)
super(AristotleSignalProcessor, self).setup()
def __enter__(self):
self.action = {}
self.revision = {}
post_revision_commit.connect(self.post_revision_commit)
return self
def __enter__(self):
self.action = {}
self.revision = {}
post_revision_commit.connect(self.post_revision_commit)
return self
from django.db.models.signals import post_save, pre_delete
from django.dispatch.dispatcher import receiver
from reversion.revisions import create_revision
from reversion.signals import post_revision_commit, pre_revision_commit
from cmj.sigad.models import Documento, Revisao, CMSMixin
def save_revision_documents(sender, **kwargs):
versions = list(kwargs.get('versions', []))
if not versions:
return
for version in versions:
if CMSMixin in type.mro(type(version.object)):
with create_revision(False):
Revisao.gerar_revisao(
version.object, version.revision.user)
post_revision_commit.connect(save_revision_documents, sender=create_revision)
@receiver(pre_delete, sender=Documento, dispatch_uid='documento_delete_signal')
def log_deleted_documento(sender, instance, using, **kwargs):
print('passou log_deleted_documento pk = %s, parent = %s' % (
instance.pk,
instance.parent.pk if instance.parent else ''))
def setup(self):
from aristotle_mdr.models import _concept, Workgroup
# post_save.connect(self.handle_concept_save, sender=_concept)
post_revision_commit.connect(self.handle_concept_revision)
pre_delete.connect(self.handle_concept_delete, sender=_concept)
super(AristotleSignalProcessor, self).setup()
from django.db.models.signals import pre_delete
from django.dispatch.dispatcher import receiver
from reversion.revisions import create_revision
from reversion.signals import post_revision_commit
from cmj.sigad.models import Documento, Revisao, CMSMixin
def save_revision_documents(sender, **kwargs):
versions = list(kwargs.get('versions', []))
if not versions:
return
for version in versions:
if CMSMixin in type.mro(type(version.object)):
with create_revision(False):
Revisao.gerar_revisao(version.object, version.revision.user)
post_revision_commit.connect(save_revision_documents, sender=create_revision)
@receiver(pre_delete, sender=Documento, dispatch_uid='documento_delete_signal')
def log_deleted_documento(sender, instance, using, **kwargs):
print('passou log_deleted_documento pk = %s, parent = %s' %
(instance.pk, instance.parent.pk if instance.parent else ''))
