@ieeesa-npm/groups 0.15.9 → 0.15.11

package/esm2022/lib/services/roster-import-api.service.mjs

@@ -0,0 +1,174 @@
+import { Injectable } from '@angular/core';
+import { map, catchError } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@ieeesa-npm/utility";
+/**
+ * RosterImportApiService wraps the backend roster-import state-machine API
+ * exposed by sa-saapps-groups-api's `RosterImportController`
+ * (`/v1/groups/roster/import`). It drives the upload → validate → preview →
+ * confirm / cancel lifecycle plus the read-only import history.
+ *
+ * All calls return the standard `Response<T>` envelope from the platform
+ * (`{ status, body }`); each method maps through the envelope's `body` where
+ * useful and rethrows errors so callers can inspect `error.error.body.errorCodes`
+ * (e.g. 1072 unsupported format, 1073 too large, 1074 row-limit, 1075 invalid
+ * status transition) — mirroring the existing GroupsService pattern.
+ *
+ * The base URL already carries the version segment (e.g. `.../v1`), matching
+ * every other GroupsService call built as `${apiBaseUrl}/groups/...`, so the
+ * version is NOT repeated here. Call {@link setApiBaseUrl} before use.
+ *
+ * @export
+ * @class RosterImportApiService
+ */
+export class RosterImportApiService {
+    constructor(
+    // eslint-disable-next-line no-unused-vars
+    httpService) {
+        this.httpService = httpService;
+        /** Path prefix (relative to apiBaseUrl) for the roster-import endpoints. */
+        this.IMPORT_BASE_PATH = 'groups/roster/import';
+    }
+    /**
+     * Sets the API base URL for roster-import calls.
+     * @param {string} url - Base URL ending in the version segment (e.g. '.../v1').
+     * @memberof RosterImportApiService
+     */
+    setApiBaseUrl(url) {
+        this.apiBaseUrl = url;
+    }
+    /**
+     * Builds an import endpoint URL from apiBaseUrl + the base path, guarding
+     * against a double slash if apiBaseUrl has a trailing slash.
+     * @param {string} [suffix] - Extra path appended after the base path.
+     * @return {string}
+     * @memberof RosterImportApiService
+     */
+    buildUrl(suffix = '') {
+        if (!this.apiBaseUrl) {
+            throw new Error('RosterImportApiService apiBaseUrl is not set. Call setApiBaseUrl() first.');
+        }
+        const base = this.apiBaseUrl.replace(/\/+$/, '');
+        return `${base}/${this.IMPORT_BASE_PATH}${suffix}`;
+    }
+    /**
+     * Uploads a roster-import file for a group and creates a PENDING import job.
+     * POST {apiBaseUrl}/groups/roster/import/upload (multipart form-data).
+     *
+     * Server validation may reject with: 1072 (unsupported format — only .xlsx /
+     * .csv), 1073 (file > 10MB), 1074 (> 10,000 data rows).
+     * @param {File} file - The .xlsx or .csv roster file.
+     * @param {string} groupId - The target group id.
+     * @return {Observable<RosterImportJob>} - The created PENDING import job.
+     * @memberof RosterImportApiService
+     */
+    uploadImportFile(file, groupId) {
+        const formData = new FormData();
+        formData.append('file', file);
+        formData.append('groupId', groupId);
+        return this.httpService
+            .postFormData(this.buildUrl('/upload'), formData)
+            .pipe(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        map((response) => response?.body), catchError((errorRes) => {
+            throw errorRes;
+        }));
+    }
+    /**
+     * Transitions a PENDING import job to VALIDATING and returns the per-row
+     * validation preview.
+     * POST {apiBaseUrl}/groups/roster/import/{importId}/validate.
+     * @param {string} importId - The import job identifier.
+     * @return {Observable<RosterImportPreview>}
+     * @memberof RosterImportApiService
+     */
+    validateImportJob(importId) {
+        return this.httpService
+            .postData(this.buildUrl(`/${importId}/validate`), {})
+            .pipe(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        map((response) => response?.body), catchError((errorRes) => {
+            throw errorRes;
+        }));
+    }
+    /**
+     * Returns the per-row validation preview for a validated import job without
+     * committing any roster changes.
+     * GET {apiBaseUrl}/groups/roster/import/{importId}/preview.
+     * @param {string} importId - The import job identifier.
+     * @return {Observable<RosterImportPreview>}
+     * @memberof RosterImportApiService
+     */
+    getImportPreview(importId) {
+        return this.httpService.getData(this.buildUrl(`/${importId}/preview`)).pipe(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        map((response) => response?.body), catchError((errorRes) => {
+            throw errorRes;
+        }));
+    }
+    /**
+     * Commits a validated import job's roster changes and returns the job with
+     * its terminal status (COMPLETED / PARTIAL / FAILED).
+     * POST {apiBaseUrl}/groups/roster/import/{importId}/confirm.
+     *
+     * May reject with 1075 (invalid status transition) if the job is not in a
+     * confirmable state.
+     * @param {string} importId - The import job identifier.
+     * @return {Observable<RosterImportJob>}
+     * @memberof RosterImportApiService
+     */
+    confirmImportJob(importId) {
+        return this.httpService
+            .postData(this.buildUrl(`/${importId}/confirm`), {})
+            .pipe(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        map((response) => response?.body), catchError((errorRes) => {
+            throw errorRes;
+        }));
+    }
+    /**
+     * Cancels an import job after preview without committing any roster changes.
+     * POST {apiBaseUrl}/groups/roster/import/{importId}/cancel.
+     * @param {string} importId - The import job identifier.
+     * @return {Observable<string>} - The cancellation confirmation message.
+     * @memberof RosterImportApiService
+     */
+    cancelImportJob(importId) {
+        return this.httpService
+            .postData(this.buildUrl(`/${importId}/cancel`), {})
+            .pipe(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        map((response) => response?.body), catchError((errorRes) => {
+            throw errorRes;
+        }));
+    }
+    /**
+     * Returns the roster import history for a group (read-only), scoped by the
+     * requester's app_id on the server.
+     * GET {apiBaseUrl}/groups/roster/import/history/{groupId}.
+     *
+     * May reject with 403 if the requester lacks view-roster permission for the
+     * group.
+     * @param {string} groupId - The group whose import history is requested.
+     * @return {Observable<RosterImportJob[]>} - The import jobs (never null).
+     * @memberof RosterImportApiService
+     */
+    getImportHistory(groupId) {
+        return this.httpService
+            .getData(this.buildUrl(`/history/${groupId}`))
+            .pipe(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        map((response) => response?.body ?? []), catchError((errorRes) => {
+            throw errorRes;
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RosterImportApiService, deps: [{ token: i1.HttpService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RosterImportApiService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RosterImportApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"roster-import-api.service.js","sourceRoot":"","sources":["../../../../../projects/groups/src/lib/services/roster-import-api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { Observable } from 'rxjs';\r\nimport { map, catchError } from 'rxjs/operators';\r\nimport { HttpService } from '@ieeesa-npm/utility';\r\nimport {\r\n  RosterImportJob,\r\n  RosterImportPreview,\r\n} from '../models/roster-import.model';\r\n\r\n/**\r\n * RosterImportApiService wraps the backend roster-import state-machine API\r\n * exposed by sa-saapps-groups-api's `RosterImportController`\r\n * (`/v1/groups/roster/import`). It drives the upload → validate → preview →\r\n * confirm / cancel lifecycle plus the read-only import history.\r\n *\r\n * All calls return the standard `Response<T>` envelope from the platform\r\n * (`{ status, body }`); each method maps through the envelope's `body` where\r\n * useful and rethrows errors so callers can inspect `error.error.body.errorCodes`\r\n * (e.g. 1072 unsupported format, 1073 too large, 1074 row-limit, 1075 invalid\r\n * status transition) — mirroring the existing GroupsService pattern.\r\n *\r\n * The base URL already carries the version segment (e.g. `.../v1`), matching\r\n * every other GroupsService call built as `${apiBaseUrl}/groups/...`, so the\r\n * version is NOT repeated here. Call {@link setApiBaseUrl} before use.\r\n *\r\n * @export\r\n * @class RosterImportApiService\r\n */\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class RosterImportApiService {\r\n  private apiBaseUrl!: string;\r\n\r\n  /** Path prefix (relative to apiBaseUrl) for the roster-import endpoints. */\r\n  private readonly IMPORT_BASE_PATH = 'groups/roster/import';\r\n\r\n  constructor(\r\n    // eslint-disable-next-line no-unused-vars\r\n    private httpService: HttpService\r\n  ) {}\r\n\r\n  /**\r\n   * Sets the API base URL for roster-import calls.\r\n   * @param {string} url - Base URL ending in the version segment (e.g. '.../v1').\r\n   * @memberof RosterImportApiService\r\n   */\r\n  setApiBaseUrl(url: string): void {\r\n    this.apiBaseUrl = url;\r\n  }\r\n\r\n  /**\r\n   * Builds an import endpoint URL from apiBaseUrl + the base path, guarding\r\n   * against a double slash if apiBaseUrl has a trailing slash.\r\n   * @param {string} [suffix] - Extra path appended after the base path.\r\n   * @return {string}\r\n   * @memberof RosterImportApiService\r\n   */\r\n  private buildUrl(suffix = ''): string {\r\n    if (!this.apiBaseUrl) {\r\n      throw new Error(\r\n        'RosterImportApiService apiBaseUrl is not set. Call setApiBaseUrl() first.'\r\n      );\r\n    }\r\n    const base = this.apiBaseUrl.replace(/\\/+$/, '');\r\n    return `${base}/${this.IMPORT_BASE_PATH}${suffix}`;\r\n  }\r\n\r\n  /**\r\n   * Uploads a roster-import file for a group and creates a PENDING import job.\r\n   * POST {apiBaseUrl}/groups/roster/import/upload (multipart form-data).\r\n   *\r\n   * Server validation may reject with: 1072 (unsupported format — only .xlsx /\r\n   * .csv), 1073 (file > 10MB), 1074 (> 10,000 data rows).\r\n   * @param {File} file - The .xlsx or .csv roster file.\r\n   * @param {string} groupId - The target group id.\r\n   * @return {Observable<RosterImportJob>} - The created PENDING import job.\r\n   * @memberof RosterImportApiService\r\n   */\r\n  uploadImportFile(file: File, groupId: string): Observable<RosterImportJob> {\r\n    const formData = new FormData();\r\n    formData.append('file', file);\r\n    formData.append('groupId', groupId);\r\n    return this.httpService\r\n      .postFormData(this.buildUrl('/upload'), formData)\r\n      .pipe(\r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n        map((response: any) => response?.body as RosterImportJob),\r\n        catchError((errorRes) => {\r\n          throw errorRes;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Transitions a PENDING import job to VALIDATING and returns the per-row\r\n   * validation preview.\r\n   * POST {apiBaseUrl}/groups/roster/import/{importId}/validate.\r\n   * @param {string} importId - The import job identifier.\r\n   * @return {Observable<RosterImportPreview>}\r\n   * @memberof RosterImportApiService\r\n   */\r\n  validateImportJob(importId: string): Observable<RosterImportPreview> {\r\n    return this.httpService\r\n      .postData(this.buildUrl(`/${importId}/validate`), {})\r\n      .pipe(\r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n        map((response: any) => response?.body as RosterImportPreview),\r\n        catchError((errorRes) => {\r\n          throw errorRes;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Returns the per-row validation preview for a validated import job without\r\n   * committing any roster changes.\r\n   * GET {apiBaseUrl}/groups/roster/import/{importId}/preview.\r\n   * @param {string} importId - The import job identifier.\r\n   * @return {Observable<RosterImportPreview>}\r\n   * @memberof RosterImportApiService\r\n   */\r\n  getImportPreview(importId: string): Observable<RosterImportPreview> {\r\n    return this.httpService.getData(this.buildUrl(`/${importId}/preview`)).pipe(\r\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n      map((response: any) => response?.body as RosterImportPreview),\r\n      catchError((errorRes) => {\r\n        throw errorRes;\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Commits a validated import job's roster changes and returns the job with\r\n   * its terminal status (COMPLETED / PARTIAL / FAILED).\r\n   * POST {apiBaseUrl}/groups/roster/import/{importId}/confirm.\r\n   *\r\n   * May reject with 1075 (invalid status transition) if the job is not in a\r\n   * confirmable state.\r\n   * @param {string} importId - The import job identifier.\r\n   * @return {Observable<RosterImportJob>}\r\n   * @memberof RosterImportApiService\r\n   */\r\n  confirmImportJob(importId: string): Observable<RosterImportJob> {\r\n    return this.httpService\r\n      .postData(this.buildUrl(`/${importId}/confirm`), {})\r\n      .pipe(\r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n        map((response: any) => response?.body as RosterImportJob),\r\n        catchError((errorRes) => {\r\n          throw errorRes;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Cancels an import job after preview without committing any roster changes.\r\n   * POST {apiBaseUrl}/groups/roster/import/{importId}/cancel.\r\n   * @param {string} importId - The import job identifier.\r\n   * @return {Observable<string>} - The cancellation confirmation message.\r\n   * @memberof RosterImportApiService\r\n   */\r\n  cancelImportJob(importId: string): Observable<string> {\r\n    return this.httpService\r\n      .postData(this.buildUrl(`/${importId}/cancel`), {})\r\n      .pipe(\r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n        map((response: any) => response?.body as string),\r\n        catchError((errorRes) => {\r\n          throw errorRes;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Returns the roster import history for a group (read-only), scoped by the\r\n   * requester's app_id on the server.\r\n   * GET {apiBaseUrl}/groups/roster/import/history/{groupId}.\r\n   *\r\n   * May reject with 403 if the requester lacks view-roster permission for the\r\n   * group.\r\n   * @param {string} groupId - The group whose import history is requested.\r\n   * @return {Observable<RosterImportJob[]>} - The import jobs (never null).\r\n   * @memberof RosterImportApiService\r\n   */\r\n  getImportHistory(groupId: string): Observable<RosterImportJob[]> {\r\n    return this.httpService\r\n      .getData(this.buildUrl(`/history/${groupId}`))\r\n      .pipe(\r\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n        map((response: any) => (response?.body as RosterImportJob[]) ?? []),\r\n        catchError((errorRes) => {\r\n          throw errorRes;\r\n        })\r\n      );\r\n  }\r\n}\r\n"]}

package/esm2022/public-api.mjs

@@ -7,6 +7,10 @@ export * from './lib/components/edit-user-roles/edit-user-roles.component';
 export * from './lib/components/reciprocal-credit-section/reciprocal-credit-section.component';
 export * from './lib/components/add-working-groups/add-working-groups.component';
 export * from './lib/components/roster-import/roster-import.component';
+export * from './lib/components/roster-import-history/roster-import-history.component';
+export * from './lib/components/interest-form-management/interest-form-management.component';
+export * from './lib/components/interested-rosters/interested-rosters.component';
+export * from './lib/components/interest-form/interest-form.component';
 export * from './lib/groups.component';
 export * from './lib/models/create-group.model';
 export * from './lib/models/group-action.model';
@@ -29,7 +33,8 @@ export * from './lib/models/parent-groups-info.model';
 export * from './lib/models/reciprocal-credit.model';
 export * from './lib/services/groups.service';
 export * from './lib/services/roster-export.service';
+export * from './lib/services/roster-import-api.service';
 export * from './lib/models/roster-import.model';
 export * from './lib/assets/form-validations';
 export * from './lib/groups.module';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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