def set_kc_require_auth(user_id, require_auth): ''' Configure whether or not authentication is required to see and submit data to a user's projects. WRITES to KC's UserProfile.require_auth :param int user_id: ID/primary key of the :py:class:`User` object. :param bool require_auth: The desired setting. ''' # Get/generate the user's auth. token. user = User.objects.get(pk=user_id) token, is_new = Token.objects.get_or_create(user=user) # Trigger the user's KoBoCAT profile to be generated if it doesn't exist. url = settings.KOBOCAT_URL + '/api/v1/user' response = requests.get(url, headers={'Authorization': 'Token ' + token.key}) if not response.status_code == 200: raise RuntimeError('Bad HTTP status code `{}` when retrieving KoBoCAT user profile' ' for `{}`.'.format(response.status_code, user.username)) try: profile = _models.UserProfile.objects.get( user_id=user_id) if profile.require_auth != require_auth: profile.require_auth = require_auth profile.save() except ProgrammingError as e: raise ProgrammingError(u'set_kc_require_auth error accessing kobocat ' u'tables: {}'.format(e.message))
def _wrapper(*args, **kwargs): try: return func(*args, **kwargs) except ProgrammingError as e: raise ProgrammingError( 'kc_access error accessing kobocat tables: {}'.format(str(e)) )
def payment_post_before_handler(sender, **kwargs): """ Триггер проверки контракта перед сохранением оплаты :param sender: :param kwargs: :return: """ if kwargs['raw']: return instance = kwargs['instance'] contract = Contract.objects.get(pk=instance.id_contract.id) print(contract.contract_state) if contract.contract_state == CONTRACT_STATE_DRAFT: raise ProgrammingError( 'Контракт в состоянии черновика, оплата невозможна!') if contract.contract_state == CONTRACT_STATE_READY: raise ProgrammingError('Контракт исполнен!')
def create(self, token): if self.account_id: raise ProgrammingError('Stripe Account is already created') self._account = stripe.Account.create_external_account( self.connect_account.account_id, external_account=token) self.account_id = self._account.id self.save()
def save(self, *args, **kwargs): is_new = self._state.adding if is_new: # This is a CREATE operation # Check that the chat referenced does not contain more than 1 other user in the chat in the database. chat_users_in_chat = self.chat_id.chatuser_set.all() # Check that the chat you want to insert the chat user in is not already full if len(chat_users_in_chat) >= 2: raise DataError( "Cannot assign this ChatUser instance to a Chat with pk %(pk)s because this \ chat already contains at least 2 users (the chat is full)" % {'pk': self.chat_id.pk}) # Check that as a result of inserting the chat user instances you won't have # two chats in the database after calling save() that each have the 'same' chat users. # # For example: # A chat with pk 16 with Joe and Jessica in the chat # and another chat with pk 32 with Joe and Jessica again. # # This check is necessary as to not violate the business logic that there should # not be more than one chat between two different warframe accounts to capture the # idea of a sort of "unique chat area" that two warframe accounts use to chat between each other. if len(chat_users_in_chat) == 1: chat_user_in_chat = chat_users_in_chat[0] chat_user_wfa = chat_user_in_chat.warframe_account_id #print("chat_user_in_chat.warframe_account_id.pk: ") #print(chat_user_in_chat.warframe_account_id.pk) #print("self.warframe_account_id.pk:") #print(self.warframe_account_id.pk) #print("chat_user_in_chat.warframe_account_id.pk != (self.warframe_account_id.pk):") #print(chat_user_in_chat.warframe_account_id.pk != self.warframe_account_id.pk) if (chat_user_in_chat.warframe_account_id.pk != (self.warframe_account_id.pk)): if (self._chat_between_wfa_already_exists( chat_user_wfa, self.warframe_account_id)): raise DataError("Attempted to add a chat user to a chat that would result " + \ "in duplicate chats between two particular WarframeAcccount instances.") else: # chat_user_in_chat's warframe_account_id is the same as self.warframe_account_id # meaning that after the save() there will be two warframe accounts in the same chat room. # But since this case is handled by the 'no_duplicate_warframe_accounts_in_chat' constraint # will just let the database constraint handle it. pass else: # This is an update. Don't do anything on an update since a chat user cannot be updated raise ProgrammingError( "An attempt was made to update a ChatUser model. ChatUser should not and cannot be updated!" ) super(ChatUser, self).save(*args, **kwargs)
def get_route_path(route): if hasattr(route, '_route'): route = route._route elif hasattr(route, '_regex'): route = route._regex else: raise ProgrammingError( 'Route is not available on {} object'.format(route)) return route.lstrip('^').rstrip('$')
def set_kc_require_auth(user_id, require_auth): ''' WRITES to KC's UserProfile.require_auth ''' try: profile, created = _models.UserProfile.objects.get_or_create( user_id=user_id) if profile.require_auth != require_auth: profile.require_auth = require_auth profile.save() except ProgrammingError as e: raise ProgrammingError(u'set_kc_require_auth error accessing kobocat ' u'tables: {}'.format(e.message))
def register_anonym(models): for model, cls_anonym in models: if model._meta.db_table not in connection.introspection.table_names(): raise ProgrammingError(f'Model {Anonymizer.key(model)} ' f'registered, but table does not exist') cls_anonym.init_meta(model) anonym_fields = set(cls_anonym.get_fields_names()) model_fields = set(field.name for field in model._meta.get_fields() if isinstance(field, Field)) if hasattr(cls_anonym.Meta, 'exclude_fields'): exclude_fields = set(cls_anonym.Meta.exclude_fields) else: exclude_fields = model_fields - anonym_fields exclude_fields.update(cls_anonym.get_relation_fields(model)) if exclude_fields & anonym_fields: raise LookupError( f'Fields {list(exclude_fields & anonym_fields)} of model ' f'{Anonymizer.key(model)} are present in both anonymization ' f'and excluded lists') specified_fields = exclude_fields | anonym_fields if specified_fields < model_fields: raise LookupError( f'Fields {list(model_fields - specified_fields)} were not ' f'registered in {Anonymizer.key(cls_anonym)} class for ' f'{Anonymizer.key(model)} model') if specified_fields > model_fields: raise LookupError( f'Fields {list(specified_fields - model_fields)} present in ' f'{Anonymizer.key(cls_anonym)} class, but does not exist in ' f'{Anonymizer.key(model)} model' '') if specified_fields != model_fields: raise LookupError( f'Fields in {Anonymizer.key(cls_anonym)} are not ' f'the same as in {Anonymizer.key(model)} Check spelling') if Anonymizer.key(model) in Anonymizer.anonym_models.keys(): raise ValueError(f'Model {Anonymizer.key(model)} ' f'is already declared in register_anonym') Anonymizer.anonym_models[Anonymizer.key(model)] = cls_anonym
def _validate_lookup(self, question, lookup): try: valid_lookups = self.VALID_LOOKUPS[question.type] except KeyError: # pragma: no cover # Not covered in tests - this only happens when you add a new # question type and forget to update the lookup config above. In # that case, the fix is simple - go up a few lines and adjust the # VALID_LOOKUPS dict. raise ProgrammingError( f"Valid lookups not configured for question type {question.type}" ) if lookup not in valid_lookups: raise exceptions.ValidationError( f"Invalid lookup for question slug={question.slug} ({question.type.upper()}): {lookup.upper()}" )
def get_db_table(cls, sharding): db_table = generate_db_table_name(cls, sharding) if db_table not in _shard_tables: register_model(cls, sharding) with closing(connection.cursor()) as cursor: tables = [ table_info.name for table_info in connection.introspection.get_table_list(cursor) ] if db_table not in tables: raise ProgrammingError(f"relation {db_table} does not exist") return db_table
def _get_declared_fields( cls, name: str, bases: Sequence, attrs: Dict[str, Any], meta_fields: Sequence[str], ) -> Dict[str, Field]: bases_fields = cls._get_declared_fields_from_bases(bases=bases) local_fields = { name: attrs.pop(name) for name, obj in list(attrs.items()) if isinstance(obj, Field) } if any(field not in meta_fields for field in local_fields): raise ProgrammingError( f"[{name}] One or more declared fields are not present in Meta.fields" ) return {**bases_fields, **local_fields}
def register_clean(models): for model, cls_anonym in models: if not (cls_anonym == AnonymBase or isinstance(cls_anonym, AnonymBase)): raise TypeError( f'Class used for cleaning model {Anonymizer.key(model)} does ' f'not belong to the allowed {Anonymizer.key(AnonymBase)}') if model._meta.db_table not in connection.introspection.table_names(): raise ProgrammingError(f'Model {Anonymizer.key(model)} ' f'registered, but table does not exist') queryset = model.objects.all() queryset.truncate = cls_anonym.truncate if Anonymizer.key(model) in Anonymizer.clean_models.keys(): raise ValueError(f'Model {Anonymizer.key(model)} ' f'is already declared in register_clean') Anonymizer.clean_models[Anonymizer.key(model)] = queryset
def set_kc_require_auth(user_id, require_auth): ''' Configure whether or not authentication is required to see and submit data to a user's projects. WRITES to KC's UserProfile.require_auth :param int user_id: ID/primary key of the :py:class:`User` object. :param bool require_auth: The desired setting. ''' user = User.objects.get(pk=user_id) _trigger_kc_profile_creation(user) token, _ = Token.objects.get_or_create(user=user) with transaction.atomic(): try: profile = _models.UserProfile.objects.get(user_id=user_id) except ProgrammingError as e: raise ProgrammingError(u'set_kc_require_auth error accessing ' u'kobocat tables: {}'.format(repr(e))) else: if profile.require_auth != require_auth: profile.require_auth = require_auth profile.save()
def create_test_db(self, verbosity=1, autoclobber=False, serialize=True, keepdb=False): """ Create a test database, prompting the user for confirmation if the database already exists. Return the name of the test database created. """ # Don't import django.core.management if it isn't needed. test_database_name = self._get_test_db_name() if verbosity >= 1: action = 'Creating' if keepdb: action = "Using existing" print("%s test database for alias %s..." % ( action, self._get_database_display_str(verbosity, test_database_name), )) # We could skip this call if keepdb is True, but we instead # give it the keepdb param. This is to handle the case # where the test DB doesn't exist, in which case we need to # create it, then just not destroy it. If we instead skip # this, we will get an exception. self._create_test_db(verbosity, autoclobber, keepdb) self.connection.close() settings.DATABASES[self.connection.alias]["NAME"] = test_database_name self.connection.settings_dict["NAME"] = test_database_name if keepdb: return cur = self.connection.cursor() cur.execute( raw_sql( "CREATE EXTENSION IF NOT EXISTS pg_trgm WITH SCHEMA pg_catalog;" )) header = """ CREATE EXTENSION IF NOT EXISTS postgis WITH SCHEMA {schema}; CREATE EXTENSION IF NOT EXISTS fuzzystrmatch WITH SCHEMA {schema}; CREATE EXTENSION IF NOT EXISTS pg_trgm WITH SCHEMA {schema}; SET default_tablespace = ''; """ public_dump = Path(settings.ETOOLS_DUMP_LOCATION) / "public.sqldump" # tenant_dump = Path(settings.ETOOLS_DUMP_LOCATION) / "tenant.sql" if not public_dump.exists(): raise ProgrammingError(f"'{public_dump}' not not found") # if not tenant_dump.exists(): # raise ProgrammingError(f"'{tenant_dump}' not not found") for i, schema in enumerate(settings.TEST_SCHEMAS, 1): tenant_dump = Path( settings.ETOOLS_DUMP_LOCATION) / ("tenant%s.sql" % i) if not tenant_dump.exists(): raise ProgrammingError(f"'{tenant_dump}' not not found") if verbosity >= 1: print("Restoring %s" % public_dump) cmds = [ "pg_restore", "-U", self.connection.settings_dict['USER'], "-p", str(self.connection.settings_dict['PORT']), "-h", self.connection.settings_dict['HOST'], "-d", self.connection.settings_dict['NAME'], "--no-owner", "--clean", "--if-exists", "--disable-triggers", "--exit-on-error", str(public_dump) ] try: subprocess.check_call(cmds) except BaseException as e: print(" ======= UNRECOVERABLE ERROR ========= ") print(e) print(" ".join(cmds)) if hasattr(sys, '_called_from_test'): import pytest pytest.exit("--") sys.exit(2) try: cur.execute(raw_sql(header.format(schema='public'))) except BaseException as e: raise BaseException(f"Error creating schema 'public'") from e for i, schema in enumerate(settings.TEST_SCHEMAS, 1): tenant_dump = Path( settings.ETOOLS_DUMP_LOCATION) / ("tenant%s.sql" % i) if verbosity >= 1: print("Creating schema %s" % schema) try: sql = tenant_dump.read_text() sql = sql.replace("[[schema]]", schema).replace( "SET default_tablespace = '';", header.format(schema=schema)) cur.execute(raw_sql(sql)) except BaseException as e: raise BaseException(f"Error creating schema {schema}") from e self.connection.close() self.connection.ensure_connection() return test_database_name
def __init__(self): raise ProgrammingError(f'{self.__class__.__name__} must not be initialized')
def _wrapper(*args, **kwargs): try: return func(*args, **kwargs) except ProgrammingError as e: raise ProgrammingError('kc_reader error accessing kobocat ' 'tables: {}'.format(e.message))