← Back to branch summary

~dobey/ubuntuone-credentials/signon-plugin-part2

« back to all changes in this revision

Viewing changes to libubuntuoneauth/authenticator.cpp

  • Committer: Rodney Dawes
  • Date: 2016-06-17 18:24:10 UTC
  • Revision ID: rodney.dawes@canonical.com-20160617182410-hwt345smyxi0iwbk
Refactor so createSession/process are called after identity is stored.
Fix invalidateCredentials to actually invalidate the credentials.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libubuntuoneauth/authenticator.cpp
119
119
    return account->credentialsId();
120
120
}
121
121
 
 
122
void Authenticator::process(SignOn::Identity *identity,
 
123
                            const QString &tokenName,
 
124
                            const QString &userName,
 
125
                            const QString &password,
 
126
                            const QString &otp)
 
127
{
 
128
    auto session = identity->createSession(QStringLiteral("ubuntuone"));
 
129
    if (Q_UNLIKELY(!session)) {
 
130
        qCritical() << "Unable to create AuthSession.";
 
131
        Q_EMIT error(AuthenticationError, "");
 
132
        return;
 
133
    }
 
134
 
 
135
    connect(session, SIGNAL(response(const SignOn::SessionData&)),
 
136
            this, SLOT(handleSessionData(const SignOn::SessionData&)));
 
137
    connect(session, SIGNAL(error(const SignOn::Error&)),
 
138
            this, SLOT(handleError(const SignOn::Error&)));
 
139
 
 
140
    PluginData data;
 
141
    data.setTokenName(tokenName);
 
142
    data.setUserName(userName);
 
143
    data.setSecret(password);
 
144
    data.setOneTimePassword(otp);
 
145
    int uiPolicy = m_uiAllowed ?
 
146
        SignOn::DefaultPolicy : SignOn::NoUserInteractionPolicy;
 
147
    data.setUiPolicy(uiPolicy);
 
148
    if (m_invalidate) {
 
149
        data.setInvalidateToken(true);
 
150
        m_invalidate = false;
 
151
    }
 
152
 
 
153
    session->process(data, QStringLiteral("ubuntuone"));
 
154
}
 
155
 
122
156
void Authenticator::authenticate(const QString &tokenName,
123
157
                                 const QString &userName,
124
158
                                 const QString &password,
135
169
 
136
170
        identity = SignOn::Identity::newIdentity(info, this);
137
171
        connect(identity, &SignOn::Identity::credentialsStored,
138
 
                [this](const quint32 id) {
 
172
                [=](const quint32 id) {
139
173
                    m_credentialsId = id;
 
174
                    process(identity, tokenName, userName, password, otp);
140
175
                });
141
176
        connect(identity, &SignOn::Identity::error,
142
 
                [this](const SignOn::Error &err) {
 
177
                [=](const SignOn::Error &err) {
143
178
                    qCritical() << "authenticate(): unable to store identity";
144
179
                    Q_EMIT error(AccountNotFound, "");
145
180
                });
151
186
            Q_EMIT error(AccountNotFound, "");
152
187
            return;
153
188
        }
154
 
    }
155
 
 
156
 
    auto session = identity->createSession(QStringLiteral("ubuntuone"));
157
 
    if (Q_UNLIKELY(!session)) {
158
 
        qCritical() << "Unable to create AuthSession.";
159
 
        Q_EMIT error(AuthenticationError, "");
160
 
        return;
161
 
    }
162
 
 
163
 
    connect(session, SIGNAL(response(const SignOn::SessionData&)),
164
 
            this, SLOT(handleSessionData(const SignOn::SessionData&)));
165
 
    connect(session, SIGNAL(error(const SignOn::Error&)),
166
 
            this, SLOT(handleError(const SignOn::Error&)));
167
 
 
168
 
    PluginData data;
169
 
    data.setTokenName(tokenName);
170
 
    data.setUserName(userName);
171
 
    data.setSecret(password);
172
 
    data.setOneTimePassword(otp);
173
 
    int uiPolicy = m_uiAllowed ?
174
 
        SignOn::DefaultPolicy : SignOn::NoUserInteractionPolicy;
175
 
    data.setUiPolicy(uiPolicy);
176
 
    if (m_invalidate) {
177
 
        data.setInvalidateToken(true);
178
 
        m_invalidate = false;
179
 
    }
180
 
 
181
 
    session->process(data, QStringLiteral("ubuntuone"));
 
189
        process(identity, tokenName, userName, password, otp);
 
190
    }
 
191
 
182
192
}
183
193
 
184
194
void Authenticator::invalidateCredentials()
185
195
{
186
 
    m_invalidate = true;
 
196
    m_credentialsId = existingCredentialsId();
 
197
    if (m_credentialsId == 0) {
 
198
        qCritical() << "invalidateCredentials(): no existing credentials.";
 
199
        Q_EMIT error(AccountNotFound, "");
 
200
        return;
 
201
    }
 
202
 
 
203
    auto identity = SignOn::Identity::existingIdentity(m_credentialsId, this);
 
204
    process(identity, Token::buildTokenName());
187
205
}
188
206
 
189
207
void Authenticator::setUiAllowed(bool allowed)