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(), }