@m481/mp-sdk-ng 0.1.0-dev.20251024165513

package/fesm2022/m481-mp-sdk-ng.mjs

@@ -0,0 +1,889 @@
+import * as i0 from '@angular/core';
+import { Injectable, inject, Directive, NgModule } from '@angular/core';
+import { HttpClient, HttpErrorResponse, HttpParams, provideHttpClient, HTTP_INTERCEPTORS, withInterceptorsFromDi } from '@angular/common/http';
+import { throwError, from, catchError as catchError$1, map, switchMap, tap } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+import { AES, enc } from 'crypto-js';
+import * as i2 from '@angular/router';
+import 'cross-fetch/polyfill';
+import PocketBase, { ClientResponseError } from 'pocketbase';
+
+class BaseModel {
+    id;
+    created;
+    updated;
+}
+
+class CalendarShiftModel extends BaseModel {
+    shiftId;
+    startAt;
+    endAt;
+}
+
+class EventModel extends BaseModel {
+    message;
+    scope;
+    objectId;
+    userId;
+}
+
+class MissionModel extends BaseModel {
+    name;
+    isRegular;
+    color;
+    hours; // [ [11, 13], [17, 19] ] -
+    teamId;
+    team;
+    isEnabled;
+}
+
+var RecurrenceType;
+(function (RecurrenceType) {
+    RecurrenceType[RecurrenceType["DAILY"] = 0] = "DAILY";
+    RecurrenceType[RecurrenceType["WEEKLY"] = 1] = "WEEKLY";
+    RecurrenceType[RecurrenceType["MONTHLY"] = 2] = "MONTHLY";
+})(RecurrenceType || (RecurrenceType = {}));
+class ShiftModel extends BaseModel {
+    missionId;
+    missionHourIndex;
+    teamId;
+    assignedUsersIds;
+    mission;
+    repeatData;
+    isEnabled;
+}
+
+class UserModel extends BaseModel {
+    email;
+    verified;
+    name;
+    teamsAdmin;
+    teamsMember;
+    password;
+    avatar;
+    avatarUrl;
+    isEnabled;
+}
+
+class TeamModel extends BaseModel {
+    name;
+    isEnabled;
+}
+
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 1] = "WARN";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
+})(LogLevel || (LogLevel = {}));
+class LoggerService {
+    log = window.console;
+    LOG_FNS = [this.log.log, this.log.warn, this.log.error];
+    MSG_PREFIXES = [["[", "]"], ["[", "] WARN: "], ["[", "] ERROR: "]];
+    get(prefix, level) {
+        const logLevel = level || LogLevel.INFO;
+        if (logLevel >= LogLevel.INFO) {
+            this.LOG_FNS[0].call(this.log, "[" + prefix + "] Logger created");
+        }
+        const loggerFns = this.LOG_FNS.map((logTemplFn, i) => {
+            return logTemplFn.bind(this.log, this.MSG_PREFIXES[i][0] + prefix + this.MSG_PREFIXES[i][1]);
+        });
+        return {
+            d: (...args) => {
+                if (logLevel === LogLevel.DEBUG) {
+                    loggerFns[0].apply(this.log, [...args]);
+                }
+            },
+            w: (...args) => {
+                if (logLevel >= LogLevel.WARN) {
+                    loggerFns[1].apply(this.log, [...args]);
+                }
+            },
+            e: (...args) => {
+                if (logLevel >= LogLevel.ERROR) {
+                    loggerFns[2].apply(this.log, [...args]);
+                }
+            }
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: LoggerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: LoggerService, providedIn: "root" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: LoggerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }] });
+
+class Configuration {
+    baseUrl;
+    secret;
+    isProduction;
+    constructor(params) {
+        this.baseUrl = params.baseUrl || "";
+        this.secret = params.secret;
+        this.isProduction = params.isProduction || false;
+    }
+}
+
+class BasePlain {
+    log;
+    config = inject(Configuration);
+    constructor(logLevel) {
+        const logger = inject(LoggerService);
+        this.log = logger.get(this.constructor.name, logLevel || this.config.isProduction ? LogLevel.ERROR : LogLevel.DEBUG);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: BasePlain, deps: [{ token: LogLevel }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.14", type: BasePlain, isStandalone: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: BasePlain, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: LogLevel }] });
+
+class UtilsService extends BasePlain {
+    cfg;
+    constructor(cfg) {
+        super();
+        this.cfg = cfg;
+    }
+    encryptText(text) {
+        let data = text;
+        if (this.cfg.secret) {
+            data = AES.encrypt(text, this.cfg.secret).toString();
+        }
+        return data;
+    }
+    decryptText(data) {
+        let text = data;
+        if (text) {
+            if (this.cfg.secret) {
+                const bytes = AES.decrypt(data.toString(), this.cfg.secret);
+                const decrypted = bytes.toString(enc.Utf8);
+                if (decrypted) {
+                    text = decrypted;
+                }
+                else {
+                    this.log.d("error decrypting", data);
+                }
+            }
+        }
+        return text;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: UtilsService, deps: [{ token: Configuration }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: UtilsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: UtilsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: Configuration }] });
+
+class AuthStoreService {
+    utilsSrv;
+    KEY_TOKEN = "mp_sdk:token";
+    token = "";
+    constructor(utilsSrv) {
+        this.utilsSrv = utilsSrv;
+    }
+    setToken(token) {
+        this.token = this.utilsSrv.encryptText(token);
+        sessionStorage.setItem(this.KEY_TOKEN, this.token);
+    }
+    getToken() {
+        const data = sessionStorage.getItem(this.KEY_TOKEN);
+        return !!data ? this.utilsSrv.decryptText(data) : null;
+    }
+    clearToken() {
+        this.token = null;
+        sessionStorage.removeItem(this.KEY_TOKEN);
+    }
+    isStoredToken() {
+        return this.getToken() !== null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AuthStoreService, deps: [{ token: UtilsService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AuthStoreService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AuthStoreService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: UtilsService }] });
+
+class AuthInterceptor extends BasePlain {
+    authStore;
+    router;
+    // URLs that don't require authentication
+    excludedUrls = [
+        '/auth/login',
+        '/auth/register',
+        '/public',
+        '/health'
+    ];
+    constructor(authStore, router) {
+        super(LogLevel.DEBUG);
+        this.authStore = authStore;
+        this.router = router;
+    }
+    intercept(req, next) {
+        // Check if the URL should be excluded
+        if (this.shouldExcludeUrl(req.url)) {
+            return next.handle(req);
+        }
+        // Get token from AuthStore service
+        const authToken = this.authStore.getToken();
+        this.log.d("intercepting", req.url, authToken);
+        let ret;
+        if (authToken) {
+            // Clone the request and add authorization header
+            const authReq = req.clone({
+                setHeaders: {
+                    Authorization: authToken
+                }
+            });
+            // Continue with modified request and handle errors
+            ret = next.handle(authReq).pipe(catchError((error) => this.handleAuthError(error)));
+        }
+        else {
+            // If no token, continue with original request
+            ret = next.handle(req);
+        }
+        return ret;
+    }
+    shouldExcludeUrl(url) {
+        return this.excludedUrls.some(excludedUrl => url.includes(excludedUrl));
+    }
+    handleAuthError(error) {
+        if (error.status === 401) {
+            // Invalid or expired token
+            this.log.w('Invalid or expired authentication token');
+            this.authStore.clearToken();
+            // Redirect to login
+            this.router.navigate(['/login']);
+        }
+        else if (error.status === 403) {
+            // Insufficient permissions
+            this.log.w('Insufficient permissions to access the resource');
+        }
+        // Propagate error for component handling
+        return throwError(() => error);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AuthInterceptor, deps: [{ token: AuthStoreService }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AuthInterceptor });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AuthInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: AuthStoreService }, { type: i2.Router }] });
+
+;
+class BaseSdk extends BasePlain {
+    authStore = inject(AuthStoreService);
+    http = inject(HttpClient);
+    doGet(endpoint, params) {
+        return this.http.get(this.config.baseUrl + endpoint, {
+            params,
+        });
+    }
+    doGetList(endpoint, params) {
+        return this.http.get(this.config.baseUrl + endpoint, {
+            params,
+        });
+    }
+    getAuthHeader() {
+        return {
+            headers: {
+                "Authorization": this.authStore.getToken(),
+            }
+        };
+    }
+    handleError(error) {
+        this.log.e("Error", error);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: BaseSdk, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.14", type: BaseSdk, isStandalone: true, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: BaseSdk, decorators: [{
+            type: Directive
+        }] });
+
+class BasePocket extends BaseSdk {
+    connection;
+    connect() {
+        if (!this.connection) {
+            this.connection = new PocketBase(this.config.baseUrl);
+        }
+    }
+    getList(entity, options) {
+        this.connect();
+        this.log.d("getList --- entity", entity, this.authStore.getToken());
+        return from(this.connection.collection(entity).getList(1, 20, this.buildOptions(options))).pipe(catchError$1(err => this.handleError(err)), map(d => (d ? {
+            page: d.page,
+            pageSize: d.perPage,
+            pagesTotal: d.totalPages,
+            items: d.items,
+            total: d.totalItems
+        } : null)));
+    }
+    getOne(entity, id, options) {
+        this.connect();
+        this.log.d("fetchOne", entity, this.authStore.getToken());
+        return from(this.connection.collection(entity).getOne(id, this.buildOptions(options))).pipe(catchError$1(err => this.handleError(err)));
+    }
+    save(entity, data) {
+        this.connect();
+        this.log.d("save", entity, data?.id, this.authStore.getToken());
+        const target = this.connection.collection(entity);
+        let promise;
+        if (data.id) {
+            promise = target.update(data.id, data, this.getAuthHeader());
+        }
+        else {
+            promise = target.create(data, this.getAuthHeader());
+        }
+        return from(promise).pipe(catchError$1(err => this.handleError(err)));
+    }
+    remove(entity, id) {
+        this.connect();
+        this.log.d("remove", entity, this.authStore.getToken());
+        return from(this.connection.collection(entity).delete(id, this.getAuthHeader())).pipe(catchError$1(err => this.handleError(err)));
+    }
+    handleError(error) {
+        if (error instanceof ClientResponseError) {
+            this.log.w("Http error", error.status);
+            throw new HttpErrorResponse({
+                error: error.originalError,
+                status: error.status,
+                url: error.url
+            });
+        }
+        else {
+            this.log.w("Error response unknown", error);
+            throw error;
+        }
+    }
+    buildOptions(options) {
+        return options
+            ? { ...options, ...this.getAuthHeader() }
+            : this.getAuthHeader();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: BasePocket, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.14", type: BasePocket, isStandalone: true, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: BasePocket, decorators: [{
+            type: Directive
+        }] });
+
+class SdkConfig {
+    static Entities = {
+        AUTH: "users",
+        USERS: "users",
+        EVENTS: "events",
+        MISSIONS: "missions",
+        SHIFTS: "shifts",
+        CALENDAR_SHIFTS: "calendar_shifts",
+        TEAMS: "teams"
+    };
+    static Endpoints = {
+        TEAMS: "/api/collections/teams/records"
+    };
+    static ModelKeys = {
+        CREATE_AT: "created",
+        UPDATE_AT: "updated"
+    };
+}
+
+class AuthService extends BasePocket {
+    constructor() {
+        super();
+    }
+    login(user, pass) {
+        this.connect();
+        return from(this.connection.collection(SdkConfig.Entities.AUTH).authWithPassword(user, pass)).pipe(catchError$1(err => this.handleError(err)), map(data => {
+            this.log.d("login ok", data);
+            this.authStore.setToken(data.token);
+            return data.record;
+        }));
+    }
+    logout() {
+        this.authStore.clearToken();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AuthService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AuthService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class BaseResource extends BasePocket {
+    fetchList() {
+        return this.getList(this.Entity, this.Options);
+    }
+    fetchOne(id) {
+        return this.getOne(this.Entity, id);
+    }
+    create(data) {
+        return this.save(this.Entity, data);
+    }
+    update(id, data) {
+        return this.save(this.Entity, { id, ...data });
+    }
+    delete(id) {
+        return this.remove(this.Entity, id);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: BaseResource, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.14", type: BaseResource, isStandalone: true, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: BaseResource, decorators: [{
+            type: Directive
+        }] });
+
+class MissionsService extends BaseResource {
+    Options = {
+        filter: "isEnabled = true"
+    };
+    Entity = SdkConfig.Entities.MISSIONS;
+    constructor() {
+        super();
+    }
+    getArchived() {
+        return this.getList(SdkConfig.Entities.MISSIONS, {
+            filter: "isEnabled = false"
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: MissionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: MissionsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: MissionsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class ShiftsService extends BaseResource {
+    Options = {
+        filter: "isEnabled = true"
+    };
+    Entity = SdkConfig.Entities.SHIFTS;
+    constructor() {
+        super();
+    }
+    create(data) {
+        const repeat = data.repeatData;
+        if (!repeat) {
+            return throwError(() => new Error('No repeat data provided'));
+        }
+        // Generate CalendarShifts based on repeat configuration
+        const calendarShifts = this.generateCalendarShifts(repeat);
+        // Create the main Shift first
+        return super.create(data).pipe(switchMap(createdShift => {
+            // Assign the shiftId to all generated CalendarShifts
+            const shiftsToCreate = calendarShifts.map(cs => ({
+                shiftId: createdShift.id,
+                startAt: cs.startAt,
+                endAt: cs.endAt
+            }));
+            // Create all CalendarShifts in batch
+            return this.createCalendarShiftsBatch(shiftsToCreate).pipe(
+            // If successful, return the created shift
+            switchMap(() => from([createdShift])), 
+            // If CalendarShift creation fails, rollback
+            catchError$1(error => {
+                this.log.e('Error creating calendar shifts, rolling back...', error);
+                return this.delete(createdShift.id).pipe(switchMap(() => throwError(() => new Error('Failed to create calendar shifts. Shift has been rolled back.'))));
+            }));
+        }), catchError$1(error => {
+            this.log.e('Error creating shift', error);
+            return throwError(() => error);
+        }));
+    }
+    delete(id) {
+        this.connect();
+        // First, fetch all CalendarShifts associated with this Shift
+        return this.getCalendarShiftsByShiftId(id).pipe(switchMap(calendarShifts => {
+            // Store the IDs for potential rollback
+            const calendarShiftIds = calendarShifts.map(cs => cs.id);
+            // Delete all CalendarShifts first
+            return this.deleteCalendarShiftsBatch(calendarShiftIds).pipe(switchMap(() => {
+                // After successful CalendarShift deletion, delete the main Shift
+                return super.delete(id).pipe(catchError$1(error => {
+                    // If Shift deletion fails, try to restore CalendarShifts
+                    this.log.e('Error deleting shift, attempting rollback...', error);
+                    return this.restoreCalendarShifts(calendarShifts).pipe(switchMap(() => throwError(() => new Error('Failed to delete shift. CalendarShifts have been restored.'))));
+                }));
+            }), catchError$1(error => {
+                // If CalendarShift deletion fails, propagate the error
+                this.log.e('Error deleting calendar shifts', error);
+                return throwError(() => new Error('Failed to delete calendar shifts.'));
+            }));
+        }), catchError$1(error => {
+            this.log.e('Error fetching calendar shifts for deletion', error);
+            return throwError(() => error);
+        }));
+    }
+    /**
+     * Generates CalendarShifts based on repeat configuration
+     */
+    generateCalendarShifts(repeat) {
+        const shifts = [];
+        const startDate = new Date(repeat.initDate);
+        let currentDate = new Date(startDate);
+        let occurrenceCount = 0;
+        // Determine the end date
+        const endDate = repeat.finalizeDate
+            ? new Date(repeat.finalizeDate)
+            : this.calculateEndDateByOccurrences(startDate, repeat);
+        while (currentDate <= endDate) {
+            // Check if we've reached the maximum number of occurrences
+            if (repeat.occurrences && occurrenceCount >= repeat.occurrences) {
+                break;
+            }
+            // Add shift based on recurrence type
+            if (this.shouldAddShift(currentDate, repeat)) {
+                const shift = new CalendarShiftModel();
+                shift.startAt = currentDate.getTime();
+                // Assume each shift lasts until end of day (you can adjust this)
+                const endDateTime = new Date(currentDate);
+                endDateTime.setHours(23, 59, 59, 999);
+                shift.endAt = endDateTime.getTime();
+                shifts.push(shift);
+                occurrenceCount++;
+            }
+            // Move to next period
+            currentDate = this.getNextDate(currentDate, repeat);
+        }
+        return shifts;
+    }
+    /**
+     * Determines if a shift should be added on the current date
+     */
+    shouldAddShift(date, repeat) {
+        switch (repeat.type) {
+            case RecurrenceType.DAILY:
+                return true;
+            case RecurrenceType.WEEKLY:
+                if (repeat.daysOfWeek && repeat.daysOfWeek.length > 0) {
+                    const dayOfWeek = date.getDay();
+                    return repeat.daysOfWeek.includes(dayOfWeek);
+                }
+                return true;
+            case RecurrenceType.MONTHLY:
+                if (repeat.dayOfMonth) {
+                    return date.getDate() === repeat.dayOfMonth;
+                }
+                return true;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Calculates the next date based on recurrence type
+     */
+    getNextDate(currentDate, repeat) {
+        const nextDate = new Date(currentDate);
+        switch (repeat.type) {
+            case RecurrenceType.DAILY:
+                nextDate.setDate(nextDate.getDate() + repeat.interval);
+                break;
+            case RecurrenceType.WEEKLY:
+                nextDate.setDate(nextDate.getDate() + (7 * repeat.interval));
+                break;
+            case RecurrenceType.MONTHLY:
+                nextDate.setMonth(nextDate.getMonth() + repeat.interval);
+                break;
+        }
+        return nextDate;
+    }
+    /**
+     * Calculates the end date based on number of occurrences
+     */
+    calculateEndDateByOccurrences(startDate, repeat) {
+        if (!repeat.occurrences) {
+            // If no occurrences defined, set a reasonable limit (e.g., 1 year)
+            const defaultEnd = new Date(startDate);
+            defaultEnd.setFullYear(defaultEnd.getFullYear() + 1);
+            return defaultEnd;
+        }
+        let estimatedEnd = new Date(startDate);
+        switch (repeat.type) {
+            case RecurrenceType.DAILY:
+                estimatedEnd.setDate(estimatedEnd.getDate() + (repeat.occurrences * repeat.interval));
+                break;
+            case RecurrenceType.WEEKLY:
+                estimatedEnd.setDate(estimatedEnd.getDate() + (repeat.occurrences * 7 * repeat.interval));
+                break;
+            case RecurrenceType.MONTHLY:
+                estimatedEnd.setMonth(estimatedEnd.getMonth() + (repeat.occurrences * repeat.interval));
+                break;
+        }
+        return estimatedEnd;
+    }
+    /**
+     * Fetches all CalendarShifts associated with a specific Shift ID
+     */
+    getCalendarShiftsByShiftId(shiftId) {
+        this.log.d('Fetching calendar shifts for shift', shiftId);
+        const filter = `shiftId = "${shiftId}"`;
+        return from(this.connection.collection(SdkConfig.Entities.CALENDAR_SHIFTS)
+            .getFullList({ filter, ...this.getAuthHeader() })).pipe(catchError$1(err => this.handleError(err)));
+    }
+    /**
+     * Deletes multiple CalendarShifts in batch
+     */
+    deleteCalendarShiftsBatch(calendarShiftIds) {
+        if (calendarShiftIds.length === 0) {
+            return from([true]);
+        }
+        this.log.d('Deleting calendar shifts batch', calendarShiftIds.length);
+        // PocketBase batch ops could be disabled,
+        // so we create a manual transaction using Promise.all
+        const promises = calendarShiftIds.map(id => this.connection.collection(SdkConfig.Entities.CALENDAR_SHIFTS)
+            .delete(id, this.getAuthHeader()));
+        return from(Promise.all(promises)).pipe(switchMap(() => from([true])), catchError$1(err => this.handleError(err)));
+    }
+    /**
+     * Restores CalendarShifts in case of rollback
+     */
+    restoreCalendarShifts(calendarShifts) {
+        if (calendarShifts.length === 0) {
+            return from([true]);
+        }
+        this.log.d('Restoring calendar shifts', calendarShifts.length);
+        // Recreate the CalendarShifts with their original data
+        const promises = calendarShifts.map(cs => this.connection.collection(SdkConfig.Entities.CALENDAR_SHIFTS)
+            .create({
+            shiftId: cs.shiftId,
+            startAt: cs.startAt,
+            endAt: cs.endAt
+        }, this.getAuthHeader()));
+        return from(Promise.all(promises)).pipe(switchMap(() => from([true])), catchError$1(err => {
+            this.log.e('Failed to restore calendar shifts during rollback', err);
+            return this.handleError(err);
+        }));
+    }
+    /**
+     * Creates multiple CalendarShifts
+     * TODO move to backend?
+     */
+    createCalendarShiftsBatch(shifts) {
+        this.connect();
+        if (shifts.length === 0) {
+            return from([]);
+        }
+        this.log.d('Creating calendar shifts batch', shifts.length);
+        // PocketBase batch ops could be disabled,
+        // so we create a manual transaction using Promise.all
+        const promises = shifts.map(shift => this.connection.collection(SdkConfig.Entities.CALENDAR_SHIFTS)
+            .create(shift, this.getAuthHeader()));
+        return from(Promise.all(promises)).pipe(catchError$1(err => this.handleError(err)));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: ShiftsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: ShiftsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: ShiftsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class CrewService extends BaseResource {
+    Options = {
+        filter: "isEnabled = true"
+    };
+    Entity = SdkConfig.Entities.USERS;
+    constructor() {
+        super();
+    }
+    create(data) {
+        throw new Error("Method not supported.");
+    }
+    update(id, data) {
+        throw new Error("Method not supported.");
+    }
+    delete(id) {
+        throw new Error("Method not supported.");
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: CrewService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: CrewService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: CrewService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class TeamsService extends BaseResource {
+    Options = {
+        filter: "isEnabled = true",
+        fields: "id,name,isEnabled"
+    };
+    Entity = SdkConfig.Entities.TEAMS;
+    constructor() {
+        super();
+    }
+    // Unsupported methods
+    /**
+     * @
+     */
+    fetchOne(id) {
+        throw new Error("Method not supported.");
+    }
+    create(data) {
+        throw new Error("Method not supported.");
+    }
+    update(id, data) {
+        throw new Error("Method not supported.");
+    }
+    delete(id) {
+        throw new Error("Method not supported.");
+    }
+    // Alternative methods using Angular Http
+    getTeams() {
+        const params = new HttpParams({
+            fromObject: this.Options
+        });
+        return this.doGetList(SdkConfig.Endpoints.TEAMS, params)
+            .pipe(tap(d => this.log.d("teams!!", d)));
+    }
+    fetchTeams() {
+        return this.getList(SdkConfig.Entities.TEAMS, this.Options);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: TeamsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: TeamsService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: TeamsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class MpSdkService extends BasePlain {
+    missionsSrv;
+    shiftsSrv;
+    staffSrv;
+    teamsSrv;
+    authSrv = inject(AuthService);
+    authStoreSrv = inject(AuthStoreService);
+    constructor(missionsSrv, shiftsSrv, staffSrv, teamsSrv) {
+        super();
+        this.missionsSrv = missionsSrv;
+        this.shiftsSrv = shiftsSrv;
+        this.staffSrv = staffSrv;
+        this.teamsSrv = teamsSrv;
+    }
+    // Auth
+    login(user, pass) {
+        return this.authSrv.login(user, pass);
+    }
+    logout() {
+        this.authSrv.logout();
+    }
+    isLoggedIn() {
+        return this.authStoreSrv.isStoredToken();
+    }
+    // Missions
+    getMissions() {
+        return this.missionsSrv.fetchList();
+    }
+    getArchivedMissions() {
+        return this.missionsSrv.getArchived();
+    }
+    getMissionById(id) {
+        return this.missionsSrv.fetchOne(id);
+    }
+    saveMission(m) {
+        return !m.id
+            ? this.missionsSrv.create(m)
+            : this.missionsSrv.update(m.id, m);
+    }
+    deleteMission(id) {
+        return this.missionsSrv.delete(id);
+    }
+    // Shifts
+    getShifts() {
+        return this.shiftsSrv.fetchList();
+    }
+    getShiftById(id) {
+        return this.shiftsSrv.fetchOne(id);
+    }
+    saveShift(m) {
+        return !m.id
+            ? this.shiftsSrv.create(m)
+            : this.shiftsSrv.update(m.id, m);
+    }
+    deleteShift(id) {
+        return this.shiftsSrv.delete(id);
+    }
+    // Staff
+    getStaffUsers() {
+        return this.staffSrv.fetchList();
+    }
+    getStaffUser(id) {
+        return this.staffSrv.fetchOne(id);
+    }
+    getStaffTeams() {
+        return this.teamsSrv.fetchList();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: MpSdkService, deps: [{ token: MissionsService }, { token: ShiftsService }, { token: CrewService }, { token: TeamsService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: MpSdkService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: MpSdkService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: MissionsService }, { type: ShiftsService }, { type: CrewService }, { type: TeamsService }] });
+
+const defaultConfig = () => {
+    return new Configuration({
+        baseUrl: "http://localhost:3000/api/",
+        secret: "lwjhvkjdfhglk",
+        isProduction: false
+    });
+};
+class MpSdkModule {
+    static forRoot(configurationFactory) {
+        return {
+            ngModule: MpSdkModule,
+            providers: [{
+                    provide: Configuration,
+                    useFactory: configurationFactory || defaultConfig
+                }],
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: MpSdkModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.14", ngImport: i0, type: MpSdkModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: MpSdkModule, providers: [
+            provideHttpClient(withInterceptorsFromDi()),
+            {
+                provide: HTTP_INTERCEPTORS,
+                useClass: AuthInterceptor,
+                multi: true
+            },
+            LoggerService,
+            UtilsService,
+            AuthStoreService,
+            AuthService,
+            MissionsService,
+            ShiftsService,
+            TeamsService,
+            CrewService,
+            MpSdkService
+        ] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: MpSdkModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        provideHttpClient(withInterceptorsFromDi()),
+                        {
+                            provide: HTTP_INTERCEPTORS,
+                            useClass: AuthInterceptor,
+                            multi: true
+                        },
+                        LoggerService,
+                        UtilsService,
+                        AuthStoreService,
+                        AuthService,
+                        MissionsService,
+                        ShiftsService,
+                        TeamsService,
+                        CrewService,
+                        MpSdkService
+                    ]
+                }]
+        }] });
+
+/*
+ * Public API Surface of lib
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AuthStoreService, CalendarShiftModel, Configuration, EventModel, MissionModel, MpSdkModule, MpSdkService, RecurrenceType, ShiftModel, TeamModel, UserModel };
+//# sourceMappingURL=m481-mp-sdk-ng.mjs.map