def create_log(instance, changes, action):
"""Create a new log entry"""
AuditLogEntry.objects.create(
content_object=instance,
object_verbose_name=str(instance),
action=action,
changes=changes,
user=get_current_user() if get_current_user()
and not get_current_user().is_anonymous else None)
def has_permission(self, action, obj=None, user=None):
"""Check if action can be performed on object"""
assert action in ['view', 'add', 'change', 'delete']
if not user:
user = get_current_user()
mapping = {
'view': {
'disabled': self.disable_view,
'signal': can_view,
'admin': self.admin_view_only,
},
'add': {
'disabled': self.disable_add,
'signal': can_add,
'admin': self.admin_add_only,
},
'change': {
'disabled': self.disable_change,
'signal': can_change,
'admin': self.admin_change_only,
},
'delete': {
'disabled': self.disable_delete,
'signal': can_delete,
'admin': self.admin_delete_only,
}
}
# First check if its disabled in config
if mapping[action]['disabled']:
return False
if mapping[action]['admin']:
return user and user.is_superuser
has_permission = True
# If user is set check Django permissions
if user:
has_permission = has_permission and user.has_perm(
'{app_label}.{action}_{model_name}'.format(
app_label=self.app_label,
action=action,
model_name=self.model_name,
).lower())
# If obj, check if any signal response has permission
if obj and not user.is_superuser:
assert isinstance(obj, self.model)
responses = mapping[action]['signal'].send(self.model,
instance=obj)
has_permission = has_permission and all(
[resp for recv, resp in responses])
return has_permission
def delay(self, *args, **kwargs):
"""Start task"""
task_id = uuid()
user = kwargs.pop('task_user', None)
description = kwargs.pop('task_description', self.task_description)
object = kwargs.pop('task_object', None)
model = kwargs.pop('task_model', self.task_model)
eta = kwargs.pop('task_eta', None)
queue = kwargs.pop('task_queue', self.task_queue)
eta = eta if isinstance(eta, datetime) else None
countdown = self.default_countdown if eta is None else None
model = object if object else model
if not user and get_current_user() and get_current_user(
).is_authenticated:
user = get_current_user()
Task.objects.create(
celery_task_id=task_id,
description=description,
identifier=self.name,
object_id=object.id if object else None,
object_type=ContentType.objects.get_for_model(model)
if model else None,
object_verbose_name=str(object) if object else '',
user=user,
status=Task.SCHEDULED if eta else Task.QUEUE,
scheduled_at=eta,
)
return self.apply_async(args=args,
kwargs=kwargs,
task_id=task_id,
eta=eta,
queue=queue,
countdown=countdown)
def __init__(self, *args, **kwargs):
"""Init"""
super().__init__(*args, **kwargs)
if utils.get_current_user().id == self.instance.id:
text = _(
'Are you sure you want to invalidate your current API key and generate a new one?'
)
else:
text = _(
'Are you sure you want to invalidate the API key and generate a new one for {user}?'
.format(user=self.instance))
self.helper = FormHelper()
self.helper.layout = Layout(
Div(HTML(text), css_class='alert alert-warning'))
def save(self, *args, update_fields=None, **kwargs):
"""Save model"""
try:
self.verbose_name = self.generate_verbose_name()
if update_fields:
update_fields.append('verbose_name')
except Exception:
pass
try:
if not self.pk and not self.created_by:
self.created_by = utils.get_current_user()
except Exception:
pass
return super().save(*args, update_fields=update_fields, **kwargs)
def add_user(sender=None, headers=None, body=None, **kwargs):
"""Add user to celery"""
user = utils.get_current_user()
headers['__metadata__'] = {
'trionyx_user_id': user.id if user else None
}
def __init__(self, *args, **kwargs):
"""Init form"""
super().__init__(*args, **kwargs)
from trionyx.widgets import widget_data, GraphWidget
self.fields['source'].choices = [
('', '------'),
*[(code, data['name'])
for code, data in widget_data.get_all_data(GraphWidget).items()],
('__custom__', _('Custom'))
]
content_type_map = ContentType.objects.get_for_models(
*list(models_config.get_all_models(utils.get_current_user())))
interval_fields = {}
graph_fields = {}
for config in models_config.get_all_configs():
if config.model not in content_type_map:
continue
graph_fields[content_type_map[config.model].id] = [{
'id':
'__count__',
'text':
str(_('Count records')),
}, *[{
'id': field.name,
'text': str(field.verbose_name)
} for field in config.get_fields()
if config.get_field_type(field) in ['int', 'float']]]
interval_fields[content_type_map[config.model].id] = [
{
'id': field.name,
'text': str(field.verbose_name)
} for field in config.get_fields(True)
if config.get_field_type(field) in ['date', 'datetime']
]
self.fields['model'].choices = [
(content_type.id, model._meta.verbose_name.capitalize())
for model, content_type in content_type_map.items()
]
self.helper = FormHelper()
self.helper.layout = Layout(
'source',
Depend([('source', r'__custom__')],
'icon',
Div(Div(
'model',
css_class="col-md-6",
),
Div(
HtmlTemplate(
'widgets/forms/model_field.html', {
'model_id': '#id_model',
'label': _('Field'),
'name': 'field',
'fields': graph_fields,
'value': self.initial.get('field'),
}),
css_class="col-md-6",
),
css_class="row"),
Div(Div(
HtmlTemplate(
'widgets/forms/model_field.html', {
'model_id': '#id_model',
'label': _('Interval field'),
'name': 'interval_field',
'fields': interval_fields,
'value': self.initial.get('interval_field'),
}),
css_class="col-md-6",
),
Div(
'interval_period',
css_class="col-md-6",
),
css_class="row"),
Fieldset(
_('Filters'),
Filters('filters', content_type_input_id='id_model'),
),
css_id='widget-custom-source'))