// (C) Copyright 2015 Moodle Pty Ltd. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. import { Injectable } from '@angular/core'; import { TranslateService } from '@ngx-translate/core'; import { CoreAppProvider } from './app'; import { CoreInitDelegate } from './init'; import { CoreLoggerProvider } from './logger'; import { CoreSitesProvider, CoreSiteCheckResponse } from './sites'; import { CoreDomUtilsProvider } from './utils/dom'; import { CoreTextUtilsProvider } from './utils/text'; import { CoreUrlUtilsProvider } from './utils/url'; import { CoreUtilsProvider } from './utils/utils'; import { CoreLoginHelperProvider, CoreLoginSSOData } from '@core/login/providers/helper'; import { CoreContentLinksHelperProvider } from '@core/contentlinks/providers/helper'; import { CoreContentLinksDelegate } from '@core/contentlinks/providers/delegate'; import { CoreSitePluginsProvider } from '@core/siteplugins/providers/siteplugins'; import { CoreConfigConstants } from '../configconstants'; import { CoreConstants } from '@core/constants'; import { makeSingleton } from '@singletons/core.singletons'; /** * All params that can be in a custom URL scheme. */ export interface CoreCustomURLSchemesParams extends CoreLoginSSOData { /** * Username. */ username?: string; /** * URL to open once authenticated. */ redirect?: any; /** * Whether it's an SSO token URL. */ isSSOToken?: boolean; /** * Whether the URL is meant to perform an authentication. */ isAuthenticationURL?: boolean; } /* * Provider to handle custom URL schemes. */ @Injectable() export class CoreCustomURLSchemesProvider { protected logger; protected lastUrls = {}; constructor(logger: CoreLoggerProvider, protected appProvider: CoreAppProvider, protected utils: CoreUtilsProvider, protected loginHelper: CoreLoginHelperProvider, protected linksHelper: CoreContentLinksHelperProvider, protected initDelegate: CoreInitDelegate, protected domUtils: CoreDomUtilsProvider, protected urlUtils: CoreUrlUtilsProvider, protected sitesProvider: CoreSitesProvider, protected textUtils: CoreTextUtilsProvider, protected linksDelegate: CoreContentLinksDelegate, protected translate: TranslateService, protected sitePluginsProvider: CoreSitePluginsProvider) { this.logger = logger.getInstance('CoreCustomURLSchemesProvider'); } /** * Given some data of a custom URL with a token, create a site if it needs to be created. * * @param data URL data. * @return Promise resolved with the site ID. */ protected async createSiteIfNeeded(data: CoreCustomURLSchemesParams): Promise { if (!data.token) { return; } const currentSite = this.sitesProvider.getCurrentSite(); if (!currentSite || currentSite.getToken() != data.token) { // Token belongs to a different site, create it. It doesn't matter if it already exists. if (!data.siteUrl.match(/^https?:\/\//)) { // URL doesn't have a protocol and it's required to be able to create the site. Check which one to use. const result = await this.sitesProvider.checkSite(data.siteUrl); data.siteUrl = result.siteUrl; await this.sitesProvider.checkRequiredMinimumVersion(result.config); } return this.sitesProvider.newSite(data.siteUrl, data.token, data.privateToken, data.isSSOToken, this.loginHelper.getOAuthIdFromParams(data.ssoUrlParams)); } else { // Token belongs to current site, no need to create it. return this.sitesProvider.getCurrentSiteId(); } } /** * Handle an URL received by custom URL scheme. * * @param url URL to treat. * @return Promise resolved when done. If rejected, the parameter is of type CoreCustomURLSchemesHandleError. */ async handleCustomURL(url: string): Promise { if (!this.isCustomURL(url)) { throw new CoreCustomURLSchemesHandleError(null); } /* First check that this URL hasn't been treated a few seconds ago. The function that handles custom URL schemes already does this, but this function is called from other places so we need to handle it in here too. */ if (this.lastUrls[url] && Date.now() - this.lastUrls[url] < 3000) { // Function called more than once, stop. return; } this.lastUrls[url] = Date.now(); url = this.textUtils.decodeURIComponent(url); // Wait for app to be ready. await this.initDelegate.ready(); // Some platforms like Windows add a slash at the end. Remove it. // Some sites add a # at the end of the URL. If it's there, remove it. url = url.replace(/\/?#?\/?$/, ''); const modal = this.domUtils.showModalLoading(); let data: CoreCustomURLSchemesParams; // Get the data from the URL. try { if (this.isCustomURLToken(url)) { data = await this.getCustomURLTokenData(url); } else if (this.isCustomURLLink(url)) { // In iOS, the protocol after the scheme doesn't have ":". Add it. url = url.replace(/\/\/link=(https?)\/\//, '//link=$1://'); data = await this.getCustomURLLinkData(url); } else { // In iOS, the protocol after the scheme doesn't have ":". Add it. url = url.replace(/\/\/(https?)\/\//, '//$1://'); data = await this.getCustomURLData(url); } } catch (error) { modal.dismiss(); throw error; } try { if (data.redirect && data.redirect.match(/^https?:\/\//) && data.redirect.indexOf(data.siteUrl) == -1) { // Redirect URL must belong to the same site. Reject. throw this.translate.instant('core.contentlinks.errorredirectothersite'); } // First of all, create the site if needed. const siteId = await this.createSiteIfNeeded(data); if (data.isSSOToken) { // Site created and authenticated, open the page to go. if (data.pageName) { // State defined, go to that state instead of site initial page. this.appProvider.getRootNavController().push(data.pageName, data.pageParams); } else { this.loginHelper.goToSiteInitialPage(); } return; } if (data.redirect && !data.redirect.match(/^https?:\/\//)) { // Redirect is a relative URL. Append the site URL. data.redirect = this.textUtils.concatenatePaths(data.siteUrl, data.redirect); } let siteIds = [siteId]; if (!siteId) { // No site created, check if the site is stored (to know which one to use). siteIds = await this.sitesProvider.getSiteIdsFromUrl(data.siteUrl, true, data.username); } if (siteIds.length > 1) { // More than one site to treat the URL, let the user choose. this.linksHelper.goToChooseSite(data.redirect || data.siteUrl); } else if (siteIds.length == 1) { // Only one site, handle the link. const site = await this.sitesProvider.getSite(siteIds[0]); if (!data.redirect) { // No redirect, go to the root URL if needed. await this.linksHelper.handleRootURL(site, false, true); } else { // Handle the redirect link. modal.dismiss(); // Dismiss modal so it doesn't collide with confirms. /* Always use the username from the site in this case. If the link has a username and a token, this will make sure that the link is opened with the user the token belongs to. */ const username = site.getInfo().username || data.username; const treated = await this.linksHelper.handleLink(data.redirect, username); if (!treated) { this.domUtils.showErrorModal('core.contentlinks.errornoactions', true); } } } else { // Site not stored. Try to add the site. const result = await this.sitesProvider.checkSite(data.siteUrl); // Site exists. We'll allow to add it. modal.dismiss(); // Dismiss modal so it doesn't collide with confirms. await this.goToAddSite(data, result); } } catch (error) { throw new CoreCustomURLSchemesHandleError(error, data); } finally { modal.dismiss(); if (data.isSSOToken) { this.appProvider.finishSSOAuthentication(); } } } /** * Get the data from a custom URL scheme. The structure of the URL is: * moodlemobile://username@domain.com?token=TOKEN&privatetoken=PRIVATETOKEN&redirect=http://domain.com/course/view.php?id=2 * * @param url URL to treat. * @return Promise resolved with the data. */ protected async getCustomURLData(url: string): Promise { if (!this.isCustomURL(url)) { throw new CoreCustomURLSchemesHandleError(null); } // App opened using custom URL scheme. this.logger.debug('Treating custom URL scheme: ' + url); // Delete the sso scheme from the URL. url = this.removeCustomURLScheme(url); // Detect if there's a user specified. const username = this.urlUtils.getUsernameFromUrl(url); if (username) { url = url.replace(username + '@', ''); // Remove the username from the URL. } // Get the params of the URL. const params = this.urlUtils.extractUrlParams(url); // Remove the params to get the site URL. if (url.indexOf('?') != -1) { url = url.substr(0, url.indexOf('?')); } if (!url.match(/https?:\/\//)) { // Url doesn't have a protocol. Check if the site is stored in the app to be able to determine the protocol. const siteIds = await this.sitesProvider.getSiteIdsFromUrl(url, true, username); if (siteIds.length) { // There is at least 1 site with this URL. Use it to know the full URL. const site = await this.sitesProvider.getSite(siteIds[0]); url = site.getURL(); } } return { siteUrl: url, username: username, token: params.token, privateToken: params.privateToken, redirect: params.redirect, isAuthenticationURL: !!params.token, }; } /** * Get the data from a "link" custom URL scheme. This kind of URL is deprecated. * * @param url URL to treat. * @return Promise resolved with the data. */ protected async getCustomURLLinkData(url: string): Promise { if (!this.isCustomURLLink(url)) { throw new CoreCustomURLSchemesHandleError(null); } // App opened using custom URL scheme. this.logger.debug('Treating custom URL scheme with link param: ' + url); // Delete the sso scheme from the URL. url = this.removeCustomURLLinkScheme(url); // Detect if there's a user specified. const username = this.urlUtils.getUsernameFromUrl(url); if (username) { url = url.replace(username + '@', ''); // Remove the username from the URL. } // First of all, check if it's the root URL of a site. const data = await this.sitesProvider.isStoredRootURL(url, username); if (data.site) { // Root URL. return { siteUrl: data.site.getURL(), username: username }; } else if (data.siteIds.length > 0) { // Not the root URL, but at least 1 site supports the URL. Get the site URL from the list of sites. const site = await this.sitesProvider.getSite(data.siteIds[0]); return { siteUrl: site.getURL(), username: username, redirect: url }; } else { // Get the site URL. let siteUrl = this.linksDelegate.getSiteUrl(url); let redirect = url; if (!siteUrl) { // Site URL not found, use the original URL since it could be the root URL of the site. siteUrl = url; redirect = undefined; } return { siteUrl: siteUrl, username: username, redirect: redirect }; } } /** * Get the data from a "token" custom URL scheme. This kind of URL is deprecated. * * @param url URL to treat. * @return Promise resolved with the data. */ protected async getCustomURLTokenData(url: string): Promise { if (!this.isCustomURLToken(url)) { throw new CoreCustomURLSchemesHandleError(null); } if (this.appProvider.isSSOAuthenticationOngoing()) { // Authentication ongoing, probably duplicated request. throw new CoreCustomURLSchemesHandleError('Duplicated'); } if (this.appProvider.isDesktop()) { // In desktop, make sure InAppBrowser is closed. this.utils.closeInAppBrowser(true); } // App opened using custom URL scheme. Probably an SSO authentication. this.appProvider.startSSOAuthentication(); this.logger.debug('App launched by URL with an SSO'); // Delete the sso scheme from the URL. url = this.removeCustomURLTokenScheme(url); // Some platforms like Windows add a slash at the end. Remove it. // Some sites add a # at the end of the URL. If it's there, remove it. url = url.replace(/\/?#?\/?$/, ''); // Decode from base64. try { url = atob(url); } catch (err) { // Error decoding the parameter. this.logger.error('Error decoding parameter received for login SSO'); throw new CoreCustomURLSchemesHandleError(null); } const data: CoreCustomURLSchemesParams = await this.loginHelper.validateBrowserSSOLogin(url); data.isSSOToken = true; data.isAuthenticationURL = true; return data; } /** * Go to page to add a site, or open a browser if SSO. * * @param data URL data. * @param checkResponse Result of checkSite. * @return Promise resolved when done. */ protected async goToAddSite(data: CoreCustomURLSchemesParams, checkResponse: CoreSiteCheckResponse): Promise { const ssoNeeded = this.loginHelper.isSSOLoginNeeded(checkResponse.code); const pageName = 'CoreLoginCredentialsPage'; const pageParams = { siteUrl: checkResponse.siteUrl, username: data.username, urlToOpen: data.redirect, siteConfig: checkResponse.config }; let hasSitePluginsLoaded = false; if (this.sitesProvider.isLoggedIn()) { // Ask the user before changing site. await this.domUtils.showConfirm(this.translate.instant('core.contentlinks.confirmurlothersite')); if (!ssoNeeded) { hasSitePluginsLoaded = this.sitePluginsProvider.hasSitePluginsLoaded; if (hasSitePluginsLoaded) { // Store the redirect since logout will restart the app. this.appProvider.storeRedirect(CoreConstants.NO_SITE_ID, pageName, pageParams); } await this.sitesProvider.logout(); } } if (ssoNeeded) { this.loginHelper.confirmAndOpenBrowserForSSOLogin(checkResponse.siteUrl, checkResponse.code, checkResponse.service, checkResponse.config && checkResponse.config.launchurl); } else if (!hasSitePluginsLoaded) { await this.loginHelper.goToNoSitePage(undefined, pageName, pageParams); } } /** * Check whether a URL is a custom URL scheme. * * @param url URL to check. * @return Whether it's a custom URL scheme. */ isCustomURL(url: string): boolean { if (!url) { return false; } return url.indexOf(CoreConfigConstants.customurlscheme + '://') != -1; } /** * Check whether a URL is a custom URL scheme with the "link" param (deprecated). * * @param url URL to check. * @return Whether it's a custom URL scheme. */ isCustomURLLink(url: string): boolean { if (!url) { return false; } return url.indexOf(CoreConfigConstants.customurlscheme + '://link=') != -1; } /** * Check whether a URL is a custom URL scheme with a "token" param (deprecated). * * @param url URL to check. * @return Whether it's a custom URL scheme. */ isCustomURLToken(url: string): boolean { if (!url) { return false; } return url.indexOf(CoreConfigConstants.customurlscheme + '://token=') != -1; } /** * Remove the scheme from a custom URL. * * @param url URL to treat. * @return URL without scheme. */ removeCustomURLScheme(url: string): string { return url.replace(CoreConfigConstants.customurlscheme + '://', ''); } /** * Remove the scheme and the "link=" prefix from a link custom URL. * * @param url URL to treat. * @return URL without scheme and prefix. */ removeCustomURLLinkScheme(url: string): string { return url.replace(CoreConfigConstants.customurlscheme + '://link=', ''); } /** * Remove the scheme and the "token=" prefix from a token custom URL. * * @param url URL to treat. * @return URL without scheme and prefix. */ removeCustomURLTokenScheme(url: string): string { return url.replace(CoreConfigConstants.customurlscheme + '://token=', ''); } /** * Treat error returned by handleCustomURL. * * @param error Error data. */ treatHandleCustomURLError(error: CoreCustomURLSchemesHandleError): void { if (error.error == 'Duplicated') { // Duplicated request } else if (error.error && error.data && error.data.isSSOToken) { // An error occurred, display the error and logout the user. this.loginHelper.treatUserTokenError(error.data.siteUrl, error.error); this.sitesProvider.logout(); } else { this.domUtils.showErrorModalDefault(error.error, this.translate.instant('core.login.invalidsite')); } } } /** * Error returned by handleCustomURL. */ export class CoreCustomURLSchemesHandleError { /** * Constructor. * * @param error The error message or object. * @param data Data obtained from the URL (if any). */ constructor(public error: any, public data?: CoreCustomURLSchemesParams) { } } export class CoreCustomURLSchemes extends makeSingleton(CoreCustomURLSchemesProvider) {}