def test_save_tenant_set(self):
unset_current_tenant()
from .models import Project
account = self.account_fr
account_2 = self.account_us
project = Project(account=account, name="test save fr")
project.save()
project2 = Project(account=account_2, name="test save us")
project2.save()
self.assertEqual(Project.objects.count(), 2)
set_current_tenant(account)
project.name = "test update name"
project.save()
current_tenant = get_current_tenant()
self.assertEqual(current_tenant, account)
unset_current_tenant()
project = Project.objects.filter(account=account).first()
self.assertEqual(project.name, "test update name")
def test_save_tenant_set_different_than_object(self):
unset_current_tenant()
from .models import Project
account = self.account_fr
account_2 = self.account_us
project = Project(account=account, name='test save fr')
project.save()
project2 = Project(account=account_2, name='test save us')
project2.save()
self.assertEqual(Project.objects.count(), 2)
set_current_tenant(account_2)
project.name = 'test update name'
project.save()
current_tenant = get_current_tenant()
self.assertEqual(current_tenant, account_2)
unset_current_tenant()
project = Project.objects.filter(account=account).first()
self.assertEqual(project.name, 'test update name')
def _get_permissions(self, user_obj, obj, from_name):
current_shop = get_current_tenant()
if current_shop:
if not user_obj.is_active or user_obj.is_anonymous or obj is not None:
return set()
perm_cache_name = '_{}_perm_cache'.format(from_name)
if not hasattr(user_obj, perm_cache_name):
if user_obj.is_shop_admin_user:
perms = self.shop_ADMIN_PERMISSIONS
else:
perms_objs = getattr(
self,
'_get_{}_permissions'.format(from_name))(user_obj)
perms_objs = perms_objs.values_list(
'content_type__app_label', 'codename').order_by()
perms = set()
for ct, name in perms_objs:
perm_name = '{}.{}'.format(ct, name)
if perm_name in self.shop_ADMIN_PERMISSIONS:
perms.add(perm_name)
setattr(user_obj, perm_cache_name, perms)
return getattr(user_obj, perm_cache_name)
else:
return super()._get_permissions(user_obj, obj, from_name)
def save(self, commit=True):
user = super().save(commit=False)
current_shop = get_current_tenant()
user.shop = current_shop
if commit:
user.save()
return user
def test_set_current_tenant(self):
from .models import Project
projects = self.projects
account = projects[0].account
set_current_tenant(account)
self.assertEqual(get_current_tenant(), account)
unset_current_tenant()
def get_user_page_context(self):
company = get_current_tenant()
if company is None:
return {}
client = Client.objects.filter(vk_user_id=self.vk_user_id).first()
day_start = date.today()
day_end = day_start + timedelta(weeks=1)
# Prepare events
events = []
for ec in EventClass.objects.in_range(day_start, day_end):
events.extend(list(ec.get_calendar(day_start, day_end).values()))
events = sorted(
events, key=lambda x: datetime.combine(x.date, x.start_time))
# Prepare event class one time visit price
ec_otv_price = {}
for event in events:
ec_id = event.event_class_id
if ec_id in ec_otv_price:
continue
ec_otv_price[ec_id] = event.event_class.otv_price
# Prepare count of clients signed for one event
a_count = (
Attendance.objects
.filter(event__in=[x.id for x in events], signed_up=True)
.annotate(client_count=Count('event'))
.values('event_id', 'client_count')
)
event_signed_count = {
x['event_id']: x['client_count'] for x in a_count
}
# Find events where this client is marked
my_events = []
if client:
my_events = Attendance.objects.filter(
event__in=[x.id for x in events],
signed_up=True,
client=client
).values_list('event_id', flat=True)
return {
'is_admin': False,
'vk_id': self.vk_user_id,
'vk_group': self.vk_group_id,
'client': client,
'my_events': my_events,
'events': events,
'ec_otv_price': ec_otv_price,
'event_signed_count': event_signed_count
}
def has_permission(self, request, view):
is_authenticated = super().has_permission(request, view)
if not is_authenticated:
return False
current_shop = get_current_tenant()
if not current_shop:
return False
# TODO: we need to cache this
return request.user.shop_customer_members.filter(
shop=current_shop).exists()
def clean_username(self):
username = self.cleaned_data['username']
# Don't check username uniqueness if it wasn't changed
if 'username' not in self.changed_data:
return username
current_tenant = get_current_tenant()
set_current_tenant(None)
if get_user_model().objects.filter(username=username).exists():
set_current_tenant(current_tenant)
raise ValidationError(_('User with name %(username)s exists'),
code='invalid',
params={'username': username})
set_current_tenant(current_tenant)
return username
def get_admin_page_context(self):
context_data = {
'app_id': self.app_id,
'is_admin': True,
'has_company': True,
'has_access_token': False,
'vk_group': self.vk_group_id
}
company = get_current_tenant()
if company is None:
context_data['has_company'] = False
else:
context_data['has_access_token'] = (
company.vk_access_token is not None
)
context_data['vk_access_token'] = company.vk_access_token
context_data['vk_confirmation_token'] = \
company.vk_confirmation_token
return context_data
def enqueue(method: str, *args, **kwargs):
payload = {
'method': method,
'args': args,
'kwargs': kwargs,
'company_id': get_current_tenant().id
}
# The API expects a payload of type bytes.
json_payload = json.dumps(payload)
converted_payload = json_payload.encode()
if settings.USE_GOOGLE_TASKS:
project = settings.GCP_TASK_PROJECT
queue = settings.GCP_TASK_QUEUE
location = settings.GCP_TASK_LOCATION
client = tasks_v2beta3.CloudTasksClient()
# Construct the fully qualified queue name.
parent = client.queue_path(project, location, queue)
# Construct the request body.
task = {
'app_engine_http_request': { # Specify the type of request.
'http_method': 'POST',
'relative_uri': '/google_task_handler/'
}
}
# Add the payload to the request.
task['app_engine_http_request']['body'] = converted_payload
# Use the client to build and send the task.
response = client.create_task(parent, task)
else:
do_result = do(converted_payload)
if not do_result == 'OK':
raise RuntimeError(f'DO result: {do_result}')
def filter_choice_queryset(self):
"""
Class initialized ChoiceFields don't handle client tenant,
so we must manually apply filter on such fields
This function must be applied in __init__ and
**after** super().__init__
"""
tenant = get_current_tenant()
if not tenant:
return
for field in self.fields.values():
if isinstance(
field,
(forms.ModelChoiceField, forms.ModelMultipleChoiceField)):
# Check if the model being used for the ModelChoiceField
# has a tenant model field
if hasattr(field.queryset.model, 'tenant_id'):
# Add filter restricting queryset to values to this
# tenant only.
kwargs = {field.queryset.model.tenant_id: tenant}
field.queryset = field.queryset.filter(**kwargs)
def is_not_hidden_managers_in_company(user) -> bool:
return (get_current_tenant().id
not in settings.DISABLE_MANAGER_PERMISSION_FOR_COMPANIES)
def get_context_data(self, *, object_list=None, **kwargs):
context = super().get_context_data(object_list=object_list, **kwargs)
context['has_active_event_class'] = EventClass.objects.active().exists(
)
context['vk_group_id'] = get_current_tenant().vk_group_id
return context
def get_object(self, queryset=None):
current_shop = get_current_tenant()
return current_shop
def get_object(self, queryset=None):
return get_current_tenant()
def get_queryset(self, request):
qs = super().get_queryset(request)
current_shop = get_current_tenant()
return qs.filter(shop=current_shop)
def has_permission(self, request):
current_shop = get_current_tenant()
return request.user.is_active and current_shop and (
request.user.shop_id == current_shop.id)
def company(request):
return {
'company': get_current_tenant(),
}
