@lifeready/core 1.0.0 → 1.0.1

package/src/lib/plan/plan.gql.ts

@@ -0,0 +1,133 @@
+import gql from 'graphql-tag';
+
+export const CreateStripeCheckoutSessionMutation = gql`
+  mutation CreateStripeCheckoutSession(
+    $priceId: String!
+    $successUrl: String!
+    $cancelUrl: String!
+  ) {
+    createStripeCheckoutSession(
+      input: {
+        priceId: $priceId
+        successUrl: $successUrl
+        cancelUrl: $cancelUrl
+      }
+    ) {
+      sessionId
+    }
+  }
+`;
+
+export const CreateStripeBillingPortalSessionMutation = gql`
+  mutation CreateStripeBillingPortalSession($returnUrl: String!) {
+    createStripeBillingPortalSession(input: { returnUrl: $returnUrl }) {
+      sessionUrl
+    }
+  }
+`;
+
+export const planFields = `
+  name
+  data
+  state
+`;
+
+export const CreateUserIssuedPlanMutation = gql`
+mutation CreateUserIssuedPlan($input: CreateUserIssuedPlanInput!){
+  createUserIssuedPlan(input: $input) {
+    userIssuedPlan {
+      id
+      plan {
+        ${planFields}
+      }
+      token
+      tokenExpiryTime
+      planPeriodEnd
+      planPeriodEndAfterSeconds
+    }
+  }
+}`;
+
+export const DeleteUserIssuedPlanMutation = gql`
+  mutation DeleteUserIssuedPlan($input: DeleteUserIssuedPlanInput!) {
+    deleteUserIssuedPlan(input: $input) {
+      id
+    }
+  }
+`;
+
+export const UserIssuablePlansQuery = gql`
+query UserIssuablePlans {
+  userIssuablePlans {
+    plan {
+      ${planFields}
+    }
+  }
+}
+`;
+
+// Put other fields in as needed.
+export const UserIssuedPlansQuery = gql`
+  query UserIssuedPlans {
+    userIssuedPlans {
+      edges {
+        node {
+          id
+        }
+      }
+    }
+  }
+`;
+
+export const UserIssuedPlanQuery = gql`
+query UserIssuedPlan(
+  $id: LrRelayIdInput!
+  $token: String
+) {
+  userIssuedPlan(
+    id: $id
+    token: $token
+  ) {
+    id
+    plan {
+      ${planFields}
+    }
+    planPeriodEnd
+    planPeriodEndAfterSeconds
+  }
+}
+`;
+
+export const AssociateUserIssuedPlanMutation = gql`
+mutation AssociateUserIssuedPlan($input: AssociateUserIssuedPlanInput!){
+  associateUserIssuedPlan(input: $input) {
+    userPlan {
+      id
+      plan {
+        ${planFields}
+      }
+      periodEnd
+    }
+  }
+}`;
+
+export const UserPlansQuery = gql`
+query UserPlans {
+  userPlans {
+    id
+    periodEnd
+    plan {
+      ${planFields}
+    }
+  }
+}
+`;
+
+export const StripeQuery = gql`
+  query Stripe {
+    stripe {
+      id
+      customer
+    }
+  }
+`;

package/src/lib/plan/plan.service.spec.ts

@@ -0,0 +1,294 @@
+import { TestBed, async } from '@angular/core/testing';
+import {
+  lrConfigureTestingModule,
+  lrExpectAsyncThrow,
+  lrit,
+} from '../_common/tests';
+import { PlanService } from './plan.service';
+import gql from 'graphql-tag';
+import { LrApolloService } from '../api/lr-apollo.service';
+import {
+  loginTestUser,
+  logoutUser,
+} from '../auth/life-ready-auth.service.spec';
+import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
+import { environment } from 'projects/lr-auth-app/src/environments/environment';
+import { FeatureAction } from '../auth/auth.types';
+import { setupTps } from '../trusted-parties/trusted-party.service.spec';
+import { TrustedPartyService } from '../trusted-parties/trusted-party.service';
+
+const TIMEOUT = 1000 * 60 * 10;
+
+const DebugCreateUserPlanMutation = gql`
+  mutation DebugCreateUserPlan($planName: String!, $periodEnd: DateTime) {
+    debugCreateUserPlan(input: { planName: $planName, periodEnd: $periodEnd }) {
+      userPlan {
+        id
+      }
+    }
+  }
+`;
+
+const DebugDeletePlanMutation = gql`
+  mutation DebugDeleteUserPlan($id: LrRelayIdInput!) {
+    debugDeleteUserPlan(input: { id: $id }) {
+      id
+    }
+  }
+`;
+
+describe('PlanService', () => {
+  let planService: PlanService;
+  let lrApollo: LrApolloService;
+  let authService: LifeReadyAuthService;
+  let tpService: TrustedPartyService;
+
+  beforeEach(() => {
+    lrConfigureTestingModule();
+    planService = TestBed.inject(PlanService);
+    lrApollo = TestBed.inject(LrApolloService);
+    authService = TestBed.inject(LifeReadyAuthService);
+    tpService = TestBed.inject(TrustedPartyService);
+  });
+
+  enum PlanName {
+    DEBUG_ALLOW_ALL = 'debug_allow_all',
+  }
+
+  async function debugCreateUserPlan(
+    planName: PlanName,
+    periodEnd?: string // ISO string
+  ): Promise<void> {
+    const res = await lrApollo.mutate<{ debugCreateUserPlan: any }>({
+      mutation: DebugCreateUserPlanMutation,
+      variables: {
+        planName,
+        periodEnd,
+      },
+    });
+  }
+
+  async function debugDeleteUserPlan(id: string): Promise<void> {
+    const res = await lrApollo.mutate<{ debugDeleteUserPlan: any }>({
+      mutation: DebugDeletePlanMutation,
+      variables: {
+        id,
+      },
+    });
+  }
+
+  function futureDate(seconds) {
+    return new Date(Date.now() + 1000 * seconds);
+  }
+
+  async function deleteAllIssuedPlans() {
+    const issuedPlans = await planService.getUserIssuedPlans();
+    await Promise.all(
+      issuedPlans.map((t) => planService.deleteUserIssuedPlan(t.id))
+    );
+  }
+
+  async function deleteAllUserPlans() {
+    const userPlans = await planService.getUserPlans();
+    await Promise.all(userPlans.map((t) => debugDeleteUserPlan(t.id)));
+  }
+
+  const {
+    username: username1,
+    password: password1,
+  } = environment.test.users[0];
+  const {
+    username: username2,
+    password: password2,
+  } = environment.test.users[1];
+
+  lrit('should be created', () => {
+    expect(planService).toBeTruthy();
+  });
+
+  lrit(
+    'should get list of user issuable plans',
+    async () => {
+      const user1 = await loginTestUser(username1, password1);
+
+      const issuablePlans = await planService.getUserIssuablePlans();
+      expect(issuablePlans.length).toBe(1);
+      expect(issuablePlans[0].plan.name).toEqual(PlanName.DEBUG_ALLOW_ALL);
+    },
+    TIMEOUT
+  );
+
+  lrit(
+    'should issue plans',
+    async () => {
+      const user1 = await loginTestUser(username1, password1);
+
+      await deleteAllIssuedPlans();
+
+      const tokenExpiryTime = futureDate(15);
+      const planPeriodEnd = futureDate(1000);
+
+      const issuedPlan = await planService.createUserIssuedPlan({
+        planName: PlanName.DEBUG_ALLOW_ALL,
+        tokenExpiryTime,
+        planPeriodEnd,
+      });
+
+      expect(issuedPlan.plan.name).toEqual(PlanName.DEBUG_ALLOW_ALL);
+      expect(issuedPlan.planPeriodEnd).toEqual(planPeriodEnd);
+      expect(issuedPlan.tokenExpiryTime).toEqual(tokenExpiryTime);
+
+      let issuedPlans = await planService.getUserIssuedPlans();
+      expect(issuedPlans.length).toBe(1);
+
+      await planService.deleteUserIssuedPlan(issuedPlan.id);
+
+      issuedPlans = await planService.getUserIssuedPlans();
+      expect(issuedPlans.length).toBe(0);
+    },
+    TIMEOUT
+  );
+
+  lrit(
+    'should get stripe issued plans',
+    async () => {
+      await loginTestUser(username1, password1);
+      await planService.getStripe();
+    },
+    TIMEOUT
+  );
+
+  lrit(
+    'should associate issued plans',
+    async () => {
+      await loginTestUser(username1, password1);
+
+      await deleteAllIssuedPlans();
+
+      const tokenExpiryTime = futureDate(15);
+      const planPeriodEnd = futureDate(1000);
+
+      const issuedPlan = await planService.createUserIssuedPlan({
+        planName: PlanName.DEBUG_ALLOW_ALL,
+        tokenExpiryTime,
+        planPeriodEnd,
+      });
+
+      // Has access without the token
+      expect((await planService.getUserIssuedPlan(issuedPlan.id)).id).toEqual(
+        issuedPlan.id
+      );
+
+      await logoutUser();
+
+      // No access without the token
+      await lrExpectAsyncThrow(planService.getUserIssuedPlan(issuedPlan.id));
+
+      // Has access with the token
+      expect(
+        (await planService.getUserIssuedPlan(issuedPlan.id, issuedPlan.token))
+          .id
+      ).toEqual(issuedPlan.id);
+
+      await loginTestUser(username2, password2);
+      await deleteAllUserPlans();
+
+      // No access without the token
+      await lrExpectAsyncThrow(planService.getUserIssuedPlan(issuedPlan.id));
+
+      // Has access with the token
+      expect(
+        (await planService.getUserIssuedPlan(issuedPlan.id, issuedPlan.token))
+          .id
+      ).toEqual(issuedPlan.id);
+
+      await lrExpectAsyncThrow(
+        planService.associateUserIssuedPlan({
+          id: issuedPlan.id,
+          token: issuedPlan.token + '123',
+        })
+      );
+      await lrExpectAsyncThrow(
+        planService.associateUserIssuedPlan({
+          id: issuedPlan.id,
+          token: null,
+        })
+      );
+      await lrExpectAsyncThrow(
+        planService.associateUserIssuedPlan({
+          id: issuedPlan.id,
+          token: '',
+        })
+      );
+
+      const userPlan = await planService.associateUserIssuedPlan({
+        id: issuedPlan.id,
+        token: issuedPlan.token,
+      });
+
+      expect(userPlan.plan.name).toBe(PlanName.DEBUG_ALLOW_ALL);
+
+      const userPlans = await planService.getUserPlans();
+      expect(userPlans.some((t) => t.id === userPlan.id)).toBeTrue();
+
+      await loginTestUser(username1, password1);
+
+      let issuedPlans = await planService.getUserIssuedPlans();
+      expect(issuedPlans.length).toBe(1);
+      expect(issuedPlans[0].id).toBe(issuedPlan.id);
+
+      // Deleting a UserIssuedPlan should also delete any associated UserPlans.
+      await loginTestUser(username1, password1);
+      await planService.deleteUserIssuedPlan(issuedPlan.id);
+
+      await loginTestUser(username2, password2);
+      issuedPlans = await planService.getUserIssuedPlans();
+      expect(issuedPlans.length).toBe(0);
+    },
+    TIMEOUT
+  );
+
+  lrit(
+    'should create user plans',
+    async () => {
+      let user1 = await loginTestUser(username1, password1);
+      // Remove all existing plans
+      await Promise.all(
+        user1.userPlans.map((userPlan) => debugDeleteUserPlan(userPlan.id))
+      );
+
+      // End in a few seconds
+      const endSeconds = 5;
+      const periodEnd = futureDate(endSeconds).toISOString();
+
+      await debugCreateUserPlan(PlanName.DEBUG_ALLOW_ALL, periodEnd);
+
+      user1 = await authService.getUser(true);
+
+      expect(user1.userPlans.length).toBe(1);
+      expect(user1.userPlans[0].plan.name).toEqual(PlanName.DEBUG_ALLOW_ALL);
+      expect(user1.features.myVault).toEqual([FeatureAction.ACCESS]);
+      expect(user1.features.shareVault).toEqual([FeatureAction.ACCESS]);
+      expect(user1.features.tpVault).toEqual([FeatureAction.ACCESS]);
+
+      // Wait for plan to end
+      await new Promise((res) => setTimeout(res, 1000 * endSeconds));
+
+      user1 = await authService.getUser(true);
+      expect(user1.userPlans.length).toBe(0);
+
+      // Add one again
+      await debugCreateUserPlan(PlanName.DEBUG_ALLOW_ALL);
+
+      // Make sure user2 is a TP
+      await setupTps(username1, password1, username2, password2);
+
+      await loginTestUser(username2, password2);
+
+      const tps = await tpService.getTrustedParties();
+      const user2Tp1 = tps.find((tp) => tp.username === username1);
+      expect(user2Tp1.features.sharedVault.hasAccess).toBeTrue();
+    },
+    TIMEOUT
+  );
+});

package/src/lib/plan/plan.service.ts

@@ -0,0 +1,198 @@
+import { Injectable } from '@angular/core';
+import {
+  CreateStripeCheckoutSessionMutation,
+  CreateStripeBillingPortalSessionMutation,
+  UserIssuablePlansQuery,
+  CreateUserIssuedPlanMutation,
+  DeleteUserIssuedPlanMutation,
+  UserIssuedPlansQuery,
+  AssociateUserIssuedPlanMutation,
+  UserPlansQuery,
+  StripeQuery,
+  UserIssuedPlanQuery,
+} from './plan.gql';
+import { LrApolloService } from '../api/lr-apollo.service';
+import {
+  StripeCheckoutSession,
+  StripeBillingPortalSession,
+  UserIssuablePlan,
+  UserIssuedPlan,
+  UserPlan,
+} from './plan.types';
+import { LrBadArgumentException } from '../_common/exceptions';
+
+export function mapUserPlans(userPlans: any[]): UserPlan[] {
+  return userPlans.map((t) => ({
+    ...t,
+    periodEnd: t.periodEnd && new Date(t.periodEnd),
+    subscription: { id: t.stripe?.subscriptionId },
+  }));
+}
+
+@Injectable({
+  providedIn: 'root',
+})
+export class PlanService {
+  constructor(private lrApollo: LrApolloService) {}
+
+  async createStripeCheckoutSession(input: {
+    priceId: string;
+    successUrl: string;
+    cancelUrl: string;
+  }): Promise<StripeCheckoutSession> {
+    const res = await this.lrApollo.mutate<{
+      createStripeCheckoutSession: any;
+    }>({
+      mutation: CreateStripeCheckoutSessionMutation,
+      variables: {
+        ...input,
+      },
+    });
+    return {
+      id: res.createStripeCheckoutSession.sessionId,
+    };
+  }
+
+  async createStripeBillingPortalSession(
+    returnUrl: string
+  ): Promise<StripeBillingPortalSession> {
+    const res = await this.lrApollo.mutate<{
+      createStripeBillingPortalSession: any;
+    }>({
+      mutation: CreateStripeBillingPortalSessionMutation,
+      variables: {
+        returnUrl,
+      },
+    });
+    return {
+      url: res.createStripeBillingPortalSession.sessionUrl,
+    };
+  }
+
+  async getUserIssuablePlans(): Promise<UserIssuablePlan[]> {
+    const { userIssuablePlans } = await this.lrApollo.query<{
+      userIssuablePlans: any;
+    }>({
+      query: UserIssuablePlansQuery,
+    });
+
+    return userIssuablePlans;
+  }
+
+  async createUserIssuedPlan({
+    planName,
+    tokenExpiryTime,
+    planPeriodEnd,
+    planPeriodEndAfterSeconds,
+  }: {
+    planName: string;
+    tokenExpiryTime: Date;
+    planPeriodEnd?: Date;
+    planPeriodEndAfterSeconds?: number;
+  }): Promise<UserIssuedPlan> {
+    if (planPeriodEnd == null && planPeriodEndAfterSeconds == null) {
+      throw new LrBadArgumentException(
+        'Must specify either "planPeriodEnd" or "planPeriodEndAfterSeconds"'
+      );
+    }
+
+    const { createUserIssuedPlan } = await this.lrApollo.mutate<any>({
+      mutation: CreateUserIssuedPlanMutation,
+      variables: {
+        input: {
+          planName,
+          tokenExpiryTime: tokenExpiryTime.toISOString(),
+          planPeriodEnd: planPeriodEnd && planPeriodEnd.toISOString(),
+          planPeriodEndAfterSeconds,
+        },
+      },
+    });
+
+    const { userIssuedPlan } = createUserIssuedPlan;
+
+    return {
+      ...userIssuedPlan,
+      tokenExpiryTime: new Date(userIssuedPlan.tokenExpiryTime),
+      planPeriodEnd: new Date(userIssuedPlan.planPeriodEnd),
+    };
+  }
+
+  async deleteUserIssuedPlan(id: string): Promise<void> {
+    return await this.lrApollo.mutate<any>({
+      mutation: DeleteUserIssuedPlanMutation,
+      variables: {
+        input: {
+          id,
+        },
+      },
+    });
+  }
+
+  async getUserIssuedPlans(): Promise<any[]> {
+    const { userIssuedPlans } = await this.lrApollo.query<any>({
+      query: UserIssuedPlansQuery,
+    });
+
+    return userIssuedPlans.edges.map((edge) => edge.node);
+  }
+
+  async getUserIssuedPlan(id: string, token?: string): Promise<any> {
+    const { userIssuedPlan } = await this.lrApollo.query<any>({
+      query: UserIssuedPlanQuery,
+      variables: {
+        id,
+        token,
+      },
+    });
+
+    return userIssuedPlan;
+  }
+
+  async associateUserIssuedPlan({
+    id,
+    token,
+  }: {
+    id: string;
+    token: string;
+  }): Promise<UserPlan> {
+    const { associateUserIssuedPlan } = await this.lrApollo.query<any>({
+      query: AssociateUserIssuedPlanMutation,
+      variables: {
+        input: {
+          id,
+          token,
+        },
+      },
+    });
+
+    const { userPlan } = associateUserIssuedPlan;
+
+    return {
+      ...userPlan,
+      periodEnd: new Date(userPlan.periodEnd),
+    };
+  }
+
+  async getUserPlans(): Promise<UserPlan[]> {
+    const { userPlans } = await this.lrApollo.query<any>({
+      query: UserPlansQuery,
+    });
+
+    return mapUserPlans(userPlans);
+  }
+
+  async getPlanType(subscriptionId: string): Promise<string> {
+    const stripe: any = await this.getStripe();
+    return stripe.customer.subscriptions.data.filter(
+      (sub) => sub.id === subscriptionId
+    )[0].items.data[0].plan.interval;
+  }
+
+  async getStripe(): Promise<{ id: string; customer: object }> {
+    const { stripe } = await this.lrApollo.query<any>({
+      query: StripeQuery,
+    });
+
+    return stripe;
+  }
+}

package/src/lib/plan/plan.types.ts

@@ -0,0 +1,37 @@
+export class Plan {
+  name: string;
+  data: object;
+  state: string;
+}
+
+export class Subscription {
+  id: string;
+}
+
+export class UserPlan {
+  id: string;
+  plan: Plan;
+  periodEnd: Date;
+  subscription: Subscription;
+}
+
+export class StripeCheckoutSession {
+  id: string;
+}
+
+export class StripeBillingPortalSession {
+  url: string;
+}
+
+export interface UserIssuablePlan {
+  plan: Plan;
+}
+
+export interface UserIssuedPlan {
+  id: string;
+  plan: Plan;
+  token: string;
+  tokenExpiryTime: Date;
+  planPeriodEnd: Date;
+  planPeriodEndAfterSeconds: number;
+}

package/src/lib/record/record-attachment.service.spec.ts

@@ -0,0 +1,31 @@
+import { TestBed } from '@angular/core/testing';
+import { FileService } from '../api/file.service';
+import { LrApolloService } from '../api/lr-apollo.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyMetaService } from '../cryptography/key-meta.service';
+import { lrConfigureTestingModule } from '../_common/tests';
+import { RecordAttachmentService } from './record-attachment.service';
+
+const fileService = jasmine.createSpyObj<FileService>('FileService', [
+  'downloadEncryptedFile',
+]);
+const lrApollo = jasmine.createSpyObj<LrApolloService>('LrApolloService', [
+  'mutate',
+]);
+const keyGraphService = jasmine.createSpyObj<KeyGraphService>(
+  'KeyGraphService',
+  ['decryptFile']
+);
+
+describe('RecordAttachmentService', () => {
+  let service: RecordAttachmentService;
+
+  beforeEach(() => {
+    lrConfigureTestingModule();
+    service = TestBed.inject(RecordAttachmentService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});