Python ExternalAccount.save方法代码示例

# 需要导入模块: from website.oauth.models import ExternalAccount [as 别名]
# 或者: from website.oauth.models.ExternalAccount import save [as 别名]
    def test_dataverse_add_external_account_existing(self, mock_connection):
        mock_connection.return_value = create_mock_connection()
        host = 'myfakehost.data.verse'
        token = 'dont-use-this-token-in-other-tests'
        display_name = 'loaded_version'

        # Save an existing version
        external_account = ExternalAccount(
            provider='dataverse',
            provider_name='Dataverse',
            display_name=display_name,
            oauth_key=host,
            oauth_secret=token,
            provider_id=token,
        )
        external_account.save()

        url = api_url_for('dataverse_add_user_account')
        params = {'host': host, 'api_token': token}
        self.app.post_json(url, params, auth=self.user.auth)
        self.user.reload()

        assert_equal(len(self.user.external_accounts), 1)
        external_account = self.user.external_accounts[0]
        assert_equal(external_account.provider, 'dataverse')
        assert_equal(external_account.oauth_key, host)
        assert_equal(external_account.oauth_secret, token)
        # Ensure we got the loaded version
        assert_equal(external_account.display_name, display_name)

# 需要导入模块: from website.oauth.models import ExternalAccount [as 别名]
# 或者: from website.oauth.models.ExternalAccount import save [as 别名]
def migrate_to_external_account(user_settings_document):
    user_info = utils.get_user_info(access_key=user_settings_document['access_key'], secret_key=user_settings_document['secret_key'])
    user = User.load(user_settings_document['owner'])
    if not user_info:
        return (None, None, None)

    new = False
    try:
        external_account = ExternalAccount.find_one(Q('provider_id', 'eq', user_info.id))
        logger.info('Duplicate account use found: s3usersettings {0} with id {1}'.format(user_settings_document['_id'], user._id))
    except NoResultsFound:
        new = True
        external_account = ExternalAccount(
            provider=PROVIDER,
            provider_name=PROVIDER_NAME,
            provider_id=user_info.id,
            oauth_key=user_settings_document['access_key'],
            oauth_secret=user_settings_document['secret_key'],
            display_name=user_info.display_name,
        )
        external_account.save()

    user.external_accounts.append(external_account)
    user.save()
    return external_account, user, new

# 需要导入模块: from website.oauth.models import ExternalAccount [as 别名]
# 或者: from website.oauth.models.ExternalAccount import save [as 别名]
def s3_add_user_account(auth, **kwargs):
    """Verifies new external account credentials and adds to user's list"""
    try:
        access_key = request.json['access_key']
        secret_key = request.json['secret_key']
    except KeyError:
        raise HTTPError(httplib.BAD_REQUEST)

    if not (access_key and secret_key):
        return {
            'message': 'All the fields above are required.'
        }, httplib.BAD_REQUEST

    user_info = utils.get_user_info(access_key, secret_key)
    if not user_info:
        return {
            'message': ('Unable to access account.\n'
                'Check to make sure that the above credentials are valid, '
                'and that they have permission to list buckets.')
        }, httplib.BAD_REQUEST

    if not utils.can_list(access_key, secret_key):
        return {
            'message': ('Unable to list buckets.\n'
                'Listing buckets is required permission that can be changed via IAM')
        }, httplib.BAD_REQUEST

    account = None
    try:
        account = ExternalAccount(
            provider=SHORT_NAME,
            provider_name=FULL_NAME,
            oauth_key=access_key,
            oauth_secret=secret_key,
            provider_id=user_info.id,
            display_name=user_info.display_name,
        )
        account.save()
    except KeyExistsException:
        # ... or get the old one
        account = ExternalAccount.find_one(
            Q('provider', 'eq', SHORT_NAME) &
            Q('provider_id', 'eq', user_info.id)
        )
    assert account is not None

    if account not in auth.user.external_accounts:
        auth.user.external_accounts.append(account)

    # Ensure S3 is enabled.
    auth.user.get_or_add_addon('s3', auth=auth)
    auth.user.save()

    return {}

# 需要导入模块: from website.oauth.models import ExternalAccount [as 别名]
# 或者: from website.oauth.models.ExternalAccount import save [as 别名]
def do_migration(records):
    host = 'dataverse.harvard.edu'

    for user_addon in records:
        user = user_addon.owner
        api_token = user_addon.api_token

        logger.info('Record found for user {}'.format(user._id))

        # Modified from `dataverse_add_user_account`
        # Create/load external account and append to user
        try:
            account = ExternalAccount(
                provider='dataverse',
                provider_name='Dataverse',
                display_name=host,
                oauth_key=host,
                oauth_secret=api_token,
                provider_id=api_token,
            )
            account.save()
        except KeyExistsException:
            # ... or get the old one
            account = ExternalAccount.find_one(
                Q('provider', 'eq', 'dataverse') &
                Q('provider_id', 'eq', api_token)
            )
            assert account is not None
        user.external_accounts.append(account)
        user.save()

        # Remove api_token from user settings object
        user_addon.api_token = None
        user_addon.save()

        logger.info('Added external account {0} to user {1}'.format(
            account._id, user._id,
        ))

        ####### BROKEN #######
        # Field user_addon needed to be user_addon._id for lookup.
        #
        # Add external account to authorized nodes
        for node_addon in get_authorized_node_settings(user_addon):
            node_addon.set_auth(account, user)

            logger.info('Added external account {0} to node {1}'.format(
                account._id, node_addon.owner._id,
            ))