Subscriptions: Intercept login action

extensions/amp-subscriptions/0.1/amp-subscriptions.js

@@ -153,8 +153,7 @@ export class SubscriptionService {
    * service.
    *
    * @param {string} serviceId
-   * @param {function(!JsonObject, !ServiceAdapter):!SubscriptionPlatform}
-   * subscriptionPlatformFactory
+   * @param {function(!JsonObject, !ServiceAdapter):!SubscriptionPlatform} subscriptionPlatformFactory
    */
   registerPlatform(serviceId, subscriptionPlatformFactory) {
     return this.initialize_().then(() => {
@@ -271,7 +270,7 @@ export class SubscriptionService {
         this.initializeLocalPlatforms_(service);
       });
 
-      this.platformStore_.getAllRegisteredPlatforms().forEach(
+      this.platformStore_.getAvailablePlatforms().forEach(
           subscriptionPlatform => {
             this.fetchEntitlements_(subscriptionPlatform);
           }
@@ -457,6 +456,31 @@ export class SubscriptionService {
       platform.decorateUI(element, action, options);
     });
   }
+
+  /**
+   * Evaluates platforms and select the one to be selected for login.
+   * @return {!Promise<!./subscription-platform.SubscriptionPlatform>}
+   */
+  scoreBasedLogin() {
+    return this.platformStore_.getAllPlatforms().then(platforms => {
+      const platformScores = [];
+      platforms.forEach(platform => {
+        let score = 0;
+        if (platform.supportsCurrentViewer()) {
+          score += 1000;
+        }
+        platformScores.push({
+          platform,
+          score,
+        });
+      });
+
+      platformScores.sort(function(platform1, platform2) {
+        return platform2.weight - platform1.weight;
+      });
+      return platformScores[0].platform;
+    });
+  }
 }
 
 

extensions/amp-subscriptions/0.1/local-subscription-platform.js

@@ -151,11 +151,18 @@ export class LocalSubscriptionPlatform {
   handleClick_(element) {
     if (element) {
       const action = element.getAttribute('subscriptions-action');
-      if (element.hasAttribute('subscriptions-service')) {
+      if (element.getAttribute('subscriptions-service') === 'local') {
+        this.executeAction(action);
+      } else if (!element.hasAttribute('subscriptions-service')
+          || element.getAttribute('subscriptions-service') === 'auto'
+          || element.getAttribute('subscriptions-service') === '') {
+        this.serviceAdapter_.login().then(platform => {
+          const serviceId = platform.getServiceId();
+          this.serviceAdapter_.delegateActionToService(action, serviceId);
+        });
+      } else if (element.getAttribute('subscriptions-service')) {
         const serviceId = element.getAttribute('subscriptions-service');
         this.serviceAdapter_.delegateActionToService(action, serviceId);
-      } else {
-        this.executeAction(action);
       }
     }
   }

extensions/amp-subscriptions/0.1/platform-store.js

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import {Deferred} from '../../../src/utils/promise';
 import {Entitlement} from './entitlement';
 import {Observable} from '../../../src/observable';
 import {dev, user} from '../../../src/log';
@@ -49,7 +50,7 @@ export class PlatformStore {
     /** @private @const {!Observable<{serviceId: string}>} */
     this.onPlatformResolvedCallbacks_ = new Observable();
 
-    /** @private {?Promise<boolean>} */
+    /** @private {?Deferred} */
     this.grantStatusPromise_ = null;
 
     /** @private @const {!Observable} */
@@ -58,10 +59,10 @@ export class PlatformStore {
     /** @private {?Entitlement} */
     this.grantStatusEntitlement_ = null;
 
-    /** @private {?Promise<?Entitlement>} */
+    /** @private {?Deferred<?Entitlement>} */
     this.grantStatusEntitlementPromise_ = null;
 
-    /** @private {?Promise<!Array<!./entitlement.Entitlement>>} */
+    /** @private {?Deferred<!Array<!./entitlement.Entitlement>>} */
     this.allResolvedPromise_ = null;
 
     /** @private {!Array<string>} */
@@ -91,6 +92,7 @@ export class PlatformStore {
   /**
    *Calls a callback for when a platform is resolved.
    * @param {string} serviceId
+   * @param {!Function} callback
    */
   onPlatformResolves(serviceId, callback) {
     const platform = this.subscriptionPlatforms_[serviceId];
@@ -128,10 +130,11 @@ export class PlatformStore {
   }
 
   /**
-   * Returns all the platforms;
+   * Returns all available platforms.
+   *
    * @return {!Array<!./subscription-platform.SubscriptionPlatform>}
    */
-  getAllRegisteredPlatforms() {
+  getAvailablePlatforms() {
     const platforms = [];
     for (const platformKey in this.subscriptionPlatforms_) {
       const subscriptionPlatform =
@@ -141,6 +144,27 @@ export class PlatformStore {
     return platforms;
   }
 
+  /**
+   * Returns a promise which resolves when all platforms are resolved.
+   *
+   * @return {!Promise}
+   */
+  getAllPlatforms() {
+    const allPlatformPromise = new Deferred();
+    if (Object.keys(this.subscriptionPlatforms_).length
+        === this.serviceIds_.length) {
+      allPlatformPromise.resolve(this.getAvailablePlatforms());
+    } else {
+      this.onPlatformResolvedCallbacks_.add(() => {
+        const platformLength = Object.keys(this.subscriptionPlatforms_).length;
+        if (platformLength === this.serviceIds_.length) {
+          allPlatformPromise.resolve(this.getAvailablePlatforms());
+        }
+      });
+    }
+    return allPlatformPromise.promise;
+  }
+
   /**
    * This registers a callback which is called whenever a service id is resolved
    * with an entitlement.
@@ -184,37 +208,36 @@ export class PlatformStore {
    */
   getGrantStatus() {
     if (this.grantStatusPromise_ !== null) {
-      return this.grantStatusPromise_;
+      return this.grantStatusPromise_.promise;
     }
 
-    this.grantStatusPromise_ = new Promise(resolve => {
+    this.grantStatusPromise_ = new Deferred();
 
-      // Check if current entitlements unblocks the reader
-      for (const key in this.entitlements_) {
-        const entitlement = (this.entitlements_[key]);
+    // Check if current entitlements unblocks the reader
+    for (const key in this.entitlements_) {
+      const entitlement = (this.entitlements_[key]);
+      if (entitlement.granted) {
+        this.saveGrantEntitlement_(entitlement);
+        this.grantStatusPromise_.resolve(true);
+      }
+    }
+
+    if (this.areAllPlatformsResolved_()) {
+      // Resolve with null if non of the entitlements unblocks the reader
+      this.grantStatusPromise_.resolve(false);
+    } else {
+      // Listen if any upcoming entitlements unblock the reader
+      this.onChange(({entitlement}) => {
         if (entitlement.granted) {
           this.saveGrantEntitlement_(entitlement);
-          return resolve(true);
+          this.grantStatusPromise_.resolve(true);
+        } else if (this.areAllPlatformsResolved_()) {
+          this.grantStatusPromise_.resolve(false);
         }
-      }
-
-      if (this.areAllPlatformsResolved_()) {
-        // Resolve with null if non of the entitlements unblocks the reader
-        return resolve(false);
-      } else {
-        // Listen if any upcoming entitlements unblock the reader
-        this.onChange(({entitlement}) => {
-          if (entitlement.granted) {
-            this.saveGrantEntitlement_(entitlement);
-            resolve(true);
-          } else if (this.areAllPlatformsResolved_()) {
-            resolve(false);
-          }
-        });
-      }
-    });
+      });
+    }
 
-    return this.grantStatusPromise_;
+    return this.grantStatusPromise_.promise;
   }
 
   /**
@@ -240,25 +263,23 @@ export class PlatformStore {
    */
   getGrantEntitlement() {
     if (this.grantStatusEntitlementPromise_) {
-      return (this.grantStatusEntitlementPromise_);
+      return (this.grantStatusEntitlementPromise_.promise);
     }
-
-    this.grantStatusEntitlementPromise_ = new Promise(resolve => {
-      if ((this.grantStatusEntitlement_
-          && this.grantStatusEntitlement_.isSubscriber())
+    this.grantStatusEntitlementPromise_ = new Deferred();
+    if ((this.grantStatusEntitlement_
+        && this.grantStatusEntitlement_.isSubscriber())
+          || this.areAllPlatformsResolved_()) {
+      this.grantStatusEntitlementPromise_.resolve(this.grantStatusEntitlement_);
+    } else {
+      this.onGrantStateResolvedCallbacks_.add(() => {
+        if (this.grantStatusEntitlement_.granted
             || this.areAllPlatformsResolved_()) {
-        resolve(this.grantStatusEntitlement_);
-      } else {
-        this.onGrantStateResolvedCallbacks_.add(() => {
-          if (this.grantStatusEntitlement_.granted
-              || this.areAllPlatformsResolved_()) {
-            resolve(this.grantStatusEntitlement_);
-          }
-        });
-      }
-    });
-
-    return this.grantStatusEntitlementPromise_;
+          this.grantStatusEntitlementPromise_.resolve(
+              this.grantStatusEntitlement_);
+        }
+      });
+    }
+    return this.grantStatusEntitlementPromise_.promise;
   }
 
   /**
@@ -275,24 +296,23 @@ export class PlatformStore {
    */
   getAllPlatformsEntitlements_() {
     if (this.allResolvedPromise_) {
-      return this.allResolvedPromise_;
+      return this.allResolvedPromise_.promise;
     }
-
-    this.allResolvedPromise_ = new Promise(resolve => {
-      if (this.areAllPlatformsResolved_()) {
-        // Resolve with null if non of the entitlements unblocks the reader
-        return resolve(this.getAvailablePlatformsEntitlements_());
-      } else {
-        // Listen if any upcoming entitlements unblock the reader
-        this.onChange(() => {
-          if (this.areAllPlatformsResolved_()) {
-            resolve(this.getAvailablePlatformsEntitlements_());
-          }
-        });
-      }
-    });
-
-    return this.allResolvedPromise_;
+    this.allResolvedPromise_ = new Deferred();
+    if (this.areAllPlatformsResolved_()) {
+      // Resolve with null if non of the entitlements unblocks the reader
+      this.allResolvedPromise_.resolve(
+          this.getAvailablePlatformsEntitlements_());
+    } else {
+      // Listen if any upcoming entitlements unblock the reader
+      this.onChange(() => {
+        if (this.areAllPlatformsResolved_()) {
+          this.allResolvedPromise_.resolve(
+              this.getAvailablePlatformsEntitlements_());
+        }
+      });
+    }
+    return this.allResolvedPromise_.promise;
   }
 
   /**
@@ -354,7 +374,7 @@ export class PlatformStore {
     dev().assert(this.areAllPlatformsResolved_(),
         'All platforms are not resolved yet');
 
-    this.getAllRegisteredPlatforms().forEach(platform => {
+    this.getAvailablePlatforms().forEach(platform => {
       let weight = 0;
       const entitlement =
           this.getResolvedEntitlementFor(platform.getServiceId());

extensions/amp-subscriptions/0.1/service-adapter.js

@@ -79,6 +79,15 @@ export class ServiceAdapter {
   getDialog() {
     return this.subscriptionService_.getDialog();
   }
+
+  /**
+   * Returns login platform based on platform selection
+   *
+   * @return {!Promise}
+   */
+  login() {
+    return this.subscriptionService_.scoreBasedLogin();
+  }
 }
 
 /** @package @VisibleForTesting */

extensions/amp-subscriptions/0.1/test/test-amp-subscriptions.js

@@ -553,4 +553,22 @@ describes.fakeWin('AmpSubscriptions', {amp: true}, env => {
       expect(decorateUIStub).to.be.calledWith(element);
     });
   });
+
+  describe('scoreBasedLogin', () => {
+
+    it('should return the platform which ever supports viewer', () => {
+      const platform = new SubscriptionPlatform();
+      platform.getServiceId = () => 'swg-google';
+      platform.supportsCurrentViewer = () => true;
+      const localPlatform = new SubscriptionPlatform();
+      localPlatform.getServiceId = () => 'local';
+      subscriptionService.platformStore_ = new PlatformStore(
+          ['local', 'swg-google']);
+      sandbox.stub(subscriptionService.platformStore_, 'getAllPlatforms')
+          .callsFake(() => Promise.resolve([platform, localPlatform]));
+      return subscriptionService.scoreBasedLogin().then(platform => {
+        expect(platform.getServiceId()).to.be.equal(platform.getServiceId());
+      });
+    });
+  });
 });

extensions/amp-subscriptions/0.1/test/test-local-subscriptions.js

@@ -136,6 +136,7 @@ describes.fakeWin('LocalSubscriptionsPlatform', {amp: true}, env => {
     beforeEach(() => {
       element = document.createElement('div');
       element.setAttribute('subscriptions-action', 'subscribe');
+      element.setAttribute('subscriptions-service', 'local');
     });
 
     it('should call executeAction with subscriptions-action value', () => {
@@ -159,6 +160,30 @@ describes.fakeWin('LocalSubscriptionsPlatform', {amp: true}, env => {
       expect(executeStub).to.not.be.called;
       expect(delegateStub).to.be.called;
     });
+
+    it('should delegate service selection to scoreBasedLogin if no service '
+        + 'name is specified', () => {
+      element.removeAttribute('subscriptions-service');
+      const platform = {};
+      const serviceId = 'serviceId';
+      platform.getServiceId = sandbox.stub().callsFake(() => serviceId);
+      const loginStub = sandbox.stub(
+          localSubscriptionPlatform.serviceAdapter_,
+          'login'
+      ).callsFake(() => Promise.resolve(platform));
+      const delegateStub = sandbox.stub(
+          localSubscriptionPlatform.serviceAdapter_,
+          'delegateActionToService'
+      );
+      localSubscriptionPlatform.handleClick_(element);
+      expect(loginStub).to.be.called;
+      return loginStub().then(() => {
+        expect(delegateStub).to.be.calledWith(
+            element.getAttribute('subscriptions-action'),
+            serviceId,
+        );
+      });
+    });
   });
 
   describe('executeAction', () => {