feat: add count impressions functionality

Author: slawomirzaba

package.json

@@ -147,6 +147,7 @@
     "version": "0.44.1"
   },
   "dependencies": {
-    "@sentry/react-native": "^6.3.0"
+    "@sentry/react-native": "^6.3.0",
+    "react-native-uuid": "^2.0.3"
   }
 }

sharedExample/src/ContentpassUsage.tsx

@@ -87,13 +87,23 @@ export default function ContentpassUsage() {
     spConsentManager.current?.loadMessage();
   };
 
+  const countImpression = async () => {
+    try {
+      await contentpassSdk.countImpression();
+    } catch (err) {
+      // eslint-disable-next-line no-console
+      console.error('Failed to count impression', err);
+    }
+  };
+
   return (
     <>
       <View style={styles.buttonsContainer}>
         <Button
           title={'Clear sourcepoint data'}
           onPress={clearSourcepointData}
         />
+        <Button title={'Count impression'} onPress={countImpression} />
         <Button title={'Logout'} onPress={contentpassSdk.logout} />
       </View>
       <View style={styles.logsView}>

sharedExample/src/contentpassConfig.ts

@@ -4,9 +4,12 @@ export const contentpassConfig: ContentpassConfig = {
   // Testing app
   propertyId: 'cc3fc4ad-cbe5-4d09-bf85-a49796603b19',
   issuer: 'https://my.contentpass.dev',
+  apiUrl: 'https://cp.cmp-sourcepoint.contenttimes.dev',
   // Staging app
   // propertyId: '78da2fd3-8b25-4642-b7b7-4a0193d00f89',
   // issuer: 'https://my.contentpass.io',
+  // apiUrl: 'cp.cmp-sourcepoint.contenttimes.io',
 
+  samplingRate: 1,
   redirectUrl: 'de.contentpass.demo://oauth',
 };

src/Contentpass.test.ts

@@ -5,14 +5,15 @@ import * as AppAuthModule from 'react-native-app-auth';
 import * as OidcAuthStateStorageModule from './OidcAuthStateStorage';
 import type { ContentpassState } from './types/ContentpassState';
 import OidcAuthStateStorage from './OidcAuthStateStorage';
-import * as FetchContentpassTokenModule from './utils/fetchContentpassToken';
+import * as FetchContentpassTokenModule from './contentpassTokenUtils/fetchContentpassToken';
 import { SCOPES } from './consts/oidcConsts';
 import * as SentryIntegrationModule from './sentryIntegration';
 
 const config: ContentpassConfig = {
   propertyId: 'propertyId-1',
   redirectUrl: 'de.test.net://oauth',
   issuer: 'https://issuer.net',
+  apiUrl: 'https://cp.property.com',
 };
 
 const NOW = new Date('2024-12-02T11:53:56.272Z').getTime();

src/Contentpass.ts

@@ -1,3 +1,4 @@
+import uuid from 'react-native-uuid';
 import OidcAuthStateStorage, {
   type OidcAuthState,
 } from './OidcAuthStateStorage';
@@ -12,16 +13,31 @@ import {
 } from 'react-native-app-auth';
 import { REFRESH_TOKEN_RETRIES, SCOPES } from './consts/oidcConsts';
 import { RefreshTokenStrategy } from './types/RefreshTokenStrategy';
-import fetchContentpassToken from './utils/fetchContentpassToken';
-import validateSubscription from './utils/validateSubscription';
+import fetchContentpassToken from './contentpassTokenUtils/fetchContentpassToken';
+import validateSubscription from './contentpassTokenUtils/validateSubscription';
 import type { ContentpassConfig } from './types/ContentpassConfig';
 import { reportError, setSentryExtraAttribute } from './sentryIntegration';
+import sendStats from './countImpressionUtils/sendStats';
+import sendPageViewEvent from './countImpressionUtils/sendPageViewEvent';
+
+const DEFAULT_FREE_IMPRESSIONS_SAMPLING_RATE = 0.01;
 
 export type ContentpassObserver = (state: ContentpassState) => void;
 
-export default class Contentpass {
+interface ContentpassInterface {
+  authenticate: () => Promise<void>;
+  registerObserver: (observer: ContentpassObserver) => void;
+  unregisterObserver: (observer: ContentpassObserver) => void;
+  logout: () => Promise<void>;
+  recoverFromError: () => Promise<void>;
+  countImpression: () => Promise<void>;
+}
+
+export default class Contentpass implements ContentpassInterface {
   private authStateStorage: OidcAuthStateStorage;
   private readonly config: ContentpassConfig;
+  private readonly samplingRate: number;
+  private instanceId: string;
 
   private contentpassState: ContentpassState = {
     state: ContentpassStateType.INITIALISING,
@@ -31,6 +47,15 @@ export default class Contentpass {
   private refreshTimer: NodeJS.Timeout | null = null;
 
   constructor(config: ContentpassConfig) {
+    if (
+      config.samplingRate &&
+      (config.samplingRate < 0 || config.samplingRate > 1)
+    ) {
+      throw new Error('Sampling rate must be between 0 and 1');
+    }
+    this.samplingRate =
+      config.samplingRate || DEFAULT_FREE_IMPRESSIONS_SAMPLING_RATE;
+    this.instanceId = uuid.v4();
     this.authStateStorage = new OidcAuthStateStorage(config.propertyId);
     this.config = config;
     setSentryExtraAttribute('propertyId', config.propertyId);
@@ -96,6 +121,52 @@ export default class Contentpass {
     await this.initialiseAuthState();
   };
 
+  public countImpression = async () => {
+    if (this.oidcAuthState?.accessToken) {
+      await this.countPaidImpression();
+    }
+
+    // always count free impression even if user is authenticated
+    await this.countFreeImpression();
+  };
+
+  private countPaidImpression = async () => {
+    const impressionId = uuid.v4();
+
+    try {
+      await sendPageViewEvent(this.config.apiUrl, {
+        propertyId: this.config.propertyId,
+        impressionId,
+        accessToken: this.oidcAuthState!.accessToken,
+      });
+    } catch (err: any) {
+      reportError(err, { msg: 'Failed to count impression paid impression' });
+      throw err;
+    }
+  };
+
+  private countFreeImpression = async () => {
+    const generatedSample = Math.random();
+    const publicId = this.config.propertyId.slice(0, 8);
+
+    if (generatedSample >= this.samplingRate) {
+      return;
+    }
+
+    try {
+      await sendStats(this.config.apiUrl, {
+        ea: 'load',
+        ec: 'tcf-sampled',
+        cpabid: this.instanceId,
+        cppid: publicId,
+        cpsr: this.samplingRate,
+      });
+    } catch (err: any) {
+      reportError(err, { msg: 'Failed to count impression paid impression' });
+      throw err;
+    }
+  };
+
   private initialiseAuthState = async () => {
     const authState = await this.authStateStorage.getOidcAuthState();
     if (authState) {