def setUp(self):
super().init_data()
self.group = G(Group)
self.klass = G(Klass, schema=[{'name': 'a', 'type': 'string'}],
name='test',
description='test',
objects_acl={'*': Klass.get_endpoint_acl_permission_values()},
acl={'*': Klass.get_acl_permission_values()})
G(Membership, user=self.user, group=self.group)
self.group_2 = G(Group)
self.channel = G(Channel,
name='channel',
acl={'groups': {str(self.group_2.id): 'publish'}})
self.url = reverse('v2:dataobject-list', args=(self.instance.name, self.klass.name))
def test_adding_with_profile(self):
klass = Klass.get_user_profile()
klass.schema = [{'type': 'reference', 'target': 'self', 'name': 'ref'}]
klass.save()
data = {
'username': '******',
'password': '******',
'profile': {
'group_permissions': 'write'
}
}
response = self.client.post(self.url, data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
user = User.objects.last()
self.assertEqual(user.username, data['username'])
self.assertTrue(user.check_password(data['password']))
profile = self._get_user_profile(user)
self.assertEqual(profile.group_permissions, Role.ROLE_CHOICES.WRITE)
data = {
'username': '******',
'password': '******',
'profile': {
'ref': profile.id
}
}
response = self.client.post(self.url, data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.data['profile']['ref'], {
'type': 'reference',
'target': 'self',
'value': profile.id
})
def prepare_profile(self, object_list):
"""
Add User Profile Object to each User.
Django ORM is kinda stupid and we cannot do select_related on filtered reverse relation.
So this is a workaround to at have instead of a lookup per User, one batch lookup.
"""
user_profile_klass = Klass.get_user_profile()
profile_map = {}
obj_list = []
for obj in object_list:
if hasattr(obj,
'_profile_cache') and obj._profile_cache is not None:
profile_map[obj.id] = obj._profile_cache
else:
obj_list.append(obj)
if obj_list:
profiles = DataObject.objects.filter(_klass=user_profile_klass,
owner__in=obj_list)
for profile in profiles:
profile._klass = user_profile_klass
profile_map[profile.owner_id] = profile
return profile_map
def __init__(self, *args, **kwargs):
# Skip loading cache during schema generation
if 'context' in kwargs and kwargs['context'].get(
'include_dynamic_fields', True):
user_profile_klass = Klass.get_user_profile()
DataObject.load_klass(user_profile_klass)
super().__init__(*args, **kwargs)
def setUp(self):
super().init_data('admin')
self.url = reverse(self.url_name,
args=(
self.instance.name,
self.user.id,
))
with override_settings(POST_TRANSACTION_SUCCESS_EAGER=True):
klass = Klass.get_user_profile()
klass.schema = [{'type': 'datetime', 'name': 'datetime'}]
klass.save()
def setUp(self):
super().setUp()
self.url = reverse(self.url_name, args=(self.instance.name, ))
set_current_instance(self.instance)
user_profile = Klass.get_user_profile()
user_profile.schema = [{
'name': 'int',
'type': 'integer',
'filter_index': True
}]
user_profile.save()
# Add one random dataobject to make ids not in line with users
G(DataObject)
DataObject.load_klass(user_profile)
self.user1 = User.objects.create(username='******',
password='******',
profile_data={'int': 100})
self.user2 = User.objects.create(username='******',
password='******',
profile_data={'int': 150})
def initial(self, request, *args, **kwargs):
initial = super().initial(request, *args, **kwargs)
self.klass = Klass.get_user_profile()
DataObject.load_klass(self.klass)
return initial
def initialize_request(self, request, *args, **kwargs):
request = super().initialize_request(request, *args, **kwargs)
if request.instance:
self.klass = Klass.get_user_profile()
return request
def create_trigger(self):
return Trigger.objects.create(signal='post_create',
codebox=self.codebox,
klass=Klass.get_user_profile())
def get_lookup(self, value):
return DataObject.objects.get(_klass=Klass.get_user_profile(),
owner=value)
def _get_user_profile(self, user):
user_profile_klass = Klass.get_user_profile()
return DataObject.objects.filter(_klass=user_profile_klass,
owner=user).get()
def _get_profile(cls, instance):
user_profile_klass = Klass.get_user_profile()
return DataObject.objects.filter(
_klass=user_profile_klass,
owner=instance).select_for_update().get()