@equinor/fusion-framework-module-services 0.0.0-next-20230915111233

package/src/notification/settings/get/client.ts

@@ -0,0 +1,37 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../../../types';
+import { ApiVersion } from '../../static';
+
+import { generateParameters } from './generate-parameters';
+
+import type {
+    GetUserNotificationSettingsArgs,
+    GetUserNotificationsSettingsResult,
+    GetUserNotificationSettingsResponse,
+} from './types';
+
+/**
+ * Method for fetching user notification settings from the notifications service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export const getUserNotificationSettings =
+    <
+        TVersion extends string = keyof typeof ApiVersion,
+        TMethod extends keyof ClientMethod = keyof ClientMethod,
+        TClient extends IHttpClient = IHttpClient,
+    >(
+        client: TClient,
+        version: TVersion,
+        method: TMethod = 'json' as TMethod,
+    ) =>
+    <T = GetUserNotificationSettingsResponse<TVersion>>(
+        args: GetUserNotificationSettingsArgs<TVersion>,
+        init?: ClientRequestInit<TClient, T>,
+    ): GetUserNotificationsSettingsResult<TVersion, TMethod, T> =>
+        client[method](
+            ...generateParameters<T, TVersion, TClient>(version, args, init),
+        ) as GetUserNotificationsSettingsResult<TVersion, TMethod, T>;
+
+export default getUserNotificationSettings;

package/src/notification/settings/get/generate-endpoint.ts

@@ -0,0 +1,25 @@
+import { UnsupportedApiVersion } from '../../../errors';
+import { ApiVersion } from '../..';
+
+import type { GetUserNotificationSettingsArgs } from './types';
+
+/**
+ * Method for generating endpoint for getting all notifications
+ */
+export const generateEndpoint = <TVersion extends string = keyof typeof ApiVersion>(
+    version: TVersion,
+    args: GetUserNotificationSettingsArgs<TVersion>,
+) => {
+    const apiVersion = ApiVersion[version as keyof typeof ApiVersion] ?? version;
+    switch (apiVersion) {
+        case ApiVersion.v2:
+            throw new UnsupportedApiVersion(version);
+        case ApiVersion.v1:
+        default: {
+            const { userId } = args as { userId: string };
+            const params = new URLSearchParams();
+            params.append('api-version', apiVersion);
+            return `/person/${userId}/notifications/settings/?${String(params)}`;
+        }
+    }
+};

package/src/notification/settings/get/generate-parameters.ts

@@ -0,0 +1,22 @@
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ApiVersion } from '../../static';
+import { ApiClientArguments } from '../../types';
+
+import { generateEndpoint } from './generate-endpoint';
+import { GetUserNotificationSettingsArgs } from './types';
+
+/** function for creating http client arguments  */
+export const generateParameters = <
+    TResult,
+    TVersion extends string = keyof typeof ApiVersion,
+    TClient extends IHttpClient = IHttpClient,
+>(
+    version: TVersion,
+    args: GetUserNotificationSettingsArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>,
+): ApiClientArguments<TClient, TResult> => {
+    const path = generateEndpoint(version, args);
+    return [path, init];
+};
+
+export default generateParameters;

package/src/notification/settings/get/index.ts

@@ -0,0 +1,8 @@
+export { ApiVersion } from '../..';
+
+export { generateEndpoint } from './generate-endpoint';
+export { generateParameters } from './generate-parameters';
+
+export * from './types';
+
+export { getUserNotificationSettings, default } from './client';

package/src/notification/settings/get/types.ts

@@ -0,0 +1,44 @@
+import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../../../types';
+import { ApiNotificationSettingsEntity } from '../../api-models';
+import { ApiVersion } from '../../static';
+
+type GetUserNotificationSettingsArgs_v1 = {
+    userId: string;
+};
+
+type GetUserNotificationSettingsArgs_v2 = GetUserNotificationSettingsArgs_v1;
+
+type GetUserNotificationSettingsArgsTypes = {
+    [ApiVersion.v1]: GetUserNotificationSettingsArgs_v1;
+    [ApiVersion.v2]: GetUserNotificationSettingsArgs_v2;
+};
+
+export type GetUserNotificationSettingsArgs<T extends string> = T extends keyof typeof ApiVersion
+    ? GetUserNotificationSettingsArgsTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+type GetUserNotificationSettingsResponseTypes = {
+    [ApiVersion.v1]: ApiNotificationSettingsEntity<ApiVersion.v1>;
+    [ApiVersion.v2]: ApiNotificationSettingsEntity<ApiVersion.v2>;
+};
+
+export type GetUserNotificationSettingsResponse<T> = T extends keyof typeof ApiVersion
+    ? GetUserNotificationSettingsResponseTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+export type GetUserNotificationSettingsFn<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+    TResult = GetUserNotificationSettingsResponse<TVersion>,
+> = (
+    args: GetUserNotificationSettingsArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>,
+) => GetUserNotificationsSettingsResult<TVersion, TMethod, TResult>;
+
+export type GetUserNotificationsSettingsResult<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = GetUserNotificationSettingsResponse<TVersion>,
+> = ClientMethod<TResult>[TMethod];

package/src/notification/settings/put/client.ts

@@ -0,0 +1,37 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../../../types';
+import { ApiVersion } from '../../static';
+
+import { generateParameters } from './generate-parameters';
+
+import type {
+    PutUserNotificationSettingsArgs,
+    PutUserNotificationSettingsResult,
+    PutUserNotificationSettingsResponse,
+} from './types';
+
+/**
+ * Method for fetching user notification settings from the notifications service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export const updateUserNotificationSettings =
+    <
+        TVersion extends string = keyof typeof ApiVersion,
+        TMethod extends keyof ClientMethod = keyof ClientMethod,
+        TClient extends IHttpClient = IHttpClient,
+    >(
+        client: TClient,
+        version: TVersion,
+        method: TMethod = 'json' as TMethod,
+    ) =>
+    <T = PutUserNotificationSettingsResponse<TVersion>>(
+        args: PutUserNotificationSettingsArgs<TVersion>,
+        init?: ClientRequestInit<TClient, T>,
+    ): PutUserNotificationSettingsResult<TVersion, TMethod, T> =>
+        client[method](
+            ...generateParameters<T, TVersion, TClient>(version, args, init),
+        ) as PutUserNotificationSettingsResult<TVersion, TMethod, T>;
+
+export default updateUserNotificationSettings;

package/src/notification/settings/put/generate-endpoint.ts

@@ -0,0 +1,25 @@
+import { UnsupportedApiVersion } from '../../../errors';
+import { ApiVersion } from '../..';
+
+import type { PutUserNotificationSettingsArgs } from './types';
+
+/**
+ * Method for generating endpoint for getting all notifications
+ */
+export const generateEndpoint = <TVersion extends string = keyof typeof ApiVersion>(
+    version: TVersion,
+    args: PutUserNotificationSettingsArgs<TVersion>,
+) => {
+    const apiVersion = ApiVersion[version as keyof typeof ApiVersion] ?? version;
+    switch (apiVersion) {
+        case ApiVersion.v2:
+            throw new UnsupportedApiVersion(version);
+        case ApiVersion.v1:
+        default: {
+            const { userId } = args as { userId: string };
+            const params = new URLSearchParams();
+            params.append('api-version', apiVersion);
+            return `/person/${userId}/notifications/settings/?${String(params)}`;
+        }
+    }
+};

package/src/notification/settings/put/generate-parameters.ts

@@ -0,0 +1,34 @@
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ApiVersion } from '../../static';
+import { ApiClientArguments } from '../../types';
+
+import { generateEndpoint } from './generate-endpoint';
+import { PutUserNotificationSettingsArgs } from './types';
+
+/** function for creating http client arguments  */
+export const generateParameters = <
+    TResult,
+    TVersion extends string = keyof typeof ApiVersion,
+    TClient extends IHttpClient = IHttpClient,
+>(
+    version: TVersion,
+    args: PutUserNotificationSettingsArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>,
+): ApiClientArguments<TClient, TResult> => {
+    const path = generateEndpoint(version, args);
+    //add versions switch case later
+
+    //Not sure why this is needed, defaults to application/problem+json failing the request
+    const headers = new Headers();
+    headers.append('content-type', 'application/json');
+
+    const requestParams: ClientRequestInit<TClient, TResult> = Object.assign(
+        {},
+        { method: 'put', body: JSON.stringify(args), headers: headers },
+        init,
+    );
+
+    return [path, requestParams];
+};
+
+export default generateParameters;

package/src/notification/settings/put/index.ts

@@ -0,0 +1,8 @@
+export { ApiVersion } from '../..';
+
+export { generateEndpoint } from './generate-endpoint';
+export { generateParameters } from './generate-parameters';
+
+export * from './types';
+
+export { updateUserNotificationSettings, default } from './client';

package/src/notification/settings/put/types.ts

@@ -0,0 +1,38 @@
+import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../../../types';
+import { ApiNotificationSettingsEntity } from '../../api-models';
+import { ApiVersion } from '../../static';
+
+type PutUserNotificationSettingsArgsTypes = {
+    [ApiVersion.v1]: ApiNotificationSettingsEntity<ApiVersion.v1>;
+    [ApiVersion.v2]: ApiNotificationSettingsEntity<ApiVersion.v2>;
+};
+
+export type PutUserNotificationSettingsArgs<T extends string> = T extends keyof typeof ApiVersion
+    ? PutUserNotificationSettingsArgsTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+type GetUserNotificationSettingsResponseTypes = {
+    [ApiVersion.v2]: ApiNotificationSettingsEntity<ApiVersion.v2>;
+    [ApiVersion.v1]: ApiNotificationSettingsEntity<ApiVersion.v1>;
+};
+
+export type PutUserNotificationSettingsResponse<T> = T extends keyof typeof ApiVersion
+    ? GetUserNotificationSettingsResponseTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+export type PutUserNotificationSettingsFn<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+    TResult = PutUserNotificationSettingsResponse<TVersion>,
+> = (
+    args: PutUserNotificationSettingsArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>,
+) => PutUserNotificationSettingsResult<TVersion, TMethod, TResult>;
+
+export type PutUserNotificationSettingsResult<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = PutUserNotificationSettingsResponse<TVersion>,
+> = ClientMethod<TResult>[TMethod];

package/src/notification/static.ts

@@ -0,0 +1,6 @@
+/** index of api versions of context service */
+export enum ApiVersion {
+    'v1' = '1.0',
+    /** not in use atm */
+    'v2' = '2.0',
+}

package/src/notification/types.ts

@@ -0,0 +1 @@
+export { ClientMethodType, ClientMethod, ApiClientArguments } from '..';

package/src/people/api-models.ts

@@ -0,0 +1,52 @@
+import { ApiPerson_v2 } from './api-models.v2';
+import { ApiPerson_v4 } from './api-models.v4';
+import { ApiVersion } from './static';
+
+export type ApiProjectMaster = {
+    id: string;
+    name?: string;
+};
+
+export type ApiManager = {
+    azureUniqueId: string;
+    name?: string;
+    mail?: string;
+    department?: string;
+    fullDepartment?: string;
+    upn?: string;
+    jobTitle?: string;
+    accountType: ApiProfileAccountType;
+    accountClassification: ApiAccountClassification;
+};
+
+export type ApiInvitationStatus = 'Accepted' | 'Pending' | 'NotSent';
+
+export type ApiProfileAccountType =
+    | 'Employee'
+    | 'Consultant'
+    | 'Enterprise'
+    | 'External'
+    | 'External Hire';
+
+// TODO what are these?
+export type ApiAccountClassification = 'Unclassified' | 'Internal' | 'External';
+
+export type ApiProfileAccountLink = {
+    azureUniqueId: string;
+    mail?: string;
+    isPrimaryAccount?: boolean;
+    preferredContactMail?: string;
+    isExpired?: boolean;
+    upn?: string;
+};
+
+export type ApiPersonMap = {
+    [ApiVersion.v2]: ApiPerson_v2;
+    [ApiVersion.v4]: ApiPerson_v4;
+};
+
+export type ApiPerson<T extends keyof typeof ApiVersion | ApiVersion> = T extends ApiVersion
+    ? ApiPersonMap[T]
+    : T extends keyof typeof ApiVersion
+    ? ApiPersonMap[(typeof ApiVersion)[T]]
+    : unknown;

package/src/people/api-models.v2.ts

@@ -0,0 +1,31 @@
+import {
+    ApiAccountClassification,
+    ApiInvitationStatus,
+    ApiProfileAccountLink,
+    ApiProfileAccountType,
+} from './api-models';
+
+export type ApiPerson_v2 = {
+    fusionPersonId?: string;
+    azureUniqueId: string;
+    mail?: string;
+    name?: string;
+    jobTitle?: string;
+    department?: string;
+    fullDepartment?: string;
+    mobilePhone?: string;
+    officeLocation?: string;
+    sapId?: string;
+    employeeId?: string;
+    isResourceOwner?: boolean;
+    isExpired?: boolean;
+    expiredDate?: string;
+    upn?: string;
+    accountType: ApiProfileAccountType;
+    invitationStatus: ApiInvitationStatus;
+    accountClassification: ApiAccountClassification;
+    managerAzureUniqueId: string;
+    linkedAccounts?: Array<ApiProfileAccountLink>;
+    isPrimaryAccount?: boolean;
+    preferredContactMail?: string;
+};

package/src/people/api-models.v4.ts

@@ -0,0 +1,100 @@
+import {
+    ApiAccountClassification,
+    ApiInvitationStatus,
+    ApiProfileAccountLink,
+    ApiProfileAccountType,
+    ApiProjectMaster,
+} from './api-models';
+
+export type ApiPerson_v4 = {
+    azureUniqueId: string;
+    mail?: string;
+    name?: string;
+    jobTitle?: string;
+    department?: string;
+    fullDepartment?: string;
+    mobilePhone?: string;
+    officeLocation?: string;
+    upn?: string;
+    isResourceOwner?: boolean;
+    isExpired?: boolean;
+    expiredDate?: string;
+    isPrimaryAccount?: boolean;
+    preferredContactMail?: string;
+    accountType?: ApiProfileAccountType;
+
+    // TODO is this default
+    invitationStatus?: ApiInvitationStatus;
+    accountClassification?: ApiAccountClassification;
+    managerAzureUniqueId?: string;
+
+    // TODO is this default
+    linkedAccounts?: Array<ApiProfileAccountLink>;
+};
+
+export type ApiCompanyInfo_v4 = {
+    id: string;
+    name?: string;
+};
+
+export type ApiPersonRole_v4 = {
+    name?: string;
+    displayName?: string;
+    sourceSystem?: string;
+    type?: string;
+    isActive?: boolean;
+    activeToUtc?: string;
+    onDemandSupport?: boolean;
+    scopes?: Array<ApiPersonRoleScope_v4>;
+};
+
+export type ApiPersonRoleScope_v4 = {
+    type?: string;
+    values?: string[];
+    valueType?: string;
+};
+
+export type ApiPersonPosition_v4 = {
+    positionId: string;
+    positionExternalId?: string;
+    id: string;
+    parentPositionId?: string;
+    taskOwnerIds?: string[];
+    name?: string;
+    obs?: string;
+    basePosition: ApiPersonBasePosition_v4;
+    project: ApiPersonProject_v4;
+    appliesFrom: string;
+    appliesTo: string;
+    workload?: number;
+};
+
+export type ApiPersonBasePosition_v4 = {
+    id: string;
+    name?: string;
+    type?: string;
+    discipline?: string;
+};
+
+export type ApiPersonProject_v4 = {
+    id: string;
+    name?: string;
+    domainId?: string;
+    type?: string;
+};
+
+export type ApiPersonContract_v4 = {
+    id: string;
+    name?: string;
+    contractNumber?: string;
+    companyId?: string;
+    companyName?: string;
+    project: ApiPersonProject_v4;
+    projectMaster: ApiProjectMaster;
+    positions: Array<ApiPersonPosition_v4>;
+};
+
+export type ApiCompanyInfoV4 = {
+    id: string;
+    name?: string;
+};

package/src/people/client.ts

@@ -0,0 +1,109 @@
+import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+
+import type { ClientDataMethod, ClientMethod } from '../types';
+import { ApiVersion } from './static';
+
+import {
+    client as personDetailClient,
+    ApiResponse as PersonDetailApiResponse,
+    ApiResult as PersonDetailResult,
+    SupportedApiVersion as PersonDetailSupportedApiVersion,
+    ApiRequestArgs as PersonDetailApiRequestArgs,
+} from './person-details';
+
+import {
+    client as personQueryClient,
+    ApiResponse as PersonQueryApiResponse,
+    ApiResult as PersonQueryResult,
+    SupportedApiVersion as PersonQuerySupportedApiVersion,
+    ApiRequestArgs as PersonQueryApiRequestArgs,
+} from './query';
+
+import {
+    client as personPhotoClient,
+    ApiResponse as PersonPhotoApiResponse,
+    ApiResult as PersonPhotoResult,
+    SupportedApiVersion as PersonPhotoSupportedApiVersion,
+    ApiRequestArgs as PersonPhotoApiRequestArgs,
+} from './person-photo';
+
+export class PeopleApiClient<
+    // TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+> {
+    get Version(): typeof ApiVersion {
+        return ApiVersion;
+    }
+
+    constructor(protected _client: TClient) {}
+
+    /**
+     * Fetch person by id
+     */
+    public get<
+        TVersion extends PersonDetailSupportedApiVersion,
+        TArgs extends PersonDetailApiRequestArgs<TVersion>,
+        TResult extends PersonDetailApiResponse<TVersion, TArgs>,
+        TMethod extends keyof ClientMethod<TResult>,
+    >(
+        version: TVersion,
+        method: TMethod,
+        args: TArgs,
+        init?: ClientRequestInit<TClient, TResult>,
+    ): PersonDetailResult<TVersion, TArgs, TMethod, TResult> {
+        const fn = personDetailClient<TVersion, TMethod, TClient, TArgs>(
+            this._client,
+            version,
+            method,
+        );
+        return fn(args, init);
+    }
+
+    /**
+     * Query person service
+     */
+    public query<
+        TVersion extends PersonQuerySupportedApiVersion,
+        TArgs extends PersonQueryApiRequestArgs<TVersion>,
+        TResult = PersonQueryApiResponse<TVersion>,
+        TMethod extends keyof ClientMethod<TResult> = keyof ClientMethod<TResult>,
+    >(
+        version: TVersion,
+        method: TMethod,
+        args: TArgs,
+        init?: ClientRequestInit<TClient, TResult>,
+    ): PersonQueryResult<TVersion, TMethod, TResult> {
+        const fn = personQueryClient<TVersion, TMethod, TClient>(this._client, version, method);
+        return fn<TResult>(args, init);
+    }
+
+    /**
+     * Photo person service
+     */
+    public photo<
+        TVersion extends PersonPhotoSupportedApiVersion,
+        TArgs extends PersonPhotoApiRequestArgs<TVersion>,
+        TResult extends Blob = PersonPhotoApiResponse<TVersion>,
+        TMethod extends keyof ClientDataMethod = keyof ClientDataMethod,
+    >(
+        version: TVersion,
+        method: TMethod,
+        args: TArgs,
+        init?: ClientRequestInit<TClient, TResult>,
+    ): PersonPhotoResult<TMethod> {
+        const fn = personPhotoClient<TVersion, TMethod, TClient>(this._client, version, method);
+        return fn<TResult>(args, init);
+    }
+}
+
+// const oo = new PeopleApiClient(null).get('v4', 'fetch', { azureId: '123' });
+// const o2 = await new PeopleApiClient(null).get('v4', 'fetch', {
+//     azureId: '123',
+//     expand: ['roles'],
+// });
+// const o3 = await new PeopleApiClient(null).get('v4', 'fetch', {
+//     azureId: '123',
+//     expand: ['companies', 'roles'],
+// });
+
+export default PeopleApiClient;

package/src/people/index.ts

@@ -0,0 +1,5 @@
+export { PeopleApiClient, default } from './client';
+
+export { ApiVersion } from './static';
+
+export * from './api-models';

package/src/people/person-details/client.ts

@@ -0,0 +1,33 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+
+import { generateParameters } from './generate-parameters';
+
+import type { ClientMethod } from '../../types';
+import type { ApiResponse, ApiResult, ApiRequestArgs, SupportedApiVersion } from './types';
+
+/**
+ * Method for fetching context item from context service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export const client =
+    <
+        TVersion extends SupportedApiVersion,
+        TMethod extends keyof ClientMethod = keyof ClientMethod,
+        TClient extends IHttpClient = IHttpClient,
+        TArgs extends ApiRequestArgs<TVersion> = ApiRequestArgs<TVersion>,
+    >(
+        client: TClient,
+        version: TVersion,
+        method: TMethod = 'json' as TMethod,
+    ) =>
+    <T = ApiResponse<TVersion, TArgs>>(
+        args: TArgs,
+        init?: ClientRequestInit<TClient, T>,
+    ): ApiResult<TVersion, TArgs, TMethod, T> =>
+        client[method](
+            ...generateParameters<T, TVersion, TClient>(version, args, init),
+        ) as ApiResult<TVersion, TArgs, TMethod, T>;
+
+export default client;

package/src/people/person-details/generate-endpoint.ts

@@ -0,0 +1,28 @@
+import { UnsupportedApiVersion } from '../../errors';
+import { ApiVersion } from '../static';
+
+import type { ApiRequestArgs, SupportedApiVersion } from './types';
+
+/**
+ * Method for generating endpoint for getting context by id
+ */
+export const generateEndpoint = <TVersion extends SupportedApiVersion>(
+    version: TVersion,
+    args: ApiRequestArgs<TVersion>,
+) => {
+    const apiVersion = ApiVersion[version as keyof typeof ApiVersion] ?? version;
+    switch (apiVersion) {
+        case ApiVersion.v4: {
+            const { azureId, expand } = args;
+            const params = new URLSearchParams();
+            params.append('api-version', apiVersion);
+            if (expand) {
+                params.append('$expand', expand.join(','));
+            }
+            return `/persons/${azureId}?${String(params)}`;
+        }
+        default: {
+            throw new UnsupportedApiVersion(version);
+        }
+    }
+};