@lifeready/core 1.0.21 → 1.0.22

package/esm2015/lib/persist/persist.service.js

@@ -0,0 +1,180 @@
+import { __awaiter } from "tslib";
+import { Injectable, Injector, isDevMode } from '@angular/core';
+import { CookieService } from 'ngx-cookie-service';
+import { EncryptionService } from '../encryption/encryption.service';
+import { KeyFactoryService as KFS } from '../key/key-factory.service';
+import { LrBadArgumentException } from '../_common/exceptions';
+import * as i0 from "@angular/core";
+import * as i1 from "../key/key-factory.service";
+import * as i2 from "ngx-cookie-service";
+import * as i3 from "../encryption/encryption.service";
+export class PersistService {
+    constructor(keyFactory, cookieService, encryptionService, injector) {
+        this.keyFactory = keyFactory;
+        this.cookieService = cookieService;
+        this.encryptionService = encryptionService;
+        this.injector = injector;
+        this.KEY_PREFIX = 'lrSession-';
+        this.cookieSecure = true;
+        this.serverSessionEncryptionKey = null;
+        if (isDevMode()) {
+            this.setCookieSecure(false);
+        }
+    }
+    setServerSessionEncryptionKey(key) {
+        this.serverSessionEncryptionKey = key;
+    }
+    clearServerSessionEncryptionKey() {
+        this.serverSessionEncryptionKey = null;
+    }
+    // It's important that set and delete cookie use exactly the same set of parameters.
+    getCookieParams() {
+        return {
+            path: '/',
+            domain: null,
+            secure: this.cookieSecure,
+            sameSite: 'Lax',
+        };
+    }
+    clear() {
+        // Remove all cookies
+        Object.keys(this.cookieService.getAll()).forEach((key) => {
+            if (key.startsWith(this.KEY_PREFIX)) {
+                this.deletePrefixedName(key);
+            }
+        });
+        // Remove all persisted session variables
+        Object.keys(localStorage).forEach((key) => {
+            if (key.startsWith(this.KEY_PREFIX)) {
+                this.deletePrefixedName(key);
+            }
+        });
+    }
+    setCookieSecure(value) {
+        this.cookieSecure = value;
+        if (!value) {
+            if (isDevMode()) {
+                console.warn('The cookie secure flag in persistService has been set to false, set it to true in production mode');
+            }
+            else {
+                throw new LrBadArgumentException('Can not set PersistService cookie secure flag to false in production mode.');
+            }
+        }
+    }
+    prefixName(name) {
+        return this.KEY_PREFIX + name;
+    }
+    delete(name) {
+        this.deletePrefixedName(this.prefixName(name));
+    }
+    deletePrefixedName(prefixedName) {
+        const params = this.getCookieParams();
+        this.cookieService.delete(prefixedName, // name: string,
+        params.path, // path?: string,
+        params.domain, // domain ?: string,
+        params.secure, // secure ?: boolean,
+        params.sameSite // sameSite ?: 'Lax' | 'None' | 'Strict'): void;
+        );
+        localStorage.removeItem(prefixedName);
+    }
+    set({ name, value, serverSession, expiry, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const prefixedName = this.prefixName(name);
+            let item;
+            if (serverSession) {
+                item = {
+                    serverSession: true,
+                    data: yield this.encryptionService.encryptToString(this.serverSessionEncryptionKey, value),
+                };
+            }
+            else {
+                item = {
+                    data: value,
+                };
+            }
+            if (expiry) {
+                const key = yield this.keyFactory.createKey();
+                item.expiry = expiry.toISOString();
+                item.data = yield this.encryptionService.encryptToString(key, item.data);
+                const cookieItem = {
+                    key: key.toJSON(true),
+                };
+                // If path is set to anything other than "/" then the cookie is only
+                // accessible by JS if the current URL has the same prefix as the path.
+                // Ideally we don't want the encryption key cookie to be sent at all, but
+                // since the encrypted content is held in localstorage, it is not a security
+                // risk, i.e. it is at least as secure as storing only in localstorage.
+                const params = this.getCookieParams();
+                this.cookieService.set(prefixedName, // name: string,
+                JSON.stringify(cookieItem), // value: string,
+                expiry, // expires?: number | Date,
+                params.path, // path?: string,
+                params.domain, // domain?: string,
+                params.secure, // secure?: boolean,
+                params.sameSite // sameSite?: 'Lax' | 'None' | 'Strict'
+                );
+            }
+            localStorage.setItem(prefixedName, JSON.stringify(item));
+        });
+    }
+    get(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const prefixedName = this.prefixName(name);
+            try {
+                const ret = yield this.getImpl(prefixedName);
+                if (ret == null) {
+                    // Clear any cookies to keep things in sync.
+                    this.deletePrefixedName(prefixedName);
+                }
+                return ret;
+            }
+            catch (error) {
+                this.deletePrefixedName(prefixedName);
+                throw error;
+            }
+        });
+    }
+    getImpl(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const itemString = localStorage.getItem(name);
+            if (!itemString) {
+                return null;
+            }
+            const item = JSON.parse(itemString);
+            let data;
+            if (item.expiry) {
+                const cookieItemString = this.cookieService.get(name);
+                if (!cookieItemString) {
+                    // Probably expired, but we won't make any interpretations since if we only used
+                    // cookies we can't tell if it's expired or explicitly removed. So we just make
+                    // the behaviour here consistent with that.
+                    console.log('No cookie.');
+                    return null;
+                }
+                const cookieItem = JSON.parse(cookieItemString);
+                const key = yield KFS.asKey(cookieItem.key);
+                data = yield this.encryptionService.decrypt(key, item.data);
+            }
+            else {
+                data = item.data;
+            }
+            if (item.serverSession) {
+                data = yield this.encryptionService.decrypt(this.serverSessionEncryptionKey, data);
+            }
+            return data;
+        });
+    }
+}
+PersistService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PersistService_Factory() { return new PersistService(i0.ɵɵinject(i1.KeyFactoryService), i0.ɵɵinject(i2.CookieService), i0.ɵɵinject(i3.EncryptionService), i0.ɵɵinject(i0.INJECTOR)); }, token: PersistService, providedIn: "root" });
+PersistService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+PersistService.ctorParameters = () => [
+    { type: KFS },
+    { type: CookieService },
+    { type: EncryptionService },
+    { type: Injector }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"persist.service.js","sourceRoot":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/persist/persist.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector, isDevMode } from '@angular/core';\nimport { CookieService } from 'ngx-cookie-service';\nimport { JWK } from 'node-jose';\nimport { EncryptionService } from '../encryption/encryption.service';\nimport { KeyFactoryService as KFS } from '../key/key-factory.service';\nimport { LrBadArgumentException } from '../_common/exceptions';\n\ninterface Item {\n  data: string;\n  expiry?: string; // iso format\n  serverSession?: boolean;\n}\n\ninterface CookieItem {\n  key: any;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class PersistService {\n  private readonly KEY_PREFIX = 'lrSession-';\n\n  private cookieSecure = true;\n  private serverSessionEncryptionKey: JWK.Key = null;\n\n  constructor(\n    private keyFactory: KFS,\n    private cookieService: CookieService,\n    private encryptionService: EncryptionService,\n    private injector: Injector\n  ) {\n    if (isDevMode()) {\n      this.setCookieSecure(false);\n    }\n  }\n\n  setServerSessionEncryptionKey(key: JWK.Key) {\n    this.serverSessionEncryptionKey = key;\n  }\n\n  clearServerSessionEncryptionKey() {\n    this.serverSessionEncryptionKey = null;\n  }\n\n  // It's important that set and delete cookie use exactly the same set of parameters.\n  private getCookieParams() {\n    return {\n      path: '/',\n      domain: null, // which means the current domain of the frontend app.\n      secure: this.cookieSecure,\n      sameSite: 'Lax' as 'Lax' | 'None' | 'Strict',\n    };\n  }\n\n  public clear() {\n    // Remove all cookies\n    Object.keys(this.cookieService.getAll()).forEach((key) => {\n      if (key.startsWith(this.KEY_PREFIX)) {\n        this.deletePrefixedName(key);\n      }\n    });\n\n    // Remove all persisted session variables\n    Object.keys(localStorage).forEach((key) => {\n      if (key.startsWith(this.KEY_PREFIX)) {\n        this.deletePrefixedName(key);\n      }\n    });\n  }\n\n  public setCookieSecure(value: boolean) {\n    this.cookieSecure = value;\n    if (!value) {\n      if (isDevMode()) {\n        console.warn(\n          'The cookie secure flag in persistService has been set to false, set it to true in production mode'\n        );\n      } else {\n        throw new LrBadArgumentException(\n          'Can not set PersistService cookie secure flag to false in production mode.'\n        );\n      }\n    }\n  }\n\n  private prefixName(name: string): string {\n    return this.KEY_PREFIX + name;\n  }\n\n  public delete(name: string): void {\n    this.deletePrefixedName(this.prefixName(name));\n  }\n\n  private deletePrefixedName(prefixedName: string): void {\n    const params = this.getCookieParams();\n    this.cookieService.delete(\n      prefixedName, // name: string,\n      params.path, // path?: string,\n      params.domain, // domain ?: string,\n      params.secure, // secure ?: boolean,\n      params.sameSite // sameSite ?: 'Lax' | 'None' | 'Strict'): void;\n    );\n    localStorage.removeItem(prefixedName);\n  }\n\n  public async set({\n    name,\n    value,\n    serverSession,\n    expiry,\n  }: {\n    name: string;\n    value: any;\n    serverSession: boolean;\n    expiry?: Date;\n  }): Promise<void> {\n    const prefixedName = this.prefixName(name);\n\n    let item: Item;\n\n    if (serverSession) {\n      item = {\n        serverSession: true,\n        data: await this.encryptionService.encryptToString(\n          this.serverSessionEncryptionKey,\n          value\n        ),\n      };\n    } else {\n      item = {\n        data: value,\n      };\n    }\n\n    if (expiry) {\n      const key = await this.keyFactory.createKey();\n      item.expiry = expiry.toISOString();\n      item.data = await this.encryptionService.encryptToString(key, item.data);\n\n      const cookieItem: CookieItem = {\n        key: key.toJSON(true),\n      };\n\n      // If path is set to anything other than \"/\" then the cookie is only\n      // accessible by JS if the current URL has the same prefix as the path.\n      // Ideally we don't want the encryption key cookie to be sent at all, but\n      // since the encrypted content is held in localstorage, it is not a security\n      // risk, i.e. it is at least as secure as storing only in localstorage.\n      const params = this.getCookieParams();\n      this.cookieService.set(\n        prefixedName, // name: string,\n        JSON.stringify(cookieItem), // value: string,\n        expiry, // expires?: number | Date,\n        params.path, // path?: string,\n        params.domain, // domain?: string,\n        params.secure, // secure?: boolean,\n        params.sameSite // sameSite?: 'Lax' | 'None' | 'Strict'\n      );\n    }\n\n    localStorage.setItem(prefixedName, JSON.stringify(item));\n  }\n\n  public async get(name: string): Promise<any> {\n    const prefixedName = this.prefixName(name);\n\n    try {\n      const ret = await this.getImpl(prefixedName);\n      if (ret == null) {\n        // Clear any cookies to keep things in sync.\n        this.deletePrefixedName(prefixedName);\n      }\n      return ret;\n    } catch (error) {\n      this.deletePrefixedName(prefixedName);\n      throw error;\n    }\n  }\n\n  private async getImpl(name: string): Promise<any> {\n    const itemString = localStorage.getItem(name);\n    if (!itemString) {\n      return null;\n    }\n\n    const item: Item = JSON.parse(itemString);\n\n    let data: any;\n\n    if (item.expiry) {\n      const cookieItemString = this.cookieService.get(name);\n      if (!cookieItemString) {\n        // Probably expired, but we won't make any interpretations since if we only used\n        // cookies we can't tell if it's expired or explicitly removed. So we just make\n        // the behaviour here consistent with that.\n        console.log('No cookie.');\n        return null;\n      }\n\n      const cookieItem = JSON.parse(cookieItemString);\n\n      const key = await KFS.asKey(cookieItem.key);\n\n      data = await this.encryptionService.decrypt(key, item.data);\n    } else {\n      data = item.data;\n    }\n\n    if (item.serverSession) {\n      data = await this.encryptionService.decrypt(\n        this.serverSessionEncryptionKey,\n        data\n      );\n    }\n\n    return data;\n  }\n}\n"]}

package/esm2015/lib/profile/profile-details.service.js

@@ -0,0 +1,214 @@
+import { __awaiter, __rest } from "tslib";
+import { Injectable } from '@angular/core';
+import _ from 'lodash';
+import { SharedContactCardService } from '../shared-contact-card/shared-contact-card.service';
+import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
+import { TrustedPartyService } from '../trusted-party/trusted-party.service';
+import { ProfileService } from './profile.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../shared-contact-card/shared-contact-card.service";
+import * as i2 from "../trusted-party/trusted-party.service";
+import * as i3 from "./profile.service";
+import * as i4 from "../auth/life-ready-auth.service";
+var ContactFields;
+(function (ContactFields) {
+    ContactFields["Name"] = "name";
+    ContactFields["Email"] = "email";
+    ContactFields["Image"] = "image";
+    ContactFields["Phone"] = "phone";
+    ContactFields["Address"] = "address";
+})(ContactFields || (ContactFields = {}));
+const FieldNames = [
+    ContactFields.Name,
+    ContactFields.Email,
+    ContactFields.Image,
+    ContactFields.Phone,
+    ContactFields.Address,
+];
+class FieldChange {
+}
+export class ProfileDetailsService {
+    constructor(sharedContactCardService, trustedPartyService, profileService, authService) {
+        this.sharedContactCardService = sharedContactCardService;
+        this.trustedPartyService = trustedPartyService;
+        this.profileService = profileService;
+        this.authService = authService;
+    }
+    updateDetails(fields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.authService.getUser();
+            yield this.profileService.updateDetails(user.contactCard.id, user.contactCard.keyId, fields);
+            yield this.synchronizeContactCards(fields, user.contactCard);
+            return yield this.authService.getUser(true);
+        });
+    }
+    synchronizeContactCards(newFields, oldFields) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!oldFields)
+                return;
+            const changes = this.getChanges(newFields, oldFields);
+            if (changes.length === 0)
+                return;
+            const trustedParties = yield this.trustedPartyService.getTrustedParties();
+            if (trustedParties.length === 0)
+                return;
+            for (const details of trustedParties.map((x) => x.mySharedDetails)) {
+                yield this.synchronizeSharedContactCard(details, changes);
+            }
+        });
+    }
+    getChanges(newFields, oldFields) {
+        const changes = [];
+        for (const field of FieldNames) {
+            const oldField = oldFields[field];
+            if (oldField && oldField.values) {
+                for (const oldValue of oldField.values) {
+                    const newValue = newFields[field].values.find((x) => x.id === oldValue.id);
+                    if (!newValue) {
+                        changes.push({
+                            field,
+                            id: oldValue.id,
+                            label: oldValue.label,
+                            oldValue: oldValue.value,
+                        });
+                    }
+                    else if (!_.isEqual(newValue.value, oldValue.value)) {
+                        changes.push({
+                            field,
+                            id: oldValue.id,
+                            label: oldValue.label,
+                            oldValue: oldValue.value,
+                            newValue: newValue.value,
+                        });
+                    }
+                }
+            }
+        }
+        return changes;
+    }
+    synchronizeSharedContactCard(details, changes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let hasChanged = false;
+            for (const change of changes) {
+                switch (change.field) {
+                    case ContactFields.Phone:
+                        {
+                            const value = details.phones &&
+                                details.phones.find((x) => x.label === change.label);
+                            if (value) {
+                                hasChanged = true;
+                                value.value = change.newValue;
+                            }
+                        }
+                        break;
+                    case ContactFields.Address:
+                        {
+                            const value = details.addresses &&
+                                details.addresses.find((x) => x.label === change.label);
+                            if (value) {
+                                hasChanged = true;
+                                value.value = change.newValue;
+                            }
+                        }
+                        break;
+                    default: {
+                        const value = details[change.field];
+                        if (_.isEqual(value, change.oldValue)) {
+                            hasChanged = true;
+                            details[change.field] = change.newValue;
+                        }
+                    }
+                }
+            }
+            if (hasChanged) {
+                const { id, ownedKeyId, sharedKeyId } = details, contactCard = __rest(details, ["id", "ownedKeyId", "sharedKeyId"]);
+                yield this.sharedContactCardService.updateMySharedContactCard(id, ownedKeyId, sharedKeyId, contactCard);
+            }
+        });
+    }
+    updateTrustedPartyDetails(details) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { id, ownedKeyId, sharedKeyId } = details, contactCard = __rest(details, ["id", "ownedKeyId", "sharedKeyId"]);
+            yield this.sharedContactCardService.updateMySharedContactCard(id, ownedKeyId, sharedKeyId, contactCard);
+            yield this.synchronizeSharedDetails(details);
+        });
+    }
+    synchronizeSharedDetails(details) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { contactCard } = yield this.authService.getUser();
+            let hasNewValues = false;
+            contactCard = Object.assign({}, contactCard);
+            if (details.name) {
+                const property = this.checkField(details.name, contactCard.name);
+                if (property) {
+                    contactCard.name = property;
+                    hasNewValues = true;
+                }
+            }
+            if (details.email) {
+                const property = this.checkField(details.email, contactCard.email);
+                if (property) {
+                    contactCard.email = property;
+                    hasNewValues = true;
+                }
+            }
+            if (details.image) {
+                const property = this.checkField(details.image, contactCard.image);
+                if (property) {
+                    contactCard.image = property;
+                    hasNewValues = true;
+                }
+            }
+            if (details.phones && details.phones.length) {
+                for (const phone of details.phones) {
+                    const property = this.checkField(phone.value, contactCard.phone, phone.label);
+                    if (property) {
+                        contactCard.phone = property;
+                        hasNewValues = true;
+                    }
+                }
+            }
+            if (details.addresses && details.addresses.length) {
+                for (const address of details.addresses) {
+                    const property = this.checkField(address.value, contactCard.address, address.label);
+                    if (property) {
+                        contactCard.address = property;
+                        hasNewValues = true;
+                    }
+                }
+            }
+            if (hasNewValues) {
+                yield this.profileService.updateDetails(contactCard.id, contactCard.keyId, contactCard);
+            }
+        });
+    }
+    checkField(field, property, label = null) {
+        property = property || { value: field, hasMultiple: false };
+        property.values = property.values || [];
+        if (property.values.length === 0 ||
+            property.values.every((x) => !_.isEqual(field, x.value))) {
+            property.values.push({
+                id: `${label}-${new Date().getTime()}`,
+                label,
+                value: field,
+            });
+            property.hasMultiple = property.values.length > 1;
+            property.value = property.value || field;
+            return property;
+        }
+        return null;
+    }
+}
+ProfileDetailsService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ProfileDetailsService_Factory() { return new ProfileDetailsService(i0.ɵɵinject(i1.SharedContactCardService), i0.ɵɵinject(i2.TrustedPartyService), i0.ɵɵinject(i3.ProfileService), i0.ɵɵinject(i4.LifeReadyAuthService)); }, token: ProfileDetailsService, providedIn: "root" });
+ProfileDetailsService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+ProfileDetailsService.ctorParameters = () => [
+    { type: SharedContactCardService },
+    { type: TrustedPartyService },
+    { type: ProfileService },
+    { type: LifeReadyAuthService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"profile-details.service.js","sourceRoot":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/profile/profile-details.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport _ from 'lodash';\nimport { SharedContactCardService } from '../shared-contact-card/shared-contact-card.service';\nimport { CurrentUser } from '../auth/auth.types';\nimport { LifeReadyAuthService } from '../auth/life-ready-auth.service';\nimport { TrustedPartyService } from '../trusted-party/trusted-party.service';\nimport { SharedTrustedPartyDetails } from '../trusted-party/trusted-party.types';\nimport { ProfileService } from './profile.service';\nimport {\n  MainContactCardFields,\n  MainContactCardProperty,\n  TrustedPartyDetails,\n} from './profile.types';\n\nenum ContactFields {\n  Name = 'name',\n  Email = 'email',\n  Image = 'image',\n  Phone = 'phone',\n  Address = 'address',\n}\n\nconst FieldNames = [\n  ContactFields.Name,\n  ContactFields.Email,\n  ContactFields.Image,\n  ContactFields.Phone,\n  ContactFields.Address,\n];\n\nclass FieldChange {\n  field: string;\n  id: string;\n  label: string;\n  oldValue?: any;\n  newValue?: any;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ProfileDetailsService {\n  constructor(\n    private sharedContactCardService: SharedContactCardService,\n    private trustedPartyService: TrustedPartyService,\n    private profileService: ProfileService,\n    private authService: LifeReadyAuthService\n  ) {}\n\n  public async updateDetails(\n    fields: MainContactCardFields\n  ): Promise<CurrentUser> {\n    const user = await this.authService.getUser();\n    await this.profileService.updateDetails(\n      user.contactCard.id,\n      user.contactCard.keyId,\n      fields\n    );\n    await this.synchronizeContactCards(fields, user.contactCard);\n    return await this.authService.getUser(true);\n  }\n\n  private async synchronizeContactCards(\n    newFields: MainContactCardFields,\n    oldFields: MainContactCardFields\n  ): Promise<void> {\n    if (!oldFields) return;\n\n    const changes = this.getChanges(newFields, oldFields);\n\n    if (changes.length === 0) return;\n\n    const trustedParties = await this.trustedPartyService.getTrustedParties();\n\n    if (trustedParties.length === 0) return;\n\n    for (const details of trustedParties.map((x) => x.mySharedDetails)) {\n      await this.synchronizeSharedContactCard(details, changes);\n    }\n  }\n\n  private getChanges(\n    newFields: MainContactCardFields,\n    oldFields: MainContactCardFields\n  ): FieldChange[] {\n    const changes: FieldChange[] = [];\n\n    for (const field of FieldNames) {\n      const oldField = oldFields[field];\n      if (oldField && oldField.values) {\n        for (const oldValue of oldField.values) {\n          const newValue = (newFields[field].values as any[]).find(\n            (x) => x.id === oldValue.id\n          );\n\n          if (!newValue) {\n            changes.push({\n              field,\n              id: oldValue.id,\n              label: oldValue.label,\n              oldValue: oldValue.value,\n            });\n          } else if (!_.isEqual(newValue.value, oldValue.value)) {\n            changes.push({\n              field,\n              id: oldValue.id,\n              label: oldValue.label,\n              oldValue: oldValue.value,\n              newValue: newValue.value,\n            });\n          }\n        }\n      }\n    }\n    return changes;\n  }\n\n  private async synchronizeSharedContactCard(\n    details: SharedTrustedPartyDetails,\n    changes: FieldChange[]\n  ): Promise<void> {\n    let hasChanged = false;\n    for (const change of changes) {\n      switch (change.field) {\n        case ContactFields.Phone:\n          {\n            const value =\n              details.phones &&\n              details.phones.find((x) => x.label === change.label);\n\n            if (value) {\n              hasChanged = true;\n              value.value = change.newValue;\n            }\n          }\n          break;\n        case ContactFields.Address:\n          {\n            const value =\n              details.addresses &&\n              details.addresses.find((x) => x.label === change.label);\n\n            if (value) {\n              hasChanged = true;\n              value.value = change.newValue;\n            }\n          }\n          break;\n        default: {\n          const value = details[change.field];\n\n          if (_.isEqual(value, change.oldValue)) {\n            hasChanged = true;\n            details[change.field] = change.newValue;\n          }\n        }\n      }\n    }\n    if (hasChanged) {\n      const { id, ownedKeyId, sharedKeyId, ...contactCard } = details;\n\n      await this.sharedContactCardService.updateMySharedContactCard(\n        id,\n        ownedKeyId,\n        sharedKeyId,\n        contactCard\n      );\n    }\n  }\n\n  public async updateTrustedPartyDetails(details: SharedTrustedPartyDetails) {\n    const { id, ownedKeyId, sharedKeyId, ...contactCard } = details;\n\n    await this.sharedContactCardService.updateMySharedContactCard(\n      id,\n      ownedKeyId,\n      sharedKeyId,\n      contactCard\n    );\n\n    await this.synchronizeSharedDetails(details);\n  }\n\n  public async synchronizeSharedDetails(details: TrustedPartyDetails) {\n    let { contactCard } = await this.authService.getUser();\n    let hasNewValues = false;\n    contactCard = { ...contactCard };\n\n    if (details.name) {\n      const property = this.checkField(details.name, contactCard.name);\n\n      if (property) {\n        contactCard.name = property;\n        hasNewValues = true;\n      }\n    }\n\n    if (details.email) {\n      const property = this.checkField(details.email, contactCard.email);\n\n      if (property) {\n        contactCard.email = property;\n        hasNewValues = true;\n      }\n    }\n\n    if (details.image) {\n      const property = this.checkField(details.image, contactCard.image);\n\n      if (property) {\n        contactCard.image = property;\n        hasNewValues = true;\n      }\n    }\n\n    if (details.phones && details.phones.length) {\n      for (const phone of details.phones) {\n        const property = this.checkField(\n          phone.value,\n          contactCard.phone,\n          phone.label\n        );\n\n        if (property) {\n          contactCard.phone = property;\n          hasNewValues = true;\n        }\n      }\n    }\n\n    if (details.addresses && details.addresses.length) {\n      for (const address of details.addresses) {\n        const property = this.checkField(\n          address.value,\n          contactCard.address,\n          address.label\n        );\n\n        if (property) {\n          contactCard.address = property;\n          hasNewValues = true;\n        }\n      }\n    }\n\n    if (hasNewValues) {\n      await this.profileService.updateDetails(\n        contactCard.id,\n        contactCard.keyId,\n        contactCard\n      );\n    }\n  }\n\n  private checkField<T>(\n    field: T,\n    property: MainContactCardProperty<T>,\n    label: string = null\n  ) {\n    property = property || { value: field, hasMultiple: false };\n    property.values = property.values || [];\n\n    if (\n      property.values.length === 0 ||\n      property.values.every((x) => !_.isEqual(field, x.value))\n    ) {\n      property.values.push({\n        id: `${label}-${new Date().getTime()}`,\n        label,\n        value: field,\n      });\n      property.hasMultiple = property.values.length > 1;\n      property.value = property.value || field;\n      return property;\n    }\n    return null;\n  }\n}\n"]}

package/esm2015/lib/profile/profile.gql.js

@@ -0,0 +1,97 @@
+import gql from 'graphql-tag';
+import { KeyGraphFragment } from '../_common/queries.gql';
+export const CurrentUserQuery = gql `
+  query {
+    currentUser {
+      id
+      username
+      currentUserKey {
+        passKey {
+          id
+          passKeyParams
+          passIdpParams
+          wrappedPassIdpVerifierPrk
+          created
+        }
+        masterKey {
+          id
+        }
+        rootKey {
+          id
+        }
+        pxk {
+          id
+        }
+        sigPxk {
+          id
+        }
+      }
+      userDelete {
+        id
+        created
+        state
+      }
+      features {
+        myVault
+        tpVault
+        shareVault
+      }
+      sessionEncryptionKey
+    }
+    userPlans {
+      id
+      stripe {
+        subscriptionId
+      }
+      plan {
+        name
+        data
+        state
+      }
+      periodEnd
+    }
+    contactCards(orderBy: "created") {
+      edges {
+        node {
+          id
+          key {
+            id
+          }
+          cipherData
+          plainData
+        }
+      }
+    }
+    keyGraph {
+      ...KeyGraphFragment
+    }
+  }
+  ${KeyGraphFragment}
+`;
+export const CreateContactCardMutation = gql `
+  mutation CreateContactCardMutation($input: CreateContactCardInput!) {
+    createContactCard(input: $input) {
+      contactCard {
+        id
+        key {
+          id
+        }
+        cipherData
+      }
+    }
+  }
+`;
+export const UpdateContactCardMutation = gql `
+  mutation UpdateContactCardMutation($input: UpdateContactCardInput!) {
+    updateContactCard(input: $input) {
+      contactCard {
+        id
+        key {
+          id
+        }
+        cipherData
+      }
+    }
+  }
+`;
+//# sourceMappingURL=data:application/json;base64,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