@bit-ui-libs/common/src/lib/asset/chain.utils.ts

This library was generated with [Nx](https://nx.dev).

import {
  AttachmentClassification,
  AttachmentData,
  AttachmentType,
  DEFAULT_APP_ID,
  DeviceTypeEnum,
  GeolocationData,
  ReferenceType,
  RelationTypeEnum,
  SubjectTypeEnum,
  WeatherData,
  makeSampleGeolocation,
  makeSampleWeatherData,
} from '../common';
import {
  AssetTypePropertyData,
  BaseTypePropertyData,
  ChainAssetEventData,
  ChainBaseEventData,
  ChainBaseEventMetadata,
  ChainServiceEventData,
  ChainTypeEnum,
  CreateChainAssetRequest,
  CreateChainBaseRequest,
  CreateChainServiceRequest,
  EventGroupItem,
  FindMainPhotoByTypeClassOpts,
  ServiceTypePropertyData,
  UpdateChainAssetDetailsRequest,
  UpdateChainBaseDetailsRequest,
  UpdateChainServiceDetailsRequest,
} from './interfaces';

export class ChainUtils {
  static getName(data: ChainBaseEventData) {
    if ('assetName' in data) return (data as ChainAssetEventData).assetName ?? '';
    if ('serviceName' in data) return (data as ChainServiceEventData).serviceName ?? '';
    return '';
  }

  static getNameFromProperties(props: BaseTypePropertyData[]) {
    if (props.some((p) => 'isAssetName' in p)) {
      const assetData = props as AssetTypePropertyData[];
      return assetData.find((p) => p.isAssetName)?.value ?? assetData.find((p) => p.value !== '')?.value ?? '';
    }
    if (props.some((p) => 'isServiceName' in p)) {
      const serviceData = props as ServiceTypePropertyData[];
      return serviceData.find((p) => p.isServiceName)?.value ?? serviceData.find((p) => p.value !== '')?.value ?? '';
    }
    return '';
  }

  static getCategories(data: ChainBaseEventData) {
    if ('assetCategory' in data) return (data as ChainAssetEventData).assetCategory ?? [];
    if ('serviceCategory' in data) return (data as ChainServiceEventData).serviceCategory ?? [];
    return [];
  }

  static getProperties(data: ChainBaseEventData): BaseTypePropertyData[] {
    if ('assetProperties' in data) return (data as ChainAssetEventData).assetProperties ?? [];
    if ('serviceProperties' in data) return (data as ChainServiceEventData).serviceProperties ?? [];
    return [];
  }

  static getMimeType(mimeType: string) {
    return mimeType === 'application/pdf' ? AttachmentType.TokenDocument : AttachmentType.TokenPhoto;
  }

  static findMainPhotoByTypeClass<TPhotos extends Pick<AttachmentData, 'classification' | 'isMain'>>(opts: FindMainPhotoByTypeClassOpts<TPhotos>) {
    const { photos, chainType, attachmentType } = opts;
    return photos
      ?.filter(
        (p) => p.classification === ChainUtils.getAttachmentClassification(chainType, attachmentType) && p.isMain
      )
      ?.pop();
  }

  static getAttachmentClassification(chainType: ChainTypeEnum, attachmentType: AttachmentType) {
    const classifications = {
      [AttachmentType.TokenDocument]: {
        [ChainTypeEnum.Services]: AttachmentClassification.ServiceDocument,
        [ChainTypeEnum.Objects]: AttachmentClassification.AssetDocument,
        [ChainTypeEnum.Files]: AttachmentClassification.AssetDocument,
      },
      [AttachmentType.TokenPhoto]: {
        [ChainTypeEnum.Services]: AttachmentClassification.ServicePhoto,
        [ChainTypeEnum.Objects]: AttachmentClassification.AssetPhoto,
        [ChainTypeEnum.Files]: AttachmentClassification.AssetPhoto,
      },
      [AttachmentType.VerificationPhoto]: {
        [ChainTypeEnum.Services]: AttachmentClassification.ServiceVerificationPhoto,
        [ChainTypeEnum.Objects]: AttachmentClassification.AssetVerificationPhoto,
        [ChainTypeEnum.Files]: AttachmentClassification.AssetVerificationPhoto,
      },
      [AttachmentType.WitnessPhoto]: {
        [ChainTypeEnum.Services]: AttachmentClassification.ServiceWitnessPhoto,
        [ChainTypeEnum.Objects]: AttachmentClassification.AssetWitnessPhoto,
        [ChainTypeEnum.Files]: AttachmentClassification.AssetWitnessPhoto,
      },
    };
    // @ts-ignore TODO: fix TS type
    return classifications[attachmentType]?.[chainType] || null;
  }

  static getType(data: ChainBaseEventData) {
    let name = '';
    let id = '';
    if ('assetType' in data) {
      const assetData = data as ChainAssetEventData;
      id = assetData.metadata?.assetTypeId ?? '';
      name = assetData.assetType ?? '';
    }
    if ('serviceType' in data) {
      const serviceData = data as ChainServiceEventData;
      id = serviceData.metadata?.serviceTypeId ?? '';
      name = (data as ChainServiceEventData).serviceType ?? '';
    }
    return { id, name };
  }

  static makeCreateChainRequest(opts: MakeCreateChainRequestOpts) {
    const date = opts?.eventDate ?? new Date().toISOString();

    const req: CreateChainBaseRequest = {
      application: { id: opts?.appId ?? DEFAULT_APP_ID },
      subject: {
        subjectType: opts?.subjectType ?? SubjectTypeEnum.USER,
        references: [
          { type: ReferenceType.AUTH0_IDENTITY, value: opts.auth0Id },
          { type: ReferenceType.END_USER_ID, value: opts.endUserId },
        ],
        orgId: opts?.orgId,
      },
      device: {
        date,
        deviceId: opts?.deviceId ?? '',
        deviceName: opts?.deviceName ?? '',
        geolocation: opts?.geolocation ?? makeSampleGeolocation(),
        ipAddress: opts?.ipAddress ?? '',
        deviceType: opts?.deviceType ?? DeviceTypeEnum.PHONE,
      },
      weather: opts?.weather ?? makeSampleWeatherData(),
      data: { date },
    };

    if (opts?.chainType === ChainTypeEnum.Objects || opts?.chainType === ChainTypeEnum.Files) {
      if (opts?.properties) {
        opts.properties = (opts.properties as AssetTypePropertyData[])?.map((p) => ({
          id: p.id,
          name: p.name,
          value: p.value,
          isAssetName: p.isAssetName ?? false,
        }));
      }
      (req as CreateChainAssetRequest).data.asset = {
        assetType: opts?.type ?? '',
        assetCategory: opts?.category ?? [],
        assetName: opts?.name ?? '',
        assetProperties: opts?.properties ?? [],
        isFavorite: opts?.isFavorite,
        metadata: {
          ...(opts?.metadata ?? {}),
          assetTypeId: opts?.typeId ?? '',
        },
      };
    } else if (opts?.chainType === ChainTypeEnum.Services) {
      if (opts?.properties) {
        opts.properties = (opts.properties as ServiceTypePropertyData[])?.map((p) => ({
          id: p.id,
          name: p.name,
          value: p.value,
          isServiceName: p.isServiceName ?? false,
        }));
      }
      (req as CreateChainServiceRequest).data.service = {
        serviceType: opts?.type ?? '',
        serviceCategory: opts?.category ?? [],
        serviceName: opts?.name ?? '',
        serviceProperties: opts?.properties ?? [],
        isFavorite: opts?.isFavorite,
        metadata: {
          ...(opts?.metadata ?? {}),
          serviceTypeId: opts?.typeId ?? '',
        },
      };
    }

    return req;
  }

  static makeUpdateChainRequest(opts: MakeUpdateChainRequestOpts) {
    const req: UpdateChainBaseDetailsRequest = {
      date: new Date().toISOString(),
    };

    if (opts.chainType === ChainTypeEnum.Objects) {
      (req as UpdateChainAssetDetailsRequest).asset = {
        assetType: opts?.type ?? '',
        assetCategory: opts?.category ?? [],
        assetName: opts?.name ?? '',
        isFavorite: opts?.isFavorite,
        assetProperties: opts?.properties ?? [],
        metadata: opts?.metadata,
      };
    } else if (opts.chainType === ChainTypeEnum.Services) {
      (req as UpdateChainServiceDetailsRequest).service = {
        serviceType: opts?.type ?? '',
        serviceCategory: opts?.category ?? [],
        serviceName: opts?.name ?? '',
        isFavorite: opts?.isFavorite,
        serviceProperties: opts?.properties ?? [],
        metadata: opts?.metadata,
      };
    }
    return req;
  }
  static async isOfficialVerified(chainType: ChainTypeEnum, childEvents: EventGroupItem[]) {
    if (chainType === ChainTypeEnum.Services) return false;
    return childEvents.some((e) => e.relationType === RelationTypeEnum.Official);
  }
}

interface MakeCreateChainRequestOpts {
  chainType: ChainTypeEnum;
  appId?: string;
  deviceId?: string;
  deviceName?: string;
  deviceType?: DeviceTypeEnum;
  geolocation?: GeolocationData;
  ipAddress?: string;
  weather?: WeatherData;
  eventDate?: string;
  type?: string;
  category?: string[];
  name?: string;
  properties?: BaseTypePropertyData[];
  typeId?: string;
  metadata?: Partial<ChainBaseEventMetadata>;
  subjectType?: SubjectTypeEnum;
  auth0Id: string;
  endUserId: string;
  orgId?: string;
  isFavorite?: boolean;
}

interface MakeUpdateChainRequestOpts {
  chainType: ChainTypeEnum;
  type?: string;
  category?: string[];
  name?: string;
  isFavorite?: boolean;
  properties?: BaseTypePropertyData[];
  metadata?: Partial<ChainBaseEventMetadata>;
}